functionalscript 0.0.191 → 0.0.194

package/cmp/index.js

@@ -18,8 +18,8 @@ const index3 = cmp => value => /** @type {Index3} */ (cmp(value) + 1)
 
 /** @type {<T>(cmp: Cmp<T>) => (v2: Array2<T>) => Index5} */
 const index5 = cmp => ([v0, v1]) => {
-    const i = cmp(v0)
-    return /** @type {Index5} */ (i <= 0 ? i + 1 : cmp(v1) + 3)
+    const cmpV0 = cmp(v0)
+    return /** @type {Index5} */ (cmpV0 <= 0 ? cmpV0 + 1 : cmp(v1) + 3)
 }
 
 /** @type {(a: string) => (b: string) => Sign} */

package/function/index.js

@@ -7,9 +7,6 @@
 /** @type {<X, O>(f: Func<X, O>) => <I>(g: Func<I, X>) => Func<I, O>} */
 const combine = f => g => x => f(g(x))
 
-/** @type {<I, X>(g: Func<I, X>) => <O>(g: Func<X, O>) => Func<I, O>} */
-const pipe = g => f => x => f(g(x))
-
 /** @type {<T>(value: T) => T} */
 const id = value => value
 
@@ -17,7 +14,5 @@ module.exports = {
     /** @readonly */
     id,
     /** @readonly */
-    pipe,
-    /** @readonly */
     combine,
 }

package/json/index.js

@@ -1,6 +1,7 @@
 const seq = require('../sequence')
 const map = require('../map')
 const op = require('../sequence/operator')
+const option = require('../option')
 
 /** 
  * @typedef {{
@@ -25,17 +26,25 @@ const addProperty = value => {
     return path => f(seq.fromArray(path))
 }
 
-/** @type {(kv: readonly[string, seq.Sequence<string>]) => seq.Sequence<string>} */
-const property = ([k, v]) => seq.concat(seq.list(JSON.stringify(k)), seq.list(':'), v)
+/** @type {(kv: readonly[string, Json]) => seq.Sequence<string>} */
+const property = ([k, v]) => seq.concat(
+    seq.list(JSON.stringify(k)), 
+    seq.list(':'), 
+    stringSequence(v))
+
+const comma = seq.list(',')
 
 /** @type {op.Scan<seq.Sequence<string>, seq.Sequence<string>>} */
-const commaValue = a => [seq.concat(seq.list(','), a), commaValue]
+const commaValue = a => [seq.concat(comma, a), commaValue]
 
 /** @type {op.Scan<seq.Sequence<string>, seq.Sequence<string>>} */
 const joinScan = value => [value, commaValue]
 
 /** @type {seq.SequenceMap<seq.Sequence<string>, string>} */
-const join = input => seq.flat(seq.scan(joinScan)(input))
+const join = input => {
+    const _0 = seq.scan(joinScan)(input)
+    return seq.flat(_0)
+}
 
 /** @type {(open: string) => (close: string) => (input: seq.Sequence<seq.Sequence<string>>) => seq.Sequence<string>} */
 const list = open => close => {
@@ -50,16 +59,23 @@ const arrayList = list('[')(']')
 
 /** @type {(object: Object) => seq.Sequence<string>} */
 const objectStringify = object => {
-    /** @type {map.Map<seq.Sequence<string>>} */
-    const m = seq.fold(m => ([k, v]) => m.set(k)(stringSeq(v)))(map.empty)(seq.fromArray(Object.entries(object)))
-    return objectList(seq.map(property)(m.entries))
+    const _0 = Object.entries(object)
+    const _1 = seq.fromArray(_0)
+    const _2 = map.fromEntries(_1)
+    const _3 = _2.entries
+    const _4 = seq.map(property)(_3)
+    return objectList(_4)
 }
 
 /** @type {(array: Array) => seq.Sequence<string>} */
-const arrayStringify = array => arrayList(seq.map(stringSeq)(seq.fromArray(array)))
+const arrayStringify = array => {
+    const _0 = seq.fromArray(array)
+    const _1 = seq.map(stringSequence)(_0)
+    return arrayList(_1)
+}
 
 /** @type {(value: Json) => seq.Sequence<string>} */
-const stringSeq = value => {
+const stringSequence = value => {
     const x = typeof value
     switch (typeof value) {
         case 'boolean': { return seq.list(value ? "true" : "false") }
@@ -79,7 +95,7 @@ const stringSeq = value => {
  *  
  * @type {(value: Json) => string} 
  */
-const stringify = value => seq.join('')(stringSeq(value))
+const stringify = value => seq.join('')(stringSequence(value))
 
 module.exports = {
     /** @readonly */

package/json/test.js

@@ -13,6 +13,8 @@ if (json.addProperty("Hello")([])({}) !== "Hello") { throw 'error' }
 }
 
 {
-    const x = json.stringify(json.addProperty("Hello")(['a', 'x'])({ a: { y: [24] }, c: [], b: 12 }))
-    if (x !== '{"a":{"x":"Hello","y":[24]},"b":12,"c":[]}') { throw x }
+    const _0 = { a: { y: [24] }, c: [], b: 12 }
+    const _1 = json.addProperty("Hello")(['a', 'x'])(_0)
+    const _2 = json.stringify(_1)
+    if (_2 !== '{"a":{"x":"Hello","y":[24]},"b":12,"c":[]}') { throw _2 }
 }

package/map/index.js

@@ -1,5 +1,5 @@
 const option = require("../option")
-const { getVisitor, setVisitor, values: valuesList } = require("../btree")
+const { getVisitor, setVisitor, values } = require("../btree")
 const { cmp } = require("../cmp")
 const seq = require("../sequence")
 const op = require("../sequence/operator")
@@ -48,7 +48,7 @@ const create = root => ({
         if ('overflow' in result) { return create(result.overflow) }
         throw ''
     },
-    entries: valuesList(root),
+    entries: values(root),
     root,
 })
 
@@ -67,8 +67,14 @@ const empty = {
     root: undefined
 }
 
+/** @type {<T>(map: Map<T>) => (entry: Entry<T>) => Map<T>} */
+const setOperator = map => ([k, v]) => map.set(k)(v)
+
 /** @type {<T>(entries: seq.Sequence<Entry<T>>) => Map<T>} */
-const fromEntries = seq.fold(map => entry => map.set(entry))(empty)
+const fromEntries = entries => {
+    /** @typedef {typeof entries extends seq.Sequence<Entry<infer T>> ? T : never} T */
+    return seq.fold(setOperator)(/** @type {Map<T>} */(empty))(entries)
+}
 
 module.exports = {
     /** @readonly */

package/module-manager/index.js

@@ -1,5 +1,5 @@
 const array = require('../sequence/array')
-const { pipe } = require('../function')
+const { combine } = require('../function')
 const option = require('../option')
 const { head, last, splitLast, splitFirst } = array
 const iter = require('../sequence/iterable')
@@ -88,9 +88,9 @@ const external = packages => {
     const defined = ([first, tail]) => externalOrInternal(packages(first))(tail)
     /** @type {(_: Path) => readonly [string, Path]|undefined} */
     const sf = splitFirst
-    return pipe
-        (sf)
+    return combine
         (option.map(defined))
+        (sf)        
 }
 
 /** @type {(_: Location) => (_: string) => Module|undefined} */

package/package.json

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

package/sequence/array/index.js

@@ -86,10 +86,9 @@ const head = a => a.length === 0 ? undefined : uncheckHead(a)
 
 /** @type {<T>(_: Array<T>) => readonly [Array<T>, T]|undefined} */
 const splitLast = a => {
-    /** @typedef {typeof a[0]} T*/
-    /** @type {(_: T) => readonly [Array<T>, T]} */
-    const split = x => [uncheckHead(a), x]
-    return option.map(split)(last(a))
+    const lastA = last(a)
+    if (lastA === undefined) { return undefined }
+    return [uncheckHead(a), lastA]
 }
 
 /** @type {(index: number) => <T>(a: Array<T>) => readonly[T]|undefined} */

package/sequence/asyncIterable/index.js

@@ -1,4 +1,4 @@
-const { pipe } = require('../../function')
+const { combine } = require('../../function')
 const seq = require('../operator')
 
 /**
@@ -69,7 +69,7 @@ const reduce = ([first, s]) => async c => {
 
 const sum = reduce(seq.sum)
 
-const join = pipe(seq.join)(reduce)
+const join = combine(reduce)(seq.join)
 
 const length = reduce(seq.length)
 

package/sequence/index.js

@@ -1,6 +1,6 @@
 const array = require('./array')
 const seqOp = require('./operator')
-const { pipe } = require('../function')
+const { combine } = require('../function')
 const op = require('../function/operator')
 const { logicalNot, strictEqual } = require('../function/operator')
 
@@ -202,7 +202,8 @@ const sum = reduce(seqOp.sum)
 
 const length = reduce(seqOp.length)
 
-const join = pipe(seqOp.join)(reduce)
+/** @type {(separator: string) => SequenceReduce<string, string>} */
+const join = separator => reduce(seqOp.join(separator))
 
 /** @type {<T>(f: (value: T) => boolean) => SequenceMap<T, T>} */
 const takeWhile = f => input => () => {
@@ -236,7 +237,7 @@ const some = f => input => find(x => x)(map(f)(input)) !== undefined
 const includes = value => some(strictEqual(value))
 
 /** @type {<T>(f: (value: T) => boolean) => SequenceReduce<T, boolean>} */
-const every = f => input => !some(pipe(f)(logicalNot))(input)
+const every = f => input => !some(combine(logicalNot)(f))(input)
 
 /** @type {<T>(list: Sequence<T>) => Iterable<T>} */
 const iterable = list => ({

package/sequence/iterable/index.js

@@ -1,4 +1,4 @@
-const { pipe } = require('../../function')
+const { combine } = require('../../function')
 const seq = require('../operator')
 
 /** @type {<T>(a: Iterable<T>) => (b: Iterable<T>) => Iterable<T>} */
@@ -39,7 +39,7 @@ const sum = reduce(seq.sum)
 
 const length = reduce(seq.length)
 
-const join = pipe(seq.join)(reduce)
+const join = combine(reduce)(seq.join)
 
 /** @type {<T, R>(f: (value: T) => Iterable<R>) => (c: Iterable<T>) => Iterable<R>} */
 const flatMap = f => c => ({

package/sequence/iterable/test.js

@@ -1,5 +1,5 @@
 const i = require('.')
-const { pipe } = require('../../function')
+const { combine } = require('../../function')
 
 {
     const r = i.sum([120, 300, 42])
@@ -33,9 +33,9 @@ const { pipe } = require('../../function')
     /** @type {(_: string) => string|undefined} */
     const file = _ => 'x'
     /** @type {(_: string) => string|undefined} */
-    const x = p => pipe
-        (i.map(x => file(x())))
+    const x = p => combine
         (i.find(x => x !== undefined))
+        (i.map(x => file(x())))        
         ([() => p, () => `${p}.js`, () => `${p}/index.js`])
     if (x('index.js') !== 'x') { throw 'error' }
 }