functionalscript 0.3.4 → 0.3.5

package/types/number/test.f.ts

@@ -1,194 +0,0 @@
-import * as _ from './module.f.ts'
-const { sum, min, max, cmp } = _
-
-export default {
-    sum: () => {
-        const result = sum([2, 3, 4, 5])
-        if (result !== 14) { throw result }
-    },
-    min: {
-        empty: () => {
-            const result = min([])
-            if (result !== null) { throw result }
-        },
-        multi: () => {
-            const result = min([1, 2, 12, -4, 8])
-            if (result !== -4) { throw result }
-        }
-    },
-    max: () => {
-        const result = max([1, 2, 12, -4, 8])
-        if (result !== 12) { throw result }
-    },
-    cmp: () => {
-        const result = cmp(4)(5)
-        if (result !== -1) { throw result }
-    },
-    standard: () => {
-        const check
-            : (a: bigint) => (a: bigint) => void
-            = a => b => {
-            if (BigInt(Number(a)) != b) { throw [a, b] }
-        }
-
-        const eq
-            : (v: bigint) => void
-            = v => check(v)(v)
-
-        // 53, 0x35 bits.
-        //        3                   2                   1                   0
-        //   4_3210_FEDC_BA98_7654_3210_FEDC_BA98_7654_3210_FEDC_BA98_7654_3210
-        eq(0b1_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000n)
-        eq(0b1_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0001n)
-        eq(0b1_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0010n)
-        eq(0b1_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0011n)
-        eq(0b1_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0100n)
-        //
-        eq(0b1_1101_0010_0110_1110_1000_0010_1000_1101_0000_0001_0011_0100_1000n)
-        eq(0b1_0101_0110_0110_0101_0110_0011_1100_0110_0110_0100_1100_1111_0001n)
-        eq(0b1_1011_0011_0010_1010_1110_1101_1000_1111_0010_0100_1100_0010_1010n)
-        eq(0b1_1010_0101_0010_0001_1000_1100_1010_1110_0110_0011_0001_0010_0011n)
-        eq(0b1_0011_0001_0101_1101_1000_1111_0111_1100_0011_1100_0000_1010_1100n)
-        //
-        eq(0b1_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111n)
-        eq(0b1_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1110n)
-        eq(0b1_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1101n)
-        eq(0b1_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1100n)
-        eq(0b1_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1011n)
-        eq(0b1_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1010n)
-        eq(0b1_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1001n)
-        eq(0b1_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1000n)
-
-        // 54, 0x35+1 bits.
-        //           3                   2                   1                   0
-        //      4_3210_FEDC_BA98_7654_3210_FEDC_BA98_7654_3210_FEDC_BA98_7654_3210_1
-        check
-            (0b01_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0n)
-            (0b01_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0n)
-        check
-            (0b01_1101_0111_0110_0101_1001_1101_0101_0010_1101_1011_0110_0111_1011_0n)
-            (0b01_1101_0111_0110_0101_1001_1101_0101_0010_1101_1011_0110_0111_1011_0n)
-        check
-            (0b01_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_0n)
-            (0b01_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_0n)
-        // round down
-        check
-            (0b01_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_1n)
-            (0b01_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0n)
-        check
-            (0b01_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0010_1n)
-            (0b01_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0010_0n)
-        check
-            (0b01_0100_1101_0100_1111_1101_1010_0110_1100_1111_1010_1000_1111_0010_1n)
-            (0b01_0100_1101_0100_1111_1101_1010_0110_1100_1111_1010_1000_1111_0010_0n)
-        check
-            (0b01_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1110_1n)
-            (0b01_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1110_0n)
-        // round up
-        check
-            (0b01_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0001_1n)
-            (0b01_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0010_0n)
-        check
-            (0b01_1011_1101_1010_0011_1010_1111_0111_1101_0001_1110_1111_1001_1011_1n)
-            (0b01_1011_1101_1010_0011_1010_1111_0111_1101_0001_1110_1111_1001_1100_0n)
-        check
-            (0b01_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1n)
-            (0b10_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0n)
-
-        // 55, 0x35+2 bits.
-        //           3                   2                   1                   0
-        //      4_3210_FEDC_BA98_7654_3210_FEDC_BA98_7654_3210_FEDC_BA98_7654_3210_12
-        // 0_xx: down, down, up
-        // 0_00
-        check
-            (0b01_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_00n)
-            (0b01_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_00n)
-        check
-            (0b01_1011_1000_1010_1100_0110_1010_1010_0110_1100_0010_1010_1111_0000_00n)
-            (0b01_1011_1000_1010_1100_0110_1010_1010_0110_1100_0010_1010_1111_0000_00n)
-        check
-            (0b01_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1110_00n)
-            (0b01_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1110_00n)
-        // 0_01 round down
-        check
-            (0b01_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_01n)
-            (0b01_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_00n)
-        check
-            (0b01_1111_1101_1010_1111_0011_1100_0011_1010_1001_1100_1010_1110_1000_01n)
-            (0b01_1111_1101_1010_1111_0011_1100_0011_1010_1001_1100_1010_1110_1000_00n)
-        check
-            (0b01_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1110_01n)
-            (0b01_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1110_00n)
-        // 0_10 round down
-        check
-            (0b01_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_10n)
-            (0b01_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_00n)
-        check
-            (0b01_0010_0011_1101_1100_0011_0001_1000_1101_0011_0011_0011_1111_0110_10n)
-            (0b01_0010_0011_1101_1100_0011_0001_1000_1101_0011_0011_0011_1111_0110_00n)
-        check
-            (0b01_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1110_10n)
-            (0b01_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1110_00n)
-        // 0_11 round up
-        check
-            (0b01_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_11n)
-            (0b01_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0001_00n)
-        check
-            (0b01_0010_0111_0000_1101_1011_0111_0010_0100_1101_1100_0010_0111_0000_11n)
-            (0b01_0010_0111_0000_1101_1011_0111_0010_0100_1101_1100_0010_0111_0001_00n)
-        check
-            (0b01_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1110_11n)
-            (0b01_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_00n)
-        // 1_xx: down, up, up
-        // 1_00
-        check
-            (0b01_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0001_00n)
-            (0b01_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0001_00n)
-        check
-            (0b01_1000_0001_1111_0001_1011_1101_0000_1001_1111_0011_0011_0111_0101_00n)
-            (0b01_1000_0001_1111_0001_1011_1101_0000_1001_1111_0011_0011_0111_0101_00n)
-        check
-            (0b01_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1110_11n)
-            (0b01_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_00n)
-        // 1_01 round down
-        check
-            (0b01_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0001_01n)
-            (0b01_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0001_00n)
-        check
-            (0b01_0100_1000_1100_1010_0010_1111_1011_0111_1011_1010_1011_0100_0001_01n)
-            (0b01_0100_1000_1100_1010_0010_1111_1011_0111_1011_1010_1011_0100_0001_00n)
-        check
-            (0b01_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_01n)
-            (0b01_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_00n)
-        // 1_10 round up
-        check
-            (0b01_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0001_10n)
-            (0b01_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0010_00n)
-        check
-            (0b01_1111_1011_1100_1010_1111_0010_1010_1111_1101_0110_0101_1001_0011_10n)
-            (0b01_1111_1011_1100_1010_1111_0010_1010_1111_1101_0110_0101_1001_0100_00n)
-        check
-            (0b01_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_10n)
-            (0b10_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_00n)
-        // 1_11 round up
-        check
-            (0b01_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0001_11n)
-            (0b01_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0010_00n)
-        check
-            (0b01_1111_0001_1001_1000_1110_0011_1011_0011_0100_0111_0010_0000_0101_11n)
-            (0b01_1111_0001_1001_1000_1110_0011_1011_0011_0100_0111_0010_0000_0110_00n)
-        check
-            (0b01_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_11n)
-            (0b10_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_00n)
-
-        // 57, 0x35+4 bits.
-        //           3                   2                   1                   0
-        //      4_3210_FEDC_BA98_7654_3210_FEDC_BA98_7654_3210_FEDC_BA98_7654_3210_1234
-        check
-            (0b01_0111_0001_0111_1101_1011_0100_1111_1110_0010_1111_0010_0010_1111_1110n)
-            (0b01_0111_0001_0111_1101_1011_0100_1111_1110_0010_1111_0010_0011_0000_0000n)
-        check
-            (0b01_1111_1010_1111_0011_0101_0111_1001_1111_1001_1101_0111_0000_0001_0100n)
-            (0b01_1111_1010_1111_0011_0101_0111_1001_1111_1001_1101_0111_0000_0001_0000n)
-    }
-}

