{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE DeriveGeneric      #-}
{-# LANGUAGE Safe               #-}

module Valida.Validation
    ( Validation (..)
    , validation
    , validationConst
    ) where

import Data.Bifoldable    (Bifoldable (bifoldMap))
import Data.Bifunctor     (Bifunctor (bimap))
import Data.Bitraversable (Bitraversable)
import Data.Data          (Data)
import Data.List.NonEmpty (NonEmpty)
import Data.Typeable      (Typeable)

import GHC.Generics (Generic)

-- | Like 'Either', but accumulates failures upon applicative composition.

data Validation e a
  -- | Represents a validation failure with an error.

  = Failure e
  -- | Represents a successful validation with the validated value.

  | Success a
  deriving (Validation e a -> Validation e a -> Bool
(Validation e a -> Validation e a -> Bool)
-> (Validation e a -> Validation e a -> Bool)
-> Eq (Validation e a)
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, Eq (Validation e a)
Eq (Validation e a)
-> (Validation e a -> Validation e a -> Ordering)
-> (Validation e a -> Validation e a -> Bool)
-> (Validation e a -> Validation e a -> Bool)
-> (Validation e a -> Validation e a -> Bool)
-> (Validation e a -> Validation e a -> Bool)
-> (Validation e a -> Validation e a -> Validation e a)
-> (Validation e a -> Validation e a -> Validation e a)
-> Ord (Validation e a)
Validation e a -> Validation e a -> Bool
Validation e a -> Validation e a -> Ordering
Validation e a -> Validation e a -> Validation e a
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
$cp1Ord :: forall e a. (Ord e, Ord a) => Eq (Validation e a)
Ord, ReadPrec [Validation e a]
ReadPrec (Validation e a)
Int -> ReadS (Validation e a)
ReadS [Validation e a]
(Int -> ReadS (Validation e a))
-> ReadS [Validation e a]
-> ReadPrec (Validation e a)
-> ReadPrec [Validation e a]
-> Read (Validation e a)
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
forall e a. (Read e, Read a) => ReadPrec [Validation e a]
forall e a. (Read e, Read a) => ReadPrec (Validation e a)
forall e a. (Read e, Read a) => Int -> ReadS (Validation e a)
forall e a. (Read e, Read a) => ReadS [Validation e a]
readListPrec :: ReadPrec [Validation e a]
$creadListPrec :: forall e a. (Read e, Read a) => ReadPrec [Validation e a]
readPrec :: ReadPrec (Validation e a)
$creadPrec :: forall e a. (Read e, Read a) => ReadPrec (Validation e a)
readList :: ReadS [Validation e a]
$creadList :: forall e a. (Read e, Read a) => ReadS [Validation e a]
readsPrec :: Int -> ReadS (Validation e a)
$creadsPrec :: forall e a. (Read e, Read a) => Int -> ReadS (Validation e a)
Read, Int -> Validation e a -> ShowS
[Validation e a] -> ShowS
Validation e a -> String
(Int -> Validation e a -> ShowS)
-> (Validation e a -> String)
-> ([Validation e a] -> ShowS)
-> Show (Validation e a)
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, Typeable (Validation e a)
DataType
Constr
Typeable (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 (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Validation e a))
-> (Validation e a -> Constr)
-> (Validation e a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (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)))
-> ((forall b. Data b => b -> b)
    -> Validation e a -> Validation e a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Validation e a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Validation e a -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> Validation e a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Validation e a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> Validation e a -> m (Validation e a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> Validation e a -> m (Validation e a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> Validation e a -> m (Validation e a))
-> Data (Validation e a)
Validation e a -> DataType
Validation e a -> Constr
(forall b. Data b => b -> b) -> Validation e a -> Validation e 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 b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Validation e a)
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Validation e a))
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 u.
Int -> (forall d. Data d => d -> u) -> Validation e a -> u
forall u. (forall d. Data d => d -> u) -> Validation e a -> [u]
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 r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Validation e a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Validation e a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> Validation e a -> m (Validation e a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> Validation e a -> m (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. Data d => c (t d)) -> Maybe (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))
$cSuccess :: Constr
$cFailure :: Constr
$tValidation :: DataType
gmapMo :: (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 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 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 :: 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 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 :: (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 :: (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 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 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 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 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)
$cp1Data :: forall e a. (Data e, Data a) => Typeable (Validation e a)
Data, Typeable, (forall x. Validation e a -> Rep (Validation e a) x)
-> (forall x. Rep (Validation e a) x -> Validation e a)
-> Generic (Validation e a)
forall x. Rep (Validation e a) x -> Validation e a
forall x. Validation e a -> Rep (Validation e a) x
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)

{- |

[@fmap@] 'fmap' maps given function over a 'Success' value, does nothing on 'Failure' value.

__Examples__

>>> fmap (+1) (Success 2)
Success 3
>>> fmap (+1) (Failure "error")
Failure "error"
-}
instance Functor (Validation e) where
    fmap :: (a -> b) -> Validation e a -> Validation e b
fmap a -> b
_ (Failure e
e) = e -> Validation e b
forall e a. e -> Validation e a
Failure e
e
    fmap a -> b
f (Success a
a) = b -> Validation e b
forall e a. a -> Validation e a
Success (b -> Validation e b) -> b -> Validation e b
forall a b. (a -> b) -> a -> b
$ a -> b
f a
a

instance Bifunctor Validation where
    bimap :: (a -> b) -> (c -> d) -> Validation a c -> Validation b d
bimap a -> b
f c -> d
g = (a -> Validation b d)
-> (c -> Validation b d) -> Validation a c -> Validation b d
forall e c a. (e -> c) -> (a -> c) -> Validation e a -> c
validation (b -> Validation b d
forall e a. e -> Validation e a
Failure (b -> Validation b d) -> (a -> b) -> a -> Validation b d
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> b
f) (d -> Validation b d
forall e a. a -> Validation e a
Success (d -> Validation b d) -> (c -> d) -> c -> Validation b d
forall b c a. (b -> c) -> (a -> b) -> a -> c
. c -> d
g)

{- |
[@pure@] 'pure' is a 'Success' value.
[@(\<*\>)@] '(<*>)' behaves similar to 'Either', but accumulates failures instead of stopping.

__Examples__

>>> pure 2 :: Validation String Int
Success 2
>>> Success (+1) <*> Success 4
Success 5
>>> Success (+1) <*> Failure "error"
Failure "error"
>>> Failure ["err1"] <*> Failure ["err2"]
Failure ["err1","err2"]
-}
instance Semigroup e => Applicative (Validation e) where
    {-# SPECIALIZE instance Applicative (Validation (NonEmpty err)) #-}
    {-# SPECIALIZE instance Applicative (Validation ()) #-}
    {-# SPECIALIZE instance Applicative (Validation [err]) #-}
    pure :: a -> Validation e a
pure = a -> Validation e a
forall e a. a -> Validation e a
Success
    {-# INLINEABLE pure #-}
    Success a -> b
f <*> :: Validation e (a -> b) -> Validation e a -> Validation e b
<*> Success a
b = b -> Validation e b
forall e a. a -> Validation e a
Success (b -> Validation e b) -> b -> Validation e b
forall a b. (a -> b) -> a -> b
$ a -> b
f a
b
    Success a -> b
_ <*> Failure e
e = e -> Validation e b
forall e a. e -> Validation e a
Failure e
e
    Failure e
e <*> Success a
_ = e -> Validation e b
forall e a. e -> Validation e a
Failure e
e
    Failure e
x <*> Failure e
y = e -> Validation e b
forall e a. e -> Validation e a
Failure (e -> Validation e b) -> e -> Validation e b
forall a b. (a -> b) -> a -> b
$ e
x e -> e -> e
forall a. Semigroup a => a -> a -> a
<> e
y
    {-# INLINEABLE (<*>) #-}

{- |
[@(<>)@] This behaves similar to the 'Either' semigroup. i.e Returns the first 'Success'. But also accumulates 'Failure's.

__Examples__

>>> Success 1 <> Success 2
Success 1
>>> Failure "error" <> Success 1
Success 1
>>> Success 2 <> Failure "error"
Success 2
>>> Failure ["err1"] <> Failure ["err2"]
Failure ["err1","err2"]
-}
instance Semigroup e => Semigroup (Validation e a) where
    {-# SPECIALIZE instance Semigroup (Validation (NonEmpty err) a) #-}
    {-# SPECIALIZE instance Semigroup (Validation () a) #-}
    {-# SPECIALIZE instance Semigroup (Validation [err] a) #-}
    s :: Validation e a
s@(Success 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 a
_) = Validation e a
s
    Failure e
x     <> Failure e
y     = e -> Validation e a
forall e a. e -> Validation e a
Failure (e -> Validation e a) -> e -> Validation e a
forall a b. (a -> b) -> a -> b
$ e
x e -> e -> e
forall a. Semigroup a => a -> a -> a
<> e
y
    {-# INLINEABLE (<>) #-}

{- |

[@foldMap@] 'foldMap' maps given function over a 'Success' value, returns 'mempty' for a 'Failure' value.

__Examples__

>>> foldMap (:[]) (Success 2)
[2]
>>> foldMap (:[]) (Failure "error")
[]
-}
instance Foldable (Validation e) where
    foldMap :: (a -> m) -> Validation e a -> m
foldMap = (e -> m) -> (a -> m) -> Validation e a -> m
forall e c a. (e -> c) -> (a -> c) -> Validation e a -> c
validation (m -> e -> m
forall a b. a -> b -> a
const m
forall a. Monoid a => a
mempty)

{- |

[@traverse@] In case of 'Success', 'traverse' applies given function to the inner value, and maps 'Success' over the result.
In case of 'Failure', 'traverse' returns 'Failure', wrapped in minimal context of the corresponding type ('pure').

__Examples__

>>> traverse Just (Success 2)
Just (Success 2)
>>> traverse Just (Failure "error")
Just (Failure "error")
-}
instance Traversable (Validation e) where
    traverse :: (a -> f b) -> Validation e a -> f (Validation e b)
traverse a -> f b
f = (e -> f (Validation e b))
-> (a -> f (Validation e b))
-> Validation e a
-> f (Validation e b)
forall e c a. (e -> c) -> (a -> c) -> Validation e a -> c
validation (Validation e b -> f (Validation e b)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Validation e b -> f (Validation e b))
-> (e -> Validation e b) -> e -> f (Validation e b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. e -> Validation e b
forall e a. e -> Validation e a
Failure) ((b -> Validation e b) -> f b -> f (Validation e b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap b -> Validation e b
forall e a. a -> Validation e a
Success (f b -> f (Validation e b))
-> (a -> f b) -> a -> f (Validation e b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> f b
f)

{- |

[@bifoldMap@] 'bifoldMap' is the same as 'validation'.

__Examples__

'bifoldMap' (and its more generalized version, 'validation') can eliminate the need to pattern match on 'Validation'.

>>> import Data.Bifoldable
>>> bifoldMap reverse (:[]) (Success 'c' :: Validation String Char)
"c"
>>> bifoldMap reverse (:[]) (Failure "error" :: Validation String Char)
"rorre"
-}
instance Bifoldable Validation where
    bifoldMap :: (a -> m) -> (b -> m) -> Validation a b -> m
bifoldMap = (a -> m) -> (b -> m) -> Validation a b -> m
forall e c a. (e -> c) -> (a -> c) -> Validation e a -> c
validation

instance Bitraversable Validation

{- | Case analysis for 'Validation', i.e catamorphism.

In case of 'Failure e', apply the first function to e; in case of 'Success a', apply the second function to a.

This is a more generalized version of the 'bifoldMap' implementation.

==== __Examples__

>>> validation (const Nothing) Just (Success 'c' :: Validation String Char)
Just 'c'
>>> validation (const Nothing) Just (Failure "error" :: Validation String Char)
Nothing
-}
validation :: (e -> c) -> (a -> c) -> Validation e a -> c
validation :: (e -> c) -> (a -> c) -> Validation e a -> c
validation e -> c
ef a -> c
_ (Failure e
e) = e -> c
ef e
e
validation e -> c
_ a -> c
af (Success a
a) = a -> c
af a
a

{- | Case analysis for 'Validation', with replacer.

This is similar to 'validation', but takes in replacers instead of functions.

In case of 'Failure', return the first argument; otherwise, return the second argument.

@validationConst e a = 'validation' ('const' e) ('const' a)@

==== __Examples__

>>> validation (const Nothing) Just (Success 'c' :: Validation String Char)
Just 'c'
>>> validation (const Nothing) Just (Failure "error" :: Validation String Char)
Nothing
-}
validationConst :: p -> p -> Validation e a -> p
validationConst :: p -> p -> Validation e a -> p
validationConst p
e p
_ (Failure e
_) = p
e
validationConst p
_ p
a Validation e a
_           = p
a