using System;

enum JunkFood
{
    Hotdog,
    Hamburger,
    Cheeseburger,
    Chips,
    CocaCola
}

enum Currency
{
    USD,
    EUR,
    RUB
}

struct Price
{
    public double amount;
    public Currency currency;

    public Price(double amount, Currency currency)
    {
        this.amount = amount;
        this.currency = currency;
    }

    public Price ConvertTo(Currency otherCurrency)
    {
        // no conversion required
        if (currency == otherCurrency)
            return this;
        switch(otherCurrency)
        {
            case Currency.USD:
                if (currency == Currency.EUR)
                    return new Price(amount * 1.188, Currency.USD);
                else
                if (currency == Currency.RUB)
                    return new Price(amount / 28.22, Currency.USD);
            break;
            case Currency.RUB:
                if (currency == Currency.USD)
                    return new Price(amount * 28.22, Currency.RUB);
                else
                if (currency == Currency.EUR)
                    return new Price(amount * 33.52, Currency.RUB);
            break;
            case Currency.EUR:
                if (currency == Currency.USD)
                    return new Price(amount / 1.188, Currency.EUR);
                else
                if (currency == Currency.RUB)
                    return new Price(amount / 33.52, Currency.EUR);
            break;

        }
        throw new Exception("Convertion from " + currency.ToString() 
                + " to " + otherCurrency.ToString() + " not supported!");
    }

    public override string ToString()
    {
        string priceStr = amount.ToString();
        switch(currency)
        {
            case Currency.USD:
                 priceStr = "$" + priceStr;
            break;
            case Currency.RUB:
                priceStr = priceStr + " Rub.";
            break;
            case Currency.EUR:
                priceStr = priceStr + " Euro";
            break;
            default:
                throw new Exception("Invalid currency code: " + currency.ToString());
        }
        return priceStr;
    }
}

class JunkPrice
{
    public JunkPrice(JunkFood junk, Price price)
    {
        this.junk = junk;
        this.price = price;
    }
    public JunkFood junk;
    public Price price;
}

class Test
{
    delegate JunkPrice JunkPriceConvertor(JunkPrice junk);
    public static void Main()
    {
        JunkPrice[] prices =
            new JunkPrice[]
                 {
                     new JunkPrice(JunkFood.Hotdog,       new Price(0.4, Currency.EUR)),
                     new JunkPrice(JunkFood.Hamburger,    new Price(1.3, Currency.USD)),
                     new JunkPrice(JunkFood.Cheeseburger, new Price(38 , Currency.RUB)),
                     new JunkPrice(JunkFood.Chips,        new Price(0.3, Currency.EUR)),
                     new JunkPrice(JunkFood.CocaCola,     new Price(0.5, Currency.USD))
                 };

        foreach(JunkPrice junk in prices)
            Console.WriteLine("(\"{0}\", {1})", junk.junk, junk.price);

        Console.WriteLine("-------------------");

        JunkPrice[] rubPrices =
            Array.ConvertAll<JunkPrice,JunkPrice>(prices, 
            delegate(JunkPrice junk)
            {
                return new JunkPrice(junk.junk, junk.price.ConvertTo(Currency.RUB));
            });
        foreach(JunkPrice junk in rubPrices)
            Console.WriteLine("(\"{0}\", {1})", junk.junk, junk.price);
        try
        {
            Price intentionalFailure = new Price(0.5, (Currency) 55);
            intentionalFailure = intentionalFailure.ConvertTo((Currency) 32);
        }
        catch(Exception ex)
        {
            Console.WriteLine(ex.ToString());
        }
    }
}

using System;

variant JunkFood
{
    | Hotdog
    | Hamburger
    | Cheeseburger
    | Chips
    | CocaCola
    public override ToString() : string
    {
        match(this)
        {
            | Hotdog => "\"Hotdog\""
            | Hamburger => "\"Hamburger\""
            | Cheeseburger => "\"Cheeseburger\""
            | Chips => "\"Chips\""
            | CocaCola => "\"CocaCola\""
        }
    }
}

enum Currency
{
    | USD
    | EUR
    | RUB
}

[Record]
struct Price
{
    public amount : double;
    public currency : Currency;
    public ConvertTo(otherCurrency : Currency) : Price
    {
        match((otherCurrency, currency))
        {
            // no convertion required
            | (_, _) when (otherCurrency == currency) => this
            | (USD, EUR) => Price(amount * 1.188, Currency.USD)
            | (USD, RUB) => Price(amount / 28.22, Currency.USD)
            | (RUB, USD) => Price(amount * 28.22, Currency.RUB)
            | (RUB, EUR) => Price(amount * 33.52, Currency.RUB)
            | (EUR, USD) => Price(amount / 1.188, Currency.EUR)
            | (EUR, RUB) => Price(amount / 33.52, Currency.EUR)
            | _ => throw Exception($"Convertion from $currency to $otherCurrency not supported!")
        }
    }

