Predicate

class P is the main class. Most of this code contains instances of this class that evaluation of expressions at the type level.

Documentation

class P p a where

This is the core class. Each instance of this class can be combined into a dsl using >>

Associated Types

type PP (p :: k) a :: Type

Methods

eval

Arguments

:: MonadEval m

=> Proxy p

-> POpts

-> a

-> m (TT (PP p a))

returns a tree of results

Instances

GetBool b => P (b :: Bool) a

pulls the type level Bool to the value level

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @'True "ignore this"
True
TrueT

>>> pl @'False ()
False
FalseT

Defined in Predicate

Associated Types

type PP b a :: Type

Methods

eval :: MonadEval m => Proxy b -> POpts -> a -> m (TT (PP b a))

GetOrdering cmp => P (cmp :: Ordering) a

extracts the value level representation of the promoted Ordering

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @'LT "not used"
Present LT
PresentT LT

>>> pl @'EQ ()
Present EQ
PresentT EQ

Defined in Predicate

Associated Types

type PP cmp a :: Type

Methods

eval :: MonadEval m => Proxy cmp -> POpts -> a -> m (TT (PP cmp a))

KnownNat n => P (n :: Nat) a

extracts the value level representation of the type level Nat

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @123 ()
Present 123
PresentT 123

Defined in Predicate

Associated Types

type PP n a :: Type

Methods

eval :: MonadEval m => Proxy n -> POpts -> a -> m (TT (PP n a))

KnownSymbol s => P (s :: Symbol) a

pulls the type level Symbol to the value level

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @"hello world" ()
Present "hello world"
PresentT "hello world"

Defined in Predicate

Associated Types

type PP s a :: Type

Methods

eval :: MonadEval m => Proxy s -> POpts -> a -> m (TT (PP s a))

P () a

extracts the value level representation of the type level '()

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @'() ()
Present ()
PresentT ()

Defined in Predicate

Associated Types

type PP () a :: Type

Methods

eval :: MonadEval m => Proxy () -> POpts -> a -> m (TT (PP () a))

Show a => P () a

const () function

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @() "Asf"
Present ()
PresentT ()

Defined in Predicate

Associated Types

type PP () a :: Type

Methods

eval :: MonadEval m => Proxy () -> POpts -> a -> m (TT (PP () a))

(ReverseTupleC tp, Show (ReverseTupleP tp), Show tp) => P ReverseTupleN tp

Defined in Predicate

Associated Types

type PP ReverseTupleN tp :: Type

Methods

eval :: MonadEval m => Proxy ReverseTupleN -> POpts -> tp -> m (TT (PP ReverseTupleN tp))

P Stdin a

Defined in Predicate

Associated Types

type PP Stdin a :: Type

Methods

eval :: MonadEval m => Proxy Stdin -> POpts -> a -> m (TT (PP Stdin a))

P TimeZ a

Defined in Predicate

Associated Types

type PP TimeZ a :: Type

Methods

eval :: MonadEval m => Proxy TimeZ -> POpts -> a -> m (TT (PP TimeZ a))

P TimeU a

Defined in Predicate

Associated Types

type PP TimeU a :: Type

Methods

eval :: MonadEval m => Proxy TimeU -> POpts -> a -> m (TT (PP TimeU a))

P ReadEnvAll a

Defined in Predicate

Associated Types

type PP ReadEnvAll a :: Type

Methods

eval :: MonadEval m => Proxy ReadEnvAll -> POpts -> a -> m (TT (PP ReadEnvAll a))

(Show l, IsList l, Show (Item l)) => P ToListExt l

Defined in Predicate

Associated Types

type PP ToListExt l :: Type

Methods

eval :: MonadEval m => Proxy ToListExt -> POpts -> l -> m (TT (PP ToListExt l))

(Show (t a), Foldable t, t a ~ as) => P Null as

Defined in Predicate

Associated Types

type PP Null as :: Type

Methods

eval :: MonadEval m => Proxy Null -> POpts -> as -> m (TT (PP Null as))

(Show as, AsEmpty as) => P IsEmpty as

Defined in Predicate

Associated Types

type PP IsEmpty as :: Type

Methods

eval :: MonadEval m => Proxy IsEmpty -> POpts -> as -> m (TT (PP IsEmpty as))

(Show (ConsT s), Show s, Snoc s s (ConsT s) (ConsT s)) => P Unsnoc s

Defined in Predicate

Associated Types

type PP Unsnoc s :: Type

Methods

eval :: MonadEval m => Proxy Unsnoc -> POpts -> s -> m (TT (PP Unsnoc s))

(Show (ConsT s), Show s, Cons s s (ConsT s) (ConsT s)) => P Uncons s

Defined in Predicate

Associated Types

type PP Uncons s :: Type

Methods

eval :: MonadEval m => Proxy Uncons -> POpts -> s -> m (TT (PP Uncons s))

(Show t, Reversing t) => P ReverseL t

Defined in Predicate

Associated Types

type PP ReverseL t :: Type

Methods

eval :: MonadEval m => Proxy ReverseL -> POpts -> t -> m (TT (PP ReverseL t))

(Show a, as ~ [a]) => P Reverse as

Defined in Predicate

Associated Types

type PP Reverse as :: Type

Methods

eval :: MonadEval m => Proxy Reverse -> POpts -> as -> m (TT (PP Reverse as))

Show a => P MkProxy a

Defined in Predicate

Associated Types

type PP MkProxy a :: Type

Methods

eval :: MonadEval m => Proxy MkProxy -> POpts -> a -> m (TT (PP MkProxy a))

(Typeable a, Show a) => P IdT a

Defined in Predicate

Associated Types

type PP IdT a :: Type

Methods

eval :: MonadEval m => Proxy IdT -> POpts -> a -> m (TT (PP IdT a))

Show a => P Id a

Defined in Predicate

Associated Types

type PP Id a :: Type

Methods

eval :: MonadEval m => Proxy Id -> POpts -> a -> m (TT (PP Id a))

P I a

Defined in Predicate

Associated Types

type PP I a :: Type

Methods

eval :: MonadEval m => Proxy I -> POpts -> a -> m (TT (PP I a))

(Show a, as ~ [a]) => P Len as

Defined in Predicate

Associated Types

type PP Len as :: Type

Methods

eval :: MonadEval m => Proxy Len -> POpts -> as -> m (TT (PP Len as))

(Show a, IsText a) => P ToUpper a

Defined in Predicate

Associated Types

type PP ToUpper a :: Type

Methods

eval :: MonadEval m => Proxy ToUpper -> POpts -> a -> m (TT (PP ToUpper a))

(Show a, IsText a) => P ToLower a

Defined in Predicate

Associated Types

type PP ToLower a :: Type

Methods

eval :: MonadEval m => Proxy ToLower -> POpts -> a -> m (TT (PP ToLower a))

(Show (t (t a)), Show (t a), Monad t) => P Join (t (t a))

Defined in Predicate

Associated Types

type PP Join (t (t a)) :: Type

Methods

eval :: MonadEval m => Proxy Join -> POpts -> t (t a) -> m (TT (PP Join (t (t a))))

(Show (t a), Show (t (t a)), Comonad t) => P Duplicate (t a)

Defined in Predicate

Associated Types

type PP Duplicate (t a) :: Type

Methods

eval :: MonadEval m => Proxy Duplicate -> POpts -> t a -> m (TT (PP Duplicate (t a)))

(Show (t a), Show a, Comonad t) => P Extract (t a)

Defined in Predicate

Associated Types

type PP Extract (t a) :: Type

Methods

eval :: MonadEval m => Proxy Extract -> POpts -> t a -> m (TT (PP Extract (t a)))

(Show (f (t a)), Show (t (f a)), Traversable t, Applicative f) => P Sequence (t (f a))

Defined in Predicate

Associated Types

type PP Sequence (t (f a)) :: Type

Methods

eval :: MonadEval m => Proxy Sequence -> POpts -> t (f a) -> m (TT (PP Sequence (t (f a))))

(Show (t a), Foldable t, Show a) => P ToList (t a)

Defined in Predicate

Associated Types

type PP ToList (t a) :: Type

Methods

eval :: MonadEval m => Proxy ToList -> POpts -> t a -> m (TT (PP ToList (t a)))

Show a => P Pairs [a]

Defined in Predicate

Associated Types

type PP Pairs [a] :: Type

Methods

eval :: MonadEval m => Proxy Pairs -> POpts -> [a] -> m (TT (PP Pairs [a]))

(Show a, Show b) => P PartitionThese [These a b]

Defined in Predicate

Associated Types

type PP PartitionThese [These a b] :: Type

Methods

eval :: MonadEval m => Proxy PartitionThese -> POpts -> [These a b] -> m (TT (PP PartitionThese [These a b]))

(Show a, Show b) => P PartitionEithers [Either a b]

Defined in Predicate

Associated Types

type PP PartitionEithers [Either a b] :: Type

Methods

eval :: MonadEval m => Proxy PartitionEithers -> POpts -> [Either a b] -> m (TT (PP PartitionEithers [Either a b]))

Functor f => P Fmap_2 (f (x, a))

Defined in Predicate

Associated Types

type PP Fmap_2 (f (x, a)) :: Type

Methods

eval :: MonadEval m => Proxy Fmap_2 -> POpts -> f (x, a) -> m (TT (PP Fmap_2 (f (x, a))))

Functor f => P Fmap_1 (f (a, x))

Defined in Predicate

Associated Types

type PP Fmap_1 (f (a, x)) :: Type

Methods

eval :: MonadEval m => Proxy Fmap_1 -> POpts -> f (a, x) -> m (TT (PP Fmap_1 (f (a, x))))

(Ord a, Show a) => P Max [a]

Defined in Predicate

Associated Types

type PP Max [a] :: Type

Methods

eval :: MonadEval m => Proxy Max -> POpts -> [a] -> m (TT (PP Max [a]))

(Ord a, Show a) => P Min [a]

Defined in Predicate

Associated Types

type PP Min [a] :: Type

Methods

eval :: MonadEval m => Proxy Min -> POpts -> [a] -> m (TT (PP Min [a]))

Show a => P Tails [a]

Defined in Predicate

Associated Types

type PP Tails [a] :: Type

Methods

eval :: MonadEval m => Proxy Tails -> POpts -> [a] -> m (TT (PP Tails [a]))

Show a => P Inits [a]

Defined in Predicate

Associated Types

type PP Inits [a] :: Type

Methods

eval :: MonadEval m => Proxy Inits -> POpts -> [a] -> m (TT (PP Inits [a]))

Typeable a => P Unproxy (Proxy a)

Defined in Predicate

Associated Types

type PP Unproxy (Proxy a) :: Type

Methods

eval :: MonadEval m => Proxy Unproxy -> POpts -> Proxy a -> m (TT (PP Unproxy (Proxy a)))

Monoid a => P MEmptyProxy (Proxy a)

Defined in Predicate

Associated Types

type PP MEmptyProxy (Proxy a) :: Type

Methods

eval :: MonadEval m => Proxy MEmptyProxy -> POpts -> Proxy a -> m (TT (PP MEmptyProxy (Proxy a)))

P TheseToMaybe (These a b)

Defined in Predicate

Associated Types

type PP TheseToMaybe (These a b) :: Type

Methods

eval :: MonadEval m => Proxy TheseToMaybe -> POpts -> These a b -> m (TT (PP TheseToMaybe (These a b)))

P ThatToMaybe (These x a)

Defined in Predicate

Associated Types

type PP ThatToMaybe (These x a) :: Type

Methods

eval :: MonadEval m => Proxy ThatToMaybe -> POpts -> These x a -> m (TT (PP ThatToMaybe (These x a)))

P ThisToMaybe (These a x)

Defined in Predicate

Associated Types

type PP ThisToMaybe (These a x) :: Type

Methods

eval :: MonadEval m => Proxy ThisToMaybe -> POpts -> These a x -> m (TT (PP ThisToMaybe (These a x)))

P RightToMaybe (Either x a)

Defined in Predicate

Associated Types

type PP RightToMaybe (Either x a) :: Type

Methods

eval :: MonadEval m => Proxy RightToMaybe -> POpts -> Either x a -> m (TT (PP RightToMaybe (Either x a)))

P LeftToMaybe (Either a x)

Defined in Predicate

Associated Types

type PP LeftToMaybe (Either a x) :: Type

Methods

eval :: MonadEval m => Proxy LeftToMaybe -> POpts -> Either a x -> m (TT (PP LeftToMaybe (Either a x)))

(Show (p a b), Swapped p, Show (p b a)) => P Swap (p a b)

Defined in Predicate

Associated Types

type PP Swap (p a b) :: Type

Methods

eval :: MonadEval m => Proxy Swap -> POpts -> p a b -> m (TT (PP Swap (p a b)))

P ([] :: [k]) a

extracts the value level representation of the type level '[]

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @'[] False
Present []
PresentT []

Defined in Predicate

Associated Types

type PP [] a :: Type

Methods

eval :: MonadEval m => Proxy [] -> POpts -> a -> m (TT (PP [] a))

(Show a, 2 <= n, n <= 36, KnownNat n, Integral a) => P (ShowBase n :: Type) a

Defined in Predicate

Associated Types

type PP (ShowBase n) a :: Type

Methods

eval :: MonadEval m => Proxy (ShowBase n) -> POpts -> a -> m (TT (PP (ShowBase n) a))

(KnownSymbol s, NullT s ~ False) => P (Char1 s :: Type) a

Defined in Predicate

Associated Types

type PP (Char1 s) a :: Type

Methods

eval :: MonadEval m => Proxy (Char1 s) -> POpts -> a -> m (TT (PP (Char1 s) a))

(Show l, IsList l, l ~ l') => P (FromListF l' :: Type) l

Defined in Predicate

Associated Types

type PP (FromListF l') l :: Type

Methods

eval :: MonadEval m => Proxy (FromListF l') -> POpts -> l -> m (TT (PP (FromListF l') l))

Typeable t => P (Hole t :: Type) a

Acts as a proxy in this dsl where you can explicitly set the Type.

It is passed around as an argument to help the type checker when needed. see ReadP, ParseTimeP, ShowP

Defined in Predicate

Associated Types

type PP (Hole t) a :: Type

Methods

eval :: MonadEval m => Proxy (Hole t) -> POpts -> a -> m (TT (PP (Hole t) a))

(GetCharSet cs, Show a, IsText a) => P (IsCharSet cs :: Type) a

Defined in Predicate

Associated Types

type PP (IsCharSet cs) a :: Type

Methods

eval :: MonadEval m => Proxy (IsCharSet cs) -> POpts -> a -> m (TT (PP (IsCharSet cs) a))

P (Nothing :: Maybe a1) (Maybe a2)

expects Nothing otherwise it fails if the value is Nothing then it returns 'Proxy a' as this provides more information than '()'

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @'Nothing Nothing
Present Proxy
PresentT Proxy

>>> pl @'Nothing (Just True)
Error 'Nothing found Just
FailT "'Nothing found Just"

Defined in Predicate

Associated Types

type PP Nothing (Maybe a2) :: Type

Methods

eval :: MonadEval m => Proxy Nothing -> POpts -> Maybe a2 -> m (TT (PP Nothing (Maybe a2)))

(a ~ Item t, Show t, IsList t) => P (FromList t :: Type) [a]

Defined in Predicate

Associated Types

type PP (FromList t) [a] :: Type

Methods

eval :: MonadEval m => Proxy (FromList t) -> POpts -> [a] -> m (TT (PP (FromList t) [a]))

(Show (f (t a)), Show (f a), Applicative t, Functor f) => P (Pure2 t :: Type) (f a)

Defined in Predicate

Associated Types

type PP (Pure2 t) (f a) :: Type

Methods

eval :: MonadEval m => Proxy (Pure2 t) -> POpts -> f a -> m (TT (PP (Pure2 t) (f a)))

P (Proxy t :: Type) a

Defined in Predicate

Associated Types

type PP (Proxy t) a :: Type

Methods

eval :: MonadEval m => Proxy (Proxy t) -> POpts -> a -> m (TT (PP (Proxy t) a))

(PP p x ~ String, P p x) => P (ReadEnv p :: Type) x

Defined in Predicate

Associated Types

type PP (ReadEnv p) x :: Type

Methods

eval :: MonadEval m => Proxy (ReadEnv p) -> POpts -> x -> m (TT (PP (ReadEnv p) x))

(PP p x ~ String, P p x) => P (ReadDir p :: Type) x

Defined in Predicate

Associated Types

type PP (ReadDir p) x :: Type

Methods

eval :: MonadEval m => Proxy (ReadDir p) -> POpts -> x -> m (TT (PP (ReadDir p) x))

(PP p x ~ String, P p x) => P (ReadFile p :: Type) x

Defined in Predicate

Associated Types

type PP (ReadFile p) x :: Type

Methods

eval :: MonadEval m => Proxy (ReadFile p) -> POpts -> x -> m (TT (PP (ReadFile p) x))

P p x => P (Hide p :: Type) x

Defined in Predicate

Associated Types

type PP (Hide p) x :: Type

Methods

eval :: MonadEval m => Proxy (Hide p) -> POpts -> x -> m (TT (PP (Hide p) x))

(PP p x ~ [Int], P p x) => P (Luhn p :: Type) x

Defined in Predicate

Associated Types

type PP (Luhn p) x :: Type

Methods

eval :: MonadEval m => Proxy (Luhn p) -> POpts -> x -> m (TT (PP (Luhn p) x))

P (EmptyList' t :: Type) x

Defined in Predicate

Associated Types

type PP (EmptyList' t) x :: Type

Methods

eval :: MonadEval m => Proxy (EmptyList' t) -> POpts -> x -> m (TT (PP (EmptyList' t) x))

(PP p x ~ t a, P p x, Show (t a), Foldable t, Show a) => P (ToList' p :: Type) x

Defined in Predicate

Associated Types

type PP (ToList' p) x :: Type

Methods

eval :: MonadEval m => Proxy (ToList' p) -> POpts -> x -> m (TT (PP (ToList' p) x))

(Show (PP p a), P p a) => P (Skip p :: Type) a

Defined in Predicate

Associated Types

type PP (Skip p) a :: Type

Methods

eval :: MonadEval m => Proxy (Skip p) -> POpts -> a -> m (TT (PP (Skip p) a))

(Show a, P p a, PP p a ~ Bool) => P (GuardSimple p :: Type) a

Defined in Predicate

Associated Types

type PP (GuardSimple p) a :: Type

Methods

eval :: MonadEval m => Proxy (GuardSimple p) -> POpts -> a -> m (TT (PP (GuardSimple p) a))

P p a => P (W p :: Type) a

Defined in Predicate

Associated Types

type PP (W p) a :: Type

Methods

eval :: MonadEval m => Proxy (W p) -> POpts -> a -> m (TT (PP (W p) a))

(PP p x ~ t a, P p x, Show (t a), Foldable t, a ~ Bool) => P (Ors p :: Type) x

Defined in Predicate

Associated Types

type PP (Ors p) x :: Type

Methods

eval :: MonadEval m => Proxy (Ors p) -> POpts -> x -> m (TT (PP (Ors p) x))

(PP p x ~ t a, P p x, Show (t a), Foldable t, a ~ Bool) => P (Ands p :: Type) x

Defined in Predicate

Associated Types

type PP (Ands p) x :: Type

Methods

eval :: MonadEval m => Proxy (Ands p) -> POpts -> x -> m (TT (PP (Ands p) x))

Typeable t => P (ProxyT' t :: Type) a

Defined in Predicate

Associated Types

type PP (ProxyT' t) a :: Type

Methods

eval :: MonadEval m => Proxy (ProxyT' t) -> POpts -> a -> m (TT (PP (ProxyT' t) a))

(Show a, Show (t [a]), PP p x ~ t [a], P p x, Foldable t) => P (Concat p :: Type) x

Defined in Predicate

Associated Types

type PP (Concat p) x :: Type

Methods

eval :: MonadEval m => Proxy (Concat p) -> POpts -> x -> m (TT (PP (Concat p) x))

(PP p x ~ [a], P p x, Show a, Monoid a) => P (MConcat p :: Type) x

Defined in Predicate

Associated Types

type PP (MConcat p) x :: Type

Methods

eval :: MonadEval m => Proxy (MConcat p) -> POpts -> x -> m (TT (PP (MConcat p) x))

(PP p x ~ a, P p x, Show a) => P (MkJust p :: Type) x

Defined in Predicate

Associated Types

type PP (MkJust p) x :: Type

Methods

eval :: MonadEval m => Proxy (MkJust p) -> POpts -> x -> m (TT (PP (MkJust p) x))

P (MkNothing' t :: Type) a

Defined in Predicate

Associated Types

type PP (MkNothing' t) a :: Type

Methods

eval :: MonadEval m => Proxy (MkNothing' t) -> POpts -> a -> m (TT (PP (MkNothing' t) a))

(Show (PP t a), Monoid (PP t a)) => P (MEmptyT' t :: Type) a

Defined in Predicate

Associated Types

type PP (MEmptyT' t) a :: Type

Methods

eval :: MonadEval m => Proxy (MEmptyT' t) -> POpts -> a -> m (TT (PP (MEmptyT' t) a))

(PP p x ~ Bool, P p x) => P (Not p :: Type) x

Defined in Predicate

Associated Types

type PP (Not p) x :: Type

Methods

eval :: MonadEval m => Proxy (Not p) -> POpts -> x -> m (TT (PP (Not p) x))

(PP p x ~ a, P p x, Show a, Integral a) => P (Prime p :: Type) x

Defined in Predicate

Associated Types

type PP (Prime p) x :: Type

Methods

eval :: MonadEval m => Proxy (Prime p) -> POpts -> x -> m (TT (PP (Prime p) x))

(Show a, Enum a, PP p x ~ a, P p x) => P (FromEnum p :: Type) x

Defined in Predicate

Associated Types

type PP (FromEnum p) x :: Type

Methods

eval :: MonadEval m => Proxy (FromEnum p) -> POpts -> x -> m (TT (PP (FromEnum p) x))

(Show a, Enum a, PP p x ~ a, P p x) => P (Pred p :: Type) x

Defined in Predicate

Associated Types

type PP (Pred p) x :: Type

Methods

eval :: MonadEval m => Proxy (Pred p) -> POpts -> x -> m (TT (PP (Pred p) x))

(Show a, Enum a, PP p x ~ a, P p x) => P (Succ p :: Type) x

Defined in Predicate

Associated Types

type PP (Succ p) x :: Type

Methods

eval :: MonadEval m => Proxy (Succ p) -> POpts -> x -> m (TT (PP (Succ p) x))

(Show a, Show t, Coercible t a) => P (Coerce t :: Type) a

Defined in Predicate

Associated Types

type PP (Coerce t) a :: Type

Methods

eval :: MonadEval m => Proxy (Coerce t) -> POpts -> a -> m (TT (PP (Coerce t) a))

(PP p x ~ s, P p x, Show s, Show (Unwrapped s), Wrapped s) => P (Unwrap p :: Type) x

Defined in Predicate

Associated Types

type PP (Unwrap p) x :: Type

Methods

eval :: MonadEval m => Proxy (Unwrap p) -> POpts -> x -> m (TT (PP (Unwrap p) x))

(Show (PP p x), Num (PP p x), P p x) => P (Signum p :: Type) x

Defined in Predicate

Associated Types

type PP (Signum p) x :: Type

Methods

eval :: MonadEval m => Proxy (Signum p) -> POpts -> x -> m (TT (PP (Signum p) x))

(Show (PP p x), Num (PP p x), P p x) => P (Abs p :: Type) x

Defined in Predicate

Associated Types

type PP (Abs p) x :: Type

Methods

eval :: MonadEval m => Proxy (Abs p) -> POpts -> x -> m (TT (PP (Abs p) x))

(Show (PP p x), Num (PP p x), P p x) => P (Negate p :: Type) x

Defined in Predicate

Associated Types

type PP (Negate p) x :: Type

Methods

eval :: MonadEval m => Proxy (Negate p) -> POpts -> x -> m (TT (PP (Negate p) x))

P (TupleI ([] :: [k]) :: Type) a

Defined in Predicate

Associated Types

type PP (TupleI []) a :: Type

Methods

eval :: MonadEval m => Proxy (TupleI []) -> POpts -> a -> m (TT (PP (TupleI []) a))

