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

Cleaned up metaprogramming utility and lenses for records

Browse Source
This commit is contained in:
Suzanne Soy 2020-08-20 02:23:34 +00:00
parent b3d41496d5
commit 36ed190a5c
11 changed files with 471 additions and 220 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

42
Lexer.cs
View File

@ -14,45 +14,47 @@ public static partial class Lexer {
public static class Rules {
private static Rule Rule(S oldState, UnicodeCategory cat, S throughState, S newState = null)
=> new Rule(
oldState,
cat.ToString(),
c => c.codePoints
oldState: oldState,
description: cat.ToString(),
test: c => c.codePoints
.First()
.Match(some: (x => x.UnicodeCategory(0) == cat),
none: false),
throughState,
newState ?? throughState);
throughState: throughState,
newState: newState ?? throughState);
private static Rule Rule(S oldState, EOF eof, S throughState, S newState = null)
=> new Rule(
oldState,
"End of file",
c => c.endOfFile,
throughState,
newState ?? throughState);
oldState: oldState,
description: "End of file",
test: c => c.endOfFile,
throughState: throughState,
newState: newState ?? throughState);
private static string CharDescription(char c)
=> (c == '"') ? "'\"'" : $"\"{c.ToString()}\"";
private static Rule Rule(S oldState, char c, S throughState, S newState = null)
=> new Rule(
oldState,
CharDescription(c),
x => x.codePoints
oldState: oldState,
description: CharDescription(c),
test: x => x.codePoints
.Single()
.Match(some: xx => xx == c.ToString(),
none: false),
throughState,
newState ?? throughState);
throughState: throughState,
newState: newState ?? throughState);
private static Rule Rule(S oldState, char[] cs, S throughState, S newState = null) {
var csl = cs.Select(x => x.ToString()).ToImmutableList();
return new Rule(
oldState,
", ".Join(cs.Select(CharDescription)),
x => x.codePoints.Single().Match(some: csl.Contains, none: false),
throughState,
newState ?? throughState);
oldState: oldState,
description: ", ".Join(cs.Select(CharDescription)),
test: x => x.codePoints
.Single()
.Match(some: csl.Contains, none: false),
throughState: throughState,
newState: newState ?? throughState);
}
public static EOF EOF = new EOF();

24
Makefile
View File

@ -1,22 +1,26 @@
CS := $(shell find . -not \( -path ./.git \) -not \( -name '*Generator.cs' \) -name '*.cs')
GENERATORS := $(shell find . -not \( -path ./.git \) -not \( -path ./T4/Generator.cs \) -name '*Generator.cs')
CS := $(shell find . -not \( -path ./.git \) -not \( -name '*Generator.cs' \) -not \( -name '*Generated.cs' \) -name '*.cs')
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))
.PHONY: run
run: main.exe
MONO_PATH=/usr/lib/mono/4.5/:/usr/lib/mono/4.5/Facades/ mono main.exe
run: main.exe Makefile
MONO_PATH=/usr/lib/mono/4.5/:/usr/lib/mono/4.5/Facades/ mono $<
main.exe: $(sort $(CS) $(GENERATED))
main.exe: $(CS) $(GENERATED) Makefile
mcs -out:$@ \
/reference:/usr/lib/mono/fsharp/FSharp.Core.dll \
/reference:/usr/lib/mono/4.5/System.Collections.Immutable.dll \
/reference:/usr/lib/mono/4.5/Facades/netstandard.dll \
$^
$(filter-out Makefile, $^)
%Generated.cs: .%Generator.exe
mono $<
%Generated.cs: .%Generator.exe Makefile
MONO_PATH=/usr/lib/mono/4.5/:/usr/lib/mono/4.5/Facades/ mono $(filter-out Makefile, $<)
.%Generator.exe: %Generator.cs T4/Generator.cs
mcs -out:$@ $^
.%Generator.exe: %Generator.cs $(META) Makefile
mcs -out:$@ \
/reference:/usr/lib/mono/4.5/System.Collections.Immutable.dll \
/reference:/usr/lib/mono/4.5/Facades/netstandard.dll \
$(filter-out Makefile, $^)

