@konker.dev/neverthrow-r 0.0.1

package/dist/bridges.js

@@ -0,0 +1,131 @@
+/**
+ * Sync→async bridge operators: take a `ResultR` and return a `ResultAsyncR`,
+ * promoting the chain onto the async track mid-pipeline.
+ *
+ * @remarks
+ * Reach for this module when a chain that starts synchronously needs to
+ * await — typically an I/O call partway through. Three flavours, mirroring
+ * the corresponding sync combinators but lifting the operand into
+ * `ResultAsyncR`:
+ *
+ * - {@link asyncMap} — promote via a `Promise`-returning transform.
+ * - {@link asyncAndThen} — promote via a `ResultAsyncR`-returning step.
+ * - {@link asyncAndThrough} — promote via a fallible async tee.
+ *
+ * Every step *after* the bridge must come from {@link async} (the
+ * `*Async`-suffixed combinators); there is no async→sync bridge.
+ *
+ * @example
+ * ```ts
+ * import { okR } from '@konker.dev/neverthrow-r/constructors';
+ * import { mapAsync } from '@konker.dev/neverthrow-r/async';
+ * import { asyncMap } from '@konker.dev/neverthrow-r/bridges';
+ * import { pipe } from '@konker.dev/neverthrow-r/pipe';
+ *
+ * const program = pipe(
+ *   okR<number>(2),
+ *   asyncMap(async (n) => n + 1),   // sync → async here
+ *   mapAsync(async (n) => n * 10),  // continue async
+ * );
+ *
+ * program(undefined); // ResultAsync resolving to Ok(30)
+ * ```
+ *
+ * @module
+ */
+/**
+ * Promotes a `ResultR` to a `ResultAsyncR` by applying a `Promise`-returning
+ * transform to the success value.
+ *
+ * @remarks
+ * The sync→async sibling of {@link map}. After this step the chain is async;
+ * follow with {@link mapAsync}, {@link andThenAsync}, etc.
+ *
+ * @typeParam A - The input success type.
+ * @typeParam B - The output success type.
+ *
+ * @param f - `Promise`-returning transform from `A` to `B`.
+ *
+ * @example
+ * ```ts
+ * import { okR } from '@konker.dev/neverthrow-r/constructors';
+ * import { asyncMap } from '@konker.dev/neverthrow-r/bridges';
+ * import { pipe } from '@konker.dev/neverthrow-r/pipe';
+ *
+ * const program = pipe(okR<number>(2), asyncMap(async (n) => n * 2));
+ * program(undefined); // ResultAsync resolving to Ok(4)
+ * ```
+ *
+ * @see {@link map}
+ * @see {@link mapAsync}
+ */
+export const asyncMap = (f) => (rr) => (r) => rr(r).asyncMap(f);
+/**
+ * Promotes a `ResultR` to a `ResultAsyncR` by chaining a
+ * `ResultAsyncR`-returning step.
+ *
+ * @remarks
+ * Sync→async sibling of {@link andThen}. The continuation's requirements
+ * `R2` are intersected (`R1 & R2`); its error type `E2` is unioned
+ * (`E1 | E2`).
+ *
+ * @typeParam A - The previous step's success type.
+ * @typeParam R2 - The continuation's requirements.
+ * @typeParam B - The continuation's success type.
+ * @typeParam E2 - The continuation's error type.
+ *
+ * @param f - Function from the previous success value to a `ResultAsyncR`.
+ *
+ * @example
+ * ```ts
+ * import { okAsyncR, okR } from '@konker.dev/neverthrow-r/constructors';
+ * import { asyncAndThen } from '@konker.dev/neverthrow-r/bridges';
+ * import { pipe } from '@konker.dev/neverthrow-r/pipe';
+ *
+ * const program = pipe(
+ *   okR<number>(2),
+ *   asyncAndThen((n) => okAsyncR<string>(`got ${n}`)),
+ * );
+ *
+ * program(undefined); // ResultAsync resolving to Ok('got 2')
+ * ```
+ *
+ * @see {@link andThen}
+ * @see {@link andThenAsync}
+ */
+export const asyncAndThen = (f) => (rr) => (r) => rr(r).asyncAndThen((a) => f(a)(r));
+/**
+ * Promotes a `ResultR` to a `ResultAsyncR` via a fallible async tee that
+ * propagates the *original* success value.
+ *
+ * @remarks
+ * Sync→async sibling of {@link andThrough}. The tee step is itself a
+ * `ResultAsyncR` that can fail; on success its value is discarded and the
+ * chain continues with the original success value.
+ *
+ * @typeParam T - The success type (preserved through the step on success).
+ * @typeParam R2 - The tee's requirements.
+ * @typeParam F - The tee's error type.
+ *
+ * @param f - Function from the success value to a `ResultAsyncR` whose value
+ *   is ignored on success.
+ *
+ * @example
+ * ```ts
+ * import { okAsyncR, okR } from '@konker.dev/neverthrow-r/constructors';
+ * import { asyncAndThrough } from '@konker.dev/neverthrow-r/bridges';
+ * import { pipe } from '@konker.dev/neverthrow-r/pipe';
+ *
+ * const program = pipe(
+ *   okR<number>(2),
+ *   asyncAndThrough((n) => okAsyncR<unknown>(`logged ${n}`)),
+ * );
+ *
+ * program(undefined); // ResultAsync resolving to Ok(2)
+ * ```
+ *
+ * @see {@link andThrough}
+ * @see {@link andThroughAsync}
+ */
+export const asyncAndThrough = (f) => (rr) => (r) => rr(r).asyncAndThrough((t) => f(t)(r));
+//# sourceMappingURL=bridges.js.map