    public override ToString() : string
    {
        match(currency)
        {
            | USD => $"$$$amount"
            | RUB => $"$amount Rub."
            | EUR => $"$amount Euro"
            | _   => throw Exception($"Invalid currency code $currency")
        }
    }
}

module Main
{
    Main() : void
    {
        def prices = [(JunkFood.Hotdog(),       Price(0.4, Currency.EUR)),
                      (JunkFood.Hamburger(),    Price(1.3, Currency.USD)),
                      (JunkFood.Cheeseburger(), Price(38,  Currency.RUB)),
                      (JunkFood.Chips(),        Price(0.3, Currency.EUR)),
                      (JunkFood.CocaCola(),     Price(0.5, Currency.USD))];

        foreach(junk in prices)
            Console.WriteLine(junk.ToString());

        def rubPrices =
            prices.Map(fun(junk, price) { (junk, price.ConvertTo(Currency.RUB)) });

        Console.WriteLine("-------------------");

        foreach(junk in rubPrices)
            System.Console.WriteLine(junk.ToString());
        try
        {
            mutable intentionalFailure = Price(0.5, 55 :> Currency);
            intentionalFailure = intentionalFailure.ConvertTo(32 :> Currency);
        }
        catch
        {
            | ex => Console.WriteLine(ex.ToString());
        }
    }
}

namespace X
{
    using My.Sugar;
    module M
    {
        f() : void
        {
            var x = 0;
        }
    }
}
using Dudes.Sugar;
module M
{
    f() : void
    {
        var x : int "pseudo-comment, a pseudo-neat feature in dude's var macro";
    }
}

My.Sugar.var(x = 0);
Dudes.Sugar.var(x : int "pseudo-comment, bla-bla-bla");

class Currency {
    static public Currency UAH = new Currency("UAH", 1.0);
    static public Currency USD = new Currency("USD", 5.05);
    static public Currency EUR = new Currency("EUR", 6.06);

    Decimal rate;
    String isoName;

    public Currency(String isoName, Decimal rate) {
        this.isoName = isoName;
        this.rate = rate;
    }
    
    public ToString() {
        return isoName + "/" + rate;
    }
}

class JankFood {
    String name;
    public JankFood(String name) {
        this.name = name;
    }
    
    public ToString() {
        return name;
    }
}


class Price {
    JunkFood food;
    Currency currency;
    Decimal amount;

    public Price(JunkFood food, Currency currency, Decimal amount) {
        this.food = food;
        this.currency = currency;
        this.amount = amount;
    }
    
    public Price ToCurrency(Currency newCurrency) {
        return new Price(food, newCurrency, amount*currency.rate/newCurrency.rate);
    }
    
    public String ToString() {
        return food.name + ": " + amount + " " + currency.isoName;
    }
}

ANS> Проще новый язык разработать без старого багажа.

Не, ну, нужно все же более трезво смотреть на реальность. Что проще? Он уже есть!

ANS> Типа Z#, а C# объявить устаревшим Это как раз вписывается в популярную в нынешней индустрии схему "раз в пять-сем лет — новый язык".

Дык есть C# 1.х, есть C# 2.х, и будет C# 3.х. Это три разных языка имеющие обратную совместимость сверху вниз. При этом ты можешь писать на C# 1.х используя компилятор и среду от 3.х. Что еще нужно? Тебя же никто не заставляет использовать неудобные или непонятные по твоему мнению констркции?

Lisp is so bendable as a language that a particular Lisp developer(s) will tend to create a style/library that fits the way they think. A different Lisp person may come along and be really annoyed by the techniques and styles employed. Personal preferences are magnified under Lisp. This is perhaps why it is called a "hacker language". Corporations like consistent standards and conventions because they want easily-exchangable developers. A "creative" language makes this harder.

Например, в K52 была такая обобщенная функция — "повторить операцию N раз". Соответственно, была не нужна специальная команда "Goto line", все обеспечивалось обобщенными средствами. Скажите, можно ли в современном редакторе найти 18-е по счету слово с начала файла? Думаете не надо? А вот надо — это как парадигма в программировании — когда привыкнешь к хорошему, начинаешь критически смотреть на вещи. До сих пор мне подобной простой функции очень не хватает.

