B# .NET Blog

To Bind or Not To Bind – Dynamic Expression Trees – Part 2

bart — Wed, 27 Aug 2008 23:05:00 GMT

Welcome back to the dynamic expression tree fun. Last time we designed our simplified expression tree class library we’ll be using to enable dynamic treatment of objects. Today, we’ll take this one step further by emitting IL code that resolves the operations invoked on such dynamic objects at runtime through a mechanism called binders. Before we dive in, let me point out that everything discussed in this series is greatly simplified just to illustrate the core ideas and base mechanisms/principles that make dynamic language stuff work.

Introducing IL generation

Dynamic code compilation is a wonderful thing. It’s not that hard once you get the basics right (and have some level of IL opcode understanding) but quite hard to debug. Luckily we have tools like Haibo Luo’s IL Visualizer. Since I’ll be using this, download it, extract the ZIP file, compile the whole solution and copy ILMonitor\bin\Debug\*.dll to %programfiles%\Microsoft Visual Studio 9.0\Common7\Packages\Debugger\Visualizers. Alternatively you can put it in your personal Visual Studio 2008\Visualizers folder.

So, what’s our task? Assume we have the following piece of sample code:

class Program
{
    static void Main(string[] args)
    {
        var o = DynamicExpression.Parameter("o");
        var a = DynamicExpression.Parameter("a");
        var b = DynamicExpression.Parameter("b");
        var call = DynamicExpression.Call(o, "Substring", a, b);
        var func = DynamicExpression.Lambda(call, o, a, b);
        Console.WriteLine(func);
        Console.WriteLine(func.Compile().DynamicInvoke("Bart", 1, 2));
    }
}

We already know how to construct the objects and to represent it as a string (which would be (o, a, b) => o.Substring(a, b)). Now we need to focus on the marked Compile method on LambdaDynamicExpression. Starting with the signature of the delegate, we want to create (at runtime) a method that takes in three “dynamic” parameters (corresponding to parameter expressions o, a and b), returning a resulting object. Since we don’t have any type information available, everything should be System.Object, so we’d end up with the following delegate:

delegate object TheDynamicLambdaFunction(object o, object a, object b);

Looking at Compile as a black box, it will return an instance of this delegate pointing at an on-the-fly generated method corresponding to the lambda’s body expression. Returning a System.Delegate, one can call DynamicInvoke (or cast it to a compatible delegate) to invoke it with the given parameters. Obviously we want the call to do “the right thing”, in the sample above it would correspond to a method call to System.String::Substring on “Bart”, passing in startIndex 1 and length 2, producing another string containing “ar”.

It should be clear that we need to emit IL on the fly to translate the lambda expression but also the lambda’s body which could be anything, not just a MethodCallDynamicExpression. Since we lack other expression node types, one such (trivial) thing would be:

var x = DynamicExpression.Parameter("x");
var I = DynamicExpression.Lambda(x, x);
Console.WriteLine(I);
Console.WriteLine(I.Compile().DynamicInvoke("Bart"));

which is just the identity function (the underlined bold ‘o’ above indicates the lamdba’s body). I intentionally named the expression above “I” conform SKI combinators where I is defined as λx . x. Similarly we could define the K combinator as:

var x = DynamicExpression.Parameter("x");
var y = DynamicExpression.Parameter("y");
var K = DynamicExpression.Lambda(x, x, y);
Console.WriteLine(K);
Console.WriteLine(K.Compile().DynamicInvoke("Bart", 123));

but we got sidetracked, so time to move on. The whole point here is that we can’t assume the body of the lambda to be a MethodCallDynamicExpression. So, how do we tackle this? An important observation one can make is this: an expression represents a single value. Right, so what? Wait a minute, is IL-code not stack-based? Adding the two things together we could think of the following solution:

Calling a Compile method on an expression tree object, given a writeable stream for IL instructions, should add all the instructions to the stream required to evaluate the expression, leaving the result of the evaluation on top of the stack.

A LambdaDynamicExpression is the only dynamic expression that supports a publicly visible Compile method. It’s pseudo-code would look like:

Create an IL stream; here the IL stack is empty.
Take the Body expression and compile it by emitting IL instructions for it; this causes the IL stack to be one high.
Add an IL return instruction to return the object on top of the stack.
Return a delegate pointing to the method represented by the generated IL code.

Supporting expression compilation

To make this work, we’ll first extend the base class by adding one more method:

/// <summary>
/// Class representing a dynamic expression tree.
/// </summary>
abstract class DynamicExpression
{
    /// <summary>
    /// Appends IL instructions to calculate the expression's runtime value, putting it on top of the evaluation stack.
    /// </summary>
    /// <param name="ilgen">IL generator to append to.</param>
    /// <param name="ldArgs">Lambda argument mappings.</param>
    protected internal abstract void Compile(ILGenerator ilgen, Dictionary<ParameterDynamicExpression, int> ldArgs);

    …
}

This method will take in two things: the IL generator (referred to as “IL stream” in the previous paragraph) and a mapping table for the lambda’s parameter expressions. Why do we need the latter, or better: what does it map the parameter expressions to? Assume we’re compiling

(o, a, b) => o.Substring(a, b)

While traversing the expression tree, asking every node in the correct order to emit IL instructions, we’ll encounter references to the parameters again. Our goal is to write a dynamic method looking like this:

object GeneratedDynamicMethod(object o, object a, object b)
{
return o.Substring(a, b);
}

where the . obviously denotes a dynamic method call in this case. As we encounter parameter expressions like o, a or b during the translation for the method body, we need to know how to load those parameters from the argument list on the dynamic method. First of all, notice the lambda parameters got mapped in order of specification to correspond to arguments on the generated dynamic method, i.e. o as the first lambda parameter and is the first parameter on the generated method. And so on. This is precisely what the ldArgs argument on Compile stands for: a mapping from the parameter expression representation from the lambda parameters onto the concrete indices for the arguments:

o –> 0
a –> 1
b –> 2

Whenever we encounter such a parameter expression during the compilation, we know the position of the argument, so we can emit a ldarg instruction. This is the most trivial Compile override:

