如何防止尾递归函数反转List的顺序？

Question

I am experimenting with the functional List type and structural sharing. Since Javascript doesn't have a Tail Recursive Modulo Cons optimization, we can't just write List combinators like this, because they are not stack safe:

 const list = [1, [2, [3, [4, [5, []]]]]]; const take = n => ([head, tail]) => n === 0 ? [] : head === undefined ? [] : [head, take(n - 1) (tail)]; console.log( take(3) (list) // [1, [2, [3, []]]] ); 

Now I tried to implement take tail recursively, so that I can either rely on TCO (still an unsettled Promise in Ecmascript) or use a trampoline (omitted in the example to keep things simple):

 const list = [1, [2, [3, [4, [5, []]]]]]; const safeTake = n => list => { const aux = (n, acc, [head, tail]) => n === 0 ? acc : head === undefined ? acc : aux(n - 1, [head, acc], tail); return aux(n, [], list); }; console.log( safeTake(3) (list) // [3, [2, [1, []]]] ); 

This works but the new created list is in reverse order. How can I solve this issue in a purely functional manner?

Answer 1

One way to prevent the list from reversing is to use continuation passing style. Now just put it on a trampoline of your choice...

 const None = Symbol () const identity = x => x const safeTake = (n, [ head = None, tail ], cont = identity) => head === None || n === 0 ? cont ([]) : safeTake (n - 1, tail, answer => cont ([ head, answer ])) const list = [ 1, [ 2, [ 3, [ 4, [ 5, [] ] ] ] ] ] console.log (safeTake (3, list)) // [ 1, [ 2, [ 3, [] ] ] ] 

Here it is on a trampoline

const None =
  Symbol ()

const identity = x =>
  x

const call = (f, ...values) =>
  ({ tag: call, f, values })

const trampoline = acc =>
{
  while (acc && acc.tag === call)
    acc = acc.f (...acc.values)
  return acc
}

const safeTake = (n = 0, xs = []) =>
{
  const aux = (n, [ head = None, tail ], cont) =>
    head === None || n === 0
      ? call (cont, [])
      : call (aux, n - 1, tail, answer =>
          call (cont, [ head, answer ]))
  return trampoline (aux (n, xs, identity))
}

const list =
  [ 1, [ 2, [ 3, [ 4, [ 5, [] ] ] ] ] ]

console.log (safeTake (3, list))
// [ 1, [ 2, [ 3, [] ] ] ] 

Answer 2

Laziness gives you tail recursion modulo cons for free. Hence, the obvious solution is to use thunks. However, we don't just want any kind of thunk. We want a thunk for an expression in weak head normal form . In JavaScript, we can implement this using lazy getters as follows:

 const cons = (head, tail) => ({ head, tail }); const list = cons(1, cons(2, cons(3, cons(4, cons(5, null))))); const take = n => n === 0 ? xs => null : xs => xs && { head: xs.head, get tail() { delete this.tail; return this.tail = take(n - 1)(xs.tail); } }; console.log(take(3)(list)); 

There are lots of advantages to using lazy getters:

1. Normal properties and lazy properties are used in the same way.
2. You can use it to create infinite data structures.
3. You don't have to worry about blowing up the stack.

Hope that helps.