functionalscript 0.2.6 → 0.3.1

package/djs/serializer/module.f.ts

@@ -0,0 +1,90 @@
+import * as list from '../../types/list/module.f.ts'
+const { flat, map, entries: listEntries, concat: listConcat, flatMap } = list
+import * as string from '../../types/string/module.f.ts'
+const { concat } = string
+import * as O from '../../types/object/module.f.ts'
+import * as f from '../../types/function/module.f.ts'
+const { compose, fn } = f
+const { entries } = Object
+import * as bi from '../../types/bigint/module.f.ts'
+const { serialize: bigintSerialize } = bi
+import * as j from '../../json/serializer/module.f.ts'
+const { objectWrap, arrayWrap, stringSerialize, numberSerialize, nullSerialize, boolSerialize } = j
+import * as DjsParser from '../parser/module.f.ts'
+
+const colon = [':']
+
+export const undefinedSerialize = ['undefined']
+
+type Entry = O.Entry<DjsParser.DjsConst>
+
+type Entries = list.List<Entry>
+
+type MapEntries = (entries: Entries) => Entries
+
+const djsConstSerialize
+: (mapEntries: MapEntries) => (value: DjsParser.DjsConst) => list.List<string>
+= sort => {
+    const propertySerialize
+    : (kv: readonly[string, DjsParser.DjsConst]) => list.List<string>
+    = ([k, v]) => flat([
+        stringSerialize(k),
+        colon,
+        f(v)
+    ])
+    const mapPropertySerialize = map(propertySerialize)
+    const objectSerialize
+    : (object: DjsParser.DjsObject) => list.List<string>
+    = fn(entries)
+        .then(sort)
+        .then(mapPropertySerialize)
+        .then(objectWrap)
+        .result
+    const f
+    : (value: DjsParser.DjsConst) => list.List<string>
+    = value => {
+        switch (typeof value) {
+            case 'boolean': { return boolSerialize(value) }
+            case 'number': { return numberSerialize(value) }
+            case 'string': { return stringSerialize(value) }
+            case 'bigint': { return [bigintSerialize(value)] }
+            default: {
+                if (value === null) { return nullSerialize }
+                if (value === undefined) { return undefinedSerialize }
+                if (value instanceof Array) {
+                    switch (value[0]) {
+                        case 'aref': { return [`a${value[1]}`] }
+                        case 'cref': { return [`c${value[1]}`] }
+                        case 'array': { return arraySerialize(value[1]) }
+                    }
+                }
+                return objectSerialize(value)
+            }
+        }
+    }
+    const arraySerialize = compose(map(f))(arrayWrap)
+    return f
+}
+
+export const djsModuleStringify
+: (mapEntries: MapEntries) => (djsModule: DjsParser.DjsModule) => string
+= sort => djsModule => {
+    const importEntries = listEntries(djsModule[0])
+    const importSerialize
+    : (entry: list.Entry<string>) => list.List<string>
+    = entry => flat([['import a'], numberSerialize(entry[0]), [' from "', entry[1], '"\n']])
+
+    const len = djsModule[1].length
+    const constEntries = listEntries(djsModule[1])
+    const moduleEntrySerialize
+    : (entry: list.Entry<DjsParser.DjsConst>) => list.List<string>
+    = entry => {
+        if (entry[0] === len - 1) {
+            return listConcat(['export default '])(djsConstSerialize(sort)(entry[1]))
+        }
+        return flat([['const c'], numberSerialize(entry[0]), [' = '], djsConstSerialize(sort)(entry[1]), ['\n']])
+    }
+
+    return concat(listConcat(flatMap(importSerialize)(importEntries))(flatMap(moduleEntrySerialize)(constEntries)))
+}
+

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

@@ -1,9 +1,9 @@
-import * as json from '../json/module.f.mjs'
-import * as list from '../types/object/module.f.mjs'
+import * as json from '../json/module.f.ts'
+import * as list from '../types/object/module.f.ts'
 const { sort } = list
-import * as f from '../types/function/module.f.mjs'
+import * as f from '../types/function/module.f.ts'
 const { identity } = f
