{-# LANGUAGE DeriveLift #-}

-- | This module contains types and functions for working with and
-- disambiguating database and Haskell names.
--
-- @since 2.13.0.0
module Database.Persist.Names where

import Data.Text (Text)
import Language.Haskell.TH.Syntax (Lift)
-- Bring `Lift (Map k v)` instance into scope, as well as `Lift Text`
-- instance on pre-1.2.4 versions of `text`
import Instances.TH.Lift ()

-- | Convenience operations for working with '-NameDB' types.
--
-- @since 2.12.0.0
class DatabaseName a where
    escapeWith :: (Text -> str) -> (a -> str)

-- | A 'FieldNameDB' represents the datastore-side name that @persistent@
-- will use for a field.
--
-- @since 2.12.0.0
newtype FieldNameDB = FieldNameDB { FieldNameDB -> Text
unFieldNameDB :: Text }
    deriving (Int -> FieldNameDB -> ShowS
[FieldNameDB] -> ShowS
FieldNameDB -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FieldNameDB] -> ShowS
$cshowList :: [FieldNameDB] -> ShowS
show :: FieldNameDB -> String
$cshow :: FieldNameDB -> String
showsPrec :: Int -> FieldNameDB -> ShowS
$cshowsPrec :: Int -> FieldNameDB -> ShowS
Show, FieldNameDB -> FieldNameDB -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FieldNameDB -> FieldNameDB -> Bool
$c/= :: FieldNameDB -> FieldNameDB -> Bool
== :: FieldNameDB -> FieldNameDB -> Bool
$c== :: FieldNameDB -> FieldNameDB -> Bool
Eq, ReadPrec [FieldNameDB]
ReadPrec FieldNameDB
Int -> ReadS FieldNameDB
ReadS [FieldNameDB]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [FieldNameDB]
$creadListPrec :: ReadPrec [FieldNameDB]
readPrec :: ReadPrec FieldNameDB
$creadPrec :: ReadPrec FieldNameDB
readList :: ReadS [FieldNameDB]
$creadList :: ReadS [FieldNameDB]
readsPrec :: Int -> ReadS FieldNameDB
$creadsPrec :: Int -> ReadS FieldNameDB
Read, Eq FieldNameDB
FieldNameDB -> FieldNameDB -> Bool
FieldNameDB -> FieldNameDB -> Ordering
FieldNameDB -> FieldNameDB -> FieldNameDB
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: FieldNameDB -> FieldNameDB -> FieldNameDB
$cmin :: FieldNameDB -> FieldNameDB -> FieldNameDB
max :: FieldNameDB -> FieldNameDB -> FieldNameDB
$cmax :: FieldNameDB -> FieldNameDB -> FieldNameDB
>= :: FieldNameDB -> FieldNameDB -> Bool
$c>= :: FieldNameDB -> FieldNameDB -> Bool
> :: FieldNameDB -> FieldNameDB -> Bool
$c> :: FieldNameDB -> FieldNameDB -> Bool
<= :: FieldNameDB -> FieldNameDB -> Bool
$c<= :: FieldNameDB -> FieldNameDB -> Bool
< :: FieldNameDB -> FieldNameDB -> Bool
$c< :: FieldNameDB -> FieldNameDB -> Bool
compare :: FieldNameDB -> FieldNameDB -> Ordering
$ccompare :: FieldNameDB -> FieldNameDB -> Ordering
Ord, forall t.
(forall (m :: * -> *). Quote m => t -> m Exp)
-> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
forall (m :: * -> *). Quote m => FieldNameDB -> m Exp
forall (m :: * -> *). Quote m => FieldNameDB -> Code m FieldNameDB
liftTyped :: forall (m :: * -> *). Quote m => FieldNameDB -> Code m FieldNameDB
$cliftTyped :: forall (m :: * -> *). Quote m => FieldNameDB -> Code m FieldNameDB
lift :: forall (m :: * -> *). Quote m => FieldNameDB -> m Exp
$clift :: forall (m :: * -> *). Quote m => FieldNameDB -> m Exp
Lift)

-- | @since 2.12.0.0
instance DatabaseName FieldNameDB where
    escapeWith :: forall str. (Text -> str) -> FieldNameDB -> str
escapeWith Text -> str
f (FieldNameDB Text
n) = Text -> str
f Text
n

