From 36ed190a5c896679cf92501085cb2e9768ee8dda Mon Sep 17 00:00:00 2001 From: Suzanne Soy Date: Thu, 20 Aug 2020 02:23:34 +0000 Subject: [PATCH] Cleaned up metaprogramming utility and lenses for records --- Lexer.cs | 54 +++++------ Makefile | 24 +++-- Parser.cs | 20 ++-- T4/Generator.cs | 197 +++++----------------------------------- T4/RecordGenerator.cs | 115 +++++++++++++++++++++++ T4/VariantGenerator.cs | 192 +++++++++++++++++++++++++++++++++++++++ Utils/Global.cs | 2 + Utils/Immutable/Unit.cs | 19 ++++ Utils/Lens.cs | 64 +++++++++++++ Utils/Unicode.cs | 3 + Utils/Variant.cs | 1 + 11 files changed, 471 insertions(+), 220 deletions(-) create mode 100644 T4/RecordGenerator.cs create mode 100644 T4/VariantGenerator.cs create mode 100644 Utils/Immutable/Unit.cs create mode 100644 Utils/Lens.cs create mode 100644 Utils/Variant.cs diff --git a/Lexer.cs b/Lexer.cs index bdc211f..fd30f40 100644 --- a/Lexer.cs +++ b/Lexer.cs @@ -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 - .First() - .Match(some: (x => x.UnicodeCategory(0) == cat), - none: false), - throughState, - newState ?? throughState); + oldState: oldState, + description: cat.ToString(), + test: c => c.codePoints + .First() + .Match(some: (x => x.UnicodeCategory(0) == cat), + none: false), + 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 - .Single() - .Match(some: xx => xx == c.ToString(), - none: false), - throughState, - newState ?? throughState); + oldState: oldState, + description: CharDescription(c), + test: x => x.codePoints + .Single() + .Match(some: xx => xx == c.ToString(), + none: false), + 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(); diff --git a/Makefile b/Makefile index fa3b969..8c522c1 100644 --- a/Makefile +++ b/Makefile @@ -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, $^) diff --git a/Parser.cs b/Parser.cs index aeb860c..6f40cf2 100644 --- a/Parser.cs +++ b/Parser.cs @@ -13,20 +13,20 @@ 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(); } - public static PrecedenceDAG With(PrecedenceDAG precedenceDAG, Operator @operator) { + public static PrecedenceDAG With(PrecedenceDAG precedenceDAG, Operator @operator) { /*precedenceDAG.update( dagNode => dagNode.Add(@operator) );*/ diff --git a/T4/Generator.cs b/T4/Generator.cs index 4fa36a3..9e98141 100644 --- a/T4/Generator.cs +++ b/T4/Generator.cs @@ -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 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 {{"); - 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_(Visitor 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 As{C}() => Immutable.Option.None();"); - } - - 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_(Visitor 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("); - 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 {{"); - 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 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>> types) { + public static void Generate(string outputFile, string singleHeader, string header, string footer, string qualifier, ImmutableDictionary>> types) { using (var o = new System.IO.StreamWriter(outputFile)) { - o.WriteLine("// This file was generated by Generator.cs"); - o.WriteLine(""); + Action 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>> Types(params Tuple>>[] types) - => types.ToDictionary(t => t.Item1, t => t.Item2); + public static ImmutableDictionary>> Types(params Tuple>>[] types) + => types.ToImmutableDictionary(t => t.Item1, t => t.Item2); - public static Tuple>> Record(string name, params Tuple[] fields) - => new Tuple>>( + public static Tuple>> Record(string name, params Tuple[] fields) + => new Tuple>>( name, - new Tuple>( + new Tuple>( Kind.Record, - fields.ToDictionary(t => t.Item1, t => t.Item2))); + fields.ToImmutableDictionary(t => t.Item1, t => t.Item2))); - public static Tuple>> Variant(string name, params Tuple[] cases) - => new Tuple>>( + public static Tuple>> Variant(string name, params Tuple[] cases) + => new Tuple>>( name, - new Tuple>( + new Tuple>( Kind.Variant, - cases.ToDictionary(t => t.Item1, t => t.Item2))); + cases.ToImmutableDictionary(t => t.Item1, t => t.Item2))); public static Tuple Field(string type, string name) => new Tuple(name, type); diff --git a/T4/RecordGenerator.cs b/T4/RecordGenerator.cs new file mode 100644 index 0000000..9aaec48 --- /dev/null +++ b/T4/RecordGenerator.cs @@ -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; + +public static class RecordGenerator { + private static void Fields(this Action 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 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 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 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 w, string qualifier, string name, Record record) { + w($" public Lens<{name}> lens {{ get => ChainLens(x => x); }}"); + } + + private static void ChainLens(this Action w, string qualifier, string name, Record record) { + w($" public Lens ChainLens(System.Func<{name}, Whole> wrap) => new Lens(wrap: wrap, oldHole: this);"); + } + + private static void Lenses(this Action w, string qualifier, string name, Record record) { + w($" public sealed class Lens : 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 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 w, string header, string footer, string qualifier, string name, Record record) { + w($"{header}"); + w(""); + w.RecordClass(qualifier, name, record); + w($"{footer}"); + } +} diff --git a/T4/VariantGenerator.cs b/T4/VariantGenerator.cs new file mode 100644 index 0000000..919290d --- /dev/null +++ b/T4/VariantGenerator.cs @@ -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; + +public static class VariantGenerator { + private static void MatchExampleComment(this Action 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 w, string qualifier, string name, Variant variant) { + w($" private {name}() {{}}"); + } + + private static void Visitor(this Action w, string qualifier, string name, Variant variant) { + w($" public class Visitor {{"); + 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 w, string qualifier, string name, Variant variant) { + w($" public abstract T Match_(Visitor c);"); + } + + private static void CaseShorthands(this Action 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 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 w, string qualifier, string name, Variant variant) { + w($" public LeafLens<{name}> Lens {{ get => ChainLens(x => x); }}"); + } + + private static void ChainLens(this Action w, string qualifier, string name, Variant variant) { + w($" public LeafLens<{name}, Whole> ChainLens(System.Func<{name}, Whole> wrap) => new LeafLens<{name}, Whole>(wrap: wrap, oldHole: this);"); + } + + private static void GetTag(this Action 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 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 w, string qualifier, string name, string C, string Ty) { + if (Ty != null) { + w($" public readonly {Ty} value;"); + w($""); + } + } + + private static void CaseConstructor(this Action 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 w, string qualifier, string name, string C, string Ty) { + w($" public override T Match_(Visitor c) => c.{C}({Ty == null ? "" : "value"});"); + } + + private static void CaseAs(this Action 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 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 w, string qualifier, string name, string C, string Ty) { + w($" public override string ToString() => \"{C}\";"); + } + + private static void Cases(this Action 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 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 w, string qualifier, string name, Variant variant) { + w($"public static class {name}ExtensionMethods {{"); + w($" public static T Match("); + 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 {{"); + w(String.Join(",\n", variant.Select(c => + $" {c.Key} = {c.Key}"))); + w($" }});"); + w($" }}"); + } + + public static void Variant(this Action 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}"); + } +} \ No newline at end of file diff --git a/Utils/Global.cs b/Utils/Global.cs index bfcd0e1..13bee78 100644 --- a/Utils/Global.cs +++ b/Utils/Global.cs @@ -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 None() => Option.None(); public static ImmutableList ImmutableList(params T[] xs) diff --git a/Utils/Immutable/Unit.cs b/Utils/Immutable/Unit.cs new file mode 100644 index 0000000..591673d --- /dev/null +++ b/Utils/Immutable/Unit.cs @@ -0,0 +1,19 @@ +using System; + +namespace Immutable { + public sealed class Unit : IEquatable { + 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(this, other, x => x as Unit); + public bool Equals(Unit other) + => Equality.Equatable(this, other); + public override int GetHashCode() + => HashCode.Combine("Unit"); + public override string ToString() => "Unit"; + } +} \ No newline at end of file diff --git a/Utils/Lens.cs b/Utils/Lens.cs new file mode 100644 index 0000000..b778a60 --- /dev/null +++ b/Utils/Lens.cs @@ -0,0 +1,64 @@ +// Code quality of this file: low. + +using System; +using System.Collections.Immutable; + +public interface ILens { + Whole Update(Func update); +} + +public sealed class ImmutableListLens : ILens, Whole> { + public readonly System.Func, Whole> wrap; + public readonly ImmutableList oldHole; + + public ImmutableListLens(System.Func, Whole> wrap, ImmutableList 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,Whole> sub-part => oldHole.sub-part.ChainLens(value => oldHole.with-sub-part(value)); + + public Whole Update(Func, ImmutableList> update) => wrap(update(oldHole)); +} + +// Lenses for primitive types and other types that are not +// interesting to further focus. +public sealed class LeafLens : ILens { + public readonly System.Func wrap; + public readonly T oldHole; + + public LeafLens(System.Func wrap, T oldHole) { + this.wrap = wrap; + this.oldHole = oldHole; + } + + public Whole Update(Func update) => wrap(update(oldHole)); +} + +public static class LensExtensionMethods { + public static Whole Update(this ILens lens, Hole newHole) + => lens.Update(oldHole => newHole); + + public static Whole Cons(this ILens, Whole> lens, T value) + => lens.Update(oldHole => oldHole.Cons(value)); + + public static ImmutableListLens + ChainLens( + this ImmutableList hole, + System.Func, Whole> wrap) + => new ImmutableListLens(wrap: wrap, oldHole: hole); + + public static ILens ChainLens(this string hole, System.Func wrap) => new LeafLens(wrap: wrap, oldHole: hole); + + public static ILens, Whole> ChainLens(this Func hole, System.Func, Whole> wrap) => new LeafLens, Whole>(wrap: wrap, oldHole: hole); + + public class FocusableLeaf { + private readonly T value; + public FocusableLeaf(T value) { this.value = value; } + public LeafLens ChainLens(Func wrap) + => new LeafLens(wrap: wrap, oldHole: value); + } + + public static ILens, Whole> ChainLens(this ImmutableList hole, System.Func, Whole> wrap) => new ImmutableListLens(wrap: wrap, oldHole: hole); +} \ No newline at end of file diff --git a/Utils/Unicode.cs b/Utils/Unicode.cs index abb810a..6aba2f0 100644 --- a/Utils/Unicode.cs +++ b/Utils/Unicode.cs @@ -13,6 +13,9 @@ public struct GraphemeCluster { this.codePoints = codePoints; } + public LeafLens ChainLens(Func wrap) + => new LeafLens(wrap: wrap, oldHole: this); + public static implicit operator GraphemeCluster(char c) => new GraphemeCluster(false, c.ToString(), c.ToString().Singleton()); } diff --git a/Utils/Variant.cs b/Utils/Variant.cs new file mode 100644 index 0000000..0d5e1a9 --- /dev/null +++ b/Utils/Variant.cs @@ -0,0 +1 @@ +public interface IVariant {} \ No newline at end of file