functionalscript 0.3.4 → 0.3.5

package/types/list/test.f.ts

@@ -1,327 +0,0 @@
-import * as _ from './module.f.ts'
-import * as json from '../../json/module.f.ts'
-import * as o from '../object/module.f.ts'
-const { sort } = o
-import * as operator from '../function/operator/module.f.ts'
-const { addition, strictEqual, reduceToScan } = operator
-
-const stringify
-    : (sequence: _.List<json.Unknown>) => string
-    = sequence => json.stringify(sort)(_.toArray(sequence))
-
-const stringifyTest = () => {
-    const s = stringify([1, 2, 3])
-    if (s !== '[1,2,3]') { throw s }
-}
-
-const cycle = () => {
-    const x = stringify(_.toArray(_.take(10)(_.cycle([1, 2, 3]))))
-    if (x !== '[1,2,3,1,2,3,1,2,3,1]') { throw x }
-}
-
-const countdown = () => {
-    const result = stringify(_.countdown(10))
-    if (result !== '[9,8,7,6,5,4,3,2,1,0]') { throw result }
-}
-
-const flat = () => {
-    const result = stringify(_.flat([[1, 2, 3], [4, 5], [6], [], [7, 8, 9]]))
-    if (result !== '[1,2,3,4,5,6,7,8,9]') { throw result }
-}
-
-const concat = () => {
-    const result = _.concat([1])([2])
-    const x = _.next(result)
-    if (x === null) { throw x }
-    if (x.first !== 1) { throw x }
-}
-
-const flatMap = () => {
-    const result = stringify(_.flatMap((x: number) => [x, x * 2, x * 3])([0, 1, 2, 3]))
-    if (result !== '[0,0,0,1,2,3,2,4,6,3,6,9]') { throw result }
-}
-
-const take = [
-    () => {
-        const result = stringify(_.take(3)([1, 2, 3, 4, 5, 6, 7, 8, 9]))
-        if (result !== '[1,2,3]') { throw result }
-    },
-    () => {
-        const result = stringify(_.take(20)([1, 2, 3, 4, 5, 6, 7, 8, 9]))
-        if (result !== '[1,2,3,4,5,6,7,8,9]') { throw result }
-    },
-    () => {
-        const result = stringify(_.take(0)([1, 2, 3, 4, 5, 6, 7, 8, 9]))
-        if (result !== '[]') { throw result }
-    }
-]
-
-const find = [
-    () => {
-        const result = _.find(null)((x: number) => x % 2 === 0)([1, 3, 5, 7])
-        if (result !== null) { throw result }
-    },
-    () => {
-        const result = _.find(null)((x: number) => x % 2 === 0)([1, 2, 3, 4])
-        if (result !== 2) { throw result }
-    }
-]
-
-const takeWhile = [
-    () => {
-        const result = stringify(_.takeWhile((x: number) => x < 10)([1, 2, 3, 4, 5, 10, 11]))
-        if (result !== '[1,2,3,4,5]') { throw result }
-    },
-    () => {
-        const result = stringify(_.takeWhile((x: number) => x < 6)([1, 2, 3, 4, 5, 6, 7, 8, 9]))
-        if (result !== '[1,2,3,4,5]') { throw result }
-    }
-]
-
-const dropWhile = () => {
-    const result = stringify(_.dropWhile((x: number) => x < 10)([1, 2, 3, 4, 5, 10, 11]))
-    if (result !== '[10,11]') { throw result }
-}
-
-const drop = [
-    () => {
-        const result = stringify(_.drop(3)([1, 2, 3, 4, 5, 10, 11]))
-        if (result !== '[4,5,10,11]') { throw result }
-    },
-    () => {
-        const result = stringify(_.drop(0)([1, 2, 3, 4, 5, 10, 11]))
-        if (result !== '[1,2,3,4,5,10,11]') { throw result }
-    },
-    () => {
-        const result = stringify(_.drop(10)([1, 2, 3, 4, 5, 10, 11]))
-        if (result !== '[]') { throw result }
-    }
-]
-
-const additionTests = [
-    () => {
-        const op = reduceToScan(addition)
-        const result = stringify(_.scan(op)([2, 3, 4, 5]))
-        if (result !== '[2,5,9,14]') { throw result }
-    },
-    () => {
-        const result = _.reduce(addition)(null)([2, 3, 4, 5])
-        if (result !== 14) { throw result }
-    },
-    () => {
-        const result = _.reduce(addition)(null)([])
-        if (result !== null) { throw result }
-    }
-]
-
-const entries = [
-    () => {
-        const result = stringify(_.entries([]))
-        if (result !== '[]') { throw result }
-    },
-    () => {
-        const result = stringify(_.entries(['hello', 'world']))
-        if (result !== '[[0,"hello"],[1,"world"]]') { throw result }
-    }
-]
-
-const reverse = [
-    () => {
-        const result = stringify(_.reverse([]))
-        if (result !== '[]') { throw result }
-    },
-    () => {
-        const result = stringify(_.reverse([1, 2, 3, 4, 5]))
-        if (result !== '[5,4,3,2,1]') { throw result }
-    }
-]
-
-const zip = [
-    () => {
-        const result = stringify(_.zip([0, 1, 2])(['a', 'b', 'c', 'd']))
-        if (result !== '[[0,"a"],[1,"b"],[2,"c"]]') { throw result }
-    },
-    () => {
-        const result = stringify(_.zip([0, 1, 2])(['a', 'b']))
-        if (result !== '[[0,"a"],[1,"b"]]') { throw result }
-    }
-]
-
-const logic = () => {
-    const map5 = _.map((x: number) => x > 5)
-
-    return [
-        () => {
-            const result = _.some(map5([0, 1, 7]))
-            if (!result) { throw result }
-        },
-        () => {
-            const result = _.some(map5([0, 1, 4]))
-            if (result) { throw result }
-        },
-        () => {
-            const result = _.some(map5([]))
-            if (result) { throw result }
-        },
-        () => {
-            const result = _.every(map5([0, 1, 7]))
-            if (result) { throw result }
-        },
-        () => {
-            const result = _.every(map5([6, 11, 7]))
-            if (!result) { throw result }
-        },
-        () => {
-            const result = _.every(map5([]))
-            if (!result) { throw result }
-        }
-    ]
-}
-
-// stress tests
-
-const stress = () => ({
-    toArray: () => {
-        // 200_000_000 is too much
-        const n = 100_000_000
-        const result = _.toArray(_.countdown(n))
-        if (result.length !== n) { throw result.length }
-        const len = _.length(_.filter((x: number) => x > n)(result))
-        if (len !== 0) { throw len }
-    },
-    first: () => {
-        // 100_000_000 is too much
-        const n = 50_000_000
-        const result = _.toArray(_.countdown(n))
-        if (result.length !== n) { throw result.length }
-        const first = _.first(null)(result)
-        if (first !== n - 1) { throw first }
-    },
-    concatBack: () => {
-        let sequence
-            : _.List<number>
-            = []
-        // 20_000_000 is too much
-        // 10_000_000 is too much for Deno 1
-        for (let i = 0; i < 5_000_000; ++i) {
-            sequence = _.concat(sequence)([i])
-        }
-        const r = _.toArray(sequence)
-    },
-    flatToArray: () => {
-        let sequence
-            : _.List<number>
-            = []
-        // 4_000_000 is too much
-        for (let i = 0; i < 2_000_000; ++i) {
-            sequence = _.flat([sequence, [i]])
-        }
-        const r = _.toArray(sequence)
-    },
-    flatNext: () => {
-        let sequence
-            : _.List<number>
-            = []
-        // 4_000_000 is too much
-        for (let i = 0; i < 2_000_000; ++i) {
-            sequence = _.flat([sequence, [i]])
-        }
-        const a = _.next(sequence)
-    },
-    concatFront: () => {
-        let sequence
-            : _.List<number>
-            = []
-        // 20_000_000 is too much
-        for (let i = 0; i < 10_000_000; ++i) {
-            sequence = _.concat([i])(sequence)
-        }
-        const a = _.next(sequence)
-    },
-    flatFront: () => {
-        let sequence
-            : _.List<number>
-            = []
-        // 10_000_000 is too much
-        for (let i = 0; i < 5_000_000; ++i) {
-            sequence = _.flat([[i], sequence])
-        }
-        const a = _.next(sequence)
-    },
-    filterMap: () => {
-        // 100_000_000 is too much
-        const n = 50_000_000
-        const result = _.toArray(_.countdown(n))
-        if (result.length !== n) { throw result.length }
-        const len = _.length(_.filterMap(() => null)(result))
-        if (len !== 0) { throw len }
-    },
-    dropWhile: () => {
-        // 50_000_000 is too much
-        const n = 20_000_000
-        const result = _.toArray(_.countdown(n))
-        if (result.length !== n) { throw result.length }
-        const len = _.length(_.dropWhile(() => true)(result))
-        if (len !== 0) { throw len }
-    },
-    reverse: () => {
-        // 10_000_000 is too much
-        const n = 5_000_000
-        const result = _.toArray(_.reverse(_.countdown(n)))
-        if (result.length !== n) { throw result.length }
-    }
-
-})
-
-export default {
-    stringifyTest,
-    cycle,
-    countdown,
-    flat,
-    concat,
-    flatMap,
-    take,
-    find,
-    takeWhile,
-    dropWhile,
-    drop,
-    additionTests,
-    entries,
-    reverse,
-    zip,
-    logic,
-    strictEqual: [
-        () => {
-            const result = _.equal(strictEqual)([1])([2, 3])
-            if (result) { throw result }
-        },
-        () => {
-            const result = _.equal(strictEqual)([1, 3])([1])
-            if (result) { throw result }
-        },
-        () => {
-            const result = _.equal(strictEqual)([15, 78])([15, 78])
-            if (!result) { throw result }
-        },
-        () => {
-            const result = _.equal(strictEqual)([])([])
-            if (!result) { throw result }
-        }
-    ],
-    isEmpty: [
-        () => {
-            const result = _.isEmpty(() => [])
-            if (result !== true) { throw result }
-        },
-        () => {
-            const result = _.isEmpty(() => [2])
-            if (result !== false) { throw result }
-        }
-    ],
-    length: () => {
-        if (_.length([1, 2, 3]) !== 3) { throw 3 }
-        if (_.length(null) !== 0) { throw 0 }
-        if (_.length(_.flat([[1, 3], null, () => [3], _.concat([12])([4, 89])])) !== 6) { throw 6 }
-    },
-    // stress
-}