18
Parser.cs
View File

@ -13,15 +13,15 @@ public static partial class Parser {
public static PrecedenceDAG DefaultPrecedenceDAG = new PrecedenceDAG();
public static DAGNode With(DAGNode node, Operator op) {
/* var newOp = op.fixity.Match(
Closed: () => node.WithClosed(op),
InfixLeftAssociative: () => node.WithInfixLeftAssociative(op),
InfixRightAssociative: () => node.WithInfixRightAssociative(op),
InfixNonAssociative: () => node.WithInfixNonAssociative(op),
Prefix: () => node.WithPrefix(op),
Postfix: () => node.WithPostFix(op),
Terminal: () => node.WithTerminal(op)
);*/
var newOp = op.fixity.Match(
Closed: () => node.lens.closed.Cons(op),
InfixLeftAssociative: () => node.lens.infixLeftAssociative.Cons(op),
InfixRightAssociative: () => node.lens.infixRightAssociative.Cons(op),
InfixNonAssociative: () => node.lens.infixNonAssociative.Cons(op),
Prefix: () => node.lens.prefix.Cons(op),
Postfix: () => node.lens.postfix.Cons(op),
Terminal: () => node.lens.terminal.Cons(op)
);
// op.fixity, parts, holes
throw new NotImplementedException();
}

197
T4/Generator.cs
View File

@ -1,210 +1,59 @@
// Code quality of this file: low.
// Code quality of this file: medium.
using System;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Linq;
public enum Kind {
Record,
Variant,
}
public static class Generator {
public static void WriteVariant(this System.IO.StreamWriter o, string header, string footer, string qualifier, string name, Dictionary<string, string> variant) {
o.WriteLine($"{header}");
o.WriteLine($"");
o.WriteLine($" /* To match against an instance of {name}, write:");
o.WriteLine($" x.Match(");
o.WriteLine(String.Join(",\n", variant.Select(@case =>
$" {@case.Key}: {@case.Value == null ? "()" : "value"} => throw new NotImplementedYetException()")));
o.WriteLine($" )");
o.WriteLine($" */");
o.WriteLine($" public abstract class {name} : IEquatable<{name}> {{");
o.WriteLine($" public class Visitor<T> {{");
foreach (var @case in variant) {
var C = @case.Key;
var Ty = @case.Value;
o.WriteLine($" public Func<{Ty == null ? "" : $"{Ty}, "}T> {C} {{ get; set; }} ");
}
o.WriteLine($" }}");
o.WriteLine($" public abstract T Match_<T>(Visitor<T> c);");
foreach (var @case in variant) {
var C = @case.Key;
var Ty = @case.Value;
o.WriteLine($" public static {name} {C}{Ty == null
? $" = new Constructors.{C}()"
: $"({Ty} value) => new Constructors.{C}(value)"};");
}
foreach (var @case in variant) {
var C = @case.Key;
var Ty = @case.Value;
o.WriteLine($" public virtual Immutable.Option<Constructors.{C}> As{C}() => Immutable.Option.None<Constructors.{C}>();");
}
o.WriteLine($" private string GetTag() {{");
o.WriteLine($" return this.Match(");
o.WriteLine(String.Join(",\n", variant.Select(@case =>
$" {@case.Key}: {@case.Value == null ? "()" : "value"} => \"{@case.Key}\"")));
o.WriteLine($" );");
o.WriteLine($" }}");
o.WriteLine($"");
o.WriteLine($" public override abstract bool Equals(Object other);");
o.WriteLine($" public abstract bool Equals({name} other);");
o.WriteLine($"");
o.WriteLine($" public override abstract int GetHashCode();");
o.WriteLine($" public static class Constructors {{");
foreach (var @case in variant) {
var C = @case.Key;
var Ty = @case.Value;
o.WriteLine($" public sealed class {C} : {name} {{");
if (Ty != null) {
o.WriteLine($" public readonly {Ty} value;");
}
o.WriteLine($" public {C}({Ty == null ? "" : $"{Ty} value"}) {{ {Ty == null ? "" : $"this.value = value; "}}}");
o.WriteLine($" public override T Match_<T>(Visitor<T> c) => c.{C}({Ty == null ? "" : "value"});");
o.WriteLine($" public override Immutable.Option<{C}> As{C}() => Immutable.Option.Some<{C}>(this);");
o.WriteLine($" public static bool operator ==({C} a, {C} b)");
o.WriteLine($" => Equality.Operator(a, b);");
o.WriteLine($" public static bool operator !=({C} a, {C} b)");
o.WriteLine($" => !(a == b);");
o.WriteLine($" public override bool Equals(object other)");
if (Ty == null) {
o.WriteLine($" => Equality.Untyped<{C}>(this, other, x => x as {C});");
} else {
o.WriteLine($" => Equality.Untyped<{C}>(this, other, x => x as {C}, x => x.value);");
}
o.WriteLine($" public override bool Equals({name} other)");
o.WriteLine($" => Equality.Equatable<{name}>(this, other);");
o.WriteLine($" public override int GetHashCode()");
if (Ty == null) {
o.WriteLine($" => HashCode.Combine(\"{C}\");");
} else {
o.WriteLine($" => HashCode.Combine(\"{C}\", this.value);");
}
o.WriteLine("");
o.WriteLine($" public override string ToString() => \"{C}\";");
o.WriteLine($" }}");
o.WriteLine("");
}
o.WriteLine($" }}");
o.WriteLine($" }}");
o.WriteLine("");
o.WriteLine($"}}");
o.WriteLine($"public static class {name}ExtensionMethods {{");
o.WriteLine($" public static T Match<T>(");
o.WriteLine($" this {qualifier}{name} e,");
o.WriteLine(String.Join(",\n", variant.Select(c =>
$" Func<{c.Value == null ? "" : $"{c.Value}, "}T> {c.Key}")));
o.WriteLine($" ) {{");
o.WriteLine($" return e.Match_(new {qualifier}{name}.Visitor<T> {{");
o.WriteLine(String.Join(",\n", variant.Select(c =>
$" {c.Key} = {c.Key}")));
o.WriteLine($" }});");
o.WriteLine($" }}");
o.WriteLine($"{footer}");
}
public static void WriteRecord(this System.IO.StreamWriter o, string header, string footer, string qualifier, string name, Dictionary<string, string> record) {
o.WriteLine($"{header}");
o.WriteLine("");
o.WriteLine($" public sealed class {name} : IEquatable<{name}> {{");
foreach (var @field in record) {
var F = @field.Key;
var Ty = @field.Value;
o.WriteLine($" public readonly {Ty} {F};");
}
o.WriteLine($" public {name}(");
o.WriteLine(String.Join(",\n", record.Select(@field =>
$" {@field.Value} {@field.Key}")));
o.WriteLine($" ) {{");
foreach (var @field in record) {
var F = @field.Key;
var Ty = @field.Value;
o.WriteLine($" this.{F} = {F};");
}
o.WriteLine($" }}");
o.WriteLine($"");
o.WriteLine($" public static bool operator ==({name} a, {name} b)");
o.WriteLine($" => Equality.Operator(a, b);");
o.WriteLine($" public static bool operator !=({name} a, {name} b)");
o.WriteLine($" => !(a == b);");
o.WriteLine($" public override bool Equals(object other)");
o.WriteLine($" => Equality.Untyped<{name}>(this, other, x => x as {name},");
o.WriteLine(String.Join(",\n", record.Select(@field =>
$" x => x.{@field.Key}")));
o.WriteLine($" );");
o.WriteLine($" public bool Equals({name} other)");
o.WriteLine($" => Equality.Equatable<{name}>(this, other);");
o.WriteLine($" public override int GetHashCode()");
o.WriteLine($" => Equality.HashCode(\"{name}\",");
o.WriteLine(String.Join(",\n", record.Select(@field =>
$" this.{@field.Key}")));
o.WriteLine($" );");
foreach (var @field in record) {
var F = @field.Key;
var noAtF = F.StartsWith("@") ? F.Substring(1) : F;
var caseF = Char.ToUpper(noAtF[0]) + noAtF.Substring(1);
var Ty = @field.Value;
o.Write($" public {name} With{caseF}({Ty} {F}) => new {name}(");
o.Write(String.Join(", ", record.Select(@f => $"{f.Key}: {f.Key}")));
o.WriteLine(");");
}
o.WriteLine($" }}");
o.WriteLine($"{footer}");
}
public static void Generate(string outputFile, string singleHeader, string header, string footer, string qualifier, Dictionary<string, Tuple<Kind, Dictionary<string, string>>> types) {
public static void Generate(string outputFile, string singleHeader, string header, string footer, string qualifier, ImmutableDictionary<string, Tuple<Kind, ImmutableDictionary<string, string>>> types) {
using (var o = new System.IO.StreamWriter(outputFile)) {
o.WriteLine("// This file was generated by Generator.cs");
o.WriteLine("");
Action<string> w = o.WriteLine;
w("// This file was generated by Generator.cs");
w("");
o.WriteLine("using System;");
o.WriteLine($"{singleHeader}");
o.WriteLine("");
w("using System;");
w($"{singleHeader}");
w("");
foreach (var type in types) {
var name = type.Key;
var kind = type.Value.Item1;
var components = type.Value.Item2;
switch (kind) {
case Kind.Record:
o.WriteRecord(header, footer, qualifier, name, @components);
w.Record(header, footer, qualifier, name, @components);
break;
case Kind.Variant:
o.WriteVariant(header, footer, qualifier, name, @components);
w.Variant(header, footer, qualifier, name, @components);
break;
}
o.WriteLine("");
w("");
}
}
}
// Below are shorthands for making the last argument to Generate().
public static Dictionary<string, Tuple<Kind, Dictionary<string, string>>> Types(params Tuple<string, Tuple<Kind, Dictionary<string, string>>>[] types)
=> types.ToDictionary(t => t.Item1, t => t.Item2);
public static ImmutableDictionary<string, Tuple<Kind, ImmutableDictionary<string, string>>> Types(params Tuple<string, Tuple<Kind, ImmutableDictionary<string, string>>>[] types)
=> types.ToImmutableDictionary(t => t.Item1, t => t.Item2);
public static Tuple<string, Tuple<Kind, Dictionary<string, string>>> Record(string name, params Tuple<string, string>[] fields)
=> new Tuple<string, Tuple<Kind, Dictionary<string, string>>>(
public static Tuple<string, Tuple<Kind, ImmutableDictionary<string, string>>> Record(string name, params Tuple<string, string>[] fields)
=> new Tuple<string, Tuple<Kind, ImmutableDictionary<string, string>>>(
name,
new Tuple<Kind, Dictionary<string, string>>(
new Tuple<Kind, ImmutableDictionary<string, string>>(
Kind.Record,
fields.ToDictionary(t => t.Item1, t => t.Item2)));
fields.ToImmutableDictionary(t => t.Item1, t => t.Item2)));
public static Tuple<string, Tuple<Kind, Dictionary<string, string>>> Variant(string name, params Tuple<string, string>[] cases)
=> new Tuple<string, Tuple<Kind, Dictionary<string, string>>>(
public static Tuple<string, Tuple<Kind, ImmutableDictionary<string, string>>> Variant(string name, params Tuple<string, string>[] cases)
=> new Tuple<string, Tuple<Kind, ImmutableDictionary<string, string>>>(
name,
new Tuple<Kind, Dictionary<string, string>>(
new Tuple<Kind, ImmutableDictionary<string, string>>(
Kind.Variant,
cases.ToDictionary(t => t.Item1, t => t.Item2)));
cases.ToImmutableDictionary(t => t.Item1, t => t.Item2)));
public static Tuple<string, string> Field(string type, string name)
=> new Tuple<string, string>(name, type);

115
T4/RecordGenerator.cs Normal file
View File

@ -0,0 +1,115 @@
// Code quality of this file: medium.
using System;
using System.Collections.Generic;
using System.Linq;
using Record = System.Collections.Immutable.ImmutableDictionary<string, string>;
public static class RecordGenerator {
private static void Fields(this Action<string> w, string qualifier, string name, Record record) {
foreach (var @field in record) {
var F = @field.Key;
var Ty = @field.Value;
w($" public readonly {Ty} {F};");
}
}
private static void Constructor(this Action<string> w, string qualifier, string name, Record record) {
w($" public {name}(");
w(String.Join(",\n", record.Select(@field =>
$" {@field.Value} {@field.Key}")));
w($" ) {{");
foreach (var @field in record) {
var F = @field.Key;
var Ty = @field.Value;
w($" this.{F} = {F};");
}
w($" }}");
}
private static void Equality(this Action<string> w, string qualifier, string name, Record record) {
w($" public static bool operator ==({name} a, {name} b)");
w($" => Equality.Operator(a, b);");
w($" public static bool operator !=({name} a, {name} b)");
w($" => !(a == b);");
w($" public override bool Equals(object other)");
w($" => Equality.Untyped<{name}>(this, other, x => x as {name},");
w(String.Join(",\n", record.Select(@field =>
$" x => x.{@field.Key}")));
w($" );");
w($" public bool Equals({name} other)");
w($" => Equality.Equatable<{name}>(this, other);");
w($" public override int GetHashCode()");
w($" => Equality.HashCode(\"{name}\",");
w(String.Join(",\n", record.Select(@field =>
$" this.{@field.Key}")));
w($" );");
}
private static void With(this Action<string> w, string qualifier, string name, Record record) {
foreach (var @field in record) {
var F = @field.Key;
var noAtF = F.StartsWith("@") ? F.Substring(1) : F;
var caseF = Char.ToUpper(noAtF[0]) + noAtF.Substring(1);
var Ty = @field.Value;
w($" public {name} With{caseF}({Ty} {F}) => new {name}("
+ String.Join(", ", record.Select(@f => $"{f.Key}: {f.Key}"))
+ ");");
}
}
private static void Lens(this Action<string> w, string qualifier, string name, Record record) {
w($" public Lens<{name}> lens {{ get => ChainLens(x => x); }}");
}
private static void ChainLens(this Action<string> w, string qualifier, string name, Record record) {
w($" public Lens<Whole> ChainLens<Whole>(System.Func<{name}, Whole> wrap) => new Lens<Whole>(wrap: wrap, oldHole: this);");
}
private static void Lenses(this Action<string> w, string qualifier, string name, Record record) {
w($" public sealed class Lens<Whole> : ILens<{name}, Whole> {{");
w($" public readonly System.Func<{name}, Whole> wrap;");
w($" public readonly {name} oldHole;");
w($"");
w($" public Lens(System.Func<{name}, Whole> wrap, {name} oldHole) {{");
w($" this.wrap = wrap;");
w($" this.oldHole = oldHole;");
w($" }}");
foreach (var @field in record) {
var F = @field.Key;
var noAtF = F.StartsWith("@") ? F.Substring(1) : F;
var caseF = Char.ToUpper(noAtF[0]) + noAtF.Substring(1);
var Ty = @field.Value;
w($" public ILens<{Ty},Whole> {F}");
w($" => oldHole.{F}.ChainLens(");
w($" value => wrap(oldHole.With{caseF}(value)));");
}
w($" public Whole Update(Func<{name}, {name}> update) => wrap(update(oldHole));");
w($" }}");
}
private static void RecordClass(this Action<string> w, string qualifier, string name, Record record) {
w($" public sealed class {name} : IEquatable<{name}> {{");
w.Fields(qualifier, name, record);
w($"");
w.Constructor(qualifier, name, record);
w($"");
w.Equality(qualifier, name, record);
w($"");
w.With(qualifier, name, record);
w($"");
w.Lens(qualifier, name, record);
w($"");
w.ChainLens(qualifier, name, record);
w($"");
w.Lenses(qualifier, name, record);
w($" }}");
}
public static void Record(this Action<string> w, string header, string footer, string qualifier, string name, Record record) {
w($"{header}");
w("");
w.RecordClass(qualifier, name, record);
w($"{footer}");
}
}

192
T4/VariantGenerator.cs Normal file
View File

@ -0,0 +1,192 @@
// Code quality of this file: medium.
using System;
using System.Collections.Generic;
using System.Linq;
using Variant = System.Collections.Immutable.ImmutableDictionary<string, string>;
public static class VariantGenerator {
private static void MatchExampleComment(this Action<string> w, string qualifier, string name, Variant variant) {
w($" /* To match against an instance of {name}, write:");
w($" x.Match(");
w(String.Join(",\n", variant.Select(@case =>
$" {@case.Key}: {@case.Value == null ? "()" : "value"} => throw new NotImplementedException()")));
w($" )");
w($" */");
}
private static void PrivateConstructor(this Action<string> w, string qualifier, string name, Variant variant) {
w($" private {name}() {{}}");
}
private static void Visitor(this Action<string> w, string qualifier, string name, Variant variant) {
w($" public class Visitor<T> {{");
foreach (var @case in variant) {
var C = @case.Key;
var Ty = @case.Value;
w($" public Func<{Ty == null ? "" : $"{Ty}, "}T> {C} {{ get; set; }} ");
}
w($" }}");
}
private static void Match_(this Action<string> w, string qualifier, string name, Variant variant) {
w($" public abstract T Match_<T>(Visitor<T> c);");
}
private static void CaseShorthands(this Action<string> w, string qualifier, string name, Variant variant) {
foreach (var @case in variant) {
var C = @case.Key;
var Ty = @case.Value;
w($" public static {name} {C}{Ty == null
? $" = new Cases.{C}()"
: $"({Ty} value) => new Cases.{C}(value)"};");
}
}
private static void As(this Action<string> w, string qualifier, string name, Variant variant) {
foreach (var @case in variant) {
var C = @case.Key;
var Ty = @case.Value;
w($" public virtual Immutable.Option<{Ty == null ? "Immutable.Unit" : Ty}> As{C}() => Immutable.Option.None<{Ty == null ? "Immutable.Unit" : Ty}>();");
}
}
private static void Lens(this Action<string> w, string qualifier, string name, Variant variant) {
w($" public LeafLens<{name}> Lens {{ get => ChainLens(x => x); }}");
}
private static void ChainLens(this Action<string> w, string qualifier, string name, Variant variant) {
w($" public LeafLens<{name}, Whole> ChainLens<Whole>(System.Func<{name}, Whole> wrap) => new LeafLens<{name}, Whole>(wrap: wrap, oldHole: this);");
}
private static void GetTag(this Action<string> w, string qualifier, string name, Variant variant) {
w($" private string GetTag() {{");
w($" return this.Match(");
w(String.Join(",\n", variant.Select(@case =>
$" {@case.Key}: {@case.Value == null ? "()" : "value"} => \"{@case.Key}\"")));
w($" );");
w($" }}");
}
private static void Equality(this Action<string> w, string qualifier, string name, Variant variant) {
w($" public static bool operator ==({name} a, {name} b)");
w($" => Equality.Operator(a, b);");
w($" public static bool operator !=({name} a, {name} b)");
w($" => !(a == b);");
w($" public override abstract bool Equals(Object other);");
w($" public abstract bool Equals({name} other);");
w($"");
w($" public override abstract int GetHashCode();");
}
private static void CaseValue(this Action<string> w, string qualifier, string name, string C, string Ty) {
if (Ty != null) {
w($" public readonly {Ty} value;");
w($"");
}
}
private static void CaseConstructor(this Action<string> w, string qualifier, string name, string C, string Ty) {
w($" public {C}({Ty == null ? "" : $"{Ty} value"}) {{ {Ty == null ? "" : $"this.value = value; "}}}");
}
private static void CaseMatch_(this Action<string> w, string qualifier, string name, string C, string Ty) {
w($" public override T Match_<T>(Visitor<T> c) => c.{C}({Ty == null ? "" : "value"});");
}
private static void CaseAs(this Action<string> w, string qualifier, string name, string C, string Ty) {
w($" public override Immutable.Option<{Ty == null ? "Immutable.Unit" : Ty}> As{C}() => Immutable.Option.Some<{Ty == null ? "Immutable.Unit" : Ty}>({Ty == null ? "Immutable.Unit.unit" : "this.value"});");
}
private static void CaseEquality(this Action<string> w, string qualifier, string name, string C, string Ty) {
w($" public static bool operator ==({C} a, {C} b)");
w($" => Equality.Operator(a, b);");
w($" public static bool operator !=({C} a, {C} b)");
w($" => !(a == b);");
w($" public override bool Equals(object other)");
if (Ty == null) {
w($" => Equality.Untyped<{C}>(this, other, x => x as {C});");
} else {
w($" => Equality.Untyped<{C}>(this, other, x => x as {C}, x => x.value);");
}
w($" public override bool Equals({name} other)");
w($" => Equality.Equatable<{name}>(this, other);");
w($" public override int GetHashCode()");
if (Ty == null) {
w($" => HashCode.Combine(\"{C}\");");
} else {
w($" => HashCode.Combine(\"{C}\", this.value);");
}
}
private static void CaseToString(this Action<string> w, string qualifier, string name, string C, string Ty) {
w($" public override string ToString() => \"{C}\";");
}
private static void Cases(this Action<string> w, string qualifier, string name, Variant variant) {
foreach (var @case in variant) {
var C = @case.Key;
var Ty = @case.Value;
w($" public sealed class {C} : {name} {{");
w.CaseValue(qualifier, name, C, Ty);
w.CaseConstructor(qualifier, name, C, Ty);
w($"");
w.CaseMatch_(qualifier, name, C, Ty);
w($"");
w.CaseAs(qualifier, name, C, Ty);
w($"");
w.CaseEquality(qualifier, name, C, Ty);
w($"");
w.CaseToString(qualifier, name, C, Ty);
w($" }}");
}
}
private static void VariantClass(this Action<string> w, string qualifier, string name, Variant variant) {
w($" public abstract class {name} : IEquatable<{name}> {{");
w.PrivateConstructor(qualifier, name, variant);
w($"");
w.Visitor(qualifier, name, variant);
w($"");
w.Match_(qualifier, name, variant);
w($"");
w.CaseShorthands(qualifier, name, variant);
w($"");
w.As(qualifier, name, variant);
w($"");
w.ChainLens(qualifier, name, variant);
w($"");
w.Equality(qualifier, name, variant);
w($" public static class Cases {{");
w.Cases(qualifier, name, variant);
w($" }}");
w($" }}");
w("");
w($"}}");
}
private static void ExtensionMethods(this Action<string> w, string qualifier, string name, Variant variant) {
w($"public static class {name}ExtensionMethods {{");
w($" public static T Match<T>(");
w($" this {qualifier}{name} e,");
w(String.Join(",\n", variant.Select(c =>
$" Func<{c.Value == null ? "" : $"{c.Value}, "}T> {c.Key}")));
w($" ) {{");
w($" return e.Match_(new {qualifier}{name}.Visitor<T> {{");
w(String.Join(",\n", variant.Select(c =>
$" {c.Key} = {c.Key}")));
w($" }});");
w($" }}");
}
public static void Variant(this Action<string> w, string header, string footer, string qualifier, string name, Variant variant) {
w($"{header}");
w($"");
w.MatchExampleComment(qualifier, name, variant);
w.VariantClass(qualifier, name, variant);
w.ExtensionMethods(qualifier, name, variant);
w($"{footer}");
}
}

2
Utils/Global.cs
View File

@ -11,6 +11,8 @@ public static class Global {
public static void Log (string str) => Console.WriteLine(str);
public static Unit unit() => Unit.unit;
public static Option<T> None<T>() => Option.None<T>();
public static ImmutableList<T> ImmutableList<T>(params T[] xs)

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

@ -0,0 +1,19 @@
using System;
namespace Immutable {
public sealed class Unit : IEquatable<Unit> {
public static readonly Unit unit = new Unit();
private Unit() {}
public static bool operator ==(Unit a, Unit b)
=> Equality.Operator(a, b);
public static bool operator !=(Unit a, Unit b)
=> !(a == b);
public override bool Equals(object other)
=> Equality.Untyped<Unit>(this, other, x => x as Unit);
public bool Equals(Unit other)
=> Equality.Equatable<Unit>(this, other);
public override int GetHashCode()
=> HashCode.Combine("Unit");
public override string ToString() => "Unit";
}
}

64
Utils/Lens.cs Normal file
View File

@ -0,0 +1,64 @@
// Code quality of this file: low.
using System;
using System.Collections.Immutable;
public interface ILens<Hole, Whole> {
Whole Update(Func<Hole, Hole> update);
}
public sealed class ImmutableListLens<T, Whole> : ILens<ImmutableList<T>, Whole> {
public readonly System.Func<ImmutableList<T>, Whole> wrap;
public readonly ImmutableList<T> oldHole;
public ImmutableListLens(System.Func<ImmutableList<T>, Whole> wrap, ImmutableList<T> oldHole) {
this.wrap = wrap;
this.oldHole = oldHole;
}
// Put methods with the following signature here to focus on sub-parts of the list as needed.
// public ILens<ImmutableList<T>,Whole> sub-part => oldHole.sub-part.ChainLens(value => oldHole.with-sub-part(value));
public Whole Update(Func<ImmutableList<T>, ImmutableList<T>> update) => wrap(update(oldHole));
}
// Lenses for primitive types and other types that are not
// interesting to further focus.
public sealed class LeafLens<T, Whole> : ILens<T, Whole> {
public readonly System.Func<T, Whole> wrap;
public readonly T oldHole;
public LeafLens(System.Func<T, Whole> wrap, T oldHole) {
this.wrap = wrap;
this.oldHole = oldHole;
}
public Whole Update(Func<T, T> update) => wrap(update(oldHole));
}
public static class LensExtensionMethods {
public static Whole Update<Hole, Whole>(this ILens<Hole, Whole> lens, Hole newHole)
=> lens.Update(oldHole => newHole);
public static Whole Cons<T, Whole>(this ILens<ImmutableList<T>, Whole> lens, T value)
=> lens.Update(oldHole => oldHole.Cons(value));
public static ImmutableListLens<T, Whole>
ChainLens<T, Whole>(
this ImmutableList<T> hole,
System.Func<ImmutableList<T>, Whole> wrap)
=> new ImmutableListLens<T, Whole>(wrap: wrap, oldHole: hole);
public static ILens<string, Whole> ChainLens<Whole>(this string hole, System.Func<string, Whole> wrap) => new LeafLens<string, Whole>(wrap: wrap, oldHole: hole);
public static ILens<Func<GraphemeCluster,bool>, Whole> ChainLens<Whole>(this Func<GraphemeCluster,bool> hole, System.Func<Func<GraphemeCluster,bool>, Whole> wrap) => new LeafLens<Func<GraphemeCluster,bool>, Whole>(wrap: wrap, oldHole: hole);
public class FocusableLeaf<T> {
private readonly T value;
public FocusableLeaf(T value) { this.value = value; }
public LeafLens<T, Whole> ChainLens<Whole>(Func<T, Whole> wrap)
=> new LeafLens<T, Whole>(wrap: wrap, oldHole: value);
}
public static ILens<ImmutableList<string>, Whole> ChainLens<Whole>(this ImmutableList<string> hole, System.Func<ImmutableList<string>, Whole> wrap) => new ImmutableListLens<string, Whole>(wrap: wrap, oldHole: hole);
}

3
Utils/Unicode.cs
View File

@ -13,6 +13,9 @@ public struct GraphemeCluster {
this.codePoints = codePoints;
}
public LeafLens<GraphemeCluster, Whole> ChainLens<Whole>(Func<GraphemeCluster, Whole> wrap)
=> new LeafLens<GraphemeCluster, Whole>(wrap: wrap, oldHole: this);
public static implicit operator GraphemeCluster(char c)
=> new GraphemeCluster(false, c.ToString(), c.ToString().Singleton());
}

1
Utils/Variant.cs Normal file
View File

@ -0,0 +1 @@
public interface IVariant {}