Logged

Logged: object

Defined in: Core/Logged.ts:29

Type Declaration

ap

ap: <W, A>(arg) => <B>(data) => Logged<W, B>

Applies a function wrapped in a Logged to a value wrapped in a Logged, concatenating both logs.

Type Parameters

W

W

A

A

Parameters

arg

Logged<W, A>

Returns

<B>(data) => Logged<W, B>

Example

const fn: Logged<string, (n: number) => number> = {
  value: n => n * 2,
  log: ["fn-loaded"],
};
const arg: Logged<string, number> = { value: 5, log: ["arg-loaded"] };

const result = pipe(fn, Logged.ap(arg));
Logged.run(result); // [10, ["fn-loaded", "arg-loaded"]]

bind

bind: <K, W, A, B>(key, f) => (data) => Logged<W, A & { [P in string]: B }>

Evaluates a new Logged using the current accumulator and attaches the output to a new key.

Type Parameters

K

K extends string

W

W

A

A

B

B

Parameters

key

K

f

(a) => Logged<W, B>

Returns

(data) => Logged<W, A & { [P in string]: B }>

Example

pipe(
  Logged.from.value<string, { a: number }>({ a: 1 }),
  Logged.bind("b", ({ a }) => Logged.from.value<string, number>(a + 1))
); // Logged({ value: { a: 1, b: 2 } })

bindTo

bindTo: <K>(key) => <W, A>(data) => Logged<W, { [P in string]: A }>

Lifts a Logged value into an accumulator object.

Type Parameters

K

K extends string

Parameters

key

K

Returns

<W, A>(data) => Logged<W, { [P in string]: A }>

Example

pipe(Logged.from.value<string, number>(42), Logged.bindTo("value")); // Logged({ value: 42 })

chain

chain: <W, A, B>(f) => (data) => Logged<W, B> = chainLogged

Sequences two Logged computations, concatenating their logs. The value from the first is passed to f; the resulting log entries are appended after the entries from the first.

Data-last — the first computation is the data being piped.

Type Parameters

W

W

A

A

B

B

Parameters

f

(a) => Logged<W, B>

Returns

(data) => Logged<W, B>

Example

const result = pipe(
  Logged.from.value<string, number>(1),
  Logged.chain(n => pipe(Logged.from.entry("step"), Logged.map(() => n + 1))),
  Logged.chain(n => pipe(Logged.from.entry("done"), Logged.map(() => n * 10))),
);

Logged.run(result); // [20, ["step", "done"]]

focus

focus: <S, A>(lens) => <W>(f) => (data) => Logged<W, S>

Focuses a Logged computation’s value transformation using a Lens.

Type Parameters

S

S

A

A

Parameters

lens

Lens<S, A>

Returns

<W>(f) => (data) => Logged<W, S>

Example

const nameLens = Lens.from.property<{ name: string }>()("name");
const logged = Logged.from.value<string, { name: string }>({ name: "alice" });
pipe(logged, Logged.focus(nameLens)(s => s.toUpperCase()));

from

from: object

from.entry

entry: <W>(logEntry) => Logged<W, undefined> = makeEntry

Creates a Logged that records a single log entry and produces no meaningful value. Use this to append to the log inside a chain.

Type Parameters

W

W

Parameters

logEntry

W

Returns

Logged<W, undefined>

Example

Logged.from.entry("operation completed"); // { value: undefined, log: ["operation completed"] }

from.value

value: <W, A>(val) => Logged<W, A> = makeValue

Wraps a pure value into a Logged with an empty log.

Type Parameters

W

W

A

A

Parameters

val

A

Returns

Logged<W, A>

Example

Logged.from.value<string, number>(42); // { value: 42, log: [] }

map

map: <W, A, B>(f) => (data) => Logged<W, B> = mapLogged

Transforms the value inside a Logged without affecting the log.

Type Parameters

W

W

A

A

B

B

Parameters

f

(a) => B

Returns

(data) => Logged<W, B>

Example

pipe(
  Logged.from.value<string, number>(5),
  Logged.map(n => n * 2),
); // { value: 10, log: [] }

run

run: <W, A>(data) => readonly [A, readonly W[]]

Extracts the value and log as a readonly [A, ReadonlyArray<W>] tuple. Use this at the boundary where you need to consume both.

Type Parameters

W

W

A

A

Parameters

data

Logged<W, A>

Returns

readonly [A, readonly W[]]

Example

const result = pipe(
  Logged.from.value<string, number>(1),
  Logged.chain(n => pipe(Logged.from.entry("incremented"), Logged.map(() => n + 1))),
);

const [value, log] = Logged.run(result);
// value = 2, log = ["incremented"]

tap

tap: <W, A>(f) => (data) => Logged<W, A>

Runs a side effect on the value without changing the Logged. Useful for debugging or inspecting intermediate values.

Type Parameters

W

W

A

A

Parameters

f

(a) => void

Returns

(data) => Logged<W, A>

Example

pipe(
  Logged.from.value<string, number>(42),
  Logged.tap(n => console.log("value:", n)),
);