functionalscript 0.2.5 → 0.3.0

package/types/function/operator/module.f.ts

@@ -0,0 +1,63 @@
+type Binary<A, B, R> = (a: A) => (b: B) => R
+
+export type Fold<I, O> = Binary<I, O, O>
+
+export const join
+: (separator: string) => Reduce<string>
+= separator => value => prior => `${prior}${separator}${value}`
+
+export const concat
+: Reduce<string>
+= i => acc => `${acc}${i}`
+
+export type Unary<T, R> = (value: T) => R
+
+export const logicalNot
+: Unary<boolean, boolean>
+= v => !v
+
+export type Equal<T> = Binary<T, T, boolean>
+
+export const strictEqual
+: <T>(a: T) => (b: T) => boolean
+= a => b => a === b
+
+export type Scan<I, O> = (input: I) => readonly[O, Scan<I,O>]
+
+export type StateScan<I, S, O> = (prior: S) => (input: I) => readonly[O, S]
+
+export const stateScanToScan
+: <I, S, O>(op: StateScan<I, S, O>) => (prior: S) => Scan<I, O>
+= op => prior => i => {
+    const [o, s] = op(prior)(i)
+    return [o, stateScanToScan(op)(s)]
+}
+
+export const foldToScan
+: <I, O>(fold: Fold<I, O>) => (prior: O) => Scan<I, O>
+= fold => prior => i => {
+    const result = fold(i)(prior)
+    return [result, foldToScan(fold)(result)]
+}
+
+export type Reduce<T> = Fold<T, T>
+
+export const reduceToScan
+: <T>(fold: Reduce<T>) => Scan<T, T>
+= op => init => [init, foldToScan(op)(init)]
+
+export const addition
+: Reduce<number>
+= a => b => a + b
+
+export const min
+: Reduce<number>
+= a => b => a < b ? a : b
+
+export const max
+: Reduce<number>
+= a => b => a > b ? a : b
+
+export const increment = addition(1)
+
+export const counter = () => increment

package/types/function/test.f.ts

@@ -0,0 +1,20 @@
+import * as _ from './module.f.ts'
+
+const { fn } = _
+
+export default () => {
+    const f
+        : (x: string) => readonly[string]
+        = x => [x]
+    const g
+        : (x: readonly[string]) => readonly[number]
+        = ([x]) => [x.length]
+    const w
+        : (x: readonly[number]) => number
+        = ([x]) => x
+
+    const r = fn(f).then(g).then(w).result
+
+    const result = r('hello')
+    if (result !== 5) { throw r }
+}

package/types/list/module.f.ts