-- | A 'FieldNameHS' represents the Haskell-side name that @persistent@
-- will use for a field.
--
-- @since 2.12.0.0
newtype FieldNameHS = FieldNameHS { FieldNameHS -> Text
unFieldNameHS :: Text }
    deriving (Int -> FieldNameHS -> ShowS
[FieldNameHS] -> ShowS
FieldNameHS -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FieldNameHS] -> ShowS
$cshowList :: [FieldNameHS] -> ShowS
show :: FieldNameHS -> String
$cshow :: FieldNameHS -> String
showsPrec :: Int -> FieldNameHS -> ShowS
$cshowsPrec :: Int -> FieldNameHS -> ShowS
Show, FieldNameHS -> FieldNameHS -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FieldNameHS -> FieldNameHS -> Bool
$c/= :: FieldNameHS -> FieldNameHS -> Bool
== :: FieldNameHS -> FieldNameHS -> Bool
$c== :: FieldNameHS -> FieldNameHS -> Bool
Eq, ReadPrec [FieldNameHS]
ReadPrec FieldNameHS
Int -> ReadS FieldNameHS
ReadS [FieldNameHS]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [FieldNameHS]
$creadListPrec :: ReadPrec [FieldNameHS]
readPrec :: ReadPrec FieldNameHS
$creadPrec :: ReadPrec FieldNameHS
readList :: ReadS [FieldNameHS]
$creadList :: ReadS [FieldNameHS]
readsPrec :: Int -> ReadS FieldNameHS
$creadsPrec :: Int -> ReadS FieldNameHS
Read, Eq FieldNameHS
FieldNameHS -> FieldNameHS -> Bool
FieldNameHS -> FieldNameHS -> Ordering
FieldNameHS -> FieldNameHS -> FieldNameHS
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: FieldNameHS -> FieldNameHS -> FieldNameHS
$cmin :: FieldNameHS -> FieldNameHS -> FieldNameHS
max :: FieldNameHS -> FieldNameHS -> FieldNameHS
$cmax :: FieldNameHS -> FieldNameHS -> FieldNameHS
>= :: FieldNameHS -> FieldNameHS -> Bool
$c>= :: FieldNameHS -> FieldNameHS -> Bool
> :: FieldNameHS -> FieldNameHS -> Bool
$c> :: FieldNameHS -> FieldNameHS -> Bool
<= :: FieldNameHS -> FieldNameHS -> Bool
$c<= :: FieldNameHS -> FieldNameHS -> Bool
< :: FieldNameHS -> FieldNameHS -> Bool
$c< :: FieldNameHS -> FieldNameHS -> Bool
compare :: FieldNameHS -> FieldNameHS -> Ordering
$ccompare :: FieldNameHS -> FieldNameHS -> Ordering
Ord, forall t.
(forall (m :: * -> *). Quote m => t -> m Exp)
-> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
forall (m :: * -> *). Quote m => FieldNameHS -> m Exp
forall (m :: * -> *). Quote m => FieldNameHS -> Code m FieldNameHS
liftTyped :: forall (m :: * -> *). Quote m => FieldNameHS -> Code m FieldNameHS
$cliftTyped :: forall (m :: * -> *). Quote m => FieldNameHS -> Code m FieldNameHS
lift :: forall (m :: * -> *). Quote m => FieldNameHS -> m Exp
$clift :: forall (m :: * -> *). Quote m => FieldNameHS -> m Exp
Lift)

