Initial commit, migrating stuff from elm-lang/core

Author: process-bot

LICENSE

@@ -0,0 +1,27 @@
+Copyright (c) 2016, Evan Czaplicki
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the {organization} nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

README.md

@@ -0,0 +1,7 @@
+# Trampolines
+
+Popular JavaScript implementations do not perform any tail-call elimination, so recursive functions can cause a stack overflow if they go too deep. That said, the Elm compiler optimizes [tail calls](https://en.wikipedia.org/wiki/Tail_call) into loops for functions that call themselves, so most situations will just get optimized behind the scenes for you.
+
+The compiler does not do anything for *mutually* tail-recursive functions though. If you find yourself needing that, you can use a [trampoline](http://en.wikipedia.org/wiki/Tail-recursive_function#Through_trampolining). Trampolines make it possible to call functions recursively without growing the stack.
+
+This strategy creates intermediate closures, which is very expensive in JavaScript, so use this library only when it is essential that you recurse deeply.

src/Trampoline.elm

@@ -0,0 +1,50 @@
+module Trampoline
+  ( trampoline
+  , Trampoline
+  , done, continue
+  )
+  where
+
+{-| A [trampoline](http://en.wikipedia.org/wiki/Tail-recursive_function#Through_trampolining)
+makes it possible to recursively call a function without growing the stack.
+
+Popular JavaScript implementations do not perform any tail-call elimination, so
+recursive functions can cause a stack overflow if they go too deep. Trampolines
+permit unbounded recursion despite limitations in JavaScript.
+
+This strategy may create many intermediate closures, which is very expensive in
+JavaScript, so use this library only when it is essential that you recurse deeply.
+
+# Trampolines
+@docs Trampoline, done, jump, evaluate
+-}
+
+
+{-| A computation that has been broken up into a bunch of smaller chunks. The
+programmer explicitly adds "pause points" so each chunk of computation can be
+run without making the stack any deeper.
+-}
+type Trampoline a
+    = Done a
+    | Jump (() -> Trampoline a)
+
+
+done : a -> Trampoline a
+done =
+  Done
+
+
+jump : (() -> Trampoline a) -> Trampoline a
+jump =
+  Jump
+
+
+{-| Evaluate a trampolined value in constant space. -}
+evaluate : Trampoline a -> a
+evaluate trampoline =
+  case trampoline of
+    Done value ->
+      value
+
+    Jump f ->
+      evaluate (f ())