Make the Lazy basic implementation much faster...

elm-package.json

@@ -1,5 +1,4 @@
 {
-    "version": "2.0.0",
     "summary": "Basic primitives for working with laziness",
     "repository": "http://github.com/elm-lang/lazy.git",
     "license": "BSD3",

src/Lazy.elm

@@ -1,14 +1,14 @@
 module Lazy exposing
     ( Lazy
-    , force, lazy
+    , force, lazy, lazyFromValue
     , map, map2, map3, map4, map5
     , apply, andThen
     )
 
 {-| This library lets you delay a computation until later.
 
 # Basics
-@docs Lazy, lazy, force
+@docs Lazy, lazy, lazyFromValue, force
 
 # Mapping
 @docs map, map2, map3, map4, map5
@@ -25,8 +25,9 @@ import Native.Lazy
 
 
 {-| A wrapper around a value that will be lazily evaluated. -}
-type Lazy a =
-  Lazy (() -> a)
+type Lazy a
+  = Evaluated a
+  | Unevaluated (() -> a)
 
 
 {-| Delay the evaluation of a value until later. For example, maybe we will
@@ -41,7 +42,25 @@ Now we only pay for `lazySum` if we actually need it.
 -}
 lazy : (() -> a) -> Lazy a
 lazy thunk =
-  Lazy (Native.Lazy.memoize thunk)
+  Unevaluated thunk
+
+
+{-| `lazyFromValue' Sets the created Lazy a to an already evaluated value.
+For example, maybe we want to set the tail of a lazy list to an Empty node so
+there is no need to defer the calculation as it is a simple constant:
+
+    type LazyList a = Empty | Cons a (Lazy (LazyList a))
+
+    shortLazyList : LazyList Int
+    shortLazyList =
+      Cons 1 <| lazyFromValue Empty
+
+Now the tail of the shortLazyList is immediately available to
+force without calling an evaluation functtion.
+-}
+lazyFromValue : a -> Lazy a
+lazyFromValue v =
+  Evaluated v
 
 
 {-| Force the evaluation of a lazy value. This means we only pay for the
@@ -61,8 +80,10 @@ the first one, but all the rest are very cheap, basically just looking up a
 value in memory.
 -}
 force : Lazy a -> a
-force (Lazy thunk) =
-  thunk ()
+force lzy =
+  case lzy of
+    Evaluated a -> a
+    Unevaluated _ -> Native.Lazy.memoize lzy
 
 
 
@@ -134,30 +155,34 @@ apply f x =
 steps that all need to be performed lazily. This can be nice when you need to
 pattern match on a value, for example, when appending lazy lists:
 
-    type List a = Empty | Node a (Lazy (List a))
+    type LazyList a = Empty | Cons a (Lazy (LazyList a))
 
-    cons : a -> Lazy (List a) -> Lazy (List a)
-    cons first rest =
-      Lazy.map (Node first) rest
+    cons : a -> Lazy (LazyList a) -> Lazy (LazyList a)
+    cons v lazylist =
+      Lazy.map (\x -> Cons v <| lazy (\() -> x)) lazylist
 
-    append : Lazy (List a) -> Lazy (List a) -> Lazy (List a)
-    append lazyList1 lazyList2 =
+    append : Lazy (LazyList a) -> Lazy (LazyList a) -> Lazy (LazyList a)
+    append list1 list2 =
       let
-        appendHelp list1 =
-          case list1 of
-            Empty ->
-              lazyList2
-
-            Node first rest ->
-              cons first (append rest list2))
-      in
-        lazyList1
-          |> Lazy.andThen appendHelp
-
-
-By using `andThen` we ensure that neither `lazyList1` or `lazyList2` are forced
+        appendi lazylist1 =
+          let appendHelp ll1 =
+            case ll1 of
+              Empty -> list2
+              Cons first rest ->
+                cons first (appendi rest)
+          in
+            lazylist1 |> Lazy.andThen appendHelp
+      in appendi list1
+
+
+By using `andThen` we ensure that neither `lazyList1` nor `lazyList2` are forced
 before they are needed. So as written, the `append` function delays the pattern
 matching until later.
+Note that although this is the way to write `cons' and `append' for a `Lazy (Lazylist a)`
+so as to avoid "The Halting Problem" and make infinite lazy lists possible inside the wrapper,
+which would otherwise cause stack overflow (or detection and an exception thrown),
+the extra level of laziness of the outer `Lazy' wrapper costs much in terms of performance
+due to the number of force/thunk/lazy chains of function calls/composition needed.
 -}
 andThen : (a -> Lazy b) -> Lazy a -> Lazy b
 andThen callback a =

src/Native/Lazy.js

@@ -1,16 +1,14 @@
 var _elm_lang$lazy$Native_Lazy = function() {
 
-function memoize(thunk)
-{
-    var value;
-    var isForced = false;
-    return function(tuple0) {
-        if (!isForced) {
-            value = thunk(tuple0);
-            isForced = true;
-        }
-        return value;
-    };
+// mutates `lzy` Unevaluated thunk into Evaluated value, returning value.
+function memoize(lzy) {
+    if (lzy.ctor === 'Evaluating')
+        throw Error("Lazy.memoize:  recursive evaluation error!!!");
+    lzy.ctor = 'Evaluating';
+    var v = lzy._0(lzy); // dummy placeholder arg
+    lzy.ctor = 'Evaluated';
+    lzy._0 = v;
+    return v;
 }
 
 return {