(P p a, P (TupleI ps) a, Show a) => P (TupleI (p ': ps) :: Type) a

Defined in Predicate

Associated Types

type PP (TupleI (p ': ps)) a :: Type

Methods

eval :: MonadEval m => Proxy (TupleI (p ': ps)) -> POpts -> a -> m (TT (PP (TupleI (p ': ps)) a))

P (DoExpandT ps) a => P (Do ps :: Type) a

Defined in Predicate

Associated Types

type PP (Do ps) a :: Type

Methods

eval :: MonadEval m => Proxy (Do ps) -> POpts -> a -> m (TT (PP (Do ps) a))

(a ~ PP p x, Show a, Real a, P p x) => P (ToRational p :: Type) x

Defined in Predicate

Associated Types

type PP (ToRational p) x :: Type

Methods

eval :: MonadEval m => Proxy (ToRational p) -> POpts -> x -> m (TT (PP (ToRational p) x))

(Show (ExtractL6T (PP p x)), ExtractL6C (PP p x), P p x, Show (PP p x)) => P (L6 p :: Type) x

Defined in Predicate

Associated Types

type PP (L6 p) x :: Type

Methods

eval :: MonadEval m => Proxy (L6 p) -> POpts -> x -> m (TT (PP (L6 p) x))

(Show (ExtractL5T (PP p x)), ExtractL5C (PP p x), P p x, Show (PP p x)) => P (L5 p :: Type) x

Defined in Predicate

Associated Types

type PP (L5 p) x :: Type

Methods

eval :: MonadEval m => Proxy (L5 p) -> POpts -> x -> m (TT (PP (L5 p) x))

(Show (ExtractL4T (PP p x)), ExtractL4C (PP p x), P p x, Show (PP p x)) => P (L4 p :: Type) x

Defined in Predicate

Associated Types

type PP (L4 p) x :: Type

Methods

eval :: MonadEval m => Proxy (L4 p) -> POpts -> x -> m (TT (PP (L4 p) x))

(Show (ExtractL3T (PP p x)), ExtractL3C (PP p x), P p x, Show (PP p x)) => P (L3 p :: Type) x

Defined in Predicate

Associated Types

type PP (L3 p) x :: Type

Methods

eval :: MonadEval m => Proxy (L3 p) -> POpts -> x -> m (TT (PP (L3 p) x))

(Show (ExtractL2T (PP p x)), ExtractL2C (PP p x), P p x, Show (PP p x)) => P (L2 p :: Type) x

Defined in Predicate

Associated Types

type PP (L2 p) x :: Type

Methods

eval :: MonadEval m => Proxy (L2 p) -> POpts -> x -> m (TT (PP (L2 p) x))

(Show (ExtractL1T (PP p x)), ExtractL1C (PP p x), P p x, Show (PP p x)) => P (L1 p :: Type) x

Defined in Predicate

Associated Types

type PP (L1 p) x :: Type

Methods

eval :: MonadEval m => Proxy (L1 p) -> POpts -> x -> m (TT (PP (L1 p) x))

(PP p x ~ t a, P p x, Show (t a), Foldable t) => P (Length p :: Type) x

Defined in Predicate

Associated Types

type PP (Length p) x :: Type

Methods

eval :: MonadEval m => Proxy (Length p) -> POpts -> x -> m (TT (PP (Length p) x))

(PP p x ~ Day, P p x) => P (UnMkDay p :: Type) x

Defined in Predicate

Associated Types

type PP (UnMkDay p) x :: Type

Methods

eval :: MonadEval m => Proxy (UnMkDay p) -> POpts -> x -> m (TT (PP (UnMkDay p) x))

(Show (PP p x), P p x) => P (ShowP p :: Type) x

Defined in Predicate

Associated Types

type PP (ShowP p) x :: Type

Methods

eval :: MonadEval m => Proxy (ShowP p) -> POpts -> x -> m (TT (PP (ShowP p) x))

(PP p x ~ [a], P p x, Show a) => P (Ones p :: Type) x

Defined in Predicate

Associated Types

type PP (Ones p) x :: Type

Methods

eval :: MonadEval m => Proxy (Ones p) -> POpts -> x -> m (TT (PP (Ones p) x))

(PP p x ~ ([String] -> String), P p x) => P (MakeRR3 p :: Type) x

Defined in Predicate

Associated Types

type PP (MakeRR3 p) x :: Type

Methods

eval :: MonadEval m => Proxy (MakeRR3 p) -> POpts -> x -> m (TT (PP (MakeRR3 p) x))

(PP p x ~ (String -> String), P p x) => P (MakeRR2 p :: Type) x

Defined in Predicate

Associated Types

type PP (MakeRR2 p) x :: Type

Methods

eval :: MonadEval m => Proxy (MakeRR2 p) -> POpts -> x -> m (TT (PP (MakeRR2 p) x))

(PP p x ~ (String -> [String] -> String), P p x) => P (MakeRR1 p :: Type) x

Defined in Predicate

Associated Types

type PP (MakeRR1 p) x :: Type

Methods

eval :: MonadEval m => Proxy (MakeRR1 p) -> POpts -> x -> m (TT (PP (MakeRR1 p) x))

(PP p x ~ String, P p x) => P (MakeRR p :: Type) x

Defined in Predicate

Associated Types

type PP (MakeRR p) x :: Type

Methods

eval :: MonadEval m => Proxy (MakeRR p) -> POpts -> x -> m (TT (PP (MakeRR p) x))

(Show (PP p a2), P p a2, Show a2) => P (Just p :: Maybe a1) (Maybe a2)

extracts the 'a' from type level 'Maybe a' if the value exists

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @('Just Id) (Just 123)
Present 123
PresentT 123

>>> pl @('Just (Not Id)) (Just True)
Present False
PresentT False

>>> pl @('Just Id) Nothing
Error 'Just found Nothing
FailT "'Just found Nothing"

Defined in Predicate

Associated Types

type PP (Just p) (Maybe a2) :: Type

Methods

eval :: MonadEval m => Proxy (Just p) -> POpts -> Maybe a2 -> m (TT (PP (Just p) (Maybe a2)))

(Show a, KnownNat n, GetBool strict, TupleListD (ToN n) a, Show (TupleListT (ToN n) a)) => P (TupleListImpl strict n :: Type) [a]

Defined in Predicate

Associated Types

type PP (TupleListImpl strict n) [a] :: Type

Methods

eval :: MonadEval m => Proxy (TupleListImpl strict n) -> POpts -> [a] -> m (TT (PP (TupleListImpl strict n) [a]))

(Show (f a), Show (f (PP t (f a))), Functor f, Monoid (PP t (f a))) => P (MEmptyT2' t :: Type) (f a)

Defined in Predicate

Associated Types

type PP (MEmptyT2' t) (f a) :: Type

Methods

eval :: MonadEval m => Proxy (MEmptyT2' t) -> POpts -> f a -> m (TT (PP (MEmptyT2' t) (f a)))

(Show (f a), Show (f t), Coercible t a, Functor f) => P (Coerce2 t :: Type) (f a)

Defined in Predicate

Associated Types

type PP (Coerce2 t) (f a) :: Type

Methods

eval :: MonadEval m => Proxy (Coerce2 t) -> POpts -> f a -> m (TT (PP (Coerce2 t) (f a)))

(Show (PP p a2), Show a2, P (p1 ': ps) a2, PP (p1 ': ps) a2 ~ [PP p1 a2], P p a2, PP p a2 ~ PP p1 a2) => P (p ': (p1 ': ps) :: [a1]) a2

Defined in Predicate

Associated Types

type PP (p ': (p1 ': ps)) a2 :: Type

Methods

eval :: MonadEval m => Proxy (p ': (p1 ': ps)) -> POpts -> a2 -> m (TT (PP (p ': (p1 ': ps)) a2))

(Show (PP p a), Show a, P p a) => P (p ': ([] :: [k]) :: [k]) a

runs each predicate in turn from the promoted list

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> :set -XNoStarIsType
>>> pl @'[1, 2, 3] 999
Present [1,2,3]
PresentT [1,2,3]

>>> pl @'[W 1, W 2, W 3, Id] 999
Present [1,2,3,999]
PresentT [1,2,3,999]

>>> pl @'[W 1, W 2, W 3, Id * 4, Pred Id] 999
Present [1,2,3,3996,998]
PresentT [1,2,3,3996,998]

>>> :set -XTypeOperators
>>> pl @'[Id * 4, Pred Id] 999
Present [3996,998]
PresentT [3996,998]

Defined in Predicate

Associated Types

type PP (p ': []) a :: Type

Methods

eval :: MonadEval m => Proxy (p ': []) -> POpts -> a -> m (TT (PP (p ': []) a))

P (DoExpandT (RepeatT n p)) a => P (DoN n p :: Type) a

Defined in Predicate

Associated Types

type PP (DoN n p) a :: Type

Methods

eval :: MonadEval m => Proxy (DoN n p) -> POpts -> a -> m (TT (PP (DoN n p) a))

P (RepeatT n p) a => P (Repeat n p :: Type) a

Defined in Predicate

Associated Types

type PP (Repeat n p) a :: Type

Methods

eval :: MonadEval m => Proxy (Repeat n p) -> POpts -> a -> m (TT (PP (Repeat n p) a))

(GetFHandle fh, P p a, PP p a ~ String) => P (WritefileImpl fh p :: Type) a

Defined in Predicate

Associated Types

type PP (WritefileImpl fh p) a :: Type

Methods

eval :: MonadEval m => Proxy (WritefileImpl fh p) -> POpts -> a -> m (TT (PP (WritefileImpl fh p) a))

(P p x, PP p x ~ a, Show (t a), Show a, Alternative t) => P (EmptyT t p :: Type) x

Defined in Predicate

Associated Types

type PP (EmptyT t p) x :: Type

Methods

eval :: MonadEval m => Proxy (EmptyT t p) -> POpts -> x -> m (TT (PP (EmptyT t p) x))

(P p x, Show (PP p x), Show (t (PP p x)), Applicative t) => P (Pure t p :: Type) x

Defined in Predicate

Associated Types

type PP (Pure t p) x :: Type

Methods

eval :: MonadEval m => Proxy (Pure t p) -> POpts -> x -> m (TT (PP (Pure t p) x))

(GetBool strict, GetLen ps, P (ParaImpl (LenT ps) strict ps) [a]) => P (ParaImplW strict ps :: Type) [a]

Defined in Predicate

Associated Types

type PP (ParaImplW strict ps) [a] :: Type

Methods

eval :: MonadEval m => Proxy (ParaImplW strict ps) -> POpts -> [a] -> m (TT (PP (ParaImplW strict ps) [a]))

(P def (Proxy a), PP def (Proxy a) ~ a, KnownNat n, Show a) => P (Ix n def :: Type) [a]

Defined in Predicate

Associated Types

type PP (Ix n def) [a] :: Type

Methods

eval :: MonadEval m => Proxy (Ix n def) -> POpts -> [a] -> m (TT (PP (Ix n def) [a]))

(FailIfT (NotT (OrT l r)) (Text "Trim': left and right cannot both be False"), GetBool l, GetBool r, IsText (PP p x), P p x) => P (Trim' l r p :: Type) x

Defined in Predicate

Associated Types

type PP (Trim' l r p) x :: Type

Methods

eval :: MonadEval m => Proxy (Trim' l r p) -> POpts -> x -> m (TT (PP (Trim' l r p) x))

(P p x, P q x, PP p x ~ (a -> b), FnT (PP p x) ~ b, PP q x ~ a, Show a, Show b) => P (p $ q :: Type) x

Defined in Predicate

Associated Types

type PP (p $ q) x :: Type

Methods

eval :: MonadEval m => Proxy (p $ q) -> POpts -> x -> m (TT (PP (p $ q) x))

(P p x, P q x, Show (t b), Alternative t, t b ~ PP p x, PP q x ~ t b) => P (p <|> q :: Type) x

Defined in Predicate

Associated Types

type PP (p <|> q) x :: Type

Methods

eval :: MonadEval m => Proxy (p <|> q) -> POpts -> x -> m (TT (PP (p <|> q) x))

(Show (t c), P p x, P q x, Show (t b), Applicative t, t b ~ PP p x, PP q x ~ t c) => P (p <* q :: Type) x

Defined in Predicate

Associated Types

type PP (p <* q) x :: Type

Methods

eval :: MonadEval m => Proxy (p <* q) -> POpts -> x -> m (TT (PP (p <* q) x))

(P p x, P q x, Show (PP p x), Functor t, PP q x ~ t c, ApplyConstT (PP q x) (PP p x) ~ t (PP p x)) => P (p <$ q :: Type) x

Defined in Predicate

Associated Types

type PP (p <$ q) x :: Type

Methods

eval :: MonadEval m => Proxy (p <$ q) -> POpts -> x -> m (TT (PP (p <$ q) x))

(KnownNat (TupleLenT as), PrintC bs, (b, bs) ~ ReverseTupleP (a, as), ReverseTupleC (a, as), Show a, Show as, PrintfArg b, PP s x ~ String, PP p x ~ (a, as), P s x, P p x, CheckT (PP p x) ~ True) => P (Printfn s p :: Type) x

Defined in Predicate

Associated Types

type PP (Printfn s p) x :: Type

Methods

eval :: MonadEval m => Proxy (Printfn s p) -> POpts -> x -> m (TT (PP (Printfn s p) x))

(Semigroup (PP p x), PP p x ~ PP q x, P p x, Show (PP q x), P q x) => P (p <> q :: Type) x

Defined in Predicate

Associated Types

type PP (p <> q) x :: Type

Methods

eval :: MonadEval m => Proxy (p <> q) -> POpts -> x -> m (TT (PP (p <> q) x))

(PrintfArg (PP p x), Show (PP p x), PP s x ~ String, P s x, P p x) => P (Printf s p :: Type) x

Defined in Predicate

Associated Types

type PP (Printf s p) x :: Type

Methods

eval :: MonadEval m => Proxy (Printf s p) -> POpts -> x -> m (TT (PP (Printf s p) x))

(PP p x ~ [a], PP q x ~ PP p x, P p x, P q x, Show a) => P (Intercalate p q :: Type) x

Defined in Predicate

Associated Types

type PP (Intercalate p q) x :: Type

Methods

eval :: MonadEval m => Proxy (Intercalate p q) -> POpts -> x -> m (TT (PP (Intercalate p q) x))

(Show (f y), PP p a ~ f x, PP q a ~ f y, ExtractAFromTA (f x) ~ x, ExtractAFromTA (f y) ~ y, Show (f x), Align f, Show (f (These x y)), P p a, P q a) => P (ZipTheseF p q :: Type) a

Defined in Predicate

Associated Types

type PP (ZipTheseF p q) a :: Type

Methods

eval :: MonadEval m => Proxy (ZipTheseF p q) -> POpts -> a -> m (TT (PP (ZipTheseF p q) a))

(PP p a ~ [x], PP q a ~ [y], P p a, P q a, Show x, Show y) => P (ZipThese p q :: Type) a

Defined in Predicate

Associated Types

type PP (ZipThese p q) a :: Type

Methods

eval :: MonadEval m => Proxy (ZipThese p q) -> POpts -> a -> m (TT (PP (ZipThese p q) a))

(Show x, P p x, Typeable (PP t (PP p x)), Show (PP t (PP p x)), FoldableWithIndex (PP t (PP p x)) f, PP p x ~ f a, Show a) => P (IToList' t p :: Type) x

Defined in Predicate

Associated Types

type PP (IToList' t p) x :: Type

Methods

eval :: MonadEval m => Proxy (IToList' t p) -> POpts -> x -> m (TT (PP (IToList' t p) x))

(PP p a ~ String, PP p a ~ PP q a, P p a, P q a) => P (OrdI p q :: Type) a

Defined in Predicate

Associated Types

type PP (OrdI p q) a :: Type

Methods

eval :: MonadEval m => Proxy (OrdI p q) -> POpts -> a -> m (TT (PP (OrdI p q) a))

(Ord (PP p a), PP p a ~ PP q a, P p a, Show (PP q a), P q a) => P (OrdP p q :: Type) a

Defined in Predicate

Associated Types

type PP (OrdP p q) a :: Type

Methods

eval :: MonadEval m => Proxy (OrdP p q) -> POpts -> a -> m (TT (PP (OrdP p q) a))

(P p a, P q a, PP p a ~ Bool, PP q a ~ Bool) => P (p ~> q :: Type) a

Defined in Predicate

Associated Types

type PP (p ~> q) a :: Type

Methods

eval :: MonadEval m => Proxy (p ~> q) -> POpts -> a -> m (TT (PP (p ~> q) a))

(P p a, P q a, PP p a ~ Bool, PP q a ~ Bool) => P (p || q :: Type) a

Defined in Predicate

Associated Types

type PP (p || q) a :: Type

Methods

eval :: MonadEval m => Proxy (p || q) -> POpts -> a -> m (TT (PP (p || q) a))

(P p a, P q a, PP p a ~ Bool, PP q a ~ Bool) => P (p && q :: Type) a

Defined in Predicate

Associated Types

type PP (p && q) a :: Type

Methods

eval :: MonadEval m => Proxy (p && q) -> POpts -> a -> m (TT (PP (p && q) a))

(Show (PP p a), Show (PP q (PP p a)), P p a, P q (PP p a)) => P (p >> q :: Type) a

Defined in Predicate

Associated Types

type PP (p >> q) a :: Type

Methods

eval :: MonadEval m => Proxy (p >> q) -> POpts -> a -> m (TT (PP (p >> q) a))

(Show a, P prt a, PP prt a ~ String, P p a, PP p a ~ Bool) => P (Guard prt p :: Type) a

Defined in Predicate

Associated Types

type PP (Guard prt p) a :: Type

Methods

eval :: MonadEval m => Proxy (Guard prt p) -> POpts -> a -> m (TT (PP (Guard prt p) a))

(PP p a ~ PP q a, P p a, P q a, Show (PP p a), Integral (PP p a)) => P (QuotRem p q :: Type) a

Defined in Predicate

Associated Types

type PP (QuotRem p q) a :: Type

Methods

eval :: MonadEval m => Proxy (QuotRem p q) -> POpts -> a -> m (TT (PP (QuotRem p q) a))

(PP p a ~ PP q a, P p a, P q a, Show (PP p a), Integral (PP p a)) => P (DivMod p q :: Type) a

Defined in Predicate

Associated Types

type PP (DivMod p q) a :: Type

Methods

eval :: MonadEval m => Proxy (DivMod p q) -> POpts -> a -> m (TT (PP (DivMod p q) a))

(PP p a ~ PP q a, P p a, P q a, Show (PP p a), Integral (PP p a)) => P (Mod p q :: Type) a

Defined in Predicate

Associated Types

type PP (Mod p q) a :: Type

Methods

eval :: MonadEval m => Proxy (Mod p q) -> POpts -> a -> m (TT (PP (Mod p q) a))

(PP p a ~ PP q a, P p a, P q a, Show (PP p a), Integral (PP p a)) => P (Div p q :: Type) a

Defined in Predicate

Associated Types

type PP (Div p q) a :: Type

Methods

eval :: MonadEval m => Proxy (Div p q) -> POpts -> a -> m (TT (PP (Div p q) a))

(P p x, P q ((String, x), Proxy (PP p x)), PP p x ~ PP q ((String, x), Proxy (PP p x))) => P (Catch p q :: Type) x

Defined in Predicate

Associated Types

type PP (Catch p q) x :: Type

Methods

eval :: MonadEval m => Proxy (Catch p q) -> POpts -> x -> m (TT (PP (Catch p q) x))

(P prt a, PP prt a ~ String) => P (Fail t prt :: Type) a

Defined in Predicate

Associated Types

type PP (Fail t prt) a :: Type

Methods

eval :: MonadEval m => Proxy (Fail t prt) -> POpts -> a -> m (TT (PP (Fail t prt) a))

(P p x, PP q a ~ [x], PP p x ~ Bool, P q a) => P (Break p q :: Type) a

Defined in Predicate

Associated Types

type PP (Break p q) a :: Type

Methods

eval :: MonadEval m => Proxy (Break p q) -> POpts -> a -> m (TT (PP (Break p q) a))

(P p x, Show x, PP q a ~ [x], PP p x ~ Bool, P q a) => P (Partition p q :: Type) a

Defined in Predicate

Associated Types

type PP (Partition p q) a :: Type

Methods

eval :: MonadEval m => Proxy (Partition p q) -> POpts -> a -> m (TT (PP (Partition p q) a))

(Show (PP p a), P p a, PP q x ~ f a, P q x, Show a, Show (f a), Foldable f) => P (Map p q :: Type) x

Defined in Predicate

Associated Types

type PP (Map p q) x :: Type

Methods

eval :: MonadEval m => Proxy (Map p q) -> POpts -> x -> m (TT (PP (Map p q) x))

(PP q a ~ s, PP p s ~ Maybe (b, s), P q a, P p s, Show s, Show b) => P (Unfoldr p q :: Type) a

Defined in Predicate

Associated Types

type PP (Unfoldr p q) a :: Type

Methods

eval :: MonadEval m => Proxy (Unfoldr p q) -> POpts -> a -> m (TT (PP (Unfoldr p q) a))

(P p x, P q x, PP p x ~ a, Show a, PP q x ~ a, Enum a) => P (EnumFromTo p q :: Type) x

Defined in Predicate

Associated Types

type PP (EnumFromTo p q) x :: Type

Methods

eval :: MonadEval m => Proxy (EnumFromTo p q) -> POpts -> x -> m (TT (PP (EnumFromTo p q) x))

(P p x, P q x, Show (PP q x), Show (PP p x), Snoc (PP p x) (PP p x) (PP q x) (PP q x)) => P (p +: q :: Type) x

Defined in Predicate

Associated Types

type PP (p +: q) x :: Type

Methods

eval :: MonadEval m => Proxy (p +: q) -> POpts -> x -> m (TT (PP (p +: q) x))

(P p x, P q x, Show (PP p x), Show (PP q x), Cons (PP q x) (PP q x) (PP p x) (PP p x)) => P (p :+ q :: Type) x

Defined in Predicate

Associated Types

type PP (p :+ q) x :: Type

Methods

eval :: MonadEval m => Proxy (p :+ q) -> POpts -> x -> m (TT (PP (p :+ q) x))

(P q a, P p a, Show (PP p a), Ixed (PP p a), PP q a ~ Index (PP p a), Show (Index (PP p a)), Show (IxValue (PP p a))) => P (Lookup p q :: Type) a

Defined in Predicate

Associated Types

type PP (Lookup p q) a :: Type

Methods

eval :: MonadEval m => Proxy (Lookup p q) -> POpts -> a -> m (TT (PP (Lookup p q) a))

(P p a, P q a, Show (PP p a), Show (PP q a)) => P (MkThese p q :: Type) a

Defined in Predicate

Associated Types

type PP (MkThese p q) a :: Type

Methods

eval :: MonadEval m => Proxy (MkThese p q) -> POpts -> a -> m (TT (PP (MkThese p q) a))

(Show (PP p x), P p x) => P (MkThat' t p :: Type) x

Defined in Predicate

Associated Types

type PP (MkThat' t p) x :: Type

Methods

eval :: MonadEval m => Proxy (MkThat' t p) -> POpts -> x -> m (TT (PP (MkThat' t p) x))

(Show (PP p x), P p x) => P (MkThis' t p :: Type) x

Defined in Predicate

Associated Types

type PP (MkThis' t p) x :: Type

Methods

eval :: MonadEval m => Proxy (MkThis' t p) -> POpts -> x -> m (TT (PP (MkThis' t p) x))

(Show (PP p x), P p x) => P (MkRight' t p :: Type) x

Defined in Predicate

Associated Types

type PP (MkRight' t p) x :: Type

Methods

eval :: MonadEval m => Proxy (MkRight' t p) -> POpts -> x -> m (TT (PP (MkRight' t p) x))

(Show (PP p x), P p x) => P (MkLeft' t p :: Type) x

Defined in Predicate

Associated Types

type PP (MkLeft' t p) x :: Type

Methods

eval :: MonadEval m => Proxy (MkLeft' t p) -> POpts -> x -> m (TT (PP (MkLeft' t p) x))

(P n a, Integral (PP n a), Semigroup (PP p a), P p a, Show (PP p a)) => P (STimes n p :: Type) a

Defined in Predicate

Associated Types

type PP (STimes n p) a :: Type

Methods

eval :: MonadEval m => Proxy (STimes n p) -> POpts -> a -> m (TT (PP (STimes n p) a))

([PP p a] ~ PP q a, P p a, P q a, Show (PP p a), Eq (PP p a)) => P (Elem p q :: Type) a

Defined in Predicate

Associated Types

type PP (Elem p q) a :: Type

Methods

eval :: MonadEval m => Proxy (Elem p q) -> POpts -> a -> m (TT (PP (Elem p q) a))

(P def (Proxy (PP t a)), PP def (Proxy (PP t a)) ~ PP t a, Show a, Show (PP t a), Bounded (PP t a), Enum (PP t a), Integral a) => P (ToEnumB' t def :: Type) a

Defined in Predicate

Associated Types

type PP (ToEnumB' t def) a :: Type

Methods

eval :: MonadEval m => Proxy (ToEnumB' t def) -> POpts -> a -> m (TT (PP (ToEnumB' t def) a))

(PP p x ~ a, P p x, Show a, Enum (PP t x), Show (PP t x), Integral a) => P (ToEnum' t p :: Type) x

Defined in Predicate

Associated Types

type PP (ToEnum' t p) x :: Type

Methods

eval :: MonadEval m => Proxy (ToEnum' t p) -> POpts -> x -> m (TT (PP (ToEnum' t p) x))

(PP q x ~ a, P q x, P p (Proxy a), PP p (Proxy a) ~ a, Show a, Eq a, Bounded a, Enum a) => P (PredB p q :: Type) x

Defined in Predicate

Associated Types

type PP (PredB p q) x :: Type

Methods

eval :: MonadEval m => Proxy (PredB p q) -> POpts -> x -> m (TT (PP (PredB p q) x))

(PP q x ~ a, P q x, P p (Proxy a), PP p (Proxy a) ~ a, Show a, Eq a, Bounded a, Enum a) => P (SuccB p q :: Type) x

Defined in Predicate

Associated Types

type PP (SuccB p q) x :: Type

Methods

eval :: MonadEval m => Proxy (SuccB p q) -> POpts -> x -> m (TT (PP (SuccB p q) x))

(Show (PP p x), P p x, Unwrapped (PP s x) ~ PP p x, Wrapped (PP s x), Show (PP s x)) => P (Wrap' s p :: Type) x

Defined in Predicate

Associated Types

type PP (Wrap' s p) x :: Type

Methods

eval :: MonadEval m => Proxy (Wrap' s p) -> POpts -> x -> m (TT (PP (Wrap' s p) x))

(Integral (PP p x), Integral (PP q x), Eq (PP q x), P p x, P q x, Show (PP p x), Show (PP q x)) => P (p % q :: Type) x

Defined in Predicate

Associated Types

type PP (p % q) x :: Type

Methods

eval :: MonadEval m => Proxy (p % q) -> POpts -> x -> m (TT (PP (p % q) x))

(PP p a ~ PP q a, Eq (PP q a), P p a, P q a, Show (PP p a), Fractional (PP p a)) => P (DivF p q :: Type) a

Defined in Predicate

Associated Types

type PP (DivF p q) a :: Type

Methods

eval :: MonadEval m => Proxy (DivF p q) -> POpts -> a -> m (TT (PP (DivF p q) a))

(PP p a ~ [b], P n a, P p a, Show b, Integral (PP n a)) => P (SplitAt n p :: Type) a

Defined in Predicate

Associated Types

type PP (SplitAt n p) a :: Type

Methods

eval :: MonadEval m => Proxy (SplitAt n p) -> POpts -> a -> m (TT (PP (SplitAt n p) a))

(P ns x, P p x, PP p x ~ [a], Show n, Show a, PP ns x ~ [n], Integral n) => P (SplitAts ns p :: Type) x

Defined in Predicate

Associated Types

type PP (SplitAts ns p) x :: Type

Methods

eval :: MonadEval m => Proxy (SplitAts ns p) -> POpts -> x -> m (TT (PP (SplitAts ns p) x))

(P prt a, PP prt a ~ String, P p a) => P (Msg prt p :: Type) a

Defined in Predicate

Associated Types

type PP (Msg prt p) a :: Type

Methods

eval :: MonadEval m => Proxy (Msg prt p) -> POpts -> a -> m (TT (PP (Msg prt p) a))

(Show (PP p a), P b a, P p a, PP b a ~ Bool) => P (MaybeB b p :: Type) a

Defined in Predicate

Associated Types

type PP (MaybeB b p) a :: Type

Methods

eval :: MonadEval m => Proxy (MaybeB b p) -> POpts -> a -> m (TT (PP (MaybeB b p) a))

(Show (PP p x), P p x, Show (PP t x), RealFrac (PP p x), Integral (PP t x)) => P (Floor' t p :: Type) x

Defined in Predicate

Associated Types

type PP (Floor' t p) x :: Type

Methods

eval :: MonadEval m => Proxy (Floor' t p) -> POpts -> x -> m (TT (PP (Floor' t p) x))

(Show (PP p x), P p x, Show (PP t x), RealFrac (PP p x), Integral (PP t x)) => P (Ceiling' t p :: Type) x

Defined in Predicate

Associated Types

type PP (Ceiling' t p) x :: Type

Methods

eval :: MonadEval m => Proxy (Ceiling' t p) -> POpts -> x -> m (TT (PP (Ceiling' t p) x))

(Show (PP p x), P p x, Show (PP t x), RealFrac (PP p x), Integral (PP t x)) => P (Truncate' t p :: Type) x

Defined in Predicate

Associated Types

type PP (Truncate' t p) x :: Type

Methods

eval :: MonadEval m => Proxy (Truncate' t p) -> POpts -> x -> m (TT (PP (Truncate' t p) x))

(P r a, PP r a ~ Rational, Show (PP t a), Fractional (PP t a)) => P (FromRational' t r :: Type) a

Defined in Predicate

Associated Types

type PP (FromRational' t r) a :: Type

Methods

eval :: MonadEval m => Proxy (FromRational' t r) -> POpts -> a -> m (TT (PP (FromRational' t r) a))

(Num (PP t a), Integral (PP n a), P n a, Show (PP t a), Show (PP n a)) => P (FromIntegral' t n :: Type) a

Defined in Predicate

Associated Types

type PP (FromIntegral' t n) a :: Type

Methods

eval :: MonadEval m => Proxy (FromIntegral' t n) -> POpts -> a -> m (TT (PP (FromIntegral' t n) a))

(Num (PP t a), Integral (PP n a), P n a, Show (PP t a)) => P (FromInteger' t n :: Type) a

Defined in Predicate

Associated Types

type PP (FromInteger' t n) a :: Type

Methods

eval :: MonadEval m => Proxy (FromInteger' t n) -> POpts -> a -> m (TT (PP (FromInteger' t n) a))

(P s a, PP s a ~ String, Show (PP t a), IsString (PP t a)) => P (FromStringP' t s :: Type) a

Defined in Predicate

Associated Types

type PP (FromStringP' t s) a :: Type

Methods

eval :: MonadEval m => Proxy (FromStringP' t s) -> POpts -> a -> m (TT (PP (FromStringP' t s) a))

(P p (a, a), P q x, Show a, PP q x ~ [a], PP p (a, a) ~ Ordering) => P (SortBy p q :: Type) x

Defined in Predicate

Associated Types

type PP (SortBy p q) x :: Type

Methods

eval :: MonadEval m => Proxy (SortBy p q) -> POpts -> x -> m (TT (PP (SortBy p q) x))

(P p x, PP p x ~ String, Typeable (PP t x), Show (PP t x), Read (PP t x)) => P (ReadP'' t p :: Type) x

Defined in Predicate

Associated Types

type PP (ReadP'' t p) x :: Type

Methods

eval :: MonadEval m => Proxy (ReadP'' t p) -> POpts -> x -> m (TT (PP (ReadP'' t p) x))

(PP p x ~ String, FormatTime (PP q x), P p x, Show (PP q x), P q x) => P (FormatTimeP p q :: Type) x

Defined in Predicate

Associated Types

type PP (FormatTimeP p q) x :: Type

Methods

eval :: MonadEval m => Proxy (FormatTimeP p q) -> POpts -> x -> m (TT (PP (FormatTimeP p q) x))

(P (ParaImpl (LenT (RepeatT n p)) strict (RepeatT n p)) [a], GetLen (RepeatT n p), GetBool strict) => P (ParaImplN strict n p :: Type) [a]

Defined in Predicate

Associated Types

type PP (ParaImplN strict n p) [a] :: Type

Methods

eval :: MonadEval m => Proxy (ParaImplN strict n p) -> POpts -> [a] -> m (TT (PP (ParaImplN strict n p) [a]))

(TypeError (Text "ParaImpl '[] invalid: requires at least one value in the list") :: Constraint) => P (ParaImpl n strict ([] :: [k]) :: Type) [a]

Defined in Predicate

Associated Types

type PP (ParaImpl n strict []) [a] :: Type

Methods

eval :: MonadEval m => Proxy (ParaImpl n strict []) -> POpts -> [a] -> m (TT (PP (ParaImpl n strict []) [a]))

(KnownNat n, GetBool strict, GetLen ps, P p a, P (ParaImpl n strict (p1 ': ps)) [a], PP (ParaImpl n strict (p1 ': ps)) [a] ~ [PP p a], Show a, Show (PP p a)) => P (ParaImpl n strict (p ': (p1 ': ps)) :: Type) [a]

Defined in Predicate

Associated Types

type PP (ParaImpl n strict (p ': (p1 ': ps))) [a] :: Type

Methods

eval :: MonadEval m => Proxy (ParaImpl n strict (p ': (p1 ': ps))) -> POpts -> [a] -> m (TT (PP (ParaImpl n strict (p ': (p1 ': ps))) [a]))

(Show (PP p a), KnownNat n, GetBool strict, Show a, P p a) => P (ParaImpl n strict (p ': ([] :: [k])) :: Type) [a]

Defined in Predicate

Associated Types

type PP (ParaImpl n strict (p ': [])) [a] :: Type

Methods

eval :: MonadEval m => Proxy (ParaImpl n strict (p ': [])) -> POpts -> [a] -> m (TT (PP (ParaImpl n strict (p ': [])) [a]))

(GetBool strict, GetLen ps, P (GuardsImpl (LenT ps) strict ps) [a]) => P (GuardsImplW strict ps :: Type) [a]

Defined in Predicate

Associated Types

type PP (GuardsImplW strict ps) [a] :: Type

Methods

eval :: MonadEval m => Proxy (GuardsImplW strict ps) -> POpts -> [a] -> m (TT (PP (GuardsImplW strict ps) [a]))

(P q a, Show a, Show (PP q a), PP p (Proxy (PP q a)) ~ PP q a, P p (Proxy (PP q a))) => P (MaybeIn p q :: Type) (Maybe a)

Defined in Predicate

Associated Types

type PP (MaybeIn p q) (Maybe a) :: Type

Methods

eval :: MonadEval m => Proxy (MaybeIn p q) -> POpts -> Maybe a -> m (TT (PP (MaybeIn p q) (Maybe a)))

(Show (PP p a), Show (PP q b), P p a, P q b, Show a, Show b) => P (p +++ q :: Type) (Either a b)

Defined in Predicate

Associated Types

type PP (p +++ q) (Either a b) :: Type

Methods

eval :: MonadEval m => Proxy (p +++ q) -> POpts -> Either a b -> m (TT (PP (p +++ q) (Either a b)))

(Show (PP p a), P p a, P q b, PP p a ~ PP q b, Show a, Show b) => P (p ||| q :: Type) (Either a b)

Defined in Predicate

Associated Types

type PP (p ||| q) (Either a b) :: Type

Methods

eval :: MonadEval m => Proxy (p ||| q) -> POpts -> Either a b -> m (TT (PP (p ||| q) (Either a b)))

(Show (PP p a), Show (PP q b), P p a, P q b, Show a, Show b) => P (p *** q :: Type) (a, b)

Defined in Predicate

Associated Types

type PP (p *** q) (a, b) :: Type

Methods

eval :: MonadEval m => Proxy (p *** q) -> POpts -> (a, b) -> m (TT (PP (p *** q) (a, b)))

(GetBool r, PP p x ~ String, P p x, IsText (PP q x), P q x) => P (StripLR r p q :: Type) x

Defined in Predicate

Associated Types

type PP (StripLR r p q) x :: Type

Methods

eval :: MonadEval m => Proxy (StripLR r p q) -> POpts -> x -> m (TT (PP (StripLR r p q) x))

(Typeable (PP t x), BetweenT 2 36 n, Show (PP t x), Num (PP t x), KnownNat n, PP p x ~ String, P p x) => P (ReadBase' t n p :: Type) x

Defined in Predicate

Associated Types

type PP (ReadBase' t n p) x :: Type

Methods

eval :: MonadEval m => Proxy (ReadBase' t n p) -> POpts -> x -> m (TT (PP (ReadBase' t n p) x))

(PP p x ~ These a b, P p x, Show a, Show b, GetThese th) => P (IsTh th p :: Type) x

Defined in Predicate

Associated Types

type PP (IsTh th p) x :: Type

Methods

eval :: MonadEval m => Proxy (IsTh th p) -> POpts -> x -> m (TT (PP (IsTh th p) x))

(PP p a ~ String, GetOrd o, PP p a ~ PP q a, P p a, P q a) => P (CmpI o p q :: Type) a

Defined in Predicate

Associated Types

type PP (CmpI o p q) a :: Type

Methods

eval :: MonadEval m => Proxy (CmpI o p q) -> POpts -> a -> m (TT (PP (CmpI o p q) a))

(GetOrd o, Ord (PP p a), Show (PP p a), PP p a ~ PP q a, P p a, P q a) => P (Cmp o p q :: Type) a

Defined in Predicate

Associated Types

type PP (Cmp o p q) a :: Type

Methods

eval :: MonadEval m => Proxy (Cmp o p q) -> POpts -> a -> m (TT (PP (Cmp o p q) a))

(GetBool keep, Eq a, Show a, P p x, P q x, PP p x ~ PP q x, PP q x ~ [a]) => P (KeepImpl keep p q :: Type) x

Defined in Predicate

Associated Types

type PP (KeepImpl keep p q) x :: Type

Methods

eval :: MonadEval m => Proxy (KeepImpl keep p q) -> POpts -> x -> m (TT (PP (KeepImpl keep p q) x))

(GetBinOp op, PP p a ~ PP q a, P p a, P q a, Show (PP p a), Num (PP p a)) => P (Bin op p q :: Type) a

Defined in Predicate

Associated Types

type PP (Bin op p q) a :: Type

Methods

eval :: MonadEval m => Proxy (Bin op p q) -> POpts -> a -> m (TT (PP (Bin op p q) a))

(GetROpts rs, PP p x ~ String, PP q x ~ String, P p x, P q x) => P (Resplit' rs p q :: Type) x

Defined in Predicate

Associated Types

type PP (Resplit' rs p q) x :: Type

Methods

eval :: MonadEval m => Proxy (Resplit' rs p q) -> POpts -> x -> m (TT (PP (Resplit' rs p q) x))

(GetROpts rs, PP p x ~ String, PP q x ~ String, P p x, P q x) => P (RescanRanges' rs p q :: Type) x

Defined in Predicate

Associated Types

type PP (RescanRanges' rs p q) x :: Type

Methods

eval :: MonadEval m => Proxy (RescanRanges' rs p q) -> POpts -> x -> m (TT (PP (RescanRanges' rs p q) x))

(GetROpts rs, PP p x ~ String, PP q x ~ String, P p x, P q x) => P (Rescan' rs p q :: Type) x

Defined in Predicate

Associated Types

type PP (Rescan' rs p q) x :: Type

Methods

eval :: MonadEval m => Proxy (Rescan' rs p q) -> POpts -> x -> m (TT (PP (Rescan' rs p q) x))

(GetROpts rs, PP p x ~ String, PP q x ~ String, P p x, P q x) => P (Re' rs p q :: Type) x

Defined in Predicate

Associated Types

type PP (Re' rs p q) x :: Type

Methods

eval :: MonadEval m => Proxy (Re' rs p q) -> POpts -> x -> m (TT (PP (Re' rs p q) x))

(KnownNat n, GetBool strict, Show a) => P (GuardsImpl n strict ([] :: [(k, k1)]) :: Type) [a]

Defined in Predicate

Associated Types

type PP (GuardsImpl n strict []) [a] :: Type

Methods

eval :: MonadEval m => Proxy (GuardsImpl n strict []) -> POpts -> [a] -> m (TT (PP (GuardsImpl n strict []) [a]))

(PP prt (Int, a) ~ String, P prt (Int, a), KnownNat n, GetBool strict, GetLen ps, P p a, PP p a ~ Bool, P (GuardsImpl n strict ps) [a], PP (GuardsImpl n strict ps) [a] ~ [a], Show a) => P (GuardsImpl n strict ((,) prt p ': ps) :: Type) [a]

Defined in Predicate

Associated Types

type PP (GuardsImpl n strict ((prt, p) ': ps)) [a] :: Type

Methods

eval :: MonadEval m => Proxy (GuardsImpl n strict ((prt, p) ': ps)) -> POpts -> [a] -> m (TT (PP (GuardsImpl n strict ((prt, p) ': ps)) [a]))

(GetBool ignore, P p x, P q x, PP p x ~ String, PP q x ~ String, GetOrdering cmp) => P (IsFixImpl cmp ignore p q :: Type) x

Defined in Predicate

Associated Types

type PP (IsFixImpl cmp ignore p q) x :: Type

Methods

eval :: MonadEval m => Proxy (IsFixImpl cmp ignore p q) -> POpts -> x -> m (TT (PP (IsFixImpl cmp ignore p q) x))

(GetBool lc, GetBool rc, PP p a ~ [x], PP q a ~ [y], P p a, P q a, Show x, Show y) => P (Zip lc rc p q :: Type) a

Defined in Predicate

Associated Types

type PP (Zip lc rc p q) a :: Type

Methods

eval :: MonadEval m => Proxy (Zip lc rc p q) -> POpts -> a -> m (TT (PP (Zip lc rc p q) a))

(Show (PP r a), P p a, PP p a ~ Bool, P q a, P r a, PP q a ~ PP r a) => P (If p q r :: Type) a

Defined in Predicate

Associated Types

type PP (If p q r) a :: Type

Methods

eval :: MonadEval m => Proxy (If p q r) -> POpts -> a -> m (TT (PP (If p q r) a))

(PP p (b, a) ~ b, PP q x ~ b, PP r x ~ [a], P p (b, a), P q x, P r x, Show b, Show a) => P (Scanl p q r :: Type) x

Defined in Predicate

Associated Types

type PP (Scanl p q r) x :: Type

Methods

eval :: MonadEval m => Proxy (Scanl p q r) -> POpts -> x -> m (TT (PP (Scanl p q r) x))

(P q a, P p a, Show (PP p a), Ixed (PP p a), PP q a ~ Index (PP p a), Show (Index (PP p a)), Show (IxValue (PP p a)), P r (Proxy (IxValue (PP p a))), PP r (Proxy (IxValue (PP p a))) ~ IxValue (PP p a)) => P (IxL p q r :: Type) a

Defined in Predicate

Associated Types

type PP (IxL p q r) a :: Type

Methods

eval :: MonadEval m => Proxy (IxL p q r) -> POpts -> a -> m (TT (PP (IxL p q r) a))

(P r x, P p (x, a), P q (x, b), PP r x ~ Either a b, PP p (x, a) ~ c, PP q (x, b) ~ c) => P (EitherX p q r :: Type) x

Defined in Predicate

Associated Types

type PP (EitherX p q r) x :: Type

Methods

eval :: MonadEval m => Proxy (EitherX p q r) -> POpts -> x -> m (TT (PP (EitherX p q r) x))

(P r x, P p (x, Proxy a), P q (x, a), PP r x ~ Maybe a, PP p (x, Proxy a) ~ b, PP q (x, a) ~ b) => P (MaybeXP p q r :: Type) x

Defined in Predicate

Associated Types

type PP (MaybeXP p q r) x :: Type

Methods

eval :: MonadEval m => Proxy (MaybeXP p q r) -> POpts -> x -> m (TT (PP (MaybeXP p q r) x))

(Show (PP p a), P p a, Show (PP q a), P q a, P b a, PP b a ~ Bool) => P (EitherB b p q :: Type) a

Defined in Predicate

Associated Types

type PP (EitherB b p q) a :: Type

Methods

eval :: MonadEval m => Proxy (EitherB b p q) -> POpts -> a -> m (TT (PP (EitherB b p q) a))

(P p x, P q x, P r x, PP p x ~ Int, PP q x ~ Int, PP r x ~ Int) => P (MkDay' p q r :: Type) x

Defined in Predicate

Associated Types

type PP (MkDay' p q r) x :: Type

Methods

eval :: MonadEval m => Proxy (MkDay' p q r) -> POpts -> x -> m (TT (PP (MkDay' p q r) x))

(ParseTime (PP t a), Typeable (PP t a), Show (PP t a), P p a, P q a, PP p a ~ [String], PP q a ~ String) => P (ParseTimes' t p q :: Type) a

Defined in Predicate

Associated Types

type PP (ParseTimes' t p q) a :: Type

Methods

eval :: MonadEval m => Proxy (ParseTimes' t p q) -> POpts -> a -> m (TT (PP (ParseTimes' t p q) a))

(ParseTime (PP t a), Typeable (PP t a), Show (PP t a), P p a, P q a, PP p a ~ String, PP q a ~ String) => P (ParseTimeP' t p q :: Type) a

Defined in Predicate

Associated Types

type PP (ParseTimeP' t p q) a :: Type

Methods

eval :: MonadEval m => Proxy (ParseTimeP' t p q) -> POpts -> a -> m (TT (PP (ParseTimeP' t p q) a))

(GetBool strict, GetLen (ToGuardsT prt (RepeatT n p)), P (GuardsImpl (LenT (ToGuardsT prt (RepeatT n p))) strict (ToGuardsT prt (RepeatT n p))) [a]) => P (GuardsImplN strict prt n p :: Type) [a]

Defined in Predicate

Associated Types

type PP (GuardsImplN strict prt n p) [a] :: Type

Methods

eval :: MonadEval m => Proxy (GuardsImplN strict prt n p) -> POpts -> [a] -> m (TT (PP (GuardsImplN strict prt n p) [a]))

(Show a, Show b, Show (PP p a), P p a, P q b, P r (a, b), PP p a ~ PP q b, PP p a ~ PP r (a, b), PP q b ~ PP r (a, b)) => P (TheseIn p q r :: Type) (These a b)

Defined in Predicate

Associated Types

type PP (TheseIn p q r) (These a b) :: Type

Methods

eval :: MonadEval m => Proxy (TheseIn p q r) -> POpts -> These a b -> m (TT (PP (TheseIn p q r) (These a b)))

(P n a, GetBool left, Integral (PP n a), [PP p a] ~ PP q a, P p a, P q a, Show (PP p a)) => P (Pad left n p q :: Type) a

Defined in Predicate

Associated Types

type PP (Pad left n p q) a :: Type

Methods

eval :: MonadEval m => Proxy (Pad left n p q) -> POpts -> a -> m (TT (PP (Pad left n p q) a))

(FailIfT (NotT (LenT ps == LenT qs)) (((Text "lengths are not the same " :<>: ShowType (LenT ps)) :<>: Text " vs ") :<>: ShowType (LenT qs)), P (CaseImpl (LenT ps) e ps qs r) x) => P (Case e ps qs r :: Type) x

Defined in Predicate

Associated Types

type PP (Case e ps qs r) x :: Type

Methods

eval :: MonadEval m => Proxy (Case e ps qs r) -> POpts -> x -> m (TT (PP (Case e ps qs r) x))

(P s x, P p (x, a), P q (x, b), P r (x, (a, b)), PP s x ~ These a b, PP p (x, a) ~ c, PP q (x, b) ~ c, PP r (x, (a, b)) ~ c) => P (TheseX p q r s :: Type) x

Defined in Predicate

Associated Types

type PP (TheseX p q r s) x :: Type

Methods

eval :: MonadEval m => Proxy (TheseX p q r s) -> POpts -> x -> m (TT (PP (TheseX p q r s) x))

(GetBool b, GetROpts rs, PP p x ~ String, PP q x ~ RR, PP r x ~ String, P p x, P q x, P r x) => P (ReplaceImpl b rs p q r :: Type) x

Defined in Predicate

Associated Types

type PP (ReplaceImpl b rs p q r) x :: Type

Methods

eval :: MonadEval m => Proxy (ReplaceImpl b rs p q r) -> POpts -> x -> m (TT (PP (ReplaceImpl b rs p q r) x))

(KnownNat n, GetLen ps, P r x, P p (PP r x), P q (PP r x), PP p (PP r x) ~ Bool, Show (PP q (PP r x)), Show (PP r x), P (CaseImpl n e (p1 ': ps) (q1 ': qs) r) x, PP (CaseImpl n e (p1 ': ps) (q1 ': qs) r) x ~ PP q (PP r x)) => P (CaseImpl n e (p ': (p1 ': ps)) (q ': (q1 ': qs)) r :: Type) x

Defined in Predicate

Associated Types

type PP (CaseImpl n e (p ': (p1 ': ps)) (q ': (q1 ': qs)) r) x :: Type

