## Reversing the order of default arguments in JavaScript - 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.

## Related

### Emulating lisp list operations in js

What would be the proper way to define the cons, car, and cdr functions if we were to use javascript and functional programming? So far I have: // CAR = λxy.x // CDR = λxy.y // CONS = λxy => ? const car = a => b => a; const cdr = a => b => b; const cons = f => a => b; let pair = cons(3)(4); console.log(pair(car)); console.log(pair(cdr)); But my issue is pair(car) seems like an odd way to invoke the function. It seems like car(pair) seems like a better way but I'm not sure how to save the pair so it can be passed like that. How would that be done?

You can write them using continuations - const cons = (a,b) => k => k(a,b) const car = k => k((a,b) => a) const cdr = k => k((a,b) => b) const l = cons(1, cons(2, cons(3, null))) console.log(car(l), car(cdr(l)), car(cdr(cdr(l))), cdr(cdr(cdr(l)))) // 1 2 3 null Define more like list, toString, map, and filter - const cons = (a,b) => k => k(a,b) const car = k => k((a,b) => a) const cdr = k => k((a,b) => b) const list = (v, ...vs) => v == null ? null : cons(v, list(...vs)) const toString = l => l == null ? "Ø" : car(l) + "->" + toString(cdr(l)) console.log(toString(list(1,2,3,4,5))) // 1->2->3->4->5->Ø const square = x => x * x const map = (f, l) => l == null ? null : cons(f(car(l)), map(f, cdr(l))) console.log(toString(map(square, list(1,2,3,4,5)))) // 1->4->9->16->25->Ø const isOdd = x => x & 1 const filter = (f, l) => l == null ? null : Boolean(f(car(l))) ? cons(car(l), filter(f, cdr(l))) : filter(f, cdr(l)) console.log(toString(filter(isOdd, map(square, list(1,2,3,4,5))))) // 1->9->25->Ø Note you could just as easily write cons, car, and cdr abstractions using an array. Lambda is more fun but anything that fulfills the contract is acceptable. Being able to change the underlying representation like this and not require changes in other parts of your program is what makes data abstraction a powerful technique. const cons = (a,b) => [a,b] const car = k => k[0] const cdr = k => k[1] const l = cons(1, cons(2, cons(3, null))) console.log(car(l), car(cdr(l)), car(cdr(cdr(l))), cdr(cdr(cdr(l)))) // 1 2 3 null

The following would be one way to define it, where car and cdr take one argument (a pair) instead of two: // CAR = λxy.x or λp.p[0] where p is xy and p[0] means the first argument (x) // CDR = λxy.y or λp.p[1] where p is xy and p[1] means the second argument (y) // CONS = λxyf.xyf -- basically just saving x and y in a closure and deferring a function call const first = a => b => a; const second = a => b => b; const getFirstFromPair = p => p(first), car = getFirstFromPair; const getSecondFromPair = p => p(second), cdr = getSecondFromPair; const cons = a => b => f => f(a)(b); let pair = cons(3)(4); console.log(car(pair)); console.log(cdr(pair)); Or, if we allow a pair as a single argument, such as (1,2): const cons = (a,b) => f => f(a,b); // f is like a fake function call to do encapsulation const car = f => f((a,b) => a); // and we have to un-do the function call here by passing it the first const cdr = f => f((a,b) => b); console.log(cdr(cons(1,2)));

### Similar curry functions producing different results

I am learning functional javascript and I came across two different implementations of the curry function. I am trying to understand the difference between the two they seem similar yet one works incorrectly for some cases and correctly for other cases. I have tried interchanging the functions the one defined using es6 'const' works for simple cases but when using 'filter' to filter strings the results are incorrect, but with integers it produces the desired results. //es6 //Does not work well with filter when filtering strings //but works correctly with numbers const curry = (fn, initialArgs=[]) => ( (...args) => ( a => a.length === fn.length ? fn(...a) : curry(fn, a) )([...initialArgs, ...args]) ); //Regular js //Works well for all cases function curry(fn) { const arity = fn.length; return function $curry(...args) { if (args.length < arity) { return $curry.bind(null, ...args); } return fn.call(null, ...args); }; } const match = curry((pattern, s) => s.match(pattern)); const filter = curry((f, xs) => xs.filter(f)); const hasQs = match(/q/i); const filterWithQs = filter(hasQs); console.log(filterWithQs(["hello", "quick", "sand", "qwerty", "quack"])); //Output: //es6: [ 'hello', 'quick', 'sand', 'qwerty', 'quack' ] //regular: [ 'quick', 'qwerty', 'quack' ]

