functionalscript 0.0.487 → 0.0.488

package/com/cpp/module.f.cjs

@@ -66,8 +66,7 @@ const cpp = name => lib => {
         if (typeof (t) === 'string') { return baseType(t) }
         if (t.length === 2) { return `${type(t[1])} const*` }
         const [id] = t
-        if ('interface' in lib[id]) { return i(id) }
-        return id
+        return 'interface' in lib[id] ? i(id) : id
     }
 
     const type = objectType(comRef)

package/com/cpp/test.f.cjs

@@ -36,7 +36,7 @@ const f = () =>
         '        virtual void SetManagedStruct(ManagedStruct a) const noexcept = 0;\n' +
         '    };\n' +
         '}'
-    if (cpp !== e) { throw cpp }
+    if (cpp() !== e) { throw cpp }
 }
 
 module.exports = f

package/com/cpp/testlib.f.cjs

@@ -3,4 +3,4 @@ const { flat } = require("../../text/module.f.cjs")
 const library = require('../types/testlib.f.cjs')
 const { cpp } = require('./module.f.cjs')
 
-module.exports = join('\n')(flat('    ')(cpp('My')(library)))
+module.exports = () => join('\n')(flat('    ')(cpp('My')(library)))

package/com/test/build.f.cjs

@@ -65,7 +65,7 @@ const output = platform => name => {
 const cpp = ({dirname, platform}) => ({
     file: {
         name: `${dirname}/cpp/_result.hpp`,
-        content: cppContent,
+        content: cppContent(),
     },
     line: [
         flat([

package/commonjs/build/module.f.cjs

@@ -86,7 +86,7 @@ const getOrBuild = compile => packageGet => moduleMapInterface =>  {
         // check moduleMap
         {
             const m = moduleMapInterface.at(moduleIdStr)(moduleMap)
-            if (m !== undefined) { return [m, moduleMap] }
+            if (m !== null) { return [m, moduleMap] }
         }
         // check package
         const p = packageGet(moduleId.package)

package/commonjs/build/test.f.cjs

@@ -73,11 +73,12 @@ const getOrBuild = _.getOrBuild
 module.exports = () => {
     let [r, m] = getOrBuild({ package: '', path: ['index.js'] })(map.empty)
     {
+        if (r === null) { throw 'r === null' }
         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
+            throw `0:${x}`
         }
     }
     {

package/commonjs/module/module.f.cjs

@@ -3,7 +3,7 @@ const object = require('../../types/object/module.f.cjs')
 /**
  * @template M
  * @typedef {{
- *  readonly at: (moduleId: string) => (moduleMap: M) => State | undefined
+ *  readonly at: (moduleId: string) => (moduleMap: M) => State | null
  *  readonly setReplace: (moduleId: string) => (moduleState: State) => (moduleMap: M) => M
  * }} MapInterface
  */

package/commonjs/path/module.f.cjs

@@ -27,7 +27,7 @@ const normItemsOp = first => prior => {
         case '': case '.': { return prior }
         case '..': {
             const result = next(tail)
-            if (result === list.empty) { return null }
+            if (result === null) { return null }
             return [result.tail]
         }
         default: {
@@ -80,10 +80,10 @@ const variants = prior => () => {
     return { first: n, tail: variants(n) }
 }
 
-/** @type {(d: (local: string) => string|null) => (p: IdPath) => IdPath|undefined} */
+/** @type {(d: (local: string) => string|null) => (p: IdPath) => IdPath|null} */
 const mapDependency = d => ([external, internal]) => {
     const id = d(external)
-    return id === null ? undefined : [id, internal]
+    return id === null ? null : [id, internal]
 }
 
 /**
@@ -152,10 +152,10 @@ const parseAndFind = packageGet => moduleId => path => {
     if (p === null) { return null }
     const pack = packageGet(p.package)
     if (pack === null) { return null }
-    /** @type {(file: string) => FoundResult | undefined } */
+    /** @type {(file: string) => FoundResult | null } */
     const tryFile = file => {
         const source = pack.file(file)
-        return source === null ? undefined : { id: { package: p.package, path: file.split('/') }, source }
+        return source === null ? null : { id: { package: p.package, path: file.split('/') }, source }
     }
     const file = p.items.join('/')
     const indexJs = join('/')(concat(p.items)(['index.js']))

package/dev/test.mjs

@@ -4,7 +4,7 @@ import { loadModuleMap } from './module.mjs'
 const main = async() => {
     const moduleMap = await loadModuleMap()
 
-    /** @type {(s: string) => (_: undefined) => undefined} */
+    /** @type {(s: string) => <T>(_: T) => T} */
     const log = s => state => {
         console.log(s)
         return state

package/doc/predefined.md

@@ -8,7 +8,7 @@ Global objects. Global objects can't be assigned to something `const r = Object`
 
 - [x] `Infinity`
 - [x] `NaN`
-- [x] `undefined`
+- [ ] `undefined`
 - [ ] `globalThis`
 
 ### Function properties
@@ -120,7 +120,7 @@ https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects
 
 - [ ] ! `constructor`. The property can create a new function. For example
   ```js
-  const f = (() => undefined).constructor('a', 'return a * a')
+  const f = (() => null).constructor('a', 'return a * a')
   ```
 - [ ] deprecated `__proto__`
 - [ ] ! deprecated `__defineGetter__`. The property can mutate an object.

package/fsc/test.f.cjs

@@ -6,7 +6,7 @@ const s = stringify(i => i)
 /** @type {(v: string) => string} */
 const f = v => {
     const n = one(v)
-    return s(_.init(undefined)(n)[0])
+    return s(_.init(null)(n)[0])
 }
 
 module.exports = {

package/json/module.f.cjs

@@ -17,13 +17,13 @@ const { entries } = Object
 
 /** @typedef {Object|boolean|string|number|null|Array} Unknown */
 
-/** @type {(value: Unknown) => (path: list.List<string>) => (src: Unknown|undefined) => Unknown} */
+/** @type {(value: Unknown) => (path: list.List<string>) => (src: Unknown) => Unknown} */
 const setProperty = value => {
-    /** @type {(path: list.List<string>) => (src: Unknown|undefined) => Unknown} */
+    /** @type {(path: list.List<string>) => (src: Unknown) => Unknown} */
     const f = path => src => {
         const result = next(path)
-        if (result === undefined) { return value }
-        const srcObject = (src === undefined || src === null || typeof src !== 'object' || src instanceof Array) ? {} : src
+        if (result === null) { return value }
+        const srcObject = (src === null || typeof src !== 'object' || src instanceof Array) ? {} : src
         const { first, tail } = result
         return { ...srcObject, [first]: f(tail)(at(first)(srcObject)) }
     }

package/package.json

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

package/text/README.md

@@ -37,7 +37,7 @@ Total error states:
 ### utf8/module.f.cjs
 
 ```js
-/** @type {(input: List<u8|undefined>) => List<i32>} */
+/** @type {(input: List<u8|null>) => List<i32>} */
 const toCodePointList
 
 /** @type {(input: List<i32>) => List<u8>} */
@@ -72,7 +72,7 @@ Total error states: 11 bit
 ### utf16/module.f.cjs
 
 ```js
-/** @type {(input: List<u16|undefined>) => List<i32>} */
+/** @type {(input: List<u16|null>) => List<i32>} */
 const toCodePointList
 
 /** @type {(input: List<i32>) => List<u16>} */

package/text/utf8/module.f.cjs

@@ -3,11 +3,11 @@ const operator = require('../../types/function/operator/module.f.cjs')
 const array = require('../../types/array/module.f.cjs')
 const { flatMap, flat, stateScan } = list
 
-/** @typedef {u8|undefined} ByteOrEof */
+/** @typedef {u8|null} ByteOrEof */
 
 /** @typedef {array.Array1<number>|array.Array2<number>|array.Array3<number>} Utf8NonEmptyState */
 
-/** @typedef {undefined|Utf8NonEmptyState} Utf8State */
+/** @typedef {null|Utf8NonEmptyState} Utf8State */
 
 /** @typedef {number} u8 */
 
@@ -50,45 +50,45 @@ const utf8ByteToCodePointOp = state => byte => {
     if (byte < 0x00 || byte > 0xff) {
         return [[errorMask], state]
     }
-    if (state == undefined) {
-        if (byte < 0b1000_0000) { return [[byte], undefined] }
+    if (state === null) {
+        if (byte < 0b1000_0000) { return [[byte], null] }
         if (byte >= 0b1100_0010 && byte <= 0b1111_0100) { return [[], [byte]] }
-        return [[byte | errorMask], undefined]
+        return [[byte | errorMask], null]
     }
     if (byte >= 0b1000_0000 && byte < 0b1100_0000) {
         switch (state.length) {
             case 1:
-                if (state[0] < 0b1110_0000) { return [[((state[0] & 0b0001_1111) << 6) + (byte & 0b0011_1111)], undefined] }
+                if (state[0] < 0b1110_0000) { return [[((state[0] & 0b0001_1111) << 6) + (byte & 0b0011_1111)], null] }
                 if (state[0] < 0b1111_1000) { return [[], [state[0], byte]] }
                 break
             case 2:
-                if (state[0] < 0b1111_0000) { return [[((state[0] & 0b0000_1111) << 12) + ((state[1] & 0b0011_1111) << 6) + (byte & 0b0011_1111)], undefined] }
+                if (state[0] < 0b1111_0000) { return [[((state[0] & 0b0000_1111) << 12) + ((state[1] & 0b0011_1111) << 6) + (byte & 0b0011_1111)], null] }
                 if (state[0] < 0b1111_1000) { return [[], [state[0], state[1], byte]] }
                 break
             case 3:
-                return [[((state[0] & 0b0000_0111) << 18) + ((state[1] & 0b0011_1111) << 12) + ((state[2] & 0b0011_1111) << 6) + (byte & 0b0011_1111)], undefined]
+                return [[((state[0] & 0b0000_0111) << 18) + ((state[1] & 0b0011_1111) << 12) + ((state[2] & 0b0011_1111) << 6) + (byte & 0b0011_1111)], null]
         }
     }
     const error = utf8StateToError(state)
-    if (byte < 0b1000_0000) { return [[error, byte], undefined] }
+    if (byte < 0b1000_0000) { return [[error, byte], null] }
     if (byte >= 0b1100_0010 && byte <= 0b1111_0100) { return [[error], [byte]] }
-    return [[error, byte | errorMask], undefined]
+    return [[error, byte | errorMask], null]
 }
 
 /** @type {(state: Utf8State) => readonly[list.List<i32>, Utf8State]} */
 const utf8EofToCodePointOp = state => {
-    if (state === undefined) { return [undefined, undefined] }
-    return [[utf8StateToError(state)], undefined]
+    if (state === null) { return [null, null] }
+    return [[utf8StateToError(state)], null]
 }
 
 /** @type {operator.StateScan<ByteOrEof, Utf8State, list.List<i32>>} */
-const utf8ByteOrEofToCodePointOp = state => input => input === undefined ? utf8EofToCodePointOp(state) : utf8ByteToCodePointOp(state)(input)
+const utf8ByteOrEofToCodePointOp = state => input => input === null ? utf8EofToCodePointOp(state) : utf8ByteToCodePointOp(state)(input)
 
 /** @type {list.List<ByteOrEof>} */
-const eofList = [undefined]
+const eofList = [null]
 
 /** @type {(input: list.List<u8>) => list.List<i32>} */
-const toCodePointList = input => flat(stateScan(utf8ByteOrEofToCodePointOp)(undefined)(flat([input, eofList])))
+const toCodePointList = input => flat(stateScan(utf8ByteOrEofToCodePointOp)(null)(flat([input, eofList])))
 
 module.exports = {
     /** @readonly */

package/types/array/module.f.cjs

@@ -1,4 +1,4 @@
-const option = require('../option/module.f.cjs')
+const option = require('../nullable/module.f.cjs')
 const { map } = option
 
 /**
@@ -84,14 +84,17 @@ const uncheckTail = a => a.slice(1)
 /** @type {<T>(_: readonly T[]) => readonly T[]} */
 const uncheckHead = a => a.slice(0, -1)
 
-/** @type {<T>(a: T|undefined) => T|null} */
-const undefinedToNull = a => a === void 0 ? null : a
+/** @type {(index: number) => <T>(a: readonly T[]) => T|null} */
+const unsafeAt = i => a => {
+    const r = a[i]
+    return r === void 0 ? null : r
+}
 
 /** @type {<T>(_: readonly T[]) => T|null} */
-const first = a => undefinedToNull(a[0])
+const first = unsafeAt(0)
 
 /** @type {<T>(_: readonly T[]) => T|null} */
-const last = a => undefinedToNull(a[a.length - 1])
+const last = a => unsafeAt(a.length - 1)(a)
 
 /** @type {<T>(_: readonly T[]) => readonly T[] | null} */
 const tail = a => a.length === 0 ? null : uncheckTail(a)
@@ -101,7 +104,7 @@ const splitFirst = a => {
     /** @typedef {typeof a[0]} T*/
     /** @type {(_: T) => readonly[T, readonly T[]]} */
     const split = first => [first, uncheckTail(a)]
-    return undefinedToNull(map(split)(a[0]))
+    return map(split)(first(a))
 }
 
 /** @type {<T>(_: readonly T[]) => readonly T[]|null} */

package/types/btree/find/module.f.cjs

@@ -94,7 +94,7 @@ const find = c => {
             }
         }
     }
-    return f(undefined)
+    return f(null)
 }
 
 /** @type {<T>(first: First<T>) => boolean} */
@@ -105,7 +105,7 @@ const isFound = ([i]) => {
     }
 }
 
-/** @type {<T>(first: First<T>) => T | undefined} */
+/** @type {<T>(first: First<T>) => T | null} */
 const value = ([i, r]) => {
     switch (i) {
         case 1: {
@@ -118,7 +118,7 @@ const value = ([i, r]) => {
             return r.length === 2 ? r[1] : r[3]
         }
         default: {
-            return undefined
+            return null
         }
     }
 }

package/types/btree/module.f.cjs

@@ -1,6 +1,6 @@
 const list = require('../list/module.f.cjs')
 const { flat } = list
-const { map } = require('../option/module.f.cjs')
+const { map } = require('../nullable/module.f.cjs')
 const _ = require('./types/module.f.cjs')
 
 /** @type {<T>(node: _.Node<T>) => list.Thunk<T>} */
@@ -31,7 +31,7 @@ const values = map(nodeValues)
 
 module.exports = {
     /** @readonly */
-    empty: undefined,
+    empty: null,
     /** @readonly */
     find: require('./find/module.f.cjs'),
     /** @readonly */

package/types/btree/remove/module.f.cjs

@@ -4,11 +4,11 @@ const find = require('../find/module.f.cjs')
 const list = require('../../list/module.f.cjs')
 const { fold, concat, next } = list
 const array = require('../../array/module.f.cjs')
-const { map } = require('../../option/module.f.cjs')
+const { map } = require('../../nullable/module.f.cjs')
 
 /**
  * @template T
- * @typedef {undefined | _.Leaf1<T>} Leaf01
+ * @typedef {null | _.Leaf1<T>} Leaf01
  */
 
 /**
@@ -22,7 +22,7 @@ const { map } = require('../../option/module.f.cjs')
 /** @type {<T>(tail: find.Path<T>) => (n: _.Node<T>) => readonly[T, RemovePath<T>]} */
 const path = tail => n => {
     switch (n.length) {
-        case 1: { return [n[0], { first: undefined, tail }] }
+        case 1: { return [n[0], { first: null, tail }] }
         case 2: { return [n[0], { first: [n[1]], tail }] }
         case 3: { return path({ first: [0, n], tail })(n[0]) }
         case 5: { return path({ first: [0, n], tail })(n[0]) }
@@ -65,7 +65,7 @@ const reduceValue2 = a => n => {
 /** @type {<T>(a: Leaf01<T>) => (n: _.Branch3<T>) => _.Branch1<T> | _.Branch3<T>} */
 const initValue0 = a => n => {
     const [, v1, n2] = n
-    if (a === undefined) {
+    if (a === null) {
         switch (n2.length) {
             case 1: { return [[v1, ...n2]] }
             case 2: { return [[v1], n2[0], [n2[1]]] }
@@ -79,7 +79,7 @@ const initValue0 = a => n => {
 /** @type {<T>(a: Leaf01<T>) => (n: _.Branch3<T>) => _.Branch1<T> | _.Branch3<T>} */
 const initValue1 = a => n => {
     const [n0, v1] = n
-    if (a === undefined) {
+    if (a === null) {
         switch (n0.length) {
             case 1: { return [[...n0, v1]] }
             case 2: { return [[n0[0]], n0[1], [v1]] }
@@ -118,19 +118,19 @@ const initReduce = reduceX([initValue0, initValue1])
 /** @type {<T>(c: cmp.Compare<T>) => (node: _.Node<T>) => _.Tree<T>} */
 const nodeRemove = c => node => {
     /** @typedef {typeof c extends cmp.Compare<infer T> ? T : never} T */
-    /** @type  {() => undefined | RemovePath<T>} */
+    /** @type  {() => null | RemovePath<T>} */
     const f = () => {
         const { first, tail } = find.find(c)(node)
         /** @type {(n: _.Node<T>) => (f: (v: T) => find.PathItem<T>) => RemovePath<T>} */
         const branch = n => f => {
-            const [v, p] = path(/** @type {find.Path<T>} */(undefined))(n)
+            const [v, p] = path(/** @type {find.Path<T>} */(null))(n)
             return { first: p.first, tail: concat(p.tail)({ first: f(v), tail }) }
         }
         const [i, n] = first
         switch (i) {
             case 1: {
                 switch (n.length) {
-                    case 1: { return { first: undefined, tail } }
+                    case 1: { return { first: null, tail } }
                     case 2: { return { first: [n[1]], tail } }
                     case 3: { return branch(n[2])(v => [2, [n[0], v, n[2]]]) }
                     case 5: { return branch(n[2])(v => [2, [n[0], v, n[2], n[3], n[4]]]) }
@@ -142,14 +142,14 @@ const nodeRemove = c => node => {
                     case 5: { return branch(n[4])(v => [4, [n[0], n[1], n[2], v, n[4]]]) }
                 }
             }
-            default: { return undefined }
+            default: { return null }
         }
     }
     const r = f()
-    if (r === undefined) { return node }
+    if (r === null) { return node }
     const { first, tail } = r
     const tailR = next(tail)
-    if (tailR === undefined) { return first }
+    if (tailR === null) { return first }
     const { first: tf, tail: tt } = tailR
     const result = reduce(initReduce(tf)(first))(tt)
     return result.length === 1 ? result[0] : result