VD>def x : int = любое_выражение;
VD>

def acceleration_derivative_by_distance : ?что тут писать? = (acceleration2 - acceleration1) / (coord2 - coord1)

using Localization;

[assembly: LocalizationFile("Strings.xml")]

using System.Console;

def nums = array[1, 2, 3];
def x = 5;

WriteLine(%%"a=$(nums[1]) x = $x");

def F(y : int){ y * y }
WriteLine(%%"F(3)=$(F(3))");

<strings>
    <ID_0>
        <en-US>a={0} x = {1}</en-US>
    </ID_0>
    <ID_1>
        <en-US>F(3)={0}</en-US>
    </ID_1>
</strings>

<strings>
    <ID_0>
        <en-US>a={0} x = {1}</en-US>
    </ID_0>
    <ID_1>
        <en-US>F(3)={0}</en-US>
    <ru-RU>Функция F(3) вернуло значение {0}.</ru-RU>
    </ID_1>
</strings>

using System;
using System.Console;
using Nemerle.Compiler;
using Nemerle.Collections;
using Nemerle.Macros;
using PT = Nemerle.Compiler.Parsetree;
using System.Text;
using System.IO;
using System.Xml.XPath;

namespace Localization
{
  
  // Meta-attribut which call when assembly loading.
  // It's receive name of localization file nale.
  // The LocalizationString macro write into this file 
  // localization information. Папа мама я.
  [Nemerle.MacroUsage(Nemerle.MacroPhase.BeforeInheritance,
    Nemerle.MacroTargets.Assembly)
  ]
  macro LocalizationFile(fileName : string)
  {
    Helper._fileName = fileName;
    _ = Helper._builder.AppendLine("<strings>");
    // _holder save _builder content to a file when ncc closing.
    Helper._holder = Helper.Holder();
  }

  macro LocalizationString(str : string)
  syntax ("%%", str)
  {
    def exprs = Helper.make_splice_distribution (
      str, ImplicitCTX().Env);

    // Формируем строку формата "str" и список аргуменов (выражений в них подсавляемых).
    def (str, args, _) = exprs.FoldRight(("", [], 0), fun(expr, accumulator)
    {
      // Выделяем из кортежа отдельные значения
      // str - формируемая строка форамата.
      def (str, args, i) = accumulator;
      def x = expr.ToString(); // Преобразуем текущее выражение в строку.
      // Функция Unquot(s) убирает обрамляющие ковычки из строки.
      def Unquot(s) { s.Substring(1).Substring(0, s.Length - 2) }
      // AddTwiceBraces(s) удваиват знаки "{" и "}".
      def AddTwiceBraces(s) { s.Replace("{", "{{").Replace("}", "}}") }
      
      if (x.Length > 0)
      {
        // Если стока начинается с ", то это просто подстрока которую нужно 
        // обработать и добавить в строку формата.
        if (x[0] == '"')
          (str + AddTwiceBraces(Unquot(x)), args, i)
        // иначе это "встроеное" подвыражение выделенное из строки.
        // Для каждого такого подвыражения нужно добавить с форматную строку
        // тег вида {x} где x - это номер подвыражения, а так же добавить выражение 
        // в список выражений которые в посделствии будут формировать параметры.
        else
          (str + "{" + i.ToString() + "}", expr :: args, i + 1)
      }
      else // Если строка пуста, то ничего не делаем.
        accumulator
    });

    // Добавляем в начала списока параметров парамер содержащий строку формата.
    // сам список параметров при этом разворачиваем, так как формировался он в обратном порядке.
    def args = <[ $(Helper.GenerateId() : string) ]> :: args.Reverse();

    // Добавляем тег в файл локализации.
    Helper.AddString(str);
    
    // Формируем выражение форматированного вывода и возвращаем его как результат работы макроса.
    // Этот код заместит вызов макроса. Консрукция ( .. $args) сформирует кортэж с параметрами.
    // В Nemerle кортежи и списки параметров функций равнозначны. Так что можно считать, что 
    // сформирован список парамтеров!
    <[ Localiser._instace.Format( .. $args) ]>
  }

