functionalscript 0.0.592 → 0.1.594

package/.github/workflows/ci.yml

@@ -34,14 +34,14 @@ jobs:
 
     strategy:
       matrix:
-        deno-version: [2]
+        deno-version: [1, 2]
 
     steps:
     - uses: actions/checkout@v2
     - uses: denoland/setup-deno@v1
       with:
         deno-version: ${{ matrix.deno-version }}
-    - run: deno run --quiet --allow-read --allow-env --allow-net --allow-hrtime ./dev/test.mjs
+    - run: deno run --quiet --allow-read --allow-env --allow-net ./dev/test.mjs
 
   bun:
 
@@ -64,7 +64,7 @@ jobs:
     - uses: actions/checkout@v3
     - uses: actions/setup-node@v2
       with:
-        node-version: 22
+        node-version: 23
     - uses: actions/setup-dotnet@v3
       with:
         dotnet-version: 9

package/README.md

@@ -1,6 +1,7 @@
 # FunctionalScript
 
 [![NPM Version](https://img.shields.io/npm/v/functionalscript)](https://www.npmjs.com/package/functionalscript)
+[![JSR Version](https://img.shields.io/jsr/v/%40functionalscript/functionalscript)](https://jsr.io/@functionalscript/functionalscript)
 
 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

package/com/cpp/{module.f.cjs → module.f.mjs}

@@ -1,13 +1,14 @@
-const types = require('../types/module.f.cjs')
+import types, * as typesT from '../types/module.f.mjs'
+import text, * as textT from '../../text/module.f.mjs'
+import obj, * as O from '../../types/object/module.f.mjs'
+import list from '../../types/list/module.f.mjs'
+import string from '../../types/string/module.f.mjs'
+const { join } = string
 const { paramList } = types
-const text = require('../../text/module.f.cjs')
-const obj = require('../../types/object/module.f.cjs')
-const list = require('../../types/list/module.f.cjs')
 const { map, flatMap, flat } = list
-const { join } = require('../../types/string/module.f.cjs')
 const { entries } = Object
 
-/** @type {(name: string) => (body: text.Block) => text.Block} */
+/** @type {(name: string) => (body: textT.Block) => textT.Block} */
 const struct = name => body => [`struct ${name}`, '{', body, '};']
 
 const baseTypeMap = {
@@ -26,7 +27,7 @@ const baseTypeMap = {
     bool: 'bool',
 }
 
-/** @type {(t: types.BaseType) => string} */
+/** @type {(t: typesT.BaseType) => string} */
 const baseType = t => baseTypeMap[t]
 
 const resultVoid = types.result('void')
@@ -42,17 +43,17 @@ const ptr = id => `${id} const*`
 /** @type {(id: string) => string} */
 const ref = id => `${id} const&`
 
-/** @type {(p: types.Field) => string} */
+/** @type {(p: typesT.Field) => string} */
 const paramName = ([name]) => name
 
 const mapParamName = map(paramName)
 
 const joinComma = join(', ')
 
-/** @type {(name: string) => (lib: types.Library) => text.Block} */
+/** @type {(name: string) => (lib: typesT.Library) => textT.Block} */
 const cpp = name => lib => {
 
-    /** @type {(t: types.Type) => string|null} */
+    /** @type {(t: typesT.Type) => string|null} */
     const interface_ = t => {
         if (!(t instanceof Array) || t.length !== 1) {
             return null
@@ -61,7 +62,7 @@ const cpp = name => lib => {
         return 'interface' in lib[name] ? name : null
     }
 
-    /** @type {(i: (t: string) => string) => (t: types.Type) => string} */
+    /** @type {(i: (t: string) => string) => (t: typesT.Type) => string} */
     const objectType = i => t => {
         if (typeof (t) === 'string') { return baseType(t) }
         if (t.length === 2) { return `${type(t[1])} const*` }
@@ -73,27 +74,27 @@ const cpp = name => lib => {
 
     const resultType = objectType(ptr)
 
-    /** @type {(s: types.Field) => text.Item} */
+    /** @type {(s: typesT.Field) => textT.Item} */
     const field = ([name, t]) => `${type(t)} ${name};`
 
     const mapField = map(field)
 
-    /** @type {(s: types.Struct) => text.Block} */
+    /** @type {(s: typesT.Struct) => textT.Block} */
     const defStruct = s => mapField(entries(s.struct))
 
-    /** @type {(fa: types.FieldArray) => string} */
+    /** @type {(fa: typesT.FieldArray) => string} */
     const cppResult = resultVoid(resultType)
 
-    /** @type {(p: types.Field) => string} */
+    /** @type {(p: typesT.Field) => string} */
     const param = ([name, t]) => `${objectType(ref)(t)} ${name}`
 
     const mapParam = map(param)
 
-    /** @type {(result: string) => (paramArrayStr: string) => (name: string) => text.Item} */
+    /** @type {(result: string) => (paramArrayStr: string) => (name: string) => textT.Item} */
     const methodHeader = result => paramArrayStr => name =>
         `virtual ${result} ${name}${paramArrayStr} const noexcept = 0;`
 
-    /** @type {(m: types.Method) => readonly text.Item[]} */
+    /** @type {(m: typesT.Method) => readonly textT.Item[]} */
     const method = ([name, paramArray]) => {
         const result = cppResult(paramArray)
         const paramL = paramList(paramArray)
@@ -114,7 +115,7 @@ const cpp = name => lib => {
 
     const mapMethod = flatMap(method)
 
-    /** @type {(i: types.Interface) => text.Block} */
+    /** @type {(i: typesT.Interface) => textT.Block} */
     const defInterface = ({ guid, interface: i }) => {
         const g = guid.replaceAll('-', '');
         const lo = g.substring(0, 16);
@@ -125,7 +126,7 @@ const cpp = name => lib => {
         ])
     }
 
-    /** @type {(kv: obj.Entry<types.Definition>) => text.Block} */
+    /** @type {(kv: O.Entry<typesT.Definition>) => textT.Block} */
     const def = ([name, d]) => 'interface' in d
         ? [
             `class ${name} : public ::nanocom::IUnknown`,
@@ -136,7 +137,7 @@ const cpp = name => lib => {
         ]
         : struct(name)(defStruct(d))
 
-    /** @type {(kv: obj.Entry<types.Definition>) => text.Block} */
+    /** @type {(kv: O.Entry<typesT.Definition>) => textT.Block} */
     const forward = ([name]) => [`struct ${name};`]
 
     const e = entries(lib)
@@ -147,7 +148,7 @@ const cpp = name => lib => {
     ])
 }
 
-module.exports = {
+export default {
     /** @readonly */
     cpp,
 }

package/com/cpp/{test.f.cjs → test.f.mjs}

@@ -1,4 +1,4 @@
-const cpp = require('./testlib.f.cjs')
+import cpp from './testlib.f.mjs'
 
 const f = () =>
 {
@@ -39,4 +39,4 @@ const f = () =>
     if (cpp() !== e) { throw cpp }
 }
 
-module.exports = f
+export default f

package/com/cpp/testlib.f.mjs

@@ -0,0 +1,9 @@
+import string from '../../types/string/module.f.mjs'
+const { join } = string
+import text from '../../text/module.f.mjs'
+const { flat } = text
+import library from '../types/testlib.f.mjs'
+import m from './module.f.mjs'
+const { cpp } = m
+
+export default () => join('\n')(flat('    ')(cpp('My')(library)))

package/com/cs/{module.f.cjs → module.f.mjs}

@@ -1,22 +1,23 @@
-const types = require('../types/module.f.cjs')
+import types, * as typesT from '../types/module.f.mjs'
 const { result, paramList } = types
-const text = require('../../text/module.f.cjs')
+import text, * as textT from '../../text/module.f.mjs'
 const { curly } = text
-const list = require('../../types/list/module.f.cjs')
+import list, * as List from '../../types/list/module.f.mjs'
 const { flat, map, some, flatMap } = list
-const { join } = require('../../types/string/module.f.cjs')
-const obj = require('../../types/object/module.f.cjs')
+import string from '../../types/string/module.f.mjs'
+const { join } = string
+import obj, * as O from '../../types/object/module.f.mjs'
 const { entries } = Object
 
 /** @type {(v: string) => string} */
 const using = v => `using ${v};`
 
 /**
- * @type {(attributes: list.List<string>) =>
+ * @type {(attributes: List.List<string>) =>
  *  (type: string) =>
  *  (name: string) =>
- *  (body: text.Block) =>
- *  list.List<text.Item>}
+ *  (body: textT.Block) =>
+ *  List.List<textT.Item>}
  */
 const typeDef = attributes => type => name => body =>
     flat([
@@ -40,33 +41,33 @@ const baseTypeMap = {
     usize: 'UIntPtr',
 }
 
-/** @type {(t: types.BaseType) => string} */
+/** @type {(t: typesT.BaseType) => string} */
 const baseType = t => baseTypeMap[t]
 
 /** @type {(isUnsafe: boolean) => string} */
 const unsafe = isUnsafe => isUnsafe ? 'unsafe ' : ''
 
-/** @type {(t: types.Type) => readonly[boolean, string]} */
+/** @type {(t: typesT.Type) => readonly[boolean, string]} */
 const fullType = t =>
     typeof (t) === 'string' ? [false, baseType(t)] :
         t.length === 1 ? [false, t[0]] :
             [true, `${type(t[1])}*`]
 
-/** @type {(m: types.Type) => string} */
+/** @type {(m: typesT.Type) => string} */
 const type = t => fullType(t)[1]
 
-/** @type {(f: types.Field) => string} */
+/** @type {(f: typesT.Field) => string} */
 const param = ([name, t]) => `${type(t)} ${name}`
 
 const mapParam = map(param)
 
-/** @type {(f: types.Field) => string} */
+/** @type {(f: typesT.Field) => string} */
 const field = ([name, comType]) => {
     const [isUnsafe, t] = fullType(comType)
     return `public ${unsafe(isUnsafe)}${t} ${name};`
 }
 
-/** @type {(field: types.Field) => boolean} */
+/** @type {(field: typesT.Field) => boolean} */
 const isUnsafeField = field => fullType(field[1])[0]
 
 const mapIsUnsafeField = map(isUnsafeField)
@@ -75,7 +76,7 @@ const resultVoid = result('void')
 
 const joinComma = join(', ')
 
-/** @type {(e: obj.Entry<types.FieldArray>) => readonly string[]} */
+/** @type {(e: O.Entry<typesT.FieldArray>) => readonly string[]} */
 const method = ([name, m]) => {
     const paramAndResultList = entries(m)
     const pl = paramList(m)
@@ -94,7 +95,7 @@ const mapField = map(field)
 
 const flatMapMethod = flatMap(method)
 
-/** @type {(e: obj.Entry<types.Definition>) => list.List<text.Item>} */
+/** @type {(e: O.Entry<typesT.Definition>) => List.List<textT.Item>} */
 const def = ([n, d]) => {
     return !('interface' in d) ?
         struct(n)(mapField(entries(d.struct))) :
@@ -109,21 +110,21 @@ const flatMapDef = flatMap(def)
 
 const namespace = curly('namespace')
 
-/** @type {text.Block} */
+/** @type {textT.Block} */
 const header = [
     using('System'),
     using('System.Runtime.InteropServices'),
     ''
 ]
 
-/** @type {(name: string) => (library: types.Library) => text.Block} */
+/** @type {(name: string) => (library: typesT.Library) => textT.Block} */
 const cs = name => library => {
     const v = flatMapDef(entries(library))
     const ns = namespace(name)(v)
     return flat([header, ns])
 }
 
-module.exports = {
+export default {
     /** @readonly */
     cs,
 }

package/com/cs/{test.f.cjs → test.f.mjs}

@@ -1,4 +1,4 @@
-const cs = require('./testlib.f.cjs')
+import cs from './testlib.f.mjs'
 
 const f = () =>
 {
@@ -42,4 +42,4 @@ const f = () =>
     if (cs !== e) { throw cs }
 }
 
-module.exports = f
+export default f

package/com/cs/testlib.f.mjs

@@ -0,0 +1,10 @@
+import text from '../../text/module.f.mjs'
+const { flat } = text
+import string from '../../types/string/module.f.mjs'
+const { join } = string
+import x from './module.f.mjs'
+import library from '../types/testlib.f.mjs'
+
+const { cs } = x
+
+export default join('\n')(flat('    ')(cs('My')(library)))

package/com/rust/{module.f.cjs → module.f.mjs}

@@ -1,19 +1,21 @@
-const types = require('../types/module.f.cjs')
+import types, * as typesT from '../types/module.f.mjs'
 const { paramList } = types
-const text = require('../../text/module.f.cjs')
-const object = require('../../types/object/module.f.cjs')
-const list = require('../../types/list/module.f.cjs')
-const { flat, map, flatMap, isEmpty } = list
+import text, * as textT from '../../text/module.f.mjs'
+import object, * as O from '../../types/object/module.f.mjs'
+import list, * as List from '../../types/list/module.f.mjs'
+const { flat, map, flatMap } = list
 const { entries } = Object
-const { fn } = require('../../types/function/module.f.cjs')
-const { join } = require('../../types/string/module.f.cjs')
+import func from '../../types/function/module.f.mjs'
+const { fn } = func
+import string from '../../types/string/module.f.mjs'
+const { join } = string
 
 /** @type {(field: string) => string} */
 const rustField = field => `pub ${field},`
 
 const mapRustField = map(rustField)
 
-/** @type {(b: list.Thunk<string>) => (name: string) => text.Block} */
+/** @type {(b: List.Thunk<string>) => (name: string) => textT.Block} */
 const rustStruct = b => name => [`#[repr(C)]`, `pub struct ${name} {`, mapRustField(b), `}`]
 
 const commaJoin = join(', ')
@@ -26,21 +28,21 @@ const obj = name => `&${name}::Object`
 
 const self = ['&self']
 
-/** @type {(p: types.Field) => string} */
+/** @type {(p: typesT.Field) => string} */
 const paramName = ([n]) => n
 
-/** @type {(p: types.FieldArray) => list.Thunk<string>} */
+/** @type {(p: typesT.FieldArray) => List.Thunk<string>} */
 const callList = p => map(paramName)(paramList(p))
 
-/** @type {(p: types.FieldArray) => string} */
+/** @type {(p: typesT.FieldArray) => string} */
 const call = p => commaJoin(callList(p))
 
-/** @type {(p: types.FieldArray) => string} */
+/** @type {(p: typesT.FieldArray) => string} */
 const virtualCall = p => commaJoin(flat([['self'], callList(p)]))
 
 const super_ = 'super::'
 
-/** @type {(m: types.Method) => string} */
+/** @type {(m: typesT.Method) => string} */
 const assign = ([n]) => `${n}: Self::${n},`
 
 const mapAssign = map(assign)
@@ -58,10 +60,10 @@ const rustType = n => `pub type ${n} = nanocom::${n}<Interface>;`
 /** @typedef {{readonly where: readonly string[]}} Where */
 
 /**
- * @typedef {OptionalProperty<Where> & {readonly content: text.Block}} WhereContent
+ * @typedef {OptionalProperty<Where> & {readonly content: textT.Block}} WhereContent
  */
 
-/** @type {(h: string) => (wh: WhereContent) => text.Block} */
+/** @type {(h: string) => (wh: WhereContent) => textT.Block} */
 const whereContent = h => wh => {
     const w = 'where' in wh ? [
         h,
@@ -82,11 +84,11 @@ const whereContent = h => wh => {
  *  readonly trait: string
  *  readonly type: string
  *  readonly where?: readonly string[]
- *  readonly content: text.Block
+ *  readonly content: textT.Block
  * }} Impl
  */
 
-/** @type {(impl: Impl) => text.Block} */
+/** @type {(impl: Impl) => textT.Block} */
 const rustImpl = i => {
     const p = 'param' in i ? `<${i.param}>` : ''
     const header = `impl${p} ${i.trait} for ${i.type}`
@@ -98,7 +100,7 @@ const rustImpl = i => {
  *  readonly pub?: true
  *  readonly type: string
  *  readonly where?: readonly string[]
- *  readonly content: text.Block
+ *  readonly content: textT.Block
  * }} Trait
  */
 
@@ -107,14 +109,14 @@ const comma = s => `${s},`
 
 const mapComma = map(comma)
 
-/** @type {(t: Trait) => text.Block} */
+/** @type {(t: Trait) => textT.Block} */
 const trait = t => {
     const p = t.pub === true ? 'pub ' : ''
     const h = `${p}trait ${t.type}`
     return whereContent(h)(t)
 }
 
-/** @type {(t: Trait) => text.Block} */
+/** @type {(t: Trait) => textT.Block} */
 const traitImpl = t => {
     const i = rustImpl({
         param: 'T',
@@ -128,12 +130,12 @@ const traitImpl = t => {
 
 const where = ['Self: nanocom::Class<Interface = Interface>', 'nanocom::CObject<Self>: Ex']
 
-/** @type {(library: types.Library) => text.Block} */
+/** @type {(library: typesT.Library) => textT.Block} */
 const rust = library => {
 
-    /** @type {(p: string) => (o: (_: string) => string) => (t: types.Type) => string} */
+    /** @type {(p: string) => (o: (_: string) => string) => (t: typesT.Type) => string} */
     const type = p => {
-        /** @type {(o: (_: string) => string) => (t: types.Type) => string} */
+        /** @type {(o: (_: string) => string) => (t: typesT.Type) => string} */
         const f = o => t => {
             if (typeof t === 'string') { return t }
             if (t.length === 2) { return `*const ${f(ref)(t[1])}` }
@@ -144,7 +146,7 @@ const rust = library => {
         return f
     }
 
-    /** @type {(p: string) => (o: (_: string) => string) => (f: types.Field) => string} */
+    /** @type {(p: string) => (o: (_: string) => string) => (f: typesT.Field) => string} */
     const pf = p => o => ([name, t]) => `${name}: ${type(p)(o)(t)}`
 
     const param = pf(super_)(obj)
@@ -153,36 +155,36 @@ const rust = library => {
 
     const mapField = map(pf('')(ref))
 
-    /** @type {(fa: types.FieldArray) => (name: string) => text.Block} */
+    /** @type {(fa: typesT.FieldArray) => (name: string) => textT.Block} */
     const struct = fn(entries)
         .then(mapField)
         .then(rustStruct)
         .result
 
-    /** @type {(first: readonly string[]) => (p: types.FieldArray) => string} */
+    /** @type {(first: readonly string[]) => (p: typesT.FieldArray) => string} */
     const func = first => p => {
         const resultStr = '_' in p ? ` -> ${type(super_)(ref)(p._)}` : ''
         const params = commaJoin(flat([first, mapParam(paramList(p))]))
         return `(${params})${resultStr}`
     }
 
-    /** @type {(n: string) => (p: types.FieldArray) => string} */
+    /** @type {(n: string) => (p: typesT.FieldArray) => string} */
     const virtualFnType = n => p => `extern "system" fn${n}${func(this_)(p)}`
 
-    /** @type {(m: types.Method) => string} */
+    /** @type {(m: typesT.Method) => string} */
     const virtualFn = ([n, p]) => `${n}: unsafe ${virtualFnType('')(p)}`
 
     const mapVirtualFn = map(virtualFn)
 
-    /** @type {(m: types.Method) => string} */
+    /** @type {(m: typesT.Method) => string} */
     const headerFn = ([n, p]) => `fn ${n}${func(self)(p)}`
 
-    /** @type {(m: types.Method) => string} */
+    /** @type {(m: typesT.Method) => string} */
     const traitFn = m => `${headerFn(m)};`
 
     const mapTraitFn = map(traitFn)
 
-    /** @type {(m: types.Method) => text.Block} */
+    /** @type {(m: typesT.Method) => textT.Block} */
     const implFn = m => {
         const [n, p] = m
         return [
@@ -194,7 +196,7 @@ const rust = library => {
 
     const flatMapImplFn = flatMap(implFn)
 
-    /** @type {(m: types.Method) => text.Block} */
+    /** @type {(m: typesT.Method) => textT.Block} */
     const impl = ([n, p]) => {
         const type = virtualFnType(` ${n}`)(p)
         return [
@@ -206,7 +208,7 @@ const rust = library => {
 
     const flatMapImpl = flatMap(impl)
 
-    /** @type {(i: types.Interface) => (name: string) => text.Block} */
+    /** @type {(i: typesT.Interface) => (name: string) => textT.Block} */
     const interface_ = ({ interface: i, guid }) => name => {
 
         const e = entries(i)
@@ -250,13 +252,13 @@ const rust = library => {
         ]
     }
 
-    /** @type {(type: object.Entry<types.Definition>) => text.Block} */
+    /** @type {(type: O.Entry<typesT.Definition>) => textT.Block} */
     const def = ([name, type]) => ('interface' in type ? interface_(type) : struct(type.struct))(name)
 
     return flat([['#![allow(non_snake_case)]'], flatMap(def)(entries(library))])
 }
 
-module.exports = {
+export default {
     /** @readonly */
     rust,
 }

package/com/rust/{test.f.cjs → test.f.mjs}

@@ -1,6 +1,6 @@
-const rust = require('./testlib.f.cjs')
+import rust from './testlib.f.mjs'
 
-module.exports = () => {
+export default () => {
     const e =
         '#![allow(non_snake_case)]\n' +
         '#[repr(C)]\n' +

package/com/rust/testlib.f.mjs

@@ -0,0 +1,10 @@
+import text from '../../text/module.f.mjs'
+const { flat } = text
+import string from '../../types/string/module.f.mjs'
+const { join } = string
+import x from './module.f.mjs'
+import library from '../types/testlib.f.mjs'
+
+const { rust } = x
+
+export default join('\n')(flat('    ')(rust(library)))

package/com/test/{build.f.cjs → build.f.mjs}

@@ -1,9 +1,9 @@
-const list = require('../../types/list/module.f.cjs')
+import list, * as List from '../../types/list/module.f.mjs'
 const { flat } = list
 
-const cppContent = require('../cpp/testlib.f.cjs')
-const csContent = require('../cs/testlib.f.cjs')
-const rustContent = require("../rust/testlib.f.cjs")
+import cppContent from '../cpp/testlib.f.mjs'
+import csContent from '../cs/testlib.f.mjs'
+import rustContent from '../rust/testlib.f.mjs'
 
 /**
  * @typedef {|
@@ -34,7 +34,7 @@ const rustContent = require("../rust/testlib.f.cjs")
  *      readonly name: string
  *      readonly content: string
  *  }
- *  readonly line: list.List<list.List<string>>
+ *  readonly line: List.List<List.List<string>>
  * }} Output
  */
 
@@ -99,7 +99,7 @@ const rust = ({ dirname }) => ({
     line: [['cargo', 'build' /**, '--locked' */]]
 })
 
-module.exports = {
+export default {
     /** @readonly */
     cpp,
     /** @readonly */

package/com/test/{build.cjs → build.mjs}

@@ -1,19 +1,27 @@
-const { writeFileSync } = require('node:fs')
-const { execSync } = require('node:child_process')
-const { platform, exit } = require('node:process')
-const build = require('./build.f.cjs')
+import { writeFileSync } from 'node:fs'
+import { execSync } from 'node:child_process'
+import { platform, exit } from 'node:process'
+import build, * as buildT from './build.f.mjs'
 const { cpp, cs, rust } = build
-const { join } = require('../../types/string/module.f.cjs')
+import string from '../../types/string/module.f.mjs'
+const { join } = string
 const { log, error } = console
-const { bold, reset } = require('../../text/sgr/module.f.cjs')
-const list = require('../../types/list/module.f.cjs')
+import sgr from '../../text/sgr/module.f.mjs'
+const { bold, reset } = sgr
+import list from '../../types/list/module.f.mjs'
+
+import { fileURLToPath } from 'node:url'
+import { dirname } from 'node:path'
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename)
 
 const nodeJs = {
     dirname: __dirname,
     platform,
 }
 
-/** @type {(f: build.Func) => void} */
+/** @type {(f: buildT.Func) => void} */
 const run = f => {
     const { file: { name, content }, line } = f(nodeJs)
     log(`${bold}writing: ${name}${reset}`)