functionalscript 0.3.4 → 0.3.6

package/dev/test/module.f.ts

@@ -1,135 +0,0 @@
-import * as list from '../../types/list/module.f.ts'
-const { fold } = list
-import * as codes from '../../text/sgr/module.f.ts'
-const { reset, fgGreen, fgRed, bold } = codes
-import * as Result from '../../types/result/module.f.ts'
-
-type DependencyMap = {
-   readonly[k in string]?: Module
-}
-
-type Module = {
-   readonly default?: unknown
-}
-
-type ModuleMap = {
-   readonly[k in string]: Module
-}
-
-type Log<T> = (v: string) => (state: T) => T
-
-type Measure<T> = <R>(f: () => R) => (state: T) => readonly[R, number, T]
-
-type Input<T> = {
-    readonly moduleMap: ModuleMap,
-    readonly log: Log<T>,
-    readonly error: Log<T>,
-    readonly measure: Measure<T>,
-    readonly state: T,
-    readonly tryCatch: <R>(f: () => R) => Result.Result<R, unknown>,
-    readonly env: (n: string) => string|undefined
- }
-
-const isTest
-    : (s: string) => boolean
-    = s => s.endsWith('test.f.mjs') || s.endsWith('test.f.js') || s.endsWith('test.f.ts')
-
-type TestState = {
-    readonly time: number,
-    readonly pass: number,
-    readonly fail: number,
- }
-
-const addPass
-    : (time: number) => (testState: TestState) => TestState
-    = delta => ts => ({ ...ts, time: ts.time + delta, pass: ts.pass + 1 })
-
-const addFail
-    : (time: number) => (testState: TestState) => TestState
-    = delta => ts => ({ ...ts, time: ts.time + delta, fail: ts.fail + 1 })
-
-type FullState<T> = readonly[TestState, T]
-
-const timeFormat
-    : (a: number) => string
-    = a => {
-    const y = Math.round(a * 10_000).toString()
-    const yl = 5 - y.length
-    const x = '0'.repeat(yl > 0 ? yl : 0) + y
-    const s = x.length - 4
-    const b = x.substring(0, s)
-    const e = x.substring(s)
-    return `${b}.${e} ms`
-}
-
-export default <T>(input: Input<T>): readonly[number, T] => {
-    let { moduleMap, log, error, measure, tryCatch, env, state } = input
-    const isGitHub = env('GITHUB_ACTION') !== void 0
-    // type T = input extends Input<infer T> ? T : never
-    /** @type {} */
-    const f
-        : (k: readonly[string, Module]) => (fs: FullState<T>) => FullState<T>
-        = ([k, v]) => {
-        const test
-            : (i: string) => (v: unknown) => (fs: FullState<T>) => FullState<T>
-            = i => v => ([ts, state]) => {
-            const next = test(`${i}| `)
-            switch (typeof v) {
-                case 'function': {
-                    if (v.length === 0) {
-                        const [[s, r], delta, state0] = measure(() => tryCatch(v as () => unknown))(state)
-                        state = state0
-                        if (s === 'error') {
-                            ts = addFail(delta)(ts)
-                            if (isGitHub) {
-                                // https://docs.github.com/en/actions/learn-github-actions/workflow-commands-for-github-actions
-                                // https://github.com/OndraM/ci-detector/blob/main/src/Ci/GitHubActions.php
-                                state = error(`::error file=${k},line=1,title=[3]['a']()::${r}`)(state)
-                            } else {
-                                state = error(`${i}() ${fgRed}error${reset}, ${timeFormat(delta)}`)(state)
-                                state = error(`${fgRed}${r}${reset}`)(state)
-                            }
-                        } else {
-                            ts = addPass(delta)(ts)
-                            state = log(`${i}() ${fgGreen}ok${reset}, ${timeFormat(delta)}`)(state)
-                        }
-                        [ts, state] = next(r)([ts, state])
-                    }
-                    break
-                }
-                case 'object': {
-                    if (v !== null) {
-                        const f
-                            : (k: readonly[string|number, unknown]) => (fs: FullState<T>) => FullState<T>
-                            = ([k, v]) => ([time, state]) => {
-                            state = log(`${i}${k}:`)(state);
-                            [time, state] = next(v)([time, state])
-                            return [time, state]
-                        }
-                        [ts, state] = fold
-                            (f)
-                            ([ts, state])
-                            (v instanceof Array ? list.entries(v) : Object.entries(v))
-                    }
-                    break
-                }
-            }
-            return [ts, state]
-        }
-        return ([ts, state]) => {
-            if (isTest(k)) {
-                state = log(`testing ${k}`)(state);
-                [ts, state] = test('| ')(v.default)([ts, state])
-            }
-            return [ts, state]
-        }
-    }
-    let ts
-        : TestState
-        = { time: 0, pass: 0, fail: 0 };
-    [ts, state] = fold(f)([ts, state])(Object.entries(moduleMap))
-    const fgFail = ts.fail === 0 ? fgGreen : fgRed
-    state = log(`${bold}Number of tests: pass: ${fgGreen}${ts.pass}${reset}${bold}, fail: ${fgFail}${ts.fail}${reset}${bold}, total: ${ts.pass + ts.fail}${reset}`)(state)
-    state = log(`${bold}Time: ${timeFormat(ts.time)}${reset}`)(state);
-    return [ts.fail !== 0 ? 1 : 0, state]
-}

package/dev/test.ts

