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

Initial commit

Browse Source
This commit is contained in:
Suzanne Soy 2020-08-11 02:22:40 +00:00
commit 900749670e
14 changed files with 387 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

42
Ast.cs Normal file
View File

@ -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
});
}
}

7
Compilers/JS.cs Normal file
View File

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

8
Evaluator.cs Normal file
View File

@ -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()
);
}
}

8
Global.cs Normal file
View File

@ -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);
}

6
Parser.cs Normal file
View File

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

1
Tests/001-42.e Normal file
View File

@ -0,0 +1 @@
42

1
Tests/001-42.o Normal file
View File

@ -0,0 +1 @@
42

31
Utils/Collection.cs Normal file
View File

@ -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;
}
}

29
Utils/Func.cs Normal file
View File

@ -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);
}
}

39
Utils/Immutable/List.cs Normal file
View File

@ -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; }
}
}
}
*/

36
Utils/Immutable/Option.cs Normal file
View File

@ -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);
}
}
*/

92
Utils/Path.cs Normal file
View File

@ -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;
}
}

10
Utils/Piping.cs Normal file
View File

@ -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; }
}

77
main.cs Normal file
View File

@ -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());
}
}
}