functionalscript 0.0.267 → 0.0.271

package/README.md

@@ -15,7 +15,7 @@ Try FunctionalScript [here](https://functionalscript.com/).
 
 In FunctionalScript:
 
-- Any module is a valid JavaScript module
+- Any module is a valid JavaScript module. No additional build steps are required.
 - Code should not have [side-effects](https://en.wikipedia.org/wiki/Side_effect_(computer_science)). Any JavaScript statement, expression, or function which has a side effect is not allowed in FunctionalScript. There are no exceptions to this rule, such as `unsafe` code which can be found in Rust, C#, and other languages.
 - A module can't depend on non FunctionalScript module. 
 - It also has no standard library, only a safe subset of standard JavaScript API can be used without referencing other modules.
@@ -172,6 +172,7 @@ The format of an arrow function is `ARGUMENT_NAME => FUNCTION_BODY`. An arrow fu
 x => x * 2
 a => a + 4
 s => `template literal ${s}`
+a => b => a + b // an arrow functions that returns another arrow functions.
 () => 'hello' // an arrow function with no arguments
 ```
 

package/commonjs/build/index.js

@@ -2,6 +2,9 @@ const package_ = require('../package')
 const module_ = require('../module')
 const function_ = require('../module/function')
 const { todo } = require('../../dev')
+const map = require('../../types/map')
+const object = require('../../types/object')
+const list = require('../../types/list')
 
 /**
  * @template M
@@ -13,47 +16,81 @@ const { todo } = require('../../dev')
  * }} Config
  */
 
-/** 
+/**
  * @template M
- * @typedef {readonly[module_.State, M]} Result 
+ * @typedef {readonly[module_.State, M]} Result
  */
 
-/** 
+/** @type {<M>(moduleMap: M) => Result<M>} */
+const notFound = moduleMap => [['error', ['file not found']], moduleMap]
+
+/**
  * @type {(packageGet: package_.Get) =>
  *  <M>(moduleMapInterface: module_.MapInterface<M>) =>
  *  (compile: function_.Compile) =>
  *  (moduleId: module_.Id) =>
- *  (moduleMap: M) =>
+ *  (moduleMapFirst: M) =>
  *  Result<M>
- * } 
+ * }
  */
-const getOrBuild = packageGet => moduleMapInterface => compile => moduleId => moduleMap => {
+const getOrBuild = packageGet => moduleMapInterface => compile => moduleId => {
+
+    /** @typedef {typeof moduleMapInterface extends module_.MapInterface<infer M> ? M : never} M */
+
     const moduleIdStr = module_.idToString(moduleId)
 
-    /** @type {() => Result<typeof moduleMap>} */
-    const notFound = () => [['error', ['file not found']], moduleMap]
-    
-    /** @type {(e: module_.Error) => Result<typeof moduleMap>} */
-    const error = e => {
+    /** @type {(e: module_.Error) => (moduleMap: M) => Result<M>} */
+    const error = e => moduleMap => {
         /** @type {module_.State} */
         const state = ['error', e]
-        moduleMapInterface.insert(moduleIdStr)(state)
-        return [state, moduleMap]
+        return [state, moduleMapInterface.insert(moduleIdStr)(state)(moduleMap)]
     }
 
-    const m = moduleMapInterface.at(moduleIdStr)(moduleMap)
-    if (m !== undefined) { return [m, moduleMap] }
-    
-    const p = packageGet(moduleId.packageId)
-    if (p === undefined) { return notFound() }
-    
-    const source = p.file(moduleId.path.join('/'))
-    if (source === undefined) { return notFound() }
-    
-    const compileResult = compile(source)
-    if (compileResult[0] === 'error') { return error(['compilation error', compileResult[1]]) }
-    
-    return todo()
+    /** @type {function_.Require<readonly[M, map.Map<string>]>} */
+    const require_ = path => ([moduleMap, requireMap]) => {
+        return todo()
+    }
+
+    return moduleMapFirst => {
+        let moduleMap = moduleMapFirst
+
+        {
+            const m = moduleMapInterface.at(moduleIdStr)(moduleMap)
+            if (m !== undefined) { return [m, moduleMap] }
+        }
+
+        const p = packageGet(moduleId.packageId)
+        if (p === undefined) { return notFound(moduleMap) }
+
+        const source = p.file(moduleId.path.join('/'))
+        if (source === undefined) { return notFound(moduleMap) }
+
+        const compileResult = compile(source)
+        if (compileResult[0] === 'error') { return error(['compilation error', compileResult[1]])(moduleMap) }
+
+        const moduleFunction = compileResult[1]
+
+        moduleMap = moduleMapInterface.insert(moduleIdStr)(['building'])(moduleMap)
+
+        const [[type, exportsOrError], [newModuleMap, requireMap]] = moduleFunction(require_)([moduleMap, map.empty])
+        moduleMap = newModuleMap
+
+        {
+            const m = moduleMapInterface.at(moduleIdStr)(moduleMap)
+            if (m === undefined ) { throw 'm === undefined' }
+            if (m[0] !== 'building') { return [m, moduleMap] }
+        }
+
+        /** @type {module_.State} */
+        const result = type === 'error' ?
+            ['error', ['runtime error', exportsOrError]] :
+            ['ok', {
+                exports: exportsOrError,
+                requireMap: object.fromMap(requireMap)
+            }]
+
+        return [result, moduleMapInterface.insert(moduleIdStr)(result)(moduleMap)]
+    }
 }
 
 module.exports = {

package/commonjs/module/function/index.js

@@ -4,11 +4,11 @@
 
 const result = require('../../../types/result')
 
-/** @typedef {<M>(require: Require<M>) => (prior: M) => Result<M>} Function */
+/** @typedef {<M>(require: Require<M>) => (prior: M) => Result<M>} Function_ */
 
 /**
  * @template M
- * @typedef {readonly[result.Result<unknown, unknown>, M]} Result 
+ * @typedef {readonly[result.Result<unknown, unknown>, M]} Result
  */
 
 /**
@@ -16,6 +16,6 @@ const result = require('../../../types/result')
  * @typedef {(path: string) => (prior: M) => Result<M>} Require
  */
 
-/** @typedef {(source: string) => result.Result<Function, unknown>} Compile */
+/** @typedef {(source: string) => result.Result<Function_, unknown>} Compile */
 
 module.exports = {}

package/commonjs/module/index.js

@@ -8,12 +8,12 @@ const object = require('../../types/object')
  * }} MapInterface
  */
 
-/** 
+/**
  * @typedef {|
- *  readonly['ok', Module] | 
- *  readonly['error', Error] | 
+ *  readonly['ok', Module] |
+ *  readonly['error', Error] |
  *  readonly['building']
- * } State 
+ * } State
  */
 
 /**
@@ -23,11 +23,11 @@ const object = require('../../types/object')
  * }} Module
  */
 
-/** 
+/**
  * @typedef {|
- *  ['file not found'] | 
- *  ['compilation error', unknown] | 
- *  ['runtime error'] | 
+ *  ['file not found'] |
+ *  ['compilation error', unknown] |
+ *  ['runtime error', unknown] |
  *  ['circular reference']
  * } Error
  */

package/commonjs/path/index.js

@@ -1,49 +1,49 @@
-const seq = require("../../types/list")
+const list = require("../../types/list")
 const option = require("../../types/option")
 const { compose } = require("../../types/function")
-const dep = require("../package/dependencies")
-const { at } = require("../../types/object")
-// const pack = require("../package")
+const { todo } = require("../../dev")
+const package_ = require("../package")
+const module_ = require("../module")
 
 /** @typedef {readonly string[]} Items */
 
-/** 
+/**
  * @typedef {{
  *  readonly external: boolean
  *  readonly dir: boolean
  *  readonly items: Items
- * }} LocalPath 
+ * }} LocalPath
  */
 
 /** @type {(path: string) => readonly string[]} */
 const split = path => path.split('/')
 
-/** @type {(s: undefined|seq.List<string>) => (items: string) => undefined|seq.List<string>} */
+/** @type {(s: undefined|list.List<string>) => (items: string) => undefined|list.List<string>} */
 const normItemsOp = prior => item => {
     if (prior === undefined) { return undefined }
     switch (item) {
         case '': case '.': { return prior }
         case '..': {
-            const result = seq.next(prior)
+            const result = list.next(prior)
             if (result === undefined) { return undefined }
             return result.tail
         }
         default: {
-            return seq.nonEmpty(item)(prior)
+            return list.nonEmpty(item)(prior)
         }
     }
 }
 
-/** @type {(items: seq.List<string>) => seq.List<string>|undefined} */
-const normItems = compose(seq.reduce(normItemsOp)([]))(option.map(seq.reverse))
+/** @type {(items: list.List<string>) => list.List<string>|undefined} */
+const normItems = compose(list.reduce(normItemsOp)([]))(option.map(list.reverse))
 
 /** @type {(local: string) => (path: string) => LocalPath|undefined} */
 const parseLocal = local => {
-    /** @type {(path: string) => readonly[boolean, seq.List<string>]} */
+    /** @type {(path: string) => readonly[boolean, list.List<string>]} */
     const fSeq = path => {
         const pathSeq = split(path)
-        switch (seq.first(undefined)(pathSeq)) {
-            case '.': case '..': { return [false, seq.flat([split(local), pathSeq])] }
+        switch (list.first(undefined)(pathSeq)) {
+            case '.': case '..': { return [false, list.flat([split(local), pathSeq])] }
             default: { return [true, pathSeq] }
         }
     }
@@ -55,18 +55,18 @@ const parseLocal = local => {
         return {
             external,
             dir: path[path.length - 1] === '/',
-            items: seq.toArray(n)
+            items: list.toArray(n)
         }
     }
     return f
 }
 
-/** @typedef {readonly[string, seq.List<string>]} IdPath */
+/** @typedef {readonly[string, list.List<string>]} IdPath */
 
-/** @type {(prior: readonly[string|undefined, seq.List<string>]) => seq.Thunk<IdPath>} */
+/** @type {(prior: readonly[string|undefined, list.List<string>]) => list.Thunk<IdPath>} */
 const variants = prior => () => {
     const [a, b] = prior
-    const r = seq.next(b)
+    const r = list.next(b)
     if (r === undefined) { return undefined }
     const { first, tail } = r
     /** @type {IdPath} */
@@ -74,38 +74,76 @@ const variants = prior => () => {
     return { first: n, tail: variants(n) }
 }
 
-/** @type {(d: dep.DependencyMapJson) => (p: IdPath) => IdPath|undefined} */
+/** @type {(d: (local: string) => string|undefined) => (p: IdPath) => IdPath|undefined} */
 const mapDependency = d => ([external, internal]) => {
-    const id = at(external)(d)
+    const id = d(external)
     return id === undefined ? undefined : [id, internal]
 }
 
 /**
  * @typedef {{
- *  readonly name: string,
+ *  readonly packageId: string,
  *  readonly items: Items,
  *  readonly dir: boolean,
  * }} Path
  */
 
-/** @type {(d: dep.DependenciesJson) => (dir: boolean) => (items: seq.List<string>) => Path|undefined} */
+/**
+ * @type {(d: (local: string) => string|undefined) =>
+ *  (dir: boolean) =>
+ *  (items: list.List<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))
+    const r = list.first(undefined)(list.filterMap(mapDependency(d))(v))
     if (r === undefined) { return undefined }
-    return { name: r[0], items: seq.toArray(r[1]), dir }
+    return { packageId: r[0], items: list.toArray(r[1]), dir }
 }
 
-/** @type {(name: string) => (dependencies: dep.DependenciesJson) => (local: string) => (path: string) => Path|undefined } */
-const parse = name => dependencies => local => path => {
+/**
+ * @type {(packageId: string) =>
+ *  (dependencies: (local: string) => string|undefined) =>
+ *  (local: string) =>
+ *  (path: string) =>
+ *  Path|undefined }
+ */
+const parse = packageId => dependencies => local => path => {
     const parsed = parseLocal(local)(path)
     if (parsed === undefined) { return undefined }
-    const {external, dir, items} = parsed
-    if (!external) { return { name, items, dir } }
+    const {external, dir, items } = parsed
+    if (!external) { return { packageId, items, dir } }
     return parseGlobal(dependencies)(dir)(items)
 }
 
+/** @typedef {readonly[string, string] | undefined} Result */
+
+/**
+ * @type {(packageGet: package_.Get) =>
+ *  (packageId: string) =>
+ *  (local: string) =>
+ *  (path: string) =>
+ *  Result
+ * }
+ */
+const parseAndFind = packageGet => packageId => local => path => {
+    const currentPack = packageGet(packageId)
+    if (currentPack === undefined) { return undefined }
+    const p = parse(packageId)(currentPack.dependency)(local)(path)
+    if (p === undefined) { return undefined }
+    const pack = packageGet(p.packageId)
+    if (pack === undefined) { return undefined }
+    /** @type {(fileId: string) => Result } */
+    const tryFile = fileId => {
+        const source = pack.file(fileId)
+        return source === undefined ? undefined : [fileId, source]
+    }
+    const file = p.items.join('/')
+    const indexJs = list.join('/')(list.concat(p.items)(['index.js']))
+    const fileList = p.dir || list.isEmpty(p.items) ? [indexJs] : [file, `${file}.js`, indexJs]
+    return list.first(undefined)(list.filterMap(tryFile)(fileList))
+}
+
 module.exports = {
     /** @readonly */
     parseLocal,
@@ -113,4 +151,6 @@ module.exports = {
     parseGlobal,
     /** @readonly */
     parse,
+    /** @readonly */
+    parseAndFind,
 }

package/commonjs/path/test.js

@@ -1,6 +1,7 @@
 const _ = require('.')
 const json = require('../../json')
 const { identity } = require('../../types/function')
+const { at } = require('../../types/object')
 
 /** @type {(g: json.Unknown|undefined) => string} */
 const stringify = g => {
@@ -45,20 +46,20 @@ const stringify = g => {
 }
 
 {
-    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' }
+    if (_.parseGlobal(() => undefined)(false)(['a', 'b']) !== undefined) { throw 'error' }
+    if (_.parseGlobal(() => undefined)(false)(['b']) !== undefined) { throw 'error' }
+    if (_.parseGlobal(d => at(d)({ b: 'x' }))(false)(['d']) !== undefined) { throw 'error' }
     {
-        const result = stringify(_.parseGlobal({ b: 'x' })(false)(['b']))
+        const result = stringify(_.parseGlobal(d => at(d)({ b: 'x' }))(false)(['b']))
         if (result !== '["x",""]') { throw result }
     }
-    if (_.parseGlobal({ 'b/r': 'x' })(false)(['b']) !== undefined) { throw 'error' }
+    if (_.parseGlobal(d => at(d)({ 'b/r': 'x' }))(false)(['b']) !== undefined) { throw 'error' }
     {
-        const result = stringify(_.parseGlobal({ 'b/r': 'x' })(false)(['b', 'r']))
+        const result = stringify(_.parseGlobal(d => at(d)({ 'b/r': 'x' }))(false)(['b', 'r']))
         if (result !== '["x",""]') { throw result }
     }
     {
-        const result = stringify(_.parseGlobal({ 'b/r': 'x' })(false)(['b', 'r', 'd', 't']))
+        const result = stringify(_.parseGlobal(d => at(d)({ 'b/r': 'x' }))(false)(['b', 'r', 'd', 't']))
         if (result !== '["x","d/t"]') { throw result }
     }
 }

package/io/commonjs/index.js

@@ -2,12 +2,12 @@ const { tryCatch } = require('../result')
 const { unwrap } = require('../../types/result')
 const moduleFunction = require('../../commonjs/module/function')
 
-/** @type {(f: Function) => moduleFunction.Function} */
+/** @type {(f: Function) => moduleFunction.Function_} */
 const build = f => immutableRequire => mutableData => {
     /** @type {(path: string) => unknown} */
     const mutableRequire = path => {
         const [result, data] = immutableRequire(path)(mutableData)
-        // Side effect: setting a variable from a nested function (closure) 
+        // Side effect: setting a variable from a nested function (closure)
         // is not allowed in FunctionalScript.
         mutableData = data
         return unwrap(result)
@@ -21,7 +21,7 @@ const build = f => immutableRequire => mutableData => {
 }
 
 /** @type {moduleFunction.Compile} */
-const compile = source => 
+const compile = source =>
     // Side effect: a `Function` constructor is not allowed in FunctionalScript.
     tryCatch(() => build(Function('module', 'require', `"use strict";${source}`)))
 

package/package.json

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

package/types/btree/index.js

@@ -36,8 +36,8 @@ const seq = require('../list')
 //
 
 /**
- * @template T 
- * @typedef {Array1<T>} Leaf1 
+ * @template T
+ * @typedef {Array1<T>} Leaf1
  */
 
 /**
@@ -62,9 +62,9 @@ const seq = require('../list')
 
 /** @typedef {readonly['done']} NotFoundDone */
 
-/** 
+/**
  * @template T
- * @typedef {readonly['done', T]} FoundDone 
+ * @typedef {readonly['done', T]} FoundDone
  */
 
 /**
@@ -92,7 +92,7 @@ const seq = require('../list')
 /** @typedef {<T>(_: Lazy<T>) => (_: Branch3<T>) => Result<T>} InBranch3 */
 /** @typedef {<T>(_: Lazy<T>) => (_: Branch5<T>) => Result<T>} InBranch5 */
 
-/** 
+/**
  * @typedef {{
  *  readonly leaf1: InLeaf1
  *  readonly leaf2_left: InLeaf2
@@ -113,7 +113,7 @@ const seq = require('../list')
  * }} NotFound
  */
 
-/** 
+/**
  * @typedef {{
  *  readonly found: Found
  *  readonly notFound: NotFound
@@ -128,11 +128,11 @@ const seq = require('../list')
 /** @type {<T>(n: Branch7<T>) => Branch3<T>} */
 const split = ([n0, v1, n2, v3, n4, v5, n6]) => [[n0, v1, n2], v3, [n4, v5, n6]]
 
-/** 
- * @type {<T>(extend: (o: Branch3<T>) => Result<T>) => 
- *  (replace: (r: Node<T>) => Node<T>) => 
- *  (result: Result<T>) => 
- *  Result<T>} 
+/**
+ * @type {<T>(extend: (o: Branch3<T>) => Result<T>) =>
+ *  (replace: (r: Node<T>) => Node<T>) =>
+ *  (result: Result<T>) =>
+ *  Result<T>}
  */
 const merge = extend => replace => result => {
     switch (result[0]) {
@@ -147,17 +147,17 @@ 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>} 
+    /**
+     * @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>) => 
+    /**
+     * @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))])
@@ -305,34 +305,31 @@ const replaceVisitor = {
 
 /** @type {<T>(node: Node<T>) => seq.List<T>} */
 const values = node => () => {
-    const f = () => {
-        switch (node.length) {
-            case 1: case 2: { return node }
-            case 3: { 
-                return seq.flat([
-                    values(node[0]), 
-                    [node[1]], 
-                    values(node[2])
-                ])
-            }
-            default: {
-                return seq.flat([
-                    values(node[0]),
-                    [node[1]],
-                    values(node[2]),
-                    [node[3]],
-                    values(node[4])
-                ])
-            }
+    switch (node.length) {
+        case 1: case 2: { return node }
+        case 3: {
+            return seq.flat([
+                values(node[0]),
+                [node[1]],
+                values(node[2])
+            ])
+        }
+        default: {
+            return seq.flat([
+                values(node[0]),
+                [node[1]],
+                values(node[2]),
+                [node[3]],
+                values(node[4])
+            ])
         }
     }
-    return seq.next(f())
 }
 
 module.exports = {
     /** @readonly */
     values,
-    /** 
+    /**
      * @readonly
      * @type { <T>(cmp: Cmp<T>) => (node: Node<T>) => T|undefined }
      */

package/types/list/index.js

@@ -199,6 +199,9 @@ const some = input => find
     (/** @type {(_: boolean) => boolean} */(identity))
     (input)
 
+/** @type {<T>(input: List<T>) => boolean} */
+const isEmpty = input => !some(map(() => true)(input))
+
 /** @type {(input: List<boolean>) => boolean} */
 const every = input => !some(map(logicalNot)(input))
 
@@ -336,6 +339,8 @@ module.exports = {
     /** @readonly */
     every,
     /** @readonly */
+    isEmpty,
+    /** @readonly */
     includes,
     /** @readonly */
     countdown,

package/types/list/test.js

@@ -214,6 +214,16 @@ const stringify = sequence => json.stringify(sort)(_.toArray(sequence))
     if (result !== 12) { throw result }
 }
 
+{
+    const result = _.isEmpty(() => [])
+    if (result !== true) { throw result }
+}
+
+{
+    const result = _.isEmpty(() => [2])
+    if (result !== false) { throw result }
+}
+
 // stress tests
 
 const stress = () => {

package/types/map/index.js

@@ -3,13 +3,13 @@ const btree = require('../btree')
 const { getVisitor, setVisitor, values } = require("../btree")
 const compare = require("../function/compare")
 const { cmp } = require("../function/compare")
-const seq = require("../list")
+const list = require("../list")
 
 /** @typedef {compare.Sign} Sign */
 
 /**
- * @template T 
- * @typedef {btree.Leaf1<T>} Leaf1 
+ * @template T
+ * @typedef {btree.Leaf1<T>} Leaf1
  */
 
 /**
@@ -27,7 +27,7 @@ const seq = require("../list")
  * @typedef {readonly[string, T]} Entry
  */
 
-/** 
+/**
  * @template T
  * @typedef {undefined|TNode<Entry<T>>} Map
  */
@@ -54,16 +54,16 @@ const set = name => value => map =>  {
     }
 }
 
-/** @type {<T>(map: Map<T>) => seq.List<Entry<T>>} */
-const entries = map => map === undefined ? [] : values(map)
+/** @type {<T>(map: Map<T>) => list.List<Entry<T>>} */
+const entries = map => map === undefined ? undefined : values(map)
 
 /** @type {<T>(map: Map<T>) => (entry: Entry<T>) => Map<T>} */
 const setOp = map => ([name, value]) => set(name)(value)(map)
 
-/** @type {<T>(entries: seq.List<Entry<T>>) => Map<T>} */
+/** @type {<T>(entries: list.List<Entry<T>>) => Map<T>} */
 const fromEntries = entries => {
-    /** @typedef {typeof entries extends seq.List<Entry<infer T>> ? T : never} T */    
-    return seq.reduce(setOp)(/** @type {Map<T>} */(undefined))(entries)
+    /** @typedef {typeof entries extends list.List<Entry<infer T>> ? T : never} T */
+    return list.reduce(setOp)(/** @type {Map<T>} */(undefined))(entries)
 }
 
 module.exports = {

package/types/object/index.js

@@ -1,4 +1,4 @@
-const seq = require('../list')
+const list = require('../list')
 const map = require('../map')
 
 /**
@@ -16,12 +16,17 @@ const map = require('../map')
 /** @type {(name: string) => <T>(object: Map<T>) => T|undefined} */
 const at = name => object => Object.getOwnPropertyDescriptor(object, name)?.value
 
-/** @type {<T>(entries: seq.List<Entry<T>>) => seq.List<Entry<T>>} */
+/** @type {<T>(entries: list.List<Entry<T>>) => list.List<Entry<T>>} */
 const sort = entries => map.entries(map.fromEntries(entries))
 
+/** @type {<T>(m: map.Map<T>) => Map<T>} */
+const fromMap = m => Object.fromEntries(list.iterable(map.entries(m)))
+
 module.exports = {
     /** @readonly */
     at,
     /** @readonly */
     sort,
+    /** @readonly */
+    fromMap,
 }