functionalscript 0.30.0 → 0.31.0

package/fs/fsc/module.f.js

@@ -44,36 +44,26 @@ const create = (a) => {
 };
 export const terminal = -1;
 const toInit = () => () => [[], init];
+const single = (c) => range(c)(() => () => [[c], unexpectedSymbol]);
+const punctuation = "!\"%&'()*+,-./:;<=>?[]^`{|}~";
 export const init = create([
     codePointRange(one(terminal))(toInit),
     rangeSet(['\t', ' ', '\n', '\r'])(toInit),
-    range('!')(() => () => [['!'], unexpectedSymbol]),
-    range('"')(() => () => [['"'], unexpectedSymbol]),
     rangeSet(['$', '_', 'AZ', 'az'])(() => c => [[fromCharCode(c)], unexpectedSymbol]),
-    range('%')(() => () => [['%'], unexpectedSymbol]),
-    range('&')(() => () => [['&'], unexpectedSymbol]),
-    range("'")(() => () => [["'"], unexpectedSymbol]),
-    range('(')(() => () => [['('], unexpectedSymbol]),
-    range(')')(() => () => [[')'], unexpectedSymbol]),
-    range('*')(() => () => [['*'], unexpectedSymbol]),
-    range('+')(() => () => [['+'], unexpectedSymbol]),
-    range(',')(() => () => [[','], unexpectedSymbol]),
-    range('-')(() => () => [['-'], unexpectedSymbol]),
-    range('.')(() => () => [['.'], unexpectedSymbol]),
-    range('/')(() => () => [['/'], unexpectedSymbol]),
     range('09')(() => a => [[fromCharCode(a)], unexpectedSymbol]),
-    range(':')(() => () => [[':'], unexpectedSymbol]),
-    range(';')(() => () => [[';'], unexpectedSymbol]),
-    range('<')(() => () => [['<'], unexpectedSymbol]),
-    range('=')(() => () => [['='], unexpectedSymbol]),
-    range('>')(() => () => [['>'], unexpectedSymbol]),
-    range('?')(() => () => [['?'], unexpectedSymbol]),
-    range('[')(() => () => [['['], unexpectedSymbol]),
-    range(']')(() => () => [[']'], unexpectedSymbol]),
-    range('^')(() => () => [['^'], unexpectedSymbol]),
-    range('`')(() => () => [['`'], unexpectedSymbol]),
-    range('{')(() => () => [['{'], unexpectedSymbol]),
-    range('|')(() => () => [['|'], unexpectedSymbol]),
-    range('}')(() => () => [['}'], unexpectedSymbol]),
-    range('~')(() => () => [['~'], unexpectedSymbol]),
+    ...[...punctuation].map(single),
 ])(undefined);
+export const proof = {
+    // union throws when two distinct non-def handlers are merged for the same range;
+    // this path is unreachable through the public API (init has no overlapping ranges),
+    // so we exercise it here where the private union function is in scope.
+    throw: {
+        unionConflict: () => {
+            const a = _s => unexpectedSymbol;
+            const b = _s => unexpectedSymbol;
+            a(undefined);
+            b(undefined);
+            union(a)(b);
+        }
+    }
+};

package/fs/fsc/proof.f.d.ts

@@ -1,8 +1,16 @@
 export declare const proof: {
     a: () => void;
+    b: () => void;
+    c: () => void;
     fn: () => void;
     f1: () => void;
     f2: () => void;
     f3: () => void;
     f4: () => void;
+    chars: {
+        whitespace: () => void;
+        punctuation: () => void;
+        identifier_start: () => void;
+        digits: () => void;
+    };
 };

package/fs/fsc/proof.f.js

@@ -1,6 +1,7 @@
-import { init } from "./module.f.js";
+import { init, terminal } from "./module.f.js";
 import { one } from "../text/ascii/module.f.js";
 import { stringify } from "../json/module.f.js";
+import { assertEq } from "../asserts/module.f.js";
 const s = stringify(i => i);
 const f = v => {
     const n = one(v);
@@ -18,6 +19,21 @@ export const proof = {
             throw x;
         }
     },
