functionalscript 0.0.333 → 0.0.336

package/commonjs/build/index.js

@@ -1,7 +1,6 @@
 const package_ = require('../package/index.js')
 const module_ = require('../module/index.js')
 const function_ = require('../module/function/index.js')
-const { todo } = require('../../dev/index.js')
 const map = require('../../types/map/index.js')
 const object = require('../../types/object/index.js')
 const path = require('../path/index.js')
@@ -60,10 +59,10 @@ const getOrBuild = compile => packageGet => moduleMapInterface =>  {
             /** @type {(e: module_.Error) => (m: M) => Result<M>} */
             const error = e => set(['error', e])
             // check compilation
-            const j = compile(source)
-            if (j[0] === 'error') { return error(['compilation error', j[1]])(moduleMap) }
+            const [kind, result] = compile(source)
+            if (kind === 'error') { return error(['compilation error', result])(moduleMap) }
             // build
-            const [r, [requireMap, moduleMap2]] = j[1](require_)([undefined, moduleMap])
+            const [r, [requireMap, moduleMap2]] = result(require_)([undefined, moduleMap])
             const x = r[0] === 'error' ?
                 error(['runtime error', r[1]]) :
                 set(['ok', { exports: r[1], requireMap: object.fromMap(requireMap) }])

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.0.333",
+  "version": "0.0.336",
   "description": "FunctionalScript is a functional subset of JavaScript",
   "main": "index.js",
   "scripts": {
@@ -28,7 +28,7 @@
   },
   "homepage": "https://github.com/functionalscript/functionalscript#readme",
   "devDependencies": {
-    "@types/node": "^16.11.19",
-    "typescript": "^4.5.4"
+    "@types/node": "^16.11.26",
+    "typescript": "^4.6.2"
   }
 }

package/test.js

@@ -14,6 +14,7 @@ require('./commonjs/path/test.js')
 require('./types/function/compare/test.js')
 require('./types/stringSet/test.js')
 require('./commonjs/build/test.js')
+require('./types/range/test.js')
 
 /** @type {() => never} */
 const assert = () => { throw 'assert' }

package/types/btree/find/index.js

@@ -97,26 +97,24 @@ const find = c => {
 }
 
 /** @type {<T>(first: First<T>) => boolean} */
