How do I replace while loops with a functional programming alternative without tail call optimization?
An example in JavaScript
Here's an example using JavaScript. Currently, most browsers do not support tail call optimisation and therefore the following snippet will fail
const repeat = n => f => x => n === 0 ? x : repeat (n - 1) (f) (f(x)) console.log(repeat(1e3) (x => x + 1) (0)) // 1000console.log(repeat(1e5) (x => x + 1) (0)) // Error: Uncaught RangeError: Maximum call stack size exceededTrampolines
We can work around this limitation by changing the way we write repeat, but only slightly. Instead of returning a value directly or immediately recurring, we will return one of our two trampoline types, Bounce or Done. Then we will use our trampoline function to handle the loop.
// trampolineconst Bounce = (f,x) => ({ isBounce: true, f, x })const Done = x => ({ isBounce: false, x })const trampoline = ({ isBounce, f, x }) => { while (isBounce) ({ isBounce, f, x } = f(x)) return x}// our revised repeat function, now stack-safeconst repeat = n => f => x => n === 0 ? Done(x) : Bounce(repeat (n - 1) (f), f(x))// apply trampoline to the result of an ordinary call repeatlet result = trampoline(repeat(1e6) (x => x + 1) (0))// no more stack overflowconsole.log(result) // 1000000Currying slows things down a little bit too, but we can remedy that using an auxiliary function for the recursion. This is nice too because it hides the trampoline implementation detail and does not expect the caller to bounce the return value. This runs about twice as fast as the above repeat
// aux helper hides trampoline implementation detail// runs about 2x as fastconst repeat = n => f => x => { const aux = (n, x) => n === 0 ? Done(x) : Bounce(x => aux (n - 1, x), f (x)) return trampoline (aux (n, x))}Clojure-style loop/recur
Trampolines are nice and all but it's kind of annoying to have to have to worry about calling trampoline on your function's return value. We saw the alternative was to use an auxiliary helper, but c'mon that's kind of annoying, too. I'm sure some of you aren't too keen about the Bounce and Done wrappers, too.
Clojure creates a specialised trampoline interface that uses a pair of functions, loop and recur – this tandem pair lends itself to a remarkably elegant expression of a program
Oh and it's really fast, too
const recur = (...values) => ({ recur, values }) const loop = run =>{ let r = run () while (r && r.recur === recur) r = run (...r.values) return r}const repeat = n => f => x => loop ( (m = n, r = x) => m === 0 ? r : recur (m - 1, f (r)) ) console.time ('loop/recur')console.log (repeat (1e6) (x => x + 1) (0)) // 1000000console.timeEnd ('loop/recur') // 24 msInitially this style will feel foreign, but over time I am finding it to be the most consistent while producing durable programs. Comments below help ease you into the expression-rich syntax -
const repeat = n => f => x => loop // begin a loop with ( ( m = n // local loop var m: counter, init with n , r = x // local loop var r: result, init with x ) => m === 0 // terminating condition ? r // return result : recur // otherwise recur with ( m - 1 // next m value , f (r) // next r value ) )The continuation monad
This is one of my favourite topics tho, so we're gonna see what this looks like with the continuation monad. Reusing loop and recur, we implement a stack-safe cont that can sequence operations using chain and run operation sequences using runCont. For repeat, this is senseless (and slow), but it's cool to see the mechanics of cont at work in this simple example -
const identity = x => xconst recur = (...values) => ({ recur, values }) const loop = run =>{ let r = run () while (r && r.recur === recur) r = run (...r.values) return r}// cont : 'a -> 'a contconst cont = x => k => recur (k, x)// chain : ('a -> 'b cont) -> 'a cont -> 'b contconst chain = f => mx => k => recur (mx, x => recur (f (x), k))// runCont : ('a -> 'b) -> a cont -> 'bconst runCont = f => mx => loop ((r = mx, k = f) => r (k))const repeat = n => f => x =>{ const aux = n => x => n === 0 // terminating condition ? cont (x) // base case, continue with x : chain // otherise (aux (n - 1)) // sequence next operation on (cont (f (x))) // continuation of f(x) return runCont // run continuation (identity) // identity; pass-thru (aux (n) (x)) // the continuation returned by aux}console.time ('cont monad')console.log (repeat (1e6) (x => x + 1) (0)) // 1000000console.timeEnd ('cont monad') // 451 msY combinator
The Y combinator is my spirit combinator; this answer would be incomplete without giving it some place amongst the other techniques. Most implementations of the Y combinator however, are not stack-safe and will overflow if the user-supplied function recurs too many times. Since this answer is all about preserving stack-safe behaviour, of course we'll implement Y in a safe way – again, relying on our trusty trampoline.
Y demonstrates the ability to extend easy-to-use, stack-safe, synchronous infinite recursion without cluttering up your function.
const bounce = f => (...xs) => ({ isBounce: true, f, xs })const trampoline = t => { while (t && t.isBounce) t = t.f(...t.xs) return t}// stack-safe Y combinatorconst Y = f => { const safeY = f => bounce((...xs) => f (safeY (f), ...xs)) return (...xs) => trampoline (safeY (f) (...xs))}// recur safely to your heart's contentconst repeat = Y ((recur, n, f, x) => n === 0 ? x : recur (n - 1, f, f (x))) console.log(repeat (1e5, x => x + 1, 0)) // 10000Practicality with while loop
But let's be honest: that's a lot of ceremony when we're overlooking one of the more obvious potential solutions: use a for or while loop, but hide it behind a functional interface
For all intents and purposes, this repeat function works identically to the ones provided above – except this one is about one or two gadzillion times faster (with exception to the loop/recur solution). Heck, it's arguably a lot easier to read too.
Granted, this function is perhaps a contrived example – not all recursive functions can be converted to a for or while loop so easily, but in such a scenario where it's possible, it's probably best to just do it like this. Save the trampolines and continuations for heavy lifting when a simple loop won't do.
const repeat = n => f => x => { let m = n while (true) { if (m === 0) return x else (m = m - 1, x = f (x)) }}const gadzillionTimes = repeat(1e8)const add1 = x => x + 1const result = gadzillionTimes (add1) (0)console.log(result) // 100000000setTimeout is NOT a solution to the stack overflow problem
OK, so it does work, but only paradoxically. If your dataset is small, you don't need setTimeout because there will be no stack overflow. If your dataset is large and you use setTimeout as a safe recursion mechanism, not only do you make it impossible to synchronously return a value from your function, it will be so F slow you won't even want to use your function
Some people have found an interview Q&A prep site that encourages this dreadful strategy
What our repeat would look like using setTimeout – notice it's also defined in continuation passing style – ie, we must call repeat with a callback (k) to get the final value
// do NOT implement recursion using setTimeoutconst repeat = n => f => x => k => n === 0 ? k (x) : setTimeout (x => repeat (n - 1) (f) (x) (k), 0, f (x)) // be patient, this one takes about 5 seconds, even for just 1000 recursionsrepeat (1e3) (x => x + 1) (0) (console.log)// comment the next line out for absolute madness// 10,000 recursions will take ~1 MINUTE to complete// paradoxically, direct recursion can compute this in a few milliseconds// setTimeout is NOT a fix for the problem// -----------------------------------------------------------------------------// repeat (1e4) (x => x + 1) (0) (console.log)I can't stress enough how bad this is. Even 1e5 takes so long to run that I gave up trying to measure it. I'm not including this in the benchmarks below because it's just too slow to even be considered a viable approach.
Promises
Promises have the ability to chain computations and are stack safe. However, achieving a stack-safe repeat using Promises means we'll have to give up our synchronous return value, the same way we did using setTimeout. I'm providing this as a "solution" because it does solve the problem, unlike setTimeout, but in a way that's very simple compared to the trampoline or continuation monad. As you might imagine though, the performance is somewhat bad, but nowhere near as bad as the setTimeout example above
Worth noting in this solution, the Promise implementation detail is completely hidden from the caller. A single continuation is provided as a 4th argument and its called when the computation is complete.
const repeat = n => f => x => k => n === 0 ? Promise.resolve(x).then(k) : Promise.resolve(f(x)).then(x => repeat (n - 1) (f) (x) (k)) // be patient ...repeat (1e6) (x => x + 1) (0) (x => console.log('done', x))Benchmarks
Seriously, the while loop is a lot faster - like almost 100x faster (when comparing best to worst – but not including async answers: setTimeout and Promise)
// sync// -----------------------------------------------------------------------------// repeat implemented with basic trampolineconsole.time('A')console.log(tramprepeat(1e6) (x => x + 1) (0))console.timeEnd('A')// 1000000// A 114 ms// repeat implemented with basic trampoline and aux helperconsole.time('B')console.log(auxrepeat(1e6) (x => x + 1) (0))console.timeEnd('B')// 1000000// B 64 ms// repeat implemented with cont monadconsole.time('C')console.log(contrepeat(1e6) (x => x + 1) (0))console.timeEnd('C')// 1000000// C 33 ms// repeat implemented with Yconsole.time('Y')console.log(yrepeat(1e6) (x => x + 1) (0))console.timeEnd('Y')// 1000000// Y 544 ms// repeat implemented with while loopconsole.time('D')console.log(whilerepeat(1e6) (x => x + 1) (0))console.timeEnd('D')// 1000000// D 4 ms// async// -----------------------------------------------------------------------------// repeat implemented with Promiseconsole.time('E')promiserepeat(1e6) (x => x + 1) (0) (console.log)console.timeEnd('E')// 1000000// E 2224 ms// repeat implemented with setTimeout; FAILEDconsole.time('F')timeoutrepeat(1e6) (x => x + 1) (0) (console.log)console.timeEnd('F')// ...// too slow; didn't finish after 3 minutesStone Age JavaScript
The above techniques are demonstrated using newer ES6 syntaxes, but you could implement a trampoline in the earliest possible version of JavaScript – it only requires while and first class functions
Below, we use stone age javascript to demonstrate infinite recursion is possible and performant without necessarily sacrificing a synchronous return value – 100,000,000 recursions in under 6 seconds - this is a dramatic difference compared to setTimeout which can only 1,000 recursions in the same amount of time.
function trampoline (t) { while (t && t.isBounce) t = t.f (t.x); return t.x;}function bounce (f, x) { return { isBounce: true, f: f, x: x };}function done (x) { return { isBounce: false, x: x };}function repeat (n, f, x) { function aux (n, x) { if (n === 0) return done (x); else return bounce (function (x) { return aux (n - 1, x); }, f (x)); } return trampoline (aux (n, x));}console.time('JS1 100K');console.log (repeat (1e5, function (x) { return x + 1 }, 0));console.timeEnd('JS1 100K');// 100000// JS1 100K: 15msconsole.time('JS1 100M');console.log (repeat (1e8, function (x) { return x + 1 }, 0));console.timeEnd('JS1 100M');// 100000000// JS1 100K: 5999msNon-blocking infinite recursion using stone age JavaScript
If, for some reason, you want non-blocking (asynchronous) infinite recursion, we can rely on setTimeout to defer a single frame at the start of the computation. This program also uses stone age javascript and computes 100,000,000 recursions in under 8 seconds, but this time in a non-blocking way.
This demonstrates that there's nothing special about having a non-blocking requirement. A while loop and first-class functions are still the only fundamental requirement to achieve stack-safe recursion without sacrificing performance
In a modern program, given Promises, we would substitute the setTimeout call for a single Promise.
function donek (k, x) { return { isBounce: false, k: k, x: x };}function bouncek (f, x) { return { isBounce: true, f: f, x: x };}function trampolinek (t) { // setTimeout is called ONCE at the start of the computation // NOT once per recursion return setTimeout(function () { while (t && t.isBounce) { t = t.f (t.x); } return t.k (t.x); }, 0);}// stack-safe infinite recursion, non-blocking, 100,000,000 recursions in under 8 seconds// now repeatk expects a 4th-argument callback which is called with the asynchronously computed resultfunction repeatk (n, f, x, k) { function aux (n, x) { if (n === 0) return donek (k, x); else return bouncek (function (x) { return aux (n - 1, x); }, f (x)); } return trampolinek (aux (n, x));}console.log('non-blocking line 1')console.time('non-blocking JS1')repeatk (1e8, function (x) { return x + 1; }, 0, function (result) { console.log('non-blocking line 3', result) console.timeEnd('non-blocking JS1')})console.log('non-blocking line 2')// non-blocking line 1// non-blocking line 2// [ synchronous program stops here ]// [ below this line, asynchronous program continues ]// non-blocking line 3 100000000// non-blocking JS1: 7762ms
A better loop/recur pattern
There are two things that I dislike about the loop/recur pattern described in the accepted answer. Note that I actually like the idea behind the loop/recur pattern. However, I dislike the way it has been implemented. So, let's first look at the way I would have implemented it.
// Recur :: a -> Result a bconst Recur = (...args) => ({ recur: true, args });// Return :: b -> Result a bconst Return = value => ({ recur: false, value });// loop :: (a -> Result a b) -> a -> bconst loop = func => (...args) => { let result = func(...args); while (result.recur) result = func(...result.args); return result.value;};// repeat :: (Int, a -> a, a) -> aconst repeat = loop((n, f, x) => n === 0 ? Return(x) : Recur(n - 1, f, f(x)));console.time("loop/recur/return");console.log(repeat(1e6, x => x + 1, 0));console.timeEnd("loop/recur/return");Compare this with the loop/recur pattern described in the aforementioned answer.
// recur :: a -> Recur aconst recur = (...args) => ({ recur, args });// loop :: (a? -> Recur a ∪ b) -> bconst loop = func => { let result = func(); while (result && result.recur === recur) result = func(...result.args); return result;};// repeat :: (Int, a -> a, a) -> aconst repeat = (n, f, x) => loop((m = n, r = x) => m === 0 ? r : recur(m - 1, f(r)));console.time("loop/recur");console.log(repeat(1e6, x => x + 1, 0));console.timeEnd("loop/recur");If you notice, the type signature of the second loop function uses default parameters (i.e. a?) and untagged unions (i.e. Recur a ∪ b). Both of these features are at odds with the functional programming paradigm.
Problem with default parameters
The loop/recur pattern in the aforementioned answer uses default parameters to supply the initial arguments of the function. I think this is an abuse of default parameters. You can just as easily supply initial arguments using my version of loop.
// repeat :: (Int, a -> a, a) -> aconst repeat = (n, f, x) => loop((n, x) => n === 0 ? Return(x) : Recur(n - 1, f(x)))(n, x);// or more readableconst repeat = (n, f, x) => { const repeatF = loop((n, x) => n === 0 ? Return(x) : Recur(n - 1, f(x))); return repeatF(n, x);};Futhermore, it allows eta conversion when the all the arguments are passed through.
// repeat :: (Int, a -> a, a) -> aconst repeat = (n, f, x) => loop((n, f, x) => n === 0 ? Return(x) : Recur(n - 1, f, f(x)))(n, f, x);// can be η-converted toconst repeat = loop((n, f, x) => n === 0 ? Return(x) : Recur(n - 1, f, f(x)));Using the version of loop with default parameters does not allow eta conversion. In addition, it forces you to rename parameters because you can't write (n = n, x = x) => ... in JavaScript.
Problem with untagged unions
Untagged unions are bad because they erase important information, i.e. information of where the data came from. For example, because my Result type is tagged I can distinguish Return(Recur(0)) from Recur(0).
On the other hand, because the right-hand side variant of Recur a ∪ b is untagged, if b is specialized to Recur a, i.e. if the type is specialized to Recur a ∪ Recur a, then it's impossible to determine whether the Recur a came from the left-hand side or the right-hand side.
One criticism might be that b will never be specialized to Recur a, and hence it doesn't matter that b is untagged. Here's a simple counterexample to that criticism.
// recur :: a -> Recur aconst recur = (...args) => ({ recur, args });// loop :: (a? -> Recur a ∪ b) -> bconst loop = func => { let result = func(); while (result && result.recur === recur) result = func(...result.args); return result;};// repeat :: (Int, a -> a, a) -> aconst repeat = (n, f, x) => loop((m = n, r = x) => m === 0 ? r : recur(m - 1, f(r)));// infinite loopconsole.log(repeat(1, x => recur(1, x), "wow, such hack, much loop"));// unreachable codeconsole.log("repeat wasn't hacked");Compare this with my version of repeat which is bulletproof.
// Recur :: a -> Result a bconst Recur = (...args) => ({ recur: true, args });// Return :: b -> Result a bconst Return = value => ({ recur: false, value });// loop :: (a -> Result a b) -> a -> bconst loop = func => (...args) => { let result = func(...args); while (result.recur) result = func(...result.args); return result.value;};// repeat :: (Int, a -> a, a) -> aconst repeat = loop((n, f, x) => n === 0 ? Return(x) : Recur(n - 1, f, f(x)));// finite loopconsole.log(repeat(1, x => Recur(1, x), "wow, such hack, much loop"));// reachable codeconsole.log("repeat wasn't hacked");Thus, untagged unions are unsafe. However, even if we were careful to avoid the pitfalls of untagged unions I would still prefer tagged unions because the tags provide useful information when reading and debugging the program. IMHO, the tags make the program more understandable and easier to debug.
Conclusion
To quote the Zen of Python.
Explicit is better than implicit.
Default parameters and untagged unions are bad because they are implicit, and can lead to ambiguities.
The Trampoline monad
Now, I'd like to switch gears and talk about monads. The accepted answer demonstrates a stack-safe continuation monad. However, if you only need to create a monadic stack-safe recursive function then you don't need the full power of the continuation monad. You can use the Trampoline monad.
The Trampoline monad is a more powerful cousin of the Loop monad, which is just the loop function converted into a monad. So, let's start by understanding the Loop monad. Then we'll see the main problem of the Loop monad and how the Trampoline monad can be used to fix that problem.
// Recur :: a -> Result a bconst Recur = (...args) => ({ recur: true, args });// Return :: b -> Result a bconst Return = value => ({ recur: false, value });// Loop :: (a -> Result a b) -> a -> Loop bconst Loop = func => (...args) => ({ func, args });// runLoop :: Loop a -> aconst runLoop = ({ func, args }) => { let result = func(...args); while (result.recur) result = func(...result.args); return result.value;};// pure :: a -> Loop aconst pure = Loop(Return);// bind :: (Loop a, a -> Loop b) -> Loop bconst bind = (loop, next) => Loop(({ first, loop: { func, args } }) => { const result = func(...args); if (result.recur) return Recur({ first, loop: { func, args: result.args } }); if (first) return Recur({ first: false, loop: next(result.value) }); return result;})({ first: true, loop });// ack :: (Int, Int) -> Loop Intconst ack = (m, n) => { if (m === 0) return pure(n + 1); if (n === 0) return ack(m - 1, 1); return bind(ack(m, n - 1), n => ack(m - 1, n));};console.log(runLoop(ack(3, 4)));Note that loop has been split into a Loop and a runLoop function. The data structure returned by Loop is a monad, and the pure and bind functions implement its monadic interface. We use the pure and bind functions to write a straightforward implementation of the Ackermann function.
Unfortunately, the ack function is not stack safe because it recursively calls itself until it reaches a pure value. Instead, we would like ack to return a Recur like data structure for its inductive cases. However, Recur values are of type Result instead of Loop. This problem is solved by the Trampoline monad.
// Bounce :: (a -> Trampoline b) -> a -> Trampoline bconst Bounce = func => (...args) => ({ bounce: true, func, args });// Return :: a -> Trampoline aconst Return = value => ({ bounce: false, value });// trampoline :: Trampoline a -> aconst trampoline = result => { while (result.bounce) result = result.func(...result.args); return result.value;};// pure :: a -> Trampoline aconst pure = Return;// bind :: (Trampoline a, a -> Trampoline b) -> Trampoline bconst bind = (first, next) => first.bounce ? Bounce(args => bind(first.func(...args), next))(first.args) : next(first.value);// ack :: (Int, Int) -> Trampoline Intconst ack = Bounce((m, n) => { if (m === 0) return pure(n + 1); if (n === 0) return ack(m - 1, 1); return bind(ack(m, n - 1), n => ack(m - 1, n));});console.log(trampoline(ack(3, 4)));The Trampoline data type is a combination of Loop and Result. The Loop and Recur data constructors have been combined into a single Bounce data constructor. The runLoop function has been simplified and renamed to trampoline. The pure and bind functions have also been simplified. In fact, pure is just Return. Finally, we apply Bounce to the original implementation of the ack function.
Another advantage of Trampoline is that it can be used to define stack-safe mutually recursive functions. For example, here's an implementation of the Hofstadter Female and Male sequence functions.
// Bounce :: (a -> Trampoline b) -> a -> Trampoline bconst Bounce = func => (...args) => ({ bounce: true, func, args });// Return :: a -> Trampoline aconst Return = value => ({ bounce: false, value });// trampoline :: Trampoline a -> aconst trampoline = result => { while (result.bounce) result = result.func(...result.args); return result.value;};// pure :: a -> Trampoline aconst pure = Return;// bind :: (Trampoline a, a -> Trampoline b) -> Trampoline bconst bind = (first, next) => first.bounce ? Bounce(args => bind(first.func(...args), next))(first.args) : next(first.value);// female :: Int -> Trampoline Intconst female = Bounce(n => n === 0 ? pure(1) : bind(female(n - 1), f => bind(male(f), m => pure(n - m))));// male :: Int -> Trampoline Intconst male = Bounce(n => n === 0 ? pure(0) : bind(male(n - 1), m => bind(female(m), f => pure(n - f))));console.log(Array.from({ length: 21 }, (_, n) => trampoline(female(n))).join(" "));console.log(Array.from({ length: 21 }, (_, n) => trampoline(male(n))).join(" "));The major pain point of writing monadic code is callback hell. However, this can be solved using generators.
// Bounce :: (a -> Trampoline b) -> a -> Trampoline bconst Bounce = func => (...args) => ({ bounce: true, func, args });// Return :: a -> Trampoline aconst Return = value => ({ bounce: false, value });// trampoline :: Trampoline a -> aconst trampoline = result => { while (result.bounce) result = result.func(...result.args); return result.value;};// pure :: a -> Trampoline aconst pure = Return;// bind :: (Trampoline a, a -> Trampoline b) -> Trampoline bconst bind = (first, next) => first.bounce ? Bounce(args => bind(first.func(...args), next))(first.args) : next(first.value);// bounce :: (a -> Generator (Trampoline b)) -> a -> Trampoline bconst bounce = func => Bounce((...args) => { const gen = func(...args); const next = data => { const { value, done } = gen.next(data); return done ? value : bind(value, next); }; return next(undefined);});// female :: Int -> Trampoline Intconst female = bounce(function* (n) { return pure(n ? n - (yield male(yield female(n - 1))) : 1);});// male :: Int -> Trampoline Intconst male = bounce(function* (n) { return pure(n ? n - (yield female(yield male(n - 1))) : 0);});console.log(Array.from({ length: 21 }, (_, n) => trampoline(female(n))).join(" "));console.log(Array.from({ length: 21 }, (_, n) => trampoline(male(n))).join(" "));Finally, mutually recursive functions also demonstrate the advantage of having a separate trampoline function. It allows us to call a function returning a Trampoline value without actually running it. This allows us to build bigger Trampoline values, and then run the entire computation when required.
Conclusion
If you're want to write indirectly or mutually recursive stack-safe functions, or monadic stack-safe functions then use the Trampoline monad. If you want to write non-monadic directly recursive stack-safe functions then use the loop/recur/return pattern.
Programming in the sense of the functional paradigm means that we are guided by types to express our algorithms.
To transform a tail recursive function into a stack-safe version we have to consider two cases:
- base case
- recursive case
We have to make a choice and this goes well with tagged unions. However, Javascript doesn't have such a data type so either we have to create one or fall back to Object encodings.
Object Encoded
// simulate a tagged union with two Object typesconst Loop = x => ({value: x, done: false}); const Done = x => ({value: x, done: true});// trampolineconst tailRec = f => (...args) => { let step = Loop(args); do { step = f(Loop, Done, step.value); } while (!step.done); return step.value;};// stack-safe functionconst repeat = n => f => x => tailRec((Loop, Done, [m, y]) => m === 0 ? Done(y) : Loop([m - 1, f(y)])) (n, x);// run...const inc = n => n + 1;console.time();console.log(repeat(1e6) (inc) (0));console.timeEnd();Function Encoded
Alternatively, we can create a real tagged union with a function encoding. Now our style is much closer to mature functional languages:
// type/data constructorconst Type = Tcons => (tag, Dcons) => { const t = new Tcons(); t.run = cases => Dcons(cases); t.tag = tag; return t;};// tagged union specific for the caseconst Step = Type(function Step() {});const Done = x => Step("Done", cases => cases.Done(x)); const Loop = args => Step("Loop", cases => cases.Loop(args));// trampolineconst tailRec = f => (...args) => { let step = Loop(args); do { step = f(step); } while (step.tag === "Loop"); return step.run({Done: id});};// stack-safe functionconst repeat = n => f => x => tailRec(step => step.run({ Loop: ([m, y]) => m === 0 ? Done(y) : Loop([m - 1, f(y)]), Done: y => Done(y) })) (n, x);// run...const inc = n => n + 1;const id = x => x;console.log(repeat(1e6) (inc) (0));