functionalscript 0.2.5 → 0.3.0

package/dev/{module.mjs → module.ts}

@@ -1,3 +1,4 @@
+import { existsSync } from 'node:fs'
 import { readdir, writeFile, readFile } from 'node:fs/promises'
 
 /**
@@ -20,73 +21,74 @@ import { readdir, writeFile, readFile } from 'node:fs/promises'
  * }} FsPromises
  */
 
-/**
- * @typedef {{
- *  readonly default?: unknown
- * }} Module
- */
+type Module = {
+   readonly default?: unknown
+}
 
 /** @typedef {(name: string) => unknown} Require */
 
-/**
- * @typedef {{
- *  readonly[k in string]: unknown
- * }} UnknownMap
- */
+type UnknownMap = {
+   readonly[k in string]: unknown
+}
 
-/**
- * @template T
- * @typedef {readonly[string, T]} Entry
- */
+type Entry<T> = readonly[string, T]
 
-/** @type {(a: Entry<unknown>, b: Entry<unknown>) => number} */
-const cmp = ([a], [b]) => a < b ? -1 : a > b ? 1 : 0
+const cmp
+    : (a: Entry<unknown>, b: Entry<unknown>) => number
+    = ([a], [b]) => a < b ? -1 : a > b ? 1 : 0
 
-/**
- * @typedef {{
- *  [k in string]: Module
- * }} MutableModuleMap
- */
+type MutableModuleMap = {
+   [k in string]: Module
+}
 
-/**
- * @typedef {{
- *  readonly[k in string]: Module
- * }} ModuleMap
- */
+type ModuleMap = {
+   readonly[k in string]: Module
+}
 
-/** @type {(v: readonly string[]) => (dif: number) => readonly string[]} */
-const remove_tail = v => dif => v.slice(0, v.length - dif)
+const remove_tail
+    : (v: readonly string[]) => (dif: number) => readonly string[]
+    = v => dif => v.slice(0, v.length - dif)
 
-/** @type {any} */
-const self = globalThis
+const self: any = globalThis
 
-/** @type {(code: number) => never} */
-export const exit = self.Deno ? self.Deno.exit : process.exit
+export const exit
+    : (code: number) => never
+    = self.Deno ? self.Deno.exit : process.exit
 
