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

    ...

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

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]

mutable min = recSets.NFirst();

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