sealed class ParameterDynamicExpression : DynamicExpression
{
    protected internal override void Compile(ILGenerator ilgen, Dictionary<ParameterDynamicExpression, int> ldArgs)
    {
        if (!ldArgs.ContainsKey(this))
            throw new InvalidOperationException("Parameter expression " + Name + " is not in scope.");

        ilgen.Emit(OpCodes.Ldarg, ldArgs[this]);
    }

    …
}

This simply says, whenever code needs to be emitted for a ParameterDynamicExpression, simply try to find it in the dictionary to map it onto the formal parameter index on the dynamic method being emitted and turn it into a ldarg instruction for that argument index. Real full-fledged expression tree implementations would be slightly more complicated because arguments could be hidden when dealing with nested lambdas (quoting, invocation expressions, etc) but that would take us too far away from home.

For the LambdaDynamicExpression, besides a public Compile method, there will also be an override to the inherited one. It simply asks the Body expression to emit itself (which will result in a one-level high stack containing the evaluation result of the body expression), followed by a ret instruction (simply returning the value evaluated through the Body’s IL code preceding it):

sealed class LambdaDynamicExpression : DynamicExpression
{
    protected internal override void Compile(ILGenerator ilgen, Dictionary<ParameterDynamicExpression, int> ldArgs)
    {
        Body.Compile(ilgen, ldArgs);
        ilgen.Emit(OpCodes.Ret);
    }

    …
}

Emitting code

For this post, we’ll omit an implementation for MethodCallDynamicExpression as that will be part of the next post focusing on binders. All we want to get to work today is the I combinator or identity function (yeah, another world-beater :-)):

var x = DynamicExpression.Parameter("x");
var I = DynamicExpression.Lambda(x, x);
Console.WriteLine(I);
Console.WriteLine(I.Compile().DynamicInvoke("Bart"));

In other words, today we’ll focus on the plumbing of emitting the code and wrapping the method in a delegate that can be returned upon calling LambdaDynamicExpression.Compile. The result for the sample above would be equivalent to:

public Delegate Compile()
{
    return new Func<object, object>(delegate(object x) { return x; });
}

The underlined portion is the code corresponding to I’s compilation. In IL-terms it would be as simplistic as this:

ldarg.0
ret

This emitted IL method body then needs to get the signature that says “taking in an object, returning an object”. All of this makes up the dynamic method. But we’re not done yet, as we need to return a delegate to it. In the free translation above, I’ve leveraged the generic System.Func<T1,R> delegate but we only have a limited number of those (up to four arguments), so what if we encounter a method that takes more arguments? Indeed, we’ll need to generate our own delegate types as well. Notice we could cache those very efficiently: the ones with arity (~ number of parameters) up to 4 could simply be mapped onto System.Func delegates with System.Object type parameters, while others would be generated on the fly and kept for reuse if another method with same arity gets compiled. We’ll omit this optimization for now.

Here’s how the code to create our own delegate type looks like:

private static Type GetDynamicDelegate(Type[] argumentTypes, Type returnType)
{
    //
    // Assemblies contain modules; generate those with unique names.
    // The generated assembly is runtime only (doesn't need to be saved to disk).
    //
    AssemblyBuilder assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(new AssemblyName(Guid.NewGuid().ToString()), AssemblyBuilderAccess.Run);
    ModuleBuilder moduleBuilder = assemblyBuilder.DefineDynamicModule(Guid.NewGuid().ToString());

    //
    // Our delegate is a private sealed type deriving from MultiCastDelegate.
    //
    TypeBuilder typeBuilder = moduleBuilder.DefineType("Lambdas", TypeAttributes.NotPublic | TypeAttributes.Sealed | TypeAttributes.AutoLayout | TypeAttributes.AnsiClass, typeof(MulticastDelegate));

    //
    // The delegate's constructor is a "special name" method with signature (object native int).
    // It doesn't have a method body by itself; rather, it's supplied by the managed runtime.
    //
    ConstructorBuilder ctorBuilder = typeBuilder.DefineConstructor(MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName, CallingConventions.Standard, new Type[] { typeof(object), typeof(IntPtr) });
    ctorBuilder.SetImplementationFlags(MethodImplAttributes.Runtime | MethodImplAttributes.Managed);

    //
    // We only need the Invoke method (BeginInvoke and EndInvoke are irrelevant for us).
    // It doesn't have a method body by itself; rather, it's supplied by the managed runtime.
    // Here our delegate signature is enforced.
    //
    MethodBuilder invokeMethodBuilder = typeBuilder.DefineMethod("Invoke", MethodAttributes.Public | MethodAttributes.NewSlot | MethodAttributes.HideBySig | MethodAttributes.Virtual, CallingConventions.HasThis, returnType, argumentTypes);
    invokeMethodBuilder.SetImplementationFlags(MethodImplAttributes.Runtime | MethodImplAttributes.Managed);

    //
    // Return the created delegate type.
    // Notice we could cache this for reuse by other dynamic methods.
    //
    return typeBuilder.CreateType();
}

Lots of attribute flags which you can read all about in the CLI specification. I don’t pretend to memorize all of those attributes; why would I if ILDASM makes life just great? :-)

This is the screenshot of ILDASM showing a delegate for a method with signature object(object, object) as you can see on the Invoke method. We don’t need any of the asynchronous pattern implementation, so we just need a constructor and Invoke method (see section IIA.13.6 on “Delegates” in the CLI standard). One special thing about those is they don’t have an IL code body as they are “runtime managed” (see IIA.14.4.3 on “Implementation Attributes of Methods” in the CLI standard):

Now that we can generate the delegate, we just need to ask the lambda (since that’s the root) expression tree to emit its IL code, which will traverse the entire tree. In order to be able to do this, we need to keep mapping information about the lambda parameters mapped onto the formal arguments as mentioned earlier. Here’s the result:

public Delegate Compile()
{
    //
    // Map the lambda parameters onto formal argument indices.
    // Also build up the argument type array.
    //
    var args = new Type[Parameters.Count];
    var ldArgs = new Dictionary<ParameterDynamicExpression, int>();
    for (int i = 0; i < args.Length; i++)
    {
        args[i] = typeof(object);
        ldArgs[Parameters[i]] = i;
    }

    //
    // Compile the expression tree to an IL method body.
    //
    var method = new DynamicMethod("", typeof(object), args);
    var ilgen = method.GetILGenerator();
    Compile(ilgen, ldArgs);

    //
    // Get the delegate matching the dynamic method signature.
    //
    Type dynamicDelegate = GetDynamicDelegate(args, typeof(object));

    //
    // Return a delegate pointing at our dynamic method.
    //
    return method.CreateDelegate(dynamicDelegate);
}

