functionalscript 0.2.0 → 0.2.2

package/out/types/sorted_list/test.f.mjs

@@ -0,0 +1,66 @@
+import * as _ from './module.f.mjs';
+import * as compare from '../function/compare/module.f.mjs';
+const { unsafeCmp } = compare;
+import * as json from '../../json/module.f.mjs';
+import * as object from '../object/module.f.mjs';
+const { sort } = object;
+import * as list from '../list/module.f.mjs';
+const { toArray, countdown, length } = list;
+import * as Map from '../map/module.f.mjs';
+import * as f from '../function/module.f.mjs';
+const { flip } = f;
+/** @type {(a: readonly json.Unknown[]) => string} */
+const stringify = json.stringify(sort);
+/** @type {<T>(a: T) => (b: T) => Map.Sign} */
+const reverseCmp = flip(unsafeCmp);
+export default {
+    sortedMergre: [
+        () => {
+            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])([])));
+            if (result !== '[1,2,3]') {
+                throw result;
+            }
+        },
+        () => {
+            const n = 10_000;
+            const list = countdown(n);
+            const result = _.merge(reverseCmp)(list)(list);
+            const len = length(result);
+            if (len != n) {
+                throw result;
+            }
+        }
+    ],
+    find: [
+        () => {
+            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]);
+            if (result !== null) {
+                throw result;
+            }
+        },
+        () => {
+            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]);
+            if (result !== 80) {
+                throw result;
+            }
+        }
+    ]
+};

package/out/types/sorted_set/module.f.mjs

@@ -0,0 +1,29 @@
+// @ts-self-types="./module.f.d.mts"
+import * as Compare from '../function/compare/module.f.mjs';
+import * as list from "../list/module.f.mjs";
+const { toArray } = list;
+import * as sortedList from '../sorted_list/module.f.mjs';
+const { merge, genericMerge, find } = sortedList;
+/**
+ * @template T
+ * @typedef {readonly T[]} SortedSet
+ */
+/**
+ * @template T
+ * @typedef {(a: T) => (b: T) => Compare.Sign} Cmp
+ */
+/** @typedef {number} Byte */
+/** @type {<T>(cmp: Cmp<T>) => (a: SortedSet<T>) => (b: SortedSet<T>) => SortedSet<T>} */
+export const union = cmp => a => b => toArray(merge(cmp)(a)(b));
+/** @type {<T>(cmp: Cmp<T>) => (a: SortedSet<T>) => (b: SortedSet<T>) => SortedSet<T>} */
+export const intersect = cmp => a => b => toArray(intersectMerge(cmp)(a)(b));
+const tailReduce = () => () => null;
+/** @type {<T>(cmp: Cmp<T>) => (a: sortedList.SortedList<T>) => (b: sortedList.SortedList<T>) => sortedList.SortedList<T>} */
+const intersectMerge = cmp => genericMerge({ reduceOp: intersectReduce(cmp), tailReduce })(null);
+/** @type {<T,S>(cmp: Cmp<T>) => sortedList.ReduceOp<T,S>} */
+const intersectReduce = cmp => state => a => b => {
+    const sign = cmp(a)(b);
+    return [sign === 0 ? a : null, sign, state];
+};
+/** @type {<T>(cmp: Cmp<T>) => (value: T) => (set: SortedSet<T>) => boolean} */
+export const has = cmp => value => set => find(cmp)(value)(set) === value;

package/out/types/sorted_set/test.f.mjs

@@ -0,0 +1,80 @@
+import * as _ from './module.f.mjs';
+import * as compare from '../function/compare/module.f.mjs';
+const { unsafeCmp } = compare;
+import * as json from '../../json/module.f.mjs';
+import * as object from '../object/module.f.mjs';
+const { sort } = object;
+import * as list from '../list/module.f.mjs';
+const { toArray, countdown, length } = list;
+import * as Map from '../map/module.f.mjs';
+import * as f from '../function/module.f.mjs';
+const { flip } = f;
+/** @type {(a: readonly json.Unknown[]) => string} */
+const stringify = a => json.stringify(sort)(a);
+/** @type {<T>(a: T) => (b: T) => Map.Sign} */
+const reverseCmp = flip(unsafeCmp);
+export default {
+    union: [
+        () => {
+            const result = stringify(toArray(_.union(unsafeCmp)([2, 3, 4])([1, 3, 5])));
+            if (result !== '[1,2,3,4,5]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = stringify(toArray(_.union(unsafeCmp)([1, 2, 3])([])));
+            if (result !== '[1,2,3]') {
+                throw result;
+            }
+        },
+        () => {
+            const n = 10_000;
+            const sortedSet = toArray(countdown(n));
+            const result = _.union(reverseCmp)(sortedSet)(sortedSet);
+            const len = length(result);
+            if (len != n) {
+                throw result;
+            }
+        }
+    ],
+    intersect: [
+        () => {
+            const result = stringify(toArray(_.intersect(unsafeCmp)([2, 3, 4])([1, 3, 5])));
+            if (result !== '[3]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = stringify(toArray(_.intersect(unsafeCmp)([1, 2, 3])([])));
+            if (result !== '[]') {
+                throw result;
+            }
+        }
+    ],
+    has: [
+        () => {
+            const result = _.has(unsafeCmp)(0)([0, 10, 20, 30, 40, 50, 60, 70, 80, 90]);
+            if (!result) {
+                throw result;
+            }
+        },
+        () => {
+            const result = _.has(unsafeCmp)(3)([0, 10, 20, 30, 40, 50, 60, 70, 80, 90]);
+            if (result) {
+                throw result;
+            }
+        },
+        () => {
+            const result = _.has(unsafeCmp)(77)([0, 10, 20, 30, 40, 50, 60, 70, 80, 90]);
+            if (result) {
+                throw result;
+            }
+        },
+        () => {
+            const result = _.has(unsafeCmp)(80)([0, 10, 20, 30, 40, 50, 60, 70, 80, 90]);
+            if (!result) {
+                throw result;
+            }
+        }
+    ]
+};

package/out/types/string/module.f.mjs

@@ -0,0 +1,17 @@
+// @ts-self-types="./module.f.d.mts"
+import * as list from '../list/module.f.mjs';
+const { reduce: listReduce, repeat: listRepeat } = list;
+import * as f from '../function/module.f.mjs';
+const { compose } = f;
+import * as compare from '../function/compare/module.f.mjs';
+const { unsafeCmp } = compare;
+import * as op from '../function/operator/module.f.mjs';
+const { join: joinOp, concat: concatOp } = op;
+/** @type {(o: op.Reduce<string>) => (input: list.List<string>) => string} */
+const reduce = o => listReduce(o)('');
+export const join = compose(joinOp)(reduce);
+export const concat = reduce(concatOp);
+/** @type {(n: string) => (v: number) => string} */
+export const repeat = v => compose(listRepeat(v))(concat);
+/** @type {(a: string) => (b: string) => compare.Sign} */
+export const cmp = unsafeCmp;

package/out/types/string/test.f.mjs

@@ -0,0 +1,58 @@
+import * as _ from './module.f.mjs';
+const { join, concat, repeat, cmp } = _;
+import * as list from '../list/module.f.mjs';
+const { repeat: repeatList } = list;
+export default {
+    join: {
+        0: () => {
+            const result = join('/')([]);
+            if (result !== '') {
+                throw result;
+            }
+        },
+        1: () => {
+            const result = join('/')(['']);
+            if (result !== '') {
+                throw result;
+            }
+        },
+        3: () => {
+            const result = join(' ')(['hello', 'world', '!']);
+            if (result !== 'hello world !') {
+                throw result;
+            }
+        }
+    },
+    concat: () => {
+        const result = concat(['hello', 'world']);
+        if (result !== 'helloworld') {
+            throw result;
+        }
+    },
+    repeatList: {
+        0: () => {
+            const s = join('.')(repeatList('x')(0));
+            if (s != '') {
+                throw s;
+            }
+        },
+        5: () => {
+            const s = join('.')(repeatList('x')(5));
+            if (s != 'x.x.x.x.x') {
+                throw s;
+            }
+        }
+    },
+    repeat: () => {
+        const s = repeat('x')(5);
+        if (s != 'xxxxx') {
+            throw s;
+        }
+    },
+    cmp: () => {
+        const result = cmp('3')('4');
+        if (result !== -1) {
+            throw result;
+        }
+    }
+};

package/out/types/string_set/module.f.mjs

@@ -0,0 +1,29 @@
+// @ts-self-types="./module.f.d.mts"
+import * as BtreeTypes from '../btree/types/module.f.mjs';
+import * as btree from '../btree/module.f.mjs';
+import * as btf from '../btree/find/module.f.mjs';
+const { find, isFound } = btf;
+import * as btr from '../btree/remove/module.f.mjs';
+const { remove: btreeRemove } = btr;
+import * as bts from '../btree/set/module.f.mjs';
+const { set: btreeSet } = bts;
+export const { 
+/** @type {(s: StringSet) => list.List<string>} */
+values, empty, } = btree;
+import * as string from "../string/module.f.mjs";
+const { cmp } = string;
+import * as list from '../list/module.f.mjs';
+const { fold } = list;
+import * as f from '../function/module.f.mjs';
+const { compose } = f;
+/** @typedef {BtreeTypes.Tree<string>} StringSet */
+/** @type {(value: string) => (set: StringSet) => boolean} */
+export const contains = value => {
+    const f = find(cmp(value));
+    return s => s !== null && isFound(f(s).first);
+};
+/** @type {(value: string) => (s: StringSet) => StringSet} */
+export const set = value => btreeSet(cmp(value))(() => value);
+export const fromValues = fold(set)(null);
+/** @type {(value: string) => (s: StringSet) => StringSet} */
+export const remove = compose(cmp)(btreeRemove);

package/out/types/string_set/test.f.mjs

@@ -0,0 +1,65 @@
+import * as _ from './module.f.mjs';
+export default {
+    contains: () => {
+        const r = _.set('hello')(null);
+        if (!_.contains('hello')(r)) {
+            throw r;
+        }
+        if (_.contains('hello1')(r)) {
+            throw r;
+        }
+    },
+    remove: () => {
+        let r = _.set('hello')(null);
+        r = _.set('world')(r);
+        r = _.set('HELLO')(r);
+        r = _.set('WORLD!')(r);
+        if (!_.contains('hello')(r)) {
+            throw r;
+        }
+        if (_.contains('hello1')(r)) {
+            throw r;
+        }
+        if (!_.contains('HELLO')(r)) {
+            throw r;
+        }
+        if (_.contains('WORLD')(r)) {
+            throw r;
+        }
+        if (!_.contains('world')(r)) {
+            throw r;
+        }
+        if (_.contains('world!')(r)) {
+            throw r;
+        }
+        if (!_.contains('WORLD!')(r)) {
+            throw r;
+        }
+        //
+        r = _.remove('hello')(r);
+        if (_.contains('hello')(r)) {
+            throw r;
+        }
+        if (!_.contains('world')(r)) {
+            throw r;
+        }
+        r = _.remove('world')(r);
+        if (_.contains('world')(r)) {
+            throw r;
+        }
+        if (!_.contains('HELLO')(r)) {
+            throw r;
+        }
+        r = _.remove('HELLO')(r);
+        if (_.contains('HELLO')(r)) {
+            throw r;
+        }
+        if (!_.contains('WORLD!')(r)) {
+            throw r;
+        }
+        r = _.remove('WORLD!')(r);
+        if (r !== null) {
+            throw r;
+        }
+    }
+};

package/package.json

@@ -1,16 +1,17 @@
 {
   "name": "functionalscript",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "type": "module",
   "description": "FunctionalScript is a functional subset of JavaScript",
   "scripts": {
-    "tscp": "tsc --declaration --emitDeclarationOnly --noEmit false",
+    "tscp": "rm -rf out/ && tsc --NoEmit false",
     "tsc": "tsc",
     "test": "tsc && npm run test-only",
     "index": "node ./dev/index.mjs",
     "version": "node ./nodejs/version/main.mjs",
     "test-only": "node --trace-uncaught ./dev/test.mjs",
-    "comtest": "node ./com/test/build.mjs"
+    "comtest": "node ./com/test/build.mjs",
+    "doc": "rm -rf docs/ && npm run tscp && deno doc --html out/**/module.f.mjs"
   },
   "repository": {
     "type": "git",
@@ -32,7 +33,7 @@
   },
   "homepage": "https://github.com/functionalscript/functionalscript#readme",
   "devDependencies": {
-    "@types/node": "^22.10.1",
+    "@types/node": "^22.10.2",
     "typescript": "^5.7.2"
   }
 }

package/tsconfig.json

@@ -42,12 +42,12 @@
     // "maxNodeModuleJsDepth": 1,                        /* Specify the maximum folder depth used for checking JavaScript files from `node_modules`. Only applicable with `allowJs`. */
 
     /* Emit */
-    // "declaration": true,                              /* Generate .d.ts files from TypeScript and JavaScript files in your project. */
+    "declaration": true,                              /* Generate .d.ts files from TypeScript and JavaScript files in your project. */
     // "declarationMap": true,                           /* Create sourcemaps for d.ts files. */
     // "emitDeclarationOnly": true,                      /* Only output d.ts files and not JavaScript files. */
     // "sourceMap": true,                                /* Create source map files for emitted JavaScript files. */
     // "outFile": "./",                                  /* Specify a file that bundles all outputs into one JavaScript file. If `declaration` is true, also designates a file that bundles all .d.ts output. */
-    // "outDir": "./",                                   /* Specify an output folder for all emitted files. */
+    "outDir": "./out",                                   /* Specify an output folder for all emitted files. */
     // "removeComments": true,                           /* Disable emitting comments. */
     "noEmit": true,                                   /* Disable emitting files from a compilation. */
     // "importHelpers": true,                            /* Allow importing helper functions from tslib once per project, instead of including them per-file. */