functionalscript 0.0.237 → 0.0.241

package/.github/workflows/node.js.yml

@@ -5,9 +5,7 @@ name: Node.js CI
 
 on:
   push:
-    branches: [ main ]
   pull_request:
-    branches: [ main ]
 
 jobs:
   build:

package/commonjs/README.md

@@ -0,0 +1,55 @@
+# Common.js
+
+```ts
+// package/index.js
+
+type PackageGet = (packageId: string) => Package | undefined
+type Package = {
+    // returns a global package id.
+    readonly dependency: (localPackageId: string) => string | undefined
+    // returns source of the file.
+    readonly file: (localFileId: string) => string | undefined
+}
+
+// module/index.js
+
+type ModuleMapInterface<M> = {
+    readonly at: (moduleId: string) => (moduleMap: M) => ModuleState | undefined
+    readonly insert: (moduleId: string) => (moduleState: ModuleState) => (moduleMap: M) => M
+}
+
+type ModuleState = readonly['ok', Module] | readonly['error', ModuleError] | readonly['building']
+
+type Module = {
+    readonly exports: unknown
+    readonly requireMap: object.Map<string>
+}
+
+type ModuleError = 'file not found' | 'compile error' | 'runtime error' | 'circular reference'
+
+type ModuleId = { 
+    readonly packageId: string,
+    readonly path: readonly string[],
+}
+
+const moduleIdToString: (moduleId: ModuleId) => string;
+
+// build/index.js
+
+type BuildConfig<M> = {
+    readonly packageGet: PackageGet
+    readonly moduleMapInterface: ModuleMapInterface<M>     
+    readonly moduleId: ModuleId
+    readonly moduleMap: M // mutable
+}
+
+type BuildState<M> = {
+    readonly packageGet: PackageGet
+    readonly moduleMapInterface: ModuleMapInterface<M>
+    readonly moduleId: ModuleId
+    readonly moduleMap: M // mutable
+    readonly ModuleRequireMap: map.Map<string> // mutable
+}
+
+const getOrBuild: <M>(buildConfig: BuildConfig<M>) => readonly[ModuleState, M];
+```

package/commonjs/module/index.js

@@ -0,0 +1,35 @@
+const object = require('../../types/object')
+
+/**
+ * @template M
+ * @typedef {{
+ *  readonly at: (moduleId: string) => (moduleMap: M) => ModuleState | undefined
+ *  readonly insert: (moduleId: string) => (moduleState: ModuleState) => (moduleMap: M) => M
+ * }} ModuleMapInterface
+ */
+
+/** 
+ * @typedef {|
+ *  readonly['ok', Module] | 
+ *  readonly['error', ModuleError] | 
+ *  readonly['building']
+ * } ModuleState 
+ */
+
+/**
+ * @typedef {{
+ *  readonly exports: unknown
+ *  readonly requireMap: object.Map<string>
+ * }} Module
+ */
+
+/** 
+ * @typedef {|
+ *  'file not found' | 
+ *  'compile error' | 
+ *  'runtime error' | 
+ *  'circular reference'
+ * } ModuleError
+ */
+
+module.exports = {}

package/commonjs/package/dependencies/index.js

@@ -1,9 +1,5 @@
-const { todo } = require('../../../dev')
 const json = require('../../../json')
-const { isObject } = json
 const seq = require('../../../types/sequence')
-const path = require('../../path')
-const { at } = require('../../../types/object')
 
 /** @typedef {readonly[string, string]} DependencyJson */
 
@@ -21,41 +17,7 @@ const isDependenciesJson = j => {
     return seq.every(seq.map(isDependencyJson)(Object.entries(j)))
 }
 
