functionalscript 0.2.6 → 0.3.0

package/out/dev/test.f.mjs

@@ -1,58 +0,0 @@
-/** @type {() => never} */
-const assert = () => { throw 'assert'; };
-/** @type {(_: boolean) => void} */
-const assert_if = c => { if (c) {
-    throw 'assert_if';
-} };
-export default {
-    ctor: () => {
-        const c = (() => { })['constructor'];
-        const f = c('return 5');
-        const result = f();
-        if (result !== 5) {
-            throw 'function';
-        }
-    },
-    ctorEmpty: () => {
-        /** @type {any} */
-        const o = {};
-        const c = o['constructor'];
-        // console.log(c)
-        // console.log(c(()=>{}))
-    },
-    ctorUndefined: () => {
-        /** @type {any} */
-        const o = {
-            constructor: void 0
-        };
-        const c = o['constructor'];
-        //console.log(c)
-    },
-    number: () => {
-        /** @type {any} */
-        const b = '42';
-        const r = Number(b);
-        //console.log(r)
-    },
-    properties: () => {
-        /** @type {any} */
-        const o = {};
-        //const c = o['constructor']
-        //const c = o['__proto__']
-        //const c = o['__defineGetter__']
-        //const c = o['__defineSetter__']
-        //const c = o['__lookupGetter__']
-        //const c = o['__lookupSetter__']
-        //const c = o['hasOwnProperty']
-        //const c = o['isPrototypeOf']
-        //const c = o['propertyIsEnumerable']
-        //const c = o['toString']
-        const c = o['valueOf'];
-        //console.log(c)
-    },
-    getOwnPropertyDescriptor: () => {
-        const x = { 'a': 12 };
-        const c = Object.getOwnPropertyDescriptor(x, 'constructor');
-        const a = Object.getOwnPropertyDescriptor(x, 'a');
-    }
-};

package/out/dev/test.mjs

@@ -1,52 +0,0 @@
-import { loadModuleMap, exit, env } from './module.mjs';
-import test from './test/module.f.mjs';
-/** @type {(f: (s: string) => void) => (s: string) => <T>(_: T) => T} */
-const anyLog = f => s => state => {
-    f(s);
-    return state;
-};
-/**
- * @template T
- * @typedef {readonly['ok', T]} Ok
- */
-/**
- * @template E
- * @typedef {readonly['error', E]} Error
- */
-/**
- * @template T
- * @template E
- * @typedef {Ok<T>|Error<E>} Result
- */
-/** @type {<T>(f: () => T) => Result<T, unknown>} */
-const tryCatch = f => {
-    // `try catch` is not allowed in FunctionalScript.
-    try {
-        return ['ok', f()];
-    }
-    catch (e) {
-        return ['error', e];
-    }
-};
-/** @type {<R>(f: () => R) => <T>(state: T) => readonly[R, number, T]} Measure} */
-const measure = f => state => {
-    const b = performance.now();
-    const r = f();
-    const e = performance.now();
-    return [r, e - b, state];
-};
-// test runner.
-const main = async () => {
-    const moduleMap = await loadModuleMap();
-    const r = test({
-        moduleMap,
-        log: anyLog(console.log),
-        error: anyLog(console.error),
-        measure,
-        tryCatch,
-        env,
-        state: void 0,
-    });
-    exit(r[0]);
-};
-main();

package/out/djs/module.f.d.mts

@@ -1,20 +0,0 @@
-/** @typedef {O.Entry<Unknown>} Entry*/
-/** @typedef {(list.List<Entry>)} Entries */
-/** @typedef {(entries: Entries) => Entries} MapEntries */
-/** @type {(mapEntries: MapEntries) => (value: Unknown) => list.List<string>} */
-export const serialize: (mapEntries: MapEntries) => (value: Unknown) => list.List<string>;
-/**
- * The standard `JSON.stringify` rules determined by
- * https://262.ecma-international.org/6.0/#sec-ordinary-object-internal-methods-and-internal-slots-ownpropertykeys
- *
- * @type {(mapEntries: MapEntries) => (value: Unknown) => string}
- */
-export const stringify: (mapEntries: MapEntries) => (value: Unknown) => string;
-export type Object = { readonly [k in string]: Unknown; };
-export type Array = readonly Unknown[];
-export type Unknown = Object | boolean | string | number | null | Array | bigint | undefined;
-export type Entry = O.Entry<Unknown>;
-export type Entries = (list.List<Entry>);
-export type MapEntries = (entries: Entries) => Entries;
-import * as list from '../types/list/module.f.mjs';
-import * as O from '../types/object/module.f.mjs';

package/out/djs/module.f.mjs

