functionalscript 0.0.473 → 0.0.475

package/fsm/module.f.cjs

@@ -1,9 +1,9 @@
 const list = require('../types/list/module.f.cjs')
-const { equal, isEmpty, fold, toArray, scan } = list
+const { equal, isEmpty, fold, toArray, scan, foldScan } = list
 const byteSet = require('../types/byte_set/module.f.cjs')
-const { toRangeMap } = byteSet
+const { toRangeMap, union: byteSetUnion, one, empty } = byteSet
 const sortedSet = require('../types/sorted_set/module.f.cjs')
-const { intersect, union } = sortedSet
+const { intersect, union: sortedSetUnion } = sortedSet
 const rangeMap = require('../types/range_map/module.f.cjs')
 const { merge } = rangeMap
 const { unsafeCmp } = require('../types/function/compare/module.f.cjs')
@@ -11,6 +11,7 @@ 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')
+const { stringToList } = require('../text/utf16/module.f.cjs')
 
 /** @typedef {readonly[string, byteSet.ByteSet, string]} Rule */
 
@@ -24,8 +25,23 @@ const { identity } = require('../types/function/module.f.cjs')
 
 const stringifyIdentity = stringify(identity)
 
+/** @type {(s: string) => byteSet.ByteSet} */
+const toRange = s => {
+    const [b, e] = toArray(stringToList(s))
+    return byteSet.range([b, e])
+}
+
+/** @type {operator.Fold<number, byteSet.ByteSet>} */
+const toUnionOp = i => bs => byteSetUnion(bs)(one(i))
+
+/** @type {(s: string) => byteSet.ByteSet} */
+const toUnion = s => {
+    const codePoints = stringToList(s)
+    return fold(toUnionOp)(empty)(codePoints)
+}
+
 /** @type {rangeMap.Operators<sortedSet.SortedSet<string>>} */
-const mergeOp = { union: union(unsafeCmp), equal: equal(strictEqual) }
+const mergeOp = { union: sortedSetUnion(unsafeCmp), equal: equal(strictEqual) }
 
 /** @type {(s: string) => (set: sortedSet.SortedSet<string>) => boolean} */
 const hasState = s => set => !isEmpty(intersect(unsafeCmp)([s])(set))
@@ -57,10 +73,34 @@ const addEntry = grammar => set => dfa => {
     return fold(addEntry(grammar))(newDfa)(newStates)
 }
 
+/** @type {string[]} */
+const emptyState = []
+
+const emptyStateStringify = stringifyIdentity(emptyState)
+
+const initialState = ['']
+
+const initialStateStringify = stringifyIdentity(initialState)
+
 /** @type {(grammar: Grammar) => Dfa} */
-const dfa = grammar => addEntry(grammar)([''])({})
+const dfa = grammar => addEntry(grammar)(initialState)({})
+
+/** @type {(dfa: Dfa) => operator.Fold<number, string>} */
+const runOp = dfa => input => s => {
+    const state = rangeMap.get(input)(dfa[s])
+    return state === undefined ? emptyStateStringify : state
+}
+
+/** @type {(dfa: Dfa) => (input: list.List<number>) => list.List<string>} */
+const run = dfa => input => foldScan(runOp(dfa))(initialStateStringify)(input)
 
 module.exports = {
     /** @readonly */
     dfa,
+    /** @readonly */
+    run,
+    /** @readonly */
+    toRange,
+    /** @readonly */
+    toUnion
 }

package/fsm/test.f.cjs

@@ -3,39 +3,43 @@ 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')
+const { toArray } = require('../types/list/module.f.cjs')
+const { stringToList } = require('../text/utf16/module.f.cjs')
 
-/** @type {(c: string) => number} */
-const toCharCode = c => c.charCodeAt(0)
+const stringifyIdentity = json.stringify(identity)
 