@@ -0,0 +1,345 @@
+import * as function_ from '../function/module.f.ts'
+const { identity, fn, compose } = function_
+import * as operator from '../function/operator/module.f.ts'
+const {
+    addition,
+    logicalNot,
+    strictEqual,
+    stateScanToScan,
+    foldToScan,
+    reduceToScan
+} = operator
+
+export type List<T> = NotLazy<T> | Thunk<T>
+
+type NotLazy<T> = |
+    Result<T> |
+    Concat<T> |
+    readonly T[]
+
+type Empty = null
+
+export type Result<T> = Empty | NonEmpty<T>
+
+export type Thunk<T> = () => List<T>
+
+type NonEmpty<T> = {
+    readonly first: T
+    readonly tail: List<T>
+}
+
+type Concat<T> = {
+    readonly head: List<T>
+    readonly tail: List<T>
+}
+
+const fromArray
+: <T>(array: readonly T[]) => Result<T>
+= array => {
+    type T = typeof array extends readonly (infer T)[] ? T : never
+    const at
+    : (i: number) => Result<T>
+    = i => i < array.length ? { first: array[i], tail: () => at(i + 1) } : null
+    return at(0)
+}
+
+export const concat
+: <T>(head: List<T>) => (tail: List<T>) => List<T>
+= head => tail => tail === null ? head : ({ head, tail })
+
+const trampoline
+: <T>(list: List<T>) => NotLazy<T>
+= list => {
+    while (typeof list === 'function') { list = list() }
+    return list
+}
+
+export const next
+: <T>(list: List<T>) => Result<T>
+= head => {
+    let tail: typeof head = null
+    while (true) {
+        head = trampoline(head)
+
+        if (head instanceof Array) {
+            head = fromArray(head)
+        } else if (head !== null && 'head' in head) {
+            [head, tail] = [head.head, concat(head.tail)(tail)]
+            continue
+        }
+
+        if (head !== null) {
+            return { first: head.first, tail: concat(head.tail)(tail) }
+        }
+
+        if (tail === null) { return null }
+
+        [head, tail] = [tail, null]
+    }
+}
+
+export const iterable
+: <T>(list: List<T>) => Iterable<T>
+= list => ({
+    *[Symbol.iterator]() {
+        let i = list
+        while (true) {
+            const r = next(i)
+            if (r === null) { return }
+            yield r.first
+            i = r.tail
+        }
+    }
+})
+
+const { from } = Array
+
+export const toArray
+: <T>(list: List<T>) => readonly T[]
+= list => {
+    const u = trampoline(list)
+    return u instanceof Array ? u : from(iterable(u))
+}
+
+const apply
+: <I, O>(step: (n: NonEmpty<I>) => List<O>) => (input: List<I>) => Thunk<O>
+= f => input => () => {
+    const n = next(input)
+    if (n === null) { return null }
+    return f(n)
+}
+
+const flatStep
+: <T>(n: NonEmpty<List<T>>) => List<T>
+= ({ first, tail }) => concat(first)(flat(tail))
+
+export const flat
+: <T>(list: List<List<T>>) => Thunk<T>
+= apply(flatStep)
+
+const mapStep
+: <I, O>(f: (value: I) => O) => (n: NonEmpty<I>) => List<O>
+= f => ({ first, tail }) => ({ first: f(first), tail: map(f)(tail) })
+
+export const map
+: <I, O>(f: (value: I) => O) => (input: List<I>) => Thunk<O>
+= f => apply(mapStep(f))
+
+export const flatMap
+: <I, O>(f: (value: I) => List<O>) => (input: List<I>) => Thunk<O>
+= f => compose(map(f))(flat)
+
+const filterStep
+: <T>(f: (value: T) => boolean) => (n: NonEmpty<T>) => List<T>
+= f => ({ first, tail }) => {
+    const newTail = filter(f)(tail)
+    return f(first) ? { first, tail: newTail } : newTail
+}
+
+export const filter
+: <T>(f: (value: T) => boolean) => (input: List<T>) => Thunk<T>
+= f => apply(filterStep(f))
+
+const filterMapStep
+: <I, O>(f: (value: I) => O|null) => (n: NonEmpty<I>) => List<O>
+= f => n => {
+    const [first, tail] = [f(n.first), filterMap(f)(n.tail)]
+    return first === null ? tail : { first, tail }
+}
+
+export const filterMap
+: <I, O>(f: (value: I) => O|null) => (input: List<I>) => Thunk<O>
+= f => apply(filterMapStep(f))
+
+const takeWhileStep
+: <T>(f: (value: T) => boolean) => (n: NonEmpty<T>) => List<T>
+= f => ({ first, tail }) => f(first) ? { first, tail: takeWhile(f)(tail) } : null
+
+export const takeWhile
+: <T>(f: (value: T) => boolean) => (input: List<T>) => Thunk<T>
+= f => apply(takeWhileStep(f))
+
+const takeStep
+: (n: number) => <T>(result: NonEmpty<T>) => List<T>
+= n => ({ first, tail }) => 0 < n ? { first: first, tail: take(n - 1)(tail) } : null
+
+export const take
+: (n: number) => <T>(input: List<T>) => Thunk<T>
+= n => apply(takeStep(n))
+
+const dropWhileStep
+: <T>(f: (value: T) => boolean) => (ne: NonEmpty<T>) => List<T>
+= f => ne => f(ne.first) ? dropWhile(f)(ne.tail) : ne
+
+export const dropWhile
+: <T>(f: (value: T) => boolean) => (input: List<T>) => Thunk<T>
+= f => apply(dropWhileStep(f))
+
+const dropStep
+: (n: number) => <T>(ne: NonEmpty<T>) => List<T>
+= n => ne => 0 < n ? drop(n - 1)(ne.tail) : ne
+
+export const drop
+: (n: number) => <T>(input: List<T>) => Thunk<T>
+= n => apply(dropStep(n))
+
+export const first
+: <D>(def: D) => <T>(input: List<T>) => D|T
+= def => input => {
+    const ne = next(input)
+    return ne === null ? def : ne.first
+}
+
+export const last
+: <D>(first: D) => <T>(tail: List<T>) => D|T
+= first => tail => {
+    type T = typeof tail extends List<infer T> ? T : never
+    let i: NonEmpty<typeof first|T> = { first, tail }
+    while (true) {
+        const result = next(i.tail)
+        if (result === null) {
+            return i.first
+        }
+        i = result
+    }
+}
+
+export const find
+: <D>(def: D) => <T>(f: (value: T) => boolean) => (input: List<T>) => D|T
+= def => f => compose(filter(f))(first(def))
+
+export const some
+: (input: List<boolean>) => boolean
+= find(false)(identity)
+
+export const isEmpty
+: <T>(input: List<T>) => boolean
+= fn(map(() => true))
+    .then(some)
+    .then(logicalNot)
+    .result
+
+export const every = fn(map(logicalNot))
+    .then(some)
+    .then(logicalNot)
+    .result
+
+export const includes
+: <T>(value: T) => (sequence: List<T>) => boolean
+= value => compose(map(strictEqual(value)))(some)
+
+export const countdown
+: (count: number) => Thunk<number>
+= count => () => {
+    if (count <= 0) { return null }
+    const first = count - 1
+    return { first, tail: countdown(first) }
+}
+
+export const repeat
+: <T>(v: T) => (c: number) => Thunk<T>
+= v => compose(countdown)(map(() => v))
+
+export const cycle
+: <T>(list: List<T>) => List<T>
+= list => () => {
+    const i = next(list)
+    return i === null ? null : { first: i.first, tail: concat(i.tail)(cycle(list)) }
+}
+
+const scanStep
+: <I, O>(op: operator.Scan<I, O>) => (ne: NonEmpty<I>) => List<O>
+= op => ne => {
+    const [first, newOp] = op(ne.first)
+    return { first, tail: scan(newOp)(ne.tail) }
+}
+
+export const scan
+: <I, O>(op: operator.Scan<I, O>) => (input: List<I>) => Thunk<O>
+= op => apply(scanStep(op))
+
+export const stateScan
+: <I, S, O>(op: operator.StateScan<I, S, O>) => (init: S) => (input: List<I>) => Thunk<O>
+= op => compose(stateScanToScan(op))(scan)
+
+export const foldScan
+: <I,O>(op: operator.Fold<I, O>) => (init: O) => (input: List<I>) => Thunk<O>
+= op => compose(foldToScan(op))(scan)
+
+export const fold
+: <I,O>(op: operator.Fold<I, O>) => (init: O) => (input: List<I>) => O
+= op => init => compose(foldScan(op)(init))(last(init))
+
+export const reduce
+: <T>(op: operator.Reduce<T>) => <D>(def: D) => (input: List<T>) => D|T
+= op => def => compose(scan(reduceToScan(op)))(last(def))
+
+const lengthList
+: <T>(list: List<T>) => Thunk<number>
+= list => () => {
+    const notLazy = trampoline(list)
+    if (notLazy === null) { return null }
+    if (notLazy instanceof Array) { return [notLazy.length] }
+    const tail = lengthList(notLazy.tail)
+    if ('first' in notLazy) {
+        return { first: 1, tail }
+    }
+    return { head: lengthList(notLazy.head), tail }
+}
+
+const sum = reduce(addition)(0)
+
+export const length
+: <T>(input: List<T>) => number
+= input => sum(lengthList(input))
+
+export type Entry<T> = readonly[number, T]
+
+const entryOperator
+: (index: number) => <T>(value: T) => readonly[Entry<T>, number]
+= index => value => [[index, value], index + 1]
+
+export const entries
+: <T>(input: List<T>) => Thunk<Entry<T>>
+= input => {
+    type T = typeof input extends List<infer T> ? T : never
+    const o
+    : operator.StateScan<T, number, Entry<T>>
+    = entryOperator
+    return stateScan(o)(0)(input)
+}
+
+const reverseOperator
+: <T>(value: T) => (prior: List<T>) => List<T>
+= first => tail => ({ first, tail })
+
+export const reverse
+: <T>(input: List<T>) => List<T>
+= fold(reverseOperator)(null)
+
+export const zip
+: <A>(a: List<A>) => <B>(b: List<B>) => Thunk<readonly[A, B]>
+= a => b => () => {
+    const aResult = next(a)
+    if (aResult === null) { return null }
+    const bResult = next(b)
+    if (bResult === null) { return null }
+    return { first: [aResult.first, bResult.first], tail: zip(aResult.tail)(bResult.tail) }
+}
+
+export const equal
+: <T>(e: operator.Equal<T>) => (a: List<T>) => (b: List<T>) => boolean
+= e => {
+    type T = typeof e extends operator.Equal<infer T> ? T : never
+    const f
+    : (a: List<T>) => (b: List<T>) => List<boolean>
+    = a => b => () => {
+        const [aResult, bResult] = [next(a), next(b)]
+        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))
+}
+
+export const empty = null

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