S>Поэтому мне совершенно непонятно, зачем бороться с инструментом, который объективно ускоряет написание кода. Может, конечно, это языки такие убогие; но я не знаю языка, который бы не выиграл от внятного редактора. Даже HP-GL я бы предпочел с раскраской синтаксиса и операциями типа scale fragment

def builder = ctx.Env.Define(<[ decl: [Record] public class $(className : name) { [Nemerle.Utility.Accessor] mutable test : int; } ]>);

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();
        <[ () ]>
    }
}

E>>VLADD2_FOREACH_IN_HASH( k, h; hash ) { ... }

E>>EAO197_DECLARE_PERSISTENT_ATTR v : some_type;
E>>

agent_class LoadBalancer
  message MsgAddNode { ... }
  message MsgRemoveNode { ... }
  message MsgTakeNodeStat { ... }
  message MsgPing { ... }
  event EvtAddNode( m : MsgAddNode ) { ... } autosubscribe MsgAddNode priority 0
  event EvtRemoveNode( m : MsgRemoveNode ) { ... } autosubscribe MsgRemoveNode priority 0
  event EvtTakeNodeStat( m : MsgTakeNodeStat ) { ... } autosubscribe MsgTakeNodeStat priority 0
  event EvtReconfigure( m : Configurator.MsgConfig ) { ... } autosubscribe MsgConfig form Configurator.AgentName() priority 1;

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

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

| <[ { .. $props } ]> =>
   props.Map(fun(_) { | <[ $(n : name) : $(t : name) ]> => (n, t) })

Standard:
Initialize all variables at the point of declaration; null is prefered for reference types and strings while min- and max- values are preferred for value types, e.g. DateTime.MinValue.

Code:

string docOwnerUsername = "null";

• Отсутствие удобной документации. Нет, конечно есть статьи в Wiki и исходный код макросов, но во время интенсивного кодинга хотелось бы иметь нечто MSDN-like под рукой.
  
• Местами откровенно нелогичный compile-time API. Создаётся такое ощущение, что этот API вообще не дизайнили, а просто постепенно дописывали, дописывали, дописывали... Смущает, в общем-то, что для получения одного и того же результата в разных случаях нужно выполнить разные последовательности операций. Как результат — написание макросов становится процедурой менее интуитивной и куча времени тратится на Reflector и лазанье по сорсам.
  
• Отсутствие нормальной IDE. Прежде чем писать этот макрос, я попробовал ещё несколько сред для Nemerle кроме Scintilla. В итоге под Винду я так и не нашёл ничего лучше. В общем, интелисенса и рефакторинга не хватает. Но без этого ещё можно жить — кода получается не так много.
  
• Баги компилятора. Вот это то, что действительно раздражает. Но тут ничего не поделаешь — релиза ещё не было и баги гарантированно будут присутствовать. Я, собственно, за время кодинга запостил всего один баг, но всё равно неудобно.

using Nemerle.Utility;
using BLToolkit.Nemerle;
using BLToolkit.Reflection;

public class MyFactory : IObjectFactory
{
  public CreateInstance(_ : TypeAccessor, _ : InitContext) : object implements IObjectFactory.CreateInstance
  {
    null
  }
}

[TypeAccessorHolder]
[ObjectFactory(typeof(MyFactory))]
public class MyBO
{
  [Accessor]
    _name : string = "Hello there!";
    
    mutable public HeyHey : int = 1;
}

_ = MyBO().GetTypeAccessor()

public static T CreateInstance<T>();
public static T CreateInstance<T>(InitContext context);

using System;
using System.Reflection;
using Nemerle;
using Nemerle.Collections;
using Nemerle.Compiler;
using BLToolkit.Reflection;

namespace BLToolkit.Nemerle
{
  // BO will automatically implement this interface using macro TypeAccessorHolder
  public interface ITypeAccessorHolder
  {
    // Retrieve singleton TypeAccessor instance for given class
    GetTypeAccessor() : TypeAccessor;
  }
  
  
  // We must add interface to BO on this stage
  [MacroUsage(MacroPhase.BeforeInheritance, MacroTargets.Class, Inherited = true)]
  macro TypeAccessorHolder(t : TypeBuilder)
  {
        t.AddImplementedInterface(<[ ITypeAccessorHolder ]>);
  }
  