package/types/map/module.f.ts

@@ -1,65 +0,0 @@
-import * as BtreeTypes from '../btree/types/module.f.ts'
-import * as btf from '../btree/find/module.f.ts'
-const { value, find } = btf
-import * as bts from '../btree/set/module.f.ts'
-const { set } = bts
-import * as btr from '../btree/remove/module.f.ts'
-const { remove: btreeRemove } = btr
-import * as bt from '../btree/module.f.ts'
-const { values } = bt
-import * as Compare from '../function/compare/module.f.ts'
-import * as s from '../string/module.f.ts'
-const { cmp } = s
-import * as list from '../list/module.f.ts'
-const { fold } = list
-import * as Operator from '../function/operator/module.f.ts'
-
-export type Sign = Compare.Sign
-
-type Cmp<T> = Compare.Compare<T>
-
-export type Entry<T> = readonly[string, T]
-
-export type Map<T> = BtreeTypes.Tree<Entry<T>>
-
-const keyCmp
-    : (a: string) => <T>(b: Entry<T>) => Sign
-    = a => ([b]) => cmp(a)(b)
-
-export const at
-    = (name: string) => <T>(map: Map<T>): T|null => {
-    if (map === null) { return null }
-    const result = value(find(keyCmp(name))(map).first)
-    return result === null ? null : result[1]
-}
-
-const setReduceEntry
-    : <T>(reduce: Operator.Reduce<T>) => (entry: Entry<T>) => (map: Map<T>) => Map<T>
-    = reduce => entry =>
-    set(keyCmp(entry[0]))(old => old === null ? entry : [old[0], reduce(old[1])(entry[1])])
-
-export const setReduce
-    : <T>(reduce: Operator.Reduce<T>) => (name: string) => (value: T) => (map: Map<T>) => Map<T>
-    = reduce => name => value => setReduceEntry(reduce)([name, value])
-
-const replace
-    : <T>(a: T) => (b: T) => T
-    = () => b => b
-
-export const setReplace
-    : (name: string) => <T>(value: T) => (map: Map<T>) => Map<T>
-    = name => value => setReduceEntry(replace)([name, value])
-
-export const entries
-    : <T>(map: Map<T>) => list.List<Entry<T>>
-    = values
-
-export const fromEntries
-    : <T>(entries: list.List<Entry<T>>) => Map<T>
-    = fold(setReduceEntry(replace))(null)
-
-export const remove
-    : (name: string) => <T>(map: Map<T>) => Map<T>
-    = name => btreeRemove(keyCmp(name))
-
-export const empty = null

