Class Passing<T>

constructor

• new Passing<T>(value: T): Passing<T>

  Type Parameters

  • T

  Parameters

  • value: T

  Returns Passing<T>

Readonlytype

Readonlyvalue

chain

• chain<R>(fn: (x: Passing<T>) => Validation<R>): Validation<R>

  Chains a function that returns a Validation, enabling monadic composition. For Passing, applies the function; for Failing, returns unchanged.

  Type Parameters

  • R

  Parameters

  • fn: (x: Passing<T>) => Validation<R>

    Function that takes a Passing and returns a new Validation.

  Returns Validation<R>

  The Validation returned by fn (for Passing) or the same instance (for Failing).

  Example

  const passing = Validation.Passing(42);
  const result = passing.chain(v => Validation.Passing(v.value * 2)); // Passing<84>
  Copy

concat

• concat<R>(validation: Validation<R>): Validation<R>

  Combines this Validation with another, following semigroup rules. Returns Passing if both are Passing, otherwise returns a Failing with concatenated messages.

  Type Parameters

  • R

  Parameters

  • validation: Validation<R>

    Another Validation to combine with.

  Returns Validation<R>

  A new Validation combining the states.

  Example

  const passing = Validation.Passing(42);
  const failing = Validation.Failing(['error']);
  const result = passing.concat(failing); // Failing<['error']>
  Copy

map

• map<R>(fn: (x: T) => R): Passing<R>

  Transforms the Passing value using a function, preserving the Validation structure. Acts as a functor operation, similar to Array.map. Failing returns unchanged.

  Type Parameters

  • R

  Parameters

  • fn: (x: T) => R

    Function to transform the Passing value.

  Returns Passing<R>

  A new Validation with the transformed value (for Passing) or the same instance (for Failing).

  Example

  const passing = Validation.Passing(42);
  const result = passing.map(x => x + 1); // Passing<43>
  Copy

matchWith

• matchWith<R>(pattern: ValidationPattern<T, R>): R

  Matches the Validation state with a pattern, returning a value. Enables declarative state handling, similar to a switch statement.

  Type Parameters

  • R

  Parameters

  • pattern: ValidationPattern<T, R>

    Object with functions for each Validation state.

  Returns R

  The result of the matching function.

  Example

  const validation = Validation.Passing(42);
  const result = validation.matchWith({
    Passing: ({ value }) => value * 2,
    Failing: () => 0,
  }); // 84
  Copy

matchWithPartial

• matchWithPartial(pattern: Partial<ValidationPattern<T, void>>): void

  Matches the Validation state with a partial pattern, performing side effects.

  Parameters

  • pattern: Partial<ValidationPattern<T, void>>

    Partial object with functions for some Validation states.

  Returns void

  Example

  Validation.Failing(['error']).matchWithPartial({
    Failing: ({ messages }) => console.log(messages),
  });
  Copy

Staticof

• of<T>(value: T): Passing<T>

  Creates a new Passing Validation.

  Type Parameters

  • T

  Parameters

  • value: T

    The validated value.

  Returns Passing<T>