Predicate.Refined

Simple refinement type with only one type and a predicate

Refined

data Refined p a

a simple refinement type that ensures the predicate 'p' holds for the type 'a'

>>> prtRefinedIO @(Between 10 14 Id) oz 13
Right (Refined {unRefined = 13})

>>> prtRefinedIO @(Between 10 14 Id) oz 99
Left FalseP

>>> prtRefinedIO @(Last Id >> Len == 4) oz ["one","two","three","four"]
Right (Refined {unRefined = ["one","two","three","four"]})

>>> prtRefinedIO @(Re "^\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}$" Id) oz "141.213.1.99"
Right (Refined {unRefined = "141.213.1.99"})

>>> prtRefinedIO @(Re "^\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}$" Id) oz "141.213.1"
Left FalseP

>>> prtRefinedIO @(Map (ReadP Int Id) (Resplit "\\." Id) >> Guard (PrintF "bad length: found %d" Len) (Len == 4) >> 'True) oz "141.213.1"
Left (FailP "bad length: found 3")

>>> prtRefinedIO @(Map (ReadP Int Id) (Resplit "\\." Id) >> Guard (PrintF "bad length: found %d" Len) (Len == 4) >> GuardsN (PrintT "octet %d out of range %d" Id) 4 (Between 0 255 Id) >> 'True) oz "141.213.1.444"
Left (FailP "octet 3 out of range 444")

>>> prtRefinedIO @(Map (ReadP Int Id) (Resplit "\\." Id) >> Guard (PrintF "bad length: found %d" Len) (Len == 4) >> GuardsN (PrintT "octet %d out of range %d" Id) 4 (Between 0 255 Id) >> 'True) oz "141.213.1x34.444"
Left (FailP "ReadP Int (1x34)")

>>> prtRefinedIO @(Map ('[Id] >> ReadP Int Id) Id >> Luhn Id) oz "12344"
Right (Refined {unRefined = "12344"})

>>> prtRefinedIO @(Map ('[Id] >> ReadP Int Id) Id >> Luhn Id) oz "12340"
Left FalseP

>>> prtRefinedIO @(Any (Prime Id) Id) oz [11,13,17,18]
Right (Refined {unRefined = [11,13,17,18]})

>>> prtRefinedIO @(All (Prime Id) Id) oz [11,13,17,18]
Left FalseP

>>> prtRefinedIO @(Snd Id !! Fst Id >> Len > 5) oz (2,["abc","defghij","xyzxyazsfd"])
Right (Refined {unRefined = (2,["abc","defghij","xyzxyazsfd"])})

>>> prtRefinedIO @(Snd Id !! Fst Id >> Len > 5) oz (27,["abc","defghij","xyzxyazsfd"])
Left (FailP "(!!) index not found")

>>> prtRefinedIO @(Snd Id !! Fst Id >> Len <= 5) oz (2,["abc","defghij","xyzxyazsfd"])
Left FalseP

Instances

Eq a => Eq (Refined p a)

Defined in Predicate.Refined

Methods

(==) :: Refined p a -> Refined p a -> Bool

(/=) :: Refined p a -> Refined p a -> Bool

(RefinedC p a, Read a) => Read (Refined p a)

Read instance for Refined

>>> reads @(Refined (Between 0 255 Id) Int) "Refined {unRefined = 254}"
[(Refined {unRefined = 254},"")]

>>> reads @(Refined (Between 0 255 Id) Int) "Refined {unRefined = 300}"
[]

Defined in Predicate.Refined

Methods

readsPrec :: Int -> ReadS (Refined p a)

readList :: ReadS [Refined p a]

readPrec :: ReadPrec (Refined p a)

readListPrec :: ReadPrec [Refined p a]

Show a => Show (Refined p a)

Defined in Predicate.Refined

Methods

showsPrec :: Int -> Refined p a -> ShowS

show :: Refined p a -> String

showList :: [Refined p a] -> ShowS

RefinedC p String => IsString (Refined p String)

Defined in Predicate.Refined

Methods

fromString :: String -> Refined p String

Generic (Refined p a)

Defined in Predicate.Refined

Associated Types

type Rep (Refined p a) :: Type -> Type

Methods

from :: Refined p a -> Rep (Refined p a) x

to :: Rep (Refined p a) x -> Refined p a

Lift a => Lift (Refined p a)

Defined in Predicate.Refined

Methods

lift :: Refined p a -> Q Exp

(RefinedC p a, Binary a) => Binary (Refined p a)

Binary instance for Refined

>>> import Data.Time
>>> import Control.Lens
>>> import Control.Arrow ((+++))
>>> type K1 = Refined (ReadP Day Id >> 'True) String
>>> type K2 = Refined (Between (ReadP Day "2019-05-30") (ReadP Day "2019-06-01") (ReadP Day Id)) String
>>> r = unsafeRefined' oz "2019-04-23" :: K1
>>> removeAnsi $ (view _3 +++ view _3) $ B.decodeOrFail @K1 (B.encode r)
Refined {unRefined = "2019-04-23"}

>>> removeAnsi $ (view _3 +++ view _3) $ B.decodeOrFail @K2 (B.encode r)
Refined:FalseP
False 2019-05-30 <= 2019-04-23
|
+- P ReadP Day 2019-04-23
|  |
|  `- P Id "2019-04-23"
|
+- P ReadP Day 2019-05-30
|  |
|  `- P '2019-05-30
|
`- P ReadP Day 2019-06-01
   |
   `- P '2019-06-01

Defined in Predicate.Refined

Methods

put :: Refined p a -> Put

get :: Get (Refined p a)

putList :: [Refined p a] -> Put

(RefinedC p a, FromJSON a) => FromJSON (Refined p a)

FromJSON instance for Refined

>>> :set -XOverloadedStrings
>>> import qualified Data.Aeson as A
>>> A.eitherDecode' @(Refined (Between 10 14 Id) Int) "13"
Right (Refined {unRefined = 13})

>>> removeAnsi $ A.eitherDecode' @(Refined (Between 10 14 Id) Int) "16"
Error in $: Refined:FalseP
False 16 <= 14
|
+- P Id 16
|
+- P '10
|
`- P '14

Defined in Predicate.Refined

Methods

parseJSON :: Value -> Parser (Refined p a)

parseJSONList :: Value -> Parser [Refined p a]

(RefinedC p a, Hashable a) => Hashable (Refined p a)

Hashable instance for Refined

Defined in Predicate.Refined

Methods

hashWithSalt :: Int -> Refined p a -> Int

hash :: Refined p a -> Int

ToJSON a => ToJSON (Refined p a)

ToJSON instance for Refined

Defined in Predicate.Refined

Methods

toJSON :: Refined p a -> Value

toEncoding :: Refined p a -> Encoding

toJSONList :: [Refined p a] -> Value

toEncodingList :: [Refined p a] -> Encoding

type Rep (Refined p a)

Defined in Predicate.Refined

type Rep (Refined p a) = D1 (MetaData "Refined" "Predicate.Refined" "predicate-typed-0.6.2.0-IoKn08I3B6tDFtG6D3yS1n" True) (C1 (MetaCons "Refined" PrefixI True) (S1 (MetaSel (Just "unRefined") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type RefinedC p a = (PP p a ~ Bool, P p a)

the constraints that Refined must adhere to

newRefined :: forall p a m. (MonadEval m, RefinedC p a) => POpts -> a -> m ((BoolP, (String, String)), Maybe (Refined p a))

returns a Refined value if 'a' is valid for the predicate 'p'

newtype RefinedT m a

Constructors

RefinedT

Fields

• unRefinedT :: ExceptT String (WriterT [String] m) a

Instances

MonadTrans RefinedT

Defined in Predicate.Refined

Methods

lift :: Monad m => m a -> RefinedT m a

Monad m => MonadError String (RefinedT m)

Defined in Predicate.Refined

Methods

throwError :: String -> RefinedT m a

catchError :: RefinedT m a -> (String -> RefinedT m a) -> RefinedT m a

Monad m => Monad (RefinedT m)

Defined in Predicate.Refined

Methods

(>>=) :: RefinedT m a -> (a -> RefinedT m b) -> RefinedT m b

(>>) :: RefinedT m a -> RefinedT m b -> RefinedT m b

return :: a -> RefinedT m a

fail :: String -> RefinedT m a

Functor m => Functor (RefinedT m)

Defined in Predicate.Refined

Methods

fmap :: (a -> b) -> RefinedT m a -> RefinedT m b

(<$) :: a -> RefinedT m b -> RefinedT m a

Monad m => Applicative (RefinedT m)

Defined in Predicate.Refined

Methods

pure :: a -> RefinedT m a

(<*>) :: RefinedT m (a -> b) -> RefinedT m a -> RefinedT m b

liftA2 :: (a -> b -> c) -> RefinedT m a -> RefinedT m b -> RefinedT m c

(*>) :: RefinedT m a -> RefinedT m b -> RefinedT m b

(<*) :: RefinedT m a -> RefinedT m b -> RefinedT m a

MonadIO m => MonadIO (RefinedT m)

Defined in Predicate.Refined

Methods

liftIO :: IO a -> RefinedT m a

MonadCont m => MonadCont (RefinedT m)

Defined in Predicate.Refined

Methods

callCC :: ((a -> RefinedT m b) -> RefinedT m a) -> RefinedT m a

Monad m => MonadWriter [String] (RefinedT m)

Defined in Predicate.Refined

Methods

writer :: (a, [String]) -> RefinedT m a

tell :: [String] -> RefinedT m ()

listen :: RefinedT m a -> RefinedT m (a, [String])

pass :: RefinedT m (a, [String] -> [String]) -> RefinedT m a

(Show1 m, Show a) => Show (RefinedT m a)

Defined in Predicate.Refined

Methods

showsPrec :: Int -> RefinedT m a -> ShowS

show :: RefinedT m a -> String

showList :: [RefinedT m a] -> ShowS

print methods

prtRefinedIO :: forall p a. RefinedC p a => POpts -> a -> IO (Either BoolP (Refined p a))

same as newRefined but prints the results

prtRefinedTIO :: (MonadIO m, Show a) => RefinedT m a -> m ()

prtRefinedT :: (MonadIO m, Show a) => RefinedT Identity a -> m ()

create methods

withRefinedT :: forall p m a b. (Monad m, RefinedC p a) => POpts -> a -> (Refined p a -> RefinedT m b) -> RefinedT m b

invokes the callback with the Refined value if 'a' is valid for the predicate 'p'

withRefinedTIO :: forall p m a b. (MonadIO m, RefinedC p a) => POpts -> a -> (Refined p a -> RefinedT m b) -> RefinedT m b

newRefinedT :: forall p a m. (RefinedC p a, Monad m) => POpts -> a -> RefinedT m (Refined p a)

returns a wrapper RefinedT around a possible Refined value if 'a' is valid for the predicate 'p'

newRefinedTIO :: forall p a m. (RefinedC p a, MonadIO m) => POpts -> a -> RefinedT m (Refined p a)

QuickCheck method

arbRefined :: forall p a. (Arbitrary a, RefinedC p a) => POpts -> Gen (Refined p a)

arbitrary value for Refined

manipulate RefinedT values

convertRefinedT :: forall m p p1 a a1. (RefinedC p1 a1, Monad m) => POpts -> (a -> a1) -> RefinedT m (Refined p a) -> RefinedT m (Refined p1 a1)

attempts to lift a refinement type to another refinement type by way of transformation function you can control both the predicate and the type

unRavelT :: RefinedT m a -> m (Either String a, [String])

unRavelTIO :: RefinedT IO a -> IO (Either String a, [String])

rapply :: forall m p a. (RefinedC p a, Monad m) => POpts -> (a -> a -> a) -> RefinedT m (Refined p a) -> RefinedT m (Refined p a) -> RefinedT m (Refined p a)

binary operation applied to two RefinedT values

rapply0 :: forall p a m. (RefinedC p a, Monad m) => POpts -> (a -> a -> a) -> a -> a -> RefinedT m (Refined p a)

takes two values and lifts them into RefinedT and then applies the binary operation

rapplyLift :: forall m p a. (RefinedC p a, Monad m) => POpts -> (a -> a -> a) -> Refined p a -> Refined p a -> RefinedT m (Refined p a)

same as rapply except we already have valid Refined values as input

unsafe create methods

unsafeRefined :: forall p a. a -> Refined p a

a way to unsafely create a Refined value

unsafeRefined' :: forall p a. (RefinedC p a, HasCallStack) => POpts -> a -> Refined p a

a way to unsafely create a Refined value but run the predicate