functionalscript 0.0.173 → 0.0.174

package/btree/index.js

@@ -336,7 +336,7 @@ const values = node => ({
 const flatArray = (...array) => list.flat(list.fromArray(array))
 
 /** @type {<T>(node: Node<T>) => list.List<T>} */
-const valuesList = node => {
+const valuesList = node => () => {
     const f = () => {
         switch (node.length) {
             case 1: case 2: { return list.fromArray(node) }
@@ -358,7 +358,7 @@ const valuesList = node => {
             }
         }
     }
-    return f()
+    return f()()
 }
 
 module.exports = {

package/btree/test.js

@@ -23,7 +23,8 @@ const test = () => {
         /** @type {import('../sequence/list').Result<string>} */
         let result = valuesList(node)()
         while (result !== undefined) {
-            console.log(result[0])
+            const t = result[0]
+            console.log(t)
             result = result[1]()
         }
     }

package/package.json

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

package/sequence/array/index.js

@@ -85,8 +85,8 @@ const splitLast = a => {
     return option.map(split)(last(a))
 }
 
-/** @type {<T>(a: Array<T>) => (index: number) => readonly[T]|undefined} */
-const at = a => index => index < a.length ? [a[index]] : undefined
+/** @type {(index: number) => <T>(a: Array<T>) => readonly[T]|undefined} */
+const at = index => a => index < a.length ? [a[index]] : undefined
 
 module.exports = {
     /** @readonly */

package/sequence/asyncIterable/index.js

@@ -56,12 +56,12 @@ const scan = s => c => ({
 })
 
 /** @type {<T, R>(s: seq.InclusiveScan<T, R>) => (c: AsyncOrSyncIterable<T>) => AsyncIterable<R>} */
-const inclusiveScan = s => c => concat([s.first])(scan(s.scan)(c))
+const inclusiveScan = ([first, s]) => c => concat([first])(scan(s)(c))
 
 /** @type {<T, R>(is: seq.InclusiveScan<T, R>) => (c: AsyncOrSyncIterable<T>) => Promise<R>} */
-const reduce = is => async c => {
-    let next = is.first
-    for await (const i of scan(is.scan)(c)) {
+const reduce = ([first, s]) => async c => {
+    let next = first
+    for await (const i of scan(s)(c)) {
         next = i
     }
     return next
@@ -71,7 +71,7 @@ const sum = reduce(seq.sum)
 
 const join = pipe(seq.join)(reduce)
 
-const size = reduce(seq.size)
+const length = reduce(seq.length)
 
 /** @type {<T>(f: (value: T) => boolean) => (c: AsyncOrSyncIterable<T>) => AsyncIterable<T>} */
 const takeWhile = f => c => ({
@@ -99,7 +99,7 @@ module.exports = {
     /** @readonly */
     sum,
     /** @readonly */
-    size,
+    length,
     /** @readonly */
     join,
     /** @readonly */

package/sequence/index.js

@@ -22,10 +22,7 @@ const { id } = require('../function')
 /**
  * @template T
  * @template R
- * @typedef {{
- *  readonly scan: Scan<T, R>
- *  readonly first: R
- * }} InclusiveScan
+ * @typedef {Tuple2<R, Scan<T, R>>} InclusiveScan
  */
 
 /** @type {<R, T>(operator: op.BinaryOperator<R, T>) => (prior: R) => Scan<T, R>} */
@@ -42,10 +39,7 @@ const scan = operator => {
 } 
 
 /** @type {<R, T>(operator: op.BinaryOperator<R, T>) => (first: R) => InclusiveScan<T, R>} */
-const inclusiveScan = operator => first => ({
-    scan: scan(operator)(first),
-    first,
-})
+const inclusiveScan = operator => first => [first, scan(operator)(first)]
 
 /** 
  * @template T
@@ -58,14 +52,11 @@ const createEntries = index => value => [[index, value], createEntries(index + 1
 const entries = createEntries(0)
 
 /** @type {(separator: string) => InclusiveScan<string, string>} */
-const join = separator => ({
-    scan: value => [value, scan(op.join(separator))(value)],
-    first: ''
-})
+const join = separator => ['', value => [value, scan(op.join(separator))(value)]]
 
 const sum = inclusiveScan(op.addition)(0)
 
-const size = inclusiveScan(a => () => a + 1)(0)
+const length = inclusiveScan(a => () => a + 1)(0)
 
 /**
  * @template T
@@ -89,7 +80,7 @@ module.exports = {
     /** @readonly */
     sum,
     /** @readonly */
-    size,
+    length,
     /** @readonly */
     entries,
     /** @readonly */

package/sequence/iterable/index.js

@@ -22,12 +22,12 @@ const scan = s => c => ({
 })
 
 /** @type {<T, R>(s: seq.InclusiveScan<T, R>) => (c: Iterable<T>) => Iterable<R>} */
-const inclusiveScan = s => c => concat([s.first])(scan(s.scan)(c))
+const inclusiveScan = ([first, s]) => c => concat([first])(scan(s)(c))
 
 /** @type {<T, R>(s: seq.InclusiveScan<T, R>) => (c: Iterable<T>) => R} */
-const reduce = s => c => {
-    let next = s.first
-    for (const i of scan(s.scan)(c)) {
+const reduce = ([first, s]) => c => {
+    let next = first
+    for (const i of scan(s)(c)) {
         next = i
     }
     return next
@@ -37,7 +37,7 @@ const entries = scan(seq.entries)
 
 const sum = reduce(seq.sum)
 
-const size = reduce(seq.size)
+const length = reduce(seq.length)
 
 const join = pipe(seq.join)(reduce)
 
@@ -87,7 +87,7 @@ module.exports = {
     /** @readonly */
     sum,
     /** @readonly */
-    size,
+    length,
     /** @readonly */
     entries,
     /** @readonly */

package/sequence/list/index.js

@@ -1,5 +1,7 @@
 const array = require('../array')
 const option = require('../../option')
+const base = require('..')
+const { pipe } = require('../../function')
 
 /**
  * @template T
@@ -21,10 +23,10 @@ const empty = () => undefined
 /**
  * @template T
  * @template R
- * @typedef {(list: List<T>) => List<R>} Map
+ * @typedef {(list: List<T>) => List<R>} ListMap
  */
 
-/** @type {<T>(first: T) => Map<T, T>} */
+/** @type {<T>(first: T) => ListMap<T, T>} */
 const list = first => tail => () => [first, tail]
 
 /** @type {<T>(first: T) => List<T>} */
@@ -34,43 +36,89 @@ const one = first => list(first)(empty)
 const fromArray = a => {
     /** @typedef {typeof a extends array.Array<infer T> ? T : never} T */
     /** @type {(index: number) => List<T>} */
-    const listFrom = index => {
+    const at = index => {
         /** @type {(value: readonly [T]) => Result<T>} */
-        const result = ([value]) => list(value)(listFrom(index + 1))()
-        return () => option.map(result)(array.at(a)(index))
+        const result = ([value]) => list(value)(at(index + 1))()
+        return () => option.map(result)(array.at(index)(a))
     }
-    return listFrom(0)
+    return at(0)
 }
 
-/** @type {<T>(list0: List<T>) => Map<T, T>} */
-const concat = list0 => list1 => () => {
-    /** @typedef {typeof list0 extends List<infer T> ? T : never} T */
+/** @type {<T>(list0: List<T>) => ListMap<T, T>} */
+const concat = a => b => () => {
+    /** @typedef {typeof a extends List<infer T> ? T : never} T */
     /** @type {(firstAntTail: FirstAndTail<T>) => Result<T>} */
-    const result = ([first, tail]) => [first, concat(tail)(list1)]
-    return option.map(result)(list0())
+    const defined = ([first, tail]) => [first, concat(tail)(b)]
+    return option.match(defined)(b)(a())
 }
 
-/** @type {<T, R>(f: (value: T) => List<R>) => Map<T, R>} */
+/** @type {<T, R>(f: (value: T) => List<R>) => ListMap<T, R>} */
 const flatMap = f => {
     /** @typedef {typeof f extends (value: infer T) => List<infer R> ? [T, R] : never} TR */
     /** @typedef {TR[0]} T */
     /** @typedef {TR[1]} R */
     /** @type {(firstAntTail: FirstAndTail<T>) => Result<R>} */
-    const result = ([first, tail]) => concat(f(first))(map(tail))()
+    const defined = ([first, tail]) => concat(f(first))(listMap(tail))()
     /** @type {(list: List<T>) => List<R>} */
-    const map = list => () => option.map(result)(list())
-    return map
+    const listMap = list => () => option.map(defined)(list())
+    return listMap
 }
 
 /** @type {<T>(list: List<List<T>>) => List<T>} */
 const flat = flatMap(i => i)
 
-/** @type {<T, R>(f: (value: T) => R) => Map<T, R>} */
+/** @type {<T, R>(f: (value: T) => R) => ListMap<T, R>} */
 const map = f => flatMap(i => one(f(i)))
 
-/** @type {<T>(f: (value: T) => boolean) => Map<T, T>} */
+/** @type {<T>(f: (value: T) => boolean) => ListMap<T, T>} */
 const filter = f => flatMap(i => f(i) ? one(i) : empty)
 
+/** @type {<T, R>(s: base.Scan<T, R>) => ListMap<T, R>} */
+const scan = s => input => () => {
+    /** @typedef {typeof s extends base.Scan<infer T, infer R> ? [T, R] : never} TR */
+    /** @typedef {TR[0]} T */
+    /** @typedef {TR[1]} R */
+    /** @type {(firstAndTail: FirstAndTail<T>) => Result<R>} */
+    const defined = ([first, tail]) => {
+        const [newFirst, newS] = s(first)
+        return [newFirst, scan(newS)(tail)]
+    }
+    return option.map(defined)(input())
+}
+
+/** @type {<T, R>(s: base.InclusiveScan<T, R>) => ListMap<T, R>} */
+const inclusiveScan = ([first, s]) => input => list(first)(scan(s)(input))
+
+/** @type {<T>(def: T) => (input: List<T>) => T} */
+const last = def => input => {
+    let i = input()
+    let r = def
+    while (i !== undefined) {
+        r = i[0]
+        i = i[1]()
+    }
+    return r
+}
+
+/** @type {<T, R>(s: base.InclusiveScan<T, R>) => (input: List<T>) => R} */
+const reduce = s => input => last(s[0])(inclusiveScan(s)(input))
+
+const entries = scan(base.entries)
+
+const sum = reduce(base.sum)
+
+const length = reduce(base.length)
+
+const join = pipe(base.join)(reduce)
+
+/** @type {<T>(f: (value: T) => boolean) => (input: List<T>) => T|undefined} */
+const find = f => input => {
+    /** @typedef {typeof f extends (value: infer T) => boolean ? T : never} T */
+    /** @type {(result: FirstAndTail<T>) => T} */
+    const defined = ([first]) => first
+    return option.map(defined)(filter(f)(input)())
+}
+
 /**
  * Note: probably, it's possible to implement using the `scan` concept.
  * @type {<T>(list: List<T>) => Iterable<T>} 
@@ -106,4 +154,22 @@ module.exports = {
     map,
     /** @readonly */
     filter,
+    /** @readonly */
+    scan,
+    /** @readonly */
+    inclusiveScan,
+    /** @readonly */
+    last,
+    /** @readonly */
+    reduce,
+    /** @readonly */
+    entries,
+    /** @readonly */
+    sum,
+    /** @readonly */
+    join,
+    /** @readonly */
+    length,
+    /** @readonly */
+    find,
 }

package/sequence/list/test.js

@@ -0,0 +1,24 @@
+const list = require('.')
+const { sum } = require('..')
+
+/** @type {<T>(l: list.List<T>) => void} */
+const print = a => {
+    let i = a()
+    while (i !== undefined) {
+        console.log(i[0])
+        i = i[1]()
+    }
+}
+
+{
+    const big = list.fromArray([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 42, 60])
+    print(big)
+    /*
+    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)
+    print(list3)
+    const r = list.find(x => x === 42)(list.fromArray([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 42, 60]))
+    */
+}

package/test.js

@@ -1,5 +1,6 @@
 const i = require('./')
 
+require('./sequence/list/test')
 require('./btree/test')
 require('./sequence/iterable/test')
 require('./sequence/asyncIterable/test')