If you change filter to use xs.filter(x => f(x)) instead of xs.filter(f) it will work - const filter = curry((f, xs) => xs.filter(x => f(x))) // ... console.log(filterWithQs(["hello", "quick", "sand", "qwerty", "quack"])) // => [ 'quick', 'qwerty', 'quack' ] The reason for this is because Array.prototype.filter passes three (3) arguments to the "callback" function, callback - Function is a predicate, to test each element of the array. Return true to keep the element, false otherwise. It accepts three arguments: element - The current element being processed in the array. index (Optional) - The index of the current element being processed in the array. array (Optional) - The array filter was called upon. The f you are using in filter is match(/q/i), and so when it is called by Array.prototype.filter, you are getting three (3) extra arguments instead of the expected one (1). In the context of curry, that means a.length will be four (4), and since 4 === fn.length is false (where fn.length is 2), the returned value is curry(fn, a), which is another function. Since all functions are considered truthy values in JavaScript, the filter call returns all of the input strings. // your original code: xs.filter(f) // is equivalent to: xs.filter((elem, index, arr) => f(elem, index, arr)) By changing filter to use ...filter(x => f(x)), we only allow one (1) argument to be passed to the callback, and so curry will evaluate 2 === 2, which is true, and the return value is the result of evaluating match, which returns the expected true or false. // the updated code: xs.filter(x => f(x)) // is equivalent to: xs.filter((elem, index, arr) => f(elem)) An alternative, and probably better option, is to change the === to >= in your "es6" curry - const curry = (fn, initialArgs=[]) => ( (...args) => ( a => a.length >= fn.length ? fn(...a) : curry(fn, a) )([...initialArgs, ...args]) ) // ... console.log(filterWithQs(["hello", "quick", "sand", "qwerty", "quack"])) // => [ 'quick', 'qwerty', 'quack' ] This allows you to "overflow" function parameters "normally", which JavaScript has no problem with - const foo = (a, b, c) => // has only three (3) parameters console.log(a + b + c) foo(1,2,3,4,5) // called with five (5) args // still works // => 6 Lastly here's some other ways I've written curry over the past. I've tested that each of them produce the correct output for your problem - by auxiliary loop - const curry = f => { const aux = (n, xs) => n === 0 ? f (...xs) : x => aux (n - 1, [...xs, x]) return aux (f.length, []) } versatile curryN, works with variadic functions - const curryN = n => f => { const aux = (n, xs) => n === 0 ? f (...xs) : x => aux (n - 1, [...xs, x]) return aux (n, []) }; // curry derived from curryN const curry = f => curryN (f.length) (f) spreads for days - const curry = (f, ...xs) => (...ys) => f.length > xs.length + ys.length ? curry (f, ...xs, ...ys) : f (...xs, ...ys) homage to the lambda calculus and Howard Curry's fixed-point Y-combinator - const U = f => f (f) const Y = U (h => f => f (x => U (h) (f) (x))) const curryN = Y (h => xs => n => f => n === 0 ? f (...xs) : x => h ([...xs, x]) (n - 1) (f) ) ([]) const curry = f => curryN (f.length) (f) and my personal favourites - // for binary (2-arity) functions const curry2 = f => x => y => f (x, y) // for ternary (3-arity) functions const curry3 = f => x => y => z => f (x, y, z) // for arbitrary arity const partial = (f, ...xs) => (...ys) => f (...xs, ...ys) Lastly a fun twist on #Donat's answer that enables anonymous recursion - const U = f => f (f) const curry = fn => U (r => (...args) => args.length < fn.length ? U (r) .bind (null, ...args) : fn (...args) )

The main difference here is not the es6 syntax but how the arguments are partially applied to the function. First version: curry(fn, a) Second versison: $curry.bind(null, ...args) It works for only one step of currying (as needed in your example) if you change first version (es6) to fn.bind(null, ...args) The representation of the "Regular js" version in es6 syntax would look like this (you need the constant to have a name for the function in the recursive call): curry = (fn) => { const c = (...args) => ( args.length < fn.length ? c.bind(null, ...args) : fn(...args) ); return c; }

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

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.

### 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()));

### 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)