functionalscript 0.0.467 → 0.0.469

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.469",
   "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

@@ -1,6 +1,7 @@
 const sortedList = require("../sorted_list/module.f.cjs")
 const { genericMerge } = sortedList
 const list = require("../list/module.f.cjs")
+const { next } = list
 const option = require("../option/module.f.cjs")
 const { cmp } = require('../number/module.f.cjs')
 const operator = require("../function/operator/module.f.cjs")
@@ -15,6 +16,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 {{
@@ -45,7 +51,7 @@ const reduceOp = union => equal => state => ([aItem, aMax]) => ([bItem, bMax])
 /** @type {<T>(equal: operator.Equal<T>) => sortedList.TailReduce<Entry<T>, RangeState<T>>} */
 const tailReduce = equal => state => tail => {
   if (state === undefined) { return tail }
-  const tailResult = list.next(tail)
+  const tailResult = next(tail)
   if (tailResult === undefined) { return [state] }
   if (equal(state[0])(tailResult.first[0])) { return tailResult }
   return { first: state, tail: tailResult }

package/types/sorted_list/module.f.cjs

@@ -3,12 +3,18 @@ const list = require('../list/module.f.cjs')
 const option = require('../option/module.f.cjs')
 const { next } = list
 const { identity } = require('../function/module.f.cjs')
+const range = require('../range/module.f.cjs')
 
 /**
  * @template T
  * @typedef {list.List<T>} SortedList
  */
 
+/**
+ * @template T
+ * @typedef {readonly T[]} SortedArray
+ */
+
 /**
  * @template T
  * @typedef {(a: T) => (b: T) => compare.Sign} Cmp
@@ -78,9 +84,33 @@ const cmpReduce = cmp => () => a => b => {
 /** @type {() => <T>(tail: list.List<T>) => list.List<T>} */
 const mergeTail = () => identity
 
+/** @type {<T>(cmp: Cmp<T>) => (value: T) => (array: SortedArray<T>) =>  T|undefined} */
+const find = cmp => value => array => {
+    let b = 0
+    let e = array.length - 1
+    while (true) {
+        if (e - b < 0) return undefined
+        const mid = b + (e - b >> 1)
+        const sign = cmp(value)(array[mid])
+        switch(sign) {
+            case -1: {
+                 e = mid - 1
+                 break
+            }
+            case 0: { return value }
+            case 1: {
+                 b = mid + 1
+                 break
+            }
+        }
+    }
+}
+
 module.exports = {
     /** @readonly */
     merge,
     /** @readonly */
-    genericMerge
+    genericMerge,
+    /** @readonly */
+    find
 }

package/types/sorted_list/test.f.cjs

@@ -29,5 +29,23 @@ module.exports = {
             const len = length(result)
             if (len != n) { throw result }
         }
+    ],
+    find: [
+        () => {
+            const result = _.find(unsafeCmp)(0)([0, 10, 20, 30, 40, 50, 60, 70, 80, 90])
+            if (result !== 0) { throw result }
+        },
+        () => {
+            const result = _.find(unsafeCmp)(3)([0, 10, 20, 30, 40, 50, 60, 70, 80, 90])
+            if (result !== undefined) { throw result }
+        },
+        () => {
+            const result = _.find(unsafeCmp)(77)([0, 10, 20, 30, 40, 50, 60, 70, 80, 90])
+            if (result !== undefined) { throw result }
+        },
+        () => {
+            const result = _.find(unsafeCmp)(80)([0, 10, 20, 30, 40, 50, 60, 70, 80, 90])
+            if (result !== 80) { throw result }
+        }
     ]
 }

package/types/sorted_set/module.f.cjs

@@ -1,9 +1,7 @@
 const compare = require("../function/compare/module.f.cjs")
 const { toArray } = require("../list/module.f.cjs")
 const sortedList = require("../sorted_list/module.f.cjs")
-const { merge, genericMerge } = sortedList
-const list = require("../list/module.f.cjs")
-const option = require("../option/module.f.cjs")
+const { merge, genericMerge, find } = sortedList
 
 /**
  * @template T
@@ -34,9 +32,14 @@ const intersectReduce = cmp => state => a => b => {
 
 const intersectTail = () => () => undefined
 
+/** @type {<T>(cmp: Cmp<T>) => (value: T) => (set: SortedSet<T>) => boolean} */
+const has = cmp => value => set => find(cmp)(value)(set) === value
+
 module.exports = {
     /** @readonly */
     union,
     /** @readonly */
-    intersect
+    intersect,
+    /** @readonly */
+    has
 }

package/types/sorted_set/test.f.cjs

@@ -40,5 +40,23 @@ module.exports = {
             const result = stringify(toArray(_.intersect(unsafeCmp)([1, 2, 3])([])))
             if (result !== '[]') { throw result }
         }
+    ],
+    has: [
+        () => {
+            const result = _.has(unsafeCmp)(0)([0, 10, 20, 30, 40, 50, 60, 70, 80, 90])
+            if (!result) { throw result }
+        },
+        () => {
+            const result = _.has(unsafeCmp)(3)([0, 10, 20, 30, 40, 50, 60, 70, 80, 90])
+            if (result) { throw result }
+        },
+        () => {
+            const result = _.has(unsafeCmp)(77)([0, 10, 20, 30, 40, 50, 60, 70, 80, 90])
+            if (result) { throw result }
+        },
+        () => {
+            const result = _.has(unsafeCmp)(80)([0, 10, 20, 30, 40, 50, 60, 70, 80, 90])
+            if (!result) { throw result }
+        }
     ]
 }