Validation

Validation: object

Defined in: Core/Validation.ts:35

Type Declaration

ap

ap: <E, A>(arg) => <B>(data) => Validation<E, B>

Applies a function wrapped in a Validation to a value wrapped in a Validation. Accumulates errors from both sides.

Type Parameters

E

E

A

A

Parameters

arg

Validation<E, A>

Returns

<B>(data) => Validation<E, B>

Example

const add = (a: number) => (b: number) => a + b;
pipe(
  Validation.make.passed(add),
  Validation.ap(Validation.make.passed(5)),
  Validation.ap(Validation.make.passed(3))
); // Passed(8)

pipe(
  Validation.make.passed(add),
  Validation.ap(Validation.make.failed<string>("bad a")),
  Validation.ap(Validation.make.failed<string>("bad b"))
); // Failed(["bad a", "bad b"])

apCustom

apCustom: <E1, E2, E3>(concat) => <A>(arg) => <B>(data) => Validation<E3, B>

Applies a function wrapped in a Validation to a value wrapped in a Validation, using a custom error concatenator function when both sides fail.

Type Parameters

E1

E1

E2

E2

E3

E3

Parameters

concat

(e1, e2) => NonEmptyArr<E3>

Returns

<A>(arg) => <B>(data) => Validation<E3, B>

Example

const concat = (e1: NonEmptyArr<string>, e2: NonEmptyArr<string>): NonEmptyArr<string> =>
  [...e1, ...e2];
pipe(fnVal, Validation.apCustom(concat)(argVal));

fold

fold: <E, A, B>(onFailed, onPassed) => (data) => B

Extracts the value from a Validation by providing handlers for both cases.

Type Parameters

E

E

A

A

B

B

Parameters

onFailed

(errors) => B

onPassed

(a) => B

Returns

(data) => B

Example

pipe(
  Validation.make.passed(42),
  Validation.fold(
    errors => `Errors: ${errors.join(", ")}`,
    value => `Value: ${value}`
  )
);

from

from: object

from.Maybe

Maybe: <E>(onNone) => <A>(maybe) => Validation<E, A>

Creates a Validation from a Maybe. If the Maybe is None, returns Failed with the error from onNone. Otherwise, returns Passed.

Type Parameters

E

E

Parameters

onNone

() => E

Returns

<A>(maybe) => Validation<E, A>

Example

pipe(Maybe.make.none(), Validation.from.Maybe(() => "is none")); // Failed(["is none"])
pipe(Maybe.make.some(42), Validation.from.Maybe(() => "is none")); // Passed(42)

from.nullable

nullable: <E>(onNull) => <A>(value) => Validation<E, A>

Creates a Validation from a nullable value. If the value is null or undefined, returns Failed with the error from onNull. Otherwise, returns Passed.

Type Parameters

E

E

Parameters

onNull

() => E

Returns

<A>(value) => Validation<E, A>

Example

pipe(null, Validation.from.nullable(() => "is null")); // Failed(["is null"])
pipe(42, Validation.from.nullable(() => "is null"));   // Passed(42)

from.Predicate

Predicate: <E, A>(pred, onFalse) => (a) => Validation<E, A>

Creates a Validation from a predicate applied to a value. Returns Passed if the predicate passes, Failed from onFalse otherwise.

Type Parameters

E

E

A

A

Parameters

pred

(a) => boolean

onFalse

(a) => E

Returns

(a) => Validation<E, A>

Example

const validateName = Validation.from.Predicate(
  (s: string) => s.length > 0,
  () => "Name is required"
);

validateName("Alice"); // Passed("Alice")
validateName("");      // Failed(["Name is required"])

from.Result

Result: <E, A>(data) => Validation<E, A>

Converts a Result to a Validation. Ok becomes Passed; Err(e) becomes Failed([e]).

Useful when bridging from error-short-circuiting Result pipelines into error-accumulating Validation pipelines.

Type Parameters

E

E

A

A

Parameters

data

Result<E, A>

Returns

Validation<E, A>

Example

Validation.from.Result(Result.make.ok(42));       // Passed(42)
Validation.from.Result(Result.make.err("bad"));   // Failed(["bad"])

getOrElse

getOrElse: <B>(defaultValue) => <E, A>(data) => B | A

Returns the success value or a default value if the Validation is failed. The default can be a different type, widening the result to A | B.

Type Parameters

B

B

Parameters

defaultValue

() => B

Returns

<E, A>(data) => B | A

Example