-/** @type {(v: string) => string|undefined} */
-export const env =
-    self.Deno ? self.Deno.env.get :
+export const env
+    : (v: string) => string|undefined
+    = self.Deno ? self.Deno.env.get :
         a => {
             const r = Object.getOwnPropertyDescriptor(process.env, a)
-            return r === void 0 ? void 0 :
+            return r === undefined ? undefined :
                 typeof r.get === 'function' ? r.get() :
                     r.value
         }
 
 export const loadModuleMap = async () => {
-    /** @type {() => Promise<UnknownMap>} */
-    const load = async () => {
-        /** @type {(readonly[string, unknown])[]} */
-        const map = []
-        /** @type {(path: string) => Promise<void>} */
-        const f = async p => {
+    const load
+        : () => Promise<UnknownMap>
+        = async () => {
+        const map
+            : (readonly[string, unknown])[]
+            = []
+        /** @type {} */
+        const f
+            : (path: string) => Promise<void>
+            = async p => {
             for (const i of await readdir(p, { withFileTypes: true })) {
                 const { name } = i
                 if (!name.startsWith('.')) {
                     const file = `${p}/${name}`
                     if (i.isDirectory()) {
                         await f(file)
-                    } else if (name.endsWith('.f.mjs') || name.endsWith('.f.js')) {
+                        continue
+                    }
+                    if (name.endsWith('.f.mjs') ||
+                        name.endsWith('.f.js') ||
+                        (name.endsWith('.f.ts') && !existsSync(file.substring(0, file.length - 3) + '.js'))
+                    ) {
+                        console.log(file)
                         const source = await import(`../${file}`)
                         map.push([file, source.default])
                     }
@@ -100,12 +102,15 @@ export const loadModuleMap = async () => {
 
     const map = await load()
 
-    /** @type {() => ModuleMap} */
-    const build = () => {
-        /** @type {MutableModuleMap} */
-        const d = {}
-        /** @type {(base: readonly string[]) => (k: string) => readonly[string, Module]} */
-        const getModule = base => k => {
+    const build
+        : () => ModuleMap
+        = () => {
+        const d
+            : MutableModuleMap
+            = {}
+        const getModule
+            : (base: readonly string[]) => (k: string) => readonly[string, Module]
+            = base => k => {
             const relativePath = k.split('/')
             const dif = relativePath.filter(v => v === '..').length
             const path = [remove_tail(base)(dif), relativePath.filter(v => !['..', '.'].includes(v))]
@@ -136,14 +141,13 @@ export const loadModuleMap = async () => {
     return build()
 }
 
-/**
- * @typedef {{
- *  readonly[k in string]: string | FolderMap
- * }} FolderMap
- */
+type FolderMap = {
+   readonly[k in string]: string | FolderMap
+}
 
-/** @type {(m: FolderMap) => (s: readonly string[]) => FolderMap } */
-const folderMapAdd = m => s => {
+const folderMapAdd
+    : (m: FolderMap) => (s: readonly string[]) => FolderMap
+    = m => s => {
     const [first, ...rest] = s
     const firstResult = m[first]
     return typeof firstResult === 'string'
@@ -158,8 +162,9 @@ const folderMapAdd = m => s => {
 
 const indent = '  '
 
-/** @type {(i: string) => (p: string) => (m: FolderMap) => readonly[string,string]} */
-const codeAdd = i => p => m => {
+const codeAdd
+    : (i: string) => (p: string) => (m: FolderMap) => readonly[string,string]
+    = i => p => m => {
     let result = ''
     let im = ''
     for (const [k, v] of Object.entries(m)) {
@@ -179,8 +184,8 @@ const codeAdd = i => p => m => {
 }
 
 export const index = async () => {
-    const jj = './jsr.json'
-    const n = '/module.f.mjs'
+    const jj = './deno.json'
+    const n = '/module.f.ts'
     const jsr_json = JSON.parse(await readFile(jj, { encoding: 'utf8' }))
     const list = Object.keys(await loadModuleMap()).filter(v => v.endsWith(n))
     const exportsA = list.filter(v => !v.startsWith('./out')).map(v => [v.replace(n, ''), `./out/${v.substring(2)}`])

package/dev/test/{module.f.mjs → module.f.ts}

@@ -1,75 +1,58 @@
-// @ts-self-types="./module.f.d.mts"
-import * as list from '../../types/list/module.f.mjs'
+import * as list from '../../types/list/module.f.ts'
 const { fold } = list
-import * as sgr from '../../text/sgr/module.f.mjs'
+import * as sgr from '../../text/sgr/module.f.ts'
 const { reset, fgGreen, fgRed, bold } = sgr.codes
-import * as Result from '../../types/result/module.f.mjs'
+import * as Result from '../../types/result/module.f.ts'
 
-/**
- * @typedef {{
- *  readonly[k in string]?: Module
- * }} DependencyMap
- */
+type DependencyMap = {
+   readonly[k in string]?: Module
+}
 
-/**
- * @typedef {{
- *  readonly default?: unknown
- * }} Module
- */
+type Module = {
+   readonly default?: unknown
+}
 
-/**
- * @typedef {{
- *  readonly[k in string]: Module
- * }} ModuleMap
- */
+type ModuleMap = {
+   readonly[k in string]: Module
+}
 
-/**
- * @template T
- * @typedef {(v: string) => (state: T) => T} Log
- */
+type Log<T> = (v: string) => (state: T) => T
 
-/**
- * @template T
- * @typedef {<R>(f: () => R) => (state: T) => readonly[R, number, T]} Measure
- */
+type Measure<T> = <R>(f: () => R) => (state: T) => readonly[R, number, T]
 
-/**
- * @template T
- * @typedef {{
- *  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
- * }} Input
- */
+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
+ }
 
-/** @type {(s: string) => boolean} */
-const isTest = s => s.endsWith('test.f.mjs') || s.endsWith('test.f.js')
+const isTest
+    : (s: string) => boolean
+    = s => s.endsWith('test.f.mjs') || s.endsWith('test.f.js') || s.endsWith('test.f.ts')
 
-/**
- * @typedef {{
- *  readonly time: number,
- *  readonly pass: number,
- *  readonly fail: number,
- * }} TestState
- */
+type TestState = {
+    readonly time: number,
+    readonly pass: number,
+    readonly fail: number,
+ }
 
-/** @type {(time: number) => (testState: TestState) => TestState} */
-const addPass = delta => ts => ({ ...ts, time: ts.time + delta, pass: ts.pass + 1 })
+const addPass
+    : (time: number) => (testState: TestState) => TestState
+    = delta => ts => ({ ...ts, time: ts.time + delta, pass: ts.pass + 1 })
 
-/** @type {(time: number) => (testState: TestState) => TestState} */
-const addFail = delta => ts => ({ ...ts, time: ts.time + delta, fail: ts.fail + 1 })
+const addFail
+    : (time: number) => (testState: TestState) => TestState
+    = delta => ts => ({ ...ts, time: ts.time + delta, fail: ts.fail + 1 })
 
-/**
- * @template T
- * @typedef {readonly[TestState, T]} FullState
- */
+type FullState<T> = readonly[TestState, T]
 
-/** @type {(a: number) => string} */
-const timeFormat = a => {
+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
@@ -79,20 +62,22 @@ const timeFormat = a => {
     return `${b}.${e} ms`
 }
 
-/** @type {<T>(input: Input<T>) => readonly[number, T]} */
-export default input => {
+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
-    /** @typedef {input extends Input<infer T> ? T : never} T */
-    /** @type {(k: readonly[string, Module]) => (fs: FullState<T>) => FullState<T>} */
-    const f = ([k, v]) => {
-        /** @type {(i: string) => (v: unknown) => (fs: FullState<T>) => FullState<T>} */
-        const test = i => v => ([ts, state]) => {
+    // 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(/** @type {() => unknown} */(v)))(state)
+                        const [[s, r], delta, state0] = measure(() => tryCatch(v as () => unknown))(state)
                         state = state0
                         if (s === 'error') {
                             ts = addFail(delta)(ts)
@@ -114,8 +99,9 @@ export default input => {
                 }
                 case 'object': {
                     if (v !== null) {
-                        /** @type {(k: readonly[string|number, unknown]) => (fs: FullState<T>) => FullState<T>} */
-                        const f = ([k, v]) => ([time, state]) => {
+                        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]
@@ -138,8 +124,9 @@ export default input => {
             return [ts, state]
         }
     }
-    /** @type {TestState} */
-    let ts = { time: 0, pass: 0, fail: 0 };
+    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)

package/dev/{test.f.mjs → test.f.ts}

@@ -1,8 +1,10 @@
-/** @type {() => never} */
-const assert = () => { throw 'assert' }
+const assert
+    : () => never
+    = () => { throw 'assert' }
 
-/** @type {(_: boolean) => void} */
-const assert_if = c => { if (c) { throw 'assert_if' } }
+const assert_if
+    : (_: boolean) => void
+    = c => { if (c) { throw 'assert_if' } }
 
 export default {
     ctor: () => {
@@ -53,4 +55,4 @@ export default {
         const c = Object.getOwnPropertyDescriptor(x, 'constructor')
         const a = Object.getOwnPropertyDescriptor(x, 'a')
     }
-}
+}

package/dev/test.ts

@@ -0,0 +1,53 @@
+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/{module.f.mjs → module.f.ts}

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