using System.Console;

def n(f) { WriteLine(f(1, 2)); }

// 1.
n(b : {def f(x, y) { x + y }; f });

// 2.
n(fun(x, y) { x + y });

// 3.
n((x, y) => { x + y });

// 4.
n(_ + _);

__>def n(f) { WriteLine(f(1, 2)); }

n({def f(x, y) { x + y }; f });

__>// 2.
__>n(fun(x, y) { x + y });

__>// 3.
__>n((x, y) => { x + y });

__>// 4.
__>n(_ + _);

__> одного

__>>// 4.
__>>n(_ + _);
VD>

def c = _ + _;
def c1 = (x) => c(2,x);
WriteLine(c1(2));

using System.Console;
using Nemerle.Utility;

[Record]
public class A
{
  public Value : string = "default";
  public override ToString() : string { Value }
}

def f = fun[T](a : T) where T: class, new() { | null => T() | _ => a };

WriteLine(f(A("test")));
WriteLine(f(null : A));

__>>>>// 3.
__>>>>n((x, y) => { x + y });
VD>>>

n((x, y) : int => { x + y });

__>n((x, y) : int => { x + y });
__>

 $name : $type => $code

            tokens.Iter(token =>
            {
                | Token.Keyword =>
                    reduceWhitespace();
                    _ = builder.Append(token);
                    _ = builder.Append(" ");
                    precedingWhitespace = true;
                | Token.Symbol =>
                    reduceWhitespace();
                    _ = builder.Append(token);
                    precedingWhitespace = false;
                | _ =>
                    _ = builder.Append(token);
                    precedingWhitespace = false;
            });

VD>def f = fun[T](a : T) where T: class, new() { | null => T() | _ => a };
VD>

      entries.Iter(location : Location => Debug.WriteLine(location));