const int Original = 4;
const double             
    N2 = 0.1,
    N3 = 3.5;
const int N = (int)(( (Original+N2)*N3 - N2*N3) / N3);        
                
int Func()
{
    if (N == Original)
       return 0;
}

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

either have no solutions or have one solution, then that mode is semideterministic(semidet);

WH>

    require: IsTyped(collection) // требуем чтобы перед вызовом тела макроса был типизирован параметр collection

  macro ForEachOnArray : Ast.Expression
    syntax: "foreach" "(" pattern "in" collection ")" body
      where: pattern    = Ast.PatternWithGuard,
             collection = Ast.Expression,
             body       = Ast.Expression;
    require: GetKind(collection.Type) == TypeKind.Array
  {
    <[ /* реализация для массива */ ]>
  }

  macro ForEachOnArray : Ast.Expression
    syntax: "foreach" "(" pattern "in" collection ")" body
      where: pattern    = Ast.PatternWithGuard,
             collection = Ast.Expression,
             body       = Ast.Expression;
    require: GetKind(collection.Type) == TypeKind.IEnumarableT
  {
    <[ /* реализация для IEnumarable[T] */ ]>
  }
...

def expr2 = 
  match (expr1)
  {
    | <[ $call(..$parms) ]> => <[ $call(..$parms) ]>
    ...
  };

Я уже говорил тебе, что не буду ничего обсуждать до предъявления тобой прсевдокода реализаций foreach, linq и PegGrammar с объяснением того что дает такая реализация.

  macro ForEach : Ast.Expression
    syntax: "foreach" "(" pattern "in" collection ")" body
      where: pattern    = Ast.PatternWithGuard,
             collection = Ast.Expression,
             body       = Ast.Expression;
    require: collection.Type as X && !X.IsPrimitive
    require: X has <[ method GetEnumerator() : E ]>
  {
    <[ /* реализация по умолчанию реализующая паттерн "перечислитель" */ ]>
  }

  // Перегрузка макры ForEach. 
  macro ForEachIEnumarableT overload ForEach
    require: collection.Type is IEnumarable[_]
    priority: < ForEach // Срабатывает только если не срабатывает основной вариант
  {
    <[ /* реализация для IEnumarable[T] */ ]>
  }
  ...
  // Где-то в другом месте... возможно в другой сборке...
  // Так как тип array[_] более конкретный нежели IEnumarable[_], то для массивов 
  // срабатывает именно эта перегрузка!
  macro ForEachArray overload ForEach
    require: collection.Type is array[_]
    priority: < ForEach
  {
    <[ /* реализация для массива */ ]>
  }

              Message.HintOnce ("this means two branches of ``if'' or "
                                "``match'' have different types"));

abstract ast Expression
{
    Type : out ExpressionType;
}

abstract ast Literal
{
    Type : out ExpressionType;
}

abstract ast Pattern
{
    InType : in ExpressionType;
    Type : out PatternType;
}

ast LiteralExpression : Expression
{
    syntax literal;
    literal : Literal;
}
typing
{
    Type = literal.Type;
}

ast LiteralExpression : Expression
{
    syntax literal;
    literal : Literal;
}

tast TypedLiteralExpression for LiteralExpression
{
    Type = literal.Type;
}

ast LiteralPattern : Pattern
{
    syntax literal;
    literal : Literal;
}
typing
{
    ConvertibleTo(InType, literal.Type)
        @@@ $"Can't match $InType over $(literal.Type)."; // Если Location не указан то берется this.Location
    Type = PatternType(); // Пустой словарь ибо литерл не производит никакого связывания.
}

ast RoundsPattern : Pattern
{
    syntax "(" pattern ")";
    pattern : Pattern;
}
typing
{
    InType = pattern.InType;//Просто передаем входной тип во вложенный паттерн.
    Type = pattern.Type;//Возвращаем тип вложенного паттерна.
}

ast OrPattern : Pattern
{
    syntax lPattern "|" rPattern;
    lPattern : Pattern;
    rPattern : Pattern;
}
typing
{
    lPattern.InType = InType;
    rPattern.InType = InType;

    lPattern.Type = rPattern.Type
        @@@ $"Patterns must return same set of values.";
    Type = lPattern.Type;
}

//Позволяет одно и тоже выражение разобрать разными паттернами
ast AndPattern : Pattern
{
    syntax lPattern "&" rPattern;
    lPattern : Pattern;
    rPattern : Pattern;
}
typing
{
    lPattern.InType = InType;
    rPattern.InType = InType;

    AddPatterns([lPattern.Type, rPattern.Type], Type)
        @@@ "Names in patterns must not intersect.";
}

ast VarPattern : Pattern
{
    syntax name;
    name : Identifier;
}
typing
{
    Type = PatternType(name, InType);
}