Methods

eval :: MonadEval m => Proxy (CaseImpl n e (p ': (p1 ': ps)) (q ': (q1 ': qs)) r) -> POpts -> x -> m (TT (PP (CaseImpl n e (p ': (p1 ': ps)) (q ': (q1 ': qs)) r) x))

(P r x, P q (PP r x), Show (PP q (PP r x)), P p (PP r x), PP p (PP r x) ~ Bool, KnownNat n, Show (PP r x), P e (PP r x, Proxy (PP q (PP r x))), PP e (PP r x, Proxy (PP q (PP r x))) ~ PP q (PP r x)) => P (CaseImpl n e (p ': ([] :: [k])) (q ': ([] :: [k1])) r :: Type) x

Defined in Predicate

Associated Types

type PP (CaseImpl n e (p ': []) (q ': []) r) x :: Type

Methods

eval :: MonadEval m => Proxy (CaseImpl n e (p ': []) (q ': []) r) -> POpts -> x -> m (TT (PP (CaseImpl n e (p ': []) (q ': []) r) x))

(TypeError (Text "CaseImpl '[] invalid: lists are both empty") :: Constraint) => P (CaseImpl n e ([] :: [k]) ([] :: [k1]) r :: Type) x

Defined in Predicate

Associated Types

type PP (CaseImpl n e [] [] r) x :: Type

Methods

eval :: MonadEval m => Proxy (CaseImpl n e [] [] r) -> POpts -> x -> m (TT (PP (CaseImpl n e [] [] r) x))

