functionalscript 0.0.483 → 0.0.485

package/package.json

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

package/text/ascii/module.f.cjs

@@ -3,7 +3,7 @@ const _range = require('../../types/range/module.f.cjs')
 /** @type {(s: string) => (i: number) => number} */
 const at = s => i => {
     const r = s.codePointAt(i)
-    if (r === undefined) { throw s }
+    if (r === void 0) { throw s }
     return r
 }
 

package/text/utf16/module.f.cjs

@@ -2,11 +2,11 @@ const list = require('../../types/list/module.f.cjs')
 const operator = require('../../types/function/operator/module.f.cjs')
 const { contains } = require('../../types/range/module.f.cjs')
 const { fn } = require('../../types/function/module.f.cjs')
-const { map, flat, stateScan, reduce, flatMap } = list
+const { map, flat, stateScan, reduce, flatMap, empty } = list
 
-/** @typedef {u16|undefined} WordOrEof */
+/** @typedef {u16|null} WordOrEof */
 
-/** @typedef {undefined|number} Utf16State */
+/** @typedef {number|null} Utf16State */
 
 /** @typedef {number} u16 */
 
@@ -50,39 +50,39 @@ const utf16ByteToCodePointOp = state => word => {
     if (!u16(word)) {
         return [[0xffffffff], state]
     }
-    if (state === undefined) {
-        if (isBmpCodePoint(word)) { return [[word], undefined] }
+    if (state === null) {
+        if (isBmpCodePoint(word)) { return [[word], null] }
         if (isHighSurrogate(word)) { return [[], word] }
-        return [[word | errorMask], undefined]
+        return [[word | errorMask], null]
     }
     if (isLowSurrogate(word)) {
         const high = state - 0xd800
         const low = word - 0xdc00
-        return [[(high << 10) + low + 0x10000], undefined]
+        return [[(high << 10) + low + 0x10000], null]
     }
-    if (isBmpCodePoint(word)) { return [[state | errorMask, word], undefined] }
+    if (isBmpCodePoint(word)) { return [[state | errorMask, word], null] }
     if (isHighSurrogate(word)) { return [[state | errorMask], word] }
-    return [[state | errorMask, word | errorMask], undefined]
+    return [[state | errorMask, word | errorMask], null]
 }
 
 /** @type {(state: Utf16State) => readonly[list.List<i32>, Utf16State]} */
-const utf16EofToCodePointOp = state => [state === undefined ? undefined : [state | errorMask],  undefined]
+const utf16EofToCodePointOp = state => [state === null ? empty : [state | errorMask],  null]
 
 /** @type {operator.StateScan<WordOrEof, Utf16State, list.List<i32>>} */
-const utf16ByteOrEofToCodePointOp = state => input => input === undefined ? utf16EofToCodePointOp(state) : utf16ByteToCodePointOp(state)(input)
+const utf16ByteOrEofToCodePointOp = state => input => input === null ? utf16EofToCodePointOp(state) : utf16ByteToCodePointOp(state)(input)
 
 /** @type {list.List<WordOrEof>} */
-const eofList = [undefined]
+const eofList = [null]
 
 /** @type {(input: list.List<u16>) => list.List<i32>} */
-const toCodePointList = input => flat(stateScan(utf16ByteOrEofToCodePointOp)(undefined)(flat([input, eofList])))
+const toCodePointList = input => flat(stateScan(utf16ByteOrEofToCodePointOp)(null)(flat([input, eofList])))
 
 /** @type {(s: string) => list.List<u16>} */
 const stringToList = s => {
     /** @type {(i: number) => list.Result<number>} */
     const at = i => {
         const first = s.charCodeAt(i)
-        return isNaN(first) ? undefined : { first, tail: () => at(i + 1) }
+        return isNaN(first) ? empty : { first, tail: () => at(i + 1) }
     }
     return at(0)
 }

package/types/array/module.f.cjs

@@ -84,35 +84,38 @@ const uncheckTail = a => a.slice(1)
 /** @type {<T>(_: readonly T[]) => readonly T[]} */
 const uncheckHead = a => a.slice(0, -1)
 
-/** @type {<T>(_: readonly T[]) => T|undefined} */
-const first = a => a[0]
+/** @type {<T>(a: T|undefined) => T|null} */
+const undefinedToNull = a => a === undefined ? null : a
 
-/** @type {<T>(_: readonly T[]) => T|undefined} */
-const last = a => a[a.length - 1]
+/** @type {<T>(_: readonly T[]) => T|null} */
+const first = a => undefinedToNull(a[0])
 
-/** @type {<T>(_: readonly T[]) => readonly T[] | undefined} */
-const tail = a => a.length === 0 ? undefined : uncheckTail(a)
+/** @type {<T>(_: readonly T[]) => T|null} */
+const last = a => undefinedToNull(a[a.length - 1])
 
-/** @type {<T>(_: readonly T[]) => readonly[T, readonly T[]]|undefined} */
+/** @type {<T>(_: readonly T[]) => readonly T[] | null} */
+const tail = a => a.length === 0 ? null : uncheckTail(a)
+
+/** @type {<T>(_: readonly T[]) => readonly[T, readonly T[]]|null} */
 const splitFirst = a => {
     /** @typedef {typeof a[0]} T*/
     /** @type {(_: T) => readonly[T, readonly T[]]} */
     const split = first => [first, uncheckTail(a)]
-    return map(split)(a[0])
+    return undefinedToNull(map(split)(a[0]))
 }
 
-/** @type {<T>(_: readonly T[]) => readonly T[]|undefined} */
-const head = a => a.length === 0 ? undefined : uncheckHead(a)
+/** @type {<T>(_: readonly T[]) => readonly T[]|null} */
+const head = a => a.length === 0 ? null : uncheckHead(a)
 
-/** @type {<T>(_: readonly T[]) => readonly[readonly T[], T]|undefined} */
+/** @type {<T>(_: readonly T[]) => readonly[readonly T[], T]|null} */
 const splitLast = a => {
     const lastA = last(a)
-    if (lastA === undefined) { return undefined }
+    if (lastA === null) { return null }
     return [uncheckHead(a), lastA]
 }
 
-/** @type {(index: number) => <T>(a: readonly T[]) => readonly[T]|undefined} */
-const at = index => a => index < a.length ? [a[index]] : undefined
+/** @type {(index: number) => <T>(a: readonly T[]) => readonly[T]|null} */
+const at = index => a => index < a.length ? [a[index]] : null
 
 module.exports = {
     /** @readonly */

package/types/array/test.f.cjs

@@ -2,8 +2,7 @@ const _ = require('./module.f.cjs')
 const json = require('../../json/module.f.cjs')
 const { sort } = require('../object/module.f.cjs')
 
-/** @type {(a: readonly json.Unknown[]) => string} */
-const stringify = a => json.stringify(sort)(a)
+const stringify = json.stringify(sort)
 
 module.exports = {
     stringify: () => {
@@ -13,13 +12,13 @@ module.exports = {
     at: [
         () => {
             const result = _.at(2)([1, 20, 300])
-            if (result === undefined) { throw result }
+            if (result === null) { throw result }
             if (result[0] !== 300) { throw result }
         },
 
         () => {
             const result = _.at(3)([1, 20, 300])
-            if (result !== undefined) { throw result }
+            if (result !== null) { throw result }
         }
     ],
     first: [
@@ -29,7 +28,7 @@ module.exports = {
         },
         () => {
             const result = _.first([])
-            if (result !== undefined) { throw result }
+            if (result !== null) { throw result }
         }
     ],
     last: [
@@ -39,54 +38,51 @@ module.exports = {
         },
         () => {
             const result = _.last([])
-            if (result !== undefined) { throw result }
+            if (result !== null) { throw result }
         }
     ],
     head: [
         () => {
             const result = _.head([1, 20, 300])
-            if (result === undefined) { throw result }
+            if (result === null) { throw result }
             const str = stringify(result)
             if (str !== '[1,20]') { throw str }
         },
         () => {
             const result = _.head([])
-            if (result !== undefined) { throw result }
+            if (result !== null) { throw result }
         }
     ],
     tail: [
         () => {
             const result = _.tail([1, 20, 300])
-            if (result === undefined) { throw result }
             const str = stringify(result)
             if (str !== '[20,300]') { throw str }
         },
         () => {
             const result = _.tail([])
-            if (result !== undefined) { throw result }
+            if (result !== null) { throw result }
         }
     ],
 
     splitFirst: [
         () => {
             const result = _.splitFirst([1, 20, 300])
-            if (result === undefined) { throw result }
             const str = stringify(result)
             if (str !== '[1,[20,300]]') { throw str }
         },
         () => {
             const result = _.splitFirst([])
-            if (result !== undefined) { throw result }
+            if (result !== null) { throw result }
         },
         () => {
             const result = _.splitLast([1, 20, 300])
-            if (result === undefined) { throw result }
             const str = stringify(result)
             if (str !== '[[1,20],300]') { throw str }
         },
         () => {
             const result = _.splitLast([])
-            if (result !== undefined) { throw result }
+            if (result !== null) { throw result }
         }
     ]
 }