private static Initialization <Guid> CompilePositiveConstructor(Class <Guid, Guid, ITerm <Guid, Guid> > @class, Initialization <Guid, Func <Term <Guid>, Term <Guid> > > initialization)
{
switch (@class.Tag)
{
case Class <Guid, Guid, ITerm <Guid, Guid> > .Tags.Quantifier:
{
var quantifier = (Class <Guid, Guid, ITerm <Guid, Guid> > .Quantifier)@class;
var pair = (Initialization <Guid, Func <Term <Guid>, Term <Guid> > > .Exists.Quantifier)initialization;
return(new Initialization <Guid> .Pair(pair.Left(null), pair.Right(null)));
}
case Class <Guid, Guid, ITerm <Guid, Guid> > .Tags.Shift:
{
var shift = (Class <Guid, Guid, ITerm <Guid, Guid> > .Shift)@class;
var delay = (Initialization <Guid, Func <Term <Guid>, Term <Guid> > > .Exists.Shift)initialization;
var fresh = Fresh();
return(new Initialization <Guid> .Lambda(fresh, delay.Body(new Term <Guid> .Variable(fresh))));
}
default:
throw new InvalidProgramException("Should never happen.");
}
}
private static ContinuationPassing.Continuation <Guid> CompileNegativeConstructor(Class <Guid, Guid, ITerm <Guid, Guid> > @class, Initialization <Guid, Func <Term <Guid>, Term <Guid> > > initialization)
{
switch (@class.Tag)
{
case Class <Guid, Guid, ITerm <Guid, Guid> > .Tags.Quantifier:
{
var quantifier = (Class <Guid, Guid, ITerm <Guid, Guid> > .Quantifier)@class;
var lambda = (Initialization <Guid, Func <Term <Guid>, Term <Guid> > > .Forall.Quantifier)initialization;
Guid fresh = Fresh();
return(new ContinuationPassing.Continuation <Guid> .Extract(lambda.Parameter, fresh, lambda.Body(new Term <Guid> .Variable(fresh))));
}
case Class <Guid, Guid, ITerm <Guid, Guid> > .Tags.Shift:
{
var shift = (Class <Guid, Guid, ITerm <Guid, Guid> > .Shift)@class;
var @return = (Initialization <Guid, Func <Term <Guid>, Term <Guid> > > .Forall.Shift)initialization;
return(new ContinuationPassing.Continuation <Guid> .Jump(@return.Body(null)));
}
default:
throw new InvalidProgramException("Should never happen.");
}
}
private static Func <Term <Guid>, Term <Guid> > CompileConstructor(IUniverse universe, Class <Guid, Guid, ITerm <Guid, Guid> > @class, Initialization <Guid, Func <Term <Guid>, Term <Guid> > > initialization)
{
switch (universe.Polarity)
{
case Polarity.Forall:
{
var qualifiedSelfType = universe.Qualify <Guid, Guid, ITerm <Guid, Guid> >(new Term <Guid, Guid>(new TermF <Guid, Guid, ITerm <Guid, Guid> > .Type(@class)));
var compiledSelfType = Compile(qualifiedSelfType);
var selfUniverse = new Term <Guid> .Universe(universe.Rank);
return(continuation =>
{
var qualifiedSelf = new Qualified <Guid, Term <Guid> >(selfUniverse, compiledSelfType, continuation);
var arguments = CompileNegativeConstructor(@class, initialization);
return new Term <Guid> .Destructor(qualifiedSelf, arguments);
});
}
case Polarity.Exists:
{
return(_ =>
{
var arguments = CompilePositiveConstructor(@class, initialization);
return new Term <Guid> .Constructor(arguments);
});
}
case null:
default:
throw new ArgumentOutOfRangeException("polarity");
}
}
private Initialization <Bind, TR> Map(Sequence <IExpression <Bind, Id, Bind> > environment, IUniverse universe, Class <Bind, Id, ITerm <Bind, Id> > @class, Initialization <Bind, T> initialization)
{
switch (universe.Polarity)
{
case Polarity.Forall:
switch (@class.Tag)
{
case Class <Bind, Id, ITerm <Bind, Id> > .Tags.Quantifier:
{
var quantifier = (Class <Bind, Id, ITerm <Bind, Id> > .Quantifier)@class;
var lambda = (Initialization <Bind, T> .Forall.Quantifier)initialization;
var returnType = Substitute(environment, quantifier.Dependency, quantifier.Dependent, UseDeclarationF(lambda.Parameter));
var qualifiedBody = new Expression <Bind, Id, T>(universe, returnType, lambda.Body);
var dependency = quantifier.Dependency.Fmap(_ => lambda.Parameter);
environment = environment.Push(dependency);
var body = ConvertF(qualifiedBody.Annotate(environment));
return(new Initialization <Bind, TR> .Forall.Quantifier(lambda.Parameter, body));
}
case Class <Bind, Id, ITerm <Bind, Id> > .Tags.Shift:
{
var shift = (Class <Bind, Id, ITerm <Bind, Id> > .Shift)@class;
var @return = (Initialization <Bind, T> .Forall.Shift)initialization;
var qualifiedBody = new Expression <Bind, Id, T>(universe.Dual(), shift.Content, @return.Body);
var body = ConvertF(qualifiedBody.Annotate(environment));
return(new Initialization <Bind, TR> .Forall.Shift(body));
}
default:
throw new InvalidProgramException("Should never happen.");
}
case Polarity.Exists:
switch (@class.Tag)
{
case Class <Bind, Id, ITerm <Bind, Id> > .Tags.Quantifier:
{
var quantifier = (Class <Bind, Id, ITerm <Bind, Id> > .Quantifier)@class;
var pair = (Initialization <Bind, T> .Exists.Quantifier)initialization;
var qualifiedLeft = quantifier.Dependency.Fmap(_ => pair.Left);
var rightType = Substitute(environment, quantifier.Dependency, quantifier.Dependent, pair.Left);
var qualifiedRight = new Expression <Bind, Id, T>(universe, @rightType, pair.Right);
var left = ConvertF(qualifiedLeft.Annotate(environment));
var right = ConvertF(qualifiedRight.Annotate(environment));
return(new Initialization <Bind, TR> .Exists.Quantifier(left, right));
}
case Class <Bind, Id, ITerm <Bind, Id> > .Tags.Shift:
{
var shift = (Class <Bind, Id, ITerm <Bind, Id> > .Shift)@class;
var delay = (Initialization <Bind, T> .Exists.Shift)initialization;
var qualifiedBody = new Expression <Bind, Id, T>(universe.Dual(), shift.Content, delay.Body);
var body = ConvertF(qualifiedBody.Annotate(environment));
return(new Initialization <Bind, TR> .Exists.Shift(body));
}
default:
throw new InvalidProgramException("Should never happen.");
}
case null:
default:
throw new InvalidProgramException("Should never happen.");
}
}
private IEnumerable <Bits> SerializeConstructor(Sequence <IExpression <Bind, Id, Bind> > environment, IUniverse universe, Class <Bind, Id, ITerm <Bind, Id> > @class, Initialization <Bind, IEnumerable <Bits> > initialization)
{
switch (universe.Polarity)
{
case Polarity.Forall:
switch (@class.Tag)
{
case Class <Bind, Id, ITerm <Bind, Id> > .Tags.Quantifier:
{
var quantifier = (Class <Bind, Id, ITerm <Bind, Id> > .Quantifier)@class;
var lambda = (Initialization <Bind, IEnumerable <Bits> > .Forall.Quantifier)initialization;
var parameter = SerializeBinding(new Annotated <Bind, Id, Bind>(environment, quantifier.Dependency.Fmap(_ => lambda.Parameter)));
foreach (var bit in Encoding.Concatenate(parameter, lambda.Body))
{
yield return(bit);
}
yield break;
}
case Class <Bind, Id, ITerm <Bind, Id> > .Tags.Shift:
{
var shift = (Class <Bind, Id, ITerm <Bind, Id> > .Shift)@class;
var @return = (Initialization <Bind, IEnumerable <Bits> > .Forall.Shift)initialization;
foreach (var bit in @return.Body)
{
yield return(bit);
}
yield break;
}
default:
{
throw new InvalidProgramException("Should never happen.");
}
}
case Polarity.Exists:
switch (@class.Tag)
{
case Class <Bind, Id, ITerm <Bind, Id> > .Tags.Quantifier:
{
var quantifier = (Class <Bind, Id, ITerm <Bind, Id> > .Quantifier)@class;
var pair = (Initialization <Bind, IEnumerable <Bits> > .Exists.Quantifier)initialization;
foreach (var bit in Encoding.Concatenate(pair.Left, pair.Right))
{
yield return(bit);
}
yield break;
}
case Class <Bind, Id, ITerm <Bind, Id> > .Tags.Shift:
{
var shift = (Class <Bind, Id, ITerm <Bind, Id> > .Shift)@class;
var delay = (Initialization <Bind, IEnumerable <Bits> > .Exists.Shift)initialization;
foreach (var bit in delay.Body)
{
yield return(bit);
}
yield break;
}
default:
{
throw new InvalidProgramException("Should never happen.");
}
}
case null:
default:
throw new InvalidProgramException("Should never happen.");
}
}
private static IEvaluator <R> EvaluateConstructor <R>(Polarity?polarity, Class <Unit, uint, ITerm <Unit, uint> > @class, Initialization <Unit, IEvaluator <R> > initialization)
{
switch (polarity)
{
case Polarity.Forall:
switch (@class.Tag)
{
case Class <Unit, uint, ITerm <Unit, uint> > .Tags.Quantifier:
{
var quantifier = (Class <Unit, uint, ITerm <Unit, uint> > .Quantifier)@class;
var lambda = (Initialization <Unit, IEvaluator <R> > .Forall.Quantifier)initialization;
if (quantifier.Dependency.Universe.Rank != 0)
{
return(lambda.Body);
}
return(new Evaluator <R>(
evaluateF: (locals, argument) =>
{
var pair = (Value <R> .Pair)argument;
return lambda.Body.Evaluate(locals.Push(pair.Left), pair.Right);
}));
}
case Class <Unit, uint, ITerm <Unit, uint> > .Tags.Shift:
{
var shift = (Class <Unit, uint, ITerm <Unit, uint> > .Shift)@class;
var @return = (Initialization <Unit, IEvaluator <R> > .Forall.Shift)initialization;
return(new Evaluator <R>(
evaluateF: (locals, argument) =>
{
return @return.Body.Evaluate(locals, argument);
}));
}
default:
throw new InvalidProgramException("Should never happen.");
}
case Polarity.Exists:
switch (@class.Tag)
{
case Class <Unit, uint, ITerm <Unit, uint> > .Tags.Quantifier:
{
var quantifier = (Class <Unit, uint, ITerm <Unit, uint> > .Quantifier)@class;
var pair = (Initialization <Unit, IEvaluator <R> > .Exists.Quantifier)initialization;
if (quantifier.Dependency.Universe.Rank != 0)
{
return(pair.Right);
}
return(new Evaluator <R>(
evaluateF: (locals, argument) =>
{
return pair.Left.Evaluate(locals,
argument: new Value <R> .Continuation(
content: new Continuation <R>(
throwF: left =>
{
return pair.Right.Evaluate(locals,
argument: new Value <R> .Continuation(
content: new Continuation <R>(
throwF: right =>
{
var continuation = (Value <R> .Continuation)argument;
return continuation.Content.Throw(new Value <R> .Pair(left, right));
})));
})));
}));
}
case Class <Unit, uint, ITerm <Unit, uint> > .Tags.Shift:
{
var shift = (Class <Unit, uint, ITerm <Unit, uint> > .Shift)@class;
var delay = (Initialization <Unit, IEvaluator <R> > .Exists.Shift)initialization;
return(new Evaluator <R>(
evaluateF: (locals, argument) =>
{
var continuation = (Value <R> .Continuation)argument;
return continuation.Content.Throw(
argument: new Value <R> .Continuation(
new Continuation <R>(
throwF: result =>
{
return delay.Body.Evaluate(locals, result);
})));
}));
}
default:
throw new InvalidProgramException("Should never happen.");
}
case null:
default:
throw new InvalidProgramException("Should never happen.");
}
}
