private static Classification <dynamic> Interpret(ref Environment <Classification <dynamic> > environment, string line)
{
var tokens = ProgramParsing.Separated(ProgramParsing.Token()).ParseCompletely(line.ToStream());
var command = ProgramParsing.CommandLine().ParseCompletely(tokens.ToStream());
foreach (var defun in command.Definition.Each())
{
var term = defun;
foreach (var type in command.Declaration.Each())
{
term = new Term.Annotation(new Annotated(type, term));
}
var typed = Execute(environment, term);
if (command.Identifier != null)
{
if (environment.Maps(command.Identifier))
{
Console.WriteLine("Shadowing is not allowed!");
}
else
{
environment = environment.Push(command.Identifier, typed);
}
}
return(typed);
}
throw new ArgumentException("Command line must include evaluable expression.");
}
public static IParser <Token, Statement> Element()
{
var declaration = Literal(Symbols.HasType).Continue(_ => Expression()).Option();
var definition = Literal(Symbols.Equals).Continue(_ => Expression()).Option();
return(Identifier().Continue(identifier =>
Parameter().Repeat().Continue(parameters =>
declaration.Continue(type =>
definition.Continue(term =>
{
if (type.Tag == Option.None && term.Tag == Option.None)
{
return Parsers.Fails <Token, Statement>("Statement must be a declaration or a definition.");
}
if (parameters.Length != 0)
{
if (term.Tag == Option.None)
{
throw new ArgumentException("Cannot have parameters on the left hand side of a pure declaration: " + identifier);
}
var body = term.Get();
foreach (var annotation in type.Each())
{
body = new Term.Annotation(new Annotated(annotation, body));
}
return Parsers.Returns <Token, Statement>(new Statement(identifier, new Option <Term> .None(), MergeDefinitionParameters(parameters, body).Some()));
}
return Parsers.Returns <Token, Statement>(new Statement(identifier, type, term));
})))));
}
private static Definition[] AccumulateDefinitions(Statement[] bindings)
{
var declarations = new Dictionary <string, Term>(bindings.Length);
var definitions = new List <Definition>(bindings.Length);
foreach (var element in bindings)
{
foreach (var type in element.Declaration.Each())
{
declarations.Add(element.Identifier, type);
}
foreach (var term in element.Definition.Each())
{
var identifier = element.Identifier;
if (declarations.ContainsKey(identifier))
{
var declared = declarations[identifier];
declarations.Remove(identifier);
var body = new Term.Annotation(new Annotated(declared, term));
definitions.Add(new Definition(identifier, body));
}
else
{
definitions.Add(new Definition(identifier, term));
}
}
}
return(definitions.ToArray());
}