package/dist/bridges.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bridges.js","sourceRoot":"","sources":["../src/bridges.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAIH;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,CAAC,MAAM,QAAQ,GACnB,CAAO,CAAuB,EAAE,EAAE,CAClC,CAAO,EAAoB,EAAyB,EAAE,CACtD,CAAC,CAAC,EAAE,EAAE,CACJ,EAAE,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;AAEtB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,MAAM,CAAC,MAAM,YAAY,GACvB,CAAe,CAAoC,EAAE,EAAE,CACvD,CAAS,EAAsB,EAAqC,EAAE,CACtE,CAAC,CAAC,EAAE,EAAE,CACJ,EAAE,CAAC,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AAEvC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,MAAM,CAAC,MAAM,eAAe,GAC1B,CAAW,CAAyC,EAAE,EAAE,CACxD,CAAQ,EAAqB,EAAmC,EAAE,CAClE,CAAC,CAAC,EAAE,EAAE,CACJ,EAAE,CAAC,CAAC,CAAC,CAAC,eAAe,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC"}

package/dist/constructors.d.ts

@@ -0,0 +1,214 @@
+/**
+ * Entry points for building `ResultR` / `ResultAsyncR` values from scratch or
+ * from existing `neverthrow` values. Use these where a pipeline starts.
+ *
+ * @remarks
+ * - {@link okR} / {@link errR} / {@link okAsyncR} / {@link errAsyncR} — lift a
+ *   plain value (or error) into a `ResultR` / `ResultAsyncR` with no
+ *   requirements (`R = unknown`).
+ * - {@link fromResult} / {@link fromResultAsync} — lift an existing neverthrow
+ *   `Result` / `ResultAsync` into the `R`-channel layer with no requirements.
+ * - {@link asks} / {@link ask} — build a `ResultR` whose only effect is to
+ *   read from the environment, declaring `R` in the process.
+ *
+ * Any non-trivial requirements (a database handle, a clock, …) are introduced
+ * with `asks`; the rest of the pipeline picks them up via intersection in
+ * `andThen`-style operators.
+ *
+ * @example
+ * ```ts
+ * import { asks, okR } from '@konker.dev/neverthrow-r/constructors';
+ * import { andThen, map } from '@konker.dev/neverthrow-r/sync';
+ * import { pipe } from '@konker.dev/neverthrow-r/pipe';
+ *
+ * type Clock = { now: () => Date };
+ *
+ * const year = asks((r: Clock) => r.now().getFullYear());
+ *
+ * const program = pipe(
+ *   okR<number>(2024),
+ *   map((n) => n + 1),
+ *   andThen(() => year),
+ * );
+ * ```
+ *
+ * @module
+ */
+import type { Result, ResultAsync } from 'neverthrow';
+import type { ResultAsyncR, ResultR } from './types.js';
+/**
+ * Lifts a plain success value into a `ResultR` with no requirements.
+ *
+ * @remarks
+ * Equivalent to `() => ok(value)`. The `R` parameter defaults to `unknown`
+ * because the constructor doesn't read from the environment.
+ *
+ * @typeParam T - The success type.
+ * @typeParam E - The error type (defaults to `never` since this always
+ *   succeeds).
+ *
+ * @param value - The value to wrap in an `Ok`.
+ * @returns A `ResultR<unknown, T, E>` that ignores its environment and yields
+ *   `Ok(value)`.
+ *
+ * @example
+ * ```ts
+ * import { okR } from '@konker.dev/neverthrow-r/constructors';
+ *
+ * const two = okR<number>(2);
+ * two(undefined); // Ok(2)
+ * ```
+ *
+ * @see {@link errR}
+ * @see {@link okAsyncR}
+ */
+export declare const okR: <T, E = never>(value: T) => ResultR<unknown, T, E>;
+/**
+ * Lifts a plain error value into a `ResultR` with no requirements.
+ *
+ * @typeParam E - The error type.
+ * @typeParam T - The success type (defaults to `never` since this always
+ *   fails).
+ *
+ * @param error - The error value to wrap in an `Err`.
+ *
+ * @example
+ * ```ts
+ * import { errR } from '@konker.dev/neverthrow-r/constructors';
+ *
+ * const fail = errR<string>('boom');
+ * fail(undefined); // Err('boom')
+ * ```
+ *
+ * @see {@link okR}
+ * @see {@link errAsyncR}
+ */
+export declare const errR: <E, T = never>(error: E) => ResultR<unknown, T, E>;
+/**
+ * Async sibling of {@link okR}: lifts a plain success value into a
+ * `ResultAsyncR` with no requirements.
+ *
+ * @example
+ * ```ts
+ * import { okAsyncR } from '@konker.dev/neverthrow-r/constructors';
+ *
+ * const program = okAsyncR<number>(2);
+ * program(undefined); // ResultAsync resolving to Ok(2)
+ * ```
+ *
+ * @see {@link okR}
+ */
+export declare const okAsyncR: <T, E = never>(value: T) => ResultAsyncR<unknown, T, E>;
+/**
+ * Async sibling of {@link errR}: lifts a plain error value into a
+ * `ResultAsyncR` with no requirements.
+ *
+ * @example
+ * ```ts
+ * import { errAsyncR } from '@konker.dev/neverthrow-r/constructors';
+ *
+ * const fail = errAsyncR<string>('boom');
+ * fail(undefined); // ResultAsync resolving to Err('boom')
+ * ```
+ *
+ * @see {@link errR}
+ */
+export declare const errAsyncR: <E, T = never>(error: E) => ResultAsyncR<unknown, T, E>;
+/**
+ * Lifts an existing neverthrow `Result<T, E>` into a `ResultR<unknown, T, E>`.
+ *
+ * @remarks
+ * Useful at the seam where existing neverthrow-using code is being adapted
+ * into a pipeline that wants the `R` channel — wrap the legacy value once and
+ * compose normally thereafter.
+ *
+ * @typeParam T - The success type.
+ * @typeParam E - The error type.
+ *
+ * @param r - The existing `Result` to lift.
+ *
+ * @example
+ * ```ts
+ * import { ok } from 'neverthrow';
+ * import { fromResult } from '@konker.dev/neverthrow-r/constructors';
+ *
+ * const existing = ok<number, string>(42);
+ * const lifted = fromResult(existing);
+ * lifted(undefined); // Ok(42)
+ * ```
+ *
+ * @see {@link fromResultAsync}
+ */
+export declare const fromResult: <T, E>(r: Result<T, E>) => ResultR<unknown, T, E>;
+/**
+ * Async sibling of {@link fromResult}: lifts an existing `ResultAsync<T, E>`
+ * into a `ResultAsyncR<unknown, T, E>`.
+ *
+ * @example
+ * ```ts
+ * import { okAsync } from 'neverthrow';
+ * import { fromResultAsync } from '@konker.dev/neverthrow-r/constructors';
+ *
+ * const existing = okAsync<number, string>(42);
+ * const lifted = fromResultAsync(existing);
+ * lifted(undefined); // ResultAsync resolving to Ok(42)
+ * ```
+ *
+ * @see {@link fromResult}
+ */
+export declare const fromResultAsync: <T, E>(ra: ResultAsync<T, E>) => ResultAsyncR<unknown, T, E>;
+/**
+ * Builds a `ResultR` whose value is computed from the environment. This is
+ * how requirements are *introduced* into a chain.
+ *
+ * @remarks
+ * `asks(f)` is equivalent to `(r) => ok(f(r))`. The argument's parameter type
+ * fixes the `R` channel for the rest of the pipeline; downstream operators
+ * intersect any further requirements.
+ *
+ * Use this when a step depends on something in the environment (a config
+ * value, a service handle, the current time). For just reading the entire
+ * environment unchanged, see {@link ask}.
+ *
+ * @typeParam R - The requirements (environment) read from.
+ * @typeParam A - The value computed from the environment.
+ *
+ * @param f - A pure function from environment to value.
+ *
+ * @example
+ * ```ts
+ * import { asks } from '@konker.dev/neverthrow-r/constructors';
+ *
+ * type Config = { multiplier: number };
+ *
+ * const multiplier = asks((r: Config) => r.multiplier);
+ * multiplier({ multiplier: 10 }); // Ok(10)
+ * ```
+ *
+ * @see {@link ask}
+ */
+export declare const asks: <R, A>(f: (r: R) => A) => ResultR<R, A, never>;
+/**
+ * Reads the entire environment as the success value.
+ *
+ * @remarks
+ * Specialisation of {@link asks} with the identity function. Most useful when
+ * a step wants the whole environment passed downstream — e.g. to forward it
+ * into a sub-pipeline.
+ *
+ * @typeParam R - The requirements (environment), surfaced as the success type.
+ *
+ * @example
+ * ```ts
+ * import { ask } from '@konker.dev/neverthrow-r/constructors';
+ *
+ * type Config = { multiplier: number };
+ *
+ * const env = ask<Config>();
+ * env({ multiplier: 10 }); // Ok({ multiplier: 10 })
+ * ```
+ *
+ * @see {@link asks}
+ */
+export declare const ask: <R>() => ResultR<R, R, never>;
+//# sourceMappingURL=constructors.d.ts.map