package/types/map/test.f.ts

@@ -1,76 +0,0 @@
-import * as _ from './module.f.ts'
-const { at, setReplace, setReduce, empty, entries, remove } = _
-import * as seq from '../list/module.f.ts'
-
-export default {
-    main: [
-        () => {
-            let m = setReplace('a')(1)(null)
-
-            if (at('a')(m) !== 1) { 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) !== 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) !== null) { throw 'error' }
-
-            m = setReplace('')(4)(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) !== 4) { throw 'error' }
-            if (at('Hello world!')(m) !== null) { throw 'error' }
-
-            m = setReplace('Hello world!')(42)(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) !== 4) { throw 'error' }
-            if (at('Hello world!')(m) !== 42) { 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) !== null) { throw m }
-
-            m = setReduce((a: number) => (b: number) => a + b)('a')(43)(m)
-            if (at('a')(m) !== 44) { throw 'error' }
-        },
-        () => {
-            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) !== null) { throw 'error' }
-            const e = seq.toArray(entries(m))
-            if (e.length !== 2) { throw 'error' }
-        },
-    ],
-    stress: () => {
-        let m
-            : _.Map<number>
-            = empty
-        for (let i = 0; i < 100_000; ++i) {
-            m = setReplace((i * i).toString())(i)(m)
-            /*
-            console.log()
-            console.log(`# ${i}`)
-            console.log()
-            for (const e of m.struct()) {
-                console.log(e)
-            }
-            */
-        }
-    }
-}

