functionalscript 0.0.148 → 0.0.152

package/lib/index.js

@@ -28,48 +28,18 @@
 /** @type {(_: string) => never} */
 const panic = message => { throw message }
 
-/**
- * @template T
- * @typedef {{ 
- *  readonly get: (_: string) => T|undefined
- *  readonly set: (_: string) => (_: T) => Dictionary<T> 
- *  readonly entries: () => Iterable<[string, T]>
- * }} Dictionary
- */
-
-/**
- * @template T
- * @typedef {{
- *  readonly [_ in string]: T
- * }} InternalMap
- */
-
-const dictionary = {
-    get: () => undefined,
-    /** @type {(_: string) => <T>(_: T) => Dictionary<T>} */
-    set: key => value => createDictionary({[key]: value}),
-    entries: () => []
-}
-
-/** @type {<T>(_: InternalMap<T>) => Dictionary<T>} */
-const createDictionary = internal => ({
-    get: key => internal[key],
-    set: key => value => createDictionary({ ...internal, [key]: value }),
-    entries: () => Object.entries(internal),
-})
-
 /** @type {<A>(_: A) => <B>(_: B) => [A, B]} */
 const tuple2 = a => b => [a, b]
 
-/** @type {<T>(_: (_: string) => T) => (_: Dictionary<T>) => (_: string) => [T, Dictionary<T>]} */
-const cache = f => d => k => {
-    const set = () => {
-        const r = f(k)                
-        return tuple2(r)(d.set(k)(r))
-    }
-    const result = d.get(k) 
-    return result !== undefined ? [result, d] : set()
-}
+// /** @type {<T>(_: (_: string) => T) => (_: Dictionary<T>) => (_: string) => [T, Dictionary<T>]} */
+// const cache = f => d => k => {
+//     const set = () => {
+//         const r = f(k)                
+//         return tuple2(r)(d.set(k)(r))
+//     }
+//     const result = d.get(k) 
+//     return result !== undefined ? [result, d] : set()
+// }
 
 /**
  * @template T
@@ -133,8 +103,6 @@ module.exports = {
     /** @type {(_: string) => (_: boolean) => void} */
     panic_if: message => condition => condition ? panic(message) : undefined,
 
