Safe Haskell | None |
---|---|
Language | Haskell2010 |
Dsl for evaluating and displaying type level expressions
Synopsis
- data I
- data Id
- data IdT
- data W (p :: k)
- data Msg prt p
- pe :: 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))
- pe2n :: 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))
- pun :: 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))
- pz :: forall p a. (Show (PP p a), P p a) => a -> IO (BoolT (PP p a))
- class P p a where
- runPQ :: (P p a, P q a, MonadEval m) => String -> Proxy p -> Proxy q -> POpts -> a -> [Holder] -> m (Either (TT x) (PP p a, PP q a, TT (PP p a), TT (PP q a)))
- runPQBool :: (P p a, PP p a ~ Bool, P q a, PP q a ~ Bool, MonadEval m) => String -> Proxy p -> Proxy q -> POpts -> a -> [Holder] -> m (Either (TT x) (PP p a, PP q a, TT (PP p a), TT (PP q a)))
- evalBool :: (MonadEval m, P p a, PP p a ~ Bool) => Proxy p -> POpts -> a -> m (TT (PP p a))
- evalQuick :: forall p i. P p i => i -> Either String (PP p i)
basic types
identity function
>>>
pz @I 23
Present 23 PresentT 23
identity function that also displays the type information for debugging
>>>
pz @IdT 23
Present 23 PresentT 23
add a message to give more context to the evaluation tree
>>>
pe @(Msg "[somemessage] " Id) 999
P [somemessage] Id 999 PresentT 999
>>>
pe @(Msg Id 999) "info message:"
P info message:'999 PresentT 999
display evaluation tree
pe :: forall p a. (Show (PP p a), P p a) => a -> IO (BoolT (PP p a)) Source #
displays the evaluation tree in plain text without colors
pe2 :: forall p a. (Show (PP p a), P p a) => a -> IO (BoolT (PP p a)) Source #
displays the evaluation tree using colors
pu :: forall p a. (Show (PP p a), P p a) => a -> IO (BoolT (PP p a)) Source #
display the evaluation tree using unicode and colors
pu
'(Id, "abc", 123) [1..4]
@
pe3 :: forall p a. (Show (PP p a), P p a) => a -> IO (BoolT (PP p a)) Source #
same as pe2
but allows for wider data
pl :: forall p a. (Show (PP p a), P p a) => a -> IO (BoolT (PP p a)) Source #
same as pz
but adds context to the end result
plc :: forall p a. (Show (PP p a), P p a) => a -> IO (BoolT (PP p a)) Source #
same as pz
but with colors
pz :: forall p a. (Show (PP p a), P p a) => a -> IO (BoolT (PP p a)) Source #
skips the evaluation tree and just displays the end result
P class
This is the core class. Each instance of this class can be combined into a dsl using >>
Instances
GetBool b => P (b :: Bool) a Source # | pulls the type level
|
GetOrdering cmp => P (cmp :: Ordering) a Source # | extracts the value level representation of the promoted
|
KnownNat n => P (n :: Nat) a Source # | extracts the value level representation of the type level
|
KnownSymbol s => P (s :: Symbol) a Source # | pulls the type level
|
P () a Source # | extracts the value level representation of the type level '()
|
P () a Source # |
|
(Typeable a, Show a) => P IdT a Source # | |
Show a => P Id a Source # | |
P I a Source # | |
P SapaT x => P Sapa x Source # | |
P Stdin x Source # | |
P TimeZt a Source # | |
P TimeUtc a Source # | |
P ReadEnvAll a Source # | |
Defined in Predicate.Prelude type PP ReadEnvAll a :: Type Source # eval :: MonadEval m => Proxy ReadEnvAll -> POpts -> a -> m (TT (PP ReadEnvAll a)) Source # | |
(Show l, IsList l, Show (Item l)) => P ToListExt l Source # | |
P OddT x => P Odd x Source # | |
P EvenT x => P Even x Source # | |
P ThesesT x => P Theses x Source # | |
P ThatsT x => P Thats x Source # | |
P ThissT x => P Thiss x Source # | |
P NullT a => P Null a Source # | |
(Show as, AsEmpty as) => P IsEmpty as Source # | |
(Show (ConsT s), Show s, Snoc s s (ConsT s) (ConsT s)) => P Unsnoc s Source # | |
(Show (ConsT s), Show s, Cons s s (ConsT s) (ConsT s)) => P Uncons s Source # | |
P MEmptyPT x => P MEmptyP x Source # | |
(Show t, Reversing t) => P ReverseL t Source # | |
(Show a, as ~ [a]) => P Reverse as Source # | |
Show x => P Dup x Source # | |
Show a => P MkProxy a Source # | |
(Show a, as ~ [a]) => P Len as Source # | |
P MkDayT x => P MkDay x Source # | |
(Show a, IsText a) => P ToUpper a Source # | |
(Show a, IsText a) => P ToLower a Source # | |
P IsLatin1T x => P IsLatin1 x Source # | |
P IsSeparatorT x => P IsSeparator x Source # | |
Defined in Predicate.Prelude type PP IsSeparator x :: Type Source # eval :: MonadEval m => Proxy IsSeparator -> POpts -> x -> m (TT (PP IsSeparator x)) Source # | |
P IsOctDigitT x => P IsOctDigit x Source # | |
Defined in Predicate.Prelude type PP IsOctDigit x :: Type Source # eval :: MonadEval m => Proxy IsOctDigit -> POpts -> x -> m (TT (PP IsOctDigit x)) Source # | |
P IsHexDigitT x => P IsHexDigit x Source # | |
Defined in Predicate.Prelude type PP IsHexDigit x :: Type Source # eval :: MonadEval m => Proxy IsHexDigit -> POpts -> x -> m (TT (PP IsHexDigit x)) Source # | |
P IsControlT x => P IsControl x Source # | |
P IsPunctuationT x => P IsPunctuation x Source # | |
Defined in Predicate.Prelude type PP IsPunctuation x :: Type Source # eval :: MonadEval m => Proxy IsPunctuation -> POpts -> x -> m (TT (PP IsPunctuation x)) Source # | |
P IsSpaceT x => P IsSpace x Source # | |
P IsNumberT x => P IsNumber x Source # | |
P IsUpperT x => P IsUpper x Source # | |
P IsLowerT x => P IsLower x Source # | |
P Unzip3T x => P Unzip3 x Source # | |
P UnzipT x => P Unzip x Source # | |
P AllNegativeT x => P AllNegative x Source # | |
Defined in Predicate.Prelude type PP AllNegative x :: Type Source # eval :: MonadEval m => Proxy AllNegative -> POpts -> x -> m (TT (PP AllNegative x)) Source # | |
P AllPositiveT x => P AllPositive x Source # | |
Defined in Predicate.Prelude type PP AllPositive x :: Type Source # eval :: MonadEval m => Proxy AllPositive -> POpts -> x -> m (TT (PP AllPositive x)) Source # | |
P DescT' x => P Desc' x Source # | |
P DescT x => P Desc x Source # | |
P AscT' x => P Asc' x Source # | |
P AscT x => P Asc x Source # | |
(Show (t (t a)), Show (t a), Monad t) => P Join (t (t a)) Source # | |
(Show (t a), Show (t (t a)), Comonad t) => P Duplicate (t a) Source # | |
(Show (t a), Show a, Comonad t) => P Extract (t a) Source # | |
(Show (f (t a)), Show (t (f a)), Traversable t, Applicative f) => P Sequence (t (f a)) Source # | |
(Show (t a), Foldable t, Show a) => P ToList (t a) Source # | |
Show a => P Pairs [a] Source # | |
(Show a, Show b) => P PartitionThese [These a b] Source # | |
Defined in Predicate.Prelude | |
(Show a, Show b) => P PartitionEithers [Either a b] Source # | |
Defined in Predicate.Prelude | |
Functor f => P FMapSnd (f (x, a)) Source # | |
Functor f => P FMapFst (f (a, x)) Source # | |
(Ord a, Show a) => P Max [a] Source # | |
(Ord a, Show a) => P Min [a] Source # | |
(Num a, Show a) => P Sum [a] Source # | |
Show a => P Tails [a] Source # | |
Show a => P Inits [a] Source # | |
Typeable a => P Unproxy (Proxy a) Source # | |
(Show (p (p a b) c), Show (p a (p b c)), AssocC p) => P Unassoc (p a (p b c)) Source # | |
(Show (p (p a b) c), Show (p a (p b c)), AssocC p) => P Assoc (p (p a b) c) Source # | |
(Show (p a b), SwapC p, Show (p b a)) => P Swap (p a b) Source # | |
P ([] :: [k]) a Source # | extracts the value level representation of the type level '[]
|
P (SapaT' t) x => P (Sapa' t :: Type) x Source # | |
(KnownSymbol s, CmpSymbol s "" ~ GT) => P (Char1 s :: Type) a Source # | |
P (EmptyList t :: Type) x Source # | |
(Show l, IsList l, l ~ l') => P (FromListExt l' :: Type) l Source # | |
Defined in Predicate.Prelude type PP (FromListExt l') l :: Type Source # eval :: MonadEval m => Proxy (FromListExt l') -> POpts -> l -> m (TT (PP (FromListExt l') l)) Source # | |
Typeable t => P (Hole t :: Type) a Source # | 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 |
P (IxT' n) x => P (Ix' n :: Type) x Source # | |
P (ProxyT t :: Type) x Source # | |
P (MkNothing t :: Type) x Source # | |
P (MEmptyTT t) x => P (MEmptyT t :: Type) x Source # | |
P (ToEnumBFailT t) x => P (ToEnumBFail t :: Type) x Source # | |
Defined in Predicate.Prelude type PP (ToEnumBFail t) x :: Type Source # eval :: MonadEval m => Proxy (ToEnumBFail t) -> POpts -> x -> m (TT (PP (ToEnumBFail t) x)) Source # | |
P (MEmpty2T t) x => P (MEmpty2 t :: Type) x Source # | |
P (Nothing :: Maybe a1) (Maybe a2) Source # | expects Nothing otherwise it fails if the value is Nothing then it returns 'Proxy a' as this provides more information than '()'
|
(a ~ Item t, Show t, IsList t) => P (FromList t :: Type) [a] Source # | |
(Show (f (t a)), Show (f a), Applicative t, Functor f) => P (Pure2 t :: Type) (f a) Source # | |
P (Proxy t :: Type) a Source # | |
P p a => P (W p :: Type) a Source # | |
(ToJSON (PP p x), P p x) => P (EncodeJson p :: Type) x Source # | |
Defined in Predicate.Prelude type PP (EncodeJson p) x :: Type Source # eval :: MonadEval m => Proxy (EncodeJson p) -> POpts -> x -> m (TT (PP (EncodeJson p) x)) Source # | |
(Foldable t, PP p x ~ t a, P p x) => P (OneP p :: Type) x Source # | |
P (RDotExpandT ps q) a => P (RDot ps q :: Type) a Source # | |
P (DotExpandT ps q) a => P (Dot ps q :: Type) a Source # | |
(Show a, PP p x ~ Maybe a, P p x) => P (Just p :: Type) x Source # | |
(Show s, Snoc s s (ConsT s) (ConsT s), PP p x ~ s, P p x) => P (Init p :: Type) x Source # | |
(Show (ConsT s), Show s, Snoc s s (ConsT s) (ConsT s), PP p x ~ s, P p x) => P (Last p :: Type) x Source # | |
(Show s, Cons s s (ConsT s) (ConsT s), PP p x ~ s, P p x) => P (Tail p :: Type) x Source # | |
(Show (ConsT s), Show s, Cons s s (ConsT s) (ConsT s), PP p x ~ s, P p x) => P (Head p :: Type) x Source # | |
P (TrimBothT p) x => P (TrimBoth p :: Type) x Source # | |
P (TrimRT p) x => P (TrimR p :: Type) x Source # | |
P (TrimLT p) x => P (TrimL p :: Type) x Source # | |
P (StderrT p) x => P (Stderr p :: Type) x Source # | |
P (StdoutT p) x => P (Stdout p :: Type) x Source # | |
(PP p x ~ String, P p x) => P (ReadEnv p :: Type) x Source # | |
P (DirExistsT p) x => P (DirExists p :: Type) x Source # | |
(PP p x ~ String, P p x) => P (ReadDir p :: Type) x Source # | |
P (FileExistsT p) x => P (FileExists p :: Type) x Source # | |
Defined in Predicate.Prelude type PP (FileExists p) x :: Type Source # eval :: MonadEval m => Proxy (FileExists p) -> POpts -> x -> m (TT (PP (FileExists p) x)) Source # | |
(PP p x ~ String, P p x) => P (ReadFile p :: Type) x Source # | |
P p x => P (Hide p :: Type) x Source # | |
(PP p x ~ [Int], P p x) => P (Luhn p :: Type) x Source # | |
P p x => P (Singleton p :: Type) x Source # | |
P (EmptyList' t :: Type) x Source # | |
Defined in Predicate.Prelude type PP (EmptyList' t) x :: Type Source # eval :: MonadEval m => Proxy (EmptyList' t) -> POpts -> x -> m (TT (PP (EmptyList' t) x)) Source # | |
P (IsTheseT p) x => P (IsThese p :: Type) x Source # | |
P (IsThatT p) x => P (IsThat p :: Type) x Source # | |
P (IsThisT p) x => P (IsThis p :: Type) x Source # | |
(PP p x ~ t a, P p x, Show (t a), Foldable t, Show a) => P (ToList' p :: Type) x Source # | |
P (OrdA' p p) x => P (OrdA p :: Type) x Source # | |
(PP p x ~ Bool, P p x) => P (Not p :: Type) x Source # | |
(Show (PP p a), P p a) => P (Skip p :: Type) a Source # | |
(Show a, P p a, PP p a ~ Bool) => P (GuardSimple p :: Type) a Source # | |
Defined in Predicate.Prelude type PP (GuardSimple p) a :: Type Source # eval :: MonadEval m => Proxy (GuardSimple p) -> POpts -> a -> m (TT (PP (GuardSimple p) a)) Source # | |
P (Fail Unproxy p) x => P (Failp p :: Type) x Source # | |
P (Fail I p) x => P (FailS p :: Type) x Source # | |
P (ScanNAT q) x => P (ScanNA q :: Type) x Source # | |
(Show (t a), Foldable t, t a ~ PP p x, P p x) => P (Null' p :: Type) x Source # | |
(PP p x ~ t a, P p x, Show (t a), Foldable t, a ~ Bool) => P (Ors p :: Type) x Source # | |
(PP p x ~ t a, P p x, Show (t a), Foldable t, a ~ Bool) => P (Ands p :: Type) x Source # | |
P (ProxyT' t :: Type) x Source # | |
(Show a, Show (t [a]), PP p x ~ t [a], P p x, Foldable t) => P (Concat p :: Type) x Source # | |
(PP p x ~ [a], P p x, Show a, Monoid a) => P (MConcat p :: Type) x Source # | |
(PP p x ~ a, P p x, Show a) => P (MkJust p :: Type) x Source # | |
P (MkNothing' t :: Type) a Source # | |
Defined in Predicate.Prelude type PP (MkNothing' t) a :: Type Source # eval :: MonadEval m => Proxy (MkNothing' t) -> POpts -> a -> m (TT (PP (MkNothing' t) a)) Source # | |
(Show (PP t a), Monoid (PP t a)) => P (MEmptyT' t :: Type) a Source # | |
P (CatMaybesT q) x => P (CatMaybes q :: Type) x Source # | |
(P p x, PP p x ~ Maybe a) => P (IsNothing p :: Type) x Source # | |
(P p x, PP p x ~ Maybe a) => P (IsJust p :: Type) x Source # | |
P (TheseT' p) x => P (These' p :: Type) x Source # | |
P (ThatT' p) x => P (That' p :: Type) x Source # | |
P (ThisT' p) x => P (This' p :: Type) x Source # | |
P (RightT' p) x => P (Right' p :: Type) x Source # | |
P (LeftT' p) x => P (Left' p :: Type) x Source # | |
(PP p x ~ a, P p x, Show a, Integral a) => P (Prime p :: Type) x Source # | |
(Show a, Enum a, PP p x ~ a, P p x) => P (FromEnum p :: Type) x Source # | |
(Show a, Enum a, PP p x ~ a, P p x) => P (Pred p :: Type) x Source # | |
(Show a, Enum a, PP p x ~ a, P p x) => P (Succ p :: Type) x Source # | |
P (PredBT' q) x => P (PredB' q :: Type) x Source # | |
P (SuccBT' q) x => P (SuccB' q :: Type) x Source # | |
(Show a, Show t, Coercible t a) => P (Coerce t :: Type) a Source # | |
(PP p x ~ s, P p x, Show s, Show (Unwrapped s), Wrapped s) => P (Unwrap p :: Type) x Source # | |
(Show (PP p x), Num (PP p x), P p x) => P (Signum p :: Type) x Source # | |
(Show (PP p x), Num (PP p x), P p x) => P (Abs p :: Type) x Source # | |
(Show (PP p x), Num (PP p x), P p x) => P (Negate p :: Type) x Source # | |
(P p x, PP p x ~ Either a b) => P (IsRight p :: Type) x Source # | |
(P p x, PP p x ~ Either a b) => P (IsLeft p :: Type) x Source # | |
P (SecondT q) x => P (Second q :: Type) x Source # | |
P (FirstT p) x => P (First p :: Type) x Source # | |
P (DoExpandT ps) a => P (Do ps :: Type) a Source # | |
(a ~ PP p x, Show a, Real a, P p x) => P (ToRational p :: Type) x Source # | |
Defined in Predicate.Prelude type PP (ToRational p) x :: Type Source # eval :: MonadEval m => Proxy (ToRational p) -> POpts -> x -> m (TT (PP (ToRational p) x)) Source # | |
(Show (ExtractL6T (PP p x)), ExtractL6C (PP p x), P p x, Show (PP p x)) => P (L6 p :: Type) x Source # | |
(Show (ExtractL5T (PP p x)), ExtractL5C (PP p x), P p x, Show (PP p x)) => P (L5 p :: Type) x Source # | |
(Show (ExtractL4T (PP p x)), ExtractL4C (PP p x), P p x, Show (PP p x)) => P (L4 p :: Type) x Source # | |
P (L3T p) x => P (L3 p :: Type) x Source # | |
(Show (ExtractL3T (PP p x)), ExtractL3C (PP p x), P p x, Show (PP p x)) => P (Thd p :: Type) x Source # | |
P (L2T p) x => P (L2 p :: Type) x Source # | |
(Show (ExtractL2T (PP p x)), ExtractL2C (PP p x), P p x, Show (PP p x)) => P (Snd p :: Type) x Source # | |
P (L1T p) x => P (L1 p :: Type) x Source # | |
(Show (ExtractL1T (PP p x)), ExtractL1C (PP p x), P p x, Show (PP p x)) => P (Fst p :: Type) x Source # | |
(PP p x ~ t a, P p x, Show (t a), Foldable t) => P (Length p :: Type) x Source # | |
(PP p x ~ Day, P p x) => P (UnMkDay p :: Type) x Source # | |
(Show (PP p x), P p x) => P (ShowP p :: Type) x Source # | |
(PP p x ~ [a], P p x, Show a) => P (Ones p :: Type) x Source # | |
(PP p x ~ ([String] -> String), P p x) => P (ReplaceFn3 p :: Type) x Source # | |
Defined in Predicate.Prelude type PP (ReplaceFn3 p) x :: Type Source # eval :: MonadEval m => Proxy (ReplaceFn3 p) -> POpts -> x -> m (TT (PP (ReplaceFn3 p) x)) Source # | |
(PP p x ~ (String -> String), P p x) => P (ReplaceFn2 p :: Type) x Source # | |
Defined in Predicate.Prelude type PP (ReplaceFn2 p) x :: Type Source # eval :: MonadEval m => Proxy (ReplaceFn2 p) -> POpts -> x -> m (TT (PP (ReplaceFn2 p) x)) Source # | |
(PP p x ~ (String -> [String] -> String), P p x) => P (ReplaceFn1 p :: Type) x Source # | |
Defined in Predicate.Prelude type PP (ReplaceFn1 p) x :: Type Source # eval :: MonadEval m => Proxy (ReplaceFn1 p) -> POpts -> x -> m (TT (PP (ReplaceFn1 p) x)) Source # | |
(PP p x ~ String, P p x) => P (ReplaceFn p :: Type) x Source # | |
(Show (PP p a2), P p a2, Show a2) => P (Just p :: Maybe a1) (Maybe a2) Source # | extracts the 'a' from type level 'Maybe a' if the value exists
|
(GetLen ps, P (ParaImpl (LenT ps) ps) [a]) => P (Para ps :: Type) [a] Source # | |
(Show (f a), Show (f (PP t (f a))), Functor f, Monoid (PP t (f a))) => P (MEmpty2' t :: Type) (f a) Source # | |
(Show (f a), Show (f t), Coercible t a, Functor f) => P (Coerce2 t :: Type) (f a) Source # | |
(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 Source # | |
(Show (PP p a), Show a, P p a) => P (p ': ([] :: [k]) :: [k]) a Source # | runs each predicate in turn from the promoted list
|
P (ParseJsonFileT t p) x => P (ParseJsonFile t p :: Type) x Source # | |
Defined in Predicate.Prelude type PP (ParseJsonFile t p) x :: Type Source # eval :: MonadEval m => Proxy (ParseJsonFile t p) -> POpts -> x -> m (TT (PP (ParseJsonFile t p) x)) Source # | |
P (ParseJsonT t p) x => P (ParseJson t p :: Type) x Source # | |
P (DoNT n p) a => P (DoN n p :: Type) a Source # | |
P (RepeatT n p) a => P (Repeat n p :: Type) a Source # | |
P (WriteFileT s p) x => P (WriteFile s p :: Type) x Source # | |
P (WriteFileT' s p) x => P (WriteFile' s p :: Type) x Source # | |
Defined in Predicate.Prelude type PP (WriteFile' s p) x :: Type Source # eval :: MonadEval m => Proxy (WriteFile' s p) -> POpts -> x -> m (TT (PP (WriteFile' s p) x)) Source # | |
P (AppendFileT s p) x => P (AppendFile s p :: Type) x Source # | |
Defined in Predicate.Prelude type PP (AppendFile s p) x :: Type Source # eval :: MonadEval m => Proxy (AppendFile s p) -> POpts -> x -> m (TT (PP (AppendFile s p) x)) Source # | |
(PP p x ~ a, P p x, Show a, 2 <= n, n <= 36, KnownNat n, Integral a) => P (ShowBase n p :: Type) x Source # | |
P (IToListT t p) x => P (IToList t p :: Type) x Source # | |
P (Fail (Hole t) p) x => P (Failt t p :: Type) x Source # | |
P (FoldMapT t p) x => P (FoldMap t p :: Type) x Source # | |
P (MkThatT t p) x => P (MkThat t p :: Type) x Source # | |
P (MkThisT t p) x => P (MkThis t p :: Type) x Source # | |
P (MkRightT t p) x => P (MkRight t p :: Type) x Source # | |
P (MkLeftT t p) x => P (MkLeft t p :: Type) x Source # | |
(P p x, PP p x ~ a, Show (t a), Show a, Alternative t) => P (EmptyT t p :: Type) x Source # | |
(P p x, Show (PP p x), Show (t (PP p x)), Applicative t) => P (Pure t p :: Type) x Source # | |
P (ToEnumBDefT t def) x => P (ToEnumBDef t def :: Type) x Source # | |
Defined in Predicate.Prelude type PP (ToEnumBDef t def) x :: Type Source # eval :: MonadEval m => Proxy (ToEnumBDef t def) -> POpts -> x -> m (TT (PP (ToEnumBDef t def) x)) Source # | |
P (ToEnumT t p) x => P (ToEnum t p :: Type) x Source # | |
P (WrapT t p) x => P (Wrap t p :: Type) x Source # | |
P (FloorT t p) x => P (Floor t p :: Type) x Source # | |
P (CeilingT t p) x => P (Ceiling t p :: Type) x Source # | |
P (TruncateT t p) x => P (Truncate t p :: Type) x Source # | |
P (FromRationalT t p) x => P (FromRational t p :: Type) x Source # | |
Defined in Predicate.Prelude type PP (FromRational t p) x :: Type Source # eval :: MonadEval m => Proxy (FromRational t p) -> POpts -> x -> m (TT (PP (FromRational t p) x)) Source # | |
P (FromIntegralT t p) x => P (FromIntegral t p :: Type) x Source # | |
Defined in Predicate.Prelude type PP (FromIntegral t p) x :: Type Source # eval :: MonadEval m => Proxy (FromIntegral t p) -> POpts -> x -> m (TT (PP (FromIntegral t p) x)) Source # | |
P (FromIntegerT t p) x => P (FromInteger t p :: Type) x Source # | |
Defined in Predicate.Prelude type PP (FromInteger t p) x :: Type Source # eval :: MonadEval m => Proxy (FromInteger t p) -> POpts -> x -> m (TT (PP (FromInteger t p) x)) Source # | |
P (FromStringPT t p) x => P (FromStringP t p :: Type) x Source # | |
Defined in Predicate.Prelude type PP (FromStringP t p) x :: Type Source # eval :: MonadEval m => Proxy (FromStringP t p) -> POpts -> x -> m (TT (PP (FromStringP t p) x)) Source # | |
P (ReadQT t p) x => P (ReadQ t p :: Type) x Source # | |
P (ReadMaybeT t p) x => P (ReadMaybe t p :: Type) x Source # | |
P (ReadPT t p) x => P (ReadP t p :: Type) x Source # | |
(P (ParaImpl (LenT (RepeatT n p)) (RepeatT n p)) [a], GetLen (RepeatT n p)) => P (ParaN n p :: Type) [a] Source # | |
(GetLen ps, P (BoolsImpl (LenT ps) ps) [a], PP (BoolsImpl (LenT ps) ps) [a] ~ Bool) => P (Bools ps :: Type) [a] Source # | |
(GetLen ps, P (GuardsImpl (LenT ps) ps) [a]) => P (Guards ps :: Type) [a] Source # | |
(P def (Proxy a), PP def (Proxy a) ~ a, KnownNat n, Show a) => P (Ix n def :: Type) [a] Source # | |
(P prt a, PP prt a ~ String, P p a) => P (Msg prt p :: Type) a Source # | |
P (OrAT p q) x => P (p |+ q :: Type) x Source # | |
P (AndAT p q) x => P (p &* q :: Type) x Source # | |
(P p x, PP p x ~ String, Typeable (PP t x), Show (PP t x), FromJSON (PP t x)) => P (ParseJsonFile' t p :: Type) x Source # | |
Defined in Predicate.Prelude type PP (ParseJsonFile' t p) x :: Type Source # eval :: MonadEval m => Proxy (ParseJsonFile' t p) -> POpts -> x -> m (TT (PP (ParseJsonFile' t p) x)) Source # | |
(P p x, PP p x ~ String, Typeable (PP t x), Show (PP t x), FromJSON (PP t x)) => P (ParseJson' t p :: Type) x Source # | |
Defined in Predicate.Prelude type PP (ParseJson' t p) x :: Type Source # eval :: MonadEval m => Proxy (ParseJson' t p) -> POpts -> x -> m (TT (PP (ParseJson' t p) x)) Source # | |
(ExtractL1C (PP q x), ExtractL2C (PP q x), P p (ExtractL1T (PP q x)), P p (ExtractL2T (PP q x)), P q x) => P (Both p q :: Type) x Source # | |
P p a => P (K p q :: Type) a Source # | |
P (p q) a => P (q & p :: Type) a Source # | |
P (p q) a => P (p $ q :: Type) a Source # | |
(PP p x ~ String, PP q x ~ These a b, P p x, P q x) => P (TheseFail p q :: Type) x Source # | |
(PP p x ~ String, PP q x ~ These a b, P p x, P q x) => P (ThatFail p q :: Type) x Source # | |
(PP p x ~ String, PP q x ~ These a b, P p x, P q x) => P (ThisFail p q :: Type) x Source # | |
(PP q x ~ These a b, PP p x ~ (a, b), P q x, P p x) => P (TheseDef p q :: Type) x Source # | |
(PP q x ~ These a b, PP p x ~ b, P q x, P p x) => P (ThatDef p q :: Type) x Source # | |
(PP q x ~ These a b, PP p x ~ a, P q x, P p x) => P (ThisDef p q :: Type) x Source # | |
(PP p (a, x) ~ String, PP q x ~ Either a b, P p (a, x), P q x) => P (RightFail p q :: Type) x Source # | |
(PP p (b, x) ~ String, PP q x ~ Either a b, P p (b, x), P q x) => P (LeftFail p q :: Type) x Source # | |
(PP q x ~ Either a b, PP p (a, x) ~ b, P q x, P p (a, x)) => P (RightDef p q :: Type) x Source # | |
(PP q x ~ Either a b, PP p (b, x) ~ a, P q x, P p (b, x)) => P (LeftDef p q :: Type) x Source # | |
(PP p x ~ String, PP q x ~ Maybe a, P p x, P q x) => P (JustFail p q :: Type) x Source # | |
(PP p x ~ a, PP q x ~ Maybe a, P p x, P q x) => P (JustDef p q :: Type) x Source # | |
P (StripRT p q) x => P (StripR p q :: Type) x Source # | |
P (StripLT p q) x => P (StripL p q :: Type) x Source # | |
(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 (q $& p :: Type) x Source # | |
(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 Source # | |
(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 Source # | |
P (ArrowRT p q) x => P (p *> q :: Type) x Source # | |
(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 Source # | |
(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 Source # | |
(PrintC bs, (b, bs) ~ InductTupleP y, InductTupleC y, PrintfArg b, PP s x ~ String, PP p x ~ y, P s x, P p x, CheckT (PP p x) ~ True) => P (PrintT s p :: Type) x Source # | |
(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 Source # | |
P (IsSuffixIT p q) x => P (IsSuffixI p q :: Type) x Source # | |
P (IsInfixIT p q) x => P (IsInfixI p q :: Type) x Source # | |
P (IsPrefixIT p q) x => P (IsPrefixI p q :: Type) x Source # | |
P (IsSuffixT p q) x => P (IsSuffix p q :: Type) x Source # | |
P (IsInfixT p q) x => P (IsInfix p q :: Type) x Source # | |
P (IsPrefixT p q) x => P (IsPrefix p q :: Type) x Source # | |
P (TraverseT p q) x => P (Traverse p q :: Type) x Source # | |
(PrintfArg (PP p x), Show (PP p x), PP s x ~ String, P s x, P p x) => P (PrintF s p :: Type) x Source # | |
(PP p x ~ [a], PP q x ~ PP p x, P p x, P q x, Show a) => P (Intercalate p q :: Type) x Source # | |
Defined in Predicate.Prelude type PP (Intercalate p q) x :: Type Source # eval :: MonadEval m => Proxy (Intercalate p q) -> POpts -> x -> m (TT (PP (Intercalate p q) x)) Source # | |
P (ReadBaseT t n p) x => P (ReadBase t n p :: Type) x Source # | |
(PP p a ~ [x], PP q a ~ [y], P p a, P q a, Show x, Show y) => P (Zip p q :: Type) a Source # | |
(PP p a ~ [x], PP q a ~ [y], P p a, P q a, Show x, Show y) => P (ZipThese p q :: Type) a Source # | |
P (TheseIdT p q) x => P (TheseId p q :: Type) x Source # | |
(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 Source # | |
(PP p a ~ String, PP p a ~ PP q a, P p a, P q a) => P (p ===~ q :: Type) a Source # | |
P (OrdAT' p q) x => P (OrdA' p q :: Type) x Source # | |
(Ord (PP p a), PP p a ~ PP q a, P p a, Show (PP q a), P q a) => P (p ==! q :: Type) a Source # | |
(P p a, P q a, PP p a ~ Bool, PP q a ~ Bool) => P (p ~> q :: Type) a Source # | |
(P p a, P q a, PP p a ~ Bool, PP q a ~ Bool) => P (p || q :: Type) a Source # | |
(P p a, P q a, PP p a ~ Bool, PP q a ~ Bool) => P (p && q :: Type) a Source # | |
P (LeftArrowsT p q) x => P (p << q :: Type) x Source # | |
(Show (PP p a), Show (PP q (PP p a)), P p a, P q (PP p a)) => P (p >> q :: Type) a Source # | |
P (SkipBothT p q) x => P (p >|> q :: Type) x Source # | |
P (SkipRT p q) x => P (p >| q :: Type) x Source # | |
P (SkipLT p q) x => P (p |> q :: Type) x Source # | |
P (ExitWhenT prt p) x => P (ExitWhen prt p :: Type) x Source # | |
(Show a, P prt a, PP prt a ~ String, P p a, PP p a ~ Bool) => P (Guard prt p :: Type) a Source # | |
(PP (Bools (ToGuardsT prt ps)) x ~ Bool, P (BoolsQuickT prt ps) x) => P (BoolsQuick prt ps :: Type) x Source # | |
Defined in Predicate.Prelude type PP (BoolsQuick prt ps) x :: Type Source # eval :: MonadEval m => Proxy (BoolsQuick prt ps) -> POpts -> x -> m (TT (PP (BoolsQuick prt ps) x)) Source # | |
P (GuardsQuickT prt ps) x => P (GuardsQuick prt ps :: Type) x Source # | |
Defined in Predicate.Prelude type PP (GuardsQuick prt ps) x :: Type Source # eval :: MonadEval m => Proxy (GuardsQuick prt ps) -> POpts -> x -> m (TT (PP (GuardsQuick prt ps) x)) Source # | |
P (RemT p q) x => P (Rem p q :: Type) x Source # | |
P (QuotT p q) x => P (Quot p q :: Type) x Source # | |
(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 Source # | |
(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 Source # | |
(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 Source # | |
(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 Source # | |
P (CatchT' p s) x => P (Catch' p s :: Type) x Source # | |
(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 Source # | |
(P prt a, PP prt a ~ String) => P (Fail t prt :: Type) a Source # | |
P (SpanT p q) x => P (Span p q :: Type) x Source # | |
(P p x, PP q a ~ [x], PP p x ~ Bool, P q a) => P (Break p q :: Type) a Source # | |
P (FilterT p q) x => P (Filter p q :: Type) x Source # | |
(P p x, Show x, PP q a ~ [x], PP p x ~ Bool, P q a) => P (Partition p q :: Type) a Source # | |
P (ConcatMapT p q) x => P (ConcatMap p q :: Type) x Source # | |
(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 Source # | |
P (IterateWhileT p f) x => P (IterateWhile p f :: Type) x Source # | |
Defined in Predicate.Prelude type PP (IterateWhile p f) x :: Type Source # eval :: MonadEval m => Proxy (IterateWhile p f) -> POpts -> x -> m (TT (PP (IterateWhile p f) x)) Source # | |
P (IterateUntilT p f) x => P (IterateUntil p f :: Type) x Source # | |
Defined in Predicate.Prelude type PP (IterateUntil p f) x :: Type Source # eval :: MonadEval m => Proxy (IterateUntil p f) -> POpts -> x -> m (TT (PP (IterateUntil p f) x)) Source # | |
P (IterateNT n f) x => P (IterateN n f :: Type) x Source # | |
(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 Source # | |
(P p x, P q x, PP p x ~ a, Show a, PP q x ~ a, Enum a) => P (EnumFromTo p q :: Type) x Source # | |
Defined in Predicate.Prelude type PP (EnumFromTo p q) x :: Type Source # eval :: MonadEval m => Proxy (EnumFromTo p q) -> POpts -> x -> m (TT (PP (EnumFromTo p q) x)) Source # | |
(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 Source # | |
(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 Source # | |
(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 Source # | |
P (BangBangT p q) a => P (p !! q :: Type) a Source # | |
(Show a, Show (t a), PP p x ~ t a, P p x, Integral (PP n x), P n x, Foldable t) => P (Cycle n p :: Type) x Source # | |
(P p a, P q a, Show (PP p a), Show (PP q a)) => P (MkThese p q :: Type) a Source # | |
(Show (PP p x), P p x) => P (MkThat' t p :: Type) x Source # | |
(Show (PP p x), P p x) => P (MkThis' t p :: Type) x Source # | |
(Show (PP p x), P p x) => P (MkRight' t p :: Type) x Source # | |
(Show (PP p x), P p x) => P (MkLeft' t p :: Type) x Source # | |
(P n a, Integral (PP n a), Semigroup (PP p a), P p a, Show (PP p a)) => P (STimes n p :: Type) a Source # | |
P (MapMaybeT p q) x => P (MapMaybe p q :: Type) x Source # | |
P (InitFailT msg q) x => P (InitFail msg q :: Type) x Source # | |
P (InitDefT p q) x => P (InitDef p q :: Type) x Source # | |
P (LastFailT msg q) x => P (LastFail msg q :: Type) x Source # | |
P (LastDefT p q) x => P (LastDef p q :: Type) x Source # | |
P (TailFailT msg q) x => P (TailFail msg q :: Type) x Source # | |
P (TailDefT p q) x => P (TailDef p q :: Type) x Source # | |
P (HeadFailT msg q) x => P (HeadFail msg q :: Type) x Source # | |
P (HeadDefT p q) x => P (HeadDef p q :: Type) x Source # | |
([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 Source # | |
P (RemoveT p q) x => P (Remove p q :: Type) x Source # | |
P (KeepT p q) x => P (Keep p q :: Type) x Source # | |
(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 (ToEnumBDef' t def :: Type) a Source # | |
Defined in Predicate.Prelude type PP (ToEnumBDef' t def) a :: Type Source # eval :: MonadEval m => Proxy (ToEnumBDef' t def) -> POpts -> a -> m (TT (PP (ToEnumBDef' t def) a)) Source # | |
(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 Source # | |
(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 Source # | |
(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 Source # | bounded
|
(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 Source # | |
P (NegateRatioT p q) x => P (p -% q :: Type) x Source # | |
(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 Source # | |
(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 (p / q :: Type) a Source # | |
P (CmpI CNe p q) x => P (p /=~ q :: Type) x Source # | |
P (CmpI CLt p q) x => P (p <~ q :: Type) x Source # | |
P (CmpI CLe p q) x => P (p <=~ q :: Type) x Source # | |
P (CmpI CEq p q) x => P (p ==~ q :: Type) x Source # | |
P (CmpI CGe p q) x => P (p >=~ q :: Type) x Source # | |
P (CmpI CGt p q) x => P (p >~ q :: Type) x Source # | |
P (Cmp CNe p q) x => P (p /= q :: Type) x Source # | |
P (Cmp CLt p q) x => P (p < q :: Type) x Source # | |
P (Cmp CLe p q) x => P (p <= q :: Type) x Source # | |
P (Cmp CEq p q) x => P (p == q :: Type) x Source # | |
P (Cmp CGe p q) x => P (p >= q :: Type) x Source # | |
P (Cmp CGt p q) x => P (p > q :: Type) x Source # | |
P (MultT p q) x => P (p * q :: Type) x Source # | |
P (SubT p q) x => P (p - q :: Type) x Source # | |
P (AddT p q) x => P (p + q :: Type) x Source # | |
P (WAmpT p q) x => P (p &&& q :: Type) x Source # | |
P (DropT n p) x => P (Drop n p :: Type) x Source # | |
P (TakeT n p) x => P (Take n p :: Type) x Source # | |
(PP p a ~ [b], P n a, P p a, Show b, Integral (PP n a)) => P (SplitAt n p :: Type) a Source # | |
(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 Source # | |
(Show (PP p a), P b a, P p a, PP b a ~ Bool) => P (MaybeBool b p :: Type) a Source # | |
(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 Source # | |
(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 Source # | |
(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 Source # | |
(P r a, PP r a ~ Rational, Show (PP t a), Fractional (PP t a)) => P (FromRational' t r :: Type) a Source # | |
Defined in Predicate.Prelude type PP (FromRational' t r) a :: Type Source # eval :: MonadEval m => Proxy (FromRational' t r) -> POpts -> a -> m (TT (PP (FromRational' t r) a)) Source # | |
(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 Source # | |
Defined in Predicate.Prelude type PP (FromIntegral' t n) a :: Type Source # eval :: MonadEval m => Proxy (FromIntegral' t n) -> POpts -> a -> m (TT (PP (FromIntegral' t n) a)) Source # | |
(Num (PP t a), Integral (PP n a), P n a, Show (PP t a)) => P (FromInteger' t n :: Type) a Source # | |
Defined in Predicate.Prelude type PP (FromInteger' t n) a :: Type Source # eval :: MonadEval m => Proxy (FromInteger' t n) -> POpts -> a -> m (TT (PP (FromInteger' t n) a)) Source # | |
(P s a, PP s a ~ String, Show (PP t a), IsString (PP t a)) => P (FromStringP' t s :: Type) a Source # | |
Defined in Predicate.Prelude type PP (FromStringP' t s) a :: Type Source # eval :: MonadEval m => Proxy (FromStringP' t s) -> POpts -> a -> m (TT (PP (FromStringP' t s) a)) Source # | |
P (SortOnDescT p q) x => P (SortOnDesc p q :: Type) x Source # | |
Defined in Predicate.Prelude type PP (SortOnDesc p q) x :: Type Source # eval :: MonadEval m => Proxy (SortOnDesc p q) -> POpts -> x -> m (TT (PP (SortOnDesc p q) x)) Source # | |
P (SortOnT p q) x => P (SortOn p q :: Type) x Source # | |
(P p (a, a), P q x, Show a, PP q x ~ [a], PP p (a, a) ~ Ordering) => P (SortBy p q :: Type) x Source # | |
P (ReadQT' t p) x => P (ReadQ' t p :: Type) x Source # | |
(P p x, PP p x ~ String, Typeable (PP t x), Show (PP t x), Read (PP t x)) => P (ReadMaybe' t p :: Type) x Source # | |
Defined in Predicate.Prelude type PP (ReadMaybe' t p) x :: Type Source # eval :: MonadEval m => Proxy (ReadMaybe' t p) -> POpts -> x -> m (TT (PP (ReadMaybe' t p) x)) Source # | |
(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 Source # | |
(PP p x ~ String, FormatTime (PP q x), P p x, Show (PP q x), P q x) => P (FormatTimeP p q :: Type) x Source # | |
Defined in Predicate.Prelude type PP (FormatTimeP p q) x :: Type Source # eval :: MonadEval m => Proxy (FormatTimeP p q) -> POpts -> x -> m (TT (PP (FormatTimeP p q) x)) Source # | |
P (ResplitT p q) x => P (Resplit p q :: Type) x Source # | |
P (RescanRangesT p q) x => P (RescanRanges p q :: Type) x Source # | |
Defined in Predicate.Prelude type PP (RescanRanges p q) x :: Type Source # eval :: MonadEval m => Proxy (RescanRanges p q) -> POpts -> x -> m (TT (PP (RescanRanges p q) x)) Source # | |
P (RescanT p q) x => P (Rescan p q :: Type) x Source # | |
P (ReT p q) x => P (Re p q :: Type) x Source # | |
(P p a, PP p a ~ Bool, PP q x ~ f a, P q x, Show a, Foldable f) => P (Any p q :: Type) x Source # | |
(P p a, PP p a ~ Bool, PP q x ~ f a, P q x, Show a, Foldable f) => P (All p q :: Type) x Source # | |
P (BetweenT p q) x => P (p <..> q :: Type) x Source # | |
(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) Source # | |
(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) Source # | |
(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) Source # | |
(Show (PP p a), Show (PP q b), P p a, P q b, Show a, Show b) => P (p *** q :: Type) (a, b) Source # | |
(PP q x ~ (a, b), PP (p a b (PP r x)) x ~ PP (p (Fst Id) (Snd Id) (Thd Id)) (a, b, PP r x), P q x, P r x, P (p (Fst Id) (Snd Id) (Thd Id)) (a, b, PP r x)) => P (Uncurry p q r :: Type) x Source # | |
(KnownNat n, PrintC bs, (b, bs) ~ InductListP n a, InductListC n a, PrintfArg b, PP s x ~ String, PP p x ~ [a], P s x, P p x) => P (PrintL n s p :: Type) x Source # | |
(Typeable (PP t x), ZwischenT 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 Source # | |
(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 Source # | |
(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 Source # | |
P (GuardsDetailT prt ps) x => P (GuardsDetail prt ps :: Type) x Source # | |
Defined in Predicate.Prelude type PP (GuardsDetail prt ps) x :: Type Source # eval :: MonadEval m => Proxy (GuardsDetail prt ps) -> POpts -> x -> m (TT (PP (GuardsDetail prt ps) x)) Source # | |
P (ParseTimesT t p q) x => P (ParseTimes t p q :: Type) x Source # | |
Defined in Predicate.Prelude type PP (ParseTimes t p q) x :: Type Source # eval :: MonadEval m => Proxy (ParseTimes t p q) -> POpts -> x -> m (TT (PP (ParseTimes t p q) x)) Source # | |
P (ParseTimePT t p q) x => P (ParseTimeP t p q :: Type) x Source # | |
Defined in Predicate.Prelude type PP (ParseTimeP t p q) x :: Type Source # eval :: MonadEval m => Proxy (ParseTimeP t p q) -> POpts -> x -> m (TT (PP (ParseTimeP t p q) x)) Source # | |
(GetROpts rs, PP p x ~ String, PP q x ~ String, P p x, P q x) => P (Resplit' rs p q :: Type) x Source # | |
(GetROpts rs, PP p x ~ String, PP q x ~ String, P p x, P q x) => P (RescanRanges' rs p q :: Type) x Source # | |
Defined in Predicate.Prelude type PP (RescanRanges' rs p q) x :: Type Source # eval :: MonadEval m => Proxy (RescanRanges' rs p q) -> POpts -> x -> m (TT (PP (RescanRanges' rs p q) x)) Source # | |
(GetROpts rs, PP p x ~ String, PP q x ~ String, P p x, P q x) => P (Rescan' rs p q :: Type) x Source # | |
(GetROpts rs, PP p x ~ String, PP q x ~ String, P p x, P q x) => P (Re' rs p q :: Type) x Source # | |
P (GuardsNT prt n p) [a] => P (GuardsN prt n p :: Type) [a] Source # | |
P (BoolsNT prt n p) [a] => P (BoolsN prt n p :: Type) [a] Source # | |
(PP r x ~ (a, b), PP p a ~ Bool, PP q b ~ Bool, P p a, P q b, P r x) => P (OrA p q r :: Type) x Source # | |
(PP r x ~ (a, b), PP p a ~ Bool, PP q b ~ Bool, P p a, P q b, P r x) => P (AndA p q r :: Type) x Source # | |
P (CaseT' ps qs r) x => P (Case' ps qs r :: Type) x Source # | |
(PP r a ~ y, P r a, PP p a ~ [x], PP q a ~ [y], P p a, P q a, Show x, Show y) => P (ZipR r p q :: Type) a Source # | |
(PP l a ~ x, P l a, PP p a ~ [x], PP q a ~ [y], P p a, P q a, Show x, Show y) => P (ZipL l p q :: Type) a Source # | |
(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 Source # | |
P (IterateNUntilT n p f) x => P (IterateNUntil n p f :: Type) x Source # | |
Defined in Predicate.Prelude type PP (IterateNUntil n p f) x :: Type Source # eval :: MonadEval m => Proxy (IterateNUntil n p f) -> POpts -> x -> m (TT (PP (IterateNUntil n p f) x)) Source # | |
P (IterateNWhileT n p f) x => P (IterateNWhile n p f :: Type) x Source # | |
Defined in Predicate.Prelude type PP (IterateNWhile n p f) x :: Type Source # eval :: MonadEval m => Proxy (IterateNWhile n p f) -> POpts -> x -> m (TT (PP (IterateNWhile n p f) x)) Source # | |
P (FoldLT p q r) x => P (FoldL p q r :: Type) x Source # | |
P (FoldNT n p q) x => P (FoldN n p q :: Type) x Source # | |
P (ScanNT n p q) x => P (ScanN n p q :: Type) x Source # | |
(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 Source # | |
(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 Source # | |
P (LookupFailT msg v w) x => P (LookupFail msg v w :: Type) x Source # | |
Defined in Predicate.Prelude type PP (LookupFail msg v w) x :: Type Source # eval :: MonadEval m => Proxy (LookupFail msg v w) -> POpts -> x -> m (TT (PP (LookupFail msg v w) x)) Source # | |
P (LookupDefT v w p) x => P (LookupDef v w p :: Type) x Source # | |
P (PadRT n p q) x => P (PadR n p q :: Type) x Source # | |
P (PadLT n p q) x => P (PadL n p q :: Type) x Source # | |
(Show (PP p a), P p a, Show (PP q a), P q a, P b a, PP b a ~ Bool) => P (EitherBool b p q :: Type) a Source # | |
Defined in Predicate.Prelude type PP (EitherBool b p q) a :: Type Source # eval :: MonadEval m => Proxy (EitherBool b p q) -> POpts -> a -> m (TT (PP (EitherBool b p q) a)) Source # | |
(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 Source # | |
(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 Source # | |
Defined in Predicate.Prelude type PP (ParseTimes' t p q) a :: Type Source # eval :: MonadEval m => Proxy (ParseTimes' t p q) -> POpts -> a -> m (TT (PP (ParseTimes' t p q) a)) Source # | |
(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 Source # | |
Defined in Predicate.Prelude type PP (ParseTimeP' t p q) a :: Type Source # eval :: MonadEval m => Proxy (ParseTimeP' t p q) -> POpts -> a -> m (TT (PP (ParseTimeP' t p q) a)) Source # | |
P (ReplaceOneStringT p q r) x => P (ReplaceOneString p q r :: Type) x Source # | |
Defined in Predicate.Prelude type PP (ReplaceOneString p q r) x :: Type Source # eval :: MonadEval m => Proxy (ReplaceOneString p q r) -> POpts -> x -> m (TT (PP (ReplaceOneString p q r) x)) Source # | |
P (ReplaceAllStringT p q r) x => P (ReplaceAllString p q r :: Type) x Source # | |
Defined in Predicate.Prelude type PP (ReplaceAllString p q r) x :: Type Source # eval :: MonadEval m => Proxy (ReplaceAllString p q r) -> POpts -> x -> m (TT (PP (ReplaceAllString p q r) x)) Source # | |
P (ReplaceOneT p q r) x => P (ReplaceOne p q r :: Type) x Source # | |
Defined in Predicate.Prelude type PP (ReplaceOne p q r) x :: Type Source # eval :: MonadEval m => Proxy (ReplaceOne p q r) -> POpts -> x -> m (TT (PP (ReplaceOne p q r) x)) Source # | |
P (ReplaceAllT p q r) x => P (ReplaceAll p q r :: Type) x Source # | |
Defined in Predicate.Prelude type PP (ReplaceAll p q r) x :: Type Source # eval :: MonadEval m => Proxy (ReplaceAll p q r) -> POpts -> x -> m (TT (PP (ReplaceAll p q r) x)) Source # | |
(Ord (PP p x), Show (PP p x), PP r x ~ PP p x, PP r x ~ PP q x, P p x, P q x, P r x) => P (Between p q r :: Type) x Source # | |
(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) Source # | |
P (ReplaceOneStringT' rs p q r) x => P (ReplaceOneString' rs p q r :: Type) x Source # | |
Defined in Predicate.Prelude type PP (ReplaceOneString' rs p q r) x :: Type Source # eval :: MonadEval m => Proxy (ReplaceOneString' rs p q r) -> POpts -> x -> m (TT (PP (ReplaceOneString' rs p q r) x)) Source # | |
P (ReplaceAllStringT' rs p q r) x => P (ReplaceAllString' rs p q r :: Type) x Source # | |
Defined in Predicate.Prelude type PP (ReplaceAllString' rs p q r) x :: Type Source # eval :: MonadEval m => Proxy (ReplaceAllString' rs p q r) -> POpts -> x -> m (TT (PP (ReplaceAllString' rs p q r) x)) Source # | |
P (ReplaceOneT' rs p q r) x => P (ReplaceOne' rs p q r :: Type) x Source # | |
Defined in Predicate.Prelude type PP (ReplaceOne' rs p q r) x :: Type Source # eval :: MonadEval m => Proxy (ReplaceOne' rs p q r) -> POpts -> x -> m (TT (PP (ReplaceOne' rs p q r) x)) Source # | |
P (ReplaceAllT' rs p q r) x => P (ReplaceAll' rs p q r :: Type) x Source # | |
Defined in Predicate.Prelude type PP (ReplaceAll' rs p q r) x :: Type Source # eval :: MonadEval m => Proxy (ReplaceAll' rs p q r) -> POpts -> x -> m (TT (PP (ReplaceAll' rs p q r) x)) Source # | |
P (CaseT'' s ps qs r) x => P (Case'' s ps qs r :: Type) x Source # | |
(FailUnlessT (LenT ps == LenT qs) (((Text "lengths are not the same " :<>: ShowType (LenT ps)) :<>: Text " vs ") :<>: ShowType (LenT qs)), P (CaseImplT e ps qs r) x) => P (Case e ps qs r :: Type) x Source # | |
(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 Source # | |
P (LookupFailT' msg v w q) x => P (LookupFail' msg v w q :: Type) x Source # | |
Defined in Predicate.Prelude type PP (LookupFail' msg v w q) x :: Type Source # eval :: MonadEval m => Proxy (LookupFail' msg v w q) -> POpts -> x -> m (TT (PP (LookupFail' msg v w q) x)) Source # | |
P (LookupDefT' v w p q) x => P (LookupDef' v w p q :: Type) x Source # | |
Defined in Predicate.Prelude type PP (LookupDef' v w p q) x :: Type Source # eval :: MonadEval m => Proxy (LookupDef' v w p q) -> POpts -> x -> m (TT (PP (LookupDef' v w p q) x)) Source # | |
Show a => P (Proxy :: Proxy t) a Source # | converts the value to the corresponding
|
(Show a2, Show (PP p a2), P p a2) => P (Right p :: Either a1 b) (Either x a2) Source # | extracts the 'b' from type level 'Either a b' if the value exists
|
(Show a2, Show (PP p a2), P p a2) => P (Left p :: Either a1 b) (Either a2 x) Source # | extracts the 'a' from type level 'Either a b' if the value exists
|
(Show a2, Show (PP p a2), P p a2) => P (That p :: These a1 b) (These x a2) Source # | extracts the 'b' from type level 'These a b' if the value exists
|
(Show a2, Show (PP p a2), P p a2) => P (This p :: These a1 b) (These a2 x) Source # | extracts the 'a' from type level 'These a b' if the value exists
|
(P p a, P q a) => P ((,) p q :: (k2, k1)) a Source # | run the predicates in a promoted 2-tuple; similar to
|
(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) Source # | extracts the (a,b) from type level 'These a b' if the value exists
|
(P p a, P q a, P r a) => P ((,,) p q r :: (k3, k2, k1)) a Source # | run the predicates in a promoted 3-tuple
|
(P p a, P q a, P r a, P s a) => P ((,,,) p q r s :: (k4, k3, k2, k1)) a Source # | run the predicates in a promoted 4-tuple
|
evaluation methods
runPQ :: (P p a, P q a, MonadEval m) => String -> Proxy p -> Proxy q -> POpts -> a -> [Holder] -> m (Either (TT x) (PP p a, PP q a, TT (PP p a), TT (PP q a))) Source #
runPQBool :: (P p a, PP p a ~ Bool, P q a, PP q a ~ Bool, MonadEval m) => String -> Proxy p -> Proxy q -> POpts -> a -> [Holder] -> m (Either (TT x) (PP p a, PP q a, TT (PP p a), TT (PP q a))) Source #