functionalscript 0.2.5 → 0.3.0

package/types/nibble_set/{test.f.mjs → test.f.ts}

@@ -1,6 +1,6 @@
-import * as list from '../list/module.f.mjs'
+import * as list from '../list/module.f.ts'
 const { every, map, countdown } = list
-import * as _ from './module.f.mjs'
+import * as _ from './module.f.ts'
 
 export default {
     has: () => {
@@ -41,7 +41,7 @@ export default {
         if (result !== 60) { throw result }
     },
     universe: () => {
-        const x = every(map(v => _.has(v)(_.universe))(countdown(16)))
+        const x = every(map((v: number) => _.has(v)(_.universe))(countdown(16)))
         if (!x) { throw x }
     },
     compliment: {

package/types/nullable/module.f.ts

@@ -0,0 +1,9 @@
+export type Nullable<T> = T|null
+
+export const map
+: <T, R>(f: (value: T) => R) => (value: Nullable<T>) => Nullable<R>
+= f => value => value === null ? null : f(value)
+
+export const match
+: <T, R>(f: (_: T) => R) => (none: () => R) => (_: Nullable<T>) => Nullable<R>
+= f => none => value => value === null ? none() : f(value)

package/types/nullable/{test.f.mjs → test.f.ts}

@@ -1,7 +1,7 @@
-import * as _ from './module.f.mjs'
+import * as _ from './module.f.ts'
 
 export default () => {
-    const optionSq = _.map(v => v * v)
+    const optionSq = _.map((v: number) => v * v)
     const sq3 = optionSq(3)
     if (sq3 !== 9) { throw sq3 }
     const sqNull = optionSq(null)

package/types/number/module.f.ts

@@ -0,0 +1,16 @@
+import * as list from '../list/module.f.ts'
+const { reduce } = list
+import * as operator from '../function/operator/module.f.ts'
+const { addition, min: minOp, max: maxOp } = operator
+import * as compare from '../function/compare/module.f.ts'
+const { unsafeCmp } = compare
+
+export const sum = reduce(addition)(0)
+
+export const min = reduce(minOp)(null)
+
+export const max = reduce(maxOp)(null)
+
+export const cmp
+    : (a: number) => (b: number) => compare.Sign
+    = unsafeCmp

package/types/number/{test.f.mjs → test.f.ts}

@@ -1,4 +1,4 @@
-import * as _ from './module.f.mjs'
+import * as _ from './module.f.ts'
 const { sum, min, max, cmp } = _
 
 export default {
@@ -25,13 +25,15 @@ export default {
         if (result !== -1) { throw result }
     },
     standard: () => {
-        /** @type {(a: bigint) => (a: bigint) => void} */
-        const check = a => b => {
+        const check
+            : (a: bigint) => (a: bigint) => void
+            = a => b => {
             if (BigInt(Number(a)) != b) { throw [a, b] }
         }
 
-        /** @type {(v: bigint) => void} */
-        const eq = v => check(v)(v)
+        const eq
+            : (v: bigint) => void
+            = v => check(v)(v)
 
         // 53, 0x35 bits.
         //        3                   2                   1                   0

package/types/object/module.f.ts

@@ -0,0 +1,30 @@
+import * as list from '../list/module.f.ts'
+const { iterable } = list
+import * as btMap from '../map/module.f.ts'
+const { entries: mapEntries, fromEntries: mapFromEntries } = btMap
+const { getOwnPropertyDescriptor, fromEntries: objectFromEntries } = Object
+
+export type Map<T> = {
+   readonly [k in string]: T
+}
+
+export type Entry<T> = readonly[string, T]
+
+export const at
+    : (name: string) => <T>(object: Map<T>) => T|null
+    = name => object => {
+    const r = getOwnPropertyDescriptor(object, name)
+    return r === void 0 ? null : r.value
+}
+
+export const sort
+    : <T>(e: list.List<Entry<T>>) => list.List<Entry<T>>
+    = e => mapEntries(mapFromEntries(e))
+
+export const fromEntries
+    : <T>(e: list.List<Entry<T>>) => Map<T>
+    = e => objectFromEntries(iterable(e))
+
+export const fromMap
+    : <T>(m: btMap.Map<T>) => Map<T>
+    = m => fromEntries(mapEntries(m))

package/types/object/{test.f.mjs → test.f.ts}

@@ -1,4 +1,4 @@
-import * as _ from './module.f.mjs'
+import * as _ from './module.f.ts'
 
 export default {
     ctor: () => {
@@ -11,4 +11,4 @@ export default {
         const value = _.at('constructor')(a)
         if (value !== 42) { throw value }
     }
-}
+}

package/types/range/module.f.ts

@@ -0,0 +1,10 @@
+
+export type Range = readonly[number,number]
+
+export const contains
+: (range: Range) => (i: number) => boolean
+= ([b, e]) => i => b <= i && i <= e
+
+export const one
+: (i: number) => Range
+= a => [a, a]

package/types/range/{test.f.mjs → test.f.ts}

@@ -1,4 +1,4 @@
-import * as _ from './module.f.mjs'
+import * as _ from './module.f.ts'
 
 export default () => {
     if (!_.contains([0, 5])(1)) { throw 1 }

package/types/range_map/module.f.ts

@@ -0,0 +1,70 @@
+import * as sortedList from '../sorted_list/module.f.ts'
+const { genericMerge } = sortedList
+import * as list from '../list/module.f.ts'
+const { next } = list
+import * as Option from '../nullable/module.f.ts'
+import * as number from '../number/module.f.ts'
+const { cmp } = number
+import * as O from '../function/operator/module.f.ts'
+import * as Range from '../range/module.f.ts'
+
+export type Entry<T> =[T, number]
+
+export type RangeMap<T> = sortedList.SortedList<Entry<T>>
+
+export type RangeMapArray<T> = readonly Entry<T>[]
+
+export type Operators<T> = {
+   readonly union: O.Reduce<T>
+   readonly equal: O.Equal<T>
+}
+
+type RangeState<T> = Option.Nullable<Entry<T>>
+
+export type RangeMerge<T> = O.Reduce<RangeMap<T>>
+
+const reduceOp
+    : <T>(union: O.Reduce<T>) => (equal: O.Equal<T>) => sortedList.ReduceOp<Entry<T>, RangeState<T>>
+    = 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 !== null && equal(state[0])(u) ? null : state
+    return [newState, sign, [u, min]]
+}
+
+const tailReduce
+    : <T>(equal: O.Equal<T>) => sortedList.TailReduce<Entry<T>, RangeState<T>>
+    = equal => state => tail => {
+    if (state === null) { return tail }
+    const tailResult = next(tail)
+    if (tailResult === null) { return [state] }
+    if (equal(state[0])(tailResult.first[0])) { return tailResult }
+    return { first: state, tail: tailResult }
+}
+
+export const merge
+    : <T>(op: Operators<T>) => RangeMerge<T>
+    = ({ union, equal }) => genericMerge({ reduceOp: reduceOp(union)(equal), tailReduce: tailReduce(equal) })(null)
+
+export const get
+    : <T>(def: T) => (value: number) => (rm: RangeMapArray<T>) => T
+    = def => value => rm => {
+    const len = rm.length
+    let b = 0
+    let e = len - 1
+    while (true) {
+        if (b >= len) { return def }
+        if (e - b < 0) { return rm[b][0] }
+        const mid = b + (e - b >> 1)
+        if (value <= rm[mid][1]) {
+            e = mid - 1
+        } else {
+            b = mid + 1
+        }
+    }
+}
+
+export const fromRange
+    : <T>(def: T) => (r: Range.Range) => (value: T) => RangeMapArray<T>
+    = def => ([a, b]) => v => [[def, a - 1], [v, b]]

package/types/range_map/{test.f.mjs → test.f.ts}

@@ -1,135 +1,160 @@
-import * as _ from './module.f.mjs'
-import * as compare from '../function/compare/module.f.mjs'
+import * as _ from './module.f.ts'
+import * as compare from '../function/compare/module.f.ts'
 const { unsafeCmp } = compare
-import * as json from '../../json/module.f.mjs'
-import * as object from '../object/module.f.mjs'
+import * as json from '../../json/module.f.ts'
+import * as object from '../object/module.f.ts'
 const { sort } = object
-import * as sortedSet from '../sorted_set/module.f.mjs'
-import * as list from '../list/module.f.mjs'
-import * as operator from '../function/operator/module.f.mjs'
+import * as sortedSet from '../sorted_set/module.f.ts'
+import * as list from '../list/module.f.ts'
+import * as operator from '../function/operator/module.f.ts'
 
-/** @type {(a: readonly json.Unknown[]) => string} */
-const stringify = json.stringify(sort)
+const stringify
+    : (a: readonly json.Unknown[]) => string
+    = json.stringify(sort)
 
-/** @type {_.Operators<sortedSet.SortedSet<string>>} */
-const op = { union: sortedSet.union(unsafeCmp), equal: list.equal(operator.strictEqual) }
+const op
+    : _.Operators<sortedSet.SortedSet<string>>
+    = { union: sortedSet.union(unsafeCmp), equal: list.equal(operator.strictEqual) }
 
 export default {
     merge: [
         () => {
-            /** @type {_.RangeMap<sortedSet.SortedSet<string>>} */
-            const a = [[['a'], 1], [['b'], 2]]
-            /** @type {_.RangeMap<sortedSet.SortedSet<string>>} */
-            const b = null
+            const a
+                : _.RangeMap<sortedSet.SortedSet<string>>
+                = [[['a'], 1], [['b'], 2]]
+            const b
+                : _.RangeMap<sortedSet.SortedSet<string>>
+                = 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 = null
-            /** @type {_.RangeMap<sortedSet.SortedSet<string>>} */
-            const b = [[['a'], 1], [['b'], 2]]
+            const a
+                : _.RangeMap<sortedSet.SortedSet<string>>
+                = null
+            const b
+                : _.RangeMap<sortedSet.SortedSet<string>>
+                = [[['a'], 1], [['b'], 2]]
             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 = [[['a'], 1], [['b'], 2]]
-            /** @type {_.RangeMap<sortedSet.SortedSet<string>>} */
-            const b = [[['a'], 1], [['b'], 2]]
+            const a
+                : _.RangeMap<sortedSet.SortedSet<string>>
+                = [[['a'], 1], [['b'], 2]]
+            const b
+                : _.RangeMap<sortedSet.SortedSet<string>>
+                = [[['a'], 1], [['b'], 2]]
             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 = [[['a'], 1], [['c'], 3]]
-            /** @type {_.RangeMap<sortedSet.SortedSet<string>>} */
-            const b = [[['b'], 2], [['d'], 4]]
+            const a
+                : _.RangeMap<sortedSet.SortedSet<string>>
+                = [[['a'], 1], [['c'], 3]]
+            const b
+                : _.RangeMap<sortedSet.SortedSet<string>>
+                = [[['b'], 2], [['d'], 4]]
             const merged = _.merge(op)(a)(b)
             const result = stringify(list.toArray(merged))
             if (result !== '[[["a","b"],1],[["b","c"],2],[["c","d"],3],[["d"],4]]') { throw result }
         },
         () => {
-            /** @type {_.RangeMap<sortedSet.SortedSet<string>>} */
-            const a = [[['a'], 1], [['d'], 4]]
-            /** @type {_.RangeMap<sortedSet.SortedSet<string>>} */
-            const b = [[['b'], 2], [['c'], 3]]
+            const a
+                : _.RangeMap<sortedSet.SortedSet<string>>
+                = [[['a'], 1], [['d'], 4]]
+            const b
+                : _.RangeMap<sortedSet.SortedSet<string>>
+                = [[['b'], 2], [['c'], 3]]
             const merged = _.merge(op)(a)(b)
             const result = stringify(list.toArray(merged))
             if (result !== '[[["a","b"],1],[["b","d"],2],[["c","d"],3],[["d"],4]]') { throw result }
         },
         () => {
-            /** @type {_.RangeMap<sortedSet.SortedSet<string>>} */
-            const a = [[['a'], 1], [['b'], 2]]
-            /** @type {_.RangeMap<sortedSet.SortedSet<string>>} */
-            const b = [[['b'], 1], [['a'], 2]]
+            const a
+                : _.RangeMap<sortedSet.SortedSet<string>>
+                = [[['a'], 1], [['b'], 2]]
+            const b
+                : _.RangeMap<sortedSet.SortedSet<string>>
+                = [[['b'], 1], [['a'], 2]]
             const merged = _.merge(op)(a)(b)
             const result = stringify(list.toArray(merged))
             if (result !== '[[["a","b"],2]]') { throw result }
         },
         () => {
-            /** @type {_.RangeMap<sortedSet.SortedSet<string>>} */
-            const a = [[['a'], 1], [['b'], 2], [['a'], 3]]
-            /** @type {_.RangeMap<sortedSet.SortedSet<string>>} */
-            const b = [[['a'], 5]]
+            const a
+                : _.RangeMap<sortedSet.SortedSet<string>>
+                = [[['a'], 1], [['b'], 2], [['a'], 3]]
+            const b
+                : _.RangeMap<sortedSet.SortedSet<string>>
+                = [[['a'], 5]]
             const merged = _.merge(op)(a)(b)
             const result = stringify(list.toArray(merged))
             if (result !== '[[["a"],1],[["a","b"],2],[["a"],5]]') { throw result }
         }
     ],
     get: () => {
-        /** @type {sortedSet.SortedSet<string>} */
-        const sortedSetEmpty = []
+        const sortedSetEmpty
+            : sortedSet.SortedSet<string>
+            = []
         const get = _.get(sortedSetEmpty)
         return [
             () => {
-                /** @type {_.RangeMapArray<sortedSet.SortedSet<string>>} */
-                const rm = [[['a'], 10], [['b'], 20], [['c'], 30]]
+                const rm
+                    : _.RangeMapArray<sortedSet.SortedSet<string>>
+                    = [[['a'], 10], [['b'], 20], [['c'], 30]]
                 const result = stringify(get(5)(rm))
                 if (result !== '["a"]') { throw result }
             },
             () => {
-                /** @type {_.RangeMapArray<sortedSet.SortedSet<string>>} */
-                const rm = [[['a'], 10], [['b'], 20], [['c'], 30]]
+                const rm
+                    : _.RangeMapArray<sortedSet.SortedSet<string>>
+                    = [[['a'], 10], [['b'], 20], [['c'], 30]]
                 const result = stringify(get(10)(rm))
                 if (result !== '["a"]') { throw result }
             },
             () => {
-                /** @type {_.RangeMapArray<sortedSet.SortedSet<string>>} */
-                const rm = [[['a'], 10], [['b'], 20], [['c'], 30]]
+                const rm
+                    : _.RangeMapArray<sortedSet.SortedSet<string>>
+                    = [[['a'], 10], [['b'], 20], [['c'], 30]]
                 const result = stringify(get(15)(rm))
                 if (result !== '["b"]') { throw result }
             },
             () => {
-                /** @type {_.RangeMapArray<sortedSet.SortedSet<string>>} */
-                const rm = [[['a'], 10], [['b'], 20], [['c'], 30]]
+                const rm
+                    : _.RangeMapArray<sortedSet.SortedSet<string>>
+                    = [[['a'], 10], [['b'], 20], [['c'], 30]]
                 const result = stringify(get(20)(rm))
                 if (result !== '["b"]') { throw result }
             },
             () => {
-                /** @type {_.RangeMapArray<sortedSet.SortedSet<string>>} */
-                const rm = [[['a'], 10], [['b'], 20], [['c'], 30]]
+                const rm
+                    : _.RangeMapArray<sortedSet.SortedSet<string>>
+                    = [[['a'], 10], [['b'], 20], [['c'], 30]]
                 const result = stringify(get(25)(rm))
                 if (result !== '["c"]') { throw result }
             },
             () => {
-                /** @type {_.RangeMapArray<sortedSet.SortedSet<string>>} */
-                const rm = [[['a'], 10], [['b'], 20], [['c'], 30]]
+                const rm
+                    : _.RangeMapArray<sortedSet.SortedSet<string>>
+                    = [[['a'], 10], [['b'], 20], [['c'], 30]]
                 const result = stringify(get(30)(rm))
                 if (result !== '["c"]') { throw result }
             },
             () => {
-                /** @type {_.RangeMapArray<sortedSet.SortedSet<string>>} */
-                const rm = [[['a'], 10], [['b'], 20], [['c'], 30]]
+                const rm
+                    : _.RangeMapArray<sortedSet.SortedSet<string>>
+                    = [[['a'], 10], [['b'], 20], [['c'], 30]]
                 const result = stringify(get(35)(rm))
                 if (result !== '[]') { throw result }
             },
             () => {
-                /** @type {_.RangeMapArray<sortedSet.SortedSet<string>>} */
-                const rm = []
+                const rm
+                    : _.RangeMapArray<sortedSet.SortedSet<string>>
+                    = []
                 const result = stringify(get(10)(rm))
                 if (result !== '[]') { throw result }
             }

package/types/result/module.f.ts

@@ -0,0 +1,20 @@
+type Ok<T> = readonly['ok', T]
+
+type Error<E> = readonly['error', E]
+
+export type Result<T, E> = Ok<T>|Error<E>
+
+export const ok
+: <T>(value: T) => Ok<T>
+= value => ['ok', value]
+
+export const error
+: <E>(e: E) => Error<E>
+= e => ['error', e]
+
+export const unwrap
+: <T, E>(r: Result<T, E>) => T
+= ([kind, v]) => {
+    if (kind === 'error') { throw v }
+    return v
+}

package/types/result/{module.mjs → module.ts}

@@ -1,8 +1,9 @@
-import * as result from './module.f.mjs'
+import * as result from './module.f.ts'
 const { ok, error } = result
 
-/** @type {<T>(f: () => T) => result.Result<T, unknown>} */
-const tryCatch = f => {
+const tryCatch
+    : <T>(f: () => T) => result.Result<T, unknown>
+    = f => {
     // Side effect: `try catch` is not allowed in FunctionalScript.
     try {
         return ok(f())

package/types/sorted_list/module.f.ts

@@ -0,0 +1,83 @@
+import * as compare from '../function/compare/module.f.ts'
+import * as list from '../list/module.f.ts'
+import * as option from '../nullable/module.f.ts'
+const { next } = list
+import * as f from '../function/module.f.ts'
+const { identity } = f
+
+export type SortedList<T> = list.List<T>
+
+type SortedArray<T> = readonly T[]
+
+type Cmp<T> =(a: T) => (b: T) => compare.Sign
+
+export type ReduceOp<T, S> = (state: S) => (a: T) => (b: T) => readonly[option.Nullable<T>, compare.Sign, S]
+
+export type TailReduce<T, S> = (state: S) => (tail: list.List<T>) => list.List<T>
+
+type MergeReduce<T, S> = {
+   readonly reduceOp: ReduceOp<T,S>
+   readonly tailReduce: TailReduce<T,S>
+}
+
+export const genericMerge
+    = <T,S>({ reduceOp, tailReduce }: MergeReduce<T,S>)
+        : (state: S) => (a: list.List<T>) => (b: list.List<T>) => list.List<T> => {
+    const f
+        : (state: S) => (a: list.List<T>) => (b: list.List<T>) => list.List<T>
+        = state => a => b => () => {
+        const aResult = next(a)
+        if (aResult === null) { return tailReduce(state)(b) }
+        const bResult = next(b)
+        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 === null ? tail : { first, tail }
+    }
+    return f
+}
+
+type CmpReduceOp<T> = ReduceOp<T, null>
+
+export const merge
+    = <T>(cmp: Cmp<T>)
+        : (a: SortedList<T>) => (b: SortedList<T>) => SortedList<T> => {
+    const tailReduce: TailReduce<T, null> = mergeTail
+    return genericMerge({ reduceOp: cmpReduce(cmp), tailReduce })(null)
+}
+
+const cmpReduce
+    : <T>(cmp: Cmp<T>) => CmpReduceOp<T>
+    = cmp => () => a => b => {
+    const sign = cmp(a)(b)
+    return [sign === 1 ? b : a, sign, null]
+}
+
+const mergeTail
+    : () => <T>(tail: list.List<T>) => list.List<T>
+    = () => identity
+
+export const find
+    : <T>(cmp: Cmp<T>) => (value: T) => (array: SortedArray<T>) =>  T|null
+    = cmp => value => array => {
+    let b = 0
+    let e = array.length - 1
+    while (true) {
+        if (e - b < 0) return null
+        const mid = b + (e - b >> 1)
+        const sign = cmp(value)(array[mid])
+        switch(sign) {
+            case -1: {
+                 e = mid - 1
+                 break
+            }
+            case 0: { return value }
+            case 1: {
+                 b = mid + 1
+                 break
+            }
+        }
+    }
+}

package/types/sorted_list/{test.f.mjs → test.f.ts}

@@ -1,20 +1,22 @@
-import * as _ from './module.f.mjs'
-import * as compare from '../function/compare/module.f.mjs'
+import * as _ from './module.f.ts'
+import * as compare from '../function/compare/module.f.ts'
 const { unsafeCmp } = compare
-import * as json from '../../json/module.f.mjs'
-import * as object from '../object/module.f.mjs'
+import * as json from '../../json/module.f.ts'
+import * as object from '../object/module.f.ts'
 const { sort } = object
-import * as list from '../list/module.f.mjs'
+import * as list from '../list/module.f.ts'
 const { toArray, countdown, length } = list
-import * as Map from '../map/module.f.mjs'
-import * as f from '../function/module.f.mjs'
+import * as Map from '../map/module.f.ts'
+import * as f from '../function/module.f.ts'
 const { flip } = f
 
-/** @type {(a: readonly json.Unknown[]) => string} */
-const stringify = json.stringify(sort)
+const stringify
+    : (a: readonly json.Unknown[]) => string
+    = json.stringify(sort)
 
-/** @type {<T>(a: T) => (b: T) => Map.Sign} */
-const reverseCmp = flip(unsafeCmp)
+const reverseCmp
+    : <T>(a: T) => (b: T) => Map.Sign
+    = flip(unsafeCmp)
 
 export default {
     sortedMergre: [
@@ -52,4 +54,4 @@ export default {
             if (result !== 80) { throw result }
         }
     ]
-}
+}

package/types/sorted_set/module.f.ts

@@ -0,0 +1,36 @@
+import * as Compare from '../function/compare/module.f.ts'
+import * as list from "../list/module.f.ts"
+const { toArray } = list
+import * as sortedList from '../sorted_list/module.f.ts'
+const { merge, genericMerge, find } = sortedList
+
+export type SortedSet<T> = readonly T[]
+
+type Cmp<T> = (a: T) => (b: T) => Compare.Sign
+
+type Byte = number
+
+export const union
+    : <T>(cmp: Cmp<T>) => (a: SortedSet<T>) => (b: SortedSet<T>) => SortedSet<T>
+    = cmp => a => b => toArray(merge(cmp)(a)(b))
+
+export const intersect
+    : <T>(cmp: Cmp<T>) => (a: SortedSet<T>) => (b: SortedSet<T>) => SortedSet<T>
+    = cmp => a => b => toArray(intersectMerge(cmp)(a)(b))
+
+const tailReduce = () => () => null
+
+const intersectMerge
+    : <T>(cmp: Cmp<T>) => (a: sortedList.SortedList<T>) => (b: sortedList.SortedList<T>) => sortedList.SortedList<T>
+    = cmp => genericMerge({ reduceOp: intersectReduce(cmp), tailReduce })(null)
+
+const intersectReduce
+    : <T,S>(cmp: Cmp<T>) => sortedList.ReduceOp<T,S>
+    = cmp => state => a => b => {
+    const sign = cmp(a)(b)
+    return [sign === 0 ? a : null, sign, state]
+}
+
+export const has
+    : <T>(cmp: Cmp<T>) => (value: T) => (set: SortedSet<T>) => boolean
+    = cmp => value => set => find(cmp)(value)(set) === value