functionalscript 0.0.389 → 0.0.392

package/com/cpp/module.f.cjs

@@ -1,37 +1,44 @@
 const types = require('../types/module.f.cjs')
+const { paramList } = types
 const text = require('../../text/module.f.cjs')
 const obj = require('../../types/object/module.f.cjs')
-const { list } = require('../../types/module.f.cjs')
+const list = require('../../types/list/module.f.cjs')
+const { map, join, flatMap } = list
+const { entries } =  Object
 
 /** @type {(name: string) => (body: text.Block) => text.Block} */
 const struct = name => body => [`struct ${name}`, '{', body, '};']
 
-/** @type {(t: types.BaseType) => string} */
-const baseType = t => {
-    switch (t) {
-        case 'u8': return 'uint8_t'
-        case 'i8': return 'int8_t'
-        case 'u16': return 'uint16_t'
-        case 'i16': return 'int16_t'
-        case 'u32': return 'uint32_t'
-        case 'i32': return 'int32_t'
-        case 'u64': return 'uint64_t'
-        case 'i64': return 'int64_t'
-        case 'usize': return 'size_t'
-        case 'isize': return 'ptrdiff_t'
-        case 'f32': return 'float'
-        case 'f64': return 'double'
-        case 'bool': return '::com::BOOL'
-    }
+const baseTypeMap = {
+    u8: 'uint8_t',
+    i8: 'int8_t',
+    u16: 'uint16_t',
+    i16: 'int16_t',
+    u32: 'uint32_t',
+    i32: 'int32_t',
+    u64: 'uint64_t',
+    i64: 'int64_t',
+    usize: 'size_t',
+    isize: 'ptrdiff_t',
+    f32: 'float',
+    f64: 'double',
+    bool: '::com::BOOL',
 }
 
+/** @type {(t: types.BaseType) => string} */
+const baseType = t => baseTypeMap[t]
+
+const resultVoid = types.result('void')
+
+const namespace = text.curly('namespace')
+
 /** @type {(name: string) => (lib: types.Library) => text.Block} */
 const cpp = name => lib => {
 
     /** @type {(i: (t: string) => string) => (t: types.Type) => string} */
     const objectType = i => t => {
-        if (typeof(t) === 'string') { return baseType(t) }
-        if (t.length === 2) { return `${type(t[1])}*` } 
+        if (typeof (t) === 'string') { return baseType(t) }
+        if (t.length === 2) { return `${type(t[1])}*` }
         const [id] = t
         if (lib[id].interface === undefined) { return id }
         return i(id)
@@ -42,33 +49,36 @@ const cpp = name => lib => {
     /** @type {(s: types.Field) => text.Item} */
     const field = ([name, t]) => `${type(t)} ${name};`
 
+    const mapField = map(field)
+
     /** @type {(s: types.Struct) => text.Block} */
-    const defStruct = s => list.map(field)(Object.entries(s.struct))
+    const defStruct = s => mapField(entries(s.struct))
 
     /** @type {(fa: types.FieldArray) => string} */
-    const result = types.result('void')(type)
+    const cppResult = resultVoid(type)
 
     /** @type {(p: types.Field) => string} */
     const param = ([name, t]) => `${objectType(id => `${id}&`)(t)} ${name}`
 
+    const mapParam = map(param)
+
     /** @type {(m: types.Method) => text.Item} */
-    const method = ([name, paramArray]) => 
-        `virtual ${result(paramArray)} COM_STDCALL ${name}(${list.join(', ')(list.map(param)(types.paramList(paramArray)))}) = 0;`
+    const method = ([name, paramArray]) =>
+        `virtual ${cppResult(paramArray)} COM_STDCALL ${name}(${join(', ')(mapParam(paramList(paramArray)))}) = 0;`
+
+    const mapMethod = map(method)
 
     /** @type {(i: types.Interface) => text.Block} */
-    const defInterface = i => list.map(method)(Object.entries(i.interface))
+    const defInterface = i => mapMethod(entries(i.interface))
 
     /** @type {(kv: obj.Entry<types.Definition>) => text.Block} */
-    const def = ([name, d]) => d.interface === undefined 
-        ? struct(name)(defStruct(d)) 
+    const def = ([name, d]) => d.interface === undefined
+        ? struct(name)(defStruct(d))
         : struct(`${name}: ::com::IUnknown`)(defInterface(d))
 
     return list.flat([
         ['#pragma once', ''],
-        text.curly
-            ('namespace')
-            (name)
-            (list.flatMap(def)(Object.entries(lib)))
+        namespace(name)(flatMap(def)(entries(lib)))
     ])
 }
 

package/com/cs/module.f.cjs

@@ -1,7 +1,11 @@
 const types = require('../types/module.f.cjs')
+const { result, paramList } = types
 const text = require('../../text/module.f.cjs')
+const { curly } = text
 const list = require('../../types/list/module.f.cjs')
+const { flat, map, some, join, flatMap } = list
 const obj = require('../../types/object/module.f.cjs')
+const { entries } = Object
 
 /** @type {(v: string) => string} */
 const using = v => `using ${v};`
@@ -14,30 +18,30 @@ const using = v => `using ${v};`
  *  list.List<text.Item>}
  */
 const typeDef = attributes => type => name => body =>
-    list.flat([
-        list.map(v => `[${v}]`)(attributes),
-        text.curly(`public ${type}`)(name)(body)
+    flat([
+        map(v => `[${v}]`)(attributes),
+        curly(`public ${type}`)(name)(body)
     ])
 
-/** @type {(t: types.BaseType) => string} */
-const baseType = t => {
-    switch (t) {
-        case 'bool': return 'bool'
-        case 'f32': return 'float'
-        case 'f64': return 'double'
-        case 'i16': return 'short'
-        case 'i32': return 'int'
-        case 'i64': return 'long'
-        case 'i8': return 'sbyte'
-        case 'isize': return 'IntPtr'
-        case 'u16': return 'ushort'
-        case 'u32': return 'uint'
-        case 'u64': return 'ulong'
-        case 'u8': return 'byte'
-        case 'usize': return 'UIntPtr'
-    }
+const baseTypeMap = {
+    bool: 'bool',
+    f32: 'float',
+    f64: 'double',
+    i16: 'short',
+    i32: 'int',
+    i64: 'long',
+    i8: 'sbyte',
+    isize: 'IntPtr',
+    u16: 'ushort',
+    u32: 'uint',
+    u64: 'ulong',
+    u8: 'byte',
+    usize: 'UIntPtr',    
 }
 
+/** @type {(t: types.BaseType) => string} */
+const baseType = t => baseTypeMap[t]
+
 /** @type {(isUnsafe: boolean) => string} */
 const unsafe = isUnsafe => isUnsafe ? 'unsafe ' : ''
 
@@ -53,6 +57,8 @@ const type = t => fullType(t)[1]
 /** @type {(f: types.Field) => string} */
 const param = ([name, t]) => `${type(t)} ${name}`
 
+const mapParam = map(param)
+
 /** @type {(f: types.Field) => string} */
 const field = ([name, comType]) => {
     const [isUnsafe, t] = fullType(comType)
@@ -62,46 +68,59 @@ const field = ([name, comType]) => {
 /** @type {(field: types.Field) => boolean} */
 const isUnsafeField = field => fullType(field[1])[0]
 
+const mapIsUnsafeField = map(isUnsafeField)
+
+const resultVoid = result('void')
+
+const joinComma = join(', ')
+
 /** @type {(e: obj.Entry<types.FieldArray>) => readonly string[]} */
 const method = ([name, m]) => {
-    const paramAndResultList = Object.entries(m)
-    const pl = types.paramList(m)
-    const isUnsafe = list.some(list.map(isUnsafeField)(paramAndResultList))
+    const paramAndResultList = entries(m)
+    const pl = paramList(m)
+    const isUnsafe = some(mapIsUnsafeField(paramAndResultList))
     return [
         '[PreserveSig]',
-        `${unsafe(isUnsafe)}${types.result('void')(type)(m)} ${name}(${list.join(', ')(list.map(param)(pl))});`
+        `${unsafe(isUnsafe)}${resultVoid(type)(m)} ${name}(${joinComma(mapParam(pl))});`
     ]
 }
 
+const struct = typeDef
+    (['StructLayout(LayoutKind.Sequential)'])
+    ('struct')
+
+const mapField = map(field)
+
+const flatMapMethod = flatMap(method)
+
 /** @type {(e: obj.Entry<types.Definition>) => list.List<text.Item>} */
 const def = ([n, d]) => {
     const i = d.interface
     return i === undefined ?
-        typeDef
-            (['StructLayout(LayoutKind.Sequential)'])
-            ('struct')
-            (n)
-            (list.map(field)(Object.entries(d.struct))) :
+        struct(n)(mapField(entries(d.struct))) :
         typeDef
             ([`Guid("${d.guid}")`, 'InterfaceType(ComInterfaceType.InterfaceIsIUnknown)'])
             ('interface')
             (n)
-            (list.flatMap(method)(Object.entries(d.interface)))
+            (flatMapMethod(entries(i)))
 }
 
-/** @type {(name: string) => (library: types.Library) => text.Block} */
-const cs = name => library => {
-    const v = list.flatMap(def)(Object.entries(library))
+const flatMapDef = flatMap(def)
 
-    /** @type {text.Block} */
-    const h = [
-        using('System'),
-        using('System.Runtime.InteropServices'),
-        ''
-    ]
+const namespace = curly('namespace')
+
+/** @type {text.Block} */
+const header = [
+    using('System'),
+    using('System.Runtime.InteropServices'),
+    ''
+]
 
-    const ns = text.curly('namespace')(name)(() => v)
-    return list.flat([h, ns])
+/** @type {(name: string) => (library: types.Library) => text.Block} */
+const cs = name => library => {
+    const v = flatMapDef(entries(library))
+    const ns = namespace(name)(v)
+    return flat([header, ns])
 }
 
 module.exports = {

package/com/types/module.f.cjs

@@ -1,6 +1,8 @@
 const obj = require('../../types/object/module.f.cjs')
 const list = require('../../types/list/module.f.cjs')
-const { types } = require('../module.f.cjs')
+const { compose } = require('../../types/function/module.f.cjs')
+const { filter } = list
+const { entries } = Object
 
 /** @typedef {{readonly[k in string]: Definition}} Library */
 
@@ -55,8 +57,10 @@ const { types } = require('../module.f.cjs')
 /** @type {(kv: obj.Entry<Type>) => boolean} */
 const isParam = ([name]) => name !== '_'
 
+const filterParam = filter(isParam)
+
 /** @type {(fa: FieldArray) => list.List<Field> } */
-const paramList = fa => list.filter(isParam)(Object.entries(fa))
+const paramList = compose(entries)(filterParam)
 
 /** @type {<T>(v: T) => (f: (type: Type) => T) => (fa: FieldArray) => T} */
 const result = v => f => fa => {

package/commonjs/build/module.f.cjs

@@ -1,10 +1,15 @@
 const package_ = require('../package/module.f.cjs')
 const module_ = require('../module/module.f.cjs')
+const { idToString, dir } = module_
 const function_ = require('../module/function/module.f.cjs')
 const map = require('../../types/map/module.f.cjs')
+const { set: mapSet } = map
 const object = require('../../types/object/module.f.cjs')
+const { fromMap } = object
 const path = require('../path/module.f.cjs')
-const stringSet = require('../../types/stringset/module.f.cjs')
+const { parseAndFind } = path
+const stringSet = require('../../types/string_set/module.f.cjs')
+const { set: setSet, contains: setContains } = stringSet
 
 /**
  * @template M
@@ -44,20 +49,20 @@ const getOrBuild = compile => packageGet => moduleMapInterface =>  {
      *  Result<M>}
      */
     const build = buildSet => moduleId => {
-        const moduleIdStr = module_.idToString(moduleId)
-        const buildSet1 = stringSet.set(moduleIdStr)(buildSet)
-        const dir = module_.dir(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', 'file not found'], [requireMap, m]]
-            if (dir === undefined) { return error('file not found') }
-            const r = path.parseAndFind(packageGet)(dir)(p)
+            if (moduleDir === undefined) { return error('file not found') }
+            const r = parseAndFind(packageGet)(moduleDir)(p)
             if (r === undefined) { return error('file not found') }
-            const rIdStr = module_.idToString(r.id)
-            if (stringSet.contains(rIdStr)(buildSet1)) { return error('circular reference') }
+            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], [map.set(p)(rIdStr)(requireMap), m1]]
+            return [state[0] === 'error' ? state : ['ok', state[1].exports], [mapSet(p)(rIdStr)(requireMap), m1]]
         }
         return source => moduleMap => {
             /** @type {(s: module_.State) => (m: M) => Result<M>} */
@@ -68,16 +73,16 @@ const getOrBuild = compile => packageGet => moduleMapInterface =>  {
             const [kind, result] = compile(source)
             if (kind === 'error') { return error(['compilation error', result])(moduleMap) }
             // build
-            const [r, [requireMap, moduleMap2]] = result(require_)([undefined, moduleMap])
-            const x = r[0] === 'error' ?
-                error(['runtime error', r[1]]) :
-                set(['ok', { exports: r[1], requireMap: object.fromMap(requireMap) }])
+            const [[state, value], [requireMap, moduleMap2]] = result(require_)([undefined, 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 = module_.idToString(moduleId)
+        const moduleIdStr = idToString(moduleId)
         // check moduleMap
         {
             const m = moduleMapInterface.at(moduleIdStr)(moduleMap)

package/commonjs/package/dependencies/module.f.cjs

@@ -1,5 +1,8 @@
 const json = require('../../../json/module.f.cjs')
+const { isObject } = json
 const list = require('../../../types/list/module.f.cjs')
+const { map, every } = list
+const { entries } = Object
 
 /** @typedef {readonly[string, string]} DependencyJson */
 
@@ -13,8 +16,8 @@ const isDependencyJson = ([, v]) => typeof v === 'string'
 /** @type {(j: json.Unknown|undefined) => j is DependenciesJson} */
 const isDependenciesJson = j => {
     if (j === undefined) { return true }
-    if (!json.isObject(j)) { return false }
-    return list.every(list.map(isDependencyJson)(Object.entries(j)))
+    if (!isObject(j)) { return false }
+    return every(map(isDependencyJson)(entries(j)))
 }
 
 module.exports = {

package/commonjs/package/module.f.cjs

@@ -1,5 +1,7 @@
 const json = require('../../json/module.f.cjs')
+const { isObject } = json
 const dependencies = require('./dependencies/module.f.cjs')
+const { isDependenciesJson } = dependencies
 
 /**
  * @typedef {{
@@ -11,10 +13,10 @@ const dependencies = require('./dependencies/module.f.cjs')
 
 /** @type {(j: json.Unknown) => j is PackageJson} */
 const isPackageJson = j => {
-    if (!json.isObject(j)) { return false }
+    if (!isObject(j)) { return false }
     if (typeof j.name !== 'string') { return false }
     if (typeof j.version !== 'string') { return false }
-    if (!dependencies.isDependenciesJson(j.dependencies)) { return false }
+    if (!isDependenciesJson(j.dependencies)) { return false }
     return true
 }
 

package/commonjs/path/module.f.cjs

@@ -1,4 +1,5 @@
 const list = require("../../types/list/module.f.cjs")
+const { next, reduce, reverse, first, flat, toArray, filterMap, isEmpty, concat, join } = list
 const package_ = require("../package/module.f.cjs")
 const module_ = require("../module/module.f.cjs")
 
@@ -24,7 +25,7 @@ const normItemsOp = first => prior => {
     switch (first) {
         case '': case '.': { return prior }
         case '..': {
-            const result = list.next(tail)
+            const result = next(tail)
             if (result === undefined) { return undefined }
             return [result.tail]
         }
@@ -36,19 +37,20 @@ const normItemsOp = first => prior => {
 
 /** @type {(items: list.List<string>) => OptionList} */
 const normItems = items => {
-    const result = list.reduce(normItemsOp)([undefined])(items)
-    if (result === undefined) { return result }
-    return [list.reverse(result[0])]
+    const result = reduce(normItemsOp)([undefined])(items)
+    return result === undefined ? result : [reverse(result[0])]
 }
 
+const firstUndefined = first(undefined)
+
 /** @type {(local: string) => (path: string) => LocalPath|undefined} */
 const parseLocal = local => {
     /** @type {(path: string) => readonly[boolean, boolean, list.List<string>]} */
     const fSeq = path => {
         const pathSeq = split(path)
         const dir = [undefined, '', '.', '..'].includes(pathSeq[pathSeq.length - 1])
-        return /** @type {readonly (string|undefined)[]} */(['.', '..']).includes(list.first(undefined)(pathSeq)) ?
-            [false, dir, list.flat([split(local), pathSeq])] :
+        return /** @type {readonly (string|undefined)[]} */(['.', '..']).includes(firstUndefined(pathSeq)) ?
+            [false, dir, flat([split(local), pathSeq])] :
             [true, dir, pathSeq]
     }
     /** @type {(path: string) => LocalPath|undefined} */
@@ -59,7 +61,7 @@ const parseLocal = local => {
         return {
             external,
             dir,
-            items: list.toArray(n[0])
+            items: toArray(n[0])
         }
     }
     return f
@@ -70,7 +72,7 @@ const parseLocal = local => {
 /** @type {(prior: readonly[string|undefined, list.List<string>]) => list.Thunk<IdPath>} */
 const variants = prior => () => {
     const [a, b] = prior
-    const r = list.next(b)
+    const r = next(b)
     if (r === undefined) { return undefined }
     const { first, tail } = r
     /** @type {IdPath} */
@@ -100,12 +102,12 @@ const mapDependency = d => ([external, internal]) => {
  */
 const parseGlobal = dependencies =>
 {
-    const filterMap = list.filterMap(mapDependency(dependencies))
+    const fMap = filterMap(mapDependency(dependencies))
     return dir => items => {
         const v = variants([undefined, items])
-        const r = list.first(undefined)(filterMap(v))
+        const r = firstUndefined(fMap(v))
         if (r === undefined) { return undefined }
-        return { package: r[0], items: list.toArray(r[1]), dir }
+        return { package: r[0], items: toArray(r[1]), dir }
     }
 }
 
@@ -154,9 +156,9 @@ const parseAndFind = packageGet => moduleId => path => {
         return source === undefined ? undefined : { id: { package: p.package, path: file.split('/') }, source }
     }
     const file = p.items.join('/')
-    const indexJs = list.join('/')(list.concat(p.items)(['index.js']))
-    const fileList = p.dir || list.isEmpty(p.items) ? [indexJs] : [file, `${file}.js`, indexJs]
-    return list.first(undefined)(list.filterMap(tryFile)(fileList))
+    const indexJs = join('/')(concat(p.items)(['index.js']))
+    const fileList = p.dir || isEmpty(p.items) ? [indexJs] : [file, `${file}.js`, indexJs]
+    return firstUndefined(filterMap(tryFile)(fileList))
 }
 
 module.exports = {

package/dev/test/module.f.cjs

@@ -0,0 +1,19 @@
+const { todo } = require('../module.f.cjs')
+const list = require('../../types/list/module.f.cjs')
+const function_ = require('../../commonjs/module/function/module.f.cjs')
+const package_ = require('../../commonjs/package/module.f.cjs')
+
+/**
+ * @type {(c: function_.Compile) =>
+ *  (files: string) =>
+ *  (packageGet: package_.Get) =>
+ *  never}
+ */
+const test = compile => files => packageGet => {
+    return todo()
+}
+
+module.exports = {
+    /** @readonly */
+    test,
+}