  // Here code for TypeAccessor is actually generated
  [MacroUsage(MacroPhase.WithTypedMembers, MacroTargets.Class, Inherited = true)]
  macro TypeAccessorHolder(t : TypeBuilder)
  {
    // Some oftenly used values
    def tname = t.ParsedTypeName;
    
        // Will hold TypeAccessorImpl constructor code
    mutable nestedCtorCode = [ <[ base(); ]> ];
    
    #region Accessor$
    
    // Function which generates Accessor$ class for all members in collection
    def genMemberAccessor['a](members : list['a], getMemberParam, genGetter, genSetter) where 'a: IMember {
      // Function which returns field/property accessing AST
      def useMember(m) { <[ (o :> $(tname)).$(m.Name : usesite) ]> };
      
      foreach (m in members) {
        def mname = m.Name;
        def accTypeName = Macros.UseSiteSymbol("Accessor$" + mname);
        
        // Define Accessor$ class with constructor
        def accType = t.DefineNestedType(<[ decl:
          class $(accTypeName : name) : MemberAccessor
          {
            public this(ta : TypeAccessor, mi : MemberInfo)
            {
              base(ta, mi)
            }
          } ]>);
        
        // Add code into TypeAccessorImpl ctor which will create Accessor$
        nestedCtorCode ::= <[ AddMember($(accTypeName : name)(this, GetMember($(getMemberParam : int), $(mname : string)))); ]>;
        
        // Add getter/setter methods
        when (genGetter(m)) {
          accType.Define(<[ decl: override public GetValue(o : object) : object { $(useMember(m)) } ]>);
          accType.Define(<[ decl: override public HasGetter : bool { get { true } } ]>);
        }
        
        when (genSetter(m)) {
          accType.Define(<[ decl:
            override public SetValue(o : object, v : object) : void
            {
              $(useMember(m)) = v :> $(Macros.TypedChoose(m.GetMemType()))
            } ]>);
          accType.Define(<[ decl: override public HasSetter : bool { get { true } } ]>);
        }
        
        accType.Compile();
      }
    };
    
    // Generate accessors
    genMemberAccessor(
      t.GetFields(BindingFlags.Public | BindingFlags.Instance),
      1,
      fun(_) { true },
      fun(m) { m.IsMutable });
    genMemberAccessor(
      List.Filter(t.GetProperties(BindingFlags.Public | BindingFlags.Instance), fun(m) { !m.IsIndexer }),
      2,
      fun(m) { m.GetGetter() != null },
      fun(m) { m.IsMutable });
    
    #endregion Accessor$
    
    #region IObjectFactory
    
    // Add factory initialization code if according attribute is present
    when (t.HasAttribute(Macros.GetIfIsType(t.GlobalEnv, <[ ObjectFactoryAttribute ]>).Value)) {
      nestedCtorCode ::= <[ ObjectFactory = (TypeHelper.GetFirstAttribute(typeof($tname), typeof(ObjectFactoryAttribute)) :> ObjectFactoryAttribute).ObjectFactory ]>
    }
    
    #endregion IObjectFactory
    
    // Define nested TypeAccessor implementation
    def nested = t.DefineNestedType(<[ decl:
      class TypeAccessorImpl : TypeAccessor
      {
        public this() { ..$(nestedCtorCode.Reverse()) }
      } ]>);
    
    #region CreateInstance()
    
    // Determine if BO class contains constructors in required form
    mutable defCtor = null;
    mutable initCtor = null;
    foreach (ctor in t.GetConstructors(BindingFlags.Public | BindingFlags.Instance)) {
      match (ctor.GetParameters()) {
        | [] => defCtor = ctor
        | [ param ] => when (param.SystemType.Equals(typeof(InitContext))) initCtor = ctor
      }
    }
    
    // Check obtained constructors
    when (defCtor == null && initCtor == null) {
      Message.FatalError($"The $t type must have public default or init constructor.")
    }
    
    // Declare CreateInstance() override
    def ctorParams = if (defCtor != null) [] else [ <[ null ]>] ;
    nested.Define(<[ decl: override public CreateInstance() : object { $(t.ParsedTypeName)( .. $ctorParams ) } ]>);
    
    // Declare CreateInstance(InitContext) override
    def ctorParams = if (initCtor != null) [ <[ ctx ]> ] else [];
    nested.Define(<[ decl: override public CreateInstance(ctx : InitContext) : object { $(t.ParsedTypeName)( .. $ctorParams ) } ]>);
    
    #endregion CreateInstance()
    
    #region Type/OriginalType
    
    // In this macro Type == OriginalType for me
    def defineTypeProp(n) { nested.Define(<[ decl: override public $(n : usesite) : Type { get { typeof($(t.ParsedTypeName)) } } ]>); };
    defineTypeProp("Type");
    defineTypeProp("OriginalType");
    
    #endregion Type/OriginalType
    
    // TypeAccessor implementor is ready - compile it
    nested.Compile();
    
    // Define static field which holds TypeAccessor implementation instance and method which returns it
    t.Define(<[ decl: static _typeAccessor : TypeAccessor = TypeAccessorImpl(); ]>);
    t.Define(<[ decl:
      public GetTypeAccessor() : TypeAccessor implements ITypeAccessorHolder.GetTypeAccessor
      {
        _typeAccessor
      } ]>)
  }
}