-- | An 'EntityNameHS' represents the Haskell-side name that @persistent@
-- will use for an entity.
--
-- @since 2.12.0.0
newtype EntityNameHS = EntityNameHS { EntityNameHS -> Text
unEntityNameHS :: Text }
    deriving (Int -> EntityNameHS -> ShowS
[EntityNameHS] -> ShowS
EntityNameHS -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [EntityNameHS] -> ShowS
$cshowList :: [EntityNameHS] -> ShowS
show :: EntityNameHS -> String
$cshow :: EntityNameHS -> String
showsPrec :: Int -> EntityNameHS -> ShowS
$cshowsPrec :: Int -> EntityNameHS -> ShowS
Show, EntityNameHS -> EntityNameHS -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: EntityNameHS -> EntityNameHS -> Bool
$c/= :: EntityNameHS -> EntityNameHS -> Bool
== :: EntityNameHS -> EntityNameHS -> Bool
$c== :: EntityNameHS -> EntityNameHS -> Bool
Eq, ReadPrec [EntityNameHS]
ReadPrec EntityNameHS
Int -> ReadS EntityNameHS
ReadS [EntityNameHS]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [EntityNameHS]
$creadListPrec :: ReadPrec [EntityNameHS]
readPrec :: ReadPrec EntityNameHS
$creadPrec :: ReadPrec EntityNameHS
readList :: ReadS [EntityNameHS]
$creadList :: ReadS [EntityNameHS]
readsPrec :: Int -> ReadS EntityNameHS
$creadsPrec :: Int -> ReadS EntityNameHS
Read, Eq EntityNameHS
EntityNameHS -> EntityNameHS -> Bool
EntityNameHS -> EntityNameHS -> Ordering
EntityNameHS -> EntityNameHS -> EntityNameHS
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: EntityNameHS -> EntityNameHS -> EntityNameHS
$cmin :: EntityNameHS -> EntityNameHS -> EntityNameHS
max :: EntityNameHS -> EntityNameHS -> EntityNameHS
$cmax :: EntityNameHS -> EntityNameHS -> EntityNameHS
>= :: EntityNameHS -> EntityNameHS -> Bool
$c>= :: EntityNameHS -> EntityNameHS -> Bool
> :: EntityNameHS -> EntityNameHS -> Bool
$c> :: EntityNameHS -> EntityNameHS -> Bool
<= :: EntityNameHS -> EntityNameHS -> Bool
$c<= :: EntityNameHS -> EntityNameHS -> Bool
< :: EntityNameHS -> EntityNameHS -> Bool
$c< :: EntityNameHS -> EntityNameHS -> Bool
compare :: EntityNameHS -> EntityNameHS -> Ordering
$ccompare :: EntityNameHS -> EntityNameHS -> Ordering
Ord, forall t.
(forall (m :: * -> *). Quote m => t -> m Exp)
-> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
forall (m :: * -> *). Quote m => EntityNameHS -> m Exp
forall (m :: * -> *).
Quote m =>
EntityNameHS -> Code m EntityNameHS
liftTyped :: forall (m :: * -> *).
Quote m =>
EntityNameHS -> Code m EntityNameHS
$cliftTyped :: forall (m :: * -> *).
Quote m =>
EntityNameHS -> Code m EntityNameHS
lift :: forall (m :: * -> *). Quote m => EntityNameHS -> m Exp
$clift :: forall (m :: * -> *). Quote m => EntityNameHS -> m Exp
Lift)

-- | An 'EntityNameDB' represents the datastore-side name that @persistent@
-- will use for an entity.
--
-- @since 2.12.0.0
newtype EntityNameDB = EntityNameDB { EntityNameDB -> Text
unEntityNameDB :: Text }
    deriving (Int -> EntityNameDB -> ShowS
[EntityNameDB] -> ShowS
EntityNameDB -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [EntityNameDB] -> ShowS
$cshowList :: [EntityNameDB] -> ShowS
show :: EntityNameDB -> String
$cshow :: EntityNameDB -> String
showsPrec :: Int -> EntityNameDB -> ShowS
$cshowsPrec :: Int -> EntityNameDB -> ShowS
Show, EntityNameDB -> EntityNameDB -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: EntityNameDB -> EntityNameDB -> Bool
$c/= :: EntityNameDB -> EntityNameDB -> Bool
== :: EntityNameDB -> EntityNameDB -> Bool
$c== :: EntityNameDB -> EntityNameDB -> Bool
Eq, ReadPrec [EntityNameDB]
ReadPrec EntityNameDB
Int -> ReadS EntityNameDB
ReadS [EntityNameDB]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [EntityNameDB]
$creadListPrec :: ReadPrec [EntityNameDB]
readPrec :: ReadPrec EntityNameDB
$creadPrec :: ReadPrec EntityNameDB
readList :: ReadS [EntityNameDB]
$creadList :: ReadS [EntityNameDB]
readsPrec :: Int -> ReadS EntityNameDB
$creadsPrec :: Int -> ReadS EntityNameDB
Read, Eq EntityNameDB
EntityNameDB -> EntityNameDB -> Bool
EntityNameDB -> EntityNameDB -> Ordering
EntityNameDB -> EntityNameDB -> EntityNameDB
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: EntityNameDB -> EntityNameDB -> EntityNameDB
$cmin :: EntityNameDB -> EntityNameDB -> EntityNameDB
max :: EntityNameDB -> EntityNameDB -> EntityNameDB
$cmax :: EntityNameDB -> EntityNameDB -> EntityNameDB
>= :: EntityNameDB -> EntityNameDB -> Bool
$c>= :: EntityNameDB -> EntityNameDB -> Bool
> :: EntityNameDB -> EntityNameDB -> Bool
$c> :: EntityNameDB -> EntityNameDB -> Bool
<= :: EntityNameDB -> EntityNameDB -> Bool
$c<= :: EntityNameDB -> EntityNameDB -> Bool
< :: EntityNameDB -> EntityNameDB -> Bool
$c< :: EntityNameDB -> EntityNameDB -> Bool
compare :: EntityNameDB -> EntityNameDB -> Ordering
$ccompare :: EntityNameDB -> EntityNameDB -> Ordering
Ord, forall t.
(forall (m :: * -> *). Quote m => t -> m Exp)
-> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
forall (m :: * -> *). Quote m => EntityNameDB -> m Exp
forall (m :: * -> *).
Quote m =>
EntityNameDB -> Code m EntityNameDB
liftTyped :: forall (m :: * -> *).
Quote m =>
EntityNameDB -> Code m EntityNameDB
$cliftTyped :: forall (m :: * -> *).
Quote m =>
EntityNameDB -> Code m EntityNameDB
lift :: forall (m :: * -> *). Quote m => EntityNameDB -> m Exp
$clift :: forall (m :: * -> *). Quote m => EntityNameDB -> m Exp
Lift)

