functionalscript 0.9.1 → 0.9.3

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

@@ -0,0 +1,103 @@
+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: {},
+    internet: {},
+};
+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'),
+    fetch: (state, url) => {
+        const result = state.internet[url];
+        return result === undefined ? [state, error('not found')] : [state, ok(result)];
+    },
+    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.js

@@ -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/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);