Data.Predicate

Documentation

type Predicate a f t = a -> Result f t

A predicate is a function of some value of type a to a Result, i.e. a Bool-like value with Okay as True and Fail as False, which carries additional data in each branch.

data Result f t

A Bool-like type where each branch--Fail and Okay--carries some metadata.

Constructors

Fail f

Okay !Double t

Instances

Monad (Result f)

Functor (Result f)

Applicative (Result f)

(Eq f, Eq t) => Eq (Result f t)

(Ord f, Ord t) => Ord (Result f t)

(Show f, Show t) => Show (Result f t)

result :: (f -> a) -> (Double -> t -> a) -> Result f t -> a

fromEither :: Either f t -> Result f t

toEither :: Result f t -> Either f t

newtype ResultT f m t

Constructors

ResultT

Fields

runResultT :: m (Result f t)

Instances

MonadTrans (ResultT f)

Monad m => Monad (ResultT f m)

Monad m => Functor (ResultT f m)

Monad m => Applicative (ResultT f m)

MonadIO m => MonadIO (ResultT f m)

resultT :: Monad m => (f -> m a) -> (Double -> t -> m a) -> ResultT f m t -> m a

resultT' :: Monad m => (f -> m a) -> (t -> m a) -> ResultT f m t -> m a

mapResultT :: (m (Result f t) -> n (Result f' t')) -> ResultT f m t -> ResultT f' n t'

hoistResult :: Monad m => Result f t -> ResultT f m t

okay :: Monad m => Double -> t -> ResultT f m t

throwF :: Monad m => f -> ResultT f m t

constant :: t -> Predicate a f t

A predicate which always returns Okay with the given value as metadata.

failure :: f -> Predicate a f t

A predicate which always returns Fail with the given value as metadata.

true :: Predicate a f ()

false :: Predicate a () t

and :: Predicate a f t -> Predicate a f t' -> Predicate a f (t ::: t')

A predicate corresponding to the logical AND connective of two predicate.

or :: Predicate a f t -> Predicate a f t -> Predicate a f t

A predicate corresponding to the logical OR connective of two predicates. It requires the metadata of each Okay branch to be of the same type.

If both arguments evaluate to Okay the one with the smaller "delta" will be preferred, or--if equal--the left-hand argument.

orElse :: Predicate a f t -> Predicate a f t' -> Predicate a f (Either t t')

A predicate corresponding to the logical OR connective of two predicates. The metadata of each Okay branch can be of different types.

If both arguments evaluate to Okay the one with the smaller "delta" will be preferred, or--if equal--the left-hand argument.

(.&.) :: Predicate a f t -> Predicate a f t' -> Predicate a f (t ::: t')

A predicate corresponding to the logical AND connective of two predicate.

(.|.) :: Predicate a f t -> Predicate a f t -> Predicate a f t

A predicate corresponding to the logical OR connective of two predicates. It requires the metadata of each Okay branch to be of the same type.

If both arguments evaluate to Okay the one with the smaller "delta" will be preferred, or--if equal--the left-hand argument.

(|||) :: Predicate a f t -> Predicate a f t' -> Predicate a f (Either t t')

A predicate corresponding to the logical OR connective of two predicates. The metadata of each Okay branch can be of different types.

If both arguments evaluate to Okay the one with the smaller "delta" will be preferred, or--if equal--the left-hand argument.

opt :: Predicate a f t -> Predicate a f (Maybe t)

A predicate modifier which makes the given predicate optional, i.e. the Okay metadata type becomes a Maybe and in the failure-case Nothing is returned.

def :: t -> Predicate a f t -> Predicate a f t

A predicate modifier which returns as Okay metadata the provided default value if the given predicate fails.

mapResult :: (Result f t -> Result f' t') -> Predicate a f t -> Predicate a f' t'

Map the result of the given predicate to some other result.

mapOkay :: (t -> Result f t') -> Predicate a f t -> Predicate a f t'

Like mapResult, but only maps the Okay metadata to another result.

mapFail :: (f -> Result f' t) -> Predicate a f t -> Predicate a f' t

Like mapResult, but only maps the Fail metadata to another result.

exec :: Predicate a f t -> a -> (f -> b) -> (t -> b) -> b

data a ::: b

A data-type for combining results of predicate evaluations.

Constructors

a ::: b

Instances

(Eq a, Eq b) => Eq (::: a b)

(Show a, Show b) => Show (::: a b)

(#) :: a -> (a -> b) -> b

flip ($) - useful in combination with indexed access, e.g. (x ::: True ::: False)#_2 yields True.

hd :: (a ::: b) -> a

tl :: (a ::: b) -> b

_1 :: (a ::: b) -> a

_2 :: (a ::: (b ::: c)) -> b

_3 :: (a ::: (b ::: (c ::: d))) -> c

_4 :: (a ::: (b ::: (c ::: (d ::: e)))) -> d

_5 :: (a ::: (b ::: (c ::: (d ::: (e ::: f))))) -> e

_6 :: (a ::: (b ::: (c ::: (d ::: (e ::: (f ::: g)))))) -> f

_7 :: (a ::: (b ::: (c ::: (d ::: (e ::: (f ::: (g ::: h))))))) -> g

_8 :: (a ::: (b ::: (c ::: (d ::: (e ::: (f ::: (g ::: (h ::: i)))))))) -> h

_9 :: (a ::: (b ::: (c ::: (d ::: (e ::: (f ::: (g ::: (h ::: (i ::: j))))))))) -> i

_1' :: (a ::: b) -> a

_2' :: (a ::: b) -> b

_3' :: (a ::: (b ::: c)) -> c

_4' :: (a ::: (b ::: (c ::: d))) -> d

_5' :: (a ::: (b ::: (c ::: (d ::: e)))) -> e

_6' :: (a ::: (b ::: (c ::: (d ::: (e ::: f))))) -> f

_7' :: (a ::: (b ::: (c ::: (d ::: (e ::: (f ::: g)))))) -> g

_8' :: (a ::: (b ::: (c ::: (d ::: (e ::: (f ::: (g ::: h))))))) -> h

_9' :: (a ::: (b ::: (c ::: (d ::: (e ::: (f ::: (g ::: (h ::: i)))))))) -> i