Predicate.Data.These

promoted These functions

boolean predicates

data IsThis

predicate on This

>>> pz @IsThis (This "aBc")
Val True

>>> pz @IsThis (These 1 'a')
Val False

>>> pl @IsThis (This 12)
True (IsThis | This 12)
Val True

Instances

Show IsThis

Defined in Predicate.Data.These

Methods

showsPrec :: Int -> IsThis -> ShowS

show :: IsThis -> String

showList :: [IsThis] -> ShowS

P IsThisT x => P IsThis x

Defined in Predicate.Data.These

Associated Types

type PP IsThis x

Methods

eval :: MonadEval m => proxy IsThis -> POpts -> x -> m (TT (PP IsThis x))

type PP IsThis x

Defined in Predicate.Data.These

type PP IsThis x

data IsThat

predicate on That

>>> pl @IsThat (This 12)
False (IsThat | This 12)
Val False

Instances

Show IsThat

Defined in Predicate.Data.These

Methods

showsPrec :: Int -> IsThat -> ShowS

show :: IsThat -> String

showList :: [IsThat] -> ShowS

P IsThatT x => P IsThat x

Defined in Predicate.Data.These

Associated Types

type PP IsThat x

Methods

eval :: MonadEval m => proxy IsThat -> POpts -> x -> m (TT (PP IsThat x))

type PP IsThat x

Defined in Predicate.Data.These

type PP IsThat x

data IsThese

predicate on These

>>> pl @IsThese (This 12)
False (IsThese | This 12)
Val False

>>> pz @IsThese (These 1 'a')
Val True

>>> pl @IsThese (These 'x' 12)
True (IsThese | These 'x' 12)
Val True

>>> pl @IsThese (That (SG.Sum 12))
False (IsThese | That (Sum {getSum = 12}))
Val False

>>> pl @IsThese (These 1 (SG.Sum 12))
True (IsThese | These 1 (Sum {getSum = 12}))
Val True

Instances

Show IsThese

Defined in Predicate.Data.These

Methods

showsPrec :: Int -> IsThese -> ShowS

show :: IsThese -> String

showList :: [IsThese] -> ShowS

P IsTheseT x => P IsThese x

Defined in Predicate.Data.These

Associated Types

type PP IsThese x

Methods

eval :: MonadEval m => proxy IsThese -> POpts -> x -> m (TT (PP IsThese x))

type PP IsThese x

Defined in Predicate.Data.These

type PP IsThese x

constructors

data MkThis (t :: Type) p

This constructor

>>> pl @(MkThis () Id) 'x'
Present This 'x' (MkThis This 'x')
Val (This 'x')

>>> pl @(MkThis () Fst) ('x',True)
Present This 'x' (MkThis This 'x')
Val (This 'x')

>>> pz @(MkThis _ Id) 44
Val (This 44)

Instances

P (MkThisT t p) x => P (MkThis t p :: Type) x

Defined in Predicate.Data.These

Associated Types

type PP (MkThis t p) x

Methods

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

Show (MkThis t p)

Defined in Predicate.Data.These

Methods

showsPrec :: Int -> MkThis t p -> ShowS

show :: MkThis t p -> String

showList :: [MkThis t p] -> ShowS

type PP (MkThis t p :: Type) x

Defined in Predicate.Data.These

type PP (MkThis t p :: Type) x

data MkThis' t p

This constructor