@@ -1,12 +1,13 @@
-import * as _ from './module.f.mjs'
-import * as json from '../../json/module.f.mjs'
-import * as o from '../object/module.f.mjs'
+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.mjs'
+import * as operator from '../function/operator/module.f.ts'
 const { addition, strictEqual, reduceToScan } = operator
 
-/** @type {(sequence: _.List<json.Unknown>) => string} */
-const stringify = sequence => json.stringify(sort)(_.toArray(sequence))
+const stringify
+    : (sequence: _.List<json.Unknown>) => string
+    = sequence => json.stringify(sort)(_.toArray(sequence))
 
 const stringifyTest = () => {
     const s = stringify([1, 2, 3])
@@ -36,7 +37,7 @@ const concat = () => {
 }
 
 const flatMap = () => {
-    const result = stringify(_.flatMap(x => [x, x * 2, x * 3])([0, 1, 2, 3]))
+    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 }
 }
 
@@ -57,28 +58,28 @@ const take = [
 
 const find = [
     () => {
-        const result = _.find(null)(x => x % 2 === 0)([1, 3, 5, 7])
+        const result = _.find(null)((x: number) => x % 2 === 0)([1, 3, 5, 7])
         if (result !== null) { throw result }
     },
     () => {
-        const result = _.find(null)(x => x % 2 === 0)([1, 2, 3, 4])
+        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 => x < 10)([1, 2, 3, 4, 5, 10, 11]))
+        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 => x < 6)([1, 2, 3, 4, 5, 6, 7, 8, 9]))
+        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 => x < 10)([1, 2, 3, 4, 5, 10, 11]))
+    const result = stringify(_.dropWhile((x: number) => x < 10)([1, 2, 3, 4, 5, 10, 11]))
     if (result !== '[10,11]') { throw result }
 }
 