  internal module Helper
  {
    public mutable _cointer : int = 0;
    public mutable _fileName : string;
    public _builder : StringBuilder = StringBuilder();
    public  mutable _holder : Holder;
    
    public GenerateId() : string
    {
      "ID_" + _cointer.ToString()
    }
    
    public AddString(str : string) : void
    {
      _ = _builder.AppendFormat("    <ID_{0}>", _cointer);
      _ = _builder.AppendLine();
      _ = _builder.AppendLine(  "        <en-US>" + str + "</en-US>");
      _ = _builder.AppendFormat("    </ID_{0}>", _cointer);
      _cointer++;
      _ = _builder.AppendLine();
    }

    // Holder save the _builder content to file (with name contain in _fileName) 
    // when ncc closing.
    [Record]
    internal class Holder
    {
      protected override Finalize() : void
      {
        _ = Helper._builder.AppendLine("</strings>");
        File.WriteAllText(Helper._fileName, Helper._builder.ToString());
      }
    }
    
      /** for $(..) expressions:
        - first evaluate expressions
        - store intermediate results in variables
        - return list of evaluators and reference variables in reverse order
     */
    public make_splice_distribution (str : string, _env : GlobalEnv) 
      : list [PT.PExpr]
    {
      mutable seen_non_alnum = false;
      
      def find_end (balance, idx) {
        when (idx >= str.Length)
          Message.FatalError ("runaway $(...) in format string");

        def ch = str[idx];
        seen_non_alnum = seen_non_alnum || !(System.Char.IsLetterOrDigit (ch) || ch == '_');
        match (ch) {
          | ')' when balance == 1 => idx
          | ')' => find_end (balance - 1, idx + 1)
          | '(' => find_end (balance + 1, idx + 1)
          | _ => find_end (balance, idx + 1)
        }
      }

      def find_end_normal (idx) {
        if (idx >= str.Length) idx
        else
          match (str[idx]) {
            | '_' 
            | ch when System.Char.IsLetterOrDigit (ch) => find_end_normal (idx + 1)
            | _ => idx
          }
      }

      def loop (res, idx) {
        if (idx < 0 || idx >= str.Length)
          res
        else if (str[idx] == '$') {
          when (idx + 1 >= str.Length)
            Message.FatalError ("lone `$' at the end of the format string");
          if (str[idx + 1] == '(') {
            def end = find_end (1, idx + 2);
            def expr = str.Substring (idx + 2, end - idx - 2);
            def expr =
              if (expr == "" || expr == "_" || 
                  seen_non_alnum || 
                  System.Char.IsDigit (expr [0])) {
                MacroColorizer.PushUseSiteColor ();
                def expr = MainParser.ParseExpr (_env, expr);
                MacroColorizer.PopColor ();
                expr
              } else if (expr == "this")
                <[ this ]>
              else
                <[ $(expr : usesite) ]>;
            loop (expr :: res, end + 1)
          }
          else if (str[idx + 1] == '$')
            loop (<[$("$" : string)]> :: res, idx + 2)
          else {
            def end = find_end_normal (idx + 1);
            def variable_name = str.Substring (idx + 1, end - idx - 1);
            
            if (variable_name == "") {
              Message.Warning ("expected variable name or expression enclosed with (..) after $ in splice string");
              loop (<[$("$" : string)]> :: res, idx + 1)
            }
            else {
              def expr =
                if (variable_name == "this") <[ this ]>
                else <[ $(variable_name : usesite) ]>;
              loop (expr :: res, end)
            }
          }
        } else {
          def next_idx = str.IndexOf ('$', idx);
          def next_str =
            if (next_idx == -1) str.Substring (idx)
            else str.Substring (idx, next_idx - idx);
          loop (<[ $(next_str : string) ]> :: res, next_idx)
        }
      }

      loop ([], 0)
    } 
  }

  public class Localiser
  {
    public static _instace : Localiser = Localiser();
    
    public this()
    {
      def lang = System.Threading.Thread.CurrentThread.CurrentCulture.Name;
      def defLang = "en-US";
      
      def doc = XPathDocument("Strings.xml");
      def iter = doc.CreateNavigator().Select("/strings/*");

      foreach (vlue :> XPathNavigator in iter)
      {
        mutable langIter = vlue.Select(lang);
        
        when (!langIter.MoveNext()) // Нет строк для этого языка!
        {
          langIter = vlue.Select(defLang);
          when (!langIter.MoveNext())
            throw ApplicationException("No string for ID={0} found.");
        }

        _msgMap.Add(vlue.Name, langIter.Current.Value);
      }
    }