(TypeError (Text "CaseImpl '[] invalid: rhs requires at least one value in the list") :: Constraint) => P (CaseImpl n e (p ': ps) ([] :: [k1]) r :: Type) x

Defined in Predicate

Associated Types

type PP (CaseImpl n e (p ': ps) [] r) x :: Type

Methods

eval :: MonadEval m => Proxy (CaseImpl n e (p ': ps) [] r) -> POpts -> x -> m (TT (PP (CaseImpl n e (p ': ps) [] r) x))

(TypeError (Text "CaseImpl '[] invalid: lhs requires at least one value in the list") :: Constraint) => P (CaseImpl n e ([] :: [k]) (q ': qs) r :: Type) x

Defined in Predicate

Associated Types

type PP (CaseImpl n e [] (q ': qs) r) x :: Type

Methods

eval :: MonadEval m => Proxy (CaseImpl n e [] (q ': qs) r) -> POpts -> x -> m (TT (PP (CaseImpl n e [] (q ': qs) r) x))

Show a => P (Proxy :: Proxy t) a

converts the value to the corresponding Proxy

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @'Proxy 'x'
Present Proxy
PresentT Proxy

Defined in Predicate

Associated Types

type PP Proxy a :: Type

Methods

eval :: MonadEval m => Proxy Proxy0 -> POpts -> a -> m (TT (PP Proxy0 a))

(Show a2, Show (PP p a2), P p a2) => P (Right p :: Either a1 b) (Either x a2)

extracts the 'b' from type level 'Either a b' if the value exists

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @('Right Id) (Right 123)
Present 123
PresentT 123

>>> pl @('Right Id) (Left "aaa")
Error 'Right found Left
FailT "'Right found Left"

Defined in Predicate

Associated Types

type PP (Right p) (Either x a2) :: Type

Methods

eval :: MonadEval m => Proxy (Right p) -> POpts -> Either x a2 -> m (TT (PP (Right p) (Either x a2)))

(Show a2, Show (PP p a2), P p a2) => P (Left p :: Either a1 b) (Either a2 x)

extracts the 'a' from type level 'Either a b' if the value exists

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @('Left Id) (Left 123)
Present 123
PresentT 123

>>> pl @('Left Id) (Right "aaa")
Error 'Left found Right
FailT "'Left found Right"

Defined in Predicate

Associated Types

type PP (Left p) (Either a2 x) :: Type

Methods

eval :: MonadEval m => Proxy (Left p) -> POpts -> Either a2 x -> m (TT (PP (Left p) (Either a2 x)))

(Show a2, Show (PP p a2), P p a2) => P (That p :: These a1 b) (These x a2)

extracts the 'b' from type level 'These a b' if the value exists

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @('That Id) (That 123)
Present 123
PresentT 123

>>> pl @('That Id) (This "aaa")
Error 'That found This
FailT "'That found This"

>>> pl @('That Id) (These 44 "aaa")
Error 'That found These
FailT "'That found These"

Defined in Predicate

Associated Types

type PP (That p) (These x a2) :: Type

Methods

eval :: MonadEval m => Proxy (That p) -> POpts -> These x a2 -> m (TT (PP (That p) (These x a2)))

(Show a2, Show (PP p a2), P p a2) => P (This p :: These a1 b) (These a2 x)

extracts the 'a' from type level 'These a b' if the value exists

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @('This Id) (This 123)
Present 123
PresentT 123

>>> pl @('This Id) (That "aaa")
Error 'This found That
FailT "'This found That"

>>> pl @('This Id) (These 999 "aaa")
Error 'This found These
FailT "'This found These"

Defined in Predicate

Associated Types

type PP (This p) (These a2 x) :: Type

Methods

eval :: MonadEval m => Proxy (This p) -> POpts -> These a2 x -> m (TT (PP (This p) (These a2 x)))

(P p a, P q a) => P ((,) p q :: (k2, k1)) a

run the predicates in a promoted 2-tuple; similar to &&&

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @'(Snd Id, Fst Id) ("helo",123)
Present (123,"helo")
PresentT (123,"helo")

>>> :set -XTypeOperators
>>> pl @'(Len, Id <> "|" <> Reverse) "helo"
Present (4,"helo|oleh")
PresentT (4,"helo|oleh")

Defined in Predicate

Associated Types

type PP (p, q) a :: Type

Methods

eval :: MonadEval m => Proxy (p, q) -> POpts -> a -> m (TT (PP (p, q) a))

(Show a2, Show b2, P p a2, P q b2, Show (PP p a2), Show (PP q b2)) => P (These p q :: These a1 b1) (These a2 b2)

extracts the (a,b) from type level 'These a b' if the value exists

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @('These Id Id) (These 123 "abc")
Present (123,"abc")
PresentT (123,"abc")

>>> pl @('These (Pred Id) Len) (These 123 "abcde")
Present (122,5)
PresentT (122,5)

>>> pl @('These Id Id) (This "aaa")
Error 'These found This
FailT "'These found This"

>>> pl @('These Id Id) (That "aaa")
Error 'These found That
FailT "'These found That"

Defined in Predicate

Associated Types

type PP (These p q) (These a2 b2) :: Type

Methods

eval :: MonadEval m => Proxy (These p q) -> POpts -> These0 a2 b2 -> m (TT (PP (These p q) (These0 a2 b2)))

(P p a, P q a, P r a) => P ((,,) p q r :: (k3, k2, k1)) a

run the predicates in a promoted 3-tuple

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @'(Len, Id, Reverse) "helo"
Present (4,"helo","oleh")
PresentT (4,"helo","oleh")

Defined in Predicate

Associated Types

type PP (p, q, r) a :: Type

Methods

eval :: MonadEval m => Proxy (p, q, r) -> POpts -> a -> m (TT (PP (p, q, r) a))

(P p a, P q a, P r a, P s a) => P ((,,,) p q r s :: (k4, k3, k2, k1)) a

run the predicates in a promoted 4-tuple

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @'(Len, Id, "inj", 999) "helo"
Present (4,"helo","inj",999)
PresentT (4,"helo","inj",999)

Defined in Predicate

Associated Types

type PP (p, q, r, s) a :: Type

Methods

eval :: MonadEval m => Proxy (p, q, r, s) -> POpts -> a -> m (TT (PP (p, q, r, s) a))

evalBool :: (MonadEval m, P p a, PP p a ~ Bool) => Proxy p -> POpts -> a -> m (TT (PP p a))

A specialised form of eval that works only on predicates

type Asc = Ands (Map (Fst Id <= Snd Id) Pairs)

a type level predicate for a monotonic increasing list

type Asc' = Ands (Map (Fst Id < Snd Id) Pairs)

a type level predicate for a strictly increasing list

type Desc = Ands (Map (Fst Id >= Snd Id) Pairs)

a type level predicate for a monotonic decreasing list

type Desc' = Ands (Map (Fst Id > Snd Id) Pairs)

a type level predicate for a strictly decreasing list

type Between p q = Ge p && Le q

A predicate that determines if the value is between 'p' and 'q'

type Between' p q r = (r >= p) && (r <= q)

This is the same as Between but where 'r' is Id

type AllPositive = Ands (Map Positive Id)

a type level predicate for all positive elements in a list

type AllNegative = Ands (Map Negative Id)

a type level predicate for all negative elements in a list

type Positive = Gt 0

type Negative = Lt 0

type AllPositive' = FoldMap All (Map Positive Id)

type AllNegative' = FoldMap All (Map Negative Id)

type All x p = Ands (Map x p)

type Any x p = Ors (Map x p)

type Unzip = (Map (Fst Id) Id, Map (Snd Id) Id)

unzip equivalent

data Re' (rs :: [ROpt]) p q

represents a predicate using a Symbol as a regular expression evaluates Re and returns True if there is a match

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(Re "^\\d{2}:\\d{2}:\\d{2}$" Id) "13:05:25"
True
TrueT

Instances

(GetROpts rs, PP p x ~ String, PP q x ~ String, P p x, P q x) => P (Re' rs p q :: Type) x

Defined in Predicate

Associated Types

type PP (Re' rs p q) x :: Type

Methods

eval :: MonadEval m => Proxy (Re' rs p q) -> POpts -> x -> m (TT (PP (Re' rs p q) x))

type PP (Re' rs p q :: Type) x

Defined in Predicate

type PP (Re' rs p q :: Type) x = Bool

type Re p q = Re' '[] p q

data Rescan' (rs :: [ROpt]) p q

runs a regex matcher returning the original values and optionally any groups

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(Rescan "^(\\d{2}):(\\d{2}):(\\d{2})$" Id) "13:05:25"
Present [("13:05:25",["13","05","25"])]
PresentT [("13:05:25",["13","05","25"])]

>>> pl @(Rescan (Snd Id) "13:05:25") ('a',"^(\\d{2}):(\\d{2}):(\\d{2})$")
Present [("13:05:25",["13","05","25"])]
PresentT [("13:05:25",["13","05","25"])]

Instances

(GetROpts rs, PP p x ~ String, PP q x ~ String, P p x, P q x) => P (Rescan' rs p q :: Type) x

Defined in Predicate

Associated Types

type PP (Rescan' rs p q) x :: Type

Methods

eval :: MonadEval m => Proxy (Rescan' rs p q) -> POpts -> x -> m (TT (PP (Rescan' rs p q) x))

type PP (Rescan' rs p q :: Type) x

Defined in Predicate

type PP (Rescan' rs p q :: Type) x = [(String, [String])]

type Rescan p q = Rescan' '[] p q

data RescanRanges' (rs :: [ROpt]) p q

similar to Rescan but gives the column start and ending positions instead of values

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(RescanRanges "^(\\d{2}):(\\d{2}):(\\d{2})$" Id) "13:05:25"
Present [((0,8),[(0,2),(3,5),(6,8)])]
PresentT [((0,8),[(0,2),(3,5),(6,8)])]

Instances

(GetROpts rs, PP p x ~ String, PP q x ~ String, P p x, P q x) => P (RescanRanges' rs p q :: Type) x

Defined in Predicate

Associated Types

type PP (RescanRanges' rs p q) x :: Type

Methods

eval :: MonadEval m => Proxy (RescanRanges' rs p q) -> POpts -> x -> m (TT (PP (RescanRanges' rs p q) x))

type PP (RescanRanges' rs p q :: Type) x

Defined in Predicate

type PP (RescanRanges' rs p q :: Type) x = [((Int, Int), [(Int, Int)])]

type RescanRanges p q = RescanRanges' '[] p q

data Resplit' (rs :: [ROpt]) p q

splits a string on a regex delimiter

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(Resplit "\\." Id) "141.201.1.22"
Present ["141","201","1","22"]
PresentT ["141","201","1","22"]

>>> pl @(Resplit (Singleton (Fst Id)) (Snd Id)) (':', "12:13:1")
Present ["12","13","1"]
PresentT ["12","13","1"]

Instances

(GetROpts rs, PP p x ~ String, PP q x ~ String, P p x, P q x) => P (Resplit' rs p q :: Type) x

Defined in Predicate

Associated Types

type PP (Resplit' rs p q) x :: Type

Methods

eval :: MonadEval m => Proxy (Resplit' rs p q) -> POpts -> x -> m (TT (PP (Resplit' rs p q) x))

type PP (Resplit' rs p q :: Type) x

Defined in Predicate

type PP (Resplit' rs p q :: Type) x = [String]

type Resplit p q = Resplit' '[] p q

_MX :: Int

data ReplaceImpl (alle :: Bool) (rs :: [ROpt]) p q r

replaces regex 's' with a string 's1' inside the value

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(ReplaceAllString "\\." ":" Id) "141.201.1.22"
Present "141:201:1:22"
PresentT "141:201:1:22"

Instances

(GetBool b, GetROpts rs, PP p x ~ String, PP q x ~ RR, PP r x ~ String, P p x, P q x, P r x) => P (ReplaceImpl b rs p q r :: Type) x

Defined in Predicate

Associated Types

type PP (ReplaceImpl b rs p q r) x :: Type

Methods

eval :: MonadEval m => Proxy (ReplaceImpl b rs p q r) -> POpts -> x -> m (TT (PP (ReplaceImpl b rs p q r) x))

type PP (ReplaceImpl b rs p q r :: Type) x

Defined in Predicate

type PP (ReplaceImpl b rs p q r :: Type) x = String

type ReplaceAll' (rs :: [ROpt]) p q r = ReplaceImpl True rs p q r

type ReplaceAll p q r = ReplaceAll' '[] p q r

type ReplaceOne' (rs :: [ROpt]) p q r = ReplaceImpl False rs p q r

type ReplaceOne p q r = ReplaceOne' '[] p q r

type ReplaceAllString' (rs :: [ROpt]) p q r = ReplaceAll' rs p (MakeRR q) r

type ReplaceAllString p q r = ReplaceAllString' '[] p q r

type ReplaceOneString' (rs :: [ROpt]) p q r = ReplaceOne' rs p (MakeRR q) r

type ReplaceOneString p q r = ReplaceOneString' '[] p q r

data MakeRR p

Simple replacement string: see ReplaceAllString and ReplaceOneString

Instances

(PP p x ~ String, P p x) => P (MakeRR p :: Type) x

Defined in Predicate

Associated Types

type PP (MakeRR p) x :: Type

Methods

eval :: MonadEval m => Proxy (MakeRR p) -> POpts -> x -> m (TT (PP (MakeRR p) x))

type PP (MakeRR p :: Type) x

Defined in Predicate

type PP (MakeRR p :: Type) x = RR

data MakeRR1 p

A replacement function (String -> [String] -> String) which returns the whole match and the groups Used by sub and sub Requires Text.Show.Functions

Instances

(PP p x ~ (String -> [String] -> String), P p x) => P (MakeRR1 p :: Type) x

Defined in Predicate

Associated Types

type PP (MakeRR1 p) x :: Type

Methods

eval :: MonadEval m => Proxy (MakeRR1 p) -> POpts -> x -> m (TT (PP (MakeRR1 p) x))

type PP (MakeRR1 p :: Type) x

Defined in Predicate

type PP (MakeRR1 p :: Type) x = RR

data MakeRR2 p

A replacement function (String -> String) that yields the whole match Used by sub and sub Requires Text.Show.Functions

>>> :m + Text.Show.Functions
>>> pl @(ReplaceAll "\\." (MakeRR2 (Fst Id)) (Snd Id)) (\x -> x <> ":" <> x, "141.201.1.22")
Present "141.:.201.:.1.:.22"
PresentT "141.:.201.:.1.:.22"

Instances

(PP p x ~ (String -> String), P p x) => P (MakeRR2 p :: Type) x

Defined in Predicate

Associated Types

type PP (MakeRR2 p) x :: Type

Methods

eval :: MonadEval m => Proxy (MakeRR2 p) -> POpts -> x -> m (TT (PP (MakeRR2 p) x))

type PP (MakeRR2 p :: Type) x

Defined in Predicate

type PP (MakeRR2 p :: Type) x = RR

data MakeRR3 p

A replacement function ([String] -> String) which yields the groups Used by sub and sub Requires Text.Show.Functions

>>> :m + Text.Show.Functions
>>> pl @(ReplaceAll "^(\\d+)\\.(\\d+)\\.(\\d+)\\.(\\d+)$" (MakeRR3 (Fst Id)) (Snd Id)) (\ys -> intercalate  " | " $ map (show . succ . read @Int) ys, "141.201.1.22")
Present "142 | 202 | 2 | 23"
PresentT "142 | 202 | 2 | 23"

Instances

(PP p x ~ ([String] -> String), P p x) => P (MakeRR3 p :: Type) x

Defined in Predicate

Associated Types

type PP (MakeRR3 p) x :: Type

Methods

eval :: MonadEval m => Proxy (MakeRR3 p) -> POpts -> x -> m (TT (PP (MakeRR3 p) x))

type PP (MakeRR3 p :: Type) x

Defined in Predicate

type PP (MakeRR3 p :: Type) x = RR

data IsCharSet (cs :: CharSet)

a predicate for determining if a string IsText belongs to the given character set

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> import qualified Data.Text as T
>>> pl @IsLower "abc"
True
TrueT

>>> pl @IsLower "abcX"
False
FalseT

>>> pl @IsLower (T.pack "abcX")
False
FalseT

>>> pl @IsHexDigit "01efA"
True
TrueT

>>> pl @IsHexDigit "01egfA"
False
FalseT

Instances

(GetCharSet cs, Show a, IsText a) => P (IsCharSet cs :: Type) a

Defined in Predicate

Associated Types

type PP (IsCharSet cs) a :: Type

Methods

eval :: MonadEval m => Proxy (IsCharSet cs) -> POpts -> a -> m (TT (PP (IsCharSet cs) a))

type PP (IsCharSet cs :: Type) a

Defined in Predicate

type PP (IsCharSet cs :: Type) a = Bool

data CharSet

Constructors

CLower

CUpper

CNumber

CSpace

CPunctuation

CControl

CHexDigit

COctDigit

CSeparator

CLatin1

Instances

Show CharSet

Defined in Predicate

Methods

showsPrec :: Int -> CharSet -> ShowS

show :: CharSet -> String

showList :: [CharSet] -> ShowS

class GetCharSet (cs :: CharSet) where

Methods

getCharSet :: (CharSet, Char -> Bool)

Instances

GetCharSet CLower

Defined in Predicate

Methods

getCharSet :: (CharSet, Char -> Bool)

GetCharSet CUpper

Defined in Predicate

Methods

getCharSet :: (CharSet, Char -> Bool)

GetCharSet CNumber

Defined in Predicate

Methods

getCharSet :: (CharSet, Char -> Bool)

GetCharSet CPunctuation

Defined in Predicate

Methods

getCharSet :: (CharSet, Char -> Bool)

GetCharSet CControl

Defined in Predicate

Methods

getCharSet :: (CharSet, Char -> Bool)

GetCharSet CHexDigit

Defined in Predicate

Methods

getCharSet :: (CharSet, Char -> Bool)

GetCharSet COctDigit

Defined in Predicate

Methods

getCharSet :: (CharSet, Char -> Bool)

GetCharSet CSeparator

Defined in Predicate

Methods

getCharSet :: (CharSet, Char -> Bool)

GetCharSet CLatin1

Defined in Predicate

Methods

getCharSet :: (CharSet, Char -> Bool)

type IsLower = IsCharSet CLower

type IsUpper = IsCharSet CUpper

type IsNumber = IsCharSet CNumber

type IsSpace = IsCharSet CSpace

type IsPunctuation = IsCharSet CPunctuation

type IsControl = IsCharSet CControl

type IsHexDigit = IsCharSet CHexDigit

type IsOctDigit = IsCharSet COctDigit

type IsSeparator = IsCharSet CSeparator

type IsLatin1 = IsCharSet CLatin1

data ToLower

converts a string IsText value to lower case

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @ToLower "HeLlO wOrld!"
Present "hello world!"
PresentT "hello world!"

Instances

(Show a, IsText a) => P ToLower a

Defined in Predicate

Associated Types

type PP ToLower a :: Type

Methods

eval :: MonadEval m => Proxy ToLower -> POpts -> a -> m (TT (PP ToLower a))

type PP ToLower a

Defined in Predicate

type PP ToLower a = a

data ToUpper

converts a string IsText value to upper case

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @ToUpper "HeLlO wOrld!"
Present "HELLO WORLD!"
PresentT "HELLO WORLD!"

Instances

(Show a, IsText a) => P ToUpper a

Defined in Predicate

Associated Types

type PP ToUpper a :: Type

Methods

eval :: MonadEval m => Proxy ToUpper -> POpts -> a -> m (TT (PP ToUpper a))

type PP ToUpper a

Defined in Predicate

type PP ToUpper a = a

data Inits

similar to inits

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @Inits [4,8,3,9]
Present [[],[4],[4,8],[4,8,3],[4,8,3,9]]
PresentT [[],[4],[4,8],[4,8,3],[4,8,3,9]]

>>> pl @Inits []
Present [[]]
PresentT [[]]

Instances

Show a => P Inits [a]

Defined in Predicate

Associated Types

type PP Inits [a] :: Type

Methods

eval :: MonadEval m => Proxy Inits -> POpts -> [a] -> m (TT (PP Inits [a]))

type PP Inits [a]

Defined in Predicate

type PP Inits [a] = [[a]]

data Tails

similar to tails

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @Tails [4,8,3,9]
Present [[4,8,3,9],[8,3,9],[3,9],[9],[]]
PresentT [[4,8,3,9],[8,3,9],[3,9],[9],[]]

>>> pl @Tails []
Present [[]]
PresentT [[]]

Instances

Show a => P Tails [a]

Defined in Predicate

Associated Types

type PP Tails [a] :: Type

Methods

eval :: MonadEval m => Proxy Tails -> POpts -> [a] -> m (TT (PP Tails [a]))

type PP Tails [a]

Defined in Predicate

type PP Tails [a] = [[a]]

data Ones p

split a list into single values

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(Ones Id) [4,8,3,9]
Present [[4],[8],[3],[9]]
PresentT [[4],[8],[3],[9]]

>>> pl @(Ones Id) []
Present []
PresentT []

Instances

(PP p x ~ [a], P p x, Show a) => P (Ones p :: Type) x

Defined in Predicate

Associated Types

type PP (Ones p) x :: Type

Methods

eval :: MonadEval m => Proxy (Ones p) -> POpts -> x -> m (TT (PP (Ones p) x))

type PP (Ones p :: Type) x

Defined in Predicate

type PP (Ones p :: Type) x = [PP p x]

data ShowP p

similar to show

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(ShowP Id) [4,8,3,9]
Present "[4,8,3,9]"
PresentT "[4,8,3,9]"

>>> pl @(ShowP Id) 'x'
Present "'x'"
PresentT "'x'"

>>> pl @(ShowP (42 %- 10)) 'x'
Present "(-21) % 5"
PresentT "(-21) % 5"

Instances

(Show (PP p x), P p x) => P (ShowP p :: Type) x

Defined in Predicate

Associated Types

type PP (ShowP p) x :: Type

Methods

eval :: MonadEval m => Proxy (ShowP p) -> POpts -> x -> m (TT (PP (ShowP p) x))

type PP (ShowP p :: Type) x

Defined in Predicate

type PP (ShowP p :: Type) x = String

data FormatTimeP p q

type level expression representing a formatted time similar to formatTime using a type level Symbol to get the formatting string

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(FormatTimeP "%F %T" Id) (read "2019-05-24 05:19:59" :: LocalTime)
Present "2019-05-24 05:19:59"
PresentT "2019-05-24 05:19:59"

>>> pl @(FormatTimeP (Fst Id) (Snd Id)) ("the date is %d/%m/%Y", read "2019-05-24" :: Day)
Present "the date is 24/05/2019"
PresentT "the date is 24/05/2019"

Instances

(PP p x ~ String, FormatTime (PP q x), P p x, Show (PP q x), P q x) => P (FormatTimeP p q :: Type) x

Defined in Predicate

Associated Types

type PP (FormatTimeP p q) x :: Type

Methods

eval :: MonadEval m => Proxy (FormatTimeP p q) -> POpts -> x -> m (TT (PP (FormatTimeP p q) x))

type PP (FormatTimeP p q :: Type) x

Defined in Predicate

type PP (FormatTimeP p q :: Type) x = String

data ParseTimeP' t p q

similar to parseTimeM where 't' is the ParseTime type, 'p' is the datetime format and 'q' points to the content to parse

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(ParseTimeP LocalTime "%F %T" Id) "2019-05-24 05:19:59"
Present 2019-05-24 05:19:59
PresentT 2019-05-24 05:19:59

>>> pl @(ParseTimeP LocalTime "%F %T" "2019-05-24 05:19:59") (Right "we ignore this using Symbol and not Id")
Present 2019-05-24 05:19:59
PresentT 2019-05-24 05:19:59

keeping 'q' as we might want to extract from a tuple

Instances

(ParseTime (PP t a), Typeable (PP t a), Show (PP t a), P p a, P q a, PP p a ~ String, PP q a ~ String) => P (ParseTimeP' t p q :: Type) a

Defined in Predicate

Associated Types

type PP (ParseTimeP' t p q) a :: Type

Methods

eval :: MonadEval m => Proxy (ParseTimeP' t p q) -> POpts -> a -> m (TT (PP (ParseTimeP' t p q) a))

type PP (ParseTimeP' t p q :: Type) a

Defined in Predicate

type PP (ParseTimeP' t p q :: Type) a = PP t a

type ParseTimeP (t :: Type) p q = ParseTimeP' (Hole t) p q

data ParseTimes' t p q

A convenience method to match against many different datetime formats to find a match

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(ParseTimes LocalTime '["%Y-%m-%d %H:%M:%S", "%m/%d/%y %H:%M:%S", "%B %d %Y %H:%M:%S", "%Y-%m-%dT%H:%M:%S"] "03/11/19 01:22:33") ()
Present 2019-03-11 01:22:33
PresentT 2019-03-11 01:22:33

>>> pl @(ParseTimes LocalTime (Fst Id) (Snd Id)) (["%Y-%m-%d %H:%M:%S", "%m/%d/%y %H:%M:%S", "%B %d %Y %H:%M:%S", "%Y-%m-%dT%H:%M:%S"], "03/11/19 01:22:33")
Present 2019-03-11 01:22:33
PresentT 2019-03-11 01:22:33

Instances

(ParseTime (PP t a), Typeable (PP t a), Show (PP t a), P p a, P q a, PP p a ~ [String], PP q a ~ String) => P (ParseTimes' t p q :: Type) a

Defined in Predicate

Associated Types

type PP (ParseTimes' t p q) a :: Type

Methods

eval :: MonadEval m => Proxy (ParseTimes' t p q) -> POpts -> a -> m (TT (PP (ParseTimes' t p q) a))

type PP (ParseTimes' t p q :: Type) a

Defined in Predicate

type PP (ParseTimes' t p q :: Type) a = PP t a

type ParseTimes (t :: Type) p q = ParseTimes' (Hole t) p q

data MkDay' p q r

create a Day from three int values passed in as year month and day

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @MkDay (2019,12,30)
Present Just (2019-12-30,1,1)
PresentT (Just (2019-12-30,1,1))

>>> pl @(MkDay' (Fst Id) (Snd Id) (Thd Id)) (2019,99,99999)
Present Nothing
PresentT Nothing

>>> pl @MkDay (1999,3,13)
Present Just (1999-03-13,10,6)
PresentT (Just (1999-03-13,10,6))

Instances

(P p x, P q x, P r x, PP p x ~ Int, PP q x ~ Int, PP r x ~ Int) => P (MkDay' p q r :: Type) x

Defined in Predicate

Associated Types

type PP (MkDay' p q r) x :: Type

Methods

eval :: MonadEval m => Proxy (MkDay' p q r) -> POpts -> x -> m (TT (PP (MkDay' p q r) x))

type PP (MkDay' p q r :: Type) x

Defined in Predicate

type PP (MkDay' p q r :: Type) x = Maybe (Day, Int, Int)

type MkDay = MkDay' (Fst Id) (Snd Id) (Thd Id)

data UnMkDay p

uncreate a Day returning year month and day

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(UnMkDay Id) (read "2019-12-30")
Present (2019,12,30)
PresentT (2019,12,30)

Instances

(PP p x ~ Day, P p x) => P (UnMkDay p :: Type) x

Defined in Predicate

Associated Types

type PP (UnMkDay p) x :: Type

Methods

eval :: MonadEval m => Proxy (UnMkDay p) -> POpts -> x -> m (TT (PP (UnMkDay p) x))

type PP (UnMkDay p :: Type) x

Defined in Predicate

type PP (UnMkDay p :: Type) x = (Int, Int, Int)

data ReadP'' t p

uses the Read of the given type 't' and 'p' which points to the content to read

>>> :set -XTypeApplications
>>> :set -XTypeOperators
>>> :set -XDataKinds
>>> pl @(ReadP Rational) "4 % 5"
Present 4 % 5
PresentT (4 % 5)

>>> pl @(ReadP' Day Id >> Between (ReadP' Day "2017-04-11") (ReadP' Day "2018-12-30")) "2018-10-12"
True
TrueT

>>> pl @(ReadP' Day Id >> Between (ReadP' Day "2017-04-11") (ReadP' Day "2018-12-30")) "2016-10-12"
False
FalseT

Instances

(P p x, PP p x ~ String, Typeable (PP t x), Show (PP t x), Read (PP t x)) => P (ReadP'' t p :: Type) x

Defined in Predicate

Associated Types

type PP (ReadP'' t p) x :: Type

Methods

eval :: MonadEval m => Proxy (ReadP'' t p) -> POpts -> x -> m (TT (PP (ReadP'' t p) x))

type PP (ReadP'' t p :: Type) x

Defined in Predicate

type PP (ReadP'' t p :: Type) x = PP t x

type ReadP (t :: Type) = ReadP'' (Hole t) Id

type ReadP' (t :: Type) p = ReadP'' (Hole t) p

data Min

similar to minimum

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @Min [10,4,5,12,3,4]
Present 3
PresentT 3

>>> pl @Min []
Error empty list
FailT "empty list"

Instances

(Ord a, Show a) => P Min [a]

Defined in Predicate

Associated Types

type PP Min [a] :: Type

Methods

eval :: MonadEval m => Proxy Min -> POpts -> [a] -> m (TT (PP Min [a]))

type PP Min [a]

Defined in Predicate

type PP Min [a] = a

data Max

similar to maximum

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @Max [10,4,5,12,3,4]
Present 12
PresentT 12

>>> pl @Max []
Error empty list
FailT "empty list"

Instances

(Ord a, Show a) => P Max [a]

Defined in Predicate

Associated Types

type PP Max [a] :: Type

Methods

eval :: MonadEval m => Proxy Max -> POpts -> [a] -> m (TT (PP Max [a]))

type PP Max [a]

Defined in Predicate

type PP Max [a] = a

type Max' t = FoldMap (Max t) Id

data SortBy p q

sort a list

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(SortOn (Fst Id) Id) [(10,"abc"), (3,"def"), (4,"gg"), (10,"xyz"), (1,"z")]
Present [(1,"z"),(3,"def"),(4,"gg"),(10,"abc"),(10,"xyz")]
PresentT [(1,"z"),(3,"def"),(4,"gg"),(10,"abc"),(10,"xyz")]

Instances

(P p (a, a), P q x, Show a, PP q x ~ [a], PP p (a, a) ~ Ordering) => P (SortBy p q :: Type) x

Defined in Predicate

Associated Types

type PP (SortBy p q) x :: Type

Methods

eval :: MonadEval m => Proxy (SortBy p q) -> POpts -> x -> m (TT (PP (SortBy p q) x))

type PP (SortBy p q :: Type) x

Defined in Predicate

type PP (SortBy p q :: Type) x = PP q x

type SortOn p q = SortBy (OrdA p) q

type SortOnDesc p q = SortBy (Swap >> OrdA p) q

type SortByHelper p = Partition (p >> (Id == GT)) Id

data Len

similar to length

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @Len [10,4,5,12,3,4]
Present 6
PresentT 6

>>> pl @Len []
Present 0
PresentT 0

Instances

(Show a, as ~ [a]) => P Len as

Defined in Predicate

Associated Types

type PP Len as :: Type

Methods

eval :: MonadEval m => Proxy Len -> POpts -> as -> m (TT (PP Len as))

type PP Len as

Defined in Predicate

type PP Len as = Int

data Length p

similar to length for Foldable instances

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(Length Id) (Left "aa")
Present 0
PresentT 0

>>> pl @(Length Id) (Right "aa")
Present 1
PresentT 1

>>> pl @(Length (Right' Id)) (Right "abcd")
Present 4
PresentT 4

Instances

(PP p x ~ t a, P p x, Show (t a), Foldable t) => P (Length p :: Type) x

Defined in Predicate

Associated Types

type PP (Length p) x :: Type

Methods

eval :: MonadEval m => Proxy (Length p) -> POpts -> x -> m (TT (PP (Length p) x))

type PP (Length p :: Type) x

Defined in Predicate

type PP (Length p :: Type) x = Int

data L1 p

similar to fst

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(Fst Id) (10,"Abc")
Present 10
PresentT 10

>>> pl @(Fst Id) (10,"Abc",'x')
Present 10
PresentT 10

>>> pl @(Fst Id) (10,"Abc",'x',False)
Present 10
PresentT 10

Instances

(Show (ExtractL1T (PP p x)), ExtractL1C (PP p x), P p x, Show (PP p x)) => P (L1 p :: Type) x

Defined in Predicate

Associated Types

type PP (L1 p) x :: Type

Methods

eval :: MonadEval m => Proxy (L1 p) -> POpts -> x -> m (TT (PP (L1 p) x))

type PP (L1 p :: Type) x

Defined in Predicate

type PP (L1 p :: Type) x = ExtractL1T (PP p x)

type Fst p = L1 p

class ExtractL1C tp where

Associated Types

type ExtractL1T tp

Methods

extractL1C :: tp -> ExtractL1T tp

Instances

ExtractL1C (a, b)

Defined in Predicate

Associated Types

type ExtractL1T (a, b) :: Type

Methods

extractL1C :: (a, b) -> ExtractL1T (a, b)

ExtractL1C (a, b, c)

Defined in Predicate

Associated Types

type ExtractL1T (a, b, c) :: Type

Methods

extractL1C :: (a, b, c) -> ExtractL1T (a, b, c)

ExtractL1C (a, b, c, d)

Defined in Predicate

Associated Types

type ExtractL1T (a, b, c, d) :: Type

Methods

extractL1C :: (a, b, c, d) -> ExtractL1T (a, b, c, d)

ExtractL1C (a, b, c, d, e)

Defined in Predicate

Associated Types

type ExtractL1T (a, b, c, d, e) :: Type

Methods

extractL1C :: (a, b, c, d, e) -> ExtractL1T (a, b, c, d, e)

ExtractL1C (a, b, c, d, e, f)

Defined in Predicate

Associated Types

type ExtractL1T (a, b, c, d, e, f) :: Type

Methods

extractL1C :: (a, b, c, d, e, f) -> ExtractL1T (a, b, c, d, e, f)

data L2 p

similar to snd

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(Snd Id) (10,"Abc")
Present "Abc"
PresentT "Abc"

>>> pl @(Snd Id) (10,"Abc",True)
Present "Abc"
PresentT "Abc"

Instances

(Show (ExtractL2T (PP p x)), ExtractL2C (PP p x), P p x, Show (PP p x)) => P (L2 p :: Type) x

Defined in Predicate

Associated Types

type PP (L2 p) x :: Type

Methods

eval :: MonadEval m => Proxy (L2 p) -> POpts -> x -> m (TT (PP (L2 p) x))

type PP (L2 p :: Type) x

Defined in Predicate

type PP (L2 p :: Type) x = ExtractL2T (PP p x)

type Snd p = L2 p

class ExtractL2C tp where

Associated Types

type ExtractL2T tp

Methods

extractL2C :: tp -> ExtractL2T tp

Instances

ExtractL2C (a, b)

Defined in Predicate

Associated Types

type ExtractL2T (a, b) :: Type

Methods

extractL2C :: (a, b) -> ExtractL2T (a, b)

ExtractL2C (a, b, c)

Defined in Predicate

Associated Types

type ExtractL2T (a, b, c) :: Type

Methods

extractL2C :: (a, b, c) -> ExtractL2T (a, b, c)

ExtractL2C (a, b, c, d)

Defined in Predicate

Associated Types

type ExtractL2T (a, b, c, d) :: Type

Methods

extractL2C :: (a, b, c, d) -> ExtractL2T (a, b, c, d)

ExtractL2C (a, b, c, d, e)

Defined in Predicate

Associated Types

type ExtractL2T (a, b, c, d, e) :: Type

Methods

extractL2C :: (a, b, c, d, e) -> ExtractL2T (a, b, c, d, e)

ExtractL2C (a, b, c, d, e, f)

Defined in Predicate

Associated Types

type ExtractL2T (a, b, c, d, e, f) :: Type

Methods

extractL2C :: (a, b, c, d, e, f) -> ExtractL2T (a, b, c, d, e, f)

data L3 p

similar to 3rd element in a n-tuple

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(Thd Id) (10,"Abc",133)
Present 133
PresentT 133

>>> pl @(Thd Id) (10,"Abc",133,True)
Present 133
PresentT 133

Instances

(Show (ExtractL3T (PP p x)), ExtractL3C (PP p x), P p x, Show (PP p x)) => P (L3 p :: Type) x

Defined in Predicate

Associated Types

type PP (L3 p) x :: Type

Methods

eval :: MonadEval m => Proxy (L3 p) -> POpts -> x -> m (TT (PP (L3 p) x))

type PP (L3 p :: Type) x

Defined in Predicate

type PP (L3 p :: Type) x = ExtractL3T (PP p x)

type Thd p = L3 p

class ExtractL3C tp where

Associated Types

type ExtractL3T tp

Methods

extractL3C :: tp -> ExtractL3T tp

Instances

ExtractL3C (a, b)

Defined in Predicate

Associated Types

type ExtractL3T (a, b) :: Type

Methods

extractL3C :: (a, b) -> ExtractL3T (a, b)

ExtractL3C (a, b, c)

Defined in Predicate

Associated Types

type ExtractL3T (a, b, c) :: Type

Methods

extractL3C :: (a, b, c) -> ExtractL3T (a, b, c)

ExtractL3C (a, b, c, d)

Defined in Predicate

Associated Types

type ExtractL3T (a, b, c, d) :: Type

Methods

extractL3C :: (a, b, c, d) -> ExtractL3T (a, b, c, d)

ExtractL3C (a, b, c, d, e)

Defined in Predicate

Associated Types

type ExtractL3T (a, b, c, d, e) :: Type

Methods

extractL3C :: (a, b, c, d, e) -> ExtractL3T (a, b, c, d, e)

ExtractL3C (a, b, c, d, e, f)

Defined in Predicate

Associated Types

type ExtractL3T (a, b, c, d, e, f) :: Type

Methods

extractL3C :: (a, b, c, d, e, f) -> ExtractL3T (a, b, c, d, e, f)

data L4 p

similar to 4th element in a n-tuple

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(L4 Id) (10,"Abc",'x',True)
Present True
PresentT True

>>> pl @(L4 (Fst (Snd Id))) ('x',((10,"Abc",'x',999),"aa",1),9)
Present 999
PresentT 999

Instances

(Show (ExtractL4T (PP p x)), ExtractL4C (PP p x), P p x, Show (PP p x)) => P (L4 p :: Type) x

Defined in Predicate

Associated Types

type PP (L4 p) x :: Type

Methods

eval :: MonadEval m => Proxy (L4 p) -> POpts -> x -> m (TT (PP (L4 p) x))

type PP (L4 p :: Type) x

Defined in Predicate

type PP (L4 p :: Type) x = ExtractL4T (PP p x)

class ExtractL4C tp where

Associated Types

type ExtractL4T tp

Methods

extractL4C :: tp -> ExtractL4T tp

Instances

ExtractL4C (a, b)

Defined in Predicate

Associated Types

type ExtractL4T (a, b) :: Type

Methods

extractL4C :: (a, b) -> ExtractL4T (a, b)

ExtractL4C (a, b, c)

Defined in Predicate

Associated Types

type ExtractL4T (a, b, c) :: Type

Methods

extractL4C :: (a, b, c) -> ExtractL4T (a, b, c)

ExtractL4C (a, b, c, d)

Defined in Predicate

Associated Types

type ExtractL4T (a, b, c, d) :: Type

Methods

extractL4C :: (a, b, c, d) -> ExtractL4T (a, b, c, d)

ExtractL4C (a, b, c, d, e)

Defined in Predicate

Associated Types

type ExtractL4T (a, b, c, d, e) :: Type

Methods

extractL4C :: (a, b, c, d, e) -> ExtractL4T (a, b, c, d, e)

ExtractL4C (a, b, c, d, e, f)

Defined in Predicate

Associated Types

type ExtractL4T (a, b, c, d, e, f) :: Type

Methods

extractL4C :: (a, b, c, d, e, f) -> ExtractL4T (a, b, c, d, e, f)

data L5 p

similar to 5th element in a n-tuple

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(L5 Id) (10,"Abc",'x',True,1)
Present 1
PresentT 1

Instances

(Show (ExtractL5T (PP p x)), ExtractL5C (PP p x), P p x, Show (PP p x)) => P (L5 p :: Type) x

Defined in Predicate

Associated Types

type PP (L5 p) x :: Type

Methods

eval :: MonadEval m => Proxy (L5 p) -> POpts -> x -> m (TT (PP (L5 p) x))

type PP (L5 p :: Type) x

Defined in Predicate

type PP (L5 p :: Type) x = ExtractL5T (PP p x)

class ExtractL5C tp where

Associated Types

type ExtractL5T tp

Methods

extractL5C :: tp -> ExtractL5T tp

Instances

ExtractL5C (a, b)

Defined in Predicate

Associated Types

type ExtractL5T (a, b) :: Type

Methods

extractL5C :: (a, b) -> ExtractL5T (a, b)

ExtractL5C (a, b, c)

Defined in Predicate

Associated Types

type ExtractL5T (a, b, c) :: Type

Methods

extractL5C :: (a, b, c) -> ExtractL5T (a, b, c)

ExtractL5C (a, b, c, d)

Defined in Predicate

Associated Types

type ExtractL5T (a, b, c, d) :: Type

Methods

extractL5C :: (a, b, c, d) -> ExtractL5T (a, b, c, d)

ExtractL5C (a, b, c, d, e)

Defined in Predicate

Associated Types

type ExtractL5T (a, b, c, d, e) :: Type

Methods

extractL5C :: (a, b, c, d, e) -> ExtractL5T (a, b, c, d, e)

ExtractL5C (a, b, c, d, e, f)

Defined in Predicate

Associated Types

type ExtractL5T (a, b, c, d, e, f) :: Type

Methods

extractL5C :: (a, b, c, d, e, f) -> ExtractL5T (a, b, c, d, e, f)

data L6 p

similar to 6th element in a n-tuple

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(L6 Id) (10,"Abc",'x',True,1,99)
Present 99
PresentT 99

Instances

(Show (ExtractL6T (PP p x)), ExtractL6C (PP p x), P p x, Show (PP p x)) => P (L6 p :: Type) x

Defined in Predicate

Associated Types

type PP (L6 p) x :: Type

Methods

eval :: MonadEval m => Proxy (L6 p) -> POpts -> x -> m (TT (PP (L6 p) x))

type PP (L6 p :: Type) x

Defined in Predicate

type PP (L6 p :: Type) x = ExtractL6T (PP p x)

class ExtractL6C tp where

Associated Types

type ExtractL6T tp

Methods

extractL6C :: tp -> ExtractL6T tp

Instances

ExtractL6C (a, b)

Defined in Predicate

Associated Types

type ExtractL6T (a, b) :: Type

Methods

extractL6C :: (a, b) -> ExtractL6T (a, b)

ExtractL6C (a, b, c)

Defined in Predicate

Associated Types

type ExtractL6T (a, b, c) :: Type

Methods

extractL6C :: (a, b, c) -> ExtractL6T (a, b, c)

ExtractL6C (a, b, c, d)

Defined in Predicate

Associated Types

type ExtractL6T (a, b, c, d) :: Type

Methods

extractL6C :: (a, b, c, d) -> ExtractL6T (a, b, c, d)

ExtractL6C (a, b, c, d, e)

Defined in Predicate

Associated Types

type ExtractL6T (a, b, c, d, e) :: Type

Methods

extractL6C :: (a, b, c, d, e) -> ExtractL6T (a, b, c, d, e)

ExtractL6C (a, b, c, d, e, f)

Defined in Predicate

Associated Types

type ExtractL6T (a, b, c, d, e, f) :: Type

Methods

extractL6C :: (a, b, c, d, e, f) -> ExtractL6T (a, b, c, d, e, f)

data I

identity function

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @I 23
Present 23
PresentT 23

Instances

P I a

Defined in Predicate

Associated Types

type PP I a :: Type

Methods

eval :: MonadEval m => Proxy I -> POpts -> a -> m (TT (PP I a))

type PP I a

Defined in Predicate

type PP I a = a

data Id

identity function that displays the input

even more constraints than I so we might need to add explicit type signatures

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @Id 23
Present 23
PresentT 23

Instances

Show a => P Id a

Defined in Predicate

Associated Types

type PP Id a :: Type

Methods

eval :: MonadEval m => Proxy Id -> POpts -> a -> m (TT (PP Id a))

type PP Id a

Defined in Predicate

type PP Id a = a

data IdT

identity function that also displays the type information for debugging

even more constraints than Id so we might need to explicitly add types (Typeable)

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @IdT 23
Present 23
PresentT 23

Instances

(Typeable a, Show a) => P IdT a

Defined in Predicate

Associated Types

type PP IdT a :: Type

Methods

eval :: MonadEval m => Proxy IdT -> POpts -> a -> m (TT (PP IdT a))

type PP IdT a

Defined in Predicate

type PP IdT a = a

data FromStringP' t s

fromString function

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> :set -XOverloadedStrings
>>> pl @(FromStringP (Identity _) Id) "abc"
Present Identity "abc"
PresentT (Identity "abc")

>>> pl @(FromStringP (Seq.Seq _) Id) "abc"
Present fromList "abc"
PresentT (fromList "abc")

Instances

(P s a, PP s a ~ String, Show (PP t a), IsString (PP t a)) => P (FromStringP' t s :: Type) a

Defined in Predicate

Associated Types

type PP (FromStringP' t s) a :: Type

Methods

eval :: MonadEval m => Proxy (FromStringP' t s) -> POpts -> a -> m (TT (PP (FromStringP' t s) a))

type PP (FromStringP' t s :: Type) a

Defined in Predicate

type PP (FromStringP' t s :: Type) a = PP t a

type FromStringP (t :: Type) p = FromStringP' (Hole t) p

data FromInteger' t n

fromInteger function

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(FromInteger (SG.Sum _) Id) 23
Present Sum {getSum = 23}
PresentT (Sum {getSum = 23})

Instances

(Num (PP t a), Integral (PP n a), P n a, Show (PP t a)) => P (FromInteger' t n :: Type) a

Defined in Predicate

Associated Types

type PP (FromInteger' t n) a :: Type

Methods

eval :: MonadEval m => Proxy (FromInteger' t n) -> POpts -> a -> m (TT (PP (FromInteger' t n) a))

type PP (FromInteger' t n :: Type) a

Defined in Predicate

type PP (FromInteger' t n :: Type) a = PP t a

type FromInteger (t :: Type) p = FromInteger' (Hole t) p

type FromIntegerP n = FromInteger' Unproxy n

data FromIntegral' t n

fromIntegral function

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(FromIntegral (SG.Sum _) Id) 23
Present Sum {getSum = 23}
PresentT (Sum {getSum = 23})

Instances

(Num (PP t a), Integral (PP n a), P n a, Show (PP t a), Show (PP n a)) => P (FromIntegral' t n :: Type) a

Defined in Predicate

Associated Types

type PP (FromIntegral' t n) a :: Type

Methods

eval :: MonadEval m => Proxy (FromIntegral' t n) -> POpts -> a -> m (TT (PP (FromIntegral' t n) a))

type PP (FromIntegral' t n :: Type) a

Defined in Predicate

type PP (FromIntegral' t n :: Type) a = PP t a

type FromIntegral (t :: Type) p = FromIntegral' (Hole t) p

data ToRational p

toRational function

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(ToRational Id) 23.5
Present 47 % 2
PresentT (47 % 2)

Instances

(a ~ PP p x, Show a, Real a, P p x) => P (ToRational p :: Type) x

Defined in Predicate

Associated Types

type PP (ToRational p) x :: Type

Methods

eval :: MonadEval m => Proxy (ToRational p) -> POpts -> x -> m (TT (PP (ToRational p) x))

type PP (ToRational p :: Type) x

Defined in Predicate

type PP (ToRational p :: Type) x = Rational

data FromRational' t r

fromRational function

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(FromRational Rational Id) 23.5
Present 47 % 2
PresentT (47 % 2)

Instances

(P r a, PP r a ~ Rational, Show (PP t a), Fractional (PP t a)) => P (FromRational' t r :: Type) a

Defined in Predicate

Associated Types

type PP (FromRational' t r) a :: Type

Methods

eval :: MonadEval m => Proxy (FromRational' t r) -> POpts -> a -> m (TT (PP (FromRational' t r) a))

type PP (FromRational' t r :: Type) a

Defined in Predicate

type PP (FromRational' t r :: Type) a = PP t a

type FromRational (t :: Type) p = FromRational' (Hole t) p

data Truncate' t p

truncate function

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(Truncate Int Id) (23 % 5)
Present 4
PresentT 4

Instances

(Show (PP p x), P p x, Show (PP t x), RealFrac (PP p x), Integral (PP t x)) => P (Truncate' t p :: Type) x

Defined in Predicate

Associated Types

type PP (Truncate' t p) x :: Type

Methods

eval :: MonadEval m => Proxy (Truncate' t p) -> POpts -> x -> m (TT (PP (Truncate' t p) x))

type PP (Truncate' t p :: Type) x

Defined in Predicate

type PP (Truncate' t p :: Type) x = PP t x

type Truncate (t :: Type) p = Truncate' (Hole t) p

data Ceiling' t p

ceiling function

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(Ceiling Int Id) (23 % 5)
Present 5
PresentT 5

Instances

(Show (PP p x), P p x, Show (PP t x), RealFrac (PP p x), Integral (PP t x)) => P (Ceiling' t p :: Type) x

Defined in Predicate

Associated Types

type PP (Ceiling' t p) x :: Type

Methods

eval :: MonadEval m => Proxy (Ceiling' t p) -> POpts -> x -> m (TT (PP (Ceiling' t p) x))

type PP (Ceiling' t p :: Type) x

Defined in Predicate

type PP (Ceiling' t p :: Type) x = PP t x

type Ceiling (t :: Type) p = Ceiling' (Hole t) p

data Floor' t p

floor function

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(Floor Int Id) (23 % 5)
Present 4
PresentT 4

Instances

(Show (PP p x), P p x, Show (PP t x), RealFrac (PP p x), Integral (PP t x)) => P (Floor' t p :: Type) x

Defined in Predicate

Associated Types

type PP (Floor' t p) x :: Type

Methods

eval :: MonadEval m => Proxy (Floor' t p) -> POpts -> x -> m (TT (PP (Floor' t p) x))

type PP (Floor' t p :: Type) x

Defined in Predicate

type PP (Floor' t p :: Type) x = PP t x

type Floor (t :: Type) p = Floor' (Hole t) p

data MkProxy

converts a value to a Proxy: the same as '\'Proxy'

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @MkProxy 'x'
Present Proxy
PresentT Proxy

Instances

Show a => P MkProxy a

Defined in Predicate

Associated Types

type PP MkProxy a :: Type

Methods

eval :: MonadEval m => Proxy MkProxy -> POpts -> a -> m (TT (PP MkProxy a))

type PP MkProxy a

Defined in Predicate

type PP MkProxy a = Proxy a

type family DoExpandT (ps :: [k]) :: Type where ...

Equations

DoExpandT '[] = TypeError (Text "'[] invalid: requires at least one predicate in the list")

DoExpandT '[p] = Id >> p

DoExpandT (p ': (p1 ': ps)) = p >> DoExpandT (p1 ': ps)

data Do (ps :: [k])

processes a type level list predicates running each in sequence: see >>

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(Do [Pred Id, ShowP Id, Id &&& Len]) 9876543
Present ("9876542",7)
PresentT ("9876542",7)

Instances

P (DoExpandT ps) a => P (Do ps :: Type) a

Defined in Predicate

Associated Types

type PP (Do ps) a :: Type

Methods

eval :: MonadEval m => Proxy (Do ps) -> POpts -> a -> m (TT (PP (Do ps) a))

type PP (Do ps :: Type) a

Defined in Predicate

type PP (Do ps :: Type) a = PP (DoExpandT ps) a

data MaybeB b p

Convenient method to convert a value 'p' to a Maybe based on a predicate '\b\' if '\b\' then Just 'p' else Nothing

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(MaybeB (Id > 4) Id) 24
Present Just 24
PresentT (Just 24)

>>> pl @(MaybeB (Id > 4) Id) (-5)
Present Nothing
PresentT Nothing

Instances

(Show (PP p a), P b a, P p a, PP b a ~ Bool) => P (MaybeB b p :: Type) a

Defined in Predicate

Associated Types

type PP (MaybeB b p) a :: Type

Methods

eval :: MonadEval m => Proxy (MaybeB b p) -> POpts -> a -> m (TT (PP (MaybeB b p) a))

type PP (MaybeB b p :: Type) a

Defined in Predicate

type PP (MaybeB b p :: Type) a = Maybe (PP p a)

data EitherB b p q

Convenient method to convert a 'p' or '\q' to a Either based on a predicate '\b\' if 'b' then Right 'p' else Left '\q\'

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(EitherB (Fst Id > 4) (Snd Id >> Fst Id) (Snd Id >> (Snd Id))) (24,(-1,999))
Present Right 999
PresentT (Right 999)

>>> pl @(EitherB (Fst Id > 4) (Snd Id >> Fst Id) (Snd Id >> (Snd Id))) (1,(-1,999))
Present Left (-1)
PresentT (Left (-1))

Instances

(Show (PP p a), P p a, Show (PP q a), P q a, P b a, PP b a ~ Bool) => P (EitherB b p q :: Type) a

Defined in Predicate

Associated Types

type PP (EitherB b p q) a :: Type

Methods

eval :: MonadEval m => Proxy (EitherB b p q) -> POpts -> a -> m (TT (PP (EitherB b p q) a))

type PP (EitherB b p q :: Type) a

Defined in Predicate

type PP (EitherB b p q :: Type) a = Either (PP p a) (PP q a)

data TupleI (ps :: [k])

create inductive tuples from a type level list of predicates

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(TupleI '[Id,ShowP Id,Pred Id,W "str", W 999]) 666
Present (666,("666",(665,("str",(999,())))))
PresentT (666,("666",(665,("str",(999,())))))

Instances

P (TupleI ([] :: [k]) :: Type) a

Defined in Predicate

Associated Types

type PP (TupleI []) a :: Type

Methods

eval :: MonadEval m => Proxy (TupleI []) -> POpts -> a -> m (TT (PP (TupleI []) a))

(P p a, P (TupleI ps) a, Show a) => P (TupleI (p ': ps) :: Type) a

Defined in Predicate

Associated Types

type PP (TupleI (p ': ps)) a :: Type

Methods

eval :: MonadEval m => Proxy (TupleI (p ': ps)) -> POpts -> a -> m (TT (PP (TupleI (p ': ps)) a))

type PP (TupleI (p ': ps) :: Type) a

Defined in Predicate

type PP (TupleI (p ': ps) :: Type) a = (PP p a, PP (TupleI ps) a)

type PP (TupleI ([] :: [k]) :: Type) a

Defined in Predicate

type PP (TupleI ([] :: [k]) :: Type) a = ()

data Msg prt p

add a message to give more context to the evaluation tree

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pe @(Msg' "somemessage" Id) 999
P [somemessage] Id 999
PresentT 999

Instances

(P prt a, PP prt a ~ String, P p a) => P (Msg prt p :: Type) a

Defined in Predicate

Associated Types

type PP (Msg prt p) a :: Type

Methods

eval :: MonadEval m => Proxy (Msg prt p) -> POpts -> a -> m (TT (PP (Msg prt p) a))

type PP (Msg prt p :: Type) a

Defined in Predicate

type PP (Msg prt p :: Type) a = PP p a

type Msg' prt p = Msg (Printf "[%s] " prt) p

data Pad (left :: Bool) n p q

pad 'q' with '\n' values from '\p'\

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(PadL 5 999 Id) [12,13]
Present [999,999,999,12,13]
PresentT [999,999,999,12,13]

>>> pl @(PadR 5 (Fst Id) '[12,13]) (999,'x')
Present [12,13,999,999,999]
PresentT [12,13,999,999,999]

>>> pl @(PadR 2 (Fst Id) '[12,13,14]) (999,'x')
Present [12,13,14]
PresentT [12,13,14]

Instances

(P n a, GetBool left, Integral (PP n a), [PP p a] ~ PP q a, P p a, P q a, Show (PP p a)) => P (Pad left n p q :: Type) a

Defined in Predicate

Associated Types

type PP (Pad left n p q) a :: Type

Methods

eval :: MonadEval m => Proxy (Pad left n p q) -> POpts -> a -> m (TT (PP (Pad left n p q) a))

type PP (Pad left n p q :: Type) a

Defined in Predicate

type PP (Pad left n p q :: Type) a = PP q a

type PadL n p q = Pad True n p q

type PadR n p q = Pad False n p q

data SplitAts ns p

split a list 'p' into parts using the lengths in the type level list 'ns'

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(SplitAts '[2,3,1,1] Id) "hello world"
Present ["he","llo"," ","w","orld"]
PresentT ["he","llo"," ","w","orld"]

>>> pl @(SplitAts '[2] Id) "hello world"
Present ["he","llo world"]
PresentT ["he","llo world"]

>>> pl @(SplitAts '[10,1,1,5] Id) "hello world"
Present ["hello worl","d","",""]
PresentT ["hello worl","d","",""]

Instances

(P ns x, P p x, PP p x ~ [a], Show n, Show a, PP ns x ~ [n], Integral n) => P (SplitAts ns p :: Type) x

Defined in Predicate

Associated Types

type PP (SplitAts ns p) x :: Type

Methods

eval :: MonadEval m => Proxy (SplitAts ns p) -> POpts -> x -> m (TT (PP (SplitAts ns p) x))

type PP (SplitAts ns p :: Type) x

Defined in Predicate

type PP (SplitAts ns p :: Type) x = [PP p x]

data SplitAt n p

similar to splitAt

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(SplitAt 4 Id) "hello world"
Present ("hell","o world")
PresentT ("hell","o world")

>>> pl @(SplitAt 20 Id) "hello world"
Present ("hello world","")
PresentT ("hello world","")

>>> pl @(SplitAt 0 Id) "hello world"
Present ("","hello world")
PresentT ("","hello world")

>>> pl @(SplitAt (Snd Id) (Fst Id)) ("hello world",4)
Present ("hell","o world")
PresentT ("hell","o world")

Instances

(PP p a ~ [b], P n a, P p a, Show b, Integral (PP n a)) => P (SplitAt n p :: Type) a

Defined in Predicate

Associated Types

type PP (SplitAt n p) a :: Type

Methods

eval :: MonadEval m => Proxy (SplitAt n p) -> POpts -> a -> m (TT (PP (SplitAt n p) a))

type PP (SplitAt n p :: Type) a

Defined in Predicate

type PP (SplitAt n p :: Type) a = (PP p a, PP p a)

type Take n p = SplitAt n p >> Fst Id

type Drop n p = SplitAt n p >> Snd Id

type Tail = Uncons >> Just (Snd Id)

type Head = Uncons >> Just (Fst Id)

type Init = Unsnoc >> Just (Fst Id)

type Last = Unsnoc >> Just (Snd Id)

type (&&&) p q = W '(p, q) infixr 3

similar to &&&

data (p :: k) *** (q :: k1) infixr 3

similar to ***

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(Pred Id *** ShowP Id) (13, True)
Present (12,"True")
PresentT (12,"True")

Instances

(Show (PP p a), Show (PP q b), P p a, P q b, Show a, Show b) => P (p *** q :: Type) (a, b)

Defined in Predicate

Associated Types

type PP (p *** q) (a, b) :: Type

Methods

eval :: MonadEval m => Proxy (p *** q) -> POpts -> (a, b) -> m (TT (PP (p *** q) (a, b)))

type PP (p *** q :: Type) (a, b)

Defined in Predicate

type PP (p *** q :: Type) (a, b) = (PP p a, PP q b)

type Star p q = p *** q

type First p = Star p I

type Second q = Star I q

data (p :: k) ||| (q :: k1) infixr 2

similar |||

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(Pred Id ||| Id) (Left 13)
Present 12
PresentT 12

>>> pl @(ShowP Id ||| Id) (Right "hello")
Present "hello"
PresentT "hello"

Instances

(Show (PP p a), P p a, P q b, PP p a ~ PP q b, Show a, Show b) => P (p ||| q :: Type) (Either a b)

Defined in Predicate

Associated Types

type PP (p ||| q) (Either a b) :: Type

Methods

eval :: MonadEval m => Proxy (p ||| q) -> POpts -> Either a b -> m (TT (PP (p ||| q) (Either a b)))

type PP (p ||| q :: Type) (Either a b)

Defined in Predicate

type PP (p ||| q :: Type) (Either a b) = PP p a

type EitherIn p q = p ||| q

type IsLeft = True ||| False

type IsRight = False ||| True

data (p :: k) +++ (q :: k1) infixr 2

similar +++

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(Pred Id +++ Id) (Left 13)
Present Left 12
PresentT (Left 12)

>>> pl @(ShowP Id +++ Reverse) (Right "hello")
Present Right "olleh"
PresentT (Right "olleh")

Instances

(Show (PP p a), Show (PP q b), P p a, P q b, Show a, Show b) => P (p +++ q :: Type) (Either a b)

Defined in Predicate

Associated Types

type PP (p +++ q) (Either a b) :: Type

Methods

eval :: MonadEval m => Proxy (p +++ q) -> POpts -> Either a b -> m (TT (PP (p +++ q) (Either a b)))

type PP (p +++ q :: Type) (Either a b)

Defined in Predicate

type PP (p +++ q :: Type) (Either a b) = Either (PP p a) (PP q b)

type Dup = '(Id, Id)

data BinOp

Constructors

BMult

BSub

BAdd

Instances

Eq BinOp

Defined in Predicate

Methods

(==) :: BinOp -> BinOp -> Bool

(/=) :: BinOp -> BinOp -> Bool

Show BinOp

Defined in Predicate

Methods

showsPrec :: Int -> BinOp -> ShowS

show :: BinOp -> String

showList :: [BinOp] -> ShowS

type Mult p q = Bin BMult p q

type Add p q = Bin BAdd p q

type Sub p q = Bin BSub p q

type (+) p q = Add p q infixl 6

type (-) p q = Sub p q infixl 6

type * p q = Mult p q infixl 7

type (>) p q = Cmp Cgt p q infix 4

type (>=) p q = Cmp Cge p q infix 4

type (==) p q = Cmp Ceq p q infix 4

type (/=) p q = Cmp Cne p q infix 4

type (<=) p q = Cmp Cle p q infix 4

type (<) p q = Cmp Clt p q infix 4

type (>?) p q = CmpI Cgt p q infix 4

type (>=?) p q = CmpI Cge p q infix 4

type (==?) p q = CmpI Ceq p q infix 4

type (/=?) p q = CmpI Cne p q infix 4

type (<=?) p q = CmpI Cle p q infix 4

type (<?) p q = CmpI Clt p q infix 4

class GetBinOp (k :: BinOp) where

Methods

getBinOp :: (Num a, a ~ b) => (String, a -> b -> a)

Instances

GetBinOp BMult

Defined in Predicate

Methods

getBinOp :: (Num a, a ~ b) => (String, a -> b -> a)

GetBinOp BSub

Defined in Predicate

Methods

getBinOp :: (Num a, a ~ b) => (String, a -> b -> a)

GetBinOp BAdd

Defined in Predicate

Methods

getBinOp :: (Num a, a ~ b) => (String, a -> b -> a)

data Bin (op :: BinOp) p q

addition, multiplication and subtraction

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> :set -XNoStarIsType
>>> pl @(Fst Id * (Snd Id)) (13,5)
Present 65
PresentT 65

>>> pl @(Fst Id + 4 * (Snd Id >> Len) - 4) (3,"hello")
Present 19
PresentT 19

Instances

(GetBinOp op, PP p a ~ PP q a, P p a, P q a, Show (PP p a), Num (PP p a)) => P (Bin op p q :: Type) a

Defined in Predicate

Associated Types

type PP (Bin op p q) a :: Type

Methods

eval :: MonadEval m => Proxy (Bin op p q) -> POpts -> a -> m (TT (PP (Bin op p q) a))

type PP (Bin op p q :: Type) a

Defined in Predicate

type PP (Bin op p q :: Type) a = PP p a

data DivF p q

fractional division

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(Fst Id / (Snd Id)) (13,2)
Present 6.5
PresentT 6.5

>>> pl @(ToRational 13 / Id) 0
Error DivF zero denominator
FailT "DivF zero denominator"

Instances

(PP p a ~ PP q a, Eq (PP q a), P p a, P q a, Show (PP p a), Fractional (PP p a)) => P (DivF p q :: Type) a

Defined in Predicate

Associated Types

type PP (DivF p q) a :: Type

Methods

eval :: MonadEval m => Proxy (DivF p q) -> POpts -> a -> m (TT (PP (DivF p q) a))

type PP (DivF p q :: Type) a

Defined in Predicate

type PP (DivF p q :: Type) a = PP p a

type (/) p q = DivF p q infixl 7

data p % q infixl 8

creates a Ratio

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> :set -XNoStarIsType
>>> pl @(Fst Id % (Snd Id)) (13,2)
Present 13 % 2
PresentT (13 % 2)

>>> pl @(13 % Id) 0
Error MkRatio zero denominator
FailT "MkRatio zero denominator"

>>> pl @(4 % 3 + 5 % 7) "asfd"
Present 43 % 21
PresentT (43 % 21)

>>> pl @(4 %- 7 * 5 %- 3) "asfd"
Present 20 % 21
PresentT (20 % 21)

>>> pl @(Negate (14 % 3)) ()
Present (-14) % 3
PresentT ((-14) % 3)

>>> pl @(14 % 3) ()
Present 14 % 3
PresentT (14 % 3)

>>> pl @(Negate (14 % 3) === FromIntegral _ (Negate 5)) ()
Present GT
PresentT GT

>>> pl @(14 -% 3 === 5 %- 1) "aa"
Present GT
PresentT GT

>>> pl @(Negate (14 % 3) === Negate 5 % 2) ()
Present LT
PresentT LT

>>> pl @(14 -% 3 * 5 -% 1) ()
Present 70 % 3
PresentT (70 % 3)

>>> pl @(14 % 3 === 5 % 1) ()
Present LT
PresentT LT

>>> pl @(15 % 3 / 4 % 2) ()
Present 5 % 2
PresentT (5 % 2)

Instances

(Integral (PP p x), Integral (PP q x), Eq (PP q x), P p x, P q x, Show (PP p x), Show (PP q x)) => P (p % q :: Type) x

Defined in Predicate

Associated Types

type PP (p % q) x :: Type

Methods

eval :: MonadEval m => Proxy (p % q) -> POpts -> x -> m (TT (PP (p % q) x))

type PP (p % q :: Type) x

Defined in Predicate

type PP (p % q :: Type) x = Rational

type (%-) p q = Negate (p % q) infixl 8

type (-%) p q = Negate (p % q) infixl 8

data Negate p

similar to negate

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> :set -XTypeOperators
>>> pl @(Negate Id) 14
Present -14
PresentT (-14)

>>> pl @(Negate (Fst Id * (Snd Id))) (14,3)
Present -42
PresentT (-42)

>>> pl @(Negate (15 %- 4)) "abc"
Present 15 % 4
PresentT (15 % 4)

>>> pl @(Negate (15 % 3)) ()
Present (-5) % 1
PresentT ((-5) % 1)

>>> pl @(Negate (Fst Id % (Snd Id))) (14,3)
Present (-14) % 3
PresentT ((-14) % 3)

Instances

(Show (PP p x), Num (PP p x), P p x) => P (Negate p :: Type) x

Defined in Predicate

Associated Types

type PP (Negate p) x :: Type

Methods

eval :: MonadEval m => Proxy (Negate p) -> POpts -> x -> m (TT (PP (Negate p) x))

type PP (Negate p :: Type) x

Defined in Predicate

type PP (Negate p :: Type) x = PP p x

data Abs p

similar to abs

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(Abs Id) (-14)
Present 14
PresentT 14

>>> pl @(Abs (Snd Id)) ("xx",14)
Present 14
PresentT 14

>>> pl @(Abs Id) 0
Present 0
PresentT 0

>>> pl @(Abs (Negate 44)) "aaa"
Present 44
PresentT 44

Instances

(Show (PP p x), Num (PP p x), P p x) => P (Abs p :: Type) x

Defined in Predicate

Associated Types

type PP (Abs p) x :: Type

Methods

eval :: MonadEval m => Proxy (Abs p) -> POpts -> x -> m (TT (PP (Abs p) x))

type PP (Abs p :: Type) x

Defined in Predicate

type PP (Abs p :: Type) x = PP p x

data Signum p

similar to signum

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(Signum Id) (-14)
Present -1
PresentT (-1)

>>> pl @(Signum Id) 14
Present 1
PresentT 1

>>> pl @(Signum Id) 0
Present 0
PresentT 0

Instances

(Show (PP p x), Num (PP p x), P p x) => P (Signum p :: Type) x

Defined in Predicate

Associated Types

type PP (Signum p) x :: Type

Methods

eval :: MonadEval m => Proxy (Signum p) -> POpts -> x -> m (TT (PP (Signum p) x))

type PP (Signum p :: Type) x

Defined in Predicate

type PP (Signum p :: Type) x = PP p x

data Unwrap p

unwraps a value (see Wrapped)

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(Unwrap Id) (SG.Sum (-13))
Present -13
PresentT (-13)

Instances

(PP p x ~ s, P p x, Show s, Show (Unwrapped s), Wrapped s) => P (Unwrap p :: Type) x

Defined in Predicate

Associated Types

type PP (Unwrap p) x :: Type

Methods

eval :: MonadEval m => Proxy (Unwrap p) -> POpts -> x -> m (TT (PP (Unwrap p) x))

type PP (Unwrap p :: Type) x

Defined in Predicate

type PP (Unwrap p :: Type) x = Unwrapped (PP p x)

data Wrap' t p

wraps a value (see Wrapped and Wrapped)

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> :m + Data.List.NonEmpty
>>> pl @(Wrap (SG.Sum _) Id) (-13)
Present Sum {getSum = -13}
PresentT (Sum {getSum = -13})

>>> pl @(Wrap SG.Any (Ge 4)) 13
Present Any {getAny = True}
PresentT (Any {getAny = True})

>>> pl @(Wrap (NonEmpty _) (Uncons >> 'Just Id)) "abcd"
Present 'a' :| "bcd"
PresentT ('a' :| "bcd")

Instances

(Show (PP p x), P p x, Unwrapped (PP s x) ~ PP p x, Wrapped (PP s x), Show (PP s x)) => P (Wrap' s p :: Type) x

Defined in Predicate

Associated Types

type PP (Wrap' s p) x :: Type

Methods

eval :: MonadEval m => Proxy (Wrap' s p) -> POpts -> x -> m (TT (PP (Wrap' s p) x))

type PP (Wrap' s p :: Type) x

Defined in Predicate

type PP (Wrap' s p :: Type) x = PP s x

type Wrap (t :: Type) p = Wrap' (Hole t) p

data Coerce (t :: k)

similar to coerce

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(Coerce (SG.Sum Integer)) (Identity (-13))
Present Sum {getSum = -13}
PresentT (Sum {getSum = -13})

Instances

(Show a, Show t, Coercible t a) => P (Coerce t :: Type) a

Defined in Predicate

Associated Types

type PP (Coerce t) a :: Type

Methods

eval :: MonadEval m => Proxy (Coerce t) -> POpts -> a -> m (TT (PP (Coerce t) a))

type PP (Coerce t :: Type) a

Defined in Predicate

type PP (Coerce t :: Type) a = t

data Coerce2 (t :: k)

see Coerce: coerce over a functor

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(Coerce2 (SG.Sum Integer)) [Identity (-13), Identity 4, Identity 99]
Present [Sum {getSum = -13},Sum {getSum = 4},Sum {getSum = 99}]
PresentT [Sum {getSum = -13},Sum {getSum = 4},Sum {getSum = 99}]

>>> pl @(Coerce2 (SG.Sum Integer)) (Just (Identity (-13)))
Present Just (Sum {getSum = -13})
PresentT (Just (Sum {getSum = -13}))

>>> pl @(Coerce2 (SG.Sum Int)) (Nothing @(Identity Int))
Present Nothing
PresentT Nothing

Instances

(Show (f a), Show (f t), Coercible t a, Functor f) => P (Coerce2 t :: Type) (f a)

Defined in Predicate

Associated Types

type PP (Coerce2 t) (f a) :: Type

Methods

eval :: MonadEval m => Proxy (Coerce2 t) -> POpts -> f a -> m (TT (PP (Coerce2 t) (f a)))

type PP (Coerce2 t :: Type) (f a)

Defined in Predicate

type PP (Coerce2 t :: Type) (f a) = f t

data MEmptyT2' t

lift mempty over a Functor

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(MEmptyT2 (SG.Product Int)) [Identity (-13), Identity 4, Identity 99]
Present [Product {getProduct = 1},Product {getProduct = 1},Product {getProduct = 1}]
PresentT [Product {getProduct = 1},Product {getProduct = 1},Product {getProduct = 1}]

Instances

(Show (f a), Show (f (PP t (f a))), Functor f, Monoid (PP t (f a))) => P (MEmptyT2' t :: Type) (f a)

Defined in Predicate

Associated Types

type PP (MEmptyT2' t) (f a) :: Type

Methods

eval :: MonadEval m => Proxy (MEmptyT2' t) -> POpts -> f a -> m (TT (PP (MEmptyT2' t) (f a)))

type PP (MEmptyT2' t :: Type) (f a)

Defined in Predicate

type PP (MEmptyT2' t :: Type) (f a) = f (PP t (f a))

type MEmptyT2 t = MEmptyT2' (Hole t)

data Pure2 (t :: Type -> Type)

lift pure over a Functor

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(Pure2 (Either String)) [1,2,4]
Present [Right 1,Right 2,Right 4]
PresentT [Right 1,Right 2,Right 4]

Instances

(Show (f (t a)), Show (f a), Applicative t, Functor f) => P (Pure2 t :: Type) (f a)

Defined in Predicate

Associated Types

type PP (Pure2 t) (f a) :: Type

Methods

eval :: MonadEval m => Proxy (Pure2 t) -> POpts -> f a -> m (TT (PP (Pure2 t) (f a)))

type PP (Pure2 t :: Type) (f a)

Defined in Predicate

type PP (Pure2 t :: Type) (f a) = f (t a)

type Right t = Pure (Either t) Id

type Left t = Right t >> Swap

data Reverse

similar to reverse

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @Reverse [1,2,4]
Present [4,2,1]
PresentT [4,2,1]

>>> pl @Reverse "AbcDeF"
Present "FeDcbA"
PresentT "FeDcbA"

Instances

(Show a, as ~ [a]) => P Reverse as

Defined in Predicate

Associated Types

type PP Reverse as :: Type

Methods

eval :: MonadEval m => Proxy Reverse -> POpts -> as -> m (TT (PP Reverse as))

type PP Reverse as

Defined in Predicate

type PP Reverse as = as

data ReverseL

reverses using reversing

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> import Data.Text (Text)
>>> pl @ReverseL ("AbcDeF" :: Text)
Present "FeDcbA"
PresentT "FeDcbA"

Instances

(Show t, Reversing t) => P ReverseL t

Defined in Predicate

Associated Types

type PP ReverseL t :: Type

Methods

eval :: MonadEval m => Proxy ReverseL -> POpts -> t -> m (TT (PP ReverseL t))

type PP ReverseL t

Defined in Predicate

type PP ReverseL t = t

data Swap

swaps using swapped

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @Swap (Left 123)
Present Right 123
PresentT (Right 123)

>>> pl @Swap (Right 123)
Present Left 123
PresentT (Left 123)

>>> pl @Swap (These 'x' 123)
Present These 123 'x'
PresentT (These 123 'x')

>>> pl @Swap (This 'x')
Present That 'x'
PresentT (That 'x')

>>> pl @Swap (That 123)
Present This 123
PresentT (This 123)

>>> pl @Swap (123,'x')
Present ('x',123)
PresentT ('x',123)

Instances

(Show (p a b), Swapped p, Show (p b a)) => P Swap (p a b)

Defined in Predicate

Associated Types

type PP Swap (p a b) :: Type

Methods

eval :: MonadEval m => Proxy Swap -> POpts -> p a b -> m (TT (PP Swap (p a b)))

type PP Swap (p a b)

Defined in Predicate

type PP Swap (p a b) = p b a

data SuccB p q

bounded succ function

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(SuccB' Id) (13 :: Int)
Present 14
PresentT 14

>>> pl @(SuccB' Id) LT
Present EQ
PresentT EQ

>>> pl @(SuccB 'LT Id) GT
Present LT
PresentT LT

>>> pl @(SuccB' Id) GT
Error Succ bounded failed
FailT "Succ bounded failed"

Instances

(PP q x ~ a, P q x, P p (Proxy a), PP p (Proxy a) ~ a, Show a, Eq a, Bounded a, Enum a) => P (SuccB p q :: Type) x

Defined in Predicate

Associated Types

type PP (SuccB p q) x :: Type

Methods

eval :: MonadEval m => Proxy (SuccB p q) -> POpts -> x -> m (TT (PP (SuccB p q) x))

type PP (SuccB p q :: Type) x

Defined in Predicate

type PP (SuccB p q :: Type) x = PP q x

type SuccB' q = SuccB (Failp "Succ bounded failed") q

data PredB p q

bounded pred function

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(PredB' Id) (13 :: Int)
Present 12
PresentT 12

Instances

(PP q x ~ a, P q x, P p (Proxy a), PP p (Proxy a) ~ a, Show a, Eq a, Bounded a, Enum a) => P (PredB p q :: Type) x

Defined in Predicate

Associated Types

type PP (PredB p q) x :: Type

Methods

eval :: MonadEval m => Proxy (PredB p q) -> POpts -> x -> m (TT (PP (PredB p q) x))

type PP (PredB p q :: Type) x

Defined in Predicate

type PP (PredB p q :: Type) x = PP q x

type PredB' q = PredB (Failp "Pred bounded failed") q

data Succ p

unbounded succ function

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(Succ Id) 13
Present 14
PresentT 14

>>> pl @(Succ Id) LT
Present EQ
PresentT EQ

>>> pl @(Succ Id) GT
Error Succ IO e=Prelude.Enum.Ordering.succ: bad argument
FailT "Succ IO e=Prelude.Enum.Ordering.succ: bad argument"

Instances

(Show a, Enum a, PP p x ~ a, P p x) => P (Succ p :: Type) x

Defined in Predicate

Associated Types

type PP (Succ p) x :: Type

Methods

eval :: MonadEval m => Proxy (Succ p) -> POpts -> x -> m (TT (PP (Succ p) x))

type PP (Succ p :: Type) x

Defined in Predicate

type PP (Succ p :: Type) x = PP p x

data Pred p

unbounded pred function

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(Pred Id) 13
Present 12
PresentT 12

Instances

(Show a, Enum a, PP p x ~ a, P p x) => P (Pred p :: Type) x

Defined in Predicate

Associated Types

type PP (Pred p) x :: Type

Methods

eval :: MonadEval m => Proxy (Pred p) -> POpts -> x -> m (TT (PP (Pred p) x))

type PP (Pred p :: Type) x

Defined in Predicate

type PP (Pred p :: Type) x = PP p x

data FromEnum p

fromEnum function

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(FromEnum Id) 'x'
Present 120
PresentT 120

Instances

(Show a, Enum a, PP p x ~ a, P p x) => P (FromEnum p :: Type) x

Defined in Predicate

Associated Types

type PP (FromEnum p) x :: Type

Methods

eval :: MonadEval m => Proxy (FromEnum p) -> POpts -> x -> m (TT (PP (FromEnum p) x))

type PP (FromEnum p :: Type) x

Defined in Predicate

type PP (FromEnum p :: Type) x = Int

data ToEnum' t p

unsafe toEnum function

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(ToEnum Char Id) 120
Present 'x'
PresentT 'x'

Instances

(PP p x ~ a, P p x, Show a, Enum (PP t x), Show (PP t x), Integral a) => P (ToEnum' t p :: Type) x

Defined in Predicate

Associated Types

type PP (ToEnum' t p) x :: Type

Methods

eval :: MonadEval m => Proxy (ToEnum' t p) -> POpts -> x -> m (TT (PP (ToEnum' t p) x))

type PP (ToEnum' t p :: Type) x

Defined in Predicate

type PP (ToEnum' t p :: Type) x = PP t x

type ToEnum (t :: Type) p = ToEnum' (Hole t) p

data ToEnumB' t def

bounded toEnum function

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(ToEnumB Ordering LT) 2
Present GT
PresentT GT

>>> pl @(ToEnumB Ordering LT) 6
Present LT
PresentT LT

>>> pl @(ToEnumBF Ordering) 6
Error ToEnum bounded failed
FailT "ToEnum bounded failed"

Instances

(P def (Proxy (PP t a)), PP def (Proxy (PP t a)) ~ PP t a, Show a, Show (PP t a), Bounded (PP t a), Enum (PP t a), Integral a) => P (ToEnumB' t def :: Type) a

Defined in Predicate

Associated Types

type PP (ToEnumB' t def) a :: Type

Methods

eval :: MonadEval m => Proxy (ToEnumB' t def) -> POpts -> a -> m (TT (PP (ToEnumB' t def) a))

type PP (ToEnumB' t def :: Type) a

Defined in Predicate

type PP (ToEnumB' t def :: Type) a = PP t a

type ToEnumB (t :: Type) def = ToEnumB' (Hole t) def

type ToEnumBF (t :: Type) = ToEnumB' (Hole t) (Failp "ToEnum bounded failed")

data Prime p

a predicate on prime numbers

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(Prime Id) 2
True
TrueT

>>> pl @(Map '(Id,Prime Id) Id) [0..12]
Present [(0,False),(1,False),(2,True),(3,True),(4,False),(5,True),(6,False),(7,True),(8,False),(9,False),(10,False),(11,True),(12,False)]
PresentT [(0,False),(1,False),(2,True),(3,True),(4,False),(5,True),(6,False),(7,True),(8,False),(9,False),(10,False),(11,True),(12,False)]

Instances

(PP p x ~ a, P p x, Show a, Integral a) => P (Prime p :: Type) x

Defined in Predicate

Associated Types

type PP (Prime p) x :: Type

Methods

eval :: MonadEval m => Proxy (Prime p) -> POpts -> x -> m (TT (PP (Prime p) x))

type PP (Prime p :: Type) x

Defined in Predicate

type PP (Prime p :: Type) x = Bool

data Not p

not function

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(Not Id) False
True
TrueT

>>> pl @(Not Id) True
False
FalseT

>>> pl @(Not (Fst Id)) (True,22)
False
FalseT

Instances

(PP p x ~ Bool, P p x) => P (Not p :: Type) x

Defined in Predicate

Associated Types

type PP (Not p) x :: Type

Methods

eval :: MonadEval m => Proxy (Not p) -> POpts -> x -> m (TT (PP (Not p) x))

type PP (Not p :: Type) x

Defined in Predicate

type PP (Not p :: Type) x = Bool

data KeepImpl (keep :: Bool) p q

filters a list 'q' keeping or removing those elements in 'p'

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(Keep '[5] '[1,5,5,2,5,2]) ()
Present [5,5,5]
PresentT [5,5,5]

>>> pl @(Keep '[0,1,1,5] '[1,5,5,2,5,2]) ()
Present [1,5,5,5]
PresentT [1,5,5,5]

>>> pl @(Remove '[5] '[1,5,5,2,5,2]) ()
Present [1,2,2]
PresentT [1,2,2]

>>> pl @(Remove '[0,1,1,5] '[1,5,5,2,5,2]) ()
Present [2,2]
PresentT [2,2]

>>> pl @(Remove '[99] '[1,5,5,2,5,2]) ()
Present [1,5,5,2,5,2]
PresentT [1,5,5,2,5,2]

>>> pl @(Remove '[99,91] '[1,5,5,2,5,2]) ()
Present [1,5,5,2,5,2]
PresentT [1,5,5,2,5,2]

>>> pl @(Remove Id '[1,5,5,2,5,2]) []
Present [1,5,5,2,5,2]
PresentT [1,5,5,2,5,2]

>>> pl @(Remove '[] '[1,5,5,2,5,2]) 44 -- works if you make this a number!
Present [1,5,5,2,5,2]
PresentT [1,5,5,2,5,2]

Instances

(GetBool keep, Eq a, Show a, P p x, P q x, PP p x ~ PP q x, PP q x ~ [a]) => P (KeepImpl keep p q :: Type) x

Defined in Predicate

Associated Types

type PP (KeepImpl keep p q) x :: Type

Methods

eval :: MonadEval m => Proxy (KeepImpl keep p q) -> POpts -> x -> m (TT (PP (KeepImpl keep p q) x))

type PP (KeepImpl keep p q :: Type) x

Defined in Predicate

type PP (KeepImpl keep p q :: Type) x = PP q x

type Remove p q = KeepImpl False p q

type Keep p q = KeepImpl True p q

data Elem p q

elem function

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(Elem (Fst Id) (Snd Id)) ('x',"abcdxy")
True
TrueT

>>> pl @(Elem (Fst Id) (Snd Id)) ('z',"abcdxy")
False
FalseT

Instances

([PP p a] ~ PP q a, P p a, P q a, Show (PP p a), Eq (PP p a)) => P (Elem p q :: Type) a

Defined in Predicate

Associated Types

type PP (Elem p q) a :: Type

Methods

eval :: MonadEval m => Proxy (Elem p q) -> POpts -> a -> m (TT (PP (Elem p q) a))

type PP (Elem p q :: Type) a

Defined in Predicate

type PP (Elem p q :: Type) a = Bool

type Head' p = HeadFail "Head(empty)" p

type Tail' p = TailFail "Tail(empty)" p

type Last' p = LastFail "Last(empty)" p

type Init' p = InitFail "Init(empty)" p

data Fmap_1

similar to fmap fst

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @Fmap_1 (Just (13,"Asf"))
Present Just 13
PresentT (Just 13)

to make this work we grab the fst or snd out of the Maybe so it is a head or not/ is a tail or not etc! we still have access to the whole original list so we dont lose anything!

Instances

Functor f => P Fmap_1 (f (a, x))

Defined in Predicate

Associated Types

type PP Fmap_1 (f (a, x)) :: Type

Methods

eval :: MonadEval m => Proxy Fmap_1 -> POpts -> f (a, x) -> m (TT (PP Fmap_1 (f (a, x))))

type PP Fmap_1 (f (a, x))

Defined in Predicate

type PP Fmap_1 (f (a, x)) = f a

data Fmap_2

similar to fmap snd

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @Fmap_2 (Just ("asf",13))
Present Just 13
PresentT (Just 13)

Instances

Functor f => P Fmap_2 (f (x, a))

Defined in Predicate

Associated Types

type PP Fmap_2 (f (x, a)) :: Type

Methods

eval :: MonadEval m => Proxy Fmap_2 -> POpts -> f (x, a) -> m (TT (PP Fmap_2 (f (x, a))))

type PP Fmap_2 (f (x, a))

Defined in Predicate

type PP Fmap_2 (f (x, a)) = f a

type HeadDef p q = GDef (Uncons >> Fmap_1) p q

type HeadP q = GProxy (Uncons >> Fmap_1) q

type HeadFail msg q = GFail (Uncons >> Fmap_1) msg q

type TailDef p q = GDef (Uncons >> Fmap_2) p q

type TailP q = GProxy (Uncons >> Fmap_2) q

type TailFail msg q = GFail (Uncons >> Fmap_2) msg q

type LastDef p q = GDef (Unsnoc >> Fmap_2) p q

type LastP q = GProxy (Unsnoc >> Fmap_2) q

type LastFail msg q = GFail (Unsnoc >> Fmap_2) msg q

type InitDef p q = GDef (Unsnoc >> Fmap_1) p q

type InitP q = GProxy (Unsnoc >> Fmap_1) q

type InitFail msg q = GFail (Unsnoc >> Fmap_1) msg q

type GDef' z p q r = '(I, r >> z) >> MaybeXP (X >> p) q (Snd Id)

type JustDef' p q r = GDef' I p q r

type GDef'' z p q r = '(I, r >> z) >> MaybeXP p q (Snd Id)

type JustDef'' p q r = GDef'' I p q r

type PA = Snd Id

type A = Snd Id

type X = Fst Id >> Fst Id

type XA = I

type XPA = I

type GDef_X z p q r = '(I, r >> z) >> MaybeXP (X >> p) ('(X, A) >> q) A

type JustDef''' p q r = GDef_X I p q r

type GDef_PA z p q r = (Hide % '(I, r >> z)) >> MaybeXP (PA >> p) ('(X, A) >> q) A

type GDef z p q = '(I, q >> z) >> MaybeXP (X >> p) A A

type GProxy z q = '(I, q >> z) >> MaybeXP (PA >> MEmptyP) A A

type GFail z msg q = '(I, q >> z) >> MaybeXP (Fail (PA >> Unproxy) (X >> msg)) A A

type LookupDef' x y p q = GDef (Lookup x y) p q

type LookupP' x y q = GProxy (Lookup x y) q

type LookupFail' msg x y q = GFail (Lookup x y) msg q

type LookupDef x y p = LookupDef' x y p I

type LookupP x y = LookupP' x y I

type LookupFail msg x y = LookupFail' msg x y I

type Just' p = JustFail "expected Just" p

type Left' p = LeftFail "expected Left" p

type Right' p = RightFail "expected Right" p

type This' p = ThisFail "expected This" p

type That' p = ThatFail "expected That" p

type TheseIn' p = TheseFail "expected These" p

type JustDef p q = GDef I p q

type JustP q = GProxy I q

type JustFail msg q = GFail I msg q

type LeftDef p q = GDef LeftToMaybe p q

type LeftP q = GProxy LeftToMaybe q

type LeftFail msg q = GFail LeftToMaybe msg q

type RightDef p q = GDef RightToMaybe p q

type RightP q = GProxy RightToMaybe q

type RightFail msg q = GFail RightToMaybe msg q

type ThisDef p q = GDef ThisToMaybe p q

type ThisP q = GProxy ThisToMaybe q

type ThisFail msg q = GFail ThisToMaybe msg q

type ThatDef p q = GDef ThatToMaybe p q

type ThatP q = GProxy ThatToMaybe q

type ThatFail msg q = GFail ThatToMaybe msg q

type TheseDef p q = GDef TheseToMaybe p q

type TheseP q = GProxy TheseToMaybe q

type TheseFail msg q = GFail TheseToMaybe msg q

data MaybeXP p q r

Instances

(P r x, P p (x, Proxy a), P q (x, a), PP r x ~ Maybe a, PP p (x, Proxy a) ~ b, PP q (x, a) ~ b) => P (MaybeXP p q r :: Type) x

Defined in Predicate

Associated Types

type PP (MaybeXP p q r) x :: Type

Methods

eval :: MonadEval m => Proxy (MaybeXP p q r) -> POpts -> x -> m (TT (PP (MaybeXP p q r) x))

type PP (MaybeXP p q r :: Type) x

Defined in Predicate

type PP (MaybeXP p q r :: Type) x = MaybeXPT (PP r x) x q

type MaybeX p q r = MaybeXP (Fst Id >> p) q r

type family MaybeXPT lr x q where ...

Equations

MaybeXPT (Maybe a) x q = PP q (x, a)

data LeftToMaybe

similar to either Just (const Nothing)

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @LeftToMaybe (Left 13)
Present Just 13
PresentT (Just 13)

>>> pl @LeftToMaybe (Right 13)
Present Nothing
PresentT Nothing

Instances

P LeftToMaybe (Either a x)

Defined in Predicate

Associated Types

type PP LeftToMaybe (Either a x) :: Type

Methods

eval :: MonadEval m => Proxy LeftToMaybe -> POpts -> Either a x -> m (TT (PP LeftToMaybe (Either a x)))

type PP LeftToMaybe (Either a x)

Defined in Predicate

type PP LeftToMaybe (Either a x) = Maybe a

data RightToMaybe

similar to either (const Nothing) Just

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @RightToMaybe (Right 13)
Present Just 13
PresentT (Just 13)

>>> pl @RightToMaybe (Left 13)
Present Nothing
PresentT Nothing

Instances

P RightToMaybe (Either x a)

Defined in Predicate

Associated Types

type PP RightToMaybe (Either x a) :: Type

Methods

eval :: MonadEval m => Proxy RightToMaybe -> POpts -> Either x a -> m (TT (PP RightToMaybe (Either x a)))

type PP RightToMaybe (Either x a)

Defined in Predicate

type PP RightToMaybe (Either x a) = Maybe a

data ThisToMaybe

Instances

P ThisToMaybe (These a x)

Defined in Predicate

Associated Types

type PP ThisToMaybe (These a x) :: Type

Methods

eval :: MonadEval m => Proxy ThisToMaybe -> POpts -> These a x -> m (TT (PP ThisToMaybe (These a x)))

type PP ThisToMaybe (These a x)

Defined in Predicate

type PP ThisToMaybe (These a x) = Maybe a

data ThatToMaybe

Instances

P ThatToMaybe (These x a)

Defined in Predicate

Associated Types

type PP ThatToMaybe (These x a) :: Type

Methods

eval :: MonadEval m => Proxy ThatToMaybe -> POpts -> These x a -> m (TT (PP ThatToMaybe (These x a)))

type PP ThatToMaybe (These x a)

Defined in Predicate

type PP ThatToMaybe (These x a) = Maybe a

data TheseToMaybe

Instances

P TheseToMaybe (These a b)

Defined in Predicate

Associated Types

type PP TheseToMaybe (These a b) :: Type

Methods

eval :: MonadEval m => Proxy TheseToMaybe -> POpts -> These a b -> m (TT (PP TheseToMaybe (These a b)))

type PP TheseToMaybe (These a b)

Defined in Predicate

type PP TheseToMaybe (These a b) = Maybe (a, b)

data EitherX p q r

similar to ||| but additionally gives 'p' and 'q' the original input

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(EitherX (ShowP ((Fst Id >> Fst Id) + (Snd Id))) (ShowP Id) (Snd Id)) (9,Left 123)
Present "132"
PresentT "132"

>>> pl @(EitherX (ShowP ((Fst Id >> Fst Id) + (Snd Id))) (ShowP Id) (Snd Id)) (9,Right 'x')
Present "((9,Right 'x'),'x')"
PresentT "((9,Right 'x'),'x')"

>>> pl @(EitherX (ShowP Id) (ShowP (Second (Succ Id))) (Snd Id)) (9,Right 'x')
Present "((9,Right 'x'),'y')"
PresentT "((9,Right 'x'),'y')"

Instances

(P r x, P p (x, a), P q (x, b), PP r x ~ Either a b, PP p (x, a) ~ c, PP q (x, b) ~ c) => P (EitherX p q r :: Type) x

Defined in Predicate

Associated Types

type PP (EitherX p q r) x :: Type

Methods

eval :: MonadEval m => Proxy (EitherX p q r) -> POpts -> x -> m (TT (PP (EitherX p q r) x))

type PP (EitherX p q r :: Type) x

Defined in Predicate

type PP (EitherX p q r :: Type) x = EitherXT (PP r x) x p

type family EitherXT lr x p where ...

Equations

EitherXT (Either a b) x p = PP p (x, a)

data TheseX p q r s

similar to mergeTheseWith but additionally provides 'p', '\q' and 'r' the original input as the first element in the tuple

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(TheseX (((Fst Id >> Fst Id) + (Snd Id)) >> ShowP Id) (ShowP Id) (Snd Id >> (Snd Id)) (Snd Id)) (9,This 123)
Present "132"
PresentT "132"

>>> pl @(TheseX '(Snd Id,"fromthis") '(Negate 99,(Snd Id)) (Snd Id) Id) (This 123)
Present (123,"fromthis")
PresentT (123,"fromthis")

>>> pl @(TheseX '(Snd Id,"fromthis") '(Negate 99,(Snd Id)) (Snd Id) Id) (That "fromthat")
Present (-99,"fromthat")
PresentT (-99,"fromthat")

>>> pl @(TheseX '(Snd Id,"fromthis") '(Negate 99,(Snd Id)) (Snd Id) Id) (These 123 "fromthese")
Present (123,"fromthese")
PresentT (123,"fromthese")

Instances

(P s x, P p (x, a), P q (x, b), P r (x, (a, b)), PP s x ~ These a b, PP p (x, a) ~ c, PP q (x, b) ~ c, PP r (x, (a, b)) ~ c) => P (TheseX p q r s :: Type) x

Defined in Predicate

Associated Types

type PP (TheseX p q r s) x :: Type

Methods

eval :: MonadEval m => Proxy (TheseX p q r s) -> POpts -> x -> m (TT (PP (TheseX p q r s) x))

type PP (TheseX p q r s :: Type) x

Defined in Predicate

type PP (TheseX p q r s :: Type) x = TheseXT (PP s x) x p

type family TheseXT lr x p where ...

Equations

TheseXT (These a b) x p = PP p (x, a)

data MaybeIn p q

similar to maybe

similar to MaybeX but provides a Proxy to the result of 'q' and does not provide the surrounding context

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(MaybeIn "foundnothing" (ShowP (Pred Id))) (Just 20)
Present "19"
PresentT "19"

>>> pl @(MaybeIn "found nothing" (ShowP (Pred Id))) Nothing
Present "found nothing"
PresentT "found nothing"

Instances

(P q a, Show a, Show (PP q a), PP p (Proxy (PP q a)) ~ PP q a, P p (Proxy (PP q a))) => P (MaybeIn p q :: Type) (Maybe a)

Defined in Predicate

Associated Types

type PP (MaybeIn p q) (Maybe a) :: Type

Methods

eval :: MonadEval m => Proxy (MaybeIn p q) -> POpts -> Maybe a -> m (TT (PP (MaybeIn p q) (Maybe a)))

type PP (MaybeIn p q :: Type) (Maybe a)

Defined in Predicate

type PP (MaybeIn p q :: Type) (Maybe a) = PP q a

type IsNothing = MaybeIn True False

type IsJust = MaybeIn False True

data STimes n p

similar to stimes

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(STimes 4 Id) (SG.Sum 3)
Present Sum {getSum = 12}
PresentT (Sum {getSum = 12})

>>> pl @(STimes 4 Id) "ab"
Present "abababab"
PresentT "abababab"

Instances

(P n a, Integral (PP n a), Semigroup (PP p a), P p a, Show (PP p a)) => P (STimes n p :: Type) a

Defined in Predicate

Associated Types

type PP (STimes n p) a :: Type

Methods

eval :: MonadEval m => Proxy (STimes n p) -> POpts -> a -> m (TT (PP (STimes n p) a))

type PP (STimes n p :: Type) a

Defined in Predicate

type PP (STimes n p :: Type) a = PP p a

data Pure (t :: Type -> Type) p

similar to pure

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(Pure Maybe Id) 4
Present Just 4
PresentT (Just 4)

>>> pl @(Pure [] Id) 4
Present [4]
PresentT [4]

>>> pl @(Pure (Either String) (Fst Id)) (13,True)
Present Right 13
PresentT (Right 13)

Instances

(P p x, Show (PP p x), Show (t (PP p x)), Applicative t) => P (Pure t p :: Type) x

Defined in Predicate

Associated Types

type PP (Pure t p) x :: Type

Methods

eval :: MonadEval m => Proxy (Pure t p) -> POpts -> x -> m (TT (PP (Pure t p) x))

type PP (Pure t p :: Type) x

Defined in Predicate

type PP (Pure t p :: Type) x = t (PP p x)

type PMEmpty = MEmptyT' Proxy

data MEmptyT' t

similar to mempty

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(MEmptyT (SG.Sum Int)) ()
Present Sum {getSum = 0}
PresentT (Sum {getSum = 0})

no Monoid for Maybe a unless a is also a monoid but can use empty!

Instances

(Show (PP t a), Monoid (PP t a)) => P (MEmptyT' t :: Type) a

Defined in Predicate

Associated Types

type PP (MEmptyT' t) a :: Type

Methods

eval :: MonadEval m => Proxy (MEmptyT' t) -> POpts -> a -> m (TT (PP (MEmptyT' t) a))

type PP (MEmptyT' t :: Type) a

Defined in Predicate

type PP (MEmptyT' t :: Type) a = PP t a

type MEmptyT (t :: Type) = MEmptyT' (Hole t)

type MEmptyP = MEmptyT' Unproxy

data MEmptyProxy

Instances

Monoid a => P MEmptyProxy (Proxy a)

Defined in Predicate

Associated Types

type PP MEmptyProxy (Proxy a) :: Type

Methods

eval :: MonadEval m => Proxy MEmptyProxy -> POpts -> Proxy a -> m (TT (PP MEmptyProxy (Proxy a)))

type PP MEmptyProxy (Proxy a)

Defined in Predicate

type PP MEmptyProxy (Proxy a) = a

data EmptyT (t :: Type -> Type) p

similar to empty

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(EmptyT Maybe Id) ()
Present Nothing
PresentT Nothing

>>> pl @(EmptyT [] Id) ()
Present []
PresentT []

>>> pl @(EmptyT [] (Char1 "x")) (13,True)
Present ""
PresentT ""

>>> pl @(EmptyT (Either String) (Fst Id)) (13,True)
Present Left ""
PresentT (Left "")

Instances

(P p x, PP p x ~ a, Show (t a), Show a, Alternative t) => P (EmptyT t p :: Type) x

Defined in Predicate

Associated Types

type PP (EmptyT t p) x :: Type

Methods

eval :: MonadEval m => Proxy (EmptyT t p) -> POpts -> x -> m (TT (PP (EmptyT t p) x))

type PP (EmptyT t p :: Type) x

Defined in Predicate

type PP (EmptyT t p :: Type) x = t (PP p x)

data MkNothing' t

Instances

P (MkNothing' t :: Type) a

Defined in Predicate

Associated Types

type PP (MkNothing' t) a :: Type

Methods

eval :: MonadEval m => Proxy (MkNothing' t) -> POpts -> a -> m (TT (PP (MkNothing' t) a))

type PP (MkNothing' t :: Type) a

Defined in Predicate

type PP (MkNothing' t :: Type) a = Maybe (PP t a)

type MkNothing (t :: Type) = MkNothing' (Hole t)

data MkJust p

Just constructor

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(MkJust Id) 44
Present Just 44
PresentT (Just 44)

Instances

(PP p x ~ a, P p x, Show a) => P (MkJust p :: Type) x

Defined in Predicate

Associated Types

type PP (MkJust p) x :: Type

Methods

eval :: MonadEval m => Proxy (MkJust p) -> POpts -> x -> m (TT (PP (MkJust p) x))

type PP (MkJust p :: Type) x

Defined in Predicate

type PP (MkJust p :: Type) x = Maybe (PP p x)

data MkLeft' t p

Left constructor

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(MkLeft _ Id) 44
Present Left 44
PresentT (Left 44)

Instances

(Show (PP p x), P p x) => P (MkLeft' t p :: Type) x

Defined in Predicate

Associated Types

type PP (MkLeft' t p) x :: Type

Methods

eval :: MonadEval m => Proxy (MkLeft' t p) -> POpts -> x -> m (TT (PP (MkLeft' t p) x))

type PP (MkLeft' t p :: Type) x

Defined in Predicate

type PP (MkLeft' t p :: Type) x = Either (PP p x) (PP t x)

type MkLeft (t :: Type) p = MkLeft' (Hole t) p

data MkRight' t p

Right constructor

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(MkRight _ Id) 44
Present Right 44
PresentT (Right 44)

Instances

(Show (PP p x), P p x) => P (MkRight' t p :: Type) x

Defined in Predicate

Associated Types

type PP (MkRight' t p) x :: Type

Methods

eval :: MonadEval m => Proxy (MkRight' t p) -> POpts -> x -> m (TT (PP (MkRight' t p) x))

type PP (MkRight' t p :: Type) x

Defined in Predicate

type PP (MkRight' t p :: Type) x = Either (PP t x) (PP p x)

type MkRight (t :: Type) p = MkRight' (Hole t) p

data MkThis' t p

This constructor

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(MkThis _ Id) 44
Present This 44
PresentT (This 44)

Instances

(Show (PP p x), P p x) => P (MkThis' t p :: Type) x

Defined in Predicate

Associated Types

type PP (MkThis' t p) x :: Type

Methods

eval :: MonadEval m => Proxy (MkThis' t p) -> POpts -> x -> m (TT (PP (MkThis' t p) x))

type PP (MkThis' t p :: Type) x

Defined in Predicate

type PP (MkThis' t p :: Type) x = These (PP p x) (PP t x)

type MkThis (t :: Type) p = MkThis' (Hole t) p

data MkThat' t p

That constructor

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(MkThat _ Id) 44
Present That 44
PresentT (That 44)

Instances

(Show (PP p x), P p x) => P (MkThat' t p :: Type) x

Defined in Predicate

Associated Types

type PP (MkThat' t p) x :: Type

Methods

eval :: MonadEval m => Proxy (MkThat' t p) -> POpts -> x -> m (TT (PP (MkThat' t p) x))

type PP (MkThat' t p :: Type) x

Defined in Predicate

type PP (MkThat' t p :: Type) x = These (PP t x) (PP p x)

type MkThat (t :: Type) p = MkThat' (Hole t) p

data MkThese p q

These constructor

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(MkThese (Fst Id) (Snd Id)) (44,'x')
Present These 44 'x'
PresentT (These 44 'x')

Instances

(P p a, P q a, Show (PP p a), Show (PP q a)) => P (MkThese p q :: Type) a

Defined in Predicate

Associated Types

type PP (MkThese p q) a :: Type

Methods

eval :: MonadEval m => Proxy (MkThese p q) -> POpts -> a -> m (TT (PP (MkThese p q) a))

type PP (MkThese p q :: Type) a

Defined in Predicate

type PP (MkThese p q :: Type) a = These (PP p a) (PP q a)

data MConcat p

similar to mconcat

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(MConcat Id) [SG.Sum 44, SG.Sum 12, SG.Sum 3]
Present Sum {getSum = 59}
PresentT (Sum {getSum = 59})

Instances

(PP p x ~ [a], P p x, Show a, Monoid a) => P (MConcat p :: Type) x

Defined in Predicate

Associated Types

type PP (MConcat p) x :: Type

Methods

eval :: MonadEval m => Proxy (MConcat p) -> POpts -> x -> m (TT (PP (MConcat p) x))

type PP (MConcat p :: Type) x

Defined in Predicate

type PP (MConcat p :: Type) x = ExtractAFromTA (PP p x)

type FoldMap (t :: Type) p = Map (Wrap t Id) p >> Unwrap (MConcat Id)

similar to a limited form of foldMap

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(FoldMap (SG.Sum _) Id) [44, 12, 3]
Present 59
PresentT 59

>>> pl @(FoldMap (SG.Product _) Id) [44, 12, 3]
Present 1584
PresentT 1584

type Sum (t :: Type) = FoldMap (Sum t) Id

type Min' (t :: Type) = FoldMap (Min t) Id

data Concat p

similar to concat

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(Concat Id) ["abc","D","eF","","G"]
Present "abcDeFG"
PresentT "abcDeFG"

>>> pl @(Concat (Snd Id)) ('x',["abc","D","eF","","G"])
Present "abcDeFG"
PresentT "abcDeFG"

Instances

(Show a, Show (t [a]), PP p x ~ t [a], P p x, Foldable t) => P (Concat p :: Type) x

Defined in Predicate

Associated Types

type PP (Concat p) x :: Type

Methods

eval :: MonadEval m => Proxy (Concat p) -> POpts -> x -> m (TT (PP (Concat p) x))

type PP (Concat p :: Type) x

Defined in Predicate

type PP (Concat p :: Type) x = ExtractAFromTA (PP p x)

data ProxyT' t

Instances

Typeable t => P (ProxyT' t :: Type) a

Defined in Predicate

Associated Types

type PP (ProxyT' t) a :: Type

Methods

eval :: MonadEval m => Proxy (ProxyT' t) -> POpts -> a -> m (TT (PP (ProxyT' t) a))

type PP (ProxyT' t :: Type) a

Defined in Predicate

type PP (ProxyT' t :: Type) a = Proxy (PP t a)

type ProxyT (t :: Type) = ProxyT' (Hole t)

data Ix (n :: Nat) def

similar to !!

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(Ix 4 "not found") ["abc","D","eF","","G"]
Present "G"
PresentT "G"

>>> pl @(Ix 40 "not found") ["abc","D","eF","","G"]
Present "not found"
PresentT "not found"

Instances

(P def (Proxy a), PP def (Proxy a) ~ a, KnownNat n, Show a) => P (Ix n def :: Type) [a]

Defined in Predicate

Associated Types

type PP (Ix n def) [a] :: Type

Methods

eval :: MonadEval m => Proxy (Ix n def) -> POpts -> [a] -> m (TT (PP (Ix n def) [a]))

type PP (Ix n def :: Type) [a]

Defined in Predicate

type PP (Ix n def :: Type) [a] = a

type Ix' (n :: Nat) = Ix n (Failp "Ix index not found")

data IxL p q def

similar to !! leveraging Ixed

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> import qualified Data.Map.Strict as M
>>> pl @(Id !! 2) ["abc","D","eF","","G"]
Present "eF"
PresentT "eF"

>>> pl @(Id !! 20) ["abc","D","eF","","G"]
Error (!!) index not found
FailT "(!!) index not found"

>>> pl @(Id !! "eF") (M.fromList (flip zip [0..] ["abc","D","eF","","G"]))
Present 2
PresentT 2

Instances

(P q a, P p a, Show (PP p a), Ixed (PP p a), PP q a ~ Index (PP p a), Show (Index (PP p a)), Show (IxValue (PP p a)), P r (Proxy (IxValue (PP p a))), PP r (Proxy (IxValue (PP p a))) ~ IxValue (PP p a)) => P (IxL p q r :: Type) a

Defined in Predicate

Associated Types

type PP (IxL p q r) a :: Type

Methods

eval :: MonadEval m => Proxy (IxL p q r) -> POpts -> a -> m (TT (PP (IxL p q r) a))

type PP (IxL p q r :: Type) a

Defined in Predicate

type PP (IxL p q r :: Type) a = IxValue (PP p a)

type (!!) p q = IxL p q (Failp "(!!) index not found")

data Lookup p q

lookup leveraging Ixed

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> import qualified Data.Map.Strict as M
>>> pl @(Id !!! 2) ["abc","D","eF","","G"]
Present "eF"
PresentT "eF"

>>> pl @(Id !!! 20) ["abc","D","eF","","G"]
Error index not found
FailT "index not found"

>>> pl @(Id !!! "eF") (M.fromList (flip zip [0..] ["abc","D","eF","","G"]))
Present 2
PresentT 2

>>> pl @(Lookup Id 2) ["abc","D","eF","","G"]
Present Just "eF"
PresentT (Just "eF")

>>> pl @(Lookup Id 20) ["abc","D","eF","","G"]
Present Nothing
PresentT Nothing

Instances

(P q a, P p a, Show (PP p a), Ixed (PP p a), PP q a ~ Index (PP p a), Show (Index (PP p a)), Show (IxValue (PP p a))) => P (Lookup p q :: Type) a

Defined in Predicate

Associated Types

type PP (Lookup p q) a :: Type

Methods

eval :: MonadEval m => Proxy (Lookup p q) -> POpts -> a -> m (TT (PP (Lookup p q) a))

type PP (Lookup p q :: Type) a

Defined in Predicate

type PP (Lookup p q :: Type) a = Maybe (IxValue (PP p a))

type (!!!) p q = Lookup p q >> MaybeIn (Failp "index not found") Id

type Lookup' (t :: Type) p q = (q &&& Lookup p q) >> If (Snd Id >> IsNothing) (ShowP (Fst Id) >> Fail (Hole t) (Printf "index(%s) not found" Id)) (Snd Id >> Just Id)

data Ands p

ands

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(Ands Id) [True,True,True]
True
TrueT

>>> pl @(Ands Id) [True,True,True,False]
False
FalseT

>>> pl @(Ands Id) []
True
TrueT

Instances

(PP p x ~ t a, P p x, Show (t a), Foldable t, a ~ Bool) => P (Ands p :: Type) x

Defined in Predicate

Associated Types

type PP (Ands p) x :: Type

Methods

eval :: MonadEval m => Proxy (Ands p) -> POpts -> x -> m (TT (PP (Ands p) x))

type PP (Ands p :: Type) x

Defined in Predicate

type PP (Ands p :: Type) x = Bool

type Ands' p = FoldMap All p

data Ors p

ors

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(Ors Id) [False,False,False]
False
FalseT

>>> pl @(Ors Id) [True,True,True,False]
True
TrueT

>>> pl @(Ors Id) []
False
FalseT

Instances

(PP p x ~ t a, P p x, Show (t a), Foldable t, a ~ Bool) => P (Ors p :: Type) x

Defined in Predicate

Associated Types

type PP (Ors p) x :: Type

Methods

eval :: MonadEval m => Proxy (Ors p) -> POpts -> x -> m (TT (PP (Ors p) x))

type PP (Ors p :: Type) x

Defined in Predicate

type PP (Ors p :: Type) x = Bool

type Ors' p = FoldMap Any p

data p :+ q infixr 5

similar to cons

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(Fst Id :+ (Snd Id)) (99,[1,2,3,4])
Present [99,1,2,3,4]
PresentT [99,1,2,3,4]

>>> pl @(Snd Id :+ Fst Id) ([],5)
Present [5]
PresentT [5]

>>> pl @(123 :+ EmptyList _) "somestuff"
Present [123]
PresentT [123]

Instances

(P p x, P q x, Show (PP p x), Show (PP q x), Cons (PP q x) (PP q x) (PP p x) (PP p x)) => P (p :+ q :: Type) x

Defined in Predicate

Associated Types

type PP (p :+ q) x :: Type

Methods

eval :: MonadEval m => Proxy (p :+ q) -> POpts -> x -> m (TT (PP (p :+ q) x))

type PP (p :+ q :: Type) x

Defined in Predicate

type PP (p :+ q :: Type) x = PP q x

data p +: q infixl 5

similar to snoc

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(Snd Id +: Fst Id) (99,[1,2,3,4])
Present [1,2,3,4,99]
PresentT [1,2,3,4,99]

>>> pl @(Fst Id +: (Snd Id)) ([],5)
Present [5]
PresentT [5]

>>> pl @(EmptyT [] Id +: 5) 5
Present [5]
PresentT [5]

Instances

(P p x, P q x, Show (PP q x), Show (PP p x), Snoc (PP p x) (PP p x) (PP q x) (PP q x)) => P (p +: q :: Type) x

Defined in Predicate

Associated Types

type PP (p +: q) x :: Type

Methods

eval :: MonadEval m => Proxy (p +: q) -> POpts -> x -> m (TT (PP (p +: q) x))

type PP (p +: q :: Type) x

Defined in Predicate

type PP (p +: q :: Type) x = PP p x

data Uncons

uncons

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @Uncons [1,2,3,4]
Present Just (1,[2,3,4])
PresentT (Just (1,[2,3,4]))

>>> pl @Uncons []
Present Nothing
PresentT Nothing

Instances

(Show (ConsT s), Show s, Cons s s (ConsT s) (ConsT s)) => P Uncons s

Defined in Predicate

Associated Types

type PP Uncons s :: Type

Methods

eval :: MonadEval m => Proxy Uncons -> POpts -> s -> m (TT (PP Uncons s))

type PP Uncons s

Defined in Predicate

type PP Uncons s = Maybe (ConsT s, s)

data Unsnoc

unsnoc

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @Unsnoc [1,2,3,4]
Present Just ([1,2,3],4)
PresentT (Just ([1,2,3],4))

>>> pl @Unsnoc []
Present Nothing
PresentT Nothing

Instances

(Show (ConsT s), Show s, Snoc s s (ConsT s) (ConsT s)) => P Unsnoc s

Defined in Predicate

Associated Types

type PP Unsnoc s :: Type

Methods

eval :: MonadEval m => Proxy Unsnoc -> POpts -> s -> m (TT (PP Unsnoc s))

type PP Unsnoc s

Defined in Predicate

type PP Unsnoc s = Maybe (s, ConsT s)

data IsEmpty

similar to null using AsEmpty

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @IsEmpty [1,2,3,4]
False
FalseT

>>> pl @IsEmpty []
True
TrueT

>>> pl @IsEmpty LT
False
FalseT

>>> pl @IsEmpty EQ
True
TrueT

Instances

(Show as, AsEmpty as) => P IsEmpty as

Defined in Predicate

Associated Types

type PP IsEmpty as :: Type

Methods

eval :: MonadEval m => Proxy IsEmpty -> POpts -> as -> m (TT (PP IsEmpty as))

type PP IsEmpty as

Defined in Predicate

type PP IsEmpty as = Bool

data Null

similar to null using Foldable

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @Null [1,2,3,4]
False
FalseT

>>> pl @Null []
True
TrueT

Instances

(Show (t a), Foldable t, t a ~ as) => P Null as

Defined in Predicate

Associated Types

type PP Null as :: Type

Methods

eval :: MonadEval m => Proxy Null -> POpts -> as -> m (TT (PP Null as))

type PP Null as

Defined in Predicate

type PP Null as = Bool

data EnumFromTo p q

similar to enumFromTo

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(EnumFromTo 2 5) ()
Present [2,3,4,5]
PresentT [2,3,4,5]

>>> pl @(EnumFromTo LT GT) ()
Present [LT,EQ,GT]
PresentT [LT,EQ,GT]

Instances

(P p x, P q x, PP p x ~ a, Show a, PP q x ~ a, Enum a) => P (EnumFromTo p q :: Type) x

Defined in Predicate

Associated Types

type PP (EnumFromTo p q) x :: Type

Methods

eval :: MonadEval m => Proxy (EnumFromTo p q) -> POpts -> x -> m (TT (PP (EnumFromTo p q) x))

type PP (EnumFromTo p q :: Type) x

Defined in Predicate

type PP (EnumFromTo p q :: Type) x = [PP p x]

type MapMaybe p q = ConcatMap (p >> MaybeIn MEmptyP '[Id]) q

type CatMaybes q = MapMaybe Id q

data PartitionEithers

similar to partitionEithers

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @PartitionEithers [Left 'a',Right 2,Left 'c',Right 4,Right 99]
Present ("ac",[2,4,99])
PresentT ("ac",[2,4,99])

Instances

(Show a, Show b) => P PartitionEithers [Either a b]

Defined in Predicate

Associated Types

type PP PartitionEithers [Either a b] :: Type

Methods

eval :: MonadEval m => Proxy PartitionEithers -> POpts -> [Either a b] -> m (TT (PP PartitionEithers [Either a b]))

type PP PartitionEithers [Either a b]

Defined in Predicate

type PP PartitionEithers [Either a b] = ([a], [b])

data PartitionThese

similar to partitionThese. returns a 3-tuple with the results so use Fst Snd Thd to extract

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @PartitionThese [This 'a', That 2, This 'c', These 'z' 1, That 4, These 'a' 2, That 99]
Present ("ac",[2,4,99],[('z',1),('a',2)])
PresentT ("ac",[2,4,99],[('z',1),('a',2)])

Instances

(Show a, Show b) => P PartitionThese [These a b]

Defined in Predicate

Associated Types

type PP PartitionThese [These a b] :: Type

Methods

eval :: MonadEval m => Proxy PartitionThese -> POpts -> [These a b] -> m (TT (PP PartitionThese [These a b]))

type PP PartitionThese [These a b]

Defined in Predicate

type PP PartitionThese [These a b] = ([a], [b], [(a, b)])

type Thiss = PartitionThese >> Fst Id

type Thats = PartitionThese >> Snd Id

type Theses = PartitionThese >> Thd Id

data Scanl p q r

similar to scanl

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(Scanl (Snd Id :+ Fst Id) (Fst Id) (Snd Id)) ([99],[1..5])
Present [[99],[1,99],[2,1,99],[3,2,1,99],[4,3,2,1,99],[5,4,3,2,1,99]]
PresentT [[99],[1,99],[2,1,99],[3,2,1,99],[4,3,2,1,99],[5,4,3,2,1,99]]

>>> pl @(ScanN 4 Id (Succ Id)) 'c'
Present "cdefg"
PresentT "cdefg"

>>> pl @(FoldN 4 Id (Succ Id)) 'c'
Present 'g'
PresentT 'g'

Instances

(PP p (b, a) ~ b, PP q x ~ b, PP r x ~ [a], P p (b, a), P q x, P r x, Show b, Show a) => P (Scanl p q r :: Type) x

Defined in Predicate

Associated Types

type PP (Scanl p q r) x :: Type

Methods

eval :: MonadEval m => Proxy (Scanl p q r) -> POpts -> x -> m (TT (PP (Scanl p q r) x))

type PP (Scanl p q r :: Type) x

Defined in Predicate

type PP (Scanl p q r :: Type) x = [PP q x]

type ScanN n p q = Scanl (Fst Id >> q) p (EnumFromTo 1 n)

type ScanNA q = ScanN (Fst Id) (Snd Id) q

type FoldN n p q = Last' (ScanN n p q)

type Foldl p q r = Last' (Scanl p q r)

type family UnfoldT mbs where ...

Equations

UnfoldT (Maybe (b, s)) = b

data Unfoldr p q

similar to unfoldr

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(Unfoldr (MaybeB (Not Null) (SplitAt 2 Id)) Id) [1..5]
Present [[1,2],[3,4],[5]]
PresentT [[1,2],[3,4],[5]]

>>> pl @(IterateN 4 (Succ Id)) 4
Present [4,5,6,7]
PresentT [4,5,6,7]

Instances

(PP q a ~ s, PP p s ~ Maybe (b, s), P q a, P p s, Show s, Show b) => P (Unfoldr p q :: Type) a

Defined in Predicate

Associated Types

type PP (Unfoldr p q) a :: Type

Methods

eval :: MonadEval m => Proxy (Unfoldr p q) -> POpts -> a -> m (TT (PP (Unfoldr p q) a))

type PP (Unfoldr p q :: Type) a

Defined in Predicate

type PP (Unfoldr p q :: Type) a = [UnfoldT (PP p (PP q a))]

type IterateN n f = Unfoldr (MaybeB (Fst Id > 0) '(Snd Id, Pred Id *** f)) '(n, Id)

type IterateUntil p f = IterateWhile (Not p) f

type IterateWhile p f = Unfoldr (MaybeB p '(Id, f)) Id

type IterateNWhile n p f = '(n, Id) >> (IterateWhile ((Fst Id > 0) && (Snd Id >> p)) (Pred Id *** f) >> Map (Snd Id) Id)

type IterateNUntil n p f = IterateNWhile n (Not p) f

data Map p q

similar to map

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(Map (Pred Id) Id) [1..5]
Present [0,1,2,3,4]
PresentT [0,1,2,3,4]

Instances

(Show (PP p a), P p a, PP q x ~ f a, P q x, Show a, Show (f a), Foldable f) => P (Map p q :: Type) x

Defined in Predicate

Associated Types

type PP (Map p q) x :: Type

Methods

eval :: MonadEval m => Proxy (Map p q) -> POpts -> x -> m (TT (PP (Map p q) x))

type PP (Map p q :: Type) x

Defined in Predicate

type PP (Map p q :: Type) x = [PP p (ExtractAFromTA (PP q x))]

type ConcatMap p q = Concat (Map p q)

data If p q r

if p then run q else run r

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(If (Gt 4) "greater than 4" "less than or equal to 4" ) 10
Present "greater than 4"
PresentT "greater than 4"

>>> pl @(If (Gt 4) "greater than 4" "less than or equal to 4") 0
Present "less than or equal to 4"
PresentT "less than or equal to 4"

Instances

(Show (PP r a), P p a, PP p a ~ Bool, P q a, P r a, PP q a ~ PP r a) => P (If p q r :: Type) a

Defined in Predicate

Associated Types

type PP (If p q r) a :: Type

Methods

eval :: MonadEval m => Proxy (If p q r) -> POpts -> a -> m (TT (PP (If p q r) a))

type PP (If p q r :: Type) a

Defined in Predicate

type PP (If p q r :: Type) a = PP q a

data Pairs

creates a list of overlapping pairs of elements. requires two or more elements

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @Pairs [1,2,3,4]
Present [(1,2),(2,3),(3,4)]
PresentT [(1,2),(2,3),(3,4)]

>>> pl @Pairs []
Error Pairs no data found
FailT "Pairs no data found"

>>> pl @Pairs [1]
Error Pairs only one element found
FailT "Pairs only one element found"

Instances

Show a => P Pairs [a]

Defined in Predicate

Associated Types

type PP Pairs [a] :: Type

Methods

eval :: MonadEval m => Proxy Pairs -> POpts -> [a] -> m (TT (PP Pairs [a]))

type PP Pairs [a]

Defined in Predicate

type PP Pairs [a] = [(a, a)]

data Partition p q

similar to partition

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(Partition (Ge 3) Id) [10,4,1,7,3,1,3,5]
Present ([10,4,7,3,3,5],[1,1])
PresentT ([10,4,7,3,3,5],[1,1])

>>> pl @(Partition (Prime Id) Id) [10,4,1,7,3,1,3,5]
Present ([7,3,3,5],[10,4,1,1])
PresentT ([7,3,3,5],[10,4,1,1])

>>> pl @(Partition (Ge 300) Id) [10,4,1,7,3,1,3,5]
Present ([],[10,4,1,7,3,1,3,5])
PresentT ([],[10,4,1,7,3,1,3,5])

>>> pl @(Partition (Id < 300) Id) [10,4,1,7,3,1,3,5]
Present ([10,4,1,7,3,1,3,5],[])
PresentT ([10,4,1,7,3,1,3,5],[])

Instances

(P p x, Show x, PP q a ~ [x], PP p x ~ Bool, P q a) => P (Partition p q :: Type) a

Defined in Predicate

Associated Types

type PP (Partition p q) a :: Type

Methods

eval :: MonadEval m => Proxy (Partition p q) -> POpts -> a -> m (TT (PP (Partition p q) a))

type PP (Partition p q :: Type) a

Defined in Predicate

type PP (Partition p q :: Type) a = (PP q a, PP q a)

type FilterBy p q = Partition p q >> Fst Id

data Break p q

similar to break

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(Break (Ge 3) Id) [10,4,1,7,3,1,3,5]
Present ([],[10,4,1,7,3,1,3,5])
PresentT ([],[10,4,1,7,3,1,3,5])

>>> pl @(Break (Lt 3) Id) [10,4,1,7,3,1,3,5]
Present ([10,4],[1,7,3,1,3,5])
PresentT ([10,4],[1,7,3,1,3,5])

Instances

(P p x, PP q a ~ [x], PP p x ~ Bool, P q a) => P (Break p q :: Type) a

Defined in Predicate

Associated Types

type PP (Break p q) a :: Type

Methods

eval :: MonadEval m => Proxy (Break p q) -> POpts -> a -> m (TT (PP (Break p q) a))

type PP (Break p q :: Type) a

Defined in Predicate

type PP (Break p q :: Type) a = (PP q a, PP q a)

type Span p q = Break (Not p) q

data Fail t prt

Fails the computation with a message

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(Failt Int (Printf "value=%03d" Id)) 99
Error value=099
FailT "value=099"

>>> pl @(FailS (Printf2 "value=%03d string=%s")) (99,"somedata")
Error value=099 string=somedata
FailT "value=099 string=somedata"

Instances

(P prt a, PP prt a ~ String) => P (Fail t prt :: Type) a

Defined in Predicate

Associated Types

type PP (Fail t prt) a :: Type

Methods

eval :: MonadEval m => Proxy (Fail t prt) -> POpts -> a -> m (TT (PP (Fail t prt) a))

type PP (Fail t prt :: Type) a

Defined in Predicate

type PP (Fail t prt :: Type) a = PP t a

type Failp s = Fail Unproxy s

type Failt (t :: Type) prt = Fail (Hole t) prt

type FailS s = Fail I s

type FailPrt (t :: Type) prt = Fail (Hole t) (Printf prt)

type FailPrt2 (t :: Type) prt = Fail (Hole t) (Printf2 prt)

data Hole (t :: Type)

Instances

Typeable t => P (Hole t :: Type) a

Acts as a proxy in this dsl where you can explicitly set the Type.

It is passed around as an argument to help the type checker when needed. see ReadP, ParseTimeP, ShowP

Defined in Predicate

Associated Types

type PP (Hole t) a :: Type

Methods

eval :: MonadEval m => Proxy (Hole t) -> POpts -> a -> m (TT (PP (Hole t) a))

type PP (Hole t :: Type) a

Defined in Predicate

type PP (Hole t :: Type) a = t

type T (t :: Type) = Hole t

data Unproxy

Instances

Typeable a => P Unproxy (Proxy a)

Defined in Predicate

Associated Types

type PP Unproxy (Proxy a) :: Type

Methods

eval :: MonadEval m => Proxy Unproxy -> POpts -> Proxy a -> m (TT (PP Unproxy (Proxy a)))

type PP Unproxy (Proxy a)

Defined in Predicate

type PP Unproxy (Proxy a) = a

data W (p :: k)

transparent predicate wrapper to make k of kind Type so it can be in a promoted list (cant mix kinds) see Do

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(Do '[W 123, W "xyz", Len &&& Id, Pred Id *** Id<>Id]) ()
Present (2,"xyzxyz")
PresentT (2,"xyzxyz")

>>> pl @(TupleI '[W 999,W "somestring",W 'True, Id, ShowP (Pred Id)]) 23
Present (999,("somestring",(True,(23,("22",())))))
PresentT (999,("somestring",(True,(23,("22",())))))

Instances

P p a => P (W p :: Type) a

Defined in Predicate

Associated Types

type PP (W p) a :: Type

Methods

eval :: MonadEval m => Proxy (W p) -> POpts -> a -> m (TT (PP (W p) a))

type PP (W p :: Type) a

Defined in Predicate

type PP (W p :: Type) a = PP p a

data Catch p q

catch a failure

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(Catch (Succ Id) (Fst Id >> Second (ShowP Id) >> Printf2 "%s %s" >> 'LT)) GT
Present LT
PresentT LT

>>> pl @(Catch' (Succ Id) (Second (ShowP Id) >> Printf2 "%s %s")) GT
Error Succ IO e=Prelude.Enum.Ordering.succ: bad argument GT
FailT "Succ IO e=Prelude.Enum.Ordering.succ: bad argument GT"

>>> pl @(Catch' (Succ Id) (Second (ShowP Id) >> Printf2 "%s %s")) LT
Present EQ
PresentT EQ

more flexible: takes a (String,x) and a proxy so we can still call 'False 'True now takes the FailT string and x so you can print more detail if you want need the proxy so we can fail without having to explicitly specify a type

Instances

(P p x, P q ((String, x), Proxy (PP p x)), PP p x ~ PP q ((String, x), Proxy (PP p x))) => P (Catch p q :: Type) x

Defined in Predicate

Associated Types

type PP (Catch p q) x :: Type

Methods

eval :: MonadEval m => Proxy (Catch p q) -> POpts -> x -> m (TT (PP (Catch p q) x))

type PP (Catch p q :: Type) x

Defined in Predicate

type PP (Catch p q :: Type) x = PP p x

type Catch' p s = Catch p (FailCatch s)

type FailCatch s = Fail (Snd Id >> Unproxy) (Fst Id >> s)

type Even = Mod I 2 >> Same 0

type Odd = Mod I 2 >> Same 1

type Div' p q = DivMod p q >> Fst Id

type Mod' p q = DivMod p q >> Snd Id

data Div p q

similar to div

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(Div (Fst Id) (Snd Id)) (10,4)
Present 2
PresentT 2

>>> pl @(Div (Fst Id) (Snd Id)) (10,0)
Error Div zero denominator
FailT "Div zero denominator"

Instances

(PP p a ~ PP q a, P p a, P q a, Show (PP p a), Integral (PP p a)) => P (Div p q :: Type) a

Defined in Predicate

Associated Types

type PP (Div p q) a :: Type

Methods

eval :: MonadEval m => Proxy (Div p q) -> POpts -> a -> m (TT (PP (Div p q) a))

type PP (Div p q :: Type) a

Defined in Predicate

type PP (Div p q :: Type) a = PP p a

data Mod p q

similar to mod

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(Mod (Fst Id) (Snd Id)) (10,3)
Present 1
PresentT 1

>>> pl @(Mod (Fst Id) (Snd Id)) (10,0)
Error Mod zero denominator
FailT "Mod zero denominator"

Instances

(PP p a ~ PP q a, P p a, P q a, Show (PP p a), Integral (PP p a)) => P (Mod p q :: Type) a

Defined in Predicate

Associated Types

type PP (Mod p q) a :: Type

Methods

eval :: MonadEval m => Proxy (Mod p q) -> POpts -> a -> m (TT (PP (Mod p q) a))

type PP (Mod p q :: Type) a

Defined in Predicate

type PP (Mod p q :: Type) a = PP p a

data DivMod p q

similar to divMod

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(DivMod (Fst Id) (Snd Id)) (10,3)
Present (3,1)
PresentT (3,1)

>>> pl @(DivMod (Fst Id) (Snd Id)) (10,-3)
Present (-4,-2)
PresentT (-4,-2)

>>> pl @(DivMod (Fst Id) (Snd Id)) (-10,3)
Present (-4,2)
PresentT (-4,2)

>>> pl @(DivMod (Fst Id) (Snd Id)) (-10,-3)
Present (3,-1)
PresentT (3,-1)

>>> pl @(DivMod (Fst Id) (Snd Id)) (10,0)
Error DivMod zero denominator
FailT "DivMod zero denominator"

Instances

(PP p a ~ PP q a, P p a, P q a, Show (PP p a), Integral (PP p a)) => P (DivMod p q :: Type) a

Defined in Predicate

Associated Types

type PP (DivMod p q) a :: Type

Methods

eval :: MonadEval m => Proxy (DivMod p q) -> POpts -> a -> m (TT (PP (DivMod p q) a))

type PP (DivMod p q :: Type) a

Defined in Predicate

type PP (DivMod p q :: Type) a = (PP p a, PP p a)

data QuotRem p q

similar to quotRem

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(QuotRem (Fst Id) (Snd Id)) (10,3)
Present (3,1)
PresentT (3,1)

>>> pl @(QuotRem (Fst Id) (Snd Id)) (10,-3)
Present (-3,1)
PresentT (-3,1)

>>> pl @(QuotRem (Fst Id) (Snd Id)) (-10,-3)
Present (3,-1)
PresentT (3,-1)

>>> pl @(QuotRem (Fst Id) (Snd Id)) (-10,3)
Present (-3,-1)
PresentT (-3,-1)

>>> pl @(QuotRem (Fst Id) (Snd Id)) (10,0)
Error QuotRem zero denominator
FailT "QuotRem zero denominator"

Instances

(PP p a ~ PP q a, P p a, P q a, Show (PP p a), Integral (PP p a)) => P (QuotRem p q :: Type) a

Defined in Predicate

Associated Types

type PP (QuotRem p q) a :: Type

Methods

eval :: MonadEval m => Proxy (QuotRem p q) -> POpts -> a -> m (TT (PP (QuotRem p q) a))

type PP (QuotRem p q :: Type) a

Defined in Predicate

type PP (QuotRem p q :: Type) a = (PP p a, PP p a)

type Quot p q = QuotRem p q >> Fst Id

type Rem p q = QuotRem p q >> Snd Id

type OneP = Guard (Printf "expected list of length 1 but found length=%d" Len) (Len >> Same 1) >> Head

strictmsg :: forall strict. GetBool strict => String

data GuardsImpl (n :: Nat) (strict :: Bool) (os :: [(k, k1)])

Guards contain a type level list of tuples the action to run on failure of the predicate and the predicate itself Each tuple validating against the corresponding value in a value list

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(Guards '[ '("arg1 failed",Gt 4), '("arg2 failed", Same 4)]) [17,4]
Present [17,4]
PresentT [17,4]

>>> pl @(Guards '[ '("arg1 failed",Gt 4), '("arg2 failed", Same 5)]) [17,4]
Error arg2 failed
FailT "arg2 failed"

>>> pl @(Guards '[ '("arg1 failed",Gt 99), '("arg2 failed", Same 4)]) [17,4]
Error arg1 failed
FailT "arg1 failed"

>>> pl @(Guards '[ '(Printf2 "arg %d failed with value %d",Gt 4), '(Printf2 "%d %d", Same 4)]) [17,3]
Error 2 3
FailT "2 3"

>>> pl @(GuardsQuick (Printf2 "arg %d failed with value %d") '[Gt 4, Ge 3, Same 4]) [17,3,5]
Error arg 3 failed with value 5
FailT "arg 3 failed with value 5"

>>> pl @(GuardsQuick (Printf2 "arg %d failed with value %d") '[Gt 4, Ge 3, Same 4]) [17,3,5,99]
Error Guards: data elements(4) /= predicates(3)
FailT "Guards: data elements(4) /= predicates(3)"

Instances

(KnownNat n, GetBool strict, Show a) => P (GuardsImpl n strict ([] :: [(k, k1)]) :: Type) [a]

Defined in Predicate

Associated Types

type PP (GuardsImpl n strict []) [a] :: Type

Methods

eval :: MonadEval m => Proxy (GuardsImpl n strict []) -> POpts -> [a] -> m (TT (PP (GuardsImpl n strict []) [a]))

(PP prt (Int, a) ~ String, P prt (Int, a), KnownNat n, GetBool strict, GetLen ps, P p a, PP p a ~ Bool, P (GuardsImpl n strict ps) [a], PP (GuardsImpl n strict ps) [a] ~ [a], Show a) => P (GuardsImpl n strict ((,) prt p ': ps) :: Type) [a]

Defined in Predicate

Associated Types

type PP (GuardsImpl n strict ((prt, p) ': ps)) [a] :: Type

Methods

eval :: MonadEval m => Proxy (GuardsImpl n strict ((prt, p) ': ps)) -> POpts -> [a] -> m (TT (PP (GuardsImpl n strict ((prt, p) ': ps)) [a]))

type PP (GuardsImpl n strict ((,) prt p ': ps) :: Type) [a]

Defined in Predicate

type PP (GuardsImpl n strict ((,) prt p ': ps) :: Type) [a] = [a]

type PP (GuardsImpl n strict ([] :: [(k, k1)]) :: Type) [a]

Defined in Predicate

type PP (GuardsImpl n strict ([] :: [(k, k1)]) :: Type) [a] = [a]

type Guards (os :: [(k, k1)]) = GuardsImplW True os

type GuardsLax (os :: [(k, k1)]) = GuardsImplW False os

type GuardsQuick (prt :: k) (os :: [k1]) = Guards (ToGuardsT prt os)

data GuardsImplW (strict :: Bool) (ps :: [(k, k1)])

Instances

(GetBool strict, GetLen ps, P (GuardsImpl (LenT ps) strict ps) [a]) => P (GuardsImplW strict ps :: Type) [a]

Defined in Predicate

Associated Types

type PP (GuardsImplW strict ps) [a] :: Type

Methods

eval :: MonadEval m => Proxy (GuardsImplW strict ps) -> POpts -> [a] -> m (TT (PP (GuardsImplW strict ps) [a]))

type PP (GuardsImplW strict ps :: Type) [a]

Defined in Predicate

type PP (GuardsImplW strict ps :: Type) [a] = PP (GuardsImpl (LenT ps) strict ps) [a]

data Guard prt p

'p' is the predicate and on failure of the predicate runs 'prt'

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(Guard "expected > 3" (Gt 3)) 17
Present 17
PresentT 17

>>> pl @(Guard "expected > 3" (Gt 3)) 1
Error expected > 3
FailT "expected > 3"

>>> pl @(Guard (Printf "%d not > 3" Id) (Gt 3)) (-99)
Error -99 not > 3
FailT "-99 not > 3"

Instances

(Show a, P prt a, PP prt a ~ String, P p a, PP p a ~ Bool) => P (Guard prt p :: Type) a

Defined in Predicate

Associated Types

type PP (Guard prt p) a :: Type

Methods

eval :: MonadEval m => Proxy (Guard prt p) -> POpts -> a -> m (TT (PP (Guard prt p) a))

type PP (Guard prt p :: Type) a

Defined in Predicate

type PP (Guard prt p :: Type) a = a

type Guard' p = Guard "Guard" p

type ExitWhen prt p = Guard prt (Not p)

type ExitWhen' p = ExitWhen "ExitWhen" p

data GuardSimple p

similar to Guard but uses the root message of the False predicate case as the failure message

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(GuardSimple (Luhn Id)) [1..4]
Error Luhn map=[4,6,2,2] sum=14 ret=4 | [1,2,3,4]
FailT "Luhn map=[4,6,2,2] sum=14 ret=4 | [1,2,3,4]"

>>> pl @(GuardSimple (Luhn Id)) [1,2,3,0]
Present [1,2,3,0]
PresentT [1,2,3,0]

>>> pl @(GuardSimple (Len > 30)) [1,2,3,0]
Error 4 > 30
FailT "4 > 30"

Instances

(Show a, P p a, PP p a ~ Bool) => P (GuardSimple p :: Type) a

Defined in Predicate

Associated Types

type PP (GuardSimple p) a :: Type

Methods

eval :: MonadEval m => Proxy (GuardSimple p) -> POpts -> a -> m (TT (PP (GuardSimple p) a))

type PP (GuardSimple p :: Type) a

Defined in Predicate

type PP (GuardSimple p :: Type) a = a

data Skip p

just run the effect but skip the value for example for use with Stdout so it doesnt interfere with the 'a' on the rhs unless there is an error

Instances

(Show (PP p a), P p a) => P (Skip p :: Type) a

Defined in Predicate

Associated Types

type PP (Skip p) a :: Type

Methods

eval :: MonadEval m => Proxy (Skip p) -> POpts -> a -> m (TT (PP (Skip p) a))

type PP (Skip p :: Type) a

Defined in Predicate

type PP (Skip p :: Type) a = a

type (|>) p q = Skip p >> q infixr 1

type (>|) p q = p >> Skip q infixr 1

data (p :: k) >> (q :: k1) infixr 1

This is composition for predicates

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(Fst Id >> Succ (Id !! 0)) ([11,12],'x')
Present 12
PresentT 12

>>> pl @(Len *** Succ Id >> ShowP (First (Pred Id))) ([11,12],'x')
Present "(1,'y')"
PresentT "(1,'y')"

Instances

(Show (PP p a), Show (PP q (PP p a)), P p a, P q (PP p a)) => P (p >> q :: Type) a

Defined in Predicate

Associated Types

type PP (p >> q) a :: Type

Methods

eval :: MonadEval m => Proxy (p >> q) -> POpts -> a -> m (TT (PP (p >> q) a))

type PP (p >> q :: Type) a

Defined in Predicate

type PP (p >> q :: Type) a = PP q (PP p a)

type (<<) p q = q >> p infixl 1

data (p :: k) && (q :: k1) infixr 3

similar to &&

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(Fst Id && (Snd Id >> Len >> Ge 4)) (True,[11,12,13,14])
True
TrueT

>>> pl @(Fst Id && (Snd Id >> Len >> Same 4)) (True,[12,11,12,13,14])
False
FalseT

Instances

(P p a, P q a, PP p a ~ Bool, PP q a ~ Bool) => P (p && q :: Type) a

Defined in Predicate

Associated Types

type PP (p && q) a :: Type

Methods

eval :: MonadEval m => Proxy (p && q) -> POpts -> a -> m (TT (PP (p && q) a))

type PP (p && q :: Type) a

Defined in Predicate

type PP (p && q :: Type) a = Bool

type And p q = p && q

data (p :: k) || (q :: k1) infixr 2

similar to ||

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(Fst Id || (Snd Id >> Len >> Ge 4)) (False,[11,12,13,14])
True
TrueT

>>> pl @((Not (Fst Id)) || (Snd Id >> Len >> Same 4)) (True,[12,11,12,13,14])
False
FalseT

Instances

(P p a, P q a, PP p a ~ Bool, PP q a ~ Bool) => P (p || q :: Type) a

Defined in Predicate

Associated Types

type PP (p || q) a :: Type

Methods

eval :: MonadEval m => Proxy (p || q) -> POpts -> a -> m (TT (PP (p || q) a))

type PP (p || q :: Type) a

Defined in Predicate

type PP (p || q :: Type) a = Bool

type OR p q = p || q

data (p :: k) ~> (q :: k1) infixr 1

implication

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(Fst Id ~> (Snd Id >> Len >> Ge 4)) (True,[11,12,13,14])
True
TrueT

>>> pl @(Fst Id ~> (Snd Id >> Len >> Same 4)) (True,[12,11,12,13,14])
False
FalseT

>>> pl @(Fst Id ~> (Snd Id >> Len >> Same 4)) (False,[12,11,12,13,14])
True
TrueT

>>> pl @(Fst Id ~> (Snd Id >> Len >> Ge 4)) (False,[11,12,13,14])
True
TrueT

Instances

(P p a, P q a, PP p a ~ Bool, PP q a ~ Bool) => P (p ~> q :: Type) a

Defined in Predicate

Associated Types

type PP (p ~> q) a :: Type

Methods

eval :: MonadEval m => Proxy (p ~> q) -> POpts -> a -> m (TT (PP (p ~> q) a))

type PP (p ~> q :: Type) a

Defined in Predicate

type PP (p ~> q :: Type) a = Bool

type Imply p q = p ~> q

data OrdP p q

Instances

(Ord (PP p a), PP p a ~ PP q a, P p a, Show (PP q a), P q a) => P (OrdP p q :: Type) a

Defined in Predicate

Associated Types

type PP (OrdP p q) a :: Type

Methods

eval :: MonadEval m => Proxy (OrdP p q) -> POpts -> a -> m (TT (PP (OrdP p q) a))

type PP (OrdP p q :: Type) a

Defined in Predicate

type PP (OrdP p q :: Type) a = Ordering

type (===) p q = OrdP p q infix 4

type OrdA' p q = OrdP (Fst Id >> p) (Snd Id >> q)

similar to compare

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(Fst Id === (Snd Id)) (10,9)
Present GT
PresentT GT

>>> pl @(14 % 3 === Fst Id %- (Snd Id)) (-10,7)
Present GT
PresentT GT

>>> pl @(Fst Id === (Snd Id)) (10,11)
Present LT
PresentT LT

>>> pl @(Snd Id === (Fst Id >> Snd Id >> Head' Id)) (('x',[10,12,13]),10)
Present EQ
PresentT EQ

>>> pl @(Snd Id === Head' (Snd (Fst Id))) (('x',[10,12,13]),10)
Present EQ
PresentT EQ

type OrdA p = OrdA' p p

data OrdI p q

compare two strings ignoring case

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(Fst Id ===? (Snd Id)) ("abC","aBc")
Present EQ
PresentT EQ

>>> pl @(Fst Id ===? (Snd Id)) ("abC","DaBc")
Present LT
PresentT LT

Instances

(PP p a ~ String, PP p a ~ PP q a, P p a, P q a) => P (OrdI p q :: Type) a

Defined in Predicate

Associated Types

type PP (OrdI p q) a :: Type

Methods

eval :: MonadEval m => Proxy (OrdI p q) -> POpts -> a -> m (TT (PP (OrdI p q) a))

type PP (OrdI p q :: Type) a

Defined in Predicate

type PP (OrdI p q :: Type) a = Ordering

type (===?) p q = OrdI p q infix 4

data Cmp (o :: OrderingP) p q

Instances

(GetOrd o, Ord (PP p a), Show (PP p a), PP p a ~ PP q a, P p a, P q a) => P (Cmp o p q :: Type) a

Defined in Predicate

Associated Types

type PP (Cmp o p q) a :: Type

Methods

eval :: MonadEval m => Proxy (Cmp o p q) -> POpts -> a -> m (TT (PP (Cmp o p q) a))

type PP (Cmp o p q :: Type) a

Defined in Predicate

type PP (Cmp o p q :: Type) a = Bool

data CmpI (o :: OrderingP) p q

Instances

(PP p a ~ String, GetOrd o, PP p a ~ PP q a, P p a, P q a) => P (CmpI o p q :: Type) a

Defined in Predicate

Associated Types

type PP (CmpI o p q) a :: Type

Methods

eval :: MonadEval m => Proxy (CmpI o p q) -> POpts -> a -> m (TT (PP (CmpI o p q) a))

type PP (CmpI o p q :: Type) a

Defined in Predicate

type PP (CmpI o p q :: Type) a = Bool

type Gt n = Cmp Cgt I n

type Ge n = Cmp Cge I n

type Same n = Cmp Ceq I n

type Le n = Cmp Cle I n

type Lt n = Cmp Clt I n

type Ne n = Cmp Cne I n

data IToList' t p

similar to itoList

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(IToList _) ("aBc" :: String)
Present [(0,'a'),(1,'B'),(2,'c')]
PresentT [(0,'a'),(1,'B'),(2,'c')]

Instances

(Show x, P p x, Typeable (PP t (PP p x)), Show (PP t (PP p x)), FoldableWithIndex (PP t (PP p x)) f, PP p x ~ f a, Show a) => P (IToList' t p :: Type) x

Defined in Predicate

Associated Types

type PP (IToList' t p) x :: Type

Methods

eval :: MonadEval m => Proxy (IToList' t p) -> POpts -> x -> m (TT (PP (IToList' t p) x))

type PP (IToList' t p :: Type) x

Defined in Predicate

type PP (IToList' t p :: Type) x = [(PP t (PP p x), ExtractAFromTA (PP p x))]

type IToList (t :: Type) = IToList' (Hole t) Id

data ToList

similar to toList

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @ToList ("aBc" :: String)
Present "aBc"
PresentT "aBc"

>>> pl @ToList (Just 14)
Present [14]
PresentT [14]

>>> pl @ToList Nothing
Present []
PresentT []

>>> pl @ToList (Left "xx")
Present []
PresentT []

>>> pl @ToList (These 12 "xx")
Present ["xx"]
PresentT ["xx"]

Instances

(Show (t a), Foldable t, Show a) => P ToList (t a)

Defined in Predicate

Associated Types

type PP ToList (t a) :: Type

Methods

eval :: MonadEval m => Proxy ToList -> POpts -> t a -> m (TT (PP ToList (t a)))

type PP ToList (t a)

Defined in Predicate

type PP ToList (t a) = [a]

data ToList' p

similar to toList

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(ToList' Id) ("aBc" :: String)
Present "aBc"
PresentT "aBc"

>>> pl @(ToList' Id) (Just 14)
Present [14]
PresentT [14]

>>> pl @(ToList' Id) Nothing
Present []
PresentT []

>>> pl @(ToList' Id) (Left "xx")
Present []
PresentT []

>>> pl @(ToList' Id) (These 12 "xx")
Present ["xx"]
PresentT ["xx"]

Instances

(PP p x ~ t a, P p x, Show (t a), Foldable t, Show a) => P (ToList' p :: Type) x

Defined in Predicate

Associated Types

type PP (ToList' p) x :: Type

Methods

eval :: MonadEval m => Proxy (ToList' p) -> POpts -> x -> m (TT (PP (ToList' p) x))

type PP (ToList' p :: Type) x

Defined in Predicate

type PP (ToList' p :: Type) x = [ExtractAFromTA (PP p x)]

data ToListExt

Instances

(Show l, IsList l, Show (Item l)) => P ToListExt l

Defined in Predicate

Associated Types

type PP ToListExt l :: Type

Methods

eval :: MonadEval m => Proxy ToListExt -> POpts -> l -> m (TT (PP ToListExt l))

type PP ToListExt l

Defined in Predicate

type PP ToListExt l = [Item l]

data FromList (t :: Type)

Instances

(a ~ Item t, Show t, IsList t) => P (FromList t :: Type) [a]

Defined in Predicate

Associated Types

type PP (FromList t) [a] :: Type

Methods

eval :: MonadEval m => Proxy (FromList t) -> POpts -> [a] -> m (TT (PP (FromList t) [a]))

type PP (FromList t :: Type) [a]

Defined in Predicate

type PP (FromList t :: Type) [a] = t

data FromListF (t :: Type)

Instances

(Show l, IsList l, l ~ l') => P (FromListF l' :: Type) l

Defined in Predicate

Associated Types

type PP (FromListF l') l :: Type

Methods

eval :: MonadEval m => Proxy (FromListF l') -> POpts -> l -> m (TT (PP (FromListF l') l))

type PP (FromListF l' :: Type) l

Defined in Predicate

type PP (FromListF l' :: Type) l = l'

data IsTh (th :: These x y) p

predicate on These

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(IsThis Id) (This "aBc")
True
TrueT

>>> pl @(IsThis Id) (These 1 'a')
False
FalseT

>>> pl @(IsThese Id) (These 1 'a')
True
TrueT

Instances

(PP p x ~ These a b, P p x, Show a, Show b, GetThese th) => P (IsTh th p :: Type) x

Defined in Predicate

Associated Types

type PP (IsTh th p) x :: Type

Methods

eval :: MonadEval m => Proxy (IsTh th p) -> POpts -> x -> m (TT (PP (IsTh th p) x))

type PP (IsTh th p :: Type) x

Defined in Predicate

type PP (IsTh th p :: Type) x = Bool

type IsThis p = IsTh (This ()) p

type IsThat p = IsTh (That ()) p

type IsThese p = IsTh (These () ()) p

data TheseIn p q r

similar to these

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(TheseIn Id Len (Fst Id + Length (Snd Id))) (This 13)
Present 13
PresentT 13

>>> pl @(TheseIn Id Len (Fst Id + Length (Snd Id))) (That "this is a long string")
Present 21
PresentT 21

>>> pl @(TheseIn Id Len (Fst Id + Length (Snd Id))) (These 20 "somedata")
Present 28
PresentT 28

>>> pl @(TheseIn (Left _) (Right _) (If (Fst Id > Length (Snd Id)) (MkLeft _ (Fst Id)) (MkRight _ (Snd Id)))) (That "this is a long string")
Present Right "this is a long string"
PresentT (Right "this is a long string")

>>> pl @(TheseIn (Left _) (Right _) (If (Fst Id > Length (Snd Id)) (MkLeft _ (Fst Id)) (MkRight _ (Snd Id)))) (These 1 "this is a long string")
Present Right "this is a long string"
PresentT (Right "this is a long string")

>>> pl @(TheseIn (Left _) (Right _) (If (Fst Id > Length (Snd Id)) (MkLeft _ (Fst Id)) (MkRight _ (Snd Id)))) (These 100 "this is a long string")
Present Left 100
PresentT (Left 100)

Instances

(Show a, Show b, Show (PP p a), P p a, P q b, P r (a, b), PP p a ~ PP q b, PP p a ~ PP r (a, b), PP q b ~ PP r (a, b)) => P (TheseIn p q r :: Type) (These a b)

Defined in Predicate

Associated Types

type PP (TheseIn p q r) (These a b) :: Type

Methods

eval :: MonadEval m => Proxy (TheseIn p q r) -> POpts -> These a b -> m (TT (PP (TheseIn p q r) (These a b)))

type PP (TheseIn p q r :: Type) (These a b)

Defined in Predicate

type PP (TheseIn p q r :: Type) (These a b) = PP p a

type Theseid p q = TheseIn '(I, p) '(q, I) I

data EmptyList' t

creates an empty list of the given type

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(Id :+ EmptyList _) 99
Present [99]
PresentT [99]

Instances

P (EmptyList' t :: Type) x

Defined in Predicate

Associated Types

type PP (EmptyList' t) x :: Type

Methods

eval :: MonadEval m => Proxy (EmptyList' t) -> POpts -> x -> m (TT (PP (EmptyList' t) x))

type PP (EmptyList' t :: Type) x

Defined in Predicate

type PP (EmptyList' t :: Type) x = [PP t x]

type EmptyList (t :: Type) = EmptyList' (Hole t)

type Singleton p = p :+ EmptyT [] p

data Char1 (s :: Symbol)

creates a singleton from a value

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(Singleton (Char1 "aBc")) ()
Present "a"
PresentT "a"

>>> pl @(Singleton Id) False
Present [False]
PresentT [False]

extracts the first character from a non empty Symbol

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(Char1 "aBc") ()
Present 'a'
PresentT 'a'

Instances

(KnownSymbol s, NullT s ~ False) => P (Char1 s :: Type) a

Defined in Predicate

Associated Types

type PP (Char1 s) a :: Type

Methods

eval :: MonadEval m => Proxy (Char1 s) -> POpts -> a -> m (TT (PP (Char1 s) a))

type PP (Char1 s :: Type) a

Defined in Predicate

type PP (Char1 s :: Type) a = Char

data ZipThese p q

similar to align thats pads with This or That if one list is shorter than the other

the key is that all information about both lists are preserved

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(ZipThese (Fst Id) (Snd Id)) ("aBc", [1..5])
Present [These 'a' 1,These 'B' 2,These 'c' 3,That 4,That 5]
PresentT [These 'a' 1,These 'B' 2,These 'c' 3,That 4,That 5]

>>> pl @(ZipThese (Fst Id) (Snd Id)) ("aBcDeF", [1..3])
Present [These 'a' 1,These 'B' 2,These 'c' 3,This 'D',This 'e',This 'F']
PresentT [These 'a' 1,These 'B' 2,These 'c' 3,This 'D',This 'e',This 'F']

Instances

(PP p a ~ [x], PP q a ~ [y], P p a, P q a, Show x, Show y) => P (ZipThese p q :: Type) a

Defined in Predicate

Associated Types

type PP (ZipThese p q) a :: Type

Methods

eval :: MonadEval m => Proxy (ZipThese p q) -> POpts -> a -> m (TT (PP (ZipThese p q) a))

type PP (ZipThese p q :: Type) a

Defined in Predicate

type PP (ZipThese p q :: Type) a = [These (ArrT (PP p a)) (ArrT (PP q a))]

data ZipTheseF p q

Instances

(Show (f y), PP p a ~ f x, PP q a ~ f y, ExtractAFromTA (f x) ~ x, ExtractAFromTA (f y) ~ y, Show (f x), Align f, Show (f (These x y)), P p a, P q a) => P (ZipTheseF p q :: Type) a

Defined in Predicate

Associated Types

type PP (ZipTheseF p q) a :: Type

Methods

eval :: MonadEval m => Proxy (ZipTheseF p q) -> POpts -> a -> m (TT (PP (ZipTheseF p q) a))

type PP (ZipTheseF p q :: Type) a

Defined in Predicate

type PP (ZipTheseF p q :: Type) a = ApplyConstT (PP p a) (These (ExtractAFromTA (PP p a)) (ExtractAFromTA (PP q a)))

type family ExtractAFromTA (ta :: Type) :: Type where ...

Equations

ExtractAFromTA (t a) = a

ExtractAFromTA ta = TypeError (Text "ExtractAFromTA: expected (t a) but found something else" :$$: (Text "t a = " :<>: ShowType ta))

data Zip (lc :: Bool) (rc :: Bool) p q

Zip two lists optionally cycling the one of the lists to match the size

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(Ziplc (Fst Id) (Snd Id)) ("abc", [1..5])
Present [('a',1),('b',2),('c',3),('a',4),('b',5)]
PresentT [('a',1),('b',2),('c',3),('a',4),('b',5)]

>>> pl @(Ziplc (Fst Id) (Snd Id)) ("abcdefg", [1..5])
Present [('a',1),('b',2),('c',3),('d',4),('e',5)]
PresentT [('a',1),('b',2),('c',3),('d',4),('e',5)]

>>> pl @(Ziprc (Fst Id) (Snd Id)) ("abcdefg", [1..5])
Present [('a',1),('b',2),('c',3),('d',4),('e',5),('f',1),('g',2)]
PresentT [('a',1),('b',2),('c',3),('d',4),('e',5),('f',1),('g',2)]

Instances

(GetBool lc, GetBool rc, PP p a ~ [x], PP q a ~ [y], P p a, P q a, Show x, Show y) => P (Zip lc rc p q :: Type) a

Defined in Predicate

Associated Types

type PP (Zip lc rc p q) a :: Type

Methods

eval :: MonadEval m => Proxy (Zip lc rc p q) -> POpts -> a -> m (TT (PP (Zip lc rc p q) a))

type PP (Zip lc rc p q :: Type) a

Defined in Predicate

type PP (Zip lc rc p q :: Type) a = [(ArrT (PP p a), ArrT (PP q a))]

type Ziplc p q = Zip True False p q

type Ziprc p q = Zip False True p q

type Zipn p q = Zip False False p q

data Luhn p

Luhn predicate check on last digit

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(Luhn Id) [1,2,3,0]
True
TrueT

>>> pl @(Luhn Id) [1,2,3,4]
False
FalseT

Instances

(PP p x ~ [Int], P p x) => P (Luhn p :: Type) x

Defined in Predicate

Associated Types

type PP (Luhn p) x :: Type

Methods

eval :: MonadEval m => Proxy (Luhn p) -> POpts -> x -> m (TT (PP (Luhn p) x))

type PP (Luhn p :: Type) x

Defined in Predicate

type PP (Luhn p :: Type) x = Bool

pe0 :: forall p a. (Show (PP p a), P p a) => a -> IO (BoolT (PP p a))

pe :: forall p a. (Show (PP p a), P p a) => a -> IO (BoolT (PP p a))

pe1 :: forall p a. (Show (PP p a), P p a) => a -> IO (BoolT (PP p a))

pe2 :: forall p a. (Show (PP p a), P p a) => a -> IO (BoolT (PP p a))

pu :: forall p a. (Show (PP p a), P p a) => a -> IO (BoolT (PP p a))

pex :: forall p a. (Show (PP p a), P p a) => a -> IO (BoolT (PP p a))

pe3 :: forall p a. (Show (PP p a), P p a) => a -> IO (BoolT (PP p a))

pl :: forall p a. (Show (PP p a), P p a) => a -> IO (BoolT (PP p a))

plc :: forall p a. (Show (PP p a), P p a) => a -> IO (BoolT (PP p a))

peWith :: forall p a. (Show (PP p a), P p a) => POpts -> a -> IO (BoolT (PP p a))

data ReadBase' t (n :: Nat) p

Read a number base 2 via 36

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(ReadBase Int 16) "00feD"
Present 4077
PresentT 4077

>>> pl @(ReadBase Int 16) "-ff"
Present -255
PresentT (-255)

>>> pl @(ReadBase Int 2) "10010011"
Present 147
PresentT 147

supports negative numbers unlike readInt

Instances

(Typeable (PP t x), BetweenT 2 36 n, Show (PP t x), Num (PP t x), KnownNat n, PP p x ~ String, P p x) => P (ReadBase' t n p :: Type) x

Defined in Predicate

Associated Types

type PP (ReadBase' t n p) x :: Type

Methods

eval :: MonadEval m => Proxy (ReadBase' t n p) -> POpts -> x -> m (TT (PP (ReadBase' t n p) x))

type PP (ReadBase' t n p :: Type) x

Defined in Predicate

type PP (ReadBase' t n p :: Type) x = PP t x

type ReadBase (t :: Type) (n :: Nat) = ReadBase' (Hole t) n Id

type ReadBaseInt (n :: Nat) = ReadBase' (Hole Int) n Id

getValidBase :: Int -> String

data ShowBase (n :: Nat)

Display a number at base 2 to 36

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(ShowBase 16) 4077
Present "fed"
PresentT "fed"

>>> pl @(ShowBase 16) (-255)
Present "-ff"
PresentT "-ff"

>>> pl @(ShowBase 2) 147
Present "10010011"
PresentT "10010011"

supports negative numbers unlike showIntAtBase

Instances

(Show a, 2 <= n, n <= 36, KnownNat n, Integral a) => P (ShowBase n :: Type) a

Defined in Predicate

Associated Types

type PP (ShowBase n) a :: Type

Methods

eval :: MonadEval m => Proxy (ShowBase n) -> POpts -> a -> m (TT (PP (ShowBase n) a))

type PP (ShowBase n :: Type) a

Defined in Predicate

type PP (ShowBase n :: Type) a = String

type Assocl = '(I *** Fst Id, Snd Id >> Snd Id)

type Assocr = '(Fst Id >> Fst Id, Snd Id *** I)

data Intercalate p q

Intercalate

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(Intercalate '["aB"] '["xxxx","yz","z","www","xyz"]) ()
Present ["xxxx","aB","yz","aB","z","aB","www","aB","xyz"]
PresentT ["xxxx","aB","yz","aB","z","aB","www","aB","xyz"]

Instances

(PP p x ~ [a], PP q x ~ PP p x, P p x, P q x, Show a) => P (Intercalate p q :: Type) x

Defined in Predicate

Associated Types

type PP (Intercalate p q) x :: Type

Methods

eval :: MonadEval m => Proxy (Intercalate p q) -> POpts -> x -> m (TT (PP (Intercalate p q) x))

type PP (Intercalate p q :: Type) x

Defined in Predicate

type PP (Intercalate p q :: Type) x = PP p x

getStringPrefix :: String -> (String, String)

data Printf s p

uses Printf to format output

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(Printf "value=%03d" Id) 12
Present "value=012"
PresentT "value=012"

splits string into pieces before "%" that way we have a chance of catching any errors

Instances

(PrintfArg (PP p x), Show (PP p x), PP s x ~ String, P s x, P p x) => P (Printf s p :: Type) x

Defined in Predicate

Associated Types

type PP (Printf s p) x :: Type

Methods

eval :: MonadEval m => Proxy (Printf s p) -> POpts -> x -> m (TT (PP (Printf s p) x))

type PP (Printf s p :: Type) x

Defined in Predicate

type PP (Printf s p :: Type) x = String

type family GuardsT (ps :: [k]) where ...

Equations

GuardsT '[] = '[]

GuardsT (p ': ps) = Guard' p ': GuardsT ps

type Guards' (ps :: [k]) = Para (GuardsT ps)

type ToPara (os :: [k]) = Proxy (ParaImplW True os)

type ToGuards (prt :: k) (os :: [k1]) = Proxy (Guards (ToGuardsT prt os))

type family ToGuardsT (prt :: k) (os :: [k1]) :: [(k, k1)] where ...

Equations

ToGuardsT prt '[p] = '(prt, p) ': '[]

ToGuardsT prt (p ': ps) = '(prt, p) ': ToGuardsT prt ps

data ParaImpl (n :: Nat) (strict :: Bool) (os :: [k])

runs values in parallel unlike Do

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(Para '[Id,Id + 1,Id * 4]) [10,20,30]
Present [10,21,120]
PresentT [10,21,120]

Instances

(TypeError (Text "ParaImpl '[] invalid: requires at least one value in the list") :: Constraint) => P (ParaImpl n strict ([] :: [k]) :: Type) [a]

Defined in Predicate

Associated Types

type PP (ParaImpl n strict []) [a] :: Type

Methods

eval :: MonadEval m => Proxy (ParaImpl n strict []) -> POpts -> [a] -> m (TT (PP (ParaImpl n strict []) [a]))

(KnownNat n, GetBool strict, GetLen ps, P p a, P (ParaImpl n strict (p1 ': ps)) [a], PP (ParaImpl n strict (p1 ': ps)) [a] ~ [PP p a], Show a, Show (PP p a)) => P (ParaImpl n strict (p ': (p1 ': ps)) :: Type) [a]

Defined in Predicate

Associated Types

type PP (ParaImpl n strict (p ': (p1 ': ps))) [a] :: Type

Methods

eval :: MonadEval m => Proxy (ParaImpl n strict (p ': (p1 ': ps))) -> POpts -> [a] -> m (TT (PP (ParaImpl n strict (p ': (p1 ': ps))) [a]))

(Show (PP p a), KnownNat n, GetBool strict, Show a, P p a) => P (ParaImpl n strict (p ': ([] :: [k])) :: Type) [a]

Defined in Predicate

Associated Types

type PP (ParaImpl n strict (p ': [])) [a] :: Type

Methods

eval :: MonadEval m => Proxy (ParaImpl n strict (p ': [])) -> POpts -> [a] -> m (TT (PP (ParaImpl n strict (p ': [])) [a]))

type PP (ParaImpl n strict (p ': (p1 ': ps)) :: Type) [a]

Defined in Predicate

type PP (ParaImpl n strict (p ': (p1 ': ps)) :: Type) [a] = [PP p a]

type PP (ParaImpl n strict (p ': ([] :: [k])) :: Type) [a]

Defined in Predicate

type PP (ParaImpl n strict (p ': ([] :: [k])) :: Type) [a] = [PP p a]

type PP (ParaImpl n strict ([] :: [k]) :: Type) [a]

Defined in Predicate

type PP (ParaImpl n strict ([] :: [k]) :: Type) [a] = Void

type Para (os :: [k]) = ParaImplW True os

type ParaLax (os :: [k]) = ParaImplW False os

data ParaImplW (strict :: Bool) (ps :: [k])

Instances

(GetBool strict, GetLen ps, P (ParaImpl (LenT ps) strict ps) [a]) => P (ParaImplW strict ps :: Type) [a]

Defined in Predicate

Associated Types

type PP (ParaImplW strict ps) [a] :: Type

Methods

eval :: MonadEval m => Proxy (ParaImplW strict ps) -> POpts -> [a] -> m (TT (PP (ParaImplW strict ps) [a]))

type PP (ParaImplW strict ps :: Type) [a]

Defined in Predicate

type PP (ParaImplW strict ps :: Type) [a] = PP (ParaImpl (LenT ps) strict ps) [a]

type family GuardsViaParaT prt ps where ...

Equations

GuardsViaParaT prt '[] = '[]

GuardsViaParaT prt (p ': ps) = Guard prt p ': GuardsViaParaT prt ps

type GuardsViaPara prt ps = Para (GuardsViaParaT prt ps)

data CaseImpl (n :: Nat) (e :: k0) (ps :: [k]) (qs :: [k1]) (r :: k2)

tries each predicate ps and on the first match runs the corresponding qs but if there is no match on ps then runs the fail case e

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(Case (FailS "asdf" >> (Snd Id) >> Unproxy ) '[Lt 4,Lt 10,Same 50] '[Printf "%d is lt4" Id, Printf "%d is lt10" Id, Printf "%d is same50" Id] Id) 50
Present "50 is same50"
PresentT "50 is same50"

>>> pl @(Case (FailS "asdf" >> (Snd Id) >> Unproxy ) '[Lt 4,Lt 10,Same 50] '[Printf "%d is lt4" Id, Printf "%d is lt10" Id, Printf "%d is same50" Id] Id) 9
Present "9 is lt10"
PresentT "9 is lt10"

>>> pl @(Case (FailS "asdf" >> (Snd Id) >> Unproxy ) '[Lt 4,Lt 10,Same 50] '[Printf "%d is lt4" Id, Printf "%d is lt10" Id, Printf "%d is same50" Id] Id) 3
Present "3 is lt4"
PresentT "3 is lt4"

>>> pl @(Case (FailS "asdf" >> (Snd Id) >> Unproxy ) '[Lt 4,Lt 10,Same 50] '[Printf "%d is lt4" Id, Printf "%d is lt10" Id, Printf "%d is same50" Id] Id) 99
Error asdf
FailT "asdf"

Instances

(KnownNat n, GetLen ps, P r x, P p (PP r x), P q (PP r x), PP p (PP r x) ~ Bool, Show (PP q (PP r x)), Show (PP r x), P (CaseImpl n e (p1 ': ps) (q1 ': qs) r) x, PP (CaseImpl n e (p1 ': ps) (q1 ': qs) r) x ~ PP q (PP r x)) => P (CaseImpl n e (p ': (p1 ': ps)) (q ': (q1 ': qs)) r :: Type) x

Defined in Predicate

Associated Types

type PP (CaseImpl n e (p ': (p1 ': ps)) (q ': (q1 ': qs)) r) x :: Type

Methods

eval :: MonadEval m => Proxy (CaseImpl n e (p ': (p1 ': ps)) (q ': (q1 ': qs)) r) -> POpts -> x -> m (TT (PP (CaseImpl n e (p ': (p1 ': ps)) (q ': (q1 ': qs)) r) x))

(P r x, P q (PP r x), Show (PP q (PP r x)), P p (PP r x), PP p (PP r x) ~ Bool, KnownNat n, Show (PP r x), P e (PP r x, Proxy (PP q (PP r x))), PP e (PP r x, Proxy (PP q (PP r x))) ~ PP q (PP r x)) => P (CaseImpl n e (p ': ([] :: [k])) (q ': ([] :: [k1])) r :: Type) x

Defined in Predicate

Associated Types

type PP (CaseImpl n e (p ': []) (q ': []) r) x :: Type

Methods

eval :: MonadEval m => Proxy (CaseImpl n e (p ': []) (q ': []) r) -> POpts -> x -> m (TT (PP (CaseImpl n e (p ': []) (q ': []) r) x))

(TypeError (Text "CaseImpl '[] invalid: lists are both empty") :: Constraint) => P (CaseImpl n e ([] :: [k]) ([] :: [k1]) r :: Type) x

Defined in Predicate

Associated Types

type PP (CaseImpl n e [] [] r) x :: Type

Methods

eval :: MonadEval m => Proxy (CaseImpl n e [] [] r) -> POpts -> x -> m (TT (PP (CaseImpl n e [] [] r) x))

(TypeError (Text "CaseImpl '[] invalid: rhs requires at least one value in the list") :: Constraint) => P (CaseImpl n e (p ': ps) ([] :: [k1]) r :: Type) x

Defined in Predicate

Associated Types

type PP (CaseImpl n e (p ': ps) [] r) x :: Type

Methods

eval :: MonadEval m => Proxy (CaseImpl n e (p ': ps) [] r) -> POpts -> x -> m (TT (PP (CaseImpl n e (p ': ps) [] r) x))

(TypeError (Text "CaseImpl '[] invalid: lhs requires at least one value in the list") :: Constraint) => P (CaseImpl n e ([] :: [k]) (q ': qs) r :: Type) x

Defined in Predicate

Associated Types

type PP (CaseImpl n e [] (q ': qs) r) x :: Type

Methods

eval :: MonadEval m => Proxy (CaseImpl n e [] (q ': qs) r) -> POpts -> x -> m (TT (PP (CaseImpl n e [] (q ': qs) r) x))

type PP (CaseImpl n e (p ': (p1 ': ps)) (q ': (q1 ': qs)) r :: Type) x

Defined in Predicate

type PP (CaseImpl n e (p ': (p1 ': ps)) (q ': (q1 ': qs)) r :: Type) x = PP q (PP r x)

type PP (CaseImpl n e (p ': ([] :: [k])) (q ': ([] :: [k1])) r :: Type) x

Defined in Predicate

type PP (CaseImpl n e (p ': ([] :: [k])) (q ': ([] :: [k1])) r :: Type) x = PP q (PP r x)

type PP (CaseImpl n e ([] :: [k]) ([] :: [k1]) r :: Type) x

Defined in Predicate

type PP (CaseImpl n e ([] :: [k]) ([] :: [k1]) r :: Type) x = Void

type PP (CaseImpl n e (p ': ps) ([] :: [k1]) r :: Type) x

Defined in Predicate

type PP (CaseImpl n e (p ': ps) ([] :: [k1]) r :: Type) x = Void

type PP (CaseImpl n e ([] :: [k]) (q ': qs) r :: Type) x

Defined in Predicate

type PP (CaseImpl n e ([] :: [k]) (q ': qs) r :: Type) x = Void

data Case (e :: k0) (ps :: [k]) (qs :: [k1]) (r :: k2)

Instances

(FailIfT (NotT (LenT ps == LenT qs)) (((Text "lengths are not the same " :<>: ShowType (LenT ps)) :<>: Text " vs ") :<>: ShowType (LenT qs)), P (CaseImpl (LenT ps) e ps qs r) x) => P (Case e ps qs r :: Type) x

Defined in Predicate

Associated Types

type PP (Case e ps qs r) x :: Type

Methods

eval :: MonadEval m => Proxy (Case e ps qs r) -> POpts -> x -> m (TT (PP (Case e ps qs r) x))

type PP (Case e ps qs r :: Type) x

Defined in Predicate

type PP (Case e ps qs r :: Type) x = PP (CaseImpl (LenT ps) e ps qs r) x

type Case' (ps :: [k]) (qs :: [k1]) (r :: k2) = Case (Snd Id >> Failp "Case:no match") ps qs r

type Case'' s (ps :: [k]) (qs :: [k1]) (r :: k2) = Case (FailCase s) ps qs r

type FailCase p = Fail (Snd Id >> Unproxy) (Fst Id >> p)

data Sequence

similar to sequenceA

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @Sequence [Just 10, Just 20, Just 30]
Present Just [10,20,30]
PresentT (Just [10,20,30])

>>> pl @Sequence [Just 10, Just 20, Just 30, Nothing, Just 40]
Present Nothing
PresentT Nothing

Instances

(Show (f (t a)), Show (t (f a)), Traversable t, Applicative f) => P Sequence (t (f a))

Defined in Predicate

Associated Types

type PP Sequence (t (f a)) :: Type

Methods

eval :: MonadEval m => Proxy Sequence -> POpts -> t (f a) -> m (TT (PP Sequence (t (f a))))

type PP Sequence (t (f a))

Defined in Predicate

type PP Sequence (t (f a)) = f (t a)

type Traverse p q = Map p q >> Sequence

data Hide p

Instances

P p x => P (Hide p :: Type) x

Defined in Predicate

Associated Types

type PP (Hide p) x :: Type

Methods

eval :: MonadEval m => Proxy (Hide p) -> POpts -> x -> m (TT (PP (Hide p) x))

type PP (Hide p :: Type) x

Defined in Predicate

type PP (Hide p :: Type) x = PP p x

type H = Hide

data ReadFile p

similar to readFile

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(ReadFile ".ghci" >> 'Just Id >> Len >> Gt 0) ()
True
TrueT

>>> pl @(FileExists "xyzzy") ()
False
FalseT

Instances

(PP p x ~ String, P p x) => P (ReadFile p :: Type) x

Defined in Predicate

Associated Types

type PP (ReadFile p) x :: Type

Methods

eval :: MonadEval m => Proxy (ReadFile p) -> POpts -> x -> m (TT (PP (ReadFile p) x))

type PP (ReadFile p :: Type) x

Defined in Predicate

type PP (ReadFile p :: Type) x = Maybe String

type FileExists p = ReadFile p >> IsJust

data ReadDir p

does the directory exists

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(DirExists ".") ()
True
TrueT

Instances

(PP p x ~ String, P p x) => P (ReadDir p :: Type) x

Defined in Predicate

Associated Types

type PP (ReadDir p) x :: Type

Methods

eval :: MonadEval m => Proxy (ReadDir p) -> POpts -> x -> m (TT (PP (ReadDir p) x))

type PP (ReadDir p :: Type) x

Defined in Predicate

type PP (ReadDir p :: Type) x = Maybe [FilePath]

type DirExists p = ReadDir p >> IsJust

data ReadEnv p

does the directory exists

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(DirExists ".") ()
True
TrueT

Instances

(PP p x ~ String, P p x) => P (ReadEnv p :: Type) x

Defined in Predicate

Associated Types

type PP (ReadEnv p) x :: Type

Methods

eval :: MonadEval m => Proxy (ReadEnv p) -> POpts -> x -> m (TT (PP (ReadEnv p) x))

type PP (ReadEnv p :: Type) x

Defined in Predicate

type PP (ReadEnv p :: Type) x = Maybe String

data ReadEnvAll

Instances

P ReadEnvAll a

Defined in Predicate

Associated Types

type PP ReadEnvAll a :: Type

Methods

eval :: MonadEval m => Proxy ReadEnvAll -> POpts -> a -> m (TT (PP ReadEnvAll a))

type PP ReadEnvAll a

Defined in Predicate

type PP ReadEnvAll a = [(String, String)]

data TimeU

Instances

P TimeU a

Defined in Predicate

Associated Types

type PP TimeU a :: Type

Methods

eval :: MonadEval m => Proxy TimeU -> POpts -> a -> m (TT (PP TimeU a))

type PP TimeU a

Defined in Predicate

type PP TimeU a = UTCTime

data TimeZ

Instances

P TimeZ a

Defined in Predicate

Associated Types

type PP TimeZ a :: Type

Methods

eval :: MonadEval m => Proxy TimeZ -> POpts -> a -> m (TT (PP TimeZ a))

type PP TimeZ a

Defined in Predicate

type PP TimeZ a = ZonedTime

data FHandle s

Constructors

FStdout

FStderr

FOther s WFMode

Instances

Show s => Show (FHandle s)

Defined in Predicate

Methods

showsPrec :: Int -> FHandle s -> ShowS

show :: FHandle s -> String

showList :: [FHandle s] -> ShowS

class GetFHandle (x :: FHandle Symbol) where

Methods

getFHandle :: FHandle String

Instances

GetFHandle (FStdout :: FHandle Symbol)

Defined in Predicate

Methods

getFHandle :: FHandle String

GetFHandle (FStderr :: FHandle Symbol)

Defined in Predicate

Methods

getFHandle :: FHandle String

(GetMode w, KnownSymbol s) => GetFHandle (FOther s w)

Defined in Predicate

Methods

getFHandle :: FHandle String

data WFMode

Constructors

WFAppend

WFWrite

WFWriteForce

Instances

Eq WFMode

Defined in Predicate

Methods

(==) :: WFMode -> WFMode -> Bool

(/=) :: WFMode -> WFMode -> Bool

Show WFMode

Defined in Predicate

Methods

showsPrec :: Int -> WFMode -> ShowS

show :: WFMode -> String

showList :: [WFMode] -> ShowS

class GetMode (x :: WFMode) where

Methods

getMode :: WFMode

Instances

GetMode WFAppend

Defined in Predicate

Methods

getMode :: WFMode

GetMode WFWrite

Defined in Predicate

Methods

getMode :: WFMode

GetMode WFWriteForce

Defined in Predicate

Methods

getMode :: WFMode

data WritefileImpl (hh :: FHandle Symbol) p

Instances

(GetFHandle fh, P p a, PP p a ~ String) => P (WritefileImpl fh p :: Type) a

Defined in Predicate

Associated Types

type PP (WritefileImpl fh p) a :: Type

Methods

eval :: MonadEval m => Proxy (WritefileImpl fh p) -> POpts -> a -> m (TT (PP (WritefileImpl fh p) a))

type PP (WritefileImpl fh p :: Type) a

Defined in Predicate

type PP (WritefileImpl fh p :: Type) a = ()

type Appendfile (s :: Symbol) p = WritefileImpl (FOther s WFAppend) p

type Writefile' (s :: Symbol) p = WritefileImpl (FOther s WFWriteForce) p

type Writefile (s :: Symbol) p = WritefileImpl (FOther s WFWrite) p

type Stdout p = WritefileImpl FStdout p

type Stderr p = WritefileImpl FStderr p

data Stdin

Instances

P Stdin a

Defined in Predicate

Associated Types

type PP Stdin a :: Type

Methods

eval :: MonadEval m => Proxy Stdin -> POpts -> a -> m (TT (PP Stdin a))

type PP Stdin a

Defined in Predicate

type PP Stdin a = String

type Nothing' = Guard "expected Nothing" IsNothing

data IsFixImpl (cmp :: Ordering) (ignore :: Bool) p q

isInfixOf isPrefixOf isSuffixOf equivalents

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(IsInfixI "abc" "axAbCd") ()
True
TrueT

>>> pl @(IsPrefixI "abc" "aBcbCd") ()
True
TrueT

>>> pl @(IsPrefix "abc" "aBcbCd") ()
False
FalseT

>>> pl @(IsSuffix "bCd" "aBcbCd") ()
True
TrueT

prefix infix suffix for strings

Instances

(GetBool ignore, P p x, P q x, PP p x ~ String, PP q x ~ String, GetOrdering cmp) => P (IsFixImpl cmp ignore p q :: Type) x

Defined in Predicate

Associated Types

type PP (IsFixImpl cmp ignore p q) x :: Type

Methods

eval :: MonadEval m => Proxy (IsFixImpl cmp ignore p q) -> POpts -> x -> m (TT (PP (IsFixImpl cmp ignore p q) x))

type PP (IsFixImpl cmp ignore p q :: Type) x

Defined in Predicate

type PP (IsFixImpl cmp ignore p q :: Type) x = Bool

type IsPrefix p q = IsFixImpl LT False p q

type IsInfix p q = IsFixImpl EQ False p q

type IsSuffix p q = IsFixImpl GT False p q

type IsPrefixI p q = IsFixImpl LT True p q

type IsInfixI p q = IsFixImpl EQ True p q

type IsSuffixI p q = IsFixImpl GT True p q

data p <> q infixr 6

similar to <>

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(Fst Id <> (Snd Id)) ("abc","def")
Present "abcdef"
PresentT "abcdef"

Instances

(Semigroup (PP p x), PP p x ~ PP q x, P p x, Show (PP q x), P q x) => P (p <> q :: Type) x

Defined in Predicate

Associated Types

type PP (p <> q) x :: Type

Methods

eval :: MonadEval m => Proxy (p <> q) -> POpts -> x -> m (TT (PP (p <> q) x))

type PP (p <> q :: Type) x

Defined in Predicate

type PP (p <> q :: Type) x = PP p x

type Sapa' (t :: Type) = Wrap t (Fst Id) <> Wrap t (Snd Id)

type Sapa = Fst Id <> Snd Id

runPQ :: (P p a, P q a, MonadEval m) => String -> Proxy p -> Proxy q -> POpts -> a -> m (Either (TT x) (PP p a, PP q a, TT (PP p a), TT (PP q a)))

class PrintC x where

Methods

prtC :: (PrintfArg a, PrintfType r) => String -> (a, x) -> r

Instances

PrintC ()

Defined in Predicate

Methods

prtC :: (PrintfArg a, PrintfType r) => String -> (a, ()) -> r

(PrintfArg a, PrintC rs) => PrintC (a, rs)

Defined in Predicate

Methods

prtC :: (PrintfArg a0, PrintfType r) => String -> (a0, (a, rs)) -> r

data TupleListImpl (strict :: Bool) (n :: Nat)

Instances

(Show a, KnownNat n, GetBool strict, TupleListD (ToN n) a, Show (TupleListT (ToN n) a)) => P (TupleListImpl strict n :: Type) [a]

Defined in Predicate

Associated Types

type PP (TupleListImpl strict n) [a] :: Type

Methods

eval :: MonadEval m => Proxy (TupleListImpl strict n) -> POpts -> [a] -> m (TT (PP (TupleListImpl strict n) [a]))

type PP (TupleListImpl strict n :: Type) [a]

Defined in Predicate

type PP (TupleListImpl strict n :: Type) [a] = TupleListT (ToN n) a

type TupleList (n :: Nat) = TupleListImpl True n

type TupleListLax (n :: Nat) = TupleListImpl False n

data ReverseTupleN

Instances

(ReverseTupleC tp, Show (ReverseTupleP tp), Show tp) => P ReverseTupleN tp

Defined in Predicate

Associated Types

type PP ReverseTupleN tp :: Type

Methods

eval :: MonadEval m => Proxy ReverseTupleN -> POpts -> tp -> m (TT (PP ReverseTupleN tp))

type PP ReverseTupleN tp

Defined in Predicate

type PP ReverseTupleN tp = ReverseTupleP tp

data Printfn s p

Printfn prints

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(Printfn "%s %s" Id) ("123",("def",()))
Present "123 def"
PresentT "123 def"

>>> pl @(Printfn "s=%s d=%03d" Id) ("ab",(123,()))
Present "s=ab d=123"
PresentT "s=ab d=123"

Instances

(KnownNat (TupleLenT as), PrintC bs, (b, bs) ~ ReverseTupleP (a, as), ReverseTupleC (a, as), Show a, Show as, PrintfArg b, PP s x ~ String, PP p x ~ (a, as), P s x, P p x, CheckT (PP p x) ~ True) => P (Printfn s p :: Type) x

Defined in Predicate

Associated Types

type PP (Printfn s p) x :: Type

Methods

eval :: MonadEval m => Proxy (Printfn s p) -> POpts -> x -> m (TT (PP (Printfn s p) x))

type PP (Printfn s p :: Type) x

Defined in Predicate

type PP (Printfn s p :: Type) x = String

type Printfnt (n :: Nat) s = Printfn s (TupleList n)

type PrintfntLax (n :: Nat) s = Printfn s (TupleListLax n)

type Printf2 (s :: Symbol) = Printfn s '(Fst Id, '(Snd Id, ()))

type Printf3 (s :: Symbol) = Printfn s '(Fst Id, '(Snd Id >> Fst Id, '(Snd Id >> Snd Id, ())))

type Printf3' (s :: Symbol) = Printfn s (TupleI '[Fst Id, Snd Id >> Fst Id, Snd Id >> Snd Id])

type family CheckT (tp :: Type) :: Bool where ...

Equations

CheckT () = TypeError (Text "Printfn: inductive tuple cannot be empty")

CheckT o = True

type family ApplyConstT (ta :: Type) (b :: Type) :: Type where ...

Equations

ApplyConstT (t a) b = t b

ApplyConstT ta b = TypeError ((Text "ApplyConstT: (t a) b but found something else" :$$: (Text "t a = " :<>: ShowType ta)) :$$: (Text "b = " :<>: ShowType b))

data p <$ q infixl 4

similar to <$

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(Fst Id <$ (Snd Id)) ("abc",Just 20)
Present Just "abc"
PresentT (Just "abc")

Instances

(P p x, P q x, Show (PP p x), Functor t, PP q x ~ t c, ApplyConstT (PP q x) (PP p x) ~ t (PP p x)) => P (p <$ q :: Type) x

Defined in Predicate

Associated Types

type PP (p <$ q) x :: Type

Methods

eval :: MonadEval m => Proxy (p <$ q) -> POpts -> x -> m (TT (PP (p <$ q) x))

type PP (p <$ q :: Type) x

Defined in Predicate

type PP (p <$ q :: Type) x = ApplyConstT (PP q x) (PP p x)

data p <* q infixl 4

Instances

(Show (t c), P p x, P q x, Show (t b), Applicative t, t b ~ PP p x, PP q x ~ t c) => P (p <* q :: Type) x

Defined in Predicate

Associated Types

type PP (p <* q) x :: Type

Methods

eval :: MonadEval m => Proxy (p <* q) -> POpts -> x -> m (TT (PP (p <* q) x))

type PP (p <* q :: Type) x

Defined in Predicate

type PP (p <* q :: Type) x = PP p x

type (*>) p q = q <* p infixl 4

similar to <*

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(Fst Id <* (Snd Id)) (Just "abc",Just 20)
Present Just "abc"
PresentT (Just "abc")

data p <|> q infixl 3

similar to <|>

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(Fst Id <|> (Snd Id)) (Nothing,Just 20)
Present Just 20
PresentT (Just 20)

>>> pl @(Fst Id <|> (Snd Id)) (Just 10,Just 20)
Present Just 10
PresentT (Just 10)

>>> pl @(Fst Id <|> (Snd Id)) (Nothing,Nothing)
Present Nothing
PresentT Nothing

Instances

(P p x, P q x, Show (t b), Alternative t, t b ~ PP p x, PP q x ~ t b) => P (p <|> q :: Type) x

Defined in Predicate

Associated Types

type PP (p <|> q) x :: Type

Methods

eval :: MonadEval m => Proxy (p <|> q) -> POpts -> x -> m (TT (PP (p <|> q) x))

type PP (p <|> q :: Type) x

Defined in Predicate

type PP (p <|> q :: Type) x = PP p x

data Extract

similar to extract

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @Extract (Nothing,Just 20)
Present Just 20
PresentT (Just 20)

>>> pl @Extract (Identity 20)
Present 20
PresentT 20

Instances

(Show (t a), Show a, Comonad t) => P Extract (t a)

Defined in Predicate

Associated Types

type PP Extract (t a) :: Type

Methods

eval :: MonadEval m => Proxy Extract -> POpts -> t a -> m (TT (PP Extract (t a)))

type PP Extract (t a)

Defined in Predicate

type PP Extract (t a) = a

data Duplicate

similar to duplicate

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @Duplicate (20,"abc")
Present (20,(20,"abc"))
PresentT (20,(20,"abc"))

Instances

(Show (t a), Show (t (t a)), Comonad t) => P Duplicate (t a)

Defined in Predicate

Associated Types

type PP Duplicate (t a) :: Type

Methods

eval :: MonadEval m => Proxy Duplicate -> POpts -> t a -> m (TT (PP Duplicate (t a)))

type PP Duplicate (t a)

Defined in Predicate

type PP Duplicate (t a) = t (t a)

data Join

similar to join

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @Join  (Just (Just 20))
Present Just 20
PresentT (Just 20)

Instances

(Show (t (t a)), Show (t a), Monad t) => P Join (t (t a))

Defined in Predicate

Associated Types

type PP Join (t (t a)) :: Type

Methods

eval :: MonadEval m => Proxy Join -> POpts -> t (t a) -> m (TT (PP Join (t (t a))))

type PP Join (t (t a))

Defined in Predicate

type PP Join (t (t a)) = t a

data p $ q infixl 0

Instances

(P p x, P q x, PP p x ~ (a -> b), FnT (PP p x) ~ b, PP q x ~ a, Show a, Show b) => P (p $ q :: Type) x

Defined in Predicate

Associated Types

type PP (p $ q) x :: Type

Methods

eval :: MonadEval m => Proxy (p $ q) -> POpts -> x -> m (TT (PP (p $ q) x))

type PP (p $ q :: Type) x

Defined in Predicate

type PP (p $ q :: Type) x = FnT (PP p x)

type (&) p q = q $ p infixr 1

type family FnT ab :: Type where ...

Equations

FnT (a -> b) = b

FnT ab = TypeError (Text "FnT: expected Type -> Type but found a simple Type?" :$$: (Text "ab = " :<>: ShowType ab))

evalQuick :: forall p i. P p i => i -> Either String (PP p i)

data Trim' (left :: Bool) (right :: Bool) p

similar to strip stripStart stripEnd

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(Trim (Snd Id)) (20," abc   " :: String)
Present "abc"
PresentT "abc"

>>> import Data.Text (Text)
>>> pl @(Trim (Snd Id)) (20," abc   " :: Text)
Present "abc"
PresentT "abc"

>>> pl @(TrimStart (Snd Id)) (20," abc   ")
Present "abc   "
PresentT "abc   "

>>> pl @(TrimEnd (Snd Id)) (20," abc   ")
Present " abc"
PresentT " abc"

>>> pl @(TrimEnd "  abc ") ()
Present "  abc"
PresentT "  abc"

>>> pl @(TrimEnd "") ()
Present ""
PresentT ""

>>> pl @(Trim "         ") ()
Present ""
PresentT ""

>>> pl @(Trim "") ()
Present ""
PresentT ""

Instances

(FailIfT (NotT (OrT l r)) (Text "Trim': left and right cannot both be False"), GetBool l, GetBool r, IsText (PP p x), P p x) => P (Trim' l r p :: Type) x

Defined in Predicate

Associated Types

type PP (Trim' l r p) x :: Type

Methods

eval :: MonadEval m => Proxy (Trim' l r p) -> POpts -> x -> m (TT (PP (Trim' l r p) x))

type PP (Trim' l r p :: Type) x

Defined in Predicate

type PP (Trim' l r p :: Type) x = PP p x

type Trim p = Trim' True True p

type TrimStart p = Trim' True False p

type TrimEnd p = Trim' False True p

data StripLR (right :: Bool) p q

similar to stripLeft stripRight

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(StripLeft "xyz" Id) ("xyzHello" :: String)
Present Just "Hello"
PresentT (Just "Hello")

>>> import Data.Text (Text)
>>> pl @(StripLeft "xyz" Id) ("xyzHello" :: Text)
Present Just "Hello"
PresentT (Just "Hello")

>>> pl @(StripLeft "xyz" Id) "xywHello"
Present Nothing
PresentT Nothing

>>> pl @(StripRight "xyz" Id) "Hello xyz"
Present Just "Hello "
PresentT (Just "Hello ")

>>> pl @(StripRight "xyz" Id) "xyzHelloxyw"
Present Nothing
PresentT Nothing

>>> pl @(StripRight "xyz" Id) ""
Present Nothing
PresentT Nothing

>>> pl @(StripRight "xyz" "xyz") ()
Present Just ""
PresentT (Just "")

Instances

(GetBool r, PP p x ~ String, P p x, IsText (PP q x), P q x) => P (StripLR r p q :: Type) x

Defined in Predicate

Associated Types

type PP (StripLR r p q) x :: Type

Methods

eval :: MonadEval m => Proxy (StripLR r p q) -> POpts -> x -> m (TT (PP (StripLR r p q) x))

type PP (StripLR r p q :: Type) x

Defined in Predicate

type PP (StripLR r p q :: Type) x = Maybe (PP q x)

type StripRight p q = StripLR True p q

type StripLeft p q = StripLR False p q

data ParaImplN (strict :: Bool) (n :: Nat) p

leverages Para for repeating predicates (passthrough method)

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(ParaImplN 'True 4 (Succ Id)) [1..4]
Present [2,3,4,5]
PresentT [2,3,4,5]

>>> pl @(ParaLaxN 4 (Succ Id)) "azwxm"
Present "b{xy"
PresentT "b{xy"

>>> pl @(ParaN 4 (Succ Id)) "azwxm"
Error Para: data elements(5) /= predicates(4)
FailT "Para: data elements(5) /= predicates(4)"

>>> pl @(ParaN 4 (Succ Id)) "azwx"
Present "b{xy"
PresentT "b{xy"

Instances

(P (ParaImpl (LenT (RepeatT n p)) strict (RepeatT n p)) [a], GetLen (RepeatT n p), GetBool strict) => P (ParaImplN strict n p :: Type) [a]

Defined in Predicate

Associated Types

type PP (ParaImplN strict n p) [a] :: Type

Methods

eval :: MonadEval m => Proxy (ParaImplN strict n p) -> POpts -> [a] -> m (TT (PP (ParaImplN strict n p) [a]))

type PP (ParaImplN strict n p :: Type) [a]

Defined in Predicate

type PP (ParaImplN strict n p :: Type) [a] = PP (ParaImplW strict (RepeatT n p)) [a]

type ParaN (n :: Nat) p = ParaImplN True n p

type ParaLaxN (n :: Nat) p = ParaImplN False n p

data GuardsImplN (strict :: Bool) prt (n :: Nat) p

leverages GuardsQuick for repeating predicates (passthrough method)

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(GuardsN (Printf2 "id=%d must be between 0 and 255, found %d") 4 (Between 0 255)) [121,33,7,256]
Error id=4 must be between 0 and 255, found 256
FailT "id=4 must be between 0 and 255, found 256"

>>> pl @(GuardsN (Printf2 "id=%d must be between 0 and 255, found %d") 4 (Between 0 255)) [121,33,7,44]
Present [121,33,7,44]
PresentT [121,33,7,44]

Instances

(GetBool strict, GetLen (ToGuardsT prt (RepeatT n p)), P (GuardsImpl (LenT (ToGuardsT prt (RepeatT n p))) strict (ToGuardsT prt (RepeatT n p))) [a]) => P (GuardsImplN strict prt n p :: Type) [a]

Defined in Predicate

Associated Types

type PP (GuardsImplN strict prt n p) [a] :: Type

Methods

eval :: MonadEval m => Proxy (GuardsImplN strict prt n p) -> POpts -> [a] -> m (TT (PP (GuardsImplN strict prt n p) [a]))

type PP (GuardsImplN strict prt n p :: Type) [a]

Defined in Predicate

type PP (GuardsImplN strict prt n p :: Type) [a] = PP (GuardsImplW strict (ToGuardsT prt (RepeatT n p))) [a]

type GuardsN prt (n :: Nat) p = GuardsImplN True prt n p

type GuardsLaxN prt (n :: Nat) p = GuardsImplN False prt n p

data Repeat (n :: Nat) p

creates a promoted list of predicates and then evaluates them into a list. see PP instance for '[k]

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(Repeat 4 (Succ Id)) 'c'
Present "dddd"
PresentT "dddd"

>>> pl @(Repeat 4 "abc") ()
Present ["abc","abc","abc","abc"]
PresentT ["abc","abc","abc","abc"]

Instances

P (RepeatT n p) a => P (Repeat n p :: Type) a

Defined in Predicate

Associated Types

type PP (Repeat n p) a :: Type

Methods

eval :: MonadEval m => Proxy (Repeat n p) -> POpts -> a -> m (TT (PP (Repeat n p) a))

type PP (Repeat n p :: Type) a

Defined in Predicate

type PP (Repeat n p :: Type) a = PP (RepeatT n p) a

data DoN (n :: Nat) p

leverages Do for repeating predicates (passthrough method) same as 'DoN n p' == 'FoldN n p Id' but more efficient

>>> :set -XTypeApplications
>>> :set -XDataKinds
>>> pl @(DoN 4 (Succ Id)) 'c'
Present 'g'
PresentT 'g'

>>> pl @(DoN 4 (Id <> " | ")) "abc"
Present "abc |  |  |  | "
PresentT "abc |  |  |  | "

>>> pl @(DoN 4 (Id <> "|" <> Id)) "abc"
Present "abc|abc|abc|abc|abc|abc|abc|abc|abc|abc|abc|abc|abc|abc|abc|abc"
PresentT "abc|abc|abc|abc|abc|abc|abc|abc|abc|abc|abc|abc|abc|abc|abc|abc"

Instances

P (DoExpandT (RepeatT n p)) a => P (DoN n p :: Type) a

Defined in Predicate

Associated Types

type PP (DoN n p) a :: Type

Methods

eval :: MonadEval m => Proxy (DoN n p) -> POpts -> a -> m (TT (PP (DoN n p) a))

type PP (DoN n p :: Type) a

Defined in Predicate

type PP (DoN n p :: Type) a = PP (Do (RepeatT n p)) a