functionalscript 0.3.6 → 0.3.8

package/com/cpp/module.f.js

@@ -4,7 +4,6 @@
  */
 import { paramList, result, } from "../types/module.f.js";
 import * as text from "../../text/module.f.js";
-import * as O from "../../types/object/module.f.js";
 import { map, flatMap, flat } from "../../types/list/module.f.js";
 import { join } from "../../types/string/module.f.js";
 const { entries } = Object;

package/com/cs/module.f.js

@@ -8,7 +8,6 @@ import { result, paramList, } from "../types/module.f.js";
 import { curly } from "../../text/module.f.js";
 import { flat, map, some, flatMap } from "../../types/list/module.f.js";
 import { join } from "../../types/string/module.f.js";
-import * as O from "../../types/object/module.f.js";
 const { entries } = Object;
 const using = (v) => `using ${v};`;
 const typeDef = (attributes) => (type) => (name) => (body) => flat([
@@ -31,20 +30,20 @@ const baseTypeMap = {
     usize: 'UIntPtr',
 };
 const baseType = (t) => baseTypeMap[t];
-const unsafe = isUnsafe => isUnsafe ? 'unsafe ' : '';
-const fullType = t => typeof (t) === 'string' ?
+const unsafe = (isUnsafe) => isUnsafe ? 'unsafe ' : '';
+const fullType = (t) => typeof (t) === 'string' ?
     [false, baseType(t)] :
     t.length === 1 ?
         [false, t[0]] :
         [true, `${type(t[1])}*`];
-const type = t => fullType(t)[1];
+const type = (t) => fullType(t)[1];
 const param = ([name, t]) => `${type(t)} ${name}`;
 const mapParam = map(param);
 const field = ([name, comType]) => {
     const [isUnsafe, t] = fullType(comType);
     return `public ${unsafe(isUnsafe)}${t} ${name};`;
 };
-const isUnsafeField = field => fullType(field[1])[0];
+const isUnsafeField = (field) => fullType(field[1])[0];
 const mapIsUnsafeField = map(isUnsafeField);
 const resultVoid = result('void');
 const joinComma = join(', ');
@@ -73,7 +72,7 @@ const header = [
 /**
  * Generates the C# code for a library.
  */
-export const cs = name => library => {
+export const cs = (name) => (library) => {
     const v = flatMapDef(entries(library));
     const ns = namespace(name)(v);
     return flat([header, ns]);

package/com/rust/module.f.d.ts

@@ -2,14 +2,14 @@
  * This module generates Rust code for COM interop from a high-level type library definition.
  *
  * The module provides functions to define structs, traits, and implementations in Rust,
- * specifically tailored for `nanocom` interoperation.
+ * specifically tailored for `nanocom` interpretation.
  */
 import { type Library } from '../types/module.f.ts';
-import * as Text from '../../text/module.f.ts';
+import type * as text from '../../text/module.f.ts';
 /**
  * Generates Rust code for the given type library.
  *
  * @param library - The library of type definitions to generate Rust code for.
  * @returns A block of Rust code representing the library.
  */
-export declare const rust: (library: Library) => Text.Block;
+export declare const rust: (library: Library) => text.Block;

package/com/rust/module.f.js

@@ -2,35 +2,30 @@
  * This module generates Rust code for COM interop from a high-level type library definition.
  *
  * The module provides functions to define structs, traits, and implementations in Rust,
- * specifically tailored for `nanocom` interoperation.
+ * specifically tailored for `nanocom` interpretation.
  */
 import { paramList } from "../types/module.f.js";
-import * as Text from "../../text/module.f.js";
-import * as O from "../../types/object/module.f.js";
-import * as list from "../../types/list/module.f.js";
-const { flat, map, flatMap } = list;
+import { flat, map, flatMap } from "../../types/list/module.f.js";
+import { fn } from "../../types/function/module.f.js";
+import { join } from "../../types/string/module.f.js";
 const { entries } = Object;
-import * as func from "../../types/function/module.f.js";
-const { fn } = func;
-import * as string from "../../types/string/module.f.js";
-const { join } = string;
-const rustField = field => `pub ${field},`;
+const rustField = (field) => `pub ${field},`;
 const mapRustField = map(rustField);
-const rustStruct = b => name => [`#[repr(C)]`, `pub struct ${name} {`, mapRustField(b), `}`];
+const rustStruct = (b) => (name) => [`#[repr(C)]`, `pub struct ${name} {`, mapRustField(b), `}`];
 const commaJoin = join(', ');
-const ref = name => `${name}::Ref`;
-const obj = name => `&${name}::Object`;
+const ref = (name) => `${name}::Ref`;
+const obj = (name) => `&${name}::Object`;
 const self = ['&self'];
 const paramName = ([n]) => n;
-const callList = p => map(paramName)(paramList(p));
-const call = p => commaJoin(callList(p));
-const virtualCall = p => commaJoin(flat([['self'], callList(p)]));
+const callList = (p) => map(paramName)(paramList(p));
+const call = (p) => commaJoin(callList(p));
+const virtualCall = (p) => commaJoin(flat([['self'], callList(p)]));
 const super_ = 'super::';
 const assign = ([n]) => `${n}: Self::${n},`;
 const mapAssign = map(assign);
 const this_ = ['this: &Object'];
-const rustType = n => `pub type ${n} = nanocom::${n}<Interface>;`;
-const whereContent = h => wh => {
+const rustType = (n) => `pub type ${n} = nanocom::${n}<Interface>;`;
+const whereContent = (h) => (wh) => {
     const w = 'where' in wh ? [
         h,
         `where`,
@@ -43,19 +38,19 @@ const whereContent = h => wh => {
     ];
     return flat([w, x]);
 };
-const rustImpl = i => {
+const rustImpl = (i) => {
     const p = 'param' in i ? `<${i.param}>` : '';
     const header = `impl${p} ${i.trait} for ${i.type}`;
     return whereContent(header)(i);
 };
 const comma = s => `${s},`;
 const mapComma = map(comma);
-const trait = t => {
+const trait = (t) => {
     const p = t.pub === true ? 'pub ' : '';
     const h = `${p}trait ${t.type}`;
     return whereContent(h)(t);
 };
-const traitImpl = t => {
+const traitImpl = (t) => {
     const i = rustImpl({
         param: 'T',
         trait: t.type,
@@ -73,8 +68,8 @@ const where = ['Self: nanocom::Class<Interface = Interface>', 'nanocom::CObject<
  * @returns A block of Rust code representing the library.
  */
 export const rust = (library) => {
-    const type = p => {
-        const f = o => t => {
+    const type = (p) => {
+        const f = (o) => (t) => {
             if (typeof t === 'string') {
                 return t;
             }
@@ -87,7 +82,7 @@ export const rust = (library) => {
         };
         return f;
     };
-    const pf = p => o => ([name, t]) => `${name}: ${type(p)(o)(t)}`;
+    const pf = (p) => (o) => ([name, t]) => `${name}: ${type(p)(o)(t)}`;
     const param = pf(super_)(obj);
     const mapParam = map(param);
     const mapField = map(pf('')(ref));
@@ -95,18 +90,18 @@ export const rust = (library) => {
         .then(mapField)
         .then(rustStruct)
         .result;
-    const func = first => p => {
+    const func = (first) => (p) => {
         const resultStr = '_' in p ? ` -> ${type(super_)(ref)(p._)}` : '';
         const params = commaJoin(flat([first, mapParam(paramList(p))]));
         return `(${params})${resultStr}`;
     };
-    const virtualFnType = n => p => `extern "system" fn${n}${func(this_)(p)}`;
+    const virtualFnType = (n) => (p) => `extern "system" fn${n}${func(this_)(p)}`;
     const virtualFn = ([n, p]) => `${n}: unsafe ${virtualFnType('')(p)}`;
     const mapVirtualFn = map(virtualFn);
     const headerFn = ([n, p]) => `fn ${n}${func(self)(p)}`;
-    const traitFn = m => `${headerFn(m)};`;
+    const traitFn = (m) => `${headerFn(m)};`;
     const mapTraitFn = map(traitFn);
-    const implFn = m => {
+    const implFn = (m) => {
         const [n, p] = m;
         return [
             `${headerFn(m)} {`,
@@ -124,7 +119,7 @@ export const rust = (library) => {
         ];
     };
     const flatMapImpl = flatMap(impl);
-    const interface_ = ({ interface: i, guid }) => name => {
+    const interface_ = ({ interface: i, guid }) => (name) => {
         const e = entries(i);
         return [
             `pub mod ${name} {`,

package/com/test/build.f.js

@@ -2,7 +2,7 @@ import { flat } from "../../types/list/module.f.js";
 import cppContent from "../cpp/testlib.f.js";
 import csContent from "../cs/testlib.f.js";
 import rustContent from "../rust/testlib.f.js";
-const flags = platform => {
+const flags = (platform) => {
     switch (platform) {
         case 'win32':
             return [];
@@ -12,7 +12,7 @@ const flags = platform => {
             return ['-std=c++17', '-lc++'];
     }
 };
-const output = platform => name => {
+const output = (platform) => (name) => {
     switch (platform) {
         case 'win32': return `${name}.dll`;
         case 'darwin': return `lib${name}.dylib`;

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

@@ -1,4 +1,4 @@
-import * as O from '../../types/object/module.f.ts';
+import type * as O from '../../types/object/module.f.ts';
 import { type List } from '../../types/list/module.f.ts';
 export type Library = {
     readonly [k in string]: Definition;

package/com/types/module.f.js

@@ -1,8 +1,7 @@
-import * as O from "../../types/object/module.f.js";
 import { filter } from "../../types/list/module.f.js";
 import { compose } from "../../types/function/module.f.js";
 const { entries } = Object;
 const isParam = ([name]) => name !== '_';
 const filterParam = filter(isParam);
 export const paramList = compose(entries)(filterParam);
-export const result = v => f => fa => '_' in fa ? f(fa._) : v;
+export const result = (v) => (f) => (fa) => '_' in fa ? f(fa._) : v;

package/com/types/testlib.f.js

@@ -1,4 +1,3 @@
-import * as _ from "./module.f.js";
 export default {
     Slice: {
         struct: {

package/commonjs/build/module.f.d.ts

@@ -1,6 +1,6 @@
-import * as package_ from '../package/module.f.ts';
+import type * as package_ from '../package/module.f.ts';
 import { type MapInterface, type Id, type State } from '../module/module.f.ts';
-import * as function_ from '../module/function/module.f.ts';
+import type * as function_ from '../module/function/module.f.ts';
 type Result<M> = readonly [State, M];
 export declare const getOrBuild: (compile: function_.Compile) => (packageGet: package_.Get) => <M>(moduleMapInterface: MapInterface<M>) => (moduleId: Id) => (moduleMap: M) => Result<M>;
 export {};

package/commonjs/build/module.f.js

@@ -1,15 +1,12 @@
-import * as package_ from "../package/module.f.js";
 import { idToString, dir, } from "../module/module.f.js";
-import * as function_ from "../module/function/module.f.js";
-import * as map from "../../types/map/module.f.js";
-const { empty: mapEmpty, setReplace } = map;
+import { empty as mapEmpty, setReplace } from "../../types/map/module.f.js";
 import * as object from "../../types/object/module.f.js";
 const { fromMap } = object;
 import * as path from "../path/module.f.js";
 const { parseAndFind } = path;
 import * as stringSet from "../../types/string_set/module.f.js";
 const { set: setSet, contains: setContains, empty: stringSetEmpty } = stringSet;
-const notFound = moduleMap => [['error', ['file not found']], moduleMap];
+const notFound = (moduleMap) => [['error', ['file not found']], moduleMap];
 export const getOrBuild = compile => packageGet => moduleMapInterface => {
     const build = buildSet => moduleId => {
         const moduleIdStr = idToString(moduleId);
@@ -47,7 +44,7 @@ export const getOrBuild = compile => packageGet => moduleMapInterface => {
             return x(moduleMap2);
         };
     };
-    const f = moduleId => moduleMap => {
+    const f = (moduleId) => (moduleMap) => {
         const moduleIdStr = idToString(moduleId);
         // check moduleMap
         {

package/commonjs/build/test.f.js

@@ -1,9 +1,5 @@
 import * as _ from "./module.f.js";
 import * as map from "../../types/map/module.f.js";
-import * as Module from "../module/module.f.js";
-import * as ModuleFunction from "../module/function/module.f.js";
-import * as Result from "../../types/result/module.f.js";
-import * as Package from "../package/module.f.js";
 import { at } from "../../types/object/module.f.js";
 const compileMap = {
     ':index.js': [

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

@@ -1,7 +1,7 @@
 /**
  * An IO interface for creating and running module functions.
  */
-import * as TypesResult from '../../../types/result/module.f.ts';
+import type * as TypesResult from '../../../types/result/module.f.ts';
 export type Function_ = <M>(require: Require<M>) => (prior: M) => Result<M>;
 export type Result<M> = readonly [TypesResult.Result<unknown, unknown>, M];
 export type Require<M> = (path: string) => (prior: M) => Result<M>;

package/commonjs/module/function/module.f.js

@@ -1,4 +1,4 @@
 /**
  * An IO interface for creating and running module functions.
  */
-import * as TypesResult from "../../../types/result/module.f.js";
+export {};

package/commonjs/module/module.f.d.ts

@@ -1,4 +1,4 @@
-import * as O from '../../types/object/module.f.ts';
+import type * as O from '../../types/object/module.f.ts';
 export type MapInterface<M> = {
     readonly at: (moduleId: string) => (moduleMap: M) => State | null;
     readonly setReplace: (moduleId: string) => (moduleState: State) => (moduleMap: M) => M;

package/commonjs/module/module.f.js

@@ -1,5 +1,4 @@
-import * as O from "../../types/object/module.f.js";
-export const dir = id => {
+export const dir = (id) => {
     const len = id.path.length;
     if (len < 1) {
         return null;
@@ -9,4 +8,4 @@ export const dir = id => {
         path: id.path.slice(0, len - 1)
     };
 };
-export const idToString = id => `${id.package}/${id.path.join('/')}`;
+export const idToString = (id) => `${id.package}/${id.path.join('/')}`;

package/commonjs/path/module.f.d.ts

@@ -1,6 +1,6 @@
 import { type List } from '../../types/list/module.f.ts';
-import * as Package from '../package/module.f.ts';
-import * as Module from '../module/module.f.ts';
+import type * as Package from '../package/module.f.ts';
+import type * as Module from '../module/module.f.ts';
 type Items = readonly string[];
 type LocalPath = {
     readonly external: boolean;
@@ -8,17 +8,17 @@ type LocalPath = {
     readonly items: Items;
 };
 export declare const parseLocal: (local: string) => (path: string) => LocalPath | null;
-type Path = {
+export type Path = {
     readonly package: string;
     readonly items: Items;
     readonly dir: boolean;
 };
 export declare const parseGlobal: (d: (local: string) => string | null) => (dir: boolean) => (items: List<string>) => Path | null;
 export declare const parse: (packageId: string) => (dependencies: (local: string) => string | null) => (local: string) => (path: string) => Path | null;
-type FoundResult = {
+export type FoundResult = {
     readonly id: Module.Id;
     readonly source: string;
 };
-type Result = FoundResult | null;
+export type Result = FoundResult | null;
 export declare const parseAndFind: (packageGet: Package.Get) => (moduleId: Module.Id) => (path: string) => Result;
 export {};

package/commonjs/path/module.f.js

@@ -1,9 +1,7 @@
 import { next, fold, reverse, first, flat, toArray, filterMap, isEmpty, concat, empty } from "../../types/list/module.f.js";
 import { join } from "../../types/string/module.f.js";
-import * as Package from "../package/module.f.js";
-import * as Module from "../module/module.f.js";
 const split = path => path.split('/');
-const normItemsOp = first => prior => {
+const normItemsOp = (first) => (prior) => {
     if (prior === null) {
         return null;
     }
@@ -25,13 +23,13 @@ const normItemsOp = first => prior => {
         }
     }
 };
-const normItems = items => {
+const normItems = (items) => {
     const result = fold(normItemsOp)([empty])(items);
     return result === null ? result : [reverse(result[0])];
 };
 const firstNull = first(null);
-export const parseLocal = local => {
-    const fSeq = path => {
+export const parseLocal = (local) => {
+    const fSeq = (path) => {
         const pathSeq = split(path);
         const dir = [null, '', '.', '..'].includes(pathSeq[pathSeq.length - 1]);
         return ['.', '..'].includes(firstNull(pathSeq)) ?
@@ -51,7 +49,7 @@ export const parseLocal = local => {
         };
     };
 };
-const variants = prior => () => {
+const variants = (prior) => () => {
     const [a, b] = prior;
     const r = next(b);
     if (r === empty) {
@@ -61,7 +59,7 @@ const variants = prior => () => {
     const n = [a === null ? first : `${a}/${first}`, tail];
     return { first: n, tail: variants(n) };
 };
-const mapDependency = d => ([external, internal]) => {
+const mapDependency = (d) => ([external, internal]) => {
     const id = d(external);
     return id === null ? null : [id, internal];
 };

package/commonjs/path/test.f.js

@@ -3,8 +3,7 @@ import { todo } from "../../dev/module.f.js";
 import * as json from "../../json/module.f.js";
 import { identity } from "../../types/function/module.f.js";
 import { at } from "../../types/object/module.f.js";
-import * as Package from "../package/module.f.js";
-const i = o => s => at(s)(o);
+const i = (o) => (s) => at(s)(o);
 const stringify = json.stringify(identity);
 export default {
     0: () => {

package/crypto/prime_field/module.f.d.ts

@@ -1,4 +1,4 @@
-import * as Operator from '../../types/function/operator/module.f.ts';
+import type * as Operator from '../../types/function/operator/module.f.ts';
 type Reduce = Operator.Reduce<bigint>;
 type Unary = Operator.Unary<bigint, bigint>;
 /**
@@ -39,5 +39,5 @@ export declare const prime_field: (p: bigint) => PrimeField;
  * if (root !== 2n) { throw root }
  * ```
  */
-export declare const sqrt: (f: PrimeField) => (a: bigint) => bigint | null;
+export declare const sqrt: ({ p, mul, pow }: PrimeField) => (a: bigint) => bigint | null;
 export {};

package/crypto/prime_field/module.f.js

@@ -1,12 +1,11 @@
-import * as Operator from "../../types/function/operator/module.f.js";
-import { scalar_mul } from "../../types/bigint/module.f.js";
+import { repeat } from "../../types/monoid/module.f.js";
 /**
  * Creates a prime field with the specified prime modulus and associated operations.
  *
  * @param p - A prime number to define the field.
  * @returns The prime field object.
  */
-export const prime_field = p => {
+export const prime_field = (p) => {
     const sub = a => b => {
         const r = a - b;
         return r < 0 ? r + p : r;
@@ -33,7 +32,7 @@ export const prime_field = p => {
     };
     const middle = p >> 1n;
     const pow2 = a => mul(a)(a);
-    const pow = scalar_mul({ 0: 1n, add: mul });
+    const pow = repeat({ identity: 1n, operation: mul });
     return {
         p,
         middle,

package/crypto/secp/module.f.d.ts

@@ -1,4 +1,4 @@
-import * as Operator from '../../types/function/operator/module.f.ts';
+import type * as Operator from '../../types/function/operator/module.f.ts';
 import { type PrimeField } from '../prime_field/module.f.ts';
 /**
  * A 2D point represented as a pair of `bigint` values `[x, y]`.
@@ -50,7 +50,7 @@ type Curve = {
  * const mulPoint = curveInstance.mul([1n, 1n])(3n); // Multiply a point by 3
  * ```
  */
-export declare const curve: (i: Init) => Curve;
+export declare const curve: ({ p, a: [a0, a1], n }: Init) => Curve;
 export declare const eq: (a: Point) => (b: Point) => boolean;
 /**
  * https://neuromancer.sk/std/secg/secp192r1

package/crypto/secp/module.f.js

@@ -1,6 +1,5 @@
-import * as Operator from "../../types/function/operator/module.f.js";
 import { prime_field, sqrt } from "../prime_field/module.f.js";
-import { scalar_mul } from "../../types/bigint/module.f.js";
+import { repeat } from "../../types/monoid/module.f.js";
 /**
  * Constructs an elliptic curve with the given initialization parameters.
  *
@@ -32,7 +31,7 @@ export const curve = ({ p, a: [a0, a1], n }) => {
     /**
      * y**2 = a1*x**3 + a0
      */
-    const y2 = x => addA0(add(pow3(x))(mulA1(x)));
+    const y2 = (x) => addA0(add(pow3(x))(mulA1(x)));
     const addPoint = p => q => {
         if (p === null) {
             return q;
@@ -71,10 +70,10 @@ export const curve = ({ p, a: [a0, a1], n }) => {
             return [x, neg(y)];
         },
         add: addPoint,
-        mul: scalar_mul({ 0: null, add: addPoint })
+        mul: repeat({ identity: null, operation: addPoint })
     };
 };
-export const eq = a => b => {
+export const eq = (a) => (b) => {
     if (a === null || b === null) {
         return a === b;
     }

package/crypto/sha2/module.f.d.ts

@@ -1,13 +1,76 @@
-import * as array from '../../types/array/module.f.ts';
-type HashInput = {
-    readonly f: (i: number) => number;
-    readonly length: number;
+import type { Array16, Array8 } from '../../types/array/module.f.ts';
+import { type Vec } from '../../types/bit_vec/module.f.ts';
+export type V8 = Array8<bigint>;
+export type V16 = Array16<bigint>;
+/**
+ * Type definition for the state of the SHA-2 algorithm.
+ */
+export type State = {
+    /**
+     * The current hash value.
+     */
+    readonly hash: V8;
+    /**
+     * The length of the data processed so far.
+     */
+    readonly len: bigint;
+    /**
+     * The remaining data that has not yet been processed.
+     */
+    readonly remainder: Vec;
 };
-type Hash8 = array.Array8<number>;
-type Array16 = array.Array16<number>;
-export declare const padding: (input: readonly number[]) => (bits: number) => HashInput;
-export declare const computeSha256: (input: readonly number[]) => (bitsCount: number) => Hash8;
-export declare const computeSha224: (input: readonly number[]) => (bitsCount: number) => Hash8;
-export declare const compress256: (data: Array16) => Hash8;
-export declare const compress224: (data: Array16) => Hash8;
-export {};
+export type Base = {
+    readonly bitLength: bigint;
+    readonly chunkLength: bigint;
+    readonly compress: (i: V8) => (u: bigint) => V8;
+    readonly fromV8: (a: V8) => bigint;
+    readonly append: (state: State) => (v: Vec) => State;
+    readonly end: (hashLength: bigint) => (state: State) => bigint;
+};
+/**
+ * SHA2. See https://en.wikipedia.org/wiki/SHA-2
+ *
+ * @example
+ *
+ * ```js
+ * const s = msbUtf8("The quick brown fox jumps over the lazy dog.")
+ * let state = sha224.init
+ * state = sha224.append(state)(s)
+ * const h = sha224.end(state) // 0x619cba8e8e05826e9b8c519c0a5c68f4fb653e8a3d8aa04bb2c8cd4cn
+ * ```
+ */
+export type Sha2 = {
+    /**
+     * Initial state of the SHA-2 algorithm.
+     */
+    readonly init: State;
+    /**
+     * Appends data to the state and returns the new state.
+     *
+     * @param state The current state.
+     * @param v The data to append.
+     * @returns The new state after appending data.
+     */
+    readonly append: (state: State) => (v: Vec) => State;
+    /**
+     * Finalizes the hash and returns the result as a bigint.
+     *
+     * @param state The final state.
+     * @returns The resulting hash.
+     */
+    readonly end: (state: State) => bigint;
+};
+export declare const base32: Base;
+export declare const base64: Base;
+/** SHA-256 */
+export declare const sha256: Sha2;
+/** SHA-224 */
+export declare const sha224: Sha2;
+/** SHA-512 */
+export declare const sha512: Sha2;
+/** SHA-384 */
+export declare const sha384: Sha2;
+/** SHA-512/256 */
+export declare const sha512x256: Sha2;
+/** SHA-512/224 */
+export declare const sha512x224: Sha2;