functionalscript 0.0.238 → 0.0.239

package/commonjs/run/index.js

@@ -9,7 +9,7 @@ const result = require('../../types/result')
 
 /**
  * @template T 
- * @typedef {(prior: T) => (path: string) => ModuleResult<T>} Require 
+ * @typedef {(path: string) => (prior: T) => ModuleResult<T>} Require
  */
 
 /** @typedef {(source: string) => result.Result<Module, unknown>} Compile */

package/io/commonjs/index.js

@@ -6,7 +6,7 @@ const run = require('../../commonjs/run')
 const build = f => immutableRequire => mutableData => {
     /** @type {(path: string) => unknown} */
     const mutableRequire = path => {
-        const [result, data] = immutableRequire(mutableData)(path)
+        const [result, data] = immutableRequire(path)(mutableData)
         mutableData = data
         return unwrap(result)
     }

package/io/commonjs/test.js

@@ -41,7 +41,7 @@ const run = require('../../commonjs/run')
     if (d[0] !== 'ok') { throw d }
 
     /** @type {run.Require<number>} */
-    const req = prior => path => {
+    const req = path => prior => {
         if (path !== 'm') { throw path }
         return d[1](req)(prior + 1)
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.0.238",
+  "version": "0.0.239",
   "description": "FunctionalScript is a functional subset of JavaScript",
   "main": "index.js",
   "scripts": {

package/types/map/index.js

@@ -1,86 +1,80 @@
 const option = require("../option")
+const btree = require('../btree')
 const { getVisitor, setVisitor, values } = require("../btree")
+const compare = require("../function/compare")
 const { cmp } = require("../function/compare")
 const seq = require("../sequence")
 
-/** @typedef {import("../function/compare").Sign} Sign */
+/** @typedef {compare.Sign} Sign */
 
 /**
  * @template T 
- * @typedef {import("../btree").Leaf1<T>} Leaf1 
+ * @typedef {btree.Leaf1<T>} Leaf1 
  */
 
 /**
  * @template T
- * @typedef {import("../btree").Node<T>} TNode
+ * @typedef {btree.Node<T>} TNode
  */
 
 /**
  * @template T
- * @typedef {import("../function/compare").Compare<T>} Cmp
+ * @typedef {compare.Compare<T>} Cmp
  */
 
 /**
  * @template T
- * @typedef {readonly [string, T]} Entry
+ * @typedef {readonly[string, T]} Entry
  */
 
-/**
+/** 
  * @template T
- * @typedef {{
- *  readonly get: (name: string) => T|undefined
- *  readonly set: (name: string) => (value: T) => Map<T> 
- *  readonly entries: seq.Sequence<Entry<T>>
- *  readonly root: undefined|TNode<Entry<T>>
- * }} Map
+ * @typedef {undefined|TNode<Entry<T>>} Map
  */
 
 /** @type {(a: string) => <T>(b: Entry<T>) => Sign} */
 const keyCmp = a => ([b]) => cmp(a)(b)
 
-/** @type {<T>(node: TNode<Entry<T>>) => Map<T>} */
-const create = root => ({
-    get: name => option.map(([,value]) => value)(getVisitor(keyCmp(name))(root)),
-    set: name => value => {
-        const result = setVisitor(keyCmp(name))(() => [name, value])(root)
-        switch (result[0]) {
-            case 'replace': case 'overflow': { return create(result[1]) }
-            default: { throw '' }
-        }
-    },
-    entries: values(root),
-    root,
-})
+/** @type {(name: string) => <T>(map: Map<T>) => T|undefined} */
+const at = name => map => {
+    if (map === undefined) { return undefined }
+    const result = getVisitor(keyCmp(name))(map)
+    return result === undefined ? undefined : result[1]
+}
 
-/** 
- * @type {{
- *  readonly get: (name: string) => undefined
- *  readonly set: (name: string) => <T>(value: T) => Map<T>
- *  readonly entries: []
- *  readonly root: undefined
- * }} 
- */
-const empty = {
-    get: () => undefined,
-    set: name => value => create([[name, value]]),
-    entries: [],
-    root: undefined
+/** @type {(name: string) => <T>(value: T) => (map: Map<T>) => Map<T>} */
+const insert = name => value => map =>  {
+    /** @type {Entry<typeof value>} */
+    const entry = [name, value]
+    if (map === undefined) { return [entry] }
+    const result = setVisitor(keyCmp(name))(() => entry)(map)
+    switch (result[0]) {
+        case 'replace': case 'overflow': { return result[1] }
+        default: { throw 'invalid BTree operation' }
+    }
 }
 
+/** @type {<T>(map: Map<T>) => seq.Sequence<Entry<T>>} */
+const entries = map => map === undefined ? [] : values(map)
+
 /** @type {<T>(map: Map<T>) => (entry: Entry<T>) => Map<T>} */
-const setOperator = map => ([k, v]) => map.set(k)(v)
+const insertOp = map => ([name, value]) => insert(name)(value)(map)
 
 /** @type {<T>(entries: seq.Sequence<Entry<T>>) => Map<T>} */
 const fromEntries = entries => {
-    /** @typedef {typeof entries extends seq.Sequence<Entry<infer T>> ? T : never} T */
-    /** @type {Map<T>} */
-    const init = empty
-    return seq.reduce(setOperator)(init)(entries)
+    /** @typedef {typeof entries extends seq.Sequence<Entry<infer T>> ? T : never} T */    
+    return seq.reduce(insertOp)(/** @type {Map<T>} */(undefined))(entries)
 }
 
 module.exports = {
     /** @readonly */
-    empty,
+    empty: undefined,
+    /** @readonly */
+    at,
+    /** @readonly */
+    insert,
+    /** @readonlg */
+    entries,
     /** @readonly */
     fromEntries,
 }

package/types/map/test.js

@@ -1,59 +1,60 @@
-const { empty } = require('.')
+const { at, insert, empty, entries } = require('.')
 const list = require('../sequence')
 
 {
-    let m = empty.set('a')(1)
+    let m = insert('a')(1)(undefined)
 
-    if (m.get('a') !== 1) { throw 'error' }
-    if (m.get('b') !== undefined) { throw 'error' }
+    if (at('a')(m) !== 1) { throw 'error' }
+    if (at('b')(m) !== undefined) { throw 'error' }
 
-    m = m.set('b')(2)
+    m = insert('b')(2)(m)
 
-    if (m.get('a') !== 1) { throw 'error' }
-    if (m.get('b') !== 2) { throw 'error' }
-    if (m.get('c') !== undefined) { throw 'error' }
+    if (at('a')(m) !== 1) { throw 'error' }
+    if (at('b')(m) !== 2) { throw 'error' }
+    if (at('c')(m) !== undefined) { throw 'error' }
 
-    m = m.set('z')(3)
+    m = insert('z')(3)(m)
 
-    if (m.get('a') !== 1) { throw 'error' }
-    if (m.get('b') !== 2) { throw 'error' }
-    if (m.get('z') !== 3) { throw 'error' }
-    if (m.get('') !== undefined) { throw 'error' }
+    if (at('a')(m) !== 1) { throw 'error' }
+    if (at('b')(m) !== 2) { throw 'error' }
+    if (at('z')(m) !== 3) { throw 'error' }
+    if (at('')(m) !== undefined) { throw 'error' }
 
-    m = m.set('')(4)
+    m = insert('')(4)(m)
 
-    if (m.get('a') !== 1) { throw 'error' }
-    if (m.get('b') !== 2) { throw 'error' }
-    if (m.get('z') !== 3) { throw 'error' }
-    if (m.get('') !== 4) { throw 'error' }
-    if (m.get('Hello world!') !== undefined) { throw 'error' }
+    if (at('a')(m) !== 1) { throw 'error' }
+    if (at('b')(m) !== 2) { throw 'error' }
+    if (at('z')(m) !== 3) { throw 'error' }
+    if (at('')(m) !== 4) { throw 'error' }
+    if (at('Hello world!')(m) !== undefined) { throw 'error' }
 
-    m = m.set('Hello world!')(42)
+    m = insert('Hello world!')(42)(m)
 
-    if (m.get('a') !== 1) { throw 'error' }
-    if (m.get('b') !== 2) { throw 'error' }
-    if (m.get('z') !== 3) { throw 'error' }
-    if (m.get('') !== 4) { throw 'error' }
-    if (m.get('Hello world!') !== 42) { throw 'error' }
-    if (m.get('x') !== undefined) { throw 'error' }
+    if (at('a')(m) !== 1) { throw 'error' }
+    if (at('b')(m) !== 2) { throw 'error' }
+    if (at('z')(m) !== 3) { throw 'error' }
+    if (at('')(m) !== 4) { throw 'error' }
+    if (at('Hello world!')(m) !== 42) { throw 'error' }
+    if (at('x')(m) !== undefined) { throw 'error' }
 
     // console.log(Array.from(m.entries()))
 }
 
 {
-    const m = empty.set('x')(12).set('y')(44)
-    if (m.get('x') !== 12) { throw 'error' }
-    if (m.get('y') !== 44) { throw 'error' }
-    if (m.get('a') !== undefined) { throw 'error' }
-    const entries = Array.from(list.iterable(m.entries))
-    if (entries.length !== 2) { throw 'error' }
+    let m = insert('x')(12)(undefined)
+    m = insert('y')(44)(m)
+    if (at('x')(m) !== 12) { throw 'error' }
+    if (at('y')(m) !== 44) { throw 'error' }
+    if (at('a')(m) !== undefined) { throw 'error' }
+    const e = list.toArray(entries(m))
+    if (e.length !== 2) { throw 'error' }
 }
 
 {
     /** @type {import('.').Map<number>} */
     let m = empty
     for (let i = 0; i < 100_000; ++i) {
-        m = m.set((i*i).toString())(i)
+        m = insert((i * i).toString())(i)(m)
         /*
         console.log()
         console.log(`# ${i}`)

package/types/object/index.js

@@ -1,5 +1,6 @@
 const seq = require('../sequence')
 const map = require('../map')
+const { compose } = require('../function')
 
 /**
  * @template T
@@ -17,7 +18,7 @@ const map = require('../map')
 const at = name => object => Object.getOwnPropertyDescriptor(object, name)?.value
 
 /** @type {<T>(entries: seq.Sequence<Entry<T>>) => seq.Sequence<Entry<T>>} */
-const sort = entries => map.fromEntries(entries).entries
+const sort = entries => map.entries(map.fromEntries(entries))
 
 module.exports = {
     /** @readonly */