functionalscript 0.1.609 → 0.2.1

package/djs/tokenizer/module.f.mjs

@@ -1,23 +1,23 @@
 // @ts-self-types="./module.f.d.mts"
 
 import * as Operator from '../../types/function/operator/module.f.mjs'
-import list, * as List from '../../types/list/module.f.mjs'
+import * as list from '../../types/list/module.f.mjs'
 const { empty, flat, stateScan } = list
-import bf from '../../types/bigfloat/module.f.mjs'
+import * as bf from '../../types/bigfloat/module.f.mjs'
 const { multiply } = bf
-import jsTokenizer, * as jsTokenizerT from '../../js/tokenizer/module.f.mjs'
+import * as jsTokenizer from '../../js/tokenizer/module.f.mjs'
 
 /**
  * @typedef {|
 * {readonly kind: 'true' | 'false' | 'null'} |
 * {readonly kind: '{' | '}' | ':' | ',' | '[' | ']' | '.' | '=' } |
-* jsTokenizerT.StringToken |
-* jsTokenizerT.NumberToken |
-* jsTokenizerT.ErrorToken |
-* jsTokenizerT.IdToken |
-* jsTokenizerT.BigIntToken |
-* jsTokenizerT.WhitespaceToken |
-* jsTokenizerT.NewLineToken
+* jsTokenizer.StringToken |
+* jsTokenizer.NumberToken |
+* jsTokenizer.ErrorToken |
+* jsTokenizer.IdToken |
+* jsTokenizer.BigIntToken |
+* jsTokenizer.WhitespaceToken |
+* jsTokenizer.NewLineToken
 * } DjsToken
 */
 
@@ -29,11 +29,11 @@ import jsTokenizer, * as jsTokenizerT from '../../js/tokenizer/module.f.mjs'
 
 /**
  * @typedef {|
-* jsTokenizerT.JsToken | null
+* jsTokenizer.JsToken | null
 * } ScanInput
 */
 
-/** @type {(input: jsTokenizerT.JsToken) => List.List<DjsToken>} */
+/** @type {(input: jsTokenizer.JsToken) => list.List<DjsToken>} */
 const mapToken = input =>
 {
     switch(input.kind)
@@ -60,7 +60,7 @@ const mapToken = input =>
     }
 }
 
-/** @type {(input: ScanInput) => readonly [List.List<DjsToken>, ScanState]} */
+/** @type {(input: ScanInput) => readonly [list.List<DjsToken>, ScanState]} */
 const parseDefaultState = input =>
 {
     if (input === null) return [empty, { kind: 'def'}]
@@ -71,7 +71,7 @@ const parseDefaultState = input =>
     }
 }
 
-/** @type {(input: ScanInput) => readonly [List.List<DjsToken>, ScanState]} */
+/** @type {(input: ScanInput) => readonly [list.List<DjsToken>, ScanState]} */
 const parseMinusState = input =>
 {
     if (input === null) return [[{ kind: 'error', message: 'invalid token' }], { kind: 'def'}]
@@ -84,7 +84,7 @@ const parseMinusState = input =>
     }
 }
 
