functionalscript 0.2.5 → 0.3.0

package/types/sorted_set/{test.f.mjs → test.f.ts}

@@ -1,20 +1,22 @@
-import * as _ from './module.f.mjs'
-import * as compare from '../function/compare/module.f.mjs'
+import * as _ from './module.f.ts'
+import * as compare from '../function/compare/module.f.ts'
 const { unsafeCmp } = compare
-import * as json from '../../json/module.f.mjs'
-import * as object from '../object/module.f.mjs'
+import * as json from '../../json/module.f.ts'
+import * as object from '../object/module.f.ts'
 const { sort } = object
-import * as list from '../list/module.f.mjs'
+import * as list from '../list/module.f.ts'
 const { toArray, countdown, length } = list
-import * as Map from '../map/module.f.mjs'
-import * as f from '../function/module.f.mjs'
+import * as Map from '../map/module.f.ts'
+import * as f from '../function/module.f.ts'
 const { flip } = f
 
-/** @type {(a: readonly json.Unknown[]) => string} */
-const stringify = a => json.stringify(sort)(a)
+const stringify
+    : (a: readonly json.Unknown[]) => string
+    = a => json.stringify(sort)(a)
 
-/** @type {<T>(a: T) => (b: T) => Map.Sign} */
-const reverseCmp = flip(unsafeCmp)
+const reverseCmp
+    : <T>(a: T) => (b: T) => Map.Sign
+    = flip(unsafeCmp)
 
 export default {
     union: [
@@ -62,4 +64,4 @@ export default {
             if (!result) { throw result }
         }
     ]
-}
+}

package/types/string/module.f.ts

@@ -0,0 +1,24 @@
+import * as list from '../list/module.f.ts'
+const { reduce: listReduce, repeat: listRepeat } = list
+import * as f from '../function/module.f.ts'
+const { compose } = f
+import * as compare from '../function/compare/module.f.ts'
+const { unsafeCmp } = compare
+import * as op from '../function/operator/module.f.ts'
+const { join: joinOp, concat: concatOp } = op
+
+const reduce
+    : (o: op.Reduce<string>) => (input: list.List<string>) => string
+    = o => listReduce(o)('')
+
+export const join = compose(joinOp)(reduce)
+
+export const concat = reduce(concatOp)
+
+export const repeat
+    : (n: string) => (v: number) => string
+    = v => compose(listRepeat(v))(concat)
+
+export const cmp
+    : (a: string) => (b: string) => compare.Sign
+    = unsafeCmp

package/types/string/{test.f.mjs → test.f.ts}

@@ -1,6 +1,6 @@
-import * as _ from './module.f.mjs'
+import * as _ from './module.f.ts'
 const { join, concat, repeat, cmp } = _