-/** @typedef {readonly[string, seq.Sequence<string>]} IdPath */
-
-/** @type {(prior: readonly[string|undefined, seq.Sequence<string>]) => seq.Thunk<IdPath>} */
-const variants = prior => () => {
-    const [a, b] = prior
-    const r = seq.next(b)
-    if (r === undefined) { return undefined }
-    const { first, tail } = r
-    /** @type {IdPath} */
-    const n = [a === undefined ? first : `${a}/${first}`, tail]
-    return { first: n, tail: variants(n) }
-}
-
-/** @type {(d: DependencyMapJson) => (p: IdPath) => IdPath|undefined} */
-const mapDependency = d => ([external, internal]) => {
-    const id = at(external)(d)
-    if (id === undefined) { return undefined }
-    return [id, internal]
-}
-
-/** @typedef {readonly[string, string]} GlobalPath */
-
-/** @type {(d: DependenciesJson) => (p: path.Items) => GlobalPath|undefined} */
-const idPath = d => p => {
-    if (d === undefined) { return undefined }
-    const v = variants([undefined, p])
-    const valid = seq.first(undefined)(seq.filterMap(mapDependency(d))(v))
-    if (valid === undefined) { return undefined }
-    const [packId, localId] = valid
-    return [packId, seq.join('/')(localId)]
-}
-
 module.exports = {
     /** @readonly */
     isDependenciesJson,
-    /** @readonly */
-    idPath,
 }

package/commonjs/package/dependencies/test.js

@@ -10,28 +10,3 @@ const seq = require('../../../types/sequence')
     if (!_.isDependenciesJson({'a':'b'})) { throw 'error' }
     if (_.isDependenciesJson({ 'a': 12 })) { throw 'error' }
 }
-
-/** @type {(g: _.GlobalPath|undefined) => string} */
-const stringify = g => {
-    if (g === undefined) { throw g }
-    return json.stringify(sort)(g)
-}
-
-{
-    if (_.idPath(undefined)(['a', 'b']) !== undefined) { throw 'error' }
-    if (_.idPath({})(['b']) !== undefined) { throw 'error' }
-    if (_.idPath({b:'x'})(['d']) !== undefined) { throw 'error'}
-    {
-        const result = stringify(_.idPath({ b: 'x' })(['b']))
-        if (result !== '["x",""]') { throw result }
-    }
-    if (_.idPath({ 'b/r': 'x' })(['b']) !== undefined) { throw 'error'}
-    {
-        const result = stringify(_.idPath({ 'b/r': 'x' })(['b', 'r']))
-        if (result !== '["x",""]') { throw result }
-    }
-    {
-        const result = stringify(_.idPath({ 'b/r': 'x' })(['b', 'r', 'd', 't']))
-        if (result !== '["x","d/t"]') { throw result }
-    }
-}

package/commonjs/package/index.js

@@ -1,8 +1,11 @@
 const json = require('../../json')
 const dep = require('./dependencies')