-/** @type {Operator.StateScan<ScanInput, ScanState, List.List<DjsToken>>} */
+/** @type {Operator.StateScan<ScanInput, ScanState, list.List<DjsToken>>} */
 const scanToken = state => input => {
     switch(state.kind)
     {
@@ -93,15 +93,10 @@ const scanToken = state => input => {
     }
 }
 
-/** @type {(input: List.List<number>) => List.List<DjsToken>} */
-const tokenize = input =>
+/** @type {(input: list.List<number>) => list.List<DjsToken>} */
+export const tokenize = input =>
 {
-    /** @type {List.List<ScanInput>} */
+    /** @type {list.List<ScanInput>} */
     const jsTokens = jsTokenizer.tokenize(input)
     return flat(stateScan(scanToken)({ kind: 'def' })(list.concat(jsTokens)([null])))
 }
-
-export default {
-    /** @readonly */
-    tokenize
-}

package/djs/tokenizer/test.f.mjs

@@ -1,12 +1,12 @@
-import tokenizer, * as tokenizerT from './module.f.mjs'
-import list from '../../types/list/module.f.mjs'
+import * as tokenizer from './module.f.mjs'
+import * as list from '../../types/list/module.f.mjs'
 const { toArray } = list
-import djs from '../module.f.mjs'
-import o from '../../types/object/module.f.mjs'
+import * as djs from '../module.f.mjs'
+import * as o from '../../types/object/module.f.mjs'
 const { sort } = o
-import encoding from '../../text/utf16/module.f.mjs'
+import * as encoding from '../../text/utf16/module.f.mjs'
 
-/** @type {(s: string) => readonly tokenizerT.DjsToken[]} */
+/** @type {(s: string) => readonly tokenizer.DjsToken[]} */
 const tokenizeString = s => toArray(tokenizer.tokenize(encoding.stringToList(s)))
 
 const stringify = djs.stringify(sort)

package/fsc/module.f.mjs

@@ -1,15 +1,15 @@
 // @ts-self-types="./module.f.d.mts"
-import operator from '../types/function/operator/module.f.mjs'
-import range_map, * as RM from '../types/range_map/module.f.mjs'
-const { merge: rangeMapMerge, fromRange, get } = range_map
-import list, * as List from '../types/list/module.f.mjs'
+import * as operator from '../types/function/operator/module.f.mjs'
+import * as rangeMap from '../types/range_map/module.f.mjs'
+const { merge: rangeMapMerge, fromRange, get } = rangeMap
+import * as list from '../types/list/module.f.mjs'
 const { reduce: listReduce } = list
-import ascii from '../text/ascii/module.f.mjs'
+import * as ascii from '../text/ascii/module.f.mjs'
 const { range: asciiRange } = ascii
 const { fromCharCode } = String
-import f from '../types/function/module.f.mjs'
+import * as f from '../types/function/module.f.mjs'
 const { fn } = f
-import _range, * as Range from '../types/range/module.f.mjs'
+import * as _range from '../types/range/module.f.mjs'
 const { one } = _range
 const { toArray, map } = list
 
@@ -24,7 +24,7 @@ const { toArray, map } = list
 
 /**
  * @template T
- * @typedef {RM.RangeMapArray<CreateToResult<T>>} State
+ * @typedef {rangeMap.RangeMapArray<CreateToResult<T>>} State
  */
 
 /** @type {ToResult} */
@@ -43,10 +43,10 @@ const union = a => b => {
 /** @type {readonly never[]} */
 const empty = []
 
-/** @type {<T>(a: List.List<State<T>>) => State<T>} */
+/** @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 {RM.RangeMerge<CreateToResult<T>>} */
+    /** @typedef {typeof a extends list.List<State<infer T>> ? T : never} T */
+    /** @type {rangeMap.RangeMerge<CreateToResult<T>>} */
     const merge = rangeMapMerge({
         union,
         equal: operator.strictEqual,
@@ -61,28 +61,28 @@ 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>} */
+    /** @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)
     return reduce(map(g)(l))
 }
 
-/** @type {<T>(a: List.List<State<T>>) => CreateToResult<T>} */
+/** @type {<T>(a: list.List<State<T>>) => CreateToResult<T>} */
 const create = a => {
-    /** @typedef {typeof a extends List.List<State<infer T>> ? T : never} T */
+    /** @typedef {typeof a extends list.List<State<infer T>> ? T : never} T */
     const i = reduce(a)
     /** @type {(v: number) => (i: State<T>) => (v: T) => ToResult} */
     const x = get(def)
     return v => c => x(c)(i)(v)(c)
 }
 
-const terminal = -1
+export const terminal = -1
 
 /** @type {() => ToResult} */
 const toInit = () => () => [[], init]
 
-const init = create([
+export const init = create([
     codePointRange(one(terminal))(toInit),
     rangeSet(['\t', ' ', '\n', '\r'])(toInit),
     range('!')(() => () => [['!'], unexpectedSymbol]),
@@ -114,11 +114,4 @@ const init = create([
     range('|')(() => () => [['|'], unexpectedSymbol]),
     range('}')(() => () => [['}'], unexpectedSymbol]),
     range('~')(() => () => [['~'], unexpectedSymbol]),
-])(void 0)
-
-export default {
-    /** @readonly */
-    terminal,
-    /** @readonly */
-    init,
-}
+])(undefined)

package/fsc/test.f.mjs

@@ -1,7 +1,7 @@
-import _ from './module.f.mjs'
-import ascii from '../text/ascii/module.f.mjs'
+import * as _ from './module.f.mjs'
+import * as ascii from '../text/ascii/module.f.mjs'
 const { one } = ascii
-import j from '../json/module.f.mjs'
+import * as j from '../json/module.f.mjs'
 const { stringify } = j
 const s = stringify(i => i)
 

package/fsm/module.f.mjs

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

package/fsm/test.f.mjs

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

package/html/module.f.mjs

@@ -1,12 +1,12 @@
 // @ts-self-types="./module.f.d.mts"
-import list, * as List from '../types/list/module.f.mjs'
+import * as list from '../types/list/module.f.mjs'
 const { map, flatMap, flat, concat: listConcat } = list
-import s from '../types/string/module.f.mjs'
+import * as s from '../types/string/module.f.mjs'
 const { concat: stringConcat } = s
 import * as O from '../types/object/module.f.mjs'
-import f from '../types/function/module.f.mjs'
+import * as f from '../types/function/module.f.mjs'
 const { compose } = f
-import utf16 from '../text/utf16/module.f.mjs'
+import * as utf16 from '../text/utf16/module.f.mjs'
 const { stringToList } = utf16
 const { fromCharCode } = String
 const { entries } = Object
@@ -50,7 +50,7 @@ const isVoid = tag => voidTagList.includes(tag)
  * }} Attributes
  */
 
-/** @typedef {List.List<Node>} Nodes */
+/** @typedef {list.List<Node>} Nodes */
 
 /** @typedef {Element | string} Node */
 
@@ -71,33 +71,33 @@ const escapeCharCode = code => {
 
 const escape = compose(stringToList)(map(escapeCharCode))
 
-/** @type {(n: Node) => List.List<string>} */
+/** @type {(n: Node) => list.List<string>} */
 const node = n => typeof n === 'string' ? escape(n) : element(n)
 
 const nodes = flatMap(node)
 
-/** @type {(a: O.Entry<string>) => List.List<string>} */
+/** @type {(a: O.Entry<string>) => list.List<string>} */
 const attribute = ([name, value]) => flat([[' ', name, '="'], escape(value), ['"']])
 
-/** @type {(a: Attributes) => List.List<string>} */
+/** @type {(a: Attributes) => list.List<string>} */
 const attributes = compose(entries)(flatMap(attribute))
 
 const open = (/** @type {Element2A} */[tag, a]) => flat([[`<`, tag], attributes(a), [`>`]])
 
 const close = (/** @type {string}*/tag) => ['</', tag, '>']
 
-/** @type {(_: Element3) => List.List<string>} */
+/** @type {(_: Element3) => list.List<string>} */
 const element3 = ([tag, a, ns]) =>
     flat([open([tag, a]), nodes(ns), close(tag)])
 
-/** @type {(_: Element2A) => List.List<string>} */
+/** @type {(_: Element2A) => list.List<string>} */
 const element2a = e => {
     const [tag] = e
     return flat([open(e), isVoid(tag) ? [] : close(tag)])
 }
 
-/** @type {(element: Element) => List.List<string>} */
-const element = e => {
+/** @type {(element: Element) => list.List<string>} */
+export const element = e => {
     switch (e.length) {
         case 1: { return element2a([e[0], {}]) }
         case 2: {
@@ -112,15 +112,6 @@ const element = e => {
     }
 }
 
-const html = compose(element)(listConcat(['<!DOCTYPE html>']))
+export const html = compose(element)(listConcat(['<!DOCTYPE html>']))
 
-const htmlToString = compose(html)(stringConcat)
-
-export default {
-    /** @readonly */
-    element,
-    /** @readonly */
-    html,
-    /** @readonly */
-    htmlToString,
-}
+export const htmlToString = compose(html)(stringConcat)

package/html/test.f.mjs

@@ -1,4 +1,4 @@
-import _, * as T from './module.f.mjs'
+import * as _ from './module.f.mjs'
 
 export default {
     empty: () => {
@@ -14,19 +14,19 @@ export default {
         if (r !== '<!DOCTYPE html><area>') { throw r }
     },
     some: () => {
-        /** @type {T.Element} */
+        /** @type {_.Element} */
         const x = ['div', {}, ['<div>&amp;</div>', ['a', { href: 'hello"' }, []]]]
         const s = _.htmlToString(x)
         if (s !== '<!DOCTYPE html><div>&lt;div&gt;&amp;amp;&lt;/div&gt;<a href="hello&quot;"></a></div>') { throw s }
     },
     some2: () => {
-        /** @type {T.Element} */
+        /** @type {_.Element} */
         const x = ['div', ['<div>&amp;</div>', ['a', { href: 'hello"' }, []]]]
         const s = _.htmlToString(x)
         if (s !== '<!DOCTYPE html><div>&lt;div&gt;&amp;amp;&lt;/div&gt;<a href="hello&quot;"></a></div>') { throw s }
     },
     someVoid: () => {
-        /** @type {T.Element} */
+        /** @type {_.Element} */
         const x = ['div', [['br', {id: '5'}], '<div>&amp;</div>', ['a', { href: 'hello"' }, []]]]
         const s = _.htmlToString(x)
         if (s !== '<!DOCTYPE html><div><br id="5">&lt;div&gt;&amp;amp;&lt;/div&gt;<a href="hello&quot;"></a></div>') { throw s }