functionalscript 0.3.6 → 0.3.8

package/dev/test.f.js

@@ -1,7 +1,3 @@
-const assert = () => { throw 'assert'; };
-const assert_if = c => { if (c) {
-    throw 'assert_if';
-} };
 export default {
     ctor: () => {
         const c = (() => { })['constructor'];

package/djs/module.f.d.ts

@@ -1,5 +1,5 @@
 import * as list from '../types/list/module.f.ts';
-import * as O from '../types/object/module.f.ts';
+import type * as O from '../types/object/module.f.ts';
 type Object = {
     readonly [k in string]: Unknown;
 };

package/djs/module.f.js

@@ -2,7 +2,6 @@ import * as list from "../types/list/module.f.js";
 const { flat, map } = list;
 import * as string from "../types/string/module.f.js";
 const { concat } = string;
-import * as O from "../types/object/module.f.js";
 import * as f from "../types/function/module.f.js";
 const { compose, fn } = f;
 const { entries } = Object;

package/djs/parser/module.f.d.ts

@@ -1,6 +1,6 @@
 import * as result from '../../types/result/module.f.ts';
 import { type List } from '../../types/list/module.f.ts';
-import * as tokenizerT from '../tokenizer/module.f.ts';
+import type * as tokenizerT from '../tokenizer/module.f.ts';
 export type DjsModule = [readonly string[], readonly DjsConst[]];
 export type DjsConst = boolean | string | number | null | bigint | undefined | DjsModuleRef | DjsArray | DjsObject;
 type DjsModuleRef = ['aref' | 'cref', number];

package/djs/parser/module.f.js

@@ -1,7 +1,5 @@
 import * as result from "../../types/result/module.f.js";
 import { fold, first, drop, toArray, length, concat } from "../../types/list/module.f.js";
-import * as Operator from "../../types/function/operator/module.f.js";
-import * as tokenizerT from "../tokenizer/module.f.js";
 import { setReplace, at } from "../../types/map/module.f.js";
 import * as o from "../../types/object/module.f.js";
 const { fromMap } = o;

package/djs/serializer/module.f.d.ts

@@ -1,6 +1,6 @@
 import * as list from '../../types/list/module.f.ts';
-import * as O from '../../types/object/module.f.ts';
-import * as DjsParser from '../parser/module.f.ts';
+import type * as O from '../../types/object/module.f.ts';
+import type * as DjsParser from '../parser/module.f.ts';
 export declare const undefinedSerialize: string[];
 type Entry = O.Entry<DjsParser.DjsConst>;
 type Entries = list.List<Entry>;

package/djs/serializer/module.f.js

@@ -2,7 +2,6 @@ import * as list from "../../types/list/module.f.js";
 const { flat, map, entries: listEntries, concat: listConcat, flatMap } = list;
 import * as string from "../../types/string/module.f.js";
 const { concat } = string;
-import * as O from "../../types/object/module.f.js";
 import * as f from "../../types/function/module.f.js";
 const { compose, fn } = f;
 const { entries } = Object;
@@ -10,7 +9,6 @@ import * as bi from "../../types/bigint/module.f.js";
 const { serialize: bigintSerialize } = bi;
 import * as j from "../../json/serializer/module.f.js";
 const { objectWrap, arrayWrap, stringSerialize, numberSerialize, nullSerialize, boolSerialize } = j;
-import * as DjsParser from "../parser/module.f.js";
 const colon = [':'];
 export const undefinedSerialize = ['undefined'];
 const djsConstSerialize = sort => {

package/djs/tokenizer/module.f.js

@@ -1,4 +1,3 @@
-import * as Operator from "../../types/function/operator/module.f.js";
 import * as list from "../../types/list/module.f.js";
 const { empty, flat, stateScan } = list;
 import * as bf from "../../types/bigfloat/module.f.js";

package/fsc/test.f.js

@@ -4,7 +4,6 @@ const { one } = ascii;
 import * as j from "../json/module.f.js";
 const { stringify } = j;
 const s = stringify(i => i);
-/** @type {} */
 const f = v => {
     const n = one(v);
     return s(_.init(n)[0]);

package/html/module.f.d.ts

@@ -7,7 +7,7 @@ type Attributes = {
     readonly [k in string]: string;
 };
 export type Node = Element | string;
-export declare const element: (element: Element) => List<string>;
+export declare const element: (e: Element) => List<string>;
 export declare const html: (_: Element) => List<string>;
 export declare const htmlToString: (_: Element) => string;
 export {};

package/html/module.f.js

@@ -1,6 +1,5 @@
 import { map, flatMap, flat, concat as listConcat } from "../types/list/module.f.js";
 import { concat as stringConcat } from "../types/string/module.f.js";
-import * as O from "../types/object/module.f.js";
 import { compose } from "../types/function/module.f.js";
 import * as utf16 from "../text/utf16/module.f.js";
 const { stringToList } = utf16;
@@ -27,11 +26,10 @@ const voidTagList = [
     'track',
     'wbr',
 ];
-const isVoid = tag => voidTagList.includes(tag);
 /**
  * https://stackoverflow.com/questions/7381974/which-characters-need-to-be-escaped-in-html
  */
-const escapeCharCode = code => {
+const escapeCharCode = (code) => {
     switch (code) {
         case 0x22: return '"';
         case 0x26: return '&';
@@ -41,18 +39,24 @@ const escapeCharCode = code => {
     }
 };
 const escape = compose(stringToList)(map(escapeCharCode));
-const node = n => typeof n === 'string' ? escape(n) : element(n);
+const node = (n) => typeof n === 'string' ? escape(n) : element(n);
 const nodes = flatMap(node);
 const attribute = ([name, value]) => flat([[' ', name, '="'], escape(value), ['"']]);
 const attributes = compose(entries)(flatMap(attribute));
-const open = t => a => flat([[`<`, t], attributes(a), [`>`]]);
-const element3 = t => ([a, n]) => {
-    const o = flat([[`<`, t], attributes(a), [`>`]]);
-    return isVoid(t) ? o : flat([o, nodes(n), ['</', t, '>']]);
+const parseElement = (e) => {
+    const [tag, item1, ...list] = e;
+    return item1 === undefined ?
+        [tag, {}, []] :
+        typeof item1 === 'object' && !(item1 instanceof Array) ?
+            [tag, item1, list] :
+            [tag, {}, [item1, ...list]];
 };
-export const element = e => {
-    const [t, a, ...n] = e;
-    return element3(t)(a === undefined ? [{}, []] : typeof a === 'object' && !(a instanceof Array) ? [a, n] : [{}, [a, ...n]]);
+export const element = (e) => {
+    const [tag, a, n] = parseElement(e);
+    const open = flat([[`<`, tag], attributes(a), [`>`]]);
+    return voidTagList.includes(tag) ?
+        open :
+        flat([open, nodes(n), ['</', tag, '>']]);
 };
 export const html = compose(element)(listConcat(['<!DOCTYPE html>']));
 export const htmlToString = compose(html)(stringConcat);

package/html/test.f.js

@@ -1,40 +1,40 @@
-import * as _ from "./module.f.js";
+import { htmlToString } from "./module.f.js";
 export default {
     empty: () => {
-        const r = _.htmlToString(['html']);
+        const r = htmlToString(['html']);
         if (r !== '<!DOCTYPE html><html></html>') {
             throw `empty: ${r}`;
         }
     },
     empty2: () => {
-        const r = _.htmlToString(['html']);
+        const r = htmlToString(['html']);
         if (r !== '<!DOCTYPE html><html></html>') {
             throw r;
         }
     },
     void: () => {
-        const r = _.htmlToString(['area']);
+        const r = htmlToString(['area']);
         if (r !== '<!DOCTYPE html><area>') {
             throw r;
         }
     },
     some: () => {
         const x = ['div', {}, '<div>&amp;</div>', ['a', { href: 'hello"' }]];
-        const s = _.htmlToString(x);
+        const s = htmlToString(x);
         if (s !== '<!DOCTYPE html><div>&lt;div&gt;&amp;amp;&lt;/div&gt;<a href="hello&quot;"></a></div>') {
             throw s;
         }
     },
     some2: () => {
         const x = ['div', '<div>&amp;</div>', ['a', { href: 'hello"' }]];
-        const s = _.htmlToString(x);
+        const s = htmlToString(x);
         if (s !== '<!DOCTYPE html><div>&lt;div&gt;&amp;amp;&lt;/div&gt;<a href="hello&quot;"></a></div>') {
             throw s;
         }
     },
     someVoid: () => {
         const x = ['div', ['br', { id: '5' }], '<div>&amp;</div>', ['a', { href: 'hello"' }]];
-        const s = _.htmlToString(x);
+        const s = htmlToString(x);
         if (s !== '<!DOCTYPE html><div><br id="5">&lt;div&gt;&amp;amp;&lt;/div&gt;<a href="hello&quot;"></a></div>') {
             throw s;
         }

package/js/tokenizer/module.f.d.ts

@@ -1,5 +1,5 @@
 import * as list from '../../types/list/module.f.ts';
-import * as bigfloatT from '../../types/bigfloat/module.f.ts';
+import type * as bigfloatT from '../../types/bigfloat/module.f.ts';
 export type StringToken = {
     readonly kind: 'string';
     readonly value: string;
@@ -81,6 +81,6 @@ export type CommentToken = {
 };
 export type JsToken = KeywordToken | TrueToken | FalseToken | NullToken | WhitespaceToken | NewLineToken | StringToken | NumberToken | ErrorToken | IdToken | BigIntToken | UndefinedToken | OperatorToken | CommentToken;
 type ErrorMessage = '" are missing' | 'unescaped character' | 'invalid hex value' | 'unexpected character' | 'invalid number' | 'invalid token' | '*\/ expected' | 'unterminated string literal' | 'eof';
-export declare const isKeywordToken: (token: JsToken) => Boolean;
+export declare const isKeywordToken: (token: JsToken) => boolean;
 export declare const tokenize: (input: list.List<number>) => list.List<JsToken>;
 export {};

package/js/tokenizer/module.f.js

@@ -7,7 +7,6 @@ const { at } = map;
 import * as _range from "../../types/range/module.f.js";
 const { one } = _range;
 const { empty, stateScan, flat, toArray, reduce: listReduce, scan } = list;
-import * as bigfloatT from "../../types/bigfloat/module.f.js";
 const { fromCharCode } = String;
 import * as ascii from "../../text/ascii/module.f.js";
 const { range } = ascii;
@@ -486,8 +485,8 @@ const tokenizeEofOp = state => {
                 case 'e':
                 case 'e+':
                 case 'e-': return [[{ kind: 'error', message: 'invalid number' }], { kind: 'eof', }];
-                default: return [[bufferToNumberToken(state)], { kind: 'eof' }];
             }
+            return [[bufferToNumberToken(state)], { kind: 'eof' }];
         case 'op': return [[getOperatorToken(state.value)], { kind: 'eof' }];
         case '//': return [[{ kind: '//', value: state.value }], { kind: 'eof' }];
         case '/*':

package/json/parser/module.f.d.ts

@@ -1,5 +1,5 @@
 import * as result from '../../types/result/module.f.ts';
 import * as list from '../../types/list/module.f.ts';
-import * as Tokenizer from '../tokenizer/module.f.ts';
-import * as Json from '../module.f.ts';
+import type * as Tokenizer from '../tokenizer/module.f.ts';
+import type * as Json from '../module.f.ts';
 export declare const parse: (tokenList: list.List<Tokenizer.JsonToken>) => result.Result<Json.Unknown, string>;

package/json/parser/module.f.js

@@ -1,11 +1,8 @@
 import * as result from "../../types/result/module.f.js";
 import * as list from "../../types/list/module.f.js";
 const { fold, first, drop, toArray } = list;
-import * as Operator from "../../types/function/operator/module.f.js";
-import * as Tokenizer from "../tokenizer/module.f.js";
 import * as map from "../../types/map/module.f.js";
 const { setReplace } = map;
-import * as Json from "../module.f.js";
 import * as o from "../../types/object/module.f.js";
 const { fromMap } = o;
 const addKeyToObject = obj => key => ({ kind: 'object', values: obj.values, key: key });

package/json/serializer/module.f.js

@@ -1,7 +1,5 @@
 import * as list from "../../types/list/module.f.js";
 const { flat, reduce, empty } = list;
-import * as O from "../../types/object/module.f.js";
-import * as Operator from "../../types/function/operator/module.f.js";
 const jsonStringify = JSON.stringify;
 export const stringSerialize = input => [jsonStringify(input)];
 export const numberSerialize = input => [jsonStringify(input)];

package/json/tokenizer/module.f.js

@@ -1,4 +1,3 @@
-import * as Operator from "../../types/function/operator/module.f.js";
 import * as list from "../../types/list/module.f.js";
 const { empty, flat, stateScan } = list;
 import * as bf from "../../types/bigfloat/module.f.js";

package/nanvm-lib/tests/test.f.d.ts

@@ -23,5 +23,33 @@ declare const _default: {
             object: () => void;
         };
     };
+    unary_plus: () => {
+        null: () => void;
+        undefined: () => void;
+        boolean: {
+            false: () => void;
+            true: () => void;
+        };
+        number: {
+            zero: () => void;
+            positive: () => void;
+            negative: () => void;
+        };
+        string: {
+            empty: () => void;
+            zero: () => void;
+            positive: () => void;
+            nan: () => void;
+        };
+        array: {
+            empty: () => void;
+            single_number: () => void;
+            single_string: () => void;
+            multiple: () => void;
+        };
+        object: {
+            empty: () => void;
+        };
+    };
 };
 export default _default;

package/nanvm-lib/tests/test.f.js

@@ -25,6 +25,7 @@ export default {
             },
             nullish: () => {
                 n(false)(undefined);
+                n(false)(null);
             }
         },
         number: {
@@ -80,5 +81,49 @@ export default {
                 n(o)({ '0': '0' });
             }
         }
+    },
+    unary_plus: () => {
+        const op = (n) => +n;
+        const nan = (n) => {
+            let result = op(n);
+            if (!Number.isNaN(result)) {
+                throw result;
+            }
+        };
+        return {
+            null: () => e(op(null))(0),
+            undefined: () => nan(undefined),
+            boolean: {
+                false: () => e(op(false))(0),
+                true: () => e(op(true))(1)
+            },
+            number: {
+                zero: () => e(op(0))(0),
+                positive: () => e(op(2.3))(2.3),
+                negative: () => e(op(-2.3))(-2.3)
+            },
+            string: {
+                empty: () => e(op(""))(0),
+                zero: () => e(op("0"))(0),
+                positive: () => e(op("2.3"))(2.3),
+                nan: () => nan("a")
+            },
+            // TODO: bigint - handle TypeError exception for bigint. The test below (that follows
+            // current Rust implementation) is incorrect.
+            // bigint: {
+            //     nan: () => u_p_nan(0n)
+            // }
+            array: {
+                empty: () => e(op([]))(0),
+                single_number: () => e(op([2.3]))(2.3),
+                single_string: () => e(op(["-2.3"]))(-2.3),
+                multiple: () => nan([null, null])
+            },
+            object: {
+                empty: () => nan({})
+                // TODO: test objects with valueOf, toString functions - when Rust logic is implemented
+            }
+            // TODO: test Function - when Rust logic is implemented
+        };
     }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.3.6",
+  "version": "0.3.8",
   "type": "module",
   "files": [
     "**/*.f.d.ts",

package/text/ascii/module.f.d.ts

@@ -1,4 +1,4 @@
-import { type Range } from '../../types/range/module.f.ts';
+import type { Range } from '../../types/range/module.f.ts';
 export declare const one: (s: string) => number;
 export declare const range: (s: string) => Range;
 /** 0x08 */

package/text/ascii/module.f.js

@@ -1,5 +1,4 @@
-import {} from "../../types/range/module.f.js";
-const at = s => i => {
+const at = (s) => (i) => {
     const r = s.codePointAt(i);
     if (r === void 0) {
         throw s;
@@ -7,7 +6,7 @@ const at = s => i => {
     return r;
 };
 export const one = (s) => at(s)(0);
-export const range = s => {
+export const range = (s) => {
     const f = at(s);
     const f0 = f(0);
     if (s.length === 1) {

package/text/ascii/test.f.js

@@ -1,8 +1,6 @@
-import * as _ from "./module.f.js";
-const { range } = _;
+import { range } from "./module.f.js";
 import * as json from "../../json/module.f.js";
-import * as o from "../../types/object/module.f.js";
-const { sort } = o;
+import { sort } from "../../types/object/module.f.js";
 const stringify = json.stringify(sort);
 export default {
     range: () => {

package/text/module.f.d.ts

@@ -1,8 +1,23 @@
-import * as list from '../types/list/module.f.ts';
+import { type Vec } from "../types/bit_vec/module.f.ts";
+import { type List } from '../types/list/module.f.ts';
 export type Block = ItemThunk | ItemArray;
 type ItemArray = readonly Item[];
-type ItemThunk = () => list.List<Item>;
+type ItemThunk = () => List<Item>;
 export type Item = string | ItemArray | ItemThunk;
-export declare const flat: (indent: string) => (text: Block) => list.List<string>;
+export declare const flat: (indent: string) => (text: Block) => List<string>;
 export declare const curly: (type: string) => (name: string) => (body: Block) => Block;
+/**
+ * Converts a string to an UTF-8, represented as an MSB first bit vector.
+ *
+ * @param s The input string to be converted.
+ * @returns The resulting UTF-8 bit vector, MSB first.
+ */
+export declare const msbUtf8: (s: string) => Vec;
+/**
+ * Converts a UTF-8 bit vector with MSB first encoding to a string.
+ *
+ * @param msbV - The UTF-8 bit vector with MSB first encoding.
+ * @returns The resulting string.
+ */
+export declare const msbUtf8ToString: (msbV: Vec) => string;
 export {};

package/text/module.f.js

@@ -1,10 +1,26 @@
-import * as list from "../types/list/module.f.js";
-const { flatMap } = list;
-export const flat = indent => {
-    const f = prefix => {
-        const g = item => typeof (item) === 'string' ? [`${prefix}${item}`] : f(`${prefix}${indent}`)(item);
+import { msb, u8List, u8ListToVec } from "../types/bit_vec/module.f.js";
+import { flatMap } from "../types/list/module.f.js";
+import * as utf8 from "./utf8/module.f.js";
+import * as utf16 from "./utf16/module.f.js";
+export const flat = (indent) => {
+    const f = (prefix) => {
+        const g = (item) => typeof (item) === 'string' ? [`${prefix}${item}`] : f(`${prefix}${indent}`)(item);
         return flatMap(g);
     };
     return f('');
 };
-export const curly = type => name => body => [`${type} ${name}`, '{', body, '}'];
+export const curly = (type) => (name) => (body) => [`${type} ${name}`, '{', body, '}'];
+/**
+ * Converts a string to an UTF-8, represented as an MSB first bit vector.
+ *
+ * @param s The input string to be converted.
+ * @returns The resulting UTF-8 bit vector, MSB first.
+ */
+export const msbUtf8 = (s) => u8ListToVec(msb)(utf8.fromCodePointList(utf16.toCodePointList(utf16.stringToList(s))));
+/**
+ * Converts a UTF-8 bit vector with MSB first encoding to a string.
+ *
+ * @param msbV - The UTF-8 bit vector with MSB first encoding.
+ * @returns The resulting string.
+ */
+export const msbUtf8ToString = (msbV) => utf16.listToString(utf16.fromCodePointList(utf8.toCodePointList(u8List(msb)(msbV))));

package/text/sgr/module.f.js

@@ -1,7 +1,7 @@
 /**
  * https://en.wikipedia.org/wiki/ANSI_escape_code#SGR
  */
-export const sgr = c => `\x1b[${c.toString()}m`;
+export const sgr = (c) => `\x1b[${c.toString()}m`;
 export const reset = sgr(0);
 export const bold = sgr(1);
 export const fgRed = sgr(31);

package/text/test.f.d.ts

@@ -1,2 +1,5 @@
-declare const _default: () => void;
+declare const _default: {
+    block: () => void;
+    encoding: () => void;
+};
 export default _default;

package/text/test.f.js

@@ -1,18 +1,26 @@
-import * as _ from "./module.f.js";
-import * as string from "../types/string/module.f.js";
-const { join } = string;
-export default () => {
-    const text = [
-        'a',
-        'b',
-        () => [
-            'c',
-            () => ['d'],
-        ],
-        'e',
-    ];
-    const result = join('\n')(_.flat(':')(text));
-    if (result !== 'a\nb\n:c\n::d\ne') {
-        throw result;
+import { flat, msbUtf8, msbUtf8ToString } from "./module.f.js";
+import { join } from "../types/string/module.f.js";
+export default {
+    block: () => {
+        const text = [
+            'a',
+            'b',
+            () => [
+                'c',
+                () => ['d'],
+            ],
+            'e',
+        ];
+        const result = join('\n')(flat(':')(text));
+        if (result !== 'a\nb\n:c\n::d\ne') {
+            throw result;
+        }
+    },
+    encoding: () => {
+        const v = msbUtf8('Hello world!');
+        const r = msbUtf8ToString(v);
+        if (r !== 'Hello world!') {
+            throw r;
+        }
     }
 };

package/text/utf16/module.f.d.ts

@@ -1,9 +1,8 @@
 import { type List, type Thunk } from '../../types/list/module.f.ts';
-type u16 = number;
-type i32 = number;
+type U16 = number;
+type I32 = number;
 export declare const fromCodePointList: (input: List<number>) => Thunk<number>;
-declare const u16: (i: number) => boolean;
-export declare const toCodePointList: (input: List<u16>) => List<i32>;
-export declare const stringToList: (s: string) => List<u16>;
-export declare const listToString: (input: List<u16>) => string;
+export declare const toCodePointList: (input: List<U16>) => List<I32>;
+export declare const stringToList: (s: string) => List<U16>;
+export declare const listToString: (input: List<U16>) => string;
 export {};

package/text/utf16/module.f.js

@@ -1,16 +1,15 @@
 import { map, flat, stateScan, reduce, flatMap, empty, } from "../../types/list/module.f.js";
-import * as operator from "../../types/function/operator/module.f.js";
+import { concat } from "../../types/function/operator/module.f.js";
 import { contains } from "../../types/range/module.f.js";
-import * as f from "../../types/function/module.f.js";
-const { fn } = f;
+import { fn } from "../../types/function/module.f.js";
 const lowBmp = contains([0x0000, 0xd7ff]);
 const highBmp = contains([0xe000, 0xffff]);
-const isBmpCodePoint = codePoint => lowBmp(codePoint) || highBmp(codePoint);
+const isBmpCodePoint = (codePoint) => lowBmp(codePoint) || highBmp(codePoint);
 const isHighSurrogate = contains([0xd800, 0xdbff]);
 const isLowSurrogate = contains([0xdc00, 0xdfff]);
 const errorMask = 0b1000_0000_0000_0000_0000_0000_0000_0000;
 const isSupplementaryPlane = contains([0x01_0000, 0x10_ffff]);
-const codePointToUtf16 = codePoint => {
+const codePointToUtf16 = (codePoint) => {
     if (isBmpCodePoint(codePoint)) {
         return [codePoint];
     }
@@ -50,17 +49,17 @@ const utf16ByteToCodePointOp = state => word => {
     }
     return [[state | errorMask, word | errorMask], null];
 };
-const utf16EofToCodePointOp = state => [state === null ? empty : [state | errorMask], null];
+const utf16EofToCodePointOp = (state) => [state === null ? empty : [state | errorMask], null];
 const utf16ByteOrEofToCodePointOp = state => input => input === null ? utf16EofToCodePointOp(state) : utf16ByteToCodePointOp(state)(input);
 const eofList = [null];
-export const toCodePointList = input => flat(stateScan(utf16ByteOrEofToCodePointOp)(null)(flat([input, eofList])));
-export const stringToList = s => {
-    const at = i => {
+export const toCodePointList = (input) => flat(stateScan(utf16ByteOrEofToCodePointOp)(null)(flat([input, eofList])));
+export const stringToList = (s) => {
+    const at = (i) => {
         const first = s.charCodeAt(i);
         return isNaN(first) ? empty : { first, tail: () => at(i + 1) };
     };
     return at(0);
 };
 export const listToString = fn(map(String.fromCharCode))
-    .then(reduce(operator.concat)(''))
+    .then(reduce(concat)(''))
     .result;