functionalscript 0.1.609 → 0.2.0

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

@@ -1,25 +1,3 @@
-declare namespace _default {
-    export { join };
-    export { addition };
-    export { increment };
-    export { strictEqual };
-    export { logicalNot };
-    export { min };
-    export { max };
-    export { stateScanToScan };
-    export { foldToScan };
-    export { reduceToScan };
-    export { counter };
-    export { concat };
-}
-export default _default;
-export type Binary<A, B, R> = (a: A) => (b: B) => R;
-export type Fold<I, O> = Binary<I, O, O>;
-export type Unary<T, R> = (value: T) => R;
-export type Equal<T> = Binary<T, T, boolean>;
-export type Scan<I, O> = (input: I) => readonly [O, Scan<I, O>];
-export type StateScan<I, S, O> = (prior: S) => (input: I) => readonly [O, S];
-export type Reduce<T> = Fold<T, T>;
 /**
  * @template A
  * @template B
@@ -31,27 +9,22 @@ export type Reduce<T> = Fold<T, T>;
  * @typedef {Binary<I, O, O>} Fold
  */
 /** @type {(separator: string) => Reduce<string>} */
-declare const join: (separator: string) => Reduce<string>;
-/** @type {Reduce<number>} */
-declare const addition: Reduce<number>;
-declare const increment: (b: number) => number;
-/**
- * @template T
- * @typedef {Binary<T, T, boolean>} Equal
- */
-/** @type {<T>(a: T) => (b: T) => boolean} */
-declare const strictEqual: <T>(a: T) => (b: T) => boolean;
+export const join: (separator: string) => Reduce<string>;
+/** @type {Reduce<string>} */
+export const concat: Reduce<string>;
 /**
  * @template T
  * @template R
  * @typedef {(value: T) => R} Unary
  */
 /** @type {Unary<boolean, boolean>} */
-declare const logicalNot: Unary<boolean, boolean>;
-/** @type {Reduce<number>} */
-declare const min: Reduce<number>;
-/** @type {Reduce<number>} */
-declare const max: Reduce<number>;
+export const logicalNot: Unary<boolean, boolean>;
+/**
+ * @template T
+ * @typedef {Binary<T, T, boolean>} Equal
+ */
+/** @type {<T>(a: T) => (b: T) => boolean} */
+export const strictEqual: <T>(a: T) => (b: T) => boolean;
 /**
  * @template I,O
  * @typedef {(input: I) => readonly[O, Scan<I,O>]} Scan
@@ -61,15 +34,27 @@ declare const max: Reduce<number>;
  * @typedef {(prior: S) => (input: I) => readonly[O, S]} StateScan
  */
 /** @type {<I, S, O>(op: StateScan<I, S, O>) => (prior: S) => Scan<I, O>} */
-declare const stateScanToScan: <I, S, O>(op: StateScan<I, S, O>) => (prior: S) => Scan<I, O>;
+export const stateScanToScan: <I, S, O>(op: StateScan<I, S, O>) => (prior: S) => Scan<I, O>;
 /** @type {<I, O>(fold: Fold<I, O>) => (prior: O) => Scan<I, O>} */
-declare const foldToScan: <I, O>(fold: Fold<I, O>) => (prior: O) => Scan<I, O>;
+export const foldToScan: <I, O>(fold: Fold<I, O>) => (prior: O) => Scan<I, O>;
 /**
  * @template T
  * @typedef {Fold<T, T>} Reduce
  */
 /** @type {<T>(fold: Reduce<T>) => Scan<T, T>} */
-declare const reduceToScan: <T>(fold: Reduce<T>) => Scan<T, T>;
-declare function counter(): (b: number) => number;
-/** @type {Reduce<string>} */
-declare const concat: Reduce<string>;
+export const reduceToScan: <T>(fold: Reduce<T>) => Scan<T, T>;
+/** @type {Reduce<number>} */
+export const addition: Reduce<number>;
+/** @type {Reduce<number>} */
+export const min: Reduce<number>;
+/** @type {Reduce<number>} */
+export const max: Reduce<number>;
+export const increment: (b: number) => number;
+export function counter(): (b: number) => number;
+export type Binary<A, B, R> = (a: A) => (b: B) => R;
+export type Fold<I, O> = Binary<I, O, O>;
+export type Unary<T, R> = (value: T) => R;
+export type Equal<T> = Binary<T, T, boolean>;
+export type Scan<I, O> = (input: I) => readonly [O, Scan<I, O>];
+export type StateScan<I, S, O> = (prior: S) => (input: I) => readonly [O, S];
+export type Reduce<T> = Fold<T, T>;

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

@@ -12,10 +12,10 @@
  */
 
 /** @type {(separator: string) => Reduce<string>} */
-const join = separator => value => prior => `${prior}${separator}${value}`
+export const join = separator => value => prior => `${prior}${separator}${value}`
 
 /** @type {Reduce<string>} */
-const concat = i => acc => `${acc}${i}`
+export const concat = i => acc => `${acc}${i}`
 
 /**
  * @template T
@@ -24,7 +24,7 @@ const concat = i => acc => `${acc}${i}`
  */
 
 /** @type {Unary<boolean, boolean>} */
-const logicalNot = v => !v
+export const logicalNot = v => !v
 
 /**
  * @template T
@@ -32,7 +32,7 @@ const logicalNot = v => !v
  */
 
 /** @type {<T>(a: T) => (b: T) => boolean} */
-const strictEqual = a => b => a === b
+export const strictEqual = a => b => a === b
 
 /**
  * @template I,O
@@ -45,13 +45,13 @@ const strictEqual = a => b => a === b
  */
 
 /** @type {<I, S, O>(op: StateScan<I, S, O>) => (prior: S) => Scan<I, O>} */
-const stateScanToScan = op => prior => i => {
+export const stateScanToScan = op => prior => i => {
     const [o, s] = op(prior)(i)
     return [o, stateScanToScan(op)(s)]
 }
 
 /** @type {<I, O>(fold: Fold<I, O>) => (prior: O) => Scan<I, O>} */
-const foldToScan = fold => prior => i => {
+export const foldToScan = fold => prior => i => {
     const result = fold(i)(prior)
     return [result, foldToScan(fold)(result)]
 }
@@ -62,44 +62,17 @@ const foldToScan = fold => prior => i => {
  */
 
 /** @type {<T>(fold: Reduce<T>) => Scan<T, T>} */
-const reduceToScan = op => init => [init, foldToScan(op)(init)]
+export const reduceToScan = op => init => [init, foldToScan(op)(init)]
 
 /** @type {Reduce<number>} */
-const addition = a => b => a + b
+export const addition = a => b => a + b
 
 /** @type {Reduce<number>} */
-const min = a => b => a < b ? a : b
+export const min = a => b => a < b ? a : b
 
 /** @type {Reduce<number>} */
-const max = a => b => a > b ? a : b
-
-const increment = addition(1)
-
-const counter = () => increment
-
-export default {
-    /** @readonly */
-    join,
-    /** @readonly */
-    addition,
-    /** @readonly */
-    increment,
-    /** @readonly */
-    strictEqual,
-    /** @readonly */
-    logicalNot,
-    /** @readonly */
-    min,
-    /** @readonly */
-    max,
-    /** @readonly */
-    stateScanToScan,
-    /** @readonly */
-    foldToScan,
-    /** @readonly */
-    reduceToScan,
-    /** @readonly */
-    counter,
-    /** @readonly */
-    concat,
-}
+export const max = a => b => a > b ? a : b
+
+export const increment = addition(1)
+
+export const counter = () => increment

package/types/function/test.f.mjs

@@ -1,4 +1,4 @@
-import _ from './module.f.mjs'
+import * as _ from './module.f.mjs'
 
 const { fn } = _
 

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

@@ -1,117 +1,82 @@
-declare namespace _default {
-    export let empty: null;
-    export { concat };
-    export { next };
-    export { iterable };
-    export { toArray };
-    export { flat };
-    export { map };
-    export { flatMap };
-    export { filter };
-    export { filterMap };
-    export { takeWhile };
-    export { take };
-    export { dropWhile };
-    export { drop };
-    export { first };
-    export { last };
-    export { find };
-    export { some };
-    export { every };
-    export { isEmpty };
-    export { includes };
-    export { countdown };
-    export { repeat };
-    export { cycle };
-    export { scan };
-    export { stateScan };
-    export { foldScan };
-    export { fold };
-    export { reduce };
-    export { length };
-    export { entries };
-    export { reverse };
-    export { zip };
-    export { equal };
-}
-export default _default;
-export type List<T> = NotLazy<T> | Thunk<T>;
-export type NotLazy<T> = Result<T> | Concat<T> | readonly T[];
-export type Empty = null;
-export type Result<T> = Empty | NonEmpty<T>;
-export type Thunk<T> = () => List<T>;
-export type NonEmpty<T> = {
-    readonly first: T;
-    readonly tail: List<T>;
-};
-export type Concat<T> = {
-    readonly head: List<T>;
-    readonly tail: List<T>;
-};
-export type Entry<T> = readonly [number, T];
 /** @type {<T>(head: List<T>) => (tail: List<T>) => List<T>} */
-declare const concat: <T>(head: List<T>) => (tail: List<T>) => List<T>;
+export const concat: <T>(head: List<T>) => (tail: List<T>) => List<T>;
 /** @type {<T>(list: List<T>) => Result<T>} */
-declare const next: <T>(list: List<T>) => Result<T>;
+export const next: <T>(list: List<T>) => Result<T>;
 /** @type {<T>(list: List<T>) => Iterable<T>} */
-declare const iterable: <T>(list: List<T>) => Iterable<T>;
+export const iterable: <T>(list: List<T>) => Iterable<T>;
 /** @type {<T>(list: List<T>) => readonly T[]} */
-declare const toArray: <T>(list: List<T>) => readonly T[];
+export const toArray: <T>(list: List<T>) => readonly T[];
 /** @type {<T>(list: List<List<T>>) => Thunk<T>} */
-declare const flat: <T>(list: List<List<T>>) => Thunk<T>;
+export const flat: <T>(list: List<List<T>>) => Thunk<T>;
 /** @type {<I, O>(f: (value: I) => O) => (input: List<I>) => Thunk<O>} */
-declare const map: <I, O>(f: (value: I) => O) => (input: List<I>) => Thunk<O>;
+export const map: <I, O>(f: (value: I) => O) => (input: List<I>) => Thunk<O>;
 /** @type {<I, O>(f: (value: I) => List<O>) => (input: List<I>) => Thunk<O>} */
-declare const flatMap: <I, O>(f: (value: I) => List<O>) => (input: List<I>) => Thunk<O>;
+export const flatMap: <I, O>(f: (value: I) => List<O>) => (input: List<I>) => Thunk<O>;
 /** @type {<T>(f: (value: T) => boolean) => (input: List<T>) => Thunk<T>} */
-declare const filter: <T>(f: (value: T) => boolean) => (input: List<T>) => Thunk<T>;
+export const filter: <T>(f: (value: T) => boolean) => (input: List<T>) => Thunk<T>;
 /** @type {<I, O>(f: (value: I) => O|null) => (input: List<I>) => Thunk<O>} */
-declare const filterMap: <I, O>(f: (value: I) => O | null) => (input: List<I>) => Thunk<O>;
+export const filterMap: <I, O>(f: (value: I) => O | null) => (input: List<I>) => Thunk<O>;
 /** @type {<T>(f: (value: T) => boolean) => (input: List<T>) => Thunk<T>} */
-declare const takeWhile: <T>(f: (value: T) => boolean) => (input: List<T>) => Thunk<T>;
+export const takeWhile: <T>(f: (value: T) => boolean) => (input: List<T>) => Thunk<T>;
 /** @type {(n: number) => <T>(input: List<T>) => Thunk<T>} */
-declare const take: (n: number) => <T>(input: List<T>) => Thunk<T>;
+export const take: (n: number) => <T>(input: List<T>) => Thunk<T>;
 /** @type {<T>(f: (value: T) => boolean) => (input: List<T>) => Thunk<T>} */
-declare const dropWhile: <T>(f: (value: T) => boolean) => (input: List<T>) => Thunk<T>;
+export const dropWhile: <T>(f: (value: T) => boolean) => (input: List<T>) => Thunk<T>;
 /** @type {(n: number) => <T>(input: List<T>) => Thunk<T>} */
-declare const drop: (n: number) => <T>(input: List<T>) => Thunk<T>;
+export const drop: (n: number) => <T>(input: List<T>) => Thunk<T>;
 /** @type {<D>(def: D) => <T>(input: List<T>) => D|T} */
-declare const first: <D>(def: D) => <T>(input: List<T>) => D | T;
+export const first: <D>(def: D) => <T>(input: List<T>) => D | T;
 /** @type {<D>(first: D) => <T>(tail: List<T>) => D|T} */
-declare const last: <D>(first: D) => <T>(tail: List<T>) => D | T;
+export const last: <D>(first: D) => <T>(tail: List<T>) => D | T;
 /** @type {<D>(def: D) => <T>(f: (value: T) => boolean) => (input: List<T>) => D|T} */
-declare const find: <D>(def: D) => <T>(f: (value: T) => boolean) => (input: List<T>) => D | T;
+export const find: <D>(def: D) => <T>(f: (value: T) => boolean) => (input: List<T>) => D | T;
 /** @type {(input: List<boolean>) => boolean} */
-declare const some: (input: List<boolean>) => boolean;
-declare const every: import("../function/module.f.mjs").Func<List<boolean>, boolean>;
+export const some: (input: List<boolean>) => boolean;
 /** @type {<T>(input: List<T>) => boolean} */
-declare const isEmpty: <T>(input: List<T>) => boolean;
+export const isEmpty: <T>(input: List<T>) => boolean;
+export const every: function_.Func<List<boolean>, boolean>;
 /** @type {<T>(value: T) => (sequence: List<T>) => boolean} */
-declare const includes: <T>(value: T) => (sequence: List<T>) => boolean;
+export const includes: <T>(value: T) => (sequence: List<T>) => boolean;
 /** @type {(count: number) => Thunk<number>} */
-declare const countdown: (count: number) => Thunk<number>;
+export const countdown: (count: number) => Thunk<number>;
 /** @type {<T>(v: T) => (c: number) => Thunk<T>} */
-declare const repeat: <T>(v: T) => (c: number) => Thunk<T>;
+export const repeat: <T>(v: T) => (c: number) => Thunk<T>;
 /** @type {<T>(list: List<T>) => List<T>} */
-declare const cycle: <T>(list: List<T>) => List<T>;
-/** @type {<I, O>(op: Operator.Scan<I, O>) => (input: List<I>) => Thunk<O>} */
-declare const scan: <I, O>(op: Operator.Scan<I, O>) => (input: List<I>) => Thunk<O>;
-/** @type {<I, S, O>(op: Operator.StateScan<I, S, O>) => (init: S) => (input: List<I>) => Thunk<O>} */
-declare const stateScan: <I, S, O>(op: Operator.StateScan<I, S, O>) => (init: S) => (input: List<I>) => Thunk<O>;
-/** @type {<I,O>(op: Operator.Fold<I, O>) => (init: O) => (input: List<I>) => Thunk<O>} */
-declare const foldScan: <I, O>(op: Operator.Fold<I, O>) => (init: O) => (input: List<I>) => Thunk<O>;
-/** @type {<I,O>(op: Operator.Fold<I, O>) => (init: O) => (input: List<I>) => O} */
-declare const fold: <I, O>(op: Operator.Fold<I, O>) => (init: O) => (input: List<I>) => O;
-/** @type {<T>(op: Operator.Reduce<T>) => <D>(def: D) => (input: List<T>) => D|T} */
-declare const reduce: <T>(op: Operator.Reduce<T>) => <D>(def: D) => (input: List<T>) => D | T;
+export const cycle: <T>(list: List<T>) => List<T>;
+/** @type {<I, O>(op: operator.Scan<I, O>) => (input: List<I>) => Thunk<O>} */
+export const scan: <I, O>(op: operator.Scan<I, O>) => (input: List<I>) => Thunk<O>;
+/** @type {<I, S, O>(op: operator.StateScan<I, S, O>) => (init: S) => (input: List<I>) => Thunk<O>} */
+export const stateScan: <I, S, O>(op: operator.StateScan<I, S, O>) => (init: S) => (input: List<I>) => Thunk<O>;
+/** @type {<I,O>(op: operator.Fold<I, O>) => (init: O) => (input: List<I>) => Thunk<O>} */
+export const foldScan: <I, O>(op: operator.Fold<I, O>) => (init: O) => (input: List<I>) => Thunk<O>;
+/** @type {<I,O>(op: operator.Fold<I, O>) => (init: O) => (input: List<I>) => O} */
+export const fold: <I, O>(op: operator.Fold<I, O>) => (init: O) => (input: List<I>) => O;
+/** @type {<T>(op: operator.Reduce<T>) => <D>(def: D) => (input: List<T>) => D|T} */
+export const reduce: <T>(op: operator.Reduce<T>) => <D>(def: D) => (input: List<T>) => D | T;
 /** @type {<T>(input: List<T>) => number} */
-declare const length: <T>(input: List<T>) => number;
+export const length: <T>(input: List<T>) => number;
 /** @type {<T>(input: List<T>) => Thunk<Entry<T>>} */
-declare const entries: <T>(input: List<T>) => Thunk<Entry<T>>;
+export const entries: <T>(input: List<T>) => Thunk<Entry<T>>;
 /** @type {<T>(input: List<T>) => List<T>} */
-declare const reverse: <T>(input: List<T>) => List<T>;
+export const reverse: <T>(input: List<T>) => List<T>;
 /** @type {<A>(a: List<A>) => <B>(b: List<B>) => Thunk<readonly[A, B]>} */
-declare const zip: <A>(a: List<A>) => <B>(b: List<B>) => Thunk<readonly [A, B]>;
-/** @type {<T>(e: Operator.Equal<T>) => (a: List<T>) => (b: List<T>) => boolean} */
-declare const equal: <T>(e: Operator.Equal<T>) => (a: List<T>) => (b: List<T>) => boolean;
-import * as Operator from '../function/operator/module.f.mjs';
+export const zip: <A>(a: List<A>) => <B>(b: List<B>) => Thunk<readonly [A, B]>;
+/** @type {<T>(e: operator.Equal<T>) => (a: List<T>) => (b: List<T>) => boolean} */
+export const equal: <T>(e: operator.Equal<T>) => (a: List<T>) => (b: List<T>) => boolean;
+export const empty: null;
+export type List<T> = NotLazy<T> | Thunk<T>;
+export type NotLazy<T> = Result<T> | Concat<T> | readonly T[];
+export type Empty = null;
+export type Result<T> = Empty | NonEmpty<T>;
+export type Thunk<T> = () => List<T>;
+export type NonEmpty<T> = {
+    readonly first: T;
+    readonly tail: List<T>;
+};
+export type Concat<T> = {
+    readonly head: List<T>;
+    readonly tail: List<T>;
+};
+export type Entry<T> = readonly [number, T];
+import * as function_ from '../function/module.f.mjs';
+import * as operator from '../function/operator/module.f.mjs';