+const object = require('../../types/object')
+const run = require('../run')
 
 /** 
  * @typedef {{
+ *  readonly name: string
  *  readonly version: string
  *  readonly dependencies?: dep.DependenciesJson
  * }} PackageJson 
@@ -11,6 +14,7 @@ const dep = require('./dependencies')
 /** @type {(j: json.Unknown) => j is PackageJson} */
 const isPackageJson = j => {
     if (!json.isObject(j)) { return false }
+    if (typeof j.name !== 'string') { return false }
     if (typeof j.version !== 'string') { return false }
     if (!dep.isDependenciesJson(j.dependencies)) { return false }
     return true
@@ -18,10 +22,13 @@ const isPackageJson = j => {
 
 /**
  * @typedef {{
- *  readonly dependencies: dep.DependenciesJson
+ *  readonly dependency: (localPackageId: string) => string | undefined
+ *  readonly file: (localFileId: string) => string | undefined
  * }} Package
  */
 
+/** @typedef {(packageId: string) => Package | undefined} PackageGet */
+
 module.exports = {
     /** @readonly */
     isPackageJson,

package/commonjs/package/test.js

@@ -5,12 +5,12 @@ require('./dependencies/test')
 {
     if (_.isPackageJson(null)) { throw 'error' }
     if (_.isPackageJson({})) { throw 'error' }
-    if (_.isPackageJson({version:12})) { throw 'error' }
-    if (!_.isPackageJson({version:"12"})) { throw 'error' }
+    if (_.isPackageJson({name:'x',version:12})) { throw 'error' }
+    if (!_.isPackageJson({name:'x',version:"12"})) { throw 'error' }
     if (_.isPackageJson({version:"",dependencies:[]})) { throw 'error' }
-    if (!_.isPackageJson({ version: "", dependencies: {} })) { throw 'error' }
-    if (_.isPackageJson({ version: "", dependencies: { x: 12} })) { throw 'error' }
-    if (!_.isPackageJson({ version: "", dependencies: { x: "12" } })) { throw 'error' }
+    if (!_.isPackageJson({name:'a', version: "", dependencies: {} })) { throw 'error' }
+    if (_.isPackageJson({name:'b', version: "", dependencies: { x: 12} })) { throw 'error' }
+    if (!_.isPackageJson({name:'c', version: "", dependencies: { x: "12" } })) { throw 'error' }
 }
 
 module.exports = {}

package/commonjs/path/index.js

@@ -1,6 +1,9 @@
 const seq = require("../../types/sequence")
 const option = require("../../types/option")
 const { compose } = require("../../types/function")
+const dep = require("../package/dependencies")
+const { at } = require("../../types/object")
+const pack = require("../package")
 
 /** @typedef {readonly string[]} Items */
 
@@ -9,7 +12,7 @@ const { compose } = require("../../types/function")
  *  readonly external: boolean
  *  readonly dir: boolean
  *  readonly items: Items
- * }} Path 
+ * }} LocalPath 
  */
 
 /** @type {(path: string) => readonly string[]} */
