functionalscript 0.0.479 → 0.0.481

package/commonjs/build/module.f.cjs

@@ -58,7 +58,7 @@ const getOrBuild = compile => packageGet => moduleMapInterface =>  {
             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)
@@ -90,10 +90,10 @@ const getOrBuild = compile => packageGet => moduleMapInterface =>  {
         }
         // check package
         const p = packageGet(moduleId.package)
-        if (p === undefined) { return notFound(moduleMap) }
+        if (p === null) { return notFound(moduleMap) }
         // check file
         const source = p.file(moduleId.path.join('/'))
-        return (source === undefined ? notFound : build(undefined)(moduleId)(source))(moduleMap)
+        return (source === null ? notFound : build(undefined)(moduleId)(source))(moduleMap)
     }
     return f
 }

package/commonjs/build/test.f.cjs

@@ -4,6 +4,7 @@ const module_ = require('../module/module.f.cjs')
 const function_ = require('../module/function/module.f.cjs')
 const result = require('../../types/result/module.f.cjs')
 const package_ = require('../package/module.f.cjs')
+const { at } = require('../../types/object/module.f.cjs')
 
 /** @type {{ readonly [k in string]?: result.Result<function_.Function_, unknown> }} */
 const compileMap = {
@@ -11,11 +12,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': [
@@ -32,9 +33,9 @@ const compileMap = {
 /** @type {function_.Compile} */
 const compile = source => compileMap[source] ?? ['error', 'invalid source']
 
-/** @typedef {{ readonly [k in string]?: string }} StringMap */
+/** @typedef {{ readonly [k in string]: string }} StringMap */
 
-/** @type {{ readonly [k in string]?: { readonly dependencies: StringMap, files: StringMap }}} */
+/** @type {{ readonly [k in string]: { readonly dependencies: StringMap, readonly files: StringMap }}} */
 const packageMap = {
     '': {
         dependencies: {
@@ -56,11 +57,11 @@ const packageMap = {
 
 /** @type {package_.Get} */
 const packageGet = packageId => {
-    const p = packageMap[packageId]
-    return p === undefined ? undefined :
+    const p = at(packageId)(packageMap)
+    return p === null ? null :
         {
-            dependency: dependency => p.dependencies[dependency],
-            file: file => p.files[file]
+            dependency: dependency => at(dependency)(p.dependencies),
+            file: file => at(file)(p.files),
         }
 }
 
@@ -71,21 +72,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/package/module.f.cjs

@@ -22,14 +22,14 @@ const isPackageJson = j => {
 
 /**
  * @typedef {{
- *  readonly dependency: (localPackageId: string) => string | undefined
- *  readonly file: (localFileId: string) => string | undefined
+ *  readonly dependency: (localPackageId: string) => string | null
+ *  readonly file: (localFileId: string) => string | null
  * }} Package
  */
 
 /**
  * @note Current package has an empty string '' as a packageId.
- * @typedef {(packageId: string) => Package | undefined} Get
+ * @typedef {(packageId: string) => Package | null} Get
  */
 
 module.exports = {

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,53 +38,52 @@ 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) }
 }
 
-/** @type {(d: (local: string) => string|undefined) => (p: IdPath) => IdPath|undefined} */
+/** @type {(d: (local: string) => string|null) => (p: IdPath) => IdPath|undefined} */
 const mapDependency = d => ([external, internal]) => {
     const id = d(external)
-    return id === undefined ? undefined : [id, internal]
+    return id === null ? undefined : [id, internal]
 }
 
 /**
@@ -96,34 +95,34 @@ const mapDependency = d => ([external, internal]) => {
  */
 
 /**
- * @type {(d: (local: string) => string|undefined) =>
+ * @type {(d: (local: string) => string|null) =>
  *  (dir: boolean) =>
  *  (items: list.List<string>) =>
- *  Path|undefined}
+ *  Path|null}
  */
 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 null }
         return { package: r[0], items: toArray(r[1]), dir }
     }
 }
 
 /**
  * @type {(packageId: string) =>
- *  (dependencies: (local: string) => string|undefined) =>
+ *  (dependencies: (local: string) => string|null) =>
  *  (local: string) =>
  *  (path: string) =>
- *  Path|undefined }
+ *  Path|null }
  */
 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 null }
         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,20 +147,20 @@ const parse = packageId => dependencies => {
  */
 const parseAndFind = packageGet => moduleId => path => {
     const currentPack = packageGet(moduleId.package)
-    if (currentPack === undefined) { return undefined }
+    if (currentPack === null) { return null }
     const p = parse(moduleId.package)(currentPack.dependency)(moduleId.path.join('/'))(path)
-    if (p === undefined) { return undefined }
+    if (p === null) { return null }
     const pack = packageGet(p.package)
-    if (pack === undefined) { return undefined }
-    /** @type {(file: string) => Result } */
+    if (pack === null) { 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 }
+        return source === null ? undefined : { id: { package: p.package, path: file.split('/') }, source }
     }
     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,88 +6,90 @@ 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|null} */
+const i = o => s => at(s)(o)
+
 /** @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 }
     },
-    () => {
-        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' }
-        {
-            const result = stringify(_.parseGlobal(d => at(d)({ b: 'x' }))(false)(['b']))
+    8: {
+        0: () => { if (_.parseGlobal(() => null)(false)(['a', 'b']) !== null) { throw 'error' } },
+        1: () => { if (_.parseGlobal(() => null)(false)(['b']) !== null) { throw 'error' } },
+        2: () => { if (_.parseGlobal(i({ b: 'x' }))(false)(['d']) !== null) { throw 'error' } },
+        3: () => {
+            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' }
-        {
-            const result = stringify(_.parseGlobal(d => at(d)({ 'b/r': 'x' }))(false)(['b', 'r']))
+        },
+        4: () => { if (_.parseGlobal(i({ 'b/r': 'x' }))(false)(['b']) !== null) { throw 'error' } },
+        5: () => {
+            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']))
+        },
+        6: () => {
+            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']))
+        },
+        7: () => {
+            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 = {
             '': {
                 dependency: x => {
                     const path = `node_modules/${x}`
-                    return at(path)(packages) !== undefined ? path : undefined
+                    return at(path)(packages) !== null ? path : null
                 },
-                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 +97,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 : null
                 },
                 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 : null
                 },
                 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.0.479",
+  "version": "0.0.481",
   "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 }