In the namespace `MS.Internal`, there is a class named `NamedObject`.

It has a weird block of code:

    public override string ToString()
    {
      if (_name[0] != &#39;{&#39;)
      {
        // lazily add {} around the name, to avoid allocating a string 
        // until it&#39;s actually needed
        _name = String.Format(CultureInfo.InvariantCulture, &quot;{{{0}}}&quot;, _name);
      }

      return _name;
    }

I&#39;m curious about this comment specifically:

        // lazily add {} around the name, to avoid allocating a string 
        // until it&#39;s actually needed
        _name = String.Format(CultureInfo.InvariantCulture, &quot;{{{0}}}&quot;, _name);

How is that &#39;lazy&#39;? What does it do to be lazy?

__________ 

Full class from the [reference source][1]:


    //---------------------------------------------------------------------------- 
    //
    // &lt;copyright file=&quot;NamedObject.cs&quot; company=&quot;Microsoft&quot;&gt;
    //    Copyright (C) Microsoft Corporation.  All rights reserved.
    // &lt;/copyright&gt; 
    //
    // Description: Placeholder object, with a name that appears in the debugger 
    // 
    //---------------------------------------------------------------------------
    
    using System;
    using System.Globalization;
    using MS.Internal.WindowsBase;
    
    namespace MS.Internal
    {
      /// &lt;summary&gt; 
      /// An instance of this class can be used wherever you might otherwise use
      /// &quot;new Object()&quot;.  The name will show up in the debugger, instead of 
      /// merely &quot;{object}&quot;
      /// &lt;/summary&gt;
      [FriendAccessAllowed]   // Built into Base, also used by Framework.
      internal class NamedObject
      {
        public NamedObject(string name)
        {
          if (String.IsNullOrEmpty(name))
            throw new ArgumentNullException(name);
    
          _name = name;
        }
    
        public override string ToString()
        {
          if (_name[0] != &#39;{&#39;)
          {
            // lazily add {} around the name, to avoid allocating a string 
            // until it&#39;s actually needed
            _name = String.Format(CultureInfo.InvariantCulture, &quot;{{{0}}}&quot;, _name);
          }
    
          return _name;
        }
    
        string _name;
      }
    }
    
    // File provided for Reference Use Only by Microsoft Corporation (c) 2007.
    // Copyright (c) Microsoft Corporation. All rights reserved.


  [1]: http://referencesource.microsoft.com/#WindowsBase/Base/MS/Internal/NamedObject.cs,6a3daa330bc0a54b

What does {{{0}}} on string.Format do?

I came across the following definition as I try to learn Haskell using a real project to drive it.  I don&#39;t understand what the exclamation mark in front of each argument means and my books didn&#39;t seem to mention it.

    data MidiMessage = MidiMessage !Int !MidiMessage

What does the exclamation mark mean in a Haskell declaration?

    [1, 2, 3, -1, -2].filter({ $0 &gt; 0 }).count // =&gt; 3
    
    [1, 2, 3, -1, -2].lazy.filter({ $0 &gt; 0 }).count // =&gt; 3

What is the advantage of adding `lazy` to the second statement. As per my understanding, when `lazy` variable is used, memory is initialized to that variable at the time when it used. How does it make sense in this context?

[![enter image description here][1]][1]

Trying to understand the the use of `LazySequence` in little more detail. I had used the `map`, `reduce` and `filter` functions on sequences, but never on `lazy` sequence. Need to understand why to use this?

  [1]: https://i.stack.imgur.com/kx3L9.png

Why and when to use lazy with Array in Swift?

I noticed that Scala provide `lazy vals`. But I don&#39;t get what they do.

    scala&gt; val x = 15
    x: Int = 15

    scala&gt; lazy val y = 13
    y: Int = &lt;lazy&gt;

    scala&gt; x
    res0: Int = 15

    scala&gt; y
    res1: Int = 13

The [REPL][1] shows that `y` is a `lazy val`, but how is it different from a normal `val`?

  [1]: http://en.wikipedia.org/wiki/Read-eval-print_loop


What does a lazy val do?

Is there a more succinct way to get one column of a dplyr tbl as a vector, from a tbl with database back-end (i.e. the data frame/table can&#39;t be subset directly)?

    require(dplyr)
    db &lt;- src_sqlite(tempfile(), create = TRUE)
    iris2 &lt;- copy_to(db, iris)
    iris2$Species
    # NULL

That would have been too easy, so

    collect(select(iris2, Species))[, 1]
    # [1] &quot;setosa&quot;     &quot;setosa&quot;     &quot;setosa&quot;     &quot;setosa&quot;  etc.

But it seems a bit clumsy.


Extract a dplyr tbl column as a vector

One handy feature of Scala is `lazy val`, where the evaluation of a `val` is delayed until it&#39;s necessary (at first access).

Of course, a `lazy val` must have some overhead - somewhere Scala must keep track of whether the value has already been evaluated and the evaluation must be synchronized, because multiple threads might try to access the value for the first time at the same time.

What exactly is the cost of a `lazy val` - is there a hidden boolean flag associated with a `lazy val` to keep track if it has been evaluated or not, what exactly is synchronized and are there any more costs?

In addition, suppose I do this:

    class Something {
        lazy val (x, y) = { ... }
    }

Is this the same as having two separate `lazy val`s `x` and `y` or do I get the overhead only once, for the pair `(x, y)`?


What&#39;s the (hidden) cost of Scala&#39;s lazy val?

In JDK 8 with lambda b93 there was a class [java.util.stream.Streams.zip in b93][1] which could be used to zip streams (this is illustrated in the tutorial [Exploring Java8 Lambdas. Part 1 by Dhananjay Nene][2]). This function :

&gt; Creates a lazy and sequential combined Stream whose elements are the
&gt; result of combining the elements of two streams.

However in b98 this has disappeared. Infact the `Streams` class is not even accessible in [java.util.stream in b98][3]. 

**Has this functionality been moved, and if so how do I zip streams concisely using b98?** 

The application I have in mind is [in this java implementation of Shen][4], where I replaced the zip functionality in the 

 - `static &lt;T&gt; boolean every(Collection&lt;T&gt; c1, Collection&lt;T&gt; c2, BiPredicate&lt;T, T&gt; pred)`
 - `static &lt;T&gt; T find(Collection&lt;T&gt; c1, Collection&lt;T&gt; c2, BiPredicate&lt;T, T&gt; pred)`

functions with rather verbose code (which doesn&#39;t use functionality from b98).


  [1]: http://download.java.net/lambda/b93/docs/api/java/util/stream/Streams.html
  [2]: http://blog.dhananjaynene.com/2013/02/exploring-java8-lambdas-part-1/  
  [3]: http://download.java.net/lambda/b98/docs/api/java/util/stream/package-summary.html
  [4]: https://github.com/hraberg/Shen.java/commit/e260f6a6c4f4012642b44c9a93c4a761cef18aa0#diff-0

Zipping streams using JDK8 with lambda (java.util.stream.Streams.zip)

While I was investigating a problem I had with lexical closures in Javascript code, I came along this problem in Python:

    flist = []
    
    for i in xrange(3):
        def func(x): return x * i
        flist.append(func)
    
    for f in flist:
        print f(2)

Note that this example mindfully avoids `lambda`. It prints &quot;4 4 4&quot;, which is surprising. I&#39;d expect &quot;0 2 4&quot;. 

This equivalent Perl code does it right:

    my @flist = ();
    
    foreach my $i (0 .. 2)
    {
        push(@flist, sub {$i * $_[0]});
    }
    
    foreach my $f (@flist)
    {
        print $f-&gt;(2), &quot;\n&quot;;
    }

&quot;0 2 4&quot; is printed.

Can you please explain the difference ?


----------


Update: 

The problem **is not** with `i` being global. This displays the same behavior:

    flist = []
    
    def outer():
        for i in xrange(3):
            def inner(x): return x * i
            flist.append(inner)
    
    outer()
    #~ print i   # commented because it causes an error
    
    for f in flist:
        print f(2)

As the commented line shows, `i` is unknown at that point. Still, it prints &quot;4 4 4&quot;.





How do lexical closures work?

I am trying to read a large file one line at a time. I found [a question on Quora][1] that dealt with the subject but I&#39;m missing some connections to make the whole thing fit together.

     var Lazy=require(&quot;lazy&quot;);
     new Lazy(process.stdin)
         .lines
         .forEach(
              function(line) { 
	              console.log(line.toString()); 
	          }
     );
     process.stdin.resume();


The bit that I&#39;d like to figure out is how I might read one line at a time from a file instead of STDIN as in this sample.

I tried: 

     fs.open(&#39;./VeryBigFile.csv&#39;, &#39;r&#39;, &#39;0666&#39;, Process);

     function Process(err, fd) {
     	if (err) throw err;
        // DO lazy read 
     }

but it&#39;s not working.  I know that in a pinch I could fall back to using something like PHP, but I would like to figure this out.  

I don&#39;t think the other answer would work as the file is much larger than the server I&#39;m running it on has memory for. 

  [1]: http://www.quora.com/What-is-the-best-way-to-read-a-file-line-by-line-in-node-js

Read a file one line at a time in node.js?

The code for the myAny function in &lt;a href=&quot;https://stackoverflow.com/questions/833186/why-does-this-haskell-code-work-successfully-with-infinite-lists/833218&quot;&gt;this question&lt;/a&gt; uses foldr.  It stops processing an infinite list when the predicate is satisfied.

I rewrote it using foldl:

&lt;pre&gt;&lt;code&gt;myAny :: (a -&gt; Bool) -&gt; [a] -&gt; Bool
myAny p list = foldl step False list
   where
      step acc item = p item || acc&lt;/code&gt;&lt;/pre&gt;

(Note that the arguments to the step function are correctly reversed.)

However, it no longer stops processing infinite lists.

I attempted to trace the function&#39;s execution as in &lt;a href=&quot;https://stackoverflow.com/questions/833186/why-does-this-haskell-code-work-successfully-with-infinite-lists/833218#833218&quot;&gt;Apocalisp&#39;s answer&lt;/a&gt;:

&lt;pre&gt;&lt;code&gt;myAny even [1..]
foldl step False [1..]
step (foldl step False [2..]) 1
even 1 || (foldl step False [2..])
False  || (foldl step False [2..])
foldl step False [2..]
step (foldl step False [3..]) 2
even 2 || (foldl step False [3..])
True   || (foldl step False [3..])
True&lt;/code&gt;&lt;/pre&gt;

However, this is not the way the function behaves.  How is this wrong?

foldl versus foldr behavior with infinite lists

I have long been wondering why lazy evaluation is useful. I have yet to have anyone explain to me in a way that makes sense; mostly it ends up boiling down to &quot;trust me&quot;.

Note: I do not mean memoization. 

Why is lazy evaluation useful?

By what mechanism is this fibonacci-function memoized?

    fib = (map fib&#39; [0..] !!)                 
         where fib&#39; 1 = 1                                                        
               fib&#39; 2 = 1                                                        
               fib&#39; n = fib (n-2) + fib (n-1)                    

And on a related note, why is this version not?

    fib n = (map fib&#39; [0..] !! n)                                               
         where fib&#39; 1 = 1                                                        
               fib&#39; 2 = 1                                                        
               fib&#39; n = fib (n-2) + fib (n-1)                    

How is this fibonacci-function memoized?

I tried the following in Clojure, expecting to have the class of a non-lazy sequence returned:

    (.getClass (doall (take 3 (repeatedly rand))))

However, this still returns `clojure.lang.LazySeq`.  My guess is that `doall` does evaluate the entire sequence, but returns the original sequence as it&#39;s still useful for memoization.

So what is the idiomatic means of creating a non-lazy sequence from a lazy one?
 

How to convert lazy sequence to non-lazy in Clojure

I discovered the &quot;time&quot; command in unix today and thought I&#39;d use it to check the difference in runtimes between tail-recursive and normal recursive functions in Haskell.

I wrote the following functions:

    --tail recursive
    fac :: (Integral a) =&gt; a -&gt; a
    fac x = fac&#39; x 1 where
    	fac&#39; 1 y = y
    	fac&#39; x y = fac&#39; (x-1) (x*y) 
    
    --normal recursive
    facSlow :: (Integral a) =&gt; a -&gt; a
    facSlow 1 = 1
    facSlow x = x * facSlow (x-1)

These are valid keeping in mind they were solely for use with this project, so I didn&#39;t bother to check for zeroes or negative numbers.

However, upon writing a main method for each, compiling them, and running them with the &quot;time&quot; command, both had similar runtimes with the *normal* recursive function edging out the tail recursive one. This is contrary to what I&#39;d heard with regards to tail-recursive optimization in lisp. What&#39;s the reason for this?


Does Haskell have tail-recursive optimization?

AngularJS has a new feature since the version 1.3.0-beta.10: the [&quot;lazy one-time binding&quot;][1].

Simple expressions can be prefixed with `::`, telling angular to stop watching after the expression was first evaluated. The common example given is something like:

    &lt;div&gt;{{::user.name}}&lt;/div&gt;

Is there a similar syntax for expressions like the following ones?

    &lt;div ng-if=&quot;user.isSomething &amp;&amp; user.isSomethingElse&quot;&gt;&lt;/div&gt;
    &lt;div ng-class=&quot;{classNameFoo: user.isSomething}&quot;&gt;&lt;/div&gt;

  [1]: https://github.com/angular/angular.js/commit/cee429f0aaebf32ef1c9aedd8447a48f163dd0a4

Angular lazy one-time binding for expressions

We all know (or should know) that Haskell is lazy by default. Nothing is evaluated until it must be evaluated. So when must something be evaluated? There are points where Haskell must be strict. I call these &quot;strictness points&quot;, although this particular term isn&#39;t as widespread as I had thought. According to me:

&gt; Reduction (or evaluation) in Haskell *only* occurs at strictness points.

So the question is: **what, *precisely*, are Haskell&#39;s strictness points?** My intuition says that `main`, `seq` / bang patterns, pattern matching, and any `IO` action performed via `main` are the primary strictness points, but I don&#39;t really know why I know that.

(Also, if they&#39;re not called &quot;strictness points&quot;, what *are* they called?)

I imagine a good answer will include some discussion about WHNF and so on. I also imagine it might touch on lambda calculus.

----

*Edit: additional thoughts about this question.*

As I&#39;ve reflected on this question, I think it would be clearer to add something to the definition of a strictness point. Strictness points can have varying *contexts* and varying *depth* (or strictness). Falling back to my definition that &quot;reduction in Haskell only occurs at strictness points&quot;, let us add to that definition this clause: &quot;a strictness point is only triggered when its surrounding context is evaluated or reduced.&quot;

So, let me try to get you started on the kind of answer I want. `main` is a strictness point. It is specially designated as the primary strictness point of its context: the program. When the program (`main`&#39;s context) is evaluated, the strictness point of main is activated. Main&#39;s depth is maximal: it must be fully evaluated. Main is usually composed of IO actions, which are also strictness points, whose context is `main`.

Now you try: discuss `seq` and pattern matching in these terms. Explain the nuances of function application: how is it strict? How is it not? What about `deepseq`? `let` and `case` statements? `unsafePerformIO`? `Debug.Trace`? Top-level definitions? Strict data types? Bang patterns? Etc. How many of these items can be described in terms of just seq or pattern matching?

What are Haskell&#39;s strictness points?

I&#39;ve generally heard that production code should avoid using Lazy I/O. My question is, why? Is it ever OK to use Lazy I/O outside of just toying around? And what makes the alternatives (e.g. enumerators) better?

What&#39;s so bad about Lazy I/O?

Is it always more performant to use withFilter instead of filter, when afterwards applying       functions like map, flatmap etc.?

Why are only map, flatmap and foreach supported? (Expected functions like forall/exists as well)  

withFilter instead of filter

For example, if I have the following statement:

    if( foo1 or foo2)
        ...
        ...
if foo1 is true, will python check the condition of foo2?

Does Python evaluate if&#39;s conditions lazily?

C++ does not have native support for lazy evaluation (as Haskell does).

I&#39;m wondering if it is possible to implement lazy evaluation in C++ in a reasonable manner. If yes, how would you do it?

EDIT: I like Konrad Rudolph&#39;s answer.

I&#39;m wondering if it&#39;s possible to implement it in a more generic fashion, for example by using a parametrized class lazy&lt;T&gt; that essentially works for T the way matrix_add works for matrix.

Any operation on T would return lazy&lt;T&gt; instead. The only problem is to store the arguments and operation code inside lazy&lt;T&gt; itself. Can anyone see how to improve this?

Lazy evaluation in C++

Here&#39;s one that has me perplexed. I&#39;m trying to implement a basic Hibernate DAO structure, but am having a problem.

Here&#39;s the essential code:

	int startingCount = sfdao.count();
	sfdao.create( sf );
	SecurityFiling sf2 = sfdao.read( sf.getId() );
	sfdao.delete( sf );
	int endingCount = sfdao.count();

	assertTrue( startingCount == endingCount );
	assertTrue( sf.getId().longValue() == sf2.getId().longValue() );
	assertTrue( sf.getSfSubmissionType().equals( sf2.getSfSubmissionType() ) );
	assertTrue( sf.getSfTransactionNumber().equals( sf2.getSfTransactionNumber() ) );

It fails on the third assertTrue where it&#39;s trying to compare a value in sf to the corresponding value in sf2. Here&#39;s the exception:

    org.hibernate.LazyInitializationException: could not initialize proxy - no Session
    	at org.hibernate.proxy.AbstractLazyInitializer.initialize(AbstractLazyInitializer.java:86)
    	at org.hibernate.proxy.AbstractLazyInitializer.getImplementation(AbstractLazyInitializer.java:140)
    	at org.hibernate.proxy.pojo.javassist.JavassistLazyInitializer.invoke(JavassistLazyInitializer.java:190)
    	at com.freightgate.domain.SecurityFiling_$$_javassist_7.getSfSubmissionType(SecurityFiling_$$_javassist_7.java)
    	at com.freightgate.dao.SecurityFilingTest.test(SecurityFilingTest.java:73)
    	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    	at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)
    	at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)
    	at com.intellij.rt.execution.junit.JUnitStarter.main(JUnitStarter.java:40)




hibernate: LazyInitializationException: could not initialize proxy

I&#39;m having a hard time understanding the difference between `rest` and `next` in Clojure. [The official site&#39;s page on laziness](http://clojure.org/lazy) indicates that the preference should probably be to use `rest`, but it doesn&#39;t really explain clearly the difference between the two. Can anybody provide some insight?

Clojure: rest vs. next

I was looking around stackoverflow [Non-Trivial Lazy Evaluation][1], which led me to Keegan McAllister&#39;s presentation: [Why learn Haskell][2]. In slide 8, he shows the minimum function, defined as:

    minimum = head . sort

and states that its complexity is O(n). I don&#39;t understand why the complexity is said to be linear if sorting by replacement is O(nlog n). The sorting referred in the post can&#39;t be linear, as it does not assume anything about the data, as it would be required by linear sorting methods, such as counting sort.

Is lazy evaluation playing a mysterious role in here? If so, what is the explanation behind it?


  [1]: https://stackoverflow.com/questions/7868507/non-trivial-lazy-evaluation
  [2]: http://ugcs.net/~keegan/talks/why-learn-haskell/talk.pdf

Lazy Evaluation and Time Complexity

I&#39;m learning Haskell, and came across the following code:

    fibs = 0 : 1 : zipWith (+) fibs (tail fibs)

which I&#39;m having a bit of trouble parsing, in terms of how it works. It&#39;s very neat, I understand that nothing more is needed, but I&#39;d like to understand how Haskell manages to &quot;fill in&quot; fibs when I write:

    take 50 fibs

Any help?

Thanks!

Understanding a recursively defined list (fibs in terms of zipWith)

Am I right understanding that

 - `def` is evaluated every time it gets accessed

 - `lazy val` is evaluated once it gets accessed

 - `val` is evaluated once it gets into the execution scope?

`def` vs `val` vs `lazy val` evaluation in Scala

Is it bad practice to change my getter method like version 2 in my class.

Version 1:

     public String getMyValue(){
         return this.myValue
     }

Version 2:

     public String getMyValue(){
 
        if(this.myValue == null || this.myValue.isEmpty()){
           this.myValue = &quot;N/A&quot;;
        }

        return this.myValue;
     }


Is it bad practice to have my getter method change the stored value?

I often read that **lazy** is not the same as **non-strict** but I find it hard to understand the difference. They *seem* to be used interchangeably but I understand that they have different meanings. I would appreciate some help understanding the difference.

I have a few questions which are scattered about this post. I will summarize those questions at the end of this post. I have a few example snippets, I did not test them, I only presented them as concepts. I have added quotes to save you from looking them up. Maybe it will help someone later on with the same question.

Non-Strict Def:
--------------

&gt; A function f is said to be strict if, when applied to a nonterminating
&gt; expression, it also fails to terminate. In other words, f is strict
&gt; iff the value of f bot is _|_. For most programming languages, all
&gt; functions are strict. But this is not so in Haskell. As a simple
&gt; example, consider const1, the constant 1 function, defined by: 
&gt; 
&gt; const1 x                = 1
&gt; 
&gt; The value of const1 bot in Haskell is 1. Operationally speaking, since
&gt; const1 does not &quot;need&quot; the value of its argument, it never attempts to
&gt; evaluate it, and thus never gets caught in a nonterminating
&gt; computation. For this reason, non-strict functions are also called
&gt; &quot;lazy functions&quot;, and are said to evaluate their arguments &quot;lazily&quot;,
&gt; or &quot;by need&quot;.

-[A Gentle Introduction To Haskell: Functions][1]

I really like this definition. It seems the best one I could find for understanding strict. Is `const1 x = 1` lazy as well?


&gt; Non-strictness means that reduction (the mathematical term for
&gt; evaluation) proceeds from the outside in,
&gt; 
&gt; so if you have (a+(b*c)) then first you reduce the +, then you reduce
&gt; the inner (b*c).

-[Haskell Wiki: Lazy vs non-strict][2]

The Haskell Wiki really confuses me. I understand what they are saying about order but I fail to see how `(a+(b*c))` would evaluate non-strictly if it was pass `_|_`?

&gt; In non-strict evaluation, arguments to a function are not evaluated
&gt; unless they are actually used in the evaluation of the function body.
&gt; 
&gt; Under Church encoding, lazy evaluation of operators maps to non-strict
&gt; evaluation of functions; for this reason, non-strict evaluation is
&gt; often referred to as &quot;lazy&quot;. Boolean expressions in many languages use
&gt; a form of non-strict evaluation called short-circuit evaluation, where
&gt; evaluation returns as soon as it can be determined that an unambiguous
&gt; Boolean will result — for example, in a disjunctive expression where
&gt; true is encountered, or in a conjunctive expression where false is
&gt; encountered, and so forth. Conditional expressions also usually use
&gt; lazy evaluation, where evaluation returns as soon as an unambiguous
&gt; branch will result.

-[Wikipedia: Evaluation Strategy][3]

Lazy Def:
-----

&gt; Lazy evaluation, on the other hand, means only evaluating an
&gt; expression when its results are needed (note the shift from
&gt; &quot;reduction&quot; to &quot;evaluation&quot;). So when the evaluation engine sees an
&gt; expression it builds a thunk data structure containing whatever values
&gt; are needed to evaluate the expression, plus a pointer to the
&gt; expression itself. When the result is actually needed the evaluation
&gt; engine calls the expression and then replaces the thunk with the
&gt; result for future reference.
&gt; ...
&gt; 
&gt; Obviously there is a strong correspondence between a thunk and a
&gt; partly-evaluated expression. Hence in most cases the terms &quot;lazy&quot; and
&gt; &quot;non-strict&quot; are synonyms. But not quite.

-[Haskell Wiki: Lazy vs non-strict][4]

This seems like a Haskell specific answer. I take that **lazy** means thunks and **non-strict** means partial evaluation. Is that comparison too simplified? Does **lazy** always mean thunks and **non-strict** always mean partial evaluation.

&gt; In programming language theory, lazy evaluation or call-by-need[1] is
&gt; an evaluation strategy which delays the evaluation of an expression
&gt; until its value is actually required (non-strict evaluation) and also
&gt; avoid repeated evaluations (sharing).

-[Wikipedia: Lazy Evaluation][5]


Imperative Examples
------
I know most people say forget imperative programming when learning a functional language. However, I would like to know if these qualify as non-strict, lazy, both or neither? At the very least it would provide something familiar.


**Short Circuiting**

    f1() || f2()

**C#, Python and other languages with &quot;yield&quot;**

    public static IEnumerable Power(int number, int exponent)
    {
        int counter = 0;
        int result = 1;
        while (counter++ &lt; exponent)
        {
            result = result * number;
            yield return result;
        }
    }

-[MSDN: yield (c#)][6]

**Callbacks**

    int f1() { return 1;}
    int f2() { return 2;}

    int lazy(int (*cb1)(), int (*cb2)() , int x) {
        if (x == 0)
            return cb1();
        else
            return cb2();
    }

    int eager(int e1, int e2, int x) {
        if (x == 0)
             return e1;
        else
             return e2;
    }
   
    lazy(f1, f2, x);
    eager(f1(), f2(), x);

Questions
----

I know the answer is right in front of me with all those resources, but I can&#39;t grasp it. It all seems like the definition is too easily dismissed as implied or obvious.

I know I have a lot of questions. Feel free to answer whatever questions you feel are relevant. I added those questions for discussion.

 - Is `const1 x = 1` also lazy?
 - How is evaluating from &quot;inward&quot; non-strict? Is it because inward allows reductions of unnecessary expressions, like in `const1 x = 1`? Reductions seem to fit the definition of lazy.
 - Does **lazy** always mean **thunks** and **non-strict** always mean **partial evaluation**? Is this just a generalization?
 - Are the following imperative concepts Lazy, Non-Strict, Both or Neither?
    - Short Circuiting
    - Using yield
    - Passing Callbacks to delay or avoid execution
 - Is **lazy** a subset of **non-strict** or vice versa, or are they mutually exclusive. For example is it possible to be **non-strict** without being **lazy**, or **lazy** without being **non-strict**?
 - Is Haskell&#39;s non-strictness achieved by laziness?

Thank you SO!


  [1]: http://www.haskell.org/tutorial/functions.html
  [2]: http://www.haskell.org/haskellwiki/Lazy_vs._non-strict
  [3]: http://en.wikipedia.org/wiki/Evaluation_strategy#Non-strict_evaluation
  [4]: http://www.haskell.org/haskellwiki/Lazy_vs._non-strict
  [5]: http://en.wikipedia.org/wiki/Lazy_evaluation
  [6]: http://msdn.microsoft.com/en-us/library/9k7k7cf0%28v=vs.80%29.aspx
  [7]: http://en.wikipedia.org/wiki/Evaluation_strategy
  [8]: http://webcache.googleusercontent.com/search?q=cache:o7wQ-sooFyUJ:citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.35.1663&amp;rep=rep1&amp;type=ps%20%22call%20by%20need%22%20imperative%20language&amp;cd=3&amp;hl=en&amp;ct=clnk&amp;gl=ca&amp;source=www.google.ca
  [9]: http://en.wikipedia.org/wiki/Evaluation_strategy
  [10]: http://en.wikipedia.org/wiki/Evaluation_strategy#Non-strict_evaluation

How does non-strict and lazy differ?

I found this article about `Lazy`: [Laziness in C# 4.0 – Lazy&lt;T&gt;](http://sankarsan.wordpress.com/2009/10/04/laziness-in-c-4-0-lazyt/)

What is the best practice to have best performance using Lazy objects?
Can someone point me to a practical use in a real application? In other words, when should I use it?

When should I use Lazy&lt;T&gt;?

I want to parameterise the following computation using `dplyr` that finds which values of `Sepal.Length` are associated with more than one value of `Sepal.Width`:

    library(dplyr)

    iris %&gt;%
        group_by(Sepal.Length) %&gt;%
        summarise(n.uniq=n_distinct(Sepal.Width)) %&gt;%
        filter(n.uniq &gt; 1)

Normally I would write something like this:

    not.uniq.per.group &lt;- function(data, group.var, uniq.var) {
        iris %&gt;%
            group_by(group.var) %&gt;%
            summarise(n.uniq=n_distinct(uniq.var)) %&gt;%
            filter(n.uniq &gt; 1)
    }

However, this approach throws errors because `dplyr` uses [non-standard evaluation](http://adv-r.had.co.nz/Computing-on-the-language.html). How should this function be written?

Pass arguments to dplyr functions

What is lazy evaluation in Python?

One website said : 

In Python 3.x the `range()` function returns a special range object which computes elements of the list on demand (lazy or deferred evaluation):

    
    &gt;&gt;&gt; r = range(10)
    &gt;&gt;&gt; print(r)
    range(0, 10)
    &gt;&gt;&gt; print(r[3])
    3

What is meant by this?

Lazy evaluation in Python

Haskell has a magical function named `seq`, which takes an argument of any type and reduces it to *Weak Head Normal Form* (WHNF).

I&#39;ve read a couple of sources [not that I can remember who they were _now_...] which claim that &quot;polymorphic `seq` is bad&quot;. In what way are they &quot;bad&quot;?

Similarly, there is the `rnf` function, which reduces an argument to *Normal Form* (NF). But _this_ is a class method; it does not work for arbitrary types. It seems &quot;obvious&quot; to me that one could alter the language spec to provide this as a built-in primitive, similar to `seq`. This, presumably, would be &quot;even more bad&quot; than just having `seq`. In what way is this so?

Finally, somebody suggested that giving `seq`, `rnf`, `par` and similars the same type as the `id` function, rather than the `const` function as it is now, would be an improvement. How so?


Why is seq bad?

I have this code:


    public class MyClass
    {
        public int X { get; set; }
        public int Y { get; set; }

        private Lazy&lt;int&gt; lazyGetSum = new Lazy&lt;int&gt;(new Func&lt;int&gt;(() =&gt; X + Y));
        public int Sum{ get { return lazyGetSum.Value; } }

    }

Gives me this error:

&gt; A field initializer cannot reference the non-static field, method, or
&gt; property.


I think it is very reasonable to access a non-static member via lazy, how to do this?


*** EDIT ***

The accepted answer solves the problem perfectly, but to see the detailed and in-depth -as always- reason of the problem you can read [Joh Skeet&#39;s answer][1].


  [1]: https://stackoverflow.com/a/14029456/283787

Accessing a non-static member via Lazy&lt;T&gt; or any lambda expression

I am reading Hadley Wickhams&#39;s book on Github, in particular [this part on lazy evaluation][1]. There he gives an example of consequences of lazy evaluation, in the part with `add/adders` functions. Let me quote that bit: 

&gt; This [lazy evaluation] is important when creating closures with lapply or a loop:
&gt; 
&gt; 
&gt;     add &lt;- function(x) {
&gt;       function(y) x + y
&gt;     }
&gt;     adders &lt;- lapply(1:10, add)
&gt;     adders[[1]](10)
&gt;     adders[[10]](10)
&gt; 
&gt; x is lazily evaluated the first time that you call one of the adder
&gt; functions. At this point, the loop is complete and the final value of
&gt; x is 10. Therefore all of the adder functions will add 10 on to their
&gt; input, probably not what you wanted! Manually forcing evaluation fixes
&gt; the problem:
&gt; 
&gt; 
&gt;     add &lt;- function(x) {
&gt;       force(x)
&gt;       function(y) x + y
&gt;     }
&gt;     adders2 &lt;- lapply(1:10, add)
&gt;     adders2[[1]](10)
&gt;     adders2[[10]](10)

I do not seem to understand that bit, and the explanation there is minimal. Could someone please elaborate that particular example, and explain what happens there? I am specifically puzzled by the sentence &quot;at this point, the loop is complete and the final value of x is 10&quot;. What loop? What final value, where? Must be something simple I am missing, but I just don&#39;t see it. Thanks a lot in advance.

  [1]: http://adv-r.had.co.nz/Functions.html#lazy-evaluation


Explain a lazy evaluation quirk

When writing code like this in C++:

    bool allTrue = true;
    allTrue = allTrue &amp;&amp; check_foo();
    allTrue = allTrue &amp;&amp; check_bar();

`check_bar()` will not be evaluated if `check_foo()` returned `false`. This is called [short-circuiting or short-circuit evaluation](http://en.wikipedia.org/wiki/Short-circuit_evaluation) and is part of the lazy evaluation principle.

Does this work with the compound assignment operator `&amp;=`?

    bool allTrue = true;
    allTrue &amp;= check_foo();
    allTrue &amp;= check_bar(); //what now?

*For logical `OR` replace all `&amp; ` with `|` and `true` with `false`.*

All Lazy Evaluation Solutions on Gang of Coders

Total of 34 Lazy Evaluation Solutions