<?xml version="1.0" encoding="UTF-8" ?>
<?xml-stylesheet type="text/xsl" href="http://blogs.msdn.com/utility/FeedStylesheets/rss.xsl" media="screen"?><rss version="2.0" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:slash="http://purl.org/rss/1.0/modules/slash/" xmlns:wfw="http://wellformedweb.org/CommentAPI/"><channel><title>Recursive lambda expressions</title><link>http://blogs.msdn.com/madst/archive/2007/05/11/recursive-lambda-expressions.aspx</link><description>This is a very geeky post. The tiny piece of useful information comes right at the bottom. The rest of it is all artifacts of the obscure art of doing lambda calculus in C# , which can also be characterized as doing very much with very little, sacrificing</description><dc:language>en</dc:language><generator>CommunityServer 2.1 SP1 (Build: 61025.2)</generator><item><title>Y combinators anyone?</title><link>http://blogs.msdn.com/madst/archive/2007/05/11/recursive-lambda-expressions.aspx#2555060</link><pubDate>Sat, 12 May 2007 02:17:37 GMT</pubDate><guid isPermaLink="false">91d46819-8472-40ad-a661-2c78acb4018c:2555060</guid><dc:creator>Luca Bolognese's WebLog</dc:creator><description>&lt;p&gt;From Mads, our proud C# language PM: &lt;a rel="nofollow" target="_new" href="http://blogs.msdn.com/madst/archive/2007/05/11/recursive-lambda-expressions.aspx"&gt;http://blogs.msdn.com/madst/archive/2007/05/11/recursive-lambda-expressions.aspx&lt;/a&gt;&lt;/p&gt;
</description></item><item><title>re: Recursive lambda expressions</title><link>http://blogs.msdn.com/madst/archive/2007/05/11/recursive-lambda-expressions.aspx#2559844</link><pubDate>Sat, 12 May 2007 05:41:57 GMT</pubDate><guid isPermaLink="false">91d46819-8472-40ad-a661-2c78acb4018c:2559844</guid><dc:creator>Senior .NET Developer</dc:creator><description>&lt;p&gt;My head hurts. I think I'll go become a manager.&lt;/p&gt;
</description></item><item><title>re: Recursive lambda expressions</title><link>http://blogs.msdn.com/madst/archive/2007/05/11/recursive-lambda-expressions.aspx#2577219</link><pubDate>Sat, 12 May 2007 22:08:05 GMT</pubDate><guid isPermaLink="false">91d46819-8472-40ad-a661-2c78acb4018c:2577219</guid><dc:creator>Tom Kirby-Green</dc:creator><description>&lt;p&gt;I love this stuff. More of the same please!&lt;/p&gt;
</description></item><item><title>re: Recursive lambda expressions</title><link>http://blogs.msdn.com/madst/archive/2007/05/11/recursive-lambda-expressions.aspx#2578015</link><pubDate>Sat, 12 May 2007 22:53:18 GMT</pubDate><guid isPermaLink="false">91d46819-8472-40ad-a661-2c78acb4018c:2578015</guid><dc:creator>j marlowe</dc:creator><description>&lt;p&gt;awesome.&lt;/p&gt;
&lt;p&gt;and all this included in language that can actually pay the mortgage.&lt;/p&gt;
&lt;p&gt;3.5 cannot be released fast enough!&lt;/p&gt;
&lt;p&gt;how do you plan to deal with the inevitable problem of unifying the existing bcl apis with the more functional-style possible in 3.5 and beyond? &amp;nbsp;extension methods only go so far in this regard. &amp;nbsp;how will you avoid a &amp;quot;split&amp;quot; into apis that prefer a functional-style and those that do not?&lt;/p&gt;
</description></item><item><title>A different point of view.</title><link>http://blogs.msdn.com/madst/archive/2007/05/11/recursive-lambda-expressions.aspx#2581574</link><pubDate>Sun, 13 May 2007 01:40:05 GMT</pubDate><guid isPermaLink="false">91d46819-8472-40ad-a661-2c78acb4018c:2581574</guid><dc:creator>Community Blogs</dc:creator><description>&lt;p&gt;I've met both the author (Mads T), and Luca in person. This post is not an impersonal, anonymous attack.&lt;/p&gt;
</description></item><item><title>re: Recursive lambda expressions</title><link>http://blogs.msdn.com/madst/archive/2007/05/11/recursive-lambda-expressions.aspx#2617008</link><pubDate>Mon, 14 May 2007 08:13:44 GMT</pubDate><guid isPermaLink="false">91d46819-8472-40ad-a661-2c78acb4018c:2617008</guid><dc:creator>David Travis</dc:creator><description>&lt;p&gt;Hmmm... It is good know we can do it. But why not stick with the good old methods we know to implement recursions? The readability trade-off here is huge.&lt;/p&gt;
&lt;p&gt;Either way, thank you for the thorough explanation.&lt;/p&gt;
</description></item><item><title>Recursive lambda expressions</title><link>http://blogs.msdn.com/madst/archive/2007/05/11/recursive-lambda-expressions.aspx#2617859</link><pubDate>Mon, 14 May 2007 08:58:29 GMT</pubDate><guid isPermaLink="false">91d46819-8472-40ad-a661-2c78acb4018c:2617859</guid><dc:creator>DotNetKicks.com</dc:creator><description>&lt;p&gt;You've been kicked (a good thing) - Trackback from DotNetKicks.com&lt;/p&gt;
</description></item><item><title>Community Convergence XXVII</title><link>http://blogs.msdn.com/madst/archive/2007/05/11/recursive-lambda-expressions.aspx#2618151</link><pubDate>Mon, 14 May 2007 09:14:13 GMT</pubDate><guid isPermaLink="false">91d46819-8472-40ad-a661-2c78acb4018c:2618151</guid><dc:creator>Charlie Calvert's Community Blog</dc:creator><description>&lt;p&gt;Welcome to the 27th Community Convergence. I use this column to keep you informed of events in the C#&lt;/p&gt;
</description></item><item><title>re: Recursive lambda expressions</title><link>http://blogs.msdn.com/madst/archive/2007/05/11/recursive-lambda-expressions.aspx#2801180</link><pubDate>Wed, 23 May 2007 01:05:32 GMT</pubDate><guid isPermaLink="false">91d46819-8472-40ad-a661-2c78acb4018c:2801180</guid><dc:creator>Matthieu MEZIL</dc:creator><description>&lt;p&gt;Why don't you do this?&lt;/p&gt;
&lt;p&gt;Func&amp;lt;int, int&amp;gt; fac &amp;nbsp;= null;&lt;/p&gt;
&lt;p&gt;fac = x =&amp;gt; x-- * (x == 0 ? 1 : fac(x));&lt;/p&gt;
</description></item><item><title>re: Recursive lambda expressions</title><link>http://blogs.msdn.com/madst/archive/2007/05/11/recursive-lambda-expressions.aspx#2810811</link><pubDate>Wed, 23 May 2007 10:30:17 GMT</pubDate><guid isPermaLink="false">91d46819-8472-40ad-a661-2c78acb4018c:2810811</guid><dc:creator>Matthieu MEZIL</dc:creator><description>&lt;p&gt;Sorry, I had bad read your post :-(&lt;/p&gt;
</description></item><item><title>Recursive lambda expressions</title><link>http://blogs.msdn.com/madst/archive/2007/05/11/recursive-lambda-expressions.aspx#2835079</link><pubDate>Thu, 24 May 2007 10:15:43 GMT</pubDate><guid isPermaLink="false">91d46819-8472-40ad-a661-2c78acb4018c:2835079</guid><dc:creator>A world apart from the everday ...</dc:creator><description>&lt;p&gt;I feel it very neccessary at this point to warn you that this is most certainly not for the faint hearted&lt;/p&gt;
</description></item><item><title>re: Recursive lambda expressions</title><link>http://blogs.msdn.com/madst/archive/2007/05/11/recursive-lambda-expressions.aspx#2835098</link><pubDate>Thu, 24 May 2007 10:17:40 GMT</pubDate><guid isPermaLink="false">91d46819-8472-40ad-a661-2c78acb4018c:2835098</guid><dc:creator>Ryan CrawCour</dc:creator><description>&lt;p&gt;Beyond words .... but thx for the entertaining read! :D&lt;/p&gt;
</description></item><item><title>re: Recursive lambda expressions</title><link>http://blogs.msdn.com/madst/archive/2007/05/11/recursive-lambda-expressions.aspx#3165221</link><pubDate>Fri, 08 Jun 2007 19:22:32 GMT</pubDate><guid isPermaLink="false">91d46819-8472-40ad-a661-2c78acb4018c:3165221</guid><dc:creator>Fduch</dc:creator><description>&lt;p&gt;How about this?&lt;/p&gt;
&lt;p&gt;I've never siin so complicated brain****ing stuff so I may be wrong:&lt;/p&gt;
&lt;p&gt;delegate int SelfApplicableInt&amp;lt;Tvoid&amp;gt;(SelfApplicableInt&amp;lt;Tvoid&amp;gt; self, int x);&lt;/p&gt;
&lt;p&gt;SelfApplicableInt&amp;lt;int&amp;gt; F = (fac, x) =&amp;gt; x == 0 ? 1 : x * fac(fac, x - 1);&lt;/p&gt;
&lt;p&gt;Func&amp;lt;int, int&amp;gt; factorial = (x) =&amp;gt; F1(F1, x);&lt;/p&gt;
&lt;p&gt;var z = factorial2(8);&lt;/p&gt;
</description></item><item><title>re: Recursive lambda expressions</title><link>http://blogs.msdn.com/madst/archive/2007/05/11/recursive-lambda-expressions.aspx#3165235</link><pubDate>Fri, 08 Jun 2007 19:24:32 GMT</pubDate><guid isPermaLink="false">91d46819-8472-40ad-a661-2c78acb4018c:3165235</guid><dc:creator>Fduch</dc:creator><description>&lt;p&gt;spelling errors...&lt;/p&gt;
&lt;p&gt;delegate int SelfApplicableInt&amp;lt;Tvoid&amp;gt;(SelfApplicableInt&amp;lt;Tvoid&amp;gt; self, int x);&lt;/p&gt;
&lt;p&gt;SelfApplicableInt&amp;lt;int&amp;gt; F = (fac, x) =&amp;gt; x == 0 ? 1 : x * fac(fac, x - 1);&lt;/p&gt;
&lt;p&gt;Func&amp;lt;int, int&amp;gt; factorial = (x) =&amp;gt; F(F, x);&lt;/p&gt;
&lt;p&gt;var z = factorial(8);&lt;/p&gt;
</description></item><item><title>re: Recursive lambda expressions</title><link>http://blogs.msdn.com/madst/archive/2007/05/11/recursive-lambda-expressions.aspx#4067603</link><pubDate>Thu, 26 Jul 2007 19:13:56 GMT</pubDate><guid isPermaLink="false">91d46819-8472-40ad-a661-2c78acb4018c:4067603</guid><dc:creator>Jeff Lebowski</dc:creator><description>&lt;p&gt;This is worse than regular expressions... but almost as entertaining. &amp;nbsp;Thanks!&lt;/p&gt;
</description></item><item><title>Taking LINQ to Objects to Extremes: A fully LINQified RayTracer</title><link>http://blogs.msdn.com/madst/archive/2007/05/11/recursive-lambda-expressions.aspx#5233779</link><pubDate>Tue, 02 Oct 2007 05:34:11 GMT</pubDate><guid isPermaLink="false">91d46819-8472-40ad-a661-2c78acb4018c:5233779</guid><dc:creator>LukeH's WebLog</dc:creator><description>&lt;p&gt;Not too long ago I blogged about a C# raytracer which took advantage of a lot of C#3.0 language constructs.&lt;/p&gt;
</description></item><item><title>re: Recursive lambda expressions</title><link>http://blogs.msdn.com/madst/archive/2007/05/11/recursive-lambda-expressions.aspx#6529702</link><pubDate>Mon, 26 Nov 2007 14:40:52 GMT</pubDate><guid isPermaLink="false">91d46819-8472-40ad-a661-2c78acb4018c:6529702</guid><dc:creator>Fan Shi</dc:creator><description>&lt;p&gt;Actually, VB can define a pure lambda founded Y combinator, no neeed to define any helper types.&lt;/p&gt;
&lt;p&gt;Dim Y1 = Function(f) _&lt;/p&gt;
&lt;p&gt;(Function(h) Function(x) f.Invoke(h.Invoke(h)).Invoke(x)) _&lt;/p&gt;
&lt;p&gt;(Function(h) Function(x) f.Invoke(h.Invoke(h)).Invoke(x))&lt;/p&gt;
&lt;p&gt;It is a late binding version. Typed version is also be able to created.&lt;/p&gt;
</description></item><item><title>Recursive Lambda with Fixed Point Generator</title><link>http://blogs.msdn.com/madst/archive/2007/05/11/recursive-lambda-expressions.aspx#6727414</link><pubDate>Tue, 11 Dec 2007 00:10:41 GMT</pubDate><guid isPermaLink="false">91d46819-8472-40ad-a661-2c78acb4018c:6727414</guid><dc:creator>TripLeZoNe Technology Playground</dc:creator><description>&lt;p&gt;Reading Mads Torgersen old blog post on Recursive Lambda Expressions , I decided it was time for me to&lt;/p&gt;
</description></item><item><title>Recursive Lambda with Fixed Point Generator</title><link>http://blogs.msdn.com/madst/archive/2007/05/11/recursive-lambda-expressions.aspx#6735024</link><pubDate>Tue, 11 Dec 2007 16:33:48 GMT</pubDate><guid isPermaLink="false">91d46819-8472-40ad-a661-2c78acb4018c:6735024</guid><dc:creator>Justin Lee's Technology Blog</dc:creator><description>&lt;p&gt;.csharpcode, .csharpcode pre { font-size: small; color: black; font-family: consolas, &amp;quot;Courier New&amp;quot;,&lt;/p&gt;
</description></item><item><title>��ư��</title><link>http://blogs.msdn.com/madst/archive/2007/05/11/recursive-lambda-expressions.aspx#7252458</link><pubDate>Sat, 26 Jan 2008 09:53:29 GMT</pubDate><guid isPermaLink="false">91d46819-8472-40ad-a661-2c78acb4018c:7252458</guid><dc:creator>assari (PukiWiki/TrackBack 0.3)</dc:creator><description>&lt;p&gt;WikiPedia:��ư�� sumii������ - ��ư���黻�Ҥդ����� �٥���ӥ͡����&amp;#228;Ʋ��˻Ȥ��Ρ� - sumii������ ���͸��� Lazy ���롣�ֳ��ԡ�Y����ӥ͡����� - ���쥲���� SICP 1.3.3 Procedures as General Methods:Finding fixed points of functions Fixed point combinato...&lt;/p&gt;
</description></item><item><title>Fun with recursive Lambda functions</title><link>http://blogs.msdn.com/madst/archive/2007/05/11/recursive-lambda-expressions.aspx#8340555</link><pubDate>Fri, 28 Mar 2008 01:59:53 GMT</pubDate><guid isPermaLink="false">91d46819-8472-40ad-a661-2c78acb4018c:8340555</guid><dc:creator> GrabBag&lt;T&gt;</dc:creator><description>&lt;p&gt;This post was originally published here . I saw a couple of posts on recursive lambda expressions , and&lt;/p&gt;
</description></item><item><title>re: Recursive lambda expressions</title><link>http://blogs.msdn.com/madst/archive/2007/05/11/recursive-lambda-expressions.aspx#8346852</link><pubDate>Tue, 01 Apr 2008 02:27:06 GMT</pubDate><guid isPermaLink="false">91d46819-8472-40ad-a661-2c78acb4018c:8346852</guid><dc:creator>gugoxx (giuseppe.ugo@integres.it)</dc:creator><description>&lt;p&gt;I can't really understand why the following wouldn't be considered enough for the solution.&lt;/p&gt;
&lt;p&gt;Func&amp;lt;int, int&amp;gt; fac = null;&lt;/p&gt;
&lt;p&gt;fac = x =&amp;gt; (x == 0) ? 1 : x * fac(x - 1);&lt;/p&gt;
&lt;p&gt;Isn't enough for declaring that it's recursive?&lt;/p&gt;
</description></item><item><title>re: Recursive lambda expressions</title><link>http://blogs.msdn.com/madst/archive/2007/05/11/recursive-lambda-expressions.aspx#8430654</link><pubDate>Sun, 27 Apr 2008 10:25:35 GMT</pubDate><guid isPermaLink="false">91d46819-8472-40ad-a661-2c78acb4018c:8430654</guid><dc:creator>MattManela</dc:creator><description>&lt;p&gt;Yes, but then you are no longer dealing with lambda expression in the mathamtical sense. &amp;nbsp;In lambda calculus there is no concept of storing the expression in a 'variable'. &amp;nbsp;Thus a function has no way to refer to itself. &amp;nbsp;This fact leads to the need for a fixpoint combinator to create recursion in a more round-a-bout way.&lt;/p&gt;
</description></item><item><title>re: Recursive lambda expressions</title><link>http://blogs.msdn.com/madst/archive/2007/05/11/recursive-lambda-expressions.aspx#8590287</link><pubDate>Tue, 10 Jun 2008 21:37:27 GMT</pubDate><guid isPermaLink="false">91d46819-8472-40ad-a661-2c78acb4018c:8590287</guid><dc:creator>PeteS</dc:creator><description>&lt;p&gt;Aside from LINQ is there any use for lambda expressions in C#? I mean it seems great academic fun, but if that's the idea why not use LISP or ML and such? Since C# is supposed to be a real world language one wonders what's this stuff doing there. &lt;/p&gt;
&lt;p&gt;Other than that it IS fun! :)&lt;/p&gt;
</description></item><item><title>re: Recursive lambda expressions</title><link>http://blogs.msdn.com/madst/archive/2007/05/11/recursive-lambda-expressions.aspx#8792240</link><pubDate>Wed, 30 Jul 2008 22:35:13 GMT</pubDate><guid isPermaLink="false">91d46819-8472-40ad-a661-2c78acb4018c:8792240</guid><dc:creator>David Conrad</dc:creator><description>&lt;p&gt;I know this is a very old post, but I hope you'll see this. I tried to &amp;quot;put Y and Fix as static members of a generic class&amp;quot;, as you said, but got errors I couldn't understand. I assume I still need the SelfApplicable delegate, and I need to put it inside the Fun&amp;lt;T&amp;gt; class? This is what I tried, but it's wrong:&lt;/p&gt;
&lt;p&gt;public class Fun&amp;lt;T&amp;gt; {&lt;/p&gt;
&lt;p&gt; &amp;nbsp; &amp;nbsp;public delegate Q SelfApplicable&amp;lt;Q&amp;gt;(SelfApplicable&amp;lt;Q&amp;gt; self);&lt;/p&gt;
&lt;p&gt; &amp;nbsp; &amp;nbsp;// The Y combinator&lt;/p&gt;
&lt;p&gt; &amp;nbsp; &amp;nbsp;public static SelfApplicable&amp;lt;Func&amp;lt;Func&amp;lt;T,T&amp;gt;,T&amp;gt;&amp;gt; Y =&lt;/p&gt;
&lt;p&gt; &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp;y =&amp;gt; f =&amp;gt; x =&amp;gt; f(y(y)(f))(x);&lt;/p&gt;
&lt;p&gt; &amp;nbsp; &amp;nbsp;// The fixed point generator&lt;/p&gt;
&lt;p&gt; &amp;nbsp; &amp;nbsp;public static Func&amp;lt;Func&amp;lt;T, T&amp;gt;, T&amp;gt; Fix = Y(Y);&lt;/p&gt;
&lt;p&gt;}&lt;/p&gt;
&lt;p&gt;Can you expand on the ellipses that you used at that point in your post?&lt;/p&gt;
</description></item><item><title>Book Links</title><link>http://blogs.msdn.com/madst/archive/2007/05/11/recursive-lambda-expressions.aspx#8879291</link><pubDate>Tue, 19 Aug 2008 20:24:28 GMT</pubDate><guid isPermaLink="false">91d46819-8472-40ad-a661-2c78acb4018c:8879291</guid><dc:creator>Programming Linq Book Log</dc:creator><description>&lt;p&gt;Chapter Page Url 4 111 &lt;a rel="nofollow" target="_new" href="http://msdn2.microsoft.com/en-us/library/bb386907.aspx"&gt;http://msdn2.microsoft.com/en-us/library/bb386907.aspx&lt;/a&gt; 4 111 &lt;a rel="nofollow" target="_new" href="http://msdn2.microsoft.com/en-us/library/bb399400.aspx"&gt;http://msdn2.microsoft.com/en-us/library/bb399400.aspx&lt;/a&gt;&lt;/p&gt;
</description></item><item><title>New and Notable 167</title><link>http://blogs.msdn.com/madst/archive/2007/05/11/recursive-lambda-expressions.aspx#9167866</link><pubDate>Wed, 03 Dec 2008 05:50:16 GMT</pubDate><guid isPermaLink="false">91d46819-8472-40ad-a661-2c78acb4018c:9167866</guid><dc:creator>Sam Gentile's Blog</dc:creator><description>&lt;p&gt;You have to love a hotel where you have the amazing Lavazza coffee in your hotel room. CLR/Silverlight/Orcas/C# One of the things that has been a bit fustrating over the years with the CLR is the limitation of one CLR per process. Specifically, where&lt;/p&gt;
</description></item><item><title>.NET Lambda Expressions – Resources</title><link>http://blogs.msdn.com/madst/archive/2007/05/11/recursive-lambda-expressions.aspx#9304871</link><pubDate>Sun, 11 Jan 2009 02:30:38 GMT</pubDate><guid isPermaLink="false">91d46819-8472-40ad-a661-2c78acb4018c:9304871</guid><dc:creator>Scott Dorman's Blog</dc:creator><description>&lt;p&gt;Note : This entry was originally posted on 11/28/2008 11:58:09 AM. I present at a lot of the local Florida&lt;/p&gt;
</description></item><item><title>re: Recursive lambda expressions</title><link>http://blogs.msdn.com/madst/archive/2007/05/11/recursive-lambda-expressions.aspx#9307783</link><pubDate>Mon, 12 Jan 2009 16:23:51 GMT</pubDate><guid isPermaLink="false">91d46819-8472-40ad-a661-2c78acb4018c:9307783</guid><dc:creator>Paul Batum</dc:creator><description>&lt;p&gt;This post inspired me to do my own series on how the y combinator can be derived. I used C# and tried to go about it using very small steps. The series starts here:&lt;/p&gt;
&lt;p&gt;&lt;a rel="nofollow" target="_new" href="http://www.paulbatum.com/2009/01/refactoring-towards-y-combinator-part-1.html"&gt;http://www.paulbatum.com/2009/01/refactoring-towards-y-combinator-part-1.html&lt;/a&gt;&lt;/p&gt;
</description></item><item><title>Recursive Lambdas</title><link>http://blogs.msdn.com/madst/archive/2007/05/11/recursive-lambda-expressions.aspx#9582888</link><pubDate>Fri, 01 May 2009 23:09:56 GMT</pubDate><guid isPermaLink="false">91d46819-8472-40ad-a661-2c78acb4018c:9582888</guid><dc:creator>Steve's Tech Talk</dc:creator><description>&lt;p&gt;At PDC several years ago, I attended the first talk on C# 3.0 by Anders Hejlsberg wherein he demonstrated&lt;/p&gt;
</description></item><item><title>re: Recursive lambda expressions</title><link>http://blogs.msdn.com/madst/archive/2007/05/11/recursive-lambda-expressions.aspx#9848856</link><pubDate>Sun, 26 Jul 2009 06:59:20 GMT</pubDate><guid isPermaLink="false">91d46819-8472-40ad-a661-2c78acb4018c:9848856</guid><dc:creator>sdclctb</dc:creator><description>&lt;p&gt;YN7PXf &amp;nbsp;&amp;lt;a href=&amp;quot;&lt;a rel="nofollow" target="_new" href="http://msfumjakhgiv.com/&amp;quot;&amp;gt;msfumjakhgiv&amp;lt;/a&amp;gt;"&gt;http://msfumjakhgiv.com/&amp;quot;&amp;gt;msfumjakhgiv&amp;lt;/a&amp;gt;&lt;/a&gt;, [url=&lt;a rel="nofollow" target="_new" href="http://pperkffacltq.com/"&gt;http://pperkffacltq.com/&lt;/a&gt;]pperkffacltq[/url], [link=&lt;a rel="nofollow" target="_new" href="http://tzxafxjhiwoc.com/"&gt;http://tzxafxjhiwoc.com/&lt;/a&gt;]tzxafxjhiwoc[/link], &lt;a rel="nofollow" target="_new" href="http://mgzyrhsvzbuk.com/"&gt;http://mgzyrhsvzbuk.com/&lt;/a&gt;&lt;/p&gt;
</description></item><item><title>re: Recursive lambda expressions</title><link>http://blogs.msdn.com/madst/archive/2007/05/11/recursive-lambda-expressions.aspx#9885165</link><pubDate>Wed, 26 Aug 2009 14:56:02 GMT</pubDate><guid isPermaLink="false">91d46819-8472-40ad-a661-2c78acb4018c:9885165</guid><dc:creator>serge</dc:creator><description>&lt;p&gt;Just for completeness. Here's what the Y combinator factorial looks like in Erlang. &amp;nbsp;Simple and clear:&lt;/p&gt;
&lt;p&gt;fun(0, _) -&amp;gt; 1; (X, F) -&amp;gt; X * F(X-1, F) end.&lt;/p&gt;
</description></item><item><title>re: Recursive lambda expressions</title><link>http://blogs.msdn.com/madst/archive/2007/05/11/recursive-lambda-expressions.aspx#9896086</link><pubDate>Thu, 17 Sep 2009 01:22:01 GMT</pubDate><guid isPermaLink="false">91d46819-8472-40ad-a661-2c78acb4018c:9896086</guid><dc:creator>Glenn Slayden</dc:creator><description>&lt;p&gt;Great post.&lt;/p&gt;
&lt;p&gt;I understand the geeky theory, and the fact that the compiler gives &amp;quot;error CS0165: Use of unassigned local variable&amp;quot; proves that it, too, is a geek.&lt;/p&gt;
&lt;p&gt;But in the real world, assigning null first, as others have pointed out, works.&lt;/p&gt;
&lt;p&gt;Func&amp;lt;int, int&amp;gt; f = null;&lt;/p&gt;
&lt;p&gt;f = x =&amp;gt; (x == 0) ? 1 : x * f(x - 1);&lt;/p&gt;
</description></item></channel></rss>