Predicate.Data.Ordering

promoted Ordering functions

compare expressions

data p > q infix 4

compare if expression 'p' is greater than 'q'

>>> pl @(Id > "xx") "abc"
False ("abc" > "xx")
FalseT

>>> pl @(Id > "aa") "abc"
True ("abc" > "aa")
TrueT

>>> pl @(Fst Id > Snd Id) (True,False)
True (True > False)
TrueT

Instances

P (Cmp CGt p q) x => P (p > q :: Type) x

Defined in Predicate.Data.Ordering

Associated Types

type PP (p > q) x :: Type

Methods

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

type PP (p > q :: Type) x

Defined in Predicate.Data.Ordering

type PP (p > q :: Type) x = Bool

data p >= q infix 4

compare if expression 'p' is greater than or equal to 'q'

Instances

P (Cmp CGe p q) x => P (p >= q :: Type) x

Defined in Predicate.Data.Ordering

Associated Types

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

Methods

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

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

Defined in Predicate.Data.Ordering

type PP (p >= q :: Type) x = Bool

data p == q infix 4

compare if expression 'p' is equal to 'q'

>>> pl @(Fst Id == Snd Id) ("ab","xyzabw")
False ("ab" == "xyzabw")
FalseT

>>> pl @(Fst Id == Snd Id) ("aBc","AbC")
False ("aBc" == "AbC")
FalseT

>>> pz @(Fst Id == Snd Id) ("aBc","aBc")
TrueT

>>> pl @(Id == "Abc") "abc"
False ("abc" == "Abc")
FalseT

>>> pl @(Fst Id == Snd Id) (True,False)
False (True == False)
FalseT

>>> pl @(Not Id *** Id >> Fst Id == Snd Id) (True,False)
True ((>>) True | {False == False})
TrueT

Instances

P (Cmp CEq p q) x => P (p == q :: Type) x

Defined in Predicate.Data.Ordering

Associated Types

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

Methods

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

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

Defined in Predicate.Data.Ordering

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

data p /= q infix 4

compare if expression 'p' is not equal to 'q'

>>> pl @(Fst Id /= Snd Id) ("ab","xyzabw")
True ("ab" /= "xyzabw")
TrueT

Instances

P (Cmp CNe p q) x => P (p /= q :: Type) x

Defined in Predicate.Data.Ordering

Associated Types

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

Methods

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

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

Defined in Predicate.Data.Ordering

type PP (p /= q :: Type) x = Bool

data p <= q infix 4

compare if expression 'p' is less than or equal to 'q'

>>> pl @(Not (Fst Id >> Len <= 6)) ([2..7],True)
False (Not ((>>) True | {6 <= 6}))
FalseT

>>> pl @(Fst Id >> Len <= 6) ([2..7],True)
True ((>>) True | {6 <= 6})
TrueT

>>> pl @(Length (Fst Id) <= 6) ([2..7],True)
True (6 <= 6)
TrueT

>>> pl @(Fst Id >> (Len <= 6)) ([2..7],True)
True ((>>) True | {6 <= 6})
TrueT

Instances

P (Cmp CLe p q) x => P (p <= q :: Type) x

Defined in Predicate.Data.Ordering

Associated Types

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

Methods

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

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

Defined in Predicate.Data.Ordering

type PP (p <= q :: Type) x = Bool

data p < q infix 4

compare if expression 'p' is less than 'q'

Instances

P (Cmp CLt p q) x => P (p < q :: Type) x

Defined in Predicate.Data.Ordering

Associated Types

type PP (p < q) x :: Type

Methods

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

type PP (p < q :: Type) x

Defined in Predicate.Data.Ordering

type PP (p < q :: Type) x = Bool

data p >~ q infix 4

case-insensitive compare if string expression 'p' is greater than 'q'

Instances

P (CmpI CGt p q) x => P (p >~ q :: Type) x

Defined in Predicate.Data.Ordering

Associated Types

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

Methods

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

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

Defined in Predicate.Data.Ordering

type PP (p >~ q :: Type) x = Bool

data p >=~ q infix 4

case-insensitive compare if string expression 'p' is greater than or equal to 'q'

Instances

P (CmpI CGe p q) x => P (p >=~ q :: Type) x

Defined in Predicate.Data.Ordering

Associated Types

type PP (p >=~ q) x :: Type

Methods

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

type PP (p >=~ q :: Type) x

Defined in Predicate.Data.Ordering

type PP (p >=~ q :: Type) x = Bool

data p ==~ q infix 4

case-insensitive compare if string expression 'p' is equal to 'q'

Instances

P (CmpI CEq p q) x => P (p ==~ q :: Type) x

Defined in Predicate.Data.Ordering

Associated Types

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

Methods

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

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

Defined in Predicate.Data.Ordering

type PP (p ==~ q :: Type) x = Bool

data p /=~ q infix 4

case-insensitive compare if string expression 'p' is not equal to 'q'

Instances

P (CmpI CNe p q) x => P (p /=~ q :: Type) x

