functionalscript 0.3.7 → 0.3.8

package/types/function/module.f.js

@@ -13,7 +13,7 @@ export const flip = f => b => a => f(a)(b);
 /**
  * Creates an `Fn` instance from a function, enabling chaining of transformations.
  */
-export const fn = result => ({
+export const fn = (result) => ({
     result,
     then: g => fn(compose(result)(g))
 });

package/types/function/operator/module.f.d.ts

@@ -1,4 +1,4 @@
-type Binary<A, B, R> = (a: A) => (b: B) => R;
+export type Binary<A, B, R> = (a: A) => (b: B) => R;
 export type Fold<I, O> = Binary<I, O, O>;
 export declare const join: (separator: string) => Reduce<string>;
 export declare const concat: Reduce<string>;
@@ -11,10 +11,9 @@ export type StateScan<I, S, O> = (prior: S) => (input: I) => readonly [O, S];
 export declare const stateScanToScan: <I, S, O>(op: StateScan<I, S, O>) => (prior: S) => Scan<I, O>;
 export declare const foldToScan: <I, O>(fold: Fold<I, O>) => (prior: O) => Scan<I, O>;
 export type Reduce<T> = Fold<T, T>;
-export declare const reduceToScan: <T>(fold: Reduce<T>) => Scan<T, T>;
+export declare const reduceToScan: <T>(op: Reduce<T>) => Scan<T, T>;
 export declare const addition: Reduce<number>;
 export declare const min: Reduce<number>;
 export declare const max: Reduce<number>;
 export declare const increment: (b: number) => number;
 export declare const counter: () => (b: number) => number;
-export {};

package/types/function/operator/module.f.js

@@ -1,16 +1,16 @@
-export const join = separator => value => prior => `${prior}${separator}${value}`;
+export const join = (separator) => value => prior => `${prior}${separator}${value}`;
 export const concat = i => acc => `${acc}${i}`;
 export const logicalNot = v => !v;
-export const strictEqual = a => b => a === b;
-export const stateScanToScan = op => prior => i => {
+export const strictEqual = (a) => (b) => a === b;
+export const stateScanToScan = (op) => (prior) => i => {
     const [o, s] = op(prior)(i);
     return [o, stateScanToScan(op)(s)];
 };
-export const foldToScan = fold => prior => i => {
+export const foldToScan = (fold) => (prior) => i => {
     const result = fold(i)(prior);
     return [result, foldToScan(fold)(result)];
 };
-export const reduceToScan = op => init => [init, foldToScan(op)(init)];
+export const reduceToScan = (op) => init => [init, foldToScan(op)(init)];
 export const addition = a => b => a + b;
 export const min = a => b => a < b ? a : b;
 export const max = a => b => a > b ? a : b;

package/types/function/test.f.js

@@ -1,5 +1,4 @@
-import * as _ from "./module.f.js";
-const { fn } = _;
+import { fn } from "./module.f.js";
 export default () => {
     const f = x => [x];
     const g = ([x]) => [x.length];

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

@@ -13,7 +13,7 @@ type Concat<T> = {
     readonly tail: List<T>;
 };
 export declare const concat: <T>(head: List<T>) => (tail: List<T>) => List<T>;
-export declare const next: <T>(list: List<T>) => Result<T>;
+export declare const next: <T>(head: List<T>) => Result<T>;
 export declare const iterable: <T>(list: List<T>) => Iterable<T>;
 export declare const toArray: <T>(list: List<T>) => readonly T[];
 export declare const flat: <T>(list: List<List<T>>) => Thunk<T>;

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,14 @@
-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';
+import type * as BtreeTypes from '../btree/types/module.f.ts';
+import type * as Compare from '../function/compare/module.f.ts';
+import { type List } from '../list/module.f.ts';
+import type * as Operator from '../function/operator/module.f.ts';
 export type Sign = Compare.Sign;
 export type Entry<T> = readonly [string, T];
 export type Map<T> = BtreeTypes.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 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,5 +1,4 @@
-import * as _ from "./module.f.js";
-const { at, setReplace, setReduce, empty, entries, remove } = _;
+import { at, setReplace, setReduce, empty, entries, remove } from "./module.f.js";
 import * as seq from "../list/module.f.js";
 export default {
     main: [

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,5 +1,4 @@
-import * as list from "../list/module.f.js";
-const { every, map, countdown } = list;
+import { every, map, countdown } from "../list/module.f.js";
 import * as _ from "./module.f.js";
 export default {
     has: () => {

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/range_map/module.f.d.ts

@@ -1,8 +1,8 @@
-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 * as O from '../function/operator/module.f.ts';
+import type * as 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>;

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/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 * as compare from '../function/compare/module.f.ts';
+import { type List } from '../list/module.f.ts';
+import type * as option 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>;
+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,14 +1,9 @@
 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 * 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 {

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

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

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;

package/types/sorted_set/test.f.js

@@ -1,14 +1,9 @@
 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 * 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 = a => json.stringify(sort)(a);
 const reverseCmp = flip(unsafeCmp);
 export default {

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

@@ -1,6 +1,6 @@
-import * as list from '../list/module.f.ts';
+import { type List } from '../list/module.f.ts';
 import * as compare from '../function/compare/module.f.ts';
-export declare const join: (_: string) => (input: list.List<string>) => string;
-export declare const concat: (input: list.List<string>) => string;
+export declare const join: (_: string) => (input: List<string>) => string;
+export declare const concat: (input: List<string>) => string;
 export declare const repeat: (n: string) => (v: number) => string;
 export declare const cmp: (a: string) => (b: string) => compare.Sign;

package/types/string/module.f.js

@@ -1,5 +1,4 @@
-import * as list from "../list/module.f.js";
-const { reduce: listReduce, repeat: listRepeat } = list;
+import { reduce as listReduce, repeat as listRepeat } from "../list/module.f.js";
 import { compose } from "../function/module.f.js";
 import * as compare from "../function/compare/module.f.js";
 const { unsafeCmp } = compare;

package/types/string/test.f.js

@@ -1,7 +1,5 @@
-import * as _ from "./module.f.js";
-const { join, concat, repeat, cmp } = _;
-import * as list from "../list/module.f.js";
-const { repeat: repeatList } = list;
+import { join, concat, repeat, cmp } from "./module.f.js";
+import { repeat as repeatList } from "../list/module.f.js";
 export default {
     join: {
         0: () => {

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

@@ -1,4 +1,4 @@
-import * as BtreeTypes from '../btree/types/module.f.ts';
+import type * as BtreeTypes from '../btree/types/module.f.ts';
 import { type List } from '../list/module.f.ts';
 export declare const values: (s: StringSet) => List<string>;
 export declare const empty: null;

package/types/string_set/module.f.js

@@ -1,16 +1,10 @@
-import * as BtreeTypes from "../btree/types/module.f.js";
 import * as btree from "../btree/module.f.js";
-import * as btf from "../btree/find/module.f.js";
-const { find, isFound } = btf;
-import * as btr from "../btree/remove/module.f.js";
-const { remove: btreeRemove } = btr;
-import * as bts from "../btree/set/module.f.js";
-const { set: btreeSet } = bts;
-import * as string from "../string/module.f.js";
-const { cmp } = string;
+import { find, isFound } from "../btree/find/module.f.js";
+import { remove as btreeRemove } from "../btree/remove/module.f.js";
+import { set as btreeSet } from "../btree/set/module.f.js";
+import { cmp } from "../string/module.f.js";
 import { fold } from "../list/module.f.js";
-import * as f from "../function/module.f.js";
-const { compose } = f;
+import { compose } from "../function/module.f.js";
 export const values = btree.values;
 export const empty = btree.empty;
 export const contains = value => {