-import * as djs from './module.f.mjs'
+import * as djs from './module.f.ts'
 
 export default {
     stringify: [

package/djs/tokenizer/{module.f.mjs → module.f.ts}

@@ -1,41 +1,29 @@
-// @ts-self-types="./module.f.d.mts"
-
-import * as Operator from '../../types/function/operator/module.f.mjs'
-import * as list from '../../types/list/module.f.mjs'
+import * as Operator from '../../types/function/operator/module.f.ts'
+import * as list from '../../types/list/module.f.ts'
 const { empty, flat, stateScan } = list
-import * as bf from '../../types/bigfloat/module.f.mjs'
+import * as bf from '../../types/bigfloat/module.f.ts'
 const { multiply } = bf
-import * as jsTokenizer from '../../js/tokenizer/module.f.mjs'
+import * as jsTokenizer from '../../js/tokenizer/module.f.ts'
 
-/**
- * @typedef {|
-* {readonly kind: 'true' | 'false' | 'null' | 'undefined'} |
-* {readonly kind: '{' | '}' | ':' | ',' | '[' | ']' | '.' | '=' } |
-* jsTokenizer.StringToken |
-* jsTokenizer.NumberToken |
-* jsTokenizer.ErrorToken |
-* jsTokenizer.IdToken |
-* jsTokenizer.BigIntToken |
-* jsTokenizer.WhitespaceToken |
-* jsTokenizer.NewLineToken |
-* jsTokenizer.CommentToken
-* } DjsToken
-*/
+export type DjsToken = |
+  {readonly kind: 'true' | 'false' | 'null' | 'undefined'} |
+  {readonly kind: '{' | '}' | ':' | ',' | '[' | ']' | '.' | '=' } |
+  jsTokenizer.StringToken |
+  jsTokenizer.NumberToken |
+  jsTokenizer.ErrorToken |
+  jsTokenizer.IdToken |
+  jsTokenizer.BigIntToken |
+  jsTokenizer.WhitespaceToken |
+  jsTokenizer.NewLineToken |
+  jsTokenizer.CommentToken
 
-/**
- * @typedef {|
-* {readonly kind: 'def' | '-' }
-* } ScanState
-*/
+type ScanState = {readonly kind: 'def' | '-' }
 
-/**
- * @typedef {|
-* jsTokenizer.JsToken | null
-* } ScanInput
-*/
+type ScanInput = | jsTokenizer.JsToken | null
 
-/** @type {(input: jsTokenizer.JsToken) => list.List<DjsToken>} */
-const mapToken = input =>
+const mapToken
+    : (input: jsTokenizer.JsToken) => list.List<DjsToken>
+    = input =>
 {
     switch(input.kind)
     {
@@ -64,8 +52,9 @@ const mapToken = input =>
     }
 }
 
-/** @type {(input: ScanInput) => readonly [list.List<DjsToken>, ScanState]} */
-const parseDefaultState = input =>
+const parseDefaultState
+    : (input: ScanInput) => readonly [list.List<DjsToken>, ScanState]
+    = input =>
 {
     if (input === null) return [empty, { kind: 'def'}]
     switch(input.kind)
@@ -75,8 +64,9 @@ const parseDefaultState = input =>
     }
 }
 
-/** @type {(input: ScanInput) => readonly [list.List<DjsToken>, ScanState]} */
-const parseMinusState = input =>
+const parseMinusState
+    : (input: ScanInput) => readonly [list.List<DjsToken>, ScanState]
+    = input =>
 {
     if (input === null) return [[{ kind: 'error', message: 'invalid token' }], { kind: 'def'}]
     switch(input.kind)
@@ -88,8 +78,9 @@ const parseMinusState = input =>
     }
 }
 
