using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Diagnostics;

namespace Test
{
    public static class ListExt
    {
        public static void Walk<T>(this List<T> source, Action<T> predicate)
        {
            foreach (var v in source)
                predicate(v);
        }

        public static IEnumerable<T> Walk<T>(this List<T> source)
        {
            foreach (var v in source)
                yield return v;
        }
    }

    class Program
    {
        public static void Test(string desc, Action act)
        {
            var watch = new Stopwatch();
            GC.Collect();
            watch.Start();
            for (int i = 0; i < 300; ++i)
                act();
            watch.Stop();
            Console.WriteLine("{0}: {1}", desc, watch.ElapsedMilliseconds);
        }

        static void Main(string[] args)
        {
            int n = 50000;
            var list = new List<long>(n);
            for (int i = 0; i < n; ++i)
                list.Add(i);

            long sum;

            sum = 0;
            Test("Plain 'Sum' ", delegate()
            {
                sum = list.Sum();
            });

            sum = 0;
            Test("foreach     ", delegate()
            {
                foreach (var v in list)
                    sum += v;
            });

            sum = 0;
            Test("for         ", delegate()
            {
                for (int i = 0; i < list.Count; ++i)
                    sum += list[i];
            });

            Test("Linq+Sum    ", delegate()
            {
                sum = (from x in list select x).Sum();
            });

            //Test("Linq        ", delegate()
            //{
            //    (from l in list where (sum += l) < 0 select l); 
            //});

            sum = 0;
            Action<long> visitor = delegate(long x) { sum += x; };
            Test("visitor     ", delegate()
            {
                list.Walk(visitor);
            });

            sum = 0;
            Test("co-procedure", delegate()
            {
                foreach (var x in list.Walk())
                    sum += x;
            });
        }
    }
}

Plain 'Sum' : ~150-200
foreach     : ~71-75
for         : ~45
Linq+Sum    : ~350
visitor     : ~87
co-procedure: ~209

foreach (var v in source)
    yield return v;

yield many source;

let rec fromTo x y =
    seq { if x <= y then
             yield  x
             yield! fromTo (x+1) y }

П>>Так о каких изменениях существующих интерфейсов Вы говорите?

class GeneratedSequenceBase<T> : IEnumerable<T>, IEnumerator<T>

П>Btw, ну ведь красота же:

П>let rec fromTo x y =
П>    seq { if x <= y then
П>             yield  x
П>             yield! fromTo (x+1) y }
П>

let rec fib = Seq.cache <| seq {
    yield 0I
    yield 1I
    yield! Seq.map2 (+) fib (Seq.skip 1 fib )}

П>Вот так:

П>Попробуйте на нынешних итераторах что-нибудь сильно рекурсивное написать, тогда может даже невооружённым глазом заметна будет разница

  private static IEnumerable<T> UngroupRecurseEnumerator<T>(
      IEnumerable<T> source, Func<T, IEnumerable<T>> getItemsFunction)
    {
      Stack<IEnumerator<T>> stack = new Stack<IEnumerator<T>>();
      stack.Push(source.GetEnumerator());
      do
      {
        IEnumerator<T> enumerator = stack.Peek();
        if (enumerator.MoveNext())
        {
          T current = enumerator.Current;
          stack.Push(getItemsFunction(current).GetEnumerator());
          yield return current;
        }
        else
        {
          stack.Pop();
        }
      }
      while (HasValues(stack));
    }

А>let rec fib = Seq.cache <| seq {
А>    yield 0I
А>    yield 1I
А>    yield! Seq.map2 (+) fib (Seq.skip 1 fib )}
А>

module Seq =

    (*  cache_rec : (seq<'a> -> #seq<'a>) -> seq<'a>  *)
    let cache_rec f =
        let self = ref Seq.empty
        let fake = Seq.delay <| fun () -> !self
        let seq  = Seq.cache <| f fake
        self := seq
        seq

let fib =
    Seq.cache_rec (fun self -> seq {
        yield  0I
        yield  1I
        yield! Seq.map2 (+) self (Seq.skip 1 self)
    })

П>module Seq =

П>    (*  cache_rec : (seq<'a> -> #seq<'a>) -> seq<'a>  *)
П>    let cache_rec f =
П>        let self = ref Seq.empty
П>        let fake = Seq.delay <| fun () -> !self
П>        let seq  = Seq.cache <| f fake
П>        self := seq
П>        seq
П>

module Seq =

    let cache_rec f =
        let rec x _ = Seq.delay (fun () -> f <| y () )
        and y _ = Seq.cache <| x ()
        f <| x ()

fib = 0 : 1 : zipWith (+) fib (tail fib)