functionalscript 0.0.306 → 0.0.310

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/commonjs/path/index.js

@@ -21,18 +21,18 @@ const split = path => path.split('/')
 /** @typedef {readonly[list.List<string>] | undefined} OptionList */
 
 /** @type {(s: OptionList) => (items: string) => OptionList} */
-const normItemsOp = prior => item => {
+const normItemsOp = prior => first => {
     if (prior === undefined) { return undefined }
-    const priorList = prior[0]
-    switch (item) {
+    const tail = prior[0]
+    switch (first) {
         case '': case '.': { return prior }
         case '..': {
-            const result = list.next(priorList)
+            const result = list.next(tail)
             if (result === undefined) { return undefined }
             return [result.tail]
         }
         default: {
-            return [list.nonEmpty(item)(priorList)]
+            return [{ first, tail }]
         }
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.0.306",
+  "version": "0.0.310",
   "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/list/index.js

@@ -44,14 +44,13 @@ const { logicalNot, strictEqual, stateScanToScan, reduceToScan, foldToScan } = r
  * }} Concat
  */
 
-/** @type {<T>(first: T) => (tail: List<T>) => NonEmpty<T>} */
-const nonEmpty = first => tail => ({ first, tail })
-
-/** @type {(i: number) => <T>(array: readonly T[]) => Result<T>} */
-const fromArrayAt = i => array => i < array.length ? nonEmpty(array[i])(() => fromArrayAt(i + 1)(array)) : undefined
-
 /** @type {<T>(array: readonly T[]) => Result<T>} */
-const fromArray = fromArrayAt(0)
+const fromArray = array => {
+    /** @typedef {typeof array extends readonly (infer T)[] ? T : never} T */
+    /** @type {(i: number) => Result<T>} */
+    const at = i => i < array.length ? { first: array[i], tail: () => at(i + 1) } : undefined
+    return at(0)
+}
 
 /** @type {<T>(a: List<T>) => (b: List<T>) => List<T>} */
 const concat = a => b => b === undefined ? a : ({ isConcat: true, a, b })
@@ -78,7 +77,7 @@ const next = list => {
         }
 
         if (a !== undefined) {
-            return nonEmpty(a.first)(concat(a.tail)(b))
+            return { first: a.first, tail: concat(a.tail)(b) }
         }
 
         if (b === undefined) { return undefined }
@@ -120,7 +119,7 @@ const flatStep = n => concat(n.first)(flat(n.tail))
 const flat = apply(flatStep)
 
 /** @type {<I, O>(f: (value: I) => O) => (n: NonEmpty<I>) => List<O>} */
-const mapStep = f => n => nonEmpty(f(n.first))(map(f)(n.tail))
+const mapStep = f => n => ({ first: f(n.first), tail: map(f)(n.tail) })
 
 /** @type {<I, O>(f: (value: I) => O) => (input: List<I>) => List<O>} */
 const map = f => apply(mapStep(f))
@@ -131,7 +130,7 @@ const flatMap = f => compose(map(f))(flat)
 /** @type {<T>(f: (value: T) => boolean) => (n: NonEmpty<T>) => List<T>} */
 const filterStep = f => n => {
     const tail = filter(f)(n.tail)
-    return f(n.first) ? nonEmpty(n.first)(tail) : tail
+    return f(n.first) ? { first: n.first, tail } : tail
 }
 
 /** @type {<T>(f: (value: T) => boolean) => (input: List<T>) => List<T>} */
@@ -140,20 +139,20 @@ const filter = f => apply(filterStep(f))
 /** @type {<I, O>(f: (value: I) => O|undefined) => (n: NonEmpty<I>) => List<O>} */
 const filterMapStep = f => n => {
     const [first, tail] = [f(n.first), filterMap(f)(n.tail)]
-    return first === undefined ? tail : nonEmpty(first)(tail)
+    return first === undefined ? tail : { first, tail }
 }
 
 /** @type {<I, O>(f: (value: I) => O|undefined) => (input: List<I>) => List<O>} */
 const filterMap = f => apply(filterMapStep(f))
 
 /** @type {<T>(f: (value: T) => boolean) => (n: NonEmpty<T>) => List<T>} */
-const takeWhileStep = f => n => f(n.first) ? nonEmpty(n.first)(takeWhile(f)(n.tail)) : undefined
+const takeWhileStep = f => n => f(n.first) ? { first: n.first, tail: takeWhile(f)(n.tail) } : undefined
 
 /** @type {<T>(f: (value: T) => boolean) => (input: List<T>) => List<T>} */
 const takeWhile = f => apply(takeWhileStep(f))
 
 /** @type {(n: number) => <T>(result: NonEmpty<T>) => List<T>} */
-const takeStep = n => ne => 0 < n ? nonEmpty(ne.first)(take(n - 1)(ne.tail)) : undefined
+const takeStep = n => ne => 0 < n ? { first: ne.first, tail: take(n - 1)(ne.tail) } : undefined
 
 /** @type {(n: number) => <T>(input: List<T>) => List<T>} */
 const take = n => apply(takeStep(n))
@@ -177,10 +176,11 @@ const first = def => input => {
     return result.first
 }
 
-/** @type {<D>(def: D) => <T>(input: List<T>) => D|T} */
-const last = def => input => {
-    /** @typedef {typeof input extends List<infer T> ? T : never} T */
-    let i = nonEmpty(/** @type {(typeof def)|T} */(def))(input)
+/** @type {<D>(first: D) => <T>(tail: List<T>) => D|T} */
+const last = first => tail => {
+    /** @typedef {typeof tail extends List<infer T> ? T : never} T */
+    /** @type {NonEmpty<typeof first|T>} */
+    let i = { first, tail }
     while (true) {
         const result = next(i.tail)
         if (result === undefined) {
@@ -212,19 +212,19 @@ const includes = value => input => some(map(strictEqual(value))(input))
 const countdown = count => () => {
     if (count <= 0) { return undefined }
     const first = count - 1
-    return nonEmpty(first)(countdown(first))
+    return { first, tail: countdown(first) }
 }
 
 /** @type {<T>(list: List<T>) => List<T>} */
 const cycle = list => () => {
     const i = next(list)
-    return i === undefined ? undefined : nonEmpty(i.first)(concat(i.tail)(cycle(list)))
+    return i === undefined ? undefined : { first: i.first, tail: concat(i.tail)(cycle(list)) }
 }
 
 /** @type {<I, O>(op: operator.Scan<I, O>) => (ne: NonEmpty<I>) => List<O>} */
 const scanStep = op => ne => {
-    const [o, newOp] = op(ne.first)
-    return nonEmpty(o)(scan(newOp)(ne.tail))
+    const [first, newOp] = op(ne.first)
+    return { first, tail: scan(newOp)(ne.tail) }
 }
 
 /** @type {<I, O>(op: operator.Scan<I, O>) => (input: List<I>) => List<O>} */
@@ -263,13 +263,13 @@ const length = reduce(operator.counter)(0)
 const entryOperator = index => value => [[index, value], index + 1]
 
 /** @type {<T>(input: List<T>) => List<Entry<T>>} */
-const entries = (input) => {
+const entries = input => {
     /** @typedef {typeof input extends List<infer T> ? T : never} T */
     return stateScan(/** @type {operator.StateScan<T, Number, Entry<T>>} */(entryOperator))(0)(input)
 }
 
 /** @type {<T>(prior: List<T>) => (value: T) => List<T>} */
-const reverseOperator = prior => value => nonEmpty(value)(prior)
+const reverseOperator = tail => first => ({ first, tail })
 
 /** @type {<T>(input: List<T>) => List<T>} */
 const reverse = reduce(reverseOperator)(undefined)
@@ -283,15 +283,15 @@ const zip = a => b => () => {
     if (aResult === undefined) { return undefined }
     const bResult = next(b)
     if (bResult === undefined) { return undefined }
-    return nonEmpty(tuple2(aResult.first)(bResult.first))(zip(aResult.tail)(bResult.tail))
+    return { first: tuple2(aResult.first)(bResult.first), tail: zip(aResult.tail)(bResult.tail) }
 }
 
 /** @type {<T>(e: operator.Equal<T>) => (a: List<T>) => (b: List<T>) => List<boolean>} */
 const equalZip = e => a => b => () => {
     const [aResult, bResult] = [next(a), next(b)]
     return aResult === undefined || bResult === undefined
-        ? nonEmpty(aResult === bResult)(undefined)
-        : nonEmpty(e(aResult.first)(bResult.first))(equalZip(e)(aResult.tail)(bResult.tail))
+        ? { first: aResult === bResult, tail: undefined }
+        : { first: e(aResult.first)(bResult.first), tail: equalZip(e)(aResult.tail)(bResult.tail) }
 }
 
 /** @type {<T>(e: operator.Equal<T>) => (a: List<T>) => (b: List<T>) => boolean} */
@@ -299,24 +299,20 @@ const equal = e => a => b => every(equalZip(e)(a)(b))
 
 /** @type {(s: string) => List<number>} */
 const toCharCodes = s => {
-    /** @type {(i: number) => List<number>} */
-    const at = i => () => {
-        const r = s.charCodeAt(i)
-        if (isNaN(r)) { return undefined }
-        return { first: r, tail: at(i + 1) }
+    /** @type {(i: number) => Result<number>} */
+    const at = i => {
+        const first = s.charCodeAt(i)
+        return isNaN(first) ? undefined : { first, tail: () => at(i + 1) }
     }
     return at(0)
 }
 
-/** @type {(x: List<number>) => string} */
-const fromCharCodes = x => fold(operator.concat)('')(map(String.fromCharCode)(x))
+const fromCharCodes = compose(map(String.fromCharCode))(fold(operator.concat)(''))
 
 module.exports = {
     /** @readonly */
     empty: undefined,
     /** @readonly */
-    nonEmpty,
-    /** @readonly */
     concat,
     /** @readonly */
     next,

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 }
+}