-/** @type {Operator.StateScan<ScanInput, ScanState, list.List<DjsToken>>} */
-const scanToken = state => input => {
+const scanToken
+    : Operator.StateScan<ScanInput, ScanState, list.List<DjsToken>>
+    = state => input => {
     switch(state.kind)
     {
         case '-': return parseMinusState(input)
@@ -97,10 +88,12 @@ const scanToken = state => input => {
     }
 }
 
-/** @type {(input: list.List<number>) => list.List<DjsToken>} */
-export const tokenize = input =>
+export const tokenize
+    : (input: list.List<number>) => list.List<DjsToken>
+    = input =>
 {
-    /** @type {list.List<ScanInput>} */
-    const jsTokens = jsTokenizer.tokenize(input)
+    const jsTokens
+        : list.List<ScanInput>
+        = jsTokenizer.tokenize(input)
     return flat(stateScan(scanToken)({ kind: 'def' })(list.concat(jsTokens)([null])))
 }

package/djs/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 '../module.f.mjs'
-import * as o from '../../types/object/module.f.mjs'
+import * as djs 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.DjsToken[]} */
-const tokenizeString = s => toArray(tokenizer.tokenize(encoding.stringToList(s)))
+const tokenizeString
+    : (s: string) => readonly tokenizer.DjsToken[]
+    = s => toArray(tokenizer.tokenize(encoding.stringToList(s)))
 
 const stringify = djs.stringify(sort)
 
@@ -360,4 +361,4 @@ export default {
             if (result !== '[{"kind":"/*","value":" multiline comment *\\n * *"},{"kind":"nl"}]') { throw result }
         },
     ]
-}
+}

package/fsc/{module.f.mjs → module.f.ts}

@@ -1,53 +1,49 @@
-// @ts-self-types="./module.f.d.mts"
-import * as operator from '../types/function/operator/module.f.mjs'
-import * as rangeMap from '../types/range_map/module.f.mjs'
+import * as operator from '../types/function/operator/module.f.ts'
+import * as rangeMap from '../types/range_map/module.f.ts'
 const { merge: rangeMapMerge, fromRange, get } = rangeMap
-import * as list from '../types/list/module.f.mjs'
+import * as list from '../types/list/module.f.ts'
 const { reduce: listReduce } = list
-import * as ascii from '../text/ascii/module.f.mjs'
+import * as ascii from '../text/ascii/module.f.ts'
 const { range: asciiRange } = ascii
 const { fromCharCode } = String
-import * as f from '../types/function/module.f.mjs'
+import * as f from '../types/function/module.f.ts'
 const { fn } = f
-import * as _range from '../types/range/module.f.mjs'
+import * as _range from '../types/range/module.f.ts'
 const { one } = _range
 const { toArray, map } = list
 
-/** @typedef {readonly[readonly string[], ToResult]} Result */
+type Result = readonly[readonly string[], ToResult]
 
-/** @typedef {(codePoint: number) => Result} ToResult */
+type ToResult = (codePoint: number) => Result
 
-/**
- * @template T
- * @typedef {(state: T) => ToResult} CreateToResult
- */
+type CreateToResult<T> = (state: T) => ToResult
 
-/**
- * @template T
- * @typedef {rangeMap.RangeMapArray<CreateToResult<T>>} State
- */
+type State<T> = rangeMap.RangeMapArray<CreateToResult<T>>
 
-/** @type {ToResult} */
-const unexpectedSymbol = codePoint => [[`unexpected symbol ${codePoint}`], unexpectedSymbol]
+const unexpectedSymbol
+    : ToResult
+    = codePoint => [[`unexpected symbol ${codePoint}`], unexpectedSymbol]
 
-/** @type {<T>(state: T) => ToResult} */
-const def = () => unexpectedSymbol
+const def
+    : <T>(state: T) => ToResult
+    = () => unexpectedSymbol
 