This code should be relatively straightforward. First we create the mapping while building up an array just containing typeof(object)’s (since all arguments are objects in our dynamic world). Next we create a dynamic method with the right signature, produce the IL generator and let the expression compilation do all of the work to emit the IL. And finally we stick the whole thing in a dynamically created delegate that matches the signature, returning that to the caller. Setting a breakpoint on the last line and executing for the “I” identity combinator shows this:

This is the IL visualizer we installed earlier. Notice the friendly string representation for the dynamic method shows the signature, which matches the one of the dynamic lambda in the watch window (which is just “I”). Bringing up the IL visualizer shows stunningly complex code:

Ignore the NOPs inserted by the IL generator, but IL_0000 was emitted by ParameterDynamicExpression.Compile through the compilation of the lambda body. IL_0006 was emitted subsequently by LambdaDynamicExpression.Compile and the stack is nicely in balance. Sure enough, the result printed is:

Woohoo – truly dynamic (though simplistic) execution! Next time: method call expressions and binders.

To Bind or Not To Bind – Dynamic Expression Trees – Part 1

bart — Wed, 27 Aug 2008 05:40:00 GMT

In the previous post, I outlined the use of the expression trees from the System.Linq.Expressions namespace. Let’s recap to set the scene:

Expression<Func<string, int, int, string>> data = (string s, int a, int b) => s.Substring(a, b);

produces (deep breadth)

ParameterExpression s = Expression.Parameter(typeof(string), “s”);
ParameterExpression a = Expression.Parameter(typeof(int), “a”);
ParameterExpression b = Expression.Parameter(typeof(int), “b”);

Expression<Func<string, int, int, string>> data = Expression.Lambda<Func<string, int, int, string>>(
Expression.Call(s, typeof(string).GetMethod(“Substring”, new Type[] { typeof(int), typeof(int) }), a, b),
s, a, b
);

Func<string, int, int, string> fun = data.Compile();
Console.WriteLine(fun(“Bart”, 1, 2));

where I’ve indicated all the strong typing using underlines. Wow, that’s a lot dude! Based on all of this strong typing, there are little or no runtime surprises possible concerning running the right method (unless a MissingMethodException occurs for some reason). Obviously, expression trees could be much more complex but to illustrate the core points of the type system, we’ll restrict ourselves to parameters, method calls and lambdas.

So what do we want to try now? We want to design an API similar to the one used above but without all this type information. Essentially, it would look like:

ParameterExpression s = Expression.Parameter(“s”);
ParameterExpression a = Expression.Parameter(“a”);
ParameterExpression b = Expression.Parameter(“b”);

LambdaExpression data = Expression.Lambda(
Expression.Call(s, “Substring”, a, b),
s, a, b
);

Delegate fun = data.Compile();
Console.WriteLine(fun.DynamicInvoke(“Bart”, 1, 2));

and all of a sudden we see the dynamic aspect lurking around the corner on the very last line where we call through the weakly-typed delegate passing in three objects which just happen to be a string and two ints, causing the lookup for a Substring method applied to s (becoming “Bart”) with arguments a and b (respectively 1 and 2) to succeed. The important thing here though is that a “Substring” method with a compatible signature might be available on another type, maybe type Bar, but taking in two longs:

class Bar
{
public Foo Substring(long a, long b) { … }
}

The calling code would still work and the console would print the result of Foo.ToString on the instance returned by Bar.Substring. What it takes to make this work consists of three things:

Dynamic expression trees (i.e. as the one above with stripped type information);
IL code generation at runtime on the fly (to produce the delegate “fun” in the sample above)
Binders (things that provide runtime support to resolve method calls)

Of course you could go much further than this with complete ASTs (the big brothers to expression trees) and “rules” but we’re not going to reinvent the DLR :-). Martin Maly has quite some information on those topics on his blog (must-reads!). Today we’ll cover the first bullet point.

Our dynamic expression trees

To disambiguate with the LINQ expression trees, let’s sneak the word Dynamic in, making our sample look like:

ParameterDynamicExpression s = DynamicExpression.Parameter(“s”);
ParameterDynamicExpression a = DynamicExpression.Parameter(“a”);
ParameterDynamicExpression b = DynamicExpression.Parameter(“b”);

LambdaDynamicExpression data = DynamicExpression.Lambda(
DynamicExpression.Call(s, “Substring”, a, b),
s, a, b
);

Delegate fun = data.Compile();
Console.WriteLine(fun.DynamicInvoke(“Bart”, 1, 2));

All of those *DynamicExpression classes extend the DynamicExpression base class while having a factory method on DynamicExpression too, following the design of LINQ’s expression trees. We’ll omit the NodeType property for simplicity and the Type property, because we obviously don’t want a static type to be associated with each expression tree node. We’ll also get rid of a lot of node types, just leaving the factories in for our three node types:

So, how does this look like? The factory methods will be just convenient syntax around internal constructor calls producing the concrete node types. In addition, we’ll override ToString to produce a friendly-on-the-eye string representation of expression trees, much like our static LINQ friends. First, the DynamicExpression base class:

abstract class DynamicExpression
{
    public static ParameterDynamicExpression Parameter(string name)
    {
        return new ParameterDynamicExpression(name);
    }

    public static MethodCallDynamicExpression Call(DynamicExpression instance, string method, params DynamicExpression[] arguments)
    {
        return new MethodCallDynamicExpression(instance, method, arguments);
    }

    public static LambdaDynamicExpression Lambda(DynamicExpression body, params ParameterDynamicExpression[] parameters)
    {
        return new LambdaDynamicExpression(body, parameters);
    }

    protected internal abstract void ToString(StringBuilder sb);

    public override string ToString()
    {
        StringBuilder sb = new StringBuilder();
        ToString(sb);
        return sb.ToString();
    }
}

We’ll extend this class a bit more in the next part where we’ll tackle compilation, but let’s move on to each of the three subtypes right now:

sealed class ParameterDynamicExpression : DynamicExpression
{
    internal ParameterDynamicExpression(string name)
    {
        Name = name;
    }

    public string Name { get; private set; }

