abstract ast Expression;

ast If : Expression
{
    syntax "if" "(" condition ")" trueExpression "else" falseExpression;
    condition       : Expression;
    trueExpression  : Expression;
    falseExpression : Expression;
}

pred ConvertibleTo(from : Type, itemType : Type)
mode (in, in) is semidet //Проверяет что один тип приводим к другому.
mode (in, out) is multi  //При помощи бектрекинга перебирает все типы к которым можно привести данный.
//multi по пому что тип как минимум можно привести к самому себе.
//Так что хоть один результат да будет.
//Реализацию выдумавать лень.

//Пытается найти тип к которому можно привести все типы из списка.
pred Unify(types : list[Type], result : Type)
mode (in, out) is semidet

abstract tast TypedExpression
for Expression//Сообщаем системе какой узел ast типизировать данным tast
{
    ExpressionType : out Type;
}

tast TypedIf : TypedExpression
for If
{
    trueType      = trueExpression.ExpressionType;//Локальные переменные.
    falseType     = falseExpression.ExpressionType;//Для краткости.
    conditionType = condition.ExpressionType;
    
    ConvertibleTo(conditionType, type(bool))
        @@@ $"Type of condition must be convertible to bool. But $(conditionType) not convertible to bool." condition.Location;

    Unify([trueType, falseType], ExpressionType)
        @@@ $"Typef of branches must be competible. $trueType and $falseType incompatible" this.Location;
}
rewrite//Понижение уровня языка.
//В режиме ИДЕ никогда не выполняется.
{
    <[
        match ($condition)
        {
            | true  => $trueExpression;
            | false => $falseExpression;
        }
    ]>
}

tast TypedIf : TypedExpression
for If
{
    ConvertibleTo(condition.ExpressionType, type(bool));
    Unify([trueExpression.ExpressionType, falseExpression.ExpressionType], ExpressionType);
}

WH>abstract tast TypedExpression
WH>for Expression//Сообщаем системе какой узел ast типизировать данным tast
WH>{
WH>    ExpressionType : out Type;
WH>}

WH>tast TypedIf : TypedExpression
WH>for If
WH>{
WH>    trueType      = trueExpression.ExpressionType;//Локальные переменные.
WH>    falseType     = falseExpression.ExpressionType;//Для краткости.
WH>    conditionType = condition.ExpressionType;
    
WH>    ConvertibleTo(conditionType, type(bool))
WH>        @@@ $"Type of condition must be convertible to bool. But $(conditionType) not convertible to bool." condition.Location;

WH>    Unify([trueType, falseType], ExpressionType)
WH>        @@@ $"Typef of branches must be competible. $trueType and $falseType incompatible" this.Location;
WH>}
WH>rewrite//Понижение уровня языка.
WH>//В режиме ИДЕ никогда не выполняется.
WH>{
WH>    <[
WH>        match ($condition)
WH>        {
WH>            | true  => $trueExpression;
WH>            | false => $falseExpression;
WH>        }
WH>    ]>
WH>}
WH>

macro If : Expression // по умолчанию типы параметров совпадающие с типом возвращаемого значения можно опускать
  syntax "if" "(" condition ")" trueExpr "else" falseExpr;
  // задаем условие на тип одного из параметров макроса
  requires condition.Type is bool otherwise Error(condition, "the expression cannot be converted to a 'bool'")
{
  <[
    match ($condition)
    {
      | true  => $trueExpr;
      | false => $falseExpr; // второе сообщение получается в результате типизации выражений в рамках match-а
    }
  ]>
}