    private _msgMap : Hashtable.[string, string] = Hashtable.[string, string]();

    public Format(msgId : string, params args : array[object]) : string
    {
      string.Format(_msgMap[msgId], args);
    }
  }
}

A>Заканчивал курсы маркетологов? Почём брали за месяц?

//
//
// ПИШЕМ СУПЕР ВЕЩЬ!
//
//
#include <Math.h>
//
template <
    int length_power, int weight_power, int time_power,
    typename value_type = double,
    int length_coef_numerator = 1, int length_coef_denominator = 1,
    int weight_coef_numerator = 1, int weight_coef_denominator = 1,
    int time_coef_numerator = 1, int time_coef_denominator = 1>
class physical_value_t
{
    private:
        value_type _value;
    private:
        static const value_type length_coefficient;
        static const value_type weight_coefficient;
        static const value_type time_coefficient;
    private:
        void assign(const physical_value_t & value)
        {
            _value = value._value;
        }
        void assign(const value_type & value)
        {
            _value = value;
        }
        template <
            typename vt,
            int lcn, int lcd,
            int wcn, int wcd,
            int tcn, int tcd>
        void assign(const physical_value_t<length_power, weight_power, time_power, vt, lcn, lcd, wcn, wcd, tcn, tcd> & value)
        {
            _value = value.dangerous_dimensionless() *
                pow((((value_type)lcn)/((value_type)lcd))/length_coefficient, length_power) *
                pow((((value_type)wcn)/((value_type)wcd))/weight_coefficient, weight_power) *
                pow((((value_type)tcn)/((value_type)tcd))/time_coefficient, time_power);
        }
    public:
        physical_value_t() : _value(0)
        {
        }
        physical_value_t(const physical_value_t & value)
        {
            assign(value);
        }
        physical_value_t(const value_type & value)
        {
            assign(value);
        }
        
        template <
            typename vt,
            int lcn, int lcd,
            int wcn, int wcd,
            int tcn, int tcd>
        physical_value_t(const physical_value_t<length_power, weight_power, time_power, vt, lcn, lcd, wcn, wcd, tcn, tcd> & value)
        {
            assign<vt, lcn, lcd, wcn, wcd, tcn, tcd>(value);
        }

        physical_value_t & operator = (const physical_value_t & value)
        {
            assign(value);
            return *this;
        }
        physical_value_t & operator = (const value_type & value)
        {
            assign(value);
            return *this;
        }
        
        template <
            typename vt,
            int lcn, int lcd,
            int wcn, int wcd,
            int tcn, int tcd>
        physical_value_t & operator = (const physical_value_t<length_power, weight_power, time_power, vt, lcn, lcd, wcn, wcd, tcn, tcd> & value)
        {
            assign<vt, lcn, lcd, wcn, wcd, tcn, tcd>(value);
            return *this;
        }

        value_type dangerous_dimensionless() const
        {
            return _value;
        }
        
        physical_value_t operator + (const physical_value_t & right)
        {
            return physical_value_t (_value + right._value);
        }
        
        physical_value_t operator - (const physical_value_t & right)
        {
            return physical_value_t (_value - right._value);
        }
        
        physical_value_t operator * (const value_type & right)
        {
            return physical_value_t(_value * right);
        }
        
        physical_value_t<
            2*length_power, 2*weight_power, 2*time_power,
            value_type,
            length_coef_numerator*length_coef_numerator, length_coef_denominator*length_coef_denominator,
            weight_coef_numerator*weight_coef_numerator, weight_coef_denominator*weight_coef_denominator,
            time_coef_numerator*time_coef_numerator, time_coef_denominator*time_coef_denominator>
                operator * (const physical_value_t & right)
        {
            return physical_value_t<
                2*length_power, 2*weight_power, 2*time_power,
                value_type,
                length_coef_numerator*length_coef_numerator, length_coef_denominator*length_coef_denominator,
                weight_coef_numerator*weight_coef_numerator, weight_coef_denominator*weight_coef_denominator,
                time_coef_numerator*time_coef_numerator, time_coef_denominator*time_coef_denominator>(
                _value * right._value);
        }
        
