Initial commit

Ast.cs

@@ -0,0 +1,42 @@
+using System;
+using Ast;
+
+public class Visitor<T> {
+  public Func<int, T> Int { get; set; }
+  public Func<string, T> String { get; set; }
+}
+
+namespace Ast {
+  public interface Expr {
+    T Match_<T>(Visitor<T> c);
+  }
+
+  public abstract class Const<T> : Expr {
+    public readonly T value;
+    public Const(T value) { this.value = value; }
+    public abstract U Match_<U>(Visitor<U> c);
+  }
+
+  public class Int : Const<int> {
+    public Int(int x) : base(x) {}
+    public override T Match_<T>(Visitor<T> c) => c.Int(value);
+  }
+
+  public class String : Const<string> {
+    public String(string x) : base(x) {}
+    public override T Match_<T>(Visitor<T> c) => c.String(value);
+  }
+}
+
+public static class AstExtensionMethods {
+  public static T Match<T>(
+      this Ast.Expr e,
+      Func<int, T> Int,
+      Func<string, T> String
+    ) {
+    return e.Match_(new Visitor<T> {
+      Int = Int,
+      String = String
+    });
+  }
+}

Compilers/JS.cs

@@ -0,0 +1,7 @@
+namespace Compilers {
+  public class JS {
+    public static string Compile(Ast.Expr source) {
+      return "process.stdout.write('42');";
+    }
+  }
+}

Evaluator.cs

@@ -0,0 +1,8 @@
+public class Evaluator {
+  public static string Evaluate(Ast.Expr source) {
+    return source.Match(
+      Int: i => i.ToString(),
+      String: s => s.ToString()
+    );
+  }
+}

Global.cs

@@ -0,0 +1,8 @@
+public static class Global {
+  public static File File(string str) => new File(str);
+  public static Ext  Ext (string str) => new Ext (str);
+  public static Dir  Dir (string str) => new Dir (str);
+  public static Exe  Exe (string str) => new Exe (str);
+  
+  public static void Log (string str) => System.Console.WriteLine(str);
+}

Parser.cs

@@ -0,0 +1,6 @@
+using Ast;
+public static class Parser {
+  public static Expr Parse(string source) {
+    return new Int(42);
+  }
+}

Tests/001-42.e

@@ -0,0 +1 @@
+42

Tests/001-42.o

@@ -0,0 +1 @@
+42

Utils/Collection.cs

@@ -0,0 +1,31 @@
+using System;
+using System.Linq;
+using System.Collections.Generic;
+
+public static class Collection {
+  public static void ForEach<T>(this IEnumerable<T> x, Action<T> f)
+    => x.ToList().ForEach(f);
+
+  /*
+  public static ListI<Tuple<T,U>> Add<T,U>(this ListI<Tuple<T,U>> l, T x, U y)
+    => l.Add(Tuple.Create(x,y));
+  */
+
+  // System.Collections.Immutable requires NuGet and is not available on repl.it
+  public static List<T> Cons<T>(this List<T> l, T x) { l.Add(x); return l; }
+
+  // Circumvent bug with collection initializers, tuples and
+  // first-class functions by using repeated .Add()
+  // See https://repl.it/@suzannesoy/WarlikeWorstTraining#main.cs
+
+  public static List<Tuple<T,U>> Cons<T,U>(this List<Tuple<T,U>> l, T x, U y)
+    => l.Cons(Tuple.Create(x,y));
+
+  public static List<Tuple<T,U,V>> Cons<T,U,V>(this List<Tuple<T,U,V>> l, T x, U y, V z)
+    => l.Cons(Tuple.Create(x,y,z));
+
+  public static void Deconstruct<A, B>(this Tuple<A, B> t, out A a, out B b) {
+    a = t.Item1;
+    b = t.Item2;
+  }
+}

Utils/Func.cs

@@ -0,0 +1,29 @@
+using System;
+using System.Linq;
+
+public static class Func {
+  // supply 1 argument to function of 2 arguments
+  public static Func<B,C> Partial<A,B,C>(this Func<A,B,C> f, A a) {
+    return b => f(a, b);
+  }
+
+  // supply 1 argument to function of 3 arguments
+  public static Func<B,C,D> Partial<A,B,C,D>(this Func<A,B,C,D> f, A a) {
+    return (b, c) => f(a, b, c);
+  }
+
+  // supply 2 arguments to function of 3 arguments
+  public static Func<C,D> Partial<A,B,C,D>(this Func<A,B,C,D> f, A a, B b) {
+    return c => f(a, b, c);
+  }
+
+  // break down function of 2 arguments to require 2 successive 1-argument calls
+  public static Func<A,Func<B,C>> Curry<A,B,C>(this Func<A,B,C> f) {
+    return a => b => f(a, b);
+  }
+
+  // break down function of 3 arguments to require 2 successive 1-argument calls
+  public static Func<A,Func<B,Func<C,D>>> Curry<A,B,C,D>(this Func<A,B,C,D> f) {
+    return a => b => c => f(a, b, c);
+  }
+}

