functionalscript 0.10.1 → 0.10.3

package/bnf/module.f.d.ts

@@ -7,9 +7,21 @@ import { type Array2 } from '../types/array/module.f.ts';
  * - 0xEEEEEE is the last symbol (24 bits)
  */
 export type TerminalRange = number;
+/**
+ * Full 24-bit symbol range packed into a single {@link TerminalRange}.
+ */
 export declare const fullRange: TerminalRange;
+/**
+ * Unicode scalar value range packed into a single {@link TerminalRange}.
+ */
 export declare const unicodeRange: TerminalRange;
+/**
+ * Maximal non-Unicode symbol encoded as a string value.
+ */
 export declare const max: string;
+/**
+ * Maximal Unicode code point encoded as a string value.
+ */
 export declare const unicodeMax: string;
 /** A sequence of rules. */
 export type Sequence = readonly Rule[];
@@ -17,16 +29,47 @@ export type Sequence = readonly Rule[];
 export type Variant = {
     readonly [k in string]: Rule;
 };
+/**
+ * Data-only grammar rule.
+ */
 export type DataRule = Variant | Sequence | TerminalRange | string;
+/**
+ * Lazily evaluated grammar rule.
+ */
 export type LazyRule = () => DataRule;
+/**
+ * Grammar rule, either immediate data or lazy rule factory.
+ */
 export type Rule = DataRule | LazyRule;
 export declare const rangeEncode: (a: number, b: number) => TerminalRange;
+/**
+ * Encodes a single symbol as a {@link TerminalRange}.
+ */
 export declare const oneEncode: (a: number) => TerminalRange;
+/**
+ * End-of-file marker represented as one code point beyond Unicode range.
+ */
 export declare const eof: TerminalRange;
+/**
+ * Decodes a packed range into `[start, end]` symbols.
+ */
 export declare const rangeDecode: (r: number) => Array2<number>;
 export declare const toSequence: (s: string) => readonly TerminalRange[];
+/**
+ * Converts the whole string into one rule:
+ * - a single {@link TerminalRange} when the string has one symbol,
+ * - a sequence of {@link TerminalRange} values when the string has multiple symbols.
+ */
 export declare const str: (s: string) => readonly TerminalRange[] | TerminalRange;
+/**
+ * Converts a string into a variant that maps each character to its symbol range.
+ */
 export declare const set: (s: string) => RangeVariant;
+/**
+ * Encodes a two-symbol string into a terminal range.
+ *
+ * @throws If `ab` does not contain exactly two unicode code points.
+ */
 export declare const range: (ab: string) => TerminalRange;
 /**
  * A set of terminal ranges compatible with the `Variant` rule.
@@ -35,14 +78,32 @@ export type RangeVariant = {
     readonly [k in string]: TerminalRange;
 };
 export declare const remove: (range: TerminalRange, v: RangeVariant) => RangeVariant;
+/**
+ * Returns the complement set of the provided ranges over {@link fullRange}.
+ */
 export declare const not: (v: RangeVariant) => RangeVariant;
+/**
+ * Returns the complement set of a character set over {@link fullRange}.
+ */
 export declare const notSet: (s: string) => RangeVariant;
+/**
+ * Empty sequence type for optional grammar branches.
+ */
 export type None = readonly [];
+/**
+ * Shared empty sequence literal.
+ */
 export declare const none: None;
+/**
+ * Optional grammar branch.
+ */
 export type Option<S> = {
     some: S;
     none: None;
 };
+/**
+ * Creates an option value from a required branch.
+ */
 export declare const option: <S extends Rule>(some: S) => Option<S>;
 export type Repeat0Plus<T> = () => Option<readonly [T, Repeat0Plus<T>]>;
 /**
@@ -61,9 +122,21 @@ export type Repeat1Plus<T> = readonly [T, Repeat0Plus<T>];
  */
 export declare const repeat1Plus: <T extends Rule>(some: T) => Repeat1Plus<T>;
 export type Join1Plus<T, S> = readonly [T, Repeat0Plus<readonly [S, T]>];