-    dictionary,
-
     /** @type {<T>(_: Continuation<T>) => T} */
     trampoline: continuation => {
         while (true) {
@@ -165,8 +133,6 @@ module.exports = {
 
     optionMap,
 
-    cache,
-
     /** @type {<T>(_: T[]) => T[]|undefined} */
     tail: a => a.length === 0 ? undefined : uncheckTail(a),
 

package/lib/map/index.js

@@ -1,5 +1,5 @@
 const { optionMap } = require("..")
-const { getVisitor, setVisitor, values } = require("../tree")
+const { getVisitor, setVisitor, values, struct } = require("../tree")
 
 /** @typedef {import("../tree/cmp").Sign} Sign */
 
@@ -29,6 +29,7 @@ const { getVisitor, setVisitor, values } = require("../tree")
  *  readonly get: (name: string) => T|undefined
  *  readonly set: (name: string) => (value: T) => Map<T> 
  *  readonly entries: () => Iterable<Entry<T>>
+ *  readonly struct: () => Iterable<string>
  * }} Map
  */
 
@@ -38,13 +39,14 @@ const cmp = a => ([b]) => a < b ? -1 : a === b ? 0 : 1
 /** @type {<T>(node: TNode<Entry<T>>) => Map<T>} */
 const create = node => ({
     get: name => optionMap(([,value]) => value)(getVisitor(cmp(name))(node)),
-    set: name => value => { 
+    set: name => value => {
         const result = setVisitor(cmp(name))(() => [name, value])(node)
         if ('replace' in result) { return create(result.replace) }
         if ('overflow' in result) { return create(result.overflow) }
         throw ''
     },
-    entries: () => values(node)
+    entries: () => values(node),
+    struct: () => struct(node),
 })
 
 /** 
@@ -52,12 +54,14 @@ const create = node => ({
  *  readonly get: (name: string) => undefined
  *  readonly set: (name: string) => <T>(value: T) => Map<T>
  *  readonly entries: () => []
+ *  readonly struct: () => []
  * }} 
  */
 const map = {
     get: () => undefined,
     set: name => value => create([[name, value]]),
     entries: () => [],
+    struct: () => [],
 }
 
 module.exports = {

package/lib/map/test.js

@@ -40,26 +40,26 @@ const lib = require('..')
     // console.log(Array.from(m.entries()))
 }
 
+{
+    const m = map.set('x')(12).set('y')(44)
+    lib.panic_if('map.get(\'x\')')(m.get('x') !== 12)
+    lib.panic_if('map.get(\'y\')')(m.get('y') !== 44)
+    lib.panic_if('map.get(\'a\')')(m.get('a') !== undefined)
+    const entries = Array.from(m.entries())
+    lib.panic_if('map.entries()')(entries.length !== 2)
+}
+
+
 {
     /** @type {import('.').Map<number>} */
     let m = map
-    for (let i = 0; i < 1_000_000; ++i) {
-        m = m.set(i.toString())(i * i)
-        if (i % 100_000 === 0) { console.log(i) }
-    }
-    for (const e of m.entries()) {
-        // console.log(e)
+    for (let i = 0; i < 10; ++i) {
+        m = m.set((i*i).toString())(i)
+        console.log()
+        console.log(`# ${i}`)
+        console.log()
+        for (const e of m.struct()) {
+            console.log(e)
+        }
     }
 }
-// console.log(':')
-{
-    /** @type {import('..').Dictionary<number>} */
-    let m = lib.dictionary
-    for (let i = 0; i < 100_000; ++i) {
-        m = m.set(i.toString())(i * i)
-        if (i % 10_000 === 0) { console.log(i) }
-    }
-    for (const e of m.entries()) {
-        // console.log(e)
-    }
-}

package/lib/test.js

@@ -3,11 +3,3 @@ const lib = require('./index')
 require('./iterable/test')
 require('./map/test')
 
-{
-    const map = lib.dictionary.set('x')(12).set('y')(44)
-    lib.panic_if('map.get(\'x\')')(map.get('x') !== 12)
-    lib.panic_if('map.get(\'y\')')(map.get('y') !== 44)
-    lib.panic_if('map.get(\'a\')')(map.get('a') !== undefined)
-    const entries = Array.from(map.entries())
-    lib.panic_if('map.entries()')(entries.length !== 2)
-}

package/lib/tree/index.js

@@ -319,7 +319,49 @@ const values = node => ({
     }
 })
 
+/**
+ * @typedef {{}}
+ */
+
+/** @type {(offset: string) => <T>(_: TNode<T>) => Iterable<string>} */
+const struct = offset => node => ({
+    *[Symbol.iterator]() {
+        const next = `${offset}  `
+        switch (node.length) {
+            case 1: {
+                yield `${offset}- [1]:`
+                yield `${next}- ${node[0]}`
+                return
+            }
+            case 2: {
+                yield `${offset}- [2]:`
+                yield `${next}- ${node[0]}`
+                yield `${next}- ${node[1]}`
+                return
+            }
+            case 3: {
+                yield  `${offset}- [3]:`
+                yield* struct(next)(node[0])
+                yield  `${next}- ${node[1]}`
+                yield* struct(next)(node[2])
+                return
+            }
+            default: {
+                yield `${offset}- [5]:`
+                yield* struct(next)(node[0])
+                yield  `${next}- ${node[1]}`
+                yield* struct(next)(node[2])
+                yield  `${next}- ${node[3]}`
+                yield* struct(next)(node[4])
+                return
+            }
+        }
+    }
+})
+
 module.exports = {
+    /** @readonly */
+    struct: struct(''),
     /** @readonly */
     values,
     /** 
@@ -327,7 +369,7 @@ module.exports = {
      * @type {<T>(cmp: Cmp<T>) => (node: TNode<T>) => T|undefined}
      */
     getVisitor: cmp => node => {
-        const result = visit(getVisitor)(cmp)(() => { throw ''})(node)
+        const result = visit(getVisitor)(cmp)(() => { throw '' })(node)
         if ('done' in result && result.done) { return result.value }
         return undefined
     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.0.148",
+  "version": "0.0.152",
   "description": "FunctionalScript is a functional subset of JavaScript",
   "main": "index.js",
   "scripts": {
@@ -19,7 +19,7 @@
   },
   "homepage": "https://github.com/functionalscript/functionalscript#readme",
   "devDependencies": {
-    "@types/node": "^16.11.7",
-    "typescript": "^4.4.4"
+    "@types/node": "^16.11.9",
+    "typescript": "^4.5.2"
   }
 }