foo () : void
{
    def i = 234;
    def addI = _ + i;
    def x = addI(123);
}

private sealed class _N_closure1425
{
    internal _N_closure1425()
    {
    }
    internal int _N_i1430;
}
private sealed class _N__N_l1189_1438 : Function<int, int>
{
    public _N__N_l1189_1438(Test._N_closure1425 _N_foo_clo1442)
    {
        this._N_foo_clo1442 = _N_foo_clo1442;
    }
    public override int apply(int _N_1437)
    {
        return (_N_1437 + this._N_foo_clo1442._N_i1430);
    }
    private Test._N_closure1425 _N_foo_clo1442;
}
private static void foo()
{
    Test._N_closure1425 _closure1 = new Test._N_closure1425();
    _closure1._N_i1430 = 0xea;
    Function<int, int> function1 = new Test._N__N_l1189_1438(_closure1);
    function1.apply(0x7b);
}

WH>foo () : void
WH>{
WH>    def i = 234;
WH>    def addI = _ + i;
WH>    def x = addI(123);
WH>}
WH>

def addI(i):
    return lambda x : x + i

print addI(234)(123)

Disassembly of addI:
  7           0 LOAD_CLOSURE             0 (i)
              3 LOAD_CONST               1 (<code object <lambda> at 01A17C20, file "D:\temp\Module2.py", line 7>)
              6 MAKE_CLOSURE             0
              9 RETURN_VALUE        
             10 LOAD_CONST               0 (None)
             13 RETURN_VALUE

    foo () : void
    {
        def i = 234;
        def combine(fn)
        {
            fn(_, i);
        }
        def addI = combine(_ + _);
        def x = addI(123);
    }

private sealed class _N__N_l1193_1471 : Function<int, int>
{
    // Methods
    public _N__N_l1193_1471(Test._N_closure1463 _N_combine_clo1475, Test._N_closure1437 _N_foo_clo1477)
    {
        this._N_combine_clo1475 = _N_combine_clo1475;
        this._N_foo_clo1477 = _N_foo_clo1477;
    }

    public override int apply(int _N_1470)
    {
        return this._N_combine_clo1475._N_fn1468.apply(_N_1470, this._N_foo_clo1477._N_i1442);
    }
    
    // Fields
    private Test._N_closure1463 _N_combine_clo1475;
    private Test._N_closure1437 _N_foo_clo1477;
}

private sealed class _N__N_l1200_1484 : Function<int, int, int>
{
    public override int apply(int _N_1482, int _N_1483)
    {
        return (_N_1482 + _N_1483);
    }
}
private sealed class _N_closure1437
{
    internal int _N_i1442;
}

private sealed class _N_closure1463
{
    internal Function<int, int, int> _N_fn1468;
}
 
private static Function<int, int> _N_combine1445(Test._N_closure1437 _N_foo_cp1444, Function<int, int, int> fn)
{
    Test._N_closure1463 _closure1 = new Test._N_closure1463();
    _closure1._N_fn1468 = fn;
    return new Test._N__N_l1193_1471(_closure1, _N_foo_cp1444);
}
private static void foo()
{
    Test._N_closure1437 _closure1 = new Test._N_closure1437();
    _closure1._N_i1442 = 0xea;
    Function<int, int, int> function1 = new Test._N__N_l1200_1484();
    Test._N_combine1445(_closure1, function1).apply(0x7b);
}

L>Первое был вариант с замыканиями, а не вариант с сахаром. От того, что их можно сэмулировать они не становятся сахаром. Иначе ВСЕ было бы сахаром — ведь все эмулируется машинными командами, верно?

_camlTst_01__f_57:
L100:
    lea    eax, DWORD PTR [ebx+eax-1]
    ret
    .CODE
    ALIGN    4
    PUBLIC    _camlTst_01__entry
_camlTst_01__entry:
L101:
    mov    eax, OFFSET _camlTst_01__1
    mov    DWORD PTR _camlTst_01, eax
    mov    eax, 1159
    call    _camlPervasives__string_of_int_153
L102:
    mov    ebx, eax
    mov    eax, DWORD PTR _camlPervasives+92
    call    _camlPervasives__output_string_214
L103:
    mov    eax, 1
    ret

L>Это неинтересно. Сэмулировать то все что угодно можно. Я видел на пхп эмуляцию замыканий

int f1(int i)
{
  return i * 2;
}

int f2(int i)
{
  return i + 20;
}

int fun1(int i);

typedef int (*FuncTypeIntToInt)(int);

FuncTypeIntToInt hof(FuncTypeIntToInt f)
{
  return f2;
}


void main()
{
    FuncTypeIntToInt funcVariable = hof(f1);
  printf("%d\n", funcVariable(3));
}

L> Иначе ВСЕ было бы сахаром — ведь все эмулируется машинными командами, верно?