functionalscript 0.0.187 → 0.0.197

package/btree/index.js

@@ -305,28 +305,25 @@ const replaceVisitor = {
     notFound: notFoundGet,
 }
 
-/** @type {<T>(...array: readonly seq.Sequence<T>[]) => seq.Sequence<T>} */
-const flatArray = (...array) => seq.flat(seq.fromArray(array))
-
 /** @type {<T>(node: Node<T>) => seq.Sequence<T>} */
-const valuesList = node => () => {
+const values = node => () => {
     const f = () => {
         switch (node.length) {
-            case 1: case 2: { return seq.fromArray(node) }
+            case 1: case 2: { return seq.list(...node) }
             case 3: { 
-                return flatArray(
-                    valuesList(node[0]), 
-                    seq.one(node[1]), 
-                    valuesList(node[2])
+                return seq.concat(
+                    values(node[0]), 
+                    seq.list(node[1]), 
+                    values(node[2])
                 )
             }
             default: {
-                return flatArray(
-                    valuesList(node[0]),
-                    seq.one(node[1]),
-                    valuesList(node[2]),
-                    seq.one(node[3]),
-                    valuesList(node[4])
+                return seq.concat(
+                    values(node[0]),
+                    seq.list(node[1]),
+                    values(node[2]),
+                    seq.list(node[3]),
+                    values(node[4])
                 )
             }
         }
@@ -336,14 +333,14 @@ const valuesList = node => () => {
 
 module.exports = {
     /** @readonly */
-    valuesList,
+    values,
     /** 
      * @readonly
      * @type { <T>(cmp: Cmp<T>) => (node: Node<T>) => T|undefined }
      */
     getVisitor: cmp => node => {
-        const result = visit(getVisitor)(cmp)(() => { throw '' })(node)
-        if ('done' in result && result.done) { return result.value }
+        const _0 = visit(getVisitor)(cmp)(() => { throw '' })(node)
+        if ('done' in _0 && _0.done) { return _0.value }
         return undefined
     },
     /** @readonly */

package/btree/test.js

@@ -1,5 +1,5 @@
 const btree = require('.')
-const { setVisitor, valuesList } = btree
+const { setVisitor, values: valuesList } = btree
 const { cmp } = require('../cmp') 
 const list = require('../sequence')
 
@@ -13,18 +13,18 @@ const set = node => value => {
 
 const test = () => {
     /** @type {btree.Node<string>} */
-    let node = ['a']
-    node = set(node)('b')
-    node = set(node)('c')
-    node = set(node)('d')
-    node = set(node)('e')
-    node = set(node)('f')
+    let _map = ['a']
+    _map = set(_map)('b')
+    _map = set(_map)('c')
+    _map = set(_map)('d')
+    _map = set(_map)('e')
+    _map = set(_map)('f')
     //
     {
         /** @type {import('../sequence').Result<string>} */
-        let result = list.next(valuesList(node))
-        while (result !== undefined) {
-            result = list.next(result[1])
+        let _item = list.next(valuesList(_map))
+        while (_item !== undefined) {
+            _item = list.next(_item[1])
         }
     }
 }

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 _0 = cmp(v0)
+    return /** @type {Index5} */ (_0 <= 0 ? _0 + 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,7 +1,8 @@
 const seq = require('../sequence')
 const map = require('../map')
 const op = require('../sequence/operator')
-const { todo } = require('../dev')
+const option = require('../option')
+const array = require('../sequence/array')
 
 /** 
  * @typedef {{
@@ -23,62 +24,79 @@ const addProperty = value => {
         const [name, tail] = result
         return { ...srcObject, [name]: f(tail)(srcObject[name]) }
     }
-    return path => f(seq.fromArray(path))
+    return path => f(array.sequence(path))
 }
 
-/** @type {(kv: readonly[string, seq.Sequence<string>]) => seq.Sequence<string>} */
-const property = ([k, v]) => {
-    let r = seq.one(JSON.stringify(k))
-    r = seq.concat(r)(seq.one(':'))
-    return seq.concat(r)(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.one(','))(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>, seq.Sequence<string>>} */
-const join = seq.scan(joinScan)
+/** @type {seq.SequenceMap<seq.Sequence<string>, string>} */
+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 => {
+    const seqOpen = seq.list(open)
+    const seqClose = seq.list(close)
+    return input => seq.concat(seqOpen, join(input), seqClose)
+}
+
+const objectList = list('{')('}')
+
+const arrayList = list('[')(']')
 
 /** @type {(object: Object) => seq.Sequence<string>} */
 const objectStringify = object => {
-    /** @type {map.Map<seq.Sequence<string>>} */
-    let m = map.empty
-    for (const [k, v] of Object.entries(object)) {
-        m = m.set(k)(stringSeq(v))
-    }
-    const properties = join(seq.map(property)(m.entries))
-    const result = seq.concat(seq.one('{'))(seq.flat(properties))
-    return seq.concat(result)(seq.one('}'))
+    const _0 = Object.entries(object)
+    const _1 = array.sequence(_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 => {
-    let a = seq.flat(join(seq.map(stringSeq)(seq.fromArray(array))))
-    const s = seq.concat(seq.one('['))(a)    
-    return seq.concat(s)(seq.one(']'))
+/** @type {(input: Array) => seq.Sequence<string>} */
+const arrayStringify = input => {
+    const _0 = array.sequence(input)
+    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.one(value ? "true" : "false") }
+        case 'boolean': { return seq.list(value ? "true" : "false") }
         // Note: we shouldn't use JSON.stringify since it has non determenistic behavior.
         // In particular: property order could be different.
-        case 'number': case 'string': { return seq.one(JSON.stringify(value)) }
+        case 'number': case 'string': { return seq.list(JSON.stringify(value)) }
         default: {
-            if (value === null) { return seq.one("null") }
+            if (value === null) { return seq.list("null") }
             if (value instanceof Array) { return arrayStringify(value) }
             return objectStringify(value)
         }
     }
 }
 
-/** @type {(value: Json) => string} */
-const stringify = value => seq.join('')(stringSeq(value))
+/**
+ * A deterministic version of `JSON.stringify`
+ *  
+ * @type {(value: Json) => string} 
+ */
+const stringify = value => seq.join('')(stringSequence(value))
 
 module.exports = {
     /** @readonly */

package/json/test.js

@@ -11,3 +11,10 @@ if (json.addProperty("Hello")([])({}) !== "Hello") { throw 'error' }
     const x = json.stringify(json.addProperty("Hello")(['a'])({c:[],b:12}))
     if (x !== '{"a":"Hello","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,7 +1,8 @@
 const option = require("../option")
-const { getVisitor, setVisitor, valuesList } = require("../btree")
+const { getVisitor, setVisitor, values } = require("../btree")
 const { cmp } = require("../cmp")
-const list = require("../sequence")
+const seq = require("../sequence")
+const op = require("../sequence/operator")
 
 /** @typedef {import("../cmp").Sign} Sign */
 
@@ -30,7 +31,7 @@ const list = require("../sequence")
  * @typedef {{
  *  readonly get: (name: string) => T|undefined
  *  readonly set: (name: string) => (value: T) => Map<T> 
- *  readonly entries: list.Sequence<Entry<T>>
+ *  readonly entries: seq.Sequence<Entry<T>>
  *  readonly root: undefined|TNode<Entry<T>>
  * }} Map
  */
@@ -42,12 +43,12 @@ const keyCmp = a => ([b]) => cmp(a)(b)
 const create = root => ({
     get: name => option.map(([,value]) => value)(getVisitor(keyCmp(name))(root)),
     set: name => value => {
-        const result = setVisitor(keyCmp(name))(() => [name, value])(root)
-        if ('replace' in result) { return create(result.replace) }
-        if ('overflow' in result) { return create(result.overflow) }
+        const _0 = setVisitor(keyCmp(name))(() => [name, value])(root)
+        if ('replace' in _0) { return create(_0.replace) }
+        if ('overflow' in _0) { return create(_0.overflow) }
         throw ''
     },
-    entries: valuesList(root),
+    entries: values(root),
     root,
 })
 
@@ -62,11 +63,22 @@ const create = root => ({
 const empty = {
     get: () => undefined,
     set: name => value => create([[name, value]]),
-    entries: list.empty,
+    entries: seq.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 = 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 */
     empty,
+    /** @readonly */
+    fromEntries,
 }

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.187",
+  "version": "0.0.197",
   "description": "FunctionalScript is a functional subset of JavaScript",
   "main": "index.js",
   "scripts": {

package/sequence/array/index.js

@@ -1,4 +1,5 @@
 const option = require('../../option')
+const seq = require('..')
 
 /**
  * @template T
@@ -86,15 +87,26 @@ 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} */
 const at = index => a => index < a.length ? [a[index]] : undefined
 
+/** @type {<T>(array: Array<T>) => seq.Sequence<T>} */
+const sequence = a => {
+    /** @typedef {typeof a extends Array<infer T> ? T : never} T */
+    /** @type {(index: number) => seq.Sequence<T>} */
+    const seq = index => () => {
+        const result = at(index)(a)
+        if (result === undefined) { return undefined }
+        return [result[0], seq(index + 1)]
+    }
+    return seq(0)
+}
+
 module.exports = {
     /** @readonly */
     at,
@@ -110,4 +122,6 @@ module.exports = {
     splitFirst,
     /** @readonly */
     splitLast,
+    /** @readonly */
+    sequence,
 }

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')
 
 /**
@@ -32,7 +32,7 @@ const { logicalNot, strictEqual } = require('../function/operator')
 
 /**
  * @template T
- * @typedef {array.Tuple2<T, Sequence<T>>} FirstAndTail
+ * @typedef {readonly[T, Sequence<T>]} FirstAndTail
  */
 
 const empty = () => undefined
@@ -77,23 +77,43 @@ const first = input => {
  * @typedef {(list: Sequence<T>) => R} SequenceReduce
  */
 
-/** @type {<T>(first: T) => Sequence<T>} */
-const one = first => () => [first, empty]
+/** @type {<T>(...array: readonly T[]) => Sequence<T>} */
+const list = (...array) => {
+    /** @typedef {typeof array extends readonly(infer T)[] ? T : never} T */
+    let i = array.length
+    /** @type {Sequence<T>} */
+    let tail = empty
+    while (true) {
+        if (i === 0) { return tail }
+        i = i - 1
+        /** @type {FirstAndTail<T>} */
+        const result = [array[i], tail]
+        tail = () => result
+    }
+}
 
-/** @type {<T>(array: array.Array<T>) => Sequence<T>} */
-const fromArray = a => {
-    /** @typedef {typeof a extends array.Array<infer T> ? T : never} T */
-    /** @type {(index: number) => Sequence<T>} */
-    const at = index => () => {
-        const result = array.at(index)(a)
-        if (result === undefined) { return undefined }
-        return [result[0], at(index + 1)]
+/** @type {<T>(...array: readonly Sequence<T>[]) => Sequence<T>} */
+const concat = (...array) => {
+    let i = array.length
+    if (i == 0) { return empty }
+    i = i - 1
+    let tail = array[i]
+    while (true) {        
+        if (i === 0) { return tail }
+        i = i - 1
+        tail = [array[i], tail]
     }
-    return at(0)
 }
 
-/** @type {<T>(a: Sequence<T>) => SequenceMap<T, T>} */
-const concat = a => b => [a, b]
+/** @type {(_: number) => Sequence<number>} */
+const generate = n => {
+    /** @type {(_: number) => Sequence<number>} */
+    const f = i => () => {
+        if (n <= i) { return undefined }
+        return [i, f(i + 1)]
+    }
+    return f(0)
+}
 
 /** @type {<T, R>(f: (value: T) => Sequence<R>) => SequenceMap<T, R>} */
 const flatMap = f => input => () => {
@@ -114,16 +134,16 @@ const flatMap = f => input => () => {
 const flat = flatMap(i => i)
 
 /** @type {<T, R>(f: (value: T) => R) => SequenceMap<T, R>} */
-const map = f => flatMap(i => one(f(i)))
+const map = f => flatMap(i => list(f(i)))
 
 /** @type {<T>(f: (value: T) => boolean) => SequenceMap<T, T>} */
-const filter = f => flatMap(i => f(i) ? one(i) : empty)
+const filter = f => flatMap(i => f(i) ? list(i) : empty)
 
 /** @type {<T, R>(f: (value: T) => R|undefined) => (value: T) => Sequence<R>} */
 const filterMapFunc = f => i => {
     const result = f(i)
     if (result === undefined) { return empty }
-    return one(result)
+    return list(result)
 }
 
 /** @type {<T, R>(f: (value: T) => R|undefined) => SequenceMap<T, R>} */
@@ -160,13 +180,17 @@ const last = def => input => {
 /** @type {<T, R>(s: seqOp.ExclusiveScan<T, R>) => (input: Sequence<T>) => R} */
 const reduce = ([first, s]) => input => last(first)(scan(s)(input))
 
+/** @type {<T, R>(ro: op.ReduceOperator<R, T>) => (first: R) => (input: Sequence<T>) => R} */
+const fold = ro => first => reduce(seqOp.exclusiveScan(ro)(first))
+
 const entries = scan(seqOp.entries)
 
 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 => () => {
@@ -200,7 +224,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 => ({
@@ -228,7 +252,7 @@ const asyncIterable = list => ({
     }
 })
 
-/** @type {<A>(a: Sequence<A>) => <B>(b: Sequence<B>) => Sequence<array.Tuple2<A, B>>} */
+/** @type {<A>(a: Sequence<A>) => <B>(b: Sequence<B>) => Sequence<readonly[A, B]>} */
 const zip = a => b => () => {
     const resultA = next(a)
     if (resultA === undefined) { return undefined }
@@ -244,7 +268,7 @@ module.exports = {
     /** @readonly */
     next,
     /** @readonly */
-    one,
+    list,
     /** @readonly */
     empty,
     /** @readonly */
@@ -252,9 +276,9 @@ module.exports = {
     /** @readonly */
     concat,
     /** @readonly */
-    first,
+    generate,
     /** @readonly */
-    fromArray,
+    first,
     /** @readonly */
     toArray,
     /** @readonly */
@@ -278,6 +302,8 @@ module.exports = {
     /** @readonly */
     last,
     /** @readonly */
+    fold,
+    /** @readonly */
     reduce,
     /** @readonly */
     entries,

package/sequence/iterable/index.js

@@ -1,4 +1,5 @@
-const { pipe } = require('../../function')
+const { iterable } = require('..')
+const { combine } = require('../../function')
 const seq = require('../operator')
 
 /** @type {<T>(a: Iterable<T>) => (b: Iterable<T>) => Iterable<T>} */
@@ -39,7 +40,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' }
 }

package/sequence/test.js

@@ -1,6 +1,7 @@
 const seq = require('.')
 const { sum } = require('./operator')
 const op = require('./operator')
+const array = require('./array')
 
 /** @type {<T>(input: seq.Sequence<T>) => void} */
 const print = input => {
@@ -8,16 +9,16 @@ const print = input => {
     while (true) {
         const result = seq.next(i)
         if (result === undefined) { return }
-        // console.log(result[0])
+        console.log(result[0])
         i = result[1]
     }
 }
 
 {
-    const big = seq.fromArray([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 42, 60])
-    const list0 = seq.fromArray([0, 1, 2, 3])
-    const list1 = seq.flatMap(x => seq.fromArray([x, x * 2, x * 3]))(list0)
-    const list2 = seq.concat(list0)(list0)
+    const big = seq.list(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 42, 60)
+    const list0 = seq.list(0, 1, 2, 3)
+    const list1 = seq.flatMap(x => seq.list(x, x * 2, x * 3))(list0)
+    const list2 = seq.concat(list0, list0)
     const list3 = seq.exclusiveScan(sum)(list0)
     const r = seq.find(x => x === 42)(big)
     if (seq.every(x => x > 0)(big) !== true) { throw 'x'}
@@ -25,10 +26,23 @@ const print = input => {
     if (seq.some(x => x > 100)(big) !== false) { throw 'x' }
     if (seq.some(x => x > 50)(big) !== true) { throw 'x' }
     if (seq.first(seq.drop(16)(big)) !== 42) { throw 'drop'}
+    {
+        const a = seq.toArray(seq.generate(1_000_000))
+        let x = seq.concat(array.sequence(a), big)
+        const r = seq.next(x)
+        // print(x)
+    }
+    {
+        const a = seq.map(seq.generate)(seq.generate(100_000))
+        const array = seq.toArray(a)
+        const x = seq.concat(...array)
+        const r = seq.next(x)
+        // print(x)
+    }
     {
         let x = big
         for (let i = 0; i < 1_000_000; ++i) {
-            x = seq.concat(seq.empty)(x)
+            x = seq.concat(seq.empty, x)
         }
         const r = seq.next(x)
         // print(x)
@@ -36,7 +50,7 @@ const print = input => {
     {
         let x = big
         for (let i = 0; i < 1_000_000; ++i) {
-            x = seq.concat(x)(seq.one(i))
+            x = seq.concat(x, seq.list(i))
         }
         const r = seq.next(x)
         // print(x)
@@ -44,6 +58,6 @@ const print = input => {
 }
 
 {
-    const x = seq.join(':')(seq.fromArray(["1", "2", "3", "4", "5", "6"]))
+    const x = seq.join(':')(seq.list("1", "2", "3", "4", "5", "6"))
     if (x !== "1:2:3:4:5:6") { throw x }
 }