+    b: () => {
+        // exercises toInit: terminal returns empty output and loops back to init
+        const result = init(terminal);
+        if (result[0].length !== 0) {
+            throw result[0];
+        }
+    },
+    c: () => {
+        // exercises unexpectedSymbol: next state after a token returns an error message
+        const next = init(one('1'))[1];
+        const result = next(42);
+        if (result[0][0] !== 'unexpected symbol 42') {
+            throw result[0][0];
+        }
+    },
     fn: () => {
         const o = {
             ["hello world!"]: () => undefined
@@ -76,5 +92,35 @@ export const proof = {
         if (f.name !== "") {
             throw f.name;
         }
-    }
+    },
+    chars: {
+        whitespace: () => {
+            for (const ch of ['\t', ' ', '\n', '\r']) {
+                const [tokens, next] = init(one(ch));
+                assertEq(tokens.length, 0);
+                assertEq(next, init);
+            }
+        },
+        punctuation: () => {
+            for (const ch of ['!', '"', '%', '&', "'", '(', ')', '*', '+', ',', '-', '.', '/', ':', ';', '<', '=', '>', '?', '[', ']', '^', '`', '{', '|', '}', '~']) {
+                const [tokens] = init(one(ch));
+                assertEq(tokens.length, 1);
+                assertEq(tokens[0], ch);
+            }
+        },
+        identifier_start: () => {
+            for (const ch of ['$', '_', 'A', 'Z', 'a', 'z']) {
+                const [tokens] = init(one(ch));
+                assertEq(tokens.length, 1);
+                assertEq(tokens[0], ch);
+            }
+        },
+        digits: () => {
+            for (const ch of ['0', '5', '9']) {
+                const [tokens] = init(one(ch));
+                assertEq(tokens.length, 1);
+                assertEq(tokens[0], ch);
+            }
+        },
+    },
 };

package/fs/fsm/module.f.d.ts

@@ -4,13 +4,12 @@
  * @module
  */
 import { type List } from '../types/list/module.f.ts';
+import type { StringMap } from '../types/object/module.f.ts';
 import { type ByteSet } from '../types/byte_set/module.f.ts';
 import { type RangeMapArray } from '../types/range_map/module.f.ts';
 type Rule = readonly [string, ByteSet, string];
 export type Grammar = List<Rule>;
-type Dfa = {
-    readonly [state in string]: RangeMapArray<string>;
-};
+type Dfa = StringMap<string, RangeMapArray<string>>;
 export declare const toRange: (s: string) => ByteSet;
 export declare const toUnion: (s: string) => ByteSet;
 export declare const dfa: (grammar: Grammar) => Dfa;

package/fs/fsm/module.f.js

@@ -51,5 +51,5 @@ const initialState = [''];
 const initialStateStringify = stringifyIdentity(initialState);
 export const dfa = grammar => addEntry(grammar)(initialState)({});
 const get = rangeMapGet(emptyStateStringify);
-const runOp = dfa => input => s => get(input)(dfa[s]);
+const runOp = dfa => input => s => get(input)(dfa[s] ?? []);
 export const run = (dfa) => (input) => foldScan(runOp(dfa))(initialStateStringify)(input);

package/fs/html/module.f.d.ts

@@ -5,6 +5,7 @@
  * @module
  */
 import { type List } from '../types/list/module.f.ts';
+import { type StringMap } from '../types/object/module.f.ts';
 import { type Vec } from '../types/bit_vec/module.f.ts';
 type Tag = string;
 type Element1 = readonly [Tag, ...Node[]];
@@ -16,9 +17,7 @@ type Element2 = readonly [Tag, Attributes, ...Node[]];
  * - `[tag, attributes, ...children]` for elements with attributes.
  */
 export type Element = Element1 | Element2;
-type Attributes = {
-    readonly [k in string]: string;
-};
+type Attributes = StringMap<string, string>;
 export type Node = Element | string;
 /**
  * Converts a FunctionalScript element into a list of HTML string chunks.

package/fs/html/module.f.js

@@ -6,13 +6,14 @@
  */
 import { map, flatMap, flat, concat as listConcat } from "../types/list/module.f.js";
 import { concat, concat as stringConcat } from "../types/string/module.f.js";
+import { definedEntries } from "../types/object/module.f.js";
 import { compose } from "../types/function/module.f.js";
 import { stringToList } from "../text/utf16/module.f.js";
 import { includes } from "../types/array/module.f.js";
 import {} from "../types/bit_vec/module.f.js";
 import { utf8 } from "../text/module.f.js";
+import { quotationMark, ampersand, lessThanSign, greaterThanSign } from "../text/ascii/module.f.js";
 const { fromCharCode } = String;
