{-# LANGUAGE UndecidableInstances #-}
{-# LANGUAGE CPP #-}
module PgSchema.Types(
  -- * PgTag types
  type (:=), (=:), (:.)(..), PgTag(..)
  -- * Enum
  , PGEnum
  -- * Aggregates
  , Aggr(..), Aggr'(..)
  -- * Arrays
  , PgArr(..), pgArr', unPgArr'
  -- * Other types
  , PgChar(..), PgOid(..)
  -- * Conversion checks
  , CanConvert, CanConvert1)
  where

import Control.Monad
import Data.Aeson
import Data.ByteString as BS
import Data.ByteString.Lazy as BSL
import Data.CaseInsensitive
import Data.Coerce
import Data.Fixed
import Data.Kind
import Data.List qualified as L
import Data.Maybe
import Data.Scientific
import Data.Singletons.TH
import Data.Text as T
import Data.Text.Encoding as T
import Data.Time
import Data.UUID.Types
import Database.PostgreSQL.Simple
import Database.PostgreSQL.Simple.FromField
import Database.PostgreSQL.Simple.ToField
import Database.PostgreSQL.Simple.Types
import GHC.TypeLits as TL
import GHC.TypeError as TE
import Data.Type.Equality (type (==))
import GHC.Int
import Prelude as P
import Type.Reflection
import PgSchema.Schema.Catalog (PGC)
import Data.Type.Bool (Not, type (&&), type (||))
import PgSchema.Schema
import PgSchema.Utils.Internal hiding (fromText)


#ifdef MK_ARBITRARY
import Test.QuickCheck(Arbitrary(arbitrary), arbitraryBoundedEnum)
#endif
#ifdef MK_FLAT
import Flat as F
#endif
#ifdef MK_HASHABLE
import Data.Hashable
#endif


-- | Introduce `enum` database types.
-- Data instances are produced by schema generation.
-- You can use these data instances in you records to @SELECT@/@INSERT@/@UPSERT@ data
data family PGEnum sch (name :: NameNSK) :: Type

instance
  (Read (PGEnum sch n), ToStar n, Typeable sch, Typeable n)
  => FromField (PGEnum sch n) where
  fromField :: FieldParser (PGEnum sch n)
fromField Field
f Maybe ByteString
mbs =
    case Maybe ByteString
mbs Maybe ByteString
-> (ByteString -> Maybe (PGEnum sch n)) -> Maybe (PGEnum sch n)
forall a b. Maybe a -> (a -> Maybe b) -> Maybe b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Text -> Maybe (PGEnum sch n)
forall sch (t :: NameNSK).
(Read (PGEnum sch t), ToStar t) =>
Text -> Maybe (PGEnum sch t)
enumFromText (Text -> Maybe (PGEnum sch n))
-> (ByteString -> Text) -> ByteString -> Maybe (PGEnum sch n)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Text
decodeUtf8 of
      Just PGEnum sch n
x -> PGEnum sch n -> Conversion (PGEnum sch n)
forall a. a -> Conversion a
forall (f :: * -> *) a. Applicative f => a -> f a
pure PGEnum sch n
x
      Maybe (PGEnum sch n)
_      -> (String -> Maybe Oid -> String -> String -> String -> ResultError)
-> Field -> String -> Conversion (PGEnum sch n)
forall a err.
(Typeable a, Exception err) =>
(String -> Maybe Oid -> String -> String -> String -> err)
-> Field -> String -> Conversion a
returnError String -> Maybe Oid -> String -> String -> String -> ResultError
Incompatible Field
f String
""

instance
  (Show (PGEnum sch n), ToStar n) => ToField (PGEnum sch n) where
  toField :: PGEnum sch n -> Action
toField = Text -> Action
forall a. ToField a => a -> Action
toField (Text -> Action)
-> (PGEnum sch n -> Text) -> PGEnum sch n -> Action
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PGEnum sch n -> Text
forall sch (t :: NameNSK).
(Show (PGEnum sch t), ToStar t) =>
PGEnum sch t -> Text
enumToText

instance (Read (PGEnum sch t), ToStar t) => FromJSON (PGEnum sch t) where
    parseJSON :: Value -> Parser (PGEnum sch t)
parseJSON = Value -> Parser Text
forall a. FromJSON a => Value -> Parser a
parseJSON (Value -> Parser Text)
-> (Text -> Parser (PGEnum sch t))
-> Value
-> Parser (PGEnum sch t)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Parser (PGEnum sch t)
-> (PGEnum sch t -> Parser (PGEnum sch t))
-> Maybe (PGEnum sch t)
-> Parser (PGEnum sch t)
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Parser (PGEnum sch t)
forall a. Parser a
forall (m :: * -> *) a. MonadPlus m => m a
mzero PGEnum sch t -> Parser (PGEnum sch t)
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Maybe (PGEnum sch t) -> Parser (PGEnum sch t))
-> (Text -> Maybe (PGEnum sch t)) -> Text -> Parser (PGEnum sch t)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Maybe (PGEnum sch t)
forall sch (t :: NameNSK).
(Read (PGEnum sch t), ToStar t) =>
Text -> Maybe (PGEnum sch t)
enumFromText

instance (Show (PGEnum sch t), ToStar t) => ToJSON (PGEnum sch t) where
  toJSON :: PGEnum sch t -> Value
toJSON = Text -> Value
forall a. ToJSON a => a -> Value
toJSON (Text -> Value) -> (PGEnum sch t -> Text) -> PGEnum sch t -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PGEnum sch t -> Text
forall sch (t :: NameNSK).
(Show (PGEnum sch t), ToStar t) =>
PGEnum sch t -> Text
enumToText

enumFromText
  :: forall sch t. (Read (PGEnum sch t), ToStar t)
  => Text -> Maybe (PGEnum sch t)
enumFromText :: forall sch (t :: NameNSK).
(Read (PGEnum sch t), ToStar t) =>
Text -> Maybe (PGEnum sch t)
enumFromText Text
t = ((PGEnum sch t, String) -> PGEnum sch t)
-> Maybe (PGEnum sch t, String) -> Maybe (PGEnum sch t)
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (PGEnum sch t, String) -> PGEnum sch t
forall a b. (a, b) -> a
fst (Maybe (PGEnum sch t, String) -> Maybe (PGEnum sch t))
-> Maybe (PGEnum sch t, String) -> Maybe (PGEnum sch t)
forall a b. (a -> b) -> a -> b
$ [(PGEnum sch t, String)] -> Maybe (PGEnum sch t, String)
forall a. [a] -> Maybe a
listToMaybe
  ([(PGEnum sch t, String)] -> Maybe (PGEnum sch t, String))
-> [(PGEnum sch t, String)] -> Maybe (PGEnum sch t, String)
forall a b. (a -> b) -> a -> b
$ ReadS (PGEnum sch t)
forall a. Read a => ReadS a
reads ReadS (PGEnum sch t) -> ReadS (PGEnum sch t)
forall a b. (a -> b) -> a -> b
$ Text -> String
T.unpack (Text -> String) -> Text -> String
forall a b. (a -> b) -> a -> b
$ Text -> Text
toTitle (NameNS' Text -> Text
forall s. NameNS' s -> s
nnsName (NameNS' Text -> Text) -> NameNS' Text -> Text
forall a b. (a -> b) -> a -> b
$ forall {k} (a :: k). (SingKind k, SingI a) => Demote k
forall (a :: NameNSK).
(SingKind NameNSK, SingI a) =>
Demote NameNSK
demote @t) Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
"_" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
t

enumToText :: forall sch t. (Show (PGEnum sch t), ToStar t) => PGEnum sch t -> Text
enumToText :: forall sch (t :: NameNSK).
(Show (PGEnum sch t), ToStar t) =>
PGEnum sch t -> Text
enumToText = Int -> Text -> Text
T.drop (Text -> Int
T.length (NameNS' Text -> Text
forall s. NameNS' s -> s
nnsName (NameNS' Text -> Text) -> NameNS' Text -> Text
forall a b. (a -> b) -> a -> b
$ forall {k} (a :: k). (SingKind k, SingI a) => Demote k
forall (a :: NameNSK).
(SingKind NameNSK, SingI a) =>
Demote NameNSK
demote @t) Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1) (Text -> Text) -> (PGEnum sch t -> Text) -> PGEnum sch t -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PGEnum sch t -> Text
forall a. Show a => a -> Text
T.show

#ifdef MK_ARBITRARY
instance (Bounded (PGEnum sch t), Enum (PGEnum sch t)) =>
  Arbitrary (PGEnum sch t) where
    arbitrary = arbitraryBoundedEnum
#endif

#ifdef MK_FLAT
instance (Read (PGEnum sch n), Show (PGEnum sch n)) => Flat (PGEnum sch n) where
  encode = F.encode . P.show
  decode = read <$> F.decode
  size = F.size . P.show
#endif

-- | Introduce aggregate functions.
--
-- I.e. @"fld" := Aggr AMin (Maybe Int32)@ means "minimum value of the field `fld`"
--
-- 'Aggr' requires a 'Maybe' argument for all functions except @count@.
--
-- Only a small set of aggregations are supported currently: @count@, @min@, @max@, @sum@, @avg@.
newtype Aggr (f :: AggrFun) t = Aggr { forall (f :: AggrFun) t. Aggr f t -> t
unAggr :: t }
  deriving stock Int -> Aggr f t -> ShowS
[Aggr f t] -> ShowS
Aggr f t -> String
(Int -> Aggr f t -> ShowS)
-> (Aggr f t -> String) -> ([Aggr f t] -> ShowS) -> Show (Aggr f t)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall (f :: AggrFun) t. Show t => Int -> Aggr f t -> ShowS
forall (f :: AggrFun) t. Show t => [Aggr f t] -> ShowS
forall (f :: AggrFun) t. Show t => Aggr f t -> String
$cshowsPrec :: forall (f :: AggrFun) t. Show t => Int -> Aggr f t -> ShowS
showsPrec :: Int -> Aggr f t -> ShowS
$cshow :: forall (f :: AggrFun) t. Show t => Aggr f t -> String
show :: Aggr f t -> String
$cshowList :: forall (f :: AggrFun) t. Show t => [Aggr f t] -> ShowS
showList :: [Aggr f t] -> ShowS
Show
  deriving newtype (Aggr f t -> Aggr f t -> Bool
(Aggr f t -> Aggr f t -> Bool)
-> (Aggr f t -> Aggr f t -> Bool) -> Eq (Aggr f t)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall (f :: AggrFun) t. Eq t => Aggr f t -> Aggr f t -> Bool
$c== :: forall (f :: AggrFun) t. Eq t => Aggr f t -> Aggr f t -> Bool
== :: Aggr f t -> Aggr f t -> Bool
$c/= :: forall (f :: AggrFun) t. Eq t => Aggr f t -> Aggr f t -> Bool
/= :: Aggr f t -> Aggr f t -> Bool
Eq, Eq (Aggr f t)
Eq (Aggr f t) =>
(Aggr f t -> Aggr f t -> Ordering)
-> (Aggr f t -> Aggr f t -> Bool)
-> (Aggr f t -> Aggr f t -> Bool)
-> (Aggr f t -> Aggr f t -> Bool)
-> (Aggr f t -> Aggr f t -> Bool)
-> (Aggr f t -> Aggr f t -> Aggr f t)
-> (Aggr f t -> Aggr f t -> Aggr f t)
-> Ord (Aggr f t)
Aggr f t -> Aggr f t -> Bool
Aggr f t -> Aggr f t -> Ordering
Aggr f t -> Aggr f t -> Aggr f t
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 (f :: AggrFun) t. Ord t => Eq (Aggr f t)
forall (f :: AggrFun) t. Ord t => Aggr f t -> Aggr f t -> Bool
forall (f :: AggrFun) t. Ord t => Aggr f t -> Aggr f t -> Ordering
forall (f :: AggrFun) t. Ord t => Aggr f t -> Aggr f t -> Aggr f t
$ccompare :: forall (f :: AggrFun) t. Ord t => Aggr f t -> Aggr f t -> Ordering
compare :: Aggr f t -> Aggr f t -> Ordering
$c< :: forall (f :: AggrFun) t. Ord t => Aggr f t -> Aggr f t -> Bool
< :: Aggr f t -> Aggr f t -> Bool
$c<= :: forall (f :: AggrFun) t. Ord t => Aggr f t -> Aggr f t -> Bool
<= :: Aggr f t -> Aggr f t -> Bool
$c> :: forall (f :: AggrFun) t. Ord t => Aggr f t -> Aggr f t -> Bool
> :: Aggr f t -> Aggr f t -> Bool
$c>= :: forall (f :: AggrFun) t. Ord t => Aggr f t -> Aggr f t -> Bool
>= :: Aggr f t -> Aggr f t -> Bool
$cmax :: forall (f :: AggrFun) t. Ord t => Aggr f t -> Aggr f t -> Aggr f t
max :: Aggr f t -> Aggr f t -> Aggr f t
$cmin :: forall (f :: AggrFun) t. Ord t => Aggr f t -> Aggr f t -> Aggr f t
min :: Aggr f t -> Aggr f t -> Aggr f t
Ord, FieldParser (Aggr f t)
FieldParser (Aggr f t) -> FromField (Aggr f t)
forall a. FieldParser a -> FromField a
forall (f :: AggrFun) t. FromField t => FieldParser (Aggr f t)
$cfromField :: forall (f :: AggrFun) t. FromField t => FieldParser (Aggr f t)
fromField :: FieldParser (Aggr f t)
FromField, Aggr f t -> Action
(Aggr f t -> Action) -> ToField (Aggr f t)
forall a. (a -> Action) -> ToField a
forall (f :: AggrFun) t. ToField t => Aggr f t -> Action
$ctoField :: forall (f :: AggrFun) t. ToField t => Aggr f t -> Action
toField :: Aggr f t -> Action
ToField, Maybe (Aggr f t)
Value -> Parser [Aggr f t]
Value -> Parser (Aggr f t)
(Value -> Parser (Aggr f t))
-> (Value -> Parser [Aggr f t])
-> Maybe (Aggr f t)
-> FromJSON (Aggr f t)
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
forall (f :: AggrFun) t. FromJSON t => Maybe (Aggr f t)
forall (f :: AggrFun) t. FromJSON t => Value -> Parser [Aggr f t]
forall (f :: AggrFun) t. FromJSON t => Value -> Parser (Aggr f t)
$cparseJSON :: forall (f :: AggrFun) t. FromJSON t => Value -> Parser (Aggr f t)
parseJSON :: Value -> Parser (Aggr f t)
$cparseJSONList :: forall (f :: AggrFun) t. FromJSON t => Value -> Parser [Aggr f t]
parseJSONList :: Value -> Parser [Aggr f t]
$comittedField :: forall (f :: AggrFun) t. FromJSON t => Maybe (Aggr f t)
omittedField :: Maybe (Aggr f t)
FromJSON, [Aggr f t] -> Value
[Aggr f t] -> Encoding
Aggr f t -> Bool
Aggr f t -> Value
Aggr f t -> Encoding
(Aggr f t -> Value)
-> (Aggr f t -> Encoding)
-> ([Aggr f t] -> Value)
-> ([Aggr f t] -> Encoding)
-> (Aggr f t -> Bool)
-> ToJSON (Aggr f t)
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
forall (f :: AggrFun) t. ToJSON t => [Aggr f t] -> Value
forall (f :: AggrFun) t. ToJSON t => [Aggr f t] -> Encoding
forall (f :: AggrFun) t. ToJSON t => Aggr f t -> Bool
forall (f :: AggrFun) t. ToJSON t => Aggr f t -> Value
forall (f :: AggrFun) t. ToJSON t => Aggr f t -> Encoding
$ctoJSON :: forall (f :: AggrFun) t. ToJSON t => Aggr f t -> Value
toJSON :: Aggr f t -> Value
$ctoEncoding :: forall (f :: AggrFun) t. ToJSON t => Aggr f t -> Encoding
toEncoding :: Aggr f t -> Encoding
$ctoJSONList :: forall (f :: AggrFun) t. ToJSON t => [Aggr f t] -> Value
toJSONList :: [Aggr f t] -> Value
$ctoEncodingList :: forall (f :: AggrFun) t. ToJSON t => [Aggr f t] -> Encoding
toEncodingList :: [Aggr f t] -> Encoding
$comitField :: forall (f :: AggrFun) t. ToJSON t => Aggr f t -> Bool
omitField :: Aggr f t -> Bool
ToJSON)

-- | All aggregate functions except @count@ can return NULL.
-- But if field under aggregate is mandatory they return NULL only on empty set
-- if there is no group by clause. E.g. `select min(a) from t where false`
-- So we require Nullable for Aggr.
--
-- 'Aggr'' is like 'Aggr' but cannot be used in SELECT without `group by`.
-- So it is mandatory if field is mandatory.
newtype Aggr' (f :: AggrFun) t = Aggr' { forall (f :: AggrFun) t. Aggr' f t -> t
unAggr' :: t }
  deriving stock Int -> Aggr' f t -> ShowS
[Aggr' f t] -> ShowS
Aggr' f t -> String
(Int -> Aggr' f t -> ShowS)
-> (Aggr' f t -> String)
-> ([Aggr' f t] -> ShowS)
-> Show (Aggr' f t)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall (f :: AggrFun) t. Show t => Int -> Aggr' f t -> ShowS
forall (f :: AggrFun) t. Show t => [Aggr' f t] -> ShowS
forall (f :: AggrFun) t. Show t => Aggr' f t -> String
$cshowsPrec :: forall (f :: AggrFun) t. Show t => Int -> Aggr' f t -> ShowS
showsPrec :: Int -> Aggr' f t -> ShowS
$cshow :: forall (f :: AggrFun) t. Show t => Aggr' f t -> String
show :: Aggr' f t -> String
$cshowList :: forall (f :: AggrFun) t. Show t => [Aggr' f t] -> ShowS
showList :: [Aggr' f t] -> ShowS
Show
  deriving newtype (Aggr' f t -> Aggr' f t -> Bool
(Aggr' f t -> Aggr' f t -> Bool)
-> (Aggr' f t -> Aggr' f t -> Bool) -> Eq (Aggr' f t)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall (f :: AggrFun) t. Eq t => Aggr' f t -> Aggr' f t -> Bool
$c== :: forall (f :: AggrFun) t. Eq t => Aggr' f t -> Aggr' f t -> Bool
== :: Aggr' f t -> Aggr' f t -> Bool
$c/= :: forall (f :: AggrFun) t. Eq t => Aggr' f t -> Aggr' f t -> Bool
/= :: Aggr' f t -> Aggr' f t -> Bool
Eq, Eq (Aggr' f t)
Eq (Aggr' f t) =>
(Aggr' f t -> Aggr' f t -> Ordering)
-> (Aggr' f t -> Aggr' f t -> Bool)
-> (Aggr' f t -> Aggr' f t -> Bool)
-> (Aggr' f t -> Aggr' f t -> Bool)
-> (Aggr' f t -> Aggr' f t -> Bool)
-> (Aggr' f t -> Aggr' f t -> Aggr' f t)
-> (Aggr' f t -> Aggr' f t -> Aggr' f t)
-> Ord (Aggr' f t)
Aggr' f t -> Aggr' f t -> Bool
Aggr' f t -> Aggr' f t -> Ordering
Aggr' f t -> Aggr' f t -> Aggr' f t
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 (f :: AggrFun) t. Ord t => Eq (Aggr' f t)
forall (f :: AggrFun) t. Ord t => Aggr' f t -> Aggr' f t -> Bool
forall (f :: AggrFun) t.
Ord t =>
Aggr' f t -> Aggr' f t -> Ordering
forall (f :: AggrFun) t.
Ord t =>
Aggr' f t -> Aggr' f t -> Aggr' f t
$ccompare :: forall (f :: AggrFun) t.
Ord t =>
Aggr' f t -> Aggr' f t -> Ordering
compare :: Aggr' f t -> Aggr' f t -> Ordering
$c< :: forall (f :: AggrFun) t. Ord t => Aggr' f t -> Aggr' f t -> Bool
< :: Aggr' f t -> Aggr' f t -> Bool
$c<= :: forall (f :: AggrFun) t. Ord t => Aggr' f t -> Aggr' f t -> Bool
<= :: Aggr' f t -> Aggr' f t -> Bool
$c> :: forall (f :: AggrFun) t. Ord t => Aggr' f t -> Aggr' f t -> Bool
> :: Aggr' f t -> Aggr' f t -> Bool
$c>= :: forall (f :: AggrFun) t. Ord t => Aggr' f t -> Aggr' f t -> Bool
>= :: Aggr' f t -> Aggr' f t -> Bool
$cmax :: forall (f :: AggrFun) t.
Ord t =>
Aggr' f t -> Aggr' f t -> Aggr' f t
max :: Aggr' f t -> Aggr' f t -> Aggr' f t
$cmin :: forall (f :: AggrFun) t.
Ord t =>
Aggr' f t -> Aggr' f t -> Aggr' f t
min :: Aggr' f t -> Aggr' f t -> Aggr' f t
Ord, FieldParser (Aggr' f t)
FieldParser (Aggr' f t) -> FromField (Aggr' f t)
forall a. FieldParser a -> FromField a
forall (f :: AggrFun) t. FromField t => FieldParser (Aggr' f t)
$cfromField :: forall (f :: AggrFun) t. FromField t => FieldParser (Aggr' f t)
fromField :: FieldParser (Aggr' f t)
FromField, Aggr' f t -> Action
(Aggr' f t -> Action) -> ToField (Aggr' f t)
forall a. (a -> Action) -> ToField a
forall (f :: AggrFun) t. ToField t => Aggr' f t -> Action
$ctoField :: forall (f :: AggrFun) t. ToField t => Aggr' f t -> Action
toField :: Aggr' f t -> Action
ToField, Maybe (Aggr' f t)
Value -> Parser [Aggr' f t]
Value -> Parser (Aggr' f t)
(Value -> Parser (Aggr' f t))
-> (Value -> Parser [Aggr' f t])
-> Maybe (Aggr' f t)
-> FromJSON (Aggr' f t)
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
forall (f :: AggrFun) t. FromJSON t => Maybe (Aggr' f t)
forall (f :: AggrFun) t. FromJSON t => Value -> Parser [Aggr' f t]
forall (f :: AggrFun) t. FromJSON t => Value -> Parser (Aggr' f t)
$cparseJSON :: forall (f :: AggrFun) t. FromJSON t => Value -> Parser (Aggr' f t)
parseJSON :: Value -> Parser (Aggr' f t)
$cparseJSONList :: forall (f :: AggrFun) t. FromJSON t => Value -> Parser [Aggr' f t]
parseJSONList :: Value -> Parser [Aggr' f t]
$comittedField :: forall (f :: AggrFun) t. FromJSON t => Maybe (Aggr' f t)
omittedField :: Maybe (Aggr' f t)
FromJSON, [Aggr' f t] -> Value
[Aggr' f t] -> Encoding
Aggr' f t -> Bool
Aggr' f t -> Value
Aggr' f t -> Encoding
(Aggr' f t -> Value)
-> (Aggr' f t -> Encoding)
-> ([Aggr' f t] -> Value)
-> ([Aggr' f t] -> Encoding)
-> (Aggr' f t -> Bool)
-> ToJSON (Aggr' f t)
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
forall (f :: AggrFun) t. ToJSON t => [Aggr' f t] -> Value
forall (f :: AggrFun) t. ToJSON t => [Aggr' f t] -> Encoding
forall (f :: AggrFun) t. ToJSON t => Aggr' f t -> Bool
forall (f :: AggrFun) t. ToJSON t => Aggr' f t -> Value
forall (f :: AggrFun) t. ToJSON t => Aggr' f t -> Encoding
$ctoJSON :: forall (f :: AggrFun) t. ToJSON t => Aggr' f t -> Value
toJSON :: Aggr' f t -> Value
$ctoEncoding :: forall (f :: AggrFun) t. ToJSON t => Aggr' f t -> Encoding
toEncoding :: Aggr' f t -> Encoding
$ctoJSONList :: forall (f :: AggrFun) t. ToJSON t => [Aggr' f t] -> Value
toJSONList :: [Aggr' f t] -> Value
$ctoEncodingList :: forall (f :: AggrFun) t. ToJSON t => [Aggr' f t] -> Encoding
toEncodingList :: [Aggr' f t] -> Encoding
$comitField :: forall (f :: AggrFun) t. ToJSON t => Aggr' f t -> Bool
omitField :: Aggr' f t -> Bool
ToJSON)

-- | 'Char' has no 'ToField' instance; this is a custom wrapper.
newtype PgChar = PgChar { PgChar -> Char
unPgChar :: Char }
  deriving stock (Int -> PgChar -> ShowS
[PgChar] -> ShowS
PgChar -> String
(Int -> PgChar -> ShowS)
-> (PgChar -> String) -> ([PgChar] -> ShowS) -> Show PgChar
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PgChar -> ShowS
showsPrec :: Int -> PgChar -> ShowS
$cshow :: PgChar -> String
show :: PgChar -> String
$cshowList :: [PgChar] -> ShowS
showList :: [PgChar] -> ShowS
Show, ReadPrec [PgChar]
ReadPrec PgChar
Int -> ReadS PgChar
ReadS [PgChar]
(Int -> ReadS PgChar)
-> ReadS [PgChar]
-> ReadPrec PgChar
-> ReadPrec [PgChar]
-> Read PgChar
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS PgChar
readsPrec :: Int -> ReadS PgChar
$creadList :: ReadS [PgChar]
readList :: ReadS [PgChar]
$creadPrec :: ReadPrec PgChar
readPrec :: ReadPrec PgChar
$creadListPrec :: ReadPrec [PgChar]
readListPrec :: ReadPrec [PgChar]
Read)
  deriving newtype (PgChar -> PgChar -> Bool
(PgChar -> PgChar -> Bool)
-> (PgChar -> PgChar -> Bool) -> Eq PgChar
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PgChar -> PgChar -> Bool
== :: PgChar -> PgChar -> Bool
$c/= :: PgChar -> PgChar -> Bool
/= :: PgChar -> PgChar -> Bool
Eq, Eq PgChar
Eq PgChar =>
(PgChar -> PgChar -> Ordering)
-> (PgChar -> PgChar -> Bool)
-> (PgChar -> PgChar -> Bool)
-> (PgChar -> PgChar -> Bool)
-> (PgChar -> PgChar -> Bool)
-> (PgChar -> PgChar -> PgChar)
-> (PgChar -> PgChar -> PgChar)
-> Ord PgChar
PgChar -> PgChar -> Bool
PgChar -> PgChar -> Ordering
PgChar -> PgChar -> PgChar
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
$ccompare :: PgChar -> PgChar -> Ordering
compare :: PgChar -> PgChar -> Ordering
$c< :: PgChar -> PgChar -> Bool
< :: PgChar -> PgChar -> Bool
$c<= :: PgChar -> PgChar -> Bool
<= :: PgChar -> PgChar -> Bool
$c> :: PgChar -> PgChar -> Bool
> :: PgChar -> PgChar -> Bool
$c>= :: PgChar -> PgChar -> Bool
>= :: PgChar -> PgChar -> Bool
$cmax :: PgChar -> PgChar -> PgChar
max :: PgChar -> PgChar -> PgChar
$cmin :: PgChar -> PgChar -> PgChar
min :: PgChar -> PgChar -> PgChar
Ord, FieldParser PgChar
FieldParser PgChar -> FromField PgChar
forall a. FieldParser a -> FromField a
$cfromField :: FieldParser PgChar
fromField :: FieldParser PgChar
FromField, Int -> PgChar
PgChar -> Int
PgChar -> [PgChar]
PgChar -> PgChar
PgChar -> PgChar -> [PgChar]
PgChar -> PgChar -> PgChar -> [PgChar]
(PgChar -> PgChar)
-> (PgChar -> PgChar)
-> (Int -> PgChar)
-> (PgChar -> Int)
-> (PgChar -> [PgChar])
-> (PgChar -> PgChar -> [PgChar])
-> (PgChar -> PgChar -> [PgChar])
-> (PgChar -> PgChar -> PgChar -> [PgChar])
-> Enum PgChar
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: PgChar -> PgChar
succ :: PgChar -> PgChar
$cpred :: PgChar -> PgChar
pred :: PgChar -> PgChar
$ctoEnum :: Int -> PgChar
toEnum :: Int -> PgChar
$cfromEnum :: PgChar -> Int
fromEnum :: PgChar -> Int
$cenumFrom :: PgChar -> [PgChar]
enumFrom :: PgChar -> [PgChar]
$cenumFromThen :: PgChar -> PgChar -> [PgChar]
enumFromThen :: PgChar -> PgChar -> [PgChar]
$cenumFromTo :: PgChar -> PgChar -> [PgChar]
enumFromTo :: PgChar -> PgChar -> [PgChar]
$cenumFromThenTo :: PgChar -> PgChar -> PgChar -> [PgChar]
enumFromThenTo :: PgChar -> PgChar -> PgChar -> [PgChar]
Enum, PgChar
PgChar -> PgChar -> Bounded PgChar
forall a. a -> a -> Bounded a
$cminBound :: PgChar
minBound :: PgChar
$cmaxBound :: PgChar
maxBound :: PgChar
Bounded, Maybe PgChar
Value -> Parser [PgChar]
Value -> Parser PgChar
(Value -> Parser PgChar)
-> (Value -> Parser [PgChar]) -> Maybe PgChar -> FromJSON PgChar
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
$cparseJSON :: Value -> Parser PgChar
parseJSON :: Value -> Parser PgChar
$cparseJSONList :: Value -> Parser [PgChar]
parseJSONList :: Value -> Parser [PgChar]
$comittedField :: Maybe PgChar
omittedField :: Maybe PgChar
FromJSON, [PgChar] -> Value
[PgChar] -> Encoding
PgChar -> Bool
PgChar -> Value
PgChar -> Encoding
(PgChar -> Value)
-> (PgChar -> Encoding)
-> ([PgChar] -> Value)
-> ([PgChar] -> Encoding)
-> (PgChar -> Bool)
-> ToJSON PgChar
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: PgChar -> Value
toJSON :: PgChar -> Value
$ctoEncoding :: PgChar -> Encoding
toEncoding :: PgChar -> Encoding
$ctoJSONList :: [PgChar] -> Value
toJSONList :: [PgChar] -> Value
$ctoEncodingList :: [PgChar] -> Encoding
toEncodingList :: [PgChar] -> Encoding
$comitField :: PgChar -> Bool
omitField :: PgChar -> Bool
ToJSON
#ifdef MK_HASHABLE
    , Hashable )
#else
    )
#endif

instance ToField PgChar where
  toField :: PgChar -> Action
toField = String -> Action
forall a. ToField a => a -> Action
toField (String -> Action) -> (PgChar -> String) -> PgChar -> Action
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Char -> ShowS
forall a. a -> [a] -> [a]
:[]) (Char -> String) -> (PgChar -> Char) -> PgChar -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PgChar -> Char
unPgChar

--
-- | 'PGArray' has no JSON instances. '[]' has JSON, but no PG instances.
-- This one has both.
--
-- Use this type to work with arrays in database.
--
-- All elements are 'Maybe' because PostgreSQL does not guarantee that all elements are present.
-- 'PgTag' @typeName@ 'PgArr' can be /safely/ converted to 'ToField' with type information (e.g. @val::int[]@).
-- This instance is used internally in the generation of SQL.
--
newtype PgArr a = PgArr { forall a. PgArr a -> [Maybe a]
unPgArr :: [Maybe a] }
  deriving stock (Int -> PgArr a -> ShowS
[PgArr a] -> ShowS
PgArr a -> String
(Int -> PgArr a -> ShowS)
-> (PgArr a -> String) -> ([PgArr a] -> ShowS) -> Show (PgArr a)
forall a. Show a => Int -> PgArr a -> ShowS
forall a. Show a => [PgArr a] -> ShowS
forall a. Show a => PgArr a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall a. Show a => Int -> PgArr a -> ShowS
showsPrec :: Int -> PgArr a -> ShowS
$cshow :: forall a. Show a => PgArr a -> String
show :: PgArr a -> String
$cshowList :: forall a. Show a => [PgArr a] -> ShowS
showList :: [PgArr a] -> ShowS
Show, ReadPrec [PgArr a]
ReadPrec (PgArr a)
Int -> ReadS (PgArr a)
ReadS [PgArr a]
(Int -> ReadS (PgArr a))
-> ReadS [PgArr a]
-> ReadPrec (PgArr a)
-> ReadPrec [PgArr a]
-> Read (PgArr a)
forall a. Read a => ReadPrec [PgArr a]
forall a. Read a => ReadPrec (PgArr a)
forall a. Read a => Int -> ReadS (PgArr a)
forall a. Read a => ReadS [PgArr a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: forall a. Read a => Int -> ReadS (PgArr a)
readsPrec :: Int -> ReadS (PgArr a)
$creadList :: forall a. Read a => ReadS [PgArr a]
readList :: ReadS [PgArr a]
$creadPrec :: forall a. Read a => ReadPrec (PgArr a)
readPrec :: ReadPrec (PgArr a)
$creadListPrec :: forall a. Read a => ReadPrec [PgArr a]
readListPrec :: ReadPrec [PgArr a]
Read)
  deriving newtype (PgArr a -> PgArr a -> Bool
(PgArr a -> PgArr a -> Bool)
-> (PgArr a -> PgArr a -> Bool) -> Eq (PgArr a)
forall a. Eq a => PgArr a -> PgArr a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => PgArr a -> PgArr a -> Bool
== :: PgArr a -> PgArr a -> Bool
$c/= :: forall a. Eq a => PgArr a -> PgArr a -> Bool
/= :: PgArr a -> PgArr a -> Bool
Eq, Eq (PgArr a)
Eq (PgArr a) =>
(PgArr a -> PgArr a -> Ordering)
-> (PgArr a -> PgArr a -> Bool)
-> (PgArr a -> PgArr a -> Bool)
-> (PgArr a -> PgArr a -> Bool)
-> (PgArr a -> PgArr a -> Bool)
-> (PgArr a -> PgArr a -> PgArr a)
-> (PgArr a -> PgArr a -> PgArr a)
-> Ord (PgArr a)
PgArr a -> PgArr a -> Bool
PgArr a -> PgArr a -> Ordering
PgArr a -> PgArr a -> PgArr a
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 a. Ord a => Eq (PgArr a)
forall a. Ord a => PgArr a -> PgArr a -> Bool
forall a. Ord a => PgArr a -> PgArr a -> Ordering
forall a. Ord a => PgArr a -> PgArr a -> PgArr a
$ccompare :: forall a. Ord a => PgArr a -> PgArr a -> Ordering
compare :: PgArr a -> PgArr a -> Ordering
$c< :: forall a. Ord a => PgArr a -> PgArr a -> Bool
< :: PgArr a -> PgArr a -> Bool
$c<= :: forall a. Ord a => PgArr a -> PgArr a -> Bool
<= :: PgArr a -> PgArr a -> Bool
$c> :: forall a. Ord a => PgArr a -> PgArr a -> Bool
> :: PgArr a -> PgArr a -> Bool
$c>= :: forall a. Ord a => PgArr a -> PgArr a -> Bool
>= :: PgArr a -> PgArr a -> Bool
$cmax :: forall a. Ord a => PgArr a -> PgArr a -> PgArr a
max :: PgArr a -> PgArr a -> PgArr a
$cmin :: forall a. Ord a => PgArr a -> PgArr a -> PgArr a
min :: PgArr a -> PgArr a -> PgArr a
Ord, Maybe (PgArr a)
Value -> Parser [PgArr a]
Value -> Parser (PgArr a)
(Value -> Parser (PgArr a))
-> (Value -> Parser [PgArr a])
-> Maybe (PgArr a)
-> FromJSON (PgArr a)
forall a. FromJSON a => Maybe (PgArr a)
forall a. FromJSON a => Value -> Parser [PgArr a]
forall a. FromJSON a => Value -> Parser (PgArr a)
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
$cparseJSON :: forall a. FromJSON a => Value -> Parser (PgArr a)
parseJSON :: Value -> Parser (PgArr a)
$cparseJSONList :: forall a. FromJSON a => Value -> Parser [PgArr a]
parseJSONList :: Value -> Parser [PgArr a]
$comittedField :: forall a. FromJSON a => Maybe (PgArr a)
omittedField :: Maybe (PgArr a)
FromJSON, [PgArr a] -> Value
[PgArr a] -> Encoding
PgArr a -> Bool
PgArr a -> Value
PgArr a -> Encoding
(PgArr a -> Value)
-> (PgArr a -> Encoding)
-> ([PgArr a] -> Value)
-> ([PgArr a] -> Encoding)
-> (PgArr a -> Bool)
-> ToJSON (PgArr a)
forall a. ToJSON a => [PgArr a] -> Value
forall a. ToJSON a => [PgArr a] -> Encoding
forall a. ToJSON a => PgArr a -> Bool
forall a. ToJSON a => PgArr a -> Value
forall a. ToJSON a => PgArr a -> Encoding
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: forall a. ToJSON a => PgArr a -> Value
toJSON :: PgArr a -> Value
$ctoEncoding :: forall a. ToJSON a => PgArr a -> Encoding
toEncoding :: PgArr a -> Encoding
$ctoJSONList :: forall a. ToJSON a => [PgArr a] -> Value
toJSONList :: [PgArr a] -> Value
$ctoEncodingList :: forall a. ToJSON a => [PgArr a] -> Encoding
toEncodingList :: [PgArr a] -> Encoding
$comitField :: forall a. ToJSON a => PgArr a -> Bool
omitField :: PgArr a -> Bool
ToJSON, NonEmpty (PgArr a) -> PgArr a
PgArr a -> PgArr a -> PgArr a
(PgArr a -> PgArr a -> PgArr a)
-> (NonEmpty (PgArr a) -> PgArr a)
-> (forall b. Integral b => b -> PgArr a -> PgArr a)
-> Semigroup (PgArr a)
forall b. Integral b => b -> PgArr a -> PgArr a
forall a. NonEmpty (PgArr a) -> PgArr a
forall a. PgArr a -> PgArr a -> PgArr a
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
forall a b. Integral b => b -> PgArr a -> PgArr a
$c<> :: forall a. PgArr a -> PgArr a -> PgArr a
<> :: PgArr a -> PgArr a -> PgArr a
$csconcat :: forall a. NonEmpty (PgArr a) -> PgArr a
sconcat :: NonEmpty (PgArr a) -> PgArr a
$cstimes :: forall a b. Integral b => b -> PgArr a -> PgArr a
stimes :: forall b. Integral b => b -> PgArr a -> PgArr a
Semigroup, Semigroup (PgArr a)
PgArr a
Semigroup (PgArr a) =>
PgArr a
-> (PgArr a -> PgArr a -> PgArr a)
-> ([PgArr a] -> PgArr a)
-> Monoid (PgArr a)
[PgArr a] -> PgArr a
PgArr a -> PgArr a -> PgArr a
forall a. Semigroup (PgArr a)
forall a. PgArr a
forall a.
Semigroup a =>
a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
forall a. [PgArr a] -> PgArr a
forall a. PgArr a -> PgArr a -> PgArr a
$cmempty :: forall a. PgArr a
mempty :: PgArr a
$cmappend :: forall a. PgArr a -> PgArr a -> PgArr a
mappend :: PgArr a -> PgArr a -> PgArr a
$cmconcat :: forall a. [PgArr a] -> PgArr a
mconcat :: [PgArr a] -> PgArr a
Monoid
#ifdef MK_HASHABLE
    , Hashable )
#else
    )
#endif
#ifdef MK_ARBITRARY
  deriving newtype Arbitrary
#endif
#ifdef MK_FLAT
  deriving newtype Flat
#endif

instance (FromField a, Typeable a) => FromField (PgTag s (PgArr a)) where
  fromField :: FieldParser (PgTag s (PgArr a))
fromField = ((PGArray (Maybe a) -> PgTag s (PgArr a))
-> Conversion (PGArray (Maybe a)) -> Conversion (PgTag s (PgArr a))
forall a b. (a -> b) -> Conversion a -> Conversion b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall a b. Coercible a b => a -> b
forall a b. Coercible a b => a -> b
coerce @(PGArray (Maybe a))) (Conversion (PGArray (Maybe a)) -> Conversion (PgTag s (PgArr a)))
-> (Maybe ByteString -> Conversion (PGArray (Maybe a)))
-> Maybe ByteString
-> Conversion (PgTag s (PgArr a))
forall b c a. (b -> c) -> (a -> b) -> a -> c
.) ((Maybe ByteString -> Conversion (PGArray (Maybe a)))
 -> Maybe ByteString -> Conversion (PgTag s (PgArr a)))
-> (Field -> Maybe ByteString -> Conversion (PGArray (Maybe a)))
-> FieldParser (PgTag s (PgArr a))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Field -> Maybe ByteString -> Conversion (PGArray (Maybe a))
forall a. FromField a => FieldParser a
fromField

instance (ToField a, ToStar s) => ToField (PgTag (s :: Maybe NameNSK) (PgArr a)) where
  toField :: PgTag s (PgArr a) -> Action
toField (PgTag (PgArr [Maybe a]
xs)) =
    case PGArray (Maybe a) -> Action
forall a. ToField a => a -> Action
toField ([Maybe a] -> PGArray (Maybe a)
forall a. [a] -> PGArray a
PGArray [Maybe a]
xs) of
      Plain Builder
b -> Builder -> Action
Plain (Builder
b Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Builder
typ)
      Many [Action]
zs -> [Action] -> Action
Many ([Action]
zs [Action] -> [Action] -> [Action]
forall a. Semigroup a => a -> a -> a
<> [Builder -> Action
Plain Builder
typ])
      Action
x -> Action
x
    where
      typ :: Builder
typ = Text -> Builder
encodeUtf8Builder (Text -> Builder) -> Text -> Builder
forall a b. (a -> b) -> a -> b
$ Text -> (NameNS' Text -> Text) -> Maybe (NameNS' Text) -> Text
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Text
forall a. Monoid a => a
mempty ((Text
"::" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<>) (Text -> Text) -> (NameNS' Text -> Text) -> NameNS' Text -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
"[]") (Text -> Text) -> (NameNS' Text -> Text) -> NameNS' Text -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NameNS' Text -> Text
qualName) (Maybe (NameNS' Text) -> Text) -> Maybe (NameNS' Text) -> Text
forall a b. (a -> b) -> a -> b
$ forall (a :: Maybe NameNSK).
(SingKind (Maybe NameNSK), SingI a) =>
Demote (Maybe NameNSK)
forall {k} (a :: k). (SingKind k, SingI a) => Demote k
demote @s

instance ToJSON a => ToJSON (PgTag (s :: Maybe NameNSK) (PgArr a)) where
  toJSON :: PgTag s (PgArr a) -> Value
toJSON = PgArr a -> Value
forall a. ToJSON a => a -> Value
toJSON (PgArr a -> Value)
-> (PgTag s (PgArr a) -> PgArr a) -> PgTag s (PgArr a) -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PgTag s (PgArr a) -> PgArr a
forall {k} (s :: k) t. PgTag s t -> t
unPgTag

instance FromJSON a => FromJSON (PgTag (s :: Maybe NameNSK) (PgArr a)) where
  parseJSON :: Value -> Parser (PgTag s (PgArr a))
parseJSON = (PgArr a -> PgTag s (PgArr a))
-> Parser (PgArr a) -> Parser (PgTag s (PgArr a))
forall a b. (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap PgArr a -> PgTag s (PgArr a)
forall {k} (s :: k) t. t -> PgTag s t
PgTag (Parser (PgArr a) -> Parser (PgTag s (PgArr a)))
-> (Value -> Parser (PgArr a))
-> Value
-> Parser (PgTag s (PgArr a))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value -> Parser (PgArr a)
forall a. FromJSON a => Value -> Parser a
parseJSON

-- | Make 'PgArr' from list. All elements are lifted to 'Maybe'
pgArr' :: [a] -> PgArr a
pgArr' :: forall a. [a] -> PgArr a
pgArr' = [Maybe a] -> PgArr a
forall a. [Maybe a] -> PgArr a
PgArr ([Maybe a] -> PgArr a) -> ([a] -> [Maybe a]) -> [a] -> PgArr a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> Maybe a) -> [a] -> [Maybe a]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> Maybe a
forall a. a -> Maybe a
Just

-- | Make list from 'PgArr'. All empty ('Nothing') elements are omitted.
unPgArr' :: PgArr a -> [a]
unPgArr' :: forall a. PgArr a -> [a]
unPgArr' = [Maybe a] -> [a]
forall a. [Maybe a] -> [a]
catMaybes ([Maybe a] -> [a]) -> (PgArr a -> [Maybe a]) -> PgArr a -> [a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PgArr a -> [Maybe a]
forall a. PgArr a -> [Maybe a]
unPgArr

-- | 'Oid' but with JSON instances
newtype PgOid = PgOid { PgOid -> Oid
fromPgOid :: Oid }
  deriving stock (Int -> PgOid -> ShowS
[PgOid] -> ShowS
PgOid -> String
(Int -> PgOid -> ShowS)
-> (PgOid -> String) -> ([PgOid] -> ShowS) -> Show PgOid
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PgOid -> ShowS
showsPrec :: Int -> PgOid -> ShowS
$cshow :: PgOid -> String
show :: PgOid -> String
$cshowList :: [PgOid] -> ShowS
showList :: [PgOid] -> ShowS
Show, ReadPrec [PgOid]
ReadPrec PgOid
Int -> ReadS PgOid
ReadS [PgOid]
(Int -> ReadS PgOid)
-> ReadS [PgOid]
-> ReadPrec PgOid
-> ReadPrec [PgOid]
-> Read PgOid
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS PgOid
readsPrec :: Int -> ReadS PgOid
$creadList :: ReadS [PgOid]
readList :: ReadS [PgOid]
$creadPrec :: ReadPrec PgOid
readPrec :: ReadPrec PgOid
$creadListPrec :: ReadPrec [PgOid]
readListPrec :: ReadPrec [PgOid]
Read)
  deriving newtype (FieldParser PgOid
FieldParser PgOid -> FromField PgOid
forall a. FieldParser a -> FromField a
$cfromField :: FieldParser PgOid
fromField :: FieldParser PgOid
FromField, PgOid -> Action
(PgOid -> Action) -> ToField PgOid
forall a. (a -> Action) -> ToField a
$ctoField :: PgOid -> Action
toField :: PgOid -> Action
ToField)

instance Eq PgOid where PgOid
_ == :: PgOid -> PgOid -> Bool
== PgOid
_ = Bool
True
  -- we don't want to distinguish by OIDs but by names instead
  -- e.g. if we recreate some table or constraint

instance FromJSON PgOid where
  parseJSON :: Value -> Parser PgOid
parseJSON = (String -> PgOid) -> Parser String -> Parser PgOid
forall a b. (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Oid -> PgOid
PgOid (Oid -> PgOid) -> (String -> Oid) -> String -> PgOid
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Oid
forall a. Read a => String -> a
read (String -> Oid) -> ShowS -> String -> Oid
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (String
"Oid " String -> ShowS
forall a. [a] -> [a] -> [a]
++)) (Parser String -> Parser PgOid)
-> (Value -> Parser String) -> Value -> Parser PgOid
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value -> Parser String
forall a. FromJSON a => Value -> Parser a
parseJSON

instance ToJSON PgOid where
  toJSON :: PgOid -> Value
toJSON = String -> Value
forall a. ToJSON a => a -> Value
toJSON (String -> Value) -> (PgOid -> String) -> PgOid -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> ShowS
forall a. Int -> [a] -> [a]
L.drop Int
4 ShowS -> (PgOid -> String) -> PgOid -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Oid -> String
forall a. Show a => a -> String
P.show (Oid -> String) -> (PgOid -> Oid) -> PgOid -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PgOid -> Oid
fromPgOid

-- | Closed type family to check that field can be converted to or from Haskell type.
-- To make your types convertible to some database type use open type family 'CanConvert1'.
type family CanConvert sch (tab :: NameNSK) (fld::Symbol) (fd :: FldDefK) (t :: Type) :: Constraint where
  CanConvert sch tab fld fd t = CanConvertMaybe sch tab fld (FdType fd)
    (FdNullable fd) (TTypDef sch (FdType fd)) t

type ErrDesc tab fld tn t =
  ( TL.Text ""
  :$$: TL.Text "Table: " :<>: TL.ShowType tab
  :$$: TL.Text "DB Field name: " :<>: TL.ShowType fld
  :$$: TL.Text "DB Field type: " :<>: TL.ShowType tn
  :$$: TL.Text "Haskell Field type: " :<>: TL.ShowType t
  :$$: TL.Text "")

type ErrWithHead s tab fld tn t = TL.TypeError (TL.Text s :$$: ErrDesc tab fld tn t)

type family GuardConvert (ok :: Bool) sch tab fld tn td t t' err :: Constraint where
  GuardConvert 'True  sch tab fld tn td t t' err = CanConvert1 sch tab fld tn td t'
  GuardConvert 'False sch tab fld tn td t t' err = ErrWithHead err tab fld tn t

type family CanConvertMaybe sch (tab::NameNSK) (fld::Symbol) (tn::NameNSK)
  (nullable :: Bool) (td :: TypDefK) (t :: Type) :: Constraint where
  CanConvertMaybe sch tab fld tn nullable td (Maybe (Aggr fn t)) =
    ErrWithHead "You can't use Maybe for aggregates. Use Maybe inside Aggr"
      tab fld tn (Aggr fn t)
  CanConvertMaybe sch tab fld tn nullable td (Maybe (Aggr' fn t)) =
    ErrWithHead "You can't use Maybe for aggregates. Use Maybe inside Aggr'"
      tab fld tn (Aggr' fn t)
  CanConvertMaybe sch tab fld tn nullable td (Maybe t) = GuardConvert
    nullable sch tab fld tn td (Maybe t) t "You can't use Maybe for mandatory fields"
  -- aggregates --
  -- ACount<=>int64; AMin/AMax<=>N,S,B,D; ASum<=>N+int*->Int64|Double; AAvg<=>N+float8
  CanConvertMaybe sch tab fld tn nullable td (Aggr ACount Int64) = ()
  CanConvertMaybe sch tab fld tn nullable td (Aggr ACount t) =
    ErrWithHead "You have to use Int64 for Aggr ACount fields" tab fld tn t
  CanConvertMaybe sch tab fld tn nullable td (Aggr' ACount Int64) = ()
  CanConvertMaybe sch tab fld tn nullable td (Aggr' ACount t) =
    ErrWithHead "You have to use Int64 for Aggr' ACount fields" tab fld tn t
  CanConvertMaybe sch tab fld tn nullable td (Aggr AMin t) = GuardConvert
    (IsMaybe t && Elem' (TypCategory td) '["N","S","B","D"])
    sch tab fld tn td (Aggr AMin t) (UnMaybe t)
    "'Aggr AMin' is possible only for 'Maybe' values and numeric, text, bool or date fields"
  CanConvertMaybe sch tab fld tn nullable td (Aggr' AMin t) = GuardConvert
    (Elem' (TypCategory td) '["N","S","B","D"]) sch tab fld tn td (Aggr' AMin t) t
      "'Aggr' AMin' is possible only for numeric, text, bool or date fields"
  CanConvertMaybe sch tab fld tn nullable td (Aggr AMax t) = GuardConvert
    (IsMaybe t && Elem' (TypCategory td) '["N","S","B","D"])
    sch tab fld tn td (Aggr AMax t) (UnMaybe t)
    "'Aggr AMax' is possible only for 'Maybe' values and numeric, text, bool or date fields"
  CanConvertMaybe sch tab fld tn nullable td (Aggr' AMax t) = GuardConvert
    (Elem' (TypCategory td) '["N","S","B","D"])
    sch tab fld tn td (Aggr' AMax t) t
    "'Aggr' AMax' is possible only for numeric, text, bool or date fields"
  CanConvertMaybe sch tab fld tn nullable td (Aggr AAvg (Maybe Scientific)) =
    Assert (TypCategory td == "N") (ErrWithHead
      "'Aggr AAvg' is possible only for numeric fields"
      tab fld tn (Aggr AAvg (Maybe Scientific)))
  CanConvertMaybe sch tab fld tn nullable td (Aggr AAvg t) = ErrWithHead
    "You have to use `Maybe Scientific` for `Aggr AAvg` fields"
    tab fld tn (Aggr AAvg t)
  CanConvertMaybe sch tab fld tn nullable td (Aggr' AAvg (Maybe Scientific)) =
    Assert (TypCategory td == "N" && nullable) (ErrWithHead
      "'Aggr' AAvg (Maybe Scientific)' is possible only for nullable numeric fields"
      tab fld tn (Aggr' AAvg (Maybe Scientific)))
  CanConvertMaybe sch tab fld tn nullable td (Aggr' AAvg Scientific) =
    Assert (TypCategory td == "N" && Not nullable) (ErrWithHead
      "'Aggr' AAvg Scientific' is possible only for mandatory numeric fields"
      tab fld tn (Aggr' AAvg Scientific))
  CanConvertMaybe sch tab fld tn nullable td (Aggr' AAvg t) = ErrWithHead
    "You have to use `Scientific` (or `Maybe Scientific`) for `Aggr' AAvg` fields"
    tab fld tn (Aggr' AAvg t)
  CanConvertMaybe sch tab fld tn nullable td (Aggr ASum (Maybe Int64)) =
    ( Assert (TypCategory td == "N" && (NnsName tn == "int2" || NnsName tn == "int4"))
      (ErrWithHead "'Aggr ASum (Maybe Int64)' is possible only for 'int2/int4' fields"
        tab fld tn (Aggr ASum (Maybe Int64))))
  CanConvertMaybe sch tab fld tn nullable td (Aggr ASum (Maybe Scientific)) =
    ( Assert (TypCategory td == "N")
      (ErrWithHead "'Aggr ASum (Maybe Scientific)' is possible only for numeric fields"
        tab fld tn (Aggr ASum (Maybe Scientific))))
  CanConvertMaybe sch tab fld tn nullable td (Aggr ASum t) = ErrWithHead
    "You have to use `Maybe Int64` (or `Maybe Scientific`) for `Aggr ASum` fields"
    tab fld tn (Aggr ASum t)
  CanConvertMaybe sch tab fld tn nullable td (Aggr' ASum (Maybe Int64)) =
    ( Assert (nullable && TypCategory td == "N" && (NnsName tn == "int2" || NnsName tn == "int4"))
      (ErrWithHead "'Aggr' ASum (Maybe Int64)' is possible only for nullable 'int2/int4' fields"
        tab fld tn (Aggr' ASum (Maybe Int64))))
  CanConvertMaybe sch tab fld tn nullable td (Aggr' ASum (Maybe Scientific)) =
    ( Assert (nullable && TypCategory td == "N")
      (ErrWithHead "'Aggr' ASum (Maybe Scientific)' is possible only for nullable numeric fields"
        tab fld tn (Aggr' ASum (Maybe Scientific))))
  CanConvertMaybe sch tab fld tn nullable td (Aggr' ASum Int64) =
    ( Assert (Not nullable && TypCategory td == "N" && (NnsName tn == "int2" || NnsName tn == "int4"))
      (ErrWithHead "'Aggr' ASum Int64' is possible only for mandatory 'int2/int4' fields"
        tab fld tn (Aggr' ASum Int64)))
  CanConvertMaybe sch tab fld tn nullable td (Aggr' ASum Scientific) =
    ( Assert (Not nullable && TypCategory td == "N")
      (ErrWithHead "'Aggr' ASum (Scientific)' is possible only for mandatory numeric fields"
        tab fld tn (Aggr' ASum Scientific)))
  CanConvertMaybe sch tab fld tn nullable td (Aggr' ASum t) = ErrWithHead
    "You have to use `[Maybe] Int64` (or `[Maybe] Scientific`) for `Aggr' ASum` fields"
    tab fld tn (Aggr' ASum t)
  -- end aggregates --
  CanConvertMaybe sch tab fld tn nullable td t = GuardConvert (Not nullable)
    sch tab fld tn td t t "You have to use Maybe for nullable fields"

-- | Open mapping from a PostgreSQL type (non-nullable) to a Haskell type.
-- Add your own equations to this family to support extra pairings.
type family CanConvert1 sch (tab::NameNSK) (fld::Symbol) (tn::NameNSK) (td::TypDefK) t :: Constraint

type instance CanConvert1 sch tab fld tn ('TypDef "A" ('Just n) y) (PgArr t) =
  CanConvert1 sch tab fld n (TTypDef sch n) t

type instance CanConvert1 sch tab fld tn ('TypDef "B" x y) Bool = ()
type instance CanConvert1 sch tab fld (PGC "int2") ('TypDef "N" x y) Int16 = ()
type instance CanConvert1 sch tab fld (PGC "int4") ('TypDef "N" x y) Int32 = ()
type instance CanConvert1 sch tab fld (PGC "int8") ('TypDef "N" x y) Int64 = ()
type instance CanConvert1 sch tab fld (PGC "float4") ('TypDef "N" x y) Double = ()
type instance CanConvert1 sch tab fld (PGC "float8") ('TypDef "N" x y) Double = ()
-- type instance CanConvert1 sch tab fld (PGC "numeric") ('TypDef "N" x y) Double = ()
type instance CanConvert1 sch tab fld (PGC "oid") ('TypDef "N" x y) Int = ()
type instance CanConvert1 sch tab fld (PGC "numeric") ('TypDef "N" x y) (Fixed k) = () -- unsafe!
type instance CanConvert1 sch tab fld (PGC "int2") ('TypDef "N" x y) Scientific = ()
type instance CanConvert1 sch tab fld (PGC "int4") ('TypDef "N" x y) Scientific = ()
type instance CanConvert1 sch tab fld (PGC "int8") ('TypDef "N" x y) Scientific = ()
type instance CanConvert1 sch tab fld (PGC "float4") ('TypDef "N" x y) Scientific = ()
type instance CanConvert1 sch tab fld (PGC "float8") ('TypDef "N" x y) Scientific = ()
type instance CanConvert1 sch tab fld (PGC "numeric") ('TypDef "N" x y) Scientific = ()
type instance CanConvert1 sch tab fld (PGC "oid") ('TypDef "N" x y) PgOid = ()

type instance CanConvert1 sch tab fld (PGC "date") ('TypDef "D" x y) Day = ()
type instance CanConvert1 sch tab fld (PGC "time") ('TypDef "D" x y) TimeOfDay = ()
type instance CanConvert1 sch tab fld (PGC "timestamp") ('TypDef "D" x y) LocalTime = ()
type instance CanConvert1 sch tab fld (PGC "timestamptz") ('TypDef "D" x y) ZonedTime = ()
type instance CanConvert1 sch tab fld (PGC "timestamptz") ('TypDef "D" x y) UTCTime = ()

type instance CanConvert1 sch tab fld (PGC "char") ('TypDef "S" x y) PgChar = ()
type instance CanConvert1 sch tab fld (PGC "text") ('TypDef "S" x y) Text = ()
type instance CanConvert1 sch tab fld (PGC "varchar") ('TypDef "S" x y) Text = ()
type instance CanConvert1 sch tab fld (PGC "name") ('TypDef "S" x y) Text = ()
type instance CanConvert1 sch tab fld (PGC "citext") ('TypDef "S" Nothing '[]) (CI Text) = ()
type instance CanConvert1 sch tab fld ("public" ->> "citext") ('TypDef "S" Nothing '[]) (CI Text) = ()
type instance CanConvert1 sch tab fld (PGC "bytea") ('TypDef "U" x y) (Binary BS.ByteString) = ()
type instance CanConvert1 sch tab fld (PGC "bytea") ('TypDef "U" x y) (Binary BSL.ByteString) = ()
-- ^ Binary ByteString has no 'FromJSON'/'ToJSON' instances, so it can
-- be used only in the root table.
type instance CanConvert1 sch tab fld (PGC "jsonb") ('TypDef "U" x y) a = (FromJSON a, ToJSON a)
type instance CanConvert1 sch tab fld (PGC "json") ('TypDef "U" x y) a = (FromJSON a, ToJSON a)
type instance CanConvert1 sch tab fld (PGC "uuid") ('TypDef "U" x y) UUID = ()

type instance CanConvert1 sch tab fld n ('TypDef "E" 'Nothing es) (PGEnum sch n)
  = ( TTypDef sch n ~ 'TypDef "E" 'Nothing es
    , FromJSON (PGEnum sch n)
    , ToJSON (PGEnum sch n) )

-- | Annotates a value with schema/type information for DML codecs.
--
-- You can describe rows in two ways:
--
-- 1. Ordinary Haskell records with a 'GHC.Generics.Generic' instance.
-- 2. Symbol-labelled rows built from '(=:)' and chained with '(:.)' from
--    @postgresql-simple@ (re-exported from "PgSchema.DML").
--
-- 'PgTag' is analogous to 'Data.Tagged.Tagged' from the @tagged@ package, but
-- carries JSON (and related) instances suited to @pg-schema@.
--
-- Both representations can be mixed in one row.
--
-- Two pieces of syntax cooperate with 'PgTag':
--
-- * '(=:)' builds a 'PgTag' value (field name + payload).
-- @RequiredTypeArguments@ lets you avoid noisy explicit type application on the
-- field name: you write "name" =: "John" instead of @"name" =: "John".
-- * '(:=)' is the type-level spelling of the same idea (see the '(:=)' type
--   synonym below).
--
newtype PgTag s t = PgTag { forall {k} (s :: k) t. PgTag s t -> t
unPgTag :: t }
  deriving stock (Int -> PgTag s t -> ShowS
[PgTag s t] -> ShowS
PgTag s t -> String
(Int -> PgTag s t -> ShowS)
-> (PgTag s t -> String)
-> ([PgTag s t] -> ShowS)
-> Show (PgTag s t)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall k (s :: k) t. Show t => Int -> PgTag s t -> ShowS
forall k (s :: k) t. Show t => [PgTag s t] -> ShowS
forall k (s :: k) t. Show t => PgTag s t -> String
$cshowsPrec :: forall k (s :: k) t. Show t => Int -> PgTag s t -> ShowS
showsPrec :: Int -> PgTag s t -> ShowS
$cshow :: forall k (s :: k) t. Show t => PgTag s t -> String
show :: PgTag s t -> String
$cshowList :: forall k (s :: k) t. Show t => [PgTag s t] -> ShowS
showList :: [PgTag s t] -> ShowS
Show, ReadPrec [PgTag s t]
ReadPrec (PgTag s t)
Int -> ReadS (PgTag s t)
ReadS [PgTag s t]
(Int -> ReadS (PgTag s t))
-> ReadS [PgTag s t]
-> ReadPrec (PgTag s t)
-> ReadPrec [PgTag s t]
-> Read (PgTag s t)
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
forall k (s :: k) t. Read t => ReadPrec [PgTag s t]
forall k (s :: k) t. Read t => ReadPrec (PgTag s t)
forall k (s :: k) t. Read t => Int -> ReadS (PgTag s t)
forall k (s :: k) t. Read t => ReadS [PgTag s t]
$creadsPrec :: forall k (s :: k) t. Read t => Int -> ReadS (PgTag s t)
readsPrec :: Int -> ReadS (PgTag s t)
$creadList :: forall k (s :: k) t. Read t => ReadS [PgTag s t]
readList :: ReadS [PgTag s t]
$creadPrec :: forall k (s :: k) t. Read t => ReadPrec (PgTag s t)
readPrec :: ReadPrec (PgTag s t)
$creadListPrec :: forall k (s :: k) t. Read t => ReadPrec [PgTag s t]
readListPrec :: ReadPrec [PgTag s t]
Read, PgTag s t -> PgTag s t -> Bool
(PgTag s t -> PgTag s t -> Bool)
-> (PgTag s t -> PgTag s t -> Bool) -> Eq (PgTag s t)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall k (s :: k) t. Eq t => PgTag s t -> PgTag s t -> Bool
$c== :: forall k (s :: k) t. Eq t => PgTag s t -> PgTag s t -> Bool
== :: PgTag s t -> PgTag s t -> Bool
$c/= :: forall k (s :: k) t. Eq t => PgTag s t -> PgTag s t -> Bool
/= :: PgTag s t -> PgTag s t -> Bool
Eq, Eq (PgTag s t)
Eq (PgTag s t) =>
(PgTag s t -> PgTag s t -> Ordering)
-> (PgTag s t -> PgTag s t -> Bool)
-> (PgTag s t -> PgTag s t -> Bool)
-> (PgTag s t -> PgTag s t -> Bool)
-> (PgTag s t -> PgTag s t -> Bool)
-> (PgTag s t -> PgTag s t -> PgTag s t)
-> (PgTag s t -> PgTag s t -> PgTag s t)
-> Ord (PgTag s t)
PgTag s t -> PgTag s t -> Bool
PgTag s t -> PgTag s t -> Ordering
PgTag s t -> PgTag s t -> PgTag s t
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 k (s :: k) t. Ord t => Eq (PgTag s t)
forall k (s :: k) t. Ord t => PgTag s t -> PgTag s t -> Bool
forall k (s :: k) t. Ord t => PgTag s t -> PgTag s t -> Ordering
forall k (s :: k) t. Ord t => PgTag s t -> PgTag s t -> PgTag s t
$ccompare :: forall k (s :: k) t. Ord t => PgTag s t -> PgTag s t -> Ordering
compare :: PgTag s t -> PgTag s t -> Ordering
$c< :: forall k (s :: k) t. Ord t => PgTag s t -> PgTag s t -> Bool
< :: PgTag s t -> PgTag s t -> Bool
$c<= :: forall k (s :: k) t. Ord t => PgTag s t -> PgTag s t -> Bool
<= :: PgTag s t -> PgTag s t -> Bool
$c> :: forall k (s :: k) t. Ord t => PgTag s t -> PgTag s t -> Bool
> :: PgTag s t -> PgTag s t -> Bool
$c>= :: forall k (s :: k) t. Ord t => PgTag s t -> PgTag s t -> Bool
>= :: PgTag s t -> PgTag s t -> Bool
$cmax :: forall k (s :: k) t. Ord t => PgTag s t -> PgTag s t -> PgTag s t
max :: PgTag s t -> PgTag s t -> PgTag s t
$cmin :: forall k (s :: k) t. Ord t => PgTag s t -> PgTag s t -> PgTag s t
min :: PgTag s t -> PgTag s t -> PgTag s t
Ord, (forall a b. (a -> b) -> PgTag s a -> PgTag s b)
-> (forall a b. a -> PgTag s b -> PgTag s a) -> Functor (PgTag s)
forall k (s :: k) a b. a -> PgTag s b -> PgTag s a
forall k (s :: k) a b. (a -> b) -> PgTag s a -> PgTag s b
forall a b. a -> PgTag s b -> PgTag s a
forall a b. (a -> b) -> PgTag s a -> PgTag s b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall k (s :: k) a b. (a -> b) -> PgTag s a -> PgTag s b
fmap :: forall a b. (a -> b) -> PgTag s a -> PgTag s b
$c<$ :: forall k (s :: k) a b. a -> PgTag s b -> PgTag s a
<$ :: forall a b. a -> PgTag s b -> PgTag s a
Functor, (forall m. Monoid m => PgTag s m -> m)
-> (forall m a. Monoid m => (a -> m) -> PgTag s a -> m)
-> (forall m a. Monoid m => (a -> m) -> PgTag s a -> m)
-> (forall a b. (a -> b -> b) -> b -> PgTag s a -> b)
-> (forall a b. (a -> b -> b) -> b -> PgTag s a -> b)
-> (forall b a. (b -> a -> b) -> b -> PgTag s a -> b)
-> (forall b a. (b -> a -> b) -> b -> PgTag s a -> b)
-> (forall a. (a -> a -> a) -> PgTag s a -> a)
-> (forall a. (a -> a -> a) -> PgTag s a -> a)
-> (forall a. PgTag s a -> [a])
-> (forall a. PgTag s a -> Bool)
-> (forall a. PgTag s a -> Int)
-> (forall a. Eq a => a -> PgTag s a -> Bool)
-> (forall a. Ord a => PgTag s a -> a)
-> (forall a. Ord a => PgTag s a -> a)
-> (forall a. Num a => PgTag s a -> a)
-> (forall a. Num a => PgTag s a -> a)
-> Foldable (PgTag s)
forall a. Eq a => a -> PgTag s a -> Bool
forall a. Num a => PgTag s a -> a
forall a. Ord a => PgTag s a -> a
forall m. Monoid m => PgTag s m -> m
forall a. PgTag s a -> Bool
forall a. PgTag s a -> Int
forall a. PgTag s a -> [a]
forall a. (a -> a -> a) -> PgTag s a -> a
forall k (s :: k) a. Eq a => a -> PgTag s a -> Bool
forall k (s :: k) a. Num a => PgTag s a -> a
forall k (s :: k) a. Ord a => PgTag s a -> a
forall k (s :: k) m. Monoid m => PgTag s m -> m
forall k (s :: k) a. PgTag s a -> Bool
forall k (s :: k) a. PgTag s a -> Int
forall k (s :: k) a. PgTag s a -> [a]
forall k (s :: k) a. (a -> a -> a) -> PgTag s a -> a
forall k (s :: k) m a. Monoid m => (a -> m) -> PgTag s a -> m
forall k (s :: k) b a. (b -> a -> b) -> b -> PgTag s a -> b
forall k (s :: k) a b. (a -> b -> b) -> b -> PgTag s a -> b
forall m a. Monoid m => (a -> m) -> PgTag s a -> m
forall b a. (b -> a -> b) -> b -> PgTag s a -> b
forall a b. (a -> b -> b) -> b -> PgTag s 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
$cfold :: forall k (s :: k) m. Monoid m => PgTag s m -> m
fold :: forall m. Monoid m => PgTag s m -> m
$cfoldMap :: forall k (s :: k) m a. Monoid m => (a -> m) -> PgTag s a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> PgTag s a -> m
$cfoldMap' :: forall k (s :: k) m a. Monoid m => (a -> m) -> PgTag s a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> PgTag s a -> m
$cfoldr :: forall k (s :: k) a b. (a -> b -> b) -> b -> PgTag s a -> b
foldr :: forall a b. (a -> b -> b) -> b -> PgTag s a -> b
$cfoldr' :: forall k (s :: k) a b. (a -> b -> b) -> b -> PgTag s a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> PgTag s a -> b
$cfoldl :: forall k (s :: k) b a. (b -> a -> b) -> b -> PgTag s a -> b
foldl :: forall b a. (b -> a -> b) -> b -> PgTag s a -> b
$cfoldl' :: forall k (s :: k) b a. (b -> a -> b) -> b -> PgTag s a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> PgTag s a -> b
$cfoldr1 :: forall k (s :: k) a. (a -> a -> a) -> PgTag s a -> a
foldr1 :: forall a. (a -> a -> a) -> PgTag s a -> a
$cfoldl1 :: forall k (s :: k) a. (a -> a -> a) -> PgTag s a -> a
foldl1 :: forall a. (a -> a -> a) -> PgTag s a -> a
$ctoList :: forall k (s :: k) a. PgTag s a -> [a]
toList :: forall a. PgTag s a -> [a]
$cnull :: forall k (s :: k) a. PgTag s a -> Bool
null :: forall a. PgTag s a -> Bool
$clength :: forall k (s :: k) a. PgTag s a -> Int
length :: forall a. PgTag s a -> Int
$celem :: forall k (s :: k) a. Eq a => a -> PgTag s a -> Bool
elem :: forall a. Eq a => a -> PgTag s a -> Bool
$cmaximum :: forall k (s :: k) a. Ord a => PgTag s a -> a
maximum :: forall a. Ord a => PgTag s a -> a
$cminimum :: forall k (s :: k) a. Ord a => PgTag s a -> a
minimum :: forall a. Ord a => PgTag s a -> a
$csum :: forall k (s :: k) a. Num a => PgTag s a -> a
sum :: forall a. Num a => PgTag s a -> a
$cproduct :: forall k (s :: k) a. Num a => PgTag s a -> a
product :: forall a. Num a => PgTag s a -> a
Foldable, Functor (PgTag s)
Foldable (PgTag s)
(Functor (PgTag s), Foldable (PgTag s)) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> PgTag s a -> f (PgTag s b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    PgTag s (f a) -> f (PgTag s a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> PgTag s a -> m (PgTag s b))
-> (forall (m :: * -> *) a.
    Monad m =>
    PgTag s (m a) -> m (PgTag s a))
-> Traversable (PgTag s)
forall k (s :: k). Functor (PgTag s)
forall k (s :: k). Foldable (PgTag s)
forall k (s :: k) (m :: * -> *) a.
Monad m =>
PgTag s (m a) -> m (PgTag s a)
forall k (s :: k) (f :: * -> *) a.
Applicative f =>
PgTag s (f a) -> f (PgTag s a)
forall k (s :: k) (m :: * -> *) a b.
Monad m =>
(a -> m b) -> PgTag s a -> m (PgTag s b)
forall k (s :: k) (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> PgTag s a -> f (PgTag s b)
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 => PgTag s (m a) -> m (PgTag s a)
forall (f :: * -> *) a.
Applicative f =>
PgTag s (f a) -> f (PgTag s a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> PgTag s a -> m (PgTag s b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> PgTag s a -> f (PgTag s b)
$ctraverse :: forall k (s :: k) (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> PgTag s a -> f (PgTag s b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> PgTag s a -> f (PgTag s b)
$csequenceA :: forall k (s :: k) (f :: * -> *) a.
Applicative f =>
PgTag s (f a) -> f (PgTag s a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
PgTag s (f a) -> f (PgTag s a)
$cmapM :: forall k (s :: k) (m :: * -> *) a b.
Monad m =>
(a -> m b) -> PgTag s a -> m (PgTag s b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> PgTag s a -> m (PgTag s b)
$csequence :: forall k (s :: k) (m :: * -> *) a.
Monad m =>
PgTag s (m a) -> m (PgTag s a)
sequence :: forall (m :: * -> *) a. Monad m => PgTag s (m a) -> m (PgTag s a)
Traversable)
  deriving newtype (NonEmpty (PgTag s t) -> PgTag s t
PgTag s t -> PgTag s t -> PgTag s t
(PgTag s t -> PgTag s t -> PgTag s t)
-> (NonEmpty (PgTag s t) -> PgTag s t)
-> (forall b. Integral b => b -> PgTag s t -> PgTag s t)
-> Semigroup (PgTag s t)
forall b. Integral b => b -> PgTag s t -> PgTag s t
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
forall k (s :: k) t.
Semigroup t =>
NonEmpty (PgTag s t) -> PgTag s t
forall k (s :: k) t.
Semigroup t =>
PgTag s t -> PgTag s t -> PgTag s t
forall k (s :: k) t b.
(Semigroup t, Integral b) =>
b -> PgTag s t -> PgTag s t
$c<> :: forall k (s :: k) t.
Semigroup t =>
PgTag s t -> PgTag s t -> PgTag s t
<> :: PgTag s t -> PgTag s t -> PgTag s t
$csconcat :: forall k (s :: k) t.
Semigroup t =>
NonEmpty (PgTag s t) -> PgTag s t
sconcat :: NonEmpty (PgTag s t) -> PgTag s t
$cstimes :: forall k (s :: k) t b.
(Semigroup t, Integral b) =>
b -> PgTag s t -> PgTag s t
stimes :: forall b. Integral b => b -> PgTag s t -> PgTag s t
Semigroup, Semigroup (PgTag s t)
PgTag s t
Semigroup (PgTag s t) =>
PgTag s t
-> (PgTag s t -> PgTag s t -> PgTag s t)
-> ([PgTag s t] -> PgTag s t)
-> Monoid (PgTag s t)
[PgTag s t] -> PgTag s t
PgTag s t -> PgTag s t -> PgTag s t
forall a.
Semigroup a =>
a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
forall k (s :: k) t. Monoid t => Semigroup (PgTag s t)
forall k (s :: k) t. Monoid t => PgTag s t
forall k (s :: k) t. Monoid t => [PgTag s t] -> PgTag s t
forall k (s :: k) t.
Monoid t =>
PgTag s t -> PgTag s t -> PgTag s t
$cmempty :: forall k (s :: k) t. Monoid t => PgTag s t
mempty :: PgTag s t
$cmappend :: forall k (s :: k) t.
Monoid t =>
PgTag s t -> PgTag s t -> PgTag s t
mappend :: PgTag s t -> PgTag s t -> PgTag s t
$cmconcat :: forall k (s :: k) t. Monoid t => [PgTag s t] -> PgTag s t
mconcat :: [PgTag s t] -> PgTag s t
Monoid)

type s := t = PgTag s t
infixr 5 :=

(=:) :: forall b. forall a -> b -> a := b
=: :: forall {k} b. forall (a :: k) -> b -> a := b
(=:) _ = b -> a := b
forall a b. Coercible a b => a -> b
coerce
infixr 5 =: