Phantom Stories Library - v0.0.8
    Preparing search index...

    Interface ValidationMethods<T>

    Interface for Validation methods, implementing functor, monad, and semigroup operations.

    interface ValidationMethods<T> {
        chain: <R>(fn: (x: Passing<T>) => Validation<R>) => Validation<R>;
        concat: <R>(validation: Validation<R>) => Validation<T | R>;
        map: <R>(fn: (x: T) => R) => Validation<R>;
        matchWith: <R>(pattern: ValidationPattern<T, R>) => R;
        matchWithPartial: (pattern: Partial<ValidationPattern<T, void>>) => void;
    }

    Type Parameters

    • T

    Implemented by

    Index

    Properties

    chain concat map matchWith matchWithPartial

    Properties

    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 declaration

    const passing = Validation.Passing(42);
    const result = passing.chain(v => Validation.Passing(v.value * 2)); // Passing<84>
    concat: <R>(validation: Validation<R>) => Validation<T | R>

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

    Type declaration

    const passing = Validation.Passing(42);
    const failing = Validation.Failing(['error']);
    const result = passing.concat(failing); // Failing<['error']>
    map: <R>(fn: (x: T) => R) => Validation<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 declaration

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

      • Type Parameters

        • R

        Parameters

        • fn: (x: T) => R

          Function to transform the Passing value.

        Returns Validation<R>

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

    const passing = Validation.Passing(42);
    const result = passing.map(x => x + 1); // Passing<43>
    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 declaration

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

      • Type Parameters

        • R

        Parameters

        Returns R

        The result of the matching function.

    const validation = Validation.Passing(42);
    const result = validation.matchWith({
      Passing: ({ value }) => value * 2,
      Failing: () => 0,
    }); // 84
    matchWithPartial: (pattern: Partial<ValidationPattern<T, void>>) => void

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

    Type declaration

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

    Settings

    Member Visibility

    On This Page

    Properties