-const { entries } = Object;
 /**
  * Void Elements
  *
@@ -47,10 +48,10 @@ const rawText = [
  */
 const escapeCharCode = (code) => {
     switch (code) {
-        case 0x22: return '"';
-        case 0x26: return '&';
-        case 0x3C: return '<';
-        case 0x3E: return '>';
+        case quotationMark: return '"';
+        case ampersand: return '&';
+        case lessThanSign: return '<';
+        case greaterThanSign: return '>';
         default: return fromCharCode(code);
     }
 };
@@ -62,7 +63,7 @@ const mr = map(raw);
 // Escape closing tags in raw text elements
 const rawMap = (n) => concat(mr(n)).replaceAll('</', '<\\/');
 const attribute = ([name, value]) => flat([[' ', name, '="'], escape(value), ['"']]);
-const attributes = compose(entries)(flatMap(attribute));
+const attributes = (a) => flatMap(attribute)(definedEntries(a));
 const parseElement = (e) => {
     const [tag, item1, ...list] = e;
     return item1 === undefined ?

package/fs/html/proof.f.d.ts

@@ -11,5 +11,6 @@ export declare const proof: {
         style: () => void;
         styleEsc: () => void;
         noRaw: () => void;
+        elemChild: () => void;
     };
 };

package/fs/html/proof.f.js

@@ -75,5 +75,12 @@ export const proof = {
                 throw s;
             }
         },
+        elemChild: () => {
+            const x = ['script', ['span', 'ignored'], 'visible'];
+            const s = htmlToString(x);
+            if (s !== '<!DOCTYPE html><script>visible</script>') {
+                throw s;
+            }
+        },
     }
 };

package/fs/js/tokenizer/module.f.js

@@ -517,5 +517,5 @@ const tokenizeWithPositionOp = (input, { state, metadata }) => {
 const scanTokenize = stateScan(tokenizeWithPositionOp);
 export const tokenize = input => path => {
     const scan = scanTokenize({ state: { kind: 'initial' }, metadata: { path, line: 1, column: 1 } });
-    return flat(scan(flat([input, [null]])));
+    return flat(scan(flat([input /*satisfies List<CharCodeOrEof>*/, [null]])));
 };

package/fs/js/tokenizer/proof.f.js

@@ -177,6 +177,13 @@ export const proof = {
                 throw result;
             }
         },