-/** @type {<T>(a: CreateToResult<T>) => (b: CreateToResult<T>) => CreateToResult<T>} */
-const union = a => b => {
+const union
+    : <T>(a: CreateToResult<T>) => (b: CreateToResult<T>) => CreateToResult<T>
+    = a => b => {
     if (a === def || a === b) { return b }
     if (b === def) { return a }
     throw [a, b]
 }
 
-/** @type {readonly never[]} */
-const empty = []
+const empty
+    : readonly never[]
+    = []
 
-/** @type {<T>(a: list.List<State<T>>) => State<T>} */
-const reduce = a => {
-    /** @typedef {typeof a extends list.List<State<infer T>> ? T : never} T */
-    /** @type {rangeMap.RangeMerge<CreateToResult<T>>} */
-    const merge = rangeMapMerge({
+const reduce = <T>(a: list.List<State<T>>): State<T> => {
+    const merge
+        : rangeMap.RangeMerge<CreateToResult<T>>
+        = rangeMapMerge({
         union,
         equal: operator.strictEqual,
     })
@@ -58,29 +54,30 @@ const codePointRange = fromRange(def)
 
 const range = fn(asciiRange).then(codePointRange).result
 
-/** @type {(l: readonly string[]) => <T>(f: CreateToResult<T>) => State<T>} */
-const rangeSet = l => f => {
-    /** @typedef {typeof f extends CreateToResult<infer T> ? T : never} T */
-    /** @type {(a: _range.Range) => (f: CreateToResult<T>) => State<T>} */
-    const codePointRange = fromRange(def)
-    /** @type {(r: string) => State<T>} */
-    const g = r => codePointRange(asciiRange(r))(f)
+const rangeSet
+    = (l: readonly string[]) => <T>(f: CreateToResult<T>): State<T> => {
+    const codePointRange
+        : (a: _range.Range) => (f: CreateToResult<T>) => State<T>
+        = fromRange(def)
+    const g
+        : (r: string) => State<T>
+        = r => codePointRange(asciiRange(r))(f)
     return reduce(map(g)(l))
 }
 
-/** @type {<T>(a: list.List<State<T>>) => CreateToResult<T>} */
-const create = a => {
-    /** @typedef {typeof a extends list.List<State<infer T>> ? T : never} T */
+const create = <T>(a: list.List<State<T>>): CreateToResult<T> => {
     const i = reduce(a)
-    /** @type {(v: number) => (i: State<T>) => (v: T) => ToResult} */
-    const x = get(def)
+    const x
+        : (v: number) => (i: State<T>) => (v: T) => ToResult
+        = get(def)
     return v => c => x(c)(i)(v)(c)
 }
 
 export const terminal = -1
 
-/** @type {() => ToResult} */
-const toInit = () => () => [[], init]
+const toInit
+    : () => ToResult
+    = () => () => [[], init]
 
 export const init = create([
     codePointRange(one(terminal))(toInit),

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

@@ -1,12 +1,14 @@
-import * as _ from './module.f.mjs'
-import * as ascii from '../text/ascii/module.f.mjs'
+import * as _ from './module.f.ts'
+import * as ascii from '../text/ascii/module.f.ts'
 const { one } = ascii
-import * as j from '../json/module.f.mjs'
+import * as j from '../json/module.f.ts'
 const { stringify } = j
 const s = stringify(i => i)
 
-/** @type {(v: string) => string} */
-const f = v => {
+/** @type {} */
+const f
+    : (v: string) => string
+    = v => {
     const n = one(v)
     return s(_.init(n)[0])
 }
@@ -16,4 +18,4 @@ export default {
         const x = f('1')
         if (x != '["1"]') { throw x }
     }
-}
+}

package/fsm/module.f.ts

@@ -0,0 +1,107 @@
+import * as list from '../types/list/module.f.ts'
+const { equal, isEmpty, fold, toArray, scan, foldScan, empty: emptyList } = list
+import * as byteSet from '../types/byte_set/module.f.ts'
+const { toRangeMap, union: byteSetUnion, one, empty } = byteSet
+import * as sortedSet from '../types/sorted_set/module.f.ts'
+const { intersect, union: sortedSetUnion } = sortedSet
+import * as rangeMap from '../types/range_map/module.f.ts'
+const { merge } = rangeMap
+import * as cmp from '../types/function/compare/module.f.ts'
+const { unsafeCmp } = cmp
+import * as operator from '../types/function/operator/module.f.ts'
+const { strictEqual } = operator
+import * as j from '../json/module.f.ts'
+const { stringify } = j
+import * as f from '../types/function/module.f.ts'
+const { identity } = f
+import * as utf16 from '../text/utf16/module.f.ts'
+const { stringToList } = utf16
+
+type Rule = readonly[string, byteSet.ByteSet, string]
+
+export type Grammar = list.List<Rule>
+
+type Dfa = {
+   readonly[state in string]: rangeMap.RangeMapArray<string>
+}
+
+const stringifyIdentity = stringify(identity)
+
+export const toRange
+    : (s: string) => byteSet.ByteSet
+    = s => {
+    const [b, e] = toArray(stringToList(s))
+    return byteSet.range([b, e])
+}
+
+const toUnionOp
+    : operator.Fold<number, byteSet.ByteSet>
+    = i => bs => byteSetUnion(bs)(one(i))
+
+export const toUnion
+    : (s: string) => byteSet.ByteSet
+    = s => {
+    const codePoints = stringToList(s)
+    return fold(toUnionOp)(empty)(codePoints)
+}
+
+const mergeOp
+    : rangeMap.Operators<sortedSet.SortedSet<string>>
+    = { union: sortedSetUnion(unsafeCmp), equal: equal(strictEqual) }
+
+const hasState
+    : (s: string) => (set: sortedSet.SortedSet<string>) => boolean
+    = s => set => !isEmpty(intersect(unsafeCmp)([s])(set))
+
+const foldOp
+    : (set: sortedSet.SortedSet<string>) => operator.Fold<Rule, rangeMap.RangeMap<sortedSet.SortedSet<string>>>
+    = set => ([ruleIn, bs, ruleOut]) => rm => {
+    if (hasState(ruleIn)(set)) { return merge(mergeOp)(rm)(toRangeMap(bs)(ruleOut)) }
+    return rm
+}
+
+const stringifyOp
+    : operator.Scan<rangeMap.Entry<sortedSet.SortedSet<string>>, rangeMap.Entry<string>>
+    = ([sortedSet, max]) => [[stringifyIdentity(sortedSet), max], stringifyOp]
+
+const scanStringify = scan(stringifyOp)
+
+const fetchOp
+    : operator.Scan<rangeMap.Entry<sortedSet.SortedSet<string>>, sortedSet.SortedSet<string>>
+    = ([item, _]) => [item, fetchOp]
+
+const scanFetch = scan(fetchOp)
+
+const addEntry
+    : (grammar: Grammar) => operator.Fold<sortedSet.SortedSet<string>, Dfa>
+    = grammar => set => dfa => {
+    const s = stringifyIdentity(set)
+    if (s in dfa) { return dfa }
+    const setMap = fold(foldOp(set))(emptyList)(grammar)
+    const stringMap = toArray(scanStringify(setMap))
+    const newDfa = { ...dfa, [s]: stringMap }
+    const newStates = scanFetch(setMap)
+    return fold(addEntry(grammar))(newDfa)(newStates)
+}
+
+const emptyState: string[] = []
+
+const emptyStateStringify = stringifyIdentity(emptyState)
+
+const initialState = ['']
+
+const initialStateStringify = stringifyIdentity(initialState)
+
+export const dfa
+    : (grammar: Grammar) => Dfa
+    = grammar => addEntry(grammar)(initialState)({})
+
+const get = rangeMap.get(emptyStateStringify)
+
+const runOp
+    : (dfa: Dfa) => operator.Fold<number, string>
+    = dfa => input => s => get(input)(dfa[s])
+
+export const run
+    : (dfa: Dfa) => (input: list.List<number>) => list.List<string>
+    = dfa => input => foldScan(runOp(dfa))(initialStateStringify)(input)

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

@@ -1,13 +1,13 @@
-import * as _ from './module.f.mjs'
-import * as byteSet from '../types/byte_set/module.f.mjs'
-import * as o from '../types/object/module.f.mjs'
+import * as _ from './module.f.ts'
+import * as byteSet from '../types/byte_set/module.f.ts'
+import * as o from '../types/object/module.f.ts'
 const { sort, fromEntries } = o
-import * as json from '../json/module.f.mjs'
-import * as f from '../types/function/module.f.mjs'
+import * as json from '../json/module.f.ts'
+import * as f from '../types/function/module.f.ts'
 const { identity } = f
-import * as list from '../types/list/module.f.mjs'
+import * as list from '../types/list/module.f.ts'
 const { toArray } = list
-import * as utf16 from '../text/utf16/module.f.mjs'
+import * as utf16 from '../text/utf16/module.f.ts'
 const { stringToList } = utf16
 
 const stringifyIdentity = json.stringify(identity)
@@ -22,8 +22,9 @@ const buildDfa = () => {
     const idNext = byteSet.union(idBegin)(digit)
     const dot = _.toUnion('.')
 
-    /** @type {_.Grammar} */
-    const grammar = [
+    const grammar
+        : _.Grammar
+        = [
         ['', digit, 'int'],
         ['int', digit, 'int'],
         ['', digit, 'floatBegin'],

package/html/module.f.ts

@@ -0,0 +1,108 @@
+import * as list from '../types/list/module.f.ts'
+const { map, flatMap, flat, concat: listConcat } = list
+import * as s from '../types/string/module.f.ts'
+const { concat: stringConcat } = s
+import * as O from '../types/object/module.f.ts'
+import * as f from '../types/function/module.f.ts'
+const { compose } = f
+import * as utf16 from '../text/utf16/module.f.ts'
+const { stringToList } = utf16
+const { fromCharCode } = String
+const { entries } = Object
+
+type Tag = string
+
+/**
+ * Void Elements
+ *
+ * https://developer.mozilla.org/en-US/docs/Glossary/Void_element
+ */
+const voidTagList = [
+    'area',
+    'base',
+    'br',
+    'col',
+    'embed',
+    'hr',
+    'img',
+    'input',
+    'link',
+    'meta',
+    'param',
+    'source',
+    'track',
+    'wbr',
+] as const
+
+type VoidTagList = typeof voidTagList
+
+type VoidTag = keyof VoidTagList
+
+const isVoid
+    : (tag: string) => boolean
+    = tag => (voidTagList as readonly string[]).includes(tag)
+
+type Element1 = readonly[Tag, ...Node[]]
+
+type Element2 = readonly[Tag, Attributes, ...Node[]]
+
+export type Element = Element1 | Element2
+
+type Attributes = {
+    readonly[k in string]: string
+}
+
+type Node = Element | string
+
+/**
+ * https://stackoverflow.com/questions/7381974/which-characters-need-to-be-escaped-in-html
+ */
+const escapeCharCode
+    : (code: number) => string
+    = code => {
+    switch (code) {
+        case 0x22: return '"'
+        case 0x26: return '&'
+        case 0x3C: return '<'
+        case 0x3E: return '>'
+        default: return fromCharCode(code)
+    }
+}
+
+const escape = compose(stringToList)(map(escapeCharCode))
+
+const node
+    : (n: Node) => list.List<string>
+    = n => typeof n === 'string' ? escape(n) : element(n)
+
+const nodes = flatMap(node)
+
+const attribute
+    : (a: O.Entry<string>) => list.List<string>
+    = ([name, value]) => flat([[' ', name, '="'], escape(value), ['"']])
+
+const attributes
+    : (a: Attributes) => list.List<string>
+    = compose(entries)(flatMap(attribute))
+
+const open
+    : (t: string) => (a: Attributes) => list.List<string>
+    = t => a => flat([[`<`, t], attributes(a), [`>`]])
+
+const element3
+    : (t: string) => (an: readonly[Attributes, readonly Node[]]) => list.List<string>
+    = t => ([a, n]) => {
+    const o = flat([[`<`, t], attributes(a), [`>`]])
+    return isVoid(t) ? o : flat([o, nodes(n), ['</', t, '>']])
+}
+
+export const element
+    : (element: Element) => list.List<string>
+    = e => {
+    const [t, a, ...n] = e
+    return element3(t)(a === undefined ? [{}, []]: typeof a === 'object' && !(a instanceof Array) ? [a, n] : [{}, [a, ...n]])
+}
+
+export const html = compose(element)(listConcat(['<!DOCTYPE html>']))
+
+export const htmlToString = compose(html)(stringConcat)