VD>    public FoldLeft[T](
VD>      [NotNull] this arr : array[T],
VD>      [NotNull] f : T * T -> T
VD>    ) : T
VD>

["a", "b", "c"].FoldLeft("", _+_) == (("" + "a") + "b") + "c" == "abc"

["a", "b", "c"].FoldLeft("", _+_) == "c" + ("b" + ("a" + "")) == "cba"

аккумулятор * элемент -> аккумулятор

[1, 2, 3].FoldRight([], _::_) == 1 :: (2 :: (3 :: [])) == [1, 2, 3]

    public Update (key : TKey, defaultValue : TValue, updateFn : TValue -> TValue) : Hashtable [TKey, TValue]
    {
      mutable value;

      unless (TryGetValue (key, out value))
        value = defaultValue;

      this[key] = updateFn(value);

      this;
    }

    public Update (key : TKey, newValue : void -> TValue, updateFn : TValue -> TValue) : Hashtable [TKey, TValue]
    {
      mutable value;

      unless (TryGetValue (key, out value))
        value = newValue();

      this[key] = updateFn(value);

      this;
    }

      def transitions = fsm.Transitions.Fold(Hashtable(), (transition : Transition, transitions) =>
        transitions.Update((transition.From, transition.To), (RangeSet(), false, false), (chars, end, epsilon) =>
          match (transition)
          {
          | Symbol(ch) => (ch.Sum(chars), end, epsilon);
          | End        => (chars, true, epsilon);
          | Epsilon    => (chars, end, true);
          }
        )
      );

      def transitions = fsm.Transitions.Fold(Hashtable(), (transition : Transition, transitions) =>
      {
        def key = (transition.From, transition.To);
        def (chars, end, epsilon) = match (transitions.Get(key))
        {
        | Some(value) => value;
        | None => (RangeSet(), false, false);
        }
        match (transition)
        {
        | Symbol(ch) => transitions[key] = (ch.Sum(chars), end, epsilon);
        | End        => transitions[key] = (chars, true, epsilon);
        | Epsilon    => transitions[key] = (chars, end, true);
        }
        transitions
      });

    public Map2ToArray[First, Second, Result](
      [NotNull] this first  : Seq[First],
      [NotNull]      second : Seq[Second],
      [NotNull]      func   : First * Second -> Result
    )
      : array[Result]
    {
      match (first, second)
      {
        | (f is array[First], s is array[Second]) => Map2ToArray(f, s, func)
        | (f is SCG.ICollection[First], s is SCG.ICollection[Second]) => Map2ToArray(f.NToArray(), s.NToArray(), func)
        | (f is list[First], s is list[Second]) =>
           def foldFunc(left, right, (arr, index))
           {
             arr[index] = func(left, right);
             (arr, index + 1)
           }

           def (result, _) = f.FoldLeft2(s, (array(f.Length), 0), foldFunc);
           result

        | _ =>
          using (e1 = first.GetEnumerator(), e2 = second.GetEnumerator())
          {
            def loop (result) : array[Result]
            {
              match (e1.MoveNext(), e2.MoveNext())
              {
                | (true,   true) => result.Add(func(e1.Current, e2.Current)); loop(result)
                | (false, false) => result.NToArray()
                | (true,  false)
                | (false,  true) => throw System.ArgumentException("Collections must have the same length", "first, second");
              }
            }

            loop(SCG.List()).NToArray();
          }
      }
    }

    public Map2ToArray[First, Second, Result](
      [NotNull] this first : array[First],
      [NotNull] second : array[Second],
      [NotNull] func: First * Second -> Result
    )
      : array[Result]
    {
      when (first.Length != second.Length)
        throw System.ArgumentException("Collections must have the same length", "first, second");

      def result = array(first.Length);

      foreach (i in[0 .. first.Length - 1])
        result[i] = func(first[i], second[i]);

      result;
    }

    ...

mutable min = recSets.NFirst();

foreach (s in recSets.Skip(1))
  when (HashSet(min).IsSupersetOf(HashSet(s)))
    min = s;

K>| Cons(_) @ cons => cons.Foo() // - вызываем метод варианта Cons
K>

| Cons(_) as cons => cons.Foo() // - вызываем метод варианта Cons

def processItem(item)
{
  //код обработки отдельного айтема вынесен чтобы не захламлять основной алгоритм
}

// основной алгоритм
...
items.Iter(processItem);
...

foreach (item in items)
  processItem(item)

apply processItem on items;

    public FoldLeft[T](
      [NotNull] this arr : array[T],
      [NotNull] f : T * T -> T
    ) : T

a.Iter(WriteLine);

foreach (i in a)
 WriteLine(i);

    public FoldLeftI[TAccumulator, T](
      [NotNull] this lst : list[T],
      mutable   acc      : TAccumulator,
      [NotNull] f        : int * TAccumulator * T -> TAccumulator
    ) : TAccumulator
    {
      foreach (value in lst with i)
        acc = f(i, acc, value);
      acc
    }

    #warning not commented
    #warning not tested
    public Concatenate[T](
      [NotNull] this lists : list[list[T]],
    ) : list[T]
    {
      $[ item | items in lists, item in items ]
    }

source.Map(f).CatOptions()

$[ x | Some(x) in $[ f(y) | y in source ]]

def loop(_)
{
    | ([], r)      => r
    | (x :: xs, r) => match(f(x)) {
        | Some(y) => loop(xs, y :: r)
        | None()  => loop(xs, r)
    }
}
loop(source, []).Rev()

def loop(lst, res)
{
    match(lst) {
        | []      => res
        | x :: xs => match(f(x)) {
            | Some(y) => loop(xs, y :: res)
            | None()  => loop(xs, res)
        }
    }
}
loop(source, []).Rev()

| Cons(_) @ cons => cons.Foo() // - вызываем метод варианта Cons

match(lst) {
    | Cons(_) with cons = lst :> InitCell => cons.Foo()

K>| Cons(_) @ cons => cons.Foo() // - вызываем метод варианта Cons
K>

| Cons(_) as cons => cons.Foo() // - вызываем метод варианта Cons

    public Tail[T](
      [NotNull] this source : Seq[T]
    ) : Seq[T]
    {
      match(source) {
        | source is LazyIterator[T] => source.Tail()
        | _                         => source.TailSeq()
      }
    }

| source is LazyIterator => ...

case source: LazyIterator => ...

def s = "";

def test1 = if (s is string) true else false; // test1 : bool
def test2 = s is string;                           // test2 : string

Z>хм... был уверен, что булево а почему оно не возвращает bool? мне видится код ниже нелогичным, есть какие-то причины?

Z>def s = "";

Z>def test1 = if (s is string) true else false; // test1 : bool
Z>def test2 = s is string;                           // test2 : string
Z>

using System.Console;

def value : option[_] = Some(1);

WriteLine(value is Some(_)); // True
WriteLine(value is Some(1)); // True
WriteLine(value is Some(2)); // False

using System.Console;

def value : option[_] = Some(1);

when (value is Some(x))
  WriteLine(x); // 1

Z>эх... нужна внятная дока и спека по языку

Z>хм... был уверен, что булево а почему оно не возвращает bool? мне видится код ниже нелогичным, есть какие-то причины?

Z>def s = "";

Z>def test1 = if (s is string) true else false; // test1 : bool
Z>def test2 = s is string;                           // test2 : string
Z>

def s : object = "";

def test1 = if (s is string) true else false; // test1 : bool
def test2 = s is string;

WriteLine(test1.GetType());
WriteLine(test2.GetType());

i in [0 .. arr.MaxIndex()]

i in [0 .. arr.Length-1]