VD>Ты утверждаешь, что на ФЯ нельзя создать линивых вычислений. Вот тебе пример примитивного варианта:

VD>

VD>class A
VD>{
VD>    int _value = 0;
VD>    public void Next() { ++_value; }
VD>    public int Current() { return _value; }
VD>}

VD>...

VD>A a = new A();
VD>for (;;a.Next())
VD>{
VD>    ... a.Current() ...
VD>}
VD>

VD>Что это по твоему не линивые вычисления? Нужно обязательно создать список из всех допустимых значений?

VD>Ну, раз линивые, то закроем этот спор. Признай что сморозил глупость.

Естественно, в С# можно эмулировать ленивые вычисления, точно так же, как на ассемблере можно писать в объектно ориентированном стиле. Вопрос насколько это красиво, удобно и понятно. Ленивые вычисления в Haskell'е врожденная черта. Чтобы ими пользоваться не нужно предпринимать никаких дополнительных действий, думать как да что. Вот, например, вычисление простых чисел методом решета:

nums = [2..] -- бесконечный список чисел начиная с 2 
sieve (head:tail) = head : sieve (filter (\x -> if x `mod` head = 0 then False else True) tail) 
-- просеивание списка, (\x -> if x `mod` head = 0 then False else True) - это функция, которая
-- возвращает False, если x делится нацело на head и True иначе. filter - это функция, которая
-- фильтрует список tail c помощью указанной функции. После чего просеивание производится по отношению
-- к новому списку, из которого удалены все элементы, делящиеся на head,
primes = sieve nums -- все простые числа

Во всех этих 3-х строках кода неявно подразумевается ленивость вычислений. В реальности ни списки не будут бесконечно большими, ни filter не будет обрабатывать весь список и sieve тоже.