functionalscript 0.0.307 → 0.0.311

package/LANGUAGE.md

@@ -13,7 +13,7 @@ const result = thirdPartyModule.someFunction('hello')
 ## 2. Packages
 
 FunctionalScript uses a `package.json` file to define a package. This file is compatible with [Node.js `package.json`](https://nodejs.org/en/knowledge/getting-started/npm/what-is-the-file-package-json/).
-The prefered way to refence dependencies is to use a GitHub URL. These dependencies in a `package.json` file could look like this,
+The preferred way to reference dependencies is to use a GitHub URL. These dependencies in a `package.json` file could look like this,
 
 ```json
 {
@@ -33,7 +33,7 @@ npm install -S github:functionalscript/functionalscript
 
 ## 3. Module Structure
 
-A module is a file with the `.js` extention. It contains three parts: references to other modules, definitions, and exports. For example
+A module is a file with the `.js` extension. It contains three parts: references to other modules, definitions, and exports. For example
 
 `./first.js`
 ```js
@@ -81,7 +81,7 @@ const localFile = require('../some-directory/some-file.js')
 
 ## 5. Definitions
 
-The format of defintions is `const NAME = EXPRESSION`, where the `EXPRESSION` is a subset of [JavaScript expressions](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Expressions_and_Operators).
+The format of definitions is `const NAME = EXPRESSION`, where the `EXPRESSION` is a subset of [JavaScript expressions](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Expressions_and_Operators).
 
 ```js
 const myConst = 42
@@ -139,7 +139,7 @@ Expressions could fall under these categories:
   - Relations Operators: `in`, `instanceof`.
   - Member Operators: `.`, `[]`.
 
-Note: the `.` member operator has prohibitted property names, such as `constructor` and `push`. To access such properties, it's recommeded to use the [Object.getOwnPropertyDescriptor](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Reflect/getOwnPropertyDescriptor) function.
+Note: the `.` member operator has prohibited property names, such as `constructor` and `push`. To access such properties, it's recommended to use the [Object.getOwnPropertyDescriptor](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Reflect/getOwnPropertyDescriptor) function.
 
 ## 8. Arrow Functions
 
@@ -167,7 +167,7 @@ const f = x => {
 
 ## 9. Statements
 
-`{ A_LIST_OF_STATEMENTS }` is one or many statements seperated by the newline control character. One of these statements mentioned earlier was [definition](#5-Definitions), also known as a [const](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/const) statement. The other statements are described below.
+`{ A_LIST_OF_STATEMENTS }` is one or many statements separated by the newline control character. One of these statements mentioned earlier was [definition](#5-Definitions), also known as a [const](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/const) statement. The other statements are described below.
 
 ### 9.1. Let
 
@@ -197,7 +197,7 @@ const f = () => x // < invalid
 
 ### 9.5. Throw
 
-[Throw](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/throw). FunctionalScript allows to throw exceptions but it doesn't catch them. You should only be using Statement throw in non-recoverable situations. It could be compared to [panic in Rust](https://doc.rust-lang.org/std/macro.panic.html).
+[Throw](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/throw). FunctionalScript allows to throw exceptions, but the language has no ability to catch them. You should only be using Statement throw in non-recoverable situations. Throwing an exception could be compared to [panic in Rust](https://doc.rust-lang.org/std/macro.panic.html).
 
 ### 9.6. While
 

package/README.md

@@ -1,6 +1,6 @@
 # FunctionalScript
 
-FunctionalScript is a pure functional programming language and a strict subset of
+FunctionalScript is a purely functional programming language and a strict subset of
 [ECMAScript](https://en.wikipedia.org/wiki/ECMAScript)/[JavaScript](https://en.wikipedia.org/wiki/JavaScript). It's inspired by
 
 - [JSON](https://en.wikipedia.org/wiki/JSON) as a subset of JavaScript. JSON is also a subset of FunctionalScript.
@@ -16,6 +16,14 @@ Create a new FunctionalScript repository on GitHub [here](https://github.com/fun
 In FunctionalScript:
 
 - 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.
+- 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 a non FunctionalScript module.
+- It also has no standard library. Only a safe subset of standard JavaScript API can be used without referencing other modules.
+
+## Applications
+
+FunctionalScript code can be used
+
+- in any JavaScript/TypeScript application,
+- as a JSON with expressions,
+- as a query language.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.0.307",
+  "version": "0.0.311",
   "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 }
+}