    protected internal override void ToString(StringBuilder sb)
    {
        sb.Append(Name);
    }
}

Nothing surprising here. The expression for a dynamic method call is a slightly bit more complicated :-)…

sealed class MethodCallDynamicExpression : DynamicExpression
{
    internal MethodCallDynamicExpression(DynamicExpression instance, string method, params DynamicExpression[] arguments)
    {
        Object = instance;
        Method = method;
        Arguments = new ReadOnlyCollection<DynamicExpression>(arguments);
    }

    public ReadOnlyCollection<DynamicExpression> Arguments { get; private set; }
    public DynamicExpression Object { get; private set; }
    public string Method { get; private set; }

    protected internal override void ToString(StringBuilder sb)
    {
        Object.ToString(sb);
        sb.Append(".");
        sb.Append(Method);
        sb.Append("(");

        int n = Arguments.Count;
        for (int i = 0; i < n; i++)
        {
            Arguments[i].ToString(sb);
            if (i != n - 1)
                sb.Append(", ");
        }

        sb.Append(")");
    }
}

I told’ya it was going to be mind-blowing. The core thing to notice though is the composability because of the use of DynamicExpressions as the Object (i.e. the instance where we’ll invoke the method on) and the Arguments collection members. Also notice we don’t support static method calls in here (for which Object would be null – you can envision the right checking in the factory method, omitted for brevity) although it would be perfectly possible to come up with such a thing (think about “global functions” for example, but remember we don’t have a type that tells us where to look for the method – ideally you’d have a mixture of statically and dynamically typed trees interwoven). Oh, and the pretty printing logic in ToString isn’t too complex either…

Finally, let’s move on to the lambda expression class:

sealed class LambdaDynamicExpression : DynamicExpression
{
    internal LambdaDynamicExpression(DynamicExpression body, params ParameterDynamicExpression[] parameters)
    {
        Body = body;
        Parameters = new ReadOnlyCollection<ParameterDynamicExpression>(parameters);
    }

    public DynamicExpression Body { get; private set; }
    public ReadOnlyCollection<ParameterDynamicExpression> Parameters { get; private set; }

    public Delegate Compile()
    {
        return null;
    }

    protected internal override void ToString(StringBuilder sb)
    {
        sb.Append("(");

        int n = Parameters.Count;
        for (int i = 0; i < n; i++)
        {
            Parameters[i].ToString(sb);
            if (i != n - 1)
                sb.Append(", ");
        }

        sb.Append(") => ");
        Body.ToString(sb);
    }
}

Same deal concerning parameterization based on DynamicExpression instances. I promise you the Compile method will be pretty interesting to say the least, so stay tuned for the next post!

To Bind or Not To Bind – Dynamic Expression Trees – Part 0

bart — Tue, 26 Aug 2008 07:59:04 GMT

By now, most of my blog readers will be familiar with the simple concept of expression trees in C# 3.0 and VB 9.0. A quick recap. What’s the type of the expression below?

(string s, int a, int b) => s.Substring(a, b)

Shockingly, you can’t tell. Why? Lambdas have two forms of representation: code (as anonymous methods) or data (as expression trees). One more time:

Func<string, int, int, string> code = (string s, int a, int b) => s.Substring(a, b);

produces

Func<string, int, int, string> code = delegate (string s, int a, int b) { return s.Substring(a, b); };

where

Expression<Func<string, int, int, string>> data = (string s, int a, int b) => s.Substring(a, b);

produces (deep breadth)

ParameterExpression s = Expression.Parameter(typeof(string), “s”);
ParameterExpression a = Expression.Parameter(typeof(int), “a”);
ParameterExpression b = Expression.Parameter(typeof(int), “b”);

Expression<Func<string, int, int, string>> data = Expression.Lambda<Func<string, int, int, string>>(
Expression.Call(s, typeof(string).GetMethod(“Substring”, new Type[] { typeof(int), typeof(int) }), a, b),
s, a, b
);

When calling the Compile method on the produced (lambda-expression) data object we’ll get exactly the same IL code but generated at runtime through the form of a (delegate pointing at a) dynamic(ally generated) method using Reflection.Emit. So far, so good. But what are the characteristics of the expression tree’s generated code? Two things:

statically typed
early-bound

In more human terms, we know at compile time the type of all the involved expressions – at the entry points (i.e. the leaf levels) we’re passing it in with uttermost detail (see the Parameter factory method’s first argument for instance) but all intermediate nodes in the expression tree have a type too. E.g. the Expression.Call factory call returns a MethodCallExpression whose wrapped method call’s return type is System.String, hence that becomes the type of the node. Talking about method calls, those are bound at compile time too: we know precisely what method to call because of all the type information available about the arguments.

Isn’t this cool? Sure it is, but what about dynamic languages? Are those able to use this particular form of expression trees? The simple answer is no; well, at least not in a dynamic way, meaning with dynamic typing (i.e. the type of every node is determined at run time) and late binding for methods (i.e. we hope to find a suitable method overload at runtime). What can we do about this? Here we’re getting in the realm of DLR stuff and such. This blog series is not about DLR itself though, it’s rather about outlining some crucial concepts of dynamic typing including “dynamic expression trees” emitting dynamic call sites using binders.

In the first part coming up soon, we’ll start by investigating how to build dynamic expression trees.

Appropriate use of Local Variable Type Inference

bart — Sat, 23 Aug 2008 09:04:45 GMT

By now, most – if not all – readers of my blog will be familiar with this C# 3.0 and VB 9.0 feature called Local Variable Type Inference or Implicitly Typed Local Variables. The idea is simple: since the compiler knows (and hence can infer) type information for expressions, also referred to as rvals, there’s no need for the developer to say the type. In most cases it’s a convenience, for example:

Dictionary<Customer, List<PhoneNumber>> phonebook = new Dictionary<Customer, List<PhoneNumber>>();

That’s literally saying the same thing twice: declare a variable of type mumble-mumble and assign it a new instance of type mumble-mumble. Wouldn’t it be nice just to say:

var phonebook = new Dictionary<Customer, List<PhoneNumber>>();

while it still means exactly the same as the original fragment? That’s what this language feature allows us to do without loosing any of the strong typing. The reason it’s very convenient in the sample above is because of the introduction of arbitrary type construction capabilities due to generics in CLR 2.0. Before this invention, types couldn’t compose arbitrarily big and type names tend to be not too long-winded (namespaces help here too).