instance DatabaseName EntityNameDB where
    escapeWith :: forall str. (Text -> str) -> EntityNameDB -> str
escapeWith Text -> str
f (EntityNameDB Text
n) = Text -> str
f Text
n

-- | A 'ConstraintNameDB' represents the datastore-side name that @persistent@
-- will use for a constraint.
--
-- @since 2.12.0.0
newtype ConstraintNameDB = ConstraintNameDB { ConstraintNameDB -> Text
unConstraintNameDB :: Text }
  deriving (Int -> ConstraintNameDB -> ShowS
[ConstraintNameDB] -> ShowS
ConstraintNameDB -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ConstraintNameDB] -> ShowS
$cshowList :: [ConstraintNameDB] -> ShowS
show :: ConstraintNameDB -> String
$cshow :: ConstraintNameDB -> String
showsPrec :: Int -> ConstraintNameDB -> ShowS
$cshowsPrec :: Int -> ConstraintNameDB -> ShowS
Show, ConstraintNameDB -> ConstraintNameDB -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ConstraintNameDB -> ConstraintNameDB -> Bool
$c/= :: ConstraintNameDB -> ConstraintNameDB -> Bool
== :: ConstraintNameDB -> ConstraintNameDB -> Bool
$c== :: ConstraintNameDB -> ConstraintNameDB -> Bool
Eq, ReadPrec [ConstraintNameDB]
ReadPrec ConstraintNameDB
Int -> ReadS ConstraintNameDB
ReadS [ConstraintNameDB]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ConstraintNameDB]
$creadListPrec :: ReadPrec [ConstraintNameDB]
readPrec :: ReadPrec ConstraintNameDB
$creadPrec :: ReadPrec ConstraintNameDB
readList :: ReadS [ConstraintNameDB]
$creadList :: ReadS [ConstraintNameDB]
readsPrec :: Int -> ReadS ConstraintNameDB
$creadsPrec :: Int -> ReadS ConstraintNameDB
Read, Eq ConstraintNameDB
ConstraintNameDB -> ConstraintNameDB -> Bool
ConstraintNameDB -> ConstraintNameDB -> Ordering
ConstraintNameDB -> ConstraintNameDB -> ConstraintNameDB
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: ConstraintNameDB -> ConstraintNameDB -> ConstraintNameDB
$cmin :: ConstraintNameDB -> ConstraintNameDB -> ConstraintNameDB
max :: ConstraintNameDB -> ConstraintNameDB -> ConstraintNameDB
$cmax :: ConstraintNameDB -> ConstraintNameDB -> ConstraintNameDB
>= :: ConstraintNameDB -> ConstraintNameDB -> Bool
$c>= :: ConstraintNameDB -> ConstraintNameDB -> Bool
> :: ConstraintNameDB -> ConstraintNameDB -> Bool
$c> :: ConstraintNameDB -> ConstraintNameDB -> Bool
<= :: ConstraintNameDB -> ConstraintNameDB -> Bool
$c<= :: ConstraintNameDB -> ConstraintNameDB -> Bool
< :: ConstraintNameDB -> ConstraintNameDB -> Bool
$c< :: ConstraintNameDB -> ConstraintNameDB -> Bool
compare :: ConstraintNameDB -> ConstraintNameDB -> Ordering
$ccompare :: ConstraintNameDB -> ConstraintNameDB -> Ordering
Ord, forall t.
(forall (m :: * -> *). Quote m => t -> m Exp)
-> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
forall (m :: * -> *). Quote m => ConstraintNameDB -> m Exp
forall (m :: * -> *).
Quote m =>
ConstraintNameDB -> Code m ConstraintNameDB
liftTyped :: forall (m :: * -> *).
Quote m =>
ConstraintNameDB -> Code m ConstraintNameDB
$cliftTyped :: forall (m :: * -> *).
Quote m =>
ConstraintNameDB -> Code m ConstraintNameDB
lift :: forall (m :: * -> *). Quote m => ConstraintNameDB -> m Exp
$clift :: forall (m :: * -> *). Quote m => ConstraintNameDB -> m Exp
Lift)

