Safe Haskell	None
Language	Haskell2010

Predicate.Data.Condition

Description

promoted conditional functions

Synopsis

data If p q r
data Case (e :: k0) (ps :: [k]) (qs :: [k1]) (r :: k2)
data Case' (ps :: [k]) (qs :: [k1]) (r :: k2)
data Case'' s (ps :: [k]) (qs :: [k1]) (r :: k2)
data Guards (ps :: [(k, k1)])
data GuardsQuick (prt :: k) (ps :: [k1])
data Guard prt p
data ExitWhen prt p
data GuardSimple p
data GuardsN prt (n :: Nat) p
data GuardsDetail prt (ps :: [(k0, k1)])
data GuardBool prt p
data Bools (ps :: [(k, k1)])
data BoolsQuick (prt :: k) (ps :: [k1])
data BoolsN prt (n :: Nat) (p :: k1)

Documentation

data If p q r #

similar to an if statement: if p then run q else run r

>>> pz @(If (Gt 4) "greater than 4" "less than or equal to 4") 10
Val "greater than 4"

>>> pz @(If (Gt 4) "greater than 4" "less than or equal to 4") 0
Val "less than or equal to 4"

>>> pz @(If (Snd == "a") '("xxx",Fst + 13) (If (Snd == "b") '("yyy",Fst + 7) (FailT _ "oops"))) (99,"b")
Val ("yyy",106)

