Data.Menshen

Data Validation inspired by JSR305

How to use this library

This library is designed for validate haskell records, such as in configurations or web request parameters.

Usage:

{-# LANGUAGE RecordWildCards #-}
module Main where
import Data.Menshen
data Body = Body
  { name :: String
  , age  :: Int
  } deriving Show

valifyBody :: Validator Body
valifyBody = \ma -> do
  Body{..} <- ma
  Body
    <$> name ?: pattern "^[a-z]{3,6}$"
    <*> age  ?: minInt 1 . maxInt 150

makeBody :: String -> Int -> Either String Body
makeBody name age = Body{..} ?: valifyBody

main = do
  print $ makeBody "daniel" 15

Useage in Record parsing process:

instance HasValid Parser where
  invalid = fail . toI18n

instance FromJSON Body where
  parseJSON = withObject "Body" $ \v -> Body
    <$> v .: "name" ? pattern "^[a-z]{3,6}$"
    <*> v .: "age"  ? minInt 1 . maxInt 150

Definition

class Monad m => HasValid m where

Define how invalid infomation passed to upper layer.

Minimal complete definition

Nothing

Methods

invalid :: HasI18n a => a -> m b

Instances

HasValid (Either String)

Defined in Data.Menshen

Methods

invalid :: HasI18n a => a -> Either String b

type Validator a = forall m. HasValid m => m a -> m a

Validator, use to define detailed validation check.

data ValidationException

Validation Error Message

Constructors

ShouldBeFalse

ShouldBeTrue

ShouldNull

ShouldNotNull

InvalidSize Word64 Word64

InvalidPositive

InvalidPositiveOrZero

InvalidNegative

InvalidNegativeOrZero

InvalidMax Integer

InvalidMin Integer

InvalidEmail

InvalidNotBlank

InvalidNotEmpty

InvalidPast

InvalidFuture

InvalidPastOrPresent

InvalidFutureOrPresent

InvalidDecimalMax Scientific

InvalidDecimalMin Scientific

InvalidDigits Word8 Word8

InvalidPattern String

Instances

Show ValidationException

Defined in Data.Menshen

Methods

showsPrec :: Int -> ValidationException -> ShowS

show :: ValidationException -> String

showList :: [ValidationException] -> ShowS

HasI18n ValidationException

Defined in Data.Menshen

Methods

toI18n :: ValidationException -> String

class HasI18n a where

Plan for i18n translate, now just for english.

Methods

toI18n :: a -> String

Instances

HasI18n ValidationException

Defined in Data.Menshen

Methods

toI18n :: ValidationException -> String

Validation Functions

class HasValidSize a where

Length checker bundle

Minimal complete definition

getLength

Methods

size :: (Word64, Word64) -> Validator a

Size validation

notEmpty :: Validator a

Assert not empty

notBlank :: Validator a

Assert not blank

getLength :: a -> Word64

calculate length from value

Instances

HasValidSize Text

Defined in Data.Menshen

Methods

size :: (Word64, Word64) -> Validator Text

notEmpty :: Validator Text

notBlank :: Validator Text

getLength :: Text -> Word64

HasValidSize Text

Defined in Data.Menshen

Methods

size :: (Word64, Word64) -> Validator Text

notEmpty :: Validator Text

notBlank :: Validator Text

getLength :: Text -> Word64

HasValidSize [a]

Defined in Data.Menshen

Methods

size :: (Word64, Word64) -> Validator [a]

notEmpty :: Validator [a]

notBlank :: Validator [a]

getLength :: [a] -> Word64

notNull :: Validator (Maybe a)

Assert not null

assertNull :: Validator (Maybe a)

Assert null

assertTrue :: Validator Bool

Assert true

assertFalse :: Validator Bool

Assert false

positive :: (Eq a, Num a) => Validator a

Positive validation

positiveOrZero :: (Eq a, Num a) => Validator a

Positive or zero validation

negative :: (Eq a, Num a) => Validator a

Negative validation

negativeOrZero :: (Eq a, Num a) => Validator a

Negative or zero validation

minInt :: Integral a => a -> Validator a

Minimum int validation

maxInt :: Integral a => a -> Validator a

Maximum int validation

minDecimal :: RealFloat a => a -> Validator a

Minimum int validation

maxDecimal :: RealFloat a => a -> Validator a

Maximum decimal validation

pattern :: RegexLike Regex a => String -> Validator a

Regular expression validation

email :: RegexLike Regex a => Validator a

Email validation

Validation Operations

(?) :: a -> (a -> b) -> b infixl 5

apply record validation to the value

valify :: HasValid m => a -> Validator a -> m a

lift value a to validation context and check if it is valid.

(?:) :: HasValid m => a -> Validator a -> m a infixl 5

lift value a to validation context and check if it is valid.

Reexport Functions

(=~) :: (RegexMaker Regex CompOption ExecOption source, RegexContext Regex source1 target) => source1 -> source -> target

This is the pure functional matching operator. If the target cannot be produced then some empty result will be returned. If there is an error in processing, then error will be called.