O>Company1.printer --> 25
O>Company2.printer --> 25
O>

using c1 = Company1;
using c2 = Company2;
c1.printer --> 25
c2.printer --> 25

VD>string.Formar("Имя: {0} Фамилия: {0}", name, lastname)
VD>

VD>$"Имя: $name Фамилия: $lastname", 
VD>

// До
def a = 5; 
$"var a has value $a, blah-blah-blah";

// После
def a = 5;
def tmp = StringBuilder("var a has value ");
tmp.Append(a.ToString());
tmp.Append(", blah-blah-blah");
tmp.ToString();

using Oyster;

metaclass TestClass {
    prop1 : int;
    prop2 : string
}

using Nemerle.Collections;

namespace Oyster
{
    macro metaclass(className, body)
    syntax ("metaclass", className, body)
    {
        // Тут я зачем-то вытаскиваю идентификатор, а потом его снова вставляю в AST.
        // Криво (?), но как иначе - не знаю
        def className = match (className) { | <[ $(x : name) ]> => x };
        
        // Разбираем "свойства"
        def props = match (body) {
            | <[ { .. $props } ]> => List.Map(props, fun(prop) { | <[ $(n : name) : $(t : name) ]> => (n, t) })
            | _ => []
        };
        
        // http://nemerle.org/Defining_types_from_inside_macros
        def ctx = Nemerle.Macros.ImplicitCTX();
        def builder = ctx.Env.Define(<[ decl: public class $(className : name) {} ]>);
        
        // Добавляем поля для начала.
        // Если я тут ничего не верну, то компилятор чего-то на меня обидится :(
        List.ForAll(props, fun(n, t) { builder.Define(<[ decl: mutable $(n.NewName("_" + n.Id) : name) : $(t : name) ; ]>); true });
        
        // Добавляем свойства
        List.ForAll(props, fun(n, t) {
            builder.Define(
                <[ decl:
                    public $(n.NewName(n.Id.Substring(0, 1).ToUpper() + n.Id.Substring(1)) : name) : $(t : name)
                    {
                        get { $(n.NewName("_" + n.Id) : name) }
                    };
                ]>);
            true });
            
        // Добавляем конструктор
        // TODO

        builder.Compile();
        <[ () ]>
    }
}

То что технически грамотно должно быть как минимум красиво.

O>using Oyster;

O>metaclass TestClass {
O>    prop1 : int;
O>    prop2 : string
O>}
O>

using Oyster;
using Nemerle.IO;

metaclass zuper
{
    test : int;
    anotherProperty : string;
}

def z = zuper(1, "crazy test");
printf("%d %s\n", z.Test, z.AnotherProperty);

using Nemerle.Collections;
using Nemerle.Macros;
using PT = Nemerle.Compiler.Parsetree;

namespace Oyster
{
    macro metaclass(className, body)
    syntax ("metaclass", className, body)
    {
        def props = match (body) {
            | <[ { .. $props } ]> =>
                props.Map(fun(_) { | <[ $(n : name) : $(t : name) ]> => (n, t) })
            | _ => []
        };
                
        def ctx = ImplicitCTX();
        def builder = ctx.Env.Define(<[ decl: public class $(className.ToString() : usesite) {} ]>);

        mutable constrParams = [] : list[PT.Fun_parm];
        mutable constrCode = [] : list[PT.PExpr];

        foreach((n, t) in props)
        {
            def prop = n.NewName("_" + n.Id);
            def accessor = n.NewName(n.Id.Substring(0, 1).ToUpper() + n.Id.Substring(1));
            builder.Define(<[ decl: mutable $(prop : name) : $(t : name) ; ]>);
            builder.Define(
                <[ decl:
                    public $(accessor : name) : $(t : name)
                    {
                        get { $(prop : name) }
                    };
                ]>);
            def paramType = ctx.BindType(<[ $(t : name) ]>);

            constrParams = <[ parameter: $(n : name) : $(paramType : typed) ]> :: constrParams;
            constrCode = <[ this.$(prop : name) = $(n : name); ]> :: constrCode;
        }
        builder.Define(
            <[ decl:
                public this(.. $(constrParams.Reverse())) { .. $constrCode }
            ]>);
        builder.Compile();
        <[ () ]>
    }
}

<EntityName Attribute1="" Attribute2="" />

EntityName
{
    Attribute1="";
    Attribute2="";
}

E>

1. Это был мой второй макрос на Nemerle. Первый считал факториал в compile-time, и писал я его тоже около часа
   
2. У меня нет никакого опыта функционального программирования — разве что читал на RSDN — поэтому паттерн-матчинг, вывод типов, туплы и списки я юзал чисто интуитивно и прыгая по граблям.
   
3. Большую часть времени заняло чтение онлайн-документации и сборок рефлектором, а не написание собственно кода.