functionalscript 0.0.156 → 0.0.163

package/array/index.js

@@ -1,3 +1,10 @@
+const option = require('../option')
+
+/**
+ * @template T
+ * @typedef {readonly T[]} Array
+ */
+
 /**
  * @template T
  * @typedef {readonly [T]} Array1
@@ -33,4 +40,51 @@
 
 /** @typedef {0|1|2|3|4} Index5 */
 
-module.exports = {}
+/** @type {<T>(_: Array<T>) => Array<T>} */
+const uncheckTail = a => a.slice(1)
+
+/** @type {<T>(_: Array<T>) => Array<T>} */
+const uncheckHead = a => a.slice(0, -1)
+
+/** @type {<T>(_: Array<T>) => T|undefined} */
+const first = a => a[0]
+
+/** @type {<T>(_: Array<T>) => T|undefined} */
+const last = a => a[a.length - 1]
+
+/** @type {<T>(_: Array<T>) => Array<T>|undefined} */
+const tail = a => a.length === 0 ? undefined : uncheckTail(a)
+
+/** @type {<T>(_: Array<T>) => readonly [T, Array<T>]|undefined} */
+const splitFirst = a => {
+    /** @typedef {typeof a[0]} T*/
+    /** @type {(_: T) => readonly [T, Array<T>]} */
+    const split = first => [first, uncheckTail(a)]
+    return option.map(split)(a[0])
+}
+
+/** @type {<T>(_: Array<T>) => Array<T>|undefined} */
+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))
+}
+
+module.exports = {
+    /** @readnly */
+    first,
+    /** @readonly */
+    last,
+    /** @readonly */
+    head,
+    /** @readonly */
+    tail,
+    /** @readonly */
+    splitFirst,
+    /** @readonly */
+    splitLast,
+}

package/async/{index.js → iterable/index.js}

@@ -1,6 +1,13 @@
-const { pipe } = require('../lib')
+const { todo } = require('../../dev')
+const { pipe } = require('../../func')
+const mapReduce = require('../../map-reduce')
 
