functionalscript 0.2.6 → 0.3.0

package/commonjs/build/{test.f.mjs → test.f.ts}

@@ -1,14 +1,15 @@
-import * as _ from './module.f.mjs'
-import * as map from '../../types/map/module.f.mjs'
-import * as Module from '../module/module.f.mjs'
-import * as ModuleFunction from '../module/function/module.f.mjs'
-import * as Result from '../../types/result/module.f.mjs'
-import * as Package from '../package/module.f.mjs'
-import * as o from '../../types/object/module.f.mjs'
+import * as _ from './module.f.ts'
+import * as map from '../../types/map/module.f.ts'
+import * as Module from '../module/module.f.ts'
+import * as ModuleFunction from '../module/function/module.f.ts'
+import * as Result from '../../types/result/module.f.ts'
+import * as Package from '../package/module.f.ts'
+import * as o from '../../types/object/module.f.ts'
 const { at } = o
 
-/** @type {{ readonly [k in string]?: Result.Result<ModuleFunction.Function_, unknown> }} */
-const compileMap = {
+const compileMap
+    : { readonly [k in string]?: Result.Result<ModuleFunction.Function_, unknown> }
+    = {
     ':index.js': [
         'ok',
         require_ => m0 => {
@@ -31,13 +32,15 @@ const compileMap = {
         () => m0 => [['ok', 'x:r.js'], m0]],
 }
 
-/** @type {ModuleFunction.Compile} */
-const compile = source => compileMap[source] ?? ['error', 'invalid source']
+const compile
+    : ModuleFunction.Compile
+    = source => compileMap[source] ?? ['error', 'invalid source']
 
-/** @typedef {{ readonly [k in string]: string }} StringMap */
+type StringMap = { readonly [k in string]: string }
 
-/** @type {{ readonly [k in string]: { readonly dependencies: StringMap, readonly files: StringMap }}} */
-const packageMap = {
+const packageMap
+    : { readonly [k in string]: { readonly dependencies: StringMap, readonly files: StringMap }}
+    = {
     '': {
         dependencies: {
             'x': '/node_modules/x'
@@ -56,8 +59,9 @@ const packageMap = {
     },
 }
 
-/** @type {Package.Get} */
-const packageGet = packageId => {
+const packageGet
+    : Package.Get
+    = packageId => {
     const p = at(packageId)(packageMap)
     return p === null ? null :
         {
@@ -69,7 +73,7 @@ const packageGet = packageId => {
 const getOrBuild = _.getOrBuild
     (compile)
     (packageGet)
-    (/** @type {Module.MapInterface<map.Map<Module.State>>} */(map))
+    (map as Module.MapInterface<map.Map<Module.State>>)
 
 export default () => {
     let [r, m] = getOrBuild({ package: '', path: ['index.js'] })(map.empty)

package/commonjs/module/function/module.f.ts

@@ -0,0 +1,13 @@
+/**
+ * An IO interface for creating and running module functions.
+ */
+
+import * as TypesResult from '../../../types/result/module.f.ts'
+
+export type Function_ = <M>(require: Require<M>) => (prior: M) => Result<M>
+
+export type Result<M> = readonly[TypesResult.Result<unknown, unknown>, M]
+
+export type Require<M> = (path: string) => (prior: M) => Result<M>
+
+export type Compile = (source: string) => TypesResult.Result<Function_, unknown>

package/commonjs/module/module.f.ts

@@ -0,0 +1,41 @@
+import * as O from '../../types/object/module.f.ts'
+
+export type MapInterface<M> = {
+    readonly at: (moduleId: string) => (moduleMap: M) => State | null
+    readonly setReplace: (moduleId: string) => (moduleState: State) => (moduleMap: M) => M
+}
+
+export type State = |
+    readonly['ok', Module] |
+    readonly['error', Error]
+
+type Module = {
+    readonly exports: unknown
+    readonly requireMap: O.Map<string>
+}
+
+export type Error = |
+    ['file not found'] |
+    ['compilation error', unknown] |
+    ['runtime error', unknown] |
+    ['circular reference']
+
+export type Id = {
+    readonly package: string
+    readonly path: readonly string[]
+}
+
+export const dir
+    : (id: Id) => Id | null
+    = id => {
+    const len = id.path.length
+    if (len < 1) { return null }
+    return {
+        package: id.package,
+        path: id.path.slice(0, len - 1)
+    }
+}
+
+export const idToString
+    : (id: Id) => string
+    = id => `${id.package}/${id.path.join('/')}`

package/commonjs/module.f.ts

@@ -0,0 +1,7 @@
+type PackageMap = (packageName: string) => PackageMap|Package|null
+
+type Package = readonly[
+    string,
+    PackageMap,
+    (fileName: string) => string|null
+]

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

@@ -1,13 +1,15 @@
-import unsafeResult from '../types/result/module.mjs'
+import unsafeResult from '../types/result/module.ts'
 const { tryCatch } = unsafeResult
-import * as result from '../types/result/module.f.mjs'
+import * as result from '../types/result/module.f.ts'
 const { unwrap } = result
-import * as ModuleFunction from './module/function/module.f.mjs'
+import * as ModuleFunction from './module/function/module.f.ts'
 
-/** @type {(f: Function) => ModuleFunction.Function_} */
-const build = f => immutableRequire => mutableData => {
-    /** @type {(path: string) => unknown} */
-    const mutableRequire = path => {
+const build
+    : (f: Function) => ModuleFunction.Function_
+    = f => immutableRequire => mutableData => {
+    const mutableRequire
+        : (path: string) => unknown
+        = path => {
         const [result, data] = immutableRequire(path)(mutableData)
         // Side effect: setting a variable from a nested function (closure)
         // is not allowed in FunctionalScript.
@@ -22,7 +24,8 @@ const build = f => immutableRequire => mutableData => {
     return [result, mutableData]
 }
 
-/** @type {ModuleFunction.Compile} */
-export const compile = source =>
+export const compile
+    : ModuleFunction.Compile
+    = source =>
     // Side effect: a `Function` constructor is not allowed in FunctionalScript.
     tryCatch(() => build(Function('module', 'require', `"use strict";${source}`)))

package/commonjs/package/dependencies/module.f.ts

@@ -0,0 +1,22 @@
+import * as json from '../../../json/module.f.ts'
+const { isObject } = json
+import * as list from '../../../types/list/module.f.ts'
+const { map, every } = list
+const { entries } = Object
+
+type DependencyJson = readonly[string, string]
+
+type DependencyMapJson = {readonly[k in string]: string}
+
+export type DependenciesJson = DependencyMapJson|null
+
+const isDependencyJson
+    : (entry: json.Entry) => boolean
+    = ([, v]) => typeof v === 'string'
+
+export const isDependenciesJson
+    = (j: json.Unknown): j is DependenciesJson => {
+    if (j === null) { return true }
+    if (!isObject(j)) { return false }
+    return every(map(isDependencyJson)(entries(j)))
+}

package/commonjs/package/dependencies/{test.f.mjs → test.f.ts}

@@ -1,4 +1,4 @@
-import * as _ from './module.f.mjs'
+import * as _ from './module.f.ts'
 
 export default () => {
     if (!_.isDependenciesJson(null)) { throw 'error' }

package/commonjs/package/module.f.ts

@@ -0,0 +1,31 @@
+import * as json from '../../json/module.f.ts'
+const { isObject } = json
+import * as dependencies from './dependencies/module.f.ts'
+const { isDependenciesJson } = dependencies
+import * as o from '../../types/object/module.f.ts'
+const { at } = o
+
+type PackageJson = {
+    readonly name: string
+    readonly version: string
+    readonly dependencies?: dependencies.DependenciesJson
+}
+
+export const isPackageJson
+    = (j: json.Unknown): j is PackageJson => {
+    if (!isObject(j)) { return false }
+    if (typeof j.name !== 'string') { return false }
+    if (typeof j.version !== 'string') { return false }
+    if (!isDependenciesJson(at('dependencies')(j))) { return false }
+    return true
+}
+
+export type Package = {
+    readonly dependency: (localPackageId: string) => string | null
+    readonly file: (localFileId: string) => string | null
+ }
+
+/**
+ * @note Current package has an empty string '' as a packageId.
+ */
+export type Get = (packageId: string) => Package | null

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

@@ -1,4 +1,4 @@
-import * as _ from './module.f.mjs'
+import * as _ from './module.f.ts'
 
 export default () => {
     if (_.isPackageJson(null)) { throw 'error' }

package/commonjs/path/{module.f.mjs → module.f.ts}

@@ -1,28 +1,27 @@
-// @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 { next, fold, reverse, first, flat, toArray, filterMap, isEmpty, concat } = list
-import * as string from '../../types/string/module.f.mjs'
+import * as string from '../../types/string/module.f.ts'
 const { join } = string
-import * as Package from '../package/module.f.mjs'
-import * as Module from '../module/module.f.mjs'
+import * as Package from '../package/module.f.ts'
+import * as Module from '../module/module.f.ts'
 
-/** @typedef {readonly string[]} Items */
+type Items = readonly string[]
 
-/**
- * @typedef {{
- *  readonly external: boolean
- *  readonly dir: boolean
- *  readonly items: Items
- * }} LocalPath
- */
+type LocalPath = {
+    readonly external: boolean
+    readonly dir: boolean
+    readonly items: Items
+}
 
-/** @type {(path: string) => readonly string[]} */
-const split = path => path.split('/')
+const split
+    : (path: string) => readonly string[]
+    = path => path.split('/')
 
-/** @typedef {readonly[list.List<string>] | null} OptionList */
+type OptionList = readonly[list.List<string>] | null
 
-/** @type {(items: string) => (prior: OptionList) => OptionList} */
-const normItemsOp = first => prior => {
+const normItemsOp
+    : (items: string) => (prior: OptionList) => OptionList
+    = first => prior => {
     if (prior === null) { return null }
     const tail = prior[0]
     switch (first) {
@@ -38,21 +37,24 @@ const normItemsOp = first => prior => {
     }
 }
 
-/** @type {(items: list.List<string>) => OptionList} */
-const normItems = items => {
+const normItems
+    : (items: list.List<string>) => OptionList
+    = items => {
     const result = fold(normItemsOp)([list.empty])(items)
     return result === null ? result : [reverse(result[0])]
 }
 
 const firstNull = first(null)
 
-/** @type {(local: string) => (path: string) => LocalPath|null} */
-export const parseLocal = local => {
-    /** @type {(path: string) => readonly[boolean, boolean, list.List<string>]} */
-    const fSeq = path => {
+export const parseLocal
+    : (local: string) => (path: string) => LocalPath|null
+    = local => {
+    const fSeq
+        : (path: string) => readonly[boolean, boolean, list.List<string>]
+        = path => {
         const pathSeq = split(path)
         const dir = [null, '', '.', '..'].includes(pathSeq[pathSeq.length - 1])
-        return /** @type {readonly (string|null)[]} */(['.', '..']).includes(firstNull(pathSeq)) ?
+        return (['.', '..'] as readonly (string|null)[]).includes(firstNull(pathSeq)) ?
             [false, dir, flat([split(local), pathSeq])] :
             [true, dir, pathSeq]
     }
@@ -69,40 +71,44 @@ export const parseLocal = local => {
     }
 }
 
-/** @typedef {readonly[string, list.List<string>]} IdPath */
+type IdPath = readonly[string, list.List<string>]
 
-/** @type {(prior: readonly[string|null, list.List<string>]) => list.Thunk<IdPath>} */
-const variants = prior => () => {
+/** @type {} */
+const variants
+    : (prior: readonly[string|null, list.List<string>]) => list.Thunk<IdPath>
+    = prior => () => {
     const [a, b] = prior
     const r = next(b)
     if (r === list.empty) { return list.empty }
     const { first, tail } = r
-    /** @type {IdPath} */
-    const n = [a === null ? first : `${a}/${first}`, tail]
+    const n
+        : IdPath
+        = [a === null ? first : `${a}/${first}`, tail]
     return { first: n, tail: variants(n) }
 }
 
-/** @type {(d: (local: string) => string|null) => (p: IdPath) => IdPath|null} */
-const mapDependency = d => ([external, internal]) => {
+const mapDependency
+    : (d: (local: string) => string|null) => (p: IdPath) => IdPath|null
+    = d => ([external, internal]) => {
     const id = d(external)
     return id === null ? null : [id, internal]
 }
 
-/**
- * @typedef {{
- *  readonly package: string,
- *  readonly items: Items,
- *  readonly dir: boolean,
- * }} Path
- */
+type Path = {
+    readonly package: string,
+    readonly items: Items,
+    readonly dir: boolean,
+}
 
 /**
- * @type {(d: (local: string) => string|null) =>
- *  (dir: boolean) =>
- *  (items: list.List<string>) =>
- *  Path|null}
+ * @type {}
  */
-export const parseGlobal = dependencies =>
+export const parseGlobal
+    :   (d: (local: string) => string|null) =>
+        (dir: boolean) =>
+        (items: list.List<string>) =>
+        Path|null
+    = dependencies =>
 {
     const fMap = filterMap(mapDependency(dependencies))
     return dir => items => {
@@ -114,13 +120,15 @@ export const parseGlobal = dependencies =>
 }
 
 /**
- * @type {(packageId: string) =>
- *  (dependencies: (local: string) => string|null) =>
- *  (local: string) =>
- *  (path: string) =>
- *  Path|null }
+ * @type { }
  */
-export const parse = packageId => dependencies => {
+export const parse
+    :   (packageId: string) =>
+        (dependencies: (local: string) => string|null) =>
+        (local: string) =>
+        (path: string) =>
+        Path|null
+    = packageId => dependencies => {
     const pg = parseGlobal(dependencies)
     return local => path => {
         const parsed = parseLocal(local)(path)
@@ -131,31 +139,28 @@ export const parse = packageId => dependencies => {
     }
 }
 
-/**
- * @typedef {{
- *  readonly id: Module.Id
- *  readonly source: string
- * }} FoundResult
- */
+type FoundResult = {
+    readonly id: Module.Id
+    readonly source: string
+}
 
-/** @typedef {FoundResult| null} Result */
+type Result = FoundResult| null
 
-/**
- * @type {(packageGet: Package.Get) =>
- *  (moduleId: Module.Id) =>
- *  (path: string) =>
- *  Result
- * }
- */
-export const parseAndFind = packageGet => moduleId => path => {
+export const parseAndFind
+    :   (packageGet: Package.Get) =>
+        (moduleId: Module.Id) =>
+        (path: string) =>
+        Result
+    = packageGet => moduleId => path => {
     const currentPack = packageGet(moduleId.package)
     if (currentPack === null) { return null }
     const p = parse(moduleId.package)(currentPack.dependency)(moduleId.path.join('/'))(path)
     if (p === null) { return null }
     const pack = packageGet(p.package)
     if (pack === null) { return null }
-    /** @type {(file: string) => FoundResult | null } */
-    const tryFile = file => {
+    const tryFile
+        : (file: string) => FoundResult | null
+        = file => {
         const source = pack.file(file)
         return source === null ? null : { id: { package: p.package, path: file.split('/') }, source }
     }

package/commonjs/path/{test.f.mjs → test.f.ts}

@@ -1,18 +1,20 @@
-import * as _ from './module.f.mjs'
-import * as dev from '../../dev/module.f.mjs'
+import * as _ from './module.f.ts'
+import * as dev from '../../dev/module.f.ts'
 const { todo } = dev
-import * as json from '../../json/module.f.mjs'
-import * as f from '../../types/function/module.f.mjs'
+import * as json from '../../json/module.f.ts'
+import * as f from '../../types/function/module.f.ts'
 const { identity } = f
-import * as object from '../../types/object/module.f.mjs'
+import * as object from '../../types/object/module.f.ts'
 const { at } = object
-import * as Package from '../package/module.f.mjs'
+import * as Package from '../package/module.f.ts'
 
-/** @type {<T>(o: object.Map<T>) => (s: string) => T|null} */
-const i = o => s => at(s)(o)
+const i
+    : <T>(o: object.Map<T>) => (s: string) => T|null
+    = o => s => at(s)(o)
 
-/** @type {(g: json.Unknown) => string} */
-const stringify = json.stringify(identity)
+const stringify
+    : (g: json.Unknown) => string
+    = json.stringify(identity)
 
 export default {
     0: () => {
@@ -70,8 +72,9 @@ export default {
         },
     },
     9: () => {
-        /** @type {object.Map<Package.Package>} */
-        const packages = {
+        const packages
+            : object.Map<Package.Package>
+            = {
             '': {
                 dependency: () => todo(),
                 file: i({ 'a/c': 'return "a/c"' }),
@@ -81,8 +84,9 @@ export default {
         if (result !== '{"id":{"package":"","path":["a","c"]},"source":"return \\"a/c\\""}') { throw result }
     },
     10: () => {
-        /** @type {object.Map<Package.Package>} */
-        const packages = {
+        const packages
+            : object.Map<Package.Package>
+            = {
             '': {
                 dependency: x => {
                     const path = `node_modules/${x}`
@@ -131,8 +135,9 @@ export default {
         }
     },
     11: () => {
-        /** @type {object.Map<Package.Package>} */
-        const packages = {
+        const packages
+        : object.Map<Package.Package>
+        = {
             '': {
                 dependency: x => {
                     const path = `node_modules/${x}`
@@ -158,8 +163,9 @@ export default {
         }
     },
     12: () => {
-        /** @type {object.Map<Package.Package>} */
-        const packages = {
+        const packages
+        : object.Map<Package.Package>
+        = {
             '': {
                 dependency: x => {
                     const path = `node_modules/${x}`
@@ -179,4 +185,4 @@ export default {
         const result = stringify(_.parseAndFind(i(packages))({ package: '', path: ['a', 'b'] })('z/a/c'))
         if (result !== '{"id":{"package":"node_modules/z/a/c","path":["index.js"]},"source":"return \\"a/c\\""}') { throw result }
     }
-}
+}

package/commonjs/{test.mjs → test.ts}

@@ -1,5 +1,5 @@
-import * as _ from './module.mjs'
-import * as Run from './module/function/module.f.mjs'
+import * as _ from './module.ts'
+import * as Run from './module/function/module.f.ts'
 
 export default {
     ok: () => {
@@ -32,8 +32,9 @@ export default {
         const d = _.compile(depSource)
         if (d[0] !== 'ok') { throw d }
 
-        /** @type {Run.Require<number>} */
-        const req = path => prior => {
+        const req
+            : Run.Require<number>
+            = path => prior => {
             if (path !== 'm') { throw path }
             return d[1](req)(prior + 1)
         }

package/crypto/prime_field/{module.f.mjs → module.f.ts}

@@ -1,50 +1,51 @@
-// @ts-self-types="./module.f.d.mts"
-import * as Operator from '../../types/function/operator/module.f.mjs'
-import * as bi from '../../types/bigint/module.f.mjs'
+import * as Operator from '../../types/function/operator/module.f.ts'
+import * as bi from '../../types/bigint/module.f.ts'
 const { scalar_mul } = bi
 
-/** @typedef {Operator.Reduce<bigint>} Reduce */
+type Reduce = Operator.Reduce<bigint>
 
-/** @typedef {Operator.Unary<bigint, bigint>} Unary*/
+type Unary = Operator.Unary<bigint, bigint>
 
 /**
  * A type representing a prime field and its associated operations.
- *
- * @typedef {{
- *  readonly p: bigint
- *  readonly middle: bigint
- *  readonly max: bigint
- *  readonly neg: Unary
- *  readonly sub: Reduce
- *  readonly add: Reduce
- *  readonly abs: Unary
- *  readonly mul: Reduce
- *  readonly reciprocal: Unary
- *  readonly div: Reduce
- *  readonly pow: Reduce
- *  readonly pow2: Unary
- *  readonly pow3: Unary
- * }} PrimeField
  */
+export type PrimeField = {
+    readonly p: bigint
+    readonly middle: bigint
+    readonly max: bigint
+    readonly neg: Unary
+    readonly sub: Reduce
+    readonly add: Reduce
+    readonly abs: Unary
+    readonly mul: Reduce
+    readonly reciprocal: Unary
+    readonly div: Reduce
+    readonly pow: Reduce
+    readonly pow2: Unary
+    readonly pow3: Unary
+}
 
 /**
  * Creates a prime field with the specified prime modulus and associated operations.
  *
  * @param p - A prime number to define the field.
  * @returns The prime field object.
- *
- * @type {(p: bigint) => PrimeField}
  */
-export const prime_field = p => {
-    /** @type {Reduce} */
-    const sub = a => b => {
+export const prime_field
+    : (p: bigint) => PrimeField
+    = p => {
+    const sub
+        : Reduce
+        = a => b => {
         const r = a - b
         return r < 0 ? r + p : r
     }
-    /** @type {Reduce} */
-    const mul = a => b => a * b % p
-    /** @type {Unary} */
-    const reciprocal = a => {
+    const mul
+        : Reduce
+        = a => b => a * b % p
+    const reciprocal
+        : Unary
+        = a => {
         if (a === 0n) { throw '1/0' }
         let a1 = a
         let a0 = p
@@ -62,10 +63,12 @@ export const prime_field = p => {
         return f1
     }
     const middle = p >> 1n
-    /** @type {Unary} */
-    const pow2 = a => mul(a)(a)
-    /** @type {Reduce} */
-    const pow = scalar_mul({ 0: 1n, add: mul })
+    const pow2
+        : Unary
+        = a => mul(a)(a)
+    const pow
+        : Reduce
+        = scalar_mul({ 0: 1n, add: mul })
     return {
         p,
         middle,
@@ -98,10 +101,10 @@ export const prime_field = p => {
  * const root = sqrt(field)(4n);
  * if (root !== 2n) { throw root }
  * ```
- *
- * @type {(f: PrimeField) => (a: bigint) => bigint|null}
  */
-export const sqrt = ({p, mul, pow }) => {
+export const sqrt
+    : (f: PrimeField) => (a: bigint) => bigint|null
+    = ({p, mul, pow }) => {
     if ((p & 3n) !== 3n) { throw 'sqrt' }
     const sqrt_k = (p + 1n) >> 2n
     return a => {