{-# LANGUAGE
AllowAmbiguousTypes
, DeriveAnyClass
, DeriveFoldable
, DeriveFunctor
, DeriveGeneric
, DeriveTraversable
, DerivingStrategies
, DefaultSignatures
, FlexibleContexts
, FlexibleInstances
, FunctionalDependencies
, GADTs
, LambdaCase
, MultiParamTypeClasses
, OverloadedStrings
, ScopedTypeVariables
, TypeApplications
, TypeFamilies
, DataKinds
, PolyKinds
, TypeOperators
, UndecidableInstances
, UndecidableSuperClasses
#-}
module Squeal.PostgreSQL.Type
(
Money (..)
, Json (..)
, Jsonb (..)
, Composite (..)
, Enumerated (..)
, VarArray (..)
, FixArray (..)
, VarChar, varChar, getVarChar
, FixChar, fixChar, getFixChar
, Only (..)
) where
import Data.Proxy
import Data.Int (Int64)
import GHC.TypeLits
import qualified Data.Text as Strict (Text)
import qualified Data.Text as Strict.Text
import qualified GHC.Generics as GHC
import qualified Generics.SOP as SOP
newtype Money = Money { Money -> Int64
cents :: Int64 }
deriving stock (Money -> Money -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Money -> Money -> Bool
$c/= :: Money -> Money -> Bool
== :: Money -> Money -> Bool
$c== :: Money -> Money -> Bool
Eq, Eq Money
Money -> Money -> Bool
Money -> Money -> Ordering
Money -> Money -> Money
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 :: Money -> Money -> Money
$cmin :: Money -> Money -> Money
max :: Money -> Money -> Money
$cmax :: Money -> Money -> Money
>= :: Money -> Money -> Bool
$c>= :: Money -> Money -> Bool
> :: Money -> Money -> Bool
$c> :: Money -> Money -> Bool
<= :: Money -> Money -> Bool
$c<= :: Money -> Money -> Bool
< :: Money -> Money -> Bool
$c< :: Money -> Money -> Bool
compare :: Money -> Money -> Ordering
$ccompare :: Money -> Money -> Ordering
Ord, Int -> Money -> ShowS
[Money] -> ShowS
Money -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Money] -> ShowS
$cshowList :: [Money] -> ShowS
show :: Money -> String
$cshow :: Money -> String
showsPrec :: Int -> Money -> ShowS
$cshowsPrec :: Int -> Money -> ShowS
Show, ReadPrec [Money]
ReadPrec Money
Int -> ReadS Money
ReadS [Money]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Money]
$creadListPrec :: ReadPrec [Money]
readPrec :: ReadPrec Money
$creadPrec :: ReadPrec Money
readList :: ReadS [Money]
$creadList :: ReadS [Money]
readsPrec :: Int -> ReadS Money
$creadsPrec :: Int -> ReadS Money
Read, forall x. Rep Money x -> Money
forall x. Money -> Rep Money x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Money x -> Money
$cfrom :: forall x. Money -> Rep Money x
GHC.Generic)
deriving anyclass (Generic Money
forall a.
Generic a
-> (forall (proxy :: * -> *). proxy a -> DatatypeInfo (Code a))
-> HasDatatypeInfo a
forall (proxy :: * -> *). proxy Money -> DatatypeInfo (Code Money)
datatypeInfo :: forall (proxy :: * -> *). proxy Money -> DatatypeInfo (Code Money)
$cdatatypeInfo :: forall (proxy :: * -> *). proxy Money -> DatatypeInfo (Code Money)
SOP.HasDatatypeInfo, All SListI (Code Money)
Rep Money -> Money
Money -> Rep Money
forall a.
All SListI (Code a) -> (a -> Rep a) -> (Rep a -> a) -> Generic a
to :: Rep Money -> Money
$cto :: Rep Money -> Money
from :: Money -> Rep Money
$cfrom :: Money -> Rep Money
SOP.Generic)
newtype Json hask = Json {forall hask. Json hask -> hask
getJson :: hask}
deriving stock (Json hask -> Json hask -> Bool
forall hask. Eq hask => Json hask -> Json hask -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Json hask -> Json hask -> Bool
$c/= :: forall hask. Eq hask => Json hask -> Json hask -> Bool
== :: Json hask -> Json hask -> Bool
$c== :: forall hask. Eq hask => Json hask -> Json hask -> Bool
Eq, Json hask -> Json hask -> Bool
Json hask -> Json hask -> Ordering
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
forall {hask}. Ord hask => Eq (Json hask)
forall hask. Ord hask => Json hask -> Json hask -> Bool
forall hask. Ord hask => Json hask -> Json hask -> Ordering
forall hask. Ord hask => Json hask -> Json hask -> Json hask
min :: Json hask -> Json hask -> Json hask
$cmin :: forall hask. Ord hask => Json hask -> Json hask -> Json hask
max :: Json hask -> Json hask -> Json hask
$cmax :: forall hask. Ord hask => Json hask -> Json hask -> Json hask
>= :: Json hask -> Json hask -> Bool
$c>= :: forall hask. Ord hask => Json hask -> Json hask -> Bool
> :: Json hask -> Json hask -> Bool
$c> :: forall hask. Ord hask => Json hask -> Json hask -> Bool
<= :: Json hask -> Json hask -> Bool
$c<= :: forall hask. Ord hask => Json hask -> Json hask -> Bool
< :: Json hask -> Json hask -> Bool
$c< :: forall hask. Ord hask => Json hask -> Json hask -> Bool
compare :: Json hask -> Json hask -> Ordering
$ccompare :: forall hask. Ord hask => Json hask -> Json hask -> Ordering
Ord, Int -> Json hask -> ShowS
forall hask. Show hask => Int -> Json hask -> ShowS
forall hask. Show hask => [Json hask] -> ShowS
forall hask. Show hask => Json hask -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Json hask] -> ShowS
$cshowList :: forall hask. Show hask => [Json hask] -> ShowS
show :: Json hask -> String
$cshow :: forall hask. Show hask => Json hask -> String
showsPrec :: Int -> Json hask -> ShowS
$cshowsPrec :: forall hask. Show hask => Int -> Json hask -> ShowS
Show, ReadPrec [Json hask]
ReadPrec (Json hask)
ReadS [Json hask]
forall hask. Read hask => ReadPrec [Json hask]
forall hask. Read hask => ReadPrec (Json hask)
forall hask. Read hask => Int -> ReadS (Json hask)
forall hask. Read hask => ReadS [Json hask]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Json hask]
$creadListPrec :: forall hask. Read hask => ReadPrec [Json hask]
readPrec :: ReadPrec (Json hask)
$creadPrec :: forall hask. Read hask => ReadPrec (Json hask)
readList :: ReadS [Json hask]
$creadList :: forall hask. Read hask => ReadS [Json hask]
readsPrec :: Int -> ReadS (Json hask)
$creadsPrec :: forall hask. Read hask => Int -> ReadS (Json hask)
Read, forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall hask x. Rep (Json hask) x -> Json hask
forall hask x. Json hask -> Rep (Json hask) x
$cto :: forall hask x. Rep (Json hask) x -> Json hask
$cfrom :: forall hask x. Json hask -> Rep (Json hask) x
GHC.Generic)
deriving anyclass (forall {hask}. Generic (Json hask)
forall a.
Generic a
-> (forall (proxy :: * -> *). proxy a -> DatatypeInfo (Code a))
-> HasDatatypeInfo a
forall hask (proxy :: * -> *).
proxy (Json hask) -> DatatypeInfo (Code (Json hask))
datatypeInfo :: forall (proxy :: * -> *).
proxy (Json hask) -> DatatypeInfo (Code (Json hask))
$cdatatypeInfo :: forall hask (proxy :: * -> *).
proxy (Json hask) -> DatatypeInfo (Code (Json hask))
SOP.HasDatatypeInfo, forall {hask}. All SListI (Code (Json hask))
forall a.
All SListI (Code a) -> (a -> Rep a) -> (Rep a -> a) -> Generic a
forall hask. Rep (Json hask) -> Json hask
forall hask. Json hask -> Rep (Json hask)
to :: Rep (Json hask) -> Json hask
$cto :: forall hask. Rep (Json hask) -> Json hask
from :: Json hask -> Rep (Json hask)
$cfrom :: forall hask. Json hask -> Rep (Json hask)
SOP.Generic)
newtype Jsonb hask = Jsonb {forall hask. Jsonb hask -> hask
getJsonb :: hask}
deriving stock (Jsonb hask -> Jsonb hask -> Bool
forall hask. Eq hask => Jsonb hask -> Jsonb hask -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Jsonb hask -> Jsonb hask -> Bool
$c/= :: forall hask. Eq hask => Jsonb hask -> Jsonb hask -> Bool
== :: Jsonb hask -> Jsonb hask -> Bool
$c== :: forall hask. Eq hask => Jsonb hask -> Jsonb hask -> Bool
Eq, Jsonb hask -> Jsonb hask -> Bool
Jsonb hask -> Jsonb hask -> Ordering
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
forall {hask}. Ord hask => Eq (Jsonb hask)
forall hask. Ord hask => Jsonb hask -> Jsonb hask -> Bool
forall hask. Ord hask => Jsonb hask -> Jsonb hask -> Ordering
forall hask. Ord hask => Jsonb hask -> Jsonb hask -> Jsonb hask
min :: Jsonb hask -> Jsonb hask -> Jsonb hask
$cmin :: forall hask. Ord hask => Jsonb hask -> Jsonb hask -> Jsonb hask
max :: Jsonb hask -> Jsonb hask -> Jsonb hask
$cmax :: forall hask. Ord hask => Jsonb hask -> Jsonb hask -> Jsonb hask
>= :: Jsonb hask -> Jsonb hask -> Bool
$c>= :: forall hask. Ord hask => Jsonb hask -> Jsonb hask -> Bool
> :: Jsonb hask -> Jsonb hask -> Bool
$c> :: forall hask. Ord hask => Jsonb hask -> Jsonb hask -> Bool
<= :: Jsonb hask -> Jsonb hask -> Bool
$c<= :: forall hask. Ord hask => Jsonb hask -> Jsonb hask -> Bool
< :: Jsonb hask -> Jsonb hask -> Bool
$c< :: forall hask. Ord hask => Jsonb hask -> Jsonb hask -> Bool
compare :: Jsonb hask -> Jsonb hask -> Ordering
$ccompare :: forall hask. Ord hask => Jsonb hask -> Jsonb hask -> Ordering
Ord, Int -> Jsonb hask -> ShowS
forall hask. Show hask => Int -> Jsonb hask -> ShowS
forall hask. Show hask => [Jsonb hask] -> ShowS
forall hask. Show hask => Jsonb hask -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Jsonb hask] -> ShowS
$cshowList :: forall hask. Show hask => [Jsonb hask] -> ShowS
show :: Jsonb hask -> String
$cshow :: forall hask. Show hask => Jsonb hask -> String
showsPrec :: Int -> Jsonb hask -> ShowS
$cshowsPrec :: forall hask. Show hask => Int -> Jsonb hask -> ShowS
Show, ReadPrec [Jsonb hask]
ReadPrec (Jsonb hask)
ReadS [Jsonb hask]
forall hask. Read hask => ReadPrec [Jsonb hask]
forall hask. Read hask => ReadPrec (Jsonb hask)
forall hask. Read hask => Int -> ReadS (Jsonb hask)
forall hask. Read hask => ReadS [Jsonb hask]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Jsonb hask]
$creadListPrec :: forall hask. Read hask => ReadPrec [Jsonb hask]
readPrec :: ReadPrec (Jsonb hask)
$creadPrec :: forall hask. Read hask => ReadPrec (Jsonb hask)
readList :: ReadS [Jsonb hask]
$creadList :: forall hask. Read hask => ReadS [Jsonb hask]
readsPrec :: Int -> ReadS (Jsonb hask)
$creadsPrec :: forall hask. Read hask => Int -> ReadS (Jsonb hask)
Read, forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall hask x. Rep (Jsonb hask) x -> Jsonb hask
forall hask x. Jsonb hask -> Rep (Jsonb hask) x
$cto :: forall hask x. Rep (Jsonb hask) x -> Jsonb hask
$cfrom :: forall hask x. Jsonb hask -> Rep (Jsonb hask) x
GHC.Generic)
deriving anyclass (forall {hask}. Generic (Jsonb hask)
forall a.
Generic a
-> (forall (proxy :: * -> *). proxy a -> DatatypeInfo (Code a))
-> HasDatatypeInfo a
forall hask (proxy :: * -> *).
proxy (Jsonb hask) -> DatatypeInfo (Code (Jsonb hask))
datatypeInfo :: forall (proxy :: * -> *).
proxy (Jsonb hask) -> DatatypeInfo (Code (Jsonb hask))
$cdatatypeInfo :: forall hask (proxy :: * -> *).
proxy (Jsonb hask) -> DatatypeInfo (Code (Jsonb hask))
SOP.HasDatatypeInfo, forall {hask}. All SListI (Code (Jsonb hask))
forall a.
All SListI (Code a) -> (a -> Rep a) -> (Rep a -> a) -> Generic a
forall hask. Rep (Jsonb hask) -> Jsonb hask
forall hask. Jsonb hask -> Rep (Jsonb hask)
to :: Rep (Jsonb hask) -> Jsonb hask
$cto :: forall hask. Rep (Jsonb hask) -> Jsonb hask
from :: Jsonb hask -> Rep (Jsonb hask)
$cfrom :: forall hask. Jsonb hask -> Rep (Jsonb hask)
SOP.Generic)
newtype Composite record = Composite {forall record. Composite record -> record
getComposite :: record}
deriving stock (Composite record -> Composite record -> Bool
forall record.
Eq record =>
Composite record -> Composite record -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Composite record -> Composite record -> Bool
$c/= :: forall record.
Eq record =>
Composite record -> Composite record -> Bool
== :: Composite record -> Composite record -> Bool
$c== :: forall record.
Eq record =>
Composite record -> Composite record -> Bool
Eq, Composite record -> Composite record -> Bool
Composite record -> Composite record -> Ordering
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
forall {record}. Ord record => Eq (Composite record)
forall record.
Ord record =>
Composite record -> Composite record -> Bool
forall record.
Ord record =>
Composite record -> Composite record -> Ordering
forall record.
Ord record =>
Composite record -> Composite record -> Composite record
min :: Composite record -> Composite record -> Composite record
$cmin :: forall record.
Ord record =>
Composite record -> Composite record -> Composite record
max :: Composite record -> Composite record -> Composite record
$cmax :: forall record.
Ord record =>
Composite record -> Composite record -> Composite record
>= :: Composite record -> Composite record -> Bool
$c>= :: forall record.
Ord record =>
Composite record -> Composite record -> Bool
> :: Composite record -> Composite record -> Bool
$c> :: forall record.
Ord record =>
Composite record -> Composite record -> Bool
<= :: Composite record -> Composite record -> Bool
$c<= :: forall record.
Ord record =>
Composite record -> Composite record -> Bool
< :: Composite record -> Composite record -> Bool
$c< :: forall record.
Ord record =>
Composite record -> Composite record -> Bool
compare :: Composite record -> Composite record -> Ordering
$ccompare :: forall record.
Ord record =>
Composite record -> Composite record -> Ordering
Ord, Int -> Composite record -> ShowS
forall record. Show record => Int -> Composite record -> ShowS
forall record. Show record => [Composite record] -> ShowS
forall record. Show record => Composite record -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Composite record] -> ShowS
$cshowList :: forall record. Show record => [Composite record] -> ShowS
show :: Composite record -> String
$cshow :: forall record. Show record => Composite record -> String
showsPrec :: Int -> Composite record -> ShowS
$cshowsPrec :: forall record. Show record => Int -> Composite record -> ShowS
Show, ReadPrec [Composite record]
ReadPrec (Composite record)
ReadS [Composite record]
forall record. Read record => ReadPrec [Composite record]
forall record. Read record => ReadPrec (Composite record)
forall record. Read record => Int -> ReadS (Composite record)
forall record. Read record => ReadS [Composite record]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Composite record]
$creadListPrec :: forall record. Read record => ReadPrec [Composite record]
readPrec :: ReadPrec (Composite record)
$creadPrec :: forall record. Read record => ReadPrec (Composite record)
readList :: ReadS [Composite record]
$creadList :: forall record. Read record => ReadS [Composite record]
readsPrec :: Int -> ReadS (Composite record)
$creadsPrec :: forall record. Read record => Int -> ReadS (Composite record)
Read, forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall record x. Rep (Composite record) x -> Composite record
forall record x. Composite record -> Rep (Composite record) x
$cto :: forall record x. Rep (Composite record) x -> Composite record
$cfrom :: forall record x. Composite record -> Rep (Composite record) x
GHC.Generic)
deriving anyclass (forall {record}. Generic (Composite record)
forall a.
Generic a
-> (forall (proxy :: * -> *). proxy a -> DatatypeInfo (Code a))
-> HasDatatypeInfo a
forall record (proxy :: * -> *).
proxy (Composite record) -> DatatypeInfo (Code (Composite record))
datatypeInfo :: forall (proxy :: * -> *).
proxy (Composite record) -> DatatypeInfo (Code (Composite record))
$cdatatypeInfo :: forall record (proxy :: * -> *).
proxy (Composite record) -> DatatypeInfo (Code (Composite record))
SOP.HasDatatypeInfo, forall {record}. All SListI (Code (Composite record))
forall a.
All SListI (Code a) -> (a -> Rep a) -> (Rep a -> a) -> Generic a
forall record. Rep (Composite record) -> Composite record
forall record. Composite record -> Rep (Composite record)
to :: Rep (Composite record) -> Composite record
$cto :: forall record. Rep (Composite record) -> Composite record
from :: Composite record -> Rep (Composite record)
$cfrom :: forall record. Composite record -> Rep (Composite record)
SOP.Generic)
newtype Enumerated enum = Enumerated {forall enum. Enumerated enum -> enum
getEnumerated :: enum}
deriving stock (Enumerated enum -> Enumerated enum -> Bool
forall enum. Eq enum => Enumerated enum -> Enumerated enum -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Enumerated enum -> Enumerated enum -> Bool
$c/= :: forall enum. Eq enum => Enumerated enum -> Enumerated enum -> Bool
== :: Enumerated enum -> Enumerated enum -> Bool
$c== :: forall enum. Eq enum => Enumerated enum -> Enumerated enum -> Bool
Eq, Enumerated enum -> Enumerated enum -> Bool
Enumerated enum -> Enumerated enum -> Ordering
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
forall {enum}. Ord enum => Eq (Enumerated enum)
forall enum. Ord enum => Enumerated enum -> Enumerated enum -> Bool
forall enum.
Ord enum =>
Enumerated enum -> Enumerated enum -> Ordering
forall enum.
Ord enum =>
Enumerated enum -> Enumerated enum -> Enumerated enum
min :: Enumerated enum -> Enumerated enum -> Enumerated enum
$cmin :: forall enum.
Ord enum =>
Enumerated enum -> Enumerated enum -> Enumerated enum
max :: Enumerated enum -> Enumerated enum -> Enumerated enum
$cmax :: forall enum.
Ord enum =>
Enumerated enum -> Enumerated enum -> Enumerated enum
>= :: Enumerated enum -> Enumerated enum -> Bool
$c>= :: forall enum. Ord enum => Enumerated enum -> Enumerated enum -> Bool
> :: Enumerated enum -> Enumerated enum -> Bool
$c> :: forall enum. Ord enum => Enumerated enum -> Enumerated enum -> Bool
<= :: Enumerated enum -> Enumerated enum -> Bool
$c<= :: forall enum. Ord enum => Enumerated enum -> Enumerated enum -> Bool
< :: Enumerated enum -> Enumerated enum -> Bool
$c< :: forall enum. Ord enum => Enumerated enum -> Enumerated enum -> Bool
compare :: Enumerated enum -> Enumerated enum -> Ordering
$ccompare :: forall enum.
Ord enum =>
Enumerated enum -> Enumerated enum -> Ordering
Ord, Int -> Enumerated enum -> ShowS
forall enum. Show enum => Int -> Enumerated enum -> ShowS
forall enum. Show enum => [Enumerated enum] -> ShowS
forall enum. Show enum => Enumerated enum -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Enumerated enum] -> ShowS
$cshowList :: forall enum. Show enum => [Enumerated enum] -> ShowS
show :: Enumerated enum -> String
$cshow :: forall enum. Show enum => Enumerated enum -> String
showsPrec :: Int -> Enumerated enum -> ShowS
$cshowsPrec :: forall enum. Show enum => Int -> Enumerated enum -> ShowS
Show, ReadPrec [Enumerated enum]
ReadPrec (Enumerated enum)
ReadS [Enumerated enum]
forall enum. Read enum => ReadPrec [Enumerated enum]
forall enum. Read enum => ReadPrec (Enumerated enum)
forall enum. Read enum => Int -> ReadS (Enumerated enum)
forall enum. Read enum => ReadS [Enumerated enum]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Enumerated enum]
$creadListPrec :: forall enum. Read enum => ReadPrec [Enumerated enum]
readPrec :: ReadPrec (Enumerated enum)
$creadPrec :: forall enum. Read enum => ReadPrec (Enumerated enum)
readList :: ReadS [Enumerated enum]
$creadList :: forall enum. Read enum => ReadS [Enumerated enum]
readsPrec :: Int -> ReadS (Enumerated enum)
$creadsPrec :: forall enum. Read enum => Int -> ReadS (Enumerated enum)
Read, forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall enum x. Rep (Enumerated enum) x -> Enumerated enum
forall enum x. Enumerated enum -> Rep (Enumerated enum) x
$cto :: forall enum x. Rep (Enumerated enum) x -> Enumerated enum
$cfrom :: forall enum x. Enumerated enum -> Rep (Enumerated enum) x
GHC.Generic)
deriving anyclass (forall {enum}. Generic (Enumerated enum)
forall a.
Generic a
-> (forall (proxy :: * -> *). proxy a -> DatatypeInfo (Code a))
-> HasDatatypeInfo a
forall enum (proxy :: * -> *).
proxy (Enumerated enum) -> DatatypeInfo (Code (Enumerated enum))
datatypeInfo :: forall (proxy :: * -> *).
proxy (Enumerated enum) -> DatatypeInfo (Code (Enumerated enum))
$cdatatypeInfo :: forall enum (proxy :: * -> *).
proxy (Enumerated enum) -> DatatypeInfo (Code (Enumerated enum))
SOP.HasDatatypeInfo, forall {enum}. All SListI (Code (Enumerated enum))
forall a.
All SListI (Code a) -> (a -> Rep a) -> (Rep a -> a) -> Generic a
forall enum. Rep (Enumerated enum) -> Enumerated enum
forall enum. Enumerated enum -> Rep (Enumerated enum)
to :: Rep (Enumerated enum) -> Enumerated enum
$cto :: forall enum. Rep (Enumerated enum) -> Enumerated enum
from :: Enumerated enum -> Rep (Enumerated enum)
$cfrom :: forall enum. Enumerated enum -> Rep (Enumerated enum)
SOP.Generic)
newtype VarArray arr
= VarArray {forall arr. VarArray arr -> arr
getVarArray :: arr}
deriving stock (VarArray arr -> VarArray arr -> Bool
forall arr. Eq arr => VarArray arr -> VarArray arr -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VarArray arr -> VarArray arr -> Bool
$c/= :: forall arr. Eq arr => VarArray arr -> VarArray arr -> Bool
== :: VarArray arr -> VarArray arr -> Bool
$c== :: forall arr. Eq arr => VarArray arr -> VarArray arr -> Bool
Eq, VarArray arr -> VarArray arr -> Bool
VarArray arr -> VarArray arr -> Ordering
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
forall {arr}. Ord arr => Eq (VarArray arr)
forall arr. Ord arr => VarArray arr -> VarArray arr -> Bool
forall arr. Ord arr => VarArray arr -> VarArray arr -> Ordering
forall arr. Ord arr => VarArray arr -> VarArray arr -> VarArray arr
min :: VarArray arr -> VarArray arr -> VarArray arr
$cmin :: forall arr. Ord arr => VarArray arr -> VarArray arr -> VarArray arr
max :: VarArray arr -> VarArray arr -> VarArray arr
$cmax :: forall arr. Ord arr => VarArray arr -> VarArray arr -> VarArray arr
>= :: VarArray arr -> VarArray arr -> Bool
$c>= :: forall arr. Ord arr => VarArray arr -> VarArray arr -> Bool
> :: VarArray arr -> VarArray arr -> Bool
$c> :: forall arr. Ord arr => VarArray arr -> VarArray arr -> Bool
<= :: VarArray arr -> VarArray arr -> Bool
$c<= :: forall arr. Ord arr => VarArray arr -> VarArray arr -> Bool
< :: VarArray arr -> VarArray arr -> Bool
$c< :: forall arr. Ord arr => VarArray arr -> VarArray arr -> Bool
compare :: VarArray arr -> VarArray arr -> Ordering
$ccompare :: forall arr. Ord arr => VarArray arr -> VarArray arr -> Ordering
Ord, Int -> VarArray arr -> ShowS
forall arr. Show arr => Int -> VarArray arr -> ShowS
forall arr. Show arr => [VarArray arr] -> ShowS
forall arr. Show arr => VarArray arr -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [VarArray arr] -> ShowS
$cshowList :: forall arr. Show arr => [VarArray arr] -> ShowS
show :: VarArray arr -> String
$cshow :: forall arr. Show arr => VarArray arr -> String
showsPrec :: Int -> VarArray arr -> ShowS
$cshowsPrec :: forall arr. Show arr => Int -> VarArray arr -> ShowS
Show, ReadPrec [VarArray arr]
ReadPrec (VarArray arr)
ReadS [VarArray arr]
forall arr. Read arr => ReadPrec [VarArray arr]
forall arr. Read arr => ReadPrec (VarArray arr)
forall arr. Read arr => Int -> ReadS (VarArray arr)
forall arr. Read arr => ReadS [VarArray arr]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [VarArray arr]
$creadListPrec :: forall arr. Read arr => ReadPrec [VarArray arr]
readPrec :: ReadPrec (VarArray arr)
$creadPrec :: forall arr. Read arr => ReadPrec (VarArray arr)
readList :: ReadS [VarArray arr]
$creadList :: forall arr. Read arr => ReadS [VarArray arr]
readsPrec :: Int -> ReadS (VarArray arr)
$creadsPrec :: forall arr. Read arr => Int -> ReadS (VarArray arr)
Read, forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall arr x. Rep (VarArray arr) x -> VarArray arr
forall arr x. VarArray arr -> Rep (VarArray arr) x
$cto :: forall arr x. Rep (VarArray arr) x -> VarArray arr
$cfrom :: forall arr x. VarArray arr -> Rep (VarArray arr) x
GHC.Generic)
deriving anyclass (forall {arr}. Generic (VarArray arr)
forall a.
Generic a
-> (forall (proxy :: * -> *). proxy a -> DatatypeInfo (Code a))
-> HasDatatypeInfo a
forall arr (proxy :: * -> *).
proxy (VarArray arr) -> DatatypeInfo (Code (VarArray arr))
datatypeInfo :: forall (proxy :: * -> *).
proxy (VarArray arr) -> DatatypeInfo (Code (VarArray arr))
$cdatatypeInfo :: forall arr (proxy :: * -> *).
proxy (VarArray arr) -> DatatypeInfo (Code (VarArray arr))
SOP.HasDatatypeInfo, forall {arr}. All SListI (Code (VarArray arr))
forall a.
All SListI (Code a) -> (a -> Rep a) -> (Rep a -> a) -> Generic a
forall arr. Rep (VarArray arr) -> VarArray arr
forall arr. VarArray arr -> Rep (VarArray arr)
to :: Rep (VarArray arr) -> VarArray arr
$cto :: forall arr. Rep (VarArray arr) -> VarArray arr
from :: VarArray arr -> Rep (VarArray arr)
$cfrom :: forall arr. VarArray arr -> Rep (VarArray arr)
SOP.Generic)
newtype FixArray arr = FixArray {forall arr. FixArray arr -> arr
getFixArray :: arr}
deriving stock (FixArray arr -> FixArray arr -> Bool
forall arr. Eq arr => FixArray arr -> FixArray arr -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FixArray arr -> FixArray arr -> Bool
$c/= :: forall arr. Eq arr => FixArray arr -> FixArray arr -> Bool
== :: FixArray arr -> FixArray arr -> Bool
$c== :: forall arr. Eq arr => FixArray arr -> FixArray arr -> Bool
Eq, FixArray arr -> FixArray arr -> Bool
FixArray arr -> FixArray arr -> Ordering
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
forall {arr}. Ord arr => Eq (FixArray arr)
forall arr. Ord arr => FixArray arr -> FixArray arr -> Bool
forall arr. Ord arr => FixArray arr -> FixArray arr -> Ordering
forall arr. Ord arr => FixArray arr -> FixArray arr -> FixArray arr
min :: FixArray arr -> FixArray arr -> FixArray arr
$cmin :: forall arr. Ord arr => FixArray arr -> FixArray arr -> FixArray arr
max :: FixArray arr -> FixArray arr -> FixArray arr
$cmax :: forall arr. Ord arr => FixArray arr -> FixArray arr -> FixArray arr
>= :: FixArray arr -> FixArray arr -> Bool
$c>= :: forall arr. Ord arr => FixArray arr -> FixArray arr -> Bool
> :: FixArray arr -> FixArray arr -> Bool
$c> :: forall arr. Ord arr => FixArray arr -> FixArray arr -> Bool
<= :: FixArray arr -> FixArray arr -> Bool
$c<= :: forall arr. Ord arr => FixArray arr -> FixArray arr -> Bool
< :: FixArray arr -> FixArray arr -> Bool
$c< :: forall arr. Ord arr => FixArray arr -> FixArray arr -> Bool
compare :: FixArray arr -> FixArray arr -> Ordering
$ccompare :: forall arr. Ord arr => FixArray arr -> FixArray arr -> Ordering
Ord, Int -> FixArray arr -> ShowS
forall arr. Show arr => Int -> FixArray arr -> ShowS
forall arr. Show arr => [FixArray arr] -> ShowS
forall arr. Show arr => FixArray arr -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FixArray arr] -> ShowS
$cshowList :: forall arr. Show arr => [FixArray arr] -> ShowS
show :: FixArray arr -> String
$cshow :: forall arr. Show arr => FixArray arr -> String
showsPrec :: Int -> FixArray arr -> ShowS
$cshowsPrec :: forall arr. Show arr => Int -> FixArray arr -> ShowS
Show, ReadPrec [FixArray arr]
ReadPrec (FixArray arr)
ReadS [FixArray arr]
forall arr. Read arr => ReadPrec [FixArray arr]
forall arr. Read arr => ReadPrec (FixArray arr)
forall arr. Read arr => Int -> ReadS (FixArray arr)
forall arr. Read arr => ReadS [FixArray arr]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [FixArray arr]
$creadListPrec :: forall arr. Read arr => ReadPrec [FixArray arr]
readPrec :: ReadPrec (FixArray arr)
$creadPrec :: forall arr. Read arr => ReadPrec (FixArray arr)
readList :: ReadS [FixArray arr]
$creadList :: forall arr. Read arr => ReadS [FixArray arr]
readsPrec :: Int -> ReadS (FixArray arr)
$creadsPrec :: forall arr. Read arr => Int -> ReadS (FixArray arr)
Read, forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall arr x. Rep (FixArray arr) x -> FixArray arr
forall arr x. FixArray arr -> Rep (FixArray arr) x
$cto :: forall arr x. Rep (FixArray arr) x -> FixArray arr
$cfrom :: forall arr x. FixArray arr -> Rep (FixArray arr) x
GHC.Generic)
deriving anyclass (forall {arr}. Generic (FixArray arr)
forall a.
Generic a
-> (forall (proxy :: * -> *). proxy a -> DatatypeInfo (Code a))
-> HasDatatypeInfo a
forall arr (proxy :: * -> *).
proxy (FixArray arr) -> DatatypeInfo (Code (FixArray arr))
datatypeInfo :: forall (proxy :: * -> *).
proxy (FixArray arr) -> DatatypeInfo (Code (FixArray arr))
$cdatatypeInfo :: forall arr (proxy :: * -> *).
proxy (FixArray arr) -> DatatypeInfo (Code (FixArray arr))
SOP.HasDatatypeInfo, forall {arr}. All SListI (Code (FixArray arr))
forall a.
All SListI (Code a) -> (a -> Rep a) -> (Rep a -> a) -> Generic a
forall arr. Rep (FixArray arr) -> FixArray arr
forall arr. FixArray arr -> Rep (FixArray arr)
to :: Rep (FixArray arr) -> FixArray arr
$cto :: forall arr. Rep (FixArray arr) -> FixArray arr
from :: FixArray arr -> Rep (FixArray arr)
$cfrom :: forall arr. FixArray arr -> Rep (FixArray arr)
SOP.Generic)
newtype Only x = Only { forall x. Only x -> x
fromOnly :: x }
deriving (forall a b. a -> Only b -> Only a
forall a b. (a -> b) -> Only a -> Only b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> Only b -> Only a
$c<$ :: forall a b. a -> Only b -> Only a
fmap :: forall a b. (a -> b) -> Only a -> Only b
$cfmap :: forall a b. (a -> b) -> Only a -> Only b
Functor,forall a. Eq a => a -> Only a -> Bool
forall a. Num a => Only a -> a
forall a. Ord a => Only a -> a
forall m. Monoid m => Only m -> m
forall a. Only a -> Bool
forall a. Only a -> Int
forall a. Only a -> [a]
forall a. (a -> a -> a) -> Only a -> a
forall m a. Monoid m => (a -> m) -> Only a -> m
forall b a. (b -> a -> b) -> b -> Only a -> b
forall a b. (a -> b -> b) -> b -> Only a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => Only a -> a
$cproduct :: forall a. Num a => Only a -> a
sum :: forall a. Num a => Only a -> a
$csum :: forall a. Num a => Only a -> a
minimum :: forall a. Ord a => Only a -> a
$cminimum :: forall a. Ord a => Only a -> a
maximum :: forall a. Ord a => Only a -> a
$cmaximum :: forall a. Ord a => Only a -> a
elem :: forall a. Eq a => a -> Only a -> Bool
$celem :: forall a. Eq a => a -> Only a -> Bool
length :: forall a. Only a -> Int
$clength :: forall a. Only a -> Int
null :: forall a. Only a -> Bool
$cnull :: forall a. Only a -> Bool
toList :: forall a. Only a -> [a]
$ctoList :: forall a. Only a -> [a]
foldl1 :: forall a. (a -> a -> a) -> Only a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Only a -> a
foldr1 :: forall a. (a -> a -> a) -> Only a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> Only a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> Only a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Only a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Only a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Only a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Only a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Only a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Only a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> Only a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> Only a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Only a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Only a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Only a -> m
fold :: forall m. Monoid m => Only m -> m
$cfold :: forall m. Monoid m => Only m -> m
Foldable,Functor Only
Foldable Only
forall (t :: * -> *).
Functor t
-> Foldable t
-> (forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => Only (m a) -> m (Only a)
forall (f :: * -> *) a. Applicative f => Only (f a) -> f (Only a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Only a -> m (Only b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Only a -> f (Only b)
sequence :: forall (m :: * -> *) a. Monad m => Only (m a) -> m (Only a)
$csequence :: forall (m :: * -> *) a. Monad m => Only (m a) -> m (Only a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Only a -> m (Only b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Only a -> m (Only b)
sequenceA :: forall (f :: * -> *) a. Applicative f => Only (f a) -> f (Only a)
$csequenceA :: forall (f :: * -> *) a. Applicative f => Only (f a) -> f (Only a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Only a -> f (Only b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Only a -> f (Only b)
Traversable,Only x -> Only x -> Bool
forall x. Eq x => Only x -> Only x -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Only x -> Only x -> Bool
$c/= :: forall x. Eq x => Only x -> Only x -> Bool
== :: Only x -> Only x -> Bool
$c== :: forall x. Eq x => Only x -> Only x -> Bool
Eq,Only x -> Only x -> Bool
Only x -> Only x -> Ordering
Only x -> Only x -> Only x
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
forall {x}. Ord x => Eq (Only x)
forall x. Ord x => Only x -> Only x -> Bool
forall x. Ord x => Only x -> Only x -> Ordering
forall x. Ord x => Only x -> Only x -> Only x
min :: Only x -> Only x -> Only x
$cmin :: forall x. Ord x => Only x -> Only x -> Only x
max :: Only x -> Only x -> Only x
$cmax :: forall x. Ord x => Only x -> Only x -> Only x
>= :: Only x -> Only x -> Bool
$c>= :: forall x. Ord x => Only x -> Only x -> Bool
> :: Only x -> Only x -> Bool
$c> :: forall x. Ord x => Only x -> Only x -> Bool
<= :: Only x -> Only x -> Bool
$c<= :: forall x. Ord x => Only x -> Only x -> Bool
< :: Only x -> Only x -> Bool
$c< :: forall x. Ord x => Only x -> Only x -> Bool
compare :: Only x -> Only x -> Ordering
$ccompare :: forall x. Ord x => Only x -> Only x -> Ordering
Ord,ReadPrec [Only x]
ReadPrec (Only x)
ReadS [Only x]
forall x. Read x => ReadPrec [Only x]
forall x. Read x => ReadPrec (Only x)
forall x. Read x => Int -> ReadS (Only x)
forall x. Read x => ReadS [Only x]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Only x]
$creadListPrec :: forall x. Read x => ReadPrec [Only x]
readPrec :: ReadPrec (Only x)
$creadPrec :: forall x. Read x => ReadPrec (Only x)
readList :: ReadS [Only x]
$creadList :: forall x. Read x => ReadS [Only x]
readsPrec :: Int -> ReadS (Only x)
$creadsPrec :: forall x. Read x => Int -> ReadS (Only x)
Read,Int -> Only x -> ShowS
forall x. Show x => Int -> Only x -> ShowS
forall x. Show x => [Only x] -> ShowS
forall x. Show x => Only x -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Only x] -> ShowS
$cshowList :: forall x. Show x => [Only x] -> ShowS
show :: Only x -> String
$cshow :: forall x. Show x => Only x -> String
showsPrec :: Int -> Only x -> ShowS
$cshowsPrec :: forall x. Show x => Int -> Only x -> ShowS
Show,forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall x x. Rep (Only x) x -> Only x
forall x x. Only x -> Rep (Only x) x
$cto :: forall x x. Rep (Only x) x -> Only x
$cfrom :: forall x x. Only x -> Rep (Only x) x
GHC.Generic)
instance SOP.Generic (Only x)
instance SOP.HasDatatypeInfo (Only x)
newtype VarChar (n :: Nat) = VarChar Strict.Text
deriving (VarChar n -> VarChar n -> Bool
forall (n :: Nat). VarChar n -> VarChar n -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VarChar n -> VarChar n -> Bool
$c/= :: forall (n :: Nat). VarChar n -> VarChar n -> Bool
== :: VarChar n -> VarChar n -> Bool
$c== :: forall (n :: Nat). VarChar n -> VarChar n -> Bool
Eq,VarChar n -> VarChar n -> Bool
VarChar n -> VarChar n -> Ordering
VarChar n -> VarChar n -> VarChar n
forall (n :: Nat). Eq (VarChar n)
forall (n :: Nat). VarChar n -> VarChar n -> Bool
forall (n :: Nat). VarChar n -> VarChar n -> Ordering
forall (n :: Nat). VarChar n -> VarChar n -> VarChar n
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 :: VarChar n -> VarChar n -> VarChar n
$cmin :: forall (n :: Nat). VarChar n -> VarChar n -> VarChar n
max :: VarChar n -> VarChar n -> VarChar n
$cmax :: forall (n :: Nat). VarChar n -> VarChar n -> VarChar n
>= :: VarChar n -> VarChar n -> Bool
$c>= :: forall (n :: Nat). VarChar n -> VarChar n -> Bool
> :: VarChar n -> VarChar n -> Bool
$c> :: forall (n :: Nat). VarChar n -> VarChar n -> Bool
<= :: VarChar n -> VarChar n -> Bool
$c<= :: forall (n :: Nat). VarChar n -> VarChar n -> Bool
< :: VarChar n -> VarChar n -> Bool
$c< :: forall (n :: Nat). VarChar n -> VarChar n -> Bool
compare :: VarChar n -> VarChar n -> Ordering
$ccompare :: forall (n :: Nat). VarChar n -> VarChar n -> Ordering
Ord,ReadPrec [VarChar n]
ReadPrec (VarChar n)
ReadS [VarChar n]
forall (n :: Nat). ReadPrec [VarChar n]
forall (n :: Nat). ReadPrec (VarChar n)
forall (n :: Nat). Int -> ReadS (VarChar n)
forall (n :: Nat). ReadS [VarChar n]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [VarChar n]
$creadListPrec :: forall (n :: Nat). ReadPrec [VarChar n]
readPrec :: ReadPrec (VarChar n)
$creadPrec :: forall (n :: Nat). ReadPrec (VarChar n)
readList :: ReadS [VarChar n]
$creadList :: forall (n :: Nat). ReadS [VarChar n]
readsPrec :: Int -> ReadS (VarChar n)
$creadsPrec :: forall (n :: Nat). Int -> ReadS (VarChar n)
Read,Int -> VarChar n -> ShowS
forall (n :: Nat). Int -> VarChar n -> ShowS
forall (n :: Nat). [VarChar n] -> ShowS
forall (n :: Nat). VarChar n -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [VarChar n] -> ShowS
$cshowList :: forall (n :: Nat). [VarChar n] -> ShowS
show :: VarChar n -> String
$cshow :: forall (n :: Nat). VarChar n -> String
showsPrec :: Int -> VarChar n -> ShowS
$cshowsPrec :: forall (n :: Nat). Int -> VarChar n -> ShowS
Show)
varChar :: forall n . KnownNat n => Strict.Text -> Maybe (VarChar n)
varChar :: forall (n :: Nat). KnownNat n => Text -> Maybe (VarChar n)
varChar Text
t =
if Text -> Int
Strict.Text.length Text
t forall a. Ord a => a -> a -> Bool
<= forall a b. (Integral a, Num b) => a -> b
fromIntegral (forall (n :: Nat) (proxy :: Nat -> *).
KnownNat n =>
proxy n -> Integer
natVal @n forall {k} (t :: k). Proxy t
Proxy)
then forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall (n :: Nat). Text -> VarChar n
VarChar Text
t
else forall a. Maybe a
Nothing
getVarChar :: VarChar n -> Strict.Text
getVarChar :: forall (n :: Nat). VarChar n -> Text
getVarChar (VarChar Text
t) = Text
t
newtype FixChar (n :: Nat) = FixChar Strict.Text
deriving (FixChar n -> FixChar n -> Bool
forall (n :: Nat). FixChar n -> FixChar n -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FixChar n -> FixChar n -> Bool
$c/= :: forall (n :: Nat). FixChar n -> FixChar n -> Bool
== :: FixChar n -> FixChar n -> Bool
$c== :: forall (n :: Nat). FixChar n -> FixChar n -> Bool
Eq,FixChar n -> FixChar n -> Bool
FixChar n -> FixChar n -> Ordering
FixChar n -> FixChar n -> FixChar n
forall (n :: Nat). Eq (FixChar n)
forall (n :: Nat). FixChar n -> FixChar n -> Bool
forall (n :: Nat). FixChar n -> FixChar n -> Ordering
forall (n :: Nat). FixChar n -> FixChar n -> FixChar n
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 :: FixChar n -> FixChar n -> FixChar n
$cmin :: forall (n :: Nat). FixChar n -> FixChar n -> FixChar n
max :: FixChar n -> FixChar n -> FixChar n
$cmax :: forall (n :: Nat). FixChar n -> FixChar n -> FixChar n
>= :: FixChar n -> FixChar n -> Bool
$c>= :: forall (n :: Nat). FixChar n -> FixChar n -> Bool
> :: FixChar n -> FixChar n -> Bool
$c> :: forall (n :: Nat). FixChar n -> FixChar n -> Bool
<= :: FixChar n -> FixChar n -> Bool
$c<= :: forall (n :: Nat). FixChar n -> FixChar n -> Bool
< :: FixChar n -> FixChar n -> Bool
$c< :: forall (n :: Nat). FixChar n -> FixChar n -> Bool
compare :: FixChar n -> FixChar n -> Ordering
$ccompare :: forall (n :: Nat). FixChar n -> FixChar n -> Ordering
Ord,ReadPrec [FixChar n]
ReadPrec (FixChar n)
ReadS [FixChar n]
forall (n :: Nat). ReadPrec [FixChar n]
forall (n :: Nat). ReadPrec (FixChar n)
forall (n :: Nat). Int -> ReadS (FixChar n)
forall (n :: Nat). ReadS [FixChar n]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [FixChar n]
$creadListPrec :: forall (n :: Nat). ReadPrec [FixChar n]
readPrec :: ReadPrec (FixChar n)
$creadPrec :: forall (n :: Nat). ReadPrec (FixChar n)
readList :: ReadS [FixChar n]
$creadList :: forall (n :: Nat). ReadS [FixChar n]
readsPrec :: Int -> ReadS (FixChar n)
$creadsPrec :: forall (n :: Nat). Int -> ReadS (FixChar n)
Read,Int -> FixChar n -> ShowS
forall (n :: Nat). Int -> FixChar n -> ShowS
forall (n :: Nat). [FixChar n] -> ShowS
forall (n :: Nat). FixChar n -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FixChar n] -> ShowS
$cshowList :: forall (n :: Nat). [FixChar n] -> ShowS
show :: FixChar n -> String
$cshow :: forall (n :: Nat). FixChar n -> String
showsPrec :: Int -> FixChar n -> ShowS
$cshowsPrec :: forall (n :: Nat). Int -> FixChar n -> ShowS
Show)
fixChar :: forall n . KnownNat n => Strict.Text -> Maybe (FixChar n)
fixChar :: forall (n :: Nat). KnownNat n => Text -> Maybe (FixChar n)
fixChar Text
t =
if Text -> Int
Strict.Text.length Text
t forall a. Eq a => a -> a -> Bool
== forall a b. (Integral a, Num b) => a -> b
fromIntegral (forall (n :: Nat) (proxy :: Nat -> *).
KnownNat n =>
proxy n -> Integer
natVal @n forall {k} (t :: k). Proxy t
Proxy)
then forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall (n :: Nat). Text -> FixChar n
FixChar Text
t
else forall a. Maybe a
Nothing
getFixChar :: FixChar n -> Strict.Text
getFixChar :: forall (n :: Nat). FixChar n -> Text
getFixChar (FixChar Text
t) = Text
t