functionalscript 0.8.0 → 0.8.2

package/types/list/test.f.js

@@ -1,35 +1,35 @@
-import * as _ from "./module.f.js";
-import * as json from "../../json/module.f.js";
+import { length, concat, countdown, cycle, drop, dropWhile, entries, every, filter, find, flat, flatMap, map, next, reduce, reverse, scan, some, take, takeWhile, toArray, zip, first, filterMap, isEmpty, equal } from "./module.f.js";
+import { stringify } from "../../json/module.f.js";
 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 str = sequence => stringify(sort)(toArray(sequence));
 const stringifyTest = () => {
-    const s = stringify([1, 2, 3]);
+    const s = str([1, 2, 3]);
     if (s !== '[1,2,3]') {
         throw s;
     }
 };
-const cycle = () => {
-    const x = stringify(_.toArray(_.take(10)(_.cycle([1, 2, 3]))));
+const cycleTest = () => {
+    const x = str(toArray(take(10)(cycle([1, 2, 3]))));
     if (x !== '[1,2,3,1,2,3,1,2,3,1]') {
         throw x;
     }
 };
-const countdown = () => {
-    const result = stringify(_.countdown(10));
+const countdownTest = () => {
+    const result = str(countdown(10));
     if (result !== '[9,8,7,6,5,4,3,2,1,0]') {
         throw result;
     }
 };
-const flat = () => {
-    const result = stringify(_.flat([[1, 2, 3], [4, 5], [6], [], [7, 8, 9]]));
+const flatTest = () => {
+    const result = str(flat([[1, 2, 3], [4, 5], [6], [], [7, 8, 9]]));
     if (result !== '[1,2,3,4,5,6,7,8,9]') {
         throw result;
     }
 };
-const concat = () => {
-    const result = _.concat([1])([2]);
-    const x = _.next(result);
+const concatTest = () => {
+    const result = concat([1])([2]);
+    const x = next(result);
     if (x === null) {
         throw x;
     }
@@ -37,81 +37,81 @@ const concat = () => {
         throw x;
     }
 };
-const flatMap = () => {
-    const result = stringify(_.flatMap((x) => [x, x * 2, x * 3])([0, 1, 2, 3]));
+const flatMapTest = () => {
+    const result = str(flatMap((x) => [x, x * 2, x * 3])([0, 1, 2, 3]));
     if (result !== '[0,0,0,1,2,3,2,4,6,3,6,9]') {
         throw result;
     }
 };
-const take = [
+const takeTest = [
     () => {
-        const result = stringify(_.take(3)([1, 2, 3, 4, 5, 6, 7, 8, 9]));
+        const result = str(take(3)([1, 2, 3, 4, 5, 6, 7, 8, 9]));
         if (result !== '[1,2,3]') {
             throw result;
         }
     },
     () => {
-        const result = stringify(_.take(20)([1, 2, 3, 4, 5, 6, 7, 8, 9]));
+        const result = str(take(20)([1, 2, 3, 4, 5, 6, 7, 8, 9]));
         if (result !== '[1,2,3,4,5,6,7,8,9]') {
             throw result;
         }
     },
     () => {
-        const result = stringify(_.take(0)([1, 2, 3, 4, 5, 6, 7, 8, 9]));
+        const result = str(take(0)([1, 2, 3, 4, 5, 6, 7, 8, 9]));
         if (result !== '[]') {
             throw result;
         }
     }
 ];
-const find = [
+const findTest = [
     () => {
-        const result = _.find(null)((x) => x % 2 === 0)([1, 3, 5, 7]);
+        const result = find(null)((x) => x % 2 === 0)([1, 3, 5, 7]);
         if (result !== null) {
             throw result;
         }
     },
     () => {
-        const result = _.find(null)((x) => x % 2 === 0)([1, 2, 3, 4]);
+        const result = find(null)((x) => x % 2 === 0)([1, 2, 3, 4]);
         if (result !== 2) {
             throw result;
         }
     }
 ];
-const takeWhile = [
+const takeWhileTest = [
     () => {
-        const result = stringify(_.takeWhile((x) => x < 10)([1, 2, 3, 4, 5, 10, 11]));
+        const result = str(takeWhile((x) => x < 10)([1, 2, 3, 4, 5, 10, 11]));
         if (result !== '[1,2,3,4,5]') {
             throw result;
         }
     },
     () => {
-        const result = stringify(_.takeWhile((x) => x < 6)([1, 2, 3, 4, 5, 6, 7, 8, 9]));
+        const result = str(takeWhile((x) => x < 6)([1, 2, 3, 4, 5, 6, 7, 8, 9]));
         if (result !== '[1,2,3,4,5]') {
             throw result;
         }
     }
 ];
-const dropWhile = () => {
-    const result = stringify(_.dropWhile((x) => x < 10)([1, 2, 3, 4, 5, 10, 11]));
+const dropWhileTest = () => {
+    const result = str(dropWhile((x) => x < 10)([1, 2, 3, 4, 5, 10, 11]));
     if (result !== '[10,11]') {
         throw result;
     }
 };
-const drop = [
+const dropTest = [
     () => {
-        const result = stringify(_.drop(3)([1, 2, 3, 4, 5, 10, 11]));
+        const result = str(drop(3)([1, 2, 3, 4, 5, 10, 11]));
         if (result !== '[4,5,10,11]') {
             throw result;
         }
     },
     () => {
-        const result = stringify(_.drop(0)([1, 2, 3, 4, 5, 10, 11]));
+        const result = str(drop(0)([1, 2, 3, 4, 5, 10, 11]));
         if (result !== '[1,2,3,4,5,10,11]') {
             throw result;
         }
     },
     () => {
-        const result = stringify(_.drop(10)([1, 2, 3, 4, 5, 10, 11]));
+        const result = str(drop(10)([1, 2, 3, 4, 5, 10, 11]));
         if (result !== '[]') {
             throw result;
         }
@@ -120,101 +120,101 @@ const drop = [
 const additionTests = [
     () => {
         const op = reduceToScan(addition);
-        const result = stringify(_.scan(op)([2, 3, 4, 5]));
+        const result = str(scan(op)([2, 3, 4, 5]));
         if (result !== '[2,5,9,14]') {
             throw result;
         }
     },
     () => {
-        const result = _.reduce(addition)(null)([2, 3, 4, 5]);
+        const result = reduce(addition)(null)([2, 3, 4, 5]);
         if (result !== 14) {
             throw result;
         }
     },
     () => {
-        const result = _.reduce(addition)(null)([]);
+        const result = reduce(addition)(null)([]);
         if (result !== null) {
             throw result;
         }
     }
 ];
-const entries = [
+const entriesTest = [
     () => {
-        const result = stringify(_.entries([]));
+        const result = str(entries([]));
         if (result !== '[]') {
             throw result;
         }
     },
     () => {
-        const result = stringify(_.entries(['hello', 'world']));
+        const result = str(entries(['hello', 'world']));
         if (result !== '[[0,"hello"],[1,"world"]]') {
             throw result;
         }
     }
 ];
-const reverse = [
+const reverseTest = [
     () => {
-        const result = stringify(_.reverse([]));
+        const result = str(reverse([]));
         if (result !== '[]') {
             throw result;
         }
     },
     () => {
-        const result = stringify(_.reverse([1, 2, 3, 4, 5]));
+        const result = str(reverse([1, 2, 3, 4, 5]));
         if (result !== '[5,4,3,2,1]') {
             throw result;
         }
     }
 ];
-const zip = [
+const zipTest = [
     () => {
-        const result = stringify(_.zip([0, 1, 2])(['a', 'b', 'c', 'd']));
+        const result = str(zip([0, 1, 2])(['a', 'b', 'c', 'd']));
         if (result !== '[[0,"a"],[1,"b"],[2,"c"]]') {
             throw result;
         }
     },
     () => {
-        const result = stringify(_.zip([0, 1, 2])(['a', 'b']));
+        const result = str(zip([0, 1, 2])(['a', 'b']));
         if (result !== '[[0,"a"],[1,"b"]]') {
             throw result;
         }
     }
 ];
 const logic = () => {
-    const map5 = _.map((x) => x > 5);
+    const map5 = map((x) => x > 5);
     return [
         () => {
-            const result = _.some(map5([0, 1, 7]));
+            const result = some(map5([0, 1, 7]));
             if (!result) {
                 throw result;
             }
         },
         () => {
-            const result = _.some(map5([0, 1, 4]));
+            const result = some(map5([0, 1, 4]));
             if (result) {
                 throw result;
             }
         },
         () => {
-            const result = _.some(map5([]));
+            const result = some(map5([]));
             if (result) {
                 throw result;
             }
         },
         () => {
-            const result = _.every(map5([0, 1, 7]));
+            const result = every(map5([0, 1, 7]));
             if (result) {
                 throw result;
             }
         },
         () => {
-            const result = _.every(map5([6, 11, 7]));
+            const result = every(map5([6, 11, 7]));
             if (!result) {
                 throw result;
             }
         },
         () => {
-            const result = _.every(map5([]));
+            const result = every(map5([]));
             if (!result) {
                 throw result;
             }
@@ -226,11 +226,11 @@ const stress = () => ({
     toArray: () => {
         // 200_000_000 is too much
         const n = 100_000_000;
-        const result = _.toArray(_.countdown(n));
+        const result = toArray(countdown(n));
         if (result.length !== n) {
             throw result.length;
         }
-        const len = _.length(_.filter((x) => x > n)(result));
+        const len = length(filter((x) => x > n)(result));
         if (len !== 0) {
             throw len;
         }
@@ -238,13 +238,13 @@ const stress = () => ({
     first: () => {
         // 100_000_000 is too much
         const n = 50_000_000;
-        const result = _.toArray(_.countdown(n));
+        const result = toArray(countdown(n));
         if (result.length !== n) {
             throw result.length;
         }
-        const first = _.first(null)(result);
-        if (first !== n - 1) {
-            throw first;
+        const f = first(null)(result);
+        if (f !== n - 1) {
+            throw f;
         }
     },
     concatBack: () => {
@@ -252,50 +252,50 @@ const stress = () => ({
         // 20_000_000 is too much
         // 10_000_000 is too much for Deno 1
         for (let i = 0; i < 5_000_000; ++i) {
-            sequence = _.concat(sequence)([i]);
+            sequence = concat(sequence)([i]);
         }
-        const r = _.toArray(sequence);
+        const r = toArray(sequence);
     },
     flatToArray: () => {
         let sequence = [];
         // 4_000_000 is too much
         for (let i = 0; i < 2_000_000; ++i) {
-            sequence = _.flat([sequence, [i]]);
+            sequence = flat([sequence, [i]]);
         }
-        const r = _.toArray(sequence);
+        const r = toArray(sequence);
     },
     flatNext: () => {
         let sequence = [];
         // 4_000_000 is too much
         for (let i = 0; i < 2_000_000; ++i) {
-            sequence = _.flat([sequence, [i]]);
+            sequence = flat([sequence, [i]]);
         }
-        const a = _.next(sequence);
+        const a = next(sequence);
     },
     concatFront: () => {
         let sequence = [];
         // 20_000_000 is too much
         for (let i = 0; i < 10_000_000; ++i) {
-            sequence = _.concat([i])(sequence);
+            sequence = concat([i])(sequence);
         }
-        const a = _.next(sequence);
+        const a = next(sequence);
     },
     flatFront: () => {
         let sequence = [];
         // 10_000_000 is too much
         for (let i = 0; i < 5_000_000; ++i) {
-            sequence = _.flat([[i], sequence]);
+            sequence = flat([[i], sequence]);
         }
-        const a = _.next(sequence);
+        const a = next(sequence);
     },
     filterMap: () => {
         // 100_000_000 is too much
         const n = 50_000_000;
-        const result = _.toArray(_.countdown(n));
+        const result = toArray(countdown(n));
         if (result.length !== n) {
             throw result.length;
         }
-        const len = _.length(_.filterMap(() => null)(result));
+        const len = length(filterMap(() => null)(result));
         if (len !== 0) {
             throw len;
         }
@@ -303,11 +303,11 @@ const stress = () => ({
     dropWhile: () => {
         // 50_000_000 is too much
         const n = 20_000_000;
-        const result = _.toArray(_.countdown(n));
+        const result = toArray(countdown(n));
         if (result.length !== n) {
             throw result.length;
         }
-        const len = _.length(_.dropWhile(() => true)(result));
+        const len = length(dropWhile(() => true)(result));
         if (len !== 0) {
             throw len;
         }
@@ -315,7 +315,7 @@ const stress = () => ({
     reverse: () => {
         // 10_000_000 is too much
         const n = 5_000_000;
-        const result = _.toArray(_.reverse(_.countdown(n)));
+        const result = toArray(reverse(countdown(n)));
         if (result.length !== n) {
             throw result.length;
         }
@@ -323,42 +323,42 @@ const stress = () => ({
 });
 export default {
     stringifyTest,
-    cycle,
-    countdown,
-    flat,
-    concat,
-    flatMap,
-    take,
-    find,
-    takeWhile,
-    dropWhile,
-    drop,
+    cycle: cycleTest,
+    countdown: countdownTest,
+    flat: flatTest,
+    concat: concatTest,
+    flatMap: flatMapTest,
+    take: takeTest,
+    find: findTest,
+    takeWhile: takeWhileTest,
+    dropWhile: dropWhileTest,
+    drop: dropTest,
     additionTests,
-    entries,
-    reverse,
-    zip,
+    entries: entriesTest,
+    reverse: reverseTest,
+    zip: zipTest,
     logic,
     strictEqual: [
         () => {
-            const result = _.equal(strictEqual)([1])([2, 3]);
+            const result = equal(strictEqual)([1])([2, 3]);
             if (result) {
                 throw result;
             }
         },
         () => {
-            const result = _.equal(strictEqual)([1, 3])([1]);
+            const result = equal(strictEqual)([1, 3])([1]);
             if (result) {
                 throw result;
             }
         },
         () => {
-            const result = _.equal(strictEqual)([15, 78])([15, 78]);
+            const result = equal(strictEqual)([15, 78])([15, 78]);
             if (!result) {
                 throw result;
             }
         },
         () => {
-            const result = _.equal(strictEqual)([])([]);
+            const result = equal(strictEqual)([])([]);
             if (!result) {
                 throw result;
             }
@@ -366,26 +366,26 @@ export default {
     ],
     isEmpty: [
         () => {
-            const result = _.isEmpty(() => []);
+            const result = isEmpty(() => []);
             if (result !== true) {
                 throw result;
             }
         },
         () => {
-            const result = _.isEmpty(() => [2]);
+            const result = isEmpty(() => [2]);
             if (result !== false) {
                 throw result;
             }
         }
     ],
     length: () => {
-        if (_.length([1, 2, 3]) !== 3) {
+        if (length([1, 2, 3]) !== 3) {
             throw 3;
         }
-        if (_.length(null) !== 0) {
+        if (length(null) !== 0) {
             throw 0;
         }
-        if (_.length(_.flat([[1, 3], null, () => [3], _.concat([12])([4, 89])])) !== 6) {
+        if (length(flat([[1, 3], null, () => [3], concat([12])([4, 89])])) !== 6) {
             throw 6;
         }
     },

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

@@ -1,4 +1,4 @@
-import type { Reduce } from '../function/operator/module.f.ts';
+import type { Fold, Reduce } from '../function/operator/module.f.ts';
 /**
  * Represents a monoid, an algebraic structure with a binary operation
  * and an identity (neutral) element.
@@ -62,14 +62,14 @@ export type Monoid<T> = {
  *     operation: a => b => a + b,
  * };
  *
- * const resultAdd = repeat(add)(2)(10n) // 20
+ * const resultAdd = repeat(add)(10n)(2) // 20
  *
  * const concat: Monoid<string> = {
  *     identity: '',
  *     operation: a => b => a + b,
  * };
  *
- * const resultConcat = repeat(concat)('ha')(3n) // 'hahaha'
+ * const resultConcat = repeat(concat)(3n)('ha') // 'hahaha'
  * ```
  */
-export declare const repeat: <T>({ identity, operation }: Monoid<T>) => (a: T) => (n: bigint) => T;
+export declare const repeat: <T>({ identity, operation }: Monoid<T>) => Fold<bigint, T>;

package/types/monoid/module.f.js

@@ -17,17 +17,17 @@
  *     operation: a => b => a + b,
  * };
  *
- * const resultAdd = repeat(add)(2)(10n) // 20
+ * const resultAdd = repeat(add)(10n)(2) // 20
  *
  * const concat: Monoid<string> = {
  *     identity: '',
  *     operation: a => b => a + b,
  * };
  *
- * const resultConcat = repeat(concat)('ha')(3n) // 'hahaha'
+ * const resultConcat = repeat(concat)(3n)('ha') // 'hahaha'
  * ```
  */
-export const repeat = ({ identity, operation }) => (a) => (n) => {
+export const repeat = ({ identity, operation }) => n => a => {
     let ai = a;
     let ni = n;
     let result = identity;

package/types/monoid/test.f.js

@@ -5,11 +5,11 @@ export default {
             identity: 0,
             operation: a => b => a + b,
         };
-        const resultAdd = repeat(add)(2)(10n); // 20
+        const resultAdd = repeat(add)(10n)(2); // 20
         if (resultAdd !== 20) {
             throw resultAdd;
         }
-        const id = repeat(add)(42)(0n);
+        const id = repeat(add)(0n)(42);
         if (id !== 0) {
             throw id;
         }
@@ -19,7 +19,7 @@ export default {
             identity: '',
             operation: a => b => a + b,
         };
-        const resultConcat = repeat(concat)('ha')(3n); // 'hahaha'
+        const resultConcat = repeat(concat)(3n)('ha'); // 'hahaha'
         if (resultConcat !== 'hahaha') {
             throw resultConcat;
         }

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

@@ -0,0 +1,5 @@
+export type Nominal<N extends string, R extends string, B> = symbol & {
+    [k in N]: readonly [R, B];
+};
+export declare const asNominal: <N extends string, R extends string, B>(b: B) => Nominal<N, R, B>;
+export declare const asBase: <T extends string, R extends string, B>(n: Nominal<T, R, B>) => B;

package/types/nominal/module.f.js

@@ -0,0 +1,4 @@
+/// note: It should compiles into `identity` and no-ops at runtime.
+export const asNominal = (b) => b;
+/// note: It should compiles into `identity` and no-ops at runtime.
+export const asBase = (n) => n;

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

@@ -0,0 +1,5 @@
+declare const _default: {
+    pre: () => void;
+    nominal: () => void;
+};
+export default _default;

package/types/nominal/test.f.js

@@ -0,0 +1,53 @@
+import { asBase, asNominal } from "./module.f.js";
+export default {
+    pre: () => {
+        const strA = asNominal(7560413859n); // "¢£"
+        const strB = asNominal(7560413860n); // "¢¤"
+        if (strA === strB) {
+            throw [strA, strB];
+        }
+        // // TypeScript compilation error.
+        // const x1 = strA > strB
+        //
+        {
+            const a = { value: 1 };
+            const b = { value: 2 };
+            // No Compile-time error
+            if (a < b) { }
+        }
+        {
+            const x = { _brand: 'NoCompare' };
+            // No Error
+            if (x < x) { }
+        }
+        {
+            const a = {};
+            const b = {};
+            // No Error
+            a < b;
+        }
+        {
+            const a = undefined;
+            const b = undefined;
+            // a < b; // TS2469: Operator '<' cannot be applied to type 'symbol'.
+        }
+    },
+    nominal: () => {
+        const userIdA = asNominal(123);
+        const userIdB = asNominal(456);
+        if (userIdA === userIdB) {
+            throw [userIdA, userIdB];
+        }
+        const to = asBase;
+        const to2 = asBase;
+        const userId2A = asNominal(123);
+        const userId2B = asNominal(456);
+        if (userId2A === userId2B) {
+            throw [userId2A, userId2B];
+        }
+        // if (userIdA === userId2A) { throw [userIdA, userId2A] } // compilation error
+        const n1 = to(userIdA);
+        const n2 = to2(userId2A);
+        // const x = to(userId2A) // compilation error
+    }
+};

package/types/number/module.f.js

@@ -1,10 +1,10 @@
 import { reduce } from "../list/module.f.js";
 import { addition, min as minOp, max as maxOp } from "../function/operator/module.f.js";
-import { unsafeCmp } from "../function/compare/module.f.js";
+import { cmp as uCmp } from "../function/compare/module.f.js";
 export const sum = reduce(addition)(0);
 export const min = reduce(minOp)(null);
 export const max = reduce(maxOp)(null);
-export const cmp = unsafeCmp;
+export const cmp = uCmp;
 const mo = [
     [0x5555_5555, 1],
     [0x3333_3333, 2],

package/{crypto → types}/prime_field/module.f.d.ts

@@ -1,4 +1,4 @@
-import type { Unary, Reduce } from '../../types/bigint/module.f.ts';
+import type { Unary, Reduce } from '../bigint/module.f.ts';
 /**
  * A type representing a prime field and its associated operations.
  */
@@ -37,4 +37,4 @@ export declare const prime_field: (p: bigint) => PrimeField;
  * if (root !== 2n) { throw root }
  * ```
  */
-export declare const sqrt: ({ p, mul, pow }: PrimeField) => (a: bigint) => bigint | null;
+export declare const sqrt: ({ p, pow, pow2 }: PrimeField) => (a: bigint) => bigint | null;

package/{crypto → types}/prime_field/module.f.js

@@ -1,4 +1,4 @@
-import { repeat } from "../../types/monoid/module.f.js";
+import { repeat } from "../monoid/module.f.js";
 /**
  * Creates a prime field with the specified prime modulus and associated operations.
  *
@@ -65,13 +65,14 @@ export const prime_field = (p) => {
  * if (root !== 2n) { throw root }
  * ```
  */
-export const sqrt = ({ p, mul, pow }) => {
+export const sqrt = ({ p, pow, pow2 }) => {
     if ((p & 3n) !== 3n) {
         throw 'sqrt';
     }
     const sqrt_k = (p + 1n) >> 2n;
+    const psk = pow(sqrt_k);
     return a => {
-        const result = pow(a)(sqrt_k);
-        return mul(result)(result) === a ? result : null;
+        const result = psk(a);
+        return pow2(result) === a ? result : null;
     };
 };