functionalscript 0.0.478 → 0.0.480

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,10 +55,10 @@ 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') }
+            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)

package/commonjs/build/test.f.cjs

@@ -11,11 +11,11 @@ const compileMap = {
         'ok',
         require_ => m0 => {
             let [r, m] = require_('./b')(m0);
-            if (r[0] === 'error') { throw r }
+            if (r[0] === 'error') { throw JSON.stringify(r) }
             [r, m] = require_('./a/')(m);
-            if (r[0] === 'error') { throw r }
+            if (r[0] === 'error') { throw JSON.stringify(r) }
             [r, m] = require_('x/r')(m);
-            if (r[0] === 'error') { throw r }
+            if (r[0] === 'error') { throw JSON.stringify(r) }
             return [['ok', ':index.js'], m]
         }],
     ':b.js': [
@@ -71,21 +71,30 @@ const getOrBuild = _.getOrBuild
 
 module.exports = () => {
     let [r, m] = getOrBuild({ package: '', path: ['index.js'] })(undefined)
-    if (JSON.stringify(r) !==
-        '["ok",{"exports":":index.js","requireMap":{"./a/":"/a/index.js","./b":"/b.js","x/r":"/node_modules/x/r.js"}}]'
-    ) {
-        throw r
+    {
+        const x = JSON.stringify(r)
+        if (x !==
+            '["ok",{"exports":":index.js","requireMap":{"./a/":"/a/index.js","./b":"/b.js","x/r":"/node_modules/x/r.js"}}]'
+        ) {
+            throw x
+        }
     }
-    [r, m] = getOrBuild({ package: '', path: ['b.js'] })(m)
-    if (JSON.stringify(r) !==
-        '["ok",{"exports":":b.js","requireMap":{}}]'
-    ) {
-        throw r
+    {
+        [r, m] = getOrBuild({ package: '', path: ['b.js'] })(m)
+        const x = JSON.stringify(r)
+        if (x !==
+            '["ok",{"exports":":b.js","requireMap":{}}]'
+        ) {
+            throw x
+        }
     }
-    [r, m] = getOrBuild({ package: '', path: ['c.js'] })(m)
-    if (JSON.stringify(r) !==
-        '["error",["file not found"]]'
-    ) {
-        throw r
+    {
+        [r, m] = getOrBuild({ package: '', path: ['c.js'] })(m)
+        const x = JSON.stringify(r)
+        if (x !==
+            '["error",["file not found"]]'
+        ) {
+            throw x
+        }
     }
 }

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/path/module.f.cjs

@@ -17,17 +17,17 @@ const module_ = require("../module/module.f.cjs")
 /** @type {(path: string) => readonly string[]} */
 const split = path => path.split('/')
 
-/** @typedef {readonly[list.List<string>] | undefined} OptionList */
+/** @typedef {readonly[list.List<string>] | null} OptionList */
 
 /** @type {(items: string) => (prior: OptionList) => OptionList} */
 const normItemsOp = first => prior => {
-    if (prior === undefined) { return undefined }
+    if (prior === null) { return null }
     const tail = prior[0]
     switch (first) {
         case '': case '.': { return prior }
         case '..': {
             const result = next(tail)
-            if (result === undefined) { return undefined }
+            if (result === list.empty) { return null }
             return [result.tail]
         }
         default: {
@@ -38,46 +38,45 @@ const normItemsOp = first => prior => {
 
 /** @type {(items: list.List<string>) => OptionList} */
 const normItems = items => {
-    const result = fold(normItemsOp)([undefined])(items)
-    return result === undefined ? result : [reverse(result[0])]
+    const result = fold(normItemsOp)([list.empty])(items)
+    return result === null ? result : [reverse(result[0])]
 }
 
-const firstUndefined = first(undefined)
+const firstNull = first(null)
 
-/** @type {(local: string) => (path: string) => LocalPath|undefined} */
+/** @type {(local: string) => (path: string) => LocalPath|null} */
 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(firstUndefined(pathSeq)) ?
+        const dir = [null, '', '.', '..'].includes(pathSeq[pathSeq.length - 1])
+        return /** @type {readonly (string|null)[]} */(['.', '..']).includes(firstNull(pathSeq)) ?
             [false, dir, flat([split(local), pathSeq])] :
             [true, dir, pathSeq]
     }
-    /** @type {(path: string) => LocalPath|undefined} */
-    const f = path => {
+    // /** @type {(path: string) => LocalPath|null} */
+    return path => {
         const [external, dir, items] = fSeq(path)
         const n = normItems(items)
-        if (n === undefined) { return undefined }
+        if (n === null) { return null }
         return {
             external,
             dir,
             items: toArray(n[0])
         }
     }
-    return f
 }
 
 /** @typedef {readonly[string, list.List<string>]} IdPath */
 
-/** @type {(prior: readonly[string|undefined, list.List<string>]) => list.Thunk<IdPath>} */
+/** @type {(prior: readonly[string|null, list.List<string>]) => list.Thunk<IdPath>} */
 const variants = prior => () => {
     const [a, b] = prior
     const r = next(b)
-    if (r === undefined) { return undefined }
+    if (r === list.empty) { return list.empty }
     const { first, tail } = r
     /** @type {IdPath} */
-    const n = [a === undefined ? first : `${a}/${first}`, tail]
+    const n = [a === null ? first : `${a}/${first}`, tail]
     return { first: n, tail: variants(n) }
 }
 
@@ -105,9 +104,9 @@ const parseGlobal = dependencies =>
 {
     const fMap = filterMap(mapDependency(dependencies))
     return dir => items => {
-        const v = variants([undefined, items])
-        const r = firstUndefined(fMap(v))
-        if (r === undefined) { return undefined }
+        const v = variants([null, items])
+        const r = firstNull(fMap(v))
+        if (r === null) { return undefined }
         return { package: r[0], items: toArray(r[1]), dir }
     }
 }
@@ -123,7 +122,7 @@ const parse = packageId => dependencies => {
     const pg = parseGlobal(dependencies)
     return local => path => {
         const parsed = parseLocal(local)(path)
-        if (parsed === undefined) { return undefined }
+        if (parsed === null) { return undefined }
         const {external, dir, items } = parsed
         if (!external) { return { package: packageId, items, dir } }
         return pg(dir)(items)
@@ -134,9 +133,11 @@ const parse = packageId => dependencies => {
  * @typedef {{
  *  readonly id: module_.Id
  *  readonly source: string
- * }| undefined} Result
+ * }} FoundResult
  */
 
+/** @typedef {FoundResult| null} Result */
+
 /**
  * @type {(packageGet: package_.Get) =>
  *  (moduleId: module_.Id) =>
@@ -146,12 +147,12 @@ const parse = packageId => dependencies => {
  */
 const parseAndFind = packageGet => moduleId => path => {
     const currentPack = packageGet(moduleId.package)
-    if (currentPack === undefined) { return undefined }
+    if (currentPack === undefined) { return null }
     const p = parse(moduleId.package)(currentPack.dependency)(moduleId.path.join('/'))(path)
-    if (p === undefined) { return undefined }
+    if (p === undefined) { return null }
     const pack = packageGet(p.package)
-    if (pack === undefined) { return undefined }
-    /** @type {(file: string) => Result } */
+    if (pack === undefined) { return null }
+    /** @type {(file: string) => FoundResult | undefined } */
     const tryFile = file => {
         const source = pack.file(file)
         return source === undefined ? undefined : { id: { package: p.package, path: file.split('/') }, source }
@@ -159,7 +160,7 @@ const parseAndFind = packageGet => moduleId => path => {
     const file = p.items.join('/')
     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))
+    return firstNull(filterMap(tryFile)(fileList))
 }
 
 module.exports = {

package/commonjs/path/test.f.cjs

@@ -6,80 +6,85 @@ const object = require('../../types/object/module.f.cjs')
 const { at } = require('../../types/object/module.f.cjs')
 const package_ = require('../package/module.f.cjs')
 
+/** @type {<T>(o: object.Map<T>) => (s: string) => T|undefined} */
+const i = o => s => {
+    const r = at(s)(o)
+    return r === null ? undefined : r
+}
+
 /** @type {(g: json.Unknown|undefined) => string} */
 const stringify = g => {
     if (g === undefined) { throw g }
     return json.stringify(identity)(g)
 }
 
-module.exports = [
-    () => {
-        const p = { name: '', version: '' }
+module.exports = {
+    0: () => {
         const result = _.parseLocal('')('./a')
         if (stringify(result) !== '{"external":false,"dir":false,"items":["a"]}') { throw result }
     },
-    () => {
+    1: () => {
         const result = _.parseLocal('')('./a/')
         if (stringify(result) !== '{"external":false,"dir":true,"items":["a"]}') { throw result }
     },
-    () => {
+    2: () => {
         const result = _.parseLocal('')('..')
-        if (result !== undefined) { throw result }
+        if (result !== null) { throw result }
     },
-    () => {
+    3: () => {
         const result = _.parseLocal('a')('')
         if (stringify(result) !== '{"external":true,"dir":true,"items":[]}') { throw result }
     },
-    () => {
+    4: () => {
         const result = _.parseLocal('')('./a/b/.././c')
         if (stringify(result) !== '{"external":false,"dir":false,"items":["a","c"]}') { throw result }
     },
-    () => {
+    5: () => {
         const result = _.parseLocal('x/r')('./a/b/.././c')
         if (stringify(result) !== '{"external":false,"dir":false,"items":["x","r","a","c"]}') { throw result }
     },
-    () => {
+    6: () => {
         const result = _.parseLocal('a')('a/b/.././c')
         if (stringify(result) !== '{"external":true,"dir":false,"items":["a","c"]}') { throw result }
     },
-    () => {
+    7: () => {
         const result = _.parseLocal('')('./x/..')
         if (stringify(result) !== '{"external":false,"dir":true,"items":[]}') { throw result }
     },
-    () => {
+    8: () => {
         if (_.parseGlobal(() => undefined)(false)(['a', 'b']) !== undefined) { throw 'error' }
         if (_.parseGlobal(() => undefined)(false)(['b']) !== undefined) { throw 'error' }
-        if (_.parseGlobal(d => at(d)({ b: 'x' }))(false)(['d']) !== undefined) { throw 'error' }
+        if (_.parseGlobal(i({ b: 'x' }))(false)(['d']) !== undefined) { throw 'error' }
         {
-            const result = stringify(_.parseGlobal(d => at(d)({ b: 'x' }))(false)(['b']))
+            const result = stringify(_.parseGlobal(i({ b: 'x' }))(false)(['b']))
             if (result !== '{"package":"x","items":[],"dir":false}') { throw result }
         }
-        if (_.parseGlobal(d => at(d)({ 'b/r': 'x' }))(false)(['b']) !== undefined) { throw 'error' }
+        if (_.parseGlobal(i({ 'b/r': 'x' }))(false)(['b']) !== undefined) { throw 'error' }
         {
-            const result = stringify(_.parseGlobal(d => at(d)({ 'b/r': 'x' }))(false)(['b', 'r']))
+            const result = stringify(_.parseGlobal(i({ 'b/r': 'x' }))(false)(['b', 'r']))
             if (result !== '{"package":"x","items":[],"dir":false}') { throw result }
         }
         {
-            const result = stringify(_.parseGlobal(d => at(d)({ 'b/r': 'x' }))(false)(['b', 'r', 'd', 't']))
+            const result = stringify(_.parseGlobal(i({ 'b/r': 'x' }))(false)(['b', 'r', 'd', 't']))
             if (result !== '{"package":"x","items":["d","t"],"dir":false}') { throw result }
         }
         {
-            const result = stringify(_.parseGlobal(d => at(d)({ 'b/r': 'x' }))(true)(['b', 'r', 'd', 't']))
+            const result = stringify(_.parseGlobal(i({ 'b/r': 'x' }))(true)(['b', 'r', 'd', 't']))
             if (result !== '{"package":"x","items":["d","t"],"dir":true}') { throw result }
         }
     },
-    () => {
+    9: () => {
         /** @type {object.Map<package_.Package>} */
         const packages = {
             '': {
                 dependency: () => todo(),
-                file: path => at(path)({ 'a/c': 'return "a/c"' }),
+                file: i({ 'a/c': 'return "a/c"' }),
             }
         }
-        const result = stringify(_.parseAndFind(p => at(p)(packages))({ package: '', path: ['a', 'b'] })('../c'))
+        const result = stringify(_.parseAndFind(i(packages))({ package: '', path: ['a', 'b'] })('../c'))
         if (result !== '{"id":{"package":"","path":["a","c"]},"source":"return \\"a/c\\""}') { throw result }
     },
-    () => {
+    10: () => {
         /** @type {object.Map<package_.Package>} */
         const packages = {
             '': {
@@ -87,7 +92,7 @@ module.exports = [
                     const path = `node_modules/${x}`
                     return at(path)(packages) !== undefined ? path : undefined
                 },
-                file: path => at(path)({
+                file: i({
                     'index.js': 'return "index.js"',
                     'x/index.js': 'return "x/index.js"',
                     'x.js': 'return "x.js"',
@@ -95,87 +100,87 @@ module.exports = [
             },
             'node_modules/z': {
                 dependency: () => todo(),
-                file: path => at(path)({ 'a/c/index.js': 'return "a/c"' }),
+                file: i({ 'a/c/index.js': 'return "a/c"' }),
             }
         }
         {
-            const result = stringify(_.parseAndFind(p => at(p)(packages))({ package: '', path: ['a', 'b'] })('z/a/c'))
+            const result = stringify(_.parseAndFind(i(packages))({ package: '', path: ['a', 'b'] })('z/a/c'))
             if (result !== '{"id":{"package":"node_modules/z","path":["a","c","index.js"]},"source":"return \\"a/c\\""}') {
                 throw result
             }
         }
         {
-            const result = stringify(_.parseAndFind(p => at(p)(packages))({ package: '', path: ['a', 'b'] })('../..'))
+            const result = stringify(_.parseAndFind(i(packages))({ package: '', path: ['a', 'b'] })('../..'))
             if (result !== '{"id":{"package":"","path":["index.js"]},"source":"return \\"index.js\\""}') { throw result }
         }
         {
-            const result = stringify(_.parseAndFind(p => at(p)(packages))({ package: '', path: [] })('./x'))
+            const result = stringify(_.parseAndFind(i(packages))({ package: '', path: [] })('./x'))
             if (result !== '{"id":{"package":"","path":["x.js"]},"source":"return \\"x.js\\""}') { throw result }
         }
         {
-            const result = stringify(_.parseAndFind(p => at(p)(packages))({ package: '', path: [] })('./x.js'))
+            const result = stringify(_.parseAndFind(i(packages))({ package: '', path: [] })('./x.js'))
             if (result !== '{"id":{"package":"","path":["x.js"]},"source":"return \\"x.js\\""}') { throw result }
         }
         {
-            const result = stringify(_.parseAndFind(p => at(p)(packages))({ package: '', path: [] })('./x/'))
+            const result = stringify(_.parseAndFind(i(packages))({ package: '', path: [] })('./x/'))
             if (result !== '{"id":{"package":"","path":["x","index.js"]},"source":"return \\"x/index.js\\""}') { throw result }
         }
         {
-            const result = stringify(_.parseAndFind(p => at(p)(packages))({ package: '', path: ['x', 'a'] })('../'))
+            const result = stringify(_.parseAndFind(i(packages))({ package: '', path: ['x', 'a'] })('../'))
             if (result !== '{"id":{"package":"","path":["x","index.js"]},"source":"return \\"x/index.js\\""}') { throw result }
         }
         {
-            const result = stringify(_.parseAndFind(p => at(p)(packages))({ package: '', path: ['x', 'a'] })('..'))
+            const result = stringify(_.parseAndFind(i(packages))({ package: '', path: ['x', 'a'] })('..'))
             if (result !== '{"id":{"package":"","path":["x","index.js"]},"source":"return \\"x/index.js\\""}') { throw result }
         }
     },
-    () => {
+    11: () => {
         /** @type {object.Map<package_.Package>} */
         const packages = {
             '': {
                 dependency: x => {
                     const path = `node_modules/${x}`
-                    return at(path)(packages) !== undefined ? path : undefined
+                    return at(path)(packages) !== null ? path : undefined
                 },
                 file: todo
             },
             'node_modules/z/a': {
                 dependency: () => todo(),
-                file: path => at(path)({
+                file: i({
                     'c/index.js': 'return "c/index.js"',
                     'c.js': 'return "c.js"'
                 }),
             }
         }
         {
-            const result = stringify(_.parseAndFind(p => at(p)(packages))({ package: '', path: ['a', 'b'] })('z/a/c'))
+            const result = stringify(_.parseAndFind(i(packages))({ package: '', path: ['a', 'b'] })('z/a/c'))
             if (result !== '{"id":{"package":"node_modules/z/a","path":["c.js"]},"source":"return \\"c.js\\""}') { throw result }
         }
         {
-            const result = stringify(_.parseAndFind(p => at(p)(packages))({ package: '', path: ['a', 'b'] })('z/a/c/'))
+            const result = stringify(_.parseAndFind(i(packages))({ package: '', path: ['a', 'b'] })('z/a/c/'))
             if (result !== '{"id":{"package":"node_modules/z/a","path":["c","index.js"]},"source":"return \\"c/index.js\\""}') { throw result }
         }
     },
-    () => {
+    12: () => {
         /** @type {object.Map<package_.Package>} */
         const packages = {
             '': {
                 dependency: x => {
                     const path = `node_modules/${x}`
-                    return at(path)(packages) !== undefined ? path : undefined
+                    return at(path)(packages) !== null ? path : undefined
                 },
                 file: todo
             },
             'node_modules/z/a/c': {
                 dependency: () => todo(),
-                file: path => at(path)({
+                file: i({
                     '': 'throw',
                     '.js': 'throw',
                     'index.js': 'return "a/c"'
                 }),
             }
         }
-        const result = stringify(_.parseAndFind(p => at(p)(packages))({ package: '', path: ['a', 'b'] })('z/a/c'))
+        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.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.480",
   "description": "FunctionalScript is a functional subset of JavaScript",
   "main": "module.f.cjs",
   "scripts": {

package/types/object/module.f.cjs

@@ -16,8 +16,11 @@ const { getOwnPropertyDescriptor, fromEntries: objectFromEntries } = Object
  * @typedef {readonly[string, T]} Entry
  */
 
-/** @type {(name: string) => <T>(object: Map<T>) => T|undefined} */
-const at = name => object => getOwnPropertyDescriptor(object, name)?.value
+/** @type {(name: string) => <T>(object: Map<T>) => T|null} */
+const at = name => object => {
+    const r = getOwnPropertyDescriptor(object, name)
+    return r === void 0 ? null : r.value
+}
 
 /** @type {<T>(e: list.List<Entry<T>>) => list.List<Entry<T>>} */
 const sort = e => mapEntries(mapFromEntries(e))
@@ -26,7 +29,7 @@ const sort = e => mapEntries(mapFromEntries(e))
 const fromEntries = e => objectFromEntries(iterable(e))
 
 /** @type {<T>(m: map.Map<T>) => Map<T>} */
-const fromMap =  m => fromEntries(mapEntries(m))
+const fromMap = m => fromEntries(mapEntries(m))
 
 module.exports = {
     /** @readonly */

package/types/object/test.f.cjs

@@ -4,7 +4,7 @@ module.exports = {
     ctor: () => {
         const a = {}
         const value = _.at('constructor')(a)
-        if (value !== undefined) { throw value }
+        if (value !== null) { throw value }
     },
     property: () => {
         const a = { constructor: 42 }