functionalscript 0.0.478 → 0.0.479

package/com/cpp/module.f.cjs

@@ -52,13 +52,13 @@ const joinComma = join(', ')
 /** @type {(name: string) => (lib: types.Library) => text.Block} */
 const cpp = name => lib => {
 
-    /** @type {(t: types.Type) => string|undefined} */
+    /** @type {(t: types.Type) => string|null} */
     const interface_ = t => {
         if (!(t instanceof Array) || t.length !== 1) {
-            return undefined
+            return null
         }
         const [name] = t
-        return lib[name].interface !== undefined ? name : undefined
+        return 'interface' in lib[name] ? name : null
     }
 
     /** @type {(i: (t: string) => string) => (t: types.Type) => string} */
@@ -66,8 +66,8 @@ const cpp = name => lib => {
         if (typeof (t) === 'string') { return baseType(t) }
         if (t.length === 2) { return `${type(t[1])} const*` }
         const [id] = t
-        if (lib[id].interface === undefined) { return id }
-        return i(id)
+        if ('interface' in lib[id]) { return i(id) }
+        return id
     }
 
     const type = objectType(comRef)
@@ -101,7 +101,7 @@ const cpp = name => lib => {
         const paramArrayStr = `(${joinComma(mapParam(paramL))})`
         const m = methodHeader(result)(paramArrayStr)
         const resultName = interface_(paramArray._)
-        if (resultName === undefined) {
+        if (resultName === null) {
             return [m(name)]
         }
         return [
@@ -127,15 +127,15 @@ const cpp = name => lib => {
     }
 
     /** @type {(kv: obj.Entry<types.Definition>) => text.Block} */
-    const def = ([name, d]) => d.interface === undefined
-        ? struct(name)(defStruct(d))
-        : [
+    const def = ([name, d]) => 'interface' in d
+        ? [
             `class ${name} : public ::nanocom::IUnknown`,
             '{',
             'public:',
             defInterface(d),
             '};'
         ]
+        : struct(name)(defStruct(d))
 
     /** @type {(kv: obj.Entry<types.Definition>) => text.Block} */
     const forward = ([name]) => [`struct ${name};`]

package/com/cs/module.f.cjs

@@ -96,14 +96,13 @@ 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 ?
+    return !('interface' in d) ?
         struct(n)(mapField(entries(d.struct))) :
         typeDef
             ([`Guid("${d.guid}")`, 'InterfaceType(ComInterfaceType.InterfaceIsIUnknown)'])
             ('interface')
             (n)
-            (flatMapMethod(entries(i)))
+            (flatMapMethod(entries(d.interface)))
 }
 
 const flatMapDef = flatMap(def)

package/com/rust/module.f.cjs

@@ -84,7 +84,7 @@ const whereContent = h => ({ where, content }) => {
 
 /** @type {(impl: Impl) => text.Block} */
 const rustImpl = i => {
-    const p = i.param === undefined ? '' : `<${i.param}>`
+    const p = 'param' in i ? `<${i.param}>` : ''
     const header = `impl${p} ${i.trait} for ${i.type}`
     return whereContent(header)(i)
 }
@@ -135,7 +135,7 @@ const rust = library => {
             if (t.length === 2) { return `*const ${f(ref)(t[1])}` }
             const [id] = t
             const fullId = `${p}${id}`
-            return library[id].interface === undefined ? fullId : o(fullId)
+            return 'interface' in library[id] ? o(fullId) : fullId
         }
         return f
     }
@@ -157,8 +157,7 @@ const rust = library => {
 
     /** @type {(first: readonly string[]) => (p: types.FieldArray) => string} */
     const func = first => p => {
-        const result = p._
-        const resultStr = result === undefined ? '' : ` -> ${type(super_)(ref)(result)}`
+        const resultStr = '_' in p ? ` -> ${type(super_)(ref)(p._)}` : ''
         const params = commaJoin(flat([first, mapParam(paramList(p))]))
         return `(${params})${resultStr}`
     }
@@ -248,7 +247,7 @@ const rust = library => {
     }
 
     /** @type {(type: object.Entry<types.Definition>) => text.Block} */
-    const def = ([name, type]) => (type.interface === undefined ? struct(type.struct) : interface_(type))(name)
+    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/types/module.f.cjs

@@ -10,7 +10,6 @@ const { entries } = Object
 
 /**
  * @typedef {{
- *  readonly interface?: undefined
  *  readonly struct: FieldArray
  * }} Struct
  */

package/commonjs/README.md

@@ -17,15 +17,15 @@
 // - `localPackageId` examples:
 //   - `functionalscript`
 
-type PackageGet = (packageId: string) => Package | undefined
+type PackageGet = (packageId: string) => Package | null
 
 // A local file id is
 
 type Package = {
     // returns a global package id.
-    readonly dependency: (localPackageId: string) => string | undefined
+    readonly dependency: (localPackageId: string) => string | null
     // returns source of the file.
-    readonly file: (localFileId: string) => string | undefined
+    readonly file: (localFileId: string) => string | null
 }
 ```
 
@@ -38,7 +38,7 @@ type Package = {
 //
 // A module is a compiled and initialized source file.
 
-type ModuleGet = (moduleId: string) => ModuleState | undefined
+type ModuleGet = (moduleId: string) => ModuleState | null
 
 type ModuleMapInterface<M> = {
     readonly get: (moduleMap: M) => ModuleGet

package/commonjs/build/module.f.cjs

@@ -55,8 +55,8 @@ const getOrBuild = compile => packageGet => moduleMapInterface =>  {
         /** @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 (moduleDir === undefined) { return error('file not found') }
+            const error = e => [['error', e], [requireMap, m]]
+            if (moduleDir === null) { return error('file not found') }
             const r = parseAndFind(packageGet)(moduleDir)(p)
             if (r === undefined) { return error('file not found') }
             const rIdStr = idToString(r.id)

package/commonjs/module/module.f.cjs

@@ -38,10 +38,10 @@ const object = require('../../types/object/module.f.cjs')
  * }} Id
  */
 
-/** @type {(id: Id) => Id | undefined} */
+/** @type {(id: Id) => Id | null} */
 const dir = id => {
     const len = id.path.length
-    if (len < 1) { return undefined }
+    if (len < 1) { return null }
     return {
         package: id.package,
         path: id.path.slice(0, len - 1)

package/commonjs/test.cjs

@@ -6,7 +6,7 @@ module.exports = {
         const source = 'module.exports = "Hello world!"'
         const m = _.compile(source)
         if (m[0] !== 'ok') { throw m }
-        const [result] = m[1](() => { throw 0 })(undefined)
+        const [result] = m[1](() => { throw 0 })(null)
         if (result[0] !== 'ok') { throw result }
         if (result[1] !== 'Hello world!') { throw result }
     },
@@ -24,7 +24,7 @@ module.exports = {
         const source = 'a = 5'
         const m = _.compile(source)
         if (m[0] !== 'ok') { throw m }
-        const [result] = m[1](() => { throw 0 })(undefined)
+        const [result] = m[1](() => { throw 0 })(null)
         if (result[0] !== 'error') { throw result }
     },
     test: () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.0.478",
+  "version": "0.0.479",
   "description": "FunctionalScript is a functional subset of JavaScript",
   "main": "module.f.cjs",
   "scripts": {