        physical_value_t operator / (const value_type & right)
        {
            return physical_value_t(_value / right);
        }
        
        physical_value_t<
            0, 0, 0,
            value_type,
            1, 1,
            1, 1,
            1, 1>
                operator / (const physical_value_t & right)
        {
            return physical_value_t<
                0, 0, 0,
                value_type,
                1, 1,
                1, 1,
                1, 1>(
                    _value / right._value);
        }
        
        physical_value_t & operator += (const physical_value_t & right)
        {
            _value += right._value;
            return *this;
        }
        
        physical_value_t & operator -= (const physical_value_t & right)
        {
            _value -= right._value;
            return *this;
        }
        
        physical_value_t & operator *= (const value_type & right)
        {
            _value += right;
            return *this;
        }
        
        physical_value_t & operator /= (const value_type & right)
        {
            _value -= right;
            return *this;
        }
        
        template <
            typename vt,
            int lcn, int lcd,
            int wcn, int wcd,
            int tcn, int tcd>
        physical_value_t operator + (const physical_value_t & right)
        {
            return physical_value_t(_value + physical_value_t(right).dangerous_dimensionless());
        }
        
        template <
            typename vt,
            int lcn, int lcd,
            int wcn, int wcd,
            int tcn, int tcd>
        physical_value_t operator - (const physical_value_t & right)
        {
            return physical_value_t(_value - physical_value_t(right).dangerous_dimensionless());
        }
        
        template <
            int lp, int wp, int tp,
            typename vt,
            int lcn, int lcd,
            int wcn, int wcd,
            int tcn, int tcd>
        physical_value_t<
            length_power + lp,
            weight_power + wp,
            time_power + tp,
            value_type,
            length_coef_numerator, length_coef_denominator,
            weight_coef_numerator, weight_coef_denominator,
            time_coef_numerator, time_coef_denominator>
                operator * (const physical_value_t<lp, wp, tp, vt, lcn, lcd, wcn, wcd, tcn, tcd> & right)
        {
            return physical_value_t<
                length_power + lp,
                weight_power + wp,
                time_power + tp,
                value_type,
                length_coef_numerator, length_coef_denominator,
                weight_coef_numerator, weight_coef_denominator,
                time_coef_numerator, time_coef_denominator>(
                    _value * right.dangerous_dimensionless() *
                    pow((((value_type)lcn)/((value_type)lcd))/length_coefficient, lp) *
                    pow((((value_type)wcn)/((value_type)wcd))/weight_coefficient, wp) *
                    pow((((value_type)tcn)/((value_type)tcd))/time_coefficient, tp));
        }
        
        template <
            int lp, int wp, int tp,
            typename vt,
            int lcn, int lcd,
            int wcn, int wcd,
            int tcn, int tcd>
        physical_value_t<
            length_power - lp,
            weight_power - wp,
            time_power - tp,
            value_type,
            length_coef_numerator, length_coef_denominator,
            weight_coef_numerator, weight_coef_denominator,
            time_coef_numerator, time_coef_denominator>
                operator / (const physical_value_t<lp, wp, tp, vt, lcn, lcd, wcn, wcd, tcn, tcd> & right)
        {
            return physical_value_t<
                length_power - lp,
                weight_power - wp,
                time_power - tp,
                value_type,
                length_coef_numerator, length_coef_denominator,
                weight_coef_numerator, weight_coef_denominator,
                time_coef_numerator, time_coef_denominator>(
                    (_value / right.dangerous_dimensionless()) *
                    pow((((value_type)lcn)/((value_type)lcd))/length_coefficient, -lp) *
                    pow((((value_type)wcn)/((value_type)wcd))/weight_coefficient, -wp) *
                    pow((((value_type)tcn)/((value_type)tcd))/time_coefficient, -tp));
        }
        
        template <
            typename vt,
            int lcn, int lcd,
            int wcn, int wcd,
            int tcn, int tcd>
        physical_value_t & operator += (const physical_value_t & right)
        {
            _value += physical_value_t(right).dangerous_dimensionless();
            return *this;
        }
        