package/types/nibble_set/module.f.ts

@@ -1,34 +0,0 @@
-type NibbleSet = number
-type Nibble = number
-
-export const empty = 0
-
-export const universe = 0xFFFF
-
-const one
-: (n: Nibble) => NibbleSet
-= n => 1 << n
-
-export const has
-: (n: Nibble) => (s: NibbleSet) => boolean
-= n => s => ((s >> n) & 1) === 1
-
-export const set
-: (n: Nibble) => (s: NibbleSet) => NibbleSet
-= n => s => s | one(n)
-
-export const complement
-: (n: NibbleSet) => NibbleSet
-= s => universe ^ s
-
-export const unset
-: (n: Nibble) => (s: NibbleSet) => NibbleSet
-= n => s => s & complement(one(n))
-
-const range
-: (r: readonly[number, number]) => NibbleSet
-= ([a, b]) => one(b - a + 1) - 1 << a
-
-export const setRange
-: (r: readonly[number, number]) => (s: NibbleSet) => NibbleSet
-= r => s => s | range(r)

package/types/nibble_set/test.f.ts

@@ -1,57 +0,0 @@
-import * as list from '../list/module.f.ts'
-const { every, map, countdown } = list
-import * as _ from './module.f.ts'
-
-export default {
-    has: () => {
-        if (_.has(0)(_.empty)) { throw _.empty }
-        if (_.has(1)(_.empty)) { throw _.empty }
-        if (_.has(15)(_.empty)) { throw _.empty }
-    },
-    set: [
-        () => {
-            const s = _.set(0)(_.empty)
-            if(s !== 1) { throw s }
-            if(!_.has(0)(s)) { throw s }
-            if (_.has(1)(s)) { throw s }
-            if (_.has(15)(s)) { throw s }
-        },
-        () => {
-            const s = _.set(15)(_.empty)
-            if (s !== 0x8000) { throw s }
-            if (_.has(0)(s)) { throw s }
-            if (_.has(1)(s)) { throw s }
-            if (!_.has(15)(s)) { throw s }
-        }
-    ],
-    unset: () => [
-        () => {
-            const a = _.set(0)(_.empty)
-            const result = _.unset(0)(a)
-            if (result !== 0) { throw result }
-        },
-        () => {
-            const a = _.set(15)(_.empty)
-            const result = _.unset(15)(a)
-            if (result !== 0) { throw result }
-        }
-    ],
-    setRange: () => {
-        const result = _.setRange([2, 5])(_.empty)
-        if (result !== 60) { throw result }
-    },
-    universe: () => {
-        const x = every(map((v: number) => _.has(v)(_.universe))(countdown(16)))
-        if (!x) { throw x }
-    },
-    compliment: {
-        empty: () => {
-            const r = _.complement(_.empty)
-            if (r !== _.universe) { throw r }
-        },
-        universe: () => {
-            const r = _.complement(_.universe)
-            if (r !== _.empty) { throw r }
-        },
-    }
-}

package/types/nullable/module.f.ts

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

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

package/types/number/module.f.ts

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