{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE UndecidableInstances #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE PolyKinds #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE ConstraintKinds #-}
{-# LANGUAGE NoStarIsType #-}
{-# LANGUAGE EmptyDataDeriving #-}
-- | promoted 'Ordering' functions

module Predicate.Data.Ordering (
  -- ** comparison

    type (>)
  , type (>=)
  , type (==)
  , type (/=)
  , type (<=)
  , type (<)
  , Gt
  , Ge
  , Same
  , Le
  , Lt
  , Ne
  , type (==!)
  , Comparing
  , Compare

  -- ** case insensitive comparison

  , type (>~)
  , type (>=~)
  , type (==~)
  , type (/=~)
  , type (<=~)
  , type (<~)
  , type (===~)

  -- ** lists

  , Asc
  , Asc'
  , Desc
  , Desc'

 -- ** numeric

  , AllPositive
  , AllNegative
  , Positive
  , Negative
 ) where
import Predicate.Core
import Predicate.Misc
import Predicate.Util
import Predicate.Data.Tuple (Pairs)
import Data.Proxy (Proxy(Proxy))
import Data.Char (toLower)
import Data.Function (on)

-- $setup

-- >>> :set -XDataKinds

-- >>> :set -XTypeApplications

-- >>> :set -XTypeOperators

-- >>> :set -XOverloadedStrings

-- >>> :set -XNoOverloadedLists

-- >>> import Predicate.Prelude


-- | compare if expression @p@ is greater than @q@

--

-- >>> pl @(Gt 4) 5

-- True (5 > 4)

-- Val True

--

data Gt n deriving Int -> Gt n -> ShowS
[Gt n] -> ShowS
Gt n -> String
(Int -> Gt n -> ShowS)
-> (Gt n -> String) -> ([Gt n] -> ShowS) -> Show (Gt n)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall k (n :: k). Int -> Gt n -> ShowS
forall k (n :: k). [Gt n] -> ShowS
forall k (n :: k). Gt n -> String
showList :: [Gt n] -> ShowS
$cshowList :: forall k (n :: k). [Gt n] -> ShowS
show :: Gt n -> String
$cshow :: forall k (n :: k). Gt n -> String
showsPrec :: Int -> Gt n -> ShowS
$cshowsPrec :: forall k (n :: k). Int -> Gt n -> ShowS
Show
type GtT n = Id > n

instance P (GtT n) x => P (Gt n) x where
  type PP (Gt n) x = PP (GtT n) x
  eval :: proxy (Gt n) -> POpts -> x -> m (TT (PP (Gt n) x))
eval proxy (Gt n)
_ = Proxy (GtT n) -> POpts -> x -> m (TT (PP (GtT n) x))
forall k (p :: k) a (m :: Type -> Type) (proxy :: k -> Type).
(P p a, MonadEval m) =>
proxy p -> POpts -> a -> m (TT (PP p a))
eval (Proxy (GtT n)
forall k (t :: k). Proxy t
Proxy @(GtT n))

-- | compare if expression @p@ is greater than or equal to @q@

data Ge n deriving Int -> Ge n -> ShowS
[Ge n] -> ShowS
Ge n -> String
(Int -> Ge n -> ShowS)
-> (Ge n -> String) -> ([Ge n] -> ShowS) -> Show (Ge n)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall k (n :: k). Int -> Ge n -> ShowS
forall k (n :: k). [Ge n] -> ShowS
forall k (n :: k). Ge n -> String
showList :: [Ge n] -> ShowS
$cshowList :: forall k (n :: k). [Ge n] -> ShowS
show :: Ge n -> String
$cshow :: forall k (n :: k). Ge n -> String
showsPrec :: Int -> Ge n -> ShowS
$cshowsPrec :: forall k (n :: k). Int -> Ge n -> ShowS
Show
type GeT n = Id >= n

instance P (GeT n) x => P (Ge n) x where
  type PP (Ge n) x = PP (GeT n) x
  eval :: proxy (Ge n) -> POpts -> x -> m (TT (PP (Ge n) x))
eval proxy (Ge n)
_ = Proxy (GeT n) -> POpts -> x -> m (TT (PP (GeT n) x))
forall k (p :: k) a (m :: Type -> Type) (proxy :: k -> Type).
(P p a, MonadEval m) =>
proxy p -> POpts -> a -> m (TT (PP p a))
eval (Proxy (GeT n)
forall k (t :: k). Proxy t
Proxy @(GeT n))

-- | compare if expression @p@ is equal to @q@

data Same n deriving Int -> Same n -> ShowS
[Same n] -> ShowS
Same n -> String
(Int -> Same n -> ShowS)
-> (Same n -> String) -> ([Same n] -> ShowS) -> Show (Same n)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall k (n :: k). Int -> Same n -> ShowS
forall k (n :: k). [Same n] -> ShowS
forall k (n :: k). Same n -> String
showList :: [Same n] -> ShowS
$cshowList :: forall k (n :: k). [Same n] -> ShowS
show :: Same n -> String
$cshow :: forall k (n :: k). Same n -> String
showsPrec :: Int -> Same n -> ShowS
$cshowsPrec :: forall k (n :: k). Int -> Same n -> ShowS
Show
type SameT n = Id == n

instance P (SameT n) x => P (Same n) x where
  type PP (Same n) x = PP (SameT n) x
  eval :: proxy (Same n) -> POpts -> x -> m (TT (PP (Same n) x))
eval proxy (Same n)
_ = Proxy (SameT n) -> POpts -> x -> m (TT (PP (SameT n) x))
forall k (p :: k) a (m :: Type -> Type) (proxy :: k -> Type).
(P p a, MonadEval m) =>
proxy p -> POpts -> a -> m (TT (PP p a))
eval (Proxy (SameT n)
forall k (t :: k). Proxy t
Proxy @(SameT n))

-- | compare if expression @p@ is less than or equal to @q@

data Le n deriving Int -> Le n -> ShowS
[Le n] -> ShowS
Le n -> String
(Int -> Le n -> ShowS)
-> (Le n -> String) -> ([Le n] -> ShowS) -> Show (Le n)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall k (n :: k). Int -> Le n -> ShowS
forall k (n :: k). [Le n] -> ShowS
forall k (n :: k). Le n -> String
showList :: [Le n] -> ShowS
$cshowList :: forall k (n :: k). [Le n] -> ShowS
show :: Le n -> String
$cshow :: forall k (n :: k). Le n -> String
showsPrec :: Int -> Le n -> ShowS
$cshowsPrec :: forall k (n :: k). Int -> Le n -> ShowS
Show
type LeT n = Id <= n

instance P (LeT n) x => P (Le n) x where
  type PP (Le n) x = PP (LeT n) x
  eval :: proxy (Le n) -> POpts -> x -> m (TT (PP (Le n) x))
eval proxy (Le n)
_ = Proxy (LeT n) -> POpts -> x -> m (TT (PP (LeT n) x))
forall k (p :: k) a (m :: Type -> Type) (proxy :: k -> Type).
(P p a, MonadEval m) =>
proxy p -> POpts -> a -> m (TT (PP p a))
eval (Proxy (LeT n)
forall k (t :: k). Proxy t
Proxy @(LeT n))

-- | compare if expression @p@ is less than to @q@

--

-- >>> pl @(Lt 4) 123

-- False (123 < 4)

-- Val False

--

-- >>> pl @(Lt 4) 1

-- True (1 < 4)

-- Val True

--

data Lt n deriving Int -> Lt n -> ShowS
[Lt n] -> ShowS
Lt n -> String
(Int -> Lt n -> ShowS)
-> (Lt n -> String) -> ([Lt n] -> ShowS) -> Show (Lt n)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall k (n :: k). Int -> Lt n -> ShowS
forall k (n :: k). [Lt n] -> ShowS
forall k (n :: k). Lt n -> String
showList :: [Lt n] -> ShowS
$cshowList :: forall k (n :: k). [Lt n] -> ShowS
show :: Lt n -> String
$cshow :: forall k (n :: k). Lt n -> String
showsPrec :: Int -> Lt n -> ShowS
$cshowsPrec :: forall k (n :: k). Int -> Lt n -> ShowS
Show
type LtT n = Id < n

instance P (LtT n) x => P (Lt n) x where
  type PP (Lt n) x = PP (LtT n) x
  eval :: proxy (Lt n) -> POpts -> x -> m (TT (PP (Lt n) x))
eval proxy (Lt n)
_ = Proxy (LtT n) -> POpts -> x -> m (TT (PP (LtT n) x))
forall k (p :: k) a (m :: Type -> Type) (proxy :: k -> Type).
(P p a, MonadEval m) =>
proxy p -> POpts -> a -> m (TT (PP p a))
eval (Proxy (LtT n)
forall k (t :: k). Proxy t
Proxy @(LtT n))

-- | compare if expression @p@ is not equal to @q@

data Ne n deriving Int -> Ne n -> ShowS
[Ne n] -> ShowS
Ne n -> String
(Int -> Ne n -> ShowS)
-> (Ne n -> String) -> ([Ne n] -> ShowS) -> Show (Ne n)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall k (n :: k). Int -> Ne n -> ShowS
forall k (n :: k). [Ne n] -> ShowS
forall k (n :: k). Ne n -> String
showList :: [Ne n] -> ShowS
$cshowList :: forall k (n :: k). [Ne n] -> ShowS
show :: Ne n -> String
$cshow :: forall k (n :: k). Ne n -> String
showsPrec :: Int -> Ne n -> ShowS
$cshowsPrec :: forall k (n :: k). Int -> Ne n -> ShowS
Show
type NeT n = Id /= n

instance P (NeT n) x => P (Ne n) x where
  type PP (Ne n) x = PP (NeT n) x
  eval :: proxy (Ne n) -> POpts -> x -> m (TT (PP (Ne n) x))
eval proxy (Ne n)
_ = Proxy (NeT n) -> POpts -> x -> m (TT (PP (NeT n) x))
forall k (p :: k) a (m :: Type -> Type) (proxy :: k -> Type).
(P p a, MonadEval m) =>
proxy p -> POpts -> a -> m (TT (PP p a))
eval (Proxy (NeT n)
forall k (t :: k). Proxy t
Proxy @(NeT n))

-- | compare if expression @p@ is greater than @q@

--

-- >>> pl @(Id > "xx") "abc"

-- False ("abc" > "xx")

-- Val False

--

-- >>> pl @(Id > "aa") "abc"

-- True ("abc" > "aa")

-- Val True

--

-- >>> pl @(Fst > Snd) (True,False)

-- True (True > False)

-- Val True

--

data p > q deriving Int -> (p > q) -> ShowS
[p > q] -> ShowS
(p > q) -> String
(Int -> (p > q) -> ShowS)
-> ((p > q) -> String) -> ([p > q] -> ShowS) -> Show (p > q)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall k (p :: k) k (q :: k). Int -> (p > q) -> ShowS
forall k (p :: k) k (q :: k). [p > q] -> ShowS
forall k (p :: k) k (q :: k). (p > q) -> String
showList :: [p > q] -> ShowS
$cshowList :: forall k (p :: k) k (q :: k). [p > q] -> ShowS
show :: (p > q) -> String
$cshow :: forall k (p :: k) k (q :: k). (p > q) -> String
showsPrec :: Int -> (p > q) -> ShowS
$cshowsPrec :: forall k (p :: k) k (q :: k). Int -> (p > q) -> ShowS
Show
infix 4 >

instance P (Cmp 'CGt p q) x => P (p > q) x where
  type PP (p > q) x = Bool
  eval :: proxy (p > q) -> POpts -> x -> m (TT (PP (p > q) x))
eval proxy (p > q)
_ = Proxy (Cmp 'CGt p q) -> POpts -> x -> m (TT (PP (Cmp 'CGt p q) x))
forall k (m :: Type -> Type) (p :: k) a (proxy :: k -> Type).
(MonadEval m, P p a, PP p a ~ Bool) =>
proxy p -> POpts -> a -> m (TT (PP p a))
evalBool (Proxy (Cmp 'CGt p q)
forall k (t :: k). Proxy t
Proxy @(Cmp 'CGt p q))

-- | compare if expression @p@ is greater than or equal to @q@

data p >= q deriving Int -> (p >= q) -> ShowS
[p >= q] -> ShowS
(p >= q) -> String
(Int -> (p >= q) -> ShowS)
-> ((p >= q) -> String) -> ([p >= q] -> ShowS) -> Show (p >= q)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall k (p :: k) k (q :: k). Int -> (p >= q) -> ShowS
forall k (p :: k) k (q :: k). [p >= q] -> ShowS
forall k (p :: k) k (q :: k). (p >= q) -> String
showList :: [p >= q] -> ShowS
$cshowList :: forall k (p :: k) k (q :: k). [p >= q] -> ShowS
show :: (p >= q) -> String
$cshow :: forall k (p :: k) k (q :: k). (p >= q) -> String
showsPrec :: Int -> (p >= q) -> ShowS
$cshowsPrec :: forall k (p :: k) k (q :: k). Int -> (p >= q) -> ShowS
Show
infix 4 >=

instance P (Cmp 'CGe p q) x => P (p >= q) x where
  type PP (p >= q) x = Bool
  eval :: proxy (p >= q) -> POpts -> x -> m (TT (PP (p >= q) x))
eval proxy (p >= q)
_ = Proxy (Cmp 'CGe p q) -> POpts -> x -> m (TT (PP (Cmp 'CGe p q) x))
forall k (m :: Type -> Type) (p :: k) a (proxy :: k -> Type).
(MonadEval m, P p a, PP p a ~ Bool) =>
proxy p -> POpts -> a -> m (TT (PP p a))
evalBool (Proxy (Cmp 'CGe p q)
forall k (t :: k). Proxy t
Proxy @(Cmp 'CGe p q))

-- | compare if expression @p@ is equal to @q@

--

-- >>> pl @(Fst == Snd) ("ab","xyzabw")

-- False ("ab" == "xyzabw")

-- Val False

--

-- >>> pl @(Fst == Snd) ("aBc","AbC")

-- False ("aBc" == "AbC")

-- Val False

--

-- >>> pz @(Fst == Snd) ("aBc","aBc")

-- Val True

--

-- >>> pl @(Id == "Abc") "abc"

-- False ("abc" == "Abc")

-- Val False

--

-- >>> pl @(Fst == Snd) (True,False)

-- False (True == False)

-- Val False

--

-- >>> pl @(Not Id *** Id >> Fst == Snd) (True,False)

-- True ((>>) True | {False == False})

-- Val True

--

data p == q deriving Int -> (p == q) -> ShowS
[p == q] -> ShowS
(p == q) -> String
(Int -> (p == q) -> ShowS)
-> ((p == q) -> String) -> ([p == q] -> ShowS) -> Show (p == q)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall k (p :: k) k (q :: k). Int -> (p == q) -> ShowS
forall k (p :: k) k (q :: k). [p == q] -> ShowS
forall k (p :: k) k (q :: k). (p == q) -> String
showList :: [p == q] -> ShowS
$cshowList :: forall k (p :: k) k (q :: k). [p == q] -> ShowS
show :: (p == q) -> String
$cshow :: forall k (p :: k) k (q :: k). (p == q) -> String
showsPrec :: Int -> (p == q) -> ShowS
$cshowsPrec :: forall k (p :: k) k (q :: k). Int -> (p == q) -> ShowS
Show
infix 4 ==

instance P (Cmp 'CEq p q) x => P (p == q) x where
  type PP (p == q) x = Bool
  eval :: proxy (p == q) -> POpts -> x -> m (TT (PP (p == q) x))
eval proxy (p == q)
_ = Proxy (Cmp 'CEq p q) -> POpts -> x -> m (TT (PP (Cmp 'CEq p q) x))
forall k (m :: Type -> Type) (p :: k) a (proxy :: k -> Type).
(MonadEval m, P p a, PP p a ~ Bool) =>
proxy p -> POpts -> a -> m (TT (PP p a))
evalBool (Proxy (Cmp 'CEq p q)
forall k (t :: k). Proxy t
Proxy @(Cmp 'CEq p q))

-- | compare if expression @p@ is less than or equal to @q@

--

-- >>> pl @(Not (Fst >> Len <= 6)) ([2..7],True)

-- False (Not ((>>) True | {6 <= 6}))

-- Val False

--

-- >>> pl @(Fst >> Len <= 6) ([2..7],True)

-- True ((>>) True | {6 <= 6})

-- Val True

--

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

-- True (6 <= 6)

-- Val True

--

-- >>> pl @(Fst >> (Len <= 6)) ([2..7],True)

-- True ((>>) True | {6 <= 6})

-- Val True

--

data p <= q deriving Int -> (p <= q) -> ShowS
[p <= q] -> ShowS
(p <= q) -> String
(Int -> (p <= q) -> ShowS)
-> ((p <= q) -> String) -> ([p <= q] -> ShowS) -> Show (p <= q)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall k (p :: k) k (q :: k). Int -> (p <= q) -> ShowS
forall k (p :: k) k (q :: k). [p <= q] -> ShowS
forall k (p :: k) k (q :: k). (p <= q) -> String
showList :: [p <= q] -> ShowS
$cshowList :: forall k (p :: k) k (q :: k). [p <= q] -> ShowS
show :: (p <= q) -> String
$cshow :: forall k (p :: k) k (q :: k). (p <= q) -> String
showsPrec :: Int -> (p <= q) -> ShowS
$cshowsPrec :: forall k (p :: k) k (q :: k). Int -> (p <= q) -> ShowS
Show
infix 4 <=

instance P (Cmp 'CLe p q) x => P (p <= q) x where
  type PP (p <= q) x = Bool
  eval :: proxy (p <= q) -> POpts -> x -> m (TT (PP (p <= q) x))
eval proxy (p <= q)
_ = Proxy (Cmp 'CLe p q) -> POpts -> x -> m (TT (PP (Cmp 'CLe p q) x))
forall k (m :: Type -> Type) (p :: k) a (proxy :: k -> Type).
(MonadEval m, P p a, PP p a ~ Bool) =>
proxy p -> POpts -> a -> m (TT (PP p a))
evalBool (Proxy (Cmp 'CLe p q)
forall k (t :: k). Proxy t
Proxy @(Cmp 'CLe p q))

-- | compare if expression @p@ is less than @q@

data p < q deriving Int -> (p < q) -> ShowS
[p < q] -> ShowS
(p < q) -> String
(Int -> (p < q) -> ShowS)
-> ((p < q) -> String) -> ([p < q] -> ShowS) -> Show (p < q)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall k (p :: k) k (q :: k). Int -> (p < q) -> ShowS
forall k (p :: k) k (q :: k). [p < q] -> ShowS
forall k (p :: k) k (q :: k). (p < q) -> String
showList :: [p < q] -> ShowS
$cshowList :: forall k (p :: k) k (q :: k). [p < q] -> ShowS
show :: (p < q) -> String
$cshow :: forall k (p :: k) k (q :: k). (p < q) -> String
showsPrec :: Int -> (p < q) -> ShowS
$cshowsPrec :: forall k (p :: k) k (q :: k). Int -> (p < q) -> ShowS
Show
infix 4 <

instance P (Cmp 'CLt p q) x => P (p < q) x where
  type PP (p < q) x = Bool
  eval :: proxy (p < q) -> POpts -> x -> m (TT (PP (p < q) x))
eval proxy (p < q)
_ = Proxy (Cmp 'CLt p q) -> POpts -> x -> m (TT (PP (Cmp 'CLt p q) x))
forall k (m :: Type -> Type) (p :: k) a (proxy :: k -> Type).
(MonadEval m, P p a, PP p a ~ Bool) =>
proxy p -> POpts -> a -> m (TT (PP p a))
evalBool (Proxy (Cmp 'CLt p q)
forall k (t :: k). Proxy t
Proxy @(Cmp 'CLt p q))

-- | compare if expression @p@ is not equal to @q@

--

-- >>> pl @(Fst /= Snd) ("ab","xyzabw")

-- True ("ab" /= "xyzabw")

-- Val True

--

data p /= q deriving Int -> (p /= q) -> ShowS
[p /= q] -> ShowS
(p /= q) -> String
(Int -> (p /= q) -> ShowS)
-> ((p /= q) -> String) -> ([p /= q] -> ShowS) -> Show (p /= q)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall k (p :: k) k (q :: k). Int -> (p /= q) -> ShowS
forall k (p :: k) k (q :: k). [p /= q] -> ShowS
forall k (p :: k) k (q :: k). (p /= q) -> String
showList :: [p /= q] -> ShowS
$cshowList :: forall k (p :: k) k (q :: k). [p /= q] -> ShowS
show :: (p /= q) -> String
$cshow :: forall k (p :: k) k (q :: k). (p /= q) -> String
showsPrec :: Int -> (p /= q) -> ShowS
$cshowsPrec :: forall k (p :: k) k (q :: k). Int -> (p /= q) -> ShowS
Show
infix 4 /=

instance P (Cmp 'CNe p q) x => P (p /= q) x where
  type PP (p /= q) x = Bool
  eval :: proxy (p /= q) -> POpts -> x -> m (TT (PP (p /= q) x))
eval proxy (p /= q)
_ = Proxy (Cmp 'CNe p q) -> POpts -> x -> m (TT (PP (Cmp 'CNe p q) x))
forall k (m :: Type -> Type) (p :: k) a (proxy :: k -> Type).
(MonadEval m, P p a, PP p a ~ Bool) =>
proxy p -> POpts -> a -> m (TT (PP p a))
evalBool (Proxy (Cmp 'CNe p q)
forall k (t :: k). Proxy t
Proxy @(Cmp 'CNe p q))

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

--

data p >~ q deriving Int -> (p >~ q) -> ShowS
[p >~ q] -> ShowS
(p >~ q) -> String
(Int -> (p >~ q) -> ShowS)
-> ((p >~ q) -> String) -> ([p >~ q] -> ShowS) -> Show (p >~ q)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall k (p :: k) k (q :: k). Int -> (p >~ q) -> ShowS
forall k (p :: k) k (q :: k). [p >~ q] -> ShowS
forall k (p :: k) k (q :: k). (p >~ q) -> String
showList :: [p >~ q] -> ShowS
$cshowList :: forall k (p :: k) k (q :: k). [p >~ q] -> ShowS
show :: (p >~ q) -> String
$cshow :: forall k (p :: k) k (q :: k). (p >~ q) -> String
showsPrec :: Int -> (p >~ q) -> ShowS
$cshowsPrec :: forall k (p :: k) k (q :: k). Int -> (p >~ q) -> ShowS
Show
infix 4 >~

instance P (CmpI 'CGt p q) x => P (p >~ q) x where
  type PP (p >~ q) x = Bool
  eval :: proxy (p >~ q) -> POpts -> x -> m (TT (PP (p >~ q) x))
eval proxy (p >~ q)
_ = Proxy (CmpI 'CGt p q)
-> POpts -> x -> m (TT (PP (CmpI 'CGt p q) x))
forall k (m :: Type -> Type) (p :: k) a (proxy :: k -> Type).
(MonadEval m, P p a, PP p a ~ Bool) =>
proxy p -> POpts -> a -> m (TT (PP p a))
evalBool (Proxy (CmpI 'CGt p q)
forall k (t :: k). Proxy t
Proxy @(CmpI 'CGt p q))

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

data p >=~ q deriving Int -> (p >=~ q) -> ShowS
[p >=~ q] -> ShowS
(p >=~ q) -> String
(Int -> (p >=~ q) -> ShowS)
-> ((p >=~ q) -> String) -> ([p >=~ q] -> ShowS) -> Show (p >=~ q)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall k (p :: k) k (q :: k). Int -> (p >=~ q) -> ShowS
forall k (p :: k) k (q :: k). [p >=~ q] -> ShowS
forall k (p :: k) k (q :: k). (p >=~ q) -> String
showList :: [p >=~ q] -> ShowS
$cshowList :: forall k (p :: k) k (q :: k). [p >=~ q] -> ShowS
show :: (p >=~ q) -> String
$cshow :: forall k (p :: k) k (q :: k). (p >=~ q) -> String
showsPrec :: Int -> (p >=~ q) -> ShowS
$cshowsPrec :: forall k (p :: k) k (q :: k). Int -> (p >=~ q) -> ShowS
Show
infix 4 >=~

instance P (CmpI 'CGe p q) x => P (p >=~ q) x where
  type PP (p >=~ q) x = Bool
  eval :: proxy (p >=~ q) -> POpts -> x -> m (TT (PP (p >=~ q) x))
eval proxy (p >=~ q)
_ = Proxy (CmpI 'CGe p q)
-> POpts -> x -> m (TT (PP (CmpI 'CGe p q) x))
forall k (m :: Type -> Type) (p :: k) a (proxy :: k -> Type).
(MonadEval m, P p a, PP p a ~ Bool) =>
proxy p -> POpts -> a -> m (TT (PP p a))
evalBool (Proxy (CmpI 'CGe p q)
forall k (t :: k). Proxy t
Proxy @(CmpI 'CGe p q))

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

--

-- >>> pl @("Abc" ==~ Id) "abc"

-- True (Abc ==~ abc)

-- Val True

--

-- >>> pl @(Fst ==~ Snd) ("aBc","AbC")

-- True (aBc ==~ AbC)

-- Val True

--

-- >>> pl @(Fst ==~ Snd && Fst == Snd) ("Abc","Abc")

-- True (True && True)

-- Val True

--

data p ==~ q deriving Int -> (p ==~ q) -> ShowS
[p ==~ q] -> ShowS
(p ==~ q) -> String
(Int -> (p ==~ q) -> ShowS)
-> ((p ==~ q) -> String) -> ([p ==~ q] -> ShowS) -> Show (p ==~ q)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall k (p :: k) k (q :: k). Int -> (p ==~ q) -> ShowS
forall k (p :: k) k (q :: k). [p ==~ q] -> ShowS
forall k (p :: k) k (q :: k). (p ==~ q) -> String
showList :: [p ==~ q] -> ShowS
$cshowList :: forall k (p :: k) k (q :: k). [p ==~ q] -> ShowS
show :: (p ==~ q) -> String
$cshow :: forall k (p :: k) k (q :: k). (p ==~ q) -> String
showsPrec :: Int -> (p ==~ q) -> ShowS
$cshowsPrec :: forall k (p :: k) k (q :: k). Int -> (p ==~ q) -> ShowS
Show
infix 4 ==~

instance P (CmpI 'CEq p q) x => P (p ==~ q) x where
  type PP (p ==~ q) x = Bool
  eval :: proxy (p ==~ q) -> POpts -> x -> m (TT (PP (p ==~ q) x))
eval proxy (p ==~ q)
_ = Proxy (CmpI 'CEq p q)
-> POpts -> x -> m (TT (PP (CmpI 'CEq p q) x))
forall k (m :: Type -> Type) (p :: k) a (proxy :: k -> Type).
(MonadEval m, P p a, PP p a ~ Bool) =>
proxy p -> POpts -> a -> m (TT (PP p a))
evalBool (Proxy (CmpI 'CEq p q)
forall k (t :: k). Proxy t
Proxy @(CmpI 'CEq p q))

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

data p <=~ q deriving Int -> (p <=~ q) -> ShowS
[p <=~ q] -> ShowS
(p <=~ q) -> String
(Int -> (p <=~ q) -> ShowS)
-> ((p <=~ q) -> String) -> ([p <=~ q] -> ShowS) -> Show (p <=~ q)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall k (p :: k) k (q :: k). Int -> (p <=~ q) -> ShowS
forall k (p :: k) k (q :: k). [p <=~ q] -> ShowS
forall k (p :: k) k (q :: k). (p <=~ q) -> String
showList :: [p <=~ q] -> ShowS
$cshowList :: forall k (p :: k) k (q :: k). [p <=~ q] -> ShowS
show :: (p <=~ q) -> String
$cshow :: forall k (p :: k) k (q :: k). (p <=~ q) -> String
showsPrec :: Int -> (p <=~ q) -> ShowS
$cshowsPrec :: forall k (p :: k) k (q :: k). Int -> (p <=~ q) -> ShowS
Show
infix 4 <=~

instance P (CmpI 'CLe p q) x => P (p <=~ q) x where
  type PP (p <=~ q) x = Bool
  eval :: proxy (p <=~ q) -> POpts -> x -> m (TT (PP (p <=~ q) x))
eval proxy (p <=~ q)
_ = Proxy (CmpI 'CLe p q)
-> POpts -> x -> m (TT (PP (CmpI 'CLe p q) x))
forall k (m :: Type -> Type) (p :: k) a (proxy :: k -> Type).
(MonadEval m, P p a, PP p a ~ Bool) =>
proxy p -> POpts -> a -> m (TT (PP p a))
evalBool (Proxy (CmpI 'CLe p q)
forall k (t :: k). Proxy t
Proxy @(CmpI 'CLe p q))

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

data p <~ q deriving Int -> (p <~ q) -> ShowS
[p <~ q] -> ShowS
(p <~ q) -> String
(Int -> (p <~ q) -> ShowS)
-> ((p <~ q) -> String) -> ([p <~ q] -> ShowS) -> Show (p <~ q)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall k (p :: k) k (q :: k). Int -> (p <~ q) -> ShowS
forall k (p :: k) k (q :: k). [p <~ q] -> ShowS
forall k (p :: k) k (q :: k). (p <~ q) -> String
showList :: [p <~ q] -> ShowS
$cshowList :: forall k (p :: k) k (q :: k). [p <~ q] -> ShowS
show :: (p <~ q) -> String
$cshow :: forall k (p :: k) k (q :: k). (p <~ q) -> String
showsPrec :: Int -> (p <~ q) -> ShowS
$cshowsPrec :: forall k (p :: k) k (q :: k). Int -> (p <~ q) -> ShowS
Show
infix 4 <~

instance P (CmpI 'CLt p q) x => P (p <~ q) x where
  type PP (p <~ q) x = Bool
  eval :: proxy (p <~ q) -> POpts -> x -> m (TT (PP (p <~ q) x))
eval proxy (p <~ q)
_ = Proxy (CmpI 'CLt p q)
-> POpts -> x -> m (TT (PP (CmpI 'CLt p q) x))
forall k (m :: Type -> Type) (p :: k) a (proxy :: k -> Type).
(MonadEval m, P p a, PP p a ~ Bool) =>
proxy p -> POpts -> a -> m (TT (PP p a))
evalBool (Proxy (CmpI 'CLt p q)
forall k (t :: k). Proxy t
Proxy @(CmpI 'CLt p q))

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

data p /=~ q deriving Int -> (p /=~ q) -> ShowS
[p /=~ q] -> ShowS
(p /=~ q) -> String
(Int -> (p /=~ q) -> ShowS)
-> ((p /=~ q) -> String) -> ([p /=~ q] -> ShowS) -> Show (p /=~ q)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall k (p :: k) k (q :: k). Int -> (p /=~ q) -> ShowS
forall k (p :: k) k (q :: k). [p /=~ q] -> ShowS
forall k (p :: k) k (q :: k). (p /=~ q) -> String
showList :: [p /=~ q] -> ShowS
$cshowList :: forall k (p :: k) k (q :: k). [p /=~ q] -> ShowS
show :: (p /=~ q) -> String
$cshow :: forall k (p :: k) k (q :: k). (p /=~ q) -> String
showsPrec :: Int -> (p /=~ q) -> ShowS
$cshowsPrec :: forall k (p :: k) k (q :: k). Int -> (p /=~ q) -> ShowS
Show
infix 4 /=~

instance P (CmpI 'CNe p q) x => P (p /=~ q) x where
  type PP (p /=~ q) x = Bool
  eval :: proxy (p /=~ q) -> POpts -> x -> m (TT (PP (p /=~ q) x))
eval proxy (p /=~ q)
_ = Proxy (CmpI 'CNe p q)
-> POpts -> x -> m (TT (PP (CmpI 'CNe p q) x))
forall k (m :: Type -> Type) (p :: k) a (proxy :: k -> Type).
(MonadEval m, P p a, PP p a ~ Bool) =>
proxy p -> POpts -> a -> m (TT (PP p a))
evalBool (Proxy (CmpI 'CNe p q)
forall k (t :: k). Proxy t
Proxy @(CmpI 'CNe p q))


-- | similar to 'compare'

--

-- >>> pz @(Fst ==! Snd) (10,9)

-- Val GT

--

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

-- Val GT

--

-- >>> pz @(Fst ==! Snd) (10,11)

-- Val LT

--

-- >>> pz @(Snd ==! (L12 >> Head)) (('x',[10,12,13]),10)

-- Val EQ

--

-- >>> pl @("aa" ==! Id) "aaaa"

-- Present LT ((==!) "aa" < "aaaa")

-- Val LT

--

-- >>> pl @(Pairs >> Map (First (Succ >> Succ) >> Fst ==! Snd)) [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)]})

-- Val [GT,GT,LT,EQ]

--

-- >>> pl @((Ones << ShowP Id) >> Map' (Fst ==! Snd) 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")]})

-- Val [LT,LT,LT,GT,EQ,LT]

--

-- >>> pl @("Abc" ==! Id) "abc"

-- Present LT ((==!) "Abc" < "abc")

-- Val LT

--

-- >>> pl @(Fst ==! Snd) (3,12)

-- Present LT ((==!) 3 < 12)

-- Val LT

--

-- >>> pl @(Fst ==! Snd) ("aBc","AbC")

-- Present GT ((==!) "aBc" > "AbC")

-- Val GT

--

-- >>> pl @(Snd ==! Fst) ("aBc","AbC")

-- Present LT ((==!) "AbC" < "aBc")

-- Val LT

--

data p ==! q deriving Int -> (p ==! q) -> ShowS
[p ==! q] -> ShowS
(p ==! q) -> String
(Int -> (p ==! q) -> ShowS)
-> ((p ==! q) -> String) -> ([p ==! q] -> ShowS) -> Show (p ==! q)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall k (p :: k) k (q :: k). Int -> (p ==! q) -> ShowS
forall k (p :: k) k (q :: k). [p ==! q] -> ShowS
forall k (p :: k) k (q :: k). (p ==! q) -> String
showList :: [p ==! q] -> ShowS
$cshowList :: forall k (p :: k) k (q :: k). [p ==! q] -> ShowS
show :: (p ==! q) -> String
$cshow :: forall k (p :: k) k (q :: k). (p ==! q) -> String
showsPrec :: Int -> (p ==! q) -> ShowS
$cshowsPrec :: forall k (p :: k) k (q :: k). Int -> (p ==! q) -> ShowS
Show
infix 4 ==!

instance ( Ord (PP p a)
         , PP p a ~ PP q a
         , P p a
         , Show (PP q a)
         , P q a
         ) => P (p ==! q) a where
  type PP (p ==! q) a = Ordering
  eval :: proxy (p ==! q) -> POpts -> a -> m (TT (PP (p ==! q) a))
eval proxy (p ==! q)
_ POpts
opts a
a = do
    let msg0 :: String
msg0 = String
"(==!)"
    Either (TT Ordering) (PP q a, PP q a, TT (PP q a), TT (PP q a))
lr <- Inline
-> String
-> Proxy p
-> Proxy q
-> POpts
-> a
-> [Tree PE]
-> m (Either
        (TT Ordering) (PP p a, PP q a, TT (PP p a), TT (PP q a)))
forall k1 k2 (p :: k1) a (q :: k2) (m :: Type -> Type)
       (proxy1 :: k1 -> Type) (proxy2 :: k2 -> Type) x.
(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)))
runPQ Inline
NoInline String
msg0 (Proxy p
forall k (t :: k). Proxy t
Proxy @p) (Proxy q
forall k (t :: k). Proxy t
Proxy @q) POpts
opts a
a []
    TT Ordering -> m (TT Ordering)
forall (f :: Type -> Type) a. Applicative f => a -> f a
pure (TT Ordering -> m (TT Ordering)) -> TT Ordering -> m (TT Ordering)
forall a b. (a -> b) -> a -> b
$ case Either (TT Ordering) (PP q a, PP q a, TT (PP q a), TT (PP q a))
lr of
      Left TT Ordering
e -> TT Ordering
e
      Right (PP q a
p,PP q a
q,TT (PP q a)
pp,TT (PP q a)
qq) ->
        let d :: Ordering
d = PP q a -> PP q a -> Ordering
forall a. Ord a => a -> a -> Ordering
compare PP q a
p PP q a
q
        in POpts -> Val Ordering -> String -> [Tree PE] -> TT Ordering
forall a. POpts -> Val a -> String -> [Tree PE] -> TT a
mkNode POpts
opts (Ordering -> Val Ordering
forall a. a -> Val a
Val Ordering
d) (String
msg0 String -> ShowS
forall a. Semigroup a => a -> a -> a
<> String
" " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> POpts -> PP q a -> String
forall a. Show a => POpts -> a -> String
showL POpts
opts PP q a
p String -> ShowS
forall a. Semigroup a => a -> a -> a
<> String
" " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> Ordering -> String
prettyOrd Ordering
d String -> ShowS
forall a. Semigroup a => a -> a -> a
<> String
" " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> POpts -> PP q a -> String
forall a. Show a => POpts -> a -> String
showL POpts
opts PP q a
q) [TT (PP q a) -> Tree PE
forall a. TT a -> Tree PE
hh TT (PP q a)
pp, TT (PP q a) -> Tree PE
forall a. TT a -> Tree PE
hh TT (PP q a)
qq]

-- | similar to 'compare' for a tuple

--

-- >>> pl @Compare ('b','A')

-- Present GT ((==!) 'b' > 'A')

-- Val GT

--

-- >>> pl @(Compare) (13,99)

-- Present LT ((==!) 13 < 99)

-- Val LT

--

data Compare deriving Int -> Compare -> ShowS
[Compare] -> ShowS
Compare -> String
(Int -> Compare -> ShowS)
-> (Compare -> String) -> ([Compare] -> ShowS) -> Show Compare
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Compare] -> ShowS
$cshowList :: [Compare] -> ShowS
show :: Compare -> String
$cshow :: Compare -> String
showsPrec :: Int -> Compare -> ShowS
$cshowsPrec :: Int -> Compare -> ShowS
Show

instance P (Comparing Id) x => P Compare x where
  type PP Compare x = PP (Comparing Id) x
  eval :: proxy Compare -> POpts -> x -> m (TT (PP Compare x))
eval proxy Compare
_ = Proxy (Comparing Id) -> POpts -> x -> m (TT (PP (Comparing Id) x))
forall k (p :: k) a (m :: Type -> Type) (proxy :: k -> Type).
(P p a, MonadEval m) =>
proxy p -> POpts -> a -> m (TT (PP p a))
eval (Proxy (Comparing Id)
forall k (t :: k). Proxy t
Proxy @(Comparing Id))

-- | similar to 'Data.Ord.comparing' for a tuple

--

-- >>> pz @(Comparing Len) ("abc","123456")

-- Val LT

--

data Comparing p deriving Int -> Comparing p -> ShowS
[Comparing p] -> ShowS
Comparing p -> String
(Int -> Comparing p -> ShowS)
-> (Comparing p -> String)
-> ([Comparing p] -> ShowS)
-> Show (Comparing p)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall k (p :: k). Int -> Comparing p -> ShowS
forall k (p :: k). [Comparing p] -> ShowS
forall k (p :: k). Comparing p -> String
showList :: [Comparing p] -> ShowS
$cshowList :: forall k (p :: k). [Comparing p] -> ShowS
show :: Comparing p -> String
$cshow :: forall k (p :: k). Comparing p -> String
showsPrec :: Int -> Comparing p -> ShowS
$cshowsPrec :: forall k (p :: k). Int -> Comparing p -> ShowS
Show
type ComparingT p = (Fst >> p) ==! (Snd >> p)

instance P (ComparingT p) x => P (Comparing p) x where
  type PP (Comparing p) x = PP (ComparingT p) x
  eval :: proxy (Comparing p) -> POpts -> x -> m (TT (PP (Comparing p) x))
eval proxy (Comparing p)
_ = Proxy (ComparingT p) -> POpts -> x -> m (TT (PP (ComparingT p) x))
forall k (p :: k) a (m :: Type -> Type) (proxy :: k -> Type).
(P p a, MonadEval m) =>
proxy p -> POpts -> a -> m (TT (PP p a))
eval (Proxy (ComparingT p)
forall k (t :: k). Proxy t
Proxy @(ComparingT p))

-- | compare two strings ignoring case and return an ordering

--

-- >>> pz @(Fst ===~ Snd) ("abC","aBc")

-- Val EQ

--

-- >>> pz @(Fst ===~ Snd) ("abC","DaBc")

-- Val LT

--

-- >>> pl @(Fst ===~ Snd &&& Fst ==! Snd) ("abc","abc")

-- Present (EQ,EQ) ('(EQ,EQ))

-- Val (EQ,EQ)

--

--

-- >>> pl @(Fst ===~ Snd) ("aBc","AbC")

-- Present EQ ((===~) aBc = AbC)

-- Val EQ

--

-- >>> pl @("Abc" ===~ Id) "abc"

-- Present EQ ((===~) Abc = abc)

-- Val EQ

--

data p ===~ q deriving Int -> (p ===~ q) -> ShowS
[p ===~ q] -> ShowS
(p ===~ q) -> String
(Int -> (p ===~ q) -> ShowS)
-> ((p ===~ q) -> String)
-> ([p ===~ q] -> ShowS)
-> Show (p ===~ q)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall k (p :: k) k (q :: k). Int -> (p ===~ q) -> ShowS
forall k (p :: k) k (q :: k). [p ===~ q] -> ShowS
forall k (p :: k) k (q :: k). (p ===~ q) -> String
showList :: [p ===~ q] -> ShowS
$cshowList :: forall k (p :: k) k (q :: k). [p ===~ q] -> ShowS
show :: (p ===~ q) -> String
$cshow :: forall k (p :: k) k (q :: k). (p ===~ q) -> String
showsPrec :: Int -> (p ===~ q) -> ShowS
$cshowsPrec :: forall k (p :: k) k (q :: k). Int -> (p ===~ q) -> ShowS
Show
infix 4 ===~

instance ( PP p a ~ String
         , PP p a ~ PP q a
         , P p a
         , P q a
         ) => P (p ===~ q) a where
  type PP (p ===~ q) a = Ordering
  eval :: proxy (p ===~ q) -> POpts -> a -> m (TT (PP (p ===~ q) a))
eval proxy (p ===~ q)
_ POpts
opts a
a = do
    let msg0 :: String
msg0 = String
"(===~)"
    Either (TT Ordering) (String, String, TT String, TT String)
lr <- Inline
-> String
-> Proxy p
-> Proxy q
-> POpts
-> a
-> [Tree PE]
-> m (Either
        (TT Ordering) (PP p a, PP q a, TT (PP p a), TT (PP q a)))
forall k1 k2 (p :: k1) a (q :: k2) (m :: Type -> Type)
       (proxy1 :: k1 -> Type) (proxy2 :: k2 -> Type) x.
(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)))
runPQ Inline
NoInline String
msg0 (Proxy p
forall k (t :: k). Proxy t
Proxy @p) (Proxy q
forall k (t :: k). Proxy t
Proxy @q) POpts
opts a
a []
    TT Ordering -> m (TT Ordering)
forall (f :: Type -> Type) a. Applicative f => a -> f a
pure (TT Ordering -> m (TT Ordering)) -> TT Ordering -> m (TT Ordering)
forall a b. (a -> b) -> a -> b
$ case Either (TT Ordering) (String, String, TT String, TT String)
lr of
      Left TT Ordering
e -> TT Ordering
e
      Right (String
p,String
q,TT String
pp,TT String
qq) ->
        let d :: Ordering
d = (String -> String -> Ordering)
-> ShowS -> String -> String -> Ordering
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
on String -> String -> Ordering
forall a. Ord a => a -> a -> Ordering
compare ((Char -> Char) -> ShowS
forall a b. (a -> b) -> [a] -> [b]
map Char -> Char
toLower) String
p String
q
        in POpts -> Val Ordering -> String -> [Tree PE] -> TT Ordering
forall a. POpts -> Val a -> String -> [Tree PE] -> TT a
mkNode POpts
opts (Ordering -> Val Ordering
forall a. a -> Val a
Val Ordering
d) (String
msg0 String -> ShowS
forall a. Semigroup a => a -> a -> a
<> String
" " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> String
p String -> ShowS
forall a. Semigroup a => a -> a -> a
<> String
" " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> Ordering -> String
prettyOrd Ordering
d String -> ShowS
forall a. Semigroup a => a -> a -> a
<> String
" " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> String
q) [TT String -> Tree PE
forall a. TT a -> Tree PE
hh TT String
pp, TT String -> Tree PE
forall a. TT a -> Tree PE
hh TT String
qq]

-- | compare two values using the given ordering @o@

data Cmp (o :: OrderingP) p q deriving Int -> Cmp o p q -> ShowS
[Cmp o p q] -> ShowS
Cmp o p q -> String
(Int -> Cmp o p q -> ShowS)
-> (Cmp o p q -> String)
-> ([Cmp o p q] -> ShowS)
-> Show (Cmp o p q)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall (o :: OrderingP) k (p :: k) k (q :: k).
Int -> Cmp o p q -> ShowS
forall (o :: OrderingP) k (p :: k) k (q :: k). [Cmp o p q] -> ShowS
forall (o :: OrderingP) k (p :: k) k (q :: k). Cmp o p q -> String
showList :: [Cmp o p q] -> ShowS
$cshowList :: forall (o :: OrderingP) k (p :: k) k (q :: k). [Cmp o p q] -> ShowS
show :: Cmp o p q -> String
$cshow :: forall (o :: OrderingP) k (p :: k) k (q :: k). Cmp o p q -> String
showsPrec :: Int -> Cmp o p q -> ShowS
$cshowsPrec :: forall (o :: OrderingP) k (p :: k) k (q :: k).
Int -> Cmp o p q -> ShowS
Show

instance ( 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) a where
  type PP (Cmp o p q) a = Bool
  eval :: proxy (Cmp o p q) -> POpts -> a -> m (TT (PP (Cmp o p q) a))
eval proxy (Cmp o p q)
_ POpts
opts a
a = do
    let (String
sfn, PP q a -> PP q a -> Bool
fn) = forall a. (GetOrd o, Ord a) => (String, a -> a -> Bool)
forall (k :: OrderingP) a.
(GetOrd k, Ord a) =>
(String, a -> a -> Bool)
getOrd @o
    Either (TT Bool) (PP q a, PP q a, TT (PP q a), TT (PP q a))
lr <- Inline
-> String
-> Proxy p
-> Proxy q
-> POpts
-> a
-> [Tree PE]
-> m (Either (TT Bool) (PP p a, PP q a, TT (PP p a), TT (PP q a)))
forall k1 k2 (p :: k1) a (q :: k2) (m :: Type -> Type)
       (proxy1 :: k1 -> Type) (proxy2 :: k2 -> Type) x.
(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)))
runPQ Inline
NoInline String
sfn (Proxy p
forall k (t :: k). Proxy t
Proxy @p) (Proxy q
forall k (t :: k). Proxy t
Proxy @q) POpts
opts a
a []
    TT Bool -> m (TT Bool)
forall (f :: Type -> Type) a. Applicative f => a -> f a
pure (TT Bool -> m (TT Bool)) -> TT Bool -> m (TT Bool)
forall a b. (a -> b) -> a -> b
$ case Either (TT Bool) (PP q a, PP q a, TT (PP q a), TT (PP q a))
lr of
      Left TT Bool
e -> TT Bool
e
      Right (PP q a
p,PP q a
q,TT (PP q a)
pp,TT (PP q a)
qq) ->
        let b :: Bool
b = PP q a -> PP q a -> Bool
fn PP q a
p PP q a
q
        in POpts -> Bool -> String -> [Tree PE] -> TT Bool
mkNodeB POpts
opts Bool
b (POpts -> PP q a -> String
forall a. Show a => POpts -> a -> String
showL POpts
opts PP q a
p String -> ShowS
forall a. Semigroup a => a -> a -> a
<> String
" " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> String
sfn String -> ShowS
forall a. Semigroup a => a -> a -> a
<> String
" " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> POpts -> PP q a -> String
forall a. Show a => POpts -> a -> String
showL POpts
opts PP q a
q) [TT (PP q a) -> Tree PE
forall a. TT a -> Tree PE
hh TT (PP q a)
pp, TT (PP q a) -> Tree PE
forall a. TT a -> Tree PE
hh TT (PP q a)
qq]

-- | compare two strings ignoring case using the given ordering @o@

data CmpI (o :: OrderingP) p q deriving Int -> CmpI o p q -> ShowS
[CmpI o p q] -> ShowS
CmpI o p q -> String
(Int -> CmpI o p q -> ShowS)
-> (CmpI o p q -> String)
-> ([CmpI o p q] -> ShowS)
-> Show (CmpI o p q)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall (o :: OrderingP) k (p :: k) k (q :: k).
Int -> CmpI o p q -> ShowS
forall (o :: OrderingP) k (p :: k) k (q :: k).
[CmpI o p q] -> ShowS
forall (o :: OrderingP) k (p :: k) k (q :: k). CmpI o p q -> String
showList :: [CmpI o p q] -> ShowS
$cshowList :: forall (o :: OrderingP) k (p :: k) k (q :: k).
[CmpI o p q] -> ShowS
show :: CmpI o p q -> String
$cshow :: forall (o :: OrderingP) k (p :: k) k (q :: k). CmpI o p q -> String
showsPrec :: Int -> CmpI o p q -> ShowS
$cshowsPrec :: forall (o :: OrderingP) k (p :: k) k (q :: k).
Int -> CmpI o p q -> ShowS
Show

instance ( PP p a ~ String
         , GetOrd o
         , PP p a ~ PP q a
         , P p a
         , P q a
         ) => P (CmpI o p q) a where
  type PP (CmpI o p q) a = Bool
  eval :: proxy (CmpI o p q) -> POpts -> a -> m (TT (PP (CmpI o p q) a))
eval proxy (CmpI o p q)
_ POpts
opts a
a = do
    let (String
sfn, String -> String -> Bool
fn) = forall a. (GetOrd o, Ord a) => (String, a -> a -> Bool)
forall (k :: OrderingP) a.
(GetOrd k, Ord a) =>
(String, a -> a -> Bool)
getOrd @o
    Either (TT Bool) (String, String, TT String, TT String)
lr <- Inline
-> String
-> Proxy p
-> Proxy q
-> POpts
-> a
-> [Tree PE]
-> m (Either (TT Bool) (PP p a, PP q a, TT (PP p a), TT (PP q a)))
forall k1 k2 (p :: k1) a (q :: k2) (m :: Type -> Type)
       (proxy1 :: k1 -> Type) (proxy2 :: k2 -> Type) x.
(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)))
runPQ Inline
NoInline String
sfn (Proxy p
forall k (t :: k). Proxy t
Proxy @p) (Proxy q
forall k (t :: k). Proxy t
Proxy @q) POpts
opts a
a []
    TT Bool -> m (TT Bool)
forall (f :: Type -> Type) a. Applicative f => a -> f a
pure (TT Bool -> m (TT Bool)) -> TT Bool -> m (TT Bool)
forall a b. (a -> b) -> a -> b
$ case Either (TT Bool) (String, String, TT String, TT String)
lr of
      Left TT Bool
e -> TT Bool
e
      Right (String
p,String
q,TT String
pp,TT String
qq) ->
        let b :: Bool
b = (String -> String -> Bool) -> ShowS -> String -> String -> Bool
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
on String -> String -> Bool
fn ((Char -> Char) -> ShowS
forall a b. (a -> b) -> [a] -> [b]
map Char -> Char
toLower) String
p String
q
        in POpts -> Bool -> String -> [Tree PE] -> TT Bool
mkNodeB POpts
opts Bool
b (String
p String -> ShowS
forall a. Semigroup a => a -> a -> a
<> String
" " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> String
sfn String -> ShowS
forall a. Semigroup a => a -> a -> a
<> String
"~ " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> String
q) [TT String -> Tree PE
forall a. TT a -> Tree PE
hh TT String
pp, TT String -> Tree PE
forall a. TT a -> Tree PE
hh TT String
qq]


-- | a type level predicate for a monotonic increasing list

--

-- >>> pl @Asc "aaacdef"

-- True ((>>) True | {All(6)})

-- Val True

--

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

-- Val True

--

-- >>> pz @Asc "axacdef"

-- Val False

--

data Asc deriving Int -> Asc -> ShowS
[Asc] -> ShowS
Asc -> String
(Int -> Asc -> ShowS)
-> (Asc -> String) -> ([Asc] -> ShowS) -> Show Asc
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Asc] -> ShowS
$cshowList :: [Asc] -> ShowS
show :: Asc -> String
$cshow :: Asc -> String
showsPrec :: Int -> Asc -> ShowS
$cshowsPrec :: Int -> Asc -> ShowS
Show
type AscT = Pairs >> All (Fst <= Snd)

instance P AscT x => P Asc x where
  type PP Asc x = PP AscT x
  eval :: proxy Asc -> POpts -> x -> m (TT (PP Asc x))
eval proxy Asc
_ = Proxy AscT -> POpts -> x -> m (TT (PP AscT x))
forall k (m :: Type -> Type) (p :: k) a (proxy :: k -> Type).
(MonadEval m, P p a, PP p a ~ Bool) =>
proxy p -> POpts -> a -> m (TT (PP p a))
evalBool (Proxy AscT
forall k (t :: k). Proxy t
Proxy @AscT)

-- | a type level predicate for a strictly increasing list

--

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

-- Val False

--

-- >>> pz @Asc' []

-- Val True

--

-- >>> pz @Asc' [-10]

-- Val True

--

data Asc' deriving Int -> Asc' -> ShowS
[Asc'] -> ShowS
Asc' -> String
(Int -> Asc' -> ShowS)
-> (Asc' -> String) -> ([Asc'] -> ShowS) -> Show Asc'
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Asc'] -> ShowS
$cshowList :: [Asc'] -> ShowS
show :: Asc' -> String
$cshow :: Asc' -> String
showsPrec :: Int -> Asc' -> ShowS
$cshowsPrec :: Int -> Asc' -> ShowS
Show
type AscT' = Pairs >> All (Fst < Snd)

instance P AscT' x => P Asc' x where
  type PP Asc' x = PP AscT' x
  eval :: proxy Asc' -> POpts -> x -> m (TT (PP Asc' x))
eval proxy Asc'
_ = Proxy AscT' -> POpts -> x -> m (TT (PP AscT' x))
forall k (m :: Type -> Type) (p :: k) a (proxy :: k -> Type).
(MonadEval m, P p a, PP p a ~ Bool) =>
proxy p -> POpts -> a -> m (TT (PP p a))
evalBool (Proxy AscT'
forall k (t :: k). Proxy t
Proxy @AscT')

-- | a type level predicate for a monotonic decreasing list

data Desc deriving Int -> Desc -> ShowS
[Desc] -> ShowS
Desc -> String
(Int -> Desc -> ShowS)
-> (Desc -> String) -> ([Desc] -> ShowS) -> Show Desc
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Desc] -> ShowS
$cshowList :: [Desc] -> ShowS
show :: Desc -> String
$cshow :: Desc -> String
showsPrec :: Int -> Desc -> ShowS
$cshowsPrec :: Int -> Desc -> ShowS
Show
type DescT = Pairs >> All (Fst >= Snd)

instance P DescT x => P Desc x where
  type PP Desc x = PP DescT x
  eval :: proxy Desc -> POpts -> x -> m (TT (PP Desc x))
eval proxy Desc
_ = Proxy DescT -> POpts -> x -> m (TT (PP DescT x))
forall k (m :: Type -> Type) (p :: k) a (proxy :: k -> Type).
(MonadEval m, P p a, PP p a ~ Bool) =>
proxy p -> POpts -> a -> m (TT (PP p a))
evalBool (Proxy DescT
forall k (t :: k). Proxy t
Proxy @DescT)
-- | a type level predicate for a strictly decreasing list

data Desc' deriving Int -> Desc' -> ShowS
[Desc'] -> ShowS
Desc' -> String
(Int -> Desc' -> ShowS)
-> (Desc' -> String) -> ([Desc'] -> ShowS) -> Show Desc'
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Desc'] -> ShowS
$cshowList :: [Desc'] -> ShowS
show :: Desc' -> String
$cshow :: Desc' -> String
showsPrec :: Int -> Desc' -> ShowS
$cshowsPrec :: Int -> Desc' -> ShowS
Show
type DescT' = Pairs >> All (Fst > Snd)

instance P DescT' x => P Desc' x where
  type PP Desc' x = PP DescT' x
  eval :: proxy Desc' -> POpts -> x -> m (TT (PP Desc' x))
eval proxy Desc'
_ = Proxy DescT' -> POpts -> x -> m (TT (PP DescT' x))
forall k (m :: Type -> Type) (p :: k) a (proxy :: k -> Type).
(MonadEval m, P p a, PP p a ~ Bool) =>
proxy p -> POpts -> a -> m (TT (PP p a))
evalBool (Proxy DescT'
forall k (t :: k). Proxy t
Proxy @DescT')


--type AscAlt = SortOn Id Id == Id

--type DescAlt = SortOnDesc Id Id == Id


-- | a type level predicate for all positive elements in a list

--

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

-- Val True

--

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

-- Val False

--

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

-- Val False

--

data AllPositive deriving Int -> AllPositive -> ShowS
[AllPositive] -> ShowS
AllPositive -> String
(Int -> AllPositive -> ShowS)
-> (AllPositive -> String)
-> ([AllPositive] -> ShowS)
-> Show AllPositive
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AllPositive] -> ShowS
$cshowList :: [AllPositive] -> ShowS
show :: AllPositive -> String
$cshow :: AllPositive -> String
showsPrec :: Int -> AllPositive -> ShowS
$cshowsPrec :: Int -> AllPositive -> ShowS
Show
type AllPositiveT = All Positive

instance P AllPositiveT x => P AllPositive x where
  type PP AllPositive x = PP AllPositiveT x
  eval :: proxy AllPositive -> POpts -> x -> m (TT (PP AllPositive x))
eval proxy AllPositive
_ = Proxy AllPositiveT -> POpts -> x -> m (TT (PP AllPositiveT x))
forall k (m :: Type -> Type) (p :: k) a (proxy :: k -> Type).
(MonadEval m, P p a, PP p a ~ Bool) =>
proxy p -> POpts -> a -> m (TT (PP p a))
evalBool (Proxy AllPositiveT
forall k (t :: k). Proxy t
Proxy @AllPositiveT)

-- | a type level predicate for all negative elements in a list

--

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

-- Val True

--

data AllNegative deriving Int -> AllNegative -> ShowS
[AllNegative] -> ShowS
AllNegative -> String
(Int -> AllNegative -> ShowS)
-> (AllNegative -> String)
-> ([AllNegative] -> ShowS)
-> Show AllNegative
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AllNegative] -> ShowS
$cshowList :: [AllNegative] -> ShowS
show :: AllNegative -> String
$cshow :: AllNegative -> String
showsPrec :: Int -> AllNegative -> ShowS
$cshowsPrec :: Int -> AllNegative -> ShowS
Show
type AllNegativeT = All Negative

instance P AllNegativeT x => P AllNegative x where
  type PP AllNegative x = PP AllNegativeT x
  eval :: proxy AllNegative -> POpts -> x -> m (TT (PP AllNegative x))
eval proxy AllNegative
_ = Proxy AllNegativeT -> POpts -> x -> m (TT (PP AllNegativeT x))
forall k (m :: Type -> Type) (p :: k) a (proxy :: k -> Type).
(MonadEval m, P p a, PP p a ~ Bool) =>
proxy p -> POpts -> a -> m (TT (PP p a))
evalBool (Proxy AllNegativeT
forall k (t :: k). Proxy t
Proxy @AllNegativeT)

-- | a type level predicate for a positive number

data Positive deriving Int -> Positive -> ShowS
[Positive] -> ShowS
Positive -> String
(Int -> Positive -> ShowS)
-> (Positive -> String) -> ([Positive] -> ShowS) -> Show Positive
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Positive] -> ShowS
$cshowList :: [Positive] -> ShowS
show :: Positive -> String
$cshow :: Positive -> String
showsPrec :: Int -> Positive -> ShowS
$cshowsPrec :: Int -> Positive -> ShowS
Show
type PositiveT = Gt 0

instance P PositiveT x => P Positive x where
  type PP Positive x = PP PositiveT x
  eval :: proxy Positive -> POpts -> x -> m (TT (PP Positive x))
eval proxy Positive
_ = Proxy PositiveT -> POpts -> x -> m (TT (PP PositiveT x))
forall k (m :: Type -> Type) (p :: k) a (proxy :: k -> Type).
(MonadEval m, P p a, PP p a ~ Bool) =>
proxy p -> POpts -> a -> m (TT (PP p a))
evalBool (Proxy PositiveT
forall k (t :: k). Proxy t
Proxy @PositiveT)

-- | a type level predicate for a negative number

data Negative deriving Int -> Negative -> ShowS
[Negative] -> ShowS
Negative -> String
(Int -> Negative -> ShowS)
-> (Negative -> String) -> ([Negative] -> ShowS) -> Show Negative
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Negative] -> ShowS
$cshowList :: [Negative] -> ShowS
show :: Negative -> String
$cshow :: Negative -> String
showsPrec :: Int -> Negative -> ShowS
$cshowsPrec :: Int -> Negative -> ShowS
Show
type NegativeT = Lt 0

instance P NegativeT x => P Negative x where
  type PP Negative x = PP NegativeT x
  eval :: proxy Negative -> POpts -> x -> m (TT (PP Negative x))
eval proxy Negative
_ = Proxy NegativeT -> POpts -> x -> m (TT (PP NegativeT x))
forall k (m :: Type -> Type) (p :: k) a (proxy :: k -> Type).
(MonadEval m, P p a, PP p a ~ Bool) =>
proxy p -> POpts -> a -> m (TT (PP p a))
evalBool (Proxy NegativeT
forall k (t :: k). Proxy t
Proxy @NegativeT)