-const isFound = first => {
-    switch (first[0]) {
+const isFound = ([i]) => {
+    switch (i) {
         case 1: case 3: { return true }
         default: { return false }
     }
 }
 
 /** @type {<T>(first: First<T>) => T | undefined} */
-const value = first => {
-    switch (first[0]) {
+const value = ([i, r]) => {
+    switch (i) {
         case 1: {
-            const x = first[1]
-            switch (x.length) {
-                case 1: case 2: { return x[0] }
-                default: { return x[1] }
+            switch (r.length) {
+                case 1: case 2: { return r[0] }
+                default: { return r[1] }
             }
         }
         case 3: {
-            const x = first[1]
-            return x.length === 2 ? x[1] : x[3]
+            return r.length === 2 ? r[1] : r[3]
         }
         default: {
             return undefined

package/types/btree/remove/index.js

@@ -93,24 +93,20 @@ const initValue1 = a => n => {
  */
 
 /** @type {<A, T>(ms: array.Array2<Merge<A, T>>) => (i: find.PathItem<T>) => (a: A) => Branch<T>} */
-const reduceX = ms => i => a => {
+const reduceX = ms => ([i, n]) => a => {
     const [m0, m2] = ms
     /** @typedef {typeof ms extends array.Array2<Merge<infer A, infer T>> ? [A,T] : never} AT */
     /** @typedef {AT[0]} A */
     /** @typedef {AT[1]} T */
     /** @type {(m: Merge<A, T>) => Branch<T>} */
     const f = m => {
-        const n = i[1]
         const ra = m(a)
         return n.length === 3 ? ra(n) : [...ra([n[0], n[1], n[2]]), n[3], n[4]]
     }
-    switch (i[0]) {
+    switch (i) {
         case 0: { return f(m0) }
         case 2: { return f(m2) }
-        case 4: {
-            const n = i[1]
-            return [n[0], n[1], ...m2(a)([n[2], n[3], n[4]])]
-        }
+        case 4: { return [n[0], n[1], ...m2(a)([n[2], n[3], n[4]])] }
     }
 }
 
@@ -129,9 +125,9 @@ const nodeRemove = c => node => {
             const [v, p] = path(/** @type {find.Path<T>} */(undefined))(n)
             return { first: p.first, tail: list.concat(p.tail)({ first: f(v), tail }) }
         }
-        switch (first[0]) {
+        const [i, n] = first
+        switch (i) {
             case 1: {
-                const n = first[1]
                 switch (n.length) {
                     case 1: { return { first: undefined, tail } }
                     case 2: { return { first: [n[1]], tail } }
@@ -140,7 +136,6 @@ const nodeRemove = c => node => {
                 }
             }
             case 3: {
-                const n = first[1]
                 switch (n.length) {
                     case 2: { return { first: [n[0]], tail } }
                     case 5: { return branch(n[4])(v => [4, [n[0], n[1], n[2], v, n[4]]]) }

package/types/btree/set/index.js

@@ -5,31 +5,28 @@ const list = require('../../list/index.js')
 
 /**
  * @template T
- * @typedef {_.Branch1<T> | _.Branch3<T>} Bracnh1To3
+ * @typedef {_.Branch1<T> | _.Branch3<T>} Branch1To3
  */
 
-/** @type {<T>(b: _.Branch5<T> | _.Branch7<T>) => Bracnh1To3<T>} */
+/** @type {<T>(b: _.Branch5<T> | _.Branch7<T>) => Branch1To3<T>} */
 const b57 = b => b.length === 5 ? [b] : [[b[0], b[1], b[2]], b[3], [b[4], b[5], b[6]]]
 
-/** @type {<T>(i: find.PathItem<T>) => (a: Bracnh1To3<T>) => Bracnh1To3<T>} */
-const reduce = i => a => {
-    switch (i[0]) {
+/** @type {<T>(i: find.PathItem<T>) => (a: Branch1To3<T>) => Branch1To3<T>} */
+const reduce = ([i, x]) => a => {
+    switch (i) {
         case 0: {
-            const x = i[1]
             switch (x.length) {
                 case 3: { return [[...a, x[1], x[2]]] }
                 case 5: { return b57([...a, x[1], x[2], x[3], x[4]]) }
             }
         }
         case 2: {
-            const x = i[1]
             switch (x.length) {
                 case 3: { return [[x[0], x[1], ...a]] }
                 case 5: { return b57([x[0], x[1], ...a, x[3], x[4]]) }
             }
         }
         case 4: {
-            const x = i[1]
             return b57([x[0], x[1], x[2], x[3], ...a])
         }
     }
@@ -38,13 +35,13 @@ const reduce = i => a => {
 /** @type {<T>(c: cmp.Compare<T>) => (value: T) => (node: _.Node<T>) => _.Node<T>} */
 const nodeSet = c => value => node => {
     const { first, tail } = find.find(c)(node)
+    const [i, x] = first;
     /** @typedef {typeof value} T */
-    /** @type {() => Bracnh1To3<T>} */
+    /** @type {() => Branch1To3<T>} */
     const f = () => {
-        switch (first[0]) {
+        switch (i) {
             case 0: {
                 // insert
-                const x = first[1]
                 switch (x.length) {
                     case 1: { return [[value, x[0]]] }
                     case 2: { return [[value], x[0], [x[1]]] }
@@ -52,7 +49,6 @@ const nodeSet = c => value => node => {
             }
             case 1: {
                 // replace
-                const x = first[1];
                 switch (x.length) {
                     case 1: { return [[value]] }
                     case 2: { return [[value, x[1]]] }
@@ -62,7 +58,6 @@ const nodeSet = c => value => node => {
             }
             case 2: {
                 // insert
-                const x = first[1];
                 switch (x.length) {
                     case 1: { return [[x[0], value]] }
                     case 2: { return [[x[0]], value, [x[1]]] }
@@ -70,7 +65,6 @@ const nodeSet = c => value => node => {
             }
             case 3: {
                 // replace
-                const x = first[1];
                 switch (x.length) {
                     case 2: { return [[x[0], value]] }
                     case 5: { return [[x[0], x[1], x[2], value, x[4]]]}
@@ -78,7 +72,7 @@ const nodeSet = c => value => node => {
             }
             case 4: {
                 // insert
-                const [v0, v1] = first[1];
+                const [v0, v1] = x;
                 return [[v0], v1, [value]]
             }
         }

package/types/range/index.js

@@ -0,0 +1,9 @@
+/** @typedef {readonly[number,number]} Range */
+
+/** @type {(range: Range) => (i: number) => boolean} */
+const contains = ([b, e]) => i => b <= i && i <= e
+
+module.exports = {
+    /** @readonly */
+    contains,
+}

package/types/range/test.js

@@ -0,0 +1,9 @@
+const _ = require('./index.js')
+
+{
+    if (!_.contains([0, 5])(1)) { throw 1 }
+    if (!_.contains([0, 5])(0)) { throw 0 }
+    if (!_.contains([0, 5])(5)) { throw 5 }
+    if (_.contains([0, 5])(-1)) { throw -1 }
+    if (_.contains([0, 5])(6)) { throw 6 }
+}

package/types/result/index.js

@@ -21,9 +21,9 @@ const ok = value => ['ok', value]
 const error = e => ['error', e]
 
 /** @type {<T, E>(r: Result<T, E>) => T} */
-const unwrap = result => {
-    if (result[0] === 'error') { throw result[1] }
-    return result[1]
+const unwrap = ([kind, v]) => {
+    if (kind === 'error') { throw v }
+    return v
 }
 
 module.exports = {