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
      }
    }

require: collection as x && !x.IsPrimitive // "x" новая переменная типа равная типу collection
require: x has method GetEnumerator() : e // проверяем соответствие паттерну "перечислитель"

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

RewriteForeachBody(fe : ForEach) : Expression
{
    def body = match (fe.Body)
    {
        | body is Expression => body
        | body is MatchBody  => <[ match (item) $body ]>
    }
    match (fe.pattern)
    {
        | pattern is VarPattern =>
            <[
                def $(pattern.Name) = item;
                $body
            ]>

        | pattern =>
            <[
                match (item)
                {
                    | $(pattern) => $body
                    | _          => ()
                }
            ]>
    }
}

rewriter GenericIEnumirableForEach for ForEach
when ConvertibleTo(collection.Type, IEnumerable[_]);
{
    <[
        using (enum = ($collection).GetEnumerator())
        {
            while (enum.MoveNext())
            {
                def item = enum.Current;
                $(RewriteForeachBody(this));
            }
        }
    ]>
}

    CollectionItemType(collection.Type, ItemType) else
        error "collection in foreach must be an array or type implementing enumerator pattern"
        hint "try specifing the type directly using 'expr : SomeType'";

  public variant Pattern : Located
  {
    | Wildcard
    | As          { pat : Pattern; decl : LocalValue; }
    | HasType     { typ : FixedType; }
    | Tuple       { args : list [Pattern]; }
    | Record      { args : list [IMember * Pattern]; }
    | Application { name : TypeInfo; arg : Pattern; }
    | Enum        { fld : IField; val : Nemerle.Compiler.Literal; }
    | Literal     { lit : Nemerle.Compiler.Literal; }
    | Error

match (x)
{
  | pattern1 => e1
  | pattern2 => e2
}

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.

WH>    CollectionItemType(collection.Type, ItemType) else
WH>        error "collection in foreach must be an array or type implementing enumerator pattern"
WH>        hint "try specifing the type directly using 'expr : SomeType'";
WH>