Why is lazy evaluation useful?

by

Mostly because it can be more efficient — values don’t need to be computed if they’re not going to be used. For example, I may pass three values into a function, but depending on the sequence of conditional expressions, only a subset may actually be used. In a language like C, all three values would be computed anyway; but in Haskell, only the necessary values are computed.

It also allows for cool stuff like infinite lists. I can’t have an infinite list in a language like C, but in Haskell, that’s no problem. Infinite lists are used fairly often in certain areas of mathematics, so it can be useful to have the ability to manipulate them.

More Related Contents:

  1. Haskell: moving image on horizontal line
  2. Getting started with Haskell
  3. Applicatives compose, monads don’t
  4. What does (f .) . g mean in Haskell?
  5. Is there a Haskell idiom for updating a nested data structure?
  6. What’s so bad about Lazy I/O?
  7. Is monad bind (>>=) operator closer to function composition (chaining) or function application?
  8. Large-scale design in Haskell? [closed]
  9. What does the exclamation mark mean in a Haskell declaration?
  10. How to compare two functions for equivalence, as in (λx.2*x) == (λx.x+x)?
  11. What are “n+k patterns” and why are they banned from Haskell 2010?
  12. Should do-notation be avoided in Haskell?
  13. Applicative functor evaluation is not clear to me
  14. What constitutes a fold for types other than list?
  15. Ordering of parameters to make use of currying
  16. How to use (->) instances of Monad and confusion about (->)
  17. How to increment a variable in functional programming?
  18. What part of Hindley-Milner do you not understand?
  19. Non-Trivial Lazy Evaluation
  20. Iterate over all pair combinations without repetition in Haskell
  21. What’s the status of multicore programming in Haskell?
  22. What does “pure” mean in “pure functional language”?
  23. Implement zip using foldr
  24. How to enumerate a recursive datatype in Haskell?
  25. Functional lenses
  26. Why does OCaml sometimes require eta expansion?
  27. Removing syntactic sugar: List comprehension in Haskell
  28. How Monads are considered pure?
  29. Explanation of “tying the knot”
  30. Is Haskell’s mapM not lazy?

Leave a Comment