As convenient as the case above can be, sometimes type inference is a requirement which is introduced by the invention of anonymous types. Typically those are used in projection clauses of LINQ queries although they can be used in separation as well. E.g.:

var res = from p in Process.GetProcesses() select new { Name = p.ProcessName, Memory = p.WorkingSet64 };

This piece of code gives birth to an anonymous type with two properties Name and Memory (notice the type of those properties is inferred in a similar way from their assigned right-hand side) which is – as the name implies – a type with an unspeakable name. In reality the above produces something like:

IEnumerable<AnonymousType1> res = from p in Process.GetProcesses() select new { Name = p.ProcessName, Memory = p.WorkingSet64 };

where the AnonymousType1 portion is unknown to the developer, so type inference comes to the rescue.

Alright. But when is it appropriate to use the type inference feature? Here are some personal rules I tend to apply quite strictly:

Do use type inference…

where anonymous types are used – you can’t go without it (unless you want to treat them as System.Object of course and only care about their ToString method or so):

var point = new { X = 10, Y = 5 }; //OK – what else could you do?
var res = from p in Process.GetProcesses() select new { Name = p.ProcessName, Memory = p.WorkingSet64 }; //OK – what else could you do?
when the right-hand side explicitly states the type or the type is clearly inferable by humans given the context:

var phonebook = new Dictionary<Customer, List<PhoneNumber>>(); //OK – object construction, with generics
var point = new Point { X = 10, Y = 5 }; //OK – object construction
var customer = (Customer)someObject; //OK – cast
var products = objects.Cast <Product>(); //Debatable – clearly something with Product objects, but a List<T>, a T[], an IEnumerable<T>, or …? Also, the type is mentioned quite far to the right, which doesn’t work too well with left-to-right parsing humans

Don’t use type inference…

for assigning constants to variables of built-in types, e.g. what’s the type of the variables below:

var i = 0123456789; //NOK – an Int32
var l = 9876543210; //NOK – an Int64
var name = “Bart”; //Debatable – what do you gain?
for “smart” type inference in foreach loops (unless you’re faced with a source of anonymous types):

foreach (var x in xs) //Debatable – depending on meaningful variable names there might be “good” exceptions to the rule
;

Moreover, foreach inserts casts for you if the source sequence is just an IEnumerable (i.e. not “Of T” aka “<T>”), so the best guess with type inference would be System.Object.
when the right-hand side doesn’t clearly indicate the type:

var something = someObject.WeirdMethod().AnotherProperty; //NOK – need to know the specific API
if you want to forcefully exercise some abstraction, e.g. because of your development methodology allowing for “planned refactorings” down the road:

IAnimal animal1 = new Lion(); //OK
var animal2 = new Giraffe(); //NOK – will be the most specific type, i.e. Giraffe

This is an interesting one as all of the refactoring support in the IDE will be based on the most specific type and with var, you force it into the most specific type.

Also, it’s important to realize that mechanical changes to variable declarations (for fun?) can yield undesired behavior due to a change in semantics. A few cases pop to mind:

Lambdas don’t play well with type inference. A lambda can either be represented as code or as data (through an expression tree), so without saying what you want, the compiler can’t know. Indeed, not every rhs has a type by itself:

Func<int> f = () => 123;
Expression<Func<int>> e = () => 123;
Implicit conversion – the long that became an int:

checked
{
    long i = 1; // don’t change to var…
    while (true)
        Console.WriteLine(i *= 2); // quiz: does i <<= 1 have the same effect?
}
Explicit interface implementations:

static void Main(string[] args)
{
    IBar b1 = new Bar();
    b1.Foo();

    var b2 = new Bar();
    b2.Foo();
}

interface IBar
{
    void Foo();
}

class Bar : IBar
{
    public void Foo()
    {
        Console.WriteLine("Bar.Foo");
    }

    void IBar.Foo()
    {
        Console.WriteLine("IBar.Foo");
    }
}

Method hiding:

static void Main(string[] args)
{
    Foo f1 = new ExtendedFoo();
    f1.Bar();

    var f2 = new ExtendedFoo();
    f2.Bar();
}

class Foo
{
    public virtual void Bar()
    {
        Console.WriteLine("Foo.Bar");
    }
}

class ExtendedFoo : Foo
{
    public new void Bar()
    {
        Console.WriteLine("ExtendedFoo.Bar");
    }
}

In the end, as usual, there’s no silver bullet. However, one should optimize code for reading it (write-once, read-many philosophy). When trying to understand programs (at least imperative ones <g>) we already have to do quite some mental “step though” to absorb the implementation specifics with loops, conditions, class hierarchies, etc. We shouldn’t extend this process of mental debugging or reverse engineering with type inference overhead in cases where it’s not immediately apparent what the intended type is. Even though the IDE will tell you the type of an implicitly-typed local when hovering over it, it’s not the kind of thing we want to rely on to decipher every single piece of code. Similarly, IntelliSense is working great for implicitly typed local variables, but that only affects the write-once side of the story.

After all, every powerful tool imposes a danger when misused. Type inference is no different in this respect.

Curry for dummies (Cont’d) – A happy ending

bart — Fri, 22 Aug 2008 15:28:00 GMT

I didn’t intend to make this a series of posts but that’s the way things go. Based on feedback from readers and additional questions raised, one decides that add that little bit more to it and ultimate you’re writing a sequel. Where have we been on this journey? First, we took a look at the abstract concept of currying in Curry for dummies. Next, evaluation strategies were outlined in Curry for dummies cont'd - A note on purity, outlining that formal substitution relies on assumptions about the expression involved, i.e. they better are side-effect free to be able to employ call-by-name semantics as opposed to – the much embraced in the imperative world – call-by-value semantics. To challenge the readers, I wrote this:

Readers looking for a challenge are invited to think about how it would be possible to adapt the original (substitution-driven) Curry for dummies code to work with call-by-need semantics; in other words, how can a lambda expression be applied (the number of arguments provided is not really relevant in this discussion) with arguments that are lazily (one time at most) evaluated? I'll post the answer some time soon.

What I’m suggesting here is to implement call-by-need semantics for applying (in formal terms, using beta-reduction) arguments to functions represented as lambdas. To help with the basic plumbing, I provided the Cell<T> class that looks like this:

