functionalscript 0.0.481 → 0.0.483

package/commonjs/build/module.f.cjs

@@ -3,13 +3,13 @@ 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 { setReplace } = map
+const { empty: mapEmpty, setReplace } = map
 const object = require('../../types/object/module.f.cjs')
 const { fromMap } = object
 const path = require('../path/module.f.cjs')
 const { parseAndFind } = path
 const stringSet = require('../../types/string_set/module.f.cjs')
-const { set: setSet, contains: setContains } = stringSet
+const { set: setSet, contains: setContains, empty: stringSetEmpty } = stringSet
 
 /**
  * @template M
@@ -73,7 +73,7 @@ const getOrBuild = compile => packageGet => moduleMapInterface =>  {
             const [kind, result] = compile(source)
             if (kind === 'error') { return error(['compilation error', result])(moduleMap) }
             // build
-            const [[state, value], [requireMap, moduleMap2]] = result(require_)([undefined, moduleMap])
+            const [[state, value], [requireMap, moduleMap2]] = result(require_)([mapEmpty, moduleMap])
             const x = state === 'error' ?
                 error(['runtime error', value]) :
                 set(['ok', { exports: value, requireMap: fromMap(requireMap) }])
@@ -93,7 +93,7 @@ const getOrBuild = compile => packageGet => moduleMapInterface =>  {
         if (p === null) { return notFound(moduleMap) }
         // check file
         const source = p.file(moduleId.path.join('/'))
-        return (source === null ? notFound : build(undefined)(moduleId)(source))(moduleMap)
+        return (source === null ? notFound : build(stringSetEmpty)(moduleId)(source))(moduleMap)
     }
     return f
 }

package/commonjs/build/test.f.cjs

@@ -71,7 +71,7 @@ const getOrBuild = _.getOrBuild
     (/** @type {module_.MapInterface<map.Map<module_.State>>} */(map))
 
 module.exports = () => {
-    let [r, m] = getOrBuild({ package: '', path: ['index.js'] })(undefined)
+    let [r, m] = getOrBuild({ package: '', path: ['index.js'] })(map.empty)
     {
         const x = JSON.stringify(r)
         if (x !==

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

@@ -8,14 +8,14 @@ const { entries } = Object
 
 /** @typedef {{readonly[k in string]: string}} DependencyMapJson */
 
-/** @typedef {DependencyMapJson|undefined} DependenciesJson */
+/** @typedef {DependencyMapJson|null} DependenciesJson */
 
 /** @type {(entry: json.Entry) => boolean} */
 const isDependencyJson = ([, v]) => typeof v === 'string'
 
-/** @type {(j: json.Unknown|undefined) => j is DependenciesJson} */
+/** @type {(j: json.Unknown) => j is DependenciesJson} */
 const isDependenciesJson = j => {
-    if (j === undefined) { return true }
+    if (j === null) { return true }
     if (!isObject(j)) { return false }
     return every(map(isDependencyJson)(entries(j)))
 }

package/commonjs/package/dependencies/test.f.cjs

@@ -1,8 +1,7 @@
 const _ = require('./module.f.cjs')
 
 module.exports = () => {
-    if (!_.isDependenciesJson(undefined)) { throw 'error' }
-    if (_.isDependenciesJson(null)) { throw 'error' }
+    if (!_.isDependenciesJson(null)) { throw 'error' }
     if (!_.isDependenciesJson({})) { throw 'error' }
     if (!_.isDependenciesJson({'a':'b'})) { throw 'error' }
     if (_.isDependenciesJson({ 'a': 12 })) { throw 'error' }

package/commonjs/package/module.f.cjs

@@ -2,6 +2,7 @@ const json = require('../../json/module.f.cjs')
 const { isObject } = json
 const dependencies = require('./dependencies/module.f.cjs')
 const { isDependenciesJson } = dependencies
+const { at } = require('../../types/object/module.f.cjs')
 
 /**
  * @typedef {{
@@ -16,7 +17,7 @@ const isPackageJson = j => {
     if (!isObject(j)) { return false }
     if (typeof j.name !== 'string') { return false }
     if (typeof j.version !== 'string') { return false }
-    if (!isDependenciesJson(j.dependencies)) { return false }
+    if (!isDependenciesJson(at('dependencies')(j))) { return false }
     return true
 }
 

package/commonjs/path/test.f.cjs

@@ -9,11 +9,8 @@ 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)
-}
+/** @type {(g: json.Unknown) => string} */
+const stringify = json.stringify(identity)
 
 module.exports = {
     0: () => {

package/dev/module.mjs

@@ -121,7 +121,7 @@ export const loadModuleMap = async () => {
             const pathStr = path.join('/')
             {
                 const module = d[pathStr]
-                if (module !== undefined) {
+                if (module !== void 0) {
                     return [pathStr, module]
                 }
             }

package/dev/test.f.cjs

@@ -21,7 +21,7 @@ module.exports = {
     ctorUndefined: () => {
         /** @type {any} */
         const o = {
-            constructor: undefined
+            constructor: void 0
         }
         const c = o['constructor']
         //console.log(c)

package/doc/LANGUAGE.md

@@ -93,7 +93,7 @@ const functionDouble = a => a * 2
 const structure = { name: "John", surname: "Smith" }
 const array = [1, 2, 3]
 const nestedStructure = {
-   address: undefined,
+   address: null,
    serialNumber: "123-45-78",
    sum: 14 + myConst + functionDouble(4),
    moreInfo: {
@@ -226,7 +226,7 @@ const iterable = list => ({
         let i = list
         while (true) {
             const r = next(i)
-            if (r === undefined) { return }
+            if (r === null) { return }
             yield r.first
             i = r.tail
         }

package/fsm/module.f.cjs

@@ -1,5 +1,5 @@
 const list = require('../types/list/module.f.cjs')
-const { equal, isEmpty, fold, toArray, scan, foldScan } = list
+const { equal, isEmpty, fold, toArray, scan, foldScan, empty: emptyList } = list
 const byteSet = require('../types/byte_set/module.f.cjs')
 const { toRangeMap, union: byteSetUnion, one, empty } = byteSet
 const sortedSet = require('../types/sorted_set/module.f.cjs')
@@ -66,7 +66,7 @@ const scanFetch = scan(fetchOp)
 const addEntry = grammar => set => dfa => {
     const s = stringifyIdentity(set)
     if (s in dfa) { return dfa }
-    const setMap = fold(foldOp(set))(undefined)(grammar)
+    const setMap = fold(foldOp(set))(emptyList)(grammar)
     const stringMap = toArray(scanStringify(setMap))
     const newDfa = { ...dfa, [s]: stringMap }
     const newStates = scanFetch(setMap)

package/json/tokenizer/module.f.cjs

@@ -1,7 +1,7 @@
 const operator = require('../../types/function/operator/module.f.cjs')
 const list = require('../../types/list/module.f.cjs')
 const { contains } = require('../../types/range/module.f.cjs')
-const { stateScan, flat } = list
+const { empty, stateScan, flat } = list
 const { fromCharCode } = String
 const {
     range,
@@ -125,7 +125,7 @@ const containsSmallLetter = contains(latinSmallLetterRange)
 
 /** @typedef {{ readonly kind: 'eof'}} EofState */
 
-/** @typedef {number|undefined} CharCodeOrEof */
+/** @typedef {number|null} CharCodeOrEof */
 
 /** @type {(old: string) => (input: number) => string} */
 const appendChar = old => input => `${old}${fromCharCode(input)}`
@@ -133,13 +133,13 @@ const appendChar = old => input => `${old}${fromCharCode(input)}`
 /** @type {(state: InitialState) => (input: number) => readonly[list.List<JsonToken>, TokenizerState]} */
 const initialStateOp = initialState => input => {
     if (containsDigitOneNine(input)) {
-        return [undefined, { kind: 'number', value: fromCharCode(input), numberKind: 'int' }]
+        return [empty, { kind: 'number', value: fromCharCode(input), numberKind: 'int' }]
     }
     if (containsSmallLetter(input)) {
-        return [undefined, { kind: 'keyword', value: fromCharCode(input) }]
+        return [empty, { kind: 'keyword', value: fromCharCode(input) }]
     }
     if (isWhiteSpace(input)) {
-        return [undefined, initialState]
+        return [empty, initialState]
     }
     switch (input) {
         case leftCurlyBracket: return [[{ kind: '{' }], initialState]
@@ -148,9 +148,9 @@ const initialStateOp = initialState => input => {
         case comma: return [[{ kind: ',' }], initialState]
         case leftSquareBracket: return [[{ kind: '[' }], initialState]
         case rightSquareBracket: return [[{ kind: ']' }], initialState]
-        case quotationMark: return [undefined, { kind: 'string', value: '' }]
-        case digit0: return [undefined, { kind: 'number', value: fromCharCode(input), numberKind: '0' }]
-        case hyphenMinus: return [undefined, { kind: 'number', value: fromCharCode(input), numberKind: '-' }]
+        case quotationMark: return [empty, { kind: 'string', value: '' }]
+        case digit0: return [empty, { kind: 'number', value: fromCharCode(input), numberKind: '0' }]
+        case hyphenMinus: return [empty, { kind: 'number', value: fromCharCode(input), numberKind: '-' }]
         default: return [[{ kind: 'error', message: 'unexpected character' }], initialState]
     }
 }
@@ -160,49 +160,49 @@ const parseNumberStateOp = state => input => {
     if (input === fullStop) {
         switch (state.numberKind) {
             case '0':
-            case 'int': return [undefined, { kind: 'number', value: appendChar(state.value)(input), numberKind: '.' }]
+            case 'int': return [empty, { kind: 'number', value: appendChar(state.value)(input), numberKind: '.' }]
             default: return tokenizeOp({ kind: 'invalidNumber' })(input)
         }
     }
     if (input === digit0) {
         switch (state.numberKind) {
             case '0': return tokenizeOp({ kind: 'invalidNumber' })(input)
-            case '-': return [undefined, { kind: 'number', value: appendChar(state.value)(input), numberKind: '0' }]
-            case '.': return [undefined, { kind: 'number', value: appendChar(state.value)(input), numberKind: 'fractional' }]
+            case '-': return [empty, { kind: 'number', value: appendChar(state.value)(input), numberKind: '0' }]
+            case '.': return [empty, { kind: 'number', value: appendChar(state.value)(input), numberKind: 'fractional' }]
             case 'e':
             case 'e+':
-            case 'e-': return [undefined, { kind: 'number', value: appendChar(state.value)(input), numberKind: 'expDigits' }]
-            default: return [undefined, { kind: 'number', value: appendChar(state.value)(input), numberKind: state.numberKind }]
+            case 'e-': return [empty, { kind: 'number', value: appendChar(state.value)(input), numberKind: 'expDigits' }]
+            default: return [empty, { kind: 'number', value: appendChar(state.value)(input), numberKind: state.numberKind }]
         }
     }
     if (containsDigitOneNine(input)) {
         switch (state.numberKind) {
             case '0': return tokenizeOp({ kind: 'invalidNumber' })(input)
-            case '-': return [undefined, { kind: 'number', value: appendChar(state.value)(input), numberKind: 'int' }]
-            case '.': return [undefined, { kind: 'number', value: appendChar(state.value)(input), numberKind: 'fractional' }]
+            case '-': return [empty, { kind: 'number', value: appendChar(state.value)(input), numberKind: 'int' }]
+            case '.': return [empty, { kind: 'number', value: appendChar(state.value)(input), numberKind: 'fractional' }]
             case 'e':
             case 'e+':
-            case 'e-': return [undefined, { kind: 'number', value: appendChar(state.value)(input), numberKind: 'expDigits' }]
-            default: return [undefined, { kind: 'number', value: appendChar(state.value)(input), numberKind: state.numberKind }]
+            case 'e-': return [empty, { kind: 'number', value: appendChar(state.value)(input), numberKind: 'expDigits' }]
+            default: return [empty, { kind: 'number', value: appendChar(state.value)(input), numberKind: state.numberKind }]
         }
     }
     if (input === latinSmallLetterE || input === latinCapitalLetterE) {
         switch (state.numberKind) {
             case '0':
             case 'int':
-            case 'fractional': return [undefined, { kind: 'number', value: appendChar(state.value)(input), numberKind: 'e' }]
+            case 'fractional': return [empty, { kind: 'number', value: appendChar(state.value)(input), numberKind: 'e' }]
             default: return tokenizeOp({ kind: 'invalidNumber' })(input)
         }
     }
     if (input === hyphenMinus) {
         switch (state.numberKind) {
-            case 'e': return [undefined, { kind: 'number', value: appendChar(state.value)(input), numberKind: 'e-' }]
+            case 'e': return [empty, { kind: 'number', value: appendChar(state.value)(input), numberKind: 'e-' }]
             default: return tokenizeOp({ kind: 'invalidNumber' })(input)
         }
     }
     if (input === plusSign) {
         switch (state.numberKind) {
-            case 'e': return [undefined, { kind: 'number', value: appendChar(state.value)(input), numberKind: 'e+' }]
+            case 'e': return [empty, { kind: 'number', value: appendChar(state.value)(input), numberKind: 'e+' }]
             default: return tokenizeOp({ kind: 'invalidNumber' })(input)
         }
     }
@@ -261,15 +261,15 @@ const invalidNumberStateOp = () => input => {
         const next = tokenizeOp({ kind: 'initial' })(input)
         return [{ first: { kind: 'error', message: 'invalid number' }, tail: next[0] }, next[1]]
     }
-    return [undefined, { kind: 'invalidNumber' }]
+    return [empty, { kind: 'invalidNumber' }]
 }
 
 /** @type {(state: ParseStringState) => (input: number) => readonly[list.List<JsonToken>, TokenizerState]} */
 const parseStringStateOp = state => input => {
     switch (input) {
         case quotationMark: return [[{ kind: 'string', value: state.value }], { kind: 'initial' }]
-        case reverseSolidus: return [undefined, { kind: 'escapeChar', value: state.value }]
-        default: return [undefined, { kind: 'string', value: appendChar(state.value)(input) }]
+        case reverseSolidus: return [empty, { kind: 'escapeChar', value: state.value }]
+        default: return [empty, { kind: 'string', value: appendChar(state.value)(input) }]
     }
 }
 
@@ -278,13 +278,13 @@ const parseEscapeCharStateOp = state => input => {
     switch (input) {
         case quotationMark:
         case reverseSolidus:
-        case solidus: return [undefined, { kind: 'string', value: appendChar(state.value)(input) }]
-        case latinSmallLetterB: return [undefined, { kind: 'string', value: appendChar(state.value)(backspace) }]
-        case latinSmallLetterF: return [undefined, { kind: 'string', value: appendChar(state.value)(ff) }]
-        case latinSmallLetterN: return [undefined, { kind: 'string', value: appendChar(state.value)(lf) }]
-        case latinSmallLetterR: return [undefined, { kind: 'string', value: appendChar(state.value)(cr) }]
-        case latinSmallLetterT: return [undefined, { kind: 'string', value: appendChar(state.value)(ht) }]
-        case latinSmallLetterU: return [undefined, { kind: 'unicodeChar', value: state.value, unicode: 0, hexIndex: 0 }]
+        case solidus: return [empty, { kind: 'string', value: appendChar(state.value)(input) }]
+        case latinSmallLetterB: return [empty, { kind: 'string', value: appendChar(state.value)(backspace) }]
+        case latinSmallLetterF: return [empty, { kind: 'string', value: appendChar(state.value)(ff) }]
+        case latinSmallLetterN: return [empty, { kind: 'string', value: appendChar(state.value)(lf) }]
+        case latinSmallLetterR: return [empty, { kind: 'string', value: appendChar(state.value)(cr) }]
+        case latinSmallLetterT: return [empty, { kind: 'string', value: appendChar(state.value)(ht) }]
+        case latinSmallLetterU: return [empty, { kind: 'unicodeChar', value: state.value, unicode: 0, hexIndex: 0 }]
         default: {
             const next = tokenizeOp({ kind: 'string', value: state.value })(input)
             return [{ first: { kind: 'error', message: 'unescaped character' }, tail: next[0] }, next[1]]
@@ -292,22 +292,23 @@ const parseEscapeCharStateOp = state => input => {
     }
 }
 
-/** @type {(hex: number) => number|undefined} */
+/** @type {(hex: number) => number|null} */
 const hexDigitToNumber = hex => {
     if (containsDigit(hex)) { return hex - digit0 }
     if (containsCapitalAF(hex)) { return hex - latinCapitalLetterA + 10 }
     if (containsSmallAF(hex)) { return hex - latinSmallLetterA + 10 }
+    return null
 }
 
 /** @type {(state: ParseUnicodeCharState) => (input: number) => readonly[list.List<JsonToken>, TokenizerState]} */
 const parseUnicodeCharStateOp = state => input => {
     const hexValue = hexDigitToNumber(input)
-    if (hexValue === undefined) {
+    if (hexValue === null) {
         const next = tokenizeOp({ kind: 'string', value: state.value })(input)
         return [{ first: { kind: 'error', message: 'invalid hex value' }, tail: next[0] }, next[1]]
     }
     const newUnicode = state.unicode | (hexValue << (3 - state.hexIndex) * 4)
-    return [undefined, state.hexIndex === 3 ?
+    return [empty, state.hexIndex === 3 ?
         { kind: 'string', value: appendChar(state.value)(newUnicode) } :
         { kind: 'unicodeChar', value: state.value, unicode: newUnicode, hexIndex: state.hexIndex + 1 }]
 }
@@ -325,7 +326,7 @@ const stringToKeywordToken = s => {
 /** @type {(state: ParseKeywordState) => (input: number) => readonly[list.List<JsonToken>, TokenizerState]} */
 const parseKeyWordStateOp = state => input => {
     if (containsSmallLetter(input)) {
-        return [undefined, { kind: 'keyword', value: appendChar(state.value)(input) }]
+        return [empty, { kind: 'keyword', value: appendChar(state.value)(input) }]
     }
     const keyWordToken = stringToKeywordToken(state.value)
     const next = tokenizeOp({ kind: 'initial' })(input)
@@ -333,7 +334,7 @@ const parseKeyWordStateOp = state => input => {
 }
 
 /** @type {(state: EofState) => (input: number) => readonly[list.List<JsonToken>, TokenizerState]} */
-const eofStateOp = state => input => [[{ kind: 'error', message: 'eof' }], state]
+const eofStateOp = state => () => [[{ kind: 'error', message: 'eof' }], state]
 
 /** @type {operator.StateScan<number, TokenizerState, list.List<JsonToken>>} */
 const tokenizeCharCodeOp = state => {
@@ -352,7 +353,7 @@ const tokenizeCharCodeOp = state => {
 /** @type {(state: TokenizerState) => readonly[list.List<JsonToken>, TokenizerState]} */
 const tokenizeEofOp = state => {
     switch (state.kind) {
-        case 'initial': return [undefined, { kind: 'eof' }]
+        case 'initial': return [empty, { kind: 'eof' }]
         case 'keyword': return [[stringToKeywordToken(state.value)], { kind: 'eof' }]
         case 'string':
         case 'escapeChar':
@@ -372,14 +373,14 @@ const tokenizeEofOp = state => {
 }
 
 /** @type {operator.StateScan<CharCodeOrEof, TokenizerState, list.List<JsonToken>>} */
-const tokenizeOp = state => input => input === undefined ? tokenizeEofOp(state) : tokenizeCharCodeOp(state)(input)
+const tokenizeOp = state => input => input === null ? tokenizeEofOp(state) : tokenizeCharCodeOp(state)(input)
 
 const scanTokenize = stateScan(tokenizeOp)
 
 const initial = scanTokenize({ kind: 'initial' })
 
 /** @type {(input: list.List<number>) => list.List<JsonToken>} */
-const tokenize = input => flat(initial(flat([/** @type {list.List<CharCodeOrEof>} */(input), [undefined]])))
+const tokenize = input => flat(initial(flat([/** @type {list.List<CharCodeOrEof>} */(input), [null]])))
 
 module.exports = {
     /** @readonly */

package/package.json

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

package/types/btree/module.f.cjs

@@ -30,6 +30,8 @@ const nodeValues = node => () => {
 const values = map(nodeValues)
 
 module.exports = {
+    /** @readonly */
+    empty: undefined,
     /** @readonly */
     find: require('./find/module.f.cjs'),
     /** @readonly */

package/types/string_set/module.f.cjs

@@ -6,6 +6,7 @@ const {
     set: { set: btreeSet },
     /** @type {(s: StringSet) => list.List<string>} */
     values,
+    empty,
 } = btree
 const { cmp } = require("../string/module.f.cjs")
 const list = require('../list/module.f.cjs')
@@ -29,6 +30,8 @@ const fromValues = fold(set)(undefined)
 const remove = compose(cmp)(btreeRemove)
 
 module.exports = {
+    /** @readonly */
+    empty,
     /** @readonly */
     contains,
     /** @readonly */