-import * as list from '../list/module.f.mjs'
+import * as list from '../list/module.f.ts'
 const { repeat: repeatList } = list
 
 export default {

package/types/string_set/module.f.ts

@@ -0,0 +1,37 @@
+import * as BtreeTypes from '../btree/types/module.f.ts'
+import * as btree from '../btree/module.f.ts'
+import * as btf from '../btree/find/module.f.ts'
+const { find, isFound } = btf
+import * as btr from '../btree/remove/module.f.ts'
+const { remove: btreeRemove } = btr
+import * as bts from '../btree/set/module.f.ts'
+const { set: btreeSet } = bts
+export const {
+    values,
+    empty,
+}: { values: (s: StringSet) => list.List<string>, empty: null } = btree
+import * as string from "../string/module.f.ts"
+const { cmp } = string
+import * as list from '../list/module.f.ts'
+const { fold } = list
+import * as f from '../function/module.f.ts'
+const { compose } = f
+
+export type StringSet = BtreeTypes.Tree<string>
+
+export const contains
+    : (value: string) => (set: StringSet) => boolean
+    = value => {
+    const f = find(cmp(value))
+    return s => s !== null && isFound(f(s).first)
+}
+
+export const set
+    : (value: string) => (s: StringSet) => StringSet
+    = value => btreeSet(cmp(value))(() => value)
+
+export const fromValues = fold(set)(null)
+
+export const remove
+    : (value: string) => (s: StringSet) => StringSet
+    = compose(cmp)(btreeRemove)

package/types/string_set/{test.f.mjs → test.f.ts}

@@ -1,4 +1,4 @@
-import * as _ from './module.f.mjs'
+import * as _ from './module.f.ts'
 
 export default {
     contains: () => {
@@ -31,4 +31,4 @@ export default {
         r = _.remove('WORLD!')(r)
         if (r !== null) { throw r }
     }
-}
+}

package/com/cpp/testlib.f.mjs

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

package/com/cs/testlib.f.mjs

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

package/com/rust/module.f.mjs

@@ -1,272 +0,0 @@
-// @ts-self-types="./module.f.d.mts"
-
-/**
- * This module generates Rust code for COM interop from a high-level type library definition.
- *
- * The module provides functions to define structs, traits, and implementations in Rust,
- * specifically tailored for `nanocom` interoperation.
- */
-import * as types from '../types/module.f.mjs'
-const { paramList } = types
-import * as Text from '../../text/module.f.mjs'
-import * as O from '../../types/object/module.f.mjs'
-import * as list from '../../types/list/module.f.mjs'
-const { flat, map, flatMap } = list
-const { entries } = Object
-import * as func from '../../types/function/module.f.mjs'
-const { fn } = func
-import * as 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} */
-const rustStruct = b => name => [`#[repr(C)]`, `pub struct ${name} {`, mapRustField(b), `}`]
-
-const commaJoin = join(', ')
-
-/** @type {(name: string) => string} */
-const ref = name => `${name}::Ref`
-
-/** @type {(name: string) => string} */
-const obj = name => `&${name}::Object`
-
-const self = ['&self']
-
-/** @type {(p: types.Field) => string} */
-const paramName = ([n]) => n
-
-/** @type {(p: types.FieldArray) => list.Thunk<string>} */
-const callList = p => map(paramName)(paramList(p))
-
-/** @type {(p: types.FieldArray) => string} */
-const call = p => commaJoin(callList(p))
-
-/** @type {(p: types.FieldArray) => string} */
-const virtualCall = p => commaJoin(flat([['self'], callList(p)]))
-
-const super_ = 'super::'
-
-/** @type {(m: types.Method) => string} */
-const assign = ([n]) => `${n}: Self::${n},`
-
-const mapAssign = map(assign)
-
-const this_ = ['this: &Object']
-
-/** @type {(n: string) => string} */
-const rustType = n => `pub type ${n} = nanocom::${n}<Interface>;`
-
-/**
- * @template T
- * @typedef {T|{}} OptionalProperty
- */
-
-/** @typedef {{readonly where: readonly string[]}} Where */
-
-/**
- * @typedef {OptionalProperty<Where> & {readonly content: Text.Block}} WhereContent
- */
-
-/** @type {(h: string) => (wh: WhereContent) => Text.Block} */
-const whereContent = h => wh => {
-    const w = 'where' in wh ? [
-        h,
-        `where`,
-        mapComma(wh.where),
-        '{'
-    ]: [`${h} {`]
-    const x = [
-        wh.content,
-        '}',
-    ]
-    return flat([w, x])
-}
-
-/**
- * @typedef {{
- *  readonly param?: string
- *  readonly trait: string
- *  readonly type: string
- *  readonly where?: readonly string[]
- *  readonly content: Text.Block
- * }} Impl
- */
-
-/** @type {(impl: Impl) => Text.Block} */
-const rustImpl = i => {
-    const p = 'param' in i ? `<${i.param}>` : ''
-    const header = `impl${p} ${i.trait} for ${i.type}`
-    return whereContent(header)(i)
-}
-
-/**
- * @typedef {{
- *  readonly pub?: true
- *  readonly type: string
- *  readonly where?: readonly string[]
- *  readonly content: Text.Block
- * }} Trait
- */
-
-/** @type {(s: string) => string} */
-const comma = s => `${s},`
-
-const mapComma = map(comma)
-
-/** @type {(t: Trait) => Text.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} */
-const traitImpl = t => {
-    const i = rustImpl({
-        param: 'T',
-        trait: t.type,
-        type: 'T',
-        where,
-        content: [],
-    })
-    return flat([trait({ ...t, where }), i])
-}
-
-const where = ['Self: nanocom::Class<Interface = Interface>', 'nanocom::CObject<Self>: Ex']
-
-/**
- * Generates Rust code for the given type library.
- *
- * @param {types.Library} library - The library of type definitions to generate Rust code for.
- * @returns {Text.Block} - A block of Rust code representing the library.
- */
-export const rust = library => {
-
-    /** @type {(p: string) => (o: (_: string) => string) => (t: types.Type) => string} */
-    const type = p => {
-        /** @type {(o: (_: string) => string) => (t: types.Type) => string} */
-        const f = o => t => {
-            if (typeof t === 'string') { return t }
-            if (t.length === 2) { return `*const ${f(ref)(t[1])}` }
-            const [id] = t
-            const fullId = `${p}${id}`
-            return 'interface' in library[id] ? o(fullId) : fullId
-        }
-        return f
-    }
-
-    /** @type {(p: string) => (o: (_: string) => string) => (f: types.Field) => string} */
-    const pf = p => o => ([name, t]) => `${name}: ${type(p)(o)(t)}`
-
-    const param = pf(super_)(obj)
-
-    const mapParam = map(param)
-
-    const mapField = map(pf('')(ref))
-
-    /** @type {(fa: types.FieldArray) => (name: string) => Text.Block} */
-    const struct = fn(entries)
-        .then(mapField)
-        .then(rustStruct)
-        .result
-
-    /** @type {(first: readonly string[]) => (p: types.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} */
-    const virtualFnType = n => p => `extern "system" fn${n}${func(this_)(p)}`
-
-    /** @type {(m: types.Method) => string} */
-    const virtualFn = ([n, p]) => `${n}: unsafe ${virtualFnType('')(p)}`
-
-    const mapVirtualFn = map(virtualFn)
-
-    /** @type {(m: types.Method) => string} */
-    const headerFn = ([n, p]) => `fn ${n}${func(self)(p)}`
-
-    /** @type {(m: types.Method) => string} */
-    const traitFn = m => `${headerFn(m)};`
-
-    const mapTraitFn = map(traitFn)
-
-    /** @type {(m: types.Method) => Text.Block} */
-    const implFn = m => {
-        const [n, p] = m
-        return [
-            `${headerFn(m)} {`,
-            [`unsafe { (self.interface().${n})(${virtualCall(p)}) }`],
-            '}'
-        ]
-    }
-
-    const flatMapImplFn = flatMap(implFn)
-
-    /** @type {(m: types.Method) => Text.Block} */
-    const impl = ([n, p]) => {
-        const type = virtualFnType(` ${n}`)(p)
-        return [
-            `${type} {`,
-            [`unsafe { nanocom::CObject::from_object_unchecked(this) }.${n}(${call(p)})`],
-            '}'
-        ]
-    }
-
-    const flatMapImpl = flatMap(impl)
-
-    /** @type {(i: types.Interface) => (name: string) => Text.Block} */
-    const interface_ = ({ interface: i, guid }) => name => {
-
-        const e = entries(i)
-
-        return [
-            `pub mod ${name} {`,
-            [
-                rustType('Object'),
-                rustType('Ref'),
-                rustType('Vmt'),
-            ],
-            rustStruct(mapVirtualFn(e))('Interface'),
-            rustImpl({
-                trait: 'nanocom::Interface',
-                type: 'Interface',
-                content: [`const GUID: nanocom::GUID = 0x${guid.replaceAll('-', '_')};`]
-            }),
-            trait({ pub: true, type: 'Ex', content: mapTraitFn(e) }),
-            rustImpl({
-                trait: 'Ex',
-                type: 'Object',
-                content: flatMapImplFn(e)
-            }),
-            traitImpl({
-                pub: true,
-                type: 'ClassEx',
-                content: ['const VMT: Vmt = Vmt {',
-                    [   'iunknown: nanocom::CObject::<Self>::IUNKNOWN,',
-                        'interface: Interface {',
-                            mapAssign(e),
-                        '},',
-                    ],
-                    '};'
-                ]
-            }),
-            traitImpl({
-                type: 'PrivateClassEx',
-                content: flatMapImpl(e)
-            }),
-            '}'
-        ]
-    }
-
-    /** @type {(type: O.Entry<types.Definition>) => Text.Block} */
-    const def = ([name, type]) => ('interface' in type ? interface_(type) : struct(type.struct))(name)
-
-    return flat([['#![allow(non_snake_case)]'], flatMap(def)(entries(library))])
-}