class Cell<T>
{
    private bool _assigned;
    private Func<T> _func;
    private T _value;

    public Cell(Func<T> func)
    {
        _func = func;
    }

    public T Value
    {
        get
        {
            if (!_assigned)
            {
                _value = _func();
                _assigned = true;
            }

            return _value;
        }
    }
}

In essence, this class allows us to evaluate a function upon the first call to retrieve its value. For example,

var val = new Cell<long>(() => DateTime.Now.Ticks);
Console.WriteLine(DateTime.Now.Ticks + " " + val.Value);
Thread.Sleep(1000);
Console.WriteLine(DateTime.Now.Ticks + " " + val.Value);

To convince you it really doesn’t change its mind after the initial evaluation, look at the following output:

The orange is the capture value and is stable. Obviously it’s later than the green one (why? ironically because of call-by-value semantics to String.Concat in the first Console.WriteLine) and earlier than the red one one second later. Anyway, this is our “smart function evaluator” which obviously relies on the fact that the function it captures doesn’t change its mind. The sample above violates this rule but it provides a way to show you it really works.

Next, let’s take a look at the signature for function application:

static LambdaExpression CallBy____(LambdaExpression func, params Expression[] parameters)

We want to create three such functions:

CallByValue
CallByName
CallByNeed

all of which will have the same signature. The way the functions work is as follows: given a lambda expression and a set of parameters, we’ll return another lambda expression that calls the original function, possibly having some remaining parameters. A sample:

var a = Expression.Parameter(typeof(int), "a");
var b = Expression.Parameter(typeof(int), "b");

var add = Expression.Lambda(Expression.Add(a, b), a, b); // represents (int a, int b) => a + b
var addOne = CallByValue(add, Expression.Constant(1));   // represents (int b) => 1 + b
var three = CallByValue(addOne, Expression.Constant(2)); // represents () => 3

If we’d call through the last function, three, without any parameters, we’d get 3. For call-by-value semantics, it would look like:

() => Invoke(b => Invoke((a, b) => (a + b),1,b),2)

but that will become clearer as we move forward. Time to switch gears and start implementing all of the strategies.

Call-by-value

This is the simplest one. We won’t change the function itself (so, no forms of substitution are carried out in the lambda body), rather we’ll call it with the (evaluated) supplied arguments, keeping remaining arguments. Here’s what it looks like:

static LambdaExpression CallByValue(LambdaExpression func, params Expression[] parameters)
{
    if (parameters.Length > func.Parameters.Count)
        throw new InvalidOperationException("Too many parameters specified.");

    ParameterExpression[] lambdaParams = func.Parameters.Skip(parameters.Length).ToArray();
    return Expression.Lambda(Expression.Invoke(func, parameters.Concat(lambdaParams)), lambdaParams);
}

Ignoring the validation, we create a new lambda expression with the remaining parameters, and a body that calls the original lambda with the supplied arguments. A sample:

var a = Expression.Parameter(typeof(int), "a");
var b = Expression.Parameter(typeof(int), "b");

var add = Expression.Lambda(Expression.Add(a, b), a, b); // represents (int a, int b) => a + b
var addOne = CallByValue(add, Expression.Constant(1));   // represents (int b) => 1 + b

The CallByValue call above does the following:

ParameterExpression[] lambdaParams = func.Parameters.Skip(parameters.Length).ToArray();

becomes { a, b }.Skip(1).ToArray() = { b }. So, the lambdaParams variable contains the remaining parameters. Next, it returns a new lambda expression that does the following:

Expression.Invoke(func, parameters.Concat(lambdaParams)

which is semantically equivalent to func(1, b). To clarify this, the parameters are 1 (which is passed in as Expression.Constant(1)) and b, the remaining parameter(s). More precisely, we keep the number of arguments to call the original lambda the same, but we’ve concretized one of them (i.e. a := 1). This lambda body is now wrapped in a new lambda that only has b as a parameter. In the end it looks like (pseudo-code):

b => ((a, b) => a + b)(1, b)

where the outer b is different from the inner b (they have different scope) and the binding of a with the constant 1 is pointed out. The ToString result of the produced lambda is:

b => Invoke((a, b) => (a + b),1,b)

What are the characteristics of this approach?

Arguments are evaluated before calling the function, which means they are evaluated exactly once.
As an implication of the previous, arguments that are not used in the body of the function yield redundant evaluations.
An argument that evaluates to the “denotational bottom” (e.g. throws an exception or doesn’t terminate) prevents the call from being made (bail out early, but maybe – see previous point – for no real reason).
On the positive side, the technique is easy to understand and compatible with lots of languages (e.g. for interop reasons).

Call-by-name

Slightly more complicated but still easy to understand is call-by-value. The idea here is to substitute occurrences of the parameters in the function’s body to create a new function. To put it another way, we don’t wrap the original function but clone it and rewrite it as a new function with fewer arguments. For the same sample:

var a = Expression.Parameter(typeof(int), "a");
var b = Expression.Parameter(typeof(int), "b");

var add = Expression.Lambda(Expression.Add(a, b), a, b); // represents (int a, int b) => a + b
var addOne = CallByName(add, Expression.Constant(1));   // represents (int b) => 1 + b

the comments on the right actually point out literally what’s happening. Indeed, a ToString of the resulting lambda looks like:

b => 1 + b

It’s important to realize that the ‘1’ here could be an arbitrary complex expression that’s put in place wherever ‘a’ was found (because of the binding to the parameter). So, if you’d have the following:

var a = Expression.Parameter(typeof(int), "a");
var twice = Expression.Lambda(Expression.Add(a, a), a); // silly way to double things: (int a) => a + a
var six = CallByName(twice, Expression.Add(Expression.Constant(1), Expression.Constant(2))); // calling twice with argument (1 + 2)

we’d get, by formal substitution of a in (int a) => a + a,

() => (1 + 2) + (1 + 2)

while call by value would evaluate the (1 + 2) first, resulting in:

() => 3 + 3

How do we implement it? The original Curry for dummies post introduces the use of the expression visitor which we inherit from to create an expression tree cloner that replaces parameter occurrences by a given expression like this:

class CurryVisitor : ExpressionVisitor
{
    private Dictionary<ParameterExpression, Expression> _parameters;

    public CurryVisitor(Dictionary<ParameterExpression, Expression> parameters)
    {
        _parameters = parameters;
    }

    protected override Expression VisitParameter(ParameterExpression p)
    {
        if (_parameters.ContainsKey(p))
            return _parameters[p];

        return base.VisitParameter(p);
    }

    public Expression Clone(Expression exp)
    {
        return base.Visit(exp);
    }
}

Using this tool – that we’ll reuse in the call-by-need implementation as well – we can write call-by-name like this:

static LambdaExpression CallByName(LambdaExpression func, params Expression[] parameters)
{
    if (parameters.Length > func.Parameters.Count)
        throw new InvalidOperationException("Too many parameters specified.");

    var assignments = new Dictionary<ParameterExpression, Expression>();

    for (int i = 0; i < parameters.Length; i++)
    {
        ParameterExpression parameter = func.Parameters[i];
        Expression value = parameters[i];

        if (!parameter.Type.IsAssignableFrom(value.Type))
            throw new InvalidOperationException("Incompatible parameter value type for parameter " + parameter.Name);

        assignments[parameter] = value;
    }

    var visitor = new CurryVisitor(assignments);
    return Expression.Lambda(visitor.Clone(func.Body), func.Parameters.Skip(parameters.Length).ToArray());
}

The most important thing here is that we go through all of the specified parameters (in the sample above that’s the expression (1 + 2)), hand-in-hand with the parameter expressions that correspond to it, adding them to a dictionary. For our sample, the dictionary will contain

a –> (1 + 2)

which is then fed in to the CurryVisitor to clone the original lambda’s body (i.e. a + a) while replacing the dictionary key occurrences (a) by the mapped substitution (1 + 2). The new body will be (1 + 2) + (1 + 2), which is hooked up as the body for the new lambda expression with the remaining arguments (in this case none at all) in precisely the same way as in call-by-value.

What are the characteristics of this approach?

Arguments are not evaluated when they are not needed in the function body for the particular invocation.
On the sunny side, too, fatal side effects (denotational bottom) have no effects for unused arguments.
But … arguments may be evaluated multiple times, which means side-effects would be multiplied.
Also, in order to do the substitution we need to gain access to the function itself, which would be a runtime (in the two senses of the word) task.

Call-by-need

As mentioned in Curry for dummies cont'd - A note on purity, call-by-need is an improvement on top of call-by-name. It follows the same principles of substitution but it employ memoization, a caching technique to remember the evaluation result for an expression, to avoid reevaluation expressions. In other words, it eliminates common subexpressions that are introduced by formal parameter substitution. To continue with the same sample, consider:

var a = Expression.Parameter(typeof(int), "a");
var twice = Expression.Lambda(Expression.Add(a, a), a); // silly way to double things
var six = CallByNeed(twice, Expression.Add(Expression.Constant(1), Expression.Constant(2))); // calling twice with argument (1 + 2)

What happens now though is something I’m going to denote using some special syntax. When evaluating twice, it’s rewritten as:

() => [| () => 1 + 2 |] + [| () => 1 + 2 |]

The cool thing about denotational semantics is you can invent your own symbols :-). Here I’m introducing what I’d call pillar syntax: i.e. [| … |]. The body of it denotes a parameter-less function using lambda syntax. In practical terms this means we have a delay-loaded or lazy-loaded value: it’s only calculated on-demand. Now by means of common subexpression elimination, the compiler can rewrite this as follows (relying on the fact that the function would be pure, i.e. there are no side-effects that call for the need of doing the evaluation every time again):

x = [| () => 1 + 2 |]
() => x + x