package/dist/constructors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constructors.d.ts","sourceRoot":"","sources":["../src/constructors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAGtD,OAAO,KAAK,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAExD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,GAAG,GACb,CAAC,EAAE,CAAC,GAAG,KAAK,EAAE,OAAO,CAAC,KAAG,OAAO,CAAC,OAAO,EAAE,CAAC,EAAE,CAAC,CAEpC,CAAC;AAEd;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,IAAI,GACd,CAAC,EAAE,CAAC,GAAG,KAAK,EAAE,OAAO,CAAC,KAAG,OAAO,CAAC,OAAO,EAAE,CAAC,EAAE,CAAC,CAEnC,CAAC;AAEf;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,QAAQ,GAClB,CAAC,EAAE,CAAC,GAAG,KAAK,EAAE,OAAO,CAAC,KAAG,YAAY,CAAC,OAAO,EAAE,CAAC,EAAE,CAAC,CAEpC,CAAC;AAEnB;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,SAAS,GACnB,CAAC,EAAE,CAAC,GAAG,KAAK,EAAE,OAAO,CAAC,KAAG,YAAY,CAAC,OAAO,EAAE,CAAC,EAAE,CAAC,CAEnC,CAAC;AAEpB;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,UAAU,GACpB,CAAC,EAAE,CAAC,EAAE,GAAG,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,KAAG,OAAO,CAAC,OAAO,EAAE,CAAC,EAAE,CAAC,CAE3C,CAAC;AAEN;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,eAAe,GACzB,CAAC,EAAE,CAAC,EAAE,IAAI,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,KAAG,YAAY,CAAC,OAAO,EAAE,CAAC,EAAE,CAAC,CAErD,CAAC;AAEP;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,eAAO,MAAM,IAAI,GACd,CAAC,EAAE,CAAC,EAAE,GAAG,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,KAAG,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,CAEjC,CAAC;AAEb;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,GAAG,GAAI,CAAC,OAAK,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,CAAsB,CAAC"}

