functionalscript 0.0.386 → 0.0.389

package/doc/vm.md

@@ -23,14 +23,12 @@
 |`_`     |`\x5F`        | 1| 26|
 |`a`..`z`|`\x61`..`\x7A`|1A| 40|
 
-## 64 bit platform
+## Value
 
 Alignment: 8 bytes.
 
 Pointer: 2^64 / 2^3 = 2^61 bit
 
-### Value
-
 - `63`: 9 x 7 bit string
 - `63`:
   - `61`: pointer + null, alignment - 8 bytes

package/html/module.f.cjs

@@ -1,6 +1,7 @@
 const list = require('../types/list/module.f.cjs')
 const object = require('../types/object/module.f.cjs')
 const { operator, compose } = require('../types/function/module.f.cjs')
+const encoding = require('../text/encoding/module.f.cjs');
 
 /**
  * @typedef {|
@@ -73,7 +74,7 @@ const escapeCharCode = code => {
     }
 }
 
-const escape = compose(list.toCharCodeList)(list.map(escapeCharCode))
+const escape = compose(encoding.stringToUtf16List)(list.map(escapeCharCode))
 
 /** @type {(n: Node) => list.List<string>} */
 const node = n => typeof n === 'string' ? escape(n) : element(n)

package/json/tokenizer/test.f.cjs

@@ -2,9 +2,10 @@ const tokenizer = require('./module.f.cjs')
 const list = require('../../types/list/module.f.cjs')
 const json = require('../module.f.cjs')
 const { sort } = require('../../types/object/module.f.cjs')
+const encoding = require('../../text/encoding/module.f.cjs');
 
 /** @type {(s: string) => readonly tokenizer.JsonToken[]} */
-const tokenizeString = s => list.toArray(tokenizer.tokenize(list.toCharCodeList(s)))
+const tokenizeString = s => list.toArray(tokenizer.tokenize(encoding.stringToUtf16List(s)))
 
 const stringify = json.stringify(sort)
 

package/package.json

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

package/text/encoding/README.md

@@ -4,14 +4,14 @@
 
 Requirement: no loss for UTF8 => codepoint => UTF8
 
-|utf8     |codepoint                              |size     |codepoint                                         |
+|utf8     |utf8 code                              |size     |codepoint                                         |
 |---------|---------------------------------------|---------|--------------------------------------------------|
 |[a]      |0xxx_xxxx                              |7 bit    |0_0000_0000_0000_0xxx_xxxx                        |
 |[b,a]    |110x_xxxx 10xx_xxxx                    |11 bit   |0_0000_0000_0xxx_xxxx_xxxx + 0_0000_0000_1000_0000|
 |[c,b,a]  |1110_xxxx 10xx_xxxx 10xx_xxxx          |16 bit   |0_0000_xxxx_xxxx_xxxx_xxxx + 0_0000_1000_0000_0000|
 |[d,c,b,a]|1111_0xxx 10xx_xxxx 10xx_xxxx 10xx_xxxx|21 bit   |x_xxxx_xxxx_xxxx_xxxx_xxxx + 1_0000_0000_0000_0000|
 
-|utf8 error|                             |size  |codepoint          |
+|utf8 error|utf8 code                    |size  |codepoint          |
 |----------|-----------------------------|------|-------------------|
 |[e]       |1111_1xxx                    | 3 bit|                   |
 |[d,]      |1111_0xxx                    | 3 bit|                   |
@@ -55,15 +55,15 @@ Requirement: no loss for UTF16 => codepoint => UTF16
 - first : 0xD800: 0b_1101_10xx_xxxx_xxxx : 10 bit
 - second: 0xDC00: 0b_1101_11xx_xxxx_xxxx : 10 bit
 
