functionalscript 0.8.2 → 0.9.2

package/types/effect/node/virtual/module.f.d.ts

@@ -0,0 +1,13 @@
+import { type Vec } from "../../../bit_vec/module.f.ts";
+import type { MemOperationMap } from "../../mock/module.f.ts";
+import type { NodeOperations } from "../module.f.ts";
+export type VirtualDir = {
+    readonly [name in string]?: VirtualDir | Vec;
+};
+export type VirtualState = {
+    stdout: string;
+    stderr: string;
+    root: VirtualDir;
+};
+export declare const emptyState: VirtualState;
+export declare const virtual: MemOperationMap<NodeOperations, VirtualState>;

package/types/effect/node/virtual/module.f.js

@@ -0,0 +1,98 @@
+import { parse } from "../../../../path/module.f.js";
+import { isVec } from "../../../bit_vec/module.f.js";
+import { error, ok } from "../../../result/module.f.js";
+export const emptyState = {
+    stdout: '',
+    stderr: '',
+    root: {},
+};
+const operation = (op) => {
+    const f = (dir, path) => {
+        if (path.length === 0) {
+            return op(dir, path);
+        }
+        const [first, ...rest] = path;
+        const subDir = dir[first];
+        if (subDir === undefined || isVec(subDir)) {
+            return op(dir, path);
+        }
+        const [newSubDir, r] = f(subDir, rest);
+        return [{ ...dir, [first]: newSubDir }, r];
+    };
+    return (state, path) => {
+        const [root, result] = f(state.root, parse(path));
+        return [{ ...state, root }, result];
+    };
+};
+// TODO: we can have a better implementation with some code shared with `operation`.
+const readOperation = (op) => operation((dir, path) => [dir, op(dir, path)]);
+const okVoid = ok(undefined);
+const mkdir = (recursive) => operation((dir, path) => {
+    let d = {};
+    let i = path.length;
+    if (i > 1 && !recursive) {
+        return [dir, error('non-recursive')];
+    }
+    while (i > 0) {
+        i -= 1;
+        d = { [path[i]]: d };
+    }
+    dir = { ...dir, ...d };
+    return [dir, okVoid];
+});
+const readFileError = error('no such file');
+const readFile = readOperation((dir, path) => {
+    if (path.length !== 1) {
+        return readFileError;
+    }
+    const file = dir[path[0]];
+    if (!isVec(file)) {
+        return error(`'${path[0]}' is not a file`);
+    }
+    return ok(file);
+});
+const writeFileError = error('invalid file');
+const writeFile = (payload) => operation((dir, path) => {
+    if (path.length !== 1) {
+        return [dir, writeFileError];
+    }
+    const [name] = path;
+    const file = dir[name];
+    // fail if the file is a directory
+    if (file !== undefined && !isVec(file)) {
+        return [dir, writeFileError];
+    }
+    dir = { ...dir, [name]: payload };
+    return [dir, okVoid];
+});
+const invalidPath = error('invalid path');
+const { entries } = Object;
+const readdir = (base, recursive) => readOperation((dir, path) => {
+    if (path.length !== 0) {
+        return invalidPath;
+    }
+    const f = (parentPath, d) => {
+        let result = [];
+        for (const [name, content] of entries(d)) {
+            if (content === undefined) {
+                continue;
+            }
+            const isFile = isVec(content);
+            result = [...result, { name, parentPath, isFile }];
+            if (!isFile && recursive) {
+                result = [...result, ...f(`${parentPath}/${name}`, content)];
+            }
+        }
+        return result;
+    };
+    return ok(f(base, dir));
+});
+const console = (name) => (state, payload) => [{ ...state, [name]: `${state[name]}${payload}\n` }, undefined];
+export const virtual = {
+    error: console('stderr'),
+    log: console('stdout'),
+    mkdir: (state, [path, p]) => mkdir(p !== undefined)(state, path),
+    readFile,
+    readdir: (state, [path, { recursive }]) => readdir(path, recursive === true)(state, path),
+    writeFile: (state, [path, payload]) => writeFile(payload)(state, path),
+};

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