package/dist/constructors.js

@@ -0,0 +1,213 @@
+/**
+ * Entry points for building `ResultR` / `ResultAsyncR` values from scratch or
+ * from existing `neverthrow` values. Use these where a pipeline starts.
+ *
+ * @remarks
+ * - {@link okR} / {@link errR} / {@link okAsyncR} / {@link errAsyncR} — lift a
+ *   plain value (or error) into a `ResultR` / `ResultAsyncR` with no
+ *   requirements (`R = unknown`).
+ * - {@link fromResult} / {@link fromResultAsync} — lift an existing neverthrow
+ *   `Result` / `ResultAsync` into the `R`-channel layer with no requirements.
+ * - {@link asks} / {@link ask} — build a `ResultR` whose only effect is to
+ *   read from the environment, declaring `R` in the process.
+ *
+ * Any non-trivial requirements (a database handle, a clock, …) are introduced
+ * with `asks`; the rest of the pipeline picks them up via intersection in
+ * `andThen`-style operators.
+ *
+ * @example
+ * ```ts
+ * import { asks, okR } from '@konker.dev/neverthrow-r/constructors';
+ * import { andThen, map } from '@konker.dev/neverthrow-r/sync';
+ * import { pipe } from '@konker.dev/neverthrow-r/pipe';
+ *
+ * type Clock = { now: () => Date };
+ *
+ * const year = asks((r: Clock) => r.now().getFullYear());
+ *
+ * const program = pipe(
+ *   okR<number>(2024),
+ *   map((n) => n + 1),
+ *   andThen(() => year),
+ * );
+ * ```
+ *
+ * @module
+ */
+import { err, errAsync, ok, okAsync } from 'neverthrow';
+/**
+ * Lifts a plain success value into a `ResultR` with no requirements.
+ *
+ * @remarks
+ * Equivalent to `() => ok(value)`. The `R` parameter defaults to `unknown`
+ * because the constructor doesn't read from the environment.
+ *
+ * @typeParam T - The success type.
+ * @typeParam E - The error type (defaults to `never` since this always
+ *   succeeds).
+ *
+ * @param value - The value to wrap in an `Ok`.
+ * @returns A `ResultR<unknown, T, E>` that ignores its environment and yields
+ *   `Ok(value)`.
+ *
+ * @example
+ * ```ts
+ * import { okR } from '@konker.dev/neverthrow-r/constructors';
+ *
+ * const two = okR<number>(2);
+ * two(undefined); // Ok(2)
+ * ```
+ *
+ * @see {@link errR}
+ * @see {@link okAsyncR}
+ */
+export const okR = (value) => () => ok(value);
+/**
+ * Lifts a plain error value into a `ResultR` with no requirements.
+ *
+ * @typeParam E - The error type.
+ * @typeParam T - The success type (defaults to `never` since this always
+ *   fails).
+ *
+ * @param error - The error value to wrap in an `Err`.
+ *
+ * @example
+ * ```ts
+ * import { errR } from '@konker.dev/neverthrow-r/constructors';
+ *
+ * const fail = errR<string>('boom');
+ * fail(undefined); // Err('boom')
+ * ```
+ *
+ * @see {@link okR}
+ * @see {@link errAsyncR}
+ */
+export const errR = (error) => () => err(error);
+/**
+ * Async sibling of {@link okR}: lifts a plain success value into a
+ * `ResultAsyncR` with no requirements.
+ *
+ * @example
+ * ```ts
+ * import { okAsyncR } from '@konker.dev/neverthrow-r/constructors';
+ *
+ * const program = okAsyncR<number>(2);
+ * program(undefined); // ResultAsync resolving to Ok(2)
+ * ```
+ *
+ * @see {@link okR}
+ */
+export const okAsyncR = (value) => () => okAsync(value);
+/**
+ * Async sibling of {@link errR}: lifts a plain error value into a
+ * `ResultAsyncR` with no requirements.
+ *
+ * @example
+ * ```ts
+ * import { errAsyncR } from '@konker.dev/neverthrow-r/constructors';
+ *
+ * const fail = errAsyncR<string>('boom');
+ * fail(undefined); // ResultAsync resolving to Err('boom')
+ * ```
+ *
+ * @see {@link errR}
+ */
+export const errAsyncR = (error) => () => errAsync(error);
+/**
+ * Lifts an existing neverthrow `Result<T, E>` into a `ResultR<unknown, T, E>`.
+ *
+ * @remarks
+ * Useful at the seam where existing neverthrow-using code is being adapted
+ * into a pipeline that wants the `R` channel — wrap the legacy value once and
+ * compose normally thereafter.
+ *
+ * @typeParam T - The success type.
+ * @typeParam E - The error type.
+ *
+ * @param r - The existing `Result` to lift.
+ *
+ * @example
+ * ```ts
+ * import { ok } from 'neverthrow';
+ * import { fromResult } from '@konker.dev/neverthrow-r/constructors';
+ *
+ * const existing = ok<number, string>(42);
+ * const lifted = fromResult(existing);
+ * lifted(undefined); // Ok(42)
+ * ```
+ *
+ * @see {@link fromResultAsync}
+ */
+export const fromResult = (r) => () => r;
+/**
+ * Async sibling of {@link fromResult}: lifts an existing `ResultAsync<T, E>`
+ * into a `ResultAsyncR<unknown, T, E>`.
+ *
+ * @example
+ * ```ts
+ * import { okAsync } from 'neverthrow';
+ * import { fromResultAsync } from '@konker.dev/neverthrow-r/constructors';
+ *
+ * const existing = okAsync<number, string>(42);
+ * const lifted = fromResultAsync(existing);
+ * lifted(undefined); // ResultAsync resolving to Ok(42)
+ * ```
+ *
+ * @see {@link fromResult}
+ */
+export const fromResultAsync = (ra) => () => ra;
+/**
+ * Builds a `ResultR` whose value is computed from the environment. This is
+ * how requirements are *introduced* into a chain.
+ *
+ * @remarks
+ * `asks(f)` is equivalent to `(r) => ok(f(r))`. The argument's parameter type
+ * fixes the `R` channel for the rest of the pipeline; downstream operators
+ * intersect any further requirements.
+ *
+ * Use this when a step depends on something in the environment (a config
+ * value, a service handle, the current time). For just reading the entire
+ * environment unchanged, see {@link ask}.
+ *
+ * @typeParam R - The requirements (environment) read from.
+ * @typeParam A - The value computed from the environment.
+ *
+ * @param f - A pure function from environment to value.
+ *
+ * @example
+ * ```ts
+ * import { asks } from '@konker.dev/neverthrow-r/constructors';
+ *
+ * type Config = { multiplier: number };
+ *
+ * const multiplier = asks((r: Config) => r.multiplier);
+ * multiplier({ multiplier: 10 }); // Ok(10)
+ * ```
+ *
+ * @see {@link ask}
+ */
+export const asks = (f) => (r) => ok(f(r));
+/**
+ * Reads the entire environment as the success value.
+ *
+ * @remarks
+ * Specialisation of {@link asks} with the identity function. Most useful when
+ * a step wants the whole environment passed downstream — e.g. to forward it
+ * into a sub-pipeline.
+ *
+ * @typeParam R - The requirements (environment), surfaced as the success type.
+ *
+ * @example
+ * ```ts
+ * import { ask } from '@konker.dev/neverthrow-r/constructors';
+ *
+ * type Config = { multiplier: number };
+ *
+ * const env = ask<Config>();
+ * env({ multiplier: 10 }); // Ok({ multiplier: 10 })
+ * ```
+ *
+ * @see {@link asks}
+ */
+export const ask = () => asks((r) => r);
+//# sourceMappingURL=constructors.js.map

