functionalscript 0.3.7 → 0.3.9

package/types/list/module.f.js

@@ -1,17 +1,17 @@
 import { identity, fn, compose } from "../function/module.f.js";
 import { addition, logicalNot, strictEqual, stateScanToScan, foldToScan, reduceToScan, } from "../function/operator/module.f.js";
-const fromArray = array => {
-    const at = i => i < array.length ? { first: array[i], tail: () => at(i + 1) } : null;
+const fromArray = (array) => {
+    const at = (i) => i < array.length ? { first: array[i], tail: () => at(i + 1) } : null;
     return at(0);
 };
-export const concat = head => tail => tail === null ? head : ({ head, tail });
-const trampoline = list => {
+export const concat = (head) => (tail) => tail === null ? head : ({ head, tail });
+const trampoline = (list) => {
     while (typeof list === 'function') {
         list = list();
     }
     return list;
 };
-export const next = head => {
+export const next = (head) => {
     let tail = null;
     while (true) {
         head = trampoline(head);
@@ -31,7 +31,7 @@ export const next = head => {
         [head, tail] = [tail, null];
     }
 };
-export const iterable = list => ({
+export const iterable = (list) => ({
     *[Symbol.iterator]() {
         let i = list;
         while (true) {
@@ -45,11 +45,11 @@ export const iterable = list => ({
     }
 });
 const { from } = Array;
-export const toArray = list => {
+export const toArray = (list) => {
     const u = trampoline(list);
     return u instanceof Array ? u : from(iterable(u));
 };
-const apply = f => input => () => {
+const apply = (f) => (input) => () => {
     const n = next(input);
     if (n === null) {
         return null;
@@ -58,7 +58,7 @@ const apply = f => input => () => {
 };
 const flatStep = ({ first, tail }) => concat(first)(flat(tail));
 export const flat = apply(flatStep);
-const mapStep = f => ({ first, tail }) => ({ first: f(first), tail: map(f)(tail) });
+const mapStep = (f) => ({ first, tail }) => ({ first: f(first), tail: map(f)(tail) });
 export const map = f => apply(mapStep(f));
 export const flatMap = f => compose(map(f))(flat);
 const filterStep = f => ({ first, tail }) => {

package/types/list/test.f.js

@@ -1,9 +1,7 @@
 import * as _ from "./module.f.js";
 import * as json from "../../json/module.f.js";
-import * as o from "../object/module.f.js";
-const { sort } = o;
-import * as operator from "../function/operator/module.f.js";
-const { addition, strictEqual, reduceToScan } = operator;
+import { sort } from "../object/module.f.js";
+import { addition, strictEqual, reduceToScan } from "../function/operator/module.f.js";
 const stringify = sequence => json.stringify(sort)(_.toArray(sequence));
 const stringifyTest = () => {
     const s = stringify([1, 2, 3]);

package/types/map/module.f.d.ts

@@ -1,14 +1,12 @@
-import * as BtreeTypes from '../btree/types/module.f.ts';
-import * as Compare from '../function/compare/module.f.ts';
-import * as list from '../list/module.f.ts';
-import * as Operator from '../function/operator/module.f.ts';
-export type Sign = Compare.Sign;
+import type { Tree } from '../btree/types/module.f.ts';
+import { type List } from '../list/module.f.ts';
+import type { Reduce } from '../function/operator/module.f.ts';
 export type Entry<T> = readonly [string, T];
-export type Map<T> = BtreeTypes.Tree<Entry<T>>;
+export type Map<T> = Tree<Entry<T>>;
 export declare const at: (name: string) => <T>(map: Map<T>) => T | null;
-export declare const setReduce: <T>(reduce: Operator.Reduce<T>) => (name: string) => (value: T) => (map: Map<T>) => Map<T>;
+export declare const setReduce: <T>(reduce: Reduce<T>) => (name: string) => (value: T) => (map: Map<T>) => Map<T>;
 export declare const setReplace: (name: string) => <T>(value: T) => (map: Map<T>) => Map<T>;
-export declare const entries: <T>(map: Map<T>) => list.List<Entry<T>>;
-export declare const fromEntries: <T>(entries: list.List<Entry<T>>) => Map<T>;
+export declare const entries: <T>(map: Map<T>) => List<Entry<T>>;
+export declare const fromEntries: <T>(entries: List<Entry<T>>) => Map<T>;
 export declare const remove: (name: string) => <T>(map: Map<T>) => Map<T>;
 export declare const empty: null;

package/types/map/module.f.js

@@ -1,18 +1,9 @@
-import * as BtreeTypes from "../btree/types/module.f.js";
-import * as btf from "../btree/find/module.f.js";
-const { value, find } = btf;
-import * as bts from "../btree/set/module.f.js";
-const { set } = bts;
-import * as btr from "../btree/remove/module.f.js";
-const { remove: btreeRemove } = btr;
-import * as bt from "../btree/module.f.js";
-const { values } = bt;
-import * as Compare from "../function/compare/module.f.js";
-import * as s from "../string/module.f.js";
-const { cmp } = s;
-import * as list from "../list/module.f.js";
-const { fold } = list;
-import * as Operator from "../function/operator/module.f.js";
+import { value, find } from "../btree/find/module.f.js";
+import { set } from "../btree/set/module.f.js";
+import { remove as btreeRemove } from "../btree/remove/module.f.js";
+import { values } from "../btree/module.f.js";
+import { cmp } from "../string/module.f.js";
+import { fold } from "../list/module.f.js";
 const keyCmp = a => ([b]) => cmp(a)(b);
 export const at = (name) => (map) => {
     if (map === null) {

package/types/map/test.f.js

@@ -1,6 +1,5 @@
-import * as _ from "./module.f.js";
-const { at, setReplace, setReduce, empty, entries, remove } = _;
-import * as seq from "../list/module.f.js";
+import { at, setReplace, setReduce, empty, entries, remove } from "./module.f.js";
+import { toArray } from "../list/module.f.js";
 export default {
     main: [
         () => {
@@ -91,7 +90,7 @@ export default {
             if (at('a')(m) !== null) {
                 throw 'error';
             }
-            const e = seq.toArray(entries(m));
+            const e = toArray(entries(m));
             if (e.length !== 2) {
                 throw 'error';
             }

package/types/nibble_set/module.f.d.ts

@@ -1,5 +1,5 @@
-type NibbleSet = number;
-type Nibble = number;
+export type NibbleSet = number;
+export type Nibble = number;
 export declare const empty = 0;
 export declare const universe = 65535;
 export declare const has: (n: Nibble) => (s: NibbleSet) => boolean;
@@ -7,4 +7,3 @@ export declare const set: (n: Nibble) => (s: NibbleSet) => NibbleSet;
 export declare const complement: (n: NibbleSet) => NibbleSet;
 export declare const unset: (n: Nibble) => (s: NibbleSet) => NibbleSet;
 export declare const setRange: (r: readonly [number, number]) => (s: NibbleSet) => NibbleSet;
-export {};

package/types/nibble_set/test.f.js

@@ -1,88 +1,87 @@
-import * as list from "../list/module.f.js";
-const { every, map, countdown } = list;
-import * as _ from "./module.f.js";
+import { every, map, countdown } from "../list/module.f.js";
+import { empty, has, set, setRange, unset, universe, complement } from "./module.f.js";
 export default {
     has: () => {
-        if (_.has(0)(_.empty)) {
-            throw _.empty;
+        if (has(0)(empty)) {
+            throw empty;
         }
-        if (_.has(1)(_.empty)) {
-            throw _.empty;
+        if (has(1)(empty)) {
+            throw empty;
         }
-        if (_.has(15)(_.empty)) {
-            throw _.empty;
+        if (has(15)(empty)) {
+            throw empty;
         }
     },
     set: [
         () => {
-            const s = _.set(0)(_.empty);
+            const s = set(0)(empty);
             if (s !== 1) {
                 throw s;
             }
-            if (!_.has(0)(s)) {
+            if (!has(0)(s)) {
                 throw s;
             }
-            if (_.has(1)(s)) {
+            if (has(1)(s)) {
                 throw s;
             }
-            if (_.has(15)(s)) {
+            if (has(15)(s)) {
                 throw s;
             }
         },
         () => {
-            const s = _.set(15)(_.empty);
+            const s = set(15)(empty);
             if (s !== 0x8000) {
                 throw s;
             }
-            if (_.has(0)(s)) {
+            if (has(0)(s)) {
                 throw s;
             }
-            if (_.has(1)(s)) {
+            if (has(1)(s)) {
                 throw s;
             }
-            if (!_.has(15)(s)) {
+            if (!has(15)(s)) {
                 throw s;
             }
         }
     ],
     unset: () => [
         () => {
-            const a = _.set(0)(_.empty);
-            const result = _.unset(0)(a);
+            const a = set(0)(empty);
+            const result = unset(0)(a);
             if (result !== 0) {
                 throw result;
             }
         },
         () => {
-            const a = _.set(15)(_.empty);
-            const result = _.unset(15)(a);
+            const a = set(15)(empty);
+            const result = unset(15)(a);
             if (result !== 0) {
                 throw result;
             }
         }
     ],
     setRange: () => {
-        const result = _.setRange([2, 5])(_.empty);
+        const result = setRange([2, 5])(empty);
         if (result !== 60) {
             throw result;
         }
     },
     universe: () => {
-        const x = every(map((v) => _.has(v)(_.universe))(countdown(16)));
+        const x = every(map((v) => has(v)(universe))(countdown(16)));
         if (!x) {
             throw x;
         }
     },
     compliment: {
         empty: () => {
-            const r = _.complement(_.empty);
-            if (r !== _.universe) {
+            const r = complement(empty);
+            if (r !== universe) {
                 throw r;
             }
         },
         universe: () => {
-            const r = _.complement(_.universe);
-            if (r !== _.empty) {
+            const r = complement(universe);
+            if (r !== empty) {
                 throw r;
             }
         },

package/types/nullable/test.f.js

@@ -1,6 +1,6 @@
-import * as _ from "./module.f.js";
+import { map } from "./module.f.js";
 export default () => {
-    const optionSq = _.map((v) => v * v);
+    const optionSq = map((v) => v * v);
     const sq3 = optionSq(3);
     if (sq3 !== 9) {
         throw sq3;

package/types/number/module.f.d.ts

@@ -1,6 +1,6 @@
 import { type List } from '../list/module.f.ts';
-import * as compare from '../function/compare/module.f.ts';
+import { type Sign } from '../function/compare/module.f.ts';
 export declare const sum: (input: List<number>) => number;
 export declare const min: (input: List<number>) => number | null;
 export declare const max: (input: List<number>) => number | null;
-export declare const cmp: (a: number) => (b: number) => compare.Sign;
+export declare const cmp: (a: number) => (b: number) => Sign;

package/types/number/module.f.js

@@ -1,7 +1,6 @@
 import { reduce } from "../list/module.f.js";
 import { addition, min as minOp, max as maxOp } from "../function/operator/module.f.js";
-import * as compare from "../function/compare/module.f.js";
-const { unsafeCmp } = compare;
+import { unsafeCmp } from "../function/compare/module.f.js";
 export const sum = reduce(addition)(0);
 export const min = reduce(minOp)(null);
 export const max = reduce(maxOp)(null);

package/types/number/test.f.js

@@ -1,5 +1,4 @@
-import * as _ from "./module.f.js";
-const { sum, min, max, cmp } = _;
+import { sum, min, max, cmp } from "./module.f.js";
 export default {
     sum: () => {
         const result = sum([2, 3, 4, 5]);

package/types/object/module.f.d.ts

@@ -1,10 +1,10 @@
-import * as list from '../list/module.f.ts';
-import * as btMap from '../map/module.f.ts';
+import { type List } from '../list/module.f.ts';
+import { type Map as BtMap } from '../map/module.f.ts';
 export type Map<T> = {
     readonly [k in string]: T;
 };
 export type Entry<T> = readonly [string, T];
 export declare const at: (name: string) => <T>(object: Map<T>) => T | null;
-export declare const sort: <T>(e: list.List<Entry<T>>) => list.List<Entry<T>>;
-export declare const fromEntries: <T>(e: list.List<Entry<T>>) => Map<T>;
-export declare const fromMap: <T>(m: btMap.Map<T>) => Map<T>;
+export declare const sort: <T>(e: List<Entry<T>>) => List<Entry<T>>;
+export declare const fromEntries: <T>(e: List<Entry<T>>) => Map<T>;
+export declare const fromMap: <T>(m: BtMap<T>) => Map<T>;

package/types/object/module.f.js

@@ -1,7 +1,5 @@
-import * as list from "../list/module.f.js";
-const { iterable } = list;
-import * as btMap from "../map/module.f.js";
-const { entries: mapEntries, fromEntries: mapFromEntries } = btMap;
+import { iterable } from "../list/module.f.js";
+import { entries as mapEntries, fromEntries as mapFromEntries } from "../map/module.f.js";
 const { getOwnPropertyDescriptor, fromEntries: objectFromEntries } = Object;
 export const at = name => object => {
     const r = getOwnPropertyDescriptor(object, name);

package/types/object/test.f.js

@@ -1,15 +1,15 @@
-import * as _ from "./module.f.js";
+import { at } from "./module.f.js";
 export default {
     ctor: () => {
         const a = {};
-        const value = _.at('constructor')(a);
+        const value = at('constructor')(a);
         if (value !== null) {
             throw value;
         }
     },
     property: () => {
         const a = { constructor: 42 };
-        const value = _.at('constructor')(a);
+        const value = at('constructor')(a);
         if (value !== 42) {
             throw value;
         }

package/types/range/test.f.js

@@ -1,18 +1,18 @@
-import * as _ from "./module.f.js";
+import { contains } from "./module.f.js";
 export default () => {
-    if (!_.contains([0, 5])(1)) {
+    if (!contains([0, 5])(1)) {
         throw 1;
     }
-    if (!_.contains([0, 5])(0)) {
+    if (!contains([0, 5])(0)) {
         throw 0;
     }
-    if (!_.contains([0, 5])(5)) {
+    if (!contains([0, 5])(5)) {
         throw 5;
     }
-    if (_.contains([0, 5])(-1)) {
+    if (contains([0, 5])(-1)) {
         throw -1;
     }
-    if (_.contains([0, 5])(6)) {
+    if (contains([0, 5])(6)) {
         throw 6;
     }
 };

package/types/range_map/module.f.d.ts

@@ -1,14 +1,14 @@
-import * as sortedList from '../sorted_list/module.f.ts';
-import * as O from '../function/operator/module.f.ts';
-import * as Range from '../range/module.f.ts';
+import { type SortedList } from '../sorted_list/module.f.ts';
+import type { Reduce, Equal } from '../function/operator/module.f.ts';
+import type { Range } from '../range/module.f.ts';
 export type Entry<T> = [T, number];
-export type RangeMap<T> = sortedList.SortedList<Entry<T>>;
+export type RangeMap<T> = SortedList<Entry<T>>;
 export type RangeMapArray<T> = readonly Entry<T>[];
 export type Operators<T> = {
-    readonly union: O.Reduce<T>;
-    readonly equal: O.Equal<T>;
+    readonly union: Reduce<T>;
+    readonly equal: Equal<T>;
 };
-export type RangeMerge<T> = O.Reduce<RangeMap<T>>;
+export type RangeMerge<T> = Reduce<RangeMap<T>>;
 export declare const merge: <T>(op: Operators<T>) => RangeMerge<T>;
 export declare const get: <T>(def: T) => (value: number) => (rm: RangeMapArray<T>) => T;
-export declare const fromRange: <T>(def: T) => (r: Range.Range) => (value: T) => RangeMapArray<T>;
+export declare const fromRange: <T>(def: T) => (r: Range) => (value: T) => RangeMapArray<T>;

package/types/range_map/module.f.js

@@ -1,12 +1,6 @@
-import * as sortedList from "../sorted_list/module.f.js";
-const { genericMerge } = sortedList;
-import * as list from "../list/module.f.js";
-const { next } = list;
-import * as Option from "../nullable/module.f.js";
-import * as number from "../number/module.f.js";
-const { cmp } = number;
-import * as O from "../function/operator/module.f.js";
-import * as Range from "../range/module.f.js";
+import { genericMerge } from "../sorted_list/module.f.js";
+import { next } from "../list/module.f.js";
+import { cmp } from "../number/module.f.js";
 const reduceOp = union => equal => state => ([aItem, aMax]) => ([bItem, bMax]) => {
     const sign = cmp(aMax)(bMax);
     const min = sign === 1 ? bMax : aMax;

package/types/range_map/test.f.js

@@ -1,9 +1,7 @@
 import * as _ from "./module.f.js";
-import * as compare from "../function/compare/module.f.js";
-const { unsafeCmp } = compare;
+import { unsafeCmp } from "../function/compare/module.f.js";
 import * as json from "../../json/module.f.js";
-import * as object from "../object/module.f.js";
-const { sort } = object;
+import { sort } from "../object/module.f.js";
 import * as sortedSet from "../sorted_set/module.f.js";
 import * as list from "../list/module.f.js";
 import * as operator from "../function/operator/module.f.js";

package/types/result/module.f.d.ts

@@ -1,7 +1,6 @@
-type Ok<T> = readonly ['ok', T];
-type Error<E> = readonly ['error', E];
+export type Ok<T> = readonly ['ok', T];
+export type Error<E> = readonly ['error', E];
 export type Result<T, E> = Ok<T> | Error<E>;
 export declare const ok: <T>(value: T) => Ok<T>;
 export declare const error: <E>(e: E) => Error<E>;
 export declare const unwrap: <T, E>(r: Result<T, E>) => T;
-export {};

package/types/sorted_list/module.f.d.ts

@@ -1,16 +1,16 @@
-import * as compare from '../function/compare/module.f.ts';
-import * as list from '../list/module.f.ts';
-import * as option from '../nullable/module.f.ts';
-export type SortedList<T> = list.List<T>;
+import type { Sign } from '../function/compare/module.f.ts';
+import { type List } from '../list/module.f.ts';
+import type { Nullable } from '../nullable/module.f.ts';
+export type SortedList<T> = List<T>;
 type SortedArray<T> = readonly T[];
-type Cmp<T> = (a: T) => (b: T) => compare.Sign;
-export type ReduceOp<T, S> = (state: S) => (a: T) => (b: T) => readonly [option.Nullable<T>, compare.Sign, S];
-export type TailReduce<T, S> = (state: S) => (tail: list.List<T>) => list.List<T>;
+type Cmp<T> = (a: T) => (b: T) => Sign;
+export type ReduceOp<T, S> = (state: S) => (a: T) => (b: T) => readonly [Nullable<T>, Sign, S];
+export type TailReduce<T, S> = (state: S) => (tail: List<T>) => List<T>;
 type MergeReduce<T, S> = {
     readonly reduceOp: ReduceOp<T, S>;
     readonly tailReduce: TailReduce<T, S>;
 };
-export declare const genericMerge: <T, S>({ reduceOp, tailReduce }: MergeReduce<T, S>) => (state: S) => (a: list.List<T>) => (b: list.List<T>) => list.List<T>;
+export declare const genericMerge: <T, S>({ reduceOp, tailReduce }: MergeReduce<T, S>) => (state: S) => (a: List<T>) => (b: List<T>) => List<T>;
 export declare const merge: <T>(cmp: Cmp<T>) => (a: SortedList<T>) => (b: SortedList<T>) => SortedList<T>;
 export declare const find: <T>(cmp: Cmp<T>) => (value: T) => (array: SortedArray<T>) => T | null;
 export {};

package/types/sorted_list/module.f.js

@@ -1,9 +1,5 @@
-import * as compare from "../function/compare/module.f.js";
-import * as list from "../list/module.f.js";
-import * as option from "../nullable/module.f.js";
-const { next } = list;
-import * as f from "../function/module.f.js";
-const { identity } = f;
+import { next } from "../list/module.f.js";
+import { identity } from "../function/module.f.js";
 export const genericMerge = ({ reduceOp, tailReduce }) => {
     const f = state => a => b => () => {
         const aResult = next(a);

package/types/sorted_list/test.f.js

@@ -1,26 +1,21 @@
-import * as _ from "./module.f.js";
-import * as compare from "../function/compare/module.f.js";
-const { unsafeCmp } = compare;
+import { find, merge } from "./module.f.js";
+import { unsafeCmp } from "../function/compare/module.f.js";
 import * as json from "../../json/module.f.js";
-import * as object from "../object/module.f.js";
-const { sort } = object;
-import * as list from "../list/module.f.js";
-const { toArray, countdown, length } = list;
-import * as Map from "../map/module.f.js";
-import * as f from "../function/module.f.js";
-const { flip } = f;
+import { sort } from "../object/module.f.js";
+import { toArray, countdown, length } from "../list/module.f.js";
+import { flip } from "../function/module.f.js";
 const stringify = json.stringify(sort);
 const reverseCmp = flip(unsafeCmp);
 export default {
     sortedMergre: [
         () => {
-            const result = stringify(toArray(_.merge(unsafeCmp)([2, 3, 4])([1, 3, 5])));
+            const result = stringify(toArray(merge(unsafeCmp)([2, 3, 4])([1, 3, 5])));
             if (result !== '[1,2,3,4,5]') {
                 throw result;
             }
         },
         () => {
-            const result = stringify(toArray(_.merge(unsafeCmp)([1, 2, 3])([])));
+            const result = stringify(toArray(merge(unsafeCmp)([1, 2, 3])([])));
             if (result !== '[1,2,3]') {
                 throw result;
             }
@@ -28,7 +23,7 @@ export default {
         () => {
             const n = 10_000;
             const list = countdown(n);
-            const result = _.merge(reverseCmp)(list)(list);
+            const result = merge(reverseCmp)(list)(list);
             const len = length(result);
             if (len != n) {
                 throw result;
@@ -37,25 +32,25 @@ export default {
     ],
     find: [
         () => {
-            const result = _.find(unsafeCmp)(0)([0, 10, 20, 30, 40, 50, 60, 70, 80, 90]);
+            const result = find(unsafeCmp)(0)([0, 10, 20, 30, 40, 50, 60, 70, 80, 90]);
             if (result !== 0) {
                 throw result;
             }
         },
         () => {
-            const result = _.find(unsafeCmp)(3)([0, 10, 20, 30, 40, 50, 60, 70, 80, 90]);
+            const result = find(unsafeCmp)(3)([0, 10, 20, 30, 40, 50, 60, 70, 80, 90]);
             if (result !== null) {
                 throw result;
             }
         },
         () => {
-            const result = _.find(unsafeCmp)(77)([0, 10, 20, 30, 40, 50, 60, 70, 80, 90]);
+            const result = find(unsafeCmp)(77)([0, 10, 20, 30, 40, 50, 60, 70, 80, 90]);
             if (result !== null) {
                 throw result;
             }
         },
         () => {
-            const result = _.find(unsafeCmp)(80)([0, 10, 20, 30, 40, 50, 60, 70, 80, 90]);
+            const result = find(unsafeCmp)(80)([0, 10, 20, 30, 40, 50, 60, 70, 80, 90]);
             if (result !== 80) {
                 throw result;
             }

package/types/sorted_set/module.f.d.ts

@@ -1,6 +1,6 @@
-import * as Compare from '../function/compare/module.f.ts';
+import type { Sign } from '../function/compare/module.f.ts';
 export type SortedSet<T> = readonly T[];
-type Cmp<T> = (a: T) => (b: T) => Compare.Sign;
+type Cmp<T> = (a: T) => (b: T) => Sign;
 export declare const union: <T>(cmp: Cmp<T>) => (a: SortedSet<T>) => (b: SortedSet<T>) => SortedSet<T>;
 export declare const intersect: <T>(cmp: Cmp<T>) => (a: SortedSet<T>) => (b: SortedSet<T>) => SortedSet<T>;
 export declare const has: <T>(cmp: Cmp<T>) => (value: T) => (set: SortedSet<T>) => boolean;

package/types/sorted_set/module.f.js

@@ -1,8 +1,5 @@
-import * as Compare from "../function/compare/module.f.js";
-import * as list from "../list/module.f.js";
-const { toArray } = list;
-import * as sortedList from "../sorted_list/module.f.js";
-const { merge, genericMerge, find } = sortedList;
+import { toArray } from "../list/module.f.js";
+import { merge, genericMerge, find } from "../sorted_list/module.f.js";
 export const union = cmp => a => b => toArray(merge(cmp)(a)(b));
 export const intersect = cmp => a => b => toArray(intersectMerge(cmp)(a)(b));
 const tailReduce = () => () => null;