| Safe Haskell | None |
|---|---|
| Language | Haskell2010 |
Predicate.Core
Contents
Description
a dsl for evaluating and displaying type level expressions
Synopsis
- data Id
- data IdT
- data W (p :: k)
- data Msg prt p
- data MsgI prt p
- data Hide p
- data Width (n :: Nat) p
- data Hole (t :: Type)
- data UnproxyT
- data Len
- data Length p
- data Map' p q
- data Map p
- data Do (ps :: [k])
- data Pure (t :: Type -> Type) p
- data Coerce (t :: k)
- data OneP
- class P p a where
- pan :: forall p a. (Show (PP p a), P p a) => a -> IO (Val (PP p a))
- panv :: forall p a. (Show (PP p a), P p a) => a -> IO (Val (PP p a))
- pa :: forall p a. (Show (PP p a), P p a) => a -> IO (Val (PP p a))
- pu :: forall p a. (Show (PP p a), P p a) => a -> IO (Val (PP p a))
- pab :: forall p a. (Show (PP p a), P p a) => a -> IO (Val (PP p a))
- pub :: forall p a. (Show (PP p a), P p a) => a -> IO (Val (PP p a))
- pav :: forall p a. (Show (PP p a), P p a) => a -> IO (Val (PP p a))
- puv :: forall p a. (Show (PP p a), P p a) => a -> IO (Val (PP p a))
- pl :: forall p a. (Show (PP p a), P p a) => a -> IO (Val (PP p a))
- pz :: forall p a. (Show (PP p a), P p a) => a -> IO (Val (PP p a))
- run :: forall opts p a. (OptC opts, Show (PP p a), P p a) => a -> IO (Val (PP p a))
- runs :: forall optss p a. (OptC (OptT optss), Show (PP p a), P p a) => a -> IO (Val (PP p a))
- runP :: (P p a, MonadEval m) => Inline -> String -> proxy p -> POpts -> a -> [Tree PE] -> m (Either (TT x) (PP p a, TT (PP p a)))
- runPQ :: (P p a, P q a, MonadEval m) => Inline -> String -> proxy1 p -> proxy2 q -> POpts -> a -> [Tree PE] -> 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) => Inline -> String -> proxy1 p -> proxy2 q -> POpts -> a -> [Tree PE] -> 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))
- evalBoolHide :: forall p a m. (MonadEval m, P p a, PP p a ~ Bool) => POpts -> a -> m (TT (PP p a))
- evalHide :: forall p a m. (MonadEval m, P p a) => POpts -> a -> m (TT (PP p a))
- evalQuick :: forall opts p i. (OptC opts, P p i) => i -> Either String (PP p i)
- data Wrap (t :: Type) p
- data Wrap' t p
- data Unwrap
- data Fail t prt
- data FailP p
- data FailT (t :: Type) p
- data FailS p
- data Fst
- data Snd
- data Thd
- data L1 p
- data L2 p
- data L3 p
- data L4 p
- data L5 p
- data L6 p
- data L7 p
- data L8 p
- data L11
- data L12
- data L13
- data L21
- data L22
- data L23
- data L31
- data L32
- data L33
- data p && q
- data p &&~ q
- data p || q
- data p ||~ q
- data p ~> q
- data Not p
- data Between p q r
- data p <..> q
- data All p
- data Any p
- data IdBool
- data p >> q
- data p >>> q
- data p << q
- data (p :: k -> k1) $ (q :: k)
- data (q :: k) & (p :: k -> k1)
- data DoL (ps :: [k])
- data Swap
basic types
identity function
>>>pz @Id 23Val 23
identity function that also displays the type information for debugging
>>>pz @IdT 23Val 23
transparent wrapper to turn kind k into kind Type
eg useful for putting in a promoted list (cant mix kinds) see Do
>>>pz @'[W 123, Id] 99Val [123,99]
>>>pz @'[W "abc", W "def", Id, Id] "ghi"Val ["abc","def","ghi","ghi"]
add a message to give more context to the evaluation tree
>>>pan @(Msg "[somemessage]" Id) 999P [somemessage] Id 999 Val 999
>>>pan @(Msg Id 999) "info message:"P info message: '999 Val 999
add a message to give more context to the evaluation tree
>>>pan @(MsgI "[somemessage] " Id) 999P [somemessage] Id 999 Val 999
>>>pan @(MsgI Id 999) "info message:"P info message:'999 Val 999
run the expression p but remove the subtrees
override the display width for the expression p
Acts as a proxy for a Type.
used internally for type inference
similar to length
>>>pz @Len [10,4,5,12,3,4]Val 6
>>>pz @Len []Val 0
>>>pz @(Pairs >> Len > 2) "abcdef"Val True
similar to length for Foldable instances
>>>pz @(Length Id) (Left "aa")Val 0
>>>pz @(Length Id) (Right "aa")Val 1
>>>pz @(Length Right') (Right "abcd")Val 4
>>>pz @(Length L23) (True,(23,'x',[10,9,1,3,4,2]))Val 6
similar to map for foldable
>>>pz @(Map' Pred Id) [1..5]Val [0,1,2,3,4]
similar to map
>>>pz @(Map Pred) [1..5]Val [0,1,2,3,4]
processes a type level list predicates running each in sequence with infixr: see >>
>>>pz @(Do [Pred, ShowP Id, Id &&& Len]) 9876543Val ("9876542",7)
>>>pz @(Do '[W 123, W "xyz", Len &&& Id, Pred *** Id<>Id]) ()Val (2,"xyzxyz")
>>>pl @(Do '[Succ,Id,ShowP Id,Ones,Map (ReadBase Int 8)]) 1239Present [1,2,4,0] ((>>) [1,2,4,0] | {Map [1,2,4,0] | ["1","2","4","0"]}) Val [1,2,4,0]
>>>pl @(Do '[Pred,Id,ShowP Id,Ones,Map (ReadBase Int 8)]) 1239Error invalid base 8 (Map(i=3, a="8") excnt=1) Fail "invalid base 8"
>>>pl @(Do '[4,5,6]) ()Present 6 ((>>) 6 | {'6}) Val 6
>>>pl @(Do '["abc", "Def", "ggg", "hhhhh"]) ()Present "hhhhh" ((>>) "hhhhh" | {'"hhhhh"}) Val "hhhhh"
>>>pl @(Do '[ 'LT, 'EQ, 'GT ]) ()Present GT ((>>) GT | {'GT}) Val GT
>>>pl @(Do '[4 % 4,22 % 1 ,12 -% 4]) ()Present (-3) % 1 ((>>) (-3) % 1 | {Negate (-3) % 1 | 3 % 1}) Val ((-3) % 1)
>>>pl @(Do '[1,2,3]) ()Present 3 ((>>) 3 | {'3}) Val 3
data Pure (t :: Type -> Type) p #
similar to pure
>>>pz @(Pure Maybe Id) 4Val (Just 4)
>>>pz @(Pure [] Id) 4Val [4]
>>>pz @(Pure (Either String) Fst) (13,True)Val (Right 13)
>>>pl @(Pure Maybe Id) 'x'Present Just 'x' (Pure Just 'x' | 'x') Val (Just 'x')
>>>pl @(Pure (Either _) Id) 'x'Present Right 'x' (Pure Right 'x' | 'x') Val (Right 'x')
>>>pl @(Pure (Either _) Id >> Swap) 'x'Present Left 'x' ((>>) Left 'x' | {Swap Left 'x' | Right 'x'}) Val (Left 'x')
>>>pl @(Pure (Either ()) Id >> Swap) 'x'Present Left 'x' ((>>) Left 'x' | {Swap Left 'x' | Right 'x'}) Val (Left 'x')
>>>pl @(Pure (Either String) Id >> Swap) 123Present Left 123 ((>>) Left 123 | {Swap Left 123 | Right 123}) Val (Left 123)
similar to coerce
>>>pz @(Coerce (SG.Sum Integer)) (Identity (-13))Val (Sum {getSum = -13})
>>>pl @(Coerce SG.Any) TruePresent Any {getAny = True} (Coerce Any {getAny = True} | True) Val (Any {getAny = True})
>>>pl @(Coerce Bool) (SG.Any True)Present True (Coerce True | Any {getAny = True}) Val True
>>>pz @(Proxy 'True >> Coerce (Proxy 'False)) () ^!? acts . _Val . to typeRepJust 'False
>>>pz @(Proxy Int >> Coerce (Proxy (String,Char))) () ^!? acts . _Val . to typeRepJust ([Char],Char)
>>>import qualified GHC.Exts as GE>>>pz @(Proxy GE.Any >> Coerce (Proxy Int)) () ^!? acts . _Val . to typeRepJust Int
>>>pz @(Proxy '(_,_) >> Coerce (Proxy '(Float,Int))) () ^!? acts . _Val . to typeRepJust ('(,) * * Float Int)
gets the singleton value from a foldable
>>>pl @OneP [10..15]Error OneP:expected one element(6) Fail "OneP:expected one element(6)"
>>>pl @OneP [10]Present 10 (OneP) Val 10
>>>pl @OneP []Error OneP:expected one element(empty) Fail "OneP:expected one element(empty)"
>>>pl @OneP (Just 10)Present 10 (OneP) Val 10
>>>pl @OneP NothingError OneP:expected one element(empty) Fail "OneP:expected one element(empty)"
core class
This is the core class. Each instance of this class can be combined into a dsl using >>
Methods
Instances
| GetBool b => P (b :: Bool) a # | pulls the type level
|
| GetOrdering cmp => P (cmp :: Ordering) a # | extracts the value level representation of the promoted
|
| KnownNat n => P (n :: Nat) a # | extracts the value level representation of the type level
|
| KnownSymbol s => P (s :: Symbol) a # | pulls the type level
|
| P () a # | extracts the value level representation of the type level '()
|
| P () a # |
|
| P L33T x => P L33 x # | |
| P L32T x => P L32 x # | |
| P L31T x => P L31 x # | |
| P L23T x => P L23 x # | |
| P L22T x => P L22 x # | |
| P L21T x => P L21 x # | |
| P L13T x => P L13 x # | |
| P L12T x => P L12 x # | |
| P L11T x => P L11 x # | |
| P ThdT x => P Thd x # | |
| P SndT x => P Snd x # | |
| P FstT x => P Fst x # | |
| (Foldable t, x ~ t a) => P OneP x # | |
| x ~ Bool => P IdBool x # | |
| (Show a, x ~ [a]) => P Len x # | |
| (Show x, Show (Unwrapped x), Wrapped x) => P Unwrap x # | |
| (Typeable a, Show a) => P IdT a # | |
| Show a => P Id a # | |
| P ReverseITuple () # | |
Defined in Predicate.Data.Tuple Associated Types type PP ReverseITuple () :: Type # Methods eval :: MonadEval m => proxy ReverseITuple -> POpts -> () -> m (TT (PP ReverseITuple ())) # | |
| ToITupleC x => P ToITuple x # | |
| ([a] ~ x, Show a) => P Pairs x # | |
| Show x => P Dup x # | |
| P IsTheseT x => P IsThese x # | |
| P IsThatT x => P IsThat x # | |
| P IsThisT x => P IsThis x # | |
| P ThesesT x => P Theses x # | |
| P ThatsT x => P Thats x # | |
| P ThissT x => P Thiss x # | |
| ToStringC x => P ToString x # | |
| P TrimBothT x => P TrimBoth x # | |
| P TrimRT x => P TrimR x # | |
| P TrimLT x => P TrimL x # | |
| P Proxy2T x # | |
| P Proxy1T x # | |
| Show x => P ProxyT x # | |
| P NegativeT x => P Negative x # | |
| P PositiveT x => P Positive x # | |
| P AllNegativeT x => P AllNegative x # | |
Defined in Predicate.Data.Ordering Associated Types type PP AllNegative x :: Type # Methods eval :: MonadEval m => proxy AllNegative -> POpts -> x -> m (TT (PP AllNegative x)) # | |
| P AllPositiveT x => P AllPositive x # | |
Defined in Predicate.Data.Ordering Associated Types type PP AllPositive x :: Type # Methods eval :: MonadEval m => proxy AllPositive -> POpts -> x -> m (TT (PP AllPositive x)) # | |
| P DescT' x => P Desc' x # | |
| P DescT x => P Desc x # | |
| P AscT' x => P Asc' x # | |
| P AscT x => P Asc x # | |
| P (OrdA' Id Id) x => P OrdA x # | |
| P OddT x => P Odd x # | |
| P EvenT x => P Even x # | |
| P MEmptyPT x => P MEmptyP x # | |
| (x ~ [a], Show a, Ord a) => P Nub x # | |
| (x ~ [a], Ord a, Show a) => P Max x # | |
| (x ~ [a], Ord a, Show a) => P Min x # | |
| (x ~ [a], Num a, Show a) => P Product x # | |
| (x ~ [a], Num a, Show a) => P Sum x # | |
| (Reversing t, Show t) => P ReverseL t # | |
| (x ~ [a], Show a) => P Reverse x # | |
| P SortT x => P Sort x # | |
| P Unzip3T x => P Unzip3 x # | |
| P UnzipT x => P Unzip x # | |
| (Snoc s s (ConsT s) (ConsT s), x ~ s, Show s) => P Init x # | |
| (Snoc x x (ConsT x) (ConsT x), Show (ConsT x), Show x) => P Last x # | |
| (Cons x x (ConsT x) (ConsT x), Show x) => P Tail x # | |
| (Cons x x (ConsT x) (ConsT x), Show (ConsT x), Show x) => P Head x # | |
| x ~ [a] => P Ones x # | |
| ([a] ~ x, Show a) => P Tails x # | |
| ([a] ~ x, Show a) => P Inits x # | |
| P GroupCntT x => P GroupCnt x # | |
| P GroupT x => P Group x # | |
| (a ~ [x], Ord x) => P GroupCntStable a # | |
Defined in Predicate.Data.List Associated Types type PP GroupCntStable a :: Type # Methods eval :: MonadEval m => proxy GroupCntStable -> POpts -> a -> m (TT (PP GroupCntStable a)) # | |
| (Show (ConsT s), Show s, Snoc s s (ConsT s) (ConsT s)) => P Unsnoc s # | |
| (Show (ConsT s), Show s, Cons s s (ConsT s) (ConsT s)) => P Uncons s # | |
| (x ~ t a, Show x, Foldable t, a ~ Bool) => P Ors x # | |
| (x ~ t a, Show (t a), Foldable t, a ~ Bool) => P Ands x # | |
| P NullT a => P Null a # | |
| (Show a, Show x, x ~ t [a], Foldable t) => P Concat x # | |
| (Show l, IsList l, Show (Item l)) => P ToListExt l # | |
| (Show as, AsEmpty as) => P IsEmpty as # | |
| P CatMaybesT x => P CatMaybes x # | |
| x ~ Maybe a => P IsNothing x # | |
| x ~ Maybe a => P IsJust x # | |
| (Show x, Enum x) => P FromEnum x # | |
| (Show x, Enum x) => P Pred x # | |
| (Show x, Enum x) => P Succ x # | |
| P GenIO x # | |
| P Stdin x # | |
| P TimeZt a # | |
| P TimeUtc a # | |
| P ReadEnvAll a # | |
Defined in Predicate.Data.IO Associated Types type PP ReadEnvAll a :: Type # Methods eval :: MonadEval m => proxy ReadEnvAll -> POpts -> a -> m (TT (PP ReadEnvAll a)) # | |
| P IListT x => P IList x # | |
| x ~ [Int] => P IsLuhn x # | |
| (Show x, Integral x) => P PrimePrev x # | |
| (Show x, Integral x) => P PrimeNext x # | |
| (x ~ a, Show a, Integral a) => P IsPrime x # | |
| P InitMayT x => P InitMay x # | |
| P TailMayT x => P TailMay x # | |
| P LastMayT x => P LastMay x # | |
| P HeadMayT x => P HeadMay x # | |
| x ~ Either a b => P IsRight x # | |
| x ~ Either a b => P IsLeft x # | |
| (ToTimeC x, Show x) => P ToTime x # | |
| (ToDayC x, Show x) => P ToDay x # | |
| (Show a, IsText a) => P ToTitle a # | |
| (Show a, IsText a) => P ToUpper a # | |
| (Show a, IsText a) => P ToLower a # | |
| P IsLatin1AllT x => P IsLatin1All x # | |
Defined in Predicate.Data.Char Associated Types type PP IsLatin1All x :: Type # Methods eval :: MonadEval m => proxy IsLatin1All -> POpts -> x -> m (TT (PP IsLatin1All x)) # | |
| P IsSeparatorAllT x => P IsSeparatorAll x # | |
Defined in Predicate.Data.Char Associated Types type PP IsSeparatorAll x :: Type # Methods eval :: MonadEval m => proxy IsSeparatorAll -> POpts -> x -> m (TT (PP IsSeparatorAll x)) # | |
| P IsOctDigitAllT x => P IsOctDigitAll x # | |
Defined in Predicate.Data.Char Associated Types type PP IsOctDigitAll x :: Type # Methods eval :: MonadEval m => proxy IsOctDigitAll -> POpts -> x -> m (TT (PP IsOctDigitAll x)) # | |
| P IsHexDigitAllT x => P IsHexDigitAll x # | |
Defined in Predicate.Data.Char Associated Types type PP IsHexDigitAll x :: Type # Methods eval :: MonadEval m => proxy IsHexDigitAll -> POpts -> x -> m (TT (PP IsHexDigitAll x)) # | |
| P IsControlAllT x => P IsControlAll x # | |
Defined in Predicate.Data.Char Associated Types type PP IsControlAll x :: Type # Methods eval :: MonadEval m => proxy IsControlAll -> POpts -> x -> m (TT (PP IsControlAll x)) # | |
| P IsPunctuationAllT x => P IsPunctuationAll x # | |
Defined in Predicate.Data.Char Associated Types type PP IsPunctuationAll x :: Type # Methods eval :: MonadEval m => proxy IsPunctuationAll -> POpts -> x -> m (TT (PP IsPunctuationAll x)) # | |
| P IsSpaceAllT x => P IsSpaceAll x # | |
Defined in Predicate.Data.Char Associated Types type PP IsSpaceAll x :: Type # Methods eval :: MonadEval m => proxy IsSpaceAll -> POpts -> x -> m (TT (PP IsSpaceAll x)) # | |
| P IsDigitAllT x => P IsDigitAll x # | |
Defined in Predicate.Data.Char Associated Types type PP IsDigitAll x :: Type # Methods eval :: MonadEval m => proxy IsDigitAll -> POpts -> x -> m (TT (PP IsDigitAll x)) # | |
| P IsUpperAllT x => P IsUpperAll x # | |
Defined in Predicate.Data.Char Associated Types type PP IsUpperAll x :: Type # Methods eval :: MonadEval m => proxy IsUpperAll -> POpts -> x -> m (TT (PP IsUpperAll x)) # | |
| P IsLowerAllT x => P IsLowerAll x # | |
Defined in Predicate.Data.Char Associated Types type PP IsLowerAll x :: Type # Methods eval :: MonadEval m => proxy IsLowerAll -> POpts -> x -> m (TT (PP IsLowerAll x)) # | |
| P IsLatin1T x => P IsLatin1 x # | |
| P IsSeparatorT x => P IsSeparator x # | |
Defined in Predicate.Data.Char Associated Types type PP IsSeparator x :: Type # Methods eval :: MonadEval m => proxy IsSeparator -> POpts -> x -> m (TT (PP IsSeparator x)) # | |
| P IsOctDigitT x => P IsOctDigit x # | |
Defined in Predicate.Data.Char Associated Types type PP IsOctDigit x :: Type # Methods eval :: MonadEval m => proxy IsOctDigit -> POpts -> x -> m (TT (PP IsOctDigit x)) # | |
| P IsHexDigitT x => P IsHexDigit x # | |
Defined in Predicate.Data.Char Associated Types type PP IsHexDigit x :: Type # Methods eval :: MonadEval m => proxy IsHexDigit -> POpts -> x -> m (TT (PP IsHexDigit x)) # | |
| P IsControlT x => P IsControl x # | |
| P IsPunctuationT x => P IsPunctuation x # | |
Defined in Predicate.Data.Char Associated Types type PP IsPunctuation x :: Type # Methods eval :: MonadEval m => proxy IsPunctuation -> POpts -> x -> m (TT (PP IsPunctuation x)) # | |
| P IsSpaceT x => P IsSpace x # | |
| P IsDigitT x => P IsDigit x # | |
| P IsUpperT x => P IsUpper x # | |
| P IsLowerT x => P IsLower x # | |
| (Show a, Show b) => P Theres [These a b] # | |
| (Show a, Show b) => P Heres [These a b] # | |
| (Show a, Show b) => P PartitionThese [These a b] # | |
Defined in Predicate.Data.These 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 (f (t a)), Show (t (f a)), Traversable t, Applicative f) => P Sequence (t (f a)) # | |
| (Show (t (t a)), Show (t a), Monad t) => P Join (t (t a)) # | |
| (Show (t a), Show (t (t a)), Comonad t) => P Duplicate (t a) # | |
| (Show (t a), Show a, Comonad t) => P Extract (t a) # | |
| (Show (t a), Foldable t) => P ToList (t a) # | |
| (Show (t a), Foldable t) => P ToNEList (t a) # | |
| Show a => P Just' (Maybe a) # | |
| (Show a, Show b) => P PartitionEithers [Either a b] # | |
Defined in Predicate.Data.Either 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])) # | |
| (Show (p a b), SwapC p, Show (p b a)) => P Swap (p a b) # | |
| Typeable t => P UnproxyT (Proxy t) # | |
| ReverseITupleC x xs () => P ReverseITuple (x, xs) # | |
Defined in Predicate.Data.Tuple Associated Types type PP ReverseITuple (x, xs) :: Type # Methods eval :: MonadEval m => proxy ReverseITuple -> POpts -> (x, xs) -> m (TT (PP ReverseITuple (x, xs))) # | |
| (Show a, Show b) => P These' (These a b) # | |
| Show a => P That' (These x a) # | |
| Show a => P This' (These a x) # | |
| (AssocC p, Show (p (p a b) c), Show (p a (p b c))) => P Unassoc (p a (p b c)) # | |
| (AssocC p, Show (p (p a b) c), Show (p a (p b c))) => P Assoc (p (p a b) c) # | |
| Show a => P Right' (Either x a) # | |
| Show a => P Left' (Either a x) # | |
| P ([] :: [k]) a # | extracts the value level representation of the type level '[]
|
| Typeable t => P (Hole t :: Type) a # | |
| (KnownNat n, FailWhenT (n <=? 0) (Text "ToITupleList:n cannot be 0"), ToITupleListC n a, xs ~ [a]) => P (ToITupleList n :: Type) xs # | |
Defined in Predicate.Data.Tuple Associated Types type PP (ToITupleList n) xs :: Type # Methods eval :: MonadEval m => proxy (ToITupleList n) -> POpts -> xs -> m (TT (PP (ToITupleList n) xs)) # | |
| (KnownNat n, FailWhenT (n <=? 1) (Text "Tuple':n cannot be less than two but found n=" :<>: ShowType n), TupleC n a, x ~ [a]) => P (Tuple' n :: Type) x # | |
| (KnownNat n, FailWhenT (n <=? 1) (Text "Tuple:n cannot be less than two but found n=" :<>: ShowType n), TupleC n a, x ~ [a], Show a) => P (Tuple n :: Type) x # | |
| (2 <= n, n <= 36, KnownNat n, Integral x) => P (ShowBase n :: Type) x # | |
| P (FloorT t) x => P (Floor t :: Type) x # | |
| P (CeilingT t) x => P (Ceiling t :: Type) x # | |
| P (TruncateT t) x => P (Truncate t :: Type) x # | |
| P (FromRationalT t) x => P (FromRational t :: Type) x # | |
Defined in Predicate.Data.Numeric Associated Types type PP (FromRational t) x :: Type # Methods eval :: MonadEval m => proxy (FromRational t) -> POpts -> x -> m (TT (PP (FromRational t) x)) # | |
| P (FromIntegralT t) x => P (FromIntegral t :: Type) x # | |
Defined in Predicate.Data.Numeric Associated Types type PP (FromIntegral t) x :: Type # Methods eval :: MonadEval m => proxy (FromIntegral t) -> POpts -> x -> m (TT (PP (FromIntegral t) x)) # | |
| P (FromIntegerT t) x => P (FromInteger t :: Type) x # | |
Defined in Predicate.Data.Numeric Associated Types type PP (FromInteger t) x :: Type # Methods eval :: MonadEval m => proxy (FromInteger t) -> POpts -> x -> m (TT (PP (FromInteger t) x)) # | |
| P (MEmptyTT t) x => P (MEmptyT t :: Type) x # | |
| P (SapT t) x => P (Sap t :: Type) x # | |
| Alternative t => P (EmptyT t :: Type) x # | |
| P (EmptyList t :: Type) x # | |
| (Show l, IsList l, l ~ l') => P (FromListExt l' :: Type) l # | |
Defined in Predicate.Data.Foldable Associated Types type PP (FromListExt l') l :: Type # Methods eval :: MonadEval m => proxy (FromListExt l') -> POpts -> l -> m (TT (PP (FromListExt l') l)) # | |
| (a ~ Item t, Show t, IsList t, [a] ~ x) => P (FromList t :: Type) x # | |
| P (IToListT t) x => P (IToList t :: Type) x # | |
| P (MkNothing t :: Type) x # | |
| P (IxT' n) x => P (Ix' n :: Type) x # | |
| P (UniverseT t) x => P (Universe t :: Type) x # | |
| P (ToEnumBFailT t) x => P (ToEnumBFail t :: Type) x # | |
Defined in Predicate.Data.Enum Associated Types type PP (ToEnumBFail t) x :: Type # Methods eval :: MonadEval m => proxy (ToEnumBFail t) -> POpts -> x -> m (TT (PP (ToEnumBFail t) x)) # | |
| P (ToEnumT t) x => P (ToEnum t :: Type) x # | |
| P (CT s) x => P (C s :: Type) x # | |
| (KnownSymbol s, FailUnlessT (CmpSymbol s "" == GT) (Text "Char1 symbol cannot be empty")) => P (Char1 s :: Type) a # | |
| P (Nothing :: Maybe a1) (Maybe a2) # | expects Nothing otherwise it fails
if the value is Nothing then it returns
|
| (Show a2, PP p x ~ Maybe a2, P p x) => P (Just p :: Maybe a1) x # | tries to extract
|
| P (Proxy t :: Type) a # | create a Proxy for a kind
|
| (Coercible t a, Show a, Show t) => P (Coerce t :: Type) a # | |
| P (DoExpandLT ps) a => P (DoL ps :: Type) a # | |
| P (DoExpandT ps) a => P (Do ps :: Type) a # | |
| (Show (PP p a), P p a, x ~ [a], Show a) => P (Map p :: Type) x # | |
| (Show (ExtractL8T (PP p x)), ExtractL8C (PP p x), P p x, Show (PP p x)) => P (L8 p :: Type) x # | |
| (Show (ExtractL7T (PP p x)), ExtractL7C (PP p x), P p x, Show (PP p x)) => P (L7 p :: Type) x # | |
| (Show (ExtractL6T (PP p x)), ExtractL6C (PP p x), P p x, Show (PP p x)) => P (L6 p :: Type) x # | |
| (Show (ExtractL5T (PP p x)), ExtractL5C (PP p x), P p x, Show (PP p x)) => P (L5 p :: Type) x # | |
| (Show (ExtractL4T (PP p x)), ExtractL4C (PP p x), P p x, Show (PP p x)) => P (L4 p :: Type) x # | |
| (Show (ExtractL3T (PP p x)), ExtractL3C (PP p x), P p x, Show (PP p x)) => P (L3 p :: Type) x # | |
| (Show (ExtractL2T (PP p x)), ExtractL2C (PP p x), P p x, Show (PP p x)) => P (L2 p :: Type) x # | |
| (Show (ExtractL1T (PP p x)), ExtractL1C (PP p x), P p x, Show (PP p x)) => P (L1 p :: Type) x # | |
| (P p a, PP p a ~ Bool, x ~ f a, Show a, Foldable f) => P (Any p :: Type) x # | |
| (P p a, PP p a ~ Bool, x ~ f a, Show a, Foldable f) => P (All p :: Type) x # | |
| P (Fail UnproxyT p) x => P (FailP p :: Type) x # | |
| P (Fail Id p) x => P (FailS p :: Type) x # | |
| (PP p x ~ Bool, P p x) => P (Not p :: Type) x # | |
| (PP p x ~ t a, P p x, Show (t a), Foldable t) => P (Length p :: Type) x # | |
| P p x => P (Hide p :: Type) x # | |
| P p a => P (W p :: Type) a # | |
| P (EachITuple p :: Type) () # | |
Defined in Predicate.Data.Tuple Associated Types type PP (EachITuple p) () :: Type # Methods eval :: MonadEval m => proxy (EachITuple p) -> POpts -> () -> m (TT (PP (EachITuple p) ())) # | |
| P (SecondT q) x => P (Second q :: Type) x # | |
| P (FirstT p) x => P (First p :: Type) x # | |
| (PP p x ~ ([String] -> String), P p x) => P (ReplaceFn3 p :: Type) x # | |
Defined in Predicate.Data.Regex Associated Types type PP (ReplaceFn3 p) x :: Type # Methods eval :: MonadEval m => proxy (ReplaceFn3 p) -> POpts -> x -> m (TT (PP (ReplaceFn3 p) x)) # | |
| (PP p x ~ (String -> String), P p x) => P (ReplaceFn2 p :: Type) x # | |
Defined in Predicate.Data.Regex Associated Types type PP (ReplaceFn2 p) x :: Type # Methods eval :: MonadEval m => proxy (ReplaceFn2 p) -> POpts -> x -> m (TT (PP (ReplaceFn2 p) x)) # | |
| (PP p x ~ (String -> [String] -> String), P p x) => P (ReplaceFn1 p :: Type) x # | |
Defined in Predicate.Data.Regex Associated Types type PP (ReplaceFn1 p) x :: Type # Methods eval :: MonadEval m => proxy (ReplaceFn1 p) -> POpts -> x -> m (TT (PP (ReplaceFn1 p) x)) # | |
| P (ResplitT p) x => P (Resplit p :: Type) x # | |
| P (RescanT p) x => P (Rescan p :: Type) x # | |
| P (ReT p) x => P (Re p :: Type) x # | |
| (PrintC bs, (b, bs) ~ x, PrintfArg b, PP s x ~ String, P s x) => P (PrintI s :: Type) x # | |
| (Show (PP p x), P p x) => P (ShowP p :: Type) x # | |
| PP p x ~ proxy z => P (Proxify p :: Type) x # | |
| P (NeT n) x => P (Ne n :: Type) x # | |
| P (LtT n) x => P (Lt n :: Type) x # | |
| P (LeT n) x => P (Le n :: Type) x # | |
| P (SameT n) x => P (Same n :: Type) x # | |
| P (GeT n) x => P (Ge n :: Type) x # | |
| P (GtT n) x => P (Gt n :: Type) x # | |
| (x ~ [a], PP n x ~ b, P n x, Integral a, Integral b) => P (UnShowBaseN n :: Type) x # | |
Defined in Predicate.Data.Numeric Associated Types type PP (UnShowBaseN n) x :: Type # Methods eval :: MonadEval m => proxy (UnShowBaseN n) -> POpts -> x -> m (TT (PP (UnShowBaseN n) x)) # | |
| P (ToBitsT p) x => P (ToBits p :: Type) x # | |
| P (ReadBaseT t n) x => P (ReadBase t n :: Type) x # | |
| (Num (PP p x), P p x, Show (PP p x)) => P (Signum p :: Type) x # | |
| (Num (PP p x), P p x, Show (PP p x)) => P (Abs p :: Type) x # | |
| (Num (PP p x), P p x, Show (PP p x)) => P (Negate p :: Type) x # | |
| (a ~ PP p x, Show a, Real a, P p x) => P (ToRational p :: Type) x # | |
Defined in Predicate.Data.Numeric Associated Types type PP (ToRational p) x :: Type # Methods eval :: MonadEval m => proxy (ToRational p) -> POpts -> x -> m (TT (PP (ToRational p) x)) # | |
| (Show (PP t a), Monoid (PP t a)) => P (MEmptyT' t :: Type) a # | |
| (PP p x ~ NonEmpty a, P p x, Show a, Semigroup a) => P (SConcat p :: Type) x # | |
| (PP p x ~ [a], P p x, Show a, Monoid a) => P (MConcat p :: Type) x # | |
| P (EmptyList' t :: Type) x # | |
Defined in Predicate.Data.List Associated Types type PP (EmptyList' t) x :: Type # Methods eval :: MonadEval m => proxy (EmptyList' t) -> POpts -> x -> m (TT (PP (EmptyList' t) x)) # | |
| P p x => P (Singleton p :: Type) x # | |
| P (ChunksOfT n) x => P (ChunksOf n :: Type) x # | |
| P (Quant p) x => P (All1 p :: Type) x # | |
| P (QuantT p) x => P (Quant p :: Type) x # | |
| P (RDotExpandT ps q) a => P (RDot ps q :: Type) a # | |
| P (DotExpandT ps q) a => P (Dot ps q :: Type) a # | |
| (Show (PP p a), P p a) => P (Skip p :: Type) a # | |
| P (TraverseT p) x => P (Traverse p :: Type) x # | |
| (Show (t a), Foldable t, t a ~ PP p x, P p x) => P (Null' p :: Type) x # | |
| (Show (f a), Typeable (PP t x), Show (PP t x), FoldableWithIndex (PP t x) f, x ~ f a, Show a) => P (IToList' t :: Type) x # | |
| (PP p x ~ a, P p x, Show a) => P (MkJust p :: Type) x # | |
| P (MkNothing' t :: Type) a # | |
Defined in Predicate.Data.Maybe Associated Types type PP (MkNothing' t) a :: Type # Methods eval :: MonadEval m => proxy (MkNothing' t) -> POpts -> a -> m (TT (PP (MkNothing' t) a)) # | |
| (PP p x ~ a, Show a, Enum a, Bounded a) => P (Universe' p :: Type) x # | |
| (Show a, Enum a, PP p x ~ a, P p x) => P (FromEnum' p :: Type) x # | |
| P (PredBT' q) x => P (PredB' q :: Type) x # | |
| P (SuccBT' q) x => P (SuccB' q :: Type) x # | |
| ([a] ~ x, GetLen ps, P (ParaImpl (LenT ps) ps) x) => P (Para ps :: Type) x # | |
| P (ScanNAT q) x => P (ScanNA q :: Type) x # | |
| (RandomGen (PP p x), P p x) => P (GenRange p :: Type) x # | |
| (RandomGen (PP p x), P p x) => P (GenNext p :: Type) x # | |
| (RandomGen (PP p x), P p x) => P (GenSplit p :: Type) x # | |
| (PP p x ~ Int, P p x) => P (GenPure p :: Type) x # | |
| P (StderrT p) x => P (Stderr p :: Type) x # | |
| P (StdoutT p) x => P (Stdout p :: Type) x # | |
| (PP p x ~ String, P p x) => P (ReadEnv p :: Type) x # | |
| (PP p x ~ String, P p x) => P (ReadDir p :: Type) x # | |
| P (DirExistsT p) x => P (DirExists p :: Type) x # | |
| P (FileExistsT p) x => P (FileExists p :: Type) x # | |
Defined in Predicate.Data.IO Associated Types type PP (FileExists p) x :: Type # Methods eval :: MonadEval m => proxy (FileExists p) -> POpts -> x -> m (TT (PP (FileExists p) x)) # | |
| (PP p x ~ String, P p x) => P (ReadFileBinary p :: Type) x # | |
Defined in Predicate.Data.IO Associated Types type PP (ReadFileBinary p) x :: Type # Methods eval :: MonadEval m => proxy (ReadFileBinary p) -> POpts -> x -> m (TT (PP (ReadFileBinary p) x)) # | |
| (PP p x ~ String, P p x) => P (ReadFile p :: Type) x # | |
| (Integral (PP n x), P n x) => P (PrimeFactors n :: Type) x # | |
Defined in Predicate.Data.Extra Associated Types type PP (PrimeFactors n) x :: Type # Methods eval :: MonadEval m => proxy (PrimeFactors n) -> POpts -> x -> m (TT (PP (PrimeFactors n) x)) # | |
| (Integral (PP n x), P n x) => P (Primes n :: Type) x # | |
| (PP p x ~ LocalTime, P p x) => P (LocalTimeToUTC p :: Type) x # | |
Defined in Predicate.Data.DateTime Associated Types type PP (LocalTimeToUTC p) x :: Type # Methods eval :: MonadEval m => proxy (LocalTimeToUTC p) -> POpts -> x -> m (TT (PP (LocalTimeToUTC p) x)) # | |
| (PP p x ~ UTCTime, P p x) => P (UTCTimeToPosix p :: Type) x # | |
Defined in Predicate.Data.DateTime Associated Types type PP (UTCTimeToPosix p) x :: Type # Methods eval :: MonadEval m => proxy (UTCTimeToPosix p) -> POpts -> x -> m (TT (PP (UTCTimeToPosix p) x)) # | |
| (PP p x ~ Rational, P p x) => P (PosixToUTCTime p :: Type) x # | |
Defined in Predicate.Data.DateTime Associated Types type PP (PosixToUTCTime p) x :: Type # Methods eval :: MonadEval m => proxy (PosixToUTCTime p) -> POpts -> x -> m (TT (PP (PosixToUTCTime p) x)) # | |
| (PP p x ~ TimeOfDay, P p x) => P (UnMkTime p :: Type) x # | |
| P (MkTimeT p) x => P (MkTime p :: Type) x # | |
| (P p x, PP p x ~ Day) => P (ToWeekYear p :: Type) x # | |
Defined in Predicate.Data.DateTime Associated Types type PP (ToWeekYear p) x :: Type # Methods eval :: MonadEval m => proxy (ToWeekYear p) -> POpts -> x -> m (TT (PP (ToWeekYear p) x)) # | |
| (P p x, PP p x ~ Day) => P (ToWeekDate p :: Type) x # | |
Defined in Predicate.Data.DateTime Associated Types type PP (ToWeekDate p) x :: Type # Methods eval :: MonadEval m => proxy (ToWeekDate p) -> POpts -> x -> m (TT (PP (ToWeekDate p) x)) # | |
| P (MkDayExtraT p) x => P (MkDayExtra p :: Type) x # | |
Defined in Predicate.Data.DateTime Associated Types type PP (MkDayExtra p) x :: Type # Methods eval :: MonadEval m => proxy (MkDayExtra p) -> POpts -> x -> m (TT (PP (MkDayExtra p) x)) # | |
| (PP p x ~ Day, P p x) => P (UnMkDay p :: Type) x # | |
| P (MkDayT p) x => P (MkDay p :: Type) x # | |
| P (FormatTimePT p) x => P (FormatTimeP p :: Type) x # | |
Defined in Predicate.Data.DateTime Associated Types type PP (FormatTimeP p) x :: Type # Methods eval :: MonadEval m => proxy (FormatTimeP p) -> POpts -> x -> m (TT (PP (FormatTimeP p) x)) # | |
| (Show a, P p a, PP p a ~ Bool) => P (GuardSimple p :: Type) a # | |
Defined in Predicate.Data.Condition Associated Types type PP (GuardSimple p) a :: Type # Methods eval :: MonadEval m => proxy (GuardSimple p) -> POpts -> a -> m (TT (PP (GuardSimple p) a)) # | |
| (Show t, Bits t) => P (ZeroBits t :: Type) a # | |
| (P p a, Show (PP p a), Bits (PP p a)) => P (PopCount p :: Type) a # | |
| (Traversable n, P p a) => P (FMap p :: Type) (n a) # | |
| (P p b, P (EachITuple p) bs) => P (EachITuple p :: Type) (b, bs) # | |
Defined in Predicate.Data.Tuple Associated Types type PP (EachITuple p) (b, bs) :: Type # Methods eval :: MonadEval m => proxy (EachITuple p) -> POpts -> (b, bs) -> m (TT (PP (EachITuple p) (b, bs))) # | |
| (P p a, P p a') => P (Both p :: Type) (a, 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 # | |
| (Show (PP p a), Show a, P p a) => P (p ': ([] :: [k]) :: [k]) a # | runs each predicate in turn from the promoted list
|
| (P p x, Show (PP p x), Show (t (PP p x)), Applicative t) => P (Pure t p :: Type) x # | |
| P (Fail (Hole t) p) x => P (FailT t p :: Type) x # | |
| P (WrapT t p) x => P (Wrap t p :: Type) x # | |
| (KnownNat n, P p a) => P (Width n p :: Type) a # | |
| P (MkThatT t p) x => P (MkThat t p :: Type) x # | |
| P (MkThisT t p) x => P (MkThis t p :: Type) x # | |
| P (FromStringPT t p) x => P (FromString t p :: Type) x # | |
Defined in Predicate.Data.String Associated Types type PP (FromString t p) x :: Type # Methods eval :: MonadEval m => proxy (FromString t p) -> POpts -> x -> m (TT (PP (FromString t p) x)) # | |
| (GetReplaceFnSub r, PP p x ~ String, P p x) => P (ReplaceFn r p :: Type) x # | |
| P (ReadMaybeT t p) x => P (ReadMaybe t p :: Type) x # | |
| P (ReadPT t p) x => P (ReadP t p :: Type) x # | |
| (GetBool pretty, ToJSON (PP p x), P p x) => P (EncodeJson pretty p :: Type) x # | |
Defined in Predicate.Data.Json Associated Types type PP (EncodeJson pretty p) x :: Type # Methods eval :: MonadEval m => proxy (EncodeJson pretty p) -> POpts -> x -> m (TT (PP (EncodeJson pretty p) x)) # | |
| P (ParseJsonFileT t p) x => P (ParseJsonFile t p :: Type) x # | |
Defined in Predicate.Data.Json Associated Types type PP (ParseJsonFile t p) x :: Type # Methods eval :: MonadEval m => proxy (ParseJsonFile t p) -> POpts -> x -> m (TT (PP (ParseJsonFile t p) x)) # | |
| P (ParseJsonT t p) x => P (ParseJson t p :: Type) x # | |
| P (FoldMapT t p) x => P (FoldMap t p :: Type) x # | |
| (P def (Proxy a), PP def (Proxy a) ~ a, KnownNat n, Show a, [a] ~ x) => P (Ix n def :: Type) x # | |
| P (ToEnumBDefT t def) x => P (ToEnumBDef t def :: Type) x # | |
Defined in Predicate.Data.Enum Associated Types type PP (ToEnumBDef t def) x :: Type # Methods eval :: MonadEval m => proxy (ToEnumBDef t def) -> POpts -> x -> m (TT (PP (ToEnumBDef t def) x)) # | |
| P (DoNT n p) a => P (DoN n p :: Type) a # | |
| P (RepeatT n p) a => P (Repeat n p :: Type) a # | |
| (x ~ [a], P (ParaImpl (LenT (RepeatT n p)) (RepeatT n p)) x, GetLen (RepeatT n p)) => P (ParaN n p :: Type) x # | |
| (Random t, P p x, Show (PP p x), RandomGen (PP p x)) => P (RandomNext t p :: Type) x # | |
Defined in Predicate.Data.IO Associated Types type PP (RandomNext t p) x :: Type # Methods eval :: MonadEval m => proxy (RandomNext t p) -> POpts -> x -> m (TT (PP (RandomNext t p) x)) # | |
| P (WriteFileT s p) x => P (WriteFile s p :: Type) x # | |
| P (WriteFileT' s p) x => P (WriteFile' s p :: Type) x # | |
Defined in Predicate.Data.IO Associated Types type PP (WriteFile' s p) x :: Type # Methods eval :: MonadEval m => proxy (WriteFile' s p) -> POpts -> x -> m (TT (PP (WriteFile' s p) x)) # | |
| P (AppendFileT s p) x => P (AppendFile s p :: Type) x # | |
Defined in Predicate.Data.IO Associated Types type PP (AppendFile s p) x :: Type # Methods eval :: MonadEval m => proxy (AppendFile s p) -> POpts -> x -> m (TT (PP (AppendFile s p) x)) # | |
| P (MkRightT t p) x => P (MkRight t p :: Type) x # | |
| P (MkLeftT t p) x => P (MkLeft t p :: Type) x # | |
| P (ParseTimePT t p) x => P (ParseTimeP t p :: Type) x # | |
Defined in Predicate.Data.DateTime Associated Types type PP (ParseTimeP t p) x :: Type # Methods eval :: MonadEval m => proxy (ParseTimeP t p) -> POpts -> x -> m (TT (PP (ParseTimeP t p) x)) # | |
| ([a] ~ x, GetLen ps, P (BoolsImpl (LenT ps) ps) x, PP (BoolsImpl (LenT ps) ps) x ~ Bool) => P (Bools ps :: Type) x # | |
| ([a] ~ x, GetLen ps, P (GuardsImpl (LenT ps) ps) x) => P (Guards ps :: Type) x # | |
| P (p q) a => P (q & p :: Type) a # | |
| P (p q) a => P (p $ q :: Type) a # | |
| (P p a, P q a, PP p a ~ Bool, PP q a ~ Bool) => P (p ~> q :: Type) a # | |
| (P p a, P q a, PP p a ~ Bool, PP q a ~ Bool) => P (p ||~ q :: Type) a # | |
| (P p a, P q a, PP p a ~ Bool, PP q a ~ Bool) => P (p || q :: Type) a # | |
| (P p a, P q a, PP p a ~ Bool, PP q a ~ Bool) => P (p &&~ q :: Type) a # | |
| (P p a, P q a, PP p a ~ Bool, PP q a ~ Bool) => P (p && q :: Type) 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 # | |
| P (BetweenT p q) x => P (p <..> q :: Type) x # | |
| (P prt a, PP prt a ~ String) => P (Fail t prt :: Type) a # | |
| (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 # | |
| P (LeftArrowsT p q) x => P (p << q :: Type) x # | |
| P (RightArrowsLeftInfixT p q) x => P (p >>> q :: Type) x # | |
| (P p a, P q (PP p a), Show (PP p a), Show (PP q (PP p a))) => P (p >> q :: Type) a # | |
| (P prt a, PP prt a ~ String, P p a) => P (MsgI prt p :: Type) a # | |
| (P prt a, PP prt a ~ String, P p a) => P (Msg prt p :: Type) a # | |
| P (OrAT p q) x => P (p |+ q :: Type) x # | |
| P (AndAT p q) x => P (p &* q :: Type) x # | |
| P (WAmpT p q) x => P (p &&& q :: Type) x # | |
| (PP p x ~ String, PP q x ~ These a b, P p x, P q x) => P (TheseFail p q :: Type) x # | |
| (PP p x ~ String, PP q x ~ These a b, P p x, P q x) => P (ThatFail p q :: Type) x # | |
| (PP p x ~ String, PP q x ~ These a b, P p x, P q x) => P (ThisFail p q :: Type) x # | |
| (PP q x ~ These a b, PP p x ~ (a, b), P q x, P p x) => P (TheseDef p q :: Type) x # | |
| (PP q x ~ These a b, PP p x ~ b, P q x, P p x) => P (ThatDef p q :: Type) x # | |
| (PP q x ~ These a b, PP p x ~ a, P q x, P p x) => P (ThisDef p q :: Type) x # | |
| (PP p a ~ [x], PP q a ~ [y], P p a, P q a, Show x, Show y) => P (ZipThese p q :: Type) a # | |
| P (TheseIdT p q) x => P (TheseId p q :: Type) x # | |
| (P p a, P q a, Show (PP p a), Show (PP q a)) => P (MkThese p q :: Type) a # | |
| (Show (PP p x), P p x) => P (MkThat' t p :: Type) x # | |
| (P p x, Show (PP p x)) => P (MkThis' t p :: Type) x # | |
| (P s a, PP s a ~ String, Show (PP t a), IsString (PP t a)) => P (FromString' t s :: Type) a # | |
Defined in Predicate.Data.String Associated Types type PP (FromString' t s) a :: Type # Methods eval :: MonadEval m => proxy (FromString' t s) -> POpts -> a -> m (TT (PP (FromString' t s) a)) # | |
| P (IsSuffixCIT p q) x => P (IsSuffixCI p q :: Type) x # | |
Defined in Predicate.Data.String Associated Types type PP (IsSuffixCI p q) x :: Type # Methods eval :: MonadEval m => proxy (IsSuffixCI p q) -> POpts -> x -> m (TT (PP (IsSuffixCI p q) x)) # | |
| P (IsInfixCIT p q) x => P (IsInfixCI p q :: Type) x # | |
| P (IsPrefixCIT p q) x => P (IsPrefixCI p q :: Type) x # | |
Defined in Predicate.Data.String Associated Types type PP (IsPrefixCI p q) x :: Type # Methods eval :: MonadEval m => proxy (IsPrefixCI p q) -> POpts -> x -> m (TT (PP (IsPrefixCI p q) x)) # | |
| P (IsSuffixCT p q) x => P (IsSuffixC p q :: Type) x # | |
| P (IsInfixCT p q) x => P (IsInfixC p q :: Type) x # | |
| P (IsPrefixCT p q) x => P (IsPrefixC p q :: Type) x # | |
| P (StripRT p q) x => P (StripR p q :: Type) x # | |
| P (StripLT p q) x => P (StripL p q :: Type) x # | |
| P (RescanRangesT p q) x => P (RescanRanges p q :: Type) x # | |
Defined in Predicate.Data.Regex Associated Types type PP (RescanRanges p q) x :: Type # Methods eval :: MonadEval m => proxy (RescanRanges p q) -> POpts -> x -> m (TT (PP (RescanRanges p q) x)) # | |
| P (PrintTT s p) x => P (PrintT s p :: Type) 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 # | |
| (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 # | |
Defined in Predicate.Data.ReadShow Associated Types type PP (ReadMaybe' t p) x :: Type # Methods eval :: MonadEval m => proxy (ReadMaybe' t p) -> POpts -> x -> m (TT (PP (ReadMaybe' t p) 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 # | |
| (PP p x ~ Proxy z, PP q x ~ Proxy w) => P (PApp p q :: Type) x # | |
| (P q x, PP p x ~ proxy z, P z (PP q x)) => P (Pop0 p q :: Type) x # | |
| (PP p a ~ String, PP p a ~ PP q a, P p a, P q a) => P (p ===~ q :: Type) a # | |
| P (OrdAT' p q) x => P (OrdA' p q :: Type) x # | |
| (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 # | |
| P (CmpI CNe p q) x => P (p /=~ q :: Type) x # | |
| P (CmpI CLt p q) x => P (p <~ q :: Type) x # | |
| P (CmpI CLe p q) x => P (p <=~ q :: Type) x # | |
| P (CmpI CEq p q) x => P (p ==~ q :: Type) x # | |
| P (CmpI CGe p q) x => P (p >=~ q :: Type) x # | |
| P (CmpI CGt p q) x => P (p >~ q :: Type) x # | |
| P (Cmp CNe p q) x => P (p /= q :: Type) x # | |
| P (Cmp CLt p q) x => P (p < q :: Type) x # | |
| P (Cmp CLe p q) x => P (p <= q :: Type) x # | |
| P (Cmp CEq p q) x => P (p == q :: Type) x # | |
| P (Cmp CGe p q) x => P (p >= q :: Type) x # | |
| P (Cmp CGt p q) x => P (p > q :: Type) x # | |
| (Integral (PP n x), Show (PP n x), PP n x ~ PP p x, P n x, P p x) => P (RoundUp n p :: Type) x # | |
| (PP p x ~ a, P p x, PP n x ~ b, P n x, Integral a, Integral b) => P (ShowBaseN n p :: Type) x # | |
| P (RemT p q) x => P (Rem p q :: Type) x # | |
| P (QuotT p q) x => P (Quot p q :: Type) x # | |
| (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 # | |
| (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 # | |
| (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 # | |
| (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 # | |
| P (NegateRatioT p q) x => P (p -% q :: Type) 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 # | |
| (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 # | |
| (PP p a ~ PP q a, P p a, P q a, Show (PP q a), Floating (PP q a), Ord (PP p a)) => P (LogBase p q :: Type) a # | |
| (PP p a ~ PP q a, P p a, P q a, Show (PP p a), Floating (PP p a), Ord (PP q a)) => P (p ** q :: Type) a # | |
| (P p a, P q a, Show (PP p a), Show (PP q a), Num (PP p a), Integral (PP q a)) => P (p ^ q :: Type) a # | |
| P (MultT p q) x => P (p * q :: Type) x # | |
| P (SubT p q) x => P (p - q :: Type) x # | |
| P (AddT p q) x => P (p + q :: Type) x # | |
| (P p x, RealFrac (PP p x), Integral (PP t x), Show (PP t x), Show (PP p x)) => P (Floor' t p :: Type) x # | |
| (P p x, RealFrac (PP p x), Integral (PP t x), Show (PP t x), Show (PP p x)) => P (Ceiling' t p :: Type) x # | |
| (P p x, RealFrac (PP p x), Integral (PP t x), Show (PP t x), Show (PP p x)) => P (Truncate' t p :: Type) x # | |
| (P p a, PP p a ~ Rational, Show (PP t a), Fractional (PP t a)) => P (FromRational' t p :: Type) a # | |
Defined in Predicate.Data.Numeric Associated Types type PP (FromRational' t p) a :: Type # Methods eval :: MonadEval m => proxy (FromRational' t p) -> POpts -> a -> m (TT (PP (FromRational' t p) 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.Data.Numeric 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.Data.Numeric 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 n a, Integral (PP n a), Semigroup (PP p a), P p a, Show (PP p a)) => P (STimes n p :: Type) a # | |
| (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 # | |
| (PP p x ~ [a], PP q x ~ [b], P p x, P q x, Show a, Show b) => P (ZipCartesian p q :: Type) x # | |
Defined in Predicate.Data.List Associated Types type PP (ZipCartesian p q) x :: Type # Methods eval :: MonadEval m => proxy (ZipCartesian p q) -> POpts -> x -> m (TT (PP (ZipCartesian p q) x)) # | |
| P (IsSuffixT p q) x => P (IsSuffix p q :: Type) x # | |
| P (IsInfixT p q) x => P (IsInfix p q :: Type) x # | |
| P (IsPrefixT p q) x => P (IsPrefix p q :: Type) x # | |
| (PP p a ~ [x], PP q a ~ [y], P p a, P q a, Show x, Show y) => P (Zip p q :: Type) a # | |
| P (SortOnDescT p q) x => P (SortOnDesc p q :: Type) x # | |
Defined in Predicate.Data.List Associated Types type PP (SortOnDesc p q) x :: Type # Methods eval :: MonadEval m => proxy (SortOnDesc p q) -> POpts -> x -> m (TT (PP (SortOnDesc p q) x)) # | |
| P (SortOnT p q) x => P (SortOn p q :: Type) x # | |
| (P p (a, a), P q x, Show a, PP q x ~ [a], PP p (a, a) ~ Ordering) => P (SortBy p q :: Type) x # | |
| P (RemoveT p q) x => P (Remove p q :: Type) x # | |
| P (KeepT p q) x => P (Keep p q :: Type) x # | |
| P (DropT n p) x => P (Drop n p :: Type) x # | |
| P (TakeT n p) x => P (Take n p :: Type) x # | |
| (PP p a ~ [b], P n a, P p a, Show b, Integral (PP n a)) => P (SplitAt n p :: Type) 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 # | |
| ([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 # | |
| (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.Data.List 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)) # | |
| P (SpanT p q) x => P (Span p q :: Type) x # | |
| (P p x, PP q a ~ [x], PP p x ~ Bool, P q a) => P (Break p q :: Type) a # | |
| P (FilterT p q) x => P (Filter p q :: Type) x # | |
| (Show x, PP q a ~ [x], PP p (x, x) ~ Bool, P p (x, x), P q a) => P (GroupBy p q :: Type) a # | |
| (P p x, Show x, PP q a ~ [x], PP p x ~ Bool, P q a) => P (Partition p q :: Type) a # | |
| P (RotateT n p) x => P (Rotate n p :: Type) 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 # | |
| (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 # | |
| (P p x, P q x, Show (PP p x), PP p x ~ [a], PP q x ~ [a]) => P (p ++ q :: Type) x # | |
| P (AppT p q) x => P (p <*> q :: Type) x # | |
| P (MBindT p q) x => P (p >>= q :: Type) x # | |
| P (FPairT p q) x => P (p <:> q :: Type) x # | |
| (Applicative n, PP p a ~ n x, PP q a ~ n y, JoinT (PP p a) (PP q a) ~ n (x, y), P p a, P q a) => P (FPair p q :: Type) a # | |
| P (FMapFlipT p q) x => P (p <&> q :: Type) x # | |
| (Traversable n, P q a, P p b, PP q a ~ n b, PP p b ~ c) => P (p <$> q :: Type) a # | |
| P (LiftT p q) x => P (Lift p q :: Type) x # | |
| P p a => P (K p q :: Type) a # | |
| P (CatchT' p s) x => P (Catch' p s :: Type) x # | |
| (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 # | |
| P (SkipBothT p q) x => P (p >|> q :: Type) x # | |
| P (SkipRT p q) x => P (p >| q :: Type) x # | |
| P (SkipLT p q) x => P (p |> q :: Type) 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 (q $& p :: Type) 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 # | |
| (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 # | |
| (P p x, P q x, Show (t b), Show (t c), Applicative t, PP p x ~ t b, PP q x ~ t c) => P (p *> q :: Type) x # | |
| (P p x, P q x, Show (t b), Show (t c), Applicative t, PP p x ~ t b, PP q x ~ t c) => P (p <* q :: Type) 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 # | |
| (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 # | |
Defined in Predicate.Data.Json Associated Types type PP (ParseJsonFile' t p) x :: Type # Methods eval :: MonadEval m => proxy (ParseJsonFile' t p) -> POpts -> x -> m (TT (PP (ParseJsonFile' t p) x)) # | |
| (P p x, PP p x ~ ByteString, Typeable (PP t x), Show (PP t x), FromJSON (PP t x)) => P (ParseJson' t p :: Type) x # | |
Defined in Predicate.Data.Json Associated Types type PP (ParseJson' t p) x :: Type # Methods eval :: MonadEval m => proxy (ParseJson' t p) -> POpts -> x -> m (TT (PP (ParseJson' t p) x)) # | |
| (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 # | |
| P (ConcatMapT p q) x => P (ConcatMap p q :: Type) x # | |
| (PP p x ~ String, PP q x ~ Maybe a, P p x, P q x) => P (JustFail p q :: Type) x # | |
| (PP p x ~ a, PP q x ~ Maybe a, P p x, P q x) => P (JustDef p q :: Type) x # | |
| P (MaybeBoolT b p) x => P (MaybeBool b p :: Type) x # | |
| P (MapMaybeT p q) x => P (MapMaybe p q :: Type) x # | |
| P (BangBangQT p q) a => P (p !!? q :: Type) a # | |
| (P p a, P q a, Show (PP q a), Ixed (PP q a), PP p a ~ Index (PP q a), Show (Index (PP q a)), Show (IxValue (PP q a))) => P (Lookup p q :: Type) a # | |
| P (BangBangT p q) a => P (p !! q :: Type) a # | |
| P (EnumFromToT p q) x => P (p ... q :: Type) x # | |
| (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.Data.Enum 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 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 # | |
Defined in Predicate.Data.Enum Associated Types type PP (ToEnumBDef' t def) a :: Type # Methods eval :: MonadEval m => proxy (ToEnumBDef' t def) -> POpts -> a -> m (TT (PP (ToEnumBDef' 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 # | |
| (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 # | |
| (Show a, Enum a, Integral (PP n x), P n x, PP p x ~ a, P p x) => P (SuccN n p :: Type) 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 # | |
| P (IterateWhileT p f) x => P (IterateWhile p f :: Type) x # | |
Defined in Predicate.Data.Iterator Associated Types type PP (IterateWhile p f) x :: Type # Methods eval :: MonadEval m => proxy (IterateWhile p f) -> POpts -> x -> m (TT (PP (IterateWhile p f) x)) # | |
| P (IterateUntilT p f) x => P (IterateUntil p f :: Type) x # | |
Defined in Predicate.Data.Iterator Associated Types type PP (IterateUntil p f) x :: Type # Methods eval :: MonadEval m => proxy (IterateUntil p f) -> POpts -> x -> m (TT (PP (IterateUntil p f) 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 # | |
| P (IMapT p q) x => P (IMap p q :: Type) x # | |
| P (InitFailT msg q) x => P (InitFail msg q :: Type) x # | |
| P (InitDefT p q) x => P (InitDef p q :: Type) x # | |
| P (LastFailT msg q) x => P (LastFail msg q :: Type) x # | |
| P (LastDefT p q) x => P (LastDef p q :: Type) x # | |
| P (TailFailT msg q) x => P (TailFail msg q :: Type) x # | |
| P (TailDefT p q) x => P (TailDef p q :: Type) x # | |
| P (HeadFailT msg q) x => P (HeadFail msg q :: Type) x # | |
| P (HeadDefT p q) x => P (HeadDef p q :: Type) x # | |
| (PP p (a, x) ~ String, PP q x ~ Either a b, P p (a, x), P q x) => P (RightFail p q :: Type) x # | |
| (PP p (b, x) ~ String, PP q x ~ Either a b, P p (b, x), P q x) => P (LeftFail p q :: Type) x # | |
| (PP q x ~ Either a b, PP p (a, x) ~ b, P q x, P p (a, x)) => P (RightDef p q :: Type) x # | |
| (PP q x ~ Either a b, PP p (b, x) ~ a, P q x, P p (b, x)) => P (LeftDef p q :: Type) x # | |
| (Show (PP p x), P p x) => P (MkRight' t p :: Type) x # | |
| (Show (PP p x), P p x) => P (MkLeft' t p :: Type) x # | |
| P (DiffLocalTimeT p q) x => P (DiffLocalTime p q :: Type) x # | |
Defined in Predicate.Data.DateTime Associated Types type PP (DiffLocalTime p q) x :: Type # Methods eval :: MonadEval m => proxy (DiffLocalTime p q) -> POpts -> x -> m (TT (PP (DiffLocalTime p q) x)) # | |
| (PP p x ~ UTCTime, PP q x ~ UTCTime, P p x, P q x) => P (DiffUTCTime p q :: Type) x # | |
Defined in Predicate.Data.DateTime Associated Types type PP (DiffUTCTime p q) x :: Type # Methods eval :: MonadEval m => proxy (DiffUTCTime p q) -> POpts -> x -> m (TT (PP (DiffUTCTime p q) 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.Data.DateTime 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 (ExitWhenT prt p) x => P (ExitWhen prt p :: Type) x # | |
| (P prt a, PP prt a ~ String, P p a, PP p a ~ Bool) => P (GuardBool prt p :: Type) a # | |
| (Show a, P prt a, PP prt a ~ String, P p a, PP p a ~ Bool) => P (Guard prt p :: Type) a # | |
| (PP (Bools (ToGuardsT prt ps)) x ~ Bool, P (BoolsQuickT prt ps) x) => P (BoolsQuick prt ps :: Type) x # | |
Defined in Predicate.Data.Condition Associated Types type PP (BoolsQuick prt ps) x :: Type # Methods eval :: MonadEval m => proxy (BoolsQuick prt ps) -> POpts -> x -> m (TT (PP (BoolsQuick prt ps) x)) # | |
| P (GuardsQuickT prt ps) x => P (GuardsQuick prt ps :: Type) x # | |
Defined in Predicate.Data.Condition Associated Types type PP (GuardsQuick prt ps) x :: Type # Methods eval :: MonadEval m => proxy (GuardsQuick prt ps) -> POpts -> x -> m (TT (PP (GuardsQuick prt ps) x)) # | |
| (P p a, Show t, Bits t, Integral (PP p a)) => P (Bit t p :: Type) a # | |
| (P p a, P q a, Show (PP q a), Bits (PP q a), Integral (PP p a)) => P (TestBit p q :: Type) a # | |
| P (BitComplementT p q) x => P (BitComplement p q :: Type) x # | |
Defined in Predicate.Data.Bits Associated Types type PP (BitComplement p q) x :: Type # Methods eval :: MonadEval m => proxy (BitComplement p q) -> POpts -> x -> m (TT (PP (BitComplement p q) x)) # | |
| P (BitClearT p q) x => P (BitClear p q :: Type) x # | |
| P (BitSetT p q) x => P (BitSet p q :: Type) x # | |
| P (BitRotateRT p q) x => P (BitRotateR p q :: Type) x # | |
Defined in Predicate.Data.Bits Associated Types type PP (BitRotateR p q) x :: Type # Methods eval :: MonadEval m => proxy (BitRotateR p q) -> POpts -> x -> m (TT (PP (BitRotateR p q) x)) # | |
| P (BitRotateLT p q) x => P (BitRotateL p q :: Type) x # | |
Defined in Predicate.Data.Bits Associated Types type PP (BitRotateL p q) x :: Type # Methods eval :: MonadEval m => proxy (BitRotateL p q) -> POpts -> x -> m (TT (PP (BitRotateL p q) x)) # | |
| P (BitRotateT p q) x => P (BitRotate p q :: Type) x # | |
| P (BitShiftRT p q) x => P (BitShiftR p q :: Type) x # | |
| P (BitShiftLT p q) x => P (BitShiftL p q :: Type) x # | |
| P (BitShiftT p q) x => P (BitShift p q :: Type) x # | |
| (P p a, P q a, Show (PP p a), PP p a ~ PP q a, Bits (PP p a)) => P (p .^. q :: Type) a # | |
| (P p a, P q a, Show (PP p a), PP p a ~ PP q a, Bits (PP p a)) => P (p .|. q :: Type) a # | |
| (P p a, P q a, Show (PP p a), PP p a ~ PP q a, Bits (PP p a)) => P (p .&. q :: Type) 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) # | |
| (P q a, P q a', P (p Fst Snd) (PP q a, PP q a')) => P (On p q :: Type) (a, a') # | |
| (Show (PP p a), Show (PP q b), P p a, P q b, Show a, Show b) => P (p *** q :: Type) (a, b) # | |
| (Bitraversable n, P p a, P q b) => P (BiMap p q :: Type) (n a b) # | |
| (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) # | |
| (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) # | |
| (GetROpts rs, PP p x ~ String, PP q x ~ String, P p x, P q x) => P (Resplit' rs p q :: Type) 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.Data.Regex 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 # | |
| (GetROpts rs, PP p x ~ String, PP q x ~ String, P p x, P q x) => P (Re' rs p q :: Type) x # | |
| P (PrintLT n s p) x => P (PrintL n s p :: Type) 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 # | |
| (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 # | |
| (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 # | |
| (GetBool pretty, PP p x ~ String, P p x, ToJSON (PP q x), P q x) => P (EncodeJsonFile pretty p q :: Type) x # | |
Defined in Predicate.Data.Json Associated Types type PP (EncodeJsonFile pretty p q) x :: Type # Methods eval :: MonadEval m => proxy (EncodeJsonFile pretty p q) -> POpts -> x -> m (TT (PP (EncodeJsonFile pretty p q) x)) # | |
| P (RandomListT n t p) x => P (RandomList n t p :: Type) x # | |
Defined in Predicate.Data.IO Associated Types type PP (RandomList n t p) x :: Type # Methods eval :: MonadEval m => proxy (RandomList n t p) -> POpts -> x -> m (TT (PP (RandomList n t p) x)) # | |
| P (ParseTimesT t p q) x => P (ParseTimes t p q :: Type) x # | |
Defined in Predicate.Data.DateTime Associated Types type PP (ParseTimes t p q) x :: Type # Methods eval :: MonadEval m => proxy (ParseTimes t p q) -> POpts -> x -> m (TT (PP (ParseTimes t p q) x)) # | |
| (x ~ [a], P (GuardsNT prt n p) x) => P (GuardsN prt n p :: Type) x # | |
| P (GuardsDetailT prt ps) x => P (GuardsDetail prt ps :: Type) x # | |
Defined in Predicate.Data.Condition Associated Types type PP (GuardsDetail prt ps) x :: Type # Methods eval :: MonadEval m => proxy (GuardsDetail prt ps) -> POpts -> x -> m (TT (PP (GuardsDetail prt ps) x)) # | |
| (x ~ [a], P (BoolsNT prt n p) x) => P (BoolsN prt n p :: Type) x # | |
| (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 # | |
| (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 # | |
| (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 # | |
| P (ReplaceOneT p q r) x => P (ReplaceOne p q r :: Type) x # | |
Defined in Predicate.Data.Regex Associated Types type PP (ReplaceOne p q r) x :: Type # Methods eval :: MonadEval m => proxy (ReplaceOne p q r) -> POpts -> x -> m (TT (PP (ReplaceOne p q r) x)) # | |
| P (ReplaceAllT p q r) x => P (ReplaceAll p q r :: Type) x # | |
Defined in Predicate.Data.Regex Associated Types type PP (ReplaceAll p q r) x :: Type # Methods eval :: MonadEval m => proxy (ReplaceAll p q r) -> POpts -> x -> m (TT (PP (ReplaceAll p q r) x)) # | |
| (PP p x ~ Proxy z, PP q x ~ Proxy w, PP r x ~ Proxy v) => P (PApp2 p q r :: Type) x # | |
| (P r x, PP p x ~ Proxy z, PP q x ~ Proxy w, P (z w) (PP r x)) => P (Pop1' p q r :: Type) x # | |
| (P r x, PP p x ~ Proxy z, P (z q) (PP r x)) => P (Pop1 p q r :: Type) x # | |
| P (DivIT t p q) x => P (DivI t p q :: Type) x # | |
| (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 # | |
| (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 # | |
| (PP q a ~ [x], PP r a ~ [y], P q a, P r a, P p (x, y), Show x, Show y, Show (PP p (x, y))) => P (ZipWith p q r :: Type) a # | |
| (PP p a ~ [b], P n a, P i a, P p a, Show b, Integral (PP i a), Integral (PP n a)) => P (ChunksOf' n i p :: Type) a # | |
| P (PadRT n p q) x => P (PadR n p q :: Type) x # | |
| P (PadLT n p q) x => P (PadL n p q :: Type) x # | |
| (P p x, Ord t, Show x, Show t, PP q a ~ [x], PP p x ~ t, P q a) => P (PartitionBy t p q :: Type) a # | |
Defined in Predicate.Data.List Associated Types type PP (PartitionBy t p q) a :: Type # Methods eval :: MonadEval m => proxy (PartitionBy t p q) -> POpts -> a -> m (TT (PP (PartitionBy t p q) a)) # | |
| (Traversable n, Applicative n, P p (a, b), P q x, P r x, PP p (a, b) ~ c, PP q x ~ n a, PP r x ~ n b) => P (LiftA2 p q r :: Type) x # | |
| P (p r q) x => P (Flip p q r :: Type) x # | |
| P (FFishT p q r) x => P (FFish p q r :: Type) x # | |
| (Show (PP p a), P b a, P p a, PP b a ~ Bool, Alternative t) => P (EmptyBool t b p :: Type) a # | |
| (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 # | |
| P (LookupFailT msg v w) x => P (LookupFail msg v w :: Type) x # | |
Defined in Predicate.Data.Index Associated Types type PP (LookupFail msg v w) x :: Type # Methods eval :: MonadEval m => proxy (LookupFail msg v w) -> POpts -> x -> m (TT (PP (LookupFail msg v w) x)) # | |
| P (LookupDefT v w p) x => P (LookupDef v w p :: Type) x # | |
| (P p x, P q x, P r x, PP p x ~ a, Show a, PP q x ~ a, PP r x ~ a, Enum a) => P (EnumFromThenTo p q r :: Type) x # | |
Defined in Predicate.Data.Enum Associated Types type PP (EnumFromThenTo p q r) x :: Type # Methods eval :: MonadEval m => proxy (EnumFromThenTo p q r) -> POpts -> x -> m (TT (PP (EnumFromThenTo p q r) x)) # | |
| P (IterateNUntilT n p f) x => P (IterateNUntil n p f :: Type) x # | |
Defined in Predicate.Data.Iterator Associated Types type PP (IterateNUntil n p f) x :: Type # Methods eval :: MonadEval m => proxy (IterateNUntil n p f) -> POpts -> x -> m (TT (PP (IterateNUntil n p f) x)) # | |
| P (IterateNWhileT n p f) x => P (IterateNWhile n p f :: Type) x # | |
Defined in Predicate.Data.Iterator Associated Types type PP (IterateNWhile n p f) x :: Type # Methods eval :: MonadEval m => proxy (IterateNWhile n p f) -> POpts -> x -> m (TT (PP (IterateNWhile n p f) x)) # | |
| P (IterateNT n p s) x => P (UnfoldN n p s :: Type) x # | |
| P (FoldLT p q r) x => P (Foldl p q r :: Type) x # | |
| P (FoldNT n p q) x => P (FoldN n p q :: Type) x # | |
| P (ScanNT n p q) x => P (ScanN n p q :: Type) x # | |
| (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 # | |
| P (PartitionsByT p q r) x => P (PartitionsBy p q r :: Type) x # | |
Defined in Predicate.Data.Extra Associated Types type PP (PartitionsBy p q r) x :: Type # Methods eval :: MonadEval m => proxy (PartitionsBy p q r) -> POpts -> x -> m (TT (PP (PartitionsBy p q r) x)) # | |
| (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 # | |
| (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 # | |
Defined in Predicate.Data.Either Associated Types type PP (EitherBool b p q) a :: Type # Methods eval :: MonadEval m => proxy (EitherBool b p q) -> POpts -> a -> m (TT (PP (EitherBool b p q) a)) # | |
| (P p x, P q x, P r x, PP p x ~ Int, PP q x ~ Int, PP r x ~ Rational) => P (MkTime' p q r :: Type) x # | |
| (P p x, P q x, P r x, PP p x ~ Int, PP q x ~ Int, PP r x ~ Int) => P (MkDayExtra' p q r :: Type) x # | |
Defined in Predicate.Data.DateTime Associated Types type PP (MkDayExtra' p q r) x :: Type # Methods eval :: MonadEval m => proxy (MkDayExtra' p q r) -> POpts -> x -> m (TT (PP (MkDayExtra' p q r) x)) # | |
| (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 # | |
| (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.Data.DateTime 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.Data.DateTime 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)) # | |
| P (CaseT' ps qs r) x => P (Case' ps qs r :: Type) x # | |
| (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 # | |
| (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) # | |
| P (ReplaceOneStringT o p q r) x => P (ReplaceOneString o p q r :: Type) x # | |
Defined in Predicate.Data.Regex Associated Types type PP (ReplaceOneString o p q r) x :: Type # Methods eval :: MonadEval m => proxy (ReplaceOneString o p q r) -> POpts -> x -> m (TT (PP (ReplaceOneString o p q r) x)) # | |
| P (ReplaceOneT' rs p q r) x => P (ReplaceOne' rs p q r :: Type) x # | |
Defined in Predicate.Data.Regex Associated Types type PP (ReplaceOne' rs p q r) x :: Type # Methods eval :: MonadEval m => proxy (ReplaceOne' rs p q r) -> POpts -> x -> m (TT (PP (ReplaceOne' rs p q r) x)) # | |
| P (ReplaceAllT' rs p q r) x => P (ReplaceAll' rs p q r :: Type) x # | |
Defined in Predicate.Data.Regex Associated Types type PP (ReplaceAll' rs p q r) x :: Type # Methods eval :: MonadEval m => proxy (ReplaceAll' rs p q r) -> POpts -> x -> m (TT (PP (ReplaceAll' rs p q r) x)) # | |
| (Random t, P r x, RandomGen (PP r x), Show (PP r x), PP p x ~ t, PP q x ~ t, P p x, P q x) => P (RandomRNext t p q r :: Type) x # | |
Defined in Predicate.Data.IO Associated Types type PP (RandomRNext t p q r) x :: Type # Methods eval :: MonadEval m => proxy (RandomRNext t p q r) -> POpts -> x -> m (TT (PP (RandomRNext t p q 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 # | |
| P (ReplaceOneStringT' rs o p q r) x => P (ReplaceOneString' rs o p q r :: Type) x # | |
Defined in Predicate.Data.Regex Associated Types type PP (ReplaceOneString' rs o p q r) x :: Type # Methods eval :: MonadEval m => proxy (ReplaceOneString' rs o p q r) -> POpts -> x -> m (TT (PP (ReplaceOneString' rs o p q r) x)) # | |
| P (ReplaceAllStringT o p q r) x => P (ReplaceAllString o p q r :: Type) x # | |
Defined in Predicate.Data.Regex Associated Types type PP (ReplaceAllString o p q r) x :: Type # Methods eval :: MonadEval m => proxy (ReplaceAllString o p q r) -> POpts -> x -> m (TT (PP (ReplaceAllString o p q r) x)) # | |
| P (ReplaceAllStringT' rs o p q r) x => P (ReplaceAllString' rs o p q r :: Type) x # | |
Defined in Predicate.Data.Regex Associated Types type PP (ReplaceAllString' rs o p q r) x :: Type # Methods eval :: MonadEval m => proxy (ReplaceAllString' rs o p q r) -> POpts -> x -> m (TT (PP (ReplaceAllString' rs o p q r) x)) # | |
| (P s x, PP p x ~ Proxy z, PP q x ~ Proxy w, PP r x ~ Proxy v, P (z w v) (PP s x)) => P (Pop2' p q r s :: Type) x # | |
| (P s x, PP p x ~ Proxy z, P (z q r) (PP s x)) => P (Pop2 p q r s :: Type) x # | |
| (PP l a ~ x, PP r a ~ y, P l a, P r a, PP p a ~ [x], PP q a ~ [y], P p a, P q a, Show x, Show y) => P (ZipPad l r p q :: Type) a # | |
| P (LookupFailT' msg v w q) x => P (LookupFail' msg v w q :: Type) x # | |
Defined in Predicate.Data.Index Associated Types type PP (LookupFail' msg v w q) x :: Type # Methods eval :: MonadEval m => proxy (LookupFail' msg v w q) -> POpts -> x -> m (TT (PP (LookupFail' msg v w q) x)) # | |
| P (LookupDefT' v w p q) x => P (LookupDef' v w p q :: Type) x # | |
Defined in Predicate.Data.Index Associated Types type PP (LookupDef' v w p q) x :: Type # Methods eval :: MonadEval m => proxy (LookupDef' v w p q) -> POpts -> x -> m (TT (PP (LookupDef' v w p q) x)) # | |
| P (CaseT'' s ps qs r) x => P (Case'' s ps qs r :: Type) x # | |
| (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 # | |
| P (RandomRListT n t p q r) x => P (RandomRList n t p q r :: Type) x # | |
Defined in Predicate.Data.IO Associated Types type PP (RandomRList n t p q r) x :: Type # Methods eval :: MonadEval m => proxy (RandomRList n t p q r) -> POpts -> x -> m (TT (PP (RandomRList n t p q r) x)) # | |
| P [] a # |
|
| P (Proxy :: Proxy t1) t2 # | converts the type to the corresponding
|
| (PP p x ~ Either a2 b2, P p x) => P (Right p :: Either a1 b1) x # | extracts the
|
| (PP p x ~ Either a2 b2, P p x) => P (Left p :: Either a1 b1) x # | extracts the
|
| (PP p x ~ These a2 b2, P p x) => P (That p :: These a1 b1) x # | extracts the
|
| (PP p x ~ These a2 b2, P p x) => P (This p :: These a1 b1) x # | extracts the
|
| (P p a, P q a, Show (PP p a), Show (PP q a)) => P ((,) p q :: (k2, k1)) a # | 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) # | extracts the (a,b) from type level
|
| (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
|
| (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
|
| (P p a, P q a, P r a, P s a, P t a) => P ((,,,,) p q r s t :: (k5, k4, k3, k2, k1)) a # | run the predicates in a promoted 5-tuple
|
| (P p a, P q a, P r a, P s a, P t a, P u a) => P ((,,,,,) p q r s t u :: (k6, k5, k4, k3, k2, k1)) a # | run the predicates in a promoted 6-tuple
|
| (P p a, P q a, P r a, P s a, P t a, P u a, P v a) => P ((,,,,,,) p q r s t u v :: (k7, k6, k5, k4, k3, k2, k1)) a # | run the predicates in a promoted 7-tuple
|
| (P p a, P q a, P r a, P s a, P t a, P u a, P v a, P w a) => P ((,,,,,,,) p q r s t u v w :: (k8, k7, k6, k5, k4, k3, k2, k1)) a # | run the predicates in a promoted 8-tuple
|
IO evaluation
pan :: forall p a. (Show (PP p a), P p a) => a -> IO (Val (PP p a)) #
displays the evaluation tree in plain text without colors
evaluate the type level expression in IO
>>>pl @(Between 4 10 Id) 7 & mapped . _Val %~ notTrue (4 <= 7 <= 10) Val False
>>>eval (Proxy @'True) defOpts 7 & mapped . ttValBool . _Val %~ notTT {_ttValP = FalseP, _ttVal = Val False, _ttString = "'True", _ttForest = []}
panv :: forall p a. (Show (PP p a), P p a) => a -> IO (Val (PP p a)) #
displays the evaluation tree in plain text without colors and verbose
evaluate the type level expression in IO
>>>pl @(Between 4 10 Id) 7 & mapped . _Val %~ notTrue (4 <= 7 <= 10) Val False
>>>eval (Proxy @'True) defOpts 7 & mapped . ttValBool . _Val %~ notTT {_ttValP = FalseP, _ttVal = Val False, _ttString = "'True", _ttForest = []}
pa :: forall p a. (Show (PP p a), P p a) => a -> IO (Val (PP p a)) #
displays the evaluation tree using colors without background colors
evaluate the type level expression in IO
>>>pl @(Between 4 10 Id) 7 & mapped . _Val %~ notTrue (4 <= 7 <= 10) Val False
>>>eval (Proxy @'True) defOpts 7 & mapped . ttValBool . _Val %~ notTT {_ttValP = FalseP, _ttVal = Val False, _ttString = "'True", _ttForest = []}
pu :: forall p a. (Show (PP p a), P p a) => a -> IO (Val (PP p a)) #
display the evaluation tree using unicode and colors
pu '(Id, "abc", 123) [1..4]
@
evaluate the type level expression in IO
>>>pl @(Between 4 10 Id) 7 & mapped . _Val %~ notTrue (4 <= 7 <= 10) Val False
>>>eval (Proxy @'True) defOpts 7 & mapped . ttValBool . _Val %~ notTT {_ttValP = FalseP, _ttVal = Val False, _ttString = "'True", _ttForest = []}
pab :: forall p a. (Show (PP p a), P p a) => a -> IO (Val (PP p a)) #
displays the evaluation tree using background colors
evaluate the type level expression in IO
>>>pl @(Between 4 10 Id) 7 & mapped . _Val %~ notTrue (4 <= 7 <= 10) Val False
>>>eval (Proxy @'True) defOpts 7 & mapped . ttValBool . _Val %~ notTT {_ttValP = FalseP, _ttVal = Val False, _ttString = "'True", _ttForest = []}
pub :: forall p a. (Show (PP p a), P p a) => a -> IO (Val (PP p a)) #
displays the evaluation tree using unicode and colors with background colors
evaluate the type level expression in IO
>>>pl @(Between 4 10 Id) 7 & mapped . _Val %~ notTrue (4 <= 7 <= 10) Val False
>>>eval (Proxy @'True) defOpts 7 & mapped . ttValBool . _Val %~ notTT {_ttValP = FalseP, _ttVal = Val False, _ttString = "'True", _ttForest = []}
pav :: forall p a. (Show (PP p a), P p a) => a -> IO (Val (PP p a)) #
pa and verbose
evaluate the type level expression in IO
>>>pl @(Between 4 10 Id) 7 & mapped . _Val %~ notTrue (4 <= 7 <= 10) Val False
>>>eval (Proxy @'True) defOpts 7 & mapped . ttValBool . _Val %~ notTT {_ttValP = FalseP, _ttVal = Val False, _ttString = "'True", _ttForest = []}
puv :: forall p a. (Show (PP p a), P p a) => a -> IO (Val (PP p a)) #
pu and verbose
evaluate the type level expression in IO
>>>pl @(Between 4 10 Id) 7 & mapped . _Val %~ notTrue (4 <= 7 <= 10) Val False
>>>eval (Proxy @'True) defOpts 7 & mapped . ttValBool . _Val %~ notTT {_ttValP = FalseP, _ttVal = Val False, _ttString = "'True", _ttForest = []}
pl :: forall p a. (Show (PP p a), P p a) => a -> IO (Val (PP p a)) #
same as pz but adds context to the end result
evaluate the type level expression in IO
>>>pl @(Between 4 10 Id) 7 & mapped . _Val %~ notTrue (4 <= 7 <= 10) Val False
>>>eval (Proxy @'True) defOpts 7 & mapped . ttValBool . _Val %~ notTT {_ttValP = FalseP, _ttVal = Val False, _ttString = "'True", _ttForest = []}
pz :: forall p a. (Show (PP p a), P p a) => a -> IO (Val (PP p a)) #
skips the evaluation tree and just displays the end result
evaluate the type level expression in IO
>>>pl @(Between 4 10 Id) 7 & mapped . _Val %~ notTrue (4 <= 7 <= 10) Val False
>>>eval (Proxy @'True) defOpts 7 & mapped . ttValBool . _Val %~ notTT {_ttValP = FalseP, _ttVal = Val False, _ttString = "'True", _ttForest = []}
run :: forall opts p a. (OptC opts, Show (PP p a), P p a) => a -> IO (Val (PP p a)) #
evaluate a typelevel expression (use type applications to pass in the options and the expression)
>>>run @OZ @Id 123Val 123
>>>run @('OMsg "field1" ':# OL) @('Left Id) (Right 123)field1 >>> Error 'Left found Right Fail "'Left found Right"
>>>run @(OptT '[ 'OMsg "test", OU, 'OEmpty, OL, 'OMsg "field2"]) @(FailT _ "oops") ()test | field2 >>> Error oops Fail "oops"
runs :: forall optss p a. (OptC (OptT optss), Show (PP p a), P p a) => a -> IO (Val (PP p a)) #
run expression with multiple options in a list
>>>runs @'[OL, 'OMsg "field2"] @'( 'True, 'False) ()field2 >>> Present (True,False) ('(True,False)) Val (True,False)
>>>runs @'[ 'OMsg "test", OU, 'OEmpty, OL, 'OMsg "field2"] @(FailT _ "oops") ()test | field2 >>> Error oops Fail "oops"
pure evaluation
runP :: (P p a, MonadEval m) => Inline -> String -> proxy p -> POpts -> a -> [Tree PE] -> m (Either (TT x) (PP p a, TT (PP p a))) #
convenience method to evaluate one expression
runPQ :: (P p a, P q a, MonadEval m) => Inline -> String -> proxy1 p -> proxy2 q -> POpts -> a -> [Tree PE] -> m (Either (TT x) (PP p a, PP q a, TT (PP p a), TT (PP q a))) #
convenience method to evaluate two expressions using the same input and return the results
runPQBool :: (P p a, PP p a ~ Bool, P q a, PP q a ~ Bool, MonadEval m) => Inline -> String -> proxy1 p -> proxy2 q -> POpts -> a -> [Tree PE] -> m (Either (TT x) (PP p a, PP q a, TT (PP p a), TT (PP q a))) #
convenience method to evaluate two boolean expressions using the same input and return the results
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
evalBoolHide :: forall p a m. (MonadEval m, P p a, PP p a ~ Bool) => POpts -> a -> m (TT (PP p a)) #
evaluate a boolean expressions but hide the results unless verbose
evalHide :: forall p a m. (MonadEval m, P p a) => POpts -> a -> m (TT (PP p a)) #
evaluate a expressions but hide the results unless verbose
wrap, unwrap
wraps a value (see _Wrapped' and _Unwrapped')
>>>pz @(Wrap (SG.Sum _) Id) (-13)Val (Sum {getSum = -13})
>>>pz @(Wrap SG.Any (Ge 4)) 13Val (Any {getAny = True})
>>>import Data.List.NonEmpty (NonEmpty(..))>>>pz @(Wrap (NonEmpty _) (Uncons >> 'Just Id)) "abcd"Val ('a' :| "bcd")
>>>pl @(Wrap (SG.Sum _) Id) 13Present Sum {getSum = 13} (Wrap Sum {getSum = 13} | 13) Val (Sum {getSum = 13})
>>>pl @(Wrap (SG.Sum _) Id >> STimes 4 Id) 13Present Sum {getSum = 52} ((>>) Sum {getSum = 52} | {getSum = 13}) Val (Sum {getSum = 52})
>>>pl @(Wrap _ 13 <> Id) (SG.Sum @Int 12)Present Sum {getSum = 25} (Sum {getSum = 13} <> Sum {getSum = 12} = Sum {getSum = 25}) Val (Sum {getSum = 25})
unwraps a value (see _Wrapped')
>>>pz @Unwrap (SG.Sum (-13))Val (-13)
>>>pl @(Unwrap >> '(Id, 'True)) (SG.Sum 13)Present (13,True) ((>>) (13,True) | {'(13,True)}) Val (13,True)
failure
Fails the computation with a message but allows you to set the output type
>>>pz @('False || (Fail 'True "failed")) (99,"somedata")Fail "failed"
>>>pz @('False || (Fail (Hole Bool) "failed")) (99,"somedata")Fail "failed"
>>>pz @('False || (Fail (Hole _) "failed")) (99,"somedata")Fail "failed"
Fails the computation with a message where the input value is a Proxy
>>>pz @(Ix 3 (FailP "oops")) "abcd"Val 'd'
>>>pz @(Ix 3 (FailP "oops")) "abc"Fail "oops"
Fails the computation with a message (wraps the type in Hole)
>>>pz @(FailT Int (PrintF "value=%03d" Id)) 99Fail "value=099"
Fails the computation with a message for simple failures: doesnt preserve types
>>>pz @(FailS (PrintT "value=%03d string=%s" Id)) (99,"somedata")Fail "value=099 string=somedata"
tuple
similar to fst
>>>pz @Fst (10,"Abc")Val 10
>>>pz @Fst (10,"Abc",'x')Val 10
>>>pz @Fst (10,"Abc",'x',False)Val 10
>>>pl @Fst (99,'a',False,1.3)Present 99 (Fst 99 | (99,'a',False,1.3)) Val 99
similar to snd
>>>pz @Snd (10,"Abc")Val "Abc"
>>>pz @Snd (10,"Abc",True)Val "Abc"
>>>pl @Snd (99,'a',False,1.3)Present 'a' (Snd 'a' | (99,'a',False,1.3)) Val 'a'
similar to 3rd element in a n-tuple
>>>pz @Thd (10,"Abc",133)Val 133
>>>pz @Thd (10,"Abc",133,True)Val 133
>>>pl @Thd (99,'a',False,1.3)Present False (Thd False | (99,'a',False,1.3)) Val False
similar to 4th element in a n-tuple
>>>pz @(L4 Id) (10,"Abc",'x',True)Val True
>>>pz @(L4 L21) ('x',((10,"Abc",'x',999),"aa",1),9)Val 999
>>>pl @(L4 Id) (99,'a',False,"someval")Present "someval" (L4 "someval" | (99,'a',False,"someval")) Val "someval"
similar to 5th element in a n-tuple
>>>pz @(L5 Id) (10,"Abc",'x',True,1)Val 1
similar to 6th element in a n-tuple
>>>pz @(L6 Id) (10,"Abc",'x',True,1,99)Val 99
similar to 7th element in a n-tuple
>>>pz @(L7 Id) (10,"Abc",'x',True,1,99,'a')Val 'a'
similar to 8th element in a n-tuple
>>>pz @(L8 Id) (10,"Abc",'x',True,1,99,True,'a')Val 'a'
first element in a tuple followed by the first element
>>>pz @L11 ((10,"ss"),2)Val 10
first element in a tuple followed by the second element
>>>pz @L12 ((10,"ss"),2)Val "ss"
first element in a tuple followed by the third element
>>>pz @L13 ((10,"ss",4.5),2)Val 4.5
second element in a tuple followed by the first element
>>>pz @L21 ('x',(10,"ss",4.5),2)Val 10
second element in a tuple followed by the second element
>>>pz @L22 ('z',(10,"ss",4.5),2)Val "ss"
second element in a tuple followed by the third element
>>>pz @L23 ('x',(10,"ss",4.5),2)Val 4.5
third element in a tuple followed by the first element
>>>pz @L31 (1,2,('c',4))Val 'c'
third element in a tuple followed by the second element
>>>pz @L32 (1,2,('c',4))Val 4
third element in a tuple followed by the third element
>>>pz @L33 (1,2,('c',4,False))Val False
boolean
similar to &&
>>>pz @(Fst && Snd) (True, True)Val True
>>>pz @(Id > 15 && Id < 17) 16Val True
>>>pz @(Id > 15 && Id < 17) 30Val False
>>>pz @(Fst && (Length Snd >= 4)) (True,[11,12,13,14])Val True
>>>pz @(Fst && (Length Snd == 4)) (True,[12,11,12,13,14])Val False
short circuit version of boolean And
>>>pl @(Id > 10 &&~ FailT _ "ss") 9False (False &&~ _ | (9 > 10)) Val False
>>>pl @(Id > 10 &&~ Id == 12) 11False (True &&~ False | (11 == 12)) Val False
>>>pl @(Id > 10 &&~ Id == 11) 11True (True &&~ True) Val True
similar to ||
>>>pz @(Fst || (Length Snd >= 4)) (False,[11,12,13,14])Val True
>>>pz @(Not Fst || (Length Snd == 4)) (True,[12,11,12,13,14])Val False
short circuit version of boolean Or
>>>pl @(Id > 10 ||~ FailT _ "ss") 11True (True ||~ _ | (11 > 10)) Val True
>>>pz @(Id > 10 ||~ Id == 9) 9Val True
>>>pl @(Id > 10 ||~ Id > 9) 9False (False ||~ False | (9 > 10) ||~ (9 > 9)) Val False
boolean implication
>>>pz @(Fst ~> (Length Snd >= 4)) (True,[11,12,13,14])Val True
>>>pz @(Fst ~> (Length Snd == 4)) (True,[12,11,12,13,14])Val False
>>>pz @(Fst ~> (Length Snd == 4)) (False,[12,11,12,13,14])Val True
>>>pz @(Fst ~> (Length Snd >= 4)) (False,[11,12,13,14])Val True
not function
>>>pz @(Not Id) FalseVal True
>>>pz @(Not Id) TrueVal False
>>>pz @(Not Fst) (True,22)Val False
>>>pl @(Not (Lt 3)) 13True (Not (13 < 3)) Val True
>>>pl @(Not 'True) ()False (Not ('True)) Val False
A predicate that determines if the value is between p and q
>>>pz @(Between 5 8 Len) [1,2,3,4,5,5,7]Val True
>>>pl @(Between 5 8 Id) 9False (9 <= 8) Val False
>>>pl @(Between L11 L12 Snd) ((1,4),3)True (1 <= 3 <= 4) Val True
>>>pl @(Between L11 L12 Snd) ((1,4),10)False (10 <= 4) Val False
A operator predicate that determines if the value is between p and q
>>>pz @(5 <..> 8) 6Val True
>>>pz @(10 % 4 <..> 40 % 5) 4Val True
>>>pz @(10 % 4 <..> 40 % 5) 33Val False
similar to all
>>>pl @(All (Between 1 8 Id)) [7,3,4,1,2,9,0,1]False (All(8) i=5 (9 <= 8)) Val False
>>>pz @(All Odd) [1,5,11,5,3]Val True
>>>pz @(All Odd) []Val True
>>>run @OANV @(All Even) [1,5,11,5,3]False All(5) i=0 (1 == 0) | +- False i=0: 1 == 0 | | | +- P 1 `mod` 2 = 1 | | | | | +- P Id 1 | | | | | `- P '2 | | | `- P '0 | +- False i=1: 1 == 0 | | | +- P 5 `mod` 2 = 1 | | | | | +- P Id 5 | | | | | `- P '2 | | | `- P '0 | +- False i=2: 1 == 0 | | | +- P 11 `mod` 2 = 1 | | | | | +- P Id 11 | | | | | `- P '2 | | | `- P '0 | +- False i=3: 1 == 0 | | | +- P 5 `mod` 2 = 1 | | | | | +- P Id 5 | | | | | `- P '2 | | | `- P '0 | `- False i=4: 1 == 0 | +- P 3 `mod` 2 = 1 | | | +- P Id 3 | | | `- P '2 | `- P '0 Val False
>>>pl @(Fst >> All (Gt 3)) ([10,12,3,5],"ss")False ((>>) False | {All(4) i=2 (3 > 3)}) Val False
>>>pl @(All (Lt 3)) [1 .. 10]False (All(10) i=2 (3 < 3)) Val False
similar to any
>>>pl @(Any Even) [1,5,11,5,3]False (Any(5)) Val False
>>>pl @(Any Even) [1,5,112,5,3]True (Any(5) i=2 (0 == 0)) Val True
>>>pz @(Any Even) []Val False
>>>pl @(Fst >> Any (Gt 3)) ([10,12,3,5],"ss")True ((>>) True | {Any(4) i=0 (10 > 3)}) Val True
>>>pl @(Any (Same 2)) [1,4,5]False (Any(3)) Val False
>>>pl @(Any (Same 2)) [1,4,5,2,1]True (Any(5) i=3 (2 == 2)) Val True
id function on a boolean
>>>pz @('[ 'True] >> Head >> IdBool) ()Val True
>>>pz @(Fst >> IdBool) (False,22)Val False
>>>pl @(Head >> IdBool) [True]True ((>>) True | {IdBool}) Val True
>>>pan @(Head >> Id) [True]P (>>) True | +- P Head True | `- P Id True Val True
>>>pan @(Head >> IdBool) [True]True (>>) True | +- P Head True | `- True IdBool Val True
type application
compose expressions
>>>pz @(L11 >> Not Id) ((True,12),'x')Val False
>>>pz @(L12 >> Succ >> Dup) ((True,12),'x')Val (13,13)
>>>pz @(10 >> '(Id,"abc") >> Second Len) ()Val (10,3)
infixl version of >>
flipped version of >>
data (p :: k -> k1) $ (q :: k) infixr 0 #
like $ for expressions taking exactly on argument
ie this doesnt work: pz @('(,) $ 4 $ 'True) ()
>>>pl @(L1 $ L2 $ Id) ((1,2),(3,4))Present 3 (Fst 3 | (3,4)) Val 3
>>>pl @((<=) 4 $ L1 $ L2 $ Id) ((1,2),(3,4))False (4 <= 3) Val False
>>>pz @('(,) 4 $ 'True) ()Val (4,True)
data (q :: k) & (p :: k -> k1) infixl 1 #
similar to & for expressions taking exactly on argument
>>>pl @(Id & L1 & Singleton & Length) (13,"xyzw")Present 1 (Length 1 | [13]) Val 1
>>>pl @(2 & (&&&) "abc") ()Present ("abc",2) ('("abc",2)) Val ("abc",2)
>>>pl @(2 & '(,) "abc") ()Present ("abc",2) ('("abc",2)) Val ("abc",2)
>>>pl @('(,) 4 $ '(,) 7 $ "aa") ()Present (4,(7,"aa")) ('(4,(7,"aa"))) Val (4,(7,"aa"))
>>>pl @(L3 $ L2 $ Fst) ((1,("X",9,'a')),(3,4))Present 'a' (Thd 'a' | ("X",9,'a')) Val 'a'
processes a type level list predicates running each in sequence with infixl: see >>
>>>pz @(DoL [Pred, ShowP Id, Id &&& Len]) 9876543Val ("9876542",7)
>>>pz @(DoL [2,3,4]) ()Val 4
>>>pl @(DoL '[4,5,6]) ()Present 6 ((>>) 6 | {'6}) Val 6
miscellaneous
swaps using SwapC
>>>pz @Swap (Left 123)Val (Right 123)
>>>pz @Swap (Right 123)Val (Left 123)
>>>pz @Swap (These 'x' 123)Val (These 123 'x')
>>>pz @Swap (This 'x')Val (That 'x')
>>>pz @Swap (That 123)Val (This 123)
>>>pz @Swap (123,'x')Val ('x',123)
>>>pz @Swap (Left "abc")Val (Right "abc")
>>>pz @Swap (Right 123)Val (Left 123)
>>>pl @Swap (Right "asfd")Present Left "asfd" (Swap Left "asfd" | Right "asfd") Val (Left "asfd")
>>>pl @Swap (12,"asfd")Present ("asfd",12) (Swap ("asfd",12) | (12,"asfd")) Val ("asfd",12)
>>>pz @Swap (True,12,"asfd")Val (True,"asfd",12)