+/**
+ * Repeats `some` one or more times separated by `separator`.
+ */
 export declare const join1Plus: <T extends Rule, S extends Rule>(some: T, separator: S) => Join1Plus<T, S>;
 export type Join0Plus<T, S> = Option<readonly [T, Repeat0Plus<readonly [S, T]>]>;
+/**
+ * Repeats `some` zero or more times separated by `separator`.
+ */
 export declare const join0Plus: <T extends Rule, S extends Rule>(some: T, separator: S) => Rule;
 export type Repeat<T> = readonly T[];
+/**
+ * Repeats a rule a fixed number of times.
+ */
 export declare const repeat: (n: number) => <T extends Rule>(some: T) => Repeat<T>;
+/**
+ * Determines whether the rule is an empty rule.
+ */
 export declare const isEmpty: (rule: Rule) => boolean;

package/bnf/module.f.js

@@ -1,9 +1,21 @@
 import { codePointListToString, stringToCodePointList } from "../text/utf16/module.f.js";
 import { isArray2 } from "../types/array/module.f.js";
 import { map, toArray, repeat as listRepeat } from "../types/list/module.f.js";
+/**
+ * Full 24-bit symbol range packed into a single {@link TerminalRange}.
+ */
 export const fullRange = 0x000000_FFFFFF;
+/**
+ * Unicode scalar value range packed into a single {@link TerminalRange}.
+ */
 export const unicodeRange = 0x000000_10FFFF;
+/**
+ * Maximal non-Unicode symbol encoded as a string value.
+ */
 export const max = codePointListToString([0xFFFFFF]);
+/**
+ * Maximal Unicode code point encoded as a string value.
+ */
 export const unicodeMax = codePointListToString([0x10FFFF]);
 // Internals:
 const { fromEntries, values } = Object;
@@ -20,17 +32,39 @@ export const rangeEncode = (a, b) => {
     }
     return Number((BigInt(a) << BigInt(offset)) | BigInt(b));
 };
+/**
+ * Encodes a single symbol as a {@link TerminalRange}.
+ */
 export const oneEncode = (a) => rangeEncode(a, a);
+/**
+ * End-of-file marker represented as one code point beyond Unicode range.
+ */
 export const eof = oneEncode(0x110000);
+/**
+ * Decodes a packed range into `[start, end]` symbols.
+ */
 export const rangeDecode = (r) => [Number(BigInt(r) >> BigInt(offset)), Number(BigInt(r) & BigInt(mask))];
 const mapOneEncode = map(oneEncode);
 export const toSequence = (s) => toArray(mapOneEncode(stringToCodePointList(s)));
+/**
+ * Converts the whole string into one rule:
+ * - a single {@link TerminalRange} when the string has one symbol,
+ * - a sequence of {@link TerminalRange} values when the string has multiple symbols.
+ */
 export const str = (s) => {
     const x = toSequence(s);
     return x.length === 1 ? x[0] : x;
 };
 const mapEntry = map((v) => [fromCodePoint(v), oneEncode(v)]);
+/**
+ * Converts a string into a variant that maps each character to its symbol range.
+ */
 export const set = (s) => fromEntries(toArray(mapEntry(stringToCodePointList(s))));
