I have to warn you that I'm trying to fix your attempts, not to make a productive code. Also, this solution is good to make our brains to explode, and maybe the computer also.

In your first snippet you tried to call recursive your field or local variable, that is not possible.Instead we can try with a lambda which could be more similar to that. We know from Church, that is also not possible, at least in the traditional way. Lambda expressions are unnamed; you can't call them by their name ( inside of the implementation ). But you can use the fixed point to do recursion. If you have a sane mind there is big chance of not knowing what is that, anyway you should give a try to this link before continuing with this.

fix :: (a -> a) -> a fix f = f (fix f)

This will be the c# implementation (which is wrong)

A fix<A>(Func<A,A> f) { return f(fix(f)); }

Why is wrong? Because fix(f) represents a beautiful stackoverflow. So we need to make it lazy:

A fix<A>(Func<Func<A>,A> f) { return f(()=>fix(f)); }

Now is lazy! Actually you will see a lot of this in the following code.

In your second snippet and also in the first, you have the problem that the second argument to Enumerable.Concat is not lazy, and you will have stackoverflow exception, or infinite loop in the idealistic way. So let's make it lazy.

static IEnumerable<T> Concat<T>(IEnumerable<T> xs,Func<IEnumerable<T>> f) { foreach (var x in xs) yield return x; foreach (var y in f()) yield return y; }

Now, we have the whole "framework" to implement what you have tried in the functional way.

void play() { Func<Func<Func<IEnumerable<int>>>, Func<IEnumerable<int>>> F = fibs => () => Concat(new int[] { 1, 1 }, ()=> Enumerable.Zip (fibs()(), fibs()().Skip(1), (a,b)=> a + b)); //let's see some action var n5 = fix(F)().Take(5).ToArray(); // instant var n20 = fix(F)().Take(20).ToArray(); // relative fast var n30 = fix(F)().Take(30).ToArray(); //this will take a lot of time to compute //var n40 = fix(F)().Take(40).ToArray(); //!!! OutOfMemoryException }

I know that the F signature is ugly like hell, but this is why languages like haskell exists, and even F#. C# is not made for this work to be done like this. Now, the question is, why haskell can achieve something like this?Why? because whenever you say something like

a:: Int a = 4

The most similar translation in C# is :

Func<Int> a = () => 4

Actually is much more involved in the haskell implementation, but this is the idea why similar method of solving problems looks so different if you want to write it in both languages