Embedded Stack Language for .NET - Redux

Awhile ago, I had posted about an embedding of a stack language in C#. The type signatures of the functions and the stack object encoded the consumption and production of stack values, so if your program compiled, it ran correctly.

Unfortunately, the prior structure had a safety problem when generating code which I noted, but didn't have time to address.

The new structure provided below does not have the safety problem, and any functions that compile are guaranteed to execute correctly. I have also altered the style to emphasize the row variable representing the "rest of the record" which the operation knows nothing about. The row variable is denoted by "_".

This is still a fairly limited embedding, but I have added a few convenience functions, and may yet add more. Here is a sample program:

var d = new DynamicMethod("test", typeof(void), null);
var s =
  1.Load()                   // load constant: { int }
   .Int(2)                   // load constant: { int, int }
   .Add()                    // add: { int, int } -> { int }
   .Do(Console.WriteLine)    // output top: { int } -> { }
   .String("Test out")       // load string: { } -> { string }
   .Do(Console.WriteLine);   // output top: { string } -> { }
s.Compile(d.GetILGenerator());// only compile empty stacks: { }
d.Invoke(null, null);

Thankfully, C# can infer the types used so we can avoid any superfluous type annotations. The code generation functions are a little more involved however:

/// <summary>
/// Abstracts the stack structure used to hold locals, etc.
/// </summary>
/// <typeparam name="_">The rest of the stack.</typeparam>
/// <typeparam name="T">The top of the stack.</typeparam>
public sealed class Stack<_, T>
{
    /// <summary>
    /// Defer the code generation by enclosing the opcodes
    /// in a closure.
    /// </summary>
    internal Action<ILGenerator> gen;
    public Stack(Action<ILGenerator> gen)
    {
        this.gen = gen;
    }
}

/// <summary>
/// An empty value aka void.
/// </summary>
public struct Unit
{
}

/// <summary>
/// Statically typed stack operations.
/// </summary>
public static class Stack
{
    /// <summary>
    /// Load an int on a new stack.
    /// </summary>
    public static Stack<Unit, int> Load(this int value)
    {
        return new Stack<Unit, int>(il =>
                   il.Emit(OpCodes.Ldc_I4, value));
    }

    /// <summary>
    /// Load a string on a new stack.
    /// </summary>
    public static Stack<Unit, string> Load(this string value)
    {
        return new Stack<Unit, string>(il =>
                   il.Emit(OpCodes.Ldstr, value));
    }

    /// <summary>
    /// Load a string on an existing stack.
    /// </summary>
    public static Stack<Stack<_, T>, string> String<_, T>(
                  this Stack<_, T> stack, string value)
    {
        return new Stack<Stack<_, T>, string>(il =>
        {
            stack.gen(il);
            il.Emit(OpCodes.Ldstr, value);
        });
    }

    /// <summary>
    /// Duplicate the top of the stack.
    /// </summary>
    public static Stack<Stack<_, T>, T> Dup<_, T>(
                  this Stack<_, T> stack)
    {
        return new Stack<Stack<_, T>, T>(il =>
                   il.Emit(OpCodes.Dup));
    }

    /// <summary>
    /// Apply a function to the top of the stack, replacing
    /// the top element with the return value of the function.
    /// </summary>
    public static Stack<_, R> Apply<_, T, R>(
                  this Stack<_, T> stack, Func<T, R> target)
    {
        return new Stack<_, R>(il =>
        {
            stack.gen(il);
            il.EmitCall(OpCodes.Call, target.Method, null);
        });
    }

    /// <summary>
    /// Apply an action to the top of the stack consuming
    /// the top value.
    /// </summary>
    public static Stack<_, Unit> Do<_, T>(
                  this Stack<_, T> stack,
                  Action<T> target)
    {
        return new Stack<_, Unit>(il =>
        {
            stack.gen(il);
            il.EmitCall(OpCodes.Call, target.Method, null);
        });
    }

    /// <summary>
    /// Load the value at the given array's index on to the stack.
    /// </summary>
    public static Stack<_, T> LoadArrayIndex<_, T>(
                  this Stack<_, Stack<T[], int>> stack)
    {
        return new Stack<_, T>(il =>
                   il.Emit(OpCodes.Ldelem, typeof(T)));
    }

    /// <summary>
    /// Check that the top element is of type U.
    /// </summary>
    public static Stack<_, U> IsInstance<_, T, U>(
                  this Stack<_, T> stack)
        where T : class
    {
        return new Stack<_, U>(il =>
        {
            stack.gen(il);
            il.Emit(OpCodes.Isinst, typeof(U));
        });
    }

    /// <summary>
    /// Load an int onto an existing stack.
    /// </summary>
    public static Stack<Stack<_, T>, int> Int<_, T>(
                  this Stack<_, T> stack, int i)
    {
        return new Stack<Stack<_, T>, int>(il =>
        {
            stack.gen(il);
            il.Emit(OpCodes.Ldc_I4, i);
        });
    }

    /// <summary>
    /// Add the two elements at the top of the stack.
    /// WARNING: T must overloead the addition operator.
    /// </summary>
    public static Stack<_, T> Add<_, T>(
                  this Stack<Stack<_, T>, T> stack)
    {
        return new Stack<_, T>(il =>
        {
            stack.gen(il);
            il.Emit(OpCodes.Add);
        });
    }

    /// <summary>
    /// Return from a function.
    /// </summary>
    public static void Return<_, T>(this Stack<_, T> stack,
                                    ILGenerator il)
    {
        stack.gen(il);
        il.Emit(OpCodes.Ret);
    }

    /// <summary>
    /// Compile the code so long as the top of the stack
    /// has type Unit.
    /// </summary>
    public static void Compile<_>(this Stack<_, Unit> stack,
                                  ILGenerator il)
    {
        stack.Return(il);
    }
}