>>> pz @(Proxy Int >> MkThis' UnproxyT 10) []
Val (This 10)

Instances

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

Defined in Predicate.Data.These

Associated Types

type PP (MkThis' t p) x

Methods

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

Show (MkThis' t p)

Defined in Predicate.Data.These

Methods

showsPrec :: Int -> MkThis' t p -> ShowS

show :: MkThis' t p -> String

showList :: [MkThis' t p] -> ShowS

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

Defined in Predicate.Data.These

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

data MkThat (t :: Type) p

That constructor

>>> pz @(MkThat _ Id) 44
Val (That 44)

>>> pz @(MkThat _ "Abc" <> MkThis _ '[1,2] <> MkThese [3,4] "def") ()
Val (These [1,2,3,4] "Abcdef")

>>> pl @(MkThat () Id) 'x'
Present That 'x' (MkThat That 'x')
Val (That 'x')

Instances

P (MkThatT t p) x => P (MkThat t p :: Type) x

Defined in Predicate.Data.These

Associated Types

type PP (MkThat t p) x

Methods

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

Show (MkThat t p)

Defined in Predicate.Data.These

Methods

showsPrec :: Int -> MkThat t p -> ShowS

show :: MkThat t p -> String

showList :: [MkThat t p] -> ShowS

type PP (MkThat t p :: Type) x

Defined in Predicate.Data.These

type PP (MkThat t p :: Type) x

data MkThat' t p

Instances

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

Defined in Predicate.Data.These

Associated Types

type PP (MkThat' t p) x

Methods

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

Show (MkThat' t p)

Defined in Predicate.Data.These

Methods

showsPrec :: Int -> MkThat' t p -> ShowS

show :: MkThat' t p -> String

showList :: [MkThat' t p] -> ShowS

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

Defined in Predicate.Data.These

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

data MkThese p q

These constructor

>>> pz @(MkThese Fst Snd) (44,'x')
Val (These 44 'x')

>>> pl @(MkThese Id 'True) 'x'
Present These 'x' True (MkThese These 'x' True)
Val (These 'x' True)

Instances

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

Defined in Predicate.Data.These

Associated Types

type PP (MkThese p q) a

Methods

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

Show (MkThese p q)

Defined in Predicate.Data.These

Methods

showsPrec :: Int -> MkThese p q -> ShowS

show :: MkThese p q -> String

showList :: [MkThese p q] -> ShowS

type PP (MkThese p q :: Type) a

Defined in Predicate.Data.These

type PP (MkThese p q :: Type) a = These (PP p a) (PP q a)

get rid of These

data This'

tries to extract a value from the This constructor

>>> pz @(This' >> Succ) (This 20)
Val 21

>>> pz @(This' >> Succ) (That 'a')
Fail "This' found That"

Instances

Show This'

Defined in Predicate.Data.These

Methods

showsPrec :: Int -> This' -> ShowS

show :: This' -> String

showList :: [This'] -> ShowS

Show a => P This' (These a x)

Defined in Predicate.Data.These

Associated Types

type PP This' (These a x)

Methods

eval :: MonadEval m => proxy This' -> POpts -> These a x -> m (TT (PP This' (These a x)))

type PP This' (These a x)

Defined in Predicate.Data.These

type PP This' (These a x) = a

data That'

tries to extract a value from the That constructor

>>> pz @(That' >> Succ) (That 20)
Val 21

>>> pz @(That' >> Succ) (This 'a')
Fail "That' found This"

Instances

Show That'

Defined in Predicate.Data.These

Methods

showsPrec :: Int -> That' -> ShowS

show :: That' -> String

showList :: [That'] -> ShowS

Show a => P That' (These x a)

Defined in Predicate.Data.These

Associated Types

type PP That' (These x a)

Methods

eval :: MonadEval m => proxy That' -> POpts -> These x a -> m (TT (PP That' (These x a)))

type PP That' (These x a)

Defined in Predicate.Data.These

type PP That' (These x a) = a

data These'

tries to extract the values from the These constructor

>>> pz @(These' >> Second Succ) (These 1 'a')
Val (1,'b')

>>> pz @(That' >> Succ) (This 'a')
Fail "That' found This"

>>> pz @(These' >> Second Succ) (That 8)
Fail "These' found That"

Instances

Show These'

Defined in Predicate.Data.These

Methods

showsPrec :: Int -> These' -> ShowS

show :: These' -> String

showList :: [These'] -> ShowS

(Show a, Show b) => P These' (These a b)

Defined in Predicate.Data.These

Associated Types

type PP These' (These a b)

Methods

eval :: MonadEval m => proxy These' -> POpts -> These a b -> m (TT (PP These' (These a b)))

type PP These' (These a b)

Defined in Predicate.Data.These

type PP These' (These a b) = (a, b)

data ThisDef p q

extract the This value from an These otherwise use the default value if there is no This value then p is passed the whole context only

>>> pz @(ThisDef (1 % 4) Id) (This 20.4)
Val (102 % 5)

>>> pz @(ThisDef (1 % 4) Id) (That "aa")
Val (1 % 4)

>>> pz @(ThisDef (1 % 4) Id) (These 2.3 "aa")
Val (1 % 4)

>>> pz @(ThisDef (PrintT "found %s fst=%d" '(ShowP Snd, Fst)) Snd) (123,That "xy")
Val "found That \"xy\" fst=123"

>>> pz @(ThisDef (MEmptyT _) Id) (That 222)
Val ()

>>> pz @(ThisDef (MEmptyT (SG.Sum _)) Id) (These 222 'x')
Val (Sum {getSum = 0})

>>> pl @(ThisDef (MEmptyT _) Id) (This (SG.Sum 12))
Present Sum {getSum = 12} (ThisDef This)
Val (Sum {getSum = 12})

>>> pl @(ThisDef (MEmptyT _) Id) (That 12)
Present () (ThisDef That)
Val ()

Instances

(PP q x ~ These a b, PP p x ~ a, P q x, P p x) => P (ThisDef p q :: Type) x

Defined in Predicate.Data.These

Associated Types

type PP (ThisDef p q) x

Methods

eval :: MonadEval m => proxy (ThisDef p q) -> POpts -> x -> m (TT (PP (ThisDef p q) x))

Show (ThisDef p q)

Defined in Predicate.Data.These

Methods

showsPrec :: Int -> ThisDef p q -> ShowS

show :: ThisDef p q -> String

showList :: [ThisDef p q] -> ShowS

type PP (ThisDef p q :: Type) x

Defined in Predicate.Data.These

type PP (ThisDef p q :: Type) x = ThisT (PP q x)

data ThisFail p q

extract the This value from a These otherwise fail with a message

if there is no This value then p is passed the whole context only

>>> pz @(ThisFail "oops" Id) (This 20.4)
Val 20.4

>>> pz @(ThisFail "oops" Id) (That "aa")
Fail "oops"

>>> pz @(ThisFail (PrintT "found %s fst=%d" '(ShowP Snd,Fst)) Snd) (123,That "xy")
Fail "found That \"xy\" fst=123"

>>> pz @(ThisFail (MEmptyT _) Id) (That 222)
Fail ""

>>> pl @(ThisFail "sdf" Id) (This (SG.Sum 12))
Present Sum {getSum = 12} (This)
Val (Sum {getSum = 12})

>>> pl @(ThisFail "sdf" Id) (That (SG.Sum 12))
Error sdf (ThisFail That)
Fail "sdf"

>>> pl @(ThisFail "sdf" Id) (That 12)
Error sdf (ThisFail That)
Fail "sdf"

Instances

(PP p x ~ String, PP q x ~ These a b, P p x, P q x) => P (ThisFail p q :: Type) x

Defined in Predicate.Data.These

Associated Types

type PP (ThisFail p q) x

Methods

eval :: MonadEval m => proxy (ThisFail p q) -> POpts -> x -> m (TT (PP (ThisFail p q) x))

Show (ThisFail p q)

Defined in Predicate.Data.These

Methods

showsPrec :: Int -> ThisFail p q -> ShowS

show :: ThisFail p q -> String

showList :: [ThisFail p q] -> ShowS

type PP (ThisFail p q :: Type) x

Defined in Predicate.Data.These

type PP (ThisFail p q :: Type) x = ThisT (PP q x)

data ThatDef p q

extract the That value from an These otherwise use the default value

if there is no That value then p is passed the whole context only

>>> pz @(ThatDef (1 % 4) Id) (That 20.4)
Val (102 % 5)

>>> pz @(ThatDef (1 % 4) Id) (This "aa")
Val (1 % 4)

>>> pz @(ThatDef (1 % 4) Id) (These "aa" 2.3)
Val (1 % 4)

>>> pz @(ThatDef (PrintT "found %s fst=%d" '(ShowP Snd, Fst)) Snd) (123,This "xy")
Val "found This \"xy\" fst=123"

>>> pz @(ThatDef (MEmptyT _) Id) (This 222)
Val ()

>>> pz @(ThatDef (MEmptyT (SG.Sum _)) Id) (These 'x' 1120)
Val (Sum {getSum = 0})

Instances

(PP q x ~ These a b, PP p x ~ b, P q x, P p x) => P (ThatDef p q :: Type) x

Defined in Predicate.Data.These

Associated Types

type PP (ThatDef p q) x

Methods

eval :: MonadEval m => proxy (ThatDef p q) -> POpts -> x -> m (TT (PP (ThatDef p q) x))

Show (ThatDef p q)

Defined in Predicate.Data.These

Methods

showsPrec :: Int -> ThatDef p q -> ShowS

show :: ThatDef p q -> String

showList :: [ThatDef p q] -> ShowS

type PP (ThatDef p q :: Type) x

Defined in Predicate.Data.These

type PP (ThatDef p q :: Type) x = ThatT (PP q x)

data ThatFail p q

extract the That value from a These otherwise fail with a message

if there is no That value then p is passed the whole context only

>>> pz @(ThatFail "oops" Id) (That 20.4)
Val 20.4

>>> pz @(ThatFail "oops" Id) (This "aa")
Fail "oops"

>>> pz @(ThatFail (PrintT "found %s fst=%d" '(ShowP Snd,Fst)) Snd) (123,This "xy")
Fail "found This \"xy\" fst=123"

>>> pz @(ThatFail (MEmptyT _) Id) (This 222)
Fail ""

Instances

(PP p x ~ String, PP q x ~ These a b, P p x, P q x) => P (ThatFail p q :: Type) x

Defined in Predicate.Data.These

Associated Types

type PP (ThatFail p q) x

Methods

eval :: MonadEval m => proxy (ThatFail p q) -> POpts -> x -> m (TT (PP (ThatFail p q) x))

Show (ThatFail p q)

Defined in Predicate.Data.These

Methods

showsPrec :: Int -> ThatFail p q -> ShowS

show :: ThatFail p q -> String

showList :: [ThatFail p q] -> ShowS

type PP (ThatFail p q :: Type) x

Defined in Predicate.Data.These

type PP (ThatFail p q :: Type) x = ThatT (PP q x)

data TheseDef p q

extract the These value from an These otherwise use the default value

if there is no These value then p is passed the whole context only

>>> pz @(TheseDef '(1 % 4,"zz") Id) (These 20.4 "x")
Val (102 % 5,"x")

>>> pz @(TheseDef '(1 % 4,"zz") Id) (This 20.4)
Val (1 % 4,"zz")

>>> pz @(TheseDef '(1 % 4,"zz") Id) (That "x")
Val (1 % 4,"zz")

>>> pz @(TheseDef '(PrintT "found %s fst=%d" '(ShowP Snd, Fst),999) Snd) (123,This "xy")
Val ("found This \"xy\" fst=123",999)

>>> pz @(TheseDef (MEmptyT (SG.Sum _, String)) Id) (This 222)
Val (Sum {getSum = 0},"")

>>> pz @(TheseDef (MEmptyT _) Id) (These (SG.Sum 222) "aa")
Val (Sum {getSum = 222},"aa")

>>> pl @(TheseDef '("xyz",'True) Id) (This "abc")
Present ("xyz",True) (TheseDef This)
Val ("xyz",True)

>>> pl @(TheseDef '("xyz",'True) Id) (That False)
Present ("xyz",True) (TheseDef That)
Val ("xyz",True)

>>> pl @(TheseDef '("xyz",'True) Id) (These "abc" False)
Present ("abc",False) (TheseDef These)
Val ("abc",False)

Instances

(PP q x ~ These a b, PP p x ~ (a, b), P q x, P p x) => P (TheseDef p q :: Type) x

Defined in Predicate.Data.These

Associated Types

type PP (TheseDef p q) x

Methods

eval :: MonadEval m => proxy (TheseDef p q) -> POpts -> x -> m (TT (PP (TheseDef p q) x))

Show (TheseDef p q)

Defined in Predicate.Data.These

Methods

showsPrec :: Int -> TheseDef p q -> ShowS

show :: TheseDef p q -> String

showList :: [TheseDef p q] -> ShowS

type PP (TheseDef p q :: Type) x

Defined in Predicate.Data.These

type PP (TheseDef p q :: Type) x = TheseT (PP q x)

data TheseFail p q

extract the These value from a These otherwise fail with a message

if there is no These value then p is passed the whole context only

>>> pz @(TheseFail "oops" Id) (These "abc" 20.4)
Val ("abc",20.4)

>>> pz @(TheseFail "oops" Id) (That "aa")
Fail "oops"

>>> pz @(TheseFail (PrintT "found %s fst=%d" '(ShowP Snd,Fst)) Snd) (123,That "xy")
Fail "found That \"xy\" fst=123"

>>> pz @(TheseFail (MEmptyT _) Id) (That 222)
Fail ""

Instances

(PP p x ~ String, PP q x ~ These a b, P p x, P q x) => P (TheseFail p q :: Type) x

Defined in Predicate.Data.These

Associated Types

type PP (TheseFail p q) x

Methods

eval :: MonadEval m => proxy (TheseFail p q) -> POpts -> x -> m (TT (PP (TheseFail p q) x))

Show (TheseFail p q)

Defined in Predicate.Data.These

Methods

showsPrec :: Int -> TheseFail p q -> ShowS

show :: TheseFail p q -> String

showList :: [TheseFail p q] -> ShowS

type PP (TheseFail p q :: Type) x

Defined in Predicate.Data.These

type PP (TheseFail p q :: Type) x = TheseT (PP q x)

data Thiss

similar to catThis

>>> pz @(Thiss) [That 1, This 'a', These 'b' 33, This 'd', That 4]
Val "ad"

>>> pz @(Thiss) [That 1, This 'a', These 'b' 33]
Val "a"

>>> pz @(Thiss) [That 1, That 9, These 1 33]
Val []

Instances

Show Thiss

Defined in Predicate.Data.These

Methods

showsPrec :: Int -> Thiss -> ShowS

show :: Thiss -> String

showList :: [Thiss] -> ShowS

P ThissT x => P Thiss x

Defined in Predicate.Data.These

Associated Types

type PP Thiss x

Methods

eval :: MonadEval m => proxy Thiss -> POpts -> x -> m (TT (PP Thiss x))

type PP Thiss x

Defined in Predicate.Data.These

type PP Thiss x

data Thats

similar to catThat

>>> pl @Thats [This 1, This 10,That 'x', This 99, That 'y']
Present "xy" ((>>) "xy" | {Snd "xy" | ([1,10,99],"xy",[])})
Val "xy"

Instances

Show Thats

Defined in Predicate.Data.These

Methods

showsPrec :: Int -> Thats -> ShowS

show :: Thats -> String

showList :: [Thats] -> ShowS

P ThatsT x => P Thats x

Defined in Predicate.Data.These

Associated Types

type PP Thats x

Methods

eval :: MonadEval m => proxy Thats -> POpts -> x -> m (TT (PP Thats x))

type PP Thats x

Defined in Predicate.Data.These

type PP Thats x

data Theses

similar to catThese

>>> pz @(ZipThese Id Tail >> Theses) [1..10]
Val [(1,2),(2,3),(3,4),(4,5),(5,6),(6,7),(7,8),(8,9),(9,10)]

Instances

Show Theses

Defined in Predicate.Data.These

Methods

showsPrec :: Int -> Theses -> ShowS

show :: Theses -> String

showList :: [Theses] -> ShowS

P ThesesT x => P Theses x

Defined in Predicate.Data.These

Associated Types

type PP Theses x

Methods

eval :: MonadEval m => proxy Theses -> POpts -> x -> m (TT (PP Theses x))

type PP Theses x

Defined in Predicate.Data.These

type PP Theses x

data Theres

similar to catThere

>>> pz @(ZipThese Id Tail >> Theres) [1..10]
Val [2,3,4,5,6,7,8,9,10]

Instances

Show Theres

Defined in Predicate.Data.These

Methods

showsPrec :: Int -> Theres -> ShowS

show :: Theres -> String

showList :: [Theres] -> ShowS

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

Defined in Predicate.Data.These

Associated Types

type PP Theres [These a b]

Methods

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

type PP Theres [These a b]

Defined in Predicate.Data.These

type PP Theres [These a b] = [b]

data Heres

similar to catHere

>>> pz @(ZipThese Id Tail >> Heres) [1..10]
Val [1,2,3,4,5,6,7,8,9,10]

Instances

Show Heres

Defined in Predicate.Data.These

Methods

showsPrec :: Int -> Heres -> ShowS

show :: Heres -> String

showList :: [Heres] -> ShowS

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

Defined in Predicate.Data.These

Associated Types

type PP Heres [These a b]

Methods

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

type PP Heres [These a b]

Defined in Predicate.Data.These

type PP Heres [These a b] = [a]

data TheseIn p q r

similar to these

>>> pz @(TheseIn Id Len (Fst + Length Snd)) (This 13)
Val 13

>>> pz @(TheseIn Id Len (Fst + Length Snd)) (That "this is a long string")
Val 21

>>> pz @(TheseIn Id Len (Fst + Length Snd)) (These 20 "somedata")
Val 28

>>> pz @(TheseIn (MkLeft _ Id) (MkRight _ Id) (If (Fst > Length Snd) (MkLeft _ Fst) (MkRight _ Snd))) (That "this is a long string")
Val (Right "this is a long string")

>>> pz @(TheseIn (MkLeft _ Id) (MkRight _ Id) (If (Fst > Length Snd) (MkLeft _ Fst) (MkRight _ Snd))) (These 1 "this is a long string")
Val (Right "this is a long string")

>>> pz @(TheseIn (MkLeft _ Id) (MkRight _ Id) (If (Fst > Length Snd) (MkLeft _ Fst) (MkRight _ Snd))) (These 100 "this is a long string")
Val (Left 100)

>>> pl @(TheseIn "this" "that" "these") (This (SG.Sum 12))
Present "this" (TheseIn "this" | This Sum {getSum = 12})
Val "this"

>>> pl @(TheseIn (Id &&& 999) ("no value" &&& Id) Id) (These "Ab" 13)
Present ("Ab",13) (TheseIn ("Ab",13) | These "Ab" 13)
Val ("Ab",13)

>>> pl @(TheseIn (Id &&& 999) ("no value" &&& Id) Id) (This "Ab")
Present ("Ab",999) (TheseIn ("Ab",999) | This "Ab")
Val ("Ab",999)

>>> pl @(TheseIn (Id &&& 999) ("no value" &&& Id) Id) (That 13)
Present ("no value",13) (TheseIn ("no value",13) | That 13)
Val ("no value",13)

Instances

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

Defined in Predicate.Data.These

Associated Types

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

Methods

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

Show (TheseIn p q r)

Defined in Predicate.Data.These

Methods

showsPrec :: Int -> TheseIn p q r -> ShowS

show :: TheseIn p q r -> String

showList :: [TheseIn p q r] -> ShowS

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

Defined in Predicate.Data.These

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

data TheseId p q

TheseId: given a These returns a tuple but you need to provide default values for both sides

>>> pl @(TheseId "xyz" 'True ) (This "abc")
Present ("abc",True) (TheseIn ("abc",True) | This "abc")
Val ("abc",True)

>>> pl @(TheseId "xyz" 'True) (That False)
Present ("xyz",False) (TheseIn ("xyz",False) | That False)
Val ("xyz",False)

>>> pl @(TheseId "xyz" 'True) (These "abc" False)
Present ("abc",False) (TheseIn ("abc",False) | These "abc" False)
Val ("abc",False)

Instances

P (TheseIdT p q) x => P (TheseId p q :: Type) x

Defined in Predicate.Data.These

Associated Types

type PP (TheseId p q) x

Methods

eval :: MonadEval m => proxy (TheseId p q) -> POpts -> x -> m (TT (PP (TheseId p q) x))

Show (TheseId p q)

Defined in Predicate.Data.These

Methods

showsPrec :: Int -> TheseId p q -> ShowS

show :: TheseId p q -> String

showList :: [TheseId p q] -> ShowS

type PP (TheseId p q :: Type) x

Defined in Predicate.Data.These

type PP (TheseId p q :: Type) x

data PartitionThese

similar to partitionThese. returns a 3-tuple with the results so use Fst Snd Thd to extract

>>> pz @PartitionThese [This 'a', That 2, This 'c', These 'z' 1, That 4, These 'a' 2, That 99]
Val ("ac",[2,4,99],[('z',1),('a',2)])

>>> pl @PartitionThese [This 4, That 'x', That 'y',These 3 'b', This 99, These 5 'x']
Present ([4,99],"xy",[(3,'b'),(5,'x')]) (PartitionThese ([4,99],"xy",[(3,'b'),(5,'x')]) | [This 4,That 'x',That 'y',These 3 'b',This 99,These 5 'x'])
Val ([4,99],"xy",[(3,'b'),(5,'x')])

>>> pl @PartitionThese [This 1,That 'x',This 4,That 'y',These 9 'z',This 10,These 8 'y']
Present ([1,4,10],"xy",[(9,'z'),(8,'y')]) (PartitionThese ([1,4,10],"xy",[(9,'z'),(8,'y')]) | [This 1,That 'x',This 4,That 'y',These 9 'z',This 10,These 8 'y'])
Val ([1,4,10],"xy",[(9,'z'),(8,'y')])

Instances

Show PartitionThese

Defined in Predicate.Data.These

Methods

showsPrec :: Int -> PartitionThese -> ShowS

show :: PartitionThese -> String

showList :: [PartitionThese] -> ShowS

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

Defined in Predicate.Data.These

Associated Types

type PP PartitionThese [These a b]

Methods

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

type PP PartitionThese [These a b]

Defined in Predicate.Data.These

type PP PartitionThese [These a b] = ([a], [b], [(a, b)])

data TheseX p q r s

similar to mergeTheseWith but additionally provides p, q and r the original input as the first element in the tuple

>>> pz @(TheseX ((L11 + Snd) >> ShowP Id) (ShowP Id) L22 Snd) (9,This 123)
Val "132"

>>> pz @(TheseX '(Snd,"fromthis") '(Negate 99,Snd) Snd Id) (This 123)
Val (123,"fromthis")

>>> pz @(TheseX '(Snd,"fromthis") '(Negate 99,Snd) Snd Id) (That "fromthat")
Val (-99,"fromthat")

>>> pz @(TheseX '(Snd,"fromthis") '(Negate 99,Snd) Snd Id) (These 123 "fromthese")
Val (123,"fromthese")

>>> pl @(TheseX (PrintF "a=%d" (Snd >> Succ)) ("b=" <> Snd) (PrintT "a=%d b=%s" Snd) Id) (These @Int 9 "rhs")
Present "a=9 b=rhs" (TheseX(These))
Val "a=9 b=rhs"

>>> pl @(TheseX (PrintF "a=%d" (Snd >> Succ)) ("b=" <> Snd) (PrintT "a=%d b=%s" Snd) Id) (This @Int 9)
Present "a=10" (TheseX(This))
Val "a=10"

>>> pl @(TheseX (PrintF "a=%d" (Snd >> Succ)) ("b=" <> Snd) (PrintT "a=%d b=%s" Snd) Id) (That @Int "rhs")
Present "b=rhs" (TheseX(That))
Val "b=rhs"

Instances

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

Defined in Predicate.Data.These

Associated Types

type PP (TheseX p q r s) x

Methods

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

Show (TheseX p q r s)

Defined in Predicate.Data.These

Methods

showsPrec :: Int -> TheseX p q r s -> ShowS

show :: TheseX p q r s -> String

showList :: [TheseX p q r s] -> ShowS

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

Defined in Predicate.Data.These

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

miscellaneous

data ZipThese p q

similar to align thats pads with This or That if one list is shorter than the other

the key is that all information about both lists are preserved

>>> pz @(ZipThese Fst Snd) ("aBc", [1..5])
Val [These 'a' 1,These 'B' 2,These 'c' 3,That 4,That 5]

>>> pz @(ZipThese Fst Snd) ("aBcDeF", [1..3])
Val [These 'a' 1,These 'B' 2,These 'c' 3,This 'D',This 'e',This 'F']

>>> pz @(ZipThese Id Reverse) "aBcDeF"
Val [These 'a' 'F',These 'B' 'e',These 'c' 'D',These 'D' 'c',These 'e' 'B',These 'F' 'a']

>>> pz @(ZipThese Id '[]) "aBcDeF"
Val [This 'a',This 'B',This 'c',This 'D',This 'e',This 'F']

>>> pz @(ZipThese '[] Id) "aBcDeF"
Val [That 'a',That 'B',That 'c',That 'D',That 'e',That 'F']

>>> pz @(ZipThese '[] '[]) "aBcDeF"
Val []

>>> pl @(ZipThese Fst Snd >> Map (TheseIn Id Id Fst)) (['w'..'y'],['a'..'f'])
Present "wxydef" ((>>) "wxydef" | {Map "wxydef" | [These 'w' 'a',These 'x' 'b',These 'y' 'c',That 'd',That 'e',That 'f']})
Val "wxydef"

>>> pl @(("sdf" &&& Id) >> ZipThese Fst Snd >> Map (TheseIn (Id &&& 0) (C "x" &&& Id) Id)) [1..5]
Present [('s',1),('d',2),('f',3),('x',4),('x',5)] ((>>) [('s',1),('d',2),('f',3),('x',4),('x',5)] | {Map [('s',1),('d',2),('f',3),('x',4),('x',5)] | [These 's' 1,These 'd' 2,These 'f' 3,That 4,That 5]})
Val [('s',1),('d',2),('f',3),('x',4),('x',5)]

Instances

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

Defined in Predicate.Data.These

Associated Types

type PP (ZipThese p q) a

Methods

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

Show (ZipThese p q)

Defined in Predicate.Data.These

Methods

showsPrec :: Int -> ZipThese p q -> ShowS

show :: ZipThese p q -> String

showList :: [ZipThese p q] -> ShowS

type PP (ZipThese p q :: Type) a

Defined in Predicate.Data.These

type PP (ZipThese p q :: Type) a = [These (ExtractAFromList (PP p a)) (ExtractAFromList (PP q a))]

data Assoc

assoc using AssocC

>>> pz @Assoc (This (These 123 'x'))
Val (These 123 (This 'x'))

>>> pz @Assoc ((99,'a'),True)
Val (99,('a',True))

>>> pz @Assoc ((99,'a'),True)
Val (99,('a',True))

>>> pz @Assoc (Right "Abc" :: Either (Either () ()) String)
Val (Right (Right "Abc"))

>>> pz @Assoc (Left (Left 'x'))
Val (Left 'x')

>>> pl @Assoc ((10,'c'),True)
Present (10,('c',True)) (Assoc (10,('c',True)) | ((10,'c'),True))
Val (10,('c',True))

>>> pl @(Assoc >> Unassoc) ((10,'c'),True)
Present ((10,'c'),True) ((>>) ((10,'c'),True) | {Unassoc ((10,'c'),True) | (10,('c',True))})
Val ((10,'c'),True)

Instances

Show Assoc

Defined in Predicate.Data.These

Methods

showsPrec :: Int -> Assoc -> ShowS

show :: Assoc -> String

showList :: [Assoc] -> ShowS

(AssocC p, Show (p (p a b) c), Show (p a (p b c))) => P Assoc (p (p a b) c)

Defined in Predicate.Data.These

Associated Types

type PP Assoc (p (p a b) c)

Methods

eval :: MonadEval m => proxy Assoc -> POpts -> p (p a b) c -> m (TT (PP Assoc (p (p a b) c)))

type PP Assoc (p (p a b) c)

Defined in Predicate.Data.These

type PP Assoc (p (p a b) c) = p a (p b c)

data Unassoc

unassoc using AssocC

>>> pz @Unassoc (These 123 (This 'x'))
Val (This (These 123 'x'))

>>> pz @Unassoc (99,('a',True))
Val ((99,'a'),True)

>>> pz @Unassoc (This 10 :: These Int (These Bool ()))
Val (This (This 10))

>>> pz @Unassoc (Right (Right 123))
Val (Right 123)

>>> pz @Unassoc (Left 'x' :: Either Char (Either Bool Double))
Val (Left (Left 'x'))

>>> pl @Unassoc (10,('c',True))
Present ((10,'c'),True) (Unassoc ((10,'c'),True) | (10,('c',True)))
Val ((10,'c'),True)

Instances

Show Unassoc

Defined in Predicate.Data.These

Methods

showsPrec :: Int -> Unassoc -> ShowS

show :: Unassoc -> String

showList :: [Unassoc] -> ShowS

(AssocC p, Show (p (p a b) c), Show (p a (p b c))) => P Unassoc (p a (p b c))

Defined in Predicate.Data.These

Associated Types

type PP Unassoc (p a (p b c))

Methods

eval :: MonadEval m => proxy Unassoc -> POpts -> p a (p b c) -> m (TT (PP Unassoc (p a (p b c))))

type PP Unassoc (p a (p b c))

Defined in Predicate.Data.These

type PP Unassoc (p a (p b c)) = p (p a b) c