+/**
+ * Encodes a two-symbol string into a terminal range.
+ *
+ * @throws If `ab` does not contain exactly two unicode code points.
+ */
 export const range = (ab) => {
     const a = toArray(stringToCodePointList(ab));
     if (!isArray2(a)) {
@@ -65,9 +99,21 @@ export const remove = (range, v) => {
     }
     return toVariantRangeSet(result);
 };
+/**
+ * Returns the complement set of the provided ranges over {@link fullRange}.
+ */
 export const not = (v) => remove(fullRange, v);
+/**
+ * Returns the complement set of a character set over {@link fullRange}.
+ */
 export const notSet = (s) => not(set(s));
+/**
+ * Shared empty sequence literal.
+ */
 export const none = [];
+/**
+ * Creates an option value from a required branch.
+ */
 export const option = (some) => ({
     some,
     none,
@@ -89,9 +135,21 @@ export const repeat0Plus = (some) => {
  * Repeat one or more times.
  */
 export const repeat1Plus = (some) => [some, repeat0Plus(some)];
+/**
+ * Repeats `some` one or more times separated by `separator`.
+ */
 export const join1Plus = (some, separator) => [some, repeat0Plus([separator, some])];
+/**
+ * Repeats `some` zero or more times separated by `separator`.
+ */
 export const join0Plus = (some, separator) => option(join1Plus(some, separator));
+/**
+ * Repeats a rule a fixed number of times.
+ */
 export const repeat = (n) => (some) => toArray(listRepeat(some)(n));
+/**
+ * Determines whether the rule is an empty rule.
+ */
 export const isEmpty = (rule) => {
     const d = typeof rule === 'function' ? rule() : rule;
     return d === '' || (d instanceof Array && d.length === 0);

package/cas/module.f.d.ts

@@ -5,8 +5,8 @@
  */
 import { type Sha2 } from "../crypto/sha2/module.f.ts";
 import type { Vec } from "../types/bit_vec/module.f.ts";
-import { type Effect, type Operations } from "../types/effect/module.f.ts";
-import { type Fs, type NodeOperations } from "../types/effect/node/module.f.ts";
+import { type Effect, type Operations } from "../types/effects/module.f.ts";
+import { type Fs, type NodeOperations } from "../types/effects/node/module.f.ts";
 export type KvStore<O extends Operations> = {
     readonly read: (key: Vec) => Effect<O, Vec | undefined>;
     readonly write: (key: Vec, value: Vec) => Effect<O, void>;

package/cas/module.f.js

@@ -6,8 +6,8 @@
 import { computeSync, sha256 } from "../crypto/sha2/module.f.js";
 import { parse } from "../path/module.f.js";
 import { cBase32ToVec, vecToCBase32 } from "../types/cbase32/module.f.js";
-import { pure } from "../types/effect/module.f.js";
-import { error, log, mkdir, readdir, readFile, writeFile } from "../types/effect/node/module.f.js";
+import { fluent, pure } from "../types/effects/module.f.js";
+import { error, log, mkdir, readdir, readFile, writeFile } from "../types/effects/node/module.f.js";
 import { toOption } from "../types/nullable/module.f.js";
 import { unwrap } from "../types/result/module.f.js";
 const o = { withFileTypes: true };
@@ -20,20 +20,29 @@ const toPath = (key) => {
     return `${prefix}/${a}/${b}/${c}`;
 };
 export const fileKvStore = (path) => ({
-    read: (key) => readFile(toPath(key))
-        .map(([status, data]) => status === 'error' ? undefined : data),
+    read: (key) => fluent
+        .step(() => readFile(toPath(key)))
+        .step(([status, data]) => pure(status === 'error' ? undefined : data))
+        .effect,
     write: (key, value) => {
         const p = toPath(key);
         const parts = parse(p);
         const dir = `${path}/${parts.slice(0, -1).join('/')}`;
         // TODO: error handling
-        return mkdir(dir, { recursive: true })
-            .pipe(() => writeFile(`${path}/${p}`, value))
-            .map(() => undefined);
+        return fluent
+            .step(() => mkdir(dir, { recursive: true }))
+            .step(() => writeFile(`${path}/${p}`, value))
+            .step(() => pure(undefined))
+            .effect;
     },
-    list: () => readdir('.cas', { recursive: true })
-        // TODO: remove unwrap
-        .map(r => unwrap(r).flatMap(({ name, parentPath, isFile }) => toOption(isFile ? cBase32ToVec(parentPath.substring(prefix.length).replaceAll('/', '') + name) : null))),
+    list: () => 
+    // TODO: remove unwrap
+    fluent
+        .step(() => readdir('.cas', { recursive: true }))
+        .step(r => pure(unwrap(r).flatMap(({ name, parentPath, isFile }) => toOption(isFile
+        ? cBase32ToVec(parentPath.substring(prefix.length).replaceAll('/', '') + name)
+        : null))))
+        .effect,
 });
 export const cas = (sha2) => {
     const compute = computeSync(sha2);
@@ -41,13 +50,18 @@ export const cas = (sha2) => {
         read,
         write: (value) => {
             const hash = compute([value]);
-            return write(hash, value)
-                .map(() => hash);
+            return fluent
+                .step(() => write(hash, value))
+                .step(() => pure(hash))
+                .effect;
         },
         list,
     });
 };
-const e = (s) => error(s).map(() => 1);
+const e = (s) => fluent
+    .step(() => error(s))
+    .step(() => pure(1))
+    .effect;
 export const main = (args) => {
     const c = cas(sha256)(fileKvStore('.'));
     const [cmd, ...options] = args;
@@ -57,10 +71,12 @@ export const main = (args) => {
                 return e("'cas add' expects one parameter");
             }
             const [path] = options;
-            return readFile(path)
-                .pipe(v => c.write(unwrap(v)))
-                .pipe(hash => log(vecToCBase32(hash)))
-                .map(() => 0);
+            return fluent
+                .step(() => readFile(path))
+                .step(v => c.write(unwrap(v)))
+                .step(hash => log(vecToCBase32(hash)))
+                .step(() => pure(0))
+                .effect;
         }
         case 'get': {
             if (options.length !== 2) {
@@ -71,25 +87,36 @@ export const main = (args) => {
             if (hash === null) {
                 return e(`invalid hash format: ${hashCBase32}`);
             }
-            return c.read(hash)
-                .pipe(v => {
+            return fluent
+                .step(() => c.read(hash))
+                .step(v => {
                 const result = v === undefined
                     ? e(`no such hash: ${hashCBase32}`)
-                    : writeFile(path, v).map(() => 0);
+                    : fluent
+                        .step(() => writeFile(path, v))
+                        .step(() => pure(0))
+                        .effect;
                 return result;
-            });
+            })
+                .effect;
         }
         case 'list': {
-            return c.list()
-                .pipe(v => {
+            return fluent
+                .step(() => c.list())
+                .step(v => {
                 // TODO: make it lazy.
-                let i = pure(undefined);
+                let i = fluent.effect;
                 for (const j of v) {
-                    i = i.pipe(() => log(vecToCBase32(j)));
+                    const prev = i;
+                    i = fluent
+                        .step(() => prev)
+                        .step(() => log(vecToCBase32(j)))
+                        .effect;
                 }
                 return i;
             })
-                .map(() => 0);
+                .step(() => pure(0))
+                .effect;
         }
         case undefined: {
             return e('Error: CAS command requires subcommand');

package/ci/module.f.d.ts

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

package/ci/module.f.js

@@ -4,7 +4,8 @@
  * @module
  */
 import { utf8 } from "../text/module.f.js";
-import { writeFile } from "../types/effect/node/module.f.js";
+import { fluent, pure } from "../types/effects/module.f.js";
+import { writeFile } from "../types/effects/node/module.f.js";
 const os = ['ubuntu', 'macos', 'windows'];
 const architecture = ['intel', 'arm'];
 // https://docs.github.com/en/actions/reference/runners/github-hosted-runners#standard-github-hosted-runners-for-public-repositories
@@ -176,6 +177,8 @@ const gha = {
     on: { pull_request: {} },
     jobs,
 };
-export const effect = writeFile('.github/workflows/ci.yml', utf8(JSON.stringify(gha, null, '  ')))
-    .map(() => 0);
+export const effect = fluent
+    .step(() => writeFile('.github/workflows/ci.yml', utf8(JSON.stringify(gha, null, '  '))))
+    .step(() => pure(0))
+    .effect;
 export default () => effect;

package/dev/module.f.js

@@ -5,10 +5,11 @@
  */
 import { fromIo } from "../io/module.f.js";
 import { updateVersion } from "./version/module.f.js";
-import { decodeUtf8, encodeUtf8 } from "../types/uint8array/module.f.js";
-import { readFile } from "../types/effect/node/module.f.js";
+import { encodeUtf8 } from "../types/uint8array/module.f.js";
+import { readFile } from "../types/effects/node/module.f.js";
 import { utf8ToString } from "../text/module.f.js";
 import { unwrap } from "../types/result/module.f.js";
+import { fluent, pure } from "../types/effects/module.f.js";
 export const todo = () => { throw 'not implemented'; };
 const cmp = ([a], [b]) => a < b ? -1 : a > b ? 1 : 0;
 export const env = ({ process: { env } }) => a => {
@@ -57,9 +58,11 @@ export const loadModuleMap = async (io) => {
     return Object.fromEntries(map.toSorted(cmp));
 };
 const denoJson = './deno.json';
-const index2 = updateVersion
-    .pipe(() => readFile(denoJson))
-    .map(v => JSON.parse(utf8ToString(unwrap(v))));
+const index2 = fluent
+    .step(() => updateVersion)
+    .step(() => readFile(denoJson))
+    .step(v => pure(JSON.parse(utf8ToString(unwrap(v)))))
+    .effect;
 export const index = async (io) => {
     const runner = fromIo(io);
     const jsr_json = await runner(index2);

package/dev/tf/all.test.js

@@ -48,4 +48,5 @@ const run = async () => {
         }
     }
 };
+// we need `await` for Playwright.
 await run();

package/dev/version/module.f.d.ts

@@ -1,2 +1,2 @@
-import { type NodeEffect } from "../../types/effect/node/module.f.ts";
+import { type NodeEffect } from "../../types/effects/node/module.f.ts";
 export declare const updateVersion: NodeEffect<number>;

package/dev/version/module.f.js

@@ -4,21 +4,24 @@
  * @module
  */
 import { utf8, utf8ToString } from "../../text/module.f.js";
-import { all } from "../../types/effect/module.f.js";
-import { readFile, writeFile } from "../../types/effect/node/module.f.js";
+import { all, fluent, pure, step } from "../../types/effects/module.f.js";
+import { readFile, writeFile } from "../../types/effects/node/module.f.js";
 import { unwrap } from "../../types/result/module.f.js";
 const { stringify, parse } = JSON;
 const jsonFile = (jsonFile) => `${jsonFile}.json`;
-const readJson = (name) => readFile(jsonFile(name))
-    .map(v => parse(utf8ToString(unwrap(v))));
-const writeVersion = (version) => (name) => readJson(name)
-    .pipe(json => writeFile(jsonFile(name), utf8(stringify({
+const readJson = (name) => fluent
+    .step(() => readFile(jsonFile(name)))
+    .step(v => pure(parse(utf8ToString(unwrap(v)))))
+    .effect;
+const writeVersion = (version) => (name) => step(readJson(name))(json => writeFile(jsonFile(name), utf8(stringify({
     ...json,
     version,
 }, null, 2))));
-export const updateVersion = readJson('package')
-    .pipe(p => {
+export const updateVersion = fluent
+    .step(() => readJson('package'))
+    .step(p => {
     const w = writeVersion(p.version);
     return all([w('package'), w('deno')]);
 })
-    .map(() => 0);
+    .step(() => pure(0))
+    .effect;

package/dev/version/test.f.js

@@ -1,9 +1,9 @@
 import { utf8, utf8ToString } from "../../text/module.f.js";
 import { isVec } from "../../types/bit_vec/module.f.js";
-import { run } from "../../types/effect/mock/module.f.js";
-import { all } from "../../types/effect/module.f.js";
-import { writeFile } from "../../types/effect/node/module.f.js";
-import { emptyState, virtual } from "../../types/effect/node/virtual/module.f.js";
+import { run } from "../../types/effects/mock/module.f.js";
+import { all } from "../../types/effects/module.f.js";
+import { writeFile } from "../../types/effects/node/module.f.js";
+import { emptyState, virtual } from "../../types/effects/node/virtual/module.f.js";
 import { updateVersion } from "./module.f.js";
 const version = '0.3.0';
 const x = {

package/io/module.d.ts

@@ -1,5 +1,5 @@
 import { type Io, type Run } from './module.f.ts';
-import type { NodeProgram } from '../types/effect/node/module.f.ts';
+import type { NodeProgram } from '../types/effects/node/module.f.ts';
 export declare const io: Io;
 export declare const legacyRun: Run;
 export type NodeRun = (p: NodeProgram) => Promise<number>;

package/io/module.f.d.ts

@@ -1,4 +1,4 @@
-import type { NodeEffect } from '../types/effect/node/module.f.ts';
+import type { NodeEffect } from '../types/effects/node/module.f.ts';
 import { type Result } from '../types/result/module.f.ts';
 /**
  * Represents a directory entry (file or directory) in the filesystem

package/io/module.f.js

@@ -1,5 +1,5 @@
 import { normalize } from "../path/module.f.js";
-import { asyncRun } from "../types/effect/module.js";
+import { asyncRun } from "../types/effects/module.js";
 import { error, ok } from "../types/result/module.f.js";
 import { fromVec, toVec } from "../types/uint8array/module.f.js";
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.10.1",
+  "version": "0.10.3",
   "type": "module",
   "files": [
     "**/*.js",

package/types/{effect → effects}/mock/module.f.js

@@ -2,10 +2,10 @@ export const run = (o) => (state) => (effect) => {
     let s = state;
     let e = effect;
     while (true) {
-        if ('pure' in e) {
-            return [s, e.pure];
+        if (e.length === 1) {
+            return [s, e[0]];
         }
-        const [cmd, payload, cont] = e.do;
+        const [cmd, payload, cont] = e;
         const operation = o[cmd];
         const [ns, m] = operation(s, payload);
         s = ns;

package/types/{effect → effects}/module.f.d.ts

@@ -6,23 +6,22 @@
 export type Operations = {
     readonly [command in string]: readonly [input: unknown, output: unknown];
 };
-export type Effect<O extends Operations, T> = Pure<O, T> | Do<O, T>;
-export type Map<O extends Operations, T> = {
-    readonly pipe: <O1 extends Operations, R>(f: (_: T) => Effect<O1, R>) => Effect<O | O1, R>;
-    readonly map: <O1 extends Operations, R>(f: (_: T) => R) => Effect<O | O1, R>;
-};
-export type Pure<O extends Operations, T> = {
-    readonly pure: T;
-} & Map<O, T>;
-export declare const pure: <O extends Operations, T>(value: T) => Pure<O, T>;
+export type Effect<O extends Operations, T> = Pure<T> | Do<O, T>;
+export type Pure<T> = readonly [T];
 export type One<O extends Operations, T, K extends keyof O & string> = readonly [K, O[K][0], (input: O[K][1]) => Effect<O, T>];
 export type Do<O extends Operations, T> = {
-    readonly do: {
-        readonly [K in keyof O & string]: One<O, T, K>;
-    }[keyof O & string];
-} & Map<O, T>;
+    readonly [K in keyof O & string]: One<O, T, K>;
+}[keyof O & string];
+export declare const pure: <T>(value: T) => Pure<T>;
 export declare const do_: <O extends Operations, K extends keyof O & string>(cmd: K, payload: O[K][0]) => Do<O, O[K][1]>;
 export type ToAsyncOperationMap<O extends Operations> = {
     readonly [K in keyof O]: (payload: O[K][0]) => Promise<O[K][1]>;
 };
+export declare const step: <O extends Operations, T>(e: Effect<O, T>) => <O1 extends Operations, R>(f: (_: T) => Effect<O1, R>) => Effect<O | O1, R>;
+export declare const map: <O extends Operations, T>(e: Effect<O, T>) => <R>(f: (_: T) => R) => Effect<O, R>;
+export type Fluent<O extends Operations, T> = {
+    readonly effect: Effect<O, T>;
+    readonly step: <O1 extends Operations, R>(f: (_: T) => Effect<O1, R>) => Fluent<O | O1, R>;
+};
+export declare const fluent: Fluent<{}, void>;
 export declare const all: <O extends Operations, T>(set: readonly Effect<O, T>[]) => Effect<O, readonly T[]>;

package/types/effects/module.f.js

@@ -0,0 +1,20 @@
+export const pure = (value) => [value];
+const doFull = (cmd, payload, cont) => [cmd, payload, cont];
+export const do_ = (cmd, payload) => doFull(cmd, payload, pure);
+export const step = (e) => (f) => {
+    if (e.length === 1) {
+        const [value] = e;
+        return f(value);
+    }
+    const [cmd, payload, cont] = e;
+    return doFull(cmd, payload, x => step(cont(x))(f));
+};
+export const map = (e) => (f) => step(e)(x => pure(f(x)));
+const wrap = (effect) => ({
+    effect,
+    step: x => wrap(step(effect)(x)),
+});
+export const fluent = wrap(pure(undefined));
+const empty = pure([]);
+// TODO: replace with either a `Do` operation or as an addition to `Pure` and `Do`.
+export const all = (set) => set.reduce((previous, current) => step(previous)(previousResult => map(current)(currentResult => [...previousResult, currentResult])), empty);

package/types/{effect → effects}/module.js

@@ -1,9 +1,9 @@
 export const asyncRun = (map) => async (effect) => {
     while (true) {
-        if ('pure' in effect) {
-            return effect.pure;
+        if (effect.length === 1) {
+            return effect[0];
         }
-        const [command, payload, continuation] = effect.do;
+        const [command, payload, continuation] = effect;
         const operation = map[command];
         const result = await operation(payload);
         effect = continuation(result);

package/types/{effect → effects}/node/test.f.js

@@ -1,10 +1,11 @@
 import { empty, isVec, uint, vec8 } from "../../bit_vec/module.f.js";
+import { map } from "../module.f.js";
 import { run } from "../mock/module.f.js";
 import { fetch, mkdir, readdir, readFile, writeFile } from "./module.f.js";
 import { emptyState, virtual } from "./virtual/module.f.js";
 export default {
     map: () => {
-        let e = readFile('hello').map(([k, v]) => {
+        let e = map(readFile('hello'))(([k, v]) => {
             if (k === 'error') {
                 throw v;
             }
@@ -12,14 +13,14 @@ export default {
         });
         //
         while (true) {
-            if ('pure' in e) {
-                const result = e.pure;
+            if (e.length === 1) {
+                const result = e[0];
                 if (result !== 0x2an) {
                     throw result;
                 }
                 return;
             }
-            const [cmd, p, cont] = e.do;
+            const [cmd, p, cont] = e;
             if (cmd !== 'readFile') {
                 throw cmd;
             }

package/website/module.f.d.ts

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

package/website/module.f.js

@@ -4,11 +4,14 @@
  * @module
  */
 import { htmlToString } from "../html/module.f.js";
-import { writeFile } from "../types/effect/node/module.f.js";
+import { writeFile } from "../types/effects/node/module.f.js";
 import { utf8 } from "../text/module.f.js";
+import { fluent, pure } from "../types/effects/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);
+const program = fluent
+    .step(() => writeFile('index.html', utf8(htmlToString(html))))
+    .step(() => pure(0))
+    .effect;
 export default () => program;

package/types/effect/module.f.js

@@ -1,14 +0,0 @@
-export const pure = (value) => ({
-    pure: value,
-    pipe: e => e(value),
-    map: f => pure(f(value))
-});
-const doFull = (cmd, payload, cont) => ({
-    do: [cmd, payload, cont],
-    pipe: e => doFull(cmd, payload, x => cont(x).pipe(e)),
-    map: f => doFull(cmd, payload, x => cont(x).map(f))
-});
-export const do_ = (cmd, payload) => doFull(cmd, payload, pure);
-const empty = pure([]);
-// TODO: replace with either a `Do` operation or as an addition to `Pure` and `Do`.
-export const all = (set) => set.reduce((previous, current) => previous.pipe(previousResult => current.map(currentResult => [...previousResult, currentResult])), empty);