Address feedback and update README

README.md

@@ -143,6 +143,15 @@ somePromiseGetter()
 
 See [Composible Error Handling in OCaml][error-handling] for several strategies that you may employ.
 
+### Stack Safety
+
+By default this library is not stack safe, you will recieve a 'Maximum call stack size exceeded' error if you recurse too deeply. You can opt into stack safety by passing an optional parameter to the constructors of trampoline. This has a slight overhead. For example:
+
+```reason
+let stackSafe = Future.make(~executor=`trampoline, resolver);
+let stackSafeValue = Future.value(~executor=`trampoline, "Value");
+```
+
 ## TODO
 
 - [ ] Implement cancellation tokens

__tests__/TestFuture.re

@@ -317,16 +317,23 @@ describe("Future Belt.Result", () => {
     let numberOfLoops = 10000;
     let rec loop = x => {
       next(x)
+      ->Future.flatMap(x => Future.value(x + 1))
+      ->Future.map(x => x + 1)
+      ->Future.flatMap(x =>
+          Future.value(x + 1)->Future.flatMap(x => Future.value(x + 1))
+        )
       ->Future.flatMap(x' =>
-          if (x' == numberOfLoops) {
+          if (x' > numberOfLoops) {
             Future.value(x');
           } else {
             loop(x');
           }
         );
     };
     loop(0)
-    ->Future.get(r => r |> expect |> toEqual(numberOfLoops) |> finish);
+    ->Future.get(r =>
+        r |> expect |> toBeGreaterThan(numberOfLoops) |> finish
+      );
   });
 
   testAsync("async recursion is stack safe", finish => {
@@ -345,4 +352,23 @@ describe("Future Belt.Result", () => {
     loop(0)
     ->Future.get(r => r |> expect |> toEqual(numberOfLoops) |> finish);
   });
+
+  test("value recursion blows the stack with default executor", () => {
+    let next = x => Future.value(x + 1);
+    let numberOfLoops = 10000;
+    let rec loop = x => {
+      next(x)
+      ->Future.flatMap(x' =>
+          if (x' > numberOfLoops) {
+            Future.value(x');
+          } else {
+            loop(x');
+          }
+        );
+    };
+    expect(() =>
+      loop(0)
+    )
+    |> toThrowMessage("Maximum call stack size exceeded");
+  });
 });

__tests__/TestUtil.re

@@ -5,4 +5,6 @@ type timeoutId;
 external setTimeout: ([@bs.uncurry] (unit => unit), int) => timeoutId = "";
 
 let delay = (~executor=`none, ms, f) =>
-  Future.make(~executor, resolve => setTimeout(() => f() |> resolve, ms) |> ignore);
+  Future.make(~executor, resolve =>
+    setTimeout(() => f() |> resolve, ms) |> ignore
+  );

src/Future.re

@@ -1,9 +1,9 @@
 type getFn('a) = ('a => unit) => unit;
 
-type executorOptions = [ | `none | `trampoline];
+type executorType = [ | `none | `trampoline];
 
 type t('a) =
-  | Future(getFn('a), executorOptions);
+  | Future(getFn('a), executorType);
 
 let trampoline = {
   let running = ref(false);
@@ -25,7 +25,7 @@ let trampoline = {
     };
 };
 
-let make = (~executor: executorOptions=`none, resolver) => {
+let make = (~executor: executorType=`none, resolver) => {
   let callbacks = ref([]);
   let data = ref(None);
 
@@ -51,14 +51,14 @@ let make = (~executor: executorOptions=`none, resolver) => {
   Future(
     resolve =>
       switch (data^) {
-      | Some(result) => trampoline(() => resolve(result))
+      | Some(result) => runCallback(result, resolve)
       | None => callbacks := [resolve, ...callbacks^]
       },
     executor,
   );
 };
 
-let value = (~executor: executorOptions=`none, x) =>
+let value = (~executor: executorType=`none, x) =>
   make(~executor, resolve => resolve(x));
 
 let map = (Future(get, executor), f) =>