@@ -34,8 +37,8 @@ const normItemsOp = prior => item => {
 /** @type {(items: seq.Sequence<string>) => seq.Sequence<string>|undefined} */
 const normItems = compose(seq.reduce(normItemsOp)([]))(option.map(seq.reverse))
 
-/** @type {(local: string) => (path: string) => Path|undefined} */
-const parse = local => {
+/** @type {(local: string) => (path: string) => LocalPath|undefined} */
+const parseLocal = local => {
     /** @type {(path: string) => readonly[boolean, seq.Sequence<string>]} */
     const fSeq = path => {
         const pathSeq = split(path)
@@ -44,7 +47,7 @@ const parse = local => {
             default: { return [true, pathSeq] }
         }
     }
-    /** @type {(path: string) => Path|undefined} */
+    /** @type {(path: string) => LocalPath|undefined} */
     const f = path => {
         const [external, items] = fSeq(path)
         const n = normItems(items)
@@ -58,9 +61,56 @@ const parse = local => {
     return f
 }
 
+/** @typedef {readonly[string, seq.Sequence<string>]} IdPath */
+
+/** @type {(prior: readonly[string|undefined, seq.Sequence<string>]) => seq.Thunk<IdPath>} */
+const variants = prior => () => {
+    const [a, b] = prior
+    const r = seq.next(b)
+    if (r === undefined) { return undefined }
+    const { first, tail } = r
+    /** @type {IdPath} */
+    const n = [a === undefined ? first : `${a}/${first}`, tail]
+    return { first: n, tail: variants(n) }
+}
+
+/** @type {(d: dep.DependencyMapJson) => (p: IdPath) => IdPath|undefined} */
+const mapDependency = d => ([external, internal]) => {
+    const id = at(external)(d)
+    return id === undefined ? undefined : [id, internal]
+}
+
+/**
+ * @typedef {{
+ *  readonly name: string,
+ *  readonly items: Items,
+ *  readonly dir: boolean,
+ * }} Path
+ */
+
+/** @type {(d: dep.DependenciesJson) => (dir: boolean) => (items: seq.Sequence<string>) => Path|undefined} */
+const parseGlobal = d => dir => items => {
+    if (d === undefined) { return undefined }
+    const v = variants([undefined, items])
+    const r = seq.first(undefined)(seq.filterMap(mapDependency(d))(v))
+    if (r === undefined) { return undefined }
+    return { name: r[0], items: seq.toArray(r[1]), dir }
+}
+
+/** @type {(name: string) => (dependencies: dep.DependenciesJson) => (local: string) => (path: string) => Path|undefined } */
+const parse = name => dependencies => local => path => {
+    const parsed = parseLocal(local)(path)
+    if (parsed === undefined) { return undefined }
+    const {external, dir, items} = parsed
+    if (!external) { return { name, items, dir } }
+    return parseGlobal(dependencies)(dir)(items)
+}
+
 module.exports = {
     /** @readonly */
-    split,
+    parseLocal,
+    /** @readonly */
+    parseGlobal,
     /** @readonly */
     parse,
 }

package/commonjs/path/test.js

@@ -1,47 +1,64 @@
 const _ = require('.')
 const json = require('../../json')
-const { identity, compose } = require('../../types/function')
-const seq = require('../../types/sequence')
+const { identity } = require('../../types/function')
 
-const stringify = json.stringify(identity)
+/** @type {(g: json.Unknown|undefined) => string} */
+const stringify = g => {
+    if (g === undefined) { throw g }
+    return json.stringify(identity)(g)
+}
 
 {
-    const result = _.parse('')('./a')
-    if (result === undefined) { throw result }
+    const p = { name: '', version: '' }
+    const result = _.parseLocal('')('./a')
     if (stringify(result) !== '{"external":false,"dir":false,"items":["a"]}') { throw result }
 }
 
 {
-    const result = _.parse('')('./a/')
-    if (result === undefined) { throw result }
+    const result = _.parseLocal('')('./a/')
     if (stringify(result) !== '{"external":false,"dir":true,"items":["a"]}') { throw result }
 }
 
 {
-    const result = _.parse('')('..')
+    const result = _.parseLocal('')('..')
     if (result !== undefined) { throw result }
 }
 
 {
-    const result = _.parse('a')('')
-    if (result === undefined) { throw result }
+    const result = _.parseLocal('a')('')
     if (stringify(result) !== '{"external":true,"dir":false,"items":[]}') { throw result }
 }
 
 {
-    const result = _.parse('')('./a/b/.././c')
-    if (result === undefined) { throw result }
+    const result = _.parseLocal('')('./a/b/.././c')
     if (stringify(result) !== '{"external":false,"dir":false,"items":["a","c"]}') { throw result }
 }
 
 {
-    const result = _.parse('x/r')('./a/b/.././c')
-    if (result === undefined) { throw result }
+    const result = _.parseLocal('x/r')('./a/b/.././c')
     if (stringify(result) !== '{"external":false,"dir":false,"items":["x","r","a","c"]}') { throw result }
 }
 
 {
-    const result = _.parse('a')('a/b/.././c')
-    if (result === undefined) { throw result }
+    const result = _.parseLocal('a')('a/b/.././c')
     if (stringify(result) !== '{"external":true,"dir":false,"items":["a","c"]}') { throw result }
 }
+
+{
+    if (_.parseGlobal(undefined)(false)(['a', 'b']) !== undefined) { throw 'error' }
+    if (_.parseGlobal({})(false)(['b']) !== undefined) { throw 'error' }
+    if (_.parseGlobal({ b: 'x' })(false)(['d']) !== undefined) { throw 'error' }
+    {
+        const result = stringify(_.parseGlobal({ b: 'x' })(false)(['b']))
+        if (result !== '["x",""]') { throw result }
+    }
+    if (_.parseGlobal({ 'b/r': 'x' })(false)(['b']) !== undefined) { throw 'error' }
+    {
+        const result = stringify(_.parseGlobal({ 'b/r': 'x' })(false)(['b', 'r']))
+        if (result !== '["x",""]') { throw result }
+    }
+    {
+        const result = stringify(_.parseGlobal({ 'b/r': 'x' })(false)(['b', 'r', 'd', 't']))
+        if (result !== '["x","d/t"]') { throw result }
+    }
+}

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

@@ -3,11 +3,11 @@ const { unwrap } = require('../../types/result')
 const run = require('../../commonjs/run')
 
 /** @type {(f: Function) => run.Module} */
-const createModule = f => req => mutableInfo => {
+const build = f => immutableRequire => mutableData => {
     /** @type {(path: string) => unknown} */
     const mutableRequire = path => {
-        const [result, info] = req(mutableInfo)(path)
-        mutableInfo = info
+        const [result, data] = immutableRequire(path)(mutableData)
+        mutableData = data
         return unwrap(result)
     }
     const result = tryCatch(() => {
@@ -15,12 +15,12 @@ const createModule = f => req => mutableInfo => {
         f(mutableModule, mutableRequire)
         return mutableModule.exports
     })
-    return [result, mutableInfo]
+    return [result, mutableData]
 }
 
 /** @type {run.Compile} */
 const compile = source => 
-    tryCatch(() => createModule(Function('module', 'require', `"use strict";${source}`)))
+    tryCatch(() => build(Function('module', 'require', `"use strict";${source}`)))
 
 module.exports = {
     /** @readonly */

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/io/nodejs/version/index.js

@@ -1,7 +1,6 @@
 const cp = require('child_process')
 const fs = require('fs')
-const json = require('../../../json')
-const { isPackageJson } = require('../../../commonjs/package')
+const package_json = require('../../../package.json')
 
 const b =cp.execSync('git log --oneline')
 
@@ -11,10 +10,6 @@ const v = `0.0.${r}`
 
 console.log(`version: ${v}`)
 
-const package_json = json.parse(fs.readFileSync('package.json').toString())
-
-if (!isPackageJson(package_json)) { throw 'error' }
-
 const x = { ...package_json, version: v }
 
 fs.writeFileSync('package.json', JSON.stringify(x, null, 2))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.0.237",
+  "version": "0.0.241",
   "description": "FunctionalScript is a functional subset of JavaScript",
   "main": "index.js",
   "scripts": {
@@ -14,12 +14,19 @@
   },
   "author": "Natfoam",
   "license": "Apache-2.0",
+  "keywords": [
+    "lambda",
+    "functional-programming",
+    "closure",
+    "pure-functional",
+    "typescript"
+  ],
   "bugs": {
     "url": "https://github.com/functionalscript/functionalscript/issues"
   },
   "homepage": "https://github.com/functionalscript/functionalscript#readme",
   "devDependencies": {
-    "@types/node": "^16.11.11",
+    "@types/node": "^16.11.12",
     "typescript": "^4.5.2"
   }
 }

package/tsconfig.json

@@ -33,7 +33,7 @@
     // "typeRoots": [],                                  /* Specify multiple folders that act like `./node_modules/@types`. */
     // "types": [],                                      /* Specify type package names to be included without being referenced in a source file. */
     // "allowUmdGlobalAccess": true,                     /* Allow accessing UMD globals from modules. */
-    // "resolveJsonModule": true,                        /* Enable importing .json files */
+    "resolveJsonModule": true,                        /* Enable importing .json files */
     // "noResolve": true,                                /* Disallow `import`s, `require`s or `<reference>`s from expanding the number of files TypeScript should add to a project. */
 
     /* JavaScript Support */

package/types/btree/index.js

@@ -129,41 +129,39 @@ const seq = require('../sequence')
 const split = ([n0, v1, n2, v3, n4, v5, n6]) => [[n0, v1, n2], v3, [n4, v5, n6]]
 
 /** 
- * @type {<T>(overflow: (o: Branch3<T>) => Result<T>) => 
+ * @type {<T>(extend: (o: Branch3<T>) => Result<T>) => 
  *  (replace: (r: Node<T>) => Node<T>) => 
  *  (result: Result<T>) => 
  *  Result<T>} 
  */
-const merge = overflow => replace => result => {
+const merge = extend => replace => result => {
     switch (result[0]) {
         case 'done': { return result }
         case 'replace': { return ['replace', replace(result[1])] }
-        default: { return overflow(result[1]) }
+        default: { return extend(result[1]) }
     }
 }
 
-/** 
- * @type {<T>(overflow: (o: Branch3<T>) => Branch5<T>) => 
- *  (replace: (r: Node<T>) => Branch3<T>) => 
- *  (result: Result<T>) => 
- *  Result<T>} 
- */
-const merge2 = overflow => merge(o => ['replace', overflow(o)])
-
-/** 
- * @type {<T>(overflow: (o: Branch3<T>) => Branch7<T>) => 
- *  (replace: (r: Node<T>) => Branch5<T>) => 
- *  (result: Result<T>) => 
- *  Result<T>} 
- */
-const merge3 = overflow => merge(o => ['overflow', split(overflow(o))])
-
 /** @type {(visitor: Visitor) => <T>(cmp: Cmp<T>) => (init: Lazy<T>) => (node: Node<T>) => Result<T>} */
 const visit = ({ found, notFound }) => cmp => {
     const i3 = index3(cmp)
     const i5 = index5(cmp)
+    /** @typedef {typeof cmp extends Cmp<infer T> ? T : never} T */
+    /** 
+     * @type {(extend: (o: Branch3<T>) => Branch5<T>) => 
+     *  (replace: (r: Node<T>) => Branch3<T>) => 
+     *  (result: Result<T>) => 
+     *  Result<T>} 
+     */
+    const merge2 = extend => merge(o => ['replace', extend(o)])
+    /** 
+     * @type {(extend: (o: Branch3<T>) => Branch7<T>) => 
+     *  (replace: (r: Node<T>) => Branch5<T>) => 
+     *  (result: Result<T>) => 
+     *  Result<T>}
+     */
+    const merge3 = extend => merge(o => ['overflow', split(extend(o))])
     return init => {
-        /** @typedef {typeof cmp extends Cmp<infer T> ? T : never} T*/
         /** @type {(node: Node<T>) => Result<T>} */
         const f = node => {
             switch (node.length) {
@@ -188,14 +186,14 @@ const visit = ({ found, notFound }) => cmp => {
                     switch (i3(v1)) {
                         case 0: {
                             return merge2
-                                (o => [...o, v1, n2])
+                                (e => [...e, v1, n2])
                                 (r => [r, v1, n2])
                                 (f(n0))
                         }
                         case 1: { return found.branch3(init)(node) }
                         default: {
                             return merge2
-                                (o => [n0, v1, ...o])
+                                (e => [n0, v1, ...e])
                                 (r => [n0, v1, r])
                                 (f(n2))
                         }
@@ -339,7 +337,7 @@ module.exports = {
      * @type { <T>(cmp: Cmp<T>) => (node: Node<T>) => T|undefined }
      */
     getVisitor: cmp => node => {
-        const result = visit(getVisitor)(cmp)(() => { throw '' })(node)
+        const result = visit(getVisitor)(cmp)(() => { throw 'getVisitor' })(node)
         if (result[0] === 'done') { return result[1] }
         return undefined
     },

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 set = 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 setOp = map => ([name, value]) => set(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(setOp)(/** @type {Map<T>} */(undefined))(entries)
 }
 
 module.exports = {
     /** @readonly */
-    empty,
+    empty: undefined,
+    /** @readonly */
+    at,
+    /** @readonly */
+    set,
+    /** @readonly */
+    entries,
     /** @readonly */
     fromEntries,
 }

package/types/map/test.js

@@ -1,59 +1,60 @@
-const { empty } = require('.')
-const list = require('../sequence')
+const { at, set, empty, entries } = require('.')
+const seq = require('../sequence')
 
 {
-    let m = empty.set('a')(1)
+    let m = set('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 = set('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 = set('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 = set('')(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 = set('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 = set('x')(12)(undefined)
+    m = set('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 = seq.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 = set((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 */