tast TypedStringIf : TypedExpression
for If
{
    trueType      = trueExpression.ExpressionType;//Локальные переменные.
    falseType     = falseExpression.ExpressionType;//Для краткости.
    conditionType = condition.ExpressionType;

    ConvertibleTo(conditionType, type(string))
        @@@ $"Type of condition must be convertible to string. But $conditionType not convertible to string." condition.Location;

    Unify([trueType, falseType], ExpressionType)
        @@@ $"Typef of branches must be competible. $trueType and $falseType incompatible" this.Location;
}
rewrite
{
    <[
        match ($condition)
        {
            | null | "" => $falseExpression;
            | _         => $trueExpression;
        }
    ]>
}
//задаем приоритет нашему расширению меньше чем стандартному if'у.
order TypedStringIf < TypedIf;

  macro @?. (expr1, expr2)
  {
    def makeMemberAccess(loc, n) { PExpr.Member(loc,  <[ e1 ]>, Splicable.Name(loc, n)) }
    def makeComplation  (loc, n) { PExpr.Member(loc,  <[ e1 ]>, Splicable.HalfId(loc, n)) }
    def loc = expr2.Location;
    def e2 = 
      match (expr2)
      {
        | Ref(n)                    => makeMemberAccess(loc, n)
        | Call(Ref(n), parms)       => PExpr.Call(loc, makeMemberAccess(loc, n), parms)
        | Indexer(Ref(n), parms)    => PExpr.Indexer(loc, makeMemberAccess(loc, n), parms)
        | ToComplete(n)             => makeComplation(loc, n)
        | Call(ToComplete(n), _)    => makeComplation(loc, n)
        | Indexer(ToComplete(n), _) => makeMemberAccess(loc, n)
        | _ => Message.FatalError(expr2.Location, $"The expression of this ($(expr2.GetType())) type not supported with operator '?.'");
      };

    <[ 
      def e1 = $expr1;
      
      if (e1 == null)
        $(Typedtree.TExpr.DefaultValue() : typed)
      else
        $e2
    ]>
  }

26.7.1 Query expression translation

The C# 3.0 language does not specify the exact execution semantics of query expressions. Rather, C# 3.0 translates query expressions into invocations of methods that adhere to the query expression pattern. Specifically, query expressions are translated into invocations of methods named Where, Select, SelectMany, OrderBy, OrderByDescending, ThenBy, ThenByDescending, and GroupBy that are expected to have particular signatures and result types, as described in §26.7.2. These methods can be instance methods of the object being queried or extension methods that are external to the object, and they implement the actual execution of the query.

The translation from query expressions to method invocations is a syntactic mapping that occurs before any type binding or overload resolution has been performed. The translation is guaranteed to be syntactically correct, but it is not guaranteed to produce semantically correct C# code. Following translation of query expressions, the resulting method invocations are processed as regular method invocations, and this may in turn uncover errors, for example if the methods do not exist, if arguments have wrong types, or if the methods are generic and type inference fails.
The translation of query expressions is demonstrated through a series of examples in the following. A formal description of the translation rules is provided in a later section.

WH>Так и знал что ты опять начнешь докапываться до синтаксиса который сочиняется на ходу.

macro module Nemerle
{
  macro ForEach : Ast.Expression
    syntax: "foreach" "(" pattern "in" collection ")" body
      where: pattern    = Ast.PatternWithGuard,
             collection = Ast.Expression,
             body       = Ast.Expression;
    require: IsTyped(collection) // требуем чтобы перед вызовом тела макроса был типизирован параметр collection
  {
    match (GetKind(collection.Type))
    {
      | TypeKind.Array        => IterateByArrayImpl(pattern, collection, body)
      | TypeKind.List         => IterateByListImpl(pattern, collection, body)
      | TypeKind.IEnumarableT => IterateByIEnumarableTImpl(pattern, collection, body)
      | TypeKind.IEnumarable  => IterateByIEnumarableImpl(pattern, collection, body)
      | _                     => TryIterateByEnumaratorPatternImpl(pattern, collection, body)
    }
  }

  IterateByArrayImpl(pattern : Ast.PatternWithGuard, collection : Ast.Expression, body : Ast.Expression) : Ast.Expression
  {
    match (pattern)
    {
      | <[ $(x : name) ]> => // pattern - это просто имя переменной (простой случай)
        <[ Nemerle: // указываем, что квази-цитата задается в грамматике Nemerle. 
           def loop(i : int, ary) : void
           {
             when (i < ary.Lenght)
             {
               def $x = ary[i];
               $body;
               loop(i + 1, ary)
             }
           } 

           loop(0, $collection);
        ]>
      ... // случаи с применением паттерн-матчинга опущены
    }
  }
  ...
}

  macro @lock : Ast.Expression
    syntax "lock" "(" lockOnExpr ")" body
    require: IsTyped(lockOnExpr)
  {
    if (lockOnTExpr.Type.IsValueType)
      Error (lockOnExpr, $"`$(lockOnTExpr.Type)' is not a reference type as required by the lock expression")
    else
      <[
        def toLock = $(lockOnTExpr : typed);
        System.Threading.Monitor.Enter(toLock);
        try { $body }
        finally { System.Threading.Monitor.Exit(toLock); }
      ]>
  }