-/** @type {<T, R>(f: (value: T) => Promise<R>) => (c: AsyncIterable<T>) => AsyncIterable<R>} */
+/** 
+ * @template T
+ * @typedef {Promise<T>|T} PromiseOrValue
+ */
+
+/** @type {<T, R>(f: (value: T) => PromiseOrValue<R>) => (c: AsyncIterable<T>) => AsyncIterable<R>} */
 const map = f => c => ({
     async *[Symbol.asyncIterator]() {
         for await (const i of c) {
@@ -30,24 +37,24 @@ const filter = f => c => ({
 })
 
 /** @type {<T, R>(f: (value: T) => AsyncIterable<R>) => (c: AsyncIterable<T>) => AsyncIterable<R>} */
-const flatMap = f => pipe(map(async x => f(x)))(flatten)
+const flatMap = f => pipe(map(f))(flatten)
 
 /** 
  * @template A
  * @template T
- * @typedef {(accumulator: A) => (value: T) => Promise<A>} ReduceFn
+ * @typedef {(accumulator: A) => (value: T) => PromiseOrValue<A>} Merge
  */
 
-/** @type {<A, T>(f: ReduceFn<A, T>) => (init: A) => (c: AsyncIterable<T>) => Promise<A>} */
-const reduce = reduceFn => init => async c => {
+/** @type {<A, T>(f: Merge<A, T>) => (init: A) => (c: AsyncIterable<T>) => Promise<A>} */
+const reduce = merge => init => async c => {
     let result = init
     for await (const i of c) {
-        result = await reduceFn(result)(i)
+        result = await merge(result)(i)
     }
     return result
 }
 
-/** @type {<A, T>(f: ReduceFn<A, T>) => (init: A) => (c: AsyncIterable<T>) => AsyncIterable<A>} */
+/** @type {<A, T>(f: Merge<A, T>) => (init: A) => (c: AsyncIterable<T>) => AsyncIterable<A>} */
 const exclusiveScan = reduceFn => init => c => ({
     async *[Symbol.asyncIterator]() {
         let result = init
@@ -58,7 +65,7 @@ const exclusiveScan = reduceFn => init => c => ({
     }
 })
 
-/** @type {<A, T>(f: ReduceFn<A, T>) => (init: A) => (c: AsyncIterable<T>) => AsyncIterable<A>} */
+/** @type {<A, T>(f: Merge<A, T>) => (init: A) => (c: AsyncIterable<T>) => AsyncIterable<A>} */
 const inclusiveScan = reduceFn => init => {
     const e = exclusiveScan(reduceFn)(init)
     return c => ({
@@ -78,10 +85,16 @@ const cast = iterable => ({
     }
 })
 
-/** @type {(c: AsyncIterable<number>) => Promise<number>} */
-const sum = reduce(a => async v => a + v)(0)
+/** @type {<I, S, R>(op: mapReduce.Operation<I, S, R>) => (_: AsyncIterable<I>) => Promise<R>} */
+const apply = ({ merge, init, result }) => async c => result(await reduce(merge)(init)(c))
+
+const sum = apply(mapReduce.sum)
+
+const join = pipe(mapReduce.join)(apply)
 
 module.exports = {
+    /** @readonly */
+    apply,
     /** @readonly */
     cast,
     /** @readonly */
@@ -95,6 +108,8 @@ module.exports = {
     /** @readonly */
     sum,
     /** @readonly */
+    join,
+    /** @readonly */
     exclusiveScan,
     /** @readonly */
     inclusiveScan,

package/btree/index.js

@@ -55,27 +55,37 @@ const { index3, index5 } = require('../cmp')
 
 /**
  * @template T
- * @typedef {Leaf1<T>|Leaf2<T>|Branch3<T>|Branch5<T>} TNode
+ * @typedef { Leaf1<T> | Leaf2<T> | Branch3<T> | Branch5<T>} TNode
+ */
+
+/** @typedef {{ readonly done: false }} NotFoundDone */
+
+/** 
+ * @template T
+ * @typedef {{ 
+ *  readonly done: true 
+ *  readonly value: T 
+ * }} FoundDone 
  */
 
 /**
  * @template T
- * @typedef {{ done: false } | { done: true, value: T }} Done
+ * @typedef { NotFoundDone | FoundDone<T> } Done
  */
 
 /**
  * @template T
- * @typedef {{ replace: TNode<T> }} Replace
+ * @typedef {{ readonly replace: TNode<T> }} Replace
  */
 
 /**
  * @template T
- * @typedef {{ overflow: Branch3<T> }} Overflow
+ * @typedef {{ readonly overflow: Branch3<T> }} Overflow
  */
 
 /**
  * @template T
- * @typedef {Done<T> | Replace<T> | Overflow<T>} Result
+ * @typedef { Done<T> | Replace<T> | Overflow<T> } Result
  */
 
 /** @typedef {<T>(_: Lazy<T>) => (_: Leaf1<T>) => Result<T>} InLeaf1 */
@@ -85,35 +95,35 @@ const { index3, index5 } = require('../cmp')
 
 /** 
  * @typedef {{
- *  leaf1: InLeaf1
- *  leaf2_left: InLeaf2
- *  leaf2_right: InLeaf2
- *  branch3: InBranch3
- *  branch5_left: InBranch5
- *  branch5_right: InBranch5
+ *  readonly leaf1: InLeaf1
+ *  readonly leaf2_left: InLeaf2
+ *  readonly leaf2_right: InLeaf2
+ *  readonly branch3: InBranch3
+ *  readonly branch5_left: InBranch5
+ *  readonly branch5_right: InBranch5
  * }} Found
  */
 
 /**
  * @typedef {{
- *  leaf1_left: InLeaf1
- *  leaf1_right: InLeaf1
- *  leaf2_left: InLeaf2
- *  leaf2_middle: InLeaf2
- *  leaf2_right: InLeaf2
+ *  readonly leaf1_left: InLeaf1
+ *  readonly leaf1_right: InLeaf1
+ *  readonly leaf2_left: InLeaf2
+ *  readonly leaf2_middle: InLeaf2
+ *  readonly leaf2_right: InLeaf2
  * }} NotFound
  */
 
 /** 
  * @typedef {{
- *  found: Found
- *  notFound: NotFound
+ *  readonly found: Found
+ *  readonly notFound: NotFound
  * }} Visitor
  */
 
 /**
  * @template T
- * @typedef {readonly [TNode<T>, T, TNode<T>, T, TNode<T>, T, TNode<T>]} Branch7
+ * @typedef { readonly [TNode<T>, T, TNode<T>, T, TNode<T>, T, TNode<T>] } Branch7
  */
 
 /** @type {<T>(n: Branch7<T>) => Branch3<T>} */
@@ -221,7 +231,7 @@ const visit = ({ found, notFound }) => cmp => {
     }
 }
 
-/** @type {<T>(_: T) => Done<T>} */
+/** @type { <T>(_: T) => Done<T> } */
 const found = value => ({ done: true, value })
 
 /** @type {Found} */
@@ -233,7 +243,7 @@ const foundGet = {
     branch5_left: () => ([, value]) => found(value),
     branch5_right: () => ([, , , value]) => found(value),
 }
-/** @type {() => () => { done: false }} */
+/** @type { () => () => NotFoundDone } */
 const notFound = () => () => ({ done: false })
 
 /** @type {NotFound} */
@@ -245,7 +255,7 @@ const notFoundGet = {
     leaf2_right: notFound,
 }
 
-/** @type {<T>(_: TNode<T>) => Replace<T>} */
+/** @type { <T>(_: TNode<T>) => Replace<T> } */
 const replace = node => ({ replace: node })
 
 /** @type {Found} */
@@ -288,6 +298,7 @@ const getOrInsertVisitor = {
     notFound: notFoundInsert,
 }
 
+/** @type {Visitor} */
 const replaceVisitor = {
     found: foundReplace,
     notFound: notFoundGet,
@@ -324,7 +335,7 @@ module.exports = {
     values,
     /** 
      * @readonly
-     * @type {<T>(cmp: Cmp<T>) => (node: TNode<T>) => T|undefined}
+     * @type { <T>(cmp: Cmp<T>) => (node: TNode<T>) => T|undefined }
      */
     getVisitor: cmp => node => {
         const result = visit(getVisitor)(cmp)(() => { throw '' })(node)

package/dev/index.js

@@ -0,0 +1,4 @@
+module.exports = {
+    /** @readonly */
+    todo: () => { throw 'not implemented' },
+}

package/func/index.js

@@ -0,0 +1,12 @@
+/** @type {<I, X>(_: (_: I) => X) => <O>(_: (_: X) => O) => (_: I) => O} */
+const pipe = g => f => x => f(g(x))
+
+/** @type {<T>(value: T) => T} */
+const id = value => value
+
+module.exports = {
+    /** @readonly */
+    id,
+    /** @readonly */
+    pipe,
+}

package/index.js

@@ -1,9 +1,3 @@
-"use strict";
-
-const lib = require('./lib')
-
-const todo = () => lib.panic('not implemented')
-
 /** @type {<F>(c: string, found: (before: string, after: string) => F, notFound: (c: string, source: string) => F) => (source: string) => F} */
 const splitOne = (c, found, notFound) => source => {
     const i = source.indexOf(c)

package/iterable/index.js

@@ -1,5 +1,4 @@
-const { pipe } = require('../lib')
-const lib = require('../lib')
+const { pipe } = require('../func')
 const mr = require('../map-reduce')
 
 /** @type {<T, R>(merge: (_: R) => (_: T) => R) => (init: R) => (_: Iterable<T>) => R} */
@@ -12,7 +11,20 @@ const reduce = merge => init => c => {
 }
 
 /** @type {<I, S, R>(op: mr.Operation<I, S, R>) => (_: Iterable<I>) => R} */
-const apply = op => pipe(reduce(op.reduce)(op.init))(op.result)
+const apply = ({ merge, init, result }) => pipe(reduce(merge)(init))(result)
+
+const sum = apply(mr.sum)
+
+const join = pipe(mr.join)(apply)
+
+/** @type {<T, R>(f: (value: T) => R) => (c: Iterable<T>) => Iterable<R>} */
+const map = f => c => ({
+    *[Symbol.iterator]() {
+        for (const i of c) {
+            yield f(i)
+        }
+    }
+})
 
 module.exports = {
     /** @readonly */
@@ -22,22 +34,13 @@ module.exports = {
     reduce,
 
     /** @readonly */
-    join: pipe(mr.join)(apply),
+    join,
 
     /** @readonly */
-    sum: apply(mr.sum),
+    sum,
 
-    /** 
-     * @readonly
-     * @type {<T, R>(f: (value: T) => R) => (c: Iterable<T>) => Iterable<R>} 
-     */
-    map: f => c => ({
-        *[Symbol.iterator]() {
-            for (const i of c) {
-                yield f(i)
-            }
-        }
-    }),
+    /** @readonly */
+    map,
 
     /** 
      * @readonly

package/iterable/test.js

@@ -1,41 +1,41 @@
 const i = require('.')
-const lib = require('../lib')
+const { pipe } = require('../func')
 
 {
     const r = i.sum([120, 300, 42])
-    lib.panic_if('reduce')(r !== 462)
+    if (r !== 462) { throw 'error' }
 }
 
 {
-    lib.panic_if('first sum')(i.sum([1, 2]) !== 3)
-    lib.panic_if('second sum')(i.sum([1, 2]) !== 3)
+    if (i.sum([1, 2]) !== 3) { throw 'error' }
+    if (i.sum([1, 2]) !== 3) { throw 'error' }
 }
 
 {
     const x = Array.from(i.map(a => a ** 2)([1, 2, 3]))
-    lib.panic_if('map')(x.length !== 3)
-    lib.panic_if('map[0]')(x[0] !== 1)
-    lib.panic_if('map[1]')(x[1] !== 4)
-    lib.panic_if('map[2]')(x[2] !== 9)
+    if (x.length !== 3) { throw 'error' }
+    if (x[0] !== 1) { throw 'error' }
+    if (x[1] !== 4) { throw 'error' }
+    if (x[2] !== 9) { throw 'error' }
 }
 
 {
-    lib.panic_if('join')(i.join('/')([]) !== '')
-    lib.panic_if('join')(i.join('/')(['a']) !== 'a')
-    lib.panic_if('join')(i.join('/')(['a', 'b']) !== 'a/b')
+    if (i.join('/')([]) !== '') { throw 'error' }
+    if (i.join('/')(['a']) !== 'a') { throw 'error' }
+    if (i.join('/')(['a', 'b']) !== 'a/b') { throw 'error'}
 }
 
 {
-    lib.panic_if('find')(i.find(x => x === 'c')(['a', 'b', 'c']) !== 'c') 
+    if (i.find(x => x === 'c')(['a', 'b', 'c']) !== 'c') { throw 'error' }
 }
 
 {
     /** @type {(_: string) => string|undefined} */
     const file = _ => 'x'
     /** @type {(_: string) => string|undefined} */
-    const x = p => lib.pipe
+    const x = p => pipe
         (i.map(x => file(x())))
         (i.find(x => x !== undefined))
         ([() => p, () => `${p}.js`, () => `${p}/index.js`])
-    lib.panic_if('map.find')(x('index.js') !== 'x')
+    if (x('index.js') !== 'x') { throw 'error' }
 }

package/map/index.js

@@ -1,4 +1,4 @@
-const { optionMap } = require("../lib")
+const option = require("../option")
 const { getVisitor, setVisitor, values } = require("../btree")
 
 /** @typedef {import("../cmp").Sign} Sign */
@@ -38,7 +38,7 @@ const cmp = a => ([b]) => a < b ? -1 : a === b ? 0 : 1
 
 /** @type {<T>(node: TNode<Entry<T>>) => Map<T>} */
 const create = root => ({
-    get: name => optionMap(([,value]) => value)(getVisitor(cmp(name))(root)),
+    get: name => option.map(([,value]) => value)(getVisitor(cmp(name))(root)),
     set: name => value => {
         const result = setVisitor(cmp(name))(() => [name, value])(root)
         if ('replace' in result) { return create(result.replace) }
@@ -53,7 +53,7 @@ const create = root => ({
  * @type {{
  *  readonly get: (name: string) => undefined
  *  readonly set: (name: string) => <T>(value: T) => Map<T>
- *  readonly entries: () => []
+ *  readonly entries: () => readonly []
  *  readonly root: undefined
  * }} 
  */

package/map/test.js

@@ -1,5 +1,4 @@
 const { empty } = require('.')
-const lib = require('../lib')
 
 {
     let m = empty.set('a')(1)
@@ -42,14 +41,13 @@ const lib = require('../lib')
 
 {
     const m = empty.set('x')(12).set('y')(44)
-    lib.panic_if('map.get(\'x\')')(m.get('x') !== 12)
-    lib.panic_if('map.get(\'y\')')(m.get('y') !== 44)
-    lib.panic_if('map.get(\'a\')')(m.get('a') !== undefined)
+    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())
-    lib.panic_if('map.entries()')(entries.length !== 2)
+    if (entries.length !== 2) { throw 'error' }
 }
 
-
 {
     /** @type {import('.').Map<number>} */
     let m = empty

package/map-reduce/index.js

@@ -1,34 +1,40 @@
-const { pipe } = require('../lib')
+const { pipe, id } = require('../func')
+
+/**
+ * @template S
+ * @template I
+ * @typedef {(state: S) => (value: I) => S} Merge
+ */
 
 /**
  * @template I
  * @template S
  * @template O
  * @typedef {{
- *  readonly reduce: (state: S) => (value: I) => S
+ *  readonly merge: Merge<S, I>
  *  readonly result: (state: S) => O
  *  readonly init: S
  * }} Operation
  */
 
 /** @type {<I, T>(mapFn: (value: I) => T) => <S, O>(op: Operation<T, S, O>) => Operation<I, S, O>} */
-const map = mapFn => ({ reduce, result, init}) => ({
-    reduce: pipe(reduce)(pipe(mapFn)),
+const map = mapFn => ({ merge, result, init}) => ({
+    merge: pipe(merge)(pipe(mapFn)),
     result,
     init,
 })
 
 /** @type {(separator: string) => Operation<string, string|undefined, string>} */
 const join = separator => ({ 
-    reduce: s => i => s === undefined ? i : `${s}${separator}${i}`, 
+    merge: s => i => s === undefined ? i : `${s}${separator}${i}`, 
     init: undefined,
     result: s => s === undefined ? '' : s
 })
 
 /** @type {Operation<number, number, number>} */
 const sum = { 
-    reduce: a => i => a + i, 
-    result: a => a,
+    merge: a => i => a + i, 
+    result: id,
     init: 0,
 }
 

package/module-manager/index.js

@@ -1,86 +1,98 @@
-const lib = require('../lib')
+const array = require('../array')
+const { pipe } = require('../func')
+const option = require('../option')
+const { head, last, splitLast, splitFirst } = array
 const iter = require('../iterable')
 const mr = require('../map-reduce')
 
+/**
+ * @template T
+ * @typedef {array.Array<T>} Array
+ */
+
+/** @typedef {Array<string>} Path */
+
 /** @typedef {(_: string) => string|undefined} ReadFile */
 
 /**
  * @typedef {{
- *  id: string[]
- *  dependencies: Dependencies
- *  file: ReadFile
+ *  readonly id: Array<string>
+ *  readonly dependencies: Dependencies
+ *  readonly file: ReadFile
  * }} Package
  */
 
 /**
  * @typedef {{
- *  pack: Package,
- *  local: string[],
+ *  readonly pack: Package,
+ *  readonly local: Array<string>,
  * }} Location
  */
 
 /**
  * @typedef {{
- *  fileName: string
- *  location: Location
- *  source: string
+ *  readonly fileName: string
+ *  readonly location: Location
+ *  readonly source: string
  * }} Module
  */
 
 /** @typedef {(_: string) => undefined|Package|Dependencies} Dependencies */
 
-/** @type {mr.Operation<string, undefined|string[], undefined|string[]>} */
+/** @type {mr.Operation<string, undefined|Path, undefined|Path>} */
 const pathNormReduce = {
-    reduce: path => item =>
+    merge: path => item =>
         path === undefined ?
             undefined :
         ['', '.'].includes(item) ?
             path :
         item === '..' ?
-            lib.head(path) :
+            head(path) :
             [...path, item],
     init: [],
     result: s => s,
 }
 
-/** @type {(_: string[]) => boolean} */
+/** @type {(_: Array<string>) => boolean} */
 const isRelative = localId => ['.', '..'].includes(localId[0])
 
 const pathNorm = iter.apply(pathNormReduce)
 
-/** @type {(_: Package) => (_: string[]) => Module|undefined} */
+/** @type {(_: Package) => (_: Path) => Module|undefined} */
 const internal = pack => {
-    /** @type {(_: string[]) => (_: string) => Module|undefined} */
+    /** @type {(_: Path) => (_: string) => Module|undefined} */
     const readFile = local => fileName => {
         const source = pack.file([...local, fileName].join('/'))
         return source === undefined ? undefined : { fileName, location: { pack, local }, source}
     }
     return path => {
-        /** @type {(_: string[]) => Module|undefined} */
+        /** @type {(_: Path) => Module|undefined} */
         const read = local => {
-            /** @type {(_: [string[], string]) => Module|undefined} */
-            const tryFiles = ([head, last]) => {
+            /** @type {(_: readonly[Path, string]) => Module|undefined} */
+            const tryFiles = ([head, file]) => {
                 /** @type {(_: string) => Module|undefined} */                
-                const one = ext => readFile(head)(last + ext)
-                return ['.', '..', '', undefined].includes(lib.last(path)) ? undefined : one('') ?? one('.js')
+                const one = ext => readFile(head)(file + ext)
+                return ['.', '..', '', undefined].includes(last(path)) ? undefined : one('') ?? one('.js')
             }
-            return lib.optionMap(tryFiles)(lib.splitLast(local)) ?? readFile(local)('index.js')
+            return option.map(tryFiles)(splitLast(local)) ?? readFile(local)('index.js')
         }
-        return lib.optionMap(read)(pathNorm(path))
+        return option.map(read)(pathNorm(path))
     }
 }
 
-/** @type {(_: Package|Dependencies|undefined) => (_: string[]) => Module|undefined} */
+/** @type {(_: Package|Dependencies|undefined) => (_: Path) => Module|undefined} */
 const externalOrInternal = p => 
     p === undefined ? () => undefined : (typeof p === 'function' ? external(p) : internal(p))
 
-/** @type {(_: Dependencies) => (_: string[]) => Module|undefined} */
+/** @type {(_: Dependencies) => (_: Path) => Module|undefined} */
 const external = packages => { 
-    /** @type {(_: [string, string[]]) => Module|undefined} */
+    /** @type {(_: readonly [string, Path]) => Module|undefined} */
     const defined = ([first, tail]) => externalOrInternal(packages(first))(tail)
-    /** @type {(_: string[]) => [string, string[]]|undefined} */
-    const splitFirst = lib.splitFirst
-    return lib.pipe(splitFirst)(lib.optionMap(defined))
+    /** @type {(_: Path) => readonly [string, Path]|undefined} */
+    const sf = splitFirst
+    return pipe
+        (sf)
+        (option.map(defined))
 }
 
 /** @type {(_: Location) => (_: string) => Module|undefined} */
@@ -101,4 +113,4 @@ module.exports = {
     getModule,
     /** @readonly */
     moduleId,
-}
+}

package/module-manager/node/test.js

@@ -1,4 +1,3 @@
-const lib = require('../../lib')
 const mm = require('..')
 const i = require('.')
 

package/module-manager/test.js

@@ -1,17 +1,18 @@
 const i = require('.')
 
-const lib = require('../lib')
-
 require('./node/test')
 
 /** @type {<T>(_: T | undefined) => T} */
-const cast = x => x === undefined ? lib.panic('x') : x
+const cast = x => {
+    if (x === undefined) { throw 'x' } 
+    return x
+}
 
-lib.panic_if('isRelative')(i.isRelative('a/b/c'.split('/')))
-lib.panic_if('!isRelative')(!i.isRelative('./a/b/c'.split('/')))
-lib.panic_if('pathNorm')(cast(i.pathNorm('a/../b'.split('/'))).join('/') !== 'b')
-lib.panic_if('pathNorm')(cast(i.pathNorm('a/../b/../c'.split('/'))).join('/') !== 'c')
-lib.panic_if('pathNorm')(cast(i.pathNorm('./a/../b/c/..//d/'.split('/'))).join('/') !== 'b/d')
+if (i.isRelative('a/b/c'.split('/'))) { throw 'error '}
+if (!i.isRelative('./a/b/c'.split('/'))) { throw 'error ' }
+if (cast(i.pathNorm('a/../b'.split('/'))).join('/') !== 'b') { throw 'error ' }
+if (cast(i.pathNorm('a/../b/../c'.split('/'))).join('/') !== 'c') { throw 'error ' }
+if (cast(i.pathNorm('./a/../b/c/..//d/'.split('/'))).join('/') !== 'b/d') { throw 'error ' }
 
 {
     /** @type {i.Package} */
@@ -35,7 +36,8 @@ lib.panic_if('pathNorm')(cast(i.pathNorm('./a/../b/c/..//d/'.split('/'))).join('
                 'index.js': 'b/c ./index.js',
                 'x/index.js': 'b/c ./x/index.js',
             }
-            return ['.js', '', 'undefined.js'].includes(path) ? lib.panic('.js') : f[path]
+            if (['.js', '', 'undefined.js'].includes(path)) { throw '.js' }
+            return f[path]
         },
         id: ['c']
     }
@@ -59,7 +61,8 @@ lib.panic_if('pathNorm')(cast(i.pathNorm('./a/../b/c/..//d/'.split('/'))).join('
                 'a/index.js': './a/index.js',
                 'a/index.js.js': './a/index.js.js',
             }
-            return ['.js', '', 'undefined.js'].includes(path) ? lib.panic('.js') : f[path] 
+            if (['.js', '', 'undefined.js'].includes(path)) { throw '.js' }
+            return  f[path] 
         },
         id: ['']
     }
@@ -72,8 +75,8 @@ lib.panic_if('pathNorm')(cast(i.pathNorm('./a/../b/c/..//d/'.split('/'))).join('
     }
     {        
         const g = i.getModule({pack, local: []})
-        lib.panic_if('getModule')(g('') !== undefined)
-        lib.panic_if('getModule')(g('..') !== undefined)
+        if (g('') !== undefined) { throw 'error' }
+        if (g('..') !== undefined) { throw 'error' }
         expect(g('.'))({ fileName: 'index.js', location: { pack, local: []}, source: './index.js'})
         expect(g('./index'))({ fileName: 'index.js', location: { pack, local: []}, source: './index.js'})
         expect(g('./index.js'))({ fileName: 'index.js', location: { pack, local: []}, source: './index.js'})
@@ -81,10 +84,10 @@ lib.panic_if('pathNorm')(cast(i.pathNorm('./a/../b/c/..//d/'.split('/'))).join('
         expect(g('./a'))({ fileName: 'index.js', location: { pack, local: ['a']}, source: './a/index.js'})
         expect(g('./a/index'))({ fileName: 'index.js', location: { pack, local: ['a']}, source: './a/index.js'})
         expect(g('./a/index.js'))({ fileName: 'index.js.js', location: { pack, local: ['a']}, source: './a/index.js'})
-        lib.panic_if('getModule')(g('./x') !== undefined)
+        if (g('./x') !== undefined) { throw 'error' }
         expect(g('a'))({ fileName: 'index.js', location: { pack: a, local: []}, source: 'a ./index.js'})
         expect(g('a/index'))({ fileName: 'index.js', location: { pack: a, local: []}, source: 'a ./index.js'})
-        lib.panic_if('getModule')(g('b') !== undefined)
+        if (g('b') !== undefined) { throw 'error' }
         expect(g('b/c'))({ fileName: 'index.js', location: { pack: c, local: []}, source: 'b/c ./index.js'})
         expect(g('b/c/index'))({ fileName: 'index.js', location: { pack: c, local: []}, source: 'b/c ./index.js'})
         expect(g('b/c/index.js'))({ fileName: 'index.js', location: { pack: c, local: []}, source: 'b/c ./index.js'})
@@ -93,21 +96,21 @@ lib.panic_if('pathNorm')(cast(i.pathNorm('./a/../b/c/..//d/'.split('/'))).join('
     }
     {
         const g = i.getModule({pack, local: ['index']})
-        lib.panic_if('getModule')(g('') !== undefined)
+        if (g('') !== undefined) { throw 'error' }
         expect(g('..'))({ fileName: 'index.js', location: { pack, local: []}, source: './index.js'})
         expect(g('.'))({ fileName: 'index.js', location: { pack, local: ['index']}, source: './index/index.js'})
         expect(g('./index'))({ fileName: 'index.js', location: { pack, local: ['index']}, source: './index/index.js'})
         expect(g('./index.js'))({ fileName: 'index.js', location: { pack, local: ['index']}, source: './index/index.js'})
-        lib.panic_if('getModule')(g('./index/') !== undefined)
-        lib.panic_if('getModule')(g('./a') !== undefined)
+        if (g('./index/') !== undefined) { throw 'error' }
+        if (g('./a') !== undefined) { throw 'error' }
         expect(g('../a'))({ fileName: 'index.js', location: { pack, local: ['a']}, source: './a/index.js'})
         expect(g('../a/index'))({ fileName: 'index.js', location: { pack, local: ['a']}, source: './a/index.js'})
         expect(g('../a/index.js'))({ fileName: 'index.js', location: { pack, local: ['a']}, source: './a/index.js'})
         expect(g('../a/index.js.js'))({ fileName: 'index.js.js', location: { pack, local: ['a']}, source: './a/index.js.js'})
-        lib.panic_if('getModule')(g('./x') !== undefined)
+        if (g('./x') !== undefined) { throw 'error' }
         expect(g('a'))({ fileName: 'index.js', location: { pack: a, local: []}, source: 'a ./index.js'})
         expect(g('a/index'))({ fileName: 'index.js', location: { pack: a, local: []}, source: 'a ./index.js'})
-        lib.panic_if('getModule')(g('b') !== undefined)
+        if (g('b') !== undefined) { throw 'error' }
         expect(g('b/c'))({ fileName: 'index.js', location: { pack: c, local: []}, source: 'b/c ./index.js'})
         expect(g('b/c/index'))({ fileName: 'index.js', location: { pack: c, local: []}, source: 'b/c ./index.js'})
         expect(g('b/c/index.js'))({ fileName: 'index.js', location: { pack: c, local: []}, source: 'b/c ./index.js'})

package/option/index.js

@@ -0,0 +1,12 @@
+/**
+ * @template T
+ * @typedef {T|undefined} Option
+ */
+
+/** @type {<T, R>(_: (_: T) => R) => (_: T|undefined) => R|undefined} */
+const map = f => x => x === undefined ? undefined : f(x)
+
+module.exports = {
+    /** @readonly */
+    map,
+}

package/package.json

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

package/test.js

@@ -1,15 +1,13 @@
-const lib = require('./lib')
 const i = require('./')
 
-require('./async/test')
+require('./async/iterable/test')
 require('./module-manager/test')
-require('./lib/test')
 
 /** @type {() => never} */
-const assert = () => lib.panic('assert')
+const assert = () => { throw 'assert' }
 
 /** @type {(_: boolean) => void} */
-const assert_if = c => lib.panic_if('assert_if')(c)
+const assert_if = c => { if (c) { throw 'assert_if' } }
 
 {
     i.parseModuleUrl('')(

package/lib/index.js

@@ -1,124 +0,0 @@
-"use strict";
-
-/**
- * @template T
- * @typedef {T|undefined} Option
- */
-
-/**
- * @template T
- * @typedef {() => NotEmptySequence<T>|undefined} Sequence 
- */
-
-/**
- * @template T
- * @typedef {{ first: T, tail: Sequence<T>}} NotEmptySequence
- */
-
-/**
- * @template T
- * @typedef {() => Continuation<T>} Continue
- */
-
-/**
- * @template T
- * @typedef {[T]|Continue<T>} Continuation
- */ 
-
-/** @type {(_: string) => never} */
-const panic = message => { throw message }
-
-/**
- * @template T
- * @template R
- * @typedef {{
- *  merge: (_: R) => (_: T) => R
- *  init: R
- * }} Reduce
- */
-
-/** @type {<I, X>(_: (_: I) => X) => <O>(_: (_: X) => O) => (_: I) => O} */
-const pipe = g => f => x => f(g(x))
-
-/** @type {<T, R>(_: (_: T) => R) => (_: T|undefined) => R|undefined} */
-const optionMap = f => x => x === undefined ? undefined : f(x)
-
-/** @type {<T>(_: T[]) => T[]} */
-const uncheckTail = a => a.slice(1)
-
-/** @type {<T>(_: T[]) => T[]} */
-const uncheckHead = a => a.slice(0, -1)
-
-/** @type {<T>(_: T[]) => T|undefined} */
-const last = a => a[a.length - 1]
-
-/**
- * @template I
- * @typedef {{
- *  readonly i: <O>(f: (input: I) => O) => Chain<O>
- *  readonly result: () => I
- * }} Chain
- */
-
-/** @type {<I>(value: I) => Chain<I>} */
-const chain = value => ({
-    i: f => chain(f(value)),
-    result: () => value
-})
-
-/**
- * @template I
- * @template T
- * @typedef {{
- *  readonly x: <O>(f: (v: T) => O) => Pipe<I, O>
- *  readonly f: (input: I) => T
- * }} Pipe
- */
-
-module.exports = {
-
-    panic,
-
-    todo: () => panic('not implemented'),
-
-    /** @type {(_: string) => (_: boolean) => void} */
-    panic_if: message => condition => condition ? panic(message) : undefined,
-
-    /** @type {<T>(_: Continuation<T>) => T} */
-    trampoline: continuation => {
-        while (true) {
-            if (typeof continuation !== 'function') {
-                return continuation[0]
-            }
-            continuation = continuation()
-        }
-    },
-
-    pipe,
-
-    last,
-
-    optionMap,
-
-    /** @type {<T>(_: T[]) => T[]|undefined} */
-    tail: a => a.length === 0 ? undefined : uncheckTail(a),
-
-    /** @type {<T>(_: T[]) => [T, T[]]|undefined} */
-    splitFirst: a => {
-        /** @typedef {typeof a[0]} T*/
-        /** @type {(_: T) => [T, T[]]} */
-        const split = first => [first, uncheckTail(a)]
-        return optionMap(split)(a[0])
-    },
-
-    /** @type {<T>(_: T[]) => T[]|undefined} */    
-    head: a => a.length === 0 ? undefined : uncheckHead(a),
-
-    /** @type {<T>(_: T[]) => [T[], T]|undefined} */
-    splitLast: a => {
-        /** @typedef {typeof a[0]} T*/
-        /** @type {(_: T) => [T[], T]} */
-        const split = x => [uncheckHead(a), x]        
-        return optionMap(split)(last(a))
-    },
-}

package/lib/test.js

@@ -1,5 +0,0 @@
-const lib = require('./index')
-
-require('../iterable/test')
-require('../map/test')
-