functionalscript 0.0.467 → 0.0.468

package/fsm/module.f.cjs

@@ -1,21 +1,64 @@
-const { todo } = require('../dev/module.f.cjs')
 const list = require('../types/list/module.f.cjs')
+const { equal, isEmpty, fold, toArray, scan } = list
 const byteSet = require('../types/byte_set/module.f.cjs')
+const { toRangeMap } = byteSet
+const sortedSet = require('../types/sorted_set/module.f.cjs')
+const { intersect, union } = sortedSet
+const rangeMap = require('../types/range_map/module.f.cjs')
+const { merge } = rangeMap
+const { unsafeCmp } = require('../types/function/compare/module.f.cjs')
+const operator = require("../types/function/operator/module.f.cjs")
+const { strictEqual } = operator
+const { stringify } = require('../json/module.f.cjs')
+const { identity } = require('../types/function/module.f.cjs')
 
 /** @typedef {readonly[string, byteSet.ByteSet, string]} Rule */
 
 /** @typedef {list.List<Rule>} Grammar */
 
-/** @typedef {readonly string[]} ByteMap */
-
 /**
  * @typedef {{
- *  readonly[state in string]: ByteMap
+ *  readonly[state in string]: rangeMap.RangeMapArray<string>
  * }} Dfa
  */
 
+const stringifyIdentity = stringify(identity)
+
+/** @type {rangeMap.Operators<sortedSet.SortedSet<string>>} */
+const mergeOp = { union: union(unsafeCmp), equal: equal(strictEqual) }
+
+/** @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, 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<rangeMap.Entry<sortedSet.SortedSet<string>>, rangeMap.Entry<string>>} */
+const stringifyOp = ([sortedSet, max]) => [[stringifyIdentity(sortedSet), max], stringifyOp]
+
+const scanStringify = scan(stringifyOp)
+
+/** @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>} */
+const addEntry = grammar => set => dfa => {
+    const s = stringifyIdentity(set)
+    if (s in dfa) { return dfa }
+    const setMap = fold(foldOp(set))(undefined)(grammar)
+    const stringMap = toArray(scanStringify(setMap))
+    const newDfa = { ...dfa, [s]: stringMap }
+    const newStates = scanFetch(setMap)
+    return fold(addEntry(grammar))(newDfa)(newStates)
+}
+
 /** @type {(grammar: Grammar) => Dfa} */
-const dfa = grammar => todo()
+const dfa = grammar => addEntry(grammar)([''])({})
 
 module.exports = {
     /** @readonly */

package/fsm/test.f.cjs

@@ -1,5 +1,79 @@
 const _ = require('./module.f.cjs')
+const byteSet = require('../types/byte_set/module.f.cjs')
+const { sort, fromEntries } = require('../types/object/module.f.cjs')
+const json = require('../json/module.f.cjs')
+const { identity } = require('../types/function/module.f.cjs')
+
+/** @type {(c: string) => number} */
+const toCharCode = c => c.charCodeAt(0)
 
 module.exports = {
+    dfa: () => {
+        const lowercaseAlpha = byteSet.range([toCharCode('a'), toCharCode('z')])
+        const uppercaseAlpha = byteSet.range([toCharCode('A'), toCharCode('Z')])
+        const alpha = byteSet.union(lowercaseAlpha)(uppercaseAlpha)
+        const idSymbol = byteSet.union(byteSet.one(toCharCode('_')))(byteSet.one(toCharCode('$')))
+        const idBegin = byteSet.union(alpha)(idSymbol)
+        const digit = byteSet.range([toCharCode('0'), toCharCode('9')])
+        const idNext = byteSet.union(idBegin)(digit)
+        const dot = byteSet.one(toCharCode('.'))
+
+        /** @type {_.Grammar} */
+        const grammar = [
+            ['', digit, 'int'],
+            ['int', digit, 'int'],
+            ['', digit, 'floatBegin'],
+            ['floatBegin', digit, 'floatBegin'],
+            ['floatBegin', dot, 'floatDot'],
+            ['floatDot', digit, 'float'],
+            ['float', digit, 'float'],
+            ['', idBegin, 'id'],
+            ['id', idNext, 'id']
+        ]
+
+        const dfa = _.dfa(grammar)
+        const entries = Object.entries(dfa)
+        const sortedEntries = sort(entries)
+        const obj = fromEntries(sortedEntries)
+        const result = json.stringify(identity)(obj)
+
+        const expectedObj = {
+            '[""]': [
+                [ '[]', 35 ],
+                [ '["id"]', 36 ],
+                [ '[]', 47 ],
+                [ '["floatBegin","int"]', 57 ],
+                [ '[]', 64 ],
+                [ '["id"]', 90 ],
+                [ '[]', 94 ],
+                [ '["id"]', 95 ],
+                [ '[]', 96 ],
+                [ '["id"]', 122 ]
+            ],
+            '["float"]': [ [ '[]', 47 ], [ '["float"]', 57 ] ],
+            '["floatBegin","int"]': [
+                [ '[]', 45 ],
+                [ '["floatDot"]', 46 ],
+                [ '[]', 47 ],
+                [ '["floatBegin","int"]', 57 ]
+            ],
+            '["floatDot"]': [ [ '[]', 47 ], [ '["float"]', 57 ] ],
+            '["id"]': [
+                [ '[]', 35 ],
+                [ '["id"]', 36 ],
+                [ '[]', 47 ],
+                [ '["id"]', 57 ],
+                [ '[]', 64 ],
+                [ '["id"]', 90 ],
+                [ '[]', 94 ],
+                [ '["id"]', 95 ],
+                [ '[]', 96 ],
+                [ '["id"]', 122 ]
+            ],
+            '[]': []
+        };
+        const expectedResult = json.stringify(identity)(expectedObj)
 
+        if (result !== expectedResult) {throw result }
+    }
 }

package/package.json

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

package/types/byte_set/module.f.cjs

@@ -72,6 +72,8 @@ module.exports = {
     /** @readonly */
     unset,
     /** @readonly */
+    one,
+    /** @readonly */
     union,
     /** @readonly */
     setRange,

package/types/range_map/module.f.cjs

@@ -15,6 +15,11 @@ const operator = require("../function/operator/module.f.cjs")
  * @typedef {sortedList.SortedList<Entry<T>>} RangeMap
  */
 
+/**
+ * @template T
+ * @typedef {readonly Entry<T>[]} RangeMapArray
+ */
+
 /**
  * @template T
  * @typedef {{