suzanne.soy/envlang-csharp
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Parser on immutable stream of lexemes, returns a rough representation of the AST

Browse Source
This commit is contained in:
Suzanne Soy 2020-08-30 22:39:01 +00:00
parent afb04df4a6
commit 829bff6c2b
6 changed files with 86 additions and 41 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
AstGenerator.cs
View File

@ -4,13 +4,16 @@ public static class AstGenerator {
public static void Main() {
Generate(
"AstGenerated.cs",
"",
"using System.Collections.Generic;",
"namespace Ast {",
"}",
"Ast.",
Types(
Variant("Expr",
Case("int", "Int"),
Case("string", "String"))));
Case("string", "String")),
Variant("AstNode",
Case("Expr", "Terminal"),
Case("IEnumerable<AstNode>", "Operator"))));
}
}

69
Parser.cs
View File

@ -4,61 +4,74 @@ using System.Collections.Generic;
using System.Collections.Immutable;
using System.Linq;
using Immutable;
using Ast;
using S = Lexer.S;
using Lexeme = Lexer.Lexeme;
using Grammar2 = MixFix.Grammar2;
using static Global;
public static partial class Parser {
public static bool Parse2(string source) {
Grammar2 grammar =
DefaultGrammar.DefaultPrecedenceDAG.ToGrammar2();
Log(grammar.Str());
// Parse3(grammar, Lexer.Lex(source))
throw new NotImplementedException();
}
public static Option<IImmutableEnumerator<Lexeme>> Parse3(
Func<Grammar2,
IImmutableEnumerator<Lexeme>,
Option<IImmutableEnumerator<Lexeme>>>
public static Option<ValueTuple<IImmutableEnumerator<Lexeme>, AstNode>> Parse3(
Func<IImmutableEnumerator<Lexeme>,
Grammar2,
//Option<IImmutableEnumerator<Lexeme>>
Option<ValueTuple<IImmutableEnumerator<Lexeme>, AstNode>>
>
Parse3,
Grammar2 grammar,
IImmutableEnumerator<Lexeme> tokens
IImmutableEnumerator<Lexeme> tokens,
Grammar2 grammar
) =>
tokens
.FirstAndRest()
.Match(
None: () =>
throw new Exception("EOF, what to do?"),
Some: headRest => {
var first = headRest.Item1;
var rest = headRest.Item2;
Some: firstRest => {
// Case("IImmutableEnumerable<AstNode>", "Operator"))
var first = firstRest.Item1;
var rest = firstRest.Item2;
return grammar.Match(
RepeatOnePlus: g =>
Parse3(g, rest)
.IfSome(rest1 =>
WhileSome(rest1, restI => Parse3(g, restI))),
rest.FoldMapWhileSome(restI => Parse3(restI, g))
.If<IImmutableEnumerator<Lexeme>, IEnumerable<AstNode>>((restN, nodes) => nodes.Count() > 1)
.IfSome((restN, nodes) => (restN, AstNode.Operator(nodes))),
//.IfSome(rest1 =>
// TODO: remove IfSome above (useless) && aggregate
// WhileSome(rest1, restI => Parse3(restI, g))),
// TODO: to check for ambiguous parses, we can use
// .SingleArg(…) instead of .FirstArg(…).
Or: l =>
l.First(g => Parse3(g, rest)),
// TODO: use a shortcut version of .Aggregate
// to exit early when None is returned by a step
l.First(g => Parse3(rest, g)),
Sequence: l =>
l.BindFold(rest,
(restI, g) => Parse3(g, restI)),
l.BindFoldMap(rest, (restI, g) => Parse3(restI, g))
.IfSome((restN, nodes) => (restN, AstNode.Operator(nodes))),
Terminal: t =>
first.state.Equals(t)
? rest.Some()
: None<IImmutableEnumerator<Lexeme>>()
? (rest,
AstNode.Terminal(/* TODO: */ Expr.String(rest.ToString())))
.Some()
: None<ValueTuple<IImmutableEnumerator<Lexeme>, AstNode>>()
);
// TODO: at the top-level, check that the lexemes
// are empty if the parser won't accept anything else.
}
);
public static Option<ValueTuple<IImmutableEnumerator<Lexeme>, AstNode>> Parse2(string source) {
Grammar2 grammar =
DefaultGrammar.DefaultPrecedenceDAG.ToGrammar2();
Log(grammar.Str());
var P = Func.YMemoize<
IImmutableEnumerator<Lexeme>,
Grammar2,
Option<ValueTuple<IImmutableEnumerator<Lexeme>, AstNode>>>(
Parse3
);
return P(Lexer.Lex(source), grammar);
}
public static Ast.Expr Parse(string source) {
return Lexer.Lex(source)
.SelectMany(lexeme =>

33
Utils/Enumerable.cs
View File

@ -239,17 +239,25 @@ public static class Collection {
public static Option<A> BindFold<T, A>(this IEnumerable<T> e, A init, Func<A, T, Option<A>> f) {
var acc = init;
foreach (var x in e) {
var @new = f(acc, x);
if (@new.IsNone) {
return Option.None<A>();
var newAcc = f(acc, x);
if (newAcc.IsNone) {
break;
} else {
acc = @new.ElseThrow(() => new Exception("impossible"));
acc = newAcc.ElseThrow(new Exception("impossible"));
}
}
return acc.Some();
}
public static A WhileSome<A>(this A init, Func<A, Option<A>> f) {
public static Option<ValueTuple<A, IEnumerable<U>>> BindFoldMap<T, A, U>(this IEnumerable<T> e, A init, Func<A, T, Option<ValueTuple<A, U>>> f)
=> e.BindFold(
(init, ImmutableStack<U>.Empty),
(accL, x) =>
f(accL.Item1, x).IfSome((newAcc, result) =>
(newAcc, accL.Item2.Push(result)))
).IfSome((acc, l) => (acc, l.Reverse<U>()));
public static A FoldWhileSome<A>(this A init, Func<A, Option<A>> f) {
var lastGood = init;
while (true) {
var @new = f(lastGood);
@ -261,6 +269,17 @@ public static class Collection {
}
}
public static Option<Tuple<A, B>> WhileSome<A, B>(this Option<Tuple<A, B>> init, Func<A, B, Option<Tuple<A, B>>> f)
=> init.IfSome(ab1 => WhileSome(ab1, ab => f(ab.Item1, ab.Item2)));
public static Option<Tuple<A, B>> FoldWhileSome<A, B>(this Option<Tuple<A, B>> init, Func<A, B, Option<Tuple<A, B>>> f)
=> init.IfSome(ab1 => ab1.FoldWhileSome(ab => f(ab.Item1, ab.Item2)));
public static Option<ValueTuple<A, B>> FoldWhileSome<A, B>(this Option<ValueTuple<A, B>> init, Func<A, B, Option<ValueTuple<A, B>>> f)
=> init.IfSome(ab1 => ab1.FoldWhileSome(ab => f(ab.Item1, ab.Item2)));
public static ValueTuple<A, IEnumerable<U>> FoldMapWhileSome<A, U>(this A init, Func<A, Option<ValueTuple<A, U>>> f)
=> FoldWhileSome(
(init, ImmutableStack<U>.Empty),
accL =>
f(accL.Item1).IfSome((newAcc, result) =>
(newAcc, accL.Item2.Push(result)))
).Pipe((acc, l) => (acc, l.Reverse<U>()));
}

8
Utils/Global.cs
View File

@ -23,11 +23,11 @@ public static class Global {
public static T To<T>(this T x) => x;
public static A WhileSome<A>(A init, Func<A, Option<A>> f)
=> Collection.WhileSome(init, f);
public static A FoldWhileSome<A>(A init, Func<A, Option<A>> f)
=> Collection.FoldWhileSome(init, f);
public static Option<Tuple<A, B>> WhileSome<A, B>(Option<Tuple<A, B>> init, Func<A, B, Option<Tuple<A, B>>> f)
=> Collection.WhileSome(init, f);
public static Option<Tuple<A, B>> FoldWhileSome<A, B>(Option<Tuple<A, B>> init, Func<A, B, Option<Tuple<A, B>>> f)
=> Collection.FoldWhileSome(init, f);
public static IImmutableEnumerator<T> Empty<T>()
=> ImmutableEnumeratorExtensionMethods.Empty<T>();

9
Utils/Immutable/Option.cs
View File

@ -64,9 +64,18 @@ namespace Immutable {
public static Option<U> IfSome<T, U>(this Option<T> o, Func<T, U> some)
=> o.Map(some);
public static Option<T> If<T>(this T value, Func<T, bool> predicate)
=> predicate(value) ? value.Some() : Option.None<T>();
public static Option<ValueTuple<T1, T2>> If<T1, T2>(this ValueTuple<T1, T2> value, Func<T1, T2, bool> predicate)
=> predicate(value.Item1, value.Item2) ? value.Some() : Option.None<ValueTuple<T1, T2>>();
public static Option<U> IfSome<T1, T2, U>(this Option<Tuple<T1, T2>> o, Func<T1, T2, U> some)
=> o.Map(o1o2 => some(o1o2.Item1, o1o2.Item2));
public static Option<U> IfSome<T1, T2, U>(this Option<ValueTuple<T1, T2>> o, Func<T1, T2, U> some)
=> o.Map(o1o2 => some(o1o2.Item1, o1o2.Item2));
public static Option<U> Bind<T, U>(this Option<T> o, Func<T, Option<U>> f)
=> o.Match_(Some: some => f(some),
None: () => Option.None<U>());

1
Utils/Piping.cs
View File

@ -3,6 +3,7 @@ using System.Linq;
public static class Piping {
public static U Pipe<T, U>(this T x, Func<T, U> f) => f(x);
public static U Pipe<T1, T2, U>(this ValueTuple<T1, T2> x, Func<T1, T2, U> f) => f(x.Item1, x.Item2);
public static void Pipe<T>(this T x, Action<T> f) => f(x);