package/types/object/module.f.ts

@@ -1,30 +0,0 @@
-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.ts

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

package/types/range/module.f.ts

@@ -1,10 +0,0 @@
-
-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.ts

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

package/types/range_map/module.f.ts

@@ -1,70 +0,0 @@
-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.ts

@@ -1,189 +0,0 @@
-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.ts'
-import * as object from '../object/module.f.ts'
-const { sort } = object
-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'
-
-const stringify
-    : (a: readonly json.Unknown[]) => string
-    = json.stringify(sort)
-
-const op
-    : _.Operators<sortedSet.SortedSet<string>>
-    = { union: sortedSet.union(unsafeCmp), equal: list.equal(operator.strictEqual) }
-
-export default {
-    merge: [
-        () => {
-            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 }
-        },
-        () => {
-            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 }
-        },
-        () => {
-            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 }
-        },
-        () => {
-            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 }
-        },
-        () => {
-            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 }
-        },
-        () => {
-            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 }
-        },
-        () => {
-            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: () => {
-        const sortedSetEmpty
-            : sortedSet.SortedSet<string>
-            = []
-        const get = _.get(sortedSetEmpty)
-        return [
-            () => {
-                const rm
-                    : _.RangeMapArray<sortedSet.SortedSet<string>>
-                    = [[['a'], 10], [['b'], 20], [['c'], 30]]
-                const result = stringify(get(5)(rm))
-                if (result !== '["a"]') { throw result }
-            },
-            () => {
-                const rm
-                    : _.RangeMapArray<sortedSet.SortedSet<string>>
-                    = [[['a'], 10], [['b'], 20], [['c'], 30]]
-                const result = stringify(get(10)(rm))
-                if (result !== '["a"]') { throw result }
-            },
-            () => {
-                const rm
-                    : _.RangeMapArray<sortedSet.SortedSet<string>>
-                    = [[['a'], 10], [['b'], 20], [['c'], 30]]
-                const result = stringify(get(15)(rm))
-                if (result !== '["b"]') { throw result }
-            },
-            () => {
-                const rm
-                    : _.RangeMapArray<sortedSet.SortedSet<string>>
-                    = [[['a'], 10], [['b'], 20], [['c'], 30]]
-                const result = stringify(get(20)(rm))
-                if (result !== '["b"]') { throw result }
-            },
-            () => {
-                const rm
-                    : _.RangeMapArray<sortedSet.SortedSet<string>>
-                    = [[['a'], 10], [['b'], 20], [['c'], 30]]
-                const result = stringify(get(25)(rm))
-                if (result !== '["c"]') { throw result }
-            },
-            () => {
-                const rm
-                    : _.RangeMapArray<sortedSet.SortedSet<string>>
-                    = [[['a'], 10], [['b'], 20], [['c'], 30]]
-                const result = stringify(get(30)(rm))
-                if (result !== '["c"]') { throw result }
-            },
-            () => {
-                const rm
-                    : _.RangeMapArray<sortedSet.SortedSet<string>>
-                    = [[['a'], 10], [['b'], 20], [['c'], 30]]
-                const result = stringify(get(35)(rm))
-                if (result !== '[]') { throw result }
-            },
-            () => {
-                const rm
-                    : _.RangeMapArray<sortedSet.SortedSet<string>>
-                    = []
-                const result = stringify(get(10)(rm))
-                if (result !== '[]') { throw result }
-            }
-        ]
-    },
-    fromRange: () => {
-        const def = -1
-        const rm = _.fromRange(def)([1, 7])(42)
-        return [
-            () => {
-                const result = _.get(def)(0)(rm)
-                if (result !== -1) { throw result }
-            },
-            () => {
-                const result = _.get(def)(1)(rm)
-                if (result !== 42) { throw result }
-            },
-            () => {
-                const result = _.get(def)(3)(rm)
-                if (result !== 42) { throw result }
-            },
-            () => {
-                const result = _.get(def)(7)(rm)
-                if (result !== 42) { throw result }
-            },
-            () => {
-                const result = _.get(def)(9)(rm)
-                if (result !== -1) { throw result }
-            },
-        ]
-    }
-}

package/types/result/module.f.ts

@@ -1,20 +0,0 @@
-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.ts

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

package/types/sorted_list/module.f.ts

@@ -1,83 +0,0 @@
-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
-            }
-        }
-    }
-}