@@ -1,79 +0,0 @@
-// @ts-self-types="./module.f.d.mts"
-import * as list from '../types/list/module.f.mjs';
-const { flat, map } = list;
-import * as string from '../types/string/module.f.mjs';
-const { concat } = string;
-import * as O from '../types/object/module.f.mjs';
-import * as f from '../types/function/module.f.mjs';
-const { compose, fn } = f;
-const { entries } = Object;
-import * as bi from '../types/bigint/module.f.mjs';
-const { serialize: bigintSerialize } = bi;
-import * as j from '../json/serializer/module.f.mjs';
-const { objectWrap, arrayWrap, stringSerialize, numberSerialize, nullSerialize, boolSerialize } = j;
-/**
- * @typedef {{
- *  readonly [k in string]: Unknown
- * }} Object
- */
-/** @typedef {readonly Unknown[]} Array */
-/** @typedef {Object|boolean|string|number|null|Array|bigint|undefined} Unknown */
-const colon = [':'];
-const undefinedSerialize = ['undefined'];
-/** @typedef {O.Entry<Unknown>} Entry*/
-/** @typedef {(list.List<Entry>)} Entries */
-/** @typedef {(entries: Entries) => Entries} MapEntries */
-/** @type {(mapEntries: MapEntries) => (value: Unknown) => list.List<string>} */
-export const serialize = sort => {
-    /** @type {(kv: readonly[string, Unknown]) => list.List<string>} */
-    const propertySerialize = ([k, v]) => flat([
-        stringSerialize(k),
-        colon,
-        f(v)
-    ]);
-    const mapPropertySerialize = map(propertySerialize);
-    /** @type {(object: Object) => list.List<string>} */
-    const objectSerialize = fn(entries)
-        .then(sort)
-        .then(mapPropertySerialize)
-        .then(objectWrap)
-        .result;
-    /** @type {(value: Unknown) => list.List<string>} */
-    const f = value => {
-        switch (typeof value) {
-            case 'boolean': {
-                return boolSerialize(value);
-            }
-            case 'number': {
-                return numberSerialize(value);
-            }
-            case 'string': {
-                return stringSerialize(value);
-            }
-            case 'bigint': {
-                return [bigintSerialize(value)];
-            }
-            default: {
-                if (value === null) {
-                    return nullSerialize;
-                }
-                if (value === undefined) {
-                    return undefinedSerialize;
-                }
-                if (value instanceof Array) {
-                    return arraySerialize(value);
-                }
-                return objectSerialize(value);
-            }
-        }
-    };
-    const arraySerialize = compose(map(f))(arrayWrap);
-    return f;
-};
-/**
- * The standard `JSON.stringify` rules determined by
- * https://262.ecma-international.org/6.0/#sec-ordinary-object-internal-methods-and-internal-slots-ownpropertykeys
- *
- * @type {(mapEntries: MapEntries) => (value: Unknown) => string}
- */
-export const stringify = sort => compose(serialize(sort))(concat);

package/out/djs/parser/module.f.d.mts

@@ -1,56 +0,0 @@
-/** @type {(tokenList: list.List<tokenizerT.DjsToken>) => result.Result<DjsModule, string>} */
-export const parse: (tokenList: list.List<tokenizerT.DjsToken>) => result.Result<DjsModule, string>;
-export type DjsModule = [readonly string[], readonly DjsConst[]];
-export type DjsConst = boolean | string | number | null | bigint | undefined | DjsModuleRef | DjsArray | DjsObject;
-export type DjsModuleRef = ["aref" | "cref", number];
-export type DjsArray = ["array", readonly DjsConst[]];
-export type DjsObject = { readonly [k in string]: DjsConst; };
-export type DjsStackArray = ["array", list.List<DjsConst>];
-export type DjsStackObject = ["object", map.Map<DjsConst>, string];
-export type DjsStackElement = DjsStackArray | DjsStackObject;
-export type DjsStack = list.List<DjsStackElement>;
-export type ParserState = InitialState | NewLineRequiredState | ImportState | ConstState | ExportState | ParseValueState | ResultState | ErrorState;
-export type ModuleState = {
-    readonly refs: map.Map<DjsModuleRef>;
-    readonly modules: list.List<string>;
-    readonly consts: list.List<DjsConst>;
-};
-export type InitialState = {
-    readonly state: "";
-    readonly module: ModuleState;
-};
-export type NewLineRequiredState = {
-    readonly state: "nl";
-    readonly module: ModuleState;
-};
-export type ImportState = {
-    readonly state: "import" | "import+name" | "import+from";
-    readonly module: ModuleState;
-};
-export type ConstState = {
-    readonly state: "const" | "const+name";
-    readonly module: ModuleState;
-};
-export type ExportState = {
-    readonly state: "export";
-    readonly module: ModuleState;
-};
-export type ParseValueState = {
-    readonly state: "constValue" | "exportValue";
-    readonly module: ModuleState;
-    readonly valueState: "" | "[" | "[v" | "[," | "{" | "{k" | "{:" | "{v" | "{,";
-    readonly top: DjsStackElement | null;
-    readonly stack: DjsStack;
-};
-export type ResultState = {
-    readonly state: "result";
-    readonly module: ModuleState;
-};
-export type ErrorState = {
-    readonly state: "error";
-    readonly message: string;
-};
-import * as list from '../../types/list/module.f.mjs';
-import * as tokenizerT from '../tokenizer/module.f.mjs';
-import * as result from '../../types/result/module.f.mjs';
-import * as map from '../../types/map/module.f.mjs';