functionalscript 0.0.388 → 0.0.391

package/json/tokenizer/module.f.cjs

@@ -1,6 +1,9 @@
 const operator = require('../../types/function/operator/module.f.cjs')
 const list = require('../../types/list/module.f.cjs')
 const range = require('../../types/range/module.f.cjs')
+const { stateScan, flat, concat } = list
+const { contains } = range
+const { fromCharCode } = String
 
 /**
  * @typedef {{
@@ -68,11 +71,11 @@ const letterT = 0x74
 const letterU = 0x75
 const letterZ = 0x7a
 
-const containsDigit = range.contains([digit0, digit9])
-const containsDigitOneNine = range.contains([digit1, digit9])
-const containsSmallAF = range.contains([letterA, letterF])
-const containsCapitalAF = range.contains([capitalLetterA, capitalLetterF])
-const containsSmallLetter = range.contains([letterA, letterZ])
+const containsDigit = contains([digit0, digit9])
+const containsDigitOneNine = contains([digit1, digit9])
+const containsSmallAF = contains([letterA, letterF])
+const containsCapitalAF = contains([capitalLetterA, capitalLetterF])
+const containsSmallLetter = contains([letterA, letterZ])
 
 /**
  * @typedef {|
@@ -124,134 +127,111 @@ const containsSmallLetter = range.contains([letterA, letterZ])
 /** @typedef {number|undefined} CharCodeOrEof */
 
 /** @type {(old: string) => (input: number) => string} */
-const appendChar = old => input => `${old}${String.fromCharCode(input)}`
+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: String.fromCharCode(input), numberKind: 'int'}]
+const initialStateOp = initialState => input => {
+    if (containsDigitOneNine(input)) {
+        return [undefined, { kind: 'number', value: fromCharCode(input), numberKind: 'int' }]
     }
-    if (containsSmallLetter(input))
-    {
-        return [undefined, { kind: 'keyword', value: String.fromCharCode(input)}]
+    if (containsSmallLetter(input)) {
+        return [undefined, { kind: 'keyword', value: fromCharCode(input) }]
     }
-    if (isWhiteSpace(input))
-    {
+    if (isWhiteSpace(input)) {
         return [undefined, initialState]
     }
-    switch(input)
-    {
-        case leftBrace: return [[{kind: '{'}], initialState]
-        case rightBrace: return [[{kind: '}'}], initialState]
-        case colon: return [[{kind: ':'}], initialState]
-        case comma: return [[{kind: ','}], initialState]
-        case leftBracket: return [[{kind: '['}], initialState]
-        case rightBracket: return [[{kind: ']'}], initialState]
-        case quotationMark: return[undefined, {kind: 'string', value: ''}]
-        case digit0: return [undefined, { kind: 'number', value: String.fromCharCode(input), numberKind: '0'}]
-        case signMinus: return [undefined, { kind: 'number', value: String.fromCharCode(input), numberKind: '-'}]
-        default: return [[{kind: 'error', message: 'unexpected character'}], initialState]
+    switch (input) {
+        case leftBrace: return [[{ kind: '{' }], initialState]
+        case rightBrace: return [[{ kind: '}' }], initialState]
+        case colon: return [[{ kind: ':' }], initialState]
+        case comma: return [[{ kind: ',' }], initialState]
+        case leftBracket: return [[{ kind: '[' }], initialState]
+        case rightBracket: return [[{ kind: ']' }], initialState]
+        case quotationMark: return [undefined, { kind: 'string', value: '' }]
+        case digit0: return [undefined, { kind: 'number', value: fromCharCode(input), numberKind: '0' }]
+        case signMinus: return [undefined, { kind: 'number', value: fromCharCode(input), numberKind: '-' }]
+        default: return [[{ kind: 'error', message: 'unexpected character' }], initialState]
     }
 }
 
 /** @type {(state: ParseNumberState) => (input: number) => readonly[list.List<JsonToken>, TokenizerState]} */
-const parseNumberStateOp = state => input =>
-{
-    if (input === decimalPoint)
-    {
-        switch (state.numberKind)
-        {
+const parseNumberStateOp = state => input => {
+    if (input === decimalPoint) {
+        switch (state.numberKind) {
             case '0':
-            case 'int': return [undefined, {kind: 'number', value: appendChar(state.value)(input), numberKind: '.'}]
-            default: return tokenizeOp({kind: 'invalidNumber'})(input)
+            case 'int': return [undefined, { 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'}]
+    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 '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 [undefined, { kind: 'number', value: appendChar(state.value)(input), numberKind: 'expDigits' }]
+            default: return [undefined, { 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'}]
+    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 '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 [undefined, { kind: 'number', value: appendChar(state.value)(input), numberKind: 'expDigits' }]
+            default: return [undefined, { kind: 'number', value: appendChar(state.value)(input), numberKind: state.numberKind }]
         }
     }
-    if (input === letterE || input === capitalLetterE)
-    {
-        switch (state.numberKind)
-        {
+    if (input === letterE || input === capitalLetterE) {
+        switch (state.numberKind) {
             case '0':
             case 'int':
-            case 'fractional': return [undefined, {kind:'number', value: appendChar(state.value)(input), numberKind: 'e'}]
-            default: return tokenizeOp({kind: 'invalidNumber'})(input)
+            case 'fractional': return [undefined, { kind: 'number', value: appendChar(state.value)(input), numberKind: 'e' }]
+            default: return tokenizeOp({ kind: 'invalidNumber' })(input)
         }
     }
-    if (input === signMinus)
-    {
-        switch (state.numberKind)
-        {
-            case 'e': return [undefined, {kind:'number', value: appendChar(state.value)(input), numberKind: 'e-'}]
-            default: return tokenizeOp({kind: 'invalidNumber'})(input)
+    if (input === signMinus) {
+        switch (state.numberKind) {
+            case 'e': return [undefined, { kind: 'number', value: appendChar(state.value)(input), numberKind: 'e-' }]
+            default: return tokenizeOp({ kind: 'invalidNumber' })(input)
         }
     }
-    if (input === signPlus)
-    {
-        switch (state.numberKind)
-        {
-            case 'e': return [undefined, {kind:'number', value: appendChar(state.value)(input), numberKind: 'e+'}]
-            default: return tokenizeOp({kind: 'invalidNumber'})(input)
+    if (input === signPlus) {
+        switch (state.numberKind) {
+            case 'e': return [undefined, { kind: 'number', value: appendChar(state.value)(input), numberKind: 'e+' }]
+            default: return tokenizeOp({ kind: 'invalidNumber' })(input)
         }
     }
-    if (isTerminalForNumber(input))
-    {
-        switch (state.numberKind)
-        {
+    if (isTerminalForNumber(input)) {
+        switch (state.numberKind) {
             case '-':
             case '.':
             case 'e':
             case 'e+':
             case 'e-':
-            {
-                const next = tokenizeOp({kind: 'initial'})(input)
-                return [{first: {kind: 'error', message: 'invalid number'}, tail: next[0]}, next[1]]
-            }
+                {
+                    const next = tokenizeOp({ kind: 'initial' })(input)
+                    return [{ first: { kind: 'error', message: 'invalid number' }, tail: next[0] }, next[1]]
+                }
             default:
-            {
-                const next = tokenizeOp({kind: 'initial'})(input)
-                return [{first: {kind: 'number', value: state.value}, tail: next[0]}, next[1]]
-            }
+                {
+                    const next = tokenizeOp({ kind: 'initial' })(input)
+                    return [{ first: { kind: 'number', value: state.value }, tail: next[0] }, next[1]]
+                }
         }
     }
-    return tokenizeOp({kind: 'invalidNumber'})(input)
+    return tokenizeOp({ kind: 'invalidNumber' })(input)
 }
 
 /** @type {(char: number) => boolean} */
-const isTerminalForNumber = char =>
-{
-    if (isWhiteSpace(char))
-    {
+const isTerminalForNumber = char => {
+    if (isWhiteSpace(char)) {
         return true;
     }
-    switch (char)
-    {
+    switch (char) {
         case quotationMark:
         case comma:
         case leftBrace:
@@ -264,10 +244,8 @@ const isTerminalForNumber = char =>
 }
 
 /** @type {(char: number) => boolean} */
-const isWhiteSpace = char =>
-{
-    switch (char)
-    {
+const isWhiteSpace = char => {
+    switch (char) {
         case horizontalTab:
         case newLine:
         case carriageReturn:
@@ -277,102 +255,88 @@ const isWhiteSpace = char =>
 }
 
 /** @type {(state: InvalidNumberState) => (input: number) => readonly[list.List<JsonToken>, TokenizerState]} */
-const invalidNumberStateOp = state => input =>
-{
-    if (isTerminalForNumber(input))
-    {
-        const next = tokenizeOp({kind: 'initial'})(input)
-        return [{first: {kind: 'error', message: 'invalid number'}, tail: next[0]}, next[1]]
+const invalidNumberStateOp = state => input => {
+    if (isTerminalForNumber(input)) {
+        const next = tokenizeOp({ kind: 'initial' })(input)
+        return [{ first: { kind: 'error', message: 'invalid number' }, tail: next[0] }, next[1]]
     }
-    return [undefined, {kind: 'invalidNumber'}]
+    return [undefined, { 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 backslash: return [undefined, {kind:'escapeChar', value: state.value}]
-        default: return [undefined, {kind:'string', value: appendChar(state.value)(input)}]
+const parseStringStateOp = state => input => {
+    switch (input) {
+        case quotationMark: return [[{ kind: 'string', value: state.value }], { kind: 'initial' }]
+        case backslash: return [undefined, { kind: 'escapeChar', value: state.value }]
+        default: return [undefined, { kind: 'string', value: appendChar(state.value)(input) }]
     }
 }
 
 /** @type {(state: ParseEscapeCharState) => (input: number) => readonly[list.List<JsonToken>, TokenizerState]} */
-const parseEscapeCharStateOp = state => input =>
-{
-    switch(input)
-    {
+const parseEscapeCharStateOp = state => input => {
+    switch (input) {
         case quotationMark:
         case backslash:
-        case slash: return [undefined, {kind: 'string', value: appendChar(state.value)(input)}]
-        case letterB: return [undefined, {kind: 'string', value: appendChar(state.value)(backspace)}]
-        case letterF: return [undefined, {kind: 'string', value: appendChar(state.value)(formfeed)}]
-        case letterN: return [undefined, {kind: 'string', value: appendChar(state.value)(newLine)}]
-        case letterR: return [undefined, {kind: 'string', value: appendChar(state.value)(carriageReturn)}]
-        case letterT: return [undefined, {kind: 'string', value: appendChar(state.value)(horizontalTab)}]
-        case letterU: return [undefined, {kind: 'unicodeChar', value: state.value, unicode: 0, hexIndex: 0}]
+        case slash: return [undefined, { kind: 'string', value: appendChar(state.value)(input) }]
+        case letterB: return [undefined, { kind: 'string', value: appendChar(state.value)(backspace) }]
+        case letterF: return [undefined, { kind: 'string', value: appendChar(state.value)(formfeed) }]
+        case letterN: return [undefined, { kind: 'string', value: appendChar(state.value)(newLine) }]
+        case letterR: return [undefined, { kind: 'string', value: appendChar(state.value)(carriageReturn) }]
+        case letterT: return [undefined, { kind: 'string', value: appendChar(state.value)(horizontalTab) }]
+        case letterU: return [undefined, { 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]]
+            const next = tokenizeOp({ kind: 'string', value: state.value })(input)
+            return [{ first: { kind: 'error', message: 'unescaped character' }, tail: next[0] }, next[1]]
         }
     }
 }
 
 /** @type {(hex: number) => number|undefined} */
-const hexDigitToNumber = hex =>
-{
+const hexDigitToNumber = hex => {
     if (containsDigit(hex)) { return hex - digit0 }
     if (containsCapitalAF(hex)) { return hex - capitalLetterA + 10 }
     if (containsSmallAF(hex)) { return hex - letterA + 10 }
 }
 
 /** @type {(state: ParseUnicodeCharState) => (input: number) => readonly[list.List<JsonToken>, TokenizerState]} */
-const parseUnicodeCharStateOp = state => input =>
-{
+const parseUnicodeCharStateOp = state => input => {
     const hexValue = hexDigitToNumber(input)
-    if (hexValue === undefined)
-    {
-        const next = tokenizeOp({kind: 'string', value: state.value})(input)
-        return [{first: {kind: 'error', message: 'invalid hex value'}, tail: next[0]}, next[1]]
+    if (hexValue === undefined) {
+        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 ?
-            {kind: 'string', value: appendChar(state.value)(newUnicode)} :
-            {kind: 'unicodeChar', value: state.value, unicode: newUnicode, hexIndex: state.hexIndex + 1}]
+    return [undefined, state.hexIndex === 3 ?
+        { kind: 'string', value: appendChar(state.value)(newUnicode) } :
+        { kind: 'unicodeChar', value: state.value, unicode: newUnicode, hexIndex: state.hexIndex + 1 }]
 }
 
 /** @type {(s: string) => JsonToken} */
-const stringToKeywordToken = s =>
-{
-    switch(s)
-    {
-        case 'true': return {kind: 'true'}
-        case 'false': return {kind: 'false'}
-        case 'null': return {kind: 'null'}
-        default: return {kind: 'error', message: 'invalid keyword'}
+const stringToKeywordToken = s => {
+    switch (s) {
+        case 'true': return { kind: 'true' }
+        case 'false': return { kind: 'false' }
+        case 'null': return { kind: 'null' }
+        default: return { kind: 'error', message: 'invalid keyword' }
     }
 }
 
 /** @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)}]
+const parseKeyWordStateOp = state => input => {
+    if (containsSmallLetter(input)) {
+        return [undefined, { kind: 'keyword', value: appendChar(state.value)(input) }]
     }
     const keyWordToken = stringToKeywordToken(state.value)
-    const next = tokenizeOp({kind: 'initial'})(input)
-    return [{first: keyWordToken, tail: next[0]}, next[1]]
+    const next = tokenizeOp({ kind: 'initial' })(input)
+    return [{ first: keyWordToken, tail: next[0] }, next[1]]
 }
 
 /** @type {(state: EofState) => (input: number) => readonly[list.List<JsonToken>, TokenizerState]} */
-const eofStateOp = state => input => [[{kind: 'error', message: 'eof'}], state]
+const eofStateOp = state => input => [[{ kind: 'error', message: 'eof' }], state]
 
 /** @type {operator.StateScan<number, TokenizerState, list.List<JsonToken>>} */
 const tokenizeCharCodeOp = state => {
-    switch(state.kind)
-    {
+    switch (state.kind) {
         case 'initial': return initialStateOp(state)
         case 'keyword': return parseKeyWordStateOp(state)
         case 'string': return parseStringStateOp(state)
@@ -386,35 +350,35 @@ const tokenizeCharCodeOp = state => {
 
 /** @type {(state: TokenizerState) => readonly[list.List<JsonToken>, TokenizerState]} */
 const tokenizeEofOp = state => {
-    switch(state.kind)
-    {
-        case 'initial': return[undefined, {kind: 'eof'}]
-        case 'keyword': return [[stringToKeywordToken(state.value)], {kind: 'eof'}]
+    switch (state.kind) {
+        case 'initial': return [undefined, { kind: 'eof' }]
+        case 'keyword': return [[stringToKeywordToken(state.value)], { kind: 'eof' }]
         case 'string':
         case 'escapeChar':
-        case 'unicodeChar': return [[{kind: 'error', message: '" are missing'}], {kind: 'eof'}]
-        case 'invalidNumber': return [[{kind: 'error', message: 'invalid number'}], {kind: 'eof'}]
+        case 'unicodeChar': return [[{ kind: 'error', message: '" are missing' }], { kind: 'eof' }]
+        case 'invalidNumber': return [[{ kind: 'error', message: 'invalid number' }], { kind: 'eof' }]
         case 'number':
-            switch (state.numberKind)
-            {
+            switch (state.numberKind) {
                 case '-':
                 case '.':
                 case 'e':
                 case 'e+':
-                case 'e-': return [[{kind: 'error', message: 'invalid number'}], {kind: 'invalidNumber', }]
-                default: return [[{kind: 'number', value: state.value}], {kind: 'eof'}]
+                case 'e-': return [[{ kind: 'error', message: 'invalid number' }], { kind: 'invalidNumber', }]
+                default: return [[{ kind: 'number', value: state.value }], { kind: 'eof' }]
             }
-        case 'eof': return [[{kind: 'error', message: 'eof'}], state]
+        case 'eof': return [[{ kind: 'error', message: 'eof' }], state]
     }
 }
 
 /** @type {operator.StateScan<CharCodeOrEof, TokenizerState, list.List<JsonToken>>} */
 const tokenizeOp = state => input => input === undefined ? tokenizeEofOp(state) : tokenizeCharCodeOp(state)(input)
 
-const initial = list.stateScan(tokenizeOp)({ kind: 'initial' })
+const scanTokenize = stateScan(tokenizeOp)
+
+const initial = scanTokenize({ kind: 'initial' })
 
 /** @type {(input: list.List<number>) => list.List<JsonToken>} */
-const tokenize = input => list.flat(initial(list.concat(/** @type {list.List<CharCodeOrEof>} */(input))([undefined])))
+const tokenize = input => flat(initial(flat([/** @type {list.List<CharCodeOrEof>} */(input), [undefined]])))
 
 module.exports = {
     /** @readonly */

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/nodejs/version/module.f.cjs

@@ -1,5 +1,3 @@
-const pack = require('../../commonjs/package/module.f.cjs')
-
 /** 
  * @typedef {{
  *  readonly execSync: (cmd: string) => Buffer
@@ -22,13 +20,15 @@ const pack = require('../../commonjs/package/module.f.cjs')
  * }} Node
  */
 
+const { stringify, parse } = JSON
+
 /** @type {<T>(node: Node<T>) => T} */
 const version = ({ child_process, fs }) =>
     fs.writeFileSync(
         'package.json',
-        JSON.stringify(
+        stringify(
             {
-                ...JSON.parse(fs.readFileSync('package.json').toString()), 
+                ...parse(fs.readFileSync('package.json').toString()), 
                 version: `0.0.${child_process.execSync('git log --oneline').toString().split('\n').length - 1}` 
             }, 
             null, 

package/package.json

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

package/sha2/module.f.cjs

@@ -73,33 +73,6 @@ const smallSigma0 = smallSigma(7)(18)(3)
 
 const smallSigma1 = smallSigma(17)(19)(10)
 
-/** @type {Hash8} */
-const init256 = [0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19]
-
-/** @type {(input: readonly number[]) => (bitsCount: number) => Hash8} */
-const computeSha256 = input => bitsCount => compute(input)(bitsCount)(init256)
-
-/** @type {Hash8} */
-const init224 = [0xc1059ed8, 0x367cd507, 0x3070dd17, 0xf70e5939, 0xffc00b31, 0x68581511, 0x64f98fa7, 0xbefa4fa4]
-
-const k = [
-    [
-        0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
-        0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174],
-    [
-        0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
-        0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967],
-    [
-        0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
-        0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070],
-    [
-        0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
-        0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2],
-];
-
-/** @type {(input: readonly number[]) => (bitsCount: number) => Hash8} */
-const computeSha224 = input => bitsCount => compute(input)(bitsCount)(init224)
-
 /** @type {(a: array.Array4<number>) => number} */
 const wi = a => (smallSigma1(a[0]) + a[1] + smallSigma0(a[2]) + a[3]) | 0
 
@@ -166,8 +139,8 @@ const compress = init => data => {
     ]
 }
 
-/** @type {(input: readonly number[]) => (bitsCount: number) => (init: Hash8) => Hash8} */
-const compute = input => bitsCount => init => {
+/** @type {(init: Hash8) => (input: readonly number[]) => (bitsCount: number) => Hash8} */
+const compute = init => input => bitsCount => {
     const { f, length } = padding(input)(bitsCount)
 
     let result = init
@@ -183,6 +156,33 @@ const compute = input => bitsCount => init => {
     return result
 }
 
+/** @type {Hash8} */
+const init256 = [0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19]
+
+/** @type {(input: readonly number[]) => (bitsCount: number) => Hash8} */
+const computeSha256 = compute(init256)
+
+/** @type {Hash8} */
+const init224 = [0xc1059ed8, 0x367cd507, 0x3070dd17, 0xf70e5939, 0xffc00b31, 0x68581511, 0x64f98fa7, 0xbefa4fa4]
+
+const k = [
+    [
+        0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+        0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174],
+    [
+        0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+        0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967],
+    [
+        0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+        0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070],
+    [
+        0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+        0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2],
+];
+
+/** @type {(input: readonly number[]) => (bitsCount: number) => Hash8} */
+const computeSha224 = compute(init224)
+
 module.exports = {
     /** @readonly */
     padding,

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 */
@@ -53,11 +55,9 @@ const codePointToUtf16 = input =>
     return [input & 0xffff]
 }
 
-/** @type {(input: list.List<number>) => list.List<ByteResult>} */
-const codePointListToUtf8List = list.flatMap(codePointToUtf8)
+const codePointListToUtf8List = flatMap(codePointToUtf8)
 
-/** @type {(input: list.List<i32>) => list.List<u16>} */
-const codePointListToUtf16List = list.flatMap(codePointToUtf16)
+const codePointListToUtf16List = flatMap(codePointToUtf16)
 
 /** @type {operator.StateScan<number, Utf8State, list.List<CodePointResult>>} */
 const utf8ByteToCodePointOp = state => byte => {
@@ -85,7 +85,7 @@ const utf8ByteToCodePointOp = state => byte => {
                 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]} */
@@ -95,7 +95,7 @@ const utf8EofToCodePointOp = state => [state === undefined ? undefined : [error(
 const utf8ByteOrEofToCodePointOp = state => input => input === undefined ? utf8EofToCodePointOp(state) : utf8ByteToCodePointOp(state)(input)
 
 /** @type {(input: list.List<number>) => list.List<CodePointResult>} */
-const utf8ListToCodePointList = 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<u16, Utf16State, list.List<i32>>} */
 const utf16ByteToCodePointOp = state => byte => {
@@ -124,7 +124,19 @@ const utf16EofToCodePointOp = state => [state === undefined ? undefined : [state
 const utf16ByteOrEofToCodePointOp = state => input => input === undefined ? utf16EofToCodePointOp(state) : utf16ByteToCodePointOp(state)(input)
 
 /** @type {(input: list.List<u16>) => list.List<i32>} */
-const utf16ListToCodePointList = input => list.flat(list.stateScan(utf16ByteOrEofToCodePointOp)(undefined)(list.concat(/** @type {list.List<WordOrEof>} */(input))([undefined])))
+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 */
@@ -134,5 +146,9 @@ module.exports = {
     /** @readonly */
     utf8ListToCodePointList,
     /** @readonly */
-    utf16ListToCodePointList
+    utf16ListToCodePointList,
+    /** @readonly */
+    stringToUtf16List,
+    /** @readonly */
+    utf16ListToString
 }

package/text/encoding/test.f.cjs

@@ -206,4 +206,18 @@ const stringify = a => json.stringify(sort)(a)
     if (result !== '[-2147427328,0]') { throw result }
 }
 
+{
+    const utf16List = encoding.stringToUtf16List("Hello world!😂🚜🚲")
+    const result = encoding.utf16ListToString(utf16List)
+    if (result !== "Hello world!😂🚜🚲") { 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 = {}