pipe(Validation.make.passed(5), Validation.getOrElse(() => 0)); // 5
pipe(Validation.make.failed("oops"), Validation.getOrElse(() => 0)); // 0
pipe(Validation.make.failed("oops"), Validation.getOrElse(() => null)); // null — typed as number | null

is

is: object

is.failed

failed: <E, A>(data) => data is Failed<E> = isFailed

Type guard that checks if a Validation is failed.

Type Parameters

E

E

A

A

Parameters

data

Validation<E, A>

Returns

data is Failed<E>

Example

const v = Validation.make.failed("invalid");
if (Validation.is.failed(v)) {
  console.log(v.errors); // ["invalid"]
}

is.passed

passed: <E, A>(data) => data is Passed<A> = isPassed

Type guard that checks if a Validation is passed.

Type Parameters

E

E

A

A

Parameters

data

Validation<E, A>

Returns

data is Passed<A>

Example

const v = Validation.make.passed(42);
if (Validation.is.passed(v)) {
  console.log(v.value); // 42
}

make

make: object

make.failed

failed: <E>(error) => Failed<E> = makeFailed

Creates a failed Validation from a single error.

Type Parameters

E

E

Parameters

error

E

Returns

Failed<E>

Example

Validation.make.failed("Invalid input");

make.failedAll

failedAll: <E>(errors) => Failed<E> = makeFailedAll

Creates a failed Validation from multiple errors.

Type Parameters

E

E

Parameters

errors

NonEmptyArr<E>

Returns

Failed<E>

Example

Validation.make.failedAll(["Invalid input"]);

make.passed

passed: <E, A>(value) => Validation<E, A> = makePassed

Wraps a value in a passed Validation.

Type Parameters

E

E

A

A

Parameters

value

A

Returns

Validation<E, A>

Example

Validation.make.passed(42); // Passed(42)

map

map: <A, B>(f) => <E>(data) => Validation<E, B>

Transforms the success value inside a Validation.

Type Parameters

A

A

B

B

Parameters

f

(a) => B

Returns

<E>(data) => Validation<E, B>

Example

pipe(Validation.make.passed(5), Validation.map(n => n * 2)); // Passed(10)
pipe(Validation.make.failed("oops"), Validation.map(n => n * 2)); // Failed(["oops"])

mapError

mapError: <E, F, A>(f) => (data) => Validation<F, A>

Transforms the error list inside a Validation.

Type Parameters

E

E

F

F

A

A

Parameters

f

(e) => F

Returns

(data) => Validation<F, A>

Example

pipe(Validation.make.failed("oops"), Validation.mapError(e => e.toUpperCase())); // Failed(["OOPS"])

match

match: <E, A, B>(cases) => (data) => B

Pattern matches on a Validation, returning the result of the matching case.

Type Parameters

E

E

A

A

B

B

Parameters

cases

failed

(errors) => B

passed

(a) => B

Returns

(data) => B

Example

pipe(
  validation,
  Validation.match({
    passed: value => `Got ${value}`,
    failed: errors => `Failed: ${errors.join(", ")}`
  })
);

product

product: <E, A, B>(first, second) => Validation<E, readonly [A, B]>

Combines two independent Validation instances into a tuple. If both are Passed, returns Passed with both values as a tuple. If either is Failed, accumulates errors from both sides.

Type Parameters

E

E

A

A

B

B

Parameters

first

Validation<E, A>

second

Validation<E, B>

Returns

Validation<E, readonly [A, B]>

Example

Validation.product(
  Validation.make.passed("alice"),
  Validation.make.passed(30)
); // Passed(["alice", 30])

Validation.product(
  Validation.make.failed("Name required"),
  Validation.make.failed("Age must be >= 0")
); // Failed(["Name required", "Age must be >= 0"])

productAll

productAll: <E, A>(data) => Validation<E, readonly A[]>

Combines a non-empty list of Validation instances, accumulating all errors. If all are Passed, returns Passed with all values collected into an array. If any are Failed, returns Failed with all accumulated errors.

Type Parameters

E

E

A

A

Parameters

data

NonEmptyArr<Validation<E, A>>

Returns

Validation<E, readonly A[]>

Example

Validation.productAll([
  validateName(name),
  validateEmail(email),
  validateAge(age)
]);
// Passed([name, email, age]) or Failed([...all errors])

recover

recover: <E, B>(fallback) => <A>(data) => Validation<E, B | A>

