functionalscript 0.2.6 → 0.3.0

package/js/tokenizer/{test.f.mjs → test.f.ts}

@@ -1,13 +1,14 @@
-import * as tokenizer from './module.f.mjs'
-import * as list from '../../types/list/module.f.mjs'
+import * as tokenizer from './module.f.ts'
+import * as list from '../../types/list/module.f.ts'
 const { toArray } = list
-import * as djs from '../../djs/module.f.mjs'
-import * as o from '../../types/object/module.f.mjs'
+import * as djs from '../../djs/module.f.ts'
+import * as o from '../../types/object/module.f.ts'
 const { sort } = o
-import * as encoding from '../../text/utf16/module.f.mjs'
+import * as encoding from '../../text/utf16/module.f.ts'
 
-/** @type {(s: string) => readonly tokenizer.JsToken[]} */
-const tokenizeString = s => toArray(tokenizer.tokenize(encoding.stringToList(s)))
+const tokenizeString
+    : (s: string) => readonly tokenizer.JsToken[]
+    = s => toArray(tokenizer.tokenize(encoding.stringToList(s)))
 
 const stringify = djs.stringify(sort)
 
@@ -91,11 +92,11 @@ export default {
         },
         () => {
             const result = stringify(tokenizeString('"\r"'))
-            if (result !== '[{"kind":"error","message":"unterminated string literal"},{"kind":"nl"},{"kind":"error","message":"\\" are missing"}]') { throw result }            
+            if (result !== '[{"kind":"error","message":"unterminated string literal"},{"kind":"nl"},{"kind":"error","message":"\\" are missing"}]') { throw result }
         },
         () => {
             const result = stringify(tokenizeString('"\n null'))
-            if (result !== '[{"kind":"error","message":"unterminated string literal"},{"kind":"nl"},{"kind":"null"}]') { throw result }            
+            if (result !== '[{"kind":"error","message":"unterminated string literal"},{"kind":"nl"},{"kind":"null"}]') { throw result }
         },
         () => {
             const result = stringify(tokenizeString('"\\b\\f\\n\\r\\t"'))
@@ -613,4 +614,4 @@ export default {
             if (result !== '[{"kind":"/*","value":" multiline comment *\\n * *"},{"kind":"nl"}]') { throw result }
         },
     ]
-}
+}

package/json/module.f.ts

@@ -0,0 +1,94 @@
+import * as list from '../types/list/module.f.ts'
+const { next, flat, map } = list
+import * as string  from '../types/string/module.f.ts'
+const { concat } = string
+import * as object from '../types/object/module.f.ts'
+const { at } = object
+import * as f from '../types/function/module.f.ts'
+const { compose, fn } = f
+const { entries } = Object
+import * as s from './serializer/module.f.ts'
+const { objectWrap, arrayWrap, stringSerialize, numberSerialize, nullSerialize, boolSerialize } = s
+
+type Object = {
+   readonly [k in string]: Unknown
+}
+
+type Array = readonly Unknown[]
+
+export type Unknown = Object|boolean|string|number|null|Array
+
+export const setProperty
+    : (value: Unknown) => (path: list.List<string>) => (src: Unknown) => Unknown
+    = value => {
+    const f
+        : (path: list.List<string>) => (src: Unknown) => Unknown
+        = path => src => {
+        const result = next(path)
+        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)) }
+    }
+    return f
+}
+
+const colon = [':']
+
+export type Entry = object.Entry<Unknown>
+
+type Entries = list.List<Entry>
+
+type MapEntries = (entries: Entries) => Entries
+
+export const serialize
+    : (mapEntries: MapEntries) => (value: Unknown) => list.List<string>
+    = sort => {
+    const propertySerialize
+        : (kv: readonly[string, Unknown]) => list.List<string>
+        = ([k, v]) => flat([
+        stringSerialize(k),
+        colon,
+        f(v)
+    ])
+    const mapPropertySerialize = map(propertySerialize)
+    const objectSerialize
+        : (object: Object) => list.List<string>
+        = fn(entries)
+        .then(sort)
+        .then(mapPropertySerialize)
+        .then(objectWrap)
+        .result
+    const f
+        : (value: Unknown) => list.List<string>
+        = value => {
+        switch (typeof value) {
+            case 'boolean': { return boolSerialize(value) }
+            case 'number': { return numberSerialize(value) }
+            case 'string': { return stringSerialize(value) }
+            default: {
+                if (value === null) { return nullSerialize }
+                if (value instanceof Array) { return arraySerialize(value) }
+                return objectSerialize(value)
+            }
+        }
+    }
+    const arraySerialize = compose(map(f))(arrayWrap)
+    return f
+}
+
+/**
+ * The standard `JSON.stringify` rules determined by
+ * https://262.ecma-international.org/6.0/#sec-ordinary-object-internal-methods-and-internal-slots-ownpropertykeys
+ */
+export const stringify
+    : (mapEntries: MapEntries) => (value: Unknown) => string
+    = sort => compose(serialize(sort))(concat)
+
+export const parse
+    : (value: string) => Unknown
+    = JSON.parse
+
+export const isObject
+    = (value: Unknown): value is Object =>
+        typeof value === 'object' && value !== null && !(value instanceof Array)

package/json/parser/{module.f.mjs → module.f.ts}

@@ -1,122 +1,116 @@
-// @ts-self-types="./module.f.d.mts"
-import * as result from '../../types/result/module.f.mjs'
-import * as list from '../../types/list/module.f.mjs'
+import * as result from '../../types/result/module.f.ts'
+import * as list from '../../types/list/module.f.ts'
 const { fold, first, drop, toArray } = list
-import * as Operator from '../../types/function/operator/module.f.mjs'
-import * as Tokenizer from '../tokenizer/module.f.mjs'
-import * as map from '../../types/map/module.f.mjs'
+import * as Operator from '../../types/function/operator/module.f.ts'
+import * as Tokenizer from '../tokenizer/module.f.ts'
+import * as map from '../../types/map/module.f.ts'
 const { setReplace } = map
-import * as Json from '../module.f.mjs'
-import * as o from '../../types/object/module.f.mjs'
+import * as Json from '../module.f.ts'
+import * as o from '../../types/object/module.f.ts'
 const { fromMap } = o
 
+type JsonObject = {
+ readonly kind: 'object'
+ readonly values: map.Map<Json.Unknown>
+ readonly key: string
+}
+
+type JsonArray = {
+ readonly kind: 'array'
+ readonly values: list.List<Json.Unknown>
+}
+
+type JsonStackElement = |
+    JsonObject |
+    JsonArray
+
+type JsonStack = list.List<JsonStackElement>
+
+type StateParse = {
+    readonly status: '' | '[' | '[v' | '[,' | '{' | '{k' | '{:' | '{v' | '{,'
+    readonly top: JsonStackElement | null
+    readonly stack: JsonStack
+}
+
+type StateResult = {
+    readonly status: 'result'
+    readonly value: Json.Unknown
+}
+
+type StateError = {
+    readonly status: 'error'
+    readonly message: string
+}
+
+type JsonState = |
+    StateParse |
+    StateResult |
+    StateError
+
+const addKeyToObject
+    : (obj: JsonObject) => (key: string) => JsonObject
+    = obj => key => ({ kind: 'object', values: obj.values, key: key })
+
+const addValueToObject
+    : (obj: JsonObject) => (value: Json.Unknown) => JsonObject
+    = obj => value => ({ kind: 'object', values: setReplace(obj.key)(value)(obj.values), key: '' })
+
+const addToArray
+    : (array: JsonArray) => (value: Json.Unknown) => JsonArray
+    = array => value => ({ kind: 'array', values: list.concat(array.values)([value]) })
 
-/**
- * @typedef {{
-* readonly kind: 'object'
-* readonly values: map.Map<Json.Unknown>
-* readonly key: string
-* }} JsonObject
-* */
-
-/**
- * @typedef {{
-* readonly kind: 'array'
-* readonly values: list.List<Json.Unknown>
-* }} JsonArray
-* */
-
-/**
- * @typedef {|
-* JsonObject |
-* JsonArray
-* } JsonStackElement
-*/
-
-/** @typedef {list.List<JsonStackElement>} JsonStack */
-
-/**
- * @typedef {{
-*  readonly status: '' | '[' | '[v' | '[,' | '{' | '{k' | '{:' | '{v' | '{,'
-*  readonly top: JsonStackElement | null
-*  readonly stack: JsonStack
-* }} StateParse
-*/
-
-/**
- * @typedef {{
-*  readonly status: 'result'
-*  readonly value: Json.Unknown
-* }} StateResult
-*/
-
-/**
- * @typedef {{
-*  readonly status: 'error'
-*  readonly message: string
-* }} StateError
-*/
-
-/**
- * @typedef {|
-* StateParse |
-* StateResult |
-* StateError
-* } JsonState
-*/
-
-/** @type {(obj: JsonObject) => (key: string) => JsonObject} */
-const addKeyToObject = obj => key => ({ kind: 'object', values: obj.values, key: key })
-
-/** @type {(obj: JsonObject) => (value: Json.Unknown) => JsonObject} */
-const addValueToObject = obj => value => ({ kind: 'object', values: setReplace(obj.key)(value)(obj.values), key: '' })
-
-/** @type {(array: JsonArray) => (value: Json.Unknown) => JsonArray} */
-const addToArray = array => value => ({ kind: 'array', values: list.concat(array.values)([value]) })
-
-/** @type {(state: StateParse) => (key: string) => JsonState} */
-const pushKey = state => value => {
+const pushKey
+    : (state: StateParse) => (key: string) => JsonState
+    = state => value => {
     if (state.top?.kind === 'object') { return { status: '{k', top: addKeyToObject(state.top)(value), stack: state.stack } }
     return { status: 'error', message: 'error' }
 }
 
-/** @type {(state: StateParse) => (value: Json.Unknown) => JsonState} */
-const pushValue = state => value => {
+const pushValue
+    : (state: StateParse) => (value: Json.Unknown) => JsonState
+    = state => value => {
     if (state.top === null) { return { status: 'result', value: value } }
     if (state.top.kind === 'array') { return { status: '[v', top: addToArray(state.top)(value), stack: state.stack } }
     return { status: '{v', top: addValueToObject(state.top)(value), stack: state.stack }
 }
 
-/** @type {(state: StateParse) => JsonState} */
-const startArray = state => {
+const startArray
+    : (state: StateParse) => JsonState
+    = state => {
     const newStack = state.top === null ? null : { first: state.top, tail: state.stack }
     return { status: '[', top: { kind: 'array', values: null }, stack: newStack }
 }
 
-/** @type {(state: StateParse) => JsonState} */
-const endArray = state => {
+const endArray
+    : (state: StateParse) => JsonState
+    = state => {
     const array = state.top !== null ? toArray(state.top.values) : null
-    /** @type {StateParse} */
-    const newState = { status: '', top: first(null)(state.stack), stack: drop(1)(state.stack) }
+    const newState
+        : StateParse
+        = { status: '', top: first(null)(state.stack), stack: drop(1)(state.stack) }
     return pushValue(newState)(array)
 }
 
-/** @type {(state: StateParse) => JsonState} */
-const startObject = state => {
+const startObject
+    : (state: StateParse) => JsonState
+    = state => {
     const newStack = state.top === null ? null : { first: state.top, tail: state.stack }
     return { status: '{', top: { kind: 'object', values: null, key: '' }, stack: newStack }
 }
 
-/** @type {(state: StateParse) => JsonState} */
-const endObject = state => {
+const endObject
+    : (state: StateParse) => JsonState
+    = state => {
     const obj = state.top?.kind === 'object' ? fromMap(state.top.values) : null
-    /** @type {StateParse} */
-    const newState = { status: '', top: first(null)(state.stack), stack: drop(1)(state.stack) }
+    const newState
+        : StateParse
+        = { status: '', top: first(null)(state.stack), stack: drop(1)(state.stack) }
     return pushValue(newState)(obj)
 }
 
-/** @type {(token: Tokenizer.JsonToken) => Json.Unknown} */
-const tokenToValue = token => {
+const tokenToValue
+    : (token: Tokenizer.JsonToken) => Json.Unknown
+    = token => {
     switch (token.kind) {
         case 'null': return null
         case 'false': return false
@@ -127,8 +121,9 @@ const tokenToValue = token => {
     }
 }
 
-/** @type {(token: Tokenizer.JsonToken) => boolean} */
-const isValueToken = token => {
+const isValueToken
+    : (token: Tokenizer.JsonToken) => boolean
+    = token => {
     switch (token.kind) {
         case 'null':
         case 'false':
@@ -139,16 +134,18 @@ const isValueToken = token => {
     }
 }
 
-/** @type {(token: Tokenizer.JsonToken) => (state: StateParse) => JsonState}} */
-const parseValueOp = token => state => {
+const parseValueOp
+    : (token: Tokenizer.JsonToken) => (state: StateParse) => JsonState
+    = token => state => {
     if (isValueToken(token)) { return pushValue(state)(tokenToValue(token)) }
     if (token.kind === '[') { return startArray(state) }
     if (token.kind === '{') { return startObject(state) }
     return { status: 'error', message: 'unexpected token' }
 }
 
-/** @type {(token: Tokenizer.JsonToken) => (state: StateParse) => JsonState}} */
-const parseArrayStartOp = token => state => {
+const parseArrayStartOp
+    : (token: Tokenizer.JsonToken) => (state: StateParse) => JsonState
+    = token => state => {
     if (isValueToken(token)) { return pushValue(state)(tokenToValue(token)) }
     if (token.kind === '[') { return startArray(state) }
     if (token.kind === ']') { return endArray(state) }
@@ -156,41 +153,47 @@ const parseArrayStartOp = token => state => {
     return { status: 'error', message: 'unexpected token' }
 }
 
-/** @type {(token: Tokenizer.JsonToken) => (state: StateParse) => JsonState}} */
-const parseArrayValueOp = token => state => {
+const parseArrayValueOp
+    : (token: Tokenizer.JsonToken) => (state: StateParse) => JsonState
+    = token => state => {
     if (token.kind === ']') { return endArray(state) }
     if (token.kind === ',') { return { status: '[,', top: state.top, stack: state.stack } }
     return { status: 'error', message: 'unexpected token' }
 }
 
-/** @type {(token: Tokenizer.JsonToken) => (state: StateParse) => JsonState}} */
-const parseObjectStartOp = token => state => {
+const parseObjectStartOp
+    : (token: Tokenizer.JsonToken) => (state: StateParse) => JsonState
+    = token => state => {
     if (token.kind === 'string') { return pushKey(state)(token.value) }
     if (token.kind === '}') { return endObject(state) }
     return { status: 'error', message: 'unexpected token' }
 }
 
-/** @type {(token: Tokenizer.JsonToken) => (state: StateParse) => JsonState}} */
-const parseObjectKeyOp = token => state => {
+const parseObjectKeyOp
+    : (token: Tokenizer.JsonToken) => (state: StateParse) => JsonState
+    = token => state => {
     if (token.kind === ':') { return { status: '{:', top: state.top, stack: state.stack } }
     return { status: 'error', message: 'unexpected token' }
 }
 
-/** @type {(token: Tokenizer.JsonToken) => (state: StateParse) => JsonState}} */
-const parseObjectNextOp = token => state => {
+const parseObjectNextOp
+    : (token: Tokenizer.JsonToken) => (state: StateParse) => JsonState
+    = token => state => {
     if (token.kind === '}') { return endObject(state) }
     if (token.kind === ',') { return { status: '{,', top: state.top, stack: state.stack } }
     return { status: 'error', message: 'unexpected token' }
 }
 
-/** @type {(token: Tokenizer.JsonToken) => (state: StateParse) => JsonState}} */
-const parseObjectCommaOp = token => state => {
+const parseObjectCommaOp
+    : (token: Tokenizer.JsonToken) => (state: StateParse) => JsonState
+    = token => state => {
     if (token.kind === 'string') { return pushKey(state)(token.value) }
     return { status: 'error', message: 'unexpected token' }
 }
 
-/** @type {Operator.Fold<Tokenizer.JsonToken, JsonState>} */
-const foldOp = token => state => {
+const foldOp
+    : Operator.Fold<Tokenizer.JsonToken, JsonState>
+    = token => state => {
     switch (state.status) {
         case 'result': return { status: 'error', message: 'unexpected token' }
         case 'error': return { status: 'error', message: state.message }
@@ -206,8 +209,9 @@ const foldOp = token => state => {
     }
 }
 
-/** @type {(tokenList: list.List<Tokenizer.JsonToken>) => result.Result<Json.Unknown, string>} */
-export const parse = tokenList => {
+export const parse
+    : (tokenList: list.List<Tokenizer.JsonToken>) => result.Result<Json.Unknown, string>
+    = tokenList => {
     const state = fold(foldOp)({ status: '', top: null, stack: null })(tokenList)
     switch (state.status) {
         case 'result': return result.ok(state.value)

package/json/parser/{test.f.mjs → test.f.ts}

@@ -1,14 +1,15 @@
-import * as parser from './module.f.mjs'
-import * as tokenizer from '../tokenizer/module.f.mjs'
-import * as list from '../../types/list/module.f.mjs'
+import * as parser from './module.f.ts'
+import * as tokenizer from '../tokenizer/module.f.ts'
+import * as list from '../../types/list/module.f.ts'
 const { toArray } = list
-import * as json from '../module.f.mjs'
-import * as o from '../../types/object/module.f.mjs'
+import * as json from '../module.f.ts'
+import * as o from '../../types/object/module.f.ts'
 const { sort } = o
-import * as encoding from '../../text/utf16/module.f.mjs'
+import * as encoding from '../../text/utf16/module.f.ts'
 
-/** @type {(s: string) => readonly tokenizer.JsonToken[]} */
-const tokenizeString = s => toArray(tokenizer.tokenize(encoding.stringToList(s)))
+const tokenizeString
+    : (s: string) => readonly tokenizer.JsonToken[]
+    = s => toArray(tokenizer.tokenize(encoding.stringToList(s)))
 
 const stringify = json.stringify(sort)
 
@@ -251,4 +252,4 @@ export default {
             if (result !== '["error","unexpected token"]') { throw result }
         },
     ]
-}
+}

package/json/serializer/module.f.ts

@@ -0,0 +1,70 @@
+import * as list from '../../types/list/module.f.ts'
+const { flat, reduce, empty } = list
+import * as O from '../../types/object/module.f.ts'
+import * as Operator from '../../types/function/operator/module.f.ts'
+
+type Obj<T> = {
+    readonly [k in string]: Unknown<T>
+}
+
+type Arr<T> = readonly Unknown<T>[]
+
+type Primitive = |
+    boolean |
+    string |
+    number |
+    null
+
+type Unknown<T> = |
+    Arr<T>|
+    Obj<T>|
+    null|
+    T
+
+const jsonStringify = JSON.stringify
+
+export const stringSerialize
+    : (_: string) => list.List<string>
+    = input => [jsonStringify(input)]
+
+export const numberSerialize
+    : (_: number) => list.List<string>
+    = input => [jsonStringify(input)]
+
+export const nullSerialize = ['null']
+
+const trueSerialize = ['true']
+
+const falseSerialize = ['false']
+
+export const boolSerialize
+    : (_: boolean) => list.List<string>
+    = value => value ? trueSerialize : falseSerialize
+
+const comma = [',']
+
+const joinOp
+    : Operator.Reduce<list.List<string>>
+    = b => prior => flat([prior, comma, b])
+
+const join
+    : (input: list.List<list.List<string>>) => list.List<string>
+    = reduce(joinOp)(empty)
+
+const wrap
+    : (open: string) => (close: string) => (input: list.List<list.List<string>>) => list.List<string>
+    = open => close => {
+    const seqOpen = [open]
+    const seqClose = [close]
+    return input => flat([seqOpen, join(input), seqClose])
+}
+
+export const objectWrap = wrap('{')('}')
+
+export const arrayWrap = wrap('[')(']')
+
+type Entry<T> = O.Entry<Unknown<T>>
+
+type Entries<T> = list.List<Entry<T>>
+
+type MapEntries<T> = (entries: Entries<T>) => Entries<T>

package/json/serializer/{test.f.mjs → test.f.ts}

@@ -1,5 +1,5 @@
-import * as _ from './module.f.mjs'
-import * as list from '../../types/list/module.f.mjs'
+import * as _ from './module.f.ts'
+import * as list from '../../types/list/module.f.ts'
 const { toArray } = list
 
 export default {
@@ -61,4 +61,4 @@ export default {
             if (result !== '["true"]') { throw result }
         }
     ]
-}
+}

package/json/{test.f.mjs → test.f.ts}

@@ -1,7 +1,7 @@
-import * as json from './module.f.mjs'
-import * as o from '../types/object/module.f.mjs'
+import * as json from './module.f.ts'
+import * as o from '../types/object/module.f.ts'
 const { sort } = o
-import * as f from '../types/function/module.f.mjs'
+import * as f from '../types/function/module.f.ts'
 const { identity } = f
 
 export default {