@@ -19,7 +19,7 @@ export declare const flip: <A, B, C>(f: (a: A) => (b: B) => C) => (b: B) => (a:
  */
 type Fn<I, O> = {
     readonly result: Func<I, O>;
-    readonly then: <T>(g: Func<O, T>) => Fn<I, T>;
+    readonly map: <T>(g: Func<O, T>) => Fn<I, T>;
 };
 /**
  * Creates an `Fn` instance from a function, enabling chaining of transformations.

package/types/function/module.f.js

@@ -15,5 +15,5 @@ export const flip = f => b => a => f(a)(b);
  */
 export const fn = (result) => ({
     result,
-    then: g => fn(compose(result)(g))
+    map: g => fn(compose(result)(g))
 });

package/types/function/test.f.js

@@ -3,7 +3,7 @@ export default () => {
     const f = x => [x];
     const g = ([x]) => [x.length];
     const w = ([x]) => x;
-    const r = fn(f).then(g).then(w).result;
+    const r = fn(f).map(g).map(w).result;
     const result = r('hello');
     if (result !== 5) {
         throw r;

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

@@ -12,6 +12,7 @@ type Concat<T> = {
     readonly head: List<T>;
     readonly tail: List<T>;
 };
+export declare const fromArrayLike: <T>(array: ArrayLike<T>) => Result<T>;
 export declare const concat: <T>(head: List<T>) => (tail: List<T>) => List<T>;
 export declare const next: <T>(head: List<T>) => Result<T>;
 export declare const iterable: <T>(list: List<T>) => Iterable<T>;

package/types/list/module.f.js

@@ -1,6 +1,6 @@
 import { identity, fn, compose } from "../function/module.f.js";
 import { addition, logicalNot, strictEqual, stateScanToScan, foldToScan, reduceToScan, } from "../function/operator/module.f.js";
-const fromArray = (array) => {
+export const fromArrayLike = (array) => {
     const at = (i) => i < array.length ? { first: array[i], tail: () => at(i + 1) } : null;
     return at(0);
 };
@@ -16,7 +16,7 @@ export const next = (head) => {
     while (true) {
         head = trampoline(head);
         if (head instanceof Array) {
-            head = fromArray(head);
+            head = fromArrayLike(head);
         }
         else if (head !== null && 'head' in head) {
             [head, tail] = [head.head, concat(head.tail)(tail)];
@@ -96,12 +96,12 @@ export const last = first => tail => {
 export const find = def => f => compose(filter(f))(first(def));
 export const some = find(false)(identity);
 export const isEmpty = fn(map(() => true))
-    .then(some)
-    .then(logicalNot)
+    .map(some)
+    .map(logicalNot)
     .result;
 export const every = fn(map(logicalNot))
-    .then(some)
-    .then(logicalNot)
+    .map(some)
+    .map(logicalNot)
     .result;
 export const includes = value => compose(map(strictEqual(value)))(some);
 export const countdown = count => () => {

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

@@ -1,3 +1,5 @@
+import type { Option } from '../option/module.f.ts';
 export type Nullable<T> = T | null;
 export declare const map: <T, R>(f: (value: T) => R) => (value: Nullable<T>) => Nullable<R>;
 export declare const match: <T, R>(f: (_: T) => R) => (none: () => R) => (_: Nullable<T>) => Nullable<R>;
+export declare const toOption: <T>(value: Nullable<T>) => Option<T>;

package/types/nullable/module.f.js

@@ -1,2 +1,3 @@
 export const map = f => value => value === null ? null : f(value);
 export const match = f => none => value => value === null ? none() : f(value);
+export const toOption = (value) => value === null ? [] : [value];

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

@@ -1,2 +1,2 @@
-declare const _default: () => void;
+declare const _default: (() => void)[];
 export default _default;

package/types/nullable/test.f.js

@@ -1,12 +1,24 @@
-import { map } from "./module.f.js";
-export default () => {
-    const optionSq = map((v) => v * v);
-    const sq3 = optionSq(3);
-    if (sq3 !== 9) {
-        throw sq3;
+import { map, toOption } from "./module.f.js";
+export default [
+    () => {
+        const optionSq = map((v) => v * v);
+        const sq3 = optionSq(3);
+        if (sq3 !== 9) {
+            throw sq3;
+        }
+        const sqNull = optionSq(null);
+        if (sqNull !== null) {
+            throw sqNull;
+        }
+    },
+    () => {
+        const opt1 = toOption(5);
+        if (opt1.length !== 1 || opt1[0] !== 5) {
+            throw opt1;
+        }
+        const opt2 = toOption(null);
+        if (opt2.length !== 0) {
+            throw opt2;
+        }
     }
-    const sqNull = optionSq(null);
-    if (sqNull !== null) {
-        throw sqNull;
-    }
-};
+];

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

@@ -0,0 +1,9 @@
+/**
+ * Optional tuple-based value representation.
+ *
+ * @module
+ */
+/**
+ * Represents an optional value as an empty tuple or a tuple with one value.
+ */
+export type Option<T> = readonly [T] | readonly [];

package/types/option/module.f.js

@@ -0,0 +1,6 @@
+/**
+ * Optional tuple-based value representation.
+ *
+ * @module
+ */
+export {};

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

@@ -0,0 +1,11 @@
+import { type Vec } from "../bit_vec/module.f.ts";
+/**
+ * Converts a Uint8Array into an MSB-first bit vector.
+ */
+export declare const toVec: (input: Uint8Array) => Vec;
+/**
+ * Converts an MSB-first bit vector into a Uint8Array.
+ */
+export declare const fromVec: (input: Vec) => Uint8Array;
+export declare const decodeUtf8: (input: Uint8Array) => string;
+export declare const encodeUtf8: (input: string) => Uint8Array;

package/types/uint8array/module.f.js

@@ -0,0 +1,21 @@
+/**
+ * Conversions between Uint8Array values and bit vectors.
+ *
+ * @module
+ */
+import { utf8, utf8ToString } from "../../text/module.f.js";
+import { msb, u8List, u8ListToVec } from "../bit_vec/module.f.js";
+import { compose } from "../function/module.f.js";
+import { fromArrayLike, iterable } from "../list/module.f.js";
+const u8ListToVecMsb = u8ListToVec(msb);
+const u8ListMsb = u8List(msb);
+/**
+ * Converts a Uint8Array into an MSB-first bit vector.
+ */
+export const toVec = (input) => u8ListToVecMsb(fromArrayLike(input));
+/**
+ * Converts an MSB-first bit vector into a Uint8Array.
+ */
+export const fromVec = (input) => Uint8Array.from(iterable(u8ListMsb(input)));
+export const decodeUtf8 = compose(toVec)(utf8ToString);
+export const encodeUtf8 = compose(utf8)(fromVec);

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

@@ -0,0 +1,12 @@
+declare const _default: {
+    empty: () => void;
+    roundTrip: () => void;
+    unalignedLength: () => void;
+    encodeUtf8Empty: () => void;
+    encodeUtf8Ascii: () => void;
+    encodeUtf8Multibyte: () => void;
+    decodeUtf8Ascii: () => void;
+    decodeUtf8Multibyte: () => void;
+    utf8RoundTrip: () => void;
+};
+export default _default;

package/types/uint8array/test.f.js

@@ -0,0 +1,58 @@
+import { vec } from "../bit_vec/module.f.js";
+import { toVec, fromVec, decodeUtf8, encodeUtf8 } from "./module.f.js";
+import { strictEqual } from "../function/operator/module.f.js";
+import { equal, fromArrayLike } from "../list/module.f.js";
+const assertEq = (a, b) => {
+    if (a !== b) {
+        throw [a, b];
+    }
+};
+const assertArrayEq = (a, b) => {
+    if (!equal(strictEqual)(fromArrayLike(a))(fromArrayLike(b))) {
+        throw [a, b];
+    }
+};
+export default {
+    empty: () => {
+        const input = new Uint8Array();
+        const vec = toVec(input);
+        const output = fromVec(vec);
+        assertArrayEq(output, input);
+    },
+    roundTrip: () => {
+        const input = Uint8Array.from([0, 1, 2, 3, 255]);
+        const vec = toVec(input);
+        const output = fromVec(vec);
+        assertArrayEq(output, input);
+    },
+    unalignedLength: () => {
+        const input = vec(4n)(0xfn);
+        const output = fromVec(input);
+        assertArrayEq(output, Uint8Array.from([0xF0]));
+    },
+    encodeUtf8Empty: () => {
+        const output = encodeUtf8('');
+        assertArrayEq(output, new Uint8Array());
+    },
+    encodeUtf8Ascii: () => {
+        const output = encodeUtf8('Hi!');
+        assertArrayEq(output, Uint8Array.from([72, 105, 33]));
+    },
+    encodeUtf8Multibyte: () => {
+        const output = encodeUtf8('✓');
+        assertArrayEq(output, Uint8Array.from([0xE2, 0x9C, 0x93]));
+    },
+    decodeUtf8Ascii: () => {
+        const output = decodeUtf8(Uint8Array.from([102, 115]));
+        assertEq(output, 'fs');
+    },
+    decodeUtf8Multibyte: () => {
+        const output = decodeUtf8(Uint8Array.from([0xE2, 0x9C, 0x93]));
+        assertEq(output, '✓');
+    },
+    utf8RoundTrip: () => {
+        const input = 'FunctionalScript 🐝';
+        const output = decodeUtf8(encodeUtf8(input));
+        assertEq(output, input);
+    }
+};

package/website/module.d.ts

@@ -0,0 +1 @@
+export {};

package/website/module.f.d.ts

@@ -0,0 +1,3 @@
+import { type NodeEffect } from '../types/effect/node/module.f.ts';
+declare const _default: () => NodeEffect<number>;
+export default _default;

package/website/module.f.js

@@ -0,0 +1,9 @@
+import { htmlToString } from "../html/module.f.js";
+import { writeFile } from "../types/effect/node/module.f.js";
+import { utf8 } from "../text/module.f.js";
+const html = ['body',
+    ['a', { href: 'https://github.com/functionalscript/functionalscript' }, 'GitHub Repository']
+];
+const program = writeFile('index.html', utf8(htmlToString(html)))
+    .map(() => 0);
+export default () => program;

package/website/module.js

@@ -0,0 +1,3 @@
+import { nodeRun } from "../io/module.js";
+import run from "./module.f.js";
+await nodeRun(run);

package/fsc/module.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export {};

package/fsc/module.js

@@ -1,4 +0,0 @@
-#!/usr/bin/env node
-import node from "../io/module.js";
-import { compile } from "../djs/module.f.js";
-await node(compile);