Utils/Immutable/List.cs

@@ -0,0 +1,39 @@
+/*
+namespace Immutable {
+  using System;
+  using System.Collections;
+  using System.Collections.Generic;
+
+  public class ListI<T> : IEnumerable<T> {
+    private readonly Option< (T, ListI<T>) > l;
+    public ListI() { this.l = Option.None< (T, ListI<T>) >(); }
+    public ListI(T hd, ListI<T> tl) { this.l = (hd, tl).Some(); }
+    public ListI<T> Add(T x) => new ListI<T>(x, this);
+    public IEnumerator<T> GetEnumerator() => new Enumerator(this);
+    IEnumerator IEnumerable.GetEnumerator() => new Enumerator(this);
+
+    private class Enumerator : IEnumerator<T>, IEnumerator {
+      private List<T> l;
+      private List<T> next = null;
+      private ListI<T> reset;
+      private T Current_()
+        => l.l.Match<(T, ListI<T>), T>(
+            Some: l => l.Item1,
+            None: (() => throw new Exception("oops"))
+          );
+      public T Current { get => Current_(); }
+      object IEnumerator.Current { get => Current_(); }
+      public Enumerator(ListI<T> l) { this.l = l; }
+      public bool MoveNext() {
+        if (first) { this.first = false; } else { this.l = l.Item2; }
+        l.l.Match<(T, ListI<T>), bool>(
+          Some: l => true,
+          None: (() => false)
+        );
+      }
+      public void Dispose() {}
+      public void Reset() { this.l = reset; }
+    }
+  }
+}
+*/

Utils/Immutable/Option.cs

@@ -0,0 +1,36 @@
+/*
+namespace Immutable {
+  using System;
+
+  public interface Option<out T> {
+    U Match_<U>(Func<T, U> Some, Func<U> None);
+  }
+
+  public static class Option {
+    public static Option<T> Some<T>(T value) => new Types.Some<T>(value);
+    public static Option<T> None<T>() => new Types.None<T>();
+
+    private static class Types {
+      public class Some<T> : Option<T> {
+        public readonly T value;
+
+        public Some(T value) { this.value = value; }
+
+        public U Match_<U>(Func<T, U> Some, Func<U> None) => Some(value);
+      }
+
+      public class None<T> : Option<T> {
+        public None() { }
+
+        public U Match_<U>(Func<T, U> Some, Func<U> None) => None();
+      }
+    }
+  }
+
+  public static class OptionExtensionMethods {
+    public static Option<T> Some<T>(this T value) => Option.Some<T>(value);
+    public static U Match<T, U>(this Option<T> o, Func<T, U> Some, Func<U> None)
+      => o.Match_(Some, None);
+ }
+}
+*/

Utils/Path.cs

@@ -0,0 +1,92 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using IO = System.IO;
+
+public abstract class Path {
+  public readonly string str;
+  
+  protected Path(string str) { this.str = str; }
+  
+  public static implicit operator string(Path p) => p.str;
+  
+  public override string ToString() => str;
+}
+
+public class File : Path { public File(string str) : base(str) {} }
+public class Ext : Path { public Ext(string str) : base(str) {} }
+public class Exe : Path { public Exe(string str) : base(str) {} }
+
+public class Dir : Path { public Dir(string str) : base(str) {}
+  public static Dir GetCurrentDirectory()
+    => IO.Directory.GetCurrentDirectory().Dir();
+}
+
+public static class ExtensionMethods {
+  public static File File(this string str) => new File(str);
+  public static Ext  Ext (this string str) => new Ext (str);
+  public static Dir  Dir (this string str) => new Dir (str);
+  public static Exe  Exe (this string str) => new Exe (str);
+
+  public static File Write(this File f, string s) {
+    IO.File.WriteAllText(f, s);
+    return f;
+  }
+
+  public static string Read(this File f) {
+    return IO.File.ReadAllText(f);
+  }
+
+  public static string WriteTo(this string s, File f) {
+    IO.File.WriteAllText(f, s);
+    return s;
+  }
+
+  public static Dir Create(this Dir d) {
+    IO.Directory.CreateDirectory(d);
+    return d;
+  }
+
+  public static IEnumerable<File> GetFiles(this Dir d, string pattern, IO.SearchOption searchOption) {
+    var prefixLen = d.ToString().Length;
+    if (!(   d.ToString().EndsWith("" + IO.Path.DirectorySeparatorChar)
+          || d.ToString().EndsWith("" + IO.Path.AltDirectorySeparatorChar))) {
+      prefixLen++;
+    }
+    // TODO: test if it also returns dirs.
+    return IO.Directory
+      .GetFiles(d, pattern, searchOption)
+      .Select(x => x.Substring(prefixLen))
+      .Select(x => x.File());
+  }
+
+  public static File Combine(this Dir a, File b)
+    => IO.Path.Combine(a, b).File();
+
+  public static File Combine(this File a, Ext b)
+    => new File(a + b);
+
+  public static Dir Combine(this Dir a, Dir b)
+    => IO.Path.Combine(a, b).Dir();
+
+  public static Dir DirName(this Path p)
+    => IO.Path.GetDirectoryName(p).Dir();
+
+  public static File DropExtension(this File f)
+    => f.DirName().Combine(IO.Path.GetFileNameWithoutExtension(f).File());
+
+  public static string Run(this Exe e, string args) {
+    var p = System.Diagnostics.Process.Start(
+      new System.Diagnostics.ProcessStartInfo {
+        FileName = e,
+        Arguments = args,
+        UseShellExecute = false,
+        CreateNoWindow = true,
+        RedirectStandardOutput = true
+      }
+    );
+    var stdout = p.StandardOutput.ReadToEnd();
+    p.WaitForExit();
+    return stdout;
+  }
+}