Defined in Predicate.Data.Ordering

Associated Types

type PP (p /=~ q) x :: Type

Methods

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

type PP (p /=~ q :: Type) x

Defined in Predicate.Data.Ordering

type PP (p /=~ q :: Type) x = Bool

data p <=~ q infix 4

case-insensitive compare if string expression 'p' is less than or equal to 'q'

Instances

P (CmpI CLe p q) x => P (p <=~ q :: Type) x

Defined in Predicate.Data.Ordering

Associated Types

type PP (p <=~ q) x :: Type

Methods

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

type PP (p <=~ q :: Type) x

Defined in Predicate.Data.Ordering

type PP (p <=~ q :: Type) x = Bool

data p <~ q infix 4

case-insensitive compare if string expression 'p' is less than 'q'

Instances

P (CmpI CLt p q) x => P (p <~ q :: Type) x

Defined in Predicate.Data.Ordering

Associated Types

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

Methods

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

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

Defined in Predicate.Data.Ordering

type PP (p <~ q :: Type) x = Bool

type Gt n = I > n

compare if expression 'p' is greater than 'q'

>>> pl @(Gt 4) 5
True (5 > 4)
TrueT

type Ge n = I >= n

type Same n = I == n

type Le n = I <= n

type Lt n = I < n

type Ne n = I /= n

data p ==! q infix 4

similar to compare

>>> pz @(Fst Id ==! Snd Id) (10,9)
PresentT GT

>>> pz @(14 % 3 ==! Fst Id -% Snd Id) (-10,7)
PresentT GT

>>> pz @(Fst Id ==! Snd Id) (10,11)
PresentT LT

>>> pz @(Snd Id ==! (Fst Id >> Snd Id >> Head Id)) (('x',[10,12,13]),10)
PresentT EQ

>>> pz @(Snd Id ==! Head (Snd (Fst Id))) (('x',[10,12,13]),10)
PresentT EQ

>>> pl @("aa" ==! Id) "aaaa"
Present LT ((==!) "aa" < "aaaa")
PresentT LT

>>> pl @(Pairs >> Map (First (Succ Id >> Succ Id) >> Fst Id ==! Snd Id) Id) [1,2,3,6,8]
Present [GT,GT,LT,EQ] ((>>) [GT,GT,LT,EQ] | {Map [GT,GT,LT,EQ] | [(1,2),(2,3),(3,6),(6,8)]})
PresentT [GT,GT,LT,EQ]

>>> pl @((Ones Id << ShowP Id) >> Map (Fst Id ==! Snd Id) Pairs) 1234223
Present [LT,LT,LT,GT,EQ,LT] ((>>) [LT,LT,LT,GT,EQ,LT] | {Map [LT,LT,LT,GT,EQ,LT] | [("1","2"),("2","3"),("3","4"),("4","2"),("2","2"),("2","3")]})
PresentT [LT,LT,LT,GT,EQ,LT]

>>> pl @("Abc" ==! Id) "abc"
Present LT ((==!) "Abc" < "abc")
PresentT LT

>>> pl @(Fst Id ==! Snd Id) (3,12)
Present LT ((==!) 3 < 12)
PresentT LT

>>> pl @(Fst Id ==! Snd Id) ("aBc","AbC")
Present GT ((==!) "aBc" > "AbC")
PresentT GT

>>> pl @(Snd Id ==! Fst Id) ("aBc","AbC")
Present LT ((==!) "AbC" < "aBc")
PresentT LT

Instances