package/com/rust/testlib.f.mjs

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

package/com/types/module.f.mjs

@@ -1,67 +0,0 @@
-// @ts-self-types="./module.f.d.mts"
-import * as O from '../../types/object/module.f.mjs'
-import * as list from '../../types/list/module.f.mjs'
-import * as f from '../../types/function/module.f.mjs'
-const { compose } = f
-const { filter } = list
-const { entries } = Object
-
-/** @typedef {{readonly[k in string]: Definition}} Library */
-
-/** @typedef {Struct|Interface} Definition */
-
-/**
- * @typedef {{
- *  readonly struct: FieldArray
- * }} Struct
- */
-
-/** @typedef {{readonly[k in string]: Type}} FieldArray */
-
-/** @typedef {O.Entry<Type>} Field */
-
-/**
- * @typedef {{
- *  readonly interface: MethodArray
- *  readonly guid: string
- * }} Interface
- */
-
-/** @typedef {{readonly[k in string]: FieldArray}} MethodArray */
-
-/** @typedef {O.Entry<FieldArray>} Method */
-
-/** @typedef {BaseType|Id|Pointer} Type */
-
-/** @typedef {readonly[string]} Id */
-
-/**
- * @typedef {|
- *  'u8'|
- *  'i8'|
- *  'u16'|
- *  'i16'|
- *  'u32'|
- *  'i32'|
- *  'u64'|
- *  'i64'|
- *  'usize'|
- *  'isize'|
- *  'f32'|
- *  'f64'|
- *  'bool'
- * } BaseType
- */
-
-/** @typedef {readonly['*', Type]} Pointer */
-
-/** @type {(kv: O.Entry<Type>) => boolean} */
-const isParam = ([name]) => name !== '_'
-
-const filterParam = filter(isParam)
-
-/** @type {(fa: FieldArray) => list.List<Field> } */
-export const paramList = compose(entries)(filterParam)
-
-/** @type {<T>(v: T) => (f: (type: Type) => T) => (fa: FieldArray) => T} */
-export const result = v => f => fa => '_' in fa ? f(fa._) : v