-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('.'))
+const buildDfa = () => {
+    const lowercaseAlpha = _.toRange('az')
+    const uppercaseAlpha = _.toRange('AZ')
+    const alpha = byteSet.union(lowercaseAlpha)(uppercaseAlpha)
+    const idSymbol = _.toUnion('_$')
+    const idBegin = byteSet.union(alpha)(idSymbol)
+    const digit = _.toRange('09')
+    const idNext = byteSet.union(idBegin)(digit)
+    const dot = _.toUnion('.')
 
-        /** @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']
-        ]
+    /** @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']
+    ]
+    return _.dfa(grammar)
+}
 
-        const dfa = _.dfa(grammar)
+module.exports = {
+    dfa: () => {
+        const dfa = buildDfa()
         const entries = Object.entries(dfa)
         const sortedEntries = sort(entries)
         const obj = fromEntries(sortedEntries)
-        const result = json.stringify(identity)(obj)
+        const result = stringifyIdentity(obj)
 
         const expectedObj = {
             '[""]': [
@@ -72,8 +76,59 @@ module.exports = {
             ],
             '[]': []
         };
-        const expectedResult = json.stringify(identity)(expectedObj)
+        const expectedResult = stringifyIdentity(expectedObj)
 
         if (result !== expectedResult) {throw result }
-    }
+    },
+    run: [
+        () => {
+            const dfa = buildDfa()
+            const input = stringToList('a1')
+            const result = stringifyIdentity(toArray(_.run(dfa)(input)))
+
+            const expectedOutput = [
+                '["id"]',
+                '["id"]'
+            ]
+            const expectedResult = stringifyIdentity(expectedOutput)
+            if (result !== expectedResult) { throw result }
+        },
+        () => {
+            const dfa = buildDfa()
+            const input = stringToList('0.1')
+            const result = stringifyIdentity(toArray(_.run(dfa)(input)))
+
+            const expectedOutput = [
+                '["floatBegin","int"]',
+                '["floatDot"]',
+                '["float"]'
+            ]
+            const expectedResult = stringifyIdentity(expectedOutput)
+            if (result !== expectedResult) { throw result }
+        },
+        () => {
+            const dfa = buildDfa()
+            const input = stringToList('//')
+            const result = stringifyIdentity(toArray(_.run(dfa)(input)))
+
+            const expectedOutput = [
+                '[]',
+                '[]'
+            ]
+            const expectedResult = stringifyIdentity(expectedOutput)
+            if (result !== expectedResult) { throw result }
+        },
+        () => {
+            const dfa = buildDfa()
+            const input = stringToList('::')
+            const result = stringifyIdentity(toArray(_.run(dfa)(input)))
+
+            const expectedOutput = [
+                '[]',
+                '[]'
+            ]
+            const expectedResult = stringifyIdentity(expectedOutput)
+            if (result !== expectedResult) { throw result }
+        }
+    ]
 }

package/package.json

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

package/types/range_map/module.f.cjs

@@ -60,7 +60,32 @@ const tailReduce = equal => state => tail => {
  /** @type {<T>(op: Operators<T>) => RangeMerge<T>} */
 const merge = ({union, equal}) => genericMerge({reduceOp: reduceOp(union)(equal), tailReduce: tailReduce(equal)})(undefined)
 
+/** @type {<T>(value: number) => (rm: RangeMapArray<T>) =>  T|undefined} */
+const get = value => rm => {
+  let b = 0
+  let e = rm.length - 1
+  while (true) {
+    if (b >= rm.length) return undefined
+    if (e - b < 0) return rm[b][0]
+    const mid = b + (e - b >> 1)
+    const sign = cmp(value)(rm[mid][1])
+    switch(sign) {
+      case -1: {
+        e = mid - 1
+        break
+      }
+      case 0: { return rm[mid][0] }
+      case 1: {
+        b = mid + 1
+        break
+      }
+    }
+  }
+}
+
 module.exports = {
     /** @readonly */
-    merge
+    merge,
+    /** @readonly */
+    get
 }

package/types/range_map/test.f.cjs

@@ -77,5 +77,55 @@ module.exports = {
             const result = stringify(list.toArray(merged))
             if (result !== '[[["a"],1],[["a","b"],2],[["a"],5]]') { throw result }
         }
+    ],
+    get: [
+        () => {
+            /** @type {_.RangeMapArray<sortedSet.SortedSet<string>>} */
+            const rm = [[['a'], 10], [['b'], 20], [['c'], 30]]
+            const result = stringify(_.get(5)(rm))
+            if (result !== '["a"]') { throw result }
+        },
+        () => {
+            /** @type {_.RangeMapArray<sortedSet.SortedSet<string>>} */
+            const rm = [[['a'], 10], [['b'], 20], [['c'], 30]]
+            const result = stringify(_.get(10)(rm))
+            if (result !== '["a"]') { throw result }
+        },
+        () => {
+            /** @type {_.RangeMapArray<sortedSet.SortedSet<string>>} */
+            const rm = [[['a'], 10], [['b'], 20], [['c'], 30]]
+            const result = stringify(_.get(15)(rm))
+            if (result !== '["b"]') { throw result }
+        },
+        () => {
+            /** @type {_.RangeMapArray<sortedSet.SortedSet<string>>} */
+            const rm = [[['a'], 10], [['b'], 20], [['c'], 30]]
+            const result = stringify(_.get(20)(rm))
+            if (result !== '["b"]') { throw result }
+        },
+        () => {
+            /** @type {_.RangeMapArray<sortedSet.SortedSet<string>>} */
+            const rm = [[['a'], 10], [['b'], 20], [['c'], 30]]
+            const result = stringify(_.get(25)(rm))
+            if (result !== '["c"]') { throw result }
+        },
+        () => {
+            /** @type {_.RangeMapArray<sortedSet.SortedSet<string>>} */
+            const rm = [[['a'], 10], [['b'], 20], [['c'], 30]]
+            const result = stringify(_.get(30)(rm))
+            if (result !== '["c"]') { throw result }
+        },
+        () => {
+            /** @type {_.RangeMapArray<sortedSet.SortedSet<string>>} */
+            const rm = [[['a'], 10], [['b'], 20], [['c'], 30]]
+            const result = _.get(35)(rm)
+            if (result !== undefined) { throw result }
+        },
+        () => {
+            /** @type {_.RangeMapArray<sortedSet.SortedSet<string>>} */
+            const rm = []
+            const result = _.get(10)(rm)
+            if (result !== undefined) { throw result }
+        }
     ]
 }