+        () => {
+            // terminal char after invalidNumber state (covers invalidNumberStateOp terminal branch)
+            const result = stringify(tokenizeString('00,'));
+            if (result !== '[{"kind":"error","message":"invalid number"},{"kind":","},{"kind":"eof"}]') {
+                throw result;
+            }
+        },
         () => {
             const result = stringify(tokenizeString('0abc,'));
             if (result !== '[{"kind":"error","message":"invalid number"},{"kind":"id","value":"abc"},{"kind":","},{"kind":"eof"}]') {

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

@@ -23,12 +23,18 @@ export declare const primitive: import("../types/rtti/module.f.ts").Or<[null, im
  * core's `unknown`, the JSON `unknown` excludes `undefined`.
  */
 export declare const unknown: () => readonly ["or", import("../types/rtti/module.f.ts").Or<[null, import("../types/rtti/module.f.ts").Boolean, import("../types/rtti/module.f.ts").Number, import("../types/rtti/module.f.ts").String]>, import("../types/rtti/module.f.ts").Type1<"record", () => readonly ["or", import("../types/rtti/module.f.ts").Or<[null, import("../types/rtti/module.f.ts").Boolean, import("../types/rtti/module.f.ts").Number, import("../types/rtti/module.f.ts").String]>, import("../types/rtti/module.f.ts").Type1<"record", /*elided*/ any>, import("../types/rtti/module.f.ts").Type1<"array", /*elided*/ any>]>, import("../types/rtti/module.f.ts").Type1<"array", () => readonly ["or", import("../types/rtti/module.f.ts").Or<[null, import("../types/rtti/module.f.ts").Boolean, import("../types/rtti/module.f.ts").Number, import("../types/rtti/module.f.ts").String]>, import("../types/rtti/module.f.ts").Type1<"record", /*elided*/ any>, import("../types/rtti/module.f.ts").Type1<"array", /*elided*/ any>]>];
-/** rtti schema matching a JSON object: `{ readonly [k: string]: Unknown }`. */
+/**
+ * rtti schema matching a JSON object: `{ readonly [k: string]?: Unknown }`.
+ */
 export declare const object: import("../types/rtti/module.f.ts").Type1<"record", () => readonly ["or", import("../types/rtti/module.f.ts").Or<[null, import("../types/rtti/module.f.ts").Boolean, import("../types/rtti/module.f.ts").Number, import("../types/rtti/module.f.ts").String]>, import("../types/rtti/module.f.ts").Type1<"record", /*elided*/ any>, import("../types/rtti/module.f.ts").Type1<"array", /*elided*/ any>]>;
 /** rtti schema matching a JSON array: `readonly Unknown[]`. */
 export declare const array: import("../types/rtti/module.f.ts").Type1<"array", () => readonly ["or", import("../types/rtti/module.f.ts").Or<[null, import("../types/rtti/module.f.ts").Boolean, import("../types/rtti/module.f.ts").Number, import("../types/rtti/module.f.ts").String]>, import("../types/rtti/module.f.ts").Type1<"record", /*elided*/ any>, import("../types/rtti/module.f.ts").Type1<"array", /*elided*/ any>]>;
 export type Primitive = Ts<typeof primitive>;
-export type Unknown = Ts<typeof unknown>;
+export type Unknown = Object | Array | Primitive;
+export type Object = {
+    readonly [k in string]?: Unknown;
+};
+export type Array = readonly Unknown[];
 export declare const setProperty: (value: Unknown) => (path: List<string>) => (src: Unknown) => Unknown;
 export type Entry = ObjectEntry<Unknown>;
 type Entries = List<Entry>;
@@ -37,6 +43,7 @@ export declare const serialize: (mapEntries: MapEntries) => (value: Unknown) =>
 /**
  * The standard `JSON.stringify` rules determined by
  * https://262.ecma-international.org/6.0/#sec-ordinary-object-internal-methods-and-internal-slots-ownpropertykeys
+ * https://tc39.es/ecma262/#sec-serializejsonproperty
  */
 export declare const stringify: (mapEntries: MapEntries) => (value: Unknown) => string;
 export declare const parse: (value: string) => Unknown;

package/fs/json/module.f.js

@@ -10,7 +10,7 @@
  */
 import { next, flat, map } from "../types/list/module.f.js";
 import { concat } from "../types/string/module.f.js";
-import { at } from "../types/object/module.f.js";
+import { at, definedEntries } from "../types/object/module.f.js";
 import { compose, fn } from "../types/function/module.f.js";
 import { objectWrap, arrayWrap, stringSerialize, numberSerialize, nullSerialize, boolSerialize } from "./serializer/module.f.js";
 import { boolean as rttiBoolean, number as rttiNumber, string as rttiString, or, record, array as rttiArray } from "../types/rtti/module.f.js";
@@ -27,14 +27,15 @@ export const primitive = or(null, rttiBoolean, rttiNumber, rttiString);
  * core's `unknown`, the JSON `unknown` excludes `undefined`.
  */
 export const unknown = () => ['or', primitive, object, array];
-/** rtti schema matching a JSON object: `{ readonly [k: string]: Unknown }`. */
+/**
+ * rtti schema matching a JSON object: `{ readonly [k: string]?: Unknown }`.
+ */
 export const object = record(unknown);
 /** rtti schema matching a JSON array: `readonly Unknown[]`. */
 export const array = rttiArray(unknown);
 // ── JSON utilities ────────────────────────────────────────────────────────────
-const { entries } = Object;
-export const setProperty = value => {
-    const f = path => src => {
+export const setProperty = (value) => {
+    const f = (path) => (src) => {
         const result = next(path);
         if (result === null) {
             return value;
@@ -53,12 +54,12 @@ export const serialize = sort => {
         f(v)
     ]);
     const mapPropertySerialize = map(propertySerialize);
-    const objectSerialize = fn(entries)
+    const objectSerialize = fn((definedEntries))
         .map(sort)
         .map(mapPropertySerialize)
         .map(objectWrap)
         .result;
-    const f = value => {
+    const f = (value) => {
         switch (typeof value) {
             case 'boolean': {
                 return boolSerialize(value);
@@ -86,6 +87,7 @@ export const serialize = sort => {
 /**
  * The standard `JSON.stringify` rules determined by
  * https://262.ecma-international.org/6.0/#sec-ordinary-object-internal-methods-and-internal-slots-ownpropertykeys
+ * https://tc39.es/ecma262/#sec-serializejsonproperty
  */
 export const stringify = sort => compose(serialize(sort))(concat);
 export const parse = JSON.parse;

package/fs/json/parser/module.f.js

@@ -68,10 +68,9 @@ const isValueToken = token => {
 };
 const parseValueOp = token => state => {
     switch (token.kind) {
+        // A value is required here (top level, after `[`+`,`, or after `:`),
+        // so `]` is never valid — strict JSON has no trailing commas.
         case ']':
-            if (state.status === '[,') {
-                return endArray(state);
-            }
             return { status: 'error', message: 'unexpected token' };
         case '[': return startArray(state);
         case '{': return startObject(state);
@@ -131,9 +130,8 @@ const parseObjectNextOp = token => state => {
     return { status: 'error', message: 'unexpected token' };
 };
 const parseObjectCommaOp = token => state => {
-    if (token.kind === '}') {
-        return endObject(state);
-    }
+    // After a `,` a member (string key) is required — `}` here would be a
+    // trailing comma, which strict JSON rejects.
     if (token.kind === 'string') {
         return pushKey(state)(token.value);
     }

package/fs/json/parser/proof.f.js

@@ -119,30 +119,31 @@ export const proof = {
             if (result !== '["ok",{"a":{"b":{"c":["d"]}}}]') {
                 throw result;
             }
-        },
+        }
+    ],
+    invalid: [
         () => {
-            const tokenList = tokenizeString('[1,]');
+            const tokenList = tokenizeString('');
             const obj = parse(tokenList);
             const result = stringify(obj);
-            if (result !== '["ok",[1]]') {
+            if (result !== '["error","unexpected end"]') {
                 throw result;
             }
         },
+        // Trailing commas are not valid JSON — strict parser rejects them.
         () => {
-            const tokenList = tokenizeString('{"a":1,}');
+            const tokenList = tokenizeString('[1,]');
             const obj = parse(tokenList);
             const result = stringify(obj);
-            if (result !== '["ok",{"a":1}]') {
+            if (result !== '["error","unexpected token"]') {
                 throw result;
             }
-        }
-    ],
-    invalid: [
+        },
         () => {
-            const tokenList = tokenizeString('');
+            const tokenList = tokenizeString('{"a":1,}');
             const obj = parse(tokenList);
             const result = stringify(obj);
-            if (result !== '["error","unexpected end"]') {
+            if (result !== '["error","unexpected token"]') {
                 throw result;
             }
         },
@@ -290,6 +291,14 @@ export const proof = {
                 throw result;
             }
         },
+        () => {
+            const tokenList = tokenizeString('{"a":1 "b":2}');
+            const obj = parse(tokenList);
+            const result = stringify(obj);
+            if (result !== '["error","unexpected token"]') {
+                throw result;
+            }
+        },
         () => {
             const tokenList = tokenizeString('[{]}');
             const obj = parse(tokenList);

package/fs/json/proof.f.d.ts

@@ -1,7 +1,8 @@
 export declare const proof: {
-    setProperty: () => void;
+    setProperty: (() => void)[];
     stringify: {
         sort: () => void;
         identity: () => void;
     }[];
+    undefined: () => void;
 };

package/fs/json/proof.f.js

@@ -1,12 +1,36 @@
 import { setProperty, stringify } from "./module.f.js";
 import { sort } from "../types/object/module.f.js";
 import { identity } from "../types/function/module.f.js";
+import { assertEq } from "../asserts/module.f.js";
 export const proof = {
-    setProperty: () => {
-        if (setProperty("Hello")([])({}) !== "Hello") {
-            throw 'error';
-        }
-    },
+    setProperty: [
+        () => {
+            if (setProperty("Hello")([])({}) !== "Hello") {
+                throw 'error';
+            }
+        },
+        () => {
+            // src === null: should treat as empty object
+            const x = stringify(sort)(setProperty("Hello")(['a'])(null));
+            if (x !== '{"a":"Hello"}') {
+                throw x;
+            }
+        },
+        () => {
+            // typeof src !== 'object': primitive src treated as empty object
+            const x = stringify(sort)(setProperty("Hello")(['a'])(42));
+            if (x !== '{"a":"Hello"}') {
+                throw x;
+            }
+        },
+        () => {
+            // src instanceof Array: array src treated as empty object
+            const x = stringify(sort)(setProperty("Hello")(['a'])([1, 2]));
+            if (x !== '{"a":"Hello"}') {
+                throw x;
+            }
+        },
+    ],
     stringify: [
         {
             sort: () => {
@@ -55,5 +79,8 @@ export const proof = {
                 }
             }
         }
-    ]
+    ],
+    undefined: () => {
+        assertEq(stringify(sort)({ x: undefined }), '{}');
+    }
 };

package/fs/json/rpc/module.f.d.ts

@@ -1,11 +1,14 @@
 import type { Ts } from '../../types/rtti/ts/module.f.ts';
 import type { Result } from '../../types/result/module.f.ts';
 import { type Unknown } from '../module.f.ts';
+export declare const jsonrpc: "2.0";
 /** Request/response identifier: a string, a number, or `null`. */
 declare const id: import("../../types/rtti/module.f.ts").Or<[import("../../types/rtti/module.f.ts").String, import("../../types/rtti/module.f.ts").Number, null]>;
 /**
  * A request or notification envelope. `id` present → request (a response is
  * expected); `id` absent → notification (no response). `params` is optional.
+ *
+ * https://www.jsonrpc.org/specification#request_object
  */
 export declare const request: {
     readonly jsonrpc: "2.0";
@@ -42,6 +45,8 @@ export declare const errorResponse: {
  * runtime decoder and the static type, with no drift. rtti structs are open
  * (extra keys allowed), so "result XOR error" is not enforced at runtime; in
  * practice the dispatcher only ever constructs one or the other.
+ *
+ * https://www.jsonrpc.org/specification#response_object
  */
 export declare const response: import("../../types/rtti/module.f.ts").Or<[{
     readonly jsonrpc: "2.0";

package/fs/json/rpc/module.f.js

@@ -10,17 +10,21 @@
  * `fs/effects/node`, and concrete method sets such as MCP (i665-mcp), which layer
  * on top of `dispatch`.
  *
+ * https://www.jsonrpc.org/specification
+ *
  * @module
  */
 import { number, string, or, option } from "../../types/rtti/module.f.js";
 import { validate } from "../../types/rtti/validate/module.f.js";
 import { unknown } from "../module.f.js";
-const jsonrpc = '2.0';
+export const jsonrpc = '2.0';
 /** Request/response identifier: a string, a number, or `null`. */
 const id = or(string, number, null);
 /**
  * A request or notification envelope. `id` present → request (a response is
  * expected); `id` absent → notification (no response). `params` is optional.
+ *
+ * https://www.jsonrpc.org/specification#request_object
  */
 export const request = {
     jsonrpc,
@@ -42,6 +46,8 @@ export const errorResponse = { jsonrpc, error, id };
  * runtime decoder and the static type, with no drift. rtti structs are open
  * (extra keys allowed), so "result XOR error" is not enforced at runtime; in
  * practice the dispatcher only ever constructs one or the other.
+ *
+ * https://www.jsonrpc.org/specification#response_object
  */
 export const response = or(successResponse, errorResponse);
 /** Decodes an untrusted value as a JSON-RPC request / notification. */
@@ -54,7 +60,7 @@ export const invalidRequest = rpcError(-32600)('Invalid Request');
 export const methodNotFound = rpcError(-32601)('Method not found');
 export const invalidParams = rpcError(-32602)('Invalid params');
 export const internalError = rpcError(-32603)('Internal error');
-const errorResponseOf = (id) => (e) => ({ jsonrpc, error: e, id });
+const errorResponseOf = (id) => (error) => ({ jsonrpc, error, id });
 /**
  * Dispatches an already-parsed JSON-RPC value against `handlers`.
  *
@@ -64,21 +70,20 @@ const errorResponseOf = (id) => (e) => ({ jsonrpc, error: e, id });
  * - otherwise the handler's `ok` / `error` result becomes a success / error response
  */
 export const dispatch = (handlers) => (value) => {
-    const decoded = decodeRequest(value);
-    if (decoded[0] === 'error') {
+    const [t, message] = decodeRequest(value);
+    if (t === 'error') {
         return errorResponseOf(null)(invalidRequest);
     }
-    const message = decoded[1];
-    const id = message.id;
+    const { id, method, params } = message;
     if (id === undefined) {
         return null;
     }
-    const handler = handlers[message.method];
+    const handler = handlers[method];
     if (handler === undefined) {
         return errorResponseOf(id)(methodNotFound);
     }
-    const result = handler(message.params);
-    return result[0] === 'ok'
-        ? { jsonrpc, result: result[1], id }
-        : errorResponseOf(id)(result[1]);
+    const [t2, result] = handler(params);
+    return t2 === 'ok'
+        ? { jsonrpc, result, id }
+        : errorResponseOf(id)(result);
 };