K>    public Compare['a, 'b](
K>      a : SCG.IEnumerable['a],
K>      b : SCG.IEnumerable['b],
K>      f : 'a * 'b -> int ) : int
K>    {
K>      def first = a.GetEnumerator();
K>      def second = b.GetEnumerator();
K>      def loop()
K>      {
K>        match ((first.MoveNext(), second.MoveNext()))
K>        {
K>          | (false, false) => 0
K>          | (true, false)  => 1
K>          | (false, true)  => -1
K>          | (true, true)   =>
K>            match (f(first.Current, second.Current))
K>            {
K>              | 0 => loop()
K>              | x => x
K>            }
K>        }
K>      }
K>      def r = loop();
K>      first.Dispose();
K>      second.Dispose();
K>      r
K>    }

public Compare['a, 'b](
  a : SCG.IEnumerable['a],
  b : SCG.IEnumerable['b],
  f : 'a * 'b -> int ) : int
  {
    using(def first = a.GetEnumerator(),
            def second = b.GetEnumerator())
        {
            def loop()
            {
                match ((first.MoveNext(), second.MoveNext()))
                {
                    | (false, false) => 0
                    | (true, false)  => 1
                    | (false, true)  => -1
                    | (true, true)   =>
                        match (f(first.Current, second.Current))
                            {
                                | 0 => loop()
                                | x => x
                            }
                }
            }
            loop()
    }
  }

K>    public Compare['a](
K>      a : SCG.IEnumerable['a],
K>      b : SCG.IEnumerable['a]) : int where 'a : System.IComparable['a]
K>    {
K>      def compare(a, b)
K>      {
K>        a.CompareTo(b)
K>      }
K>      Compare(a, b, compare)
K>    }

Compare(a, b, (a,b) => a.CompareTo(b))

Compare(a, b, _.CompareTo(_))

K>    public Reduce['a, 'b](
K>      iter : SCG.IEnumerable['a],
K>      f : 'b * 'a -> 'b,
K>      s : 'b) : 'b

FoldLeft[A, B](this source : IEnumerable[B], ini : A, f : B * A -> A) : A;
FoldRight[A, B](this source : IEnumerable[B], ini : A, f : B * A -> A) : A;
Fold[A, B](this source : IEnumerable[B], ini : A, f : B * A -> A) : A;

ToArray[T](this source : IEnumerable[T]) : array[T];

From[T](this arr : array[T], iter : IEnumerable[T])
{
    mutable i = 0;
    using(def it = iter.GetEnumerator())
        while(it.MoveNext() && (i < arr.Length))
        {
            arr[i] = it.Current;
            i++;
        }
}

public static Iter[T](this source : IEnumerable[T], f : T -> void) : void
{
  foreach(elem in source)
    f(elem)
}

public static Zip['a,'b](ia : IEnumerable['a], ib : IEnumerable['b]): IEnumerable['a * 'b]
{
  using(def first = ia.GetEnumerator(), def second = ib.GetEnumerator())
    while(first.MoveNext() && second.MoveNext())
      yield (first.Current, second.Current)
}

K>def lazy5() : IEnumerable[int] 
K>{ 
K>  while(true) yield 5; 
K>}
K>

K>def lazy5 = () => while(true) yield 5;
K>

K>public lazyFive() : IEnumerable[int] 
K>{ 
K>  while(true) yield 5; 
K>}
K>

def it = iter(n) {inf yield n};

K>>public static Iter[T](this source : IEnumerable[T], f : T -> void) : void
K>>{
K>>  foreach(elem in source)
K>>    f(elem)
K>>}
K>>

using(def sw = File.CreateText("result.txt"))
Directory("c:\logs").Files("*.log").Lines().SMatch("Klapaucius").Iter(sw.WriteLine);

using(def sw = File.CreateText("result.txt"))
foreach(elem in Directory("c:\logs").Files("*.log").Lines().SMatch("Klapaucius"))
  sw.WriteLine(elem);

Lines(this files : IEnumerable[FileInfo]) : IEnumerable[string]

Lines(this file : FileInfo) : IEnumerable[string]

Directory("c:\logs").Files("*.log").LMap(_.Lines()).Flatten().SMatch("Klapaucius").WriteTo("result.txt"));

Flatten[T](this source : IEnumerable[IEnumerable[T]]) : IEnumerable[T]
{
  foreach(seq in source)
    foreach(elem in seq)
      yield elem
}

K>using(def sw = File.CreateText("result.txt"))
K>Directory("c:\logs").Files("*.log").Lines().SMatch("Klapaucius").Iter(sw.WriteLine);
K>

Go(x);
Go(y.Iter);

class TwoList[T]
{
A:list[T];
b:list[T];
TwoList(a, b){this.A=a;this.B=b;}
Revert(){TwoList[T](B,A)}
}

public static class Sequence
{
  /// <summary>
  /// Функция возвращает "плоское" представление иерархии объектов.
  /// </summary>
  /// <typeparam name="T">Тип, общий для всех элементов иерархии.</typeparam>
  /// <param name="items">Набор "корневых" элементов.</param>
  /// <param name="selector">Функтор, возвращающий набор элементов, связанный с переданным ему элементом.</param>
  /// <returns>Рекурсивный набор всех элементов, включая переданный набор <paramref name="items"/>.</returns>
  public static IEnumerable<T> SelectRecursively<T>(IEnumerable<T> items, Function<T, IEnumerable<T>> selector) {
    foreach(T item in items) {
      yield return item;
      foreach(T x in SelectRecursively(item, selector)) {
        yield return x;
      }//for
    }//for
  }

  /// <summary>
  /// Функция возвращает "плоское" представление иерархии объектов.
  /// </summary>
  /// <typeparam name="T">Тип, общий для всех элементов иерархии.</typeparam>
  /// <param name="item">"Корневой", или даже "стартовый", элемент иерархии.</param>
  /// <param name="selector">Функтор, возвращающий набор элементов, связанный с переданным ему элементом.</param>
  /// <returns>Рекурсивный набор всех элементов, включая переданный элемент <paramref name="item"/>.</returns>
  public static IEnumerable<T> SelectRecursively<T>(T item, Function<T, IEnumerable<T>> selector) {
    foreach(T x in selector(item)) {
      yield return x;
      foreach(T y in SelectRecursively(x, selector)) {
        yield return y;
      }//for
    }//for
  }
}

public static class PageUtils
{
  /// <summary>
  /// Функция возвращает (рекурсивно) все дочернии элементы переданного ей элемента управления, имеющие тип <typeparamref name="T"/>.
  /// </summary>
  /// <typeparam name="T">Тип возвращаемых элементов управления. Так же является "фильтром" результирующего множества.
  /// Обычно, это либо тип <see cref="T:Control"/> (тогда возвращаются все дочернии элементы управления), 
  /// либо интерфейс, который должен поддерживать дочерний элемент управления для того, что бы попасть в результирующий набор.</typeparam>
  /// <param name="control">"Корневой" элемент иерархии.</param>
  /// <returns>Рекурсивный список элементов управления, являющихся дочерним для <paramref name="control"/>.</returns>
  public static IEnumerable<T> Childs<T>(Control control) where T : class {
    if(control == null) {
      throw new ArgumentNullException("control");
    }//if

    Function<Control, IEnumerable<Control>> selector = delegate(Control item) {
      if(item is T) {
        return Sequence.Empty<Control>(); // Пустая последовательность
      }//if

      return Sequence.Cast<Control>(item.Controls); // Каждый элемент преобразуется к Control
    };

    return Sequence.OfType<T>(Sequence.SelectRecursively(control, selector)); // OfType: только элементы заданного (T) типа.
  }

  /// <summary>
  /// Возвращает рекурсивный список дочерних элементов управления.
  /// </summary>
  /// <param name="control">"Корневой" элемент иерархии.</param>
  /// <returns>Рекурсивный список элементов управления, являющихся дочерним для <paramref name="control"/>.</returns>
  public static IEnumerable<Control> Childs(Control control) {
    if(control == null) {
      throw new ArgumentNullException("control");
    }//if

    Function<Control, IEnumerable<Control>> selector = delegate(Control item) {
      return Sequence.Cast<Control>(item.Controls);
    };

    return Sequence.SelectRecursively(control, selector);
  }
}

[Record]
class TwoList[T]
{
  A: list[T];
  B: list[T];
  
  public Revert() : TwoList[T] { TwoList.[T](B,A) }
  
  public override ToString() : string { $"TwoList: A = $A, B = $B" }
}

System.Console.WriteLine($"Revert of TwoList([1],[2]) is $(TwoList([1],[2]).Revert())");

  /// <summary>
  /// Функция возвращает "плоское" представление иерархии объектов.
  /// </summary>
  /// <typeparam name="T">Тип, общий для всех элементов иерархии.</typeparam>
  /// <param name="roots">Набор "корневых" элементов.</param>
  /// <param name="getChildren">Функтор, возвращающий набор элементов, связанных с переданным ему элементом.</param>
  /// <returns>Итератор, перебирающий набор всех доступных через <paramref name="getChildren"> элементов, включая переданный набор <paramref name="items"/>.</returns>
    /// <remarks>Внимание! Несмотря на то, что функция имеет ленивую семантику, крайне не рекомендуется передавать в нее структуры, содержащие циклы. Используйте подходящую версию функции Traverse* для обхода произвольных графов объектов.</remarks>
  public static IEnumerable<T> TraverseTree<T>(IEnumerable<T> roots, Function<T, IEnumerable<T>> getChildren) {
    foreach(T root in roots) {
      yield return root;
      foreach(T item in SelectRecursively(root, getChildren))
        yield return item;
    }
  }

1.2.0 alpha rev. 655

public static IEnumerable<T> TraverseTree<T>(IEnumerable<T> roots, Function<T, IEnumerable<T>> getChildren, Action<T> action) {
  foreach(T root in roots) {
    action(root);
    TraverseTree(getChildren(root), getChildren, action);
  }//for
}