@@ -147,7 +148,7 @@ const zip = [
 ]
 
 const logic = () => {
-    const map5 = _.map(x => x > 5)
+    const map5 = _.map((x: number) => x > 5)
 
     return [
         () => {
@@ -185,7 +186,7 @@ const stress = () => ({
         const n = 100_000_000
         const result = _.toArray(_.countdown(n))
         if (result.length !== n) { throw result.length }
-        const len = _.length(_.filter(x => x > n)(result))
+        const len = _.length(_.filter((x: number) => x > n)(result))
         if (len !== 0) { throw len }
     },
     first: () => {
@@ -197,8 +198,9 @@ const stress = () => ({
         if (first !== n - 1) { throw first }
     },
     concatBack: () => {
-        /** @type {_.List<number>} */
-        let sequence = []
+        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) {
@@ -207,8 +209,9 @@ const stress = () => ({
         const r = _.toArray(sequence)
     },
     flatToArray: () => {
-        /** @type {_.List<number>} */
-        let sequence = []
+        let sequence
+            : _.List<number>
+            = []
         // 4_000_000 is too much
         for (let i = 0; i < 2_000_000; ++i) {
             sequence = _.flat([sequence, [i]])
@@ -216,8 +219,9 @@ const stress = () => ({
         const r = _.toArray(sequence)
     },
     flatNext: () => {
-        /** @type {_.List<number>} */
-        let sequence = []
+        let sequence
+            : _.List<number>
+            = []
         // 4_000_000 is too much
         for (let i = 0; i < 2_000_000; ++i) {
             sequence = _.flat([sequence, [i]])
@@ -225,8 +229,9 @@ const stress = () => ({
         const a = _.next(sequence)
     },
     concatFront: () => {
-        /** @type {_.List<number>} */
-        let sequence = []
+        let sequence
+            : _.List<number>
+            = []
         // 20_000_000 is too much
         for (let i = 0; i < 10_000_000; ++i) {
             sequence = _.concat([i])(sequence)
@@ -234,8 +239,9 @@ const stress = () => ({
         const a = _.next(sequence)
     },
     flatFront: () => {
-        /** @type {_.List<number>} */
-        let sequence = []
+        let sequence
+            : _.List<number>
+            = []
         // 10_000_000 is too much
         for (let i = 0; i < 5_000_000; ++i) {
             sequence = _.flat([[i], sequence])

package/types/map/module.f.ts

@@ -0,0 +1,65 @@
+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.mjs → test.f.ts}

@@ -1,6 +1,6 @@
-import * as _ from './module.f.mjs'
+import * as _ from './module.f.ts'
 const { at, setReplace, setReduce, empty, entries, remove } = _
-import * as seq from '../list/module.f.mjs'
+import * as seq from '../list/module.f.ts'
 
 export default {
     main: [
@@ -44,7 +44,7 @@ export default {
             m = remove('Hello world!')(m)
             if (at('Hello world!')(m) !== null) { throw m }
 
-            m = setReduce(a => b => a + b)('a')(43)(m)
+            m = setReduce((a: number) => (b: number) => a + b)('a')(43)(m)
             if (at('a')(m) !== 44) { throw 'error' }
         },
         () => {
@@ -58,8 +58,9 @@ export default {
         },
     ],
     stress: () => {
-        /** @type {import('./module.f.mjs').Map<number>} */
-        let m = empty
+        let m
+            : _.Map<number>
+            = empty
         for (let i = 0; i < 100_000; ++i) {
             m = setReplace((i * i).toString())(i)(m)
             /*

package/types/nibble_set/module.f.ts

@@ -0,0 +1,34 @@
+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)