{"id":830,"date":"2009-06-24T11:27:35","date_gmt":"2009-06-24T09:27:35","guid":{"rendered":"http:\/\/www.navision-blog.de\/2009\/06\/24\/f-bootcamp-questions-and-answers-part-iii-lazy-evaluation\/"},"modified":"2009-06-24T12:22:14","modified_gmt":"2009-06-24T10:22:14","slug":"f-bootcamp-questions-and-answers-part-iii-lazy-evaluation","status":"publish","type":"post","link":"http:\/\/www.navision-blog.de\/blog\/2009\/06\/24\/f-bootcamp-questions-and-answers-part-iii-lazy-evaluation\/","title":{"rendered":"F# BootCamp – Questions and Answers – part III – Lazy evaluation"},"content":{"rendered":"

This is the third part in a \u201cQuestions and Answers\u201d-series about the F# BootCamp in Leipzig<\/a>. This time we will look at lazy evaluation.<\/p>\n

Question 5 \u2013 What is the difference between \u201cLazy Evaluation\u201d and \u201cEager evaluation\u201d?<\/h5>\n
\n

Lazy evaluation<\/b> is a technique of delaying a computation until the result is required. If we use eager evaluation<\/strong> an expression is evaluated as soon as it gets bound to a variable.<\/p>\n<\/blockquote>\n

One participant answered that lazy evaluation is used in most programming languages to calculate boolean expressions faster. For instance in the expression \u201cx() or<\/strong> y()\u201d the function y() is never called if x() returns true. <\/p>\n

Of course this answer is correct, but this "short-circuit evaluation<\/a>" is only a special case of lazy evaluation. The program would also work correctly without it. But if we want to define an infinite sequence then we can not use eager evaluation. Let\u2019s look at an example:<\/p>\n

\/\/ val fibs: seq<int>\n<\/span>let <\/span>fibs = (1, 1) |> Seq.unfold(fun <\/span>(n0, n1) -> <\/span>Some(n0, (n1, n0 + n1)))<\/pre>\n
We do not need to understand the concrete syntax of this code here. We\u2019ll discuss this later. Let\u2019s just say fibs is bound to an infinite sequence (IEnumerable<int>) of Fibonacci numbers. You could also write this in C#:<\/p>\n
\/\/\/ <summary>\n\/\/\/ <\/span>Infinite sequence of Fibonacci numbers.\n<\/span>\/\/\/ <\/summary>\n<\/span>public static <\/span>IEnumerable<\/span><int<\/span>> Fibs()\n{\n    var <\/span>n0 = 1;\n    var <\/span>n1 = 1;\n    while<\/span>(true<\/span>)\n    {\n        yield return <\/span>n0;\n        var <\/span>t = n1;\n        n1 = n1 + n0;\n        n0 = t;\n    }\n}<\/pre>\n
The trick is IEnumerable evaluates the elements lazy. Only at the time we take an element from the sequence the element will be computed:<\/p>\n
fibs\n  |> Seq.take 10\n  |> Seq.to_list\n  |> printfn "%A" <\/span>\/\/ prints [1; 1; 2; 3; 5; 8; 13; 21; 34; 55]<\/span><\/pre>\n
If we would use eager evaluation then \u201cSeq.take\u201d would never been called. But we can go one step further. If we want to get the first 10 even-valued terms in the Fibonacci sequence, we can write this code:<\/p>\n
fibs \n  |> Seq.filter (fun <\/span>fib -> <\/span>fib % 2 = 0) \/\/ lazy (via pipe)\n  <\/span>|> Seq.take 10                         \/\/ lazy (via pipe)\n  <\/span>|> Seq.to_list                         \/\/ eager\n  <\/span>|> printfn "%A" \n  \n<\/span>\/\/ prints [2; 8; 34; 144; 610; 2584; 10946; 46368; 196418; 832040]<\/span><\/pre>\n
This would be a little bit tricky if we use eager evaluation, but of course this nice laziness comes with some costs for storing intermediate results (and code). So eager evaluation is still often the better choice and sometimes (e.g. DateTime.Now()<\/em>) it makes no sense to use lazy evaluation \u2013 at least not if we don\u2019t reevaluate the function.<\/p>\n","protected":false},"excerpt":{"rendered":"
This is the third part in a \u201cQuestions and Answers\u201d-series about the F# BootCamp in Leipzig. This time we will look at lazy evaluation. Question 5 \u2013 What is the difference between \u201cLazy Evaluation\u201d and \u201cEager evaluation\u201d? Lazy evaluation is a technique of delaying a computation until the result is required. If we use eager […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":[],"categories":[23,448,8],"tags":[540,664,555],"_links":{"self":[{"href":"http:\/\/www.navision-blog.de\/blog\/wp-json\/wp\/v2\/posts\/830"}],"collection":[{"href":"http:\/\/www.navision-blog.de\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"http:\/\/www.navision-blog.de\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"http:\/\/www.navision-blog.de\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"http:\/\/www.navision-blog.de\/blog\/wp-json\/wp\/v2\/comments?post=830"}],"version-history":[{"count":3,"href":"http:\/\/www.navision-blog.de\/blog\/wp-json\/wp\/v2\/posts\/830\/revisions"}],"predecessor-version":[{"id":833,"href":"http:\/\/www.navision-blog.de\/blog\/wp-json\/wp\/v2\/posts\/830\/revisions\/833"}],"wp:attachment":[{"href":"http:\/\/www.navision-blog.de\/blog\/wp-json\/wp\/v2\/media?parent=830"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"http:\/\/www.navision-blog.de\/blog\/wp-json\/wp\/v2\/categories?post=830"},{"taxonomy":"post_tag","embeddable":true,"href":"http:\/\/www.navision-blog.de\/blog\/wp-json\/wp\/v2\/tags?post=830"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}