functionalscript 0.0.307 → 0.0.308

package/package.json

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

package/test.js

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

package/types/btree/find/index.js

@@ -44,10 +44,8 @@ const array = require('../../array')
  */
 
 /** @type {<T>(item: PathItem<T>) => _.Node<T>} */
-const child = item => {
-    /** @typedef {typeof item extends PathItem<infer T> ? T : never} T */
-    return /** @type {_.Node<T>} */(item[1][item[0]])
-}
+const child = item =>
+    /** @type {typeof item extends PathItem<infer T> ? _.Node<T> : never} */(item[1][item[0]])
 
 /**
  * @template T
@@ -98,6 +96,14 @@ const find = c => {
     return f(undefined)
 }
 
+/** @type {<T>(first: First<T>) => boolean} */
+const isFound = first => {
+    switch (first[0]) {
+        case 1: case 3: { return true }
+        default: { return false }
+    }
+}
+
 /** @type {<T>(first: First<T>) => T | undefined} */
 const value = first => {
     switch (first[0]) {
@@ -123,4 +129,6 @@ module.exports = {
     find,
     /** @readonly */
     value,
-}
+    /** @readonly */
+    isFound,
+}

package/types/btree/index.js

@@ -1,4 +1,5 @@
 const seq = require('../list')
+const option = require('../option')
 
 /**
  * @template T
@@ -48,24 +49,29 @@ const seq = require('../list')
  * @typedef { Leaf1<T> | Leaf2<T> | Branch3<T> | Branch5<T>} Node
  */
 
+/**
+ * @template T
+ * @typedef {Node<T> | undefined} Tree
+ */
+
 /** @type {<T>(node: Node<T>) => seq.Thunk<T>} */
-const values = node => () => {
+const nodeValues = node => () => {
     switch (node.length) {
         case 1: case 2: { return node }
         case 3: {
             return seq.flat([
-                values(node[0]),
+                nodeValues(node[0]),
                 [node[1]],
-                values(node[2])
+                nodeValues(node[2])
             ])
         }
         default: {
             return seq.flat([
-                values(node[0]),
+                nodeValues(node[0]),
                 [node[1]],
-                values(node[2]),
+                nodeValues(node[2]),
                 [node[3]],
-                values(node[4])
+                nodeValues(node[4])
             ])
         }
     }
@@ -81,6 +87,9 @@ const values = node => () => {
  * @typedef { readonly[...Branch5<T>, T, Node<T>] } Branch7
  */
 
+/** @type {<T>(tree: Tree<T>) => seq.List<T>} */
+const values = option.map(nodeValues)
+
 module.exports = {
     /** @readonly */
     values,

package/types/btree/remove/index.js

@@ -1,9 +1,9 @@
 const _ = require('..')
-const { todo } = require('../../../dev')
 const cmp = require('../../function/compare')
 const find = require('../find')
 const list = require('../../list')
 const array = require('../../array')
+const option = require('../../option')
 
 /**
  * @template T
@@ -118,8 +118,8 @@ const reduce = list.reduce(reduceX([reduceValue0, reduceValue2]))
 
 const initReduce = reduceX([initValue0, initValue1])
 
-/** @type {<T>(c: cmp.Compare<T>) => (node: _.Node<T>) => undefined | _.Node<T>} */
-const remove = c => node => {
+/** @type {<T>(c: cmp.Compare<T>) => (node: _.Node<T>) => _.Tree<T>} */
+const nodeRemove = c => node => {
     /** @typedef {typeof c extends cmp.Compare<infer T> ? T : never} T */
     /** @type  {() => undefined | RemovePath<T>} */
     const f = () => {
@@ -159,7 +159,12 @@ const remove = c => node => {
     return result.length === 1 ? result[0] : result
 }
 
+/** @type {<T>(c: cmp.Compare<T>) => (tree: _.Tree<T>) => _.Tree<T>} */
+const remove = c => option.map(nodeRemove(c))
+
 module.exports = {
+    /** @readonly */
+    nodeRemove,
     /** @readonly */
     remove,
-}
+}

package/types/btree/remove/test.js

@@ -9,7 +9,7 @@ const { sort } = require('../../object')
 const set = node => value => s.set(stringCmp(value))(value)(node)
 
 /** @type {(node: btree.Node<string>) => (value: string) => btree.Node<string> | undefined} */
-const remove = node => value => _.remove(stringCmp(value))(node)
+const remove = node => value => _.nodeRemove(stringCmp(value))(node)
 
 const jsonStr = json.stringify(sort)
 

package/types/btree/set/index.js

@@ -36,7 +36,7 @@ const reduce = a => i => {
 }
 
 /** @type {<T>(c: cmp.Compare<T>) => (value: T) => (node: _.Node<T>) => _.Node<T>} */
-const set = c => value => node => {
+const nodeSet = c => value => node => {
     const { first, tail } = find.find(c)(node)
     /** @typedef {typeof value} T */
     /** @type {() => Bracnh1To3<T>} */
@@ -87,7 +87,10 @@ const set = c => value => node => {
     return r.length === 1 ? r[0] : r
 }
 
+/** @type {<T>(c: cmp.Compare<T>) => (value: T) => (tree: _.Tree<T>) => _.Node<T>} */
+const set = c => value => tree => tree === undefined ? [value] : nodeSet(c)(value)(tree)
+
 module.exports = {
     /** @readonly */
     set,
-}
+}

package/types/function/index.js

@@ -1,22 +1,27 @@
-/** 
+/**
  * @template I
  * @template O
- * @typedef {(_: I) => O} Func 
+ * @typedef {(_: I) => O} Func
  */
 
-/** 
+/**
  * Postfix Compose function.
  *
- * @type {<I, X>(g: Func<I, X>) => <O>(f: Func<X, O>) => Func<I, O>} 
+ * @type {<I, X>(g: Func<I, X>) => <O>(f: Func<X, O>) => Func<I, O>}
  */
 const compose = g => f => x => f(g(x))
 
 /** @type {<T>(value: T) => T} */
 const identity = value => value
 
+/** @type {<A, B, C>(f: (a: A) => (b: B) => C) => (b: B) => (a: A) => C} */
+const flip = f => b => a => f(a)(b)
+
 module.exports = {
     /** @readonly */
     identity,
     /** @readonly */
     compose,
+    /** @reeadonly */
+    flip,
 }

package/types/map/index.js

@@ -1,24 +1,15 @@
-const option = require("../option")
 const btree = require('../btree')
 const { values } = require("../btree")
 const find = require('../btree/find')
 const s = require('../btree/set')
-const compare = require("../function/compare")
-const { stringCmp } = require("../function/compare")
-const list = require("../list")
+const compare = require('../function/compare')
+const { stringCmp } = require('../function/compare')
+const list = require('../list')
+const btRemove = require('../btree/remove')
+const { flip } = require('../function')
 
 /** @typedef {compare.Sign} Sign */
 
-/**
- * @template T
- * @typedef {btree.Leaf1<T>} Leaf1
- */
-
-/**
- * @template T
- * @typedef {btree.Node<T>} TNode
- */
-
 /**
  * @template T
  * @typedef {compare.Compare<T>} Cmp
@@ -31,7 +22,7 @@ const list = require("../list")
 
 /**
  * @template T
- * @typedef {undefined|TNode<Entry<T>>} Map
+ * @typedef {btree.Tree<Entry<T>>} Map
  */
 
 /** @type {(a: string) => <T>(b: Entry<T>) => Sign} */
@@ -44,25 +35,20 @@ const at = name => map => {
     return result === undefined ? undefined : result[1]
 }
 
+/** @type {<T>(entry: Entry<T>) => (map: Map<T>) => Map<T>} */
+const setEntry = entry => s.set(keyCmp(entry[0]))(entry)
+
 /** @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] }
-    return s.set(keyCmp(name))(entry)(map)
-}
+const set = name => value => setEntry([name, value])
 
 /** @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)
+const entries = values
 
 /** @type {<T>(entries: list.List<Entry<T>>) => Map<T>} */
-const fromEntries = entries => {
-    /** @typedef {typeof entries extends list.List<Entry<infer T>> ? T : never} T */
-    return list.reduce(setOp)(/** @type {Map<T>} */(undefined))(entries)
-}
+const fromEntries = list.reduce(flip(setEntry))(undefined)
+
+/** @type {(name: string) => <T>(map: Map<T>) => Map<T>} */
+const remove = name => btRemove.remove(keyCmp(name))
 
 module.exports = {
     /** @readonly */
@@ -75,4 +61,6 @@ module.exports = {
     entries,
     /** @readonly */
     fromEntries,
+    /** @readonly */
+    remove,
 }

package/types/map/test.js

@@ -1,4 +1,4 @@
-const { at, set, empty, entries } = require('.')
+const { at, set, empty, entries, remove } = require('.')
 const seq = require('../list')
 
 {
@@ -38,6 +38,8 @@ const seq = require('../list')
     if (at('x')(m) !== undefined) { throw 'error' }
 
     // console.log(Array.from(m.entries()))
+    m = remove('Hello world!')(m)
+    if (at('Hello world!')(m) !== undefined) { throw m }
 }
 
 {

package/types/stringSet/index.js

@@ -0,0 +1,36 @@
+const btree = require('../btree')
+const find = require('../btree/find')
+const btSet = require('../btree/set')
+const btRemove = require('../btree/remove')
+const { stringCmp } = require("../function/compare")
+const list = require('../list')
+const { flip, compose } = require('../function')
+
+/** @typedef {btree.Tree<string>} StringSet */
+
+/** @type {(value: string) => (set: StringSet) => boolean} */
+const contains = value => s => s !== undefined && find.isFound(find.find(stringCmp(value))(s).first)
+
+/** @type {(value: string) => (s: StringSet) => StringSet} */
+const set = value => btSet.set(stringCmp(value))(value)
+
+/** @type {(s: StringSet) => list.List<string>} */
+const values = btree.values
+
+const fromValues = list.reduce(flip(set))(undefined)
+
+/** @type {(value: string) => (s: StringSet) => StringSet} */
+const remove = compose(stringCmp)(btRemove.remove)
+
+module.exports = {
+    /** @readonly */
+    contains,
+    /** @readonly */
+    set,
+    /** @readonly */
+    values,
+    /** @readonly */
+    fromValues,
+    /** @readonly */
+    remove,
+}

package/types/stringSet/test.js

@@ -0,0 +1,33 @@
+const _ = require('.')
+
+{
+    const r = _.set('hello')(undefined)
+    if (!_.contains('hello')(r)) { throw r }
+    if (_.contains('hello1')(r)) { throw r }
+}
+
+{
+    let r = _.set('hello')(undefined)
+    r = _.set('world')(r)
+    r = _.set('HELLO')(r)
+    r = _.set('WORLD!')(r)
+    if (!_.contains('hello')(r)) { throw r }
+    if (_.contains('hello1')(r)) { throw r }
+    if (!_.contains('HELLO')(r)) { throw r }
+    if (_.contains('WORLD')(r)) { throw r }
+    if (!_.contains('world')(r)) { throw r }
+    if (_.contains('world!')(r)) { throw r }
+    if (!_.contains('WORLD!')(r)) { throw r }
+    //
+    r = _.remove('hello')(r)
+    if (_.contains('hello')(r)) { throw r }
+    if (!_.contains('world')(r)) { throw r }
+    r = _.remove('world')(r)
+    if (_.contains('world')(r)) { throw r }
+    if (!_.contains('HELLO')(r)) { throw r }
+    r = _.remove('HELLO')(r)
+    if (_.contains('HELLO')(r)) { throw r }
+    if (!_.contains('WORLD!')(r)) { throw r }
+    r = _.remove('WORLD!')(r)
+    if (r !== undefined) { throw r }
+}