-- | @since 2.12.0.0
instance DatabaseName ConstraintNameDB where
  escapeWith :: forall str. (Text -> str) -> ConstraintNameDB -> str
escapeWith Text -> str
f (ConstraintNameDB Text
n) = Text -> str
f Text
n

-- | An 'ConstraintNameHS' represents the Haskell-side name that @persistent@
-- will use for a constraint.
--
-- @since 2.12.0.0
newtype ConstraintNameHS = ConstraintNameHS { ConstraintNameHS -> Text
unConstraintNameHS :: Text }
  deriving (Int -> ConstraintNameHS -> ShowS
[ConstraintNameHS] -> ShowS
ConstraintNameHS -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ConstraintNameHS] -> ShowS
$cshowList :: [ConstraintNameHS] -> ShowS
show :: ConstraintNameHS -> String
$cshow :: ConstraintNameHS -> String
showsPrec :: Int -> ConstraintNameHS -> ShowS
$cshowsPrec :: Int -> ConstraintNameHS -> ShowS
Show, ConstraintNameHS -> ConstraintNameHS -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ConstraintNameHS -> ConstraintNameHS -> Bool
$c/= :: ConstraintNameHS -> ConstraintNameHS -> Bool
== :: ConstraintNameHS -> ConstraintNameHS -> Bool
$c== :: ConstraintNameHS -> ConstraintNameHS -> Bool
Eq, ReadPrec [ConstraintNameHS]
ReadPrec ConstraintNameHS
Int -> ReadS ConstraintNameHS
ReadS [ConstraintNameHS]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ConstraintNameHS]
$creadListPrec :: ReadPrec [ConstraintNameHS]
readPrec :: ReadPrec ConstraintNameHS
$creadPrec :: ReadPrec ConstraintNameHS
readList :: ReadS [ConstraintNameHS]
$creadList :: ReadS [ConstraintNameHS]
readsPrec :: Int -> ReadS ConstraintNameHS
$creadsPrec :: Int -> ReadS ConstraintNameHS
Read, Eq ConstraintNameHS
ConstraintNameHS -> ConstraintNameHS -> Bool
ConstraintNameHS -> ConstraintNameHS -> Ordering
ConstraintNameHS -> ConstraintNameHS -> ConstraintNameHS
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: ConstraintNameHS -> ConstraintNameHS -> ConstraintNameHS
$cmin :: ConstraintNameHS -> ConstraintNameHS -> ConstraintNameHS
max :: ConstraintNameHS -> ConstraintNameHS -> ConstraintNameHS
$cmax :: ConstraintNameHS -> ConstraintNameHS -> ConstraintNameHS
>= :: ConstraintNameHS -> ConstraintNameHS -> Bool
$c>= :: ConstraintNameHS -> ConstraintNameHS -> Bool
> :: ConstraintNameHS -> ConstraintNameHS -> Bool
$c> :: ConstraintNameHS -> ConstraintNameHS -> Bool
<= :: ConstraintNameHS -> ConstraintNameHS -> Bool
$c<= :: ConstraintNameHS -> ConstraintNameHS -> Bool
< :: ConstraintNameHS -> ConstraintNameHS -> Bool
$c< :: ConstraintNameHS -> ConstraintNameHS -> Bool
compare :: ConstraintNameHS -> ConstraintNameHS -> Ordering
$ccompare :: ConstraintNameHS -> ConstraintNameHS -> Ordering
Ord, forall t.
(forall (m :: * -> *). Quote m => t -> m Exp)
-> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
forall (m :: * -> *). Quote m => ConstraintNameHS -> m Exp
forall (m :: * -> *).
Quote m =>
ConstraintNameHS -> Code m ConstraintNameHS
liftTyped :: forall (m :: * -> *).
Quote m =>
ConstraintNameHS -> Code m ConstraintNameHS
$cliftTyped :: forall (m :: * -> *).
Quote m =>
ConstraintNameHS -> Code m ConstraintNameHS
lift :: forall (m :: * -> *). Quote m => ConstraintNameHS -> m Exp
$clift :: forall (m :: * -> *). Quote m => ConstraintNameHS -> m Exp
Lift)