package/commonjs/build/module.f.mjs

@@ -1,100 +0,0 @@
-// @ts-self-types="./module.f.d.mts"
-import * as package_ from '../package/module.f.mjs'
-import * as module from '../module/module.f.mjs'
-const { idToString, dir } = module
-import * as function_ from '../module/function/module.f.mjs'
-import * as map from '../../types/map/module.f.mjs'
-const { empty: mapEmpty, setReplace } = map
-import * as object from '../../types/object/module.f.mjs'
-const { fromMap } = object
-import * as path from '../path/module.f.mjs'
-const { parseAndFind } = path
-import * as stringSet from '../../types/string_set/module.f.mjs'
-const { set: setSet, contains: setContains, empty: stringSetEmpty } = stringSet
-
-/**
- * @template M
- * @typedef {{
- *  readonly packageGet: package_.Get
- *  readonly moduleMapInterface: module.MapInterface<M>
- *  readonly moduleId: module.Id
- *  readonly moduleMap: M
- * }} Config
- */
-
-/**
- * @template M
- * @typedef {readonly[module.State, M]} Result
- */
-
-/** @type {<M>(moduleMap: M) => Result<M>} */
-const notFound = moduleMap => [['error', ['file not found']], moduleMap]
-
-/**
- * @type {(compile: function_.Compile) =>
- *  (packageGet: package_.Get) =>
- *  <M>(moduleMapInterface: module.MapInterface<M>) =>
- *  (moduleId: module.Id) =>
- *  (moduleMap: M) =>
- *  Result<M>
- * }
- */
-export const getOrBuild = compile => packageGet => moduleMapInterface =>  {
-    /** @typedef {typeof moduleMapInterface extends module.MapInterface<infer M> ? M : never} M */
-
-    /**
-     * @type {(buildSet: stringSet.StringSet) =>
-     *  (moduleId: module.Id) =>
-     *  (source: string) =>
-     *  (moduleMap: M) =>
-     *  Result<M>}
-     */
-    const build = buildSet => moduleId => {
-        const moduleIdStr = idToString(moduleId)
-        const buildSet1 = setSet(moduleIdStr)(buildSet)
-        const moduleDir = dir(moduleId)
-        /** @type {function_.Require<readonly[map.Map<string>, M]>} */
-        const require_ = p => ([requireMap, m]) => {
-            /** @type {(e: unknown) => function_.Result<readonly[map.Map<string>, M]>} */
-            const error = e => [['error', e], [requireMap, m]]
-            if (moduleDir === null) { return error('file not found') }
-            const r = parseAndFind(packageGet)(moduleDir)(p)
-            if (r === null) { return error('file not found') }
-            const rIdStr = idToString(r.id)
-            if (setContains(rIdStr)(buildSet1)) { return error('circular reference') }
-            const [state, m1] = build(buildSet1)(r.id)(r.source)(m)
-            return [state[0] === 'error' ? state : ['ok', state[1].exports], [setReplace(p)(rIdStr)(requireMap), m1]]
-        }
-        return source => moduleMap => {
-            /** @type {(s: module.State) => (m: M) => Result<M>} */
-            const set = s => m => [s, moduleMapInterface.setReplace(moduleIdStr)(s)(m)]
-            /** @type {(e: module.Error) => (m: M) => Result<M>} */
-            const error = e => set(['error', e])
-            // check compilation
-            const [kind, result] = compile(source)
-            if (kind === 'error') { return error(['compilation error', result])(moduleMap) }
-            // build
-            const [[state, value], [requireMap, moduleMap2]] = result(require_)([mapEmpty, moduleMap])
-            const x = state === 'error' ?
-                error(['runtime error', value]) :
-                set(['ok', { exports: value, requireMap: fromMap(requireMap) }])
-            return x(moduleMap2)
-        }
-    }
-    /** @type {(moduleId: module.Id) => (moduleMap: M) => Result<M>} */
-    const f = moduleId => moduleMap => {
-        const moduleIdStr = idToString(moduleId)
-        // check moduleMap
-        {
-            const m = moduleMapInterface.at(moduleIdStr)(moduleMap)
-            if (m !== null) { return [m, moduleMap] }
-        }
-        // check package
-        const p = packageGet(moduleId.package)
-        if (p === null) { return notFound(moduleMap) }
-        // check file
-        const source = p.file(moduleId.path.join('/'))
-        return (source === null ? notFound : build(stringSetEmpty)(moduleId)(source))(moduleMap)
-    }
-    return f
-}

package/commonjs/module/function/module.f.mjs

@@ -1,21 +0,0 @@
-// @ts-self-types="./module.f.d.mts"
-
-/**
- * An IO interface for creating and running module functions.
- */
-
-import * as TypesResult from '../../../types/result/module.f.mjs'
-
-/** @typedef {<M>(require: Require<M>) => (prior: M) => Result<M>} Function_ */
-
-/**
- * @template M
- * @typedef {readonly[TypesResult.Result<unknown, unknown>, M]} Result
- */
-
-/**
- * @template M
- * @typedef {(path: string) => (prior: M) => Result<M>} Require
- */
-
-/** @typedef {(source: string) => TypesResult.Result<Function_, unknown>} Compile */

package/commonjs/module/module.f.mjs

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

package/commonjs/module.f.mjs

@@ -1,11 +0,0 @@
-// @ts-self-types="./module.f.d.mts"
-
-/** @typedef {(packageName: string) => PackageMap|Package|null} PackageMap */
-
-/**
- * @typedef {readonly[
- *  string,
- *  PackageMap,
- *  (fileName: string) => string|null
- * ]} Package
- */