functionalscript 0.0.313 → 0.0.314

package/commonjs/path/index.js

@@ -20,8 +20,8 @@ const split = path => path.split('/')
 
 /** @typedef {readonly[list.List<string>] | undefined} OptionList */
 
-/** @type {(s: OptionList) => (items: string) => OptionList} */
-const normItemsOp = prior => first => {
+/** @type {(items: string) => (prior: OptionList) => OptionList} */
+const normItemsOp = first => prior => {
     if (prior === undefined) { return undefined }
     const tail = prior[0]
     switch (first) {

package/json/index.js

@@ -1,12 +1,12 @@
 const seq = require('../types/list')
 const object = require('../types/object')
-const array = require('../types/array')
 const op = require('../types/function/operator')
+const { compose } = require('../types/function')
 
-/** 
+/**
  * @typedef {{
  *  readonly [k in string]: Unknown
- * }} Object 
+ * }} Object
  */
 
 /** @typedef {readonly Unknown[]} Array */
@@ -22,7 +22,7 @@ const setProperty = value => {
         const srcObject = (src === undefined || src === null || typeof src !== 'object' || src instanceof Array) ? {} : src
         const { first, tail } = result
         return { ...srcObject, [first]: f(tail)(object.at(first)(srcObject)) }
-    }    
+    }
     return f
 }
 
@@ -45,7 +45,7 @@ const colon = [':']
 const comma = [',']
 
 /** @type {op.Fold<seq.List<string>>} */
-const joinOp = a => b => seq.flat([a, comma, b])
+const joinOp = b => prior => seq.flat([prior, comma, b])
 
 /** @type {(input: seq.List<seq.List<string>>) => seq.List<string>} */
 const join = seq.fold(joinOp)([])
@@ -76,19 +76,8 @@ const serialize = sort => {
         f(v)
     ])
     /** @type {(object: Object) => seq.List<string>} */
-    const objectSerialize = input => {
-        const entries = Object.entries(input)
-        const sortedEntries = sort(entries)
-        const _ = seq.toArray(sortedEntries)
-        const serializedEntries = seq.map(propertySerialize)(sortedEntries)
-        return objectList(serializedEntries)
-    }
-    /** @type {(input: Array) => seq.List<string>} */
-    const arraySerialize = input => {
-        const serializedEntries = seq.map(f)(input)
-        return arrayList(serializedEntries)
-    }
-    /** @type {(value: Unknown) => seq.List < string >} */
+    const objectSerialize = input => objectList(seq.map(propertySerialize)(sort(Object.entries(input))))
+    /** @type {(value: Unknown) => seq.List<string>} */
     const f = value => {
         switch (typeof value) {
             case 'boolean': { return boolSerialize(value) }
@@ -101,22 +90,21 @@ const serialize = sort => {
             }
         }
     }
+    /** @type {(input: Array) => seq.List<string>} */
+    const arraySerialize = compose(seq.map(f))(arrayList)
     return f
 }
 
 /**
- * The standard `JSON.stringify` rules determined by 
+ * The standard `JSON.stringify` rules determined by
  * https://262.ecma-international.org/6.0/#sec-ordinary-object-internal-methods-and-internal-slots-ownpropertykeys
- *  
+ *
  * @type {(mapEntries: MapEntries) => (value: Unknown) => string}
  */
-const stringify = sort => value => {
-    const _s = serialize(sort)(value)
-    return seq.join('')(_s)
-}
+const stringify = sort => compose(serialize(sort))(seq.join(''))
 
 /** @type {(value: string) => Unknown} */
-const parse = value => JSON.parse(value)
+const parse = JSON.parse
 
 /** @type {(value: Unknown) => value is Object} */
 const isObject = value => typeof value === 'object' && value !== null && !(value instanceof Array)

package/package.json

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

package/types/btree/remove/index.js

@@ -92,8 +92,8 @@ const initValue1 = a => n => {
  * @typedef {(a: A) => (n: _.Branch3<T>) => _.Branch1<T> | _.Branch3<T>} Merge
  */
 
-/** @type {<A, T>(ms: array.Array2<Merge<A, T>>) => (a: A) => (i: find.PathItem<T>) => Branch<T>} */
-const reduceX = ms => a => i => {
+/** @type {<A, T>(ms: array.Array2<Merge<A, T>>) => (i: find.PathItem<T>) => (a: A) => Branch<T>} */
+const reduceX = ms => i => a => {
     const [m0, m2] = ms
     /** @typedef {typeof ms extends array.Array2<Merge<infer A, infer T>> ? [A,T] : never} AT */
     /** @typedef {AT[0]} A */
@@ -155,7 +155,7 @@ const nodeRemove = c => node => {
     const tailR = list.next(tail)
     if (tailR === undefined) { return first }
     const { first: tf, tail: tt } = tailR
-    const result = reduce(initReduce(first)(tf))(tt)
+    const result = reduce(initReduce(tf)(first))(tt)
     return result.length === 1 ? result[0] : result
 }
 

package/types/btree/set/index.js

@@ -11,8 +11,8 @@ const list = require('../../list')
 /** @type {<T>(b: _.Branch5<T> | _.Branch7<T>) => Bracnh1To3<T>} */
 const b57 = b => b.length === 5 ? [b] : [[b[0], b[1], b[2]], b[3], [b[4], b[5], b[6]]]
 
-/** @type {<T>(a: Bracnh1To3<T>) => (i: find.PathItem<T>) => Bracnh1To3<T>} */
-const reduce = a => i => {
+/** @type {<T>(i: find.PathItem<T>) => (a: Bracnh1To3<T>) => Bracnh1To3<T>} */
+const reduce = i => a => {
     switch (i[0]) {
         case 0: {
             const x = i[1]

package/types/function/operator/index.js

@@ -7,18 +7,20 @@
 
 /**
  * @template I,O
- * @typedef {Binary<O, I, O>} Reduce
+ * @typedef {Binary<I, O, O>} Reduce
  */
 
 /** @type {(separator: string) => Fold<string>} */
-const join = separator => prior => value => `${prior}${separator}${value}`
+const join = separator => value => prior => `${prior}${separator}${value}`
 
 /** @type {Fold<string>} */
-const concat = a => b => `${a}${b}`
+const concat = i => acc => `${acc}${i}`
 
 /** @type {Fold<number>} */
 const addition = a => b => a + b
 
+const increment = addition(1)
+
 /**
  * @template T
  * @template R
@@ -60,7 +62,7 @@ const stateScanToScan = op => prior => i => {
 
 /** @type {<I, O>(reduce: Reduce<I, O>) => (prior: O) => Scan<I, O>} */
 const reduceToScan = reduce => prior => i => {
-    const result = reduce(prior)(i)
+    const result = reduce(i)(prior)
     return [result, reduceToScan(reduce)(result)]
 }
 
@@ -72,8 +74,7 @@ const reduceToScan = reduce => prior => i => {
 /** @type {<T>(fold: Fold<T>) => Scan<T, T>} */
 const foldToScan = op => init => [init, reduceToScan(op)(init)]
 
-/** @type {(a: number) => () => number} */
-const counter = a => () => a + 1
+const counter = () => increment
 
 module.exports = {
     /** @readonly */
@@ -81,6 +82,8 @@ module.exports = {
     /** @readonly */
     addition,
     /** @readonly */
+    increment,
+    /** @readonly */
     strictEqual,
     /** @readonly */
     logicalNot,

package/types/list/index.js

@@ -268,8 +268,8 @@ const entries = input => {
     return stateScan(/** @type {operator.StateScan<T, Number, Entry<T>>} */(entryOperator))(0)(input)
 }
 
-/** @type {<T>(prior: List<T>) => (value: T) => List<T>} */
-const reverseOperator = tail => first => ({ first, tail })
+/** @type {<T>(value: T) => (prior: List<T>) => List<T>} */
+const reverseOperator = first => tail => ({ first, tail })
 
 /** @type {<T>(input: List<T>) => List<T>} */
 const reverse = reduce(reverseOperator)(undefined)

package/types/map/index.js

@@ -6,7 +6,6 @@ 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 */
 
@@ -45,7 +44,7 @@ const set = name => value => setEntry([name, value])
 const entries = values
 
 /** @type {<T>(entries: list.List<Entry<T>>) => Map<T>} */
-const fromEntries = list.reduce(flip(setEntry))(undefined)
+const fromEntries = list.reduce(setEntry)(undefined)
 
 /** @type {(name: string) => <T>(map: Map<T>) => Map<T>} */
 const remove = name => btRemove.remove(keyCmp(name))

package/types/object/index.js

@@ -19,8 +19,11 @@ const at = name => object => Object.getOwnPropertyDescriptor(object, name)?.valu
 /** @type {<T>(entries: list.List<Entry<T>>) => list.List<Entry<T>>} */
 const sort = entries => map.entries(map.fromEntries(entries))
 
+/** @type {<T>(entries: list.List<Entry<T>>) => Map<T>} */
+const fromEntries = entries => Object.fromEntries(list.iterable(entries))
+
 /** @type {<T>(m: map.Map<T>) => Map<T>} */
-const fromMap = m => Object.fromEntries(list.iterable(map.entries(m)))
+const fromMap = m => fromEntries(map.entries(m))
 
 module.exports = {
     /** @readonly */
@@ -28,5 +31,7 @@ module.exports = {
     /** @readonly */
     sort,
     /** @readonly */
+    fromEntries,
+    /** @readonly */
     fromMap,
 }

package/types/stringSet/index.js

@@ -4,7 +4,7 @@ const btSet = require('../btree/set')
 const btRemove = require('../btree/remove')
 const { stringCmp } = require("../function/compare")
 const list = require('../list')
-const { flip, compose } = require('../function')
+const { compose } = require('../function')
 
 /** @typedef {btree.Tree<string>} StringSet */
 
@@ -17,7 +17,7 @@ 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)
+const fromValues = list.reduce(set)(undefined)
 
 /** @type {(value: string) => (s: StringSet) => StringSet} */
 const remove = compose(stringCmp)(btRemove.remove)