using BLToolkit.Nemerle;
using BLToolkit.Reflection;
using Nemerle.Internal;
using System;
using System.Reflection;

[ObjectFactory(typeof(MyFactory)), Macro("BLToolkit.Nemerle.TypeAccessorHolder:type:postscan", 0, "")]
public class MyBO : ITypeAccessorHolder
{
    static MyBO()
    {
        MyBO._typeAccessor = new TypeAccessorImpl();
    }

    public MyBO()
    {
        this._name = "Hello there!";
        this.HeyHey = 1;
    }

    public sealed override TypeAccessor GetTypeAccessor()
    {
        return MyBO._typeAccessor;
    }


    public string Name
    {
        get
        {
            return this._name;
        }
    }


    [Immutable]
    private string _name;
    [Immutable]
    private static TypeAccessor _typeAccessor;
    public int HeyHey;


    private class Accessor$HeyHey : MemberAccessor
    {
        public Accessor$HeyHey(TypeAccessor ta, MemberInfo mi) : base(ta, mi)
        {
        }

        public override object GetValue(object o)
        {
            return ((MyBO) o).HeyHey;
        }

        public override void SetValue(object o, object v)
        {
            ((MyBO) o).HeyHey = (int) v;
        }


        public override bool HasGetter
        {
            get
            {
                return true;
            }
        }

        public override bool HasSetter
        {
            get
            {
                return true;
            }
        }

    }

    private class Accessor$Name : MemberAccessor
    {
        public Accessor$Name(TypeAccessor ta, MemberInfo mi) : base(ta, mi)
        {
        }

        public override object GetValue(object o)
        {
            return ((MyBO) o).Name;
        }


        public override bool HasGetter
        {
            get
            {
                return true;
            }
        }

    }

    private class TypeAccessorImpl : TypeAccessor
    {
        public TypeAccessorImpl()
        {
            base.AddMember(new MyBO.Accessor$HeyHey(this, base.GetMember(1, "HeyHey")));
            base.AddMember(new MyBO.Accessor$Name(this, base.GetMember(2, "Name")));
            this.ObjectFactory = ((ObjectFactoryAttribute) TypeHelper.GetFirstAttribute(typeof(MyBO), typeof(ObjectFactoryAttribute))).ObjectFactory;
        }


        public override System.Type OriginalType
        {
            get
            {
                return typeof(MyBO);
            }
        }

        public override System.Type Type
        {
            get
            {
                return typeof(MyBO);
            }
        }

    }
}

using Nemerle.Compiler;
macro test()
{
      // False True
    System.Console.WriteLine($"$(Macros.IsTypeName(<[Test]>)) $(Macros.IsTypeName(<[System.String]>))");
    <[ ]>
}

using Nemerle.IO;
using Nemerle.Macros;
def nums = array[1, 2, 3];
pretty_print_expr({ foreach(n in nums) printf("%d\n", n) }, true);

def cached_collection = nums;
def _N_994 = cached_collection.Length;
def _N_993 = (0 :> int);
block (_N_break) :  
   def []_N_for_1135 () : void {
    when (<.s (_N_993, _N_994)) {
      (block (_N_continue) :        
      match (cached_collection [_N_993]) {
          | (_) as n =>
            def _N_1146 = (n : int);
            System.Console.Write (_N_1146);
            System.Console.Write ("\n");
            ()
          | _ =>
            ()
        };
      ();
      _N_993 = ++.i4.s (_N_993);
      _N_for_1135 () : void)
    }
  }
  _N_for_1135 ()

macro TestPrint(n)
{
    def x = <[ System.Console.WriteLine($n) ]>;
    def ctx = Some(Nemerle.Macros.ImplicitCTX());
    Nemerle.Compiler.PrettyPrint.PrintExpr(ctx, x);
    x
}

// Вызов
def x = "Hello";
TestPrint(1234);
TestPrint(x);

// Печатает вот что
System.Console.WriteLine (1234)
System.Console.WriteLine (x)

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();
        <[ () ]>
    }
}

_W>>        For i = 1 To 18
_W>>            DTE.ActiveDocument.Selection.WordRight()
_W>>        Next
_W>>

E>Сравним?

E>18w
E>

alt-18 <command>