functionalscript 0.3.4 → 0.3.6

package/types/byte_set/test.f.js

@@ -0,0 +1,122 @@
+import * as _ from "./module.f.js";
+import * as list from "../list/module.f.js";
+const { every, countdown, map, toArray } = list;
+import * as json from "../../json/module.f.js";
+import * as o from "../object/module.f.js";
+const { sort } = o;
+const stringify = json.stringify(sort);
+export default {
+    has: [
+        () => {
+            if (_.has(0)(_.empty)) {
+                throw _.empty;
+            }
+            if (_.has(1)(_.empty)) {
+                throw _.empty;
+            }
+            if (_.has(33)(_.empty)) {
+                throw _.empty;
+            }
+        },
+        () => {
+            const s = _.set(0)(_.empty);
+            if (s !== 1n) {
+                throw s;
+            }
+            if (!_.has(0)(s)) {
+                throw s;
+            }
+            if (_.has(1)(s)) {
+                throw s;
+            }
+            if (_.has(33)(s)) {
+                throw s;
+            }
+        },
+        () => {
+            const s = _.set(33)(_.empty);
+            if (s !== 8589934592n) {
+                throw s;
+            }
+            if (_.has(0)(s)) {
+                throw s;
+            }
+            if (_.has(1)(s)) {
+                throw s;
+            }
+            if (!_.has(33)(s)) {
+                throw s;
+            }
+        }
+    ],
+    setRange: () => {
+        const result = _.setRange([2, 5])(_.empty);
+        if (result !== 60n) {
+            throw result;
+        }
+    },
+    unset: [
+        () => {
+            const a = _.set(0)(_.empty);
+            const result = _.unset(0)(a);
+            if (result !== 0n) {
+                throw result;
+            }
+        },
+        () => {
+            const a = _.set(255)(_.empty);
+            const result = _.unset(255)(a);
+            if (result !== 0n) {
+                throw result;
+            }
+        }
+    ],
+    universe: () => {
+        const x = every(map((v) => _.has(v)(_.universe))(countdown(256)));
+        if (!x) {
+            throw x;
+        }
+    },
+    compliment: {
+        empty: () => {
+            const r = _.complement(_.empty);
+            if (r !== _.universe) {
+                throw r;
+            }
+        },
+        universe: () => {
+            const r = _.complement(_.universe);
+            if (r !== _.empty) {
+                throw r;
+            }
+        },
+    },
+    toRangeMap: [
+        () => {
+            const result = stringify(toArray(_.toRangeMap(_.empty)('a')));
+            if (result !== '[]') {
+                throw result;
+            }
+        },
+        () => {
+            const s = _.set(0)(_.empty);
+            const result = stringify(toArray(_.toRangeMap(s)('a')));
+            if (result !== '[[["a"],0]]') {
+                throw result;
+            }
+        },
+        () => {
+            const s = _.setRange([1, 2])(_.empty);
+            const result = stringify(toArray(_.toRangeMap(s)('a')));
+            if (result !== '[[[],0],[["a"],2]]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = stringify(toArray(_.toRangeMap(_.universe)('a')));
+            if (result !== '[[["a"],255]]') {
+                throw result;
+            }
+        },
+    ]
+};

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

@@ -0,0 +1,10 @@
+import * as Array from '../../array/module.f.ts';
+export type Index3 = Array.Index3;
+export type Index5 = Array.Index5;
+type Array2<T> = Array.Array2<T>;
+export type Sign = -1 | 0 | 1;
+export type Compare<T> = (_: T) => Sign;
+export declare const index3: <T>(cmp: Compare<T>) => (value: T) => Index3;
+export declare const index5: <T>(cmp: Compare<T>) => (v2: Array2<T>) => Index5;
+export declare const unsafeCmp: <T>(a: T) => (b: T) => Sign;
+export {};

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

@@ -0,0 +1,7 @@
+import * as Array from "../../array/module.f.js";
+export const index3 = cmp => value => (cmp(value) + 1);
+export const index5 = cmp => ([v0, v1]) => {
+    const _0 = cmp(v0);
+    return (_0 <= 0 ? _0 + 1 : cmp(v1) + 3);
+};
+export const unsafeCmp = a => b => a < b ? -1 : a > b ? 1 : 0;

package/types/function/compare/test.f.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => void;
+export default _default;

package/types/function/compare/test.f.js

@@ -0,0 +1,8 @@
+import * as _ from "./module.f.js";
+const { unsafeCmp } = _;
+export default () => {
+    const result = unsafeCmp(true)(false);
+    if (result !== 1) {
+        throw result;
+    }
+};

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

@@ -0,0 +1,28 @@
+/**
+ * A generic function type.
+ */
+type Func<I, O> = (_: I) => O;
+/**
+ * A postfix compose function.
+ */
+export declare const compose: <I, X>(g: Func<I, X>) => <O>(f: Func<X, O>) => Func<I, O>;
+/**
+ * A generic identity function.
+ */
+export declare const identity: <T>(value: T) => T;
+/**
+ * Flips the arguments of a curried function.
+ */
+export declare const flip: <A, B, C>(f: (a: A) => (b: B) => C) => (b: B) => (a: A) => C;
+/**
+ * A functional utility type that enables seamless chaining of transformations.
+ */
+type Fn<I, O> = {
+    readonly result: Func<I, O>;
+    readonly then: <T>(g: Func<O, T>) => Fn<I, T>;
+};
+/**
+ * Creates an `Fn` instance from a function, enabling chaining of transformations.
+ */
+export declare const fn: <I, O>(f: (i: I) => O) => Fn<I, O>;
+export {};

package/types/function/module.f.js

@@ -0,0 +1,19 @@
+/**
+ * A postfix compose function.
+ */
+export const compose = g => f => x => f(g(x));
+/**
+ * A generic identity function.
+ */
+export const identity = value => value;
+/**
+ * Flips the arguments of a curried function.
+ */
+export const flip = f => b => a => f(a)(b);
+/**
+ * Creates an `Fn` instance from a function, enabling chaining of transformations.
+ */
+export const fn = result => ({
+    result,
+    then: g => fn(compose(result)(g))
+});

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

@@ -0,0 +1,20 @@
+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>;
+export type Unary<T, R> = (value: T) => R;
+export declare const logicalNot: Unary<boolean, boolean>;
+export type Equal<T> = Binary<T, T, boolean>;
+export declare const strictEqual: <T>(a: T) => (b: 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 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 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

@@ -0,0 +1,18 @@
+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 => {
+    const [o, s] = op(prior)(i);
+    return [o, stateScanToScan(op)(s)];
+};
+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 addition = a => b => a + b;
+export const min = a => b => a < b ? a : b;
+export const max = a => b => a > b ? a : b;
+export const increment = addition(1);
+export const counter = () => increment;

package/types/function/test.f.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => void;
+export default _default;

package/types/function/test.f.js

@@ -0,0 +1,12 @@
+import * as _ from "./module.f.js";
+const { fn } = _;
+export default () => {
+    const f = x => [x];
+    const g = ([x]) => [x.length];
+    const w = ([x]) => x;
+    const r = fn(f).then(g).then(w).result;
+    const result = r('hello');
+    if (result !== 5) {
+        throw r;
+    }
+};

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

@@ -0,0 +1,50 @@
+import { type Scan, type StateScan, type Fold, type Reduce, type Equal } from '../function/operator/module.f.ts';
+export type List<T> = NotLazy<T> | Thunk<T>;
+type NotLazy<T> = Result<T> | Concat<T> | readonly T[];
+type Empty = null;
+export type Result<T> = Empty | NonEmpty<T>;
+export type Thunk<T> = () => List<T>;
+type NonEmpty<T> = {
+    readonly first: T;
+    readonly tail: List<T>;
+};
+type Concat<T> = {
+    readonly head: List<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 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>;
+export declare const map: <I, O>(f: (value: I) => O) => (input: List<I>) => Thunk<O>;
+export declare const flatMap: <I, O>(f: (value: I) => List<O>) => (input: List<I>) => Thunk<O>;
+export declare const filter: <T>(f: (value: T) => boolean) => (input: List<T>) => Thunk<T>;
+export declare const filterMap: <I, O>(f: (value: I) => O | null) => (input: List<I>) => Thunk<O>;
+export declare const takeWhile: <T>(f: (value: T) => boolean) => (input: List<T>) => Thunk<T>;
+export declare const take: (n: number) => <T>(input: List<T>) => Thunk<T>;
+export declare const dropWhile: <T>(f: (value: T) => boolean) => (input: List<T>) => Thunk<T>;
+export declare const drop: (n: number) => <T>(input: List<T>) => Thunk<T>;
+export declare const first: <D>(def: D) => <T>(input: List<T>) => D | T;
+export declare const last: <D>(first: D) => <T>(tail: List<T>) => D | T;
+export declare const find: <D>(def: D) => <T>(f: (value: T) => boolean) => (input: List<T>) => D | T;
+export declare const some: (input: List<boolean>) => boolean;
+export declare const isEmpty: <T>(input: List<T>) => boolean;
+export declare const every: (_: List<boolean>) => boolean;
+export declare const includes: <T>(value: T) => (sequence: List<T>) => boolean;
+export declare const countdown: (count: number) => Thunk<number>;
+export declare const repeat: <T>(v: T) => (c: number) => Thunk<T>;
+export declare const cycle: <T>(list: List<T>) => List<T>;
+export declare const scan: <I, O>(op: Scan<I, O>) => (input: List<I>) => Thunk<O>;
+export declare const stateScan: <I, S, O>(op: StateScan<I, S, O>) => (init: S) => (input: List<I>) => Thunk<O>;
+export declare const foldScan: <I, O>(op: Fold<I, O>) => (init: O) => (input: List<I>) => Thunk<O>;
+export declare const fold: <I, O>(op: Fold<I, O>) => (init: O) => (input: List<I>) => O;
+export declare const reduce: <T>(op: Reduce<T>) => <D>(def: D) => (input: List<T>) => D | T;
+export declare const length: <T>(input: List<T>) => number;
+export type Entry<T> = readonly [number, T];
+export declare const entries: <T>(input: List<T>) => Thunk<Entry<T>>;
+export declare const reverse: <T>(input: List<T>) => List<T>;
+export declare const zip: <A>(a: List<A>) => <B>(b: List<B>) => Thunk<readonly [A, B]>;
+export declare const equal: <T>(e: Equal<T>) => (a: List<T>) => (b: List<T>) => boolean;
+export declare const empty: null;
+export {};

package/types/list/module.f.js

@@ -0,0 +1,171 @@
+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;
+    return at(0);
+};
+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 => {
+    let tail = null;
+    while (true) {
+        head = trampoline(head);
+        if (head instanceof Array) {
+            head = fromArray(head);
+        }
+        else if (head !== null && 'head' in head) {
+            [head, tail] = [head.head, concat(head.tail)(tail)];
+            continue;
+        }
+        if (head !== null) {
+            return { first: head.first, tail: concat(head.tail)(tail) };
+        }
+        if (tail === null) {
+            return null;
+        }
+        [head, tail] = [tail, null];
+    }
+};
+export const iterable = list => ({
+    *[Symbol.iterator]() {
+        let i = list;
+        while (true) {
+            const r = next(i);
+            if (r === null) {
+                return;
+            }
+            yield r.first;
+            i = r.tail;
+        }
+    }
+});
+const { from } = Array;
+export const toArray = list => {
+    const u = trampoline(list);
+    return u instanceof Array ? u : from(iterable(u));
+};
+const apply = f => input => () => {
+    const n = next(input);
+    if (n === null) {
+        return null;
+    }
+    return f(n);
+};
+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) });
+export const map = f => apply(mapStep(f));
+export const flatMap = f => compose(map(f))(flat);
+const filterStep = f => ({ first, tail }) => {
+    const newTail = filter(f)(tail);
+    return f(first) ? { first, tail: newTail } : newTail;
+};
+export const filter = f => apply(filterStep(f));
+const filterMapStep = f => n => {
+    const [first, tail] = [f(n.first), filterMap(f)(n.tail)];
+    return first === null ? tail : { first, tail };
+};
+export const filterMap = f => apply(filterMapStep(f));
+const takeWhileStep = f => ({ first, tail }) => f(first) ? { first, tail: takeWhile(f)(tail) } : null;
+export const takeWhile = f => apply(takeWhileStep(f));
+const takeStep = n => ({ first, tail }) => 0 < n ? { first: first, tail: take(n - 1)(tail) } : null;
+export const take = n => apply(takeStep(n));
+const dropWhileStep = f => ne => f(ne.first) ? dropWhile(f)(ne.tail) : ne;
+export const dropWhile = f => apply(dropWhileStep(f));
+const dropStep = n => ne => 0 < n ? drop(n - 1)(ne.tail) : ne;
+export const drop = n => apply(dropStep(n));
+export const first = def => input => {
+    const ne = next(input);
+    return ne === null ? def : ne.first;
+};
+export const last = first => tail => {
+    let i = { first, tail };
+    while (true) {
+        const result = next(i.tail);
+        if (result === null) {
+            return i.first;
+        }
+        i = result;
+    }
+};
+export const find = def => f => compose(filter(f))(first(def));
+export const some = find(false)(identity);
+export const isEmpty = fn(map(() => true))
+    .then(some)
+    .then(logicalNot)
+    .result;
+export const every = fn(map(logicalNot))
+    .then(some)
+    .then(logicalNot)
+    .result;
+export const includes = value => compose(map(strictEqual(value)))(some);
+export const countdown = count => () => {
+    if (count <= 0) {
+        return null;
+    }
+    const first = count - 1;
+    return { first, tail: countdown(first) };
+};
+export const repeat = v => compose(countdown)(map(() => v));
+export const cycle = list => () => {
+    const i = next(list);
+    return i === null ? null : { first: i.first, tail: concat(i.tail)(cycle(list)) };
+};
+const scanStep = op => ne => {
+    const [first, newOp] = op(ne.first);
+    return { first, tail: scan(newOp)(ne.tail) };
+};
+export const scan = op => apply(scanStep(op));
+export const stateScan = op => compose(stateScanToScan(op))(scan);
+export const foldScan = op => compose(foldToScan(op))(scan);
+export const fold = op => init => compose(foldScan(op)(init))(last(init));
+export const reduce = op => def => compose(scan(reduceToScan(op)))(last(def));
+const lengthList = list => () => {
+    const notLazy = trampoline(list);
+    if (notLazy === null) {
+        return null;
+    }
+    if (notLazy instanceof Array) {
+        return [notLazy.length];
+    }
+    const tail = lengthList(notLazy.tail);
+    if ('first' in notLazy) {
+        return { first: 1, tail };
+    }
+    return { head: lengthList(notLazy.head), tail };
+};
+const sum = reduce(addition)(0);
+export const length = input => sum(lengthList(input));
+const entryOperator = index => value => [[index, value], index + 1];
+export const entries = input => {
+    const o = entryOperator;
+    return stateScan(o)(0)(input);
+};
+const reverseOperator = first => tail => ({ first, tail });
+export const reverse = fold(reverseOperator)(null);
+export const zip = a => b => () => {
+    const aResult = next(a);
+    if (aResult === null) {
+        return null;
+    }
+    const bResult = next(b);
+    if (bResult === null) {
+        return null;
+    }
+    return { first: [aResult.first, bResult.first], tail: zip(aResult.tail)(bResult.tail) };
+};
+export const equal = e => {
+    const f = a => b => () => {
+        const [aResult, bResult] = [next(a), next(b)];
+        return aResult === null || bResult === null
+            ? { first: aResult === bResult, tail: null }
+            : { first: e(aResult.first)(bResult.first), tail: f(aResult.tail)(bResult.tail) };
+    };
+    return a => b => every(f(a)(b));
+};
+export const empty = null;

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

@@ -0,0 +1,22 @@
+declare const _default: {
+    stringifyTest: () => void;
+    cycle: () => void;
+    countdown: () => void;
+    flat: () => void;
+    concat: () => void;
+    flatMap: () => void;
+    take: (() => void)[];
+    find: (() => void)[];
+    takeWhile: (() => void)[];
+    dropWhile: () => void;
+    drop: (() => void)[];
+    additionTests: (() => void)[];
+    entries: (() => void)[];
+    reverse: (() => void)[];
+    zip: (() => void)[];
+    logic: () => (() => void)[];
+    strictEqual: (() => void)[];
+    isEmpty: (() => void)[];
+    length: () => void;
+};
+export default _default;