Module "setter"

Due to the higher-order nature of this function, generics for path validation must be given and so this function is more verbose than setIn (where the generics can usually be fully inferred).

type State = { a: { b: number } };

const setB = defSetter<State, "a", "b">(["a", "b"]);

setB({ a: { b: 1 } }, 2); // ok!
setB({ a: { b: 1 } }, "2"); // error!

type State = { a: { b: number } };

const path = <const>["a","b"];

const setB = defSetter<State, typeof path[0], typeof path[1]>(path);

Supports both arrays and objects and creates intermediate shallow copies at each level of the path. Thus provides structural sharing with the original data for any branches not being updated by the setter.

The type parameter T can be used to indicate the type of the nested value to be updated (default: any).

If path is given as string, it will be split using .. Returns function which accepts single object and when called, immutably updates value at given path, i.e. produces a partial deep copy of obj up until given path.

If any intermediate key is not present in the given obj, creates a plain empty object for that key and descends further.

If path is an empty string or array, the returned setter will simply return the new value.

Only keys in the path will be modified, all other keys present in the given object retain their original values to provide efficient structural sharing / re-use.

s = defSetterUnsafe("a.b.c");
// or
s = defSetterUnsafe(["a", "b", "c"]);

s({ a: { b: { c: 23} } }, 24)
// { a: { b: { c: 24} } }

s({ x: 23 }, 24)
// { x: 23, a: { b: { c: 24 } } }

s(null, 24)
// { a: { b: { c: 24 } } }

s = defSetterUnsafe("a.b.c");

a = { x: { y: { z: 1 } } };
b = s(a, 2);
// { x: { y: { z: 1 } }, a: { b: { c: 2 } } }

a.x === b.x // true
a.x.y === b.x.y // true