Recovers from a Failed state by providing a fallback Validation. The fallback receives the accumulated error list so callers can inspect which errors occurred. The fallback can produce a different success type, widening the result to Validation<E, A | B>.

Type Parameters

E

E

B

B

Parameters

fallback

(errors) => Validation<E, B>

Returns

<A>(data) => Validation<E, B | A>

recoverUnless

recoverUnless: <E, B>(isBlocked, fallback) => <A>(data) => Validation<E, B | A>

Recovers from a Failed state unless isBlocked returns true for any of the accumulated errors. The fallback can produce a different success type, widening the result to Validation<E, A | B>.

Type Parameters

E

E

B

B

Parameters

isBlocked

(e) => boolean

fallback

() => Validation<E, B>

Returns

<A>(data) => Validation<E, B | A>

Example

pipe(
  Validation.make.failed("field-error"),
  Validation.recoverUnless(e => e === "fatal", () => Validation.make.passed(0))
); // Passed(0)

struct

struct: <E, R>(fields) => Validation<E, R>

Combines a record of Validations into a single Validation of a record. Accumulates all failed branches’ errors.

Type Parameters

E

E

R

R extends Record<string, any>

Parameters

fields

{ [K in string | number | symbol]: Validation<E, R[K]> }

Returns

Validation<E, R>

Example

Validation.struct({
  name: Validation.make.passed("Alice"),
  age: Validation.make.passed(30)
}); // Passed({ name: "Alice", age: 30 })

Validation.struct({
  name: Validation.make.failed("Name required"),
  age: Validation.make.failed("Age must be >= 0")
}); // Failed(["Name required", "Age must be >= 0"])

tap

tap: <E, A>(f) => (data) => Validation<E, A>

Executes a side effect on the success value without changing the Validation.

Type Parameters

E

E

A

A

Parameters

f

(a) => void

Returns

(data) => Validation<E, A>

Example

pipe(
  Validation.make.passed(5),
  Validation.tap(n => console.log("Value:", n)),
  Validation.map(n => n * 2)
);

tapError

tapError: <E, A>(f) => (data) => Validation<E, A>

Executes a side effect on the accumulated errors without changing the Validation. Useful for logging or reporting validation failures.

Type Parameters

E

E

A

A

Parameters

f

(errors) => void

Returns

(data) => Validation<E, A>

Example

pipe(
  Validation.make.failed("Name required"),
  Validation.tapError(errors => console.error("validation failed:", errors)),
  Validation.map(toUser)
);

to

to: object

to.Maybe

Maybe: <E, A>(data) => Maybe<A>

Converts a Validation to a Maybe. Passed becomes Some; Failed becomes None (errors are discarded).

Type Parameters

E

E

A

A

Parameters

data

Validation<E, A>

Returns

Maybe<A>

Example

Validation.to.Maybe(Validation.make.passed(42));       // Some(42)
Validation.to.Maybe(Validation.make.failed("bad"));  // None

to.Result

Result: {<E1, E2, A>(combineErrors): (val) => Result<E2, A>; <E, A>(data): Result<NonEmptyArr<E>, A>; } = toResult

Converts a Validation to a Result. Passed becomes Ok. Direct call converts Failed to Err with accumulated error list NonEmptyArr<E>. Curried call converts Failed to Err with combined error E2 via combineErrors.

Call Signature

<E1, E2, A>(combineErrors): (val) => Result<E2, A>

Type Parameters

E1

E1

E2

E2

A

A

Parameters

combineErrors

(errors) => E2

Returns

(val) => Result<E2, A>

Call Signature

<E, A>(data): Result<NonEmptyArr<E>, A>

Type Parameters

E

E

A

A

Parameters

data

Validation<E, A>

Returns

Result<NonEmptyArr<E>, A>

Example

Validation.to.Result(Validation.make.passed(42));        // Ok(42)
Validation.to.Result(Validation.make.failed("oops"));  // Err(["oops"])
pipe(Validation.make.failed("oops"), Validation.to.Result(errors => errors.join(", "))); // Err("oops")

tryCatch

tryCatch: <E, A>(f, options) => Validation<E, A>

Creates a Validation from a synchronous thunk that may throw. Catches any errors and transforms them using the onError function into a Failed validation.

Type Parameters

E

E

A

A

Parameters

f

() => A

options

onError

(e) => E

Returns

Validation<E, A>

Example

const result = Validation.tryCatch(
  () => JSON.parse(rawString),
  { onError: (e) => `Parse error: ${e}` }
);