The semantics are as follows: when declared ("stage 0” if you want), the function is not evaluated, it’s simply cached. Next, when evaluated for the first time (“stage 1”), the function is called and the value is kept. I’m not building a formal specification here (I’m defining the “valuation function” in words after all), but realize that I’m introducing some state mutation here (let’s not get into monads and beasts like unsafePerformIO this time). On subsequent evaluations, the function isn’t called but the cached value is returned straight away (“stage > 1”). So, applying our function above becomes:

six()
= let x = [| () => 1 + 2 |] in x + x
= [| () => 1 + 2 |] + [| () => 1 + 2 |]
= [| () => 3 |] + [| () => 1 + 2 |]
= [| 3 |] + [| 3 |] 'here mutation happens; x is a “reference” variable
= 6

This is precisely what our Cell<T> does. How can we make this work though? What we need is an “environment” in which we keep all the constructed cells. Such an environment establishes bindings between parameters and the corresponding cell that captures the bound expression lifted in a function. This needs some clarification. When calling CallByNeed in the sample above, the argument (1 + 2) needs to be wrapped in a parameter-less function to make it “on-demand” evaluated. The parameter to call “twice” with is:

Expression.Add(Expression.Constant(1), Expression.Constant(2)) // 1 + 2

and needs to become

Expression.Lambda(Expression.Add(Expression.Constant(1), Expression.Constant(2))) // () => 1 + 2

Next, this lambda needs to be wrapped in a Cell<T>. T is inferred from the type of the parameter, i.e. int, and the constructor of Cell<T> takes in a Func<T>. We can turn a LambdaExpression into a delegate by calling Compile on it. We do this for all the parameters (in the same we only have one) and keep the resulting cells in a dictionary mapping the name of the parameter (a string, in this running sample “a”) onto the corresponding cell. This piece of voodoo plumbing ensures that we have just one reference to a cell per parameter and that’s the whole point of the memoization: we don’t want to reevaluate parameters when they occur in the function body multiple times. To put this in terms of the sample:

var environment = new Dictionary<string, object>();
…
environment["a"] = new Cell<int>(() => 1 + 2);

One more question to answer now is how to carry out formal substitution? More specially, what should we replace ParameterExpression occurrences with during the “tree visitation” by the CurryVisitor? The answer isn’t too hard either: a lookup into the environment dictionary, returning a Cell<T>, on which we can call Value causing either evaluation (“stage 1”) or return of the memoized value (“stage > 1”):

((Cell<int>)environment["a"]).Value

In other words, our call to twice returns an expression tree like this:

() => ((Cell<int>)environment["a"]).Value + ((Cell<int>)environment["a"]).Value

You’ll wonder where environment is kept – the answer is in some kind of “closure” that’s created when the lambda expression is compiled, but you can consider this to be an irrelevant detail at this point (if you’re really curious, invoke the Method property on the generated delegate and observe the passed-in ExecutionScope object).

Time to dive in the code:

static LambdaExpression CallByNeed(LambdaExpression func, params Expression[] parameters)
{
    if (parameters.Length > func.Parameters.Count)
        throw new InvalidOperationException("Too many parameters specified.");

    var environment = new Dictionary<string, object>();
    var assignments = new Dictionary<ParameterExpression, Expression>();

    MethodInfo envItem = typeof(Dictionary<string, object>).GetMethod("get_Item");

    for (int i = 0; i < parameters.Length; i++)
    {
        ParameterExpression parameter = func.Parameters[i];
        Expression value = parameters[i];

        if (!parameter.Type.IsAssignableFrom(value.Type))
            throw new InvalidOperationException("Incompatible parameter value type for parameter " + parameter.Name);

        LambdaExpression lazyValue = Expression.Lambda(value);
        object cell = typeof(Cell<>).MakeGenericType(value.Type).GetConstructors()[0].Invoke(new object[] { lazyValue.Compile() });

        environment[parameter.Name] = cell;
        assignments[parameter] = Expression.Property(Expression.Convert(Expression.Call(Expression.Constant(environment), envItem, Expression.Constant(parameter.Name)), typeof(Cell<>).MakeGenericType(value.Type)), "Value");
    }

    var visitor = new CurryVisitor(assignments);
    return Expression.Lambda(visitor.Clone(func.Body), func.Parameters.Skip(parameters.Length).ToArray());
}

This is roughly the same as the CallByName implementation (indeed, some refactoring could be done), but the most notable differences (indicated in bold) are:

Besides assignments, we’re building up an environment which consists of mappings from parameter.Name strings onto cell objects capturing the lambda built around the parameter expression.
The assignments themselves are property .Value calls on the result of retrieving the cell from the environment through the get_Item dictionary indexer, passing in the parameter.Name as the key, and casting the result to Cell<T>.

The substitution using the CurryVisitor is the same as before, only the mappings of ParameterExpressions onto the replacement values are different.

What are the characteristics of this approach?

Same as call-by-name but:
- Arguments are evaluated once at most, which brings it closer to call-by-value compared to call-by-name.
- However, formal substitution is still the driving mechanism here.
Also notice we need access to the implementation of the function to do the substitution. This access is not shallow – if a lambda calls into another function, the laziness of arguments needs to be propagated all the way through. When you hit the border where a call into the non-pure lazy world is needed (e.g. interop code), the landscape changes into call-by-value with eager evaluation of the arguments at the call-site. However, laziness is still beneficial because the code in between the function entry point and the interop code much lower in the stack (including OS function calls that are typically call-by-value) might be separated by a bunch of code paths that do not necessarily need to carry on all of the arguments of the original function. In other words, a (not necessarily proper) subset of the input arguments has the potential of getting discarded without any need for evaluation while others will be “degraded” to forced eagerness.

The final test

To test this stuff, I wrote this little test framework:

static Dictionary<string, Func<LambdaExpression, Expression[], LambdaExpression>> s_tests
    = new Dictionary<string, Func<LambdaExpression, Expression[], LambdaExpression>> { { "By Value", CallByValue }, { "By Name", CallByName }, { "By Need", CallByNeed } };

static void Test(string testName, LambdaExpression func, params Expression[] parameters)
{
    Test(testName, null, func, parameters);
}

static void Test(string testName, Action cleanUp, LambdaExpression func, params Expression[] parameters)
{
    Console.WriteLine(testName);
    Console.WriteLine(new string('-', testName.Length));

    foreach (var test in s_tests.Keys)
    {
        LambdaExpression res = s_tests[test](func, parameters);

        try
        {
            // this assumes all parameters have been supplied
            Console.Write(test + " -> " + res + " = ");
            Console.WriteLine(res.Compile().DynamicInvoke());
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex.InnerException.Message);
        }

        if (cleanUp != null)
            cleanUp();
    }

    Console.WriteLine();
}

As we’re in a functional mood, the use of a dictionary with delegates shouldn’t be too surprising. In essence, s_tests contains mappings of friendly names to delegate instances pointing at each of the CallBy* methods (which all have the same signature). Notice the use of C# 3.0 collection initializers to build up this dictionary. The test execution harness is simple: it iterates over all of the directory entries, extracts the test and calls it with the given lambda expression and the given parameters (assuming all parameters are “eaten” so that we can call DynamicInvoke without passing in any remaining arguments). There’s also support to clean up shared mutable state which comes in handy to compare results.

Now the tests itself:

static void Main()
{
    var a = Expression.Parameter(typeof(int), "a");
    var b = Expression.Parameter(typeof(int), "b");
    var add = Expression.Lambda(Expression.Add(a, b), a, b); // represents (int a, int b) => a + b
    var one = Expression.Constant(1);
    var two = Expression.Constant(2);
    Test("Add test", add, one, two);

    var bad = Expression.Divide(one, Expression.Constant(0));
    var twice = Expression.Lambda(Expression.Add(a, a), a, b); //doesn't use b
    Test("Eagerness test", twice, one, bad);

    var sideEffect = Expression.Call(typeof(Program).GetMethod("ChangingMind", BindingFlags.NonPublic | BindingFlags.Static), null);
    Test("Laziness test", () => { s_i = 0; }, twice, sideEffect, one /* not used */);
}

static int s_i = 0;

static int ChangingMind()
{
    return s_i++;
}

The first test deals with a pure function – we expect all strategies to come up with the same answer. The second one passes in an unused expression that results in a divide by zero. Call-by-value will crash while the others won’t. Finally, the side-effecting test calls out to a function that has mutating state (which we clean up after every iteration of the test bench since we want to see the effects on a per-strategy basis). This is a bit more subtle. Call-by-value will just call ChangingMind once, before calling the twice function. Call-by-name will duplicate the ChangingMind calls, while call-by-need will still do in-place substitution but because of the memoization with Cell<T> the ChangingMind function is only called once when the parameter is really needed. In fact, it would be a good exercise (left to the reader) to combine the last two tests. Here’s the output:

The results are as expected. Mission accomplished. You can download the code here.