Reader

Reader: object

Defined in: Core/Reader.ts:26

Type Declaration

apply

apply: <R2, A>(arg) => <B, R1>(reader) => Reader<R1 & R2, B>

Applies a function wrapped in a Reader to a value wrapped in a Reader. Combines environment requirements via intersection.

Type Parameters

R2

R2

A

A

Parameters

arg

Reader<R2, A>

Returns

<B, R1>(reader) => Reader<R1 & R2, B>

See

chain to sequence dependent Reader computations.

Example

const add = (a: number) => (b: number) => a + b;
pipe(
  Reader.make<Config, typeof add>(add),
  Reader.apply((c: Config) => c.timeout),
  Reader.apply(Reader.make(5))
)(appConfig);

ask

ask: <R>() => Reader<R, R>

Returns the full environment as the result. The fundamental way to access the environment in a pipeline.

Type Parameters

R

R

Returns

Reader<R, R>

See

make to lift a static value that ignores the environment.

Example

pipe(
  Reader.ask<Config>(),
  Reader.map(config => config.baseUrl)
)(appConfig); // "https://api.example.com"

assign

assign: <K, R2, A, B>(key, transform) => <R1>(reader) => Reader<R1 & R2, A & { [P in string]: B }>

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

Type Parameters

K

K extends string

R2

R2

A

A

B

B

Parameters

key

K

transform

(value) => Reader<R2, B>

Returns

<R1>(reader) => Reader<R1 & R2, A & { [P in string]: B }>

See

assignTo to initialize the accumulator record.

Example

pipe(
  Reader.make({ a: 1 }),
  Reader.assign("b", ({ a }) => Reader.make(a + 1))
); // Reader({ a: 1, b: 2 })

assignTo

assignTo: <K>(key) => <R, A>(reader) => Reader<R, { [P in string]: A }>

Lifts a Reader value into an accumulator object.

Type Parameters

K

K extends string

Parameters

key

K

Returns

<R, A>(reader) => Reader<R, { [P in string]: A }>

See

assign to accumulate subsequent Reader values into the object.

Example

pipe(Reader.make(42), Reader.assignTo("value")); // Reader({ value: 42 })

chain

chain: <A, R2, B>(transform) => <R1>(reader) => Reader<R1 & R2, B> = chainReader

Sequences two Readers. Both see the environment. The output of the first is passed to transform, which returns the next Reader.

Type Parameters

A

A

R2

R2

B

B

Parameters

transform

(value) => Reader<R2, B>

Returns

<R1>(reader) => Reader<R1 & R2, B>

See

map to transform the value without returning a new Reader.

Example

const buildUrl = (path: string): Reader<Config, string> =>
  c => `${c.baseUrl}${path}`;

const addAuth = (url: string): Reader<Config, string> =>
  c => `${url}?key=${c.apiKey}`;

pipe(
  buildUrl("/items"),
  Reader.chain(addAuth)
)(appConfig); // "https://api.example.com/items?key=secret"

local

local: <R2, R>(transform) => <A>(reader) => Reader<R2, A>

Adapts a Reader to work with a different (typically wider) environment by transforming the environment before passing it to the Reader. This lets you compose Readers that expect different environments.

Type Parameters

R2

R2

R

R

Parameters

transform

(env) => R

Returns

<A>(reader) => Reader<R2, A>

See

run to supply the final environment rather than transforming it.

Example

type AppEnv = { db: DbPool; config: Config; logger: Logger };

// buildUrl only needs Config
const buildUrl: Reader<Config, string> = c => c.baseUrl;

// Zoom in from AppEnv to Config
const buildUrlFromApp: Reader<AppEnv, string> =
  pipe(buildUrl, Reader.local((env: AppEnv) => env.config));

buildUrlFromApp(appEnv); // works with the full AppEnv

make

make: <R, A>(value) => Reader<R, A>

Lifts a pure value into a Reader. The environment is ignored.

Type Parameters

R

R = unknown

A

A = never

Parameters

value

A

Returns

Reader<R, A>

See

ask to retrieve the environment instead of ignoring it.

Example

const always42: Reader<Config, number> = Reader.make(42);
always42(anyConfig); // 42

map

map: <A, B>(transform) => <R>(reader) => Reader<R, B> = mapReader

Transforms the value produced by a Reader.

Type Parameters

A

A

B

B

Parameters

transform

(value) => B

Returns

<R>(reader) => Reader<R, B>

See

chain to sequence a computation that also reads from the environment.

Example

pipe(
  (c: Config) => c.baseUrl,
  Reader.map(url => url.toUpperCase())
)(appConfig); // "HTTPS://API.EXAMPLE.COM"

run

run: <R>(env) => <A>(reader) => A

Runs a Reader by supplying the environment. Use this at the edge of your program where the environment is available.

Type Parameters

R

R

Parameters

env

R

Returns

<A>(reader) => A

See

local to adapt the environment before execution.

Example

pipe(
  buildEndpoint("/users"),
  Reader.run(appConfig)
); // "https://api.example.com/users?key=secret"

tap

tap: <A>(sideEffect) => <R>(reader) => Reader<R, A>

Executes a side effect on the produced value without changing the Reader. Useful for logging or debugging inside a pipeline.

Type Parameters

A

A

Parameters

sideEffect

(value) => void

Returns

<R>(reader) => Reader<R, A>

See

map to transform the value instead of executing a side effect.

Example

pipe(
  buildUrl("/users"),
  Reader.tap(url => console.log("Requesting:", url)),
  Reader.chain(addAuth)
)(appConfig);