functionalscript 0.0.488 → 0.0.490

package/.github/workflows/deno.yml

@@ -16,4 +16,4 @@ jobs:
     - uses: denoland/setup-deno@v1
       with:
         deno-version: v1.x
-    - run: deno run --allow-read --allow-env --allow-net ./dev/test.mjs
+    - run: deno run --allow-read --allow-env --allow-net --allow-hrtime ./dev/test.mjs

package/README.md

@@ -3,8 +3,10 @@
 FunctionalScript is a purely functional programming language and a strict subset of
 [ECMAScript](https://en.wikipedia.org/wiki/ECMAScript)/[JavaScript](https://en.wikipedia.org/wiki/JavaScript). It's inspired by
 
-- [JSON](https://en.wikipedia.org/wiki/JSON) as a subset of JavaScript. JSON is also a subset of FunctionalScript.
-- [asm.JS](https://en.wikipedia.org/wiki/Asm.js)/[WebAssembly](https://en.wikipedia.org/wiki/WebAssembly), as a subset of JavaScript.
+- [JSON](https://en.wikipedia.org/wiki/JSON) and [JSON5](https://json5.org/) as subsets of JavaScript.
+  JSON is also a subset of FunctionalScript.
+- [asm.JS](https://en.wikipedia.org/wiki/Asm.js)/[WebAssembly](https://en.wikipedia.org/wiki/WebAssembly),
+  as a subset of JavaScript.
 - [TypeScript](https://en.wikipedia.org/wiki/TypeScript), as a superset of JavaScript.
 
 [A brief description of FunctionalScript Programming Language](./doc/LANGUAGE.md).

package/dev/test/module.f.cjs

@@ -26,11 +26,17 @@ const { reset, fgGreen } = require('../../text/sgr/module.f.cjs')
  * @typedef {(v: string) => (state: T) => T} Log
  */
 
+/**
+ * @template T
+ * @typedef {(state: T) => readonly[number, T]} PerformanceNow
+ */
+
 /**
  * @template T
  * @typedef {{
  *  readonly moduleMap: ModuleMap,
  *  readonly log: Log<T>,
+ *  readonly performanceNow: PerformanceNow<T>,
  *  readonly state: T,
  * }} Input
  */
@@ -38,49 +44,66 @@ const { reset, fgGreen } = require('../../text/sgr/module.f.cjs')
 /** @type {(s: string) => boolean} */
 const isTest = s => s.endsWith('test.f.cjs')
 
+/**
+ * @template T
+ * @typedef {readonly[number, T]} State
+ */
+
 /** @type {<T>(input: Input<T>) => T} */
-const main = ({moduleMap, log, state}) => {
-    /** @typedef {log extends Log<infer T> ? T : never} T */
-    /** @type {(i: string) => (v: unknown) => (state: T) => T} */
-    const test = i => v => state => {
+const main = input => {
+    let { moduleMap, log, performanceNow, state } = input
+    /** @typedef {input extends Input<infer T> ? T : never} T */
+    /** @type {(i: string) => (v: unknown) => (state: State<T>) => State<T>} */
+    const test = i => v => ([time, state]) => {
         const next = test(`${i}| `)
         switch (typeof v) {
             case 'function': {
                 if (v.length === 0) {
+                    let b = 0;
+                    [b, state] = performanceNow(state)
                     const r = v()
-                    state = log(`${i}() ${fgGreen}ok${reset}`)(state)
-                    state = next(r)(state)
+                    let e = 0;
+                    [e, state] = performanceNow(state)
+                    const delta = e - b
+                    time += delta
+                    state = log(`${i}() ${fgGreen}ok${reset}, ${delta} ms`)(state);
+                    [time, state] = next(r)([time, state])
                 }
                 break
             }
             case 'object': {
-                /** @type {(k: readonly[string|number, unknown]) => (state: T) => T} */
-                const f = ([k, v]) => state => {
-                    state = log(`${i}${k}:`)(state)
-                    state = next(v)(state)
-                    return state
+                /** @type {(k: readonly[string|number, unknown]) => (state: State<T>) => State<T>} */
+                const f = ([k, v]) => ([time, state]) => {
+                    state = log(`${i}${k}:`)(state);
+                    [time, state] = next(v)([time, state])
+                    return [time, state]
                 }
-                const foldF = fold(f)(state)
+                const foldF = fold(f)([time, state])
                 if (v instanceof Array) {
-                    state = foldF(list.entries(v))
+                    [time, state] = foldF(list.entries(v))
                 } else if (v !== null) {
-                    state = foldF(Object.entries(v))
+                    [time, state] = foldF(Object.entries(v))
                 }
                 break
             }
         }
-        return state
+        return [time, state]
     }
     const next = test('| ')
-    /** @type {(k: readonly[string, Module]) => (state: T) => T} */
-    const f = ([k, v]) => state => {
+    /** @type {(k: readonly[string, Module]) => (fs: State<T>) => State<T>} */
+    const f = ([k, v]) => ([time, state]) => {
         if (isTest(k)) {
-            state = log(`testing ${k}`)(state)
-            state = next(v.exports)(state)
+            state = log(`testing ${k}`)(state);
+            [time, state] = next(v.exports)([time, state])
         }
-        return state
+        return [time, state]
     }
-    return fold(f)(state)(Object.entries(moduleMap))
+    /** @type {State<T>} */
+    const init = [0, state]
+    let time = 0;
+    [time, state] = fold(f)(init)(Object.entries(moduleMap))
+    state = log(`total ${time} ms`)(state);
+    return state
 }
 
 module.exports = main

package/dev/test.mjs

@@ -1,20 +1,26 @@
 import { loadModuleMap } from './module.mjs'
 
+/** @type {(s: string) => <T>(_: T) => T} */
+const log = s => state => {
+    console.log(s)
+    return state
+}
+
+/** @type {<T>(_: T) => readonly[number, T]} */
+const performanceNow = state => [performance.now(), state]
+
 // test runner.
 const main = async() => {
     const moduleMap = await loadModuleMap()
 
-    /** @type {(s: string) => <T>(_: T) => T} */
-    const log = s => state => {
-        console.log(s)
-        return state
-    }
+    // await import(self.Deno ? 'https://deno.land/std/node/fs/promises.ts' : 'node:fs/promises')
 
     /** @type {any} */
     const f = moduleMap['./dev/test/module.f.cjs'].exports
     f({
         moduleMap,
         log,
+        performanceNow,
     })
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.0.488",
+  "version": "0.0.490",
   "description": "FunctionalScript is a functional subset of JavaScript",
   "main": "module.f.cjs",
   "scripts": {

package/types/array/module.f.cjs

@@ -85,16 +85,16 @@ const uncheckTail = a => a.slice(1)
 const uncheckHead = a => a.slice(0, -1)
 
 /** @type {(index: number) => <T>(a: readonly T[]) => T|null} */
-const unsafeAt = i => a => {
+const at = i => a => {
     const r = a[i]
     return r === void 0 ? null : r
 }
 
 /** @type {<T>(_: readonly T[]) => T|null} */
-const first = unsafeAt(0)
+const first = at(0)
 
 /** @type {<T>(_: readonly T[]) => T|null} */
-const last = a => unsafeAt(a.length - 1)(a)
+const last = a => at(a.length - 1)(a)
 
 /** @type {<T>(_: readonly T[]) => readonly T[] | null} */
 const tail = a => a.length === 0 ? null : uncheckTail(a)
@@ -117,9 +117,6 @@ const splitLast = a => {
     return [uncheckHead(a), lastA]
 }
 
-/** @type {(index: number) => <T>(a: readonly T[]) => readonly[T]|null} */
-const at = index => a => index < a.length ? [a[index]] : null
-
 module.exports = {
     /** @readonly */
     at,

package/types/array/test.f.cjs

@@ -12,8 +12,7 @@ module.exports = {
     at: [
         () => {
             const result = _.at(2)([1, 20, 300])
-            if (result === null) { throw result }
-            if (result[0] !== 300) { throw result }
+            if (result !== 300) { throw result }
         },
 
         () => {

package/types/byte_set/module.f.cjs

@@ -1,4 +1,4 @@
-const { fn } = require('../function/module.f.cjs')
+const { fn, compose } = require('../function/module.f.cjs')
 const rangeMap = require('../range_map/module.f.cjs')
 const sortedSet = require('../sorted_set/module.f.cjs')
 const list = require('../list/module.f.cjs')
@@ -31,17 +31,17 @@ const union = a => b => a | b
 /** @type {(a: ByteSet) => (b: ByteSet) => ByteSet} */
 const intersect = a => b => a & b
 
-/** @type {(a: ByteSet) => (b: ByteSet) => ByteSet} */
-const difference = a => b => intersect(a)(complement(b))
-
 /** @type {(n: ByteSet) => ByteSet} */
 const complement = n => universe ^ n
 
+/** @type {(a: ByteSet) => (b: ByteSet) => ByteSet} */
+const difference = compose(intersect)(compose(complement))
+
 // additional operations
 
-const set = fn(one).then(union).result
+const set = compose(one)(union)
 
-const setRange = fn(range).then(union).result
+const setRange = compose(range)(union)
 
 /** @type {(n: Byte) => (s: ByteSet) => ByteSet} */
 const unset = n => s => difference(s)(one(n))
@@ -49,8 +49,7 @@ const unset = n => s => difference(s)(one(n))
 const counter = reverse(countdown(256))
 
 /** @type {(n: ByteSet) => (s: string) => (i: number) => rangeMap.RangeMap<sortedSet.SortedSet<string>>} */
-const toRangeMapOp = n => s => i =>
-{
+const toRangeMapOp = n => s => i => {
     const current = has(i + 1)(n)
     const prev = has(i)(n)
     if (current === prev) { return null }

package/types/list/module.f.cjs

@@ -1,4 +1,5 @@
-const { compose, identity } = require('../function/module.f.cjs')
+const function_ = require('../function/module.f.cjs')
+const { identity, fn, compose } = function_
 const operator = require('../function/operator/module.f.cjs')
 const {
     counter,
@@ -121,13 +122,13 @@ const apply = f => input => () => {
 }
 
 /** @type {<T>(n: NonEmpty<List<T>>) => List<T>} */
-const flatStep = n => concat(n.first)(flat(n.tail))
+const flatStep = ({ first, tail }) => concat(first)(flat(tail))
 
 /** @type {<T>(list: List<List<T>>) => Thunk<T>} */
 const flat = apply(flatStep)
 
 /** @type {<I, O>(f: (value: I) => O) => (n: NonEmpty<I>) => List<O>} */
-const mapStep = f => n => ({ first: f(n.first), tail: map(f)(n.tail) })
+const mapStep = f => ({ first, tail }) => ({ first: f(first), tail: map(f)(tail) })
 
 /** @type {<I, O>(f: (value: I) => O) => (input: List<I>) => Thunk<O>} */
 const map = f => apply(mapStep(f))
@@ -136,9 +137,9 @@ const map = f => apply(mapStep(f))
 const flatMap = f => compose(map(f))(flat)
 
 /** @type {<T>(f: (value: T) => boolean) => (n: NonEmpty<T>) => List<T>} */
-const filterStep = f => n => {
-    const tail = filter(f)(n.tail)
-    return f(n.first) ? { first: n.first, tail } : tail
+const filterStep = f => ({ first, tail }) => {
+    const newTail = filter(f)(tail)
+    return f(first) ? { first, tail: newTail } : newTail
 }
 
 /** @type {<T>(f: (value: T) => boolean) => (input: List<T>) => Thunk<T>} */
@@ -154,13 +155,13 @@ const filterMapStep = f => n => {
 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) } : null
+const takeWhileStep = f => ({ first, tail }) => f(first) ? { first, tail: takeWhile(f)(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) } : null
+const takeStep = n => ({ first, tail }) => 0 < n ? { first: first, tail: take(n - 1)(tail) } : null
 
 /** @type {(n: number) => <T>(input: List<T>) => Thunk<T>} */
 const take = n => apply(takeStep(n))
@@ -179,8 +180,8 @@ 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 === null ? def : result.first
+    const ne = next(input)
+    return ne === null ? def : ne.first
 }
 
 /** @type {<D>(first: D) => <T>(tail: List<T>) => D|T} */
@@ -198,28 +199,24 @@ const last = first => tail => {
 }
 
 /** @type {<D>(def: D) => <T>(f: (value: T) => boolean) => (input: List<T>) => D|T} */
-const find = def => f => input => first(def)(filter(f)(input))
-
-const findTrue = find(false)
+const find = def => f => compose(filter(f))(first(def))
 
 /** @type {(input: List<boolean>) => boolean} */
-const some = input => findTrue
-    (/** @type {(_: boolean) => boolean} */(identity))
-    (input)
-
-/** @type {<T>(f: List<T>) => Thunk<boolean>} */
-const mapTrue = map(() => true)
+const some = find(false)(identity)
 
 /** @type {<T>(input: List<T>) => boolean} */
-const isEmpty = input => !some(mapTrue(input))
+const isEmpty = fn(map(() => true))
+    .then(some)
+    .then(logicalNot)
+    .result
 
-const mapNot = map(logicalNot)
-
-/** @type {(input: List<boolean>) => boolean} */
-const every = input => !some(mapNot(input))
+const every = fn(map(logicalNot))
+    .then(some)
+    .then(logicalNot)
+    .result
 
 /** @type {<T>(value: T) => (sequence: List<T>) => boolean} */
-const includes = value => input => some(map(strictEqual(value))(input))
+const includes = value => compose(map(strictEqual(value)))(some)
 
 /** @type {(count: number) => Thunk<number>} */
 const countdown = count => () => {
@@ -229,7 +226,7 @@ const countdown = count => () => {
 }
 
 /** @type {<T>(v: T) => (c: number) => Thunk<T>} */
-const repeat = v => n => map(() => v)(countdown(n))
+const repeat = v => compose(countdown)(map(() => v))
 
 /** @type {<T>(list: List<T>) => List<T>} */
 const cycle = list => () => {
@@ -247,17 +244,16 @@ const scanStep = op => ne => {
 const scan = op => apply(scanStep(op))
 
 /** @type {<I, S, O>(op: operator.StateScan<I, S, O>) => (init: S) => (input: List<I>) => Thunk<O>} */
-const stateScan = op => init => scan(stateScanToScan(op)(init))
+const stateScan = op => compose(stateScanToScan(op))(scan)
 
 /** @type {<I,O>(op: operator.Fold<I, O>) => (init: O) => (input: List<I>) => Thunk<O>} */
-const foldScan = op => init => scan(foldToScan(op)(init))
+const foldScan = op => compose(foldToScan(op))(scan)
 
 /** @type {<I,O>(op: operator.Fold<I, O>) => (init: O) => (input: List<I>) => O} */
-const fold = op => init => input => last(init)(foldScan(op)(init)(input))
+const fold = op => init => compose(foldScan(op)(init))(last(init))
 
 /** @type {<T>(op: operator.Reduce<T>) => <D>(def: D) => (input: List<T>) => D|T} */
-const reduce = op => def => input => last(def)(scan(reduceToScan(op))(input))
-
+const reduce = op => def => compose(scan(reduceToScan(op)))(last(def))
 
 /** @type {<T>(input: List<T>) => number} */
 const length = fold(counter)(0)

package/types/map/module.f.cjs

@@ -39,7 +39,8 @@ const at = name => map => {
 }
 
 /** @type {<T>(reduce: operator.Reduce<T>) => (entry: Entry<T>) => (map: Map<T>) => Map<T>} */
-const setReduceEntry = reduce => entry => set(keyCmp(entry[0]))(old => old === null ? 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])

package/types/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(null)
-    if (sqUndefined !== null) { throw sqUndefined }
+    const sqNull = optionSq(null)
+    if (sqNull !== null) { throw sqNull }
 }

package/types/sorted_list/module.f.cjs

@@ -41,9 +41,8 @@ const { identity } = require('../function/module.f.cjs')
  */
 
 /** @type {<T,S>(reduce: MergeReduce<T,S>) => (state: S) => (a: list.List<T>) => (b: list.List<T>) => list.List<T>} */
-const genericMerge = reduce => {
-    const { reduceOp, tailReduce } = reduce
-    /** @typedef {typeof reduce extends MergeReduce<infer T, infer S> ? [T, S] : never} TS */
+const genericMerge = ({ reduceOp, tailReduce }) => {
+    /** @typedef {typeof reduceOp extends ReduceOp<infer T, infer S> ? [T, S] : never} TS */
     /** @typedef {TS[0]} T */
     /** @typedef {TS[1]} S */
     /** @type {(state: S) => (a: list.List<T>) => (b: list.List<T>) => list.List<T>} */

package/types/sorted_set/module.f.cjs

@@ -21,8 +21,10 @@ const union = cmp => a => b => toArray(merge(cmp)(a)(b))
 /** @type {<T>(cmp: Cmp<T>) => (a: SortedSet<T>) => (b: SortedSet<T>) => SortedSet<T>} */
 const intersect = cmp => a => b => toArray(intersectMerge(cmp)(a)(b))
 
+const tailReduce = () => () => null
+
 /** @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 })(null)
+const intersectMerge = cmp => genericMerge({ reduceOp: intersectReduce(cmp), tailReduce })(null)
 
 /** @type {<T,S>(cmp: Cmp<T>) => sortedList.ReduceOp<T,S>} */
 const intersectReduce = cmp => state => a => b => {
@@ -30,8 +32,6 @@ const intersectReduce = cmp => state => a => b => {
     return [sign === 0 ? a : null, sign, state]
 }
 
-const intersectTail = () => () => null
-
 /** @type {<T>(cmp: Cmp<T>) => (value: T) => (set: SortedSet<T>) => boolean} */
 const has = cmp => value => set => find(cmp)(value)(set) === value