Modulevalidation-1.3.3Haskell2010

Data.Validation.Validator

6 types
16 classes
8 values

Packagevalidation-1.3.3
Exports30
LanguageHaskell2010
LicenceBSD-3-Clause
SourceValidator.hs

Accumulating, Bifunctor parameter order

1 declaration

newtypenewtype Validator x err a

A validator that applies a function x -> Validation err a. The Applicative instance accumulates errors using Semigroup, like Validation.

Unlike Validation and the other validators, the Alt instance does not accumulate errors: it behaves like Either, returning the first success, or otherwise the second failure. As a consequence there are no Plus or Alternative instances, and <> (which accumulates) differs from <!>.

Example2 expressions

>>> let Validator f = Validator (\x -> if x > 0 then Success x else Failure ["not positive"]) :: Validator Int [String] Int>>> f 5Success 5

Example1 expression

>>> f (-1)Failure ["not positive"]

Constructors

Validator (x -> Validation err a)

Instances31Bifunctor, Swap, Functor, Applicative, Alt, Apply, …

Bifunctor (Validator x)Defined in validation-1.3.3 · Data.Validation.Validator

Example3 expressions

>>> import Data.Bifunctor(Bifunctor(bimap))>>> let Validator f = bimap (map (++ "!")) (+1) (Validator Success :: Validator Int [String] Int)>>> f 10Success 11

Example2 expressions

>>> let Validator f = bimap (map (++ "!")) (+1) (Validator (\_ -> Failure ["err"]) :: Validator Int [String] Int)>>> f 0Failure ["err!"]

Swap (Validator x)Defined in validation-1.3.3 · Data.Validation.Validator

Example3 expressions

>>> import Data.Bifunctor.Swap(Swap(swap))>>> let Validator f = swap (Validator (\_ -> Failure "err") :: Validator Int String Int)>>> f 0Success "err"

Example2 expressions

>>> let Validator f = swap (Validator (\_ -> Success 1) :: Validator Int String Int)>>> f 0Failure 1

Functor (Validator x err)Defined in validation-1.3.3 · Data.Validation.Validator

Example2 expressions

>>> let Validator f = fmap (+1) (Validator Success :: Validator Int [String] Int)>>> f 10Success 11

Example2 expressions

>>> let Validator f = fmap (+1) (Validator (\_ -> Failure ["err"]) :: Validator Int [String] Int)>>> f 10Failure ["err"]

Semigroup err => Applicative (Validator x err)Defined in validation-1.3.3 · Data.Validation.Validator

Accumulates errors using Semigroup.

Example2 expressions

>>> let Validator f = pure 42 :: Validator Int [String] Int>>> f 0Success 42

Example2 expressions

>>> let Validator f = pure (+) <*> (Validator (\_ -> Failure ["e1"]) :: Validator Int [String] Int) <*> (Validator (\_ -> Failure ["e2"]) :: Validator Int [String] Int)>>> f 0Failure ["e1","e2"]

Alt (Validator x err)Defined in validation-1.3.3 · Data.Validation.Validator

First success wins, like Either; if both fail, the second failure is returned. Errors are not accumulated, so no Semigroup constraint is required.

This differs from the Alt instances for Validation, ValidatorProfunctor, ValidatorMonadT and ValidatorMonadProfunctorT, which all accumulate errors when both sides fail. Converting a Validator to one of those types (for example with validatorProfunctor) therefore changes the meaning of <!>. Use <> to accumulate errors from two Validators.

Example3 expressions

>>> import Data.Functor.Alt(Alt((<!>)))>>> let Validator f = (Validator (\_ -> Success 1) :: Validator Int [String] Int) <!> Validator (\_ -> Success 2)>>> f 0Success 1

Example2 expressions

>>> let Validator f = (Validator (\_ -> Success 1) :: Validator Int [String] Int) <!> Validator (\_ -> Failure ["e2"])>>> f 0Success 1

Example2 expressions

>>> let Validator f = (Validator (\_ -> Failure ["e1"]) :: Validator Int [String] Int) <!> Validator (\_ -> Success 2)>>> f 0Success 2

Example2 expressions

>>> let Validator f = (Validator (\_ -> Failure ["e1"]) :: Validator Int [String] Int) <!> Validator (\_ -> Failure ["e2"])>>> f 0Failure ["e2"]

Example2 expressions

>>> let Validator f = (Validator (\_ -> Failure 1) :: Validator Int Int Int) <!> Validator (\_ -> Failure 2)>>> f 0Failure 2

Semigroup err => Apply (Validator x err)Defined in validation-1.3.3 · Data.Validation.Validator

Accumulates errors using Semigroup.

Example3 expressions

>>> import Data.Functor.Apply(Apply((<.>)))>>> let Validator f = Validator (\_ -> Success (+1)) <.> (Validator Success :: Validator Int [String] Int)>>> f 10Success 11

Example2 expressions

>>> let Validator f = (Validator (\_ -> Failure ["e1"]) :: Validator Int [String] (Int -> Int)) <.> (Validator (\_ -> Failure ["e2"]) :: Validator Int [String] Int)>>> f 0Failure ["e1","e2"]

Extend (Validator x err)Defined in validation-1.3.3 · Data.Validation.Validator

Like Validation, a failure is kept: for each input, the result fails where the validator fails, and otherwise succeeds with f applied to the validator.

Example3 expressions

>>> import Data.Functor.Extend(Extend(extended))>>> let Validator f = extended (\_ -> 42) (Validator (\_ -> Success 1) :: Validator Int [String] Int)>>> f 0Success 42

Example2 expressions

>>> let Validator f = extended (\_ -> 42) (Validator (\x -> if x > 0 then Success x else Failure ["not positive"]) :: Validator Int [String] Int)>>> f 5Success 42

Example1 expression

>>> f (-1)Failure ["not positive"]

Semigroup err => Selective (Validator x err)Defined in validation-1.3.3 · Data.Validation.Validator

Example3 expressions

>>> import Control.Selective(Selective(select))>>> let Validator f = select (Validator (\_ -> Success (Right 1)) :: Validator Int [String] (Either Int Int)) (pure (+1))>>> f 0Success 1

Example2 expressions

>>> let Validator f = select (Validator (\_ -> Success (Left 1)) :: Validator Int [String] (Either Int Int)) (pure (+1))>>> f 0Success 2

Generic (Validator x err a)Defined in validation-1.3.3 · Data.Validation.Validator

Semigroup err => Semigroup (Validator x err a)Defined in validation-1.3.3 · Data.Validation.Validator

First success wins; two failures accumulate. Unlike <!> for Validator, this requires Semigroup on err.

Example2 expressions

>>> let Validator f = (Validator (\_ -> Failure ["e1"]) :: Validator Int [String] Int) <> Validator (\_ -> Failure ["e2"])>>> f 0Failure ["e1","e2"]

Example2 expressions

>>> let Validator f = (Validator (\_ -> Success 1) :: Validator Int [String] Int) <> Validator (\_ -> Failure ["e2"])>>> f 0Success 1

Monoid err => Monoid (Validator x err a)Defined in validation-1.3.3 · Data.Validation.Validator
Example2 expressions
```
>>> let Validator f = mempty :: Validator Int [String] Int>>> f 0Failure []
```

Wrapped (Validator x err a)Defined in validation-1.3.3 · Data.Validation.Validator

Example3 expressions

>>> import Control.Lens(view, _Wrapped')>>> let v = Validator (\x -> Success (x + 1)) :: Validator Int [String] Int>>> (view _Wrapped' v) 10Success 11

