title: Can every functional language be lazy?
body: <p>In a functional language, functions are first class citizens and thus <em>calling</em> them is not the only thing I can do. I can also store them away. </p>
  
  <p>Now when I have a language, which is strict by default, then I am still not forced to evaluate a function call. I have the option to store the function and its parameters e.g. in a tuple for later evaluation. </p>
  
  <p>So instead of</p>
  
  <pre><code>x = f a b c
  </code></pre>
  
  <p>I do something like</p>
  
  <pre><code>x = (f,a,b,c)
  </code></pre>
  
  <p>And later, I can evaluate this thing with something like</p>
  
  <pre><code>eval (f,a,b,c) = f a b c
  </code></pre>
  
  <p>Well, there is probably more to it, because I want to evaluate each unevaluated function call only once, but it seems to me, that this can also be solved with a data structure which is a bit fancier than just a tuple.</p>
  
  <p>The inverse also seems to be the case, because e.g. in Haskell, which is lazy be default I can enforce evaluation with <code>seq</code> or <code>BangPatterns</code>.</p>
  
  <p>So is it correct to say, that every functional language has the potential of being lazy, but most of them are just not lazy <em>by default</em> and thus require additional programming effort to call a function lazily, whereas haskell <em>is</em> lazy by default and requires additional programming effort to call a function in a strict way?</p>
  
  <p>Should that be the case, what is more difficult for the programmer: writing lazy function calls in a strict language or writing strict function calls in a lazy language?</p>
  
  <p>As a side note: was Simon P. Jone serious when he said: "the next version of haskell will be strict". I first thought that this was a joke. But now I think <em>strict by default</em> isn't all that bad as long as you can be lazy if required.</p>