ast AsPattern : Pattern
{
    syntax pattern "as" name;
    name : Identifier;
    pattern : Pattern;
}
typing
{
    pattern.InType = InType;
    exprType = PatternType(name, InType);
    AddPatterns([pattern.Type, exprType], Type)
        @@@ "Names in patterns must not intersect.";
}

8.8.4 The foreach statement

The foreach statement enumerates the elements of a collection, executing an embedded statement for each element of the collection.
foreach-statement:

foreach ( local-variable-type identifier in expression ) embedded-statement

The type and identifier of a foreach statement declare the iteration variable of the statement. If the var keyword is given as the local-variable-type, the iteration variable is said to be an implicitly typed iteration variable, and its type is taken to be the element type of the foreach statement, as specified below. The iteration variable corresponds to a read-only local variable with a scope that extends over the embedded statement. During execution of a foreach statement, the iteration variable represents the collection element for which an iteration is currently being performed. A compile-time error occurs if the embedded statement attempts to modify the iteration variable (via assignment or the ++ and operators) or pass the iteration variable as a ref or out parameter.
The compile-time processing of a foreach statement first determines the collection type, enumerator type and element type of the expression. This determination proceeds as follows:
• If the type X of expression is an array type then there is an implicit reference conversion from X to the System.Collections.IEnumerable interface (since System.Array implements this interface). The collection type is the System.Collections.IEnumerable interface, the enumerator type is the System.Collections.IEnumerator interface and the element type is the element type of the array type X.

• Otherwise, determine whether the type X has an appropriate GetEnumerator method:
o Perform member lookup on the type X with identifier GetEnumerator and no type arguments. If the member lookup does not produce a match, or it produces an ambiguity, or produces a match that is not a method group, check for an enumerable interface as described below. It is recommended that a warning be issued if member lookup produces anything except a method group or no match.
o Perform overload resolution using the resulting method group and an empty argument list. If overload resolution results in no applicable methods, results in an ambiguity, or results in a single best method but that method is either static or not public, check for an enumerable interface as described below. It is recommended that a warning be issued if overload resolution produces anything except an unambiguous public instance method or no applicable methods.
o If the return type E of the GetEnumerator method is not a class, struct or interface type, an error is produced and no further steps are taken.
o Member lookup is performed on E with the identifier Current and no type arguments. If the member lookup produces no match, the result is an error, or the result is anything except a public instance property that permits reading, an error is produced and no further steps are taken.
o Member lookup is performed on E with the identifier MoveNext and no type arguments. If the member lookup produces no match, the result is an error, or the result is anything except a method group, an error is produced and no further steps are taken.
o Overload resolution is performed on the method group with an empty argument list. If overload resolution results in no applicable methods, results in an ambiguity, or results in a single best method but that method is either static or not public, or its return type is not bool, an error is produced and no further steps are taken.
o The collection type is X, the enumerator type is E, and the element type is the type of the Current property.

• Otherwise, check for an enumerable interface:
o If there is exactly one type T such that there is an implicit conversion from X to the interface System.Collections.Generic.IEnumerable<T>, then the collection type is this interface, the enumerator type is the interface System.Collections.Generic.IEnumerator<T>, and the element type is T.
o Otherwise, if there is more than one such type T, then an error is produced and no further steps are taken.
o Otherwise, if there is an implicit conversion from X to the System.Collections.IEnumerable interface, then the collection type is this interface, the enumerator type is the interface System.Collections.IEnumerator, and the element type is object.
o Otherwise, an error is produced and no further steps are taken.
The above steps, if successful, unambiguously produce a collection type C, enumerator type E and element type T. A foreach statement of the form

foreach (V v in x) embedded-statement
is then expanded to:
{
    E e = ((C)(x)).GetEnumerator();
    try {
        V v;
        while (e.MoveNext()) {
            v = (V)(T)e.Current;
            embedded-statement
        }
    }
    finally {
        … // Dispose e
    }
}

The variable e is not visible to or accessible to the expression x or the embedded statement or any other source code of the program. The variable v is read-only in the embedded statement. If there is not an explicit conversion (§6.2) from T (the element type) to V (the type in the foreach statement), an error is produced and no further steps are taken. If x has the value null, a System.NullReferenceException is thrown at run-time.
An implementation is permitted to implement a given foreach-statement differently, e.g. for performance reasons, as long as the behavior is consistent with the above expansion.
The body of the finally block is constructed according to the following steps:
• If there is an implicit conversion from E to the System.IDisposable interface, then the finally clause is expanded to the semantic equivalent of:

finally {
    ((System.IDisposable)e).Dispose();
}

except that if e is a value type, or a type parameter instantiated to a value type, then the cast of e to System.IDisposable will not cause boxing to occur.
• Otherwise, if E is a sealed type, the finally clause is expanded to an empty block:

finally {
}

• Otherwise, the finally clause is expanded to:

finally {
    System.IDisposable d = e as System.IDisposable;
    if (d != null) d.Dispose();
}