Utils/Piping.cs

@@ -0,0 +1,10 @@
+using System;
+using System.Linq;
+
+public static class Piping {
+  public static U Pipe<T, U>(this T x, Func<T, U> f) => f(x);
+  
+  public static void Pipe<T>(this T x, Action<T> f) => f(x);
+
+  public static T Do<T>(this T x, Action<T> f) { f(x); return x; }
+}

main.cs

@@ -0,0 +1,77 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using SearchOption = System.IO.SearchOption;
+using Compiler = System.Func<Ast.Expr, string>;
+using static Global;
+
+public static class MainClass {
+  public static readonly Dir tests = Dir("Tests/");
+  public static readonly Dir tests_results = Dir("tests_results/");
+
+  public static void CompileToFile (Compiler compile, File source, File dest) {
+    source
+      .Read()
+      .Pipe(Parser.Parse)
+      .Pipe(compile)
+      .Pipe(c => dest.Write(c));
+  }
+
+  public static void RunTest(string toolchainName, Compiler compile, Exe runner, File source) {
+    var destPath = tests_results.Combine(source);
+    var sourcePath = tests.Combine(source);
+    var expected = sourcePath.DropExtension().Combine(Ext(".o"));
+    
+    Console.Write($"Running test {source} ({toolchainName}) ");
+    
+    destPath.DirName().Create();
+
+    CompileToFile(compile, sourcePath, destPath);
+    
+    if (runner.Run(destPath) != expected.Read()) {
+      Console.WriteLine("\x1b[1;31mFail\x1b[m");
+      throw new Exception("Test failed " + source);
+    } else {
+      Console.WriteLine("\x1b[1;32mOK\x1b[m");
+    }
+  }
+
+  public static void RunTests() {
+    // Circumvent bug with collection initializers, tuples and
+    // first-class functions by using repeated .Add()
+    // See https://repl.it/@suzannesoy/WarlikeWorstTraining#main.cs
+    var compilers = new List<Tuple<string, Compiler, Exe>>()
+      .Cons(" js ", Compilers.JS.Compile, Exe("node"))
+      .Cons("eval", Evaluator.Evaluate,   Exe("cat"));
+
+    foreach (var t in Dir("Tests/").GetFiles("*.e", SearchOption.AllDirectories)) {
+      foreach (var compiler in compilers) {
+        RunTest(compiler.Item1, compiler.Item2, compiler.Item3, t);
+      }
+    }
+  }
+
+  public static void Main (string[] args) {
+    if (args.Length != 1) {
+      Console.WriteLine("Usage: mono main.exe path/to/file.e");
+      Console.WriteLine("");
+      Console.WriteLine("Language syntax:");
+      Console.WriteLine("");
+      Console.WriteLine("  Expression =");
+      Console.WriteLine("    Int");
+      Console.WriteLine("  | String");
+      Console.WriteLine("  | Variable");
+      Console.WriteLine("  | Pattern \"->\" Expression");
+      Console.WriteLine("");
+      Console.WriteLine("I'll run the tests for you in the meanwhile.");
+      Console.WriteLine("");
+      RunTests();
+    } else {
+      var source = args[0].File();
+      var destPrefix = source.DropExtension();
+      CompileToFile(Compilers.JS.Compile, source, destPrefix.Combine(Ext(".js")));
+      CompileToFile(Evaluator.Evaluate,   source, destPrefix.Combine(Ext(".txt")));
+      Console.Write(destPrefix.Combine(Ext(".txt")).Read());
+    }
+  }
+}