>>> pl @(If (Len > 2) (Map Succ) (FailS "someval")) [12,15,16]
Present [13,16,17] (If 'True [13,16,17])
Val [13,16,17]

>>> pl @(Map (If (Lt 3) 'True (FailT _ "err"))) [1..10]
Error err(8) (Map(i=2, a=3) excnt=8)
Fail "err(8)"

>>> pl @(Map (If (Lt 3) 'True (FailT _ "someval"))) [1..10]
Error someval(8) (Map(i=2, a=3) excnt=8)
Fail "someval(8)"

>>> pl @(Map (If (Lt 3) 'True 'False)) [1..5]
Present [True,True,False,False,False] (Map [True,True,False,False,False] | [1,2,3,4,5])
Val [True,True,False,False,False]

>>> pl @(If (Gt 4) (Fail (Hole _) (PrintF "failing with %d" Id)) ()) 45
Error failing with 45 (If True)
Fail "failing with 45"

>>> pl @(If (Gt 4) (Fail (Hole _) (PrintF "failing with %d" Id)) (Id * 7)) 3
Present 21 (If 'False 21)
Val 21

>>> pl @(If (Gt 4) (Fail (Hole _) (PrintF "failing with %d" Id)) (Id * 7 >> ShowP Id >> Ones)) 3
Present ["2","1"] (If 'False ["2","1"])
Val ["2","1"]

>>> pl @(If (Gt 4) (Fail (Hole _) (PrintF "failing with %d" Id)) (ShowP (Id * 7) >> Ones)) 19
Error failing with 19 (If True)
Fail "failing with 19"

Instances

(Show (PP r a), P p a, PP p a ~ Bool, P q a, P r a, PP q a ~ PP r a) => P (If p q r :: Type) a #
Instance details Defined in Predicate.Data.Condition Associated Types type PP (If p q r) a :: Type # Methods eval :: MonadEval m => proxy (If p q r) -> POpts -> a -> m (TT (PP (If p q r) a)) #
Show (If p q r) #
Instance details Defined in Predicate.Data.Condition Methods showsPrec :: Int -> If p q r -> ShowS # show :: If p q r -> String # showList :: [If p q r] -> ShowS #
type PP (If p q r :: Type) a #
Instance details Defined in Predicate.Data.Condition type PP (If p q r :: Type) a = PP q a

data Case (e :: k0) (ps :: [k]) (qs :: [k1]) (r :: k2) #

tries to match the value r with a condition in ps and if there is a match calls the associated qs entry else run e

>>> pl @(Case (Snd >> FailP "xx") '[Gt 3, Lt 2, Same 3] '["gt3","lt2","eq3"] Id) 15
Present "gt3" (Case(0 of 2) "gt3" | 15)
Val "gt3"

>>> pl @(Case (Snd >> FailP "xx") '[Gt 3, Lt 2, Same 3] '["gt3","lt2","eq3"] Id) 1
Present "lt2" (Case(0) "lt2" | 1)
Val "lt2"

>>> pl @(Case (Snd >> FailP "xx") '[Gt 3, Lt 2, Same 3] '["gt3","lt2","eq3"] Id) 3
Present "eq3" (Case(0) "eq3" | 3)
Val "eq3"

>>> pl @(Case (Snd >> FailP "no match") '[Same 1, Same 2, Same 3] '["eq1","eq2","eq3"] Id) 15
Error no match (Case:otherwise failed:Proxy)
Fail "no match"

>>> pl @(Case (Fail (Snd >> UnproxyT) (PrintF "no match for %03d" Fst)) '[Same 1, Same 2, Same 3] '["eq1","eq2","eq3"] Id) 15
Error no match for 015 (Case:otherwise failed)
Fail "no match for 015"

>>> pl @(Case "other" '[Same 1, Same 2, Same 3] '["eq1","eq2","eq3"] Id) 15
Present "other" (Case(0) "other" | 15)
Val "other"

>>> pl @(Case (ShowP Fst >> Id <> Id <> Id) '[Same 1, Same 2, Same 3] '["eq1","eq2","eq3"] Id) 15
Present "151515" (Case(0) "151515" | 15)
Val "151515"

Instances

(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 #
Instance details Defined in Predicate.Data.Condition Associated Types type PP (Case e ps qs r) x :: Type # Methods eval :: MonadEval m => proxy (Case e ps qs r) -> POpts -> x -> m (TT (PP (Case e ps qs r) x)) #
Show (Case e ps qs r) #
Instance details Defined in Predicate.Data.Condition Methods showsPrec :: Int -> Case e ps qs r -> ShowS # show :: Case e ps qs r -> String # showList :: [Case e ps qs r] -> ShowS #
type PP (Case e ps qs r :: Type) x #
Instance details Defined in Predicate.Data.Condition type PP (Case e ps qs r :: Type) x

data Case' (ps :: [k]) (qs :: [k1]) (r :: k2) #

like Case but uses a generic error message (skips the e parameter)

>>> pl @(Case' '[Same 1, Same 2, Same 3] '["eq1","eq2","eq3"] Id) 15
Error Case:no match (Case:otherwise failed:Proxy)
Fail "Case:no match"

Instances

P (CaseT' ps qs r) x => P (Case' ps qs r :: Type) x #
Instance details Defined in Predicate.Data.Condition Associated Types type PP (Case' ps qs r) x :: Type # Methods eval :: MonadEval m => proxy (Case' ps qs r) -> POpts -> x -> m (TT (PP (Case' ps qs r) x)) #
Show (Case' ps qs r) #
Instance details Defined in Predicate.Data.Condition Methods showsPrec :: Int -> Case' ps qs r -> ShowS # show :: Case' ps qs r -> String # showList :: [Case' ps qs r] -> ShowS #
type PP (Case' ps qs r :: Type) x #
Instance details Defined in Predicate.Data.Condition type PP (Case' ps qs r :: Type) x

data Case'' s (ps :: [k]) (qs :: [k1]) (r :: k2) #

like Case but allows you to use the value in the error message

>>> pl @(Case'' (PrintF "no match for %03d" Id) '[Same 1, Same 2, Same 3] '["eq1","eq2","eq3"] Id) 15
Error no match for 015 (Case:otherwise failed)
Fail "no match for 015"

>>> pl @(Case'' (PrintF "no match for %03d" Id) '[Same 1, Same 2, Same 3] '["eq1","eq2","eq3"] Id) 2
Present "eq2" (Case(0) "eq2" | 2)
Val "eq2"

>>> pl @(Case'' (PrintF "no match for %04d" Id) '[Between 0 5 Id, Same 6, Between 7 10 Id] '[ 'LT, 'EQ, 'GT] Id) (-12)
Error no match for -012 (Case:otherwise failed)
Fail "no match for -012"

Instances

P (CaseT'' s ps qs r) x => P (Case'' s ps qs r :: Type) x #
Instance details Defined in Predicate.Data.Condition Associated Types type PP (Case'' s ps qs r) x :: Type # Methods eval :: MonadEval m => proxy (Case'' s ps qs r) -> POpts -> x -> m (TT (PP (Case'' s ps qs r) x)) #
Show (Case'' s ps qs r) #
Instance details Defined in Predicate.Data.Condition Methods showsPrec :: Int -> Case'' s ps qs r -> ShowS # show :: Case'' s ps qs r -> String # showList :: [Case'' s ps qs r] -> ShowS #
type PP (Case'' s ps qs r :: Type) x #
Instance details Defined in Predicate.Data.Condition type PP (Case'' s ps qs r :: Type) x

data Guards (ps :: [(k, k1)]) #

Guards contain a type level list of tuples the action to run on failure of the predicate and the predicate itself Each tuple validating against the corresponding value in a value list

prt receives (Int,a) as input which is the position and value if there is a failure

>>> pz @(Guards '[ '("arg1 failed",Gt 4), '("arg2 failed", Same 4)]) [17,4]
Val [17,4]

>>> pz @(Guards '[ '("arg1 failed",Gt 4), '("arg2 failed", Same 5)]) [17,4]
Fail "arg2 failed"

>>> pz @(Guards '[ '("arg1 failed",Gt 99), '("arg2 failed", Same 4)]) [17,4]
Fail "arg1 failed"

>>> pz @(Guards '[ '(PrintT "arg %d failed with value %d" Id,Gt 4), '(PrintT "%d %d" Id, Same 4)]) [17,3]
Fail "1 3"

>>> pz @(Msg "isbn10" (Resplit "-") >> Concat >> 'Just Unsnoc >> Map (ReadP Int (Singleton Id)) *** If (Singleton Id ==~ "X") 10 (ReadP Int (Singleton Id)) >> ZipWith (Fst * Snd) (1...10 >> Reverse) (Fst +: Snd) >> Sum >> Guard ("mod 0 oops") (Id `Mod` 11 == 0)) "0-306-40614-X"
Fail "mod 0 oops"

>>> pz @(Resplit "-" >> Concat >> 'Just Unsnoc >> Map (ReadP Int (Singleton Id)) *** If (Singleton Id ==~ "X") 10 (ReadP Int (Singleton Id)) >> ZipWith (Fst * Snd) (1...10 >> Reverse) (Fst +: Snd) >> Sum >> Guard ("mod 0 oops") (Id `Mod` 11 == 0)) "0-306-40611-X"
Val 132

>>> pz @(Msg "isbn13" (Resplit "-") >> Concat >> Map (ReadP Int (Singleton Id)) >> ZipWith (Fst * Snd) (Cycle 13 [1,3] >> Reverse) Id >> Sum >> '(Id,Id `Mod` 10) >> Guard (PrintT "sum=%d mod 10=%d" Id) (Snd == 0)) "978-0-306-40615-7"
Val (100,0)

>>> pz @(Resplit "-" >> Concat >> Map (ReadP Int (Singleton Id)) >> ZipWith (Fst * Snd) (Cycle 13 [1,3] >> Reverse) Id >> Sum >> '(Id,Id `Mod` 10) >> Guard (PrintT "sum=%d mod 10=%d" Id) (Snd == 0)) "978-0-306-40615-8"
Fail "sum=101 mod 10=1"

>>> pz @(Do '[Resplit "-", Concat, ZipWith (Fst * Snd) (Cycle 13 [1,3]) (Map (ReadP Int (Singleton Id))), Sum, Guard (PrintF "%d is not evenly divisible by 10" Id) (Id `Mod` 10 == 0)]) "978-0-7167-0344-9"
Fail "109 is not evenly divisible by 10"

>>> pz @(Do '[Resplit "-", Concat, ZipWith (Fst * Snd) (Cycle 13 [1,3]) (Map (ReadP Int (Singleton Id))), Sum, Guard (PrintF "%d is not evenly divisible by 10" Id) (Id `Mod` 10 == 0)]) "978-0-7167-0344-0"
Val 100

Instances

([a] ~ x, GetLen ps, P (GuardsImpl (LenT ps) ps) x) => P (Guards ps :: Type) x #
Instance details Defined in Predicate.Data.Condition Associated Types type PP (Guards ps) x :: Type # Methods eval :: MonadEval m => proxy (Guards ps) -> POpts -> x -> m (TT (PP (Guards ps) x)) #
Show (Guards ps) #
Instance details Defined in Predicate.Data.Condition Methods showsPrec :: Int -> Guards ps -> ShowS # show :: Guards ps -> String # showList :: [Guards ps] -> ShowS #
type PP (Guards ps :: Type) x #
Instance details Defined in Predicate.Data.Condition type PP (Guards ps :: Type) x

data GuardsQuick (prt :: k) (ps :: [k1]) #

GuardsQuick contain a type level list of conditions and one of matching values: on no match will fail using the first parameter

>>> pz @(GuardsQuick (PrintT "arg %d failed with value %d" Id) '[Gt 4, Ge 3, Same 4]) [17,3,5]
Fail "arg 2 failed with value 5"

>>> pz @(GuardsQuick (PrintT "arg %d failed with value %d" Id) '[Gt 4, Ge 3, Same 4]) [17,3,5,99]
Fail "Guards:invalid length(4) expected 3"

>>> pl @(GuardsQuick (PrintT "guard(%d) %d is out of range" Id) '[Between 0 11 Id, Between 1 4 Id,Between 3 5 Id]) [10,2,5]
Present [10,2,5] (Guards(3))
Val [10,2,5]

>>> pl @(GuardsQuick (PrintT "guard(%d) %d is out of range" Id) '[Between 1 31 Id, Between 1 12 Id, Between 1990 2050 Id]) [31,11,1999]
Present [31,11,1999] (Guards(3))
Val [31,11,1999]

>>> pl @(GuardsQuick (PrintT "guard(%d) %d is out of range" Id) '[Between 1 31 Id, Between 1 12 Id, Between 1990 2050 Id]) [31,11]
Error Guards:invalid length(2) expected 3
Fail "Guards:invalid length(2) expected 3"

>>> pl @(GuardsQuick (PrintT "guard(%d) %d is out of range" Id) '[Between 1 31 Id, Between 1 12 Id, Between 1990 2050 Id]) [31,13,1999]
Error guard(1) 13 is out of range (Guard(1) 13)
Fail "guard(1) 13 is out of range"

>>> pl @(GuardsQuick (PrintT "guard(%d) %d is out of range" Id) '[Between 1 31 Id, Between 1 12 Id, Between 1990 2050 Id]) [0,44,1999]
Error guard(0) 0 is out of range (Guard(0) 0)
Fail "guard(0) 0 is out of range"

>>> pl @(GuardsQuick (PrintT "guard(%d) %d is out of range" Id) '[Between 1 31 Id, Between 1 12 Id, Between 1990 2050 Id]) [31,11,2000,1,2]
Error Guards:invalid length(5) expected 3
Fail "Guards:invalid length(5) expected 3"

>>> pl @(GuardsQuick (PrintT "guard(%d) err %03d" Id) '[W 'True, Ge 12, W 'False, Lt 2]) [1,2,-99,-999]
Error guard(1) err 002 (Guard(1) 2)
Fail "guard(1) err 002"

>>> pl @(GuardsQuick (PrintT "guard(%d) err %03d" Id) '[W 'True, Ge 12, W 'False, Lt 2]) [1,2,-99]
Error Guards:invalid length(3) expected 4
Fail "Guards:invalid length(3) expected 4"

>>> pl @(GuardsQuick (PrintT "guard(%d) err %03d" Id) '[W 'True, Ge 12, W 'True, Lt 2]) [1,22,-99,-999,1,1,2]
Error Guards:invalid length(7) expected 4
Fail "Guards:invalid length(7) expected 4"

Instances

P (GuardsQuickT prt ps) x => P (GuardsQuick prt ps :: Type) x #
Instance details 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)) #
Show (GuardsQuick prt ps) #
Instance details Defined in Predicate.Data.Condition Methods showsPrec :: Int -> GuardsQuick prt ps -> ShowS # show :: GuardsQuick prt ps -> String # showList :: [GuardsQuick prt ps] -> ShowS #
type PP (GuardsQuick prt ps :: Type) x #
Instance details Defined in Predicate.Data.Condition type PP (GuardsQuick prt ps :: Type) x

data Guard prt p #

p is the predicate and on failure of the predicate runs prt

>>> pz @(Guard "expected > 3" (Gt 3)) 17
Val 17

>>> pz @(Guard "expected > 3" (Gt 3)) 1
Fail "expected > 3"

>>> pz @(Guard (PrintF "%d not > 3" Id) (Gt 3)) (-99)
Fail "-99 not > 3"

>>> pl @(Map (Guard "someval" (Lt 3) >> 'True)) [1 ..10]
Error someval(8) (Map(i=2, a=3) excnt=8)
Fail "someval(8)"

>>> pl @(Guard "someval" (Len == 2) >> (ShowP Id &&& Id)) ([] :: [Int])
Error someval (Guard | [])
Fail "someval"

>>> pl @(Guard "someval" (Len == 2) >> (Id &&& ShowP Id)) [2,3]
Present ([2,3],"[2,3]") ((>>) ([2,3],"[2,3]") | {'([2,3],"[2,3]")})
Val ([2,3],"[2,3]")

>>> pl @(Guard "someval" (Len == 2) >> (ShowP Id &&& Id)) [2,3,4]
Error someval (Guard | [2,3,4])
Fail "someval"

>>> pl @(Map (Guard "someval" (Lt 3) >> 'True)) [1 ..10]
Error someval(8) (Map(i=2, a=3) excnt=8)
Fail "someval(8)"

>>> pl @(Guard "oops" (Len > 2) >> Map Succ) [12,15,16]
Present [13,16,17] ((>>) [13,16,17] | {Map [13,16,17] | [12,15,16]})
Val [13,16,17]

>>> pl @(Guard "err" (Len > 2) >> Map Succ) [12]
Error err (Guard | [12])
Fail "err"

>>> pl @(Guard (PrintF "err found len=%d" Len) (Len > 5) >> Map Succ) [12,15,16]
Error err found len=3 (Guard | [12,15,16])
Fail "err found len=3"

Instances

(Show a, P prt a, PP prt a ~ String, P p a, PP p a ~ Bool) => P (Guard prt p :: Type) a #
Instance details Defined in Predicate.Data.Condition Associated Types type PP (Guard prt p) a :: Type # Methods eval :: MonadEval m => proxy (Guard prt p) -> POpts -> a -> m (TT (PP (Guard prt p) a)) #
Show (Guard prt p) #
Instance details Defined in Predicate.Data.Condition Methods showsPrec :: Int -> Guard prt p -> ShowS # show :: Guard prt p -> String # showList :: [Guard prt p] -> ShowS #
type PP (Guard prt p :: Type) a #
Instance details Defined in Predicate.Data.Condition type PP (Guard prt p :: Type) a = a

data ExitWhen prt p #

uses Guard but negates p

>>> pl @(HeadFail "failedn" Id &&& (Len == 1 >> ExitWhen "ExitWhen" Id) >> Fst) [3]
Error ExitWhen (Guard | True | True | '(,))
Fail "ExitWhen"

>>> pl @(Head &&& (Len == 1 >> Not Id >> ExitWhen "ExitWhen" Id) >> Fst) [3]
Present 3 ((>>) 3 | {Fst 3 | (3,False)})
Val 3

>>> pl @(Head &&& (Len == 1 >> ExitWhen "ExitWhen" (Not Id)) >> Fst) [3]
Present 3 ((>>) 3 | {Fst 3 | (3,True)})
Val 3

>>> pl @(ExitWhen "ExitWhen" (Len /= 1) >> Head) [3,1]
Error ExitWhen (Guard | [3,1])
Fail "ExitWhen"

>>> pl @(ExitWhen "ExitWhen" (Len /= 1) >> Head) [3]
Present 3 ((>>) 3 | {Head 3 | [3]})
Val 3

>>> pl @(ExitWhen "ExitWhen" (Len /= 1) >> Head >> Gt (20 -% 1)) [3]
True ((>>) True | {3 % 1 > (-20) % 1})
Val True

>>> pl @(ExitWhen "ExitWhen" (Len /= 1) >> Head >> Gt (20 -% 1)) [-23]
False ((>>) False | {(-23) % 1 > (-20) % 1})
Val False

>>> pl @(Map (ExitWhen "ExitWhen" (Gt 10) >> Gt 2)) [1..5]
Present [False,False,True,True,True] (Map [False,False,True,True,True] | [1,2,3,4,5])
Val [False,False,True,True,True]

>>> pl @(ExitWhen "err" (Len > 2) >> Map Succ) [12,15,16]
Error err (Guard | [12,15,16])
Fail "err"

>>> pl @(ExitWhen "err" (Len > 2) >> Map Succ) [12]
Present [13] ((>>) [13] | {Map [13] | [12]})
Val [13]

Instances

P (ExitWhenT prt p) x => P (ExitWhen prt p :: Type) x #
Instance details Defined in Predicate.Data.Condition Associated Types type PP (ExitWhen prt p) x :: Type # Methods eval :: MonadEval m => proxy (ExitWhen prt p) -> POpts -> x -> m (TT (PP (ExitWhen prt p) x)) #
Show (ExitWhen prt p) #
Instance details Defined in Predicate.Data.Condition Methods showsPrec :: Int -> ExitWhen prt p -> ShowS # show :: ExitWhen prt p -> String # showList :: [ExitWhen prt p] -> ShowS #
type PP (ExitWhen prt p :: Type) x #
Instance details Defined in Predicate.Data.Condition type PP (ExitWhen prt p :: Type) x

data GuardSimple p #

similar to Guard but uses the root message of the False predicate case as the failure message

>>> pz @(GuardSimple IsLuhn) [1..4]
Fail "(IsLuhn map=[4,6,2,2] sum=14 ret=4 | [1,2,3,4])"

>>> pl @IsLuhn [1..4]
False (IsLuhn map=[4,6,2,2] sum=14 ret=4 | [1,2,3,4])
Val False

>>> pz @(GuardSimple IsLuhn) [1,2,3,0]
Val [1,2,3,0]

>>> pz @(GuardSimple (Len > 30)) [1,2,3,0]
Fail "(4 > 30)"

>>> pl @(Map (GuardSimple (Lt 3) >> 'True)) [1 .. 10]
Error (3 < 3) | (4 < 3) | (5 < 3) | (6 < 3) | (7 < 3) | (8 < 3) | (9 < 3) | (10 < 3) (Map(i=2, a=3) excnt=8)
Fail "(3 < 3) | (4 < 3) | (5 < 3) | (6 < 3) | (7 < 3) | (8 < 3) | (9 < 3) | (10 < 3)"

>>> pl @(Map (GuardSimple (Ge 1) >> 'True)) [1 .. 10]
Present [True,True,True,True,True,True,True,True,True,True] (Map [True,True,True,True,True,True,True,True,True,True] | [1,2,3,4,5,6,7,8,9,10])
Val [True,True,True,True,True,True,True,True,True,True]

>>> pl @(Map (GuardSimple (Lt 3) >> 'True)) [1 .. 10]
Error (3 < 3) | (4 < 3) | (5 < 3) | (6 < 3) | (7 < 3) | (8 < 3) | (9 < 3) | (10 < 3) (Map(i=2, a=3) excnt=8)
Fail "(3 < 3) | (4 < 3) | (5 < 3) | (6 < 3) | (7 < 3) | (8 < 3) | (9 < 3) | (10 < 3)"

Instances

(Show a, P p a, PP p a ~ Bool) => P (GuardSimple p :: Type) a #
Instance details 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 (GuardSimple p) #
Instance details Defined in Predicate.Data.Condition Methods showsPrec :: Int -> GuardSimple p -> ShowS # show :: GuardSimple p -> String # showList :: [GuardSimple p] -> ShowS #
type PP (GuardSimple p :: Type) a #
Instance details Defined in Predicate.Data.Condition type PP (GuardSimple p :: Type) a = a

data GuardsN prt (n :: Nat) p #

leverages RepeatT for repeating predicates (passthrough method)

>>> pz @(GuardsN (PrintT "id=%d must be between 0 and 255, found %d" Id) 4 (0 <..> 0xff)) [121,33,7,256]
Fail "id=3 must be between 0 and 255, found 256"

>>> pz @(GuardsN (PrintT "id=%d must be between 0 and 255, found %d" Id) 4 (0 <..> 0xff)) [121,33,7,44]
Val [121,33,7,44]

>>> pl @(GuardsN (PrintT "guard(%d) %d is out of range" Id) 4 (0 <..> 0xff)) [1,2,3,4]
Present [1,2,3,4] (Guards(4))
Val [1,2,3,4]

>>> pl @(GuardsN (PrintT "guard(%d) %d is out of range" Id) 4 (0 <..> 0xff)) [1,2,3,4,5]
Error Guards:invalid length(5) expected 4
Fail "Guards:invalid length(5) expected 4"

>>> pl @(GuardsN (PrintT "guard(%d) %d is out of range" Id) 4 (0 <..> 0xff)) [1,2,3]
Error Guards:invalid length(3) expected 4
Fail "Guards:invalid length(3) expected 4"

Instances

(x ~ [a], P (GuardsNT prt n p) x) => P (GuardsN prt n p :: Type) x #
Instance details Defined in Predicate.Data.Condition Associated Types type PP (GuardsN prt n p) x :: Type # Methods eval :: MonadEval m => proxy (GuardsN prt n p) -> POpts -> x -> m (TT (PP (GuardsN prt n p) x)) #
Show (GuardsN prt n p) #
Instance details Defined in Predicate.Data.Condition Methods showsPrec :: Int -> GuardsN prt n p -> ShowS # show :: GuardsN prt n p -> String # showList :: [GuardsN prt n p] -> ShowS #
type PP (GuardsN prt n p :: Type) x #
Instance details Defined in Predicate.Data.Condition type PP (GuardsN prt n p :: Type) x

data GuardsDetail prt (ps :: [(k0, k1)]) #

Instances

P (GuardsDetailT prt ps) x => P (GuardsDetail prt ps :: Type) x #
Instance details 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)) #
Show (GuardsDetail prt ps) #
Instance details Defined in Predicate.Data.Condition Methods showsPrec :: Int -> GuardsDetail prt ps -> ShowS # show :: GuardsDetail prt ps -> String # showList :: [GuardsDetail prt ps] -> ShowS #
type PP (GuardsDetail prt ps :: Type) x #
Instance details Defined in Predicate.Data.Condition type PP (GuardsDetail prt ps :: Type) x

data GuardBool prt p #

boolean guard

>>> pl @(GuardBool (PrintF "bad length = %d" Len) (Len > 9)) [3..8]
Error bad length = 6 (GuardBool (6 > 9))
Fail "bad length = 6"

Instances

(P prt a, PP prt a ~ String, P p a, PP p a ~ Bool) => P (GuardBool prt p :: Type) a #
Instance details Defined in Predicate.Data.Condition Associated Types type PP (GuardBool prt p) a :: Type # Methods eval :: MonadEval m => proxy (GuardBool prt p) -> POpts -> a -> m (TT (PP (GuardBool prt p) a)) #
Show (GuardBool prt p) #
Instance details Defined in Predicate.Data.Condition Methods showsPrec :: Int -> GuardBool prt p -> ShowS # show :: GuardBool prt p -> String # showList :: [GuardBool prt p] -> ShowS #
type PP (GuardBool prt p :: Type) a #
Instance details Defined in Predicate.Data.Condition type PP (GuardBool prt p :: Type) a = Bool

data Bools (ps :: [(k, k1)]) #

boolean guard which checks a given a list of predicates against the list of values

>>> pl @(Bools '[ '(W "hh",Between 0 23 Id), '(W "mm",Between 0 59 Id), '(PrintT "<<<%d %d>>>" Id,Between 0 59 Id) ]) [12,93,14]
Error Bool(1) [mm] (93 <= 59)
Fail "Bool(1) [mm] (93 <= 59)"

>>> pl @(Bools '[ '(W "hh",Between 0 23 Id), '(W "mm",Between 0 59 Id), '(PrintT "<<<%d %d>>>" Id,Between 0 59 Id) ]) [12,13,94]
Error Bool(2) [<<<2 94>>>] (94 <= 59)
Fail "Bool(2) [<<<2 94>>>] (94 <= 59)"

>>> pl @(Bools '[ '(W "hh",Between 0 23 Id), '(W "mm",Between 0 59 Id), '(PrintT "<<<%d %d>>>" Id,Between 0 59 Id) ]) [12,13,14]
True (Bools)
Val True

>>> pl @(Bools '[ '("hours",Between 0 23 Id), '("minutes",Between 0 59 Id), '("seconds",Between 0 59 Id)]) [12,13,14]
True (Bools)
Val True

>>> pl @(Bools '[ '("hours",Between 0 23 Id), '("minutes",Between 0 59 Id), '("seconds",Between 0 59 Id)]) [12,60,14]
Error Bool(1) [minutes] (60 <= 59)
Fail "Bool(1) [minutes] (60 <= 59)"

>>> pl @(Bools '[ '("hours",Between 0 23 Id), '("minutes",Between 0 59 Id), '("seconds",Between 0 59 Id)]) [12,60,14,20]
Error Bools:invalid length(4) expected 3
Fail "Bools:invalid length(4) expected 3"

Instances

([a] ~ x, GetLen ps, P (BoolsImpl (LenT ps) ps) x, PP (BoolsImpl (LenT ps) ps) x ~ Bool) => P (Bools ps :: Type) x #
Instance details Defined in Predicate.Data.Condition Associated Types type PP (Bools ps) x :: Type # Methods eval :: MonadEval m => proxy (Bools ps) -> POpts -> x -> m (TT (PP (Bools ps) x)) #
Show (Bools ps) #
Instance details Defined in Predicate.Data.Condition Methods showsPrec :: Int -> Bools ps -> ShowS # show :: Bools ps -> String # showList :: [Bools ps] -> ShowS #
type PP (Bools ps :: Type) x #
Instance details Defined in Predicate.Data.Condition type PP (Bools ps :: Type) x = Bool

data BoolsQuick (prt :: k) (ps :: [k1]) #

boolean guard which checks a given a list of predicates against the list of values

>>> pl @(BoolsQuick "abc" '[Between 0 23 Id, Between 0 59 Id, Between 0 59 Id]) [12,13,14]
True (Bools)
Val True

>>> pl @(BoolsQuick (PrintT "id=%d val=%d" Id) '[Between 0 23 Id, Between 0 59 Id, Between 0 59 Id]) [12,13,14]
True (Bools)
Val True

>>> pl @(BoolsQuick (PrintT "id=%d val=%d" Id) '[Between 0 23 Id, Between 0 59 Id, Between 0 59 Id]) [12,13,99]
Error Bool(2) [id=2 val=99] (99 <= 59)
Fail "Bool(2) [id=2 val=99] (99 <= 59)"

Instances

(PP (Bools (ToGuardsT prt ps)) x ~ Bool, P (BoolsQuickT prt ps) x) => P (BoolsQuick prt ps :: Type) x #
Instance details 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)) #
Show (BoolsQuick prt ps) #
Instance details Defined in Predicate.Data.Condition Methods showsPrec :: Int -> BoolsQuick prt ps -> ShowS # show :: BoolsQuick prt ps -> String # showList :: [BoolsQuick prt ps] -> ShowS #
type PP (BoolsQuick prt ps :: Type) x #
Instance details Defined in Predicate.Data.Condition type PP (BoolsQuick prt ps :: Type) x = Bool

data BoolsN prt (n :: Nat) (p :: k1) #

leverages RepeatT for repeating predicates (passthrough method)

>>> pl @(BoolsN (PrintT "id=%d must be between 0 and 255, found %d" Id) 4 (0 <..> 0xff)) [121,33,7,256]
Error Bool(3) [id=3 must be between 0 and 255, found 256] (256 <= 255)
Fail "Bool(3) [id=3 must be between 0 and 255, found 256] (256 <= 255)"

>>> pl @(BoolsN (PrintT "id=%d must be between 0 and 255, found %d" Id) 4 (0 <..> 0xff)) [121,33,7,44]
True (Bools)
Val True

Instances

(x ~ [a], P (BoolsNT prt n p) x) => P (BoolsN prt n p :: Type) x #
Instance details Defined in Predicate.Data.Condition Associated Types type PP (BoolsN prt n p) x :: Type # Methods eval :: MonadEval m => proxy (BoolsN prt n p) -> POpts -> x -> m (TT (PP (BoolsN prt n p) x)) #
Show (BoolsN prt n p) #
Instance details Defined in Predicate.Data.Condition Methods showsPrec :: Int -> BoolsN prt n p -> ShowS # show :: BoolsN prt n p -> String # showList :: [BoolsN prt n p] -> ShowS #
type PP (BoolsN prt n p :: Type) x #
Instance details Defined in Predicate.Data.Condition type PP (BoolsN prt n p :: Type) x = Bool