(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

Defined in Predicate.Data.Ordering

Associated Types

type PP (p ==! q) a :: Type

Methods

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

type PP (p ==! q :: Type) a

Defined in Predicate.Data.Ordering

type PP (p ==! q :: Type) a = Ordering

type OrdP p q = p ==! q

data OrdA' p q

Instances

P (OrdAT' p q) x => P (OrdA' p q :: Type) x

Defined in Predicate.Data.Ordering

Associated Types

type PP (OrdA' p q) x :: Type

Methods

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

type PP (OrdA' p q :: Type) x

Defined in Predicate.Data.Ordering

type PP (OrdA' p q :: Type) x

data OrdA p

similar to compare but using a tuple as input

Instances

P (OrdA' p p) x => P (OrdA p :: Type) x

Defined in Predicate.Data.Ordering

Associated Types

type PP (OrdA p) x :: Type

Methods

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

type PP (OrdA p :: Type) x

Defined in Predicate.Data.Ordering

type PP (OrdA p :: Type) x = PP (OrdA' p p) x

type OrdI p q = p ===~ q

compare two strings ignoring case and return an ordering

>>> pz @(Fst Id ===~ Snd Id) ("abC","aBc")
PresentT EQ

>>> pz @(Fst Id ===~ Snd Id) ("abC","DaBc")
PresentT LT

>>> pl @(Fst Id ===~ Snd Id &&& Fst Id ==! Snd Id) ("abc","abc")
Present (EQ,EQ) (W '(EQ,EQ))
PresentT (EQ,EQ)

>>> pl @(Fst Id ===~ Snd Id) ("aBc","AbC")
Present EQ ((===~) aBc = AbC)
PresentT EQ

>>> pl @("Abc" ===~ Id) "abc"
Present EQ ((===~) Abc = abc)
PresentT EQ

>>> pl @("Abc" ==~ Id) "abc"
True (Abc ==~ abc)
TrueT

>>> pl @(Fst Id ==~ Snd Id) ("aBc","AbC")
True (aBc ==~ AbC)
TrueT

>>> pl @(Fst Id ==~ Snd Id && Fst Id == Snd Id) ("Abc","Abc")
True (True && True)
TrueT

data p ===~ q infix 4

Instances

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

Defined in Predicate.Data.Ordering

Associated Types

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

Methods

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

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

Defined in Predicate.Data.Ordering

type PP (p ===~ q :: Type) a = Ordering

data Cmp (o :: OrderingP) p q

compare two values using the given ordering 'o'

>>> pl @(Lt 4) 123
False (123 < 4)
FalseT

>>> pl @(Lt 4) 1
True (1 < 4)
TrueT

>>> pl @(Negate 7 <..> 20) (-4)
True (-7 <= -4 <= 20)
TrueT

>>> pl @(Negate 7 <..> 20) 21
False (21 <= 20)
FalseT

Instances

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

Defined in Predicate.Data.Ordering

Associated Types

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

Methods

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

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

Defined in Predicate.Data.Ordering

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

data CmpI (o :: OrderingP) p q

compare two strings ignoring case using the given ordering 'o'

Instances

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

Defined in Predicate.Data.Ordering

Associated Types

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

Methods

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

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

Defined in Predicate.Data.Ordering

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

data Asc

a type level predicate for a monotonic increasing list

>>> pl @Asc "aaacdef"
True (All(6))
TrueT

>>> pz @Asc [1,2,3,4,5,5,7]
TrueT

>>> pz @Asc "axacdef"
FalseT

Instances

P AscT x => P Asc x

Defined in Predicate.Data.Ordering

Associated Types

type PP Asc x :: Type

Methods

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

type PP Asc x

Defined in Predicate.Data.Ordering

type PP Asc x

data Asc'

a type level predicate for a strictly increasing list

>>> pz @Asc' [1,2,3,4,5,5,7]
FalseT

Instances

P AscT' x => P Asc' x

Defined in Predicate.Data.Ordering

Associated Types

type PP Asc' x :: Type

Methods

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

type PP Asc' x

Defined in Predicate.Data.Ordering

type PP Asc' x

data Desc

a type level predicate for a monotonic decreasing list

Instances

P DescT x => P Desc x

Defined in Predicate.Data.Ordering

Associated Types

type PP Desc x :: Type

Methods

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

type PP Desc x

Defined in Predicate.Data.Ordering

type PP Desc x

data Desc'

a type level predicate for a strictly decreasing list

Instances

P DescT' x => P Desc' x

Defined in Predicate.Data.Ordering

Associated Types

type PP Desc' x :: Type

Methods

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

type PP Desc' x

Defined in Predicate.Data.Ordering

type PP Desc' x

data AllPositive

a type level predicate for all positive elements in a list

>>> pz @AllPositive [1,5,10,2,3]
TrueT

>>> pz @AllPositive [0,1,5,10,2,3]
FalseT

>>> pz @AllPositive [3,1,-5,10,2,3]
FalseT

Instances

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))

type PP AllPositive x

Defined in Predicate.Data.Ordering

type PP AllPositive x

type Positive = Gt 0

data AllNegative

a type level predicate for all negative elements in a list

>>> pz @AllNegative [-1,-5,-10,-2,-3]
TrueT

Instances

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))

type PP AllNegative x

Defined in Predicate.Data.Ordering

type PP AllNegative x

type Negative = Lt 0

data Ands p

similar to and

>>> pz @(Ands Id) [True,True,True]
TrueT

>>> pl @(Ands Id) [True,True,True,False]
False (Ands(4) i=3 | [True,True,True,False])
FalseT

>>> pz @(Ands Id) []
TrueT

Instances

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

Defined in Predicate.Data.Ordering

Associated Types

type PP (Ands p) x :: Type

Methods

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

type PP (Ands p :: Type) x

Defined in Predicate.Data.Ordering

type PP (Ands p :: Type) x = Bool

data Ors p

similar to or

>>> pz @(Ors Id) [False,False,False]
FalseT

>>> pl @(Ors Id) [True,True,True,False]
True (Ors(4) i=0 | [True,True,True,False])
TrueT

>>> pl @(Ors Id) []
False (Ors(0) | [])
FalseT

Instances

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

Defined in Predicate.Data.Ordering

Associated Types

type PP (Ors p) x :: Type

Methods

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

type PP (Ors p :: Type) x

Defined in Predicate.Data.Ordering

type PP (Ors p :: Type) x = Bool