Package fj.data

Class Validation<E,​T>

  • All Implemented Interfaces:
    java.lang.Iterable<T>

    public class Validation<E,​T>
    extends java.lang.Object
    implements java.lang.Iterable<T>
    Isomorphic to Either but has renamed functions and represents failure on the left and success on the right. This type also has accumulating functions that accept a Semigroup for binding computation while keeping error values
    • Field Detail

      • parseByte

        public static final F<java.lang.String,​Validation<java.lang.NumberFormatException,​java.lang.Byte>> parseByte
        A function that parses a string into a byte.
      • parseDouble

        public static final F<java.lang.String,​Validation<java.lang.NumberFormatException,​java.lang.Double>> parseDouble
        A function that parses a string into a double.
      • parseFloat

        public static final F<java.lang.String,​Validation<java.lang.NumberFormatException,​java.lang.Float>> parseFloat
        A function that parses a string into a float.
      • parseInt

        public static final F<java.lang.String,​Validation<java.lang.NumberFormatException,​java.lang.Integer>> parseInt
        A function that parses a string into an integer.
      • parseLong

        public static final F<java.lang.String,​Validation<java.lang.NumberFormatException,​java.lang.Long>> parseLong
        A function that parses a string into a long.
      • parseShort

        public static final F<java.lang.String,​Validation<java.lang.NumberFormatException,​java.lang.Short>> parseShort
        A function that parses a string into a short.
    • Constructor Detail

      • Validation

        protected Validation​(Either<E,​T> e)
    • Method Detail

      • isFail

        public final boolean isFail()
        Returns true if this is a failure, false otherwise.
        Returns:
        true if this is a failure, false otherwise.
      • isSuccess

        public final boolean isSuccess()
        Returns true if this is a success, false otherwise.
        Returns:
        true if this is a success, false otherwise.
      • fail

        public final E fail()
        Returns the failing value, or throws an error if there is no failing value.
        Returns:
        the failing value, or throws an error if there is no failing value.
      • success

        public final T success()
        Returns the success value, or throws an error if there is no success value.
        Returns:
        the success value, or throws an error if there is no success value.
      • validation

        public final <X> X validation​(F<E,​X> fail,
                                      F<T,​X> success)
        The catamorphism for validation. Folds over this validation breaking into left or right.
        Parameters:
        fail - The function to call if this failed.
        success - The function to call if this succeeded.
        Returns:
        The reduced value.
      • f

        public final Validation.FailProjection<E,​T> f()
        Returns a failing projection of this validation.
        Returns:
        a failing projection of this validation.
      • toEither

        public final Either<E,​T> toEither()
        Returns an either projection of this validation.
        Returns:
        An either projection of this validation.
      • successE

        public final T successE​(F0<java.lang.String> err)
        Returns the success value or fails with the given error message.
        Parameters:
        err - The error message to fail with.
        Returns:
        The success value.
      • successE

        public final T successE​(java.lang.String err)
        Returns the success value or fails with the given error message.
        Parameters:
        err - The error message to fail with.
        Returns:
        The success value.
      • orSuccess

        public final T orSuccess​(F0<T> t)
        Returns the success value or the given value.
        Parameters:
        t - The value to return if this is failure.
        Returns:
        The success value or the given value.
      • orSuccess

        public final T orSuccess​(T t)
        Returns the success value or the given value.
        Parameters:
        t - The value to return if this is failure.
        Returns:
        The success value or the given value.
      • on

        public final T on​(F<E,​T> f)
        The success value or the application of the given function to the failing value.
        Parameters:
        f - The function to execute on the failing value.
        Returns:
        The success value or the application of the given function to the failing value.
      • foreach

        public final Unit foreach​(F<T,​Unit> f)
        Executes a side-effect on the success value if there is one.
        Parameters:
        f - The side-effect to execute.
        Returns:
        The unit value.
      • foreachDoEffect

        public final void foreachDoEffect​(Effect1<T> f)
        Executes a side-effect on the success value if there is one.
        Parameters:
        f - The side-effect to execute.
      • map

        public final <A> Validation<E,​A> map​(F<T,​A> f)
        Maps the given function across the success side of this validation.
        Parameters:
        f - The function to map.
        Returns:
        A new validation with the function mapped.
      • bind

        public final <A> Validation<E,​A> bind​(F<T,​Validation<E,​A>> f)
        Binds the given function across this validation's success value if it has one.
        Parameters:
        f - The function to bind across this validation.
        Returns:
        A new validation value after binding.
      • sequence

        public final <A> Validation<E,​A> sequence​(Validation<E,​A> v)
        Anonymous bind through this validation.
        Parameters:
        v - The value to bind with.
        Returns:
        A validation after binding.
      • sequence

        public static <E,​A> Validation<E,​List<A>> sequence​(Semigroup<E> s,
                                                                       List<Validation<E,​A>> list)
        If list contains a failure, returns a failure of the reduction of all the failures using the semigroup, otherwise returns the successful list.
      • filter

        public final <A> Option<Validation<A,​T>> filter​(F<T,​java.lang.Boolean> f)
        Returns None if this is a failure or if the given predicate p does not hold for the success value, otherwise, returns a success in Some.
        Parameters:
        f - The predicate function to test on this success value.
        Returns:
        None if this is a failure or if the given predicate p does not hold for the success value, otherwise, returns a success in Some.
      • apply

        public final <A> Validation<E,​A> apply​(Validation<E,​F<T,​A>> v)
        Function application on the success value.
        Parameters:
        v - The validation of the function to apply on the success value.
        Returns:
        The result of function application in validation.
      • forall

        public final boolean forall​(F<T,​java.lang.Boolean> f)
        Returns true if this is a failure or returns the result of the application of the given function to the success value.
        Parameters:
        f - The predicate function to test on this success value.
        Returns:
        true if this is a failure or returns the result of the application of the given function to the success value.
      • exists

        public final boolean exists​(F<T,​java.lang.Boolean> f)
        Returns false if this is a failure or returns the result of the application of the given function to the success value.
        Parameters:
        f - The predicate function to test on this success value.
        Returns:
        false if this is a failure or returns the result of the application of the given function to the success value.
      • equals

        public final boolean equals​(java.lang.Object other)
        Overrides:
        equals in class java.lang.Object
      • hashCode

        public final int hashCode()
        Overrides:
        hashCode in class java.lang.Object
      • toList

        public final List<T> toList()
        Returns a single element list if this is a success value, otherwise an empty list.
        Returns:
        A single element list if this is a success value, otherwise an empty list.
      • toOption

        public final Option<T> toOption()
        Returns the success value in Some if there is one, otherwise None.
        Returns:
        The success value in Some if there is one, otherwise None.
      • toArray

        public final Array<T> toArray()
        Returns a single element array if this is a success value, otherwise an empty list.
        Returns:
        A single element array if this is a success value, otherwise an empty list.
      • toStream

        public final Stream<T> toStream()
        Returns a single element stream if this is a success value, otherwise an empty list.
        Returns:
        A single element stream if this is a success value, otherwise an empty list.
      • accumapply

        public final <A> Validation<E,​A> accumapply​(Semigroup<E> s,
                                                          Validation<E,​F<T,​A>> v)
        Function application on the successful side of this validation, or accumulating the errors on the failing side using the given semigroup should one or more be encountered.
        Parameters:
        s - The semigroup to accumulate errors with if
        v - The validating function to apply.
        Returns:
        A failing validation if this or the given validation failed (with errors accumulated if both) or a succeeding validation if both succeeded.
      • accumulate

        public final <A,​B> Validation<E,​B> accumulate​(Semigroup<E> s,
                                                                  Validation<E,​A> va,
                                                                  F<T,​F<A,​B>> f)
        Accumulates errors on the failing side of this or any given validation if one or more are encountered, or applies the given function if all succeeded and returns that value on the successful side.
        Parameters:
        s - The semigroup to accumulate errors with if one or more validations fail.
        va - The second validation to accumulate errors with if it failed.
        f - The function to apply if all validations have succeeded.
        Returns:
        A succeeding validation if all validations succeeded, or a failing validation with errors accumulated if one or more failed.
      • accumulate

        public final <A,​B> Validation<E,​B> accumulate​(Semigroup<E> s,
                                                                  Validation<E,​A> va,
                                                                  F2<T,​A,​B> f)
        Accumulates errors on the failing side of this or any given validation if one or more are encountered, or applies the given function if all succeeded and returns that value on the successful side.
        Parameters:
        s - The semigroup to accumulate errors with if one or more validations fail.
        va - The second validation to accumulate errors with if it failed.
        f - The function to apply if all validations have succeeded.
        Returns:
        A succeeding validation if all validations succeeded, or a failing validation with errors accumulated if one or more failed.
      • accumulate

        public final <A> Option<E> accumulate​(Semigroup<E> s,
                                              Validation<E,​A> va)
        Accumulates errors anonymously.
        Parameters:
        s - The semigroup to accumulate errors with if one or more validations fail.
        va - The second validation to accumulate errors with if it failed.
        Returns:
        A Some if one or more validations failed (accumulated with the semigroup), otherwise, None.
      • accumulate

        public final <A,​B,​C> Validation<E,​C> accumulate​(Semigroup<E> s,
                                                                          Validation<E,​A> va,
                                                                          Validation<E,​B> vb,
                                                                          F<T,​F<A,​F<B,​C>>> f)
        Accumulates errors on the failing side of this or any given validation if one or more are encountered, or applies the given function if all succeeded and returns that value on the successful side.
        Parameters:
        s - The semigroup to accumulate errors with if one or more validations fail.
        va - The second validation to accumulate errors with if it failed.
        vb - The third validation to accumulate errors with if it failed.
        f - The function to apply if all validations have succeeded.
        Returns:
        A succeeding validation if all validations succeeded, or a failing validation with errors accumulated if one or more failed.
      • accumulate

        public final <A,​B,​C> Validation<E,​C> accumulate​(Semigroup<E> s,
                                                                          Validation<E,​A> va,
                                                                          Validation<E,​B> vb,
                                                                          F3<T,​A,​B,​C> f)
        Accumulates errors on the failing side of this or any given validation if one or more are encountered, or applies the given function if all succeeded and returns that value on the successful side.
        Parameters:
        s - The semigroup to accumulate errors with if one or more validations fail.
        va - The second validation to accumulate errors with if it failed.
        vb - The third validation to accumulate errors with if it failed.
        f - The function to apply if all validations have succeeded.
        Returns:
        A succeeding validation if all validations succeeded, or a failing validation with errors accumulated if one or more failed.
      • accumulate

        public final <A,​B> Option<E> accumulate​(Semigroup<E> s,
                                                      Validation<E,​A> va,
                                                      Validation<E,​B> vb)
        Accumulates errors anonymously.
        Parameters:
        s - The semigroup to accumulate errors with if one or more validations fail.
        va - The second validation to accumulate errors with if it failed.
        vb - The third validation to accumulate errors with if it failed.
        Returns:
        A Some if one or more validations failed (accumulated with the semigroup), otherwise, None.
      • accumulate

        public final <A,​B,​C,​D> Validation<E,​D> accumulate​(Semigroup<E> s,
                                                                                  Validation<E,​A> va,
                                                                                  Validation<E,​B> vb,
                                                                                  Validation<E,​C> vc,
                                                                                  F<T,​F<A,​F<B,​F<C,​D>>>> f)
        Accumulates errors on the failing side of this or any given validation if one or more are encountered, or applies the given function if all succeeded and returns that value on the successful side.
        Parameters:
        s - The semigroup to accumulate errors with if one or more validations fail.
        va - The second validation to accumulate errors with if it failed.
        vb - The third validation to accumulate errors with if it failed.
        vc - The fourth validation to accumulate errors with if it failed.
        f - The function to apply if all validations have succeeded.
        Returns:
        A succeeding validation if all validations succeeded, or a failing validation with errors accumulated if one or more failed.
      • accumulate

        public final <A,​B,​C,​D> Validation<E,​D> accumulate​(Semigroup<E> s,
                                                                                  Validation<E,​A> va,
                                                                                  Validation<E,​B> vb,
                                                                                  Validation<E,​C> vc,
                                                                                  F4<T,​A,​B,​C,​D> f)
        Accumulates errors on the failing side of this or any given validation if one or more are encountered, or applies the given function if all succeeded and returns that value on the successful side.
        Parameters:
        s - The semigroup to accumulate errors with if one or more validations fail.
        va - The second validation to accumulate errors with if it failed.
        vb - The third validation to accumulate errors with if it failed.
        vc - The fourth validation to accumulate errors with if it failed.
        f - The function to apply if all validations have succeeded.
        Returns:
        A succeeding validation if all validations succeeded, or a failing validation with errors accumulated if one or more failed.
      • accumulate

        public final <A,​B,​C> Option<E> accumulate​(Semigroup<E> s,
                                                              Validation<E,​A> va,
                                                              Validation<E,​B> vb,
                                                              Validation<E,​C> vc)
        Accumulates errors anonymously.
        Parameters:
        s - The semigroup to accumulate errors with if one or more validations fail.
        va - The second validation to accumulate errors with if it failed.
        vb - The third validation to accumulate errors with if it failed.
        vc - The fourth validation to accumulate errors with if it failed.
        Returns:
        A Some if one or more validations failed (accumulated with the semigroup), otherwise, None.
      • accumulate

        public final <A,​B,​C,​D,​E$> Validation<E,​E$> accumulate​(Semigroup<E> s,
                                                                                            Validation<E,​A> va,
                                                                                            Validation<E,​B> vb,
                                                                                            Validation<E,​C> vc,
                                                                                            Validation<E,​D> vd,
                                                                                            F<T,​F<A,​F<B,​F<C,​F<D,​E$>>>>> f)
        Accumulates errors on the failing side of this or any given validation if one or more are encountered, or applies the given function if all succeeded and returns that value on the successful side.
        Parameters:
        s - The semigroup to accumulate errors with if one or more validations fail.
        va - The second validation to accumulate errors with if it failed.
        vb - The third validation to accumulate errors with if it failed.
        vc - The fourth validation to accumulate errors with if it failed.
        vd - The fifth validation to accumulate errors with if it failed.
        f - The function to apply if all validations have succeeded.
        Returns:
        A succeeding validation if all validations succeeded, or a failing validation with errors accumulated if one or more failed.
      • accumulate

        public final <A,​B,​C,​D,​E$> Validation<E,​E$> accumulate​(Semigroup<E> s,
                                                                                            Validation<E,​A> va,
                                                                                            Validation<E,​B> vb,
                                                                                            Validation<E,​C> vc,
                                                                                            Validation<E,​D> vd,
                                                                                            F5<T,​A,​B,​C,​D,​E$> f)
        Accumulates errors on the failing side of this or any given validation if one or more are encountered, or applies the given function if all succeeded and returns that value on the successful side.
        Parameters:
        s - The semigroup to accumulate errors with if one or more validations fail.
        va - The second validation to accumulate errors with if it failed.
        vb - The third validation to accumulate errors with if it failed.
        vc - The fourth validation to accumulate errors with if it failed.
        vd - The fifth validation to accumulate errors with if it failed.
        f - The function to apply if all validations have succeeded.
        Returns:
        A succeeding validation if all validations succeeded, or a failing validation with errors accumulated if one or more failed.
      • accumulate

        public final <A,​B,​C,​D> Option<E> accumulate​(Semigroup<E> s,
                                                                      Validation<E,​A> va,
                                                                      Validation<E,​B> vb,
                                                                      Validation<E,​C> vc,
                                                                      Validation<E,​D> vd)
        Accumulates errors anonymously.
        Parameters:
        s - The semigroup to accumulate errors with if one or more validations fail.
        va - The second validation to accumulate errors with if it failed.
        vb - The third validation to accumulate errors with if it failed.
        vc - The fourth validation to accumulate errors with if it failed.
        vd - The fifth validation to accumulate errors with if it failed.
        Returns:
        A Some if one or more validations failed (accumulated with the semigroup), otherwise, None.
      • accumulate

        public final <A,​B,​C,​D,​E$,​F$> Validation<E,​F$> accumulate​(Semigroup<E> s,
                                                                                                     Validation<E,​A> va,
                                                                                                     Validation<E,​B> vb,
                                                                                                     Validation<E,​C> vc,
                                                                                                     Validation<E,​D> vd,
                                                                                                     Validation<E,​E$> ve,
                                                                                                     F<T,​F<A,​F<B,​F<C,​F<D,​F<E$,​F$>>>>>> f)
        Accumulates errors on the failing side of this or any given validation if one or more are encountered, or applies the given function if all succeeded and returns that value on the successful side.
        Parameters:
        s - The semigroup to accumulate errors with if one or more validations fail.
        va - The second validation to accumulate errors with if it failed.
        vb - The third validation to accumulate errors with if it failed.
        vc - The fourth validation to accumulate errors with if it failed.
        vd - The fifth validation to accumulate errors with if it failed.
        ve - The sixth validation to accumulate errors with if it failed.
        f - The function to apply if all validations have succeeded.
        Returns:
        A succeeding validation if all validations succeeded, or a failing validation with errors accumulated if one or more failed.
      • accumulate

        public final <A,​B,​C,​D,​E$,​F$> Validation<E,​F$> accumulate​(Semigroup<E> s,
                                                                                                     Validation<E,​A> va,
                                                                                                     Validation<E,​B> vb,
                                                                                                     Validation<E,​C> vc,
                                                                                                     Validation<E,​D> vd,
                                                                                                     Validation<E,​E$> ve,
                                                                                                     F6<T,​A,​B,​C,​D,​E$,​F$> f)
        Accumulates errors on the failing side of this or any given validation if one or more are encountered, or applies the given function if all succeeded and returns that value on the successful side.
        Parameters:
        s - The semigroup to accumulate errors with if one or more validations fail.
        va - The second validation to accumulate errors with if it failed.
        vb - The third validation to accumulate errors with if it failed.
        vc - The fourth validation to accumulate errors with if it failed.
        vd - The fifth validation to accumulate errors with if it failed.
        ve - The sixth validation to accumulate errors with if it failed.
        f - The function to apply if all validations have succeeded.
        Returns:
        A succeeding validation if all validations succeeded, or a failing validation with errors accumulated if one or more failed.
      • accumulate

        public final <A,​B,​C,​D,​E$> Option<E> accumulate​(Semigroup<E> s,
                                                                               Validation<E,​A> va,
                                                                               Validation<E,​B> vb,
                                                                               Validation<E,​C> vc,
                                                                               Validation<E,​D> vd,
                                                                               Validation<E,​E$> ve)
        Accumulates errors anonymously.
        Parameters:
        s - The semigroup to accumulate errors with if one or more validations fail.
        va - The second validation to accumulate errors with if it failed.
        vb - The third validation to accumulate errors with if it failed.
        vc - The fourth validation to accumulate errors with if it failed.
        vd - The fifth validation to accumulate errors with if it failed.
        ve - The sixth validation to accumulate errors with if it failed.
        Returns:
        A Some if one or more validations failed (accumulated with the semigroup), otherwise, None.
      • accumulate

        public final <A,​B,​C,​D,​E$,​F$,​G> Validation<E,​G> accumulate​(Semigroup<E> s,
                                                                                                            Validation<E,​A> va,
                                                                                                            Validation<E,​B> vb,
                                                                                                            Validation<E,​C> vc,
                                                                                                            Validation<E,​D> vd,
                                                                                                            Validation<E,​E$> ve,
                                                                                                            Validation<E,​F$> vf,
                                                                                                            F<T,​F<A,​F<B,​F<C,​F<D,​F<E$,​F<F$,​G>>>>>>> f)
        Accumulates errors on the failing side of this or any given validation if one or more are encountered, or applies the given function if all succeeded and returns that value on the successful side.
        Parameters:
        s - The semigroup to accumulate errors with if one or more validations fail.
        va - The second validation to accumulate errors with if it failed.
        vb - The third validation to accumulate errors with if it failed.
        vc - The fourth validation to accumulate errors with if it failed.
        vd - The fifth validation to accumulate errors with if it failed.
        ve - The sixth validation to accumulate errors with if it failed.
        vf - The seventh validation to accumulate errors with if it failed.
        f - The function to apply if all validations have succeeded.
        Returns:
        A succeeding validation if all validations succeeded, or a failing validation with errors accumulated if one or more failed.
      • accumulate

        public final <A,​B,​C,​D,​E$,​F$,​G> Validation<E,​G> accumulate​(Semigroup<E> s,
                                                                                                            Validation<E,​A> va,
                                                                                                            Validation<E,​B> vb,
                                                                                                            Validation<E,​C> vc,
                                                                                                            Validation<E,​D> vd,
                                                                                                            Validation<E,​E$> ve,
                                                                                                            Validation<E,​F$> vf,
                                                                                                            F7<T,​A,​B,​C,​D,​E$,​F$,​G> f)
        Accumulates errors on the failing side of this or any given validation if one or more are encountered, or applies the given function if all succeeded and returns that value on the successful side.
        Parameters:
        s - The semigroup to accumulate errors with if one or more validations fail.
        va - The second validation to accumulate errors with if it failed.
        vb - The third validation to accumulate errors with if it failed.
        vc - The fourth validation to accumulate errors with if it failed.
        vd - The fifth validation to accumulate errors with if it failed.
        ve - The sixth validation to accumulate errors with if it failed.
        vf - The seventh validation to accumulate errors with if it failed.
        f - The function to apply if all validations have succeeded.
        Returns:
        A succeeding validation if all validations succeeded, or a failing validation with errors accumulated if one or more failed.
      • accumulate

        public final <A,​B,​C,​D,​E$,​F$> Option<E> accumulate​(Semigroup<E> s,
                                                                                        Validation<E,​A> va,
                                                                                        Validation<E,​B> vb,
                                                                                        Validation<E,​C> vc,
                                                                                        Validation<E,​D> vd,
                                                                                        Validation<E,​E$> ve,
                                                                                        Validation<E,​F$> vf)
        Accumulates errors anonymously.
        Parameters:
        s - The semigroup to accumulate errors with if one or more validations fail.
        va - The second validation to accumulate errors with if it failed.
        vb - The third validation to accumulate errors with if it failed.
        vc - The fourth validation to accumulate errors with if it failed.
        vd - The fifth validation to accumulate errors with if it failed.
        ve - The sixth validation to accumulate errors with if it failed.
        vf - The seventh validation to accumulate errors with if it failed.
        Returns:
        A Some if one or more validations failed (accumulated with the semigroup), otherwise, None.
      • accumulate

        public final <A,​B,​C,​D,​E$,​F$,​G,​H> Validation<E,​H> accumulate​(Semigroup<E> s,
                                                                                                                    Validation<E,​A> va,
                                                                                                                    Validation<E,​B> vb,
                                                                                                                    Validation<E,​C> vc,
                                                                                                                    Validation<E,​D> vd,
                                                                                                                    Validation<E,​E$> ve,
                                                                                                                    Validation<E,​F$> vf,
                                                                                                                    Validation<E,​G> vg,
                                                                                                                    F<T,​F<A,​F<B,​F<C,​F<D,​F<E$,​F<F$,​F<G,​H>>>>>>>> f)
        Accumulates errors on the failing side of this or any given validation if one or more are encountered, or applies the given function if all succeeded and returns that value on the successful side.
        Parameters:
        s - The semigroup to accumulate errors with if one or more validations fail.
        va - The second validation to accumulate errors with if it failed.
        vb - The third validation to accumulate errors with if it failed.
        vc - The fourth validation to accumulate errors with if it failed.
        vd - The fifth validation to accumulate errors with if it failed.
        ve - The sixth validation to accumulate errors with if it failed.
        vf - The seventh validation to accumulate errors with if it failed.
        vg - The eighth validation to accumulate errors with if it failed.
        f - The function to apply if all validations have succeeded.
        Returns:
        A succeeding validation if all validations succeeded, or a failing validation with errors accumulated if one or more failed.
      • accumulate

        public final <A,​B,​C,​D,​E$,​F$,​G,​H> Validation<E,​H> accumulate​(Semigroup<E> s,
                                                                                                                    Validation<E,​A> va,
                                                                                                                    Validation<E,​B> vb,
                                                                                                                    Validation<E,​C> vc,
                                                                                                                    Validation<E,​D> vd,
                                                                                                                    Validation<E,​E$> ve,
                                                                                                                    Validation<E,​F$> vf,
                                                                                                                    Validation<E,​G> vg,
                                                                                                                    F8<T,​A,​B,​C,​D,​E$,​F$,​G,​H> f)
        Accumulates errors on the failing side of this or any given validation if one or more are encountered, or applies the given function if all succeeded and returns that value on the successful side.
        Parameters:
        s - The semigroup to accumulate errors with if one or more validations fail.
        va - The second validation to accumulate errors with if it failed.
        vb - The third validation to accumulate errors with if it failed.
        vc - The fourth validation to accumulate errors with if it failed.
        vd - The fifth validation to accumulate errors with if it failed.
        ve - The sixth validation to accumulate errors with if it failed.
        vf - The seventh validation to accumulate errors with if it failed.
        vg - The eighth validation to accumulate errors with if it failed.
        f - The function to apply if all validations have succeeded.
        Returns:
        A succeeding validation if all validations succeeded, or a failing validation with errors accumulated if one or more failed.
      • accumulate

        public final <A,​B,​C,​D,​E$,​F$,​G> Option<E> accumulate​(Semigroup<E> s,
                                                                                                Validation<E,​A> va,
                                                                                                Validation<E,​B> vb,
                                                                                                Validation<E,​C> vc,
                                                                                                Validation<E,​D> vd,
                                                                                                Validation<E,​E$> ve,
                                                                                                Validation<E,​F$> vf,
                                                                                                Validation<E,​G> vg)
        Accumulates errors anonymously.
        Parameters:
        s - The semigroup to accumulate errors with if one or more validations fail.
        va - The second validation to accumulate errors with if it failed.
        vb - The third validation to accumulate errors with if it failed.
        vc - The fourth validation to accumulate errors with if it failed.
        vd - The fifth validation to accumulate errors with if it failed.
        ve - The sixth validation to accumulate errors with if it failed.
        vf - The seventh validation to accumulate errors with if it failed.
        vg - The eighth validation to accumulate errors with if it failed.
        Returns:
        A Some if one or more validations failed (accumulated with the semigroup), otherwise, None.
      • iterator

        public final java.util.Iterator<T> iterator()
        Returns an iterator for this validation. This method exists to permit the use in a for-each loop.
        Specified by:
        iterator in interface java.lang.Iterable<E>
        Returns:
        A iterator for this validation.
      • accumulate

        public final <B> Validation<List<E>,​B> accumulate​(F<T,​B> f)
      • sequenceNonCumulative

        public static <A,​E> Validation<List<E>,​List<A>> sequenceNonCumulative​(List<Validation<E,​A>> list)
        If the list contains a failure, returns a Validation of the list of fails in the list, otherwise returns a successful Validation with the list of successful values. Does not accumulate the failures into a single failure using a semigroup.
      • sequenceEitherLeft

        public static final <E,​R,​C> Either<Validation<E,​C>,​R> sequenceEitherLeft​(Validation<E,​Either<C,​R>> validation)
        Sequence the given validation and collect the output on the left side of an either.
        Type Parameters:
        E - the type of the failure value
        R - the type of the right value
        C - the type of the left value
        Parameters:
        validation - the given validation
        Returns:
        the either
      • sequenceEitherRight

        public static final <E,​L,​C> Either<L,​Validation<E,​C>> sequenceEitherRight​(Validation<E,​Either<L,​C>> validation)
        Sequence the given validation and collect the output on the right side of an either.
        Type Parameters:
        E - the type of the failure value
        C - the type of the right value
        L - the type of the left value
        Parameters:
        validation - the given validation
        Returns:
        the either
      • sequenceF

        public static final <E,​C,​B> F<C,​Validation<E,​B>> sequenceF​(Validation<E,​F<C,​B>> validation)
        Sequence the given validation and collect the output as a function.
        Type Parameters:
        E - the type of the failure value
        C - the type of input value
        B - the type of output value
        Parameters:
        validation - the given validation
        Returns:
        the function
      • sequenceIO

        public static final <E,​C> IO<Validation<E,​C>> sequenceIO​(Validation<E,​IO<C>> validation)
        Sequence the given validation and collect the output as an IO.
        Type Parameters:
        E - the type of the failure value
        C - the type of the IO value
        Parameters:
        validation - the given validation
        Returns:
        the IO
      • sequenceList

        public static final <E,​C> List<Validation<E,​C>> sequenceList​(Validation<E,​List<C>> validation)
        Sequence the given validation and collect the output as a list.
        Type Parameters:
        E - the type of the failure value
        C - the type of the list value
        Parameters:
        validation - the given validation
        Returns:
        the list
      • sequenceOption

        public static final <E,​C> Option<Validation<E,​C>> sequenceOption​(Validation<E,​Option<C>> validation)
        Sequence the given validation and collect the output as an option.
        Type Parameters:
        E - the type of the failure value
        C - the type of the option value
        Parameters:
        validation - the given validation
        Returns:
        the option
      • sequenceP1

        public static final <E,​C> P1<Validation<E,​C>> sequenceP1​(Validation<E,​P1<C>> validation)
        Sequence the given validation and collect the output as a P1.
        Type Parameters:
        E - the type of the failure value
        C - the type of the P1 value
        Parameters:
        validation - the given validation
        Returns:
        the P1
      • sequenceSeq

        public static final <E,​C> Seq<Validation<E,​C>> sequenceSeq​(Validation<E,​Seq<C>> validation)
        Sequence the given validation and collect the output as a seq.
        Type Parameters:
        E - the type of the failure value
        C - the type of the seq value
        Parameters:
        validation - the given validation
        Returns:
        the seq
      • sequenceSet

        public static final <E,​C> Set<Validation<E,​C>> sequenceSet​(Ord<E> ordE,
                                                                               Ord<C> ordC,
                                                                               Validation<E,​Set<C>> validation)
        Sequence the given validation and collect the output as a set.
        Type Parameters:
        E - the type of the failure value
        C - the type of the set value
        Parameters:
        ordE - the given failure value ord
        ordC - the given success value ord
        validation - the given validation
        Returns:
        the set
      • sequenceStream

        public static final <E,​C> Stream<Validation<E,​C>> sequenceStream​(Validation<E,​Stream<C>> validation)
        Sequence the given validation and collect the output as a stream.
        Type Parameters:
        E - the type of the failure value
        C - the type of the stream value
        Parameters:
        validation - the given validation
        Returns:
        the stream
      • sequenceTrampoline

        public static final <E,​C> Trampoline<Validation<E,​C>> sequenceTrampoline​(Validation<E,​Trampoline<C>> validation)
        Sequence the given validation and collect the output as a trampoline.
        Type Parameters:
        E - the type of the failure value
        C - the type of the trampoline value
        Parameters:
        validation - the given validation
        Returns:
        the trampoline
      • sequenceValidation

        public static final <E,​E1,​C> Validation<E1,​Validation<E,​C>> sequenceValidation​(Validation<E,​Validation<E1,​C>> validation)
        Sequence the given validation and collect the output as a validation.
        Type Parameters:
        E - the type of the failure value
        E1 - the type of the failure value
        C - the type of the success value
        Parameters:
        validation - the given validation
        Returns:
        the validation
      • traverseEitherLeft

        public final <R,​C> Either<Validation<E,​C>,​R> traverseEitherLeft​(F<T,​Either<C,​R>> f)
        Traverse this validation with the given function and collect the output on the left side of an either.
        Type Parameters:
        C - the type of the left value
        R - the type of the right value
        Parameters:
        f - the given function
        Returns:
        the list
      • traverseEitherRight

        public final <L,​C> Either<L,​Validation<E,​C>> traverseEitherRight​(F<T,​Either<L,​C>> f)
        Traverse this validation with the given function and collect the output on the right side of an either.
        Type Parameters:
        L - the type of the left value
        C - the type of the right value
        Parameters:
        f - the given function
        Returns:
        the list
      • traverseF

        public final <C,​B> F<C,​Validation<E,​B>> traverseF​(F<T,​F<C,​B>> f)
        Traverse this validation with the given function and collect the output as a function.
        Type Parameters:
        C - the type of the input value
        B - the type of the output value
        Parameters:
        f - the given function
        Returns:
        the function
      • traverseIO

        public final <C> IO<Validation<E,​C>> traverseIO​(F<T,​IO<C>> f)
        Traverse this validation with the given function and collect the output as an IO.
        Type Parameters:
        C - the type of the IO value
        Parameters:
        f - the given function
        Returns:
        the IO
      • traverseList

        public final <C> List<Validation<E,​C>> traverseList​(F<T,​List<C>> f)
        Traverse this validation with the given function and collect the output as a list.
        Type Parameters:
        C - the type of the list value
        Parameters:
        f - the given function
        Returns:
        the list
      • traverseOption

        public final <C> Option<Validation<E,​C>> traverseOption​(F<T,​Option<C>> f)
        Traverse this validation with the given function and collect the output as an option.
        Type Parameters:
        C - the type of the option value
        Parameters:
        f - the given function
        Returns:
        the option
      • traverseP1

        public final <C> P1<Validation<E,​C>> traverseP1​(F<T,​P1<C>> f)
        Traverse this validation with the given function and collect the output as a P1.
        Type Parameters:
        C - the type of the P1 value
        Parameters:
        f - the given function
        Returns:
        the P1
      • traverseSeq

        public final <C> Seq<Validation<E,​C>> traverseSeq​(F<T,​Seq<C>> f)
        Traverse this validation with the given function and collect the output as a seq.
        Type Parameters:
        C - the type of the seq value
        Parameters:
        f - the given function
        Returns:
        the seq
      • traverseSet

        public final <C> Set<Validation<E,​C>> traverseSet​(Ord<E> ordE,
                                                                Ord<C> ordC,
                                                                F<T,​Set<C>> f)
        Traverse this validation with the given function and collect the output as a set; use the given success and failure value ords to order the set.
        Type Parameters:
        C - the type of the set value
        Parameters:
        ordE - the given failure value ord
        ordC - the given success value ord
        f - the given function
        Returns:
        the set
      • traverseStream

        public final <C> Stream<Validation<E,​C>> traverseStream​(F<T,​Stream<C>> f)
        Traverse this validation with the given function and collect the output as a stream.
        Type Parameters:
        C - the type of the stream value
        Parameters:
        f - the given function
        Returns:
        the stream
      • traverseTrampoline

        public final <C> Trampoline<Validation<E,​C>> traverseTrampoline​(F<T,​Trampoline<C>> f)
        Traverse this validation with the given function and collect the output as a trampoline.
        Type Parameters:
        C - the type of the trampoline value
        Parameters:
        f - the given function
        Returns:
        the trampoline
      • traverseValidation

        public final <E1,​C> Validation<E1,​Validation<E,​C>> traverseValidation​(F<T,​Validation<E1,​C>> f)
        Traverse this validation with the given function and collect the output as a validation.
        Type Parameters:
        E1 - the type of the failure value
        C - the type of the seq value
        Parameters:
        f - the given function
        Returns:
        the validation
      • successes

        public static <A,​E> List<A> successes​(List<Validation<E,​A>> list)
      • nel

        public final Validation<NonEmptyList<E>,​T> nel()
        Puts this validation's failing value in a non-empty list if there is one.
        Returns:
        A validation with its failing value in a non-empty list if there is one.
      • validation

        public static <E,​T> Validation<E,​T> validation​(Either<E,​T> e)
        Construct a validation using the given either value.
        Parameters:
        e - The either value to construct a validation with.
        Returns:
        A validation using the given either value.
      • validation

        public static <E,​T> F<Either<E,​T>,​Validation<E,​T>> validation()
        Returns a function that constructs a validation with an either.
        Returns:
        A function that constructs a validation with an either.
      • either

        public static <E,​T> F<Validation<E,​T>,​Either<E,​T>> either()
        Returns a function that constructs an either with a validation.
        Returns:
        A function that constructs an either with a validation.
      • success

        public static <E,​T> Validation<E,​T> success​(T t)
        Returns a succeeding validation containing the given value.
        Parameters:
        t - The value to use in the succeeding validation.
        Returns:
        A succeeding validation containing the given value.
      • fail

        public static <E,​T> Validation<E,​T> fail​(E e)
        Returns a failing validation containing the given value.
        Parameters:
        e - The value to use in the failing validation.
        Returns:
        A failing validation containing the given value.
      • failNEL

        public static <E,​T> Validation<NonEmptyList<E>,​T> failNEL​(E e)
        Returns a failing validation containing a non-empty list that contains the given value.
        Parameters:
        e - The value to use in a non-empty list for the failing validation.
        Returns:
        A failing validation containing a non-empty list that contains the given value.
      • condition

        public static <E,​T> Validation<E,​T> condition​(boolean c,
                                                                  E e,
                                                                  T t)
        Returns a validation based on a boolean condition. If the condition is true, the validation succeeds, otherwise it fails.
        Parameters:
        c - The condition to base the returned validation on.
        e - The failing value to use if the condition is false.
        t - The succeeding value to use if the condition is true.
        Returns:
        A validation based on a boolean condition.
      • parseByte

        public static Validation<java.lang.NumberFormatException,​java.lang.Byte> parseByte​(java.lang.String s)
        Parses the given string into a byte.
        Parameters:
        s - The string to parse.
        Returns:
        A successfully parse byte or a failing exception.
      • parseDouble

        public static Validation<java.lang.NumberFormatException,​java.lang.Double> parseDouble​(java.lang.String s)
        Parses the given string into a double.
        Parameters:
        s - The string to parse.
        Returns:
        A successfully parse double or a failing exception.
      • parseFloat

        public static Validation<java.lang.NumberFormatException,​java.lang.Float> parseFloat​(java.lang.String s)
        Parses the given string into a float.
        Parameters:
        s - The string to parse.
        Returns:
        A successfully parse float or a failing exception.
      • parseInt

        public static Validation<java.lang.NumberFormatException,​java.lang.Integer> parseInt​(java.lang.String s)
        Parses the given string into a integer.
        Parameters:
        s - The string to parse.
        Returns:
        A successfully parse integer or a failing exception.
      • parseLong

        public static Validation<java.lang.NumberFormatException,​java.lang.Long> parseLong​(java.lang.String s)
        Parses the given string into a long.
        Parameters:
        s - The string to parse.
        Returns:
        A successfully parse long or a failing exception.
      • parseShort

        public static Validation<java.lang.NumberFormatException,​java.lang.Short> parseShort​(java.lang.String s)
        Parses the given string into a short.
        Parameters:
        s - The string to parse.
        Returns:
        A successfully parse short or a failing exception.
      • partition

        public static <A,​B> P2<List<A>,​List<B>> partition​(List<Validation<A,​B>> list)
        Partitions the list into the list of fails and the list of successes
      • toString

        public final java.lang.String toString()
        Overrides:
        toString in class java.lang.Object