functionalscript 0.0.486 → 0.0.488

package/types/list/module.f.cjs

@@ -23,7 +23,7 @@ const {
  * } NotLazy
  */
 
-/** @typedef {undefined} Empty */
+/** @typedef {null} Empty */
 
 /**
  * @template T
@@ -46,8 +46,8 @@ const {
 /**
  * @template T
  * @typedef {{
- *  readonly a: List<T>
- *  readonly b: List<T>
+ *  readonly head: List<T>
+ *  readonly tail: List<T>
  * }} Concat
  */
 
@@ -55,41 +55,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 +98,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,7 +116,7 @@ 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)
 }
 
@@ -145,23 +144,23 @@ const filterStep = f => n => {
 /** @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 => n => f(n.first) ? { first: n.first, tail: takeWhile(f)(n.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 => ne => 0 < n ? { first: ne.first, tail: take(n - 1)(ne.tail) } : null
 
 /** @type {(n: number) => <T>(input: List<T>) => Thunk<T>} */
 const take = n => apply(takeStep(n))
@@ -181,7 +180,7 @@ 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
+    return result === null ? def : result.first
 }
 
 /** @type {<D>(first: D) => <T>(tail: List<T>) => D|T} */
@@ -191,7 +190,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
@@ -224,7 +223,7 @@ const includes = value => input => some(map(strictEqual(value))(input))
 
 /** @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) }
 }
@@ -235,7 +234,7 @@ const repeat = v => n => map(() => v)(countdown(n))
 /** @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>} */
@@ -283,14 +282,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 +299,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 +308,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,15 @@ 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 +54,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 sqUndefined = optionSq(null)
+    if (sqUndefined !== null) { throw sqUndefined }
 }

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
  */
 
 /**
@@ -50,46 +49,46 @@ const genericMerge = reduce => {
     /** @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) {

package/types/sorted_list/test.f.cjs

@@ -37,11 +37,11 @@ module.exports = {
         },
         () => {
             const result = _.find(unsafeCmp)(3)([0, 10, 20, 30, 40, 50, 60, 70, 80, 90])
-            if (result !== undefined) { throw result }
+            if (result !== null) { throw result }
         },
         () => {
             const result = _.find(unsafeCmp)(77)([0, 10, 20, 30, 40, 50, 60, 70, 80, 90])
-            if (result !== undefined) { throw result }
+            if (result !== null) { throw result }
         },
         () => {
             const result = _.find(unsafeCmp)(80)([0, 10, 20, 30, 40, 50, 60, 70, 80, 90])

package/types/sorted_set/module.f.cjs

@@ -22,15 +22,15 @@ const union = cmp => a => b => toArray(merge(cmp)(a)(b))
 const intersect = cmp => a => b => toArray(intersectMerge(cmp)(a)(b))
 
 /** @type {<T>(cmp: Cmp<T>) => (a: sortedList.SortedList<T>) => (b: sortedList.SortedList<T>) => sortedList.SortedList<T>} */
-const intersectMerge = cmp => genericMerge({ reduceOp: intersectReduce(cmp), tailReduce: intersectTail })(undefined)
+const intersectMerge = cmp => genericMerge({ reduceOp: intersectReduce(cmp), tailReduce: intersectTail })(null)
 
 /** @type {<T,S>(cmp: Cmp<T>) => sortedList.ReduceOp<T,S>} */
 const intersectReduce = cmp => state => a => b => {
     const sign = cmp(a)(b)
-    return [sign === 0 ? a : undefined, sign, state]
+    return [sign === 0 ? a : null, sign, state]
 }
 
-const intersectTail = () => () => undefined
+const intersectTail = () => () => null
 
 /** @type {<T>(cmp: Cmp<T>) => (value: T) => (set: SortedSet<T>) => boolean} */
 const has = cmp => value => set => find(cmp)(value)(set) === value

package/types/sorted_set/test.f.cjs

@@ -33,7 +33,6 @@ module.exports = {
     intersect: [
         () => {
             const result = stringify(toArray(_.intersect(unsafeCmp)([2, 3, 4])([1, 3, 5])))
-            // console.log(result)
             if (result !== '[3]') { throw result }
         },
         () => {

package/types/string_set/module.f.cjs

@@ -18,13 +18,13 @@ const { compose } = require('../function/module.f.cjs')
 /** @type {(value: string) => (set: StringSet) => boolean} */
 const contains = value => {
     const f = find(cmp(value))
-    return s => s !== undefined && isFound(f(s).first)
+    return s => s !== null && isFound(f(s).first)
 }
 
 /** @type {(value: string) => (s: StringSet) => StringSet} */
 const set = value => btreeSet(cmp(value))(() => value)
 
-const fromValues = fold(set)(undefined)
+const fromValues = fold(set)(null)
 
 /** @type {(value: string) => (s: StringSet) => StringSet} */
 const remove = compose(cmp)(btreeRemove)

package/types/string_set/test.f.cjs

@@ -2,12 +2,12 @@ const _ = require('./module.f.cjs')
 
 module.exports = {
     contains: () => {
-        const r = _.set('hello')(undefined)
+        const r = _.set('hello')(null)
         if (!_.contains('hello')(r)) { throw r }
         if (_.contains('hello1')(r)) { throw r }
     },
     remove: () => {
-        let r = _.set('hello')(undefined)
+        let r = _.set('hello')(null)
         r = _.set('world')(r)
         r = _.set('HELLO')(r)
         r = _.set('WORLD!')(r)
@@ -29,6 +29,6 @@ module.exports = {
         if (_.contains('HELLO')(r)) { throw r }
         if (!_.contains('WORLD!')(r)) { throw r }
         r = _.remove('WORLD!')(r)
-        if (r !== undefined) { throw r }
+        if (r !== null) { throw r }
     }
 }

package/types/option/module.f.cjs

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