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

Lexer on IImmutableEnumerable (replayable streams, leaves open the possibility to make coroutines to update the lexer's tokens later)

Browse Source
This commit is contained in:
Suzanne Soy 2020-08-30 16:11:50 +00:00
parent 90e9a53107
commit afb04df4a6
23 changed files with 1077 additions and 68 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
.gitignore vendored
View File

@ -1,5 +1,6 @@
/tests_results
/main.exe
/main.exe.mdb
/*Generated.cs
/*Generator.exe
*Generated.cs
*GeneratedF.cs
*Generator.exe

38
F.sed Normal file
View File

@ -0,0 +1,38 @@
#!/usr/bin/env sed -nf
/^[^ ].*/p
/\[F\]/,/^ *)/{
s/\( *\)private partial class \(.*\) {/\1\2/;
t classHeader;
b notClassHeader;
:classHeader
h;
s/\( *\)\(.*\)/\1private partial class \2 : IEqF</p;
b next;
:notClassHeader
/\[F\]/! {
s/^ *)/&/;
t end;
s/^ *public \(.*\) F(.*$/\1/;
t skip;
s/ *\([^ ].*\) [^ ][^ ]*$/ \1,/p;
s/^/ /;
H;
b next;
:skip H;
b next;
:end
x;
# s/\( *\)\([^\n<]*\)\([^\n]*\)\n\([^\n]*\)\n\(.*\)$/\1 \4\n > {\n\1 private \2() {}\n\1 public static readonly \2\3 Eq = new \2\3();\n\1 public static bool operator ==(\2\3 a, \2\3 b)\n\1 => Equality.Operator(a, b);\n\1 public static bool operator !=(\2\3 a, \2\3 b)\n\1 => !(a == b);\n\1 public override bool Equals(object other)\n\1 => Equality.Untyped<\2\3>(\n\1 this,\n\1 other,\n\1 x => x as \2\3,\n\1 x => x.hashCode);\n\1 public bool Equals(IEqF<\n\5\n\1 \4\n\1 > other)\n\1 => Equality.Equatable<IEqF<\n\5\n\1 \4\n\1 >>(this, other);\n\1 private int hashCode = HashCode.Combine("\2\3");\n\1 public override int GetHashCode() => hashCode;\n\1 public override string ToString() => "Equatable function \2\3()";\n\1}\n/;
s/\( *\)\([^\n<]*\)\([^\n]*\)\n\([^\n]*\)\n\(.*\)$/\1 \4\n >, IEquatable<\2\3> {\n\1 private \2() {}\n\1 public static readonly \2\3 Eq = new \2\3();\n\1 public static bool operator ==(\2\3 a, \2\3 b)\n\1 => Equality.Operator(a, b);\n\1 public static bool operator !=(\2\3 a, \2\3 b)\n\1 => !(a == b);\n\1 public override bool Equals(object other)\n\1 => Equality.Untyped<\2\3>(\n\1 this,\n\1 other,\n\1 x => x as \2\3,\n\1 x => x.hashCode);\n\1 public bool Equals(\2\3 other)\n\1 => Equality.Equatable<\2\3>(this, other);\n\1 private int hashCode = HashCode.Combine("\2\3");\n\1 public override int GetHashCode() => hashCode;\n\1 public override string ToString() => "Equatable function \2\3()";\n\1}\n/;
p;
# Clear hold space
s/.*//;
h;
:next
}
}

96
Lexer.cs
View File

@ -1,5 +1,4 @@
using System;
using System.Text;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Linq;
@ -127,7 +126,7 @@ public static partial class Lexer {
}
}
private static IEnumerable<Lexeme> Transition(ref S state, ref string lexeme, GraphemeCluster c, Rule rule) {
private static ValueTuple<S, string, IImmutableEnumerator<Lexeme>> Transition(S state, string lexeme, GraphemeCluster c, Rule rule) {
List<Lexeme> result = new List<Lexeme>();
if (rule.throughState != state) {
result.Add(new Lexeme(state, lexeme));
@ -140,13 +139,19 @@ public static partial class Lexer {
state = rule.newState;
lexeme = "";
}
return result;
return (state, lexeme, result.GetImmutableEnumerator());
}
public static ParserErrorException ParserError(StringBuilder context, IEnumerator<GraphemeCluster> stream, S state, List<Rule> possibleNext, GraphemeCluster gc) {
var rest =
stream
.SingleUseEnumerable()
public static ParserErrorException ParserError(IImmutableEnumerator<GraphemeCluster> context, IImmutableEnumerator<GraphemeCluster> rest, S state, List<Rule> possibleNext, GraphemeCluster gc) {
var strContext =
context
.ToIEnumerable()
.TakeUntil(c => c.Equals(rest))
.Select(c => c.str)
.JoinWith("");
var strRest =
rest
.TakeUntil(c => c.str.StartsWith("\n"))
.Select(c => c.str)
.JoinWith("");
@ -158,39 +163,72 @@ public static partial class Lexer {
.Match(Some: x => x.UnicodeCategory(0).ToString(),
None: "None (empty string)");
return new ParserErrorException(
$"Unexpected {actual} (Unicode category {cat}) while the lexer was in state {state}: expected one of {expected}{Environment.NewLine}{context} <--HERE {rest}"
$"Unexpected {actual} (Unicode category {cat}) while the lexer was in state {state}: expected one of {expected}{Environment.NewLine}{strContext} <--HERE {strRest}"
);
}
// fake Unicode category
private const UnicodeCategory EndOfFile = (UnicodeCategory)(-1);
public static IEnumerable<IEnumerable<Lexeme>> Lex1(string source) {
var context = new StringBuilder();
var lexeme = "";
var state = S.Space;
var e = source.TextElements().GetEnumerator();
while (e.MoveNext()) {
var c = e.Current;
context.Append(c.str);
public static U Foo<T, U>(T x, Func<T, U> f) => f(x);
[F]
private partial class Flub {
public ValueTuple<ValueTuple<string, S, IImmutableEnumerator<GraphemeCluster>>, IImmutableEnumerator<Lexeme>> F(
ValueTuple<string, S, IImmutableEnumerator<GraphemeCluster>> t,
ValueTuple<GraphemeCluster, IImmutableEnumerator<GraphemeCluster>> cur
)
{
var (lexeme, state, context) = t;
var (c, current) = cur;
var possibleNext = Rules.WithEpsilonTransitions[state];
yield return
return
possibleNext
.First(r => r.test(c))
.IfSome(rule => Transition(ref state, ref lexeme, c, rule))
.ElseThrow(() => ParserError(context, e, state, possibleNext, c));
.IfSome(rule => {
var r = Transition(state, lexeme, c, rule);
var newState = r.Item1;
var newLexeme = r.Item2;
var tokens = r.Item3;
return ((newLexeme, newState, context), tokens);
})
.ElseThrow(() => ParserError(context, current, state, possibleNext, c));
}
}
public static IEnumerable<Lexeme> Lex(string source) {
var first = true;
foreach (var x in Lex1(source).SelectMany(x => x)) {
if (first && "".Equals(x.lexeme)) {
// skip the initial empty whitespace
} else {
first = false;
yield return x;
}
}
public static IImmutableEnumerator<IImmutableEnumerator<Lexeme>> Lex2(IImmutableEnumerator<GraphemeCluster> ie) {
var lexeme = "";
var state = S.Space;
// In a REPL we could reset the context at the end of each statement.
// We could also reset the context to the containing line or function when processing files.
var context = ie;
return ie.SelectAggregate((lexeme, state, context), Flub.Eq);
}
public static IImmutableEnumerator<IImmutableEnumerator<Lexeme>>
Lex1(string source)
=> Lex2(source.TextElements().GetImmutableEnumerator());
[F]
private partial class SkipInitialEmptyWhitespace {
public IImmutableEnumerator<Lexeme> F(
IImmutableEnumerator<Lexeme> lx
)
=> lx.FirstAndRest().Match<Tuple<Lexeme, IImmutableEnumerator<Lexeme>>, IImmutableEnumerator<Lexeme>>(
Some: hdtl =>
// skip the initial empty whitespace
string.Equals(
"",
hdtl.Item1.lexeme)
? hdtl.Item2
: hdtl.Item1.ImSingleton().Concat(hdtl.Item2),
None: Empty<Lexeme>());
}
public static IImmutableEnumerator<Lexeme> Lex(string source)
=> Lex1(source)
.Flatten()
.Lazy(SkipInitialEmptyWhitespace.Eq);
}

8
Makefile
View File

@ -2,12 +2,13 @@ CS := $(shell find . -not \( -path ./.git \) -not \( -name '*Generator.cs' \) -n
META := $(shell find ./T4/ -name '*.cs')
GENERATORS := $(shell find . -not \( -path ./.git \) -not \( -path './T4/*' \) -name '*Generator.cs')
GENERATED := $(patsubst %Generator.cs,%Generated.cs,$(GENERATORS))
GENERATEDF := $(patsubst %.cs,%GeneratedF.cs,$(shell git grep -l '\[F\]' | grep '\.cs$$'))
.PHONY: run
run: main.exe Makefile
MONO_PATH=/usr/lib/mono/4.5/:/usr/lib/mono/4.5/Facades/ mono $<
main.exe: $(CS) $(GENERATED) Makefile
main.exe: $(CS) $(GENERATED) $(GENERATEDF) Makefile
@echo 'Compiling…'
@mcs -debug+ -out:$@ \
/reference:/usr/lib/mono/4.5/System.Collections.Immutable.dll \
@ -17,7 +18,7 @@ main.exe: $(CS) $(GENERATED) Makefile
%Generated.cs: .%Generator.exe Makefile
@echo 'Running code generator…'
@MONO_PATH=/usr/lib/mono/4.5/:/usr/lib/mono/4.5/Facades/ \
mono $(filter-out Makefile, $<)
mono $<
.%Generator.exe: %Generator.cs $(META) Makefile
@echo 'Compiling code generator…'
@ -26,4 +27,7 @@ main.exe: $(CS) $(GENERATED) Makefile
/reference:/usr/lib/mono/4.5/Facades/netstandard.dll \
$(filter-out Makefile, $^)
%GeneratedF.cs: %.cs F.sed Makefile
@echo 'Running code generator…'
@sed -n -f F.sed $< > $@

42
Parser.cs
View File

@ -19,49 +19,23 @@ public static partial class Parser {
throw new NotImplementedException();
}
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>();
} else {
acc = @new.ElseThrow(() => new Exception("impossible"));
}
}
return acc.Some();
}
public static A WhileSome<A>(A init, Func<A, Option<A>> f) {
var lastGood = init;
while (true) {
var @new = f(lastGood);
if (@new.IsNone) {
return lastGood;
} else {
lastGood = @new.ElseThrow(() => new Exception("impossible"));
}
}
}
public static Option<ImmutableEnumerator<Lexeme>> Parse3(
public static Option<IImmutableEnumerator<Lexeme>> Parse3(
Func<Grammar2,
ImmutableEnumerator<Lexeme>,
Option<ImmutableEnumerator<Lexeme>>>
IImmutableEnumerator<Lexeme>,
Option<IImmutableEnumerator<Lexeme>>>
Parse3,
Grammar2 grammar,
ImmutableEnumerator<Lexeme> tokens
IImmutableEnumerator<Lexeme> tokens
) =>
tokens
.MoveNext()
.Match<Tuple<Lexeme, ImmutableEnumerator<Lexeme>>, Option<ImmutableEnumerator<Lexeme>>>(
.FirstAndRest()
.Match(
None: () =>
throw new Exception("EOF, what to do?"),
Some: headRest => {
throw new Exception("NIY");
var first = headRest.Item1;
var rest = headRest.Item2;
grammar.Match<Option<ImmutableEnumerator<Lexeme>>>(
return grammar.Match(
RepeatOnePlus: g =>
Parse3(g, rest)
.IfSome(rest1 =>
@ -78,7 +52,7 @@ public static partial class Parser {
Terminal: t =>
first.state.Equals(t)
? rest.Some()
: None<ImmutableEnumerator<Lexeme>>()
: None<IImmutableEnumerator<Lexeme>>()
);
// TODO: at the top-level, check that the lexemes
// are empty if the parser won't accept anything else.

28
Utils/Enumerable.cs
View File

@ -235,4 +235,32 @@ 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>();
} else {
acc = @new.ElseThrow(() => new Exception("impossible"));
}
}
return acc.Some();
}
public static A WhileSome<A>(this A init, Func<A, Option<A>> f) {
var lastGood = init;
while (true) {
var @new = f(lastGood);
if (@new.IsNone) {
return lastGood;
} else {
lastGood = @new.ElseThrow(() => new Exception("impossible"));
}
}
}
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)));
}

48
Utils/Func.cs
View File

@ -70,4 +70,50 @@ public static class Func {
public static C YMemoized<A, B, C>(this Func<Func<A, B, C>, A, B, C> f, A a, B b) where A : IEquatable<A> where B : IEquatable<B>
=> f.YMemoize()(a, b);
}
}
// IEquatableFunction
// Possible with <in T, out U> if we remove the IEquatable constraint
public interface IEqF<T, U> {// : IEquatable<IEqF<T, U>> {
U F(T x);
}
public interface IEqF<T1, T2, U> {// : IEquatable<IEqF<T, U>> {
U F(T1 x, T2 y);
}
[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
public class F : System.Attribute {}
public class PartialEqF<T1, T2, U> : IEqF<T2, U>, IEquatable<PartialEqF<T1, T2, U>> {
private readonly IEqF<T1, T2, U> f;
private readonly T1 arg1;
public PartialEqF(IEqF<T1, T2, U> f, T1 arg1) {
this.f = f;
this.arg1 = arg1;
hashCode = Equality.HashCode("PartialEqF<T1, T2, U>", f, arg1);
}
public U F(T2 arg2) => f.F(arg1, arg2);
public static bool operator ==(PartialEqF<T1, T2, U> a, PartialEqF<T1, T2, U> b)
=> Equality.Operator(a, b);
public static bool operator !=(PartialEqF<T1, T2, U> a, PartialEqF<T1, T2, U> b)
=> !(a == b);
public override bool Equals(object other)
=> Equality.Untyped<PartialEqF<T1, T2, U>>(
this,
other,
x => x as PartialEqF<T1, T2, U>,
x => x.hashCode,
x => x.f,
x => x.arg1);
public bool Equals(PartialEqF<T1, T2, U> other)
=> Equality.Equatable<PartialEqF<T1, T2, U>>(this, other);
private int hashCode;
public override int GetHashCode() => hashCode;
public override string ToString() => "Equatable function PartialEqF<T1, T2, U>()";
}
public static class EqFExtensionMethods {
public static IEqF<T2, U> ImPartial<T1, T2, U>(this IEqF<T1, T2, U> f, T1 arg1)
=> new PartialEqF<T1, T2, U>(f, arg1);
}

9
Utils/Global.cs
View File

@ -22,4 +22,13 @@ public static class Global {
=> xs.ToImmutableHashSet();
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 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 IImmutableEnumerator<T> Empty<T>()
=> ImmutableEnumeratorExtensionMethods.Empty<T>();
}

220
Utils/Immutable/Enumerator/ExtensionMethods.cs Normal file
View File

@ -0,0 +1,220 @@
// Code quality of this file: low.
// We need an annotation on lambdas to lift them to equatable singletons.
using System;
using System.Collections;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
namespace Immutable {
public static partial class ImmutableEnumeratorExtensionMethods {
public static IImmutableEnumerator<T> ToImmutableEnumerator<T>(this IEnumerator<T> e)
=> ImmutableEnumerator<T>.Make(e);
public static IImmutableEnumerator<T> GetImmutableEnumerator<T>(this IEnumerable<T> e)
=> e.GetEnumerator().ToImmutableEnumerator();
public static Option<Tuple<T, IImmutableEnumerator<T>>> FirstAndRest<T>(this IImmutableEnumerator<T> e)
=> e.MoveNext()
.Match(
None: () =>
Option.None<Tuple<T, IImmutableEnumerator<T>>>(),
Some: elt =>
new Tuple<T, IImmutableEnumerator<T>>(
elt.First,
elt.Rest
).Some()
);
public static IEnumerable<T> ToIEnumerable<T>(this IImmutableEnumerator<T> e) {
var next = e.MoveNext();
while (next.IsSome) {
var elem = next.ElseThrow(new Exception("impossible"));
yield return elem.First;
next = elem.Rest.MoveNext();
}
}
[F]
private partial class TakeUntil_<T> {
public Option<Tuple<T, IImmutableEnumerator<T>>> F(
ValueTuple<IImmutableEnumerator<T> /*e*/, IEqF<IImmutableEnumerator<T>, bool> /*predicate*/> t
)
=> t.Item2.F(t.Item1)
? Option.None<Tuple<T, IImmutableEnumerator<T>>>()
: t.Item1.MoveNext().IfSome(next =>
new Tuple<T, IImmutableEnumerator<T>>(
next.First,
TakeUntil<T>(next.Rest, t.Item2)));
}
public static IImmutableEnumerator<T> TakeUntil<T>(this IImmutableEnumerator<T> e, IEqF<IImmutableEnumerator<T>, bool> predicate)
=> new PureImmutableEnumerator<
ValueTuple<
IImmutableEnumerator<T>,
IEqF<IImmutableEnumerator<T>, bool>
>,
T>(
(e, predicate),
TakeUntil_<T>.Eq);
[F]
private partial class Empty_<T> {
public Option<Tuple<T, IImmutableEnumerator<T>>> F(
Unit _
)
=> Option.None<Tuple<T, IImmutableEnumerator<T>>>();
}
public static IImmutableEnumerator<T> Empty<T>()
=> new PureImmutableEnumerator<Unit, T>(
Unit.unit,
Empty_<T>.Eq);
[F]
private partial class ImSingleton_<T> {
public Option<Tuple<T, IImmutableEnumerator<T>>> F(
T value
)
=> new Tuple<T, IImmutableEnumerator<T>>(
value,
Empty<T>()
).Some();
}
public static IImmutableEnumerator<T> ImSingleton<T>(this T value)
=> new PureImmutableEnumerator<T, T>(
value,
ImSingleton_<T>.Eq);
[F]
private partial class Concat_<T> {
public Option<Tuple<T, IImmutableEnumerator<T>>> F(
ValueTuple<IImmutableEnumerator<T>, /*e1*/ IImmutableEnumerator<T> /*e2*/> t
)
=> t.Item1.MoveNext().Match(
Some: element =>
new Tuple<T, IImmutableEnumerator<T>>(
element.First,
element.Rest.Concat(t.Item2)
).Some(),
None: () =>
t.Item2.MoveNext().IfSome(element =>
new Tuple<T, IImmutableEnumerator<T>>(
element.First,
element.Rest)));
}
public static IImmutableEnumerator<T> Concat<T>(this IImmutableEnumerator<T> e1, IImmutableEnumerator<T> e2)
=> new PureImmutableEnumerator<
ValueTuple<
IImmutableEnumerator<T> /*e1*/,
IImmutableEnumerator<T> /*e2*/
>,
T>(
(e1, e2),
Concat_<T>.Eq);
[F]
private partial class Lazy_<T, U> {
public Option<Tuple<U, IImmutableEnumerator<U>>> F(
ValueTuple<T, /*e*/ IEqF<T, IImmutableEnumerator<U>> /*f*/> t
)
=> t.Item2.F(t.Item1).MoveNext().IfSome(element =>
new Tuple<U, IImmutableEnumerator<U>>(
element.First,
element.Rest
));
}
// Apply a transformation to an immutable enumerator.
// The transformation function is only called when the
// result is stepped. It should only step its input
// enough to produce one element, but not more.
public static IImmutableEnumerator<U> Lazy<T, U>(
this IImmutableEnumerator<T> e,
IEqF<IImmutableEnumerator<T>, IImmutableEnumerator<U>> f)
=> new PureImmutableEnumerator<
ValueTuple<
IImmutableEnumerator<T> /*e*/,
IEqF<IImmutableEnumerator<T>, IImmutableEnumerator<U>> /*f*/
>,
U>(
(e, f),
Lazy_<IImmutableEnumerator<T>, U>.Eq);
public static IImmutableEnumerator<U> Lazy<T, U, V>(
this IImmutableEnumerator<T> e,
IEqF<
ValueTuple<IImmutableEnumerator<T> /*e*/, V /*v*/>,
IImmutableEnumerator<U>
> f,
V v)
=> new PureImmutableEnumerator<
ValueTuple<
ValueTuple<IImmutableEnumerator<T> /*e*/, V /*v*/>,
IEqF<
ValueTuple<IImmutableEnumerator<T> /*e*/,
V /*v*/>,
IImmutableEnumerator<U>> /*f*/
>,
U>(
((e, v), f),
Lazy_<ValueTuple<IImmutableEnumerator<T>, V>, U>.Eq);
[F]
private partial class Flatten_<T> {
public IImmutableEnumerator<T> F(
IImmutableEnumerator<IImmutableEnumerator<T>> e
)
=> e.MoveNext().Match(
Some: element =>
element.First.Concat(element.Rest.Flatten()),
None: () =>
Empty<T>());
}
public static IImmutableEnumerator<T> Flatten<T>(this IImmutableEnumerator<IImmutableEnumerator<T>> e)
=> e.Lazy(Flatten_<T>.Eq);
[F]
private partial class Select_<T, U> {
public IImmutableEnumerator<U> F(
ValueTuple<IImmutableEnumerator<T> /*e*/, IEqF<ValueTuple<T, IImmutableEnumerator<T>>, U> /*f*/> t
)
=> t.Item1.MoveNext().Match(
Some: element =>
t.Item2.F((element.First, t.Item1)).ImSingleton().Concat(
element.Rest.Select(t.Item2)),
None: () =>
Empty<U>());
}
public static IImmutableEnumerator<U> Select<T, U>(this IImmutableEnumerator<T> e, IEqF<ValueTuple<T, IImmutableEnumerator<T>>, U> f)
=> Lazy(e, Select_<T, U>.Eq, f);
[F]
private partial class SelectAggregate_<A, T, U> {
public IImmutableEnumerator<U> F(
ValueTuple<IImmutableEnumerator<T> /*e*/, ValueTuple<A, IEqF<A, ValueTuple<T, IImmutableEnumerator<T>>, ValueTuple<A, U>> /*f*/>> t
)
{
var (e, accf) = t;
var (acc, f) = accf;
return e.MoveNext().Match(
Some: element => {
var res = f.F(acc, (element.First, e));
var newAcc = res.Item1;
var result = res.Item2;
return result.ImSingleton().Concat<U>(
element.Rest.SelectAggregate(newAcc, f));
},
None: () =>
Empty<U>());
}
}
public static IImmutableEnumerator<U> SelectAggregate<A, T, U>(this IImmutableEnumerator<T> e, A acc, IEqF<A, ValueTuple<T, IImmutableEnumerator<T>>, ValueTuple<A, U>> f)
=> Lazy(e, SelectAggregate_<A, T, U>.Eq, (acc, f));
}
}

10
Utils/Immutable/Enumerator/IImmutableEnumerator.cs Normal file
View File

@ -0,0 +1,10 @@
using System;
using System.Collections;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
namespace Immutable {
public interface IImmutableEnumerator<T> : IEquatable<IImmutableEnumerator<T>>, IEnumerable<T>, IDisposable {
Option<IImmutableEnumeratorElement<T>> MoveNext();
}
}

12
Utils/Immutable/Enumerator/IImmutableEnumeratorElement.cs Normal file
View File

@ -0,0 +1,12 @@
using System;
using System.Collections;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
namespace Immutable {
public interface IImmutableEnumeratorElement<T> :
IEquatable<IImmutableEnumeratorElement<T>>, IDisposable {
T First { get; }
IImmutableEnumerator<T> Rest { get; }
}
}

119
Utils/Immutable/Enumerator/ImmutableEnumerator.cs Normal file
View File

@ -0,0 +1,119 @@
using System;
using System.Collections;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
// enumerator = { next: lazylist }
// enumeratorElement = {
// current: U;
// next: lazylist;
// }
// state = AlreadyUnfoldedEnd
// | AlreadyUnfolded of ImmutableEnumeratorElement<U>
// | NotUnfoldedYet of IEnumerator<U>
// lazylist = state ref
namespace Immutable {
// enumerator = { next: lazylist }
public partial class ImmutableEnumerator<U> : IImmutableEnumerator<U> {
private readonly LazyList next; // readonly
private readonly Last last; // readonly
private readonly int hashCode;
private ImmutableEnumerator(LazyList next, Last last) {
this.next = next;
this.last = last;
// Use the default hashCode on the single mutable LazyList
// instance for this position in the enumerator.
this.hashCode = next.GetHashCode();
}
public void Dispose() {
// Calling this method on any copy of any immutable
// enumerator, including via a using(){} directive
// is DANGEROUS: it will make it impossible to enumerate
// past the current position of the underlying enumerator,
// when starting from any copy of any immutable enumerator
// for that underlying enumerator.
// As a precaution, and to catch bugs early, we make it
// impossible to use any of the copies of any immutable
// enumerator for that underlying enumerator once this method
// has been called.
last.LAST.CallDispose();
last.EXPLICITLY_DISPOSED = true;
}
public static ImmutableEnumerator<U> Make(IEnumerator<U> e) {
var last = new Last { LAST = null };
var lst = new LazyList {
NEXT = new State.NotUnfoldedYet(e, last)
};
last.LAST = lst;
return new ImmutableEnumerator<U>(lst, last);
}
public Option<IImmutableEnumeratorElement<U>> MoveNext() {
if (this.last.EXPLICITLY_DISPOSED) {
throw new ObjectDisposedException("Cannot use an ImmutableEnumerator after it was explicitly disposed.");
}
return next.NEXT.Match(
AlreadyUnfoldedEnd: () =>
Option.None<IImmutableEnumeratorElement<U>>(),
AlreadyUnfolded: element =>
element.Some(),
NotUnfoldedYet: (e, last) => {
if (e.MoveNext()) {
var lst = new LazyList {
NEXT = new State.NotUnfoldedYet(e, last)
};
last.LAST = lst;
var elem = new ImmutableEnumeratorElement(
current: e.Current,
next: lst,
last : last);
next.NEXT = new State.AlreadyUnfolded(elem);
return elem.Some();
} else {
next.NEXT = new State.AlreadyUnfoldedEnd();
// Call .Dispose() on the underlying enumerator
// because we have read all its elements.
e.Dispose();
return Option.None<IImmutableEnumeratorElement<U>>();
}
}
);
}
public static bool operator ==(ImmutableEnumerator<U> a, ImmutableEnumerator<U> b)
=> Equality.Operator(a, b);
public static bool operator !=(ImmutableEnumerator<U> a, ImmutableEnumerator<U> b)
=> !(a == b);
public override bool Equals(object other)
=> Equality.Untyped<ImmutableEnumerator<U>>(
this,
other,
x => x as ImmutableEnumerator<U>,
x => x.hashCode,
// Two immutable enumerators are equal if and only if
// they are at the same position and use the same
// underlying enumerable. In that case they are guaranteed
// to behave identically to an outside observer (except for
// side-effects caused by the iteration of the underlying
// enumerator, which only occur on the first .MoveNext()
// call, if it is called on several equal immutable
// enumerators). This is also true for the
// ImmutableEnumeratorElement subclass, because if two of
// these have the same underlying generator, their current
// field are necessarily one and the same.
(x, y) => Object.ReferenceEquals(x.next, y.next));
public bool Equals(IImmutableEnumerator<U> other)
=> Equality.Equatable<IImmutableEnumerator<U>>(this, other);
public override int GetHashCode() => hashCode;
public override string ToString() => "ImmutableEnumerator";
public IEnumerator<U> GetEnumerator()
=> this.ToIEnumerable().GetEnumerator();
IEnumerator IEnumerable.GetEnumerator()
=> this.ToIEnumerable().GetEnumerator();
}
}

92
Utils/Immutable/Enumerator/ImmutableEnumeratorElement.cs Normal file
View File

@ -0,0 +1,92 @@
using System;
using System.Collections;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
// enumerator = { next: lazylist }
// enumeratorElement = {
// current: U;
// next: lazylist;
// }
// state = AlreadyUnfoldedEnd
// | AlreadyUnfolded of ImmutableEnumeratorElement<U>
// | NotUnfoldedYet of IEnumerator<U>
// lazylist = state ref
namespace Immutable {
// enumerator = { next: lazylist }
public partial class ImmutableEnumerator<U> : IImmutableEnumerator<U> {
// enumeratorElement = {
// current: U;
// next: lazylist;
// }
private sealed class ImmutableEnumeratorElement : IImmutableEnumeratorElement<U> {
private readonly U current; // immutable
private readonly ImmutableEnumerator<U> rest;
private readonly int hashCode;
public ImmutableEnumeratorElement(U current, LazyList next, Last last) {
this.current = current;
this.rest = new ImmutableEnumerator<U>(next, last);
this.hashCode = Equality.HashCode(current, rest);
}
public U First {
get {
if (this.rest.last.EXPLICITLY_DISPOSED) {
throw new ObjectDisposedException("Cannot use an ImmutableEnumerator after it was explicitly disposed.");
}
return current;
}
}
public IImmutableEnumerator<U> Rest { get => rest; }
public void Dispose() {
// Calling this method on any copy of any immutable
// enumerator, including via a using(){} directive
// is DANGEROUS: it will make it impossible to enumerate
// past the current position of the underlying enumerator,
// when starting from any copy of any immutable enumerator
// for that underlying enumerator.
// As a precaution, and to catch bugs early, we make it
// impossible to use any of the copies of any immutable
// enumerator for that underlying enumerator once this method
// has been called.
rest.last.LAST.CallDispose();
rest.last.EXPLICITLY_DISPOSED = true;
}
public Option<IImmutableEnumeratorElement<U>> MoveNext()
=> rest.MoveNext();
public static bool operator ==(ImmutableEnumeratorElement a, ImmutableEnumeratorElement b)
=> Equality.Operator(a, b);
public static bool operator !=(ImmutableEnumeratorElement a, ImmutableEnumeratorElement b)
=> !(a == b);
public override bool Equals(object other)
=> Equality.Untyped<ImmutableEnumeratorElement>(
this,
other,
x => x as ImmutableEnumeratorElement,
x => x.hashCode,
// Two immutable enumerators are equal if and only if
// they are at the same position and use the same
// underlying enumerable. In that case they are guaranteed
// to behave identically to an outside observer (except for
// side-effects caused by the iteration of the underlying
// enumerator, which only occur on the first .MoveNext()
// call, if it is called on several equal immutable
// enumerators). This is also true for the
// ImmutableEnumeratorElement subclass, because if two of
// these have the same underlying generator, their current
// field are necessarily one and the same.
x => x.current,
x => x.rest);
public bool Equals(IImmutableEnumeratorElement<U> other)
=> Equality.Equatable<IImmutableEnumeratorElement<U>>(this, other);
public override int GetHashCode() => hashCode;
public override string ToString() => "ImmutableEnumeratorElement";
}
}
}

34
Utils/Immutable/Enumerator/Last.cs Normal file
View File

@ -0,0 +1,34 @@
using System;
using System.Collections;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
// enumerator = { next: lazylist }
// enumeratorElement = {
// current: U;
// next: lazylist;
// }
// state = AlreadyUnfoldedEnd
// | AlreadyUnfolded of ImmutableEnumeratorElement<U>
// | NotUnfoldedYet of IEnumerator<U>
// lazylist = state ref
namespace Immutable {
// enumerator = { next: lazylist }
public partial class ImmutableEnumerator<U> : IImmutableEnumerator<U> {
private class Last {
// This is one of the three mutable fields in this file.
// It is used to update the pointer to the only
// NotUnfoldedYet object for a given underlying enumerator.
// This allows a call on .Dispose() to clean up after the
// underlying enumerator.
public LazyList LAST;
// This is one of the three mutable fields in this file.
// It is used to indicate that the .Dispose() method has
// been called and that it is therefore unsafe to continue
// using the immutable enumerator for this underlying
// enumerator.
public bool EXPLICITLY_DISPOSED = false;
}
}
}

49
Utils/Immutable/Enumerator/LazyList.cs Normal file
View File

@ -0,0 +1,49 @@
using System;
using System.Collections;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
// enumerator = { next: lazylist }
// enumeratorElement = {
// current: U;
// next: lazylist;
// }
// state = AlreadyUnfoldedEnd
// | AlreadyUnfolded of ImmutableEnumeratorElement<U>
// | NotUnfoldedYet of IEnumerator<U>
// lazylist = state ref
namespace Immutable {
// enumerator = { next: lazylist }
public partial class ImmutableEnumerator<U> : IImmutableEnumerator<U> {
// lazylist = state ref
private class LazyList {
// This is one of the three mutable fields in this file.
// There is one LazyList object created each time
// the underlying enumerator's MoveNext() method
// is called, except for the last failed MoveNext()
// call. There is also one initial LazyList element
// created when wrapping the underlying enumerator
// to create an immutable enumerator.
public State NEXT; // mutable
~LazyList() { this.CallDispose(); }
public void CallDispose() {
NEXT.Match(
AlreadyUnfoldedEnd: () => Unit.unit,
AlreadyUnfolded: _e => Unit.unit,
// Since at any one time there is only one LazyList
// whose state is NotUnfoldedYet (except during the
// unfolding, when there two such lists manipulated for
// a brief time by the same lambda), the enumerator
// should be disposed of when the destructor of this
// class is called.
NotUnfoldedYet: (r, last) => {
r.Dispose();
return Unit.unit;
}
);
}
}
}
}

49
Utils/Immutable/Enumerator/PureImmutableEnumerator.cs Normal file
View File

@ -0,0 +1,49 @@
using System;
using System.Collections;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
namespace Immutable {
public class PureImmutableEnumerator<T, U> : IImmutableEnumerator<U> {
private T state;
private IEqF<T, Option<Tuple<U, IImmutableEnumerator<U>>>> generator;
private int hashCode;
public PureImmutableEnumerator(T state, IEqF<T, Option<Tuple<U, IImmutableEnumerator<U>>>> generator) {
this.state = state;
this.generator = generator;
this.hashCode = Equality.HashCode("PureImmutableEnumerator", state, generator);
}
public static bool operator ==(PureImmutableEnumerator<T, U> a, PureImmutableEnumerator<T, U> b)
=> Equality.Operator(a, b);
public static bool operator !=(PureImmutableEnumerator<T, U> a, PureImmutableEnumerator<T, U> b)
=> !(a == b);
public override bool Equals(object other)
=> Equality.Untyped(
this,
other,
x => x as PureImmutableEnumerator<T, U>,
x => x.hashCode,
// Two immutable enumerators are equal if and only if
// they have the same (immutable) state and use the same
// generator lambda.
x => x.state,
x => x.generator);
public bool Equals(IImmutableEnumerator<U> other)
=> Equality.Equatable<IImmutableEnumerator<U>>(this, other);
public override int GetHashCode() => hashCode;
public override string ToString() => "ImmutableEnumerator";
public IEnumerator<U> GetEnumerator()
=> this.ToIEnumerable().GetEnumerator();
IEnumerator IEnumerable.GetEnumerator()
=> this.ToIEnumerable().GetEnumerator();
void IDisposable.Dispose() { /* Nothing to do */ }
public Option<IImmutableEnumeratorElement<U>> MoveNext()
=> generator.F(state).IfSome((first, rest) =>
new PureImmutableEnumeratorElement<U>(first, rest));
}
}

47
Utils/Immutable/Enumerator/PureImmutableEnumeratorElement.cs Normal file
View File

@ -0,0 +1,47 @@
using System;
using System.Collections;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
namespace Immutable {
public class PureImmutableEnumeratorElement<U> : IImmutableEnumeratorElement<U> {
private U element;
private IImmutableEnumerator<U> rest;
private int hashCode;
public PureImmutableEnumeratorElement(U element, IImmutableEnumerator<U> rest) {
this.element = element;
this.rest = rest;
this.hashCode = Equality.HashCode("PureImmutableEnumeratorElement", element, rest);
}
public static bool operator ==(PureImmutableEnumeratorElement<U> a, PureImmutableEnumeratorElement<U> b)
=> Equality.Operator(a, b);
public static bool operator !=(PureImmutableEnumeratorElement<U> a, PureImmutableEnumeratorElement<U> b)
=> !(a == b);
public override bool Equals(object other)
=> Equality.Untyped<PureImmutableEnumeratorElement<U>>(
this,
other,
x => x as PureImmutableEnumeratorElement<U>,
x => x.hashCode,
// Two immutable enumerators are equal if and only if
// they have the same (immutable) state and use the same
// generator lambda.
x => x.element,
x => x.rest);
public bool Equals(IImmutableEnumeratorElement<U> other)
=> Equality.Equatable<IImmutableEnumeratorElement<U>>(this, other);
public override int GetHashCode() => hashCode;
public override string ToString() => "PureImmutableEnumeratorElement";
public void Dispose() { /* Nothing to do */ }
public U First { get => element; }
public IImmutableEnumerator<U> Rest { get => rest; }
public Option<IImmutableEnumeratorElement<U>> MoveNext()
=> rest.MoveNext();
}
}

64
Utils/Immutable/Enumerator/State.cs Normal file
View File

@ -0,0 +1,64 @@
using System;
using System.Collections;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
// enumerator = { next: lazylist }
// enumeratorElement = {
// current: U;
// next: lazylist;
// }
// state = AlreadyUnfoldedEnd
// | AlreadyUnfolded of ImmutableEnumeratorElement<U>
// | NotUnfoldedYet of IEnumerator<U>
// lazylist = state ref
namespace Immutable {
// enumerator = { next: lazylist }
public partial class ImmutableEnumerator<U> : IImmutableEnumerator<U> {
// state = AlreadyUnfoldedEnd
// | AlreadyUnfolded of ImmutableEnumeratorElement<U>
// | NotUnfoldedYet of IEnumerator<U>
private abstract class State {
public abstract T Match<T>(
Func<ImmutableEnumeratorElement, T> AlreadyUnfolded,
Func<T> AlreadyUnfoldedEnd,
Func<IEnumerator<U>, Last, T> NotUnfoldedYet);
public class AlreadyUnfolded : State {
private readonly ImmutableEnumeratorElement value;
public AlreadyUnfolded(ImmutableEnumeratorElement value) {
this.value = value;
}
public override T Match<T>(
Func<ImmutableEnumeratorElement, T> AlreadyUnfolded,
Func<T> AlreadyUnfoldedEnd,
Func<IEnumerator<U>, Last, T> NotUnfoldedYet)
=> AlreadyUnfolded(value);
}
public class AlreadyUnfoldedEnd : State {
public AlreadyUnfoldedEnd() {}
public override T Match<T>(
Func<ImmutableEnumeratorElement, T> AlreadyUnfolded,
Func<T> AlreadyUnfoldedEnd,
Func<IEnumerator<U>, Last, T> NotUnfoldedYet)
=> AlreadyUnfoldedEnd();
}
public class NotUnfoldedYet : State {
private readonly IEnumerator<U> enumerator;
private readonly Last last; // readonly
public NotUnfoldedYet(IEnumerator<U> enumerator, Last last) {
this.enumerator = enumerator;
this.last = last;
}
public override T Match<T>(
Func<ImmutableEnumeratorElement, T> AlreadyUnfolded,
Func<T> AlreadyUnfoldedEnd,
Func<IEnumerator<U>, Last, T> NotUnfoldedYet)
=> NotUnfoldedYet(enumerator, last);
}
}
}
}

20
Utils/Immutable/EnumeratorGenerator.cs Normal file
View File

@ -0,0 +1,20 @@
using static Generator;
public static class EnumeratorGenerator {
public static void Main() {
Generate(
"Utils/Immutable/EnumeratorGenerated.cs",
"",
"namespace Immutable {",
"}",
"Immutable.",
Types(
// Our boilerplate generator does not support
// defining generic types for now.
/*
Record("PureImmutableGenerator<T, U>",
Field("T", "state"),
Field("Func<T, Option<Tuple<U, IImmutableEnumerator<U>>>>", "generator"))
*/));
}
}

96
Utils/Immutable/EquatableDictionary.cs Normal file
View File

@ -0,0 +1,96 @@
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Collections.Immutable;
public class EquatableDictionary<TKey, TValue> : IEnumerable<KeyValuePair<TKey, TValue>>, IString, IEquatable<EquatableDictionary<TKey, TValue>> {
public readonly ImmutableDictionary<TKey, TValue> dictionary;
public EquatableDictionary() {
this.dictionary = ImmutableDictionary<TKey, TValue>.Empty;
this.hashCode = "EquatableDictionary".GetHashCode();
}
public EquatableDictionary(ImmutableDictionary<TKey, TValue> dictionary) {
this.dictionary = dictionary;
this.hashCode = dictionary.Aggregate(
"EquatableDictionary".GetHashCode(),
(h, kvp) =>
h ^ kvp.Key.GetHashCode() ^ kvp.Value.GetHashCode());
}
private EquatableDictionary(EquatableDictionary<TKey, TValue> dictionary, TKey key, TValue value) {
this.dictionary = dictionary.dictionary.Add(key, value);
this.hashCode =
dictionary.hashCode ^ key.GetHashCode() ^ value.GetHashCode();
}
public TValue this[TKey key] {
get => dictionary[key];
}
public EquatableDictionary<TKey, TValue> Add(TKey key, TValue value)
=> new EquatableDictionary<TKey, TValue>(this, key, value);
// These would need to update the hashCode, disabled for now.
/*public EquatableDictionary<TKey, TValue> SetItem(TKey key, TValue value)
=> new EquatableDictionary<TKey, TValue>(dictionary.SetItem(key, value));
public EquatableDictionary<TKey, TValue> Remove(TKey key)
=> new EquatableDictionary<TKey, TValue>(dictionary.Remove(key));*/
public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator() => dictionary.GetEnumerator();
IEnumerator IEnumerable.GetEnumerator() => dictionary.GetEnumerator();
/*public EquatableDictionaryLens<
TKey,
TValue,
EquatableDictionary<TKey, TValue>>
lens {
get => this.ChainLens(x => x);
}*/
public override string ToString()
=> "EquatableDictionary {\n"
+ this.Select(kvp => (ks: kvp.Key.ToString(),
vs: kvp.Value.ToString()))
.OrderBy(p => p.ks)
.Select(p => $"{{ {p.ks}, {p.vs} }}")
.JoinWith(",\n")
+ "\n}";
public string Str() => ToString();
private bool SameKVP(EquatableDictionary<TKey, TValue> other) {
foreach (var kvp in this) {
// Let's hope that this uses EqualityComparer<TKey>.Default and EqualityComparer<TValue>.Default.
if (!other.Contains(kvp)) { return false; }
}
foreach (var kvp in this) {
if (!this.Contains(kvp)) { return false; }
}
return false;
}
public override bool Equals(object other)
=> Equality.Untyped<EquatableDictionary<TKey, TValue>>(
this,
other,
x => x as EquatableDictionary<TKey, TValue>,
x => x.hashCode,
(x, y) => x.SameKVP(y));
public bool Equals(EquatableDictionary<TKey, TValue> other)
=> Equality.Equatable<EquatableDictionary<TKey, TValue>>(this, other);
private readonly int hashCode;
public override int GetHashCode() => hashCode;
}
public static class EquatableDictionaryExtensionMethods {
public static EquatableDictionary<UKey, UValue> ToEquatableDictionary<T, UKey, UValue>(this IEnumerable<T> e, Func<T, UKey> key, Func<T, UValue> value)
=> new EquatableDictionary<UKey, UValue>(e.ToImmutableDictionary(key, value));
public static EquatableDictionary<TKey, TValue> ToEquatableDictionary<TKey, TValue>(this ImmutableDictionary<TKey, TValue> d)
=> new EquatableDictionary<TKey, TValue>(d);
}

7
Utils/Immutable/Option.cs
View File

@ -64,6 +64,9 @@ namespace Immutable {
public static Option<U> IfSome<T, U>(this Option<T> o, Func<T, U> some)
=> o.Map(some);
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> Bind<T, U>(this Option<T> o, Func<T, Option<U>> f)
=> o.Match_(Some: some => f(some),
None: () => Option.None<U>());
@ -83,5 +86,9 @@ namespace Immutable {
public static T ElseThrow<T>(this Option<T> o, Func<Exception> none)
=> o.Match_(Some: value => value,
None: () => throw none());
public static T ElseThrow<T>(this Option<T> o, Exception none)
=> o.Match_(Some: value => value,
None: () => throw none);
}
}

33
Utils/Immutable/Rope.cs Normal file
View File

@ -0,0 +1,33 @@
using System.Text;
using System.Collections.Immutable;
namespace Immutable {
public partial class Node {
private string CustomToString() {
var sb = new StringBuilder();
var stack = ImmutableStack<Rope>.Empty;
while (!stack.IsEmpty) {
var e = stack.Peek();
stack = stack.Pop();
e.Match(
Leaf: s => {
sb.Append(s);
return Unit.unit;
},
Node: x => {
stack = stack.Push(x.a).Push(x.b);
return Unit.unit;
});
}
return sb.ToString();
}
// TODO: this is not used by the generated code
private int CustomHashCode(Node a, Node b)
=> a.GetHashCode() ^ b.GetHashCode();
private bool CustomEquals(Node a, Node b)
// TODO: a faster implementation of equality
=> a.ToString().Equals(b.ToString());
}
}

19
Utils/Immutable/RopeGenerator.cs Normal file
View File

@ -0,0 +1,19 @@
using static Generator;
public static class RopeGenerator {
public static void Main() {
Generator.Generate(
"Utils/Immutable/RopeGenerated.cs",
"",
"namespace Immutable {",
"}",
"Immutable.",
Types(
Variant("Rope",
Case("string", "Leaf"),
Case("Immutable.Node", "Node")),
Record("Node",
Field("Rope", "a"),
Field("Rope", "b"))));
}
}