package/dist/constructors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constructors.js","sourceRoot":"","sources":["../src/constructors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAGH,OAAO,EAAE,GAAG,EAAE,QAAQ,EAAE,EAAE,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAIxD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,CAAC,MAAM,GAAG,GACd,CAAe,KAAQ,EAA0B,EAAE,CACnD,GAAG,EAAE,CACH,EAAE,CAAC,KAAK,CAAC,CAAC;AAEd;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,CAAC,MAAM,IAAI,GACf,CAAe,KAAQ,EAA0B,EAAE,CACnD,GAAG,EAAE,CACH,GAAG,CAAC,KAAK,CAAC,CAAC;AAEf;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,MAAM,QAAQ,GACnB,CAAe,KAAQ,EAA+B,EAAE,CACxD,GAAG,EAAE,CACH,OAAO,CAAC,KAAK,CAAC,CAAC;AAEnB;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,MAAM,SAAS,GACpB,CAAe,KAAQ,EAA+B,EAAE,CACxD,GAAG,EAAE,CACH,QAAQ,CAAC,KAAK,CAAC,CAAC;AAEpB;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,CAAC,MAAM,UAAU,GACrB,CAAO,CAAe,EAA0B,EAAE,CAClD,GAAG,EAAE,CACH,CAAC,CAAC;AAEN;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,MAAM,eAAe,GAC1B,CAAO,EAAqB,EAA+B,EAAE,CAC7D,GAAG,EAAE,CACH,EAAE,CAAC;AAEP;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,MAAM,CAAC,MAAM,IAAI,GACf,CAAO,CAAc,EAAwB,EAAE,CAC/C,CAAC,CAAC,EAAE,EAAE,CACJ,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AAEb;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,CAAC,MAAM,GAAG,GAAG,GAA4B,EAAE,CAAC,IAAI,CAAC,CAAC,CAAI,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC"}