AsValidator (Validator x err a) x err aDefined in validation-1.3.3 · Data.Validation.Validator
AsValidatorProfunctor (Validator x err a) err x aDefined in validation-1.3.3 · Data.Validation.Validator
GetValidator (Validator x err a) x err aDefined in validation-1.3.3 · Data.Validation.Validator
GetValidatorProfunctor (Validator x err a) err x aDefined in validation-1.3.3 · Data.Validation.Validator
HasValidator (Validator x err a) x err aDefined in validation-1.3.3 · Data.Validation.Validator
HasValidatorProfunctor (Validator x err a) err x aDefined in validation-1.3.3 · Data.Validation.Validator
ReviewValidator (Validator x err a) x err aDefined in validation-1.3.3 · Data.Validation.Validator
ReviewValidatorProfunctor (Validator x err a) err x aDefined in validation-1.3.3 · Data.Validation.Validator
AsValidatorMonadProfunctorT (Validator x err a) err Identity x aDefined in validation-1.3.3 · Data.Validation.Validator
AsValidatorMonadT (Validator x err a) x err Identity aDefined in validation-1.3.3 · Data.Validation.Validator
GetValidatorMonadProfunctorT (Validator x err a) err Identity x aDefined in validation-1.3.3 · Data.Validation.Validator
GetValidatorMonadT (Validator x err a) x err Identity aDefined in validation-1.3.3 · Data.Validation.Validator
HasValidatorMonadProfunctorT (Validator x err a) err Identity x aDefined in validation-1.3.3 · Data.Validation.Validator
HasValidatorMonadT (Validator x err a) x err Identity aDefined in validation-1.3.3 · Data.Validation.Validator
ReviewValidatorMonadProfunctorT (Validator x err a) err Identity x aDefined in validation-1.3.3 · Data.Validation.Validator
ReviewValidatorMonadT (Validator x err a) x err Identity aDefined in validation-1.3.3 · Data.Validation.Validator
Rewrapped (Validator x err a) (Validator x' err' b)Defined in validation-1.3.3 · Data.Validation.Validator
type Rep (Validator x err a) = D1 ('MetaData "Validator" "Data.Validation.Validator" "validation-1.3.3-30svjXBZxFa33c5ZrZGHG7" 'True) (C1 ('MetaCons "Validator" 'PrefixI 'False) (S1 ('MetaSel 'Nothing 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (x -> Validation err a))))Defined in validation-1.3.3 · Data.Validation.Validator
type Unwrapped (Validator x err a) = x -> Validation err aDefined in validation-1.3.3 · Data.Validation.Validator

Accumulating, Profunctor parameter order

1 declaration

newtypenewtype ValidatorProfunctor err x a

A validator function x -> Validation err a with err as the outermost parameter, enabling Profunctor and related instances.

Example1 expression

>>> runVP (ValidatorProfunctor (\x -> Success (x * 2))) 5Success 10

Example1 expression

>>> runVP (ValidatorProfunctor (\_ -> Failure ["bad"])) 5Failure ["bad"]

Constructors

ValidatorProfunctor (x -> Validation err a)

Instances36Choice, Strong, Profunctor, Traversing, Sieve, Functor, …

Choice (ValidatorProfunctor err)Defined in validation-1.3.3 · Data.Validation.Validator

Example1 expression

>>> runVP (left' vpFromInput) (Left 3)Success (Left 4)

Example1 expression

>>> runVP (left' vpFromInput) (Right "x" :: Either Int String)Success (Right "x")

Example1 expression

>>> runVP (right' vpFromInput) (Right 3)Success (Right 4)

Example1 expression

>>> runVP (right' vpFromInput) (Left "x" :: Either String Int)Success (Left "x")

Strong (ValidatorProfunctor err)Defined in validation-1.3.3 · Data.Validation.Validator
Example1 expression
```
>>> runVP (first' vpFromInput) (3, "tag")Success (4,"tag")
```
Example1 expression
```
>>> runVP (second' vpFromInput) ("tag", 3)Success ("tag",4)
```
Profunctor (ValidatorProfunctor err)Defined in validation-1.3.3 · Data.Validation.Validator
Contravariant in x, covariant in a.
Example1 expression
```
>>> runVP (dimap (*2) (+10) vpFromInput) 3Success 17
```
Example1 expression
```
>>> runVP (lmap (*2) vpFromInput) 3Success 7
```
Example1 expression
```
>>> runVP (rmap (+10) vpFromInput) 3Success 14
```
Semigroup err => Traversing (ValidatorProfunctor err)Defined in validation-1.3.3 · Data.Validation.Validator
Example1 expression
```
>>> runVP (traverse' vpFromInput) [1, 2, 3]Success [2,3,4]
```
Sieve (ValidatorProfunctor err) (Validation err)Defined in validation-1.3.3 · Data.Validation.Validator
Example1 expression
```
>>> sieve vpFromInput 3Success 4
```
Example1 expression
```
>>> sieve (vpErr ["e"]) 0Failure ["e"]
```
Functor (ValidatorProfunctor err x)Defined in validation-1.3.3 · Data.Validation.Validator
Example1 expression
```
>>> runVP (fmap (+10) vpFromInput) 3Success 14
```
Example1 expression
```
>>> runVP (fmap (+10) (vpErr ["e"])) 3Failure ["e"]
```

Semigroup err => Applicative (ValidatorProfunctor err x)Defined in validation-1.3.3 · Data.Validation.Validator

pure ignores the input, <*> accumulates errors.

Example1 expression

>>> runVP (pure 42 :: ValidatorProfunctor [String] Int Int) 0Success 42

Example1 expression

>>> runVP (pure (+1) <*> pure 2 :: ValidatorProfunctor [String] Int Int) 0Success 3

Example1 expression

>>> runVP (ValidatorProfunctor (\_ -> Failure ["e1"]) <*> ValidatorProfunctor (\_ -> Failure ["e2"]) :: ValidatorProfunctor [String] Int Int) 0Failure ["e1","e2"]

Monoid err => Alternative (ValidatorProfunctor err x)Defined in validation-1.3.3 · Data.Validation.Validator
Example1 expression
```
>>> runVP (empty :: ValidatorProfunctor [String] Int Int) 0Failure []
```
Example1 expression
```
>>> runVP (vpErr ["e1"] <|> vpOk 2) 0Success 2
```
Semigroup err => Alt (ValidatorProfunctor err x)Defined in validation-1.3.3 · Data.Validation.Validator
First success wins; two failures accumulate.
Example1 expression
```
>>> runVP (vpOk 1 <!> vpOk 2) 0Success 1
```
Example1 expression
```
>>> runVP (vpErr ["e1"] <!> vpOk 2) 0Success 2
```
Example1 expression
```
>>> runVP (vpOk 1 <!> vpErr ["e2"]) 0Success 1
```
Example1 expression
```
>>> runVP (vpErr ["e1"] <!> vpErr ["e2"]) 0Failure ["e1","e2"]
```

Semigroup err => Apply (ValidatorProfunctor err x)Defined in validation-1.3.3 · Data.Validation.Validator

Accumulates errors from both sides.

Example1 expression

>>> runVP (ValidatorProfunctor (\_ -> Success (+1)) <.> vpOk 2 :: ValidatorProfunctor [String] Int Int) 0Success 3

Example1 expression

>>> runVP (ValidatorProfunctor (\_ -> Failure ["e1"]) <.> ValidatorProfunctor (\_ -> Failure ["e2"]) :: ValidatorProfunctor [String] Int Int) 0Failure ["e1","e2"]

Example1 expression

>>> runVP (ValidatorProfunctor (\_ -> Failure ["e1"]) <.> vpOk 2 :: ValidatorProfunctor [String] Int Int) 0Failure ["e1"]

Example1 expression

>>> runVP (ValidatorProfunctor (\_ -> Success (+1)) <.> vpErr ["e2"] :: ValidatorProfunctor [String] Int Int) 0Failure ["e2"]

Extend (ValidatorProfunctor err x)Defined in validation-1.3.3 · Data.Validation.Validator
Like Validation, a failure is kept: for each input, the result fails where the validator fails, and otherwise succeeds with f applied to the validator.
Example1 expression
```
>>> runVP (extended (\_ -> 42) vpFromInput) 0Success 42
```
Example1 expression
```
>>> runVP (extended (\_ -> 42) (vpErr ["e"])) 0Failure ["e"]
```
Monoid err => Plus (ValidatorProfunctor err x)Defined in validation-1.3.3 · Data.Validation.Validator
Example1 expression
```
>>> runVP (zero :: ValidatorProfunctor [String] Int Int) 0Failure []
```

Semigroup err => Selective (ValidatorProfunctor err x)Defined in validation-1.3.3 · Data.Validation.Validator

Example1 expression

>>> runVP (select (pure (Right 1)) (pure (+1)) :: ValidatorProfunctor [String] Int Int) 0Success 1

Example1 expression

>>> runVP (select (pure (Left 1)) (pure (+1)) :: ValidatorProfunctor [String] Int Int) 0Success 2

Example1 expression

>>> runVP (select (ValidatorProfunctor (\_ -> Failure ["e1"])) (pure (+1)) :: ValidatorProfunctor [String] Int Int) 0Failure ["e1"]

Generic (ValidatorProfunctor err x a)Defined in validation-1.3.3 · Data.Validation.Validator
Semigroup err => Semigroup (ValidatorProfunctor err x a)Defined in validation-1.3.3 · Data.Validation.Validator
Example1 expression
```
>>> runVP (vpOk 1 <> vpOk 2) 0Success 1
```
Example1 expression
```
>>> runVP (vpErr ["e1"] <> vpErr ["e2"]) 0Failure ["e1","e2"]
```
Example1 expression
```
>>> runVP (vpErr ["e1"] <> vpOk 2) 0Success 2
```
Monoid err => Monoid (ValidatorProfunctor err x a)Defined in validation-1.3.3 · Data.Validation.Validator
Example1 expression
```
>>> runVP (mempty :: ValidatorProfunctor [String] Int Int) 0Failure []
```
Wrapped (ValidatorProfunctor err x a)Defined in validation-1.3.3 · Data.Validation.Validator
Example1 expression
```
>>> view _Wrapped' vpFromInput $ 3Success 4
```
AsValidator (ValidatorProfunctor err x a) x err aDefined in validation-1.3.3 · Data.Validation.Validator
AsValidatorProfunctor (ValidatorProfunctor err x a) err x aDefined in validation-1.3.3 · Data.Validation.Validator
GetValidator (ValidatorProfunctor err x a) x err aDefined in validation-1.3.3 · Data.Validation.Validator
GetValidatorProfunctor (ValidatorProfunctor err x a) err x aDefined in validation-1.3.3 · Data.Validation.Validator
HasValidator (ValidatorProfunctor err x a) x err aDefined in validation-1.3.3 · Data.Validation.Validator
HasValidatorProfunctor (ValidatorProfunctor err x a) err x aDefined in validation-1.3.3 · Data.Validation.Validator
ReviewValidator (ValidatorProfunctor err x a) x err aDefined in validation-1.3.3 · Data.Validation.Validator
ReviewValidatorProfunctor (ValidatorProfunctor err x a) err x aDefined in validation-1.3.3 · Data.Validation.Validator
AsValidatorMonadProfunctorT (ValidatorProfunctor err x a) err Identity x aDefined in validation-1.3.3 · Data.Validation.Validator
AsValidatorMonadT (ValidatorProfunctor err x a) x err Identity aDefined in validation-1.3.3 · Data.Validation.Validator
GetValidatorMonadProfunctorT (ValidatorProfunctor err x a) err Identity x aDefined in validation-1.3.3 · Data.Validation.Validator
GetValidatorMonadT (ValidatorProfunctor err x a) x err Identity aDefined in validation-1.3.3 · Data.Validation.Validator
HasValidatorMonadProfunctorT (ValidatorProfunctor err x a) err Identity x aDefined in validation-1.3.3 · Data.Validation.Validator
HasValidatorMonadT (ValidatorProfunctor err x a) x err Identity aDefined in validation-1.3.3 · Data.Validation.Validator
ReviewValidatorMonadProfunctorT (ValidatorProfunctor err x a) err Identity x aDefined in validation-1.3.3 · Data.Validation.Validator
ReviewValidatorMonadT (ValidatorProfunctor err x a) x err Identity aDefined in validation-1.3.3 · Data.Validation.Validator
Rewrapped (ValidatorProfunctor err x a) (ValidatorProfunctor err' x' b)Defined in validation-1.3.3 · Data.Validation.Validator
type Rep (ValidatorProfunctor err x a) = D1 ('MetaData "ValidatorProfunctor" "Data.Validation.Validator" "validation-1.3.3-30svjXBZxFa33c5ZrZGHG7" 'True) (C1 ('MetaCons "ValidatorProfunctor" 'PrefixI 'False) (S1 ('MetaSel 'Nothing 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (x -> Validation err a))))Defined in validation-1.3.3 · Data.Validation.Validator
type Unwrapped (ValidatorProfunctor err x a) = x -> Validation err aDefined in validation-1.3.3 · Data.Validation.Validator

Short-circuiting monad, MonadTrans parameter order

2 declarations

newtypenewtype ValidatorMonadT x err (f :: Type -> Type) a

A validator with short-circuiting Monad and MonadTrans instances. The parameter order x err f a enables MonadTrans on ValidatorMonadT x err.

Example5 expressions

>>> import Data.Functor.Identity (Identity(..))>>> import Data.Validation.Validation (Validation(..))>>> import Data.Validation.ValidationMonad (ValidationMonadT(..))>>> let v = ValidatorMonadT (\x -> ValidationMonadT (Identity (if x > 0 then Success x else Failure ["non-positive"])))>>> let ValidatorMonadT f = v in let ValidationMonadT (Identity r) = f 5 in rSuccess 5

Example1 expression

>>> let ValidatorMonadT f = v in let ValidationMonadT (Identity r) = f (-1) in rFailure ["non-positive"]

Constructors

ValidatorMonadT (x -> ValidationMonadT err f a)

Instances44MonadRWS, MonadError, MonadReader, MonadState, MonadWriter, MonadTrans, …

MonadRWS r w s f => MonadRWS r w s (ValidatorMonadT x err f)Defined in validation-1.3.3 · Data.Validation.Validator

Monad f => MonadError err (ValidatorMonadT x err f)Defined in validation-1.3.3 · Data.Validation.Validator

Example5 expressions

>>> import Data.Functor.Identity (Identity(..))>>> import Data.Validation.Validation (Validation(..))>>> import Data.Validation.ValidationMonad (ValidationMonadT(..))>>> import Control.Monad.Error.Class (throwError, catchError)>>> let ValidatorMonadT f = throwError ["oops"] :: ValidatorMonadT Int [String] Identity Int in let ValidationMonadT (Identity r) = f 0 in rFailure ["oops"]

Example2 expressions

>>> let e = ValidatorMonadT (\_ -> ValidationMonadT (Identity (Failure ["e"]))) :: ValidatorMonadT Int [String] Identity Int>>> let ValidatorMonadT f = catchError e (\_ -> ValidatorMonadT (\_ -> ValidationMonadT (Identity (Success 99)))) in let ValidationMonadT (Identity r) = f 0 in rSuccess 99

MonadReader r f => MonadReader r (ValidatorMonadT x err f)Defined in validation-1.3.3 · Data.Validation.Validator
MonadState s f => MonadState s (ValidatorMonadT x err f)Defined in validation-1.3.3 · Data.Validation.Validator
MonadWriter w f => MonadWriter w (ValidatorMonadT x err f)Defined in validation-1.3.3 · Data.Validation.Validator

MonadTrans (ValidatorMonadT x err)Defined in validation-1.3.3 · Data.Validation.Validator

Example5 expressions

>>> import Data.Functor.Identity (Identity(..))>>> import Data.Validation.Validation (Validation(..))>>> import Data.Validation.ValidationMonad (ValidationMonadT(..))>>> import Control.Monad.Trans.Class (lift)>>> let ValidatorMonadT f = lift (Identity 42) :: ValidatorMonadT Int [String] Identity Int in let ValidationMonadT (Identity r) = f 0 in rSuccess 42

BindTrans (ValidatorMonadT x err)Defined in validation-1.3.3 · Data.Validation.Validator

Monad f => Monad (ValidatorMonadT x err f)Defined in validation-1.3.3 · Data.Validation.Validator

Short-circuits on Failure.

Example6 expressions

>>> import Data.Functor.Identity (Identity(..))>>> import Data.Validation.Validation (Validation(..))>>> import Data.Validation.ValidationMonad (ValidationMonadT(..))>>> let e1 = ValidatorMonadT (\_ -> ValidationMonadT (Identity (Failure ["e1"]))) :: ValidatorMonadT Int [String] Identity Int>>> let e2 = ValidatorMonadT (\_ -> ValidationMonadT (Identity (Failure ["e2"]))) :: ValidatorMonadT Int [String] Identity Int>>> let ValidatorMonadT f = e1 >> e2 in let ValidationMonadT (Identity r) = f 0 in rFailure ["e1"]

Functor f => Functor (ValidatorMonadT x err f)Defined in validation-1.3.3 · Data.Validation.Validator

Example5 expressions

>>> import Data.Functor.Identity (Identity(..))>>> import Data.Validation.Validation (Validation(..))>>> import Data.Validation.ValidationMonad (ValidationMonadT(..))>>> let v = ValidatorMonadT (\_ -> ValidationMonadT (Identity (Success 1))) :: ValidatorMonadT Int [String] Identity Int>>> let ValidatorMonadT f = fmap (+1) v in let ValidationMonadT (Identity r) = f 0 in rSuccess 2

MonadFail f => MonadFail (ValidatorMonadT x err f)Defined in validation-1.3.3 · Data.Validation.Validator

Monad f => Applicative (ValidatorMonadT x err f)Defined in validation-1.3.3 · Data.Validation.Validator

Short-circuits on first failure (unlike Validation which accumulates).

Example6 expressions

>>> import Data.Functor.Identity (Identity(..))>>> import Data.Validation.Validation (Validation(..))>>> import Data.Validation.ValidationMonad (ValidationMonadT(..))>>> let e1 = ValidatorMonadT (\_ -> ValidationMonadT (Identity (Failure ["e1"]))) :: ValidatorMonadT Int [String] Identity (Int -> Int)>>> let e2 = ValidatorMonadT (\_ -> ValidationMonadT (Identity (Failure ["e2"]))) :: ValidatorMonadT Int [String] Identity Int>>> let ValidatorMonadT f = e1 <*> e2 in let ValidationMonadT (Identity r) = f 0 in rFailure ["e1"]

(Monad f, Monoid err) => Alternative (ValidatorMonadT x err f)Defined in validation-1.3.3 · Data.Validation.Validator

Example5 expressions

>>> import Data.Functor.Identity (Identity(..))>>> import Data.Validation.Validation (Validation(..))>>> import Data.Validation.ValidationMonad (ValidationMonadT(..))>>> let ok = ValidatorMonadT (\_ -> ValidationMonadT (Identity (Success 1))) :: ValidatorMonadT Int [String] Identity Int>>> let ValidatorMonadT f = empty <|> ok in let ValidationMonadT (Identity r) = f 0 in rSuccess 1

(Monad f, Monoid err) => MonadPlus (ValidatorMonadT x err f)Defined in validation-1.3.3 · Data.Validation.Validator
MonadIO f => MonadIO (ValidatorMonadT x err f)Defined in validation-1.3.3 · Data.Validation.Validator
MonadCont f => MonadCont (ValidatorMonadT x err f)Defined in validation-1.3.3 · Data.Validation.Validator

(Monad f, Semigroup err) => Alt (ValidatorMonadT x err f)Defined in validation-1.3.3 · Data.Validation.Validator

First success wins; two failures accumulate.

Example7 expressions

>>> import Data.Functor.Identity (Identity(..))>>> import Data.Validation.Validation (Validation(..))>>> import Data.Validation.ValidationMonad (ValidationMonadT(..))>>> import Data.Functor.Alt ((<!>))>>> let e1 = ValidatorMonadT (\_ -> ValidationMonadT (Identity (Failure ["e1"]))) :: ValidatorMonadT Int [String] Identity Int>>> let ok = ValidatorMonadT (\_ -> ValidationMonadT (Identity (Success 2))) :: ValidatorMonadT Int [String] Identity Int>>> let ValidatorMonadT f = e1 <!> ok in let ValidationMonadT (Identity r) = f 0 in rSuccess 2

Monad f => Apply (ValidatorMonadT x err f)Defined in validation-1.3.3 · Data.Validation.Validator

Example7 expressions

>>> import Data.Functor.Identity (Identity(..))>>> import Data.Validation.Validation (Validation(..))>>> import Data.Validation.ValidationMonad (ValidationMonadT(..))>>> import Data.Functor.Apply ((<.>))>>> let f = ValidatorMonadT (\_ -> ValidationMonadT (Identity (Success (+1)))) :: ValidatorMonadT Int [String] Identity (Int -> Int)>>> let a = ValidatorMonadT (\_ -> ValidationMonadT (Identity (Success 2))) :: ValidatorMonadT Int [String] Identity Int>>> let ValidatorMonadT g = f <.> a in let ValidationMonadT (Identity r) = g 0 in rSuccess 3

Monad f => Bind (ValidatorMonadT x err f)Defined in validation-1.3.3 · Data.Validation.Validator

Example6 expressions

>>> import Data.Functor.Identity (Identity(..))>>> import Data.Validation.Validation (Validation(..))>>> import Data.Validation.ValidationMonad (ValidationMonadT(..))>>> import Data.Functor.Bind ((>>-))>>> let v = ValidatorMonadT (\_ -> ValidationMonadT (Identity (Success 1))) :: ValidatorMonadT Int [String] Identity Int>>> let ValidatorMonadT f = v >>- \a -> ValidatorMonadT (\_ -> ValidationMonadT (Identity (Success (a + 1)))) in let ValidationMonadT (Identity r) = f 0 in rSuccess 2

Functor f => Extend (ValidatorMonadT x err f)Defined in validation-1.3.3 · Data.Validation.Validator

Like Validation, a failure is kept: for each input, the result fails where the validator fails, and otherwise succeeds with f applied to the validator. The effects of the validator are run.

Example6 expressions

>>> import Data.Functor.Identity (Identity(..))>>> import Data.Validation.Validation (Validation(..))>>> import Data.Validation.ValidationMonad (ValidationMonadT(..))>>> import Data.Functor.Extend (extended)>>> let v = ValidatorMonadT (\_ -> ValidationMonadT (Identity (Success 1))) :: ValidatorMonadT Int [String] Identity Int>>> let ValidatorMonadT f = extended (\_ -> 42) v in let ValidationMonadT (Identity r) = f 0 in rSuccess 42

Example2 expressions

>>> let e = ValidatorMonadT (\_ -> ValidationMonadT (Identity (Failure ["e"]))) :: ValidatorMonadT Int [String] Identity Int>>> let ValidatorMonadT f = extended (\_ -> 42) e in let ValidationMonadT (Identity r) = f 0 in rFailure ["e"]

(Monad f, Monoid err) => Plus (ValidatorMonadT x err f)Defined in validation-1.3.3 · Data.Validation.Validator

Example7 expressions

>>> import Data.Functor.Identity (Identity(..))>>> import Data.Validation.Validation (Validation(..))>>> import Data.Validation.ValidationMonad (ValidationMonadT(..))>>> import Data.Functor.Alt ((<!>))>>> import Data.Functor.Plus (zero)>>> let ok = ValidatorMonadT (\_ -> ValidationMonadT (Identity (Success 1))) :: ValidatorMonadT Int [String] Identity Int>>> let ValidatorMonadT f = (zero :: ValidatorMonadT Int [String] Identity Int) <!> ok in let ValidationMonadT (Identity r) = f 0 in rSuccess 1

Monad f => Selective (ValidatorMonadT x err f)Defined in validation-1.3.3 · Data.Validation.Validator

Example6 expressions

>>> import Data.Functor.Identity (Identity(..))>>> import Data.Validation.Validation (Validation(..))>>> import Data.Validation.ValidationMonad (ValidationMonadT(..))>>> import Control.Selective (select)>>> let ok a = ValidatorMonadT (\_ -> ValidationMonadT (Identity (Success a)))>>> let ValidatorMonadT f = select (ok (Left (1 :: Int))) (ok (+1)) :: ValidatorMonadT Int [String] Identity Int in let ValidationMonadT (Identity r) = f 0 in rSuccess 2

Generic (ValidatorMonadT x err f a)Defined in validation-1.3.3 · Data.Validation.Validator

(Applicative f, Semigroup err) => Semigroup (ValidatorMonadT x err f a)Defined in validation-1.3.3 · Data.Validation.Validator

Example6 expressions

>>> import Data.Functor.Identity (Identity(..))>>> import Data.Validation.Validation (Validation(..))>>> import Data.Validation.ValidationMonad (ValidationMonadT(..))>>> let e1 = ValidatorMonadT (\_ -> ValidationMonadT (Identity (Failure ["e1"]))) :: ValidatorMonadT Int [String] Identity Int>>> let e2 = ValidatorMonadT (\_ -> ValidationMonadT (Identity (Failure ["e2"]))) :: ValidatorMonadT Int [String] Identity Int>>> let ValidatorMonadT f = e1 <> e2 in let ValidationMonadT (Identity r) = f 0 in rFailure ["e1","e2"]

(Applicative f, Monoid err) => Monoid (ValidatorMonadT x err f a)Defined in validation-1.3.3 · Data.Validation.Validator

Example4 expressions

>>> import Data.Functor.Identity (Identity(..))>>> import Data.Validation.Validation (Validation(..))>>> import Data.Validation.ValidationMonad (ValidationMonadT(..))>>> let ValidatorMonadT f = mempty :: ValidatorMonadT Int [String] Identity Int in let ValidationMonadT (Identity r) = f 0 in rFailure []

Wrapped (ValidatorMonadT x err f a)Defined in validation-1.3.3 · Data.Validation.Validator

Example6 expressions

>>> import Data.Functor.Identity (Identity(..))>>> import Data.Validation.Validation (Validation(..))>>> import Data.Validation.ValidationMonad (ValidationMonadT(..))>>> import Control.Lens (view, _Wrapped')>>> let v = ValidatorMonadT (\_ -> ValidationMonadT (Identity (Success 1))) :: ValidatorMonadT Int String Identity Int>>> view _Wrapped' v $ 0ValidationMonadT (Identity (Success 1))

AsValidator (ValidatorMonadT x err Identity a) x err aDefined in validation-1.3.3 · Data.Validation.Validator
AsValidatorProfunctor (ValidatorMonadT x err Identity a) err x aDefined in validation-1.3.3 · Data.Validation.Validator
GetValidator (ValidatorMonadT x err Identity a) x err aDefined in validation-1.3.3 · Data.Validation.Validator
GetValidatorProfunctor (ValidatorMonadT x err Identity a) err x aDefined in validation-1.3.3 · Data.Validation.Validator
HasValidator (ValidatorMonadT x err Identity a) x err aDefined in validation-1.3.3 · Data.Validation.Validator
HasValidatorProfunctor (ValidatorMonadT x err Identity a) err x aDefined in validation-1.3.3 · Data.Validation.Validator
Applicative f => ReviewValidator (ValidatorMonadT x err f a) x err aDefined in validation-1.3.3 · Data.Validation.Validator
Applicative f => ReviewValidatorProfunctor (ValidatorMonadT x err f a) err x aDefined in validation-1.3.3 · Data.Validation.Validator
AsValidatorMonadProfunctorT (ValidatorMonadT x err f a) err f x aDefined in validation-1.3.3 · Data.Validation.Validator
AsValidatorMonadT (ValidatorMonadT x err f a) x err f aDefined in validation-1.3.3 · Data.Validation.Validator
GetValidatorMonadProfunctorT (ValidatorMonadT x err f a) err f x aDefined in validation-1.3.3 · Data.Validation.Validator
GetValidatorMonadT (ValidatorMonadT x err f a) x err f aDefined in validation-1.3.3 · Data.Validation.Validator
HasValidatorMonadProfunctorT (ValidatorMonadT x err f a) err f x aDefined in validation-1.3.3 · Data.Validation.Validator
HasValidatorMonadT (ValidatorMonadT x err f a) x err f aDefined in validation-1.3.3 · Data.Validation.Validator
ReviewValidatorMonadProfunctorT (ValidatorMonadT x err f a) err f x aDefined in validation-1.3.3 · Data.Validation.Validator
ReviewValidatorMonadT (ValidatorMonadT x err f a) x err f aDefined in validation-1.3.3 · Data.Validation.Validator
Rewrapped (ValidatorMonadT x err f a) (ValidatorMonadT x' err' f' b)Defined in validation-1.3.3 · Data.Validation.Validator
type Rep (ValidatorMonadT x err f a) = D1 ('MetaData "ValidatorMonadT" "Data.Validation.Validator" "validation-1.3.3-30svjXBZxFa33c5ZrZGHG7" 'True) (C1 ('MetaCons "ValidatorMonadT" 'PrefixI 'False) (S1 ('MetaSel 'Nothing 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (x -> ValidationMonadT err f a))))Defined in validation-1.3.3 · Data.Validation.Validator
type Unwrapped (ValidatorMonadT x err f a) = x -> ValidationMonadT err f aDefined in validation-1.3.3 · Data.Validation.Validator

typetype ValidatorMonad x err a = ValidatorMonadT x err Identity a

ValidatorMonad x err a is ValidatorMonadT x err Identity a.

Short-circuiting monad, Profunctor parameter order

2 declarations

newtypenewtype ValidatorMonadProfunctorT err (f :: Type -> Type) x a

A profunctor validator with short-circuiting monadic semantics.

ValidatorMonadProfunctorT err f x a wraps x -> ValidationMonadT err f a. The Applicative and Monad instances short-circuit on the first Failure. Category composition sequences validators, short-circuiting on the first failure.

Example4 expressions

>>> import Control.Lens(view, _Wrapped')>>> let v = ValidatorMonadProfunctorT (\x -> ValidationMonadT (Identity (Success (x + 1)))) :: ValidatorMonadProfunctorT [String] Identity Int Int>>> let ValidationMonadT (Identity r) = (view _Wrapped' v) 3>>> rSuccess 4

Constructors

ValidatorMonadProfunctorT (x -> ValidationMonadT err f a)

Instances54MonadRWS, Category, Semigroupoid, MonadError, MonadReader, MonadState, …

MonadRWS r w s f => MonadRWS r w s (ValidatorMonadProfunctorT err f x)Defined in validation-1.3.3 · Data.Validation.Validator

Monad f => Category (ValidatorMonadProfunctorT err f)Defined in validation-1.3.3 · Data.Validation.Validator

Example7 expressions

>>> import Control.Lens(view, _Wrapped')>>> import Control.Category(id, (.))>>> import Prelude hiding (id, (.))>>> let v1 = ValidatorMonadProfunctorT (\x -> ValidationMonadT (Identity (Success (x + 1)))) :: ValidatorMonadProfunctorT [String] Identity Int Int>>> let v2 = ValidatorMonadProfunctorT (\x -> ValidationMonadT (Identity (Success (x * 2)))) :: ValidatorMonadProfunctorT [String] Identity Int Int>>> let ValidationMonadT (Identity r) = view _Wrapped' (v2 . v1) 3>>> rSuccess 8

Monad f => Semigroupoid (ValidatorMonadProfunctorT err f)Defined in validation-1.3.3 · Data.Validation.Validator

Kleisli-like composition, short-circuiting on failure.

Example6 expressions

>>> import Control.Lens(view, _Wrapped')>>> import Data.Semigroupoid(Semigroupoid(o))>>> let v1 = ValidatorMonadProfunctorT (\x -> ValidationMonadT (Identity (Success (x + 1)))) :: ValidatorMonadProfunctorT [String] Identity Int Int>>> let v2 = ValidatorMonadProfunctorT (\x -> ValidationMonadT (Identity (Success (x * 2)))) :: ValidatorMonadProfunctorT [String] Identity Int Int>>> let ValidationMonadT (Identity r) = view _Wrapped' (v2 `o` v1) 3>>> rSuccess 8

Monad f => MonadError err (ValidatorMonadProfunctorT err f x)Defined in validation-1.3.3 · Data.Validation.Validator

Example4 expressions

>>> import Control.Lens(view, _Wrapped')>>> import Control.Monad.Error.Class(MonadError(throwError, catchError))>>> let ValidationMonadT (Identity r) = view _Wrapped' (throwError ["oops"] :: ValidatorMonadProfunctorT [String] Identity Int Int) 3>>> rFailure ["oops"]

Example4 expressions

>>> let v = ValidatorMonadProfunctorT (\_ -> ValidationMonadT (Identity (Failure ["e1"]))) :: ValidatorMonadProfunctorT [String] Identity Int Int>>> let h _ = ValidatorMonadProfunctorT (\x -> ValidationMonadT (Identity (Success (x * 2)))) :: ValidatorMonadProfunctorT [String] Identity Int Int>>> let ValidationMonadT (Identity r) = view _Wrapped' (catchError v h) 3>>> rSuccess 6

MonadReader r f => MonadReader r (ValidatorMonadProfunctorT err f x)Defined in validation-1.3.3 · Data.Validation.Validator
MonadState s f => MonadState s (ValidatorMonadProfunctorT err f x)Defined in validation-1.3.3 · Data.Validation.Validator
MonadWriter w f => MonadWriter w (ValidatorMonadProfunctorT err f x)Defined in validation-1.3.3 · Data.Validation.Validator

Monad f => Arrow (ValidatorMonadProfunctorT err f)Defined in validation-1.3.3 · Data.Validation.Validator

Example6 expressions

>>> import Control.Lens(view, _Wrapped')>>> import Control.Arrow(Arrow(arr))>>> import Control.Category((.))>>> import Prelude hiding ((.))>>> let ValidationMonadT (Identity r) = view _Wrapped' (arr (+1) :: ValidatorMonadProfunctorT [String] Identity Int Int) 3>>> rSuccess 4

Monad f => ArrowApply (ValidatorMonadProfunctorT err f)Defined in validation-1.3.3 · Data.Validation.Validator

Example7 expressions

>>> import Control.Lens(view, _Wrapped')>>> import Control.Arrow(ArrowApply(app))>>> import Control.Category((.))>>> import Prelude hiding ((.))>>> let v = ValidatorMonadProfunctorT (\x -> ValidationMonadT (Identity (Success (x + 1)))) :: ValidatorMonadProfunctorT [String] Identity Int Int>>> let ValidationMonadT (Identity r) = view _Wrapped' (app :: ValidatorMonadProfunctorT [String] Identity (ValidatorMonadProfunctorT [String] Identity Int Int, Int) Int) (v, 3)>>> rSuccess 4

Monad f => ArrowChoice (ValidatorMonadProfunctorT err f)Defined in validation-1.3.3 · Data.Validation.Validator

Example7 expressions

>>> import Control.Lens(view, _Wrapped')>>> import Control.Arrow(ArrowChoice(left))>>> import Control.Category((.))>>> import Prelude hiding ((.))>>> let v = ValidatorMonadProfunctorT (\x -> ValidationMonadT (Identity (Success (x + 1)))) :: ValidatorMonadProfunctorT [String] Identity Int Int>>> let ValidationMonadT (Identity r) = view _Wrapped' (left v) (Left 3 :: Either Int String)>>> rSuccess (Left 4)

(Monad f, Monoid err) => ArrowPlus (ValidatorMonadProfunctorT err f)Defined in validation-1.3.3 · Data.Validation.Validator

Example9 expressions

>>> import Control.Lens(view, _Wrapped')>>> import Data.Functor.Alt(Alt((<!>)))>>> import Control.Arrow(ArrowPlus((<+>)))>>> import Control.Category((.))>>> import Prelude hiding ((.))>>> let v1 = ValidatorMonadProfunctorT (\_ -> ValidationMonadT (Identity (Failure ["e1"]))) :: ValidatorMonadProfunctorT [String] Identity Int Int>>> let v2 = ValidatorMonadProfunctorT (\x -> ValidationMonadT (Identity (Success (x * 2)))) :: ValidatorMonadProfunctorT [String] Identity Int Int>>> let ValidationMonadT (Identity r) = view _Wrapped' (v1 <+> v2) 3>>> rSuccess 6

(Monad f, Monoid err) => ArrowZero (ValidatorMonadProfunctorT err f)Defined in validation-1.3.3 · Data.Validation.Validator

Example6 expressions

>>> import Control.Lens(view, _Wrapped')>>> import Control.Arrow(ArrowZero(zeroArrow))>>> import Control.Category((.))>>> import Prelude hiding ((.))>>> let ValidationMonadT (Identity r) = view _Wrapped' (zeroArrow :: ValidatorMonadProfunctorT [String] Identity Int Int) 3>>> rFailure []

Monad f => Choice (ValidatorMonadProfunctorT err f)Defined in validation-1.3.3 · Data.Validation.Validator

Example5 expressions

>>> import Control.Lens(view, _Wrapped')>>> import Data.Profunctor(Choice(left'))>>> let v = ValidatorMonadProfunctorT (\x -> ValidationMonadT (Identity (Success (x + 1)))) :: ValidatorMonadProfunctorT [String] Identity Int Int>>> let ValidationMonadT (Identity r) = view _Wrapped' (left' v) (Left 3 :: Either Int String)>>> rSuccess (Left 4)

Example2 expressions

>>> let ValidationMonadT (Identity r) = view _Wrapped' (left' v) (Right "x" :: Either Int String)>>> rSuccess (Right "x")

Functor f => Strong (ValidatorMonadProfunctorT err f)Defined in validation-1.3.3 · Data.Validation.Validator

Example5 expressions

>>> import Control.Lens(view, _Wrapped')>>> import Data.Profunctor(Strong(first'))>>> let v = ValidatorMonadProfunctorT (\x -> ValidationMonadT (Identity (Success (x + 1)))) :: ValidatorMonadProfunctorT [String] Identity Int Int>>> let ValidationMonadT (Identity r) = view _Wrapped' (first' v) (3, "tag")>>> rSuccess (4,"tag")

Functor f => Profunctor (ValidatorMonadProfunctorT err f)Defined in validation-1.3.3 · Data.Validation.Validator

Example5 expressions

>>> import Control.Lens(view, _Wrapped')>>> import Data.Profunctor(Profunctor(dimap, lmap, rmap))>>> let v = ValidatorMonadProfunctorT (\x -> ValidationMonadT (Identity (Success (x + 1)))) :: ValidatorMonadProfunctorT [String] Identity Int Int>>> let ValidationMonadT (Identity r) = view _Wrapped' (dimap (+10) (*2) v) 3>>> rSuccess 28

Example2 expressions

>>> let ValidationMonadT (Identity r) = view _Wrapped' (lmap (+10) v) 3>>> rSuccess 14

Example2 expressions

>>> let ValidationMonadT (Identity r) = view _Wrapped' (rmap (*2) v) 3>>> rSuccess 8

Monad f => Traversing (ValidatorMonadProfunctorT err f)Defined in validation-1.3.3 · Data.Validation.Validator

Example4 expressions

>>> import Control.Lens(view, _Wrapped')>>> let v = ValidatorMonadProfunctorT (\x -> ValidationMonadT (Identity (Success (x + 1)))) :: ValidatorMonadProfunctorT [String] Identity Int Int>>> let ValidationMonadT (Identity r) = view _Wrapped' (traverse' v) [1, 2, 3]>>> rSuccess [2,3,4]

Functor f => Sieve (ValidatorMonadProfunctorT err f) (ValidationMonadT err f)Defined in validation-1.3.3 · Data.Validation.Validator

Example4 expressions

>>> import Data.Profunctor.Sieve(Sieve(sieve))>>> let v = ValidatorMonadProfunctorT (\x -> ValidationMonadT (Identity (Success (x + 1)))) :: ValidatorMonadProfunctorT [String] Identity Int Int>>> let ValidationMonadT (Identity r) = sieve v 3>>> rSuccess 4

Monad f => Monad (ValidatorMonadProfunctorT err f x)Defined in validation-1.3.3 · Data.Validation.Validator

Example4 expressions

>>> import Control.Lens(view, _Wrapped')>>> let v = ValidatorMonadProfunctorT (\x -> ValidationMonadT (Identity (Success (x + 1)))) :: ValidatorMonadProfunctorT [String] Identity Int Int>>> let ValidationMonadT (Identity r) = view _Wrapped' (v >>= \a -> pure (a * 10)) 3>>> rSuccess 40

Example3 expressions

>>> let f = ValidatorMonadProfunctorT (\_ -> ValidationMonadT (Identity (Failure ["e1"]))) :: ValidatorMonadProfunctorT [String] Identity Int Int>>> let ValidationMonadT (Identity r) = view _Wrapped' (f >>= \a -> pure (a * 10)) 3>>> rFailure ["e1"]

Functor f => Functor (ValidatorMonadProfunctorT err f x)Defined in validation-1.3.3 · Data.Validation.Validator

Example4 expressions

>>> import Control.Lens(view, _Wrapped')>>> let v = ValidatorMonadProfunctorT (\x -> ValidationMonadT (Identity (Success (x + 1)))) :: ValidatorMonadProfunctorT [String] Identity Int Int>>> let ValidationMonadT (Identity r) = (view _Wrapped' (fmap (*10) v)) 3>>> rSuccess 40

MonadFail f => MonadFail (ValidatorMonadProfunctorT err f x)Defined in validation-1.3.3 · Data.Validation.Validator
Monad f => Applicative (ValidatorMonadProfunctorT err f x)Defined in validation-1.3.3 · Data.Validation.Validator
Short-circuiting: unlike Validation, does not accumulate errors.
Example3 expressions
```
>>> import Control.Lens(view, _Wrapped')>>> let ValidationMonadT (Identity r) = view _Wrapped' (pure 42 :: ValidatorMonadProfunctorT [String] Identity Int Int) 0>>> rSuccess 42
```

(Monad f, Monoid err) => Alternative (ValidatorMonadProfunctorT err f x)Defined in validation-1.3.3 · Data.Validation.Validator

Example3 expressions

>>> import Control.Lens(view, _Wrapped')>>> let ValidationMonadT (Identity r) = view _Wrapped' (empty :: ValidatorMonadProfunctorT [String] Identity Int Int) 3>>> rFailure []

(Monad f, Monoid err) => MonadPlus (ValidatorMonadProfunctorT err f x)Defined in validation-1.3.3 · Data.Validation.Validator
MonadIO f => MonadIO (ValidatorMonadProfunctorT err f x)Defined in validation-1.3.3 · Data.Validation.Validator
MonadCont f => MonadCont (ValidatorMonadProfunctorT err f x)Defined in validation-1.3.3 · Data.Validation.Validator

(Monad f, Semigroup err) => Alt (ValidatorMonadProfunctorT err f x)Defined in validation-1.3.3 · Data.Validation.Validator

Example6 expressions

>>> import Control.Lens(view, _Wrapped')>>> import Data.Functor.Alt(Alt((<!>)))>>> let v1 = ValidatorMonadProfunctorT (\_ -> ValidationMonadT (Identity (Failure ["e1"]))) :: ValidatorMonadProfunctorT [String] Identity Int Int>>> let v2 = ValidatorMonadProfunctorT (\x -> ValidationMonadT (Identity (Success (x * 2)))) :: ValidatorMonadProfunctorT [String] Identity Int Int>>> let ValidationMonadT (Identity r) = view _Wrapped' (v1 <!> v2) 3>>> rSuccess 6

Monad f => Apply (ValidatorMonadProfunctorT err f x)Defined in validation-1.3.3 · Data.Validation.Validator

Short-circuiting: stops at the first Failure.

Example6 expressions

>>> import Control.Lens(view, _Wrapped')>>> import Data.Functor.Apply(Apply((<.>)))>>> let f = ValidatorMonadProfunctorT (\x -> ValidationMonadT (Identity (Success (+ x)))) :: ValidatorMonadProfunctorT [String] Identity Int (Int -> Int)>>> let g = ValidatorMonadProfunctorT (\x -> ValidationMonadT (Identity (Success (x * 2)))) :: ValidatorMonadProfunctorT [String] Identity Int Int>>> let ValidationMonadT (Identity r) = (view _Wrapped' (f <.> g)) 3>>> rSuccess 9

Monad f => Bind (ValidatorMonadProfunctorT err f x)Defined in validation-1.3.3 · Data.Validation.Validator

Example5 expressions

>>> import Control.Lens(view, _Wrapped')>>> import Data.Functor.Bind(Bind((>>-)))>>> let v = ValidatorMonadProfunctorT (\x -> ValidationMonadT (Identity (Success (x + 1)))) :: ValidatorMonadProfunctorT [String] Identity Int Int>>> let ValidationMonadT (Identity r) = view _Wrapped' (v >>- \a -> pure (a * 10)) 3>>> rSuccess 40

Functor f => Extend (ValidatorMonadProfunctorT err f x)Defined in validation-1.3.3 · Data.Validation.Validator

Like Validation, a failure is kept: for each input, the result fails where the validator fails, and otherwise succeeds with f applied to the validator. The effects of the validator are run.

Example5 expressions

>>> import Control.Lens(view, _Wrapped')>>> import Data.Functor.Extend(Extend(extended))>>> let v = ValidatorMonadProfunctorT (\x -> ValidationMonadT (Identity (Success (x + 1)))) :: ValidatorMonadProfunctorT [String] Identity Int Int>>> let ValidationMonadT (Identity r) = view _Wrapped' (extended (\_ -> 99) v) 3>>> rSuccess 99

Example3 expressions

>>> let e = ValidatorMonadProfunctorT (\_ -> ValidationMonadT (Identity (Failure ["e"]))) :: ValidatorMonadProfunctorT [String] Identity Int Int>>> let ValidationMonadT (Identity r) = view _Wrapped' (extended (\_ -> 99) e) 3>>> rFailure ["e"]

(Monad f, Monoid err) => Plus (ValidatorMonadProfunctorT err f x)Defined in validation-1.3.3 · Data.Validation.Validator

Example4 expressions

>>> import Control.Lens(view, _Wrapped')>>> import Data.Functor.Plus(Plus(zero))>>> let ValidationMonadT (Identity r) = view _Wrapped' (zero :: ValidatorMonadProfunctorT [String] Identity Int Int) 3>>> rFailure []

Monad f => Selective (ValidatorMonadProfunctorT err f x)Defined in validation-1.3.3 · Data.Validation.Validator

Example5 expressions

>>> import Control.Lens(view, _Wrapped')>>> import Control.Selective(Selective(select))>>> let v = fmap Right (pure 1) :: ValidatorMonadProfunctorT [String] Identity Int (Either Int Int)>>> let ValidationMonadT (Identity r) = view _Wrapped' (select v (pure (+1))) 3>>> rSuccess 1

Generic (ValidatorMonadProfunctorT err f x a)Defined in validation-1.3.3 · Data.Validation.Validator

(Applicative f, Semigroup err) => Semigroup (ValidatorMonadProfunctorT err f x a)Defined in validation-1.3.3 · Data.Validation.Validator

Example5 expressions

>>> import Control.Lens(view, _Wrapped')>>> let v1 = ValidatorMonadProfunctorT (\_ -> ValidationMonadT (Identity (Success 1))) :: ValidatorMonadProfunctorT [String] Identity Int Int>>> let v2 = ValidatorMonadProfunctorT (\_ -> ValidationMonadT (Identity (Success 2))) :: ValidatorMonadProfunctorT [String] Identity Int Int>>> let ValidationMonadT (Identity r) = view _Wrapped' (v1 <> v2) 0>>> rSuccess 1

(Applicative f, Monoid err) => Monoid (ValidatorMonadProfunctorT err f x a)Defined in validation-1.3.3 · Data.Validation.Validator

Example3 expressions

>>> import Control.Lens(view, _Wrapped')>>> let ValidationMonadT (Identity r) = view _Wrapped' (mempty :: ValidatorMonadProfunctorT [String] Identity Int Int) 0>>> rFailure []

Wrapped (ValidatorMonadProfunctorT err f x a)Defined in validation-1.3.3 · Data.Validation.Validator

Example3 expressions

>>> import Control.Lens(view, _Wrapped')>>> let v = ValidatorMonadProfunctorT (\x -> ValidationMonadT (Identity (Success (x + 1)))) :: ValidatorMonadProfunctorT [String] Identity Int Int>>> view _Wrapped' v 3ValidationMonadT (Identity (Success 4))

AsValidator (ValidatorMonadProfunctorT err Identity x a) x err aDefined in validation-1.3.3 · Data.Validation.Validator
AsValidatorProfunctor (ValidatorMonadProfunctorT err Identity x a) err x aDefined in validation-1.3.3 · Data.Validation.Validator
GetValidator (ValidatorMonadProfunctorT err Identity x a) x err aDefined in validation-1.3.3 · Data.Validation.Validator
GetValidatorProfunctor (ValidatorMonadProfunctorT err Identity x a) err x aDefined in validation-1.3.3 · Data.Validation.Validator
HasValidator (ValidatorMonadProfunctorT err Identity x a) x err aDefined in validation-1.3.3 · Data.Validation.Validator
HasValidatorProfunctor (ValidatorMonadProfunctorT err Identity x a) err x aDefined in validation-1.3.3 · Data.Validation.Validator
Applicative f => ReviewValidator (ValidatorMonadProfunctorT err f x a) x err aDefined in validation-1.3.3 · Data.Validation.Validator
Applicative f => ReviewValidatorProfunctor (ValidatorMonadProfunctorT err f x a) err x aDefined in validation-1.3.3 · Data.Validation.Validator
AsValidatorMonadProfunctorT (ValidatorMonadProfunctorT err f x a) err f x aDefined in validation-1.3.3 · Data.Validation.Validator
AsValidatorMonadT (ValidatorMonadProfunctorT err f x a) x err f aDefined in validation-1.3.3 · Data.Validation.Validator
GetValidatorMonadProfunctorT (ValidatorMonadProfunctorT err f x a) err f x aDefined in validation-1.3.3 · Data.Validation.Validator
GetValidatorMonadT (ValidatorMonadProfunctorT err f x a) x err f aDefined in validation-1.3.3 · Data.Validation.Validator
HasValidatorMonadProfunctorT (ValidatorMonadProfunctorT err f x a) err f x aDefined in validation-1.3.3 · Data.Validation.Validator
HasValidatorMonadT (ValidatorMonadProfunctorT err f x a) x err f aDefined in validation-1.3.3 · Data.Validation.Validator
ReviewValidatorMonadProfunctorT (ValidatorMonadProfunctorT err f x a) err f x aDefined in validation-1.3.3 · Data.Validation.Validator
ReviewValidatorMonadT (ValidatorMonadProfunctorT err f x a) x err f aDefined in validation-1.3.3 · Data.Validation.Validator
Rewrapped (ValidatorMonadProfunctorT err f x a) (ValidatorMonadProfunctorT err' f' x' b)Defined in validation-1.3.3 · Data.Validation.Validator
type Rep (ValidatorMonadProfunctorT err f x a) = D1 ('MetaData "ValidatorMonadProfunctorT" "Data.Validation.Validator" "validation-1.3.3-30svjXBZxFa33c5ZrZGHG7" 'True) (C1 ('MetaCons "ValidatorMonadProfunctorT" 'PrefixI 'False) (S1 ('MetaSel 'Nothing 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (x -> ValidationMonadT err f a))))Defined in validation-1.3.3 · Data.Validation.Validator
type Unwrapped (ValidatorMonadProfunctorT err f x a) = x -> ValidationMonadT err f aDefined in validation-1.3.3 · Data.Validation.Validator

typetype ValidatorMonadProfunctor err x a = ValidatorMonadProfunctorT err Identity x a

ValidatorMonadProfunctor is ValidatorMonadProfunctorT specialised to Identity.

Optics — Validator

0 declarations

Classy lenses

classclass GetValidator s x err a | s -> x err a where

Class for types that have a Getter to a Validator.

Example3 expressions

>>> import Control.Lens(view)>>> let Validator f = view getValidator (Validator (\_ -> Success 1) :: Validator Int [String] Int)>>> f 0Success 1

Methods

getValidator :: Getter s (Validator x err a)

Instances4GetValidator

GetValidator (Validator x err a) x err aDefined in validation-1.3.3 · Data.Validation.Validator
GetValidator (ValidatorProfunctor err x a) x err aDefined in validation-1.3.3 · Data.Validation.Validator
GetValidator (ValidatorMonadProfunctorT err Identity x a) x err aDefined in validation-1.3.3 · Data.Validation.Validator
GetValidator (ValidatorMonadT x err Identity a) x err aDefined in validation-1.3.3 · Data.Validation.Validator

classclass GetValidator s x err a => HasValidator s x err a | s -> x err a where

Class for types that have a Lens' to a Validator.

Example3 expressions

>>> import Control.Lens(view)>>> let Validator f = view validator (Validator (\_ -> Success 1) :: Validator Int [String] Int)>>> f 0Success 1

Methods

validator :: Lens' s (Validator x err a)

Instances4HasValidator

HasValidator (Validator x err a) x err aDefined in validation-1.3.3 · Data.Validation.Validator
HasValidator (ValidatorProfunctor err x a) x err aDefined in validation-1.3.3 · Data.Validation.Validator
HasValidator (ValidatorMonadProfunctorT err Identity x a) x err aDefined in validation-1.3.3 · Data.Validation.Validator
HasValidator (ValidatorMonadT x err Identity a) x err aDefined in validation-1.3.3 · Data.Validation.Validator

Classy prisms

classclass ReviewValidator s x err a | s -> x err a where

Class for types that have a Review to a Validator.

Methods

reviewValidator :: Review s (Validator x err a)

Instances4ReviewValidator

ReviewValidator (Validator x err a) x err aDefined in validation-1.3.3 · Data.Validation.Validator
ReviewValidator (ValidatorProfunctor err x a) x err aDefined in validation-1.3.3 · Data.Validation.Validator
Applicative f => ReviewValidator (ValidatorMonadProfunctorT err f x a) x err aDefined in validation-1.3.3 · Data.Validation.Validator
Applicative f => ReviewValidator (ValidatorMonadT x err f a) x err aDefined in validation-1.3.3 · Data.Validation.Validator

classclass ReviewValidator s x err a => AsValidator s x err a | s -> x err a where

Class for types that have a Prism' to a Validator.

Methods

_Validator :: Prism' s (Validator x err a)

Instances4AsValidator

AsValidator (Validator x err a) x err aDefined in validation-1.3.3 · Data.Validation.Validator
AsValidator (ValidatorProfunctor err x a) x err aDefined in validation-1.3.3 · Data.Validation.Validator
AsValidator (ValidatorMonadProfunctorT err Identity x a) x err aDefined in validation-1.3.3 · Data.Validation.Validator
AsValidator (ValidatorMonadT x err Identity a) x err aDefined in validation-1.3.3 · Data.Validation.Validator

Optics — ValidatorProfunctor

0 declarations

Classy lenses

classclass GetValidatorProfunctor s err x a | s -> err x a where

Example1 expression

>>> runVP (view getValidatorProfunctor vpFromInput) 3Success 4

Methods

getValidatorProfunctor :: Getter s (ValidatorProfunctor err x a)

Instances4GetValidatorProfunctor

GetValidatorProfunctor (Validator x err a) err x aDefined in validation-1.3.3 · Data.Validation.Validator
GetValidatorProfunctor (ValidatorProfunctor err x a) err x aDefined in validation-1.3.3 · Data.Validation.Validator
GetValidatorProfunctor (ValidatorMonadProfunctorT err Identity x a) err x aDefined in validation-1.3.3 · Data.Validation.Validator
GetValidatorProfunctor (ValidatorMonadT x err Identity a) err x aDefined in validation-1.3.3 · Data.Validation.Validator

classclass GetValidatorProfunctor s err x a => HasValidatorProfunctor s err x a | s -> err x a where

Example1 expression

>>> runVP (view validatorProfunctor vpFromInput) 3Success 4

Methods

validatorProfunctor :: Lens' s (ValidatorProfunctor err x a)

Instances4HasValidatorProfunctor

HasValidatorProfunctor (Validator x err a) err x aDefined in validation-1.3.3 · Data.Validation.Validator
HasValidatorProfunctor (ValidatorProfunctor err x a) err x aDefined in validation-1.3.3 · Data.Validation.Validator
HasValidatorProfunctor (ValidatorMonadProfunctorT err Identity x a) err x aDefined in validation-1.3.3 · Data.Validation.Validator
HasValidatorProfunctor (ValidatorMonadT x err Identity a) err x aDefined in validation-1.3.3 · Data.Validation.Validator

Classy prisms

classclass ReviewValidatorProfunctor s err x a | s -> err x a where

Example1 expression

>>> runVP (review reviewValidatorProfunctor vpFromInput) 3Success 4

Methods

reviewValidatorProfunctor :: Review s (ValidatorProfunctor err x a)

Instances4ReviewValidatorProfunctor

ReviewValidatorProfunctor (Validator x err a) err x aDefined in validation-1.3.3 · Data.Validation.Validator
ReviewValidatorProfunctor (ValidatorProfunctor err x a) err x aDefined in validation-1.3.3 · Data.Validation.Validator
Applicative f => ReviewValidatorProfunctor (ValidatorMonadProfunctorT err f x a) err x aDefined in validation-1.3.3 · Data.Validation.Validator
Applicative f => ReviewValidatorProfunctor (ValidatorMonadT x err f a) err x aDefined in validation-1.3.3 · Data.Validation.Validator

classclass ReviewValidatorProfunctor s err x a => AsValidatorProfunctor s err x a | s -> err x a where

Example2 expressions

>>> let v = review _ValidatorProfunctor vpFromInput :: ValidatorProfunctor [String] Int Int>>> runVP v 3Success 4

Methods

_ValidatorProfunctor :: Prism' s (ValidatorProfunctor err x a)

Instances4AsValidatorProfunctor

AsValidatorProfunctor (Validator x err a) err x aDefined in validation-1.3.3 · Data.Validation.Validator
AsValidatorProfunctor (ValidatorProfunctor err x a) err x aDefined in validation-1.3.3 · Data.Validation.Validator
AsValidatorProfunctor (ValidatorMonadProfunctorT err Identity x a) err x aDefined in validation-1.3.3 · Data.Validation.Validator
AsValidatorProfunctor (ValidatorMonadT x err Identity a) err x aDefined in validation-1.3.3 · Data.Validation.Validator

Optics — ValidatorMonadT

0 declarations

Classy lenses

classclass GetValidatorMonadT s x err (f :: Type -> Type) a | s -> x err f a where

Example6 expressions

>>> import Data.Functor.Identity (Identity(..))>>> import Data.Validation.Validation (Validation(..))>>> import Data.Validation.ValidationMonad (ValidationMonadT(..))>>> import Control.Lens (view)>>> let v = ValidatorMonadT (\_ -> ValidationMonadT (Identity (Success 1))) :: ValidatorMonadT Int String Identity Int>>> let ValidatorMonadT f = view getValidatorMonadT v in let ValidationMonadT (Identity r) = f 0 in rSuccess 1

Methods

getValidatorMonadT :: Getter s (ValidatorMonadT x err f a)

Instances4GetValidatorMonadT

GetValidatorMonadT (Validator x err a) x err Identity aDefined in validation-1.3.3 · Data.Validation.Validator
GetValidatorMonadT (ValidatorProfunctor err x a) x err Identity aDefined in validation-1.3.3 · Data.Validation.Validator
GetValidatorMonadT (ValidatorMonadProfunctorT err f x a) x err f aDefined in validation-1.3.3 · Data.Validation.Validator
GetValidatorMonadT (ValidatorMonadT x err f a) x err f aDefined in validation-1.3.3 · Data.Validation.Validator

classclass GetValidatorMonadT s x err f a => HasValidatorMonadT s x err (f :: Type -> Type) a | s -> x err f a where

Example6 expressions

>>> import Data.Functor.Identity (Identity(..))>>> import Data.Validation.Validation (Validation(..))>>> import Data.Validation.ValidationMonad (ValidationMonadT(..))>>> import Control.Lens (view)>>> let v = ValidatorMonadT (\_ -> ValidationMonadT (Identity (Success 1))) :: ValidatorMonadT Int String Identity Int>>> let ValidatorMonadT f = view validatorMonadT v in let ValidationMonadT (Identity r) = f 0 in rSuccess 1

Methods

validatorMonadT :: Lens' s (ValidatorMonadT x err f a)

Instances4HasValidatorMonadT

HasValidatorMonadT (Validator x err a) x err Identity aDefined in validation-1.3.3 · Data.Validation.Validator
HasValidatorMonadT (ValidatorProfunctor err x a) x err Identity aDefined in validation-1.3.3 · Data.Validation.Validator
HasValidatorMonadT (ValidatorMonadProfunctorT err f x a) x err f aDefined in validation-1.3.3 · Data.Validation.Validator
HasValidatorMonadT (ValidatorMonadT x err f a) x err f aDefined in validation-1.3.3 · Data.Validation.Validator

Classy prisms

classclass ReviewValidatorMonadT s x err (f :: Type -> Type) a | s -> x err f a where

Methods

reviewValidatorMonadT :: Review s (ValidatorMonadT x err f a)

Instances4ReviewValidatorMonadT

ReviewValidatorMonadT (Validator x err a) x err Identity aDefined in validation-1.3.3 · Data.Validation.Validator
ReviewValidatorMonadT (ValidatorProfunctor err x a) x err Identity aDefined in validation-1.3.3 · Data.Validation.Validator
ReviewValidatorMonadT (ValidatorMonadProfunctorT err f x a) x err f aDefined in validation-1.3.3 · Data.Validation.Validator
ReviewValidatorMonadT (ValidatorMonadT x err f a) x err f aDefined in validation-1.3.3 · Data.Validation.Validator

classclass ReviewValidatorMonadT s x err f a => AsValidatorMonadT s x err (f :: Type -> Type) a | s -> x err f a where

Methods

_ValidatorMonadT :: Prism' s (ValidatorMonadT x err f a)

Instances4AsValidatorMonadT

AsValidatorMonadT (Validator x err a) x err Identity aDefined in validation-1.3.3 · Data.Validation.Validator
AsValidatorMonadT (ValidatorProfunctor err x a) x err Identity aDefined in validation-1.3.3 · Data.Validation.Validator
AsValidatorMonadT (ValidatorMonadProfunctorT err f x a) x err f aDefined in validation-1.3.3 · Data.Validation.Validator
AsValidatorMonadT (ValidatorMonadT x err f a) x err f aDefined in validation-1.3.3 · Data.Validation.Validator

Optics — ValidatorMonadProfunctorT

0 declarations

Classy lenses

classclass GetValidatorMonadProfunctorT s err (f :: Type -> Type) x a | s -> err f x a where

Class for types that have a Getter to a ValidatorMonadProfunctorT.

Methods

getValidatorMonadProfunctorT :: Getter s (ValidatorMonadProfunctorT err f x a)

Instances4GetValidatorMonadProfunctorT

GetValidatorMonadProfunctorT (Validator x err a) err Identity x aDefined in validation-1.3.3 · Data.Validation.Validator
GetValidatorMonadProfunctorT (ValidatorProfunctor err x a) err Identity x aDefined in validation-1.3.3 · Data.Validation.Validator
GetValidatorMonadProfunctorT (ValidatorMonadProfunctorT err f x a) err f x aDefined in validation-1.3.3 · Data.Validation.Validator
GetValidatorMonadProfunctorT (ValidatorMonadT x err f a) err f x aDefined in validation-1.3.3 · Data.Validation.Validator

class

class GetValidatorMonadProfunctorT s err f x a => HasValidatorMonadProfunctorT s err (f :: Type -> Type) x a | s -> err f x a where

Class for types that have a Lens' to a ValidatorMonadProfunctorT.

Methods

validatorMonadProfunctorT :: Lens' s (ValidatorMonadProfunctorT err f x a)

Instances4HasValidatorMonadProfunctorT

HasValidatorMonadProfunctorT (Validator x err a) err Identity x aDefined in validation-1.3.3 · Data.Validation.Validator
HasValidatorMonadProfunctorT (ValidatorProfunctor err x a) err Identity x aDefined in validation-1.3.3 · Data.Validation.Validator
HasValidatorMonadProfunctorT (ValidatorMonadProfunctorT err f x a) err f x aDefined in validation-1.3.3 · Data.Validation.Validator
HasValidatorMonadProfunctorT (ValidatorMonadT x err f a) err f x aDefined in validation-1.3.3 · Data.Validation.Validator

Classy prisms

classclass ReviewValidatorMonadProfunctorT s err (f :: Type -> Type) x a | s -> err f x a where

Class for types that have a Review to a ValidatorMonadProfunctorT.

Methods

reviewValidatorMonadProfunctorT :: Review s (ValidatorMonadProfunctorT err f x a)

Instances4ReviewValidatorMonadProfunctorT

ReviewValidatorMonadProfunctorT (Validator x err a) err Identity x aDefined in validation-1.3.3 · Data.Validation.Validator
ReviewValidatorMonadProfunctorT (ValidatorProfunctor err x a) err Identity x aDefined in validation-1.3.3 · Data.Validation.Validator
ReviewValidatorMonadProfunctorT (ValidatorMonadProfunctorT err f x a) err f x aDefined in validation-1.3.3 · Data.Validation.Validator
ReviewValidatorMonadProfunctorT (ValidatorMonadT x err f a) err f x aDefined in validation-1.3.3 · Data.Validation.Validator

class

class ReviewValidatorMonadProfunctorT s err f x a => AsValidatorMonadProfunctorT s err (f :: Type -> Type) x a | s -> err f x a where

Class for types that have a Prism' to a ValidatorMonadProfunctorT.

Methods

_ValidatorMonadProfunctorT :: Prism' s (ValidatorMonadProfunctorT err f x a)

Instances4AsValidatorMonadProfunctorT

AsValidatorMonadProfunctorT (Validator x err a) err Identity x aDefined in validation-1.3.3 · Data.Validation.Validator
AsValidatorMonadProfunctorT (ValidatorProfunctor err x a) err Identity x aDefined in validation-1.3.3 · Data.Validation.Validator
AsValidatorMonadProfunctorT (ValidatorMonadProfunctorT err f x a) err f x aDefined in validation-1.3.3 · Data.Validation.Validator
AsValidatorMonadProfunctorT (ValidatorMonadT x err f a) err f x aDefined in validation-1.3.3 · Data.Validation.Validator

Constructing validators from prisms

6 declarations

value(-->) :: ReviewValidator r s t a' => APrism s t a b -> (a -> a') -> r

Construct a validator from a prism, mapping the focus with a function. The validator succeeds with the function applied to the focus of the prism when it matches, and otherwise fails with the input, retyped to t (see matching).

p --> f is f <$> match p, and match p is p --> id. As with match, the result can be any validator with a ReviewValidator instance.

Example1 expression

>>> runV (_Just --> (+ 1) :: Validator (Maybe Int) (Maybe Int) Int) (Just 1)Success 2

Example1 expression

>>> runV (_Just --> (+ 1) :: Validator (Maybe Int) (Maybe Int) Int) NothingFailure Nothing

--> is infixl 6. It binds more loosely than ., so prisms compose without parentheses, and more tightly than <!>, so a validator can be written as one case per constructor. The first case that matches wins, and the input is returned as the failure if none match.

Example2 expressions

>>> let v = _Left --> length <!> _Right . _Just --> negate :: Validator (Either String (Maybe Int)) (Either String (Maybe Int)) Int>>> runV v (Left "abc")Success 3

Example1 expression

>>> runV v (Right (Just 5))Success (-5)

Example1 expression

>>> runV v (Right Nothing)Failure (Right Nothing)

The other validators are written the same way. Their <!> accumulates errors, which requires the input type to be a Semigroup (here Either).

Example2 expressions

>>> let v = _Left --> length <!> _Right . _Just --> negate :: ValidatorProfunctor (Either String (Maybe Int)) (Either String (Maybe Int)) Int>>> runVP v (Right (Just 5))Success (-5)

Example1 expression

>>> runVP v (Right Nothing)Failure (Right Nothing)

Example2 expressions

>>> let v = _Left --> length <!> _Right . _Just --> negate :: ValidatorMonad (Either String (Maybe Int)) (Either String (Maybe Int)) Int>>> runVM v (Right (Just 5))Success (-5)

Example1 expression

>>> runVM v (Right Nothing)Failure (Right Nothing)

Example2 expressions

>>> let v = _Left --> length <!> _Right . _Just --> negate :: ValidatorMonadProfunctor (Either String (Maybe Int)) (Either String (Maybe Int)) Int>>> runVMP v (Right (Just 5))Success (-5)

Example1 expression

>>> runVMP v (Right Nothing)Failure (Right Nothing)

valuematch :: ReviewValidator r s t a => APrism s t a b -> r

Construct a validator from a prism. The validator succeeds with the focus of the prism when it matches, and otherwise fails with the input, retyped to t (see matching).

The result can be any validator with a ReviewValidator instance, which determines the validator type from the result type. match p is p --> id.

Example2 expressions

>>> let Validator f = match _Just :: Validator (Maybe Int) (Maybe Int) Int>>> f (Just 3)Success 3

Example1 expression

>>> f NothingFailure Nothing

A type-changing prism fails with the retyped input.

Example2 expressions

>>> let Validator f = match _Left :: Validator (Either Int String) (Either Bool String) Int>>> f (Left 1)Success 1

Example1 expression

>>> f (Right "x")Failure (Right "x")

Match each constructor with its own prism, and combine the validators with <!>. The first prism that matches wins, and the input is returned as the failure if none match. The result type annotation chooses the validator; the specialisations matchValidator, matchValidatorProfunctor, matchValidatorMonad and matchValidatorMonadProfunctor avoid it.

Example2 expressions

>>> let v = match _Left <!> (show <$> match (_Right . _Just)) :: Validator (Either String (Maybe Int)) (Either String (Maybe Int)) String>>> runV v (Left "abc")Success "abc"

Example1 expression

>>> runV v (Right (Just 5))Success "5"

Example1 expression

>>> runV v (Right Nothing)Failure (Right Nothing)

ValidatorProfunctor and ValidatorMonadProfunctorT take the error type first.

Example2 expressions

>>> let v = match _Left <!> (show <$> match (_Right . _Just)) :: ValidatorProfunctor (Either String (Maybe Int)) (Either String (Maybe Int)) String>>> runVP v (Right (Just 5))Success "5"

Example1 expression

>>> runVP v (Right Nothing)Failure (Right Nothing)

Example2 expressions

>>> let v = match _Left <!> (show <$> match (_Right . _Just)) :: ValidatorMonad (Either String (Maybe Int)) (Either String (Maybe Int)) String>>> runVM v (Right (Just 5))Success "5"

Example1 expression

>>> runVM v (Right Nothing)Failure (Right Nothing)

Example2 expressions

>>> let v = match _Left <!> (show <$> match (_Right . _Just)) :: ValidatorMonadProfunctor (Either String (Maybe Int)) (Either String (Maybe Int)) String>>> runVMP v (Right (Just 5))Success "5"

Example1 expression

>>> runVMP v (Right Nothing)Failure (Right Nothing)

The monadic validators work with any Applicative.

Example2 expressions

>>> let ValidatorMonadT f = match _Just :: ValidatorMonadT (Maybe Int) (Maybe Int) [] Int>>> let ValidationMonadT r = f (Just 3) in r[Success 3]

Example2 expressions

>>> let ValidatorMonadProfunctorT f = match _Just :: ValidatorMonadProfunctorT (Maybe Int) Maybe (Maybe Int) Int>>> let ValidationMonadT r = f Nothing in rJust (Failure Nothing)

valuematchValidator :: APrism s t a b -> Validator s t a

match specialised to Validator, so no type annotation is needed.

Combine one prism per constructor with <!>. Validator does not accumulate errors, so the input type need not be a Semigroup; if no prism matches, the last failure is returned.

Example2 expressions

>>> let v = matchValidator _Left <!> (show <$> matchValidator (_Right . _Just))>>> runV v (Left "abc")Success "abc"

Example1 expression

>>> runV v (Right (Just 5))Success "5"

Example1 expression

>>> runV v (Right (Nothing :: Maybe Int))Failure (Right Nothing)

Example1 expression

>>> runV (matchValidator _Just) (Nothing :: Maybe Int)Failure Nothing

valuematchValidatorProfunctor :: APrism s t a b -> ValidatorProfunctor t s a

match specialised to ValidatorProfunctor, so no type annotation is needed.

The input type is also the error type, and <!> accumulates errors, so combining with <!> requires the input type to be a Semigroup (here Either).

Example2 expressions

>>> let v = matchValidatorProfunctor _Left <!> (show <$> matchValidatorProfunctor (_Right . _Just))>>> runVP v (Left "abc")Success "abc"

Example1 expression

>>> runVP v (Right (Just 5))Success "5"

Example1 expression

>>> runVP v (Right (Nothing :: Maybe Int))Failure (Right Nothing)

The input can be adapted with lmap.

Example1 expression

>>> runVP (lmap Just (matchValidatorProfunctor _Just)) (3 :: Int)Success 3

valuematchValidatorMonad :: APrism s t a b -> ValidatorMonad s t a

match specialised to ValidatorMonad, so no type annotation is needed.

Combining with <!> requires the input type to be a Semigroup (here Either). The Monad instance short-circuits, so a match can decide the next validator.

Example2 expressions

>>> let v = matchValidatorMonad _Left <!> (show <$> matchValidatorMonad (_Right . _Just))>>> runVM v (Left "abc")Success "abc"

Example1 expression

>>> runVM v (Right (Just 5))Success "5"

Example1 expression

>>> runVM v (Right (Nothing :: Maybe Int))Failure (Right Nothing)

Example2 expressions

>>> let w = matchValidatorMonad _Just >>= \n -> if n > (0 :: Int) then pure n else throwError (Just n)>>> runVM w (Just 3)Success 3

Example1 expression

>>> runVM w (Just (-3))Failure (Just (-3))

Example1 expression

>>> runVM w NothingFailure Nothing

valuematchValidatorMonadProfunctor

:: APrism s t a b
-> ValidatorMonadProfunctor t s a

match specialised to ValidatorMonadProfunctor, so no type annotation is needed.

Combining with <!> requires the input type to be a Semigroup (here Either).

Example2 expressions

>>> let v = matchValidatorMonadProfunctor _Left <!> (show <$> matchValidatorMonadProfunctor (_Right . _Just))>>> runVMP v (Left "abc")Success "abc"

Example1 expression

>>> runVMP v (Right (Just 5))Success "5"

Example1 expression

>>> runVMP v (Right (Nothing :: Maybe Int))Failure (Right Nothing)

Constructing prisms from validators

2 declarations

value(<--) :: GetValidator v s t a => AReview t b -> v -> Prism s t a b

An operator for unmatch. r <-- v is unmatch r v.

<-- is infixr 2. It binds more loosely than ., -->, <$> and <!>, so the review and the validator can each be written without parentheses.

Example3 expressions

>>> import Control.Lens(Prism, matching)>>> let p = _Right . _Just <-- length <$> matchValidator _Left <!> matchValidator (_Right . _Just) :: Prism (Either String (Maybe Int)) (Either String (Maybe Int)) Int Int>>> matching p (Left "abc")Right 3

Example1 expression

>>> matching p (Right (Just 5))Right 5

Example1 expression

>>> matching p (Right Nothing)Left (Right Nothing)

Example1 expression

>>> review p 7Right (Just 7)

valueunmatch :: GetValidator v s t a => AReview t b -> v -> Prism s t a b

Construct a prism from a review and a validator. The prism matches when the validator succeeds, and otherwise returns the failure, retyped to t (see matching). It is built with the review.

unmatch is an inverse of match. For a prism p, unmatch p (match p) is p, and for a validator v, match (unmatch r v) is v. The prism is lawful when the validator succeeds with b on review r b, and fails with its input otherwise.

The result is a Prism, so it can be used directly with Control.Lens.^?, review and other optics, and the review can be any AReview, including a Prism or an Control.Lens.Iso.

The validator can be any validator with a GetValidator instance.

Example4 expressions

>>> import Control.Lens(Prism, matching, withPrism)>>> let positive = Validator (\n -> if n > 0 then Success n else Failure n) :: Validator Int Int Int>>> let p = unmatch id positive>>> matching p 5Right 5

Example1 expression

>>> matching p (-5)Left (-5)

Example1 expression

>>> 5 ^? pJust 5

Example1 expression

>>> review p 77

A type-changing prism.

Example2 expressions

>>> let p = unmatch _Left (matchValidator _Left) :: Prism (Either Int String) (Either Bool String) Int Bool>>> matching p (Left 1)Right 1

Example1 expression

>>> matching p (Right "x")Left (Right "x")

Example1 expression

>>> withPrism p (\build _ -> build True)Left True

match recovers the validator.

Example1 expression

>>> runV (matchValidator (unmatch _Just (matchValidator _Just))) (Just 3)Success 3

Example1 expression

>>> runV (matchValidator (unmatch _Just (matchValidator _Just))) (Nothing :: Maybe Int)Failure Nothing

The other validators are written the same way.

Example2 expressions

>>> let p = unmatch _Right (matchValidatorProfunctor _Right) :: Prism (Either String Int) (Either String Int) Int Int>>> matching p (Left "x")Left (Left "x")

Example2 expressions

>>> let p = unmatch _Just (matchValidatorMonad _Just >>= \n -> if n > (0 :: Int) then pure n else throwError (Just n))>>> matching p (Just 3)Right 3

Example1 expression

>>> matching p (Just (-3))Left (Just (-3))

Example2 expressions

>>> let p = unmatch _Just (matchValidatorMonadProfunctor _Just)>>> matching p (Nothing :: Maybe Int)Left Nothing