functionalscript 0.0.487 → 0.0.489

package/types/list/module.f.cjs

@@ -1,4 +1,5 @@
-const { compose, identity } = require('../function/module.f.cjs')
+const function_ = require('../function/module.f.cjs')
+const { identity, fn, compose } = function_
 const operator = require('../function/operator/module.f.cjs')
 const {
     counter,
@@ -23,7 +24,7 @@ const {
  * } NotLazy
  */
 
-/** @typedef {undefined} Empty */
+/** @typedef {null} Empty */
 
 /**
  * @template T
@@ -46,8 +47,8 @@ const {
 /**
  * @template T
  * @typedef {{
- *  readonly a: List<T>
- *  readonly b: List<T>
+ *  readonly head: List<T>
+ *  readonly tail: List<T>
  * }} Concat
  */
 
@@ -55,41 +56,40 @@ const {
 const fromArray = array => {
     /** @typedef {typeof array extends readonly (infer T)[] ? T : never} T */
     /** @type {(i: number) => Result<T>} */
-    const at = i => i < array.length ? { first: array[i], tail: () => at(i + 1) } : undefined
+    const at = i => i < array.length ? { first: array[i], tail: () => at(i + 1) } : null
     return at(0)
 }
 
-/** @type {<T>(a: List<T>) => (b: List<T>) => List<T>} */
-const concat = a => b => b === undefined ? a : ({ isConcat: true, a, b })
+/** @type {<T>(head: List<T>) => (tail: List<T>) => List<T>} */
+const concat = head => tail => tail === null ? head : ({ head, tail })
 
 /** @type {<T>(list: List<T>) => NotLazy<T> } */
 const trampoline = list => {
-    let i = list
-    while (typeof i === 'function') { i = i() }
-    return i
+    while (typeof list === 'function') { list = list() }
+    return list
 }
 
 /** @type {<T>(list: List<T>) => Result<T>} */
-const next = list => {
-    /** @type {readonly[typeof list, typeof list]} */
-    let [a, b] = [list, undefined]
+const next = head => {
+    /** @type {typeof head} */
+    let tail = null
     while (true) {
-        a = trampoline(a)
+        head = trampoline(head)
 
-        if (a instanceof Array) {
-            a = fromArray(a)
-        } else if (a !== undefined && 'a' in a) {
-            [a, b] = [a.a, concat(a.b)(b)]
+        if (head instanceof Array) {
+            head = fromArray(head)
+        } else if (head !== null && 'head' in head) {
+            [head, tail] = [head.head, concat(head.tail)(tail)]
             continue
         }
 
-        if (a !== undefined) {
-            return { first: a.first, tail: concat(a.tail)(b) }
+        if (head !== null) {
+            return { first: head.first, tail: concat(head.tail)(tail) }
         }
 
-        if (b === undefined) { return undefined }
+        if (tail === null) { return null }
 
-        [a, b] = [b, undefined]
+        [head, tail] = [tail, null]
     }
 }
 
@@ -99,7 +99,7 @@ const iterable = list => ({
         let i = list
         while (true) {
             const r = next(i)
-            if (r === undefined) { return }
+            if (r === null) { return }
             yield r.first
             i = r.tail
         }
@@ -117,18 +117,18 @@ const toArray = list => {
 /** @type {<I, O>(step: (n: NonEmpty<I>) => List<O>) => (input: List<I>) => Thunk<O>} */
 const apply = f => input => () => {
     const n = next(input)
-    if (n === undefined) { return undefined }
+    if (n === null) { return null }
     return f(n)
 }
 
 /** @type {<T>(n: NonEmpty<List<T>>) => List<T>} */
-const flatStep = n => concat(n.first)(flat(n.tail))
+const flatStep = ({ first, tail }) => concat(first)(flat(tail))
 
 /** @type {<T>(list: List<List<T>>) => Thunk<T>} */
 const flat = apply(flatStep)
 
 /** @type {<I, O>(f: (value: I) => O) => (n: NonEmpty<I>) => List<O>} */
-const mapStep = f => n => ({ first: f(n.first), tail: map(f)(n.tail) })
+const mapStep = f => ({ first, tail }) => ({ first: f(first), tail: map(f)(tail) })
 
 /** @type {<I, O>(f: (value: I) => O) => (input: List<I>) => Thunk<O>} */
 const map = f => apply(mapStep(f))
@@ -137,31 +137,31 @@ const map = f => apply(mapStep(f))
 const flatMap = f => compose(map(f))(flat)
 
 /** @type {<T>(f: (value: T) => boolean) => (n: NonEmpty<T>) => List<T>} */
-const filterStep = f => n => {
-    const tail = filter(f)(n.tail)
-    return f(n.first) ? { first: n.first, tail } : tail
+const filterStep = f => ({ first, tail }) => {
+    const newTail = filter(f)(tail)
+    return f(first) ? { first, tail: newTail } : newTail
 }
 
 /** @type {<T>(f: (value: T) => boolean) => (input: List<T>) => Thunk<T>} */
 const filter = f => apply(filterStep(f))
 
-/** @type {<I, O>(f: (value: I) => O|undefined) => (n: NonEmpty<I>) => List<O>} */
+/** @type {<I, O>(f: (value: I) => O|null) => (n: NonEmpty<I>) => List<O>} */
 const filterMapStep = f => n => {
     const [first, tail] = [f(n.first), filterMap(f)(n.tail)]
-    return first === undefined ? tail : { first, tail }
+    return first === null ? tail : { first, tail }
 }
 
-/** @type {<I, O>(f: (value: I) => O|undefined) => (input: List<I>) => Thunk<O>} */
+/** @type {<I, O>(f: (value: I) => O|null) => (input: List<I>) => Thunk<O>} */
 const filterMap = f => apply(filterMapStep(f))
 
 /** @type {<T>(f: (value: T) => boolean) => (n: NonEmpty<T>) => List<T>} */
-const takeWhileStep = f => n => f(n.first) ? { first: n.first, tail: takeWhile(f)(n.tail) } : undefined
+const takeWhileStep = f => ({ first, tail }) => f(first) ? { first, tail: takeWhile(f)(tail) } : null
 
 /** @type {<T>(f: (value: T) => boolean) => (input: List<T>) => Thunk<T>} */
 const takeWhile = f => apply(takeWhileStep(f))
 
 /** @type {(n: number) => <T>(result: NonEmpty<T>) => List<T>} */
-const takeStep = n => ne => 0 < n ? { first: ne.first, tail: take(n - 1)(ne.tail) } : undefined
+const takeStep = n => ({ first, tail }) => 0 < n ? { first: first, tail: take(n - 1)(tail) } : null
 
 /** @type {(n: number) => <T>(input: List<T>) => Thunk<T>} */
 const take = n => apply(takeStep(n))
@@ -180,8 +180,8 @@ const drop = n => apply(dropStep(n))
 
 /** @type {<D>(def: D) => <T>(input: List<T>) => D|T} */
 const first = def => input => {
-    const result = next(input)
-    return result === undefined ? def : result.first
+    const ne = next(input)
+    return ne === null ? def : ne.first
 }
 
 /** @type {<D>(first: D) => <T>(tail: List<T>) => D|T} */
@@ -191,7 +191,7 @@ const last = first => tail => {
     let i = { first, tail }
     while (true) {
         const result = next(i.tail)
-        if (result === undefined) {
+        if (result === null) {
             return i.first
         }
         i = result
@@ -199,43 +199,39 @@ const last = first => tail => {
 }
 
 /** @type {<D>(def: D) => <T>(f: (value: T) => boolean) => (input: List<T>) => D|T} */
-const find = def => f => input => first(def)(filter(f)(input))
-
-const findTrue = find(false)
+const find = def => f => compose(filter(f))(first(def))
 
 /** @type {(input: List<boolean>) => boolean} */
-const some = input => findTrue
-    (/** @type {(_: boolean) => boolean} */(identity))
-    (input)
-
-/** @type {<T>(f: List<T>) => Thunk<boolean>} */
-const mapTrue = map(() => true)
+const some = find(false)(identity)
 
 /** @type {<T>(input: List<T>) => boolean} */
-const isEmpty = input => !some(mapTrue(input))
+const isEmpty = fn(map(() => true))
+    .then(some)
+    .then(logicalNot)
+    .result
 
-const mapNot = map(logicalNot)
-
-/** @type {(input: List<boolean>) => boolean} */
-const every = input => !some(mapNot(input))
+const every = fn(map(logicalNot))
+    .then(some)
+    .then(logicalNot)
+    .result
 
 /** @type {<T>(value: T) => (sequence: List<T>) => boolean} */
-const includes = value => input => some(map(strictEqual(value))(input))
+const includes = value => compose(map(strictEqual(value)))(some)
 
 /** @type {(count: number) => Thunk<number>} */
 const countdown = count => () => {
-    if (count <= 0) { return undefined }
+    if (count <= 0) { return null }
     const first = count - 1
     return { first, tail: countdown(first) }
 }
 
 /** @type {<T>(v: T) => (c: number) => Thunk<T>} */
-const repeat = v => n => map(() => v)(countdown(n))
+const repeat = v => compose(countdown)(map(() => v))
 
 /** @type {<T>(list: List<T>) => List<T>} */
 const cycle = list => () => {
     const i = next(list)
-    return i === undefined ? undefined : { first: i.first, tail: concat(i.tail)(cycle(list)) }
+    return i === null ? null : { first: i.first, tail: concat(i.tail)(cycle(list)) }
 }
 
 /** @type {<I, O>(op: operator.Scan<I, O>) => (ne: NonEmpty<I>) => List<O>} */
@@ -248,17 +244,16 @@ const scanStep = op => ne => {
 const scan = op => apply(scanStep(op))
 
 /** @type {<I, S, O>(op: operator.StateScan<I, S, O>) => (init: S) => (input: List<I>) => Thunk<O>} */
-const stateScan = op => init => scan(stateScanToScan(op)(init))
+const stateScan = op => compose(stateScanToScan(op))(scan)
 
 /** @type {<I,O>(op: operator.Fold<I, O>) => (init: O) => (input: List<I>) => Thunk<O>} */
-const foldScan = op => init => scan(foldToScan(op)(init))
+const foldScan = op => compose(foldToScan(op))(scan)
 
 /** @type {<I,O>(op: operator.Fold<I, O>) => (init: O) => (input: List<I>) => O} */
-const fold = op => init => input => last(init)(foldScan(op)(init)(input))
+const fold = op => init => compose(foldScan(op)(init))(last(init))
 
 /** @type {<T>(op: operator.Reduce<T>) => <D>(def: D) => (input: List<T>) => D|T} */
-const reduce = op => def => input => last(def)(scan(reduceToScan(op))(input))
-
+const reduce = op => def => compose(scan(reduceToScan(op)))(last(def))
 
 /** @type {<T>(input: List<T>) => number} */
 const length = fold(counter)(0)
@@ -283,14 +278,14 @@ const entries = input => {
 const reverseOperator = first => tail => ({ first, tail })
 
 /** @type {<T>(input: List<T>) => List<T>} */
-const reverse = fold(reverseOperator)(undefined)
+const reverse = fold(reverseOperator)(null)
 
 /** @type {<A>(a: List<A>) => <B>(b: List<B>) => List<readonly[A, B]>} */
 const zip = a => b => () => {
     const aResult = next(a)
-    if (aResult === undefined) { return undefined }
+    if (aResult === null) { return null }
     const bResult = next(b)
-    if (bResult === undefined) { return undefined }
+    if (bResult === null) { return null }
     return { first: [aResult.first, bResult.first], tail: zip(aResult.tail)(bResult.tail) }
 }
 
@@ -300,8 +295,8 @@ const equal = e => {
     /** @type {(a: List<T>) => (b: List<T>) => List<boolean>} */
     const f = a => b => () => {
         const [aResult, bResult] = [next(a), next(b)]
-        return aResult === undefined || bResult === undefined
-            ? { first: aResult === bResult, tail: undefined }
+        return aResult === null || bResult === null
+            ? { first: aResult === bResult, tail: null }
             : { first: e(aResult.first)(bResult.first), tail: f(aResult.tail)(bResult.tail) }
     }
     return a => b => every(f(a)(b))
@@ -309,7 +304,7 @@ const equal = e => {
 
 module.exports = {
     /** @readonly */
-    empty: undefined,
+    empty: null,
     /** @readonly */
     concat,
     /** @readonly */

package/types/list/test.f.cjs

@@ -29,7 +29,7 @@ const flat = () => {
 const concat = () => {
     const result = _.concat([1])([2])
     const x = _.next(result)
-    if (x === undefined) { throw x }
+    if (x === null) { throw x }
     if (x.first !== 1) { throw x }
 }
 
@@ -55,11 +55,11 @@ const take = [
 
 const find = [
     () => {
-        const result = _.find(undefined)(x => x % 2 === 0)([1, 3, 5, 7])
-        if (result !== undefined) { throw result }
+        const result = _.find(null)(x => x % 2 === 0)([1, 3, 5, 7])
+        if (result !== null) { throw result }
     },
     () => {
-        const result = _.find(undefined)(x => x % 2 === 0)([1, 2, 3, 4])
+        const result = _.find(null)(x => x % 2 === 0)([1, 2, 3, 4])
         if (result !== 2) { throw result }
     }
 ]
@@ -102,12 +102,12 @@ const additionTests = [
         if (result !== '[2,5,9,14]') { throw result }
     },
     () => {
-        const result = _.reduce(addition)(undefined)([2, 3, 4, 5])
+        const result = _.reduce(addition)(null)([2, 3, 4, 5])
         if (result !== 14) { throw result }
     },
     () => {
-        const result = _.reduce(addition)(undefined)([])
-        if (result !== undefined) { throw result }
+        const result = _.reduce(addition)(null)([])
+        if (result !== null) { throw result }
     }
 ]
 
@@ -191,7 +191,7 @@ const stress = () => ({
         const n = 50_000_000
         const result = _.toArray(_.countdown(n))
         if (result.length !== n) { throw result.length }
-        const first = _.first(undefined)(result)
+        const first = _.first(null)(result)
         if (first !== n - 1) { throw first }
     },
     concatBack: () => {
@@ -244,7 +244,7 @@ const stress = () => ({
         const n = 50_000_000
         const result = _.toArray(_.countdown(n))
         if (result.length !== n) { throw result.length }
-        const len = _.length(_.filterMap(() => undefined)(result))
+        const len = _.length(_.filterMap(() => null)(result))
         if (len !== 0) { throw len }
     },
     dropWhile: () => {

package/types/map/module.f.cjs

@@ -31,15 +31,16 @@ const operator = require('../function/operator/module.f.cjs')
 /** @type {(a: string) => <T>(b: Entry<T>) => Sign} */
 const keyCmp = a => ([b]) => cmp(a)(b)
 
-/** @type {(name: string) => <T>(map: Map<T>) => T|undefined} */
+/** @type {(name: string) => <T>(map: Map<T>) => T|null} */
 const at = name => map => {
-    if (map === undefined) { return undefined }
+    if (map === null) { return null }
     const result = value(find(keyCmp(name))(map).first)
-    return result === undefined ? undefined : result[1]
+    return result === null ? null : result[1]
 }
 
 /** @type {<T>(reduce: operator.Reduce<T>) => (entry: Entry<T>) => (map: Map<T>) => Map<T>} */
-const setReduceEntry = reduce => entry => set(keyCmp(entry[0]))(old => old === undefined ? entry : [old[0], reduce(old[1])(entry[1])])
+const setReduceEntry = reduce => entry =>
+    set(keyCmp(entry[0]))(old => old === null ? entry : [old[0], reduce(old[1])(entry[1])])
 
 /** @type {<T>(reduce: operator.Reduce<T>) => (name: string) => (value: T) => (map: Map<T>) => Map<T>} */
 const setReduce = reduce => name => value => setReduceEntry(reduce)([name, value])
@@ -54,14 +55,14 @@ const setReplace = name => value => setReduceEntry(replace)([name, value])
 const entries = values
 
 /** @type {<T>(entries: list.List<Entry<T>>) => Map<T>} */
-const fromEntries = fold(setReduceEntry(replace))(undefined)
+const fromEntries = fold(setReduceEntry(replace))(null)
 
 /** @type {(name: string) => <T>(map: Map<T>) => Map<T>} */
 const remove = name => btreeRemove(keyCmp(name))
 
 module.exports = {
     /** @readonly */
-    empty: undefined,
+    empty: null,
     /** @readonly */
     at,
     /** @readonly */

package/types/map/test.f.cjs

@@ -4,23 +4,23 @@ const seq = require('../list/module.f.cjs')
 module.exports = {
     main: [
         () => {
-            let m = setReplace('a')(1)(undefined)
+            let m = setReplace('a')(1)(null)
 
             if (at('a')(m) !== 1) { throw 'error' }
-            if (at('b')(m) !== undefined) { throw 'error' }
+            if (at('b')(m) !== null) { throw 'error' }
 
             m = setReplace('b')(2)(m)
 
             if (at('a')(m) !== 1) { throw 'error' }
             if (at('b')(m) !== 2) { throw 'error' }
-            if (at('c')(m) !== undefined) { throw 'error' }
+            if (at('c')(m) !== null) { throw 'error' }
 
             m = setReplace('z')(3)(m)
 
             if (at('a')(m) !== 1) { throw 'error' }
             if (at('b')(m) !== 2) { throw 'error' }
             if (at('z')(m) !== 3) { throw 'error' }
-            if (at('')(m) !== undefined) { throw 'error' }
+            if (at('')(m) !== null) { throw 'error' }
 
             m = setReplace('')(4)(m)
 
@@ -28,7 +28,7 @@ module.exports = {
             if (at('b')(m) !== 2) { throw 'error' }
             if (at('z')(m) !== 3) { throw 'error' }
             if (at('')(m) !== 4) { throw 'error' }
-            if (at('Hello world!')(m) !== undefined) { throw 'error' }
+            if (at('Hello world!')(m) !== null) { throw 'error' }
 
             m = setReplace('Hello world!')(42)(m)
 
@@ -37,21 +37,21 @@ module.exports = {
             if (at('z')(m) !== 3) { throw 'error' }
             if (at('')(m) !== 4) { throw 'error' }
             if (at('Hello world!')(m) !== 42) { throw 'error' }
-            if (at('x')(m) !== undefined) { throw 'error' }
+            if (at('x')(m) !== null) { throw 'error' }
 
             // console.log(Array.from(m.entries()))
             m = remove('Hello world!')(m)
-            if (at('Hello world!')(m) !== undefined) { throw m }
+            if (at('Hello world!')(m) !== null) { throw m }
 
             m = setReduce(a => b => a + b)('a')(43)(m)
             if (at('a')(m) !== 44) { throw 'error' }
         },
         () => {
-            let m = setReplace('x')(12)(undefined)
+            let m = setReplace('x')(12)(null)
             m = setReplace('y')(44)(m)
             if (at('x')(m) !== 12) { throw 'error' }
             if (at('y')(m) !== 44) { throw 'error' }
-            if (at('a')(m) !== undefined) { throw 'error' }
+            if (at('a')(m) !== null) { throw 'error' }
             const e = seq.toArray(entries(m))
             if (e.length !== 2) { throw 'error' }
         },

package/types/nullable/module.f.cjs

@@ -0,0 +1,17 @@
+/**
+ * @template T
+ * @typedef {T|null} Nullable
+ */
+
+/** @type {<T, R>(f: (value: T) => R) => (value: Nullable<T>) => Nullable<R>} */
+const map = f => value => value === null ? null : f(value)
+
+/** @type {<T, R>(f: (_: T) => R) => (none: () => R) => (_: Nullable<T>) => Nullable<R>} */
+const match = f => none => value => value === null ? none() : f(value)
+
+module.exports = {
+    /** @readonly */
+    map,
+    /** @readonly */
+    match,
+}

package/types/{option → nullable}/test.f.cjs

@@ -4,6 +4,6 @@ module.exports = () => {
     const optionSq = _.map(v => v * v)
     const sq3 = optionSq(3)
     if (sq3 !== 9) { throw sq3 }
-    const sqUndefined = optionSq(undefined)
-    if (sqUndefined !== undefined) { throw sqUndefined }
+    const sqNull = optionSq(null)
+    if (sqNull !== null) { throw sqNull }
 }

package/types/number/module.f.cjs

@@ -5,9 +5,9 @@ const { unsafeCmp } = compare
 
 const sum = reduce(addition)(0)
 
-const min = reduce(minOp)(undefined)
+const min = reduce(minOp)(null)
 
-const max = reduce(maxOp)(undefined)
+const max = reduce(maxOp)(null)
 
 /** @type {(a: number) => (b: number) => compare.Sign} */
 const cmp = unsafeCmp

package/types/number/test.f.cjs

@@ -8,7 +8,7 @@ module.exports = {
     min: {
         empty: () => {
             const result = min([])
-            if (result !== undefined) { throw result }
+            if (result !== null) { throw result }
         },
         multi: () => {
             const result = min([1, 2, 12, -4, 8])

package/types/range_map/module.f.cjs

@@ -2,7 +2,7 @@ const sortedList = require("../sorted_list/module.f.cjs")
 const { genericMerge } = sortedList
 const list = require("../list/module.f.cjs")
 const { next } = list
-const option = require("../option/module.f.cjs")
+const option = require("../nullable/module.f.cjs")
 const { cmp } = require('../number/module.f.cjs')
 const operator = require("../function/operator/module.f.cjs")
 const _range = require('../range/module.f.cjs')
@@ -32,7 +32,7 @@ const _range = require('../range/module.f.cjs')
 
 /**
  * @template T
- * @typedef {option.Option<Entry<T>>} RangeState
+ * @typedef {option.Nullable<Entry<T>>} RangeState
  */
 
 /**
@@ -45,21 +45,21 @@ const reduceOp = union => equal => state => ([aItem, aMax]) => ([bItem, bMax])
   const sign = cmp(aMax)(bMax)
   const min = sign === 1 ? bMax : aMax
   const u = union(aItem)(bItem)
-  const newState = state !== undefined && equal(state[0])(u) ? undefined : state
+  const newState = state !== null && equal(state[0])(u) ? null : state
   return [newState, sign, [u, min]]
 }
 
 /** @type {<T>(equal: operator.Equal<T>) => sortedList.TailReduce<Entry<T>, RangeState<T>>} */
 const tailReduce = equal => state => tail => {
-  if (state === undefined) { return tail }
+  if (state === null) { return tail }
   const tailResult = next(tail)
-  if (tailResult === undefined) { return [state] }
+  if (tailResult === null) { return [state] }
   if (equal(state[0])(tailResult.first[0])) { return tailResult }
   return { first: state, tail: tailResult }
 }
 
  /** @type {<T>(op: Operators<T>) => RangeMerge<T>} */
-const merge = ({union, equal}) => genericMerge({reduceOp: reduceOp(union)(equal), tailReduce: tailReduce(equal)})(undefined)
+const merge = ({union, equal}) => genericMerge({reduceOp: reduceOp(union)(equal), tailReduce: tailReduce(equal)})(null)
 
 /** @type {<T>(def: T) => (value: number) => (rm: RangeMapArray<T>) => T} */
 const get = def => value => rm => {

package/types/range_map/test.f.cjs

@@ -18,14 +18,14 @@ module.exports = {
             /** @type {_.RangeMap<sortedSet.SortedSet<string>>} */
             const a = [[['a'], 1], [['b'], 2]]
             /** @type {_.RangeMap<sortedSet.SortedSet<string>>} */
-            const b = undefined
+            const b = null
             const merged = _.merge(op)(a)(b)
             const result = stringify(list.toArray(merged))
             if (result !== '[[["a"],1],[["b"],2]]') { throw result }
         },
         () => {
             /** @type {_.RangeMap<sortedSet.SortedSet<string>>} */
-            const a = undefined
+            const a = null
             /** @type {_.RangeMap<sortedSet.SortedSet<string>>} */
             const b = [[['a'], 1], [['b'], 2]]
             const merged = _.merge(op)(a)(b)

package/types/sorted_list/module.f.cjs

@@ -1,9 +1,8 @@
 const compare = require('../function/compare/module.f.cjs')
 const list = require('../list/module.f.cjs')
-const option = require('../option/module.f.cjs')
+const option = require('../nullable/module.f.cjs')
 const { next } = list
 const { identity } = require('../function/module.f.cjs')
-const range = require('../range/module.f.cjs')
 
 /**
  * @template T
@@ -23,7 +22,7 @@ const range = require('../range/module.f.cjs')
 /**
  * @template T
  * @template S
- * @typedef {(state: S) => (a: T) => (b: T) => readonly[option.Option<T>, compare.Sign, S]} ReduceOp
+ * @typedef {(state: S) => (a: T) => (b: T) => readonly[option.Nullable<T>, compare.Sign, S]} ReduceOp
  */
 
 /**
@@ -42,54 +41,53 @@ const range = require('../range/module.f.cjs')
  */
 
 /** @type {<T,S>(reduce: MergeReduce<T,S>) => (state: S) => (a: list.List<T>) => (b: list.List<T>) => list.List<T>} */
-const genericMerge = reduce => {
-    const { reduceOp, tailReduce } = reduce
-    /** @typedef {typeof reduce extends MergeReduce<infer T, infer S> ? [T, S] : never} TS */
+const genericMerge = ({ reduceOp, tailReduce }) => {
+    /** @typedef {typeof reduceOp extends ReduceOp<infer T, infer S> ? [T, S] : never} TS */
     /** @typedef {TS[0]} T */
     /** @typedef {TS[1]} S */
     /** @type {(state: S) => (a: list.List<T>) => (b: list.List<T>) => list.List<T>} */
     const f = state => a => b => () => {
         const aResult = next(a)
-        if (aResult === undefined) { return tailReduce(state)(b) }
+        if (aResult === null) { return tailReduce(state)(b) }
         const bResult = next(b)
-        if (bResult === undefined) { return tailReduce(state)(aResult) }
+        if (bResult === null) { return tailReduce(state)(aResult) }
         const [first, sign, stateNext] = reduceOp(state)(aResult.first)(bResult.first)
         const aNext = sign === 1 ? a : aResult.tail
         const bNext = sign === -1 ? b : bResult.tail
         const tail = f(stateNext)(aNext)(bNext)
-        return first === undefined ? tail : { first, tail }
+        return first === null ? tail : { first, tail }
     }
     return f
 }
 
 /**
  * @template T
- * @typedef {ReduceOp<T, undefined>} CmpReduceOp
+ * @typedef {ReduceOp<T, null>} CmpReduceOp
  */
 
 /** @type {<T>(cmp: Cmp<T>) => (a: SortedList<T>) => (b: SortedList<T>) => SortedList<T>} */
 const merge = cmp => {
     /** @typedef {typeof cmp extends Cmp<infer T> ? T : never} T*/
-    /** @type {TailReduce<T, undefined>} */
+    /** @type {TailReduce<T, null>} */
     const tailReduce = mergeTail
-    return genericMerge({ reduceOp: cmpReduce(cmp), tailReduce })(undefined)
+    return genericMerge({ reduceOp: cmpReduce(cmp), tailReduce })(null)
 }
 
 /** @type {<T>(cmp: Cmp<T>) => CmpReduceOp<T>} */
 const cmpReduce = cmp => () => a => b => {
     const sign = cmp(a)(b)
-    return [sign === 1 ? b : a, sign, undefined]
+    return [sign === 1 ? b : a, sign, null]
 }
 
 /** @type {() => <T>(tail: list.List<T>) => list.List<T>} */
 const mergeTail = () => identity
 
-/** @type {<T>(cmp: Cmp<T>) => (value: T) => (array: SortedArray<T>) =>  T|undefined} */
+/** @type {<T>(cmp: Cmp<T>) => (value: T) => (array: SortedArray<T>) =>  T|null} */
 const find = cmp => value => array => {
     let b = 0
     let e = array.length - 1
     while (true) {
-        if (e - b < 0) return undefined
+        if (e - b < 0) return null
         const mid = b + (e - b >> 1)
         const sign = cmp(value)(array[mid])
         switch(sign) {