        template <
            typename vt,
            int lcn, int lcd,
            int wcn, int wcd,
            int tcn, int tcd>
        physical_value_t & operator -= (const physical_value_t & right)
        {
            _value -= physical_value_t(right).dangerous_dimensionless();
            return *this;
        }
};
//
template <
    int length_power, int weight_power, int time_power,
    typename value_type,
    int length_coef_numerator, int length_coef_denominator,
    int weight_coef_numerator, int weight_coef_denominator,
    int time_coef_numerator, int time_coef_denominator>
const value_type physical_value_t<
    length_power, weight_power, time_power,
    value_type,
    length_coef_numerator, length_coef_denominator,
    weight_coef_numerator, weight_coef_denominator,
    time_coef_numerator, time_coef_denominator>::length_coefficient = ((value_type)length_coef_numerator)/((value_type)length_coef_denominator);
//
template <
    int length_power, int weight_power, int time_power,
    typename value_type,
    int length_coef_numerator, int length_coef_denominator,
    int weight_coef_numerator, int weight_coef_denominator,
    int time_coef_numerator, int time_coef_denominator>
const value_type physical_value_t<
    length_power, weight_power, time_power,
    value_type,
    length_coef_numerator, length_coef_denominator,
    weight_coef_numerator, weight_coef_denominator,
    time_coef_numerator, time_coef_denominator>::weight_coefficient = ((value_type)weight_coef_numerator)/((value_type)weight_coef_denominator);
//
template <
    int length_power, int weight_power, int time_power,
    typename value_type,
    int length_coef_numerator, int length_coef_denominator,
    int weight_coef_numerator, int weight_coef_denominator,
    int time_coef_numerator, int time_coef_denominator>
const value_type physical_value_t<
    length_power, weight_power, time_power,
    value_type,
    length_coef_numerator, length_coef_denominator,
    weight_coef_numerator, weight_coef_denominator,
    time_coef_numerator, time_coef_denominator>::time_coefficient = ((value_type)time_coef_numerator)/((value_type)time_coef_denominator);
//
//
// УСЁ, ТЕПЕРЬ ИСПОЛЬЗУЕМ
//
//
typedef physical_value_t<1, 0, 0> phys_meter_t;
typedef physical_value_t<0, 1, 0> phys_kilogramm_t;
typedef physical_value_t<0, 0, 1> phys_second_t;
//
typedef physical_value_t<1, 0, 0, double, 1, 100, 1, 1, 1, 1> phys_centimeter_t;
typedef physical_value_t<0, 1, 0, double, 1, 1, 1, 1000, 1, 1> phys_gramm_t;
typedef physical_value_t<0, 0, 1, double, 1, 1, 1, 1, 60, 1> phys_minute_t;
typedef physical_value_t<1, 0, -1> phys_mps_t;
typedef physical_value_t<2, 0, 0> phys_m2_t;
//
int _tmain(int argc, _TCHAR* argv[])
{
    // some tests
    
    phys_meter_t m = 2;
    phys_centimeter_t cm = m;//must be 200
    phys_kilogramm_t kg = 3;
    phys_gramm_t g = kg;// must be 3000
    phys_second_t s = 5;
    phys_minute_t min = s;// must be 0.8333
    phys_mps_t mps = m / s;// must be 0.4
    mps = m / min;//must be still 0.4
    phys_m2_t m2 = m * m;//must be 4
    m2 = m * cm;//must be still 4
    m += cm * 5;// must be 12
    return 0;
}
//
//
// КОНЧАЕМ ИСПОЛЬЗОВАТЬ - ПЕРЕКУР. И ВООБЩЕ ПОРА ЖРАТЬ.
//
//

#define kg() * phys_kilogramm_t(1)

typedef physical_value_t<1, 0, 0, double, 1, 100, 1, 1, 1, 1> phys_centimeter_t;

Length[ cm ] - 1.0 / 100.0,

    basisUnits (Si)
    (
        Mass,
        Length,
        Time,
        Temperature,
        CurrentStrength,
        LightIntensity,
        QuantityOfSubstance
    )