{-# LANGUAGE DeriveAnyClass #-}
{-# LANGUAGE DeriveDataTypeable #-}
{-# language DerivingStrategies #-}
{-# language DeriveGeneric #-}
{-# language LambdaCase #-}
module Validation.Micro (
Validation (..)
, isFailure
, isSuccess
, validation
, failures
, successes
, partitionValidations
, fromFailure
, fromSuccess
, bindValidation
, failure
, failureIf
, failureUnless
, validationToEither
, eitherToValidation
, validateAll
, whenSuccess
, whenFailure
, whenSuccess_
, whenFailure_
, whenSuccessM
, whenFailureM
, whenSuccessM_
, whenFailureM_
, failureToMaybe
, successToMaybe
, maybeToFailure
, maybeToSuccess
) where
import Control.Applicative (Alternative (..), Applicative (..))
import Data.Bifoldable (Bifoldable (..))
import Data.Bifunctor (Bifunctor (..))
import Data.Bitraversable (Bitraversable (..))
import Data.Data (Data)
import Control.DeepSeq (NFData, NFData1, NFData2(..))
import Data.Foldable (Foldable (..))
import Data.List.NonEmpty (NonEmpty (..))
import GHC.Generics (Generic(..), Generic1(..))
data Validation e a
= Failure e
| Success a
deriving stock (Validation e a -> Validation e a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall e a.
(Eq e, Eq a) =>
Validation e a -> Validation e a -> Bool
/= :: Validation e a -> Validation e a -> Bool
$c/= :: forall e a.
(Eq e, Eq a) =>
Validation e a -> Validation e a -> Bool
== :: Validation e a -> Validation e a -> Bool
$c== :: forall e a.
(Eq e, Eq a) =>
Validation e a -> Validation e a -> Bool
Eq, Validation e a -> Validation e a -> Bool
Validation e a -> Validation e a -> Ordering
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall {e} {a}. (Ord e, Ord a) => Eq (Validation e a)
forall e a.
(Ord e, Ord a) =>
Validation e a -> Validation e a -> Bool
forall e a.
(Ord e, Ord a) =>
Validation e a -> Validation e a -> Ordering
forall e a.
(Ord e, Ord a) =>
Validation e a -> Validation e a -> Validation e a
min :: Validation e a -> Validation e a -> Validation e a
$cmin :: forall e a.
(Ord e, Ord a) =>
Validation e a -> Validation e a -> Validation e a
max :: Validation e a -> Validation e a -> Validation e a
$cmax :: forall e a.
(Ord e, Ord a) =>
Validation e a -> Validation e a -> Validation e a
>= :: Validation e a -> Validation e a -> Bool
$c>= :: forall e a.
(Ord e, Ord a) =>
Validation e a -> Validation e a -> Bool
> :: Validation e a -> Validation e a -> Bool
$c> :: forall e a.
(Ord e, Ord a) =>
Validation e a -> Validation e a -> Bool
<= :: Validation e a -> Validation e a -> Bool
$c<= :: forall e a.
(Ord e, Ord a) =>
Validation e a -> Validation e a -> Bool
< :: Validation e a -> Validation e a -> Bool
$c< :: forall e a.
(Ord e, Ord a) =>
Validation e a -> Validation e a -> Bool
compare :: Validation e a -> Validation e a -> Ordering
$ccompare :: forall e a.
(Ord e, Ord a) =>
Validation e a -> Validation e a -> Ordering
Ord, Int -> Validation e a -> ShowS
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall e a. (Show e, Show a) => Int -> Validation e a -> ShowS
forall e a. (Show e, Show a) => [Validation e a] -> ShowS
forall e a. (Show e, Show a) => Validation e a -> String
showList :: [Validation e a] -> ShowS
$cshowList :: forall e a. (Show e, Show a) => [Validation e a] -> ShowS
show :: Validation e a -> String
$cshow :: forall e a. (Show e, Show a) => Validation e a -> String
showsPrec :: Int -> Validation e a -> ShowS
$cshowsPrec :: forall e a. (Show e, Show a) => Int -> Validation e a -> ShowS
Show, forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall e a x. Rep (Validation e a) x -> Validation e a
forall e a x. Validation e a -> Rep (Validation e a) x
$cto :: forall e a x. Rep (Validation e a) x -> Validation e a
$cfrom :: forall e a x. Validation e a -> Rep (Validation e a) x
Generic, forall e a. Rep1 (Validation e) a -> Validation e a
forall e a. Validation e a -> Rep1 (Validation e) a
forall k (f :: k -> *).
(forall (a :: k). f a -> Rep1 f a)
-> (forall (a :: k). Rep1 f a -> f a) -> Generic1 f
$cto1 :: forall e a. Rep1 (Validation e) a -> Validation e a
$cfrom1 :: forall e a. Validation e a -> Rep1 (Validation e) a
Generic1, Validation e a -> DataType
Validation e a -> Constr
forall a.
Typeable a
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall {e} {a}. (Data e, Data a) => Typeable (Validation e a)
forall e a. (Data e, Data a) => Validation e a -> DataType
forall e a. (Data e, Data a) => Validation e a -> Constr
forall e a.
(Data e, Data a) =>
(forall b. Data b => b -> b) -> Validation e a -> Validation e a
forall e a u.
(Data e, Data a) =>
Int -> (forall d. Data d => d -> u) -> Validation e a -> u
forall e a u.
(Data e, Data a) =>
(forall d. Data d => d -> u) -> Validation e a -> [u]
forall e a r r'.
(Data e, Data a) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Validation e a -> r
forall e a r r'.
(Data e, Data a) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Validation e a -> r
forall e a (m :: * -> *).
(Data e, Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> Validation e a -> m (Validation e a)
forall e a (m :: * -> *).
(Data e, Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> Validation e a -> m (Validation e a)
forall e a (c :: * -> *).
(Data e, Data a) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Validation e a)
forall e a (c :: * -> *).
(Data e, Data a) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Validation e a -> c (Validation e a)
forall e a (t :: * -> *) (c :: * -> *).
(Data e, Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Validation e a))
forall e a (t :: * -> * -> *) (c :: * -> *).
(Data e, Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Validation e a))
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Validation e a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Validation e a -> c (Validation e a)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Validation e a))
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> Validation e a -> m (Validation e a)
$cgmapMo :: forall e a (m :: * -> *).
(Data e, Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> Validation e a -> m (Validation e a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> Validation e a -> m (Validation e a)
$cgmapMp :: forall e a (m :: * -> *).
(Data e, Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> Validation e a -> m (Validation e a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> Validation e a -> m (Validation e a)
$cgmapM :: forall e a (m :: * -> *).
(Data e, Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> Validation e a -> m (Validation e a)
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> Validation e a -> u
$cgmapQi :: forall e a u.
(Data e, Data a) =>
Int -> (forall d. Data d => d -> u) -> Validation e a -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Validation e a -> [u]
$cgmapQ :: forall e a u.
(Data e, Data a) =>
(forall d. Data d => d -> u) -> Validation e a -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Validation e a -> r
$cgmapQr :: forall e a r r'.
(Data e, Data a) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Validation e a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Validation e a -> r
$cgmapQl :: forall e a r r'.
(Data e, Data a) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Validation e a -> r
gmapT :: (forall b. Data b => b -> b) -> Validation e a -> Validation e a
$cgmapT :: forall e a.
(Data e, Data a) =>
(forall b. Data b => b -> b) -> Validation e a -> Validation e a
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Validation e a))
$cdataCast2 :: forall e a (t :: * -> * -> *) (c :: * -> *).
(Data e, Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Validation e a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Validation e a))
$cdataCast1 :: forall e a (t :: * -> *) (c :: * -> *).
(Data e, Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Validation e a))
dataTypeOf :: Validation e a -> DataType
$cdataTypeOf :: forall e a. (Data e, Data a) => Validation e a -> DataType
toConstr :: Validation e a -> Constr
$ctoConstr :: forall e a. (Data e, Data a) => Validation e a -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Validation e a)
$cgunfold :: forall e a (c :: * -> *).
(Data e, Data a) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Validation e a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Validation e a -> c (Validation e a)
$cgfoldl :: forall e a (c :: * -> *).
(Data e, Data a) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Validation e a -> c (Validation e a)
Data)
deriving anyclass (forall a. (a -> ()) -> NFData a
forall e a. (NFData e, NFData a) => Validation e a -> ()
rnf :: Validation e a -> ()
$crnf :: forall e a. (NFData e, NFData a) => Validation e a -> ()
NFData, forall e a. NFData e => (a -> ()) -> Validation e a -> ()
forall (f :: * -> *).
(forall a. (a -> ()) -> f a -> ()) -> NFData1 f
liftRnf :: forall a. (a -> ()) -> Validation e a -> ()
$cliftRnf :: forall e a. NFData e => (a -> ()) -> Validation e a -> ()
NFData1)
instance Functor (Validation e) where
fmap :: forall a b. (a -> b) -> Validation e a -> Validation e b
fmap a -> b
_ (Failure e
e) = forall e a. e -> Validation e a
Failure e
e
fmap a -> b
f (Success a
a) = forall e a. a -> Validation e a
Success (a -> b
f a
a)
{-# INLINE fmap #-}
a
x <$ :: forall a b. a -> Validation e b -> Validation e a
<$ Success b
_ = forall e a. a -> Validation e a
Success a
x
a
_ <$ Failure e
e = forall e a. e -> Validation e a
Failure e
e
{-# INLINE (<$) #-}
instance (Semigroup e, Semigroup a) => Semigroup (Validation e a) where
<> :: Validation e a -> Validation e a -> Validation e a
(<>) = forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 forall a. Semigroup a => a -> a -> a
(<>)
{-# INLINE (<>) #-}
instance (Semigroup e, Monoid a) => Monoid (Validation e a) where
mempty :: Validation e a
mempty = forall e a. a -> Validation e a
Success forall a. Monoid a => a
mempty
{-# INLINE mempty #-}
mappend :: Validation e a -> Validation e a -> Validation e a
mappend = forall a. Semigroup a => a -> a -> a
(<>)
{-# INLINE mappend #-}
instance Semigroup e => Applicative (Validation e) where
pure :: forall a. a -> Validation e a
pure = forall e a. a -> Validation e a
Success
{-# INLINE pure #-}
Failure e
e1 <*> :: forall a b.
Validation e (a -> b) -> Validation e a -> Validation e b
<*> Validation e a
b = forall e a. e -> Validation e a
Failure forall a b. (a -> b) -> a -> b
$ case Validation e a
b of
Failure e
e2 -> e
e1 forall a. Semigroup a => a -> a -> a
<> e
e2
Success a
_ -> e
e1
Success a -> b
_ <*> Failure e
e = forall e a. e -> Validation e a
Failure e
e
Success a -> b
f <*> Success a
a = forall e a. a -> Validation e a
Success (a -> b
f a
a)
{-# INLINE (<*>) #-}
Failure e
e1 *> :: forall a b. Validation e a -> Validation e b -> Validation e b
*> Validation e b
b = forall e a. e -> Validation e a
Failure forall a b. (a -> b) -> a -> b
$ case Validation e b
b of
Failure e
e2 -> e
e1 forall a. Semigroup a => a -> a -> a
<> e
e2
Success b
_ -> e
e1
Success a
_ *> Failure e
e = forall e a. e -> Validation e a
Failure e
e
Success a
_ *> Success b
b = forall e a. a -> Validation e a
Success b
b
{-# INLINE (*>) #-}
Failure e
e1 <* :: forall a b. Validation e a -> Validation e b -> Validation e a
<* Validation e b
b = forall e a. e -> Validation e a
Failure forall a b. (a -> b) -> a -> b
$ case Validation e b
b of
Failure e
e2 -> e
e1 forall a. Semigroup a => a -> a -> a
<> e
e2
Success b
_ -> e
e1
Success a
_ <* Failure e
e = forall e a. e -> Validation e a
Failure e
e
Success a
a <* Success b
_ = forall e a. a -> Validation e a
Success a
a
{-# INLINE (<*) #-}
liftA2 :: forall a b c.
(a -> b -> c) -> Validation e a -> Validation e b -> Validation e c
liftA2 a -> b -> c
_ (Failure e
e1) Validation e b
b = forall e a. e -> Validation e a
Failure forall a b. (a -> b) -> a -> b
$ case Validation e b
b of
Failure e
e2 -> e
e1 forall a. Semigroup a => a -> a -> a
<> e
e2
Success b
_ -> e
e1
liftA2 a -> b -> c
_ (Success a
_) (Failure e
e) = forall e a. e -> Validation e a
Failure e
e
liftA2 a -> b -> c
f (Success a
a) (Success b
b) = forall e a. a -> Validation e a
Success (a -> b -> c
f a
a b
b)
{-# INLINE liftA2 #-}
bindValidation :: Validation e a -> (a -> Validation e b) -> Validation e b
bindValidation :: forall e a b.
Validation e a -> (a -> Validation e b) -> Validation e b
bindValidation Validation e a
v a -> Validation e b
f = case Validation e a
v of
Failure e
e -> forall e a. e -> Validation e a
Failure e
e
Success a
a -> a -> Validation e b
f a
a
instance (Monoid e) => Alternative (Validation e) where
empty :: forall a. Validation e a
empty = forall e a. e -> Validation e a
Failure forall a. Monoid a => a
mempty
{-# INLINE empty #-}
s :: Validation e a
s@Success{} <|> :: forall a. Validation e a -> Validation e a -> Validation e a
<|> Validation e a
_ = Validation e a
s
Validation e a
_ <|> s :: Validation e a
s@Success{} = Validation e a
s
Failure e
e <|> Failure e
e' = forall e a. e -> Validation e a
Failure (e
e forall a. Semigroup a => a -> a -> a
<> e
e')
{-# INLINE (<|>) #-}
instance Foldable (Validation e) where
fold :: forall m. Monoid m => Validation e m -> m
fold = \case
Failure e
_ -> forall a. Monoid a => a
mempty
Success m
a -> m
a
{-# INLINE fold #-}
foldMap :: forall m a. Monoid m => (a -> m) -> Validation e a -> m
foldMap a -> m
f = \case
Failure e
_ -> forall a. Monoid a => a
mempty
Success a
a -> a -> m
f a
a
{-# INLINE foldMap #-}
foldr :: forall a b. (a -> b -> b) -> b -> Validation e a -> b
foldr a -> b -> b
f b
x = \case
Failure e
_ -> b
x
Success a
a -> a -> b -> b
f a
a b
x
{-# INLINE foldr #-}
foldr' :: forall a b. (a -> b -> b) -> b -> Validation e a -> b
foldr' = forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr
{-# INLINE foldr' #-}
foldl :: forall b a. (b -> a -> b) -> b -> Validation e a -> b
foldl b -> a -> b
f b
x = \case
Failure e
_ -> b
x
Success a
a -> b -> a -> b
f b
x a
a
{-# INLINE foldl #-}
foldl' :: forall b a. (b -> a -> b) -> b -> Validation e a -> b
foldl' = forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl
{-# INLINE foldl' #-}
toList :: forall a. Validation e a -> [a]
toList = \case
Failure e
_ -> []
Success a
a -> [a
a]
{-# INLINE toList #-}
null :: forall a. Validation e a -> Bool
null = \case
Failure e
_ -> Bool
True
Success a
_ -> Bool
False
{-# INLINE null #-}
length :: forall a. Validation e a -> Int
length = \case
Failure e
_ -> Int
0
Success a
_ -> Int
1
{-# INLINE length #-}
elem :: forall a. Eq a => a -> Validation e a -> Bool
elem a
x = \case
Failure e
_ -> Bool
False
Success a
a -> a
x forall a. Eq a => a -> a -> Bool
== a
a
{-# INLINE elem #-}
sum :: forall a. Num a => Validation e a -> a
sum = \case
Failure e
_ -> a
0
Success a
a -> a
a
{-# INLINE sum #-}
product :: forall a. Num a => Validation e a -> a
product = \case
Failure e
_ -> a
1
Success a
a -> a
a
{-# INLINE product #-}
instance Traversable (Validation e) where
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Validation e a -> f (Validation e b)
traverse a -> f b
f (Success a
a) = forall e a. a -> Validation e a
Success forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> f b
f a
a
traverse a -> f b
_ (Failure e
e) = forall (f :: * -> *) a. Applicative f => a -> f a
pure (forall e a. e -> Validation e a
Failure e
e)
{-# INLINE traverse #-}
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
Validation e (f a) -> f (Validation e a)
sequenceA = \case
Failure e
e -> forall (f :: * -> *) a. Applicative f => a -> f a
pure (forall e a. e -> Validation e a
Failure e
e)
Success f a
f -> forall e a. a -> Validation e a
Success forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> f a
f
{-# INLINE sequenceA #-}
instance Bifunctor Validation where
bimap :: forall a b c d.
(a -> b) -> (c -> d) -> Validation a c -> Validation b d
bimap a -> b
f c -> d
_ (Failure a
e) = forall e a. e -> Validation e a
Failure (a -> b
f a
e)
bimap a -> b
_ c -> d
g (Success c
a) = forall e a. a -> Validation e a
Success (c -> d
g c
a)
{-# INLINE bimap #-}
first :: forall a b c. (a -> b) -> Validation a c -> Validation b c
first a -> b
f (Failure a
e) = forall e a. e -> Validation e a
Failure (a -> b
f a
e)
first a -> b
_ (Success c
a) = forall e a. a -> Validation e a
Success c
a
{-# INLINE first #-}
second :: forall b c a. (b -> c) -> Validation a b -> Validation a c
second b -> c
_ (Failure a
e) = forall e a. e -> Validation e a
Failure a
e
second b -> c
g (Success b
a) = forall e a. a -> Validation e a
Success (b -> c
g b
a)
{-# INLINE second #-}
instance Bifoldable Validation where
bifoldMap :: forall m a b.
Monoid m =>
(a -> m) -> (b -> m) -> Validation a b -> m
bifoldMap a -> m
f b -> m
_ (Failure a
e) = a -> m
f a
e
bifoldMap a -> m
_ b -> m
g (Success b
a) = b -> m
g b
a
{-# INLINE bifoldMap #-}
instance Bitraversable Validation where
bitraverse :: forall (f :: * -> *) a c b d.
Applicative f =>
(a -> f c) -> (b -> f d) -> Validation a b -> f (Validation c d)
bitraverse a -> f c
f b -> f d
_ (Failure a
e) = forall e a. e -> Validation e a
Failure forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> f c
f a
e
bitraverse a -> f c
_ b -> f d
g (Success b
a) = forall e a. a -> Validation e a
Success forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> b -> f d
g b
a
{-# INLINE bitraverse #-}
instance NFData2 Validation where
liftRnf2 :: forall a b. (a -> ()) -> (b -> ()) -> Validation a b -> ()
liftRnf2 a -> ()
f b -> ()
_s (Failure a
x) = a -> ()
f a
x
liftRnf2 a -> ()
_f b -> ()
s (Success b
y) = b -> ()
s b
y
validationToEither :: Validation e a -> Either e a
validationToEither :: forall e a. Validation e a -> Either e a
validationToEither = \case
Failure e
e -> forall a b. a -> Either a b
Left e
e
Success a
a -> forall a b. b -> Either a b
Right a
a
{-# INLINE validationToEither #-}
eitherToValidation :: Either e a -> Validation e a
eitherToValidation :: forall e a. Either e a -> Validation e a
eitherToValidation = \case
Left e
e -> forall e a. e -> Validation e a
Failure e
e
Right a
a -> forall e a. a -> Validation e a
Success a
a
{-# INLINE eitherToValidation #-}
isFailure :: Validation e a -> Bool
isFailure :: forall e a. Validation e a -> Bool
isFailure = \case
Failure e
_ -> Bool
True
Success a
_ -> Bool
False
isSuccess :: Validation e a -> Bool
isSuccess :: forall e a. Validation e a -> Bool
isSuccess = \case
Success a
_ -> Bool
True
Failure e
_ -> Bool
False
validation :: (e -> x) -> (a -> x) -> Validation e a -> x
validation :: forall e x a. (e -> x) -> (a -> x) -> Validation e a -> x
validation e -> x
fe a -> x
fa = \case
Success a
a -> a -> x
fa a
a
Failure e
e -> e -> x
fe e
e
failures :: [Validation e a] -> [e]
failures :: forall e a. [Validation e a] -> [e]
failures [Validation e a]
v = [e
e | Failure e
e <- [Validation e a]
v]
{-# INLINE failures #-}
successes :: [Validation e a] -> [a]
successes :: forall e a. [Validation e a] -> [a]
successes [Validation e a]
v = [a
a | Success a
a <- [Validation e a]
v]
{-# INLINE successes #-}
partitionValidations :: [Validation e a] -> ([e], [a])
partitionValidations :: forall e a. [Validation e a] -> ([e], [a])
partitionValidations = forall e a. [Validation e a] -> ([e], [a])
go
where
go :: [Validation e a] -> ([e], [a])
go :: forall e a. [Validation e a] -> ([e], [a])
go [] = ([], [])
go (Failure e
e:[Validation e a]
rest) = forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first (e
eforall a. a -> [a] -> [a]
:) forall a b. (a -> b) -> a -> b
$ forall e a. [Validation e a] -> ([e], [a])
go [Validation e a]
rest
go (Success a
a:[Validation e a]
rest) = forall (p :: * -> * -> *) b c a.
Bifunctor p =>
(b -> c) -> p a b -> p a c
second (a
aforall a. a -> [a] -> [a]
:) forall a b. (a -> b) -> a -> b
$ forall e a. [Validation e a] -> ([e], [a])
go [Validation e a]
rest
fromFailure :: e -> Validation e a -> e
fromFailure :: forall e a. e -> Validation e a -> e
fromFailure e
_ (Failure e
e) = e
e
fromFailure e
e Validation e a
_ = e
e
fromSuccess :: a -> Validation e a -> a
fromSuccess :: forall a e. a -> Validation e a -> a
fromSuccess a
_ (Success a
a) = a
a
fromSuccess a
a Validation e a
_ = a
a
failure :: e -> Validation (NonEmpty e) a
failure :: forall e a. e -> Validation (NonEmpty e) a
failure e
e = forall e a. e -> Validation e a
Failure (e
e forall a. a -> [a] -> NonEmpty a
:| [])
{-# INLINE failure #-}
failureIf :: Bool -> e -> Validation (NonEmpty e) ()
failureIf :: forall e. Bool -> e -> Validation (NonEmpty e) ()
failureIf Bool
p e
e
| Bool
p = forall e a. e -> Validation (NonEmpty e) a
failure e
e
| Bool
otherwise = forall e a. a -> Validation e a
Success ()
{-# INLINE failureIf #-}
failureUnless :: Bool -> e -> Validation (NonEmpty e) ()
failureUnless :: forall e. Bool -> e -> Validation (NonEmpty e) ()
failureUnless Bool
p e
e
| Bool
p = forall e a. a -> Validation e a
Success ()
| Bool
otherwise = forall e a. e -> Validation (NonEmpty e) a
failure e
e
{-# INLINE failureUnless #-}
validateAll
:: (Foldable f, Semigroup e)
=> f (a -> Validation e b)
-> a
-> Validation e a
validateAll :: forall (f :: * -> *) e a b.
(Foldable f, Semigroup e) =>
f (a -> Validation e b) -> a -> Validation e a
validateAll f (a -> Validation e b)
fs a
a = forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl' (\Validation e a
res a -> Validation e b
f -> Validation e a
res forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* a -> Validation e b
f a
a) (forall e a. a -> Validation e a
Success a
a) f (a -> Validation e b)
fs
{-# INLINE validateAll #-}
whenFailure :: Applicative f => x -> Validation e a -> (e -> f x) -> f x
whenFailure :: forall (f :: * -> *) x e a.
Applicative f =>
x -> Validation e a -> (e -> f x) -> f x
whenFailure x
_ (Failure e
e) e -> f x
f = e -> f x
f e
e
whenFailure x
a (Success a
_) e -> f x
_ = forall (f :: * -> *) a. Applicative f => a -> f a
pure x
a
{-# INLINE whenFailure #-}
whenFailure_ :: Applicative f => Validation e a -> (e -> f ()) -> f ()
whenFailure_ :: forall (f :: * -> *) e a.
Applicative f =>
Validation e a -> (e -> f ()) -> f ()
whenFailure_ = forall (f :: * -> *) x e a.
Applicative f =>
x -> Validation e a -> (e -> f x) -> f x
whenFailure ()
{-# INLINE whenFailure_ #-}
whenFailureM :: Monad m => x -> m (Validation e a) -> (e -> m x) -> m x
whenFailureM :: forall (m :: * -> *) x e a.
Monad m =>
x -> m (Validation e a) -> (e -> m x) -> m x
whenFailureM x
x m (Validation e a)
mv e -> m x
f = m (Validation e a)
mv forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Validation e a
v -> forall (f :: * -> *) x e a.
Applicative f =>
x -> Validation e a -> (e -> f x) -> f x
whenFailure x
x Validation e a
v e -> m x
f
{-# INLINE whenFailureM #-}
whenFailureM_ :: Monad m => m (Validation e a) -> (e -> m ()) -> m ()
whenFailureM_ :: forall (m :: * -> *) e a.
Monad m =>
m (Validation e a) -> (e -> m ()) -> m ()
whenFailureM_ m (Validation e a)
mv e -> m ()
f = m (Validation e a)
mv forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Validation e a
v -> forall (f :: * -> *) e a.
Applicative f =>
Validation e a -> (e -> f ()) -> f ()
whenFailure_ Validation e a
v e -> m ()
f
{-# INLINE whenFailureM_ #-}
whenSuccess :: Applicative f => x -> Validation e a -> (a -> f x) -> f x
whenSuccess :: forall (f :: * -> *) x e a.
Applicative f =>
x -> Validation e a -> (a -> f x) -> f x
whenSuccess x
x (Failure e
_) a -> f x
_ = forall (f :: * -> *) a. Applicative f => a -> f a
pure x
x
whenSuccess x
_ (Success a
a) a -> f x
f = a -> f x
f a
a
{-# INLINE whenSuccess #-}
whenSuccess_ :: Applicative f => Validation e a -> (a -> f ()) -> f ()
whenSuccess_ :: forall (f :: * -> *) e a.
Applicative f =>
Validation e a -> (a -> f ()) -> f ()
whenSuccess_ = forall (f :: * -> *) x e a.
Applicative f =>
x -> Validation e a -> (a -> f x) -> f x
whenSuccess ()
{-# INLINE whenSuccess_ #-}
whenSuccessM :: Monad m => x -> m (Validation e a) -> (a -> m x) -> m x
whenSuccessM :: forall (m :: * -> *) x e a.
Monad m =>
x -> m (Validation e a) -> (a -> m x) -> m x
whenSuccessM x
x m (Validation e a)
mv a -> m x
f = m (Validation e a)
mv forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Validation e a
v -> forall (f :: * -> *) x e a.
Applicative f =>
x -> Validation e a -> (a -> f x) -> f x
whenSuccess x
x Validation e a
v a -> m x
f
{-# INLINE whenSuccessM #-}
whenSuccessM_ :: Monad m => m (Validation e a) -> (a -> m ()) -> m ()
whenSuccessM_ :: forall (m :: * -> *) e a.
Monad m =>
m (Validation e a) -> (a -> m ()) -> m ()
whenSuccessM_ m (Validation e a)
mv a -> m ()
f = m (Validation e a)
mv forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Validation e a
v -> forall (f :: * -> *) e a.
Applicative f =>
Validation e a -> (a -> f ()) -> f ()
whenSuccess_ Validation e a
v a -> m ()
f
{-# INLINE whenSuccessM_ #-}
failureToMaybe :: Validation e a -> Maybe e
failureToMaybe :: forall e a. Validation e a -> Maybe e
failureToMaybe = forall e x a. (e -> x) -> (a -> x) -> Validation e a -> x
validation forall a. a -> Maybe a
Just (forall a b. a -> b -> a
const forall a. Maybe a
Nothing)
{-# INLINE failureToMaybe #-}
successToMaybe :: Validation e a -> Maybe a
successToMaybe :: forall e a. Validation e a -> Maybe a
successToMaybe = forall e x a. (e -> x) -> (a -> x) -> Validation e a -> x
validation (forall a b. a -> b -> a
const forall a. Maybe a
Nothing) forall a. a -> Maybe a
Just
{-# INLINE successToMaybe #-}
maybeToFailure :: a -> Maybe e -> Validation e a
maybeToFailure :: forall a e. a -> Maybe e -> Validation e a
maybeToFailure a
a = forall b a. b -> (a -> b) -> Maybe a -> b
maybe (forall e a. a -> Validation e a
Success a
a) forall e a. e -> Validation e a
Failure
{-# INLINE maybeToFailure #-}
maybeToSuccess :: e -> Maybe a -> Validation e a
maybeToSuccess :: forall e a. e -> Maybe a -> Validation e a
maybeToSuccess e
e = forall b a. b -> (a -> b) -> Maybe a -> b
maybe (forall e a. e -> Validation e a
Failure e
e) forall e a. a -> Validation e a
Success
{-# INLINE maybeToSuccess #-}