@rimbu/deep 2.0.1 → 2.0.3

package/README.md

@@ -1,112 +1,347 @@
 <p align="center">
-    <img src="https://github.com/rimbu-org/rimbu/raw/main/assets/rimbu_logo.svg" />
+  <img src="https://github.com/rimbu-org/rimbu/raw/main/assets/rimbu_logo.svg" height="96" alt="Rimbu Logo" />
 </p>
 
-[![npm version](https://badge.fury.io/js/@rimbu%2Fdeep.svg)](https://www.npmjs.com/package/@rimbu/deep) [![Deno](https://shield.deno.dev/x/rimbu)](http://deno.land/x/rimbu)
+<div align="center">
 
-![Licence](https://img.shields.io/github/license/rimbu-org/rimbu)
+[![npm version](https://badge.fury.io/js/@rimbu%2Fdeep.svg)](https://www.npmjs.com/package/@rimbu/deep)
+![License](https://img.shields.io/github/license/rimbu-org/rimbu)
+![Types Included](https://img.shields.io/badge/TypeScript-ready-blue)
+![Node](https://img.shields.io/badge/Node-18+-6DA55F?logo=node.js&logoColor=white)
+![Deno](https://shield.deno.dev/x/rimbu)
+![Bun](https://img.shields.io/badge/Bun-%23000000.svg)
+![ESM + CJS](https://img.shields.io/badge/modules-ESM%20%2B%20CJS-informational)
 
-# @rimbu/deep
+</div>
 
-Offers tools to use handle plain JS objects as immutable objects. The [`Patch` object](https://rimbu.org/docs/deep/patch) allows convenient immutable modification of simple objects. The [`Match` object](https://rimbu.org/docs/deep/match) allows easy matching on plain objects. The [`Path` object](https://rimbu.org/docs/deep/path) allows easy querying of nested values. The [`Immutable` type](https://rimbu.org/docs/deep/immutable) makes it easy to create plain objects that that have compile-time protection against mutation. The [`Tuple` type](https://rimbu.org/docs/deep/tuple) is a utility to have similar functionality as `as const` but less strict.
+# `@rimbu/deep`
 
-For complete documentation please visit the [Immutable Objects overview](https://rimbu.org/docs/deep/overview) in the _[Rimbu Docs](https://rimbu.org)_, or directly see the _[Rimbu Deep API Docs](https://rimbu.org/api/rimbu/deep)_.
+**Immutable, type-safe utilities for deeply patching, matching, and selecting from plain JavaScript objects.**
 
-Or [Try Out Rimbu](https://codesandbox.io/s/github/vitoke/rimbu-sandbox/tree/main?previewwindow=console&view=split&editorsize=65&moduleview=1&module=/src/index.ts) in CodeSandBox.
+`@rimbu/deep` gives you a set of composable tools – `Patch`, `Match`, `Path`, `Selector`, `Protected`, and `Tuple` –
+to treat plain objects as if they were immutable, deeply typed data structures. You can:
 
-## Installation
+- **Apply immutable updates** to nested structures using a flexible `Patch` notation.
+- **Express rich match conditions** over objects and arrays using `Match`.
+- **Access nested properties safely** using type‑checked string `Path`s.
+- **Build typed projections** from objects using `Selector` shapes.
+- **Protect values at compile time** from accidental mutation using `Protected`.
+- **Work ergonomically with tuples** and fixed‑length arrays via `Tuple`.
 
-### Compabitity
+Use it whenever you want the convenience of plain objects, but with **deep type safety**, **immutable semantics**, and
+**refactor‑friendly string paths**.
 
-- [`Node >= 16` ![NodeJS](https://img.shields.io/badge/node.js-6DA55F?logo=node.js&logoColor=white)](https://nodejs.org)
-- [`Deno` ![Deno JS](https://img.shields.io/badge/deno%20js-000000?logo=deno&logoColor=white)](https://deno.com/runtime)
-- [`Bun >= 0.6.0` ![Bun](https://img.shields.io/badge/Bun-%23000000.svg?logoColor=white)](https://bun.sh/)
-- `Web` ![HTML5](https://img.shields.io/badge/html5-%23E34F26.svg?logoColor=white)
+---
 
-### Yarn / NPM / Bun
+## Table of Contents
 
-For convenience, all main types are also exported through [`@rimbu/core`](../core).
+1. [Why `@rimbu/deep`?](#why-rimbu-deep)
+2. [Feature Highlights](#feature-highlights)
+3. [Quick Start](#quick-start)
+4. [Core Concepts & Types](#core-concepts--types)
+5. [Deep API Helpers](#deep-api-helpers)
+6. [Installation](#installation)
+7. [Ecosystem & Further Reading](#ecosystem--further-reading)
+8. [Contributing](#contributing)
+9. [License](#license)
 
-To install this package only:
+---
 
-For `yarn`:
+## Why `@rimbu/deep`?
 
-> `yarn add @rimbu/deep`
+Plain objects are great, but they quickly become painful when:
 
-For `npm`:
+- You need to **update nested fields immutably** (e.g. in Redux‑style state).
+- You want **type‑safe string paths** like `'a.b.c[0]?.d'` instead of ad‑hoc helpers.
+- You’d like to **pattern‑match** complex structures without a forest of `if`/`switch` checks.
+- You want to **project and reshape data** (e.g. API responses) into well‑typed views.
 
-> `npm i @rimbu/deep`
+`@rimbu/deep` focuses on:
 
-For `bun`:
+- **Type‑driven paths and selectors** – `Path` and `Selector` are derived from your data types.
+- **Immutable patching** – `Patch` lets you describe updates declaratively and apply them in one go.
+- **Expressive matching** – `Match` supports nested objects, arrays, tuples, and compound predicates.
+- **Compile‑time protection** – `Protected<T>` makes entire object graphs appear readonly to TypeScript.
 
-> `bun add @rimbu/deep`
+If you find yourself writing a lot of manual cloning, deep property access, or matcher utilities, `@rimbu/deep` is a
+drop‑in improvement.
 
-### Deno
+---
 
-For Deno, the following approach is recommended:
+## Feature Highlights
 
-In the root folder of your project, create or edit a file called `import_map.json` with the following contents (where you should replace `x.y.z` with the desired version of Rimbu):
+- **Deep immutable patching** with `patch` and `patchAt`:
+  describe updates using nested objects/arrays and functions instead of manual cloning.
+- **Typed string paths** with `Path.Get` and `Path.Set`:
+  only valid paths for your data type compile.
+- **Structured matching** with `match`:
+  supports nested objects, tuple/array traversal, and compound matchers (`every`, `some`, `none`, `single`).
+- **Selection & projection** with `select` and `Selector`:
+  derive new shapes from existing data using path strings, functions, or nested selector objects.
+- **Compile‑time protection** with `Protected` and `protect`:
+  make values deeply readonly at the type level while still using the underlying runtime value.
+- **Tuple helpers** with `Tuple`:
+  ergonomics around fixed‑length tuples (construction, indexing, updates, etc.).
 
-```json
-{
-  "imports": {
-    "@rimbu/": "https://deno.land/x/rimbu@x.y.z/"
-  }
+---
+
+## Quick Start
+
+```ts
+import { Deep } from '@rimbu/deep';
+
+const input = { a: 1, b: { c: true, d: 'a' } } as const;
+
+// Immutable deep patch
+const updated = Deep.patch(input, [{ b: [{ c: (v) => !v }] }]);
+// => { a: 1, b: { c: false, d: 'a' } }
+
+// Type-safe nested get
+const cValue = Deep.getAt(input, 'b.c'); // boolean
+
+// Pattern matching
+if (Deep.match(input, { b: { c: true } })) {
+  // ...
 }
+
+// Selection / projection
+const projected = Deep.select(input, { flag: 'b.c', label: 'b.d' });
+// projected: { flag: boolean; label: string }
+```
+
+Try Rimbu (including `@rimbu/deep`) live in the browser using the
+[Rimbu Sandbox on CodeSandbox](https://codesandbox.io/s/github/vitoke/rimbu-sandbox/tree/main?previewwindow=console&view=split&editorsize=65&moduleview=1&module=/src/index.ts).
+
+---
+
+## Core Concepts & Types
+
+### Exported Types & Namespaces
+
+From `@rimbu/deep`’s main entrypoint you have access to:
+
+| Name                         | Description                                                                                              |
+| ---------------------------- | -------------------------------------------------------------------------------------------------------- |
+| `Patch<T, C = T>`           | Type describing allowed patch shapes for a value of type `T`.                                           |
+| `Match<T, C = Partial<T>>`  | Type describing allowed matchers for values of type `T`.                                                |
+| `Path`                      | Namespace containing `Path.Get<T>`, `Path.Set<T>`, and `Path.Result<T, P>` utilities for string paths.  |
+| `Selector<T>`               | Type describing allowed selector shapes for values of type `T`.                                         |
+| `Protected<T>`              | Deeply readonly/“protected” view of `T` for compile‑time mutation safety.                               |
+| `Tuple<T extends Tuple.Source>` | Tuple wrapper with helper types and functions under the `Tuple` namespace.                          |
+| `Deep`                      | Convenience namespace exposing the main deep utilities (`patch`, `match`, `getAt`, `select`, etc.).    |
+
+See the [Deep overview docs](https://rimbu.org/docs/deep/overview) and
+[API reference](https://rimbu.org/api/rimbu/deep) for the full surface.
+
+### Patching with `patch` and `Patch`
+
+```ts
+import { Deep, type Patch } from '@rimbu/deep';
+
+type State = {
+  count: number;
+  user?: { name: string; active: boolean };
+};
+
+const state: State = { count: 1, user: { name: 'Ada', active: true } };
+
+const patchItem: Patch<State> = [
+  { count: (v) => v + 1 },
+  { user: [{ active: false }] },
+];
+
+const next = Deep.patch(state, patchItem);
+// => { count: 2, user: { name: 'Ada', active: false } }
+```
+
+Patches can be:
+
+- Direct replacement values (`T`).
+- Functions `(current, parent, root) => newValue`.
+- Nested objects / arrays describing which fields or tuple indices to update.
+
+### Matching with `match` and `Match`
+
+```ts
+import { Deep, type Match } from '@rimbu/deep';
+
+type Item = { id: number; tags: string[] };
+
+const items: Item[] = [
+  { id: 1, tags: ['a', 'b'] },
+  { id: 2, tags: ['b'] },
+];
+
+const matcher: Match<Item> = {
+  tags: { someItem: (tag) => tag === 'a' },
+};
+
+const result = items.filter((item) => Deep.match(item, matcher));
+// => only items containing tag 'a'
+```
+
+`Match` supports:
+
+- Plain object matchers (`{ a: 1, b: { c: true } }`).
+- Function matchers `(value, parent, root) => boolean | matcher`.
+- Array/tuple matchers and traversal helpers such as `someItem`, `everyItem`, `noneItem`, `singleItem`.
+- Compound matchers like `['every', matcher1, matcher2]`.
+
+### Paths with `Path.Get`, `Path.Set` and `getAt` / `patchAt`
+
+```ts
+import { Deep, type Path } from '@rimbu/deep';
+
+type Model = { a: { b: { c: number }[] } };
+const value: Model = { a: { b: { c: [5, 6] } } as any };
+
+// Typed paths
+const path: Path.Get<Model> = 'a.b.c[1]?.d'; // compile-time checked
+
+// Reading
+const result = Deep.getAt(value, 'a.b.c[0]'); // number | undefined
+
+// Patching at a path
+const updated = Deep.patchAt(value, 'a.b.c', (arr) => [...arr, 7]);
+```
+
+`Path.Result<T, P>` gives you the resulting type at a given path `P` in `T`.
+
+### Selection with `Selector` and `select`
+
+```ts
+import { Deep, type Selector } from '@rimbu/deep';
+
+type Source = {
+  a: { b: number; c: string };
+  meta: { createdAt: string };
+};
+
+const source: Source = {
+  a: { b: 1, c: 'x' },
+  meta: { createdAt: '2024-01-01' },
+};
+
+const selector: Selector<Source> = {
+  value: 'a.b',
+  label: 'a.c',
+  created: 'meta.createdAt',
+};
+
+const view = Deep.select(source, selector);
+// view: { value: number; label: string; created: string }
 ```
 
-**Note: The trailing slashes are important!**
+Selectors can be:
+
+- String paths.
+- Functions `(value: Protected<T>) => any`.
+- Arrays or objects composed of other selectors.
 
-In this way you can use relative imports from Rimbu in your code, like so:
+### Protection with `Protected` and `protect`
 
 ```ts
-import { List } from '@rimbu/core/mod.ts';
-import { HashMap } from '@rimbu/hashed/mod.ts';
+import { Deep, type Protected } from '@rimbu/deep';
+
+type Data = { a: { b: number[] } };
+
+const data: Data = { a: { b: [1, 2] } };
+const protectedData: Protected<Data> = Deep.protect(data);
+
+// protectedData.a.b.push(3); // TypeScript error – `b` is readonly
 ```
 
-Note that for sub-packages, due to conversion limitations it is needed to import the `index.ts` instead of `mod.ts`, like so:
+`Protected<T>` is a **type‑level** construct: it does not freeze the value at runtime, but helps prevent
+accidental mutations in your code.
+
+---
+
+## Deep API Helpers
+
+All top‑level utilities are also available through the `Deep` namespace:
 
 ```ts
-import { HashMap } from '@rimbu/hashed/map/index.ts';
+import { Deep } from '@rimbu/deep';
+
+// Functional helpers
+const incCount = Deep.patchWith<{ count: number }>([{ count: (v) => v + 1 }]);
+const onlyActive = Deep.matchWith({ active: true });
+const getName = Deep.getAtWith<{ user: { name: string } }>('user.name');
+
+// Typed, curried API with withType
+const s = { a: 1, b: { c: 'a', d: true } };
+const api = Deep.withType<typeof s>();
+
+const next = api.patchWith([{ b: [{ d: (v) => !v }] }])(s);
+// => { a: 1, b: { c: 'a', d: false } }
+```
+
+The `Deep` namespace mirrors the main exports:
+
+- `Deep.patch`, `Deep.patchAt`, `Deep.patchWith`, `Deep.patchAtWith`
+- `Deep.match`, `Deep.matchAt`, `Deep.matchWith`, `Deep.matchAtWith`
+- `Deep.getAt`, `Deep.getAtWith`
+- `Deep.select`, `Deep.selectAt`, `Deep.selectWith`, `Deep.selectAtWith`
+- `Deep.withType<T>()` for creating a typed, curried API.
+
+---
+
+## Installation
+
+### Node / Bun / npm / Yarn
+
+```sh
+npm install @rimbu/deep
+# or
+yarn add @rimbu/deep
+# or
+bun add @rimbu/deep
 ```
 
-To run your script (let's assume the entry point is in `src/main.ts`):
+### Deno (import map)
 
-`deno run --import-map import_map.json src/main.ts`
+```jsonc
+{
+  "imports": {
+    "@rimbu/": "https://deno.land/x/rimbu@<version>/"
+  }
+}
+```
 
-## Usage
+Then:
 
 ```ts
-import { patch } from '@rimbu/deep';
-
-console.log(
-  patch({
-    a: 'a',
-    b: { c: 1, d: true },
-  })({
-    a: 'q',
-    b: { c: (v) => v + 1 },
-  })
-);
-// => { a: 'q', b: { c: 2, d: true }}
+import { Deep } from '@rimbu/deep/mod.ts';
 ```
 
-## Author
+### Browser / ESM
 
-[Arvid Nicolaas](https://github.com/vitoke)
+`@rimbu/deep` ships both **ESM** and **CJS** builds. Use it with any modern bundler
+(Vite, Webpack, esbuild, Bun, etc.) or directly in Node ESM projects.
+
+---
+
+## Ecosystem & Further Reading
+
+- Part of the broader **Rimbu** ecosystem – interoperates with `@rimbu/core`, `@rimbu/collection-types`,
+  and other collection packages.
+- Ideal for modelling immutable application state, selectors, and matchers in complex domains.
+- Learn more in the [Deep overview docs](https://rimbu.org/docs/deep/overview) and the
+  [Deep API reference](https://rimbu.org/api/rimbu/deep).
+
+---
 
 ## Contributing
 
-Feel very welcome to contribute to further improve Rimbu. Please read our [Contributing guide](https://github.com/rimbu-org/rimbu/blob/main/CONTRIBUTING.md).
+We welcome contributions! See the
+[Contributing guide](https://github.com/rimbu-org/rimbu/blob/main/CONTRIBUTING.md) for details.
 
-## Contributors
+<img src="https://contrib.rocks/image?repo=rimbu-org/rimbu" alt="Contributors" />
 
-<img src = "https://contrib.rocks/image?repo=rimbu-org/rimbu"/>
+_Made with [contributors-img](https://contrib.rocks)._
 
-Made with [contributors-img](https://contrib.rocks).
+---
 
 ## License
 
-Licensed under the MIT License, Copyright © 2020-present Arvid Nicolaas.
-
-See [LICENSE](./LICENSE) for more information.
+MIT © Rimbu contributors. See [LICENSE](./LICENSE) for details.

package/dist/bun/deep.mts

@@ -90,9 +90,9 @@ export function patchAtWith<T, P extends Path.Set<T>, TE extends T = T, TT = T>(
 
 /**
  * Returns a function that matches a given `value` with the given `matcher`.
- * @typeparam T - the patch value type
+ * @typeparam T - the input value type
  * @param matcher - a matcher object that matches input values.
- * @param source - the value to use the given `patchItem` on at the given `path`.
+ * @param source - the value to match (parameter of the returned function).
  * @example
  * ```ts
  * const items = [{ a: 1, b: 'a' }, { a: 2, b: 'b' }];
@@ -128,7 +128,7 @@ export function matchAt<T, P extends Path.Get<T>>(
 
 /**
  * Returns a function that matches a given `value` with the given `matcher` at the given string `path`.
- * @typeparam T - the patch value type
+ * @typeparam T - the input value type
  * @typeparam P - the string literal path type in the object
  * @typeparam TE - utility type
  * @param path - the string path in the object
@@ -150,7 +150,7 @@ export function matchAtWith<T, P extends Path.Get<T>, TE extends T = T>(
 
 /**
  * Returns a function that selects a certain shape from a given `value` with the given `selector`.
- * @typeparam T - the patch value type
+ * @typeparam T - the input value type
  * @typeparam SL - the selector shape type
  * @param selector - a shape indicating the selection from the source values
  * @param source - the value to use the given `selector` on.
@@ -169,7 +169,7 @@ export function selectWith<T, SL extends Selector<T>>(
 
 /**
  * Returns the result of applying the given `selector` shape to the given `source` value.
- * @typeparam T - the patch value type
+ * @typeparam T - the input value type
  * @typeparam P - the string literal path type in the object
  * @typeparam SL - the selector shape type
  * @param source - the source value to select from
@@ -185,7 +185,7 @@ export function selectWith<T, SL extends Selector<T>>(
 export function selectAt<
   T,
   P extends Path.Get<T>,
-  SL extends Selector<Path.Result<T, P>>
+  SL extends Selector<Path.Result<T, P>>,
 >(
   source: T,
   path: P,
@@ -196,7 +196,7 @@ export function selectAt<
 
 /**
  * Returns a function that selects a certain shape from a given `value` with the given `selector` at the given string `path`.
- * @typeparam T - the patch value type
+ * @typeparam T - the input value type
  * @typeparam P - the string literal path type in the object
  * @typeparam SL - the selector shape type
  * @param path - the string path in the object
@@ -211,7 +211,7 @@ export function selectAt<
 export function selectAtWith<
   T,
   P extends Path.Get<T>,
-  SL extends Selector<Path.Result<T, P>>
+  SL extends Selector<Path.Result<T, P>>,
 >(
   path: P,
   selector: Selector.Shape<SL>

package/dist/bun/match.mts

@@ -28,25 +28,31 @@ export namespace Match {
    * @typeparam P - the parent type
    * @typeparam R - the root object type
    */
-  export type Entry<T, C, P, R> = IsAnyFunc<T> extends true
-    ? // function can only be directly matched
-      T
-    : IsPlainObj<T> extends true
-    ? // determine allowed match values for object
-      Match.WithResult<T, P, R, Match.Obj<T, C, P, R>>
-    : IsArray<T> extends true
-    ? // determine allowed match values for array or tuple
-      | Match.Arr<T, C, P, R>
-        | Match.Entry<T[number & keyof T], C[number & keyof C], P, R>[]
-        | Match.Func<
-            T,
-            P,
-            R,
+  export type Entry<T, C, P, R> =
+    IsAnyFunc<T> extends true
+      ? // function can only be directly matched
+        T
+      : IsPlainObj<T> extends true
+        ? // determine allowed match values for object
+          Match.WithResult<T, P, R, Match.Obj<T, C, P, R>>
+        : IsArray<T> extends true
+          ? // determine allowed match values for array or tuple
             | Match.Arr<T, C, P, R>
-            | Match.Entry<T[number & keyof T], C[number & keyof C], P, R>[]
-          >
-    : // only accept values with same interface
-      Match.WithResult<T, P, R, { [K in keyof C]: C[K & keyof T] }>;
+              | Match.Entry<T[number & keyof T], C[number & keyof C], P, R>[]
+              | Match.Func<
+                  T,
+                  P,
+                  R,
+                  | Match.Arr<T, C, P, R>
+                  | Match.Entry<
+                      T[number & keyof T],
+                      C[number & keyof C],
+                      P,
+                      R
+                    >[]
+                >
+          : // only accept values with same interface
+            Match.WithResult<T, P, R, { [K in keyof C]: C[K & keyof T] }>;
 
   /**
    * The type that determines allowed matchers for objects.
@@ -128,7 +134,7 @@ export namespace Match {
   export type ArrayTraversalType = `${CompoundType}Item`;
 
   /**
-   * Compount matcher for objects, can only be an array staring with a compound type keyword.
+   * Compound matcher for objects, represented as an array starting with a compound type keyword.
    * @typeparam T - the input value type
    * @typeparam C - utility type
    * @typeparam P - the parent type
@@ -136,7 +142,7 @@ export namespace Match {
    */
   export type CompoundForObj<T, C, P, R> = [
     Match.CompoundType,
-    ...Match.Entry<T, C, P, R>[]
+    ...Match.Entry<T, C, P, R>[],
   ];
 
   /**
@@ -188,7 +194,7 @@ export namespace Match {
  * match(input, { a: 2 }) // => false
  * match(input, { a: (v) => v > 10 }) // => false
  * match(input, { b: { c: true }}) // => true
- * match(input, (['every', { a: (v) => v > 0 }, { b: { c: true } }]) // => true
+ * match(input, ['every', { a: (v) => v > 0 }, { b: { c: true } }]) // => true
  * match(input, { b: { c: (v, parent, root) => v && parent.d.length > 0 && root.a > 0 } })
  *  // => true
  * ```
@@ -272,9 +278,7 @@ function matchEntry<T, C, P, R>(
   // already determined above that the source and matcher are not equal
 
   failureLog?.push(
-    `value ${JSON.stringify(
-      source
-    )} does not match given matcher ${JSON.stringify(matcher)}`
+    `value ${JSON.stringify(source)} does not match given matcher ${JSON.stringify(matcher)}`
   );
 
   return false;
@@ -469,9 +473,7 @@ function matchPlainObj<T extends object, C, P, R>(
       // the source does not have the given key
 
       failureLog?.push(
-        `key ${key} is specified in matcher but not present in value ${JSON.stringify(
-          source
-        )}`
+        `key ${key} is specified in matcher but not present in value ${JSON.stringify(source)}`
       );
 
       return false;

package/dist/bun/patch.mts

@@ -22,15 +22,16 @@ export namespace Patch {
    * @typeparam P - the parent type
    * @typeparam R - the root object type
    */
-  export type Entry<T, C, P, R> = IsAnyFunc<T> extends true
-    ? T
-    : IsPlainObj<T> extends true
-    ? Patch.WithResult<T, P, R, Patch.Obj<T, C, R>>
-    : Tuple.IsTuple<T> extends true
-    ? Patch.WithResult<T, P, R, T | Patch.Tup<T, C, R>>
-    : IsArray<T> extends true
-    ? Patch.WithResult<T, P, R, T>
-    : Patch.WithResult<T, P, R, T>;
+  export type Entry<T, C, P, R> =
+    IsAnyFunc<T> extends true
+      ? T
+      : IsPlainObj<T> extends true
+        ? Patch.WithResult<T, P, R, Patch.Obj<T, C, R>>
+        : Tuple.IsTuple<T> extends true
+          ? Patch.WithResult<T, P, R, T | Patch.Tup<T, C, R>>
+          : IsArray<T> extends true
+            ? Patch.WithResult<T, P, R, T>
+            : Patch.WithResult<T, P, R, T>;
 
   /**
    * Either result type S, or a patch function with the value type, the parent type, and the root type.
@@ -109,7 +110,7 @@ export namespace Patch {
  * patch(input, [{ a: 2 }])  // => { a: 2, b: { c: true, d: 'a' } }
  * patch(input, [{ b: [{ c: (v) => !v }] }] )
  * // => { a: 1, b: { c: false, d: 'a' } }
- * patch(input: [{ a: (v) => v + 1, b: [{ d: 'q' }] }] )
+ * patch(input, [{ a: (v) => v + 1, b: [{ d: 'q' }] }] )
  * // => { a: 2, b: { c: true, d: 'q' } }
  * ```
  */