public void Parse(Environment outer, Environment env, Type result, Substitution subst)
{
try
{
var fullType = Arguments.Select(arg => arg.Parse(env, subst)).Reverse().Aggregate(
result,
(res, cur) => new FunctionType(cur, res)
).Perform(subst).Generalize(outer);
var constructor = new DataConstructor(fullType, Name, result, Arguments.Count);
Func <ImmutableList <LazyValue>, LazyValue> function =
arguments => new DataValue(constructor, arguments.ToList());
for (var i = 0; i < Arguments.Count; ++i)
{
var backup = function;
function = arguments => new FunctionValue(arg => backup(arguments.Add(arg)));
}
outer.Bind(Name, constructor);
outer.Bind(Name, fullType);
outer.Bind(Name, function(ImmutableList.Create(new LazyValue[] {})));
}
catch (StackedException ex)
{
ex.Push("In a data type constructor declaration: " + ex);
throw;
}
}
public Type Infer(Environment env)
{
var subst = new Substitution();
var ret = Infer(env, subst);
ret.Perform(subst);
env.Perform(subst);
return(ret);
}
private Tuple <Type, LazyValue> Evaluate(string input)
{
var parser = new Parser.Parser(input);
var expression = parser.Result;
var local = _env.Local();
var type = expression.Infer(local);
var value = expression.Evaluate(local);
_env = local;
return(Tuple.Create(type, value));
}
protected void AddToEnvironment(Environment env)
{
foreach (var clause in Clauses)
{
clause.PrepareValueEnvironment(env);
}
foreach (var clause in Clauses)
{
clause.AddValueToEnvironment(env);
}
}
public override Type Infer(Environment env, Substitution subst)
{
try
{
var annotated = Type.Parse(env, subst, true);
var inferred = Body.Infer(env, subst);
annotated.Unify(inferred, subst);
return(annotated.Perform(subst));
}
catch (StackedException ex)
{
ex.Push("In an annotated pattern: " + this);
throw;
}
}
public override Type Infer(Environment env, Substitution subst)
{
try
{
foreach (var clause in Clauses)
{
clause.PrepareTypeEnvironment(env, subst);
}
foreach (var clause in Clauses)
{
clause.AddTypeToEnvironment(env, subst);
}
return(TypeDefaults.Unit);
}
catch (StackedException ex)
{
ex.Push("In a def-expression: " + this);
throw;
}
}
public Program()
{
_env = new Environment();
}
public override Type Infer(Environment env, Substitution subst)
{
return(new CharacterType());
}
public override LazyValue Evaluate(Environment env)
{
return(new CharacterValue(Value));
}
public override bool Match(LazyValue value, ref Environment env)
{
return(Body.Match(value, ref env));
}
public abstract Type Infer(Environment env, Substitution subst);
public abstract LazyValue Evaluate(Environment env);
public override LazyValue Evaluate(Environment env)
{
AddToEnvironment(env);
return(Defaults.Unit);
}
public override Type Infer(Environment env, Substitution subst)
{
return(new FloatingType());
}
public override LazyValue Evaluate(Environment env)
{
throw new NotImplementedException();
}