The local variable d is not visible to or accessible to any user code. In particular, it does not conflict with any other variable whose scope includes the finally block.
The order in which foreach traverses the elements of an array, is as follows: For single-dimensional arrays elements are traversed in increasing index order, starting with index 0 and ending with index Length – 1. For multi-dimensional arrays, elements are traversed such that the indices of the rightmost dimension are increased first, then the next left dimension, and so on to the left.
The following example prints out each value in a two-dimensional array, in element order:

using System;
class Test
{
    static void Main() {
        double[,] values = {
            {1.2, 2.3, 3.4, 4.5},
            {5.6, 6.7, 7.8, 8.9}
        };
        foreach (double elementValue in values)
            Console.Write("{0} ", elementValue);
        Console.WriteLine();
    }
}

The output produced is as follows:
1.2 2.3 3.4 4.5 5.6 6.7 7.8 8.9
In the example
int[] numbers = { 1, 3, 5, 7, 9 };
foreach (var n in numbers) Console.WriteLine(n);
the type of n is inferred to be int, the element type of numbers.

macro ForEac 
  syntax "foreach" "(" var "in" collection ")" body;
  where var        = VariableDeclarationExpression,
        collection = Expression,
        body       = Expression;
{
  ...
}

for (mutable i = 0; i < collection.Length; i++)
{
  def $var = collection[i];
  $body
}

def x = collection.Type.Lookup(<[ GetEnumerator() : _ ]>).TerurnType;
assert(x != null);
def moveNext = x.Lookup(<[ MoveNext() : bool ]>);
assert(moveNext != null);

def current = x.Lookup(<[ Current : _ ]>);
assert(current != null);

var.Type = current.Type;

def e = $collection.GetEnumerator();
try
{
  $body
  while (e.MoveNext())
  {
    def $var = e.Current;
    $body
  }
}
finally
{
  ... // Dispose e
}

def e = ($collection :> IEnumerable[_]).GetEnumerator();
try
{
  $body
  while (e.MoveNext())
  {
    def $var = e.Current;
    $body
  }
}
finally
{
  ... // Dispose e
}

    resolve(name, далее объяснения как его искать и куда девать найденную информацию)

VD>Ой, надо прикопать это письмо. Я тебе потом покажу реальный код этого дела и тебе станет стыдно.

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


//Предикат, который достает тип элемента коллекции.
//Предикат объявлен абстрактным, чтобы его можно было расширять
//Это позволит реализовать этот предикат для коллекций, у которых нет IEnumirable
abstract pred CollectionItemType(collectionType : Type :: in, itemType : Type :: out) is nondet;

//Конкретный предикат.
pred GenericIEnumirableItemType(collectionType, itemType) extends CollectionItemType
{
    ConvertibleTo(collectionType, type);//Перебираем типы
    IEnumerable[itemType] = type;//Проверяем есть ли среди них IEnumerable[_] и связываем itemType
}
//Как вариант можно написать так:
//ConvertibleTo(collectionType, IEnumerable[itemType]);


pred IEnumirableItemType(collectionType, itemType) extends CollectionItemType
{//Тут все тоже самое
    ConvertibleTo(collectionType, type);
    IEnumerable = type;
    itemType = object;//Только возвращаем всегда object.
}

//Задаем порядок.
//Если GenericIEnumirableItemType нашол ответ то IEnumirableItemType проверяться не будет
order IEnumirableItemType < GenericIEnumirableItemType;

//При желании можно воткнуть что-то между ними
order IEnumirableItemType < MyCollectionItemType < GenericIEnumirableItemType;

ast ForEach : Expression
{
    syntax "foreach" "(" pattern "in" collection ")" body;
    pattern    : Pattern;
    collection : Expression;
    body       : Expression;
}
typing
{
    CollectionItemType(collection.Type, pattern.InType);
    newscope body add VarsFromPatternType(pattern.Type);
    ConvertibleTo(body.Type, #void);
    Type = #void;
}

match (x)
{
  | var is SomeType => $body
  | _ => ()
}

def var = ...

match (var)
{
  ..$body
}

    // build the body of loop (may contain additional matching)
    def build_definition(val)
    {
      match (body)
      {
        | <[ match ($(null)) { ..$cases } ]> =>
          match (iter)
          {
            | <[ $(x : name) ]> when char.IsLower(x.Id[0]) | <[ (..$_) ]> => ()
            | _ => Message.FatalError("only simple names available in pattern of foreach with direct matching")
          }

          <[ def $iter = $val;
             match ($iter) { ..$cases } ]>

        | _ =>
          def mat =
            match (iter)
            {
              | <[ $pat :> $ty ]> => <[ match ($val :> $ty) { | $pat  => $body; () | _ => () } ]>
              | _                 => <[ match ($val)        { | $iter => $body; () | _ => () } ]>
            };
          mat.cases.Iter (fun (x : PT.MatchCase) { x.disable_warnings = true });
          mat
      }
    }