SICP 是一篇精彩的文章。这里的代码应该是不言自明的。我目前时间紧，但我会在今天晚些时候跟进，以添加一些细节并回答潜在的后续问题 -
main.js
// main.js
import { of, fromArray, toString } from './list'
toString(of(999))
// 999->Empty.
toString(fromArray([]))
// Empty.
toString(fromArray([1]))
// 1->Empty.
toString(fromArray([1,2,3,4]))
// 1->2->3->4->Empty.
const big =
Array.from(Array(100000), (_, x) => x)
toString(fromArray(big))
// 0->1->2->3->...99999->Empty.
list.js
import { loop, recur } from './function'
const empty = // <-- empty list
Symbol() // <-- any sentinel value
const pair = (left, right) => // <-- pair constructor
({ pair, left, right }) // <-- plain object
const of = (x = null) => // <-- "of" constructor
pair(x, empty) // <-- singleton list
const fromArray = (xs = []) =>
loop // <-- begin loop
( ( r = empty // <-- init r
, i = 0 // <-- init i
) => // <-- loop body
i >= xs.length // <-- exit condition
? reverse(r) // <-- tail; return
: recur // <-- tail; recur
( pair(xs[i], r) // <-- next r
, i + 1 // <-- next i
)
)
const reverse = (node = empty) =>
loop // <-- begin loop
( ( r = empty // <-- init r
, t = node // <-- init t
) => // <-- loop body
t === empty // <-- exit condition
? r // <-- tail; return
: recur // <-- tail; recur
( pair(t.left, r) // <-- next r
, t.right // <-- next t
)
)
const toString = (node = empty) =>
loop // <-- begin loop
( ( r = "Empty." // <-- init r
, t = reverse(node) // <-- init t
) => // <-- loop body
t === empty // <-- exit condition
? r // <-- tail; return
: recur // <-- tail; recur
( t.left + "->" + r // <-- next r
, t.right // <-- next t
)
)
// "pair" is not exported
// it is an implementation detail of our list module
export { empty, of, fromArray, reverse, toString }
function.js
const identity = x => x
const recur = (...v) =>
({ recur, [Symbol.iterator]: _ => v.values() })
const loop = (f = identity, ...init) =>
whileTrue // <-- functional while
( r => r && r.recur // <-- while condition
, r => f(...r) // <-- next r
, f(...init) // <-- init r
)
const whileTrue = (test = identity, next = identity, r = null) =>
{ while(Boolean(test(r))) // <-- while test(r) is true
r = next(r) // <-- nexr r
return r // <-- return r
}
export { identity, loop, recur, whileTrue }
演示
展开下面的sn-p，在浏览器中验证结果-
// function.js -------
const identity = x => x
const recur = (...v) =>
({ recur, [Symbol.iterator]: _ => v.values() })
const loop = (f = identity, ...init) =>
whileTrue
( r => r && r.recur
, r => f(...r)
, f(...init)
)
const whileTrue = (test = identity, next = identity, r = null) =>
{ while(Boolean(test(r)))
r = next(r)
return r
}
// list.js -------
const empty =
Symbol()
const pair = (left, right) =>
({ pair, left, right })
const of = (x = null) =>
pair(x, empty)
const fromArray = (xs = []) =>
loop
( ( r = empty
, i = 0
) =>
i >= xs.length
? reverse(r)
: recur
( pair(xs[i], r)
, i + 1
)
)
const reverse = (node = empty) =>
loop
( ( r = empty
, t = node
) =>
t === empty
? r
: recur
( pair(t.left, r)
, t.right
)
)
const toString = (node = empty) =>
loop
( ( r = "Empty."
, t = reverse(node)
) =>
t === empty
? r
: recur
( t.left + "->" + r
, t.right
)
)
// main.js -------
console.log(toString(of(999)))
// 999->Empty.
console.log(toString(fromArray([])))
// Empty.
console.log(toString(fromArray([1])))
// 1->Empty.
console.log(toString(fromArray([1,2,3,4])))
// 1->2->3->4->Empty.
const big =
Array.from(Array(100000), (_, x) => x)
console.log(toString(fromArray(big)))
// 0->1->2->3->...99999->Empty.
进一步抽象
如果有更多时间，我可能会写 pair 作为它自己的模块 -
// pair.js
import { raise } from './function'
const empty =
Symbol()
const pair = (left, right) =>
({ pair, left, right })
const left = (t = empty) =>
t === empty
? raise(`cannot read value from empty`)
: t.left
const right = (t = empty) =>
t === empty
? raise(`cannot read value from empty`)
: t.right
const of = ([ left, right ]) =>
pair(left, right)
export { empty, pair, left, right, of }
将raise 添加到function 模块-
// function.js
const identity = //
const recur = //
const loop = //
const whileTrue = //
const raise = (msg = "") => // functional throw
{ throw Error(msg) }
export { identity, loop, recur, whileTrue, raise }
在list 模块和pair 模块之间创建更好的抽象屏障-
// list.js
import { loop, recur } from './function'
import { empty, pair, left, right } from './pair'
const of = (x = null) =>
pair(x, empty) // <-- pair, empty
const fromArray = (xs = []) =>
loop
( ( r = empty // <-- empty
, i = 0
) =>
i >= xs.length
? reverse(r)
: recur
( pair(xs[i], r) // <-- pair
, i + 1 //
)
)
const reverse = (node = empty) =>
loop
( ( r = empty // <-- empty
, t = node
) =>
t === empty // <-- empty
? r
: recur
( pair(left(t), r) // <-- pair, left
, right(t) // <-- right
)
)
const toString = (node = empty) =>
loop
( ( r = "Empty."
, t = reverse(node)
) =>
t === empty // <-- empty
? r
: recur
( left(t) + "->" + r // <-- left
, right(t) // <-- right
)
)
// re-export empty
// it's okay that List.empty and Pair.empty are
// represented using the same sentinel value
export { empty, of, fromArray, reverse, toString }
很高兴看到将pair 作为一个单独的步骤编写，因为它向我们展示了当数据结构变得过于复杂时如何分解模块。