-|utf16    |codepoint                              |size  |
-|---------|---------------------------------------|------|
-|[a]      |xxxx_xxxx_xxxx_xxxx                    |16 bit|
-|[b,a]    |1101_10xx_xxxx_xxxx 1101_11xx_xxxx_xxxx|20 bit|
+|utf16    |utf16 code                             |size  |codepoint                                       |
+|---------|---------------------------------------|------|------------------------------------------------|
+|[a]      |xxxx_xxxx_xxxx_xxxx                    |16 bit|0000_xxxx_xxxx_xxxx_xxxx                        |
+|[b,a]    |1101_10xx_xxxx_xxxx 1101_11xx_xxxx_xxxx|20 bit|xxxx_xxxx_xxxx_xxxx_xxxx + 1_0000_0000_0000_0000|
 
-|utf16 error|codepoint          |size  |
-|-----------|-------------------|------|
-|[e]        |1101_11xx_xxxx_xxxx|10 bit|
-|[b,]       |1101_10xx_xxxx_xxxx|10 bit|
+|utf16 error|utf16 code         |size  |codepoint          |
+|-----------|-------------------|------|-------------------|
+|[e]        |1101_11xx_xxxx_xxxx|10 bit|1101_11xx_xxxx_xxxx|
+|[b,]       |1101_10xx_xxxx_xxxx|10 bit|1101_10xx_xxxx_xxxx|
 
 Total error states: 11 bit
 
@@ -74,7 +74,7 @@ const utf16ListToCodePointList
 /** @type {(input: List<i32>) => List<u16>} */
 const codePointListToUtf16List
 
-/** @type {(input: string) => List<u16> */
+/** @type {(input: string) => List<u16>} */
 const stringToUtf16List
 
 /** @type {(input: List<u16>) => string} */

package/text/encoding/module.f.cjs

@@ -3,6 +3,8 @@ const list = require('../../types/list/module.f.cjs')
 const operator = require('../../types/function/operator/module.f.cjs')
 const array = require('../../types/array/module.f.cjs')
 const { contains } = require('../../types/range/module.f.cjs')
+const { compose } = require('../../types/function/module.f.cjs')
+const { map, flat, stateScan, concat, fold, toArray, flatMap } = list
 const { ok, error } = result
 
 /** @typedef {result.Result<number,number>} ByteResult */
@@ -11,9 +13,15 @@ const { ok, error } = result
 
 /** @typedef {number|undefined} ByteOrEof */
 
+/** @typedef {u16|undefined} WordOrEof */
+
 /** @typedef {undefined|array.Array1<number>|array.Array2<number>|array.Array3<number>} Utf8State */
 
-/** @typedef {undefined|array.Array1<number>|array.Array2<number>|array.Array3<number>} Utf16State */
+/** @typedef {undefined|number} Utf16State */
+
+/** @typedef {number} u16 */
+
+/** @typedef {number} i32 */
 
 /** @type {(a:number) => boolean} */
 const isBmpCodePoint = a => a >= 0x0000 && a <= 0xd7ff || a >= 0xe000 && a <= 0xffff
@@ -23,6 +31,8 @@ const isHighSurrogate = contains([0xd800, 0xdbff])
 /** @type {(a:number) => boolean} */
 const isLowSurrogate = contains([0xdc00, 0xdfff])
 
+const errorMask = 0b1000_0000_0000_0000_0000_0000_0000_0000
+
 /** @type {(input:number) => list.List<ByteResult>} */
 const codePointToUtf8 = input =>
 {
@@ -33,29 +43,29 @@ const codePointToUtf8 = input =>
     return [error(input)]
 }
 
-/** @type {(input:number) => list.List<ByteResult>} */
+/** @type {(input:i32) => list.List<u16>} */
 const codePointToUtf16 = input =>
 {
-    if (isBmpCodePoint(input)) { return [ok(input >> 8), ok(input & 0xff)] }
+    if (isBmpCodePoint(input)) { return [input] }
     if (input >= 0x010000 && input <= 0x10ffff) {
         const high = ((input - 0x10000) >> 10) + 0xd800
-        const low = ((input - 0x10000) & 0x3ff) + 0xdc00
-        return [ok(high >> 8), ok(high & 0xff), ok(low >> 8), ok(low & 0xff)]
+        const low = ((input - 0x10000) & 0b0011_1111_1111) + 0xdc00
+        return [high, low]
     }
-    return [error(input)]
+    return [input & 0xffff]
 }
 
 /** @type {(input: list.List<number>) => list.List<ByteResult>} */
-const codePointListToUtf8 = list.flatMap(codePointToUtf8)
+const codePointListToUtf8List = flatMap(codePointToUtf8)
 
-/** @type {(input: list.List<number>) => list.List<ByteResult>} */
-const codePointListToUtf16 = list.flatMap(codePointToUtf16)
+/** @type {(input: list.List<i32>) => list.List<u16>} */
+const codePointListToUtf16List = flatMap(codePointToUtf16)
 
 /** @type {operator.StateScan<number, Utf8State, list.List<CodePointResult>>} */
 const utf8ByteToCodePointOp = state => byte => {
     if (byte < 0x00 || byte > 0xff) {
         return [[error([byte])], state]
-    }    
+    }
     if (state == undefined) {
         if (byte < 0x80) { return [[ok(byte)], undefined] }
         if (byte >= 0xc2 && byte <= 0xf4) { return [[], [byte]] }
@@ -68,71 +78,79 @@ const utf8ByteToCodePointOp = state => byte => {
             case 1:
                 if (state[0] < 0xe0) { return [[ok(((state[0] & 0x1f) << 6) + (byte & 0x3f))], undefined] }
                 if (state[0] < 0xf8) { return [[], [state[0], byte]] }
-                break         
+                break
             case 2:
                 if (state[0] < 0xf0) { return [[ok(((state[0] & 0x0f) << 12) + ((state[1] & 0x3f) << 6) + (byte & 0x3f))], undefined] }
                 if (state[0] < 0xf8) { return [[], [state[0], state[1], byte]] }
                 break
-            case 3: 
+            case 3:
                 return [[ok(((state[0] & 0x07) << 18) + ((state[1] & 0x3f) << 12) + ((state[2] & 0x3f) << 6) + (byte & 0x3f))], undefined]
         }
-    }    
-    return [[error(list.toArray(list.concat(state)([byte])))], undefined]
+    }
+    return [[error(toArray(concat(state)([byte])))], undefined]
 }
 
 /** @type {(state: Utf8State) => readonly[list.List<CodePointResult>, Utf8State]} */
-const utf8EofToCodePointOp = state => [state == undefined ? undefined : [error(state)],  undefined]
+const utf8EofToCodePointOp = state => [state === undefined ? undefined : [error(state)],  undefined]
 
 /** @type {operator.StateScan<ByteOrEof, Utf8State, list.List<CodePointResult>>} */
 const utf8ByteOrEofToCodePointOp = state => input => input === undefined ? utf8EofToCodePointOp(state) : utf8ByteToCodePointOp(state)(input)
 
 /** @type {(input: list.List<number>) => list.List<CodePointResult>} */
-const utf8ListToCodePoint = input => list.flat(list.stateScan(utf8ByteOrEofToCodePointOp)(undefined)(list.concat(/** @type {list.List<ByteOrEof>} */(input))([undefined])))
+const utf8ListToCodePointList = input => flat(stateScan(utf8ByteOrEofToCodePointOp)(undefined)(concat(/** @type {list.List<ByteOrEof>} */(input))([undefined])))
 
-/** @type {operator.StateScan<number, Utf16State, list.List<CodePointResult>>} */
+/** @type {operator.StateScan<u16, Utf16State, list.List<i32>>} */
 const utf16ByteToCodePointOp = state => byte => {
-    if (byte < 0x00 || byte > 0xff) {
-        return [[error([byte])], state]
+    if (byte < 0x00 || byte > 0xffff) {
+        return [[0xffffffff], state]
     }
-    if (state == undefined) {
-        return [[], [byte]]
+    if (state === undefined) {
+        if (isBmpCodePoint(byte)) { return [[byte], undefined] }
+        if (isHighSurrogate(byte)) { return [[], byte] }
+        return [[byte | errorMask], undefined]
     }
-    switch(state.length)
-    {
-        case 1:
-            const codeUnit = (state[0] << 8) + byte
-            if (isBmpCodePoint(codeUnit)) { return [[ok(codeUnit)], undefined] }
-            if (isHighSurrogate(codeUnit)) { return [[], [state[0], byte]] }
-            break
-        case 2:
-            return [[], [state[0], state[1], byte]]
-        case 3:             
-            if (isLowSurrogate((state[2] << 8) + byte)) {
-                const high = (state[0] << 8) + state[1] - 0xd800
-                const low = (state[2] << 8) + byte - 0xdc00
-                return [[ok((high << 10) + low + 0x10000)], undefined]
-            } 
-            break
+    if (isLowSurrogate(byte)) {
+        const high = state - 0xd800
+        const low = byte - 0xdc00
+        return [[(high << 10) + low + 0x10000], undefined]
     }
-    return [[error(list.toArray(list.concat(state)([byte])))], undefined]
+    if (isBmpCodePoint(byte)) { return [[state | errorMask, byte], undefined] }
+    if (isHighSurrogate(byte)) { return [[state | errorMask], byte] }
+    return [[state | errorMask, byte | errorMask], undefined]
 }
 
-/** @type {(state: Utf8State) => readonly[list.List<CodePointResult>, Utf16State]} */
-const utf16EofToCodePointOp = state => [state == undefined ? undefined : [error(state)],  undefined]
+/** @type {(state: Utf16State) => readonly[list.List<i32>, Utf16State]} */
+const utf16EofToCodePointOp = state => [state === undefined ? undefined : [state | errorMask],  undefined]
 
-/** @type {operator.StateScan<ByteOrEof, Utf8State, list.List<CodePointResult>>} */
+/** @type {operator.StateScan<WordOrEof, Utf16State, list.List<i32>>} */
 const utf16ByteOrEofToCodePointOp = state => input => input === undefined ? utf16EofToCodePointOp(state) : utf16ByteToCodePointOp(state)(input)
 
-/** @type {(input: list.List<number>) => list.List<CodePointResult>} */
-const utf16ListToCodePoint = input => list.flat(list.stateScan(utf16ByteOrEofToCodePointOp)(undefined)(list.concat(/** @type {list.List<ByteOrEof>} */(input))([undefined])))
+/** @type {(input: list.List<u16>) => list.List<i32>} */
+const utf16ListToCodePointList = input => flat(stateScan(utf16ByteOrEofToCodePointOp)(undefined)(concat(/** @type {list.List<WordOrEof>} */(input))([undefined])))
+
+/** @type {(s: string) => list.List<u16>} */
+const stringToUtf16List = 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 at(0)
+}
+
+const utf16ListToString = compose(map(String.fromCharCode))(fold(operator.concat)(''))
 
 module.exports = {
     /** @readonly */
-    codePointListToUtf8,
+    codePointListToUtf8List,
+    /** @readonly */
+    codePointListToUtf16List,
+    /** @readonly */
+    utf8ListToCodePointList,
     /** @readonly */
-    codePointListToUtf16,
+    utf16ListToCodePointList,
     /** @readonly */
-    utf8ListToCodePoint,
+    stringToUtf16List,
     /** @readonly */
-    utf16ListToCodePoint
+    utf16ListToString
 }

package/text/encoding/test.f.cjs

@@ -7,193 +7,217 @@ const { list } = require('../../types/module.f.cjs')
 const stringify = a => json.stringify(sort)(a)
 
 {
-    const result = stringify(list.toArray(encoding.codePointListToUtf8([0,1,0x7F])))
+    const result = stringify(list.toArray(encoding.codePointListToUtf8List([0,1,0x7F])))
     if (result !== '[["ok",0],["ok",1],["ok",127]]') { throw result }
 }
 
 {
-    const result = stringify(list.toArray(encoding.codePointListToUtf8([0x80])))
+    const result = stringify(list.toArray(encoding.codePointListToUtf8List([0x80])))
     if (result !== '[["ok",194],["ok",128]]') { throw result }
 }
 
 {
-    const result = stringify(list.toArray(encoding.codePointListToUtf8([0xa9])))
+    const result = stringify(list.toArray(encoding.codePointListToUtf8List([0xa9])))
     if (result !== '[["ok",194],["ok",169]]') { throw result }
 }
 
 {
-    const result = stringify(list.toArray(encoding.codePointListToUtf8([0x7ff])))
+    const result = stringify(list.toArray(encoding.codePointListToUtf8List([0x7ff])))
     if (result !== '[["ok",223],["ok",191]]') { throw result }
 }
 
 {
-    const result = stringify(list.toArray(encoding.codePointListToUtf8([0x800])))
+    const result = stringify(list.toArray(encoding.codePointListToUtf8List([0x800])))
     if (result !== '[["ok",224],["ok",160],["ok",128]]') { throw result }
 }
 
 {
-    const result = stringify(list.toArray(encoding.codePointListToUtf8([0x801])))
+    const result = stringify(list.toArray(encoding.codePointListToUtf8List([0x801])))
     if (result !== '[["ok",224],["ok",160],["ok",129]]') { throw result }
 }
 
 {
-    const result = stringify(list.toArray(encoding.codePointListToUtf8([0xffff])))
+    const result = stringify(list.toArray(encoding.codePointListToUtf8List([0xffff])))
     if (result !== '[["ok",239],["ok",191],["ok",191]]') { throw result }
 }
 
 {
-    const result = stringify(list.toArray(encoding.codePointListToUtf8([0x10000])))
+    const result = stringify(list.toArray(encoding.codePointListToUtf8List([0x10000])))
     if (result !== '[["ok",240],["ok",144],["ok",128],["ok",128]]') { throw result }
 }
 
 {
-    const result = stringify(list.toArray(encoding.codePointListToUtf8([0x10001])))
+    const result = stringify(list.toArray(encoding.codePointListToUtf8List([0x10001])))
     if (result !== '[["ok",240],["ok",144],["ok",128],["ok",129]]') { throw result }
 }
 
 {
-    const result = stringify(list.toArray(encoding.codePointListToUtf8([0x10FFFF])))
+    const result = stringify(list.toArray(encoding.codePointListToUtf8List([0x10FFFF])))
     if (result !== '[["ok",244],["ok",143],["ok",191],["ok",191]]') { throw result }
 }
 
 {
-    const result = stringify(list.toArray(encoding.codePointListToUtf8([-1,0x110000])))
+    const result = stringify(list.toArray(encoding.codePointListToUtf8List([-1,0x110000])))
     if (result !== '[["error",-1],["error",1114112]]') { throw result }
 }
 
 {
-    const result = stringify(list.toArray(encoding.codePointListToUtf16([0])))
-    if (result !== '[["ok",0],["ok",0]]') { throw result }
+    const result = stringify(list.toArray(encoding.codePointListToUtf16List([0])))
+    if (result !== '[0]') { throw result }
 }
 
 {
-    const result = stringify(list.toArray(encoding.codePointListToUtf16([0x24])))
-    if (result !== '[["ok",0],["ok",36]]') { throw result }
+    const result = stringify(list.toArray(encoding.codePointListToUtf16List([0x24])))
+    if (result !== '[36]') { throw result }
 }
 
 {
-    const result = stringify(list.toArray(encoding.codePointListToUtf16([0x20AC])))
-    if (result !== '[["ok",32],["ok",172]]') { throw result }
+    const result = stringify(list.toArray(encoding.codePointListToUtf16List([0x20AC])))
+    if (result !== '[8364]') { throw result }
 }
 
 {
-    const result = stringify(list.toArray(encoding.codePointListToUtf16([0xd7ff])))
-    if (result !== '[["ok",215],["ok",255]]') { throw result }
+    const result = stringify(list.toArray(encoding.codePointListToUtf16List([0xd7ff])))
+    if (result !== '[55295]') { throw result }
 }
 
 {
-    const result = stringify(list.toArray(encoding.codePointListToUtf16([0xe000])))
-    if (result !== '[["ok",224],["ok",0]]') { throw result }
+    const result = stringify(list.toArray(encoding.codePointListToUtf16List([0xe000])))
+    if (result !== '[57344]') { throw result }
 }
 
 {
-    const result = stringify(list.toArray(encoding.codePointListToUtf16([0xffff])))
-    if (result !== '[["ok",255],["ok",255]]') { throw result }
+    const result = stringify(list.toArray(encoding.codePointListToUtf16List([0xffff])))
+    if (result !== '[65535]') { throw result }
 }
 
 {
-    const result = stringify(list.toArray(encoding.codePointListToUtf16([0x10000])))
-    if (result !== '[["ok",216],["ok",0],["ok",220],["ok",0]]') { throw result }
+    const result = stringify(list.toArray(encoding.codePointListToUtf16List([0x10000])))
+    if (result !== '[55296,56320]') { throw result }
 }
 
 {
-    const result = stringify(list.toArray(encoding.codePointListToUtf16([0x10437])))
-    if (result !== '[["ok",216],["ok",1],["ok",220],["ok",55]]') { throw result }
+    const result = stringify(list.toArray(encoding.codePointListToUtf16List([0x10437])))
+    if (result !== '[55297,56375]') { throw result }
 }
 
 {
-    const result = stringify(list.toArray(encoding.codePointListToUtf16([0x24B62])))
-    if (result !== '[["ok",216],["ok",82],["ok",223],["ok",98]]') { throw result }
+    const result = stringify(list.toArray(encoding.codePointListToUtf16List([0x24B62])))
+    if (result !== '[55378,57186]') { throw result }
 }
 
 {
-    const result = stringify(list.toArray(encoding.codePointListToUtf16([0x10ffff])))
-    if (result !== '[["ok",219],["ok",255],["ok",223],["ok",255]]') { throw result }
+    const result = stringify(list.toArray(encoding.codePointListToUtf16List([0x10ffff])))
+    if (result !== '[56319,57343]') { throw result }
 }
 
 {
-    const result = stringify(list.toArray(encoding.codePointListToUtf16([-1, 0xd800, 0xdfff, 0x110000])))
-    if (result !== '[["error",-1],["error",55296],["error",57343],["error",1114112]]') { throw result }
+    const result = stringify(list.toArray(encoding.codePointListToUtf16List([-1, 0xd800, 0xdfff, 0x110000])))
+    if (result !== '[65535,55296,57343,0]') { throw result }
 }
 
-{    
-    const result = stringify(list.toArray(encoding.utf8ListToCodePoint([-1, 256])))
+{
+    const result = stringify(list.toArray(encoding.utf8ListToCodePointList([-1, 256])))
     if (result !== '[["error",[-1]],["error",[256]]]') { throw result }
 }
 
-{    
-    const result = stringify(list.toArray(encoding.utf8ListToCodePoint([128, 193, 245, 255])))
+{
+    const result = stringify(list.toArray(encoding.utf8ListToCodePointList([128, 193, 245, 255])))
     if (result !== '[["error",[128]],["error",[193]],["error",[245]],["error",[255]]]') { throw result }
 }
 
-{    
-    const result = stringify(list.toArray(encoding.utf8ListToCodePoint([0, 1, 127])))
+{
+    const result = stringify(list.toArray(encoding.utf8ListToCodePointList([0, 1, 127])))
     if (result !== '[["ok",0],["ok",1],["ok",127]]') { throw result }
 }
 
 {
-    const result = stringify(list.toArray(encoding.utf8ListToCodePoint([194, 128, 194, 169, 223, 191])))
+    const result = stringify(list.toArray(encoding.utf8ListToCodePointList([194, 128, 194, 169, 223, 191])))
     if (result !== '[["ok",128],["ok",169],["ok",2047]]') { throw result }
 }
 
-{    
-    const result = stringify(list.toArray(encoding.utf8ListToCodePoint([194, 127, 194, 192, 194])))
+{
+    const result = stringify(list.toArray(encoding.utf8ListToCodePointList([194, 127, 194, 192, 194])))
     if (result !== '[["error",[194,127]],["error",[194,192]],["error",[194]]]') { throw result }
 }
 
 {
-    const result = stringify(list.toArray(encoding.utf8ListToCodePoint([224, 160, 128, 224, 160, 129, 239, 191, 191])))
+    const result = stringify(list.toArray(encoding.utf8ListToCodePointList([224, 160, 128, 224, 160, 129, 239, 191, 191])))
     if (result !== '[["ok",2048],["ok",2049],["ok",65535]]') { throw result }
 }
 
-{    
-    const result = stringify(list.toArray(encoding.utf8ListToCodePoint([224, 160, 127, 224, 160, 192, 224, 160])))
+{
+    const result = stringify(list.toArray(encoding.utf8ListToCodePointList([224, 160, 127, 224, 160, 192, 224, 160])))
     if (result !== '[["error",[224,160,127]],["error",[224,160,192]],["error",[224,160]]]') { throw result }
 }
 
 {
-    const result = stringify(list.toArray(encoding.utf8ListToCodePoint([240, 144, 128, 128, 240, 144, 128, 129, 244, 143, 191, 191])))
+    const result = stringify(list.toArray(encoding.utf8ListToCodePointList([240, 144, 128, 128, 240, 144, 128, 129, 244, 143, 191, 191])))
     if (result !== '[["ok",65536],["ok",65537],["ok",1114111]]') { throw result }
 }
 
-{    
-    const result = stringify(list.toArray(encoding.utf8ListToCodePoint([240, 144, 128, 127, 240, 144, 128, 192, 240, 144, 128])))
+{
+    const result = stringify(list.toArray(encoding.utf8ListToCodePointList([240, 144, 128, 127, 240, 144, 128, 192, 240, 144, 128])))
     if (result !== '[["error",[240,144,128,127]],["error",[240,144,128,192]],["error",[240,144,128]]]') { throw result }
 }
 
 {
-    const result = stringify(list.toArray(encoding.utf8ListToCodePoint([194, -1, 128])))
+    const result = stringify(list.toArray(encoding.utf8ListToCodePointList([194, -1, 128])))
     if (result !== '[["error",[-1]],["ok",128]]') { throw result }
 }
 
-{    
-    const result = stringify(list.toArray(encoding.utf16ListToCodePoint([-1, 256,])))
-    if (result !== '[["error",[-1]],["error",[256]]]') { throw result }
+{
+    const result = stringify(list.toArray(encoding.utf16ListToCodePointList([-1, 65536])))
+    if (result !== '[4294967295,4294967295]') { throw result }
+}
+
+{
+    const result = stringify(list.toArray(encoding.utf16ListToCodePointList([0, 36, 8364, 55295, 57344, 65535])))
+    if (result !== '[0,36,8364,55295,57344,65535]') { throw result }
+}
+
+{
+    const result = stringify(list.toArray(encoding.utf16ListToCodePointList([56320, 57343])))
+    if (result !== '[-2147427328,-2147426305]') { throw result }
+}
+
+{
+    const result = stringify(list.toArray(encoding.utf16ListToCodePointList([55296, 56320, 55297, 56375, 55378, 57186, 56319, 57343])))
+    if (result !== '[65536,66615,150370,1114111]') { throw result }
+}
+
+{
+    const result = stringify(list.toArray(encoding.utf16ListToCodePointList([55296, 55296])))
+    if (result !== '[-2147428352,-2147428352]') { throw result }
 }
 
 {
-    const result = stringify(list.toArray(encoding.utf16ListToCodePoint([0, 0, 0, 36, 32, 172, 215, 255, 224, 0, 255, 255])))
-    if (result !== '[["ok",0],["ok",36],["ok",8364],["ok",55295],["ok",57344],["ok",65535]]') { throw result }
+    const result = stringify(list.toArray(encoding.utf16ListToCodePointList([55296, 0])))
+    if (result !== '[-2147428352,0]') { throw result }
 }
 
 {
-    const result = stringify(list.toArray(encoding.utf16ListToCodePoint([220, 0, 223, 255])))
-    if (result !== '[["error",[220,0]],["error",[223,255]]]') { throw result }
+    const result = stringify(list.toArray(encoding.utf16ListToCodePointList([56320])))
+    if (result !== '[-2147427328]') { throw result }
 }
 
 {
-    const result = stringify(list.toArray(encoding.utf16ListToCodePoint([216, 0, 220, 0, 216, 1, 220, 55, 216, 82, 223, 98, 219, 255, 223, 255])))
-    if (result !== '[["ok",65536],["ok",66615],["ok",150370],["ok",1114111]]') { throw result }
+    const result = stringify(list.toArray(encoding.utf16ListToCodePointList([56320, 0])))
+    if (result !== '[-2147427328,0]') { throw result }
 }
 
 {
-    const result = stringify(list.toArray(encoding.utf16ListToCodePoint([216, 0, 216, 0])))
-    if (result !== '[["error",[216,0,216,0]]]') { throw result }
+    const utf16List = encoding.stringToUtf16List("Hello world!😂🚜🚲")
+    const result = encoding.utf16ListToString(utf16List)
+    if (result !== "Hello world!😂🚜🚲") { throw result }
 }
 
 {
-    const result = stringify(list.toArray(encoding.utf16ListToCodePoint([216, 0, 0, 0])))
-    if (result !== '[["error",[216,0,0,0]]]') { throw result }
+    const a = encoding.stringToUtf16List("Hello world!😂🚜🚲")
+    const b = encoding.utf16ListToCodePointList(a)
+    const c = encoding.codePointListToUtf16List(b)
+    const result = encoding.utf16ListToString(c)
+    if (result !== "Hello world!😂🚜🚲") { throw result }
 }
 
 module.exports = {}

package/types/list/module.f.cjs

@@ -296,18 +296,6 @@ const equalZip = e => a => b => () => {
 /** @type {<T>(e: operator.Equal<T>) => (a: List<T>) => (b: List<T>) => boolean} */
 const equal = e => a => b => every(equalZip(e)(a)(b))
 
-/** @type {(s: string) => List<number>} */
-const toCharCodeList = s => {
-    /** @type {(i: number) => Result<number>} */
-    const at = i => {
-        const first = s.charCodeAt(i)
-        return isNaN(first) ? undefined : { first, tail: () => at(i + 1) }
-    }
-    return at(0)
-}
-
-const fromCharCodeList = compose(map(String.fromCharCode))(fold(operator.concat)(''))
-
 module.exports = {
     /** @readonly */
     empty: undefined,
@@ -384,9 +372,5 @@ module.exports = {
     /** @readonly */
     zip,
     /** @readonly */
-    equal,
-    /** @readonly */
-    toCharCodeList,
-    /** @readonly */
-    fromCharCodeList,
+    equal
 }

package/types/list/test.f.cjs

@@ -236,11 +236,7 @@ const map5 = _.map(x => x > 5)
     if (result !== false) { throw result }
 }
 
-{
-    const r = _.toCharCodeList("Hello world!")
-    const x = _.fromCharCodeList(r)
-    if (x !== "Hello world!") { throw x }
-}
+
 
 // stress tests