@@ -1,53 +0,0 @@
-import { loadModuleMap, exit, env } from './module.ts'
-import test from './test/module.f.ts'
-
-const anyLog
-    : (f: (s: string) => void) => (s: string) => <T>(_: T) => T
-    = f => s => state => {
-    f(s)
-    return state
-}
-
-type Ok<T> = readonly['ok', T]
-
-type Error<E> = readonly['error', E]
-
-type Result<T, E> = Ok<T>|Error<E>
-
-const tryCatch
-    : <T>(f: () => T) => Result<T, unknown>
-    = f => {
-    // `try catch` is not allowed in FunctionalScript.
-    try {
-        return ['ok', f()]
-    } catch (e) {
-        return ['error', e]
-    }
-}
-
-const measure
-    : <R>(f: () => R) => <T>(state: T) => readonly[R, number, T]
-    = f => state => {
-    const b = performance.now()
-    const r = f()
-    const e = performance.now()
-    return [r, e - b, state]
-}
-
-// test runner.
-const main = async() => {
-    const moduleMap = await loadModuleMap()
-
-    const r = test({
-        moduleMap,
-        log: anyLog(console.log),
-        error: anyLog(console.error),
-        measure,
-        tryCatch,
-        env,
-        state: void 0,
-    })
-    exit(r[0])
-}
-
-main()

package/djs/README.md

@@ -1,54 +0,0 @@
-# DJS, Data JS or DataScript
-
-- additional types: bigint
-
-## Rules
-
-- can serialize/deserialize without reading source code
-  - no function serialization/deserialization
-
-## Next steps
-
-- [ ] rename `fjson` to `djs` (data javascript), File extensions: `.d.mjs`, `.d.js`.
-- [x] use JS tokenizer 
-- [x] identifiers `{a:5}`
-- [x] big int
-- [ ] `export default ...`
-- [ ] constants
-  ```js
-  const a = [3]
-  export default = { a: a, b: a }
-  ```
-  Serialization
-  ```js
-  const _0=[3]
-  export default {a:_0,b:_0}
-  ```
-- [ ] import
-  ```js
-  import a from 'c.d.mjs'
-  export default { a: a, b: a}
-  ```
-- [ ] short form
-  ```js
-  const a = 5;
-  export default { a }
-  ```
-
-Optional, for fun, syntax sugar:
-
-- [ ] comments. Ignore them. Not an error.
-- [ ] double/single quote strings
-
-## Decidable Language
-  
-- [ ] using operator and functions
-  ```js
-  const a = 2+2+Math.abs(5)
-  export default { a: a }
-  ```
-- [ ] decidable functions?
-  ```js
-  const f = a => b => a + b
-  export default f(1)(2)
-  ```

package/djs/module.f.ts

@@ -1,76 +0,0 @@
-import * as list from '../types/list/module.f.ts'
-const { flat, map } = list
-import * as string from '../types/string/module.f.ts'
-const { concat } = string
-import * as O from '../types/object/module.f.ts'
-import * as f from '../types/function/module.f.ts'
-const { compose, fn } = f
-const { entries } = Object
-import * as bi from '../types/bigint/module.f.ts'
-const { serialize: bigintSerialize } = bi
-import * as j from '../json/serializer/module.f.ts'
-const { objectWrap, arrayWrap, stringSerialize, numberSerialize, nullSerialize, boolSerialize } = j
-import * as djs from './serializer/module.f.ts'
-const { undefinedSerialize } = djs
-
-type Object = {
-   readonly [k in string]: Unknown
-}
-
-type Array = readonly Unknown[]
-
-type Unknown = Object|boolean|string|number|null|Array|bigint|undefined
-
-const colon = [':']
-
-type Entry = O.Entry<Unknown>
-
-type Entries = list.List<Entry>
-
-type MapEntries = (entries: Entries) => Entries
-
-export const serialize
-: (mapEntries: MapEntries) => (value: Unknown) => list.List<string>
-= sort => {
-    const propertySerialize
-    : (kv: readonly[string, Unknown]) => list.List<string>
-    = ([k, v]) => flat([
-        stringSerialize(k),
-        colon,
-        f(v)
-    ])
-    const mapPropertySerialize = map(propertySerialize)
-    const objectSerialize
-        : (object: Object) => list.List<string>
-        = fn(entries)
-        .then(sort)
-        .then(mapPropertySerialize)
-        .then(objectWrap)
-        .result
-    const f
-        : (value: Unknown) => list.List<string>
-        = value => {
-        switch (typeof value) {
-            case 'boolean': { return boolSerialize(value) }
-            case 'number': { return numberSerialize(value) }
-            case 'string': { return stringSerialize(value) }
-            case 'bigint': { return [bigintSerialize(value)] }
-            default: {
-                if (value === null) { return nullSerialize }
-                if (value === undefined) { return undefinedSerialize }
-                if (value instanceof Array) { return arraySerialize(value) }
-                return objectSerialize(value)
-            }
-        }
-    }
-    const arraySerialize = compose(map(f))(arrayWrap)
-    return f
-}
-
-/**
- * The standard `JSON.stringify` rules determined by
- * https://262.ecma-international.org/6.0/#sec-ordinary-object-internal-methods-and-internal-slots-ownpropertykeys
- */
-export const stringify
-    : (mapEntries: MapEntries) => (value: Unknown) => string
-    = sort => compose(serialize(sort))(concat)