Daerax asked if Tangent was going to support local functions. It seems he meant anonymous delegate things, so yes. They're very useful for just little tidbits of glue code (because there's no 'bind' equivalent in C#), and pretty vital in providing snippets as strategies. Since Tangent is making an increased emphasis on functions over objects, they gain that much more importance.

I went with C# lambda style syntax, since that does tend to be cleaner and a little less ambiguous for the parser than alternatives. Unfortunately, Tangent can't (nicely) support the type inference C# allows on params and on return type. So the Tangent syntax is a bit more verbose:

( method-parameter-list ) => return-type-expression block

It kinda sucks, because the verbosity might push people away from its use. And it will likely turn away functional language advocates who like things nice and succinct. I dislike succinctness in languages, but x => x + 1; is pretty damned clear.

Making the lambdas work required only a few changes. The syntax itself is constructed of bits already used elsewhere. When the lambda's block is compiled, the lambda's scope is simply added to the stack of scopes for name resolution. The name resolution got an added snippet of code to tack on a 'use the outer scope' placeholder (for locals/params/member vars in the outer method). That placeholder then becomes a VM opcode (access outer-scope) during compilation. The lambda itself is compiled into its own VM opcode that creates the method instance and binds the outer scope (params, calling-instance, locals) with it.

This should emulate C#'s closure behavior (and it's a bug if it doesn't), such as weird stuff like this:



And now for some (mildly ugly) test-code:



Binary parameter lambdas can be used as operators (not recommended) or stored in an operator delegate (more recommended). I will be providing a mechanism for combining them (and other arbitrary methods) into a method group, which should yield the ability to do stuff akin to pattern matching found in functional languages (as well as mildly nifty polymorphism on event-handling).

Next in the queue should be Properties. Though Disgaea 3 is coming out next week. Productivity that doesn't involve joyously evil tactical role playing is likely to decline precipitously.

void foo(){
    int x = 0;
    someDelegate = ()=>{ Console.WriteLine(x); x = x+1};

    x = 1000;
}

foo();
someDelegate();   

public class foo{
    
    public delegate void Execute();

    public void Initialize(){
        local int x = 0;

        Execute = ()=>void{ print x "\n"; x=x+1; }; 

        x = 1000;
   }
}

public static void main(){
    local foo A = new foo;
    local foo B = new foo;

    A.Initialize();
    B.Initialize();

    A.Execute();    // 1000
    B.Execute();    // 1000
    A.Execute();    // 1001
    A.Execute();    // 1002
    B.Execute();    // 1001
}