## Can we implement tail recursion modulo cons et al. through trampolines? - javascript

You can regard trampolines as compiler optimizations reified in the program. So what is stopping us from adapting more general optimization techniques in exactly the same manner.
Here is a sketch of tail recursion modulo cons:
const loop = f => {
let step = f();
while (step && step[step.length - 1] && step[step.length - 1].type === recur) {
let step_ = step.pop();
step.push(...f(...step_.args));
}
return step;
};
const recur = (...args) =>
({type: recur, args});
const push = (xs, x) => (xs.push(x), xs);
const map = f => xs =>
loop((i = 0) =>
i === xs.length
? []
: push([f(xs[i])], recur(i + 1)));
const xs =
map(x => x * 2) (Array(1e6).fill(0).map((x, i) => i))
.slice(0,5);
console.log(xs); // [0, 2, 4, 6, 8]
This kind of optimization depends on the associativity property of an expression. Multiplication is associative too and hence there is tail recursion modulo multiplication. However, I have to cheat to implement it in Javascript:
const loop = f => {
let step = f();
const acc = [];
while (step && step[1] && step[1].type === recur) {
acc.push(step[0]);
step = f(...step[1].args);
}
return acc.reduce((acc, f) => f(acc), step);
};
const recur = (...args) =>
({type: recur, args});
const mul = x => step => [y => x * y, step];
const pow = (x_, n_) =>
loop((x = x_, n = n_) =>
n === 0 ? 1
: n === 1 ? x
: mul(x) (recur(x, n - 1)));
console.log(
pow(2, 1e6)); // Infinity, no stack overflow
As you can see I cannot use a regular mul, which isn't particular satisfying. Is this connected with Javascript beeing a strict language? Is there a better way to achieve tail recursion modulo multiplication in JS without having to introduce awkward binary operators?

Instead of using loop/recur (which I consider an ugly and unnecessary hack), consider using folds:
const recNat = (zero, succ) => n => {
let result = zero;
while (n > 0) {
result = succ(result);
n = n - 1;
}
return result;
};
const mul = x => y => x * y;
const pow = x => recNat(1, mul(x));
console.log([0,1,2,3,4,5,6,1e6].map(pow(2))); // [1,2,4,8,16,32,64,Infinity]
Almost every recursive function can be defined using folds (a.k.a. structural recursion, a.k.a. induction). For example, even the Ackermann function can be defined using folds:
const recNat = (zero, succ) => n => {
let result = zero;
while (n > 0) {
result = succ(result);
n = n - 1;
}
return result;
};
const add = x => y => x + y;
const ack = recNat(add(1),
ackPredM => recNat(ackPredM(1),
ackMPredN => ackPredM(ackMPredN)));
console.time("ack(4)(1)");
console.log(ack(4)(1)); // 65533
console.timeEnd("ack(4)(1)");
The above code snippet takes about 18 seconds to compute the answer on my laptop.
Now, you might ask why I implemented recNat using iteration instead of natural recursion:
const recNat = (zero, succ) => function recNatZS(n) {
return n <= 0 ? zero : succ(recNatZS(n - 1));
};
I used iteration for the same reason you used iteration to implement loop. Trampolining. By implementing a different trampoline for every data type you're going to fold, you can write functional code without having to worry about stack overflows.
Bottom line: Use folds instead of explicit recursion. They are a lot more powerful than you think.

## Related

### How to implement a coroutine based on multi-shot delimited continuations?

I recently implemented delimited continuations in CPS with reset/shift: // reset :: ((a -> a) -> a) -> (a -> r) -> r reset = k => f => f(k(id)); // shift :: ((a -> r) -> (r -> r) -> r) -> (a -> r) -> r shift = f => k => f(k) (id); Studying the theory I realized the following connections: reset ~ function* // scope of the generator function shift ~ yield reset ~ async // scope of the asyn function shift ~ await As far as I understand the theory, Javascript's generators are a asymmetric, stackless, one-shot and first class coroutines. asymmetric means that the called generator can only yield to its caller stackless means a generator cannot yield from within nested functions one-shot means that a generator can only resume from a specific position once first class means a generator object can be passed around like normal data Now I want to implement a coroutine based on reset/shift with the following traits: asymmetric stackful multi-shot first class When looking at the following contrived example const id = x => x; const mul = x => y => x * y; const add = x => y => x + y; const sub = x => y => x - y; const reset = k => f => f(k(id)); const shift = f => k => f(k) (id); const of = x => k => k(x); const lift2 = f => tx => ty => k => tx(x => ty(y => k(f(x) (y)))); const k0 = lift2(sub) (reset (lift2(add) (of(3)) (shift (k => of(mul(5) (2)))))) (of(1)); // 9 const k1 = lift2(sub) (reset (lift2(add) (of(3)) (shift (k => of(k(mul(5) (2))))))) (of(1)); // 12 const k2 = lift2(sub) (reset (lift2(add) (of(3)) (shift (k => of(k(k(mul(5) (2)))))))) (of(1)); // 15 console.log(k0(id)); console.log(k1(id)); console.log(k2(id)); it seems that reset/shift already meet the last two criteria, because delimited continuations are just first class, composable functions and I can invoke the continuation k as often as required. To answer the why, I want to bypass the following limitation in connection with the list monad. Are these assumptions correct? Even if I haven't make any mistakes so far I am overwhelmed by the complexity of the task at this point. I have no clue how to implement the desired coroutine or even where to begin. I didn't found an example implementation either. I don't expect a complete implementation but maybe some guidance to achieve my goal. Goal I want to bypass the following limitation of coroutines implemented by Javascript's generators: const arrMap = f => xs => xs.map(x => f(x)); const arrAp = fs => xs => fs.reduce((acc, f) => acc.concat(xs.map(x => f(x))), []); const arrChain = xs => fm => xs.reduce((acc, x) => acc.concat(fm(x)), []); const arrOf = x => [x]; const do_ = (of, chain) => it => { const loop = ({done, value}) => done ? value : chain(value) (x => loop(it.next(x))); return loop(it.next()); }; const z = function*() { const x = yield [1,2,3] return [x, x]; } console.log( arrChain([1,2,3]) (x => [x, x])); console.log( do_(arrOf, arrChain) (z()));

### Is there a way to avoid the trade-off between readability and performance when looping?

So this is a readable way (the code doesn't matter, what matters is the style): arr.map().filter() // looping 2 times And loops are considered as a faster way: for(/* whatever */) { // looping once, and doing all we need in the same loop } So my question is: is there a way, maybe from the functional programming world, to combine the readability of the former with the performance of the latter? P.S. There is a trend to downvote such questions. If you want to, please write the reason as well.

Of course there is. 1st alternative: Transducer const mapReduce = map => reduce => (acc, x) => reduce(acc, map(x)); const filterReduce = filter => reduce => (acc, x) => filter(x) ? reduce(acc, x) : acc; const transduce = (...ts) => xs => xs.reduce(ts.reduce(comp, id) (concat), []); const comp = (f, g) => x => f(g(x)); const id = x => x; const concat = (xs, ys) => xs.concat(ys); const sqr = n => n * n; const isOdd = n => n & 1 === 1; const log = console.log; // the upper code is usually library code // so you don't have to deal with its complexity but only with its API const tx = filterReduce(isOdd), ty = mapReduce(sqr); const r = transduce(tx, ty) ([1,2,3,4,5]); // filter/map in same iteration log(r); 2nd alternative: Bare recursion with a tail call optimization effect const loop = f => { let acc = f(); while (acc && acc.type === tailRec) acc = f(...acc.args); return acc; }; const tailRec = (...args) => ({type: tailRec, args}); const comp = (f, g) => x => f(g(x)); const sqr = n => n * n; const isOdd = n => n & 1 === 1; const log = console.log; // the upper code is usually library code // so you don't have to deal with its complexity but only with its API const r = loop((xs = [1,2,3,4,5], acc = [], i = 0) => { if (i === xs.length) return acc; else return tailRec( // filter/map in same iteration xs, isOdd(xs[i]) ? acc.concat(sqr(xs[i])) : acc, i + 1); }); log(r); I'd say transducer are for normal, simpler iterations whereas recursion is suitable for more complex ones, for example when you need short circuiting (prematurely exiting).

Personally I don't think having some for-loops in your code makes it unreadable, but that's opinion based I suppose. There are many ways to make your code more readable. If you're going to use this functionality often then you could create a method to add to Array.prototype - this way you can write the for-loop once and call it when you need it without having to see what you consider ugly code. Below is an example: //This method will now be available to all Arrays instances: Array.prototype.prettyLoop = function() { console.log('All I do is execute a basic for-loop'); for (let i = 0; i < this.length; i++) { console.log(this[i]); } }; //Call the method from your script ["a", 1, null, "x", 1989, false, {}].prettyLoop();

### Reversing the order of default arguments in JavaScript

I have the following recursive compose function: const compose = (f, n = 1) => n > 1 ? compose(compose(f), n - 1) : g => x => f(g(x)); const length = a => a.length; const filter = p => a => a.filter(p); const countWhere = compose(length, 2)(filter); const odd = n => n % 2 === 1; console.log(countWhere(odd)([1,2,3,4,5,6,7,8,9])); // 5 Now, what I'd like to do is flip the arguments of compose so that the default argument is first: const compose = (n = 1, f) => n > 1 ? // wishful thinking compose(n - 1, compose(f)) : // compose(f) is the same as compose(1, f) g => x => f(g(x)); const length = a => a.length; const filter = p => a => a.filter(p); const countWhere = compose(2, length)(filter); // I want to call it like this const odd = n => n % 2 === 1; console.log(countWhere(odd)([1,2,3,4,5,6,7,8,9])); // 5 What's the most elegant way to write such functions where the default arguments come first? Edit: I actually want to create the map and ap methods of functions of various arities, so that I can write: const length = a => a.length; const filter = p => a => a.filter(p); const countWhere = length.map(2, filter); // length <$> filter const pair = x => y => [x, y]; const add = x => y => x + y; const mul = x => y => x * y; const addAndMul = pair.map(2, add).ap(2, mul); // (,) <$> (+) <*> (*) Hence, I'd rather not curry the methods as Bergi suggested in his answer. For more information, read: Is implicit wrapping and unwrapping of newtypes in Haskell a sound idea?

I would recommend to just not overload your functions or use default parameters: const compose = n => f => n > 1 ? compose(n - 1)(composeOne(f)) : g => x => f(g(x)); const composeOne = compose(1); In this case you could probably also just inline it, as it seems composeOne wouldn't be called anywhere else: const compose = n => f => n > 1 ? compose(n - 1)(compose(1)(f)) : g => x => f(g(x)); Or even not do a recursive call at all, but always create the g => x => … lambda and transform it conditionally: const compose = n => f => { const l = g => x => f(g(x)); return n > 1 ? compose(n - 1)(l) : l; }; // same without temporary variables: const id = x => x; const compose = n => f => (n > 1 ? compose(n-1) : id)(g => x => f(g(x)))

What's the most elegant way to write such functions where the default arguments come first? Using only default initialisers requires some arcane hackery: function demo(n, f = [n, n = 1][0]) { console.log(n, f); } demo(2, "f"); // 2 f demo("g"); // 1 g console.log(demo.length) // 1 The most straightforward way would be destructuring with a conditional operator: function demo(...args) { const [n, f] = args.length < 2 ? [1, ...args] : args; console.log(n, f); } demo(2, "f"); // 2 f demo("g"); // 1 g console.log(demo.length) // 0 More in the spirit of "reversing the order of arguments" might be doing that literally: function demo(...args) { const [f, n = 1] = args.reverse(); console.log(n, f); } demo(2, "f"); // 2 f demo("g"); // 1 g console.log(demo.length) // 0 The latter two attempts have the drawback of requiring an extra declaration (preventing us from using concise arrow functions) and also don't reflect the actual number or required parameters in the .length.

### Trampoline recursion stack overflow

I have this recursive function sum which computes sum of all numbers that were passed to it. function sum(num1, num2, ...nums) { if (nums.length === 0) { return num1 + num2; } return sum(num1 + num2, ...nums); } let xs = []; for (let i = 0; i < 100; i++) { xs.push(i); } console.log(sum(...xs)); xs = []; for (let i = 0; i < 10000; i++) { xs.push(i); } console.log(sum(...xs)); It works fine if only 'few' numbers are passed to it but overflows call stack otherwise. So I have tried to modify it a bit and use trampoline so that it can accept more arguments. function _sum(num1, num2, ...nums) { if (nums.length === 0) { return num1 + num2; } return () => _sum(num1 + num2, ...nums); } const trampoline = fn => (...args) => { let res = fn(...args); while (typeof res === 'function') { res = res(); } return res; } const sum = trampoline(_sum); let xs = []; for (let i = 0; i < 10000; i++) { xs.push(i); } console.log(sum(...xs)); xs = []; for (let i = 0; i < 100000; i++) { xs.push(i); } console.log(sum(...xs)); While the first version isn't able to handle 10000 numbers, the second is. But if I pass 100000 numbers to the second version I'm getting call stack overflow error again. I would say that 100000 is not really that big of a number (might be wrong here) and don't see any runaway closures that might have caused the memory leak. Does anyone know what is wrong with it?

The other answer points out the limitation on number of function arguments, but I wanted to remark on your trampoline implementation. The long computation we're running may want to return a function. If you use typeof res === 'function', it's not longer possible to compute a function as a return value! Instead, encode your trampoline variants with some sort of unique identifiers const bounce = (f, ...args) => ({ tag: bounce, f: f, args: args }) const done = (value) => ({ tag: done, value: value }) const trampoline = t => { while (t && t.tag === bounce) t = t.f (...t.args) if (t && t.tag === done) return t.value else throw Error (`unsupported trampoline type: ${t.tag}`) } Before we hop on, let's first get an example function to fix const none = Symbol () const badsum = ([ n1, n2 = none, ...rest ]) => n2 === none ? n1 : badsum ([ n1 + n2, ...rest ]) We'll throw a range of numbers at it to see it work const range = n => Array.from ( Array (n + 1) , (_, n) => n ) console.log (range (10)) // [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] console.log (badsum (range (10))) // 55 But can it handle the big leagues? console.log (badsum (range (1000))) // 500500 console.log (badsum (range (20000))) // RangeError: Maximum call stack size exceeded See the results in your browser so far const none = Symbol () const badsum = ([ n1, n2 = none, ...rest ]) => n2 === none ? n1 : badsum ([ n1 + n2, ...rest ]) const range = n => Array.from ( Array (n + 1) , (_, n) => n ) console.log (range (10)) // [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] console.log (badsum (range (1000))) // 500500 console.log (badsum (range (20000))) // RangeError: Maximum call stack size exceeded Somewhere between 10000 and 20000 our badsum function unsurprisingly causes a stack overflow. Besides renaming the function to goodsum we only have to encode the return types using our trampoline's variants const goodsum = ([ n1, n2 = none, ...rest ]) => n2 === none ? n1 ? done (n1) : goodsum ([ n1 + n2, ...rest ]) : bounce (goodsum, [ n1 + n2, ...rest ]) console.log (trampoline (goodsum (range (1000)))) // 500500 console.log (trampoline (goodsum (range (20000)))) // 200010000 // No more stack overflow! You can see the results of this program in your browser here. Now we can see that neither recursion nor the trampoline are at fault for this program being slow. Don't worry though, we'll fix that later. const bounce = (f, ...args) => ({ tag: bounce, f: f, args: args }) const done = (value) => ({ tag: done, value: value }) const trampoline = t => { while (t && t.tag === bounce) t = t.f (...t.args) if (t && t.tag === done) return t.value else throw Error (`unsupported trampoline type: ${t.tag}`) } const none = Symbol () const range = n => Array.from ( Array (n + 1) , (_, n) => n ) const goodsum = ([ n1, n2 = none, ...rest ]) => n2 === none ? done (n1) : bounce (goodsum, [ n1 + n2, ...rest ]) console.log (trampoline (goodsum (range (1000)))) // 500500 console.log (trampoline (goodsum (range (20000)))) // 200010000 // No more stack overflow! The extra call to trampoline can get annoying, and when you look at goodsum alone, it's not immediately apparent what done and bounce are doing there, unless maybe this was a very common convention in many of your programs. We can better encode our looping intentions with a generic loop function. A loop is given a function that is recalled whenever the function calls recur. It looks like a recursive call, but really recur is constructing a value that loop handles in a stack-safe way. The function we give to loop can have any number of parameters, and with default values. This is also convenient because we can now avoid the expensive ... destructuring and spreading by simply using an index parameter i initialized to 0. The caller of the function does not have the ability to access these variables outside of the loop call The last advantage here is that the reader of goodsum can clearly see the loop encoding and the explicit done tag is no longer necessary. The user of the function does not need to worry about calling trampoline either as it's already taken care of for us in loop const goodsum = (ns = []) => loop ((sum = 0, i = 0) => i >= ns.length ? sum : recur (sum + ns[i], i + 1)) console.log (goodsum (range (1000))) // 500500 console.log (goodsum (range (20000))) // 200010000 console.log (goodsum (range (999999))) // 499999500000 Here's our loop and recur pair now. This time we expand upon our { tag: ... } convention using a tagging module const recur = (...values) => tag (recur, { values }) const loop = f => { let acc = f () while (is (recur, acc)) acc = f (...acc.values) return acc } const T = Symbol () const tag = (t, x) => Object.assign (x, { [T]: t }) const is = (t, x) => t && x[T] === t Run it in your browser to verify the results const T = Symbol () const tag = (t, x) => Object.assign (x, { [T]: t }) const is = (t, x) => t && x[T] === t const recur = (...values) => tag (recur, { values }) const loop = f => { let acc = f () while (is (recur, acc)) acc = f (...acc.values) return acc } const range = n => Array.from ( Array (n + 1) , (_, n) => n ) const goodsum = (ns = []) => loop ((sum = 0, i = 0) => i >= ns.length ? sum : recur (sum + ns[i], i + 1)) console.log (goodsum (range (1000))) // 500500 console.log (goodsum (range (20000))) // 200010000 console.log (goodsum (range (999999))) // 499999500000 extra My brain has been stuck in anamorphism gear for a few months and I was curious if it was possible to implement a stack-safe unfold using the loop function introduced above Below, we look at an example program which generates the entire sequence of sums up to n. Think of it as showing the work to arrive at the answer for the goodsum program above. The total sum up to n is the last element in the array. This is a good use case for unfold. We could write this using loop directly, but the point of this was to stretch the limits of unfold so here goes const sumseq = (n = 0) => unfold ( (loop, done, [ m, sum ]) => m > n ? done () : loop (sum, [ m + 1, sum + m ]) , [ 1, 0 ] ) console.log (sumseq (10)) // [ 0, 1, 3, 6, 10, 15, 21, 28, 36, 45 ] // +1 ↗ +2 ↗ +3 ↗ +4 ↗ +5 ↗ +6 ↗ +7 ↗ +8 ↗ +9 ↗ ... If we used an unsafe unfold implementation, we could blow the stack // direct recursion, stack-unsafe! const unfold = (f, initState) => f ( (x, nextState) => [ x, ...unfold (f, nextState) ] , () => [] , initState ) console.log (sumseq (20000)) // RangeError: Maximum call stack size exceeded After playing with it a little bit, it is indeed possible to encode unfold using our stack-safe loop. Cleaning up the ... spread syntax using a push effect makes things a lot quicker too const push = (xs, x) => (xs .push (x), xs) const unfold = (f, init) => loop ((acc = [], state = init) => f ( (x, nextState) => recur (push (acc, x), nextState) , () => acc , state )) With a stack-safe unfold, our sumseq function works a treat now console.time ('sumseq') const result = sumseq (20000) console.timeEnd ('sumseq') console.log (result) // sumseq: 23 ms // [ 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, ..., 199990000 ] Verify the result in your browser below const recur = (...values) => tag (recur, { values }) const loop = f => { let acc = f () while (is (recur, acc)) acc = f (...acc.values) return acc } const T = Symbol () const tag = (t, x) => Object.assign (x, { [T]: t }) const is = (t, x) => t && x[T] === t const push = (xs, x) => (xs .push (x), xs) const unfold = (f, init) => loop ((acc = [], state = init) => f ( (x, nextState) => recur (push (acc, x), nextState) , () => acc , state )) const sumseq = (n = 0) => unfold ( (loop, done, [ m, sum ]) => m > n ? done () : loop (sum, [ m + 1, sum + m ]) , [ 1, 0 ] ) console.time ('sumseq') const result = sumseq (20000) console.timeEnd ('sumseq') console.log (result) // sumseq: 23 ms // [ 0, 1, 3, 6, 10, 15, 21, 28, 36, 45, ..., 199990000 ]

Browsers have practical limits on the number of arguments a function can take You can change the sum signature to accept an array rather than a varying number of arguments, and use destructuring to keep the syntax/readability similar to what you have. This "fixes" the stackoverflow error, but is increadibly slow :D function _sum([num1, num2, ...nums]) { /* ... */ } I.e.:, if you're running in to problems with maximum argument counts, your recursive/trampoline approach is probably going to be too slow to work with...

The other answer already explained the issue with your code. This answer demonstrates that trampolines are sufficiently fast for most array based computations and offer a higher level of abstraction: // trampoline const loop = f => { let acc = f(); while (acc && acc.type === recur) acc = f(...acc.args); return acc; }; const recur = (...args) => ({type: recur, args}); // sum const sum = xs => { const len = xs.length; return loop( (acc = 0, i = 0) => i === len ? acc : recur(acc + xs[i], i + 1)); }; // and run... const xs = Array(1e5) .fill(0) .map((x, i) => i); console.log(sum(xs)); If a trampoline based computation causes performance problems, then you can still replace it with a bare loop.

### How to implement a stack-safe chainRec operator for the continuation monad?

I am currently experimenting with the continuation monad. Cont is actually useful in Javascript, because it abstracts from the callback pattern. When we deal with monadic recursion, there is always the risk of a stack overflow, because the recursive call isn't in tail position: const chain = g => f => k => g(x => f(x) (k)); const of = x => k => k(x); const id = x => x; const inc = x => x + 1; const repeat = n => f => x => n === 0 ? of(x) : chain(of(f(x))) (repeat(n - 1) (f)); console.log( repeat(1e6) (inc) (0) (id) // stack overflow ); However, even if we are able to transform some cases into tail recursion we are still doomed, because Javascript doesn't have TCO. Consequently we have to fall back to a loop at some point. puresrcipt has a MonadRec typeclass with a tailRecM operator that enables tail recursive monadic computations for some monads. So I tried to implement chainRec in Javascript mainly according to the fantasy land spec: const chain = g => f => k => g(x => f(x) (k)); const of = x => k => k(x); const id = x => x; const Loop = x => ({value: x, done: false}); const Done = x => ({value: x, done: true}); const chainRec = f => x => { let step = f(Loop, Done, x); while (!step.done) { step = f(Loop, Done, step.value); } return of(step.value); }; const repeat_ = n => f => x => chainRec((Loop, Done, [n, x]) => n === 0 ? Done(x) : Loop([n - 1, f(x)])) ([n, x]); console.log( repeat_(1e6) (n => n + 1) (0) (id) // 1000000 ); This works, but it looks a lot like cheating, because it seems to bypass the monadic chaining and thus Cont's context. In this case the context is just "the rest of the computation", ie. function composition in reverse and as a result the expected value is returned. But does it work for any monad? To make it clear what I mean take a look at the following code snippet from this outstanding answer: const Bounce = (f,x) => ({ isBounce: true, f, x }) const Cont = f => ({ _runCont: f, chain: g => Cont(k => Bounce(f, x => Bounce(g(x)._runCont, k))) }) // ... const repeat = n => f => x => { const aux = (n,x) => n === 0 ? Cont.of(x) : Cont.of(f(x)).chain(x => aux(n - 1, x)) return runCont(aux(n,x), x => x) } Here chain is somehow incorporated into the recursive algorithm, that is the monadic effect can occur. Unfortunately, I cannot decipher this operator or reconcile it with the stack-unsafe version (Bounce(g(x)._runCont, k) seems to be the f(x) (k) portion, though). Ultimately, my question is if I messed up the implementation of chainRecor misunderstood the FL spec or both or none of it? [EDIT] Both given answers are very helpful by looking at the problem from different perspectives and deserve to be accepted. Since I can only accept one - hey stackoverflow, the world isn't that simple!!! - I won't accept any.

with best wishes, I think this might be what you're looking for, const chainRec = f => x => f ( chainRec (f) , of , x ) Implementing repeat is just as you have it – with two exceptions (thanks #Bergi for catching this detail). 1, loop and done are the chaining functions, and so the chainRec callback must return a continuation. And 2, we must tag a function with run so cont knows when we can safely collapse the stack of pending continuations – changes in bold const repeat_ = n => f => x => chainRec ((loop, done, [n, x]) => n === 0 ? of (x) (done) // cont chain done : of ([ n - 1, f (x) ]) (loop) // cont chain loop ([ n, x ]) const repeat = n => f => x => repeat_ (n) (f) (x) (run (identity)) But, if you're using chainRec as we have here, of course there's no reason to define the intermediate repeat_. We can define repeat directly const repeat = n => f => x => chainRec ((loop, done, [n, x]) => n === 0 ? of (x) (done) : of ([ n - 1, f (x) ]) (loop) ([ n, x ]) (run (identity)) Now for it to work, you just need a stack-safe continuation monad – cont (f) constructs a continuation, waiting for action g. If g is tagged with run, then it's time to bounce on the trampoline. Otherwise constructor a new continuation that adds a sequential call for f and g // not actually stack-safe; we fix this below const cont = f => g => is (run, g) ? trampoline (f (g)) : cont (k => call (f, x => call (g (x), k))) const of = x => cont (k => k (x)) Before we go further, we'll verify things are working const TAG = Symbol () const tag = (t, x) => Object.assign (x, { [TAG]: t }) const is = (t, x) => x && x [TAG] === t // ---------------------------------------- const cont = f => g => is (run, g) ? trampoline (f (g)) : cont (k => call (f, x => call (g (x), k))) const of = x => cont (k => k (x)) const chainRec = f => x => f ( chainRec (f) , of , x ) const run = x => tag (run, x) const call = (f, x) => tag (call, { f, x }) const trampoline = t => { let acc = t while (is (call, acc)) acc = acc.f (acc.x) return acc } // ---------------------------------------- const identity = x => x const inc = x => x + 1 const repeat = n => f => x => chainRec ((loop, done, [n, x]) => n === 0 ? of (x) (done) : of ([ n - 1, f (x) ]) (loop)) ([ n, x ]) (run (identity)) console.log (repeat (1e3) (inc) (0)) // 1000 console.log (repeat (1e6) (inc) (0)) // Error: Uncaught RangeError: Maximum call stack size exceeded where's the bug? The two implementations provided contain a critical difference. Specifically, it's the g(x)._runCont bit that flattens the structure. This task is trivial using the JS Object encoding of Cont as we can flatten by simply reading the ._runCont property of g(x) const Cont = f => ({ _runCont: f , chain: g => Cont (k => Bounce (f, x => // g(x) returns a Cont, flatten it Bounce (g(x)._runCont, k))) }) In our new encoding, we're using a function to represent cont, and unless we provide another special signal (like we did with run), there's no way to access f outside of cont once it's been partially applied – look at g (x) below const cont = f => g => is (run, g) ? trampoline (f (g)) : cont (k => call (f, x => // g (x) returns partially-applied `cont`, how to flatten? call (g (x), k))) Above, g (x) will return a partially-applied cont, (ie cont (something)), but this means that the entire cont function can nest infinitely. Instead of cont-wrapped something, we only want something. At least 50% of the time I spent on this answer has been coming up with various ways to flatten partially-applied cont. This solution isn't particularly graceful, but it does get the job done and highlights precisely what needs to happen. I'm really curious to see what other encodings you might find – changes in bold const FLATTEN = Symbol () const cont = f => g => g === FLATTEN ? f : is (run, g) ? trampoline (f (g)) : cont (k => call (f, x => call (g (x) (FLATTEN), k))) all systems online, captain With the cont flattening patch in place, everything else works. Now see chainRec do a million iterations… const TAG = Symbol () const tag = (t, x) => Object.assign (x, { [TAG]: t }) const is = (t, x) => x && x [TAG] === t // ---------------------------------------- const FLATTEN = Symbol () const cont = f => g => g === FLATTEN ? f : is (run, g) ? trampoline (f (g)) : cont (k => call (f, x => call (g (x) (FLATTEN), k))) const of = x => cont (k => k (x)) const chainRec = f => x => f ( chainRec (f) , of , x ) const run = x => tag (run, x) const call = (f, x) => tag (call, { f, x }) const trampoline = t => { let acc = t while (is (call, acc)) acc = acc.f (acc.x) return acc } // ---------------------------------------- const identity = x => x const inc = x => x + 1 const repeat = n => f => x => chainRec ((loop, done, [n, x]) => n === 0 ? of (x) (done) : of ([ n - 1, f (x) ]) (loop)) ([ n, x ]) (run (identity)) console.log (repeat (1e6) (inc) (0)) // 1000000 evolution of cont When we introduced cont in the code above, it's not immediately obvious how such an encoding was derived. I hope to shed some light on that. We start with how we wish we could define cont const cont = f => g => cont (comp (g,f)) const comp = (f, g) => x => f (g (x)) In this form, cont will endlessly defer evaluation. The only available thing we can do is apply g which always creates another cont and defers our action. We add an escape hatch, run, which signals to cont that we don't want to defer any longer. const cont = f => g => is (run, g) ? f (g) : cont (comp (g,f)) const is = ... const run = ... const square = x => of (x * x) of (4) (square) (square) (run (console.log)) // 256 square (4) (square) (run (console.log)) // 256 Above, we can begin to see how cont can express beautiful and pure programs. However in an environment without tail-call elimination, this still allows programs to build deferred functions sequences that exceed the evaluator's stack limit. comp directly chains functions, so that's out of the picture. Instead we'll sequence the functions using a call mechanism of our own making. When the program signals run, we collapse the stack of calls using trampoline. Below, we arrive at the form we had before the flatten fix was applied const cont = f => g => is (run, g) ? trampoline (f (g)) : cont (comp (g,f)) : cont (k => call (f, x => call (g (x), k))) const trampoline = ... const call = ... wishful thinking Another technique we were using above is one of my favorites. When I write is (run, g), I don't know how I'm going to represent is or run right away, but I can figure it out later. I use the same wishful thinking for trampoline and call. I point this out because it means I can keep all of that complexity out of cont and just focus on its elementary structure. I ended up with a set of functions that gave me this "tagging" behavior // tag contract // is (t, tag (t, value)) == true const TAG = Symbol () const tag = (t, x) => Object.assign (x, { [TAG]: t }) const is = (t, x) => x && x [TAG] === t const run = x => tag (run, x) const call = (f, x) => tag (call, { f, x }) Wishful thinking is all about writing the program you want and making your wishes come true. Once you fulfill all of your wishes, your program just magically works!

Did I mess up the implementation of chainRec, or misunderstood the FantasyLand spec, or both or none of it? Probably both, or at least the first. Notice that the type should be chainRec :: ChainRec m => ((a -> c, b -> c, a) -> m c, a) -> m b wherein m is Cont and c is your Done/Loop wrapper over a or b: chainRec :: ((a -> DL a b, b -> DL a b, a) -> Cont (DL a b), a) -> Cont b But your chainRec and repeat implementations don't use continations at all! If we implement just that type, without the requirement that it should need constant stack space, it would look like const chainRec = f => x => k => f(Loop, Done, x)(step => step.done ? k(step.value) // of(step.value)(k) : chainRec(f)(step.value)(k) ); or if we drop even the lazyness requirement (similar to transforming chain from g => f => k => g(x => f(x)(k)) to just g => f => g(f) (i.e. g => f => k => g(x => f(x))(k))), it would look like const chainRec = f => x => f(Loop, Done, x)(step => step.done ? of(step.value) : chainRec(f)(step.value) ); or even dropping Done/Loop const join = chain(id); const chainRec = f => x => join(f(chainRec(f), of, x)); (I hope I'm not going out on a limb too far with that, but it perfectly presents the idea behind ChainRec) With the lazy continuation and the non-recursive trampoline, we would however write const chainRec = f => x => k => { let step = Loop(x); do { step = f(Loop, Done, step.value)(id); // ^^^^ unwrap Cont } while (!step.done) return k(step.value); // of(step.value)(k) }; The loop syntax (initialise step with an f call, do/while instead of do) doesn't really matter, yours is fine as well but the important part is that f(Loop, Done, v) returns a continuation. I'll leave the implementation of repeat as an exercise to the reader :D (Hint: it might become more useful and also easier to get right if you have the repeated function f already use continuations)