functionalscript 0.0.182 → 0.0.185

package/function/operator/index.js

@@ -1,18 +1,41 @@
+/**
+ * @template A
+ * @template B
+ * @template R
+ * @typedef {(a: A) => (b: B) => R} BinaryOperator
+ */
+
 /**
  * @template R
  * @template T
- * @typedef {(prior: R) => (value: T) => R} BinaryOperator
+ * @typedef {BinaryOperator<R, T, R>} ReduceOperator
  */
 
-/** @type {(separator: string) => BinaryOperator<string, string>} */
+/** @type {(separator: string) => ReduceOperator<string, string>} */
 const join = separator => prior => value => `${prior}${separator}${value}`
 
 /** @type {(sum: number) => (value: number) => number} */
 const addition = a => b => a + b
 
+/**
+ * @template T
+ * @template R
+ * @typedef {(value: T) => R} UnaryOperator
+ */
+
+/** @type {(value: boolean) => boolean} */
+const logicalNot = v => !v
+
+/** @type {<T>(a: T) => (b: T) => boolean} */
+const strictEqual = a => b => a === b
+
 module.exports = {
     /** @readonly */
     join,
     /** @readonly */
     addition,
+    /** @readonly */
+    strictEqual,
+    /** @readonly */
+    logicalNot,
 }

package/map/index.js

@@ -1,6 +1,7 @@
 const option = require("../option")
-const { getVisitor, setVisitor, values } = require("../btree")
+const { getVisitor, setVisitor, valuesList } = require("../btree")
 const { cmp } = require("../cmp")
+const list = require("../sequence/list")
 
 /** @typedef {import("../cmp").Sign} Sign */
 
@@ -29,7 +30,7 @@ const { cmp } = require("../cmp")
  * @typedef {{
  *  readonly get: (name: string) => T|undefined
  *  readonly set: (name: string) => (value: T) => Map<T> 
- *  readonly entries: () => Iterable<Entry<T>>
+ *  readonly entries: list.List<Entry<T>>
  *  readonly root: undefined|TNode<Entry<T>>
  * }} Map
  */
@@ -46,7 +47,7 @@ const create = root => ({
         if ('overflow' in result) { return create(result.overflow) }
         throw ''
     },
-    entries: () => values(root),
+    entries: valuesList(root),
     root,
 })
 
@@ -54,14 +55,14 @@ const create = root => ({
  * @type {{
  *  readonly get: (name: string) => undefined
  *  readonly set: (name: string) => <T>(value: T) => Map<T>
- *  readonly entries: () => readonly []
+ *  readonly entries: () => undefined
  *  readonly root: undefined
  * }} 
  */
 const empty = {
     get: () => undefined,
     set: name => value => create([[name, value]]),
-    entries: () => [],
+    entries: list.empty,
     root: undefined
 }
 

package/map/test.js

@@ -1,4 +1,5 @@
 const { empty } = require('.')
+const list = require('../sequence/list')
 
 {
     let m = empty.set('a')(1)
@@ -44,7 +45,7 @@ const { empty } = require('.')
     if (m.get('x') !== 12) { throw 'error' }
     if (m.get('y') !== 44) { throw 'error' }
     if (m.get('a') !== undefined) { throw 'error' }
-    const entries = Array.from(m.entries())
+    const entries = Array.from(list.iterable(m.entries))
     if (entries.length !== 2) { throw 'error' }
 }
 

package/module-manager/index.js

@@ -39,8 +39,8 @@ const seq = require('../sequence')
 
 /** @typedef {(_: string) => undefined|Package|Dependencies} Dependencies */
 
-/** @type {seq.InclusiveScan<string, undefined|Path>} */
-const pathNormReduce = seq.inclusiveScan
+/** @type {seq.ExclusiveScan<string, undefined|Path>} */
+const pathNormReduce = seq.exclusiveScan
     (path => item =>
         path === undefined ?
             undefined :

package/package.json

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

package/sequence/asyncIterable/index.js

@@ -55,10 +55,10 @@ const scan = s => c => ({
     }
 })
 
-/** @type {<T, R>(s: seq.InclusiveScan<T, R>) => (c: AsyncOrSyncIterable<T>) => AsyncIterable<R>} */
-const inclusiveScan = ([first, s]) => c => concat([first])(scan(s)(c))
+/** @type {<T, R>(s: seq.ExclusiveScan<T, R>) => (c: AsyncOrSyncIterable<T>) => AsyncIterable<R>} */
+const exclusiveScan = ([first, s]) => c => concat([first])(scan(s)(c))
 
-/** @type {<T, R>(is: seq.InclusiveScan<T, R>) => (c: AsyncOrSyncIterable<T>) => Promise<R>} */
+/** @type {<T, R>(is: seq.ExclusiveScan<T, R>) => (c: AsyncOrSyncIterable<T>) => Promise<R>} */
 const reduce = ([first, s]) => async c => {
     let next = first
     for await (const i of scan(s)(c)) {
@@ -105,7 +105,7 @@ module.exports = {
     /** @readonly */
     scan,
     /** @readonly */
-    inclusiveScan,
+    exclusiveScan,
     /** @readonly */
     takeWhile,
 }

package/sequence/index.js

@@ -1,5 +1,4 @@
 const op = require('../function/operator')
-const { id } = require('../function')
 
 /**
  * @template T0
@@ -22,12 +21,12 @@ const { id } = require('../function')
 /**
  * @template T
  * @template R
- * @typedef {Tuple2<R, Scan<T, R>>} InclusiveScan
+ * @typedef {Tuple2<R, Scan<T, R>>} ExclusiveScan
  */
 
-/** @type {<R, T>(operator: op.BinaryOperator<R, T>) => (prior: R) => Scan<T, R>} */
+/** @type {<R, T>(operator: op.ReduceOperator<R, T>) => (prior: R) => Scan<T, R>} */
 const scan = operator => {
-    /** @typedef {typeof operator extends op.BinaryOperator<infer R, infer T> ? [R, T] : never} RT */
+    /** @typedef {typeof operator extends op.ReduceOperator<infer R, infer T> ? [R, T] : never} RT */
     /** @typedef {RT[0]} R */
     /** @typedef {RT[1]} T */
     /** @type {(prior: R) => Scan<T, R>} */
@@ -38,8 +37,8 @@ const scan = operator => {
     return f
 } 
 
-/** @type {<R, T>(operator: op.BinaryOperator<R, T>) => (first: R) => InclusiveScan<T, R>} */
-const inclusiveScan = operator => first => [first, scan(operator)(first)]
+/** @type {<R, T>(operator: op.ReduceOperator<R, T>) => (first: R) => ExclusiveScan<T, R>} */
+const exclusiveScan = operator => first => [first, scan(operator)(first)]
 
 /** 
  * @template T
@@ -51,15 +50,15 @@ const createEntries = index => value => [[index, value], createEntries(index + 1
 
 const entries = createEntries(0)
 
-/** @type {(separator: string) => InclusiveScan<string, string>} */
+/** @type {(separator: string) => ExclusiveScan<string, string>} */
 const join = separator => ['', value => [value, scan(op.join(separator))(value)]]
 
-const sum = inclusiveScan(op.addition)(0)
+const sum = exclusiveScan(op.addition)(0)
 
 /** @type {(a: number) => () => number} */
 const counter = a => () => a + 1
 
-const length = inclusiveScan(counter)(0)
+const length = exclusiveScan(counter)(0)
 
 /**
  * @template T
@@ -75,7 +74,7 @@ const filter = flatMap => f => flatMap(x => f(x) ? [x] : [])
 
 module.exports = {
     /** @readonly */
-    inclusiveScan,
+    exclusiveScan,
     /** @readonly */
     scan,
     /** @readonly */

package/sequence/iterable/index.js

@@ -21,10 +21,10 @@ const scan = s => c => ({
     }
 })
 
-/** @type {<T, R>(s: seq.InclusiveScan<T, R>) => (c: Iterable<T>) => Iterable<R>} */
-const inclusiveScan = ([first, s]) => c => concat([first])(scan(s)(c))
+/** @type {<T, R>(s: seq.ExclusiveScan<T, R>) => (c: Iterable<T>) => Iterable<R>} */
+const exclusiveScan = ([first, s]) => c => concat([first])(scan(s)(c))
 
-/** @type {<T, R>(s: seq.InclusiveScan<T, R>) => (c: Iterable<T>) => R} */
+/** @type {<T, R>(s: seq.ExclusiveScan<T, R>) => (c: Iterable<T>) => R} */
 const reduce = ([first, s]) => c => {
     let next = first
     for (const i of scan(s)(c)) {
@@ -93,7 +93,7 @@ module.exports = {
     /** @readonly */
     scan,
     /** @readonly */
-    inclusiveScan,
+    exclusiveScan,
     /** @readonly */
     flatMap,
     /** @readonly */

package/sequence/list/index.js

@@ -1,8 +1,7 @@
 const array = require('../array')
-const option = require('../../option')
 const base = require('..')
 const { pipe } = require('../../function')
-const { todo } = require('../../dev')
+const { logicalNot, strictEqual } = require('../../function/operator')
 
 /**
  * @template T
@@ -15,13 +14,12 @@ const { todo } = require('../../dev')
  */
 
 /**
+ * Use `next` function to get `first` and `tail` of the list.
+ * 
  * Please note that the list also contains `Concat<T>. We need this as 
  * a workaround because modern JavaScript implementations don't support 
- * ES6 TCO (Tail Call Optimization).
- *
- * Without this wotkaround we may have a stack overflow if a list
- * contains a lot of concateneted lists. Use `next` function to extract 
- * a list. 
+ * ES6 TCO (Tail Call Optimization). Without this wotkaround we may have 
+ * a stack overflow if a list contains a lot of concateneted lists. 
  *
  * @template T
  * @typedef { ListFunc<T> | Concat<T>} List
@@ -60,12 +58,25 @@ const next = list => {
     }
 }
 
+/** @type {<T>(list: List<T>) => T|undefined} */
+const first = list => {
+    const result = next(list)
+    if (result === undefined) { return undefined }
+    return result[0]
+}
+
 /**
  * @template T
  * @template R
  * @typedef {(list: List<T>) => List<R>} ListMap
  */
 
+/**
+ * @template T
+ * @template R
+ * @typedef {(list: List<T>) => R} ListReduce
+ */
+
 /** @type {<T>(first: T) => List<T>} */
 const one = first => () => [first, empty]
 
@@ -109,6 +120,16 @@ const map = f => flatMap(i => one(f(i)))
 /** @type {<T>(f: (value: T) => boolean) => ListMap<T, T>} */
 const filter = f => flatMap(i => f(i) ? one(i) : empty)
 
+/** @type {<T, R>(f: (value: T) => R|undefined) => (value: T) => List<R>} */
+const filterMapFunc = f => i => {
+    const result = f(i)
+    if (result === undefined) { return empty }
+    return one(result)
+}
+
+/** @type {<T, R>(f: (value: T) => R|undefined) => ListMap<T, R>} */
+const filterMap = f => flatMap(filterMapFunc(f)) 
+
 /** @type {<T, R>(s: base.Scan<T, R>) => ListMap<T, R>} */
 const scan = s => input => () => {
     const result = next(input)
@@ -120,8 +141,8 @@ const scan = s => input => () => {
     return [newFirst, scan(newS)(tail)]
 }
 
-/** @type {<T, R>(s: base.InclusiveScan<T, R>) => ListMap<T, R>} */
-const inclusiveScan = ([first, s]) => input => () => [first, scan(s)(input)]
+/** @type {<T, R>(s: base.ExclusiveScan<T, R>) => ListMap<T, R>} */
+const exclusiveScan = ([first, s]) => input => () => [first, scan(s)(input)]
 
 /** @type {<T>(def: T) => (input: List<T>) => T} */
 const last = def => input => {
@@ -135,10 +156,9 @@ const last = def => input => {
         r = result[0]
         i = result[1]
     }
-    return r
 }
 
-/** @type {<T, R>(s: base.InclusiveScan<T, R>) => (input: List<T>) => R} */
+/** @type {<T, R>(s: base.ExclusiveScan<T, R>) => (input: List<T>) => R} */
 const reduce = ([first, s]) => input => last(first)(scan(s)(input))
 
 const entries = scan(base.entries)
@@ -156,17 +176,34 @@ const takeWhile = f => input => () => {
     return result
 }
 
-/** @type {<T>(f: (value: T) => boolean) => (input: List<T>) => T|undefined} */
-const find = f => input => {
-    const result = next(filter(f)(input))
-    if (result === undefined) { return undefined }
-    return result[0]
+/** @type {(n: number) => <T>(input: List<T>) => List<T>} */
+const drop = n => input => () => {
+    let iN = n
+    let iInput = input
+    while (true) {
+        const result = next(iInput)
+        if (iN <= 0 || result === undefined) { return result }
+        iN = iN - 1
+        iInput = result[1]
+    }
 }
 
-/**
- * Note: probably, it's possible to implement using the `scan` concept.
- * @type {<T>(list: List<T>) => Iterable<T>} 
- */
+/** @type {(n: number) => <T>(input: List<T>) => T|undefined} */
+const at = n => input => first(drop(n)(input))
+
+/** @type {<T>(f: (value: T) => boolean) => ListReduce<T, T|undefined>} */
+const find = f => input => first(filter(f)(input))
+
+/** @type {<T>(f: (value: T) => boolean) => ListReduce<T, boolean>} */
+const some = f => input => find(x => x)(map(f)(input)) !== undefined
+
+/** @type {<T>(value: T) => ListReduce<T, boolean>} */
+const includes = value => some(strictEqual(value))
+
+/** @type {<T>(f: (value: T) => boolean) => ListReduce<T, boolean>} */
+const every = f => input => !some(pipe(f)(logicalNot))(input)
+
+/** @type {<T>(list: List<T>) => Iterable<T>} */
 const iterable = list => ({
     *[Symbol.iterator]() {
         let i = list
@@ -179,6 +216,31 @@ const iterable = list => ({
     }
 })
 
+/** @type {<T>(list: List<T>) => AsyncIterable<T>} */
+const asyncIterable = list => ({
+    async *[Symbol.asyncIterator]() {
+        let i = list
+        while (true) {
+            const result = next(i)
+            if (result === undefined) { return }
+            yield result[0]
+            i = result[1]
+        }
+    }
+})
+
+/** @type {<A>(a: List<A>) => <B>(b: List<B>) => List<array.Tuple2<A, B>>} */
+const zip = a => b => () => {
+    const resultA = next(a)
+    if (resultA === undefined) { return undefined }
+    const resultB = next(b)
+    if (resultB === undefined) { return undefined }
+    return [[resultA[0], resultB[0]], zip(resultA[1])(resultB[1])]
+}
+
+/** @type {<T>(list: List<T>) => readonly T[]} */
+const toArray = input => Array.from(iterable(input))
+
 module.exports = {
     /** @readonly */
     next,
@@ -187,12 +249,20 @@ module.exports = {
     /** @readonly */
     empty,
     /** @readonly */
+    at,
+    /** @readonly */
     concat,
     /** @readonly */
+    first,
+    /** @readonly */
     fromArray,
     /** @readonly */
+    toArray,
+    /** @readonly */
     iterable,
     /** @readonly */
+    asyncIterable,
+    /** @readonly */
     flatMap,
     /** @readonly */
     flat,
@@ -201,9 +271,11 @@ module.exports = {
     /** @readonly */
     filter,
     /** @readonly */
+    filterMap,
+    /** @readonly */
     scan,
     /** @readonly */
-    inclusiveScan,
+    exclusiveScan,
     /** @readonly */
     last,
     /** @readonly */
@@ -217,7 +289,17 @@ module.exports = {
     /** @readonly */
     length,
     /** @readonly */
+    drop,
+    /** @readonly */
     find,
     /** @readonly */
     takeWhile,
+    /** @readonly */
+    some,
+    /** @readonly */
+    every,
+    /** @readonly */
+    includes,
+    /** @readonly */
+    zip,
 }

package/sequence/list/test.js

@@ -7,7 +7,7 @@ const print = a => {
     while (true) {
         const result = list.next(i)
         if (result === undefined) { return }
-        console.log(result[0])
+        // console.log(result[0])
         i = result[1]
     }
 }
@@ -17,15 +17,20 @@ const print = a => {
     const list0 = list.fromArray([0, 1, 2, 3])
     const list1 = list.flatMap(x => list.fromArray([x, x * 2, x * 3]))(list0)
     const list2 = list.concat(list0)(list0)
-    const list3 = list.inclusiveScan(sum)(list0)
+    const list3 = list.exclusiveScan(sum)(list0)
     const r = list.find(x => x === 42)(big)
+    if (list.every(x => x > 0)(big) !== true) { throw 'x'}
+    if (list.every(x => x < 20)(big) !== false) { throw 'x' }
+    if (list.some(x => x > 100)(big) !== false) { throw 'x' }
+    if (list.some(x => x > 50)(big) !== true) { throw 'x' }
+    if (list.first(list.drop(16)(big)) !== 42) { throw 'drop'}
     {
         let x = big
         for (let i = 0; i < 1_000_000; ++i) {
             x = list.concat(list.empty)(x)
         }
         const r = list.next(x)
-        print(x)
+        // print(x)
     } 
     {
         let x = big