functionalscript 0.3.3 → 0.3.5

package/json/module.f.ts

@@ -1,94 +0,0 @@
-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.ts

@@ -1,221 +0,0 @@
-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.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.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]) })
-
-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' }
-}
-
-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 }
-}
-
-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 }
-}
-
-const endArray
-    : (state: StateParse) => JsonState
-    = state => {
-    const array = state.top !== null ? toArray(state.top.values) : null
-    const newState
-        : StateParse
-        = { status: '', top: first(null)(state.stack), stack: drop(1)(state.stack) }
-    return pushValue(newState)(array)
-}
-
-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 }
-}
-
-const endObject
-    : (state: StateParse) => JsonState
-    = state => {
-    const obj = state.top?.kind === 'object' ? fromMap(state.top.values) : null
-    const newState
-        : StateParse
-        = { status: '', top: first(null)(state.stack), stack: drop(1)(state.stack) }
-    return pushValue(newState)(obj)
-}
-
-const tokenToValue
-    : (token: Tokenizer.JsonToken) => Json.Unknown
-    = token => {
-    switch (token.kind) {
-        case 'null': return null
-        case 'false': return false
-        case 'true': return true
-        case 'number': return parseFloat(token.value)
-        case 'string': return token.value
-        default: return null
-    }
-}
-
-const isValueToken
-    : (token: Tokenizer.JsonToken) => boolean
-    = token => {
-    switch (token.kind) {
-        case 'null':
-        case 'false':
-        case 'true':
-        case 'number':
-        case 'string': return true
-        default: return false
-    }
-}
-
-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' }
-}
-
-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) }
-    if (token.kind === '{') { return startObject(state) }
-    return { status: 'error', message: 'unexpected token' }
-}
-
-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' }
-}
-
-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' }
-}
-
-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' }
-}
-
-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' }
-}
-
-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' }
-}
-
-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 }
-        case '': return parseValueOp(token)(state)
-        case '[': return parseArrayStartOp(token)(state)
-        case '[v': return parseArrayValueOp(token)(state)
-        case '[,': return parseValueOp(token)(state)
-        case '{': return parseObjectStartOp(token)(state)
-        case '{k': return parseObjectKeyOp(token)(state)
-        case '{:': return parseValueOp(token)(state)
-        case '{v': return parseObjectNextOp(token)(state)
-        case '{,': return parseObjectCommaOp(token)(state)
-    }
-}
-
-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)
-        case 'error': return result.error(state.message)
-        default: return result.error('unexpected end')
-    }
-}

package/json/parser/test.f.ts

@@ -1,255 +0,0 @@
-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.ts'
-import * as o from '../../types/object/module.f.ts'
-const { sort } = o
-import * as encoding from '../../text/utf16/module.f.ts'
-
-const tokenizeString
-    : (s: string) => readonly tokenizer.JsonToken[]
-    = s => toArray(tokenizer.tokenize(encoding.stringToList(s)))
-
-const stringify = json.stringify(sort)
-
-export default {
-    valid: [
-        () => {
-            const tokenList = tokenizeString('null')
-            const obj = parser.parse(tokenList)
-            const result = stringify(obj)
-            if (result !== '["ok",null]') { throw result }
-        },
-        () => {
-            const tokenList = tokenizeString('true')
-            const obj = parser.parse(tokenList)
-            const result = stringify(obj)
-            if (result !== '["ok",true]') { throw result }
-        },
-        () => {
-            const tokenList = tokenizeString('false')
-            const obj = parser.parse(tokenList)
-            const result = stringify(obj)
-            if (result !== '["ok",false]') { throw result }
-        },
-        () => {
-            const tokenList = tokenizeString('0.1')
-            const obj = parser.parse(tokenList)
-            const result = stringify(obj)
-            if (result !== '["ok",0.1]') { throw result }
-        },
-        () => {
-            const tokenList = tokenizeString('1.1e+2')
-            const obj = parser.parse(tokenList)
-            const result = stringify(obj)
-            if (result !== '["ok",110]') { throw result }
-        },
-        () => {
-            const tokenList = tokenizeString('"abc"')
-            const obj = parser.parse(tokenList)
-            const result = stringify(obj)
-            if (result !== '["ok","abc"]') { throw result }
-        },
-        () => {
-            const tokenList = tokenizeString('[]')
-            const obj = parser.parse(tokenList)
-            const result = stringify(obj)
-            if (result !== '["ok",[]]') { throw result }
-        },
-        () => {
-            const tokenList = tokenizeString('[1]')
-            const obj = parser.parse(tokenList)
-            const result = stringify(obj)
-            if (result !== '["ok",[1]]') { throw result }
-        },
-        () => {
-            const tokenList = tokenizeString('[[]]')
-            const obj = parser.parse(tokenList)
-            const result = stringify(obj)
-            if (result !== '["ok",[[]]]') { throw result }
-        },
-        () => {
-            const tokenList = tokenizeString('[0,[1,[2,[]]],3]')
-            const obj = parser.parse(tokenList)
-            const result = stringify(obj)
-            if (result !== '["ok",[0,[1,[2,[]]],3]]') { throw result }
-        },
-        () => {
-            const tokenList = tokenizeString('{}')
-            const obj = parser.parse(tokenList)
-            const result = stringify(obj)
-            if (result !== '["ok",{}]') { throw result }
-        },
-        () => {
-            const tokenList = tokenizeString('[{}]')
-            const obj = parser.parse(tokenList)
-            const result = stringify(obj)
-            if (result !== '["ok",[{}]]') { throw result }
-        },
-        () => {
-            const tokenList = tokenizeString('{"a":true,"b":false,"c":null}')
-            const obj = parser.parse(tokenList)
-            const result = stringify(obj)
-            if (result !== '["ok",{"a":true,"b":false,"c":null}]') { throw result }
-        },
-        () => {
-            const tokenList = tokenizeString('{"a":{"b":{"c":["d"]}}}')
-            const obj = parser.parse(tokenList)
-            const result = stringify(obj)
-            if (result !== '["ok",{"a":{"b":{"c":["d"]}}}]') { throw result }
-        }
-    ],
-    invalid: [
-        () => {
-            const tokenList = tokenizeString('')
-            const obj = parser.parse(tokenList)
-            const result = stringify(obj)
-            if (result !== '["error","unexpected end"]') { throw result }
-        },
-        () => {
-            const tokenList = tokenizeString('"123')
-            const obj = parser.parse(tokenList)
-            const result = stringify(obj)
-            if (result !== '["error","unexpected token"]') { throw result }
-        },
-        () => {
-            const tokenList = tokenizeString('[,]')
-            const obj = parser.parse(tokenList)
-            const result = stringify(obj)
-            if (result !== '["error","unexpected token"]') { throw result }
-        },
-        () => {
-            const tokenList = tokenizeString('[1 2]')
-            const obj = parser.parse(tokenList)
-            const result = stringify(obj)
-            if (result !== '["error","unexpected token"]') { throw result }
-        },
-        () => {
-            const tokenList = tokenizeString('[1,,2]')
-            const obj = parser.parse(tokenList)
-            const result = stringify(obj)
-            if (result !== '["error","unexpected token"]') { throw result }
-        },
-        () => {
-            const tokenList = tokenizeString('[]]')
-            const obj = parser.parse(tokenList)
-            const result = stringify(obj)
-            if (result !== '["error","unexpected token"]') { throw result }
-        },
-        () => {
-            const tokenList = tokenizeString('["a"')
-            const obj = parser.parse(tokenList)
-            const result = stringify(obj)
-            if (result !== '["error","unexpected end"]') { throw result }
-        },
-        () => {
-            const tokenList = tokenizeString('[1,]')
-            const obj = parser.parse(tokenList)
-            const result = stringify(obj)
-            if (result !== '["error","unexpected token"]') { throw result }
-        },
-        () => {
-            const tokenList = tokenizeString('[,1]')
-            const obj = parser.parse(tokenList)
-            const result = stringify(obj)
-            if (result !== '["error","unexpected token"]') { throw result }
-        },
-        () => {
-            const tokenList = tokenizeString('[:]')
-            const obj = parser.parse(tokenList)
-            const result = stringify(obj)
-            if (result !== '["error","unexpected token"]') { throw result }
-        },
-        () => {
-            const tokenList = tokenizeString(']')
-            const obj = parser.parse(tokenList)
-            const result = stringify(obj)
-            if (result !== '["error","unexpected token"]') { throw result }
-        },
-        () => {
-            const tokenList = tokenizeString('{,}')
-            const obj = parser.parse(tokenList)
-            const result = stringify(obj)
-            if (result !== '["error","unexpected token"]') { throw result }
-        },
-        () => {
-            const tokenList = tokenizeString('{1:2}')
-            const obj = parser.parse(tokenList)
-            const result = stringify(obj)
-            if (result !== '["error","unexpected token"]') { throw result }
-        },
-        () => {
-            const tokenList = tokenizeString('{"1"2}')
-            const obj = parser.parse(tokenList)
-            const result = stringify(obj)
-            if (result !== '["error","unexpected token"]') { throw result }
-        },
-        () => {
-            const tokenList = tokenizeString('{"1"::2}')
-            const obj = parser.parse(tokenList)
-            const result = stringify(obj)
-            if (result !== '["error","unexpected token"]') { throw result }
-        },
-        () => {
-            const tokenList = tokenizeString('{"1":2,,"3":4')
-            const obj = parser.parse(tokenList)
-            const result = stringify(obj)
-            if (result !== '["error","unexpected token"]') { throw result }
-        },
-        () => {
-            const tokenList = tokenizeString('{}}')
-            const obj = parser.parse(tokenList)
-            const result = stringify(obj)
-            if (result !== '["error","unexpected token"]') { throw result }
-        },
-        () => {
-            const tokenList = tokenizeString('{"1":2')
-            const obj = parser.parse(tokenList)
-            const result = stringify(obj)
-            if (result !== '["error","unexpected end"]') { throw result }
-        },
-        () => {
-            const tokenList = tokenizeString('{"1":2,}')
-            const obj = parser.parse(tokenList)
-            const result = stringify(obj)
-            if (result !== '["error","unexpected token"]') { throw result }
-        },
-        () => {
-            const tokenList = tokenizeString('{,"1":2}')
-            const obj = parser.parse(tokenList)
-            const result = stringify(obj)
-            if (result !== '["error","unexpected token"]') { throw result }
-        },
-        () => {
-            const tokenList = tokenizeString('}')
-            const obj = parser.parse(tokenList)
-            const result = stringify(obj)
-            if (result !== '["error","unexpected token"]') { throw result }
-        },
-        () => {
-            const tokenList = tokenizeString('[{]}')
-            const obj = parser.parse(tokenList)
-            const result = stringify(obj)
-            if (result !== '["error","unexpected token"]') { throw result }
-        },
-        () => {
-            const tokenList = tokenizeString('{[}]')
-            const obj = parser.parse(tokenList)
-            const result = stringify(obj)
-            if (result !== '["error","unexpected token"]') { throw result }
-        },
-        () => {
-            const tokenList = tokenizeString('10-5')
-            const obj = parser.parse(tokenList)
-            const result = stringify(obj)
-            if (result !== '["error","unexpected token"]') { throw result }
-        },
-        () => {
-            const tokenList = tokenizeString('undefined')
-            const obj = parser.parse(tokenList)
-            const result = stringify(obj)
-            if (result !== '["error","unexpected token"]') { throw result }
-        },
-    ]
-}

package/json/serializer/module.f.ts

@@ -1,74 +0,0 @@
-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
-: (input: list.List<list.List<string>>) => list.List<string>
-= wrap('{')('}')
-
-export const arrayWrap
-: (input: list.List<list.List<string>>) => list.List<string>
-= wrap('[')(']')
-
-type Entry<T> = O.Entry<Unknown<T>>
-
-type Entries<T> = list.List<Entry<T>>
-
-type MapEntries<T> = (entries: Entries<T>) => Entries<T>