PersistentTest

Documentation

data PersonGeneric backend

Constructors

Person

Fields

• personName :: !Text
• personAge :: !Int
• personColor :: !(Maybe Text)

Instances

PersistStore backend => ToBackendKey backend (PersonGeneric backend)

Methods

toBackendKey :: Key (PersonGeneric backend) -> BackendKey backend

fromBackendKey :: BackendKey backend -> Key (PersonGeneric backend)

Eq (BackendKey backend) => Eq (Key (PersonGeneric backend))

Methods

(==) :: Key (PersonGeneric backend) -> Key (PersonGeneric backend) -> Bool

(/=) :: Key (PersonGeneric backend) -> Key (PersonGeneric backend) -> Bool

Eq (PersonGeneric backend)

Methods

(==) :: PersonGeneric backend -> PersonGeneric backend -> Bool

(/=) :: PersonGeneric backend -> PersonGeneric backend -> Bool

Ord (BackendKey backend) => Ord (Key (PersonGeneric backend))

Methods

compare :: Key (PersonGeneric backend) -> Key (PersonGeneric backend) -> Ordering

(<) :: Key (PersonGeneric backend) -> Key (PersonGeneric backend) -> Bool

(<=) :: Key (PersonGeneric backend) -> Key (PersonGeneric backend) -> Bool

(>) :: Key (PersonGeneric backend) -> Key (PersonGeneric backend) -> Bool

(>=) :: Key (PersonGeneric backend) -> Key (PersonGeneric backend) -> Bool

max :: Key (PersonGeneric backend) -> Key (PersonGeneric backend) -> Key (PersonGeneric backend)

min :: Key (PersonGeneric backend) -> Key (PersonGeneric backend) -> Key (PersonGeneric backend)

Read (BackendKey backend) => Read (Key (PersonGeneric backend))

Methods

readsPrec :: Int -> ReadS (Key (PersonGeneric backend))

readList :: ReadS [Key (PersonGeneric backend)]

readPrec :: ReadPrec (Key (PersonGeneric backend))

readListPrec :: ReadPrec [Key (PersonGeneric backend)]

Show (BackendKey backend) => Show (Key (PersonGeneric backend))

Methods

showsPrec :: Int -> Key (PersonGeneric backend) -> ShowS

show :: Key (PersonGeneric backend) -> String

showList :: [Key (PersonGeneric backend)] -> ShowS

Show (PersonGeneric backend)

Methods

showsPrec :: Int -> PersonGeneric backend -> ShowS

show :: PersonGeneric backend -> String

showList :: [PersonGeneric backend] -> ShowS

ToJSON (BackendKey backend) => ToJSON (Key (PersonGeneric backend))

Methods

toJSON :: Key (PersonGeneric backend) -> Value

toEncoding :: Key (PersonGeneric backend) -> Encoding

toJSONList :: [Key (PersonGeneric backend)] -> Value

toEncodingList :: [Key (PersonGeneric backend)] -> Encoding

PersistStore backend => ToJSON (Entity (PersonGeneric backend))

Methods

toJSON :: Entity (PersonGeneric backend) -> Value

toEncoding :: Entity (PersonGeneric backend) -> Encoding

toJSONList :: [Entity (PersonGeneric backend)] -> Value

toEncodingList :: [Entity (PersonGeneric backend)] -> Encoding

PersistStore backend => ToJSON (PersonGeneric backend)

Methods

toJSON :: PersonGeneric backend -> Value

toEncoding :: PersonGeneric backend -> Encoding

toJSONList :: [PersonGeneric backend] -> Value

toEncodingList :: [PersonGeneric backend] -> Encoding

FromJSON (BackendKey backend) => FromJSON (Key (PersonGeneric backend))

Methods

parseJSON :: Value -> Parser (Key (PersonGeneric backend))

parseJSONList :: Value -> Parser [Key (PersonGeneric backend)]

PersistStore backend => FromJSON (Entity (PersonGeneric backend))

Methods

parseJSON :: Value -> Parser (Entity (PersonGeneric backend))

parseJSONList :: Value -> Parser [Entity (PersonGeneric backend)]

PersistStore backend => FromJSON (PersonGeneric backend)

Methods

parseJSON :: Value -> Parser (PersonGeneric backend)

parseJSONList :: Value -> Parser [PersonGeneric backend]

ToHttpApiData (BackendKey backend) => ToHttpApiData (Key (PersonGeneric backend))

Methods

toUrlPiece :: Key (PersonGeneric backend) -> Text

toEncodedUrlPiece :: Key (PersonGeneric backend) -> Builder

toHeader :: Key (PersonGeneric backend) -> ByteString

toQueryParam :: Key (PersonGeneric backend) -> Text

FromHttpApiData (BackendKey backend) => FromHttpApiData (Key (PersonGeneric backend))

Methods

parseUrlPiece :: Text -> Either Text (Key (PersonGeneric backend))

parseHeader :: ByteString -> Either Text (Key (PersonGeneric backend))

parseQueryParam :: Text -> Either Text (Key (PersonGeneric backend))

PathPiece (BackendKey backend) => PathPiece (Key (PersonGeneric backend))

Methods

fromPathPiece :: Text -> Maybe (Key (PersonGeneric backend))

toPathPiece :: Key (PersonGeneric backend) -> Text

PersistFieldSql (BackendKey backend) => PersistFieldSql (Key (PersonGeneric backend))

Methods

sqlType :: Proxy * (Key (PersonGeneric backend)) -> SqlType

PersistStore backend => PersistFieldSql (PersonGeneric backend)

Methods

sqlType :: Proxy * (PersonGeneric backend) -> SqlType

PersistStore backend => PersistEntity (PersonGeneric backend)

Associated Types

type PersistEntityBackend (PersonGeneric backend) :: *

data Key (PersonGeneric backend) :: *

data EntityField (PersonGeneric backend) a :: *

data Unique (PersonGeneric backend) :: *

Methods

keyToValues :: Key (PersonGeneric backend) -> [PersistValue]

keyFromValues :: [PersistValue] -> Either Text (Key (PersonGeneric backend))

persistIdField :: EntityField (PersonGeneric backend) (Key (PersonGeneric backend))

entityDef :: Monad m => m (PersonGeneric backend) -> EntityDef

persistFieldDef :: EntityField (PersonGeneric backend) typ -> FieldDef

toPersistFields :: PersonGeneric backend -> [SomePersistField]

fromPersistValues :: [PersistValue] -> Either Text (PersonGeneric backend)

persistUniqueKeys :: PersonGeneric backend -> [Unique (PersonGeneric backend)]

persistUniqueToFieldNames :: Unique (PersonGeneric backend) -> [(HaskellName, DBName)]

persistUniqueToValues :: Unique (PersonGeneric backend) -> [PersistValue]

fieldLens :: EntityField (PersonGeneric backend) field -> forall (f :: * -> *). Functor f => (field -> f field) -> Entity (PersonGeneric backend) -> f (Entity (PersonGeneric backend))

PersistField (BackendKey backend) => PersistField (Key (PersonGeneric backend))

Methods

toPersistValue :: Key (PersonGeneric backend) -> PersistValue

fromPersistValue :: PersistValue -> Either Text (Key (PersonGeneric backend))

PersistStore backend => PersistField (PersonGeneric backend)

Methods

toPersistValue :: PersonGeneric backend -> PersistValue

fromPersistValue :: PersistValue -> Either Text (PersonGeneric backend)

(PersistQuery backend, (~) * (PersistEntityBackend (PersonGeneric backend)) (BaseBackend backend)) => DeleteCascade (PersonGeneric backend) backend

Methods

deleteCascade :: MonadIO m => Key (PersonGeneric backend) -> ReaderT * backend m ()

data Unique (PersonGeneric backend)

data Unique (PersonGeneric backend) = PersonNameKey Text

data EntityField (PersonGeneric backend)

data EntityField (PersonGeneric backend) where

• PersonId :: EntityField (PersonGeneric backend) typ
• PersonName :: EntityField (PersonGeneric backend) typ
• PersonAge :: EntityField (PersonGeneric backend) typ
• PersonColor :: EntityField (PersonGeneric backend) typ

data Key (PersonGeneric backend)

data Key (PersonGeneric backend) = PersonKey {

• unPersonKey :: BackendKey backend

}

type PersistEntityBackend (PersonGeneric backend)

type PersistEntityBackend (PersonGeneric backend) = backend

type Person = PersonGeneric SqlBackend

type PersonId = Key Person

data Person1Generic backend

Constructors

Person1

Fields

• person1Name :: !Text
• person1Age :: !Int

Instances

PersistStore backend => ToBackendKey backend (Person1Generic backend)

Methods

toBackendKey :: Key (Person1Generic backend) -> BackendKey backend

fromBackendKey :: BackendKey backend -> Key (Person1Generic backend)

Eq (BackendKey backend) => Eq (Key (Person1Generic backend))

Methods

(==) :: Key (Person1Generic backend) -> Key (Person1Generic backend) -> Bool

(/=) :: Key (Person1Generic backend) -> Key (Person1Generic backend) -> Bool

Ord (BackendKey backend) => Ord (Key (Person1Generic backend))

Methods

compare :: Key (Person1Generic backend) -> Key (Person1Generic backend) -> Ordering

(<) :: Key (Person1Generic backend) -> Key (Person1Generic backend) -> Bool

(<=) :: Key (Person1Generic backend) -> Key (Person1Generic backend) -> Bool

(>) :: Key (Person1Generic backend) -> Key (Person1Generic backend) -> Bool

(>=) :: Key (Person1Generic backend) -> Key (Person1Generic backend) -> Bool

max :: Key (Person1Generic backend) -> Key (Person1Generic backend) -> Key (Person1Generic backend)

min :: Key (Person1Generic backend) -> Key (Person1Generic backend) -> Key (Person1Generic backend)

Read (BackendKey backend) => Read (Key (Person1Generic backend))

Methods

readsPrec :: Int -> ReadS (Key (Person1Generic backend))

readList :: ReadS [Key (Person1Generic backend)]

readPrec :: ReadPrec (Key (Person1Generic backend))

readListPrec :: ReadPrec [Key (Person1Generic backend)]

Show (BackendKey backend) => Show (Key (Person1Generic backend))

Methods

showsPrec :: Int -> Key (Person1Generic backend) -> ShowS

show :: Key (Person1Generic backend) -> String

showList :: [Key (Person1Generic backend)] -> ShowS

ToJSON (BackendKey backend) => ToJSON (Key (Person1Generic backend))

Methods

toJSON :: Key (Person1Generic backend) -> Value

toEncoding :: Key (Person1Generic backend) -> Encoding

toJSONList :: [Key (Person1Generic backend)] -> Value

toEncodingList :: [Key (Person1Generic backend)] -> Encoding

FromJSON (BackendKey backend) => FromJSON (Key (Person1Generic backend))

Methods

parseJSON :: Value -> Parser (Key (Person1Generic backend))

parseJSONList :: Value -> Parser [Key (Person1Generic backend)]

ToHttpApiData (BackendKey backend) => ToHttpApiData (Key (Person1Generic backend))

Methods

toUrlPiece :: Key (Person1Generic backend) -> Text

toEncodedUrlPiece :: Key (Person1Generic backend) -> Builder

toHeader :: Key (Person1Generic backend) -> ByteString

toQueryParam :: Key (Person1Generic backend) -> Text

FromHttpApiData (BackendKey backend) => FromHttpApiData (Key (Person1Generic backend))

Methods

parseUrlPiece :: Text -> Either Text (Key (Person1Generic backend))

parseHeader :: ByteString -> Either Text (Key (Person1Generic backend))

parseQueryParam :: Text -> Either Text (Key (Person1Generic backend))

PathPiece (BackendKey backend) => PathPiece (Key (Person1Generic backend))

Methods

fromPathPiece :: Text -> Maybe (Key (Person1Generic backend))

toPathPiece :: Key (Person1Generic backend) -> Text

PersistFieldSql (BackendKey backend) => PersistFieldSql (Key (Person1Generic backend))

Methods

sqlType :: Proxy * (Key (Person1Generic backend)) -> SqlType

PersistStore backend => PersistFieldSql (Person1Generic backend)

Methods

sqlType :: Proxy * (Person1Generic backend) -> SqlType

PersistStore backend => PersistEntity (Person1Generic backend)

Associated Types

type PersistEntityBackend (Person1Generic backend) :: *

data Key (Person1Generic backend) :: *

data EntityField (Person1Generic backend) a :: *

data Unique (Person1Generic backend) :: *

Methods

keyToValues :: Key (Person1Generic backend) -> [PersistValue]

keyFromValues :: [PersistValue] -> Either Text (Key (Person1Generic backend))

persistIdField :: EntityField (Person1Generic backend) (Key (Person1Generic backend))

entityDef :: Monad m => m (Person1Generic backend) -> EntityDef

persistFieldDef :: EntityField (Person1Generic backend) typ -> FieldDef

toPersistFields :: Person1Generic backend -> [SomePersistField]

fromPersistValues :: [PersistValue] -> Either Text (Person1Generic backend)

persistUniqueKeys :: Person1Generic backend -> [Unique (Person1Generic backend)]

persistUniqueToFieldNames :: Unique (Person1Generic backend) -> [(HaskellName, DBName)]

persistUniqueToValues :: Unique (Person1Generic backend) -> [PersistValue]

fieldLens :: EntityField (Person1Generic backend) field -> forall (f :: * -> *). Functor f => (field -> f field) -> Entity (Person1Generic backend) -> f (Entity (Person1Generic backend))

PersistField (BackendKey backend) => PersistField (Key (Person1Generic backend))

Methods

toPersistValue :: Key (Person1Generic backend) -> PersistValue

fromPersistValue :: PersistValue -> Either Text (Key (Person1Generic backend))

PersistStore backend => PersistField (Person1Generic backend)

Methods

toPersistValue :: Person1Generic backend -> PersistValue

fromPersistValue :: PersistValue -> Either Text (Person1Generic backend)

(PersistQuery backend, (~) * (PersistEntityBackend (Person1Generic backend)) (BaseBackend backend)) => DeleteCascade (Person1Generic backend) backend

Methods

deleteCascade :: MonadIO m => Key (Person1Generic backend) -> ReaderT * backend m ()

data Unique (Person1Generic backend)

data Unique (Person1Generic backend)

data EntityField (Person1Generic backend)

data EntityField (Person1Generic backend) where

• Person1Id :: EntityField (Person1Generic backend) typ
• Person1Name :: EntityField (Person1Generic backend) typ
• Person1Age :: EntityField (Person1Generic backend) typ

data Key (Person1Generic backend)

data Key (Person1Generic backend) = Person1Key {

• unPerson1Key :: BackendKey backend

}

type PersistEntityBackend (Person1Generic backend)

type PersistEntityBackend (Person1Generic backend) = backend

type Person1 = Person1Generic SqlBackend

type Person1Id = Key Person1

data PersonMaybeAgeGeneric backend

Constructors

PersonMaybeAge

Fields

• personMaybeAgeName :: !Text
• personMaybeAgeAge :: !(Maybe Int)

Instances

PersistStore backend => ToBackendKey backend (PersonMaybeAgeGeneric backend)

Methods

toBackendKey :: Key (PersonMaybeAgeGeneric backend) -> BackendKey backend

fromBackendKey :: BackendKey backend -> Key (PersonMaybeAgeGeneric backend)

Eq (BackendKey backend) => Eq (Key (PersonMaybeAgeGeneric backend))

Methods

(==) :: Key (PersonMaybeAgeGeneric backend) -> Key (PersonMaybeAgeGeneric backend) -> Bool

(/=) :: Key (PersonMaybeAgeGeneric backend) -> Key (PersonMaybeAgeGeneric backend) -> Bool

Ord (BackendKey backend) => Ord (Key (PersonMaybeAgeGeneric backend))

Methods

compare :: Key (PersonMaybeAgeGeneric backend) -> Key (PersonMaybeAgeGeneric backend) -> Ordering

(<) :: Key (PersonMaybeAgeGeneric backend) -> Key (PersonMaybeAgeGeneric backend) -> Bool

(<=) :: Key (PersonMaybeAgeGeneric backend) -> Key (PersonMaybeAgeGeneric backend) -> Bool

(>) :: Key (PersonMaybeAgeGeneric backend) -> Key (PersonMaybeAgeGeneric backend) -> Bool

(>=) :: Key (PersonMaybeAgeGeneric backend) -> Key (PersonMaybeAgeGeneric backend) -> Bool

max :: Key (PersonMaybeAgeGeneric backend) -> Key (PersonMaybeAgeGeneric backend) -> Key (PersonMaybeAgeGeneric backend)

min :: Key (PersonMaybeAgeGeneric backend) -> Key (PersonMaybeAgeGeneric backend) -> Key (PersonMaybeAgeGeneric backend)

Read (BackendKey backend) => Read (Key (PersonMaybeAgeGeneric backend))

Methods

readsPrec :: Int -> ReadS (Key (PersonMaybeAgeGeneric backend))

readList :: ReadS [Key (PersonMaybeAgeGeneric backend)]

readPrec :: ReadPrec (Key (PersonMaybeAgeGeneric backend))

readListPrec :: ReadPrec [Key (PersonMaybeAgeGeneric backend)]

Show (BackendKey backend) => Show (Key (PersonMaybeAgeGeneric backend))

Methods

showsPrec :: Int -> Key (PersonMaybeAgeGeneric backend) -> ShowS

show :: Key (PersonMaybeAgeGeneric backend) -> String

showList :: [Key (PersonMaybeAgeGeneric backend)] -> ShowS

ToJSON (BackendKey backend) => ToJSON (Key (PersonMaybeAgeGeneric backend))

Methods

toJSON :: Key (PersonMaybeAgeGeneric backend) -> Value

toEncoding :: Key (PersonMaybeAgeGeneric backend) -> Encoding

toJSONList :: [Key (PersonMaybeAgeGeneric backend)] -> Value

toEncodingList :: [Key (PersonMaybeAgeGeneric backend)] -> Encoding

FromJSON (BackendKey backend) => FromJSON (Key (PersonMaybeAgeGeneric backend))

Methods

parseJSON :: Value -> Parser (Key (PersonMaybeAgeGeneric backend))

parseJSONList :: Value -> Parser [Key (PersonMaybeAgeGeneric backend)]

ToHttpApiData (BackendKey backend) => ToHttpApiData (Key (PersonMaybeAgeGeneric backend))

Methods

toUrlPiece :: Key (PersonMaybeAgeGeneric backend) -> Text

toEncodedUrlPiece :: Key (PersonMaybeAgeGeneric backend) -> Builder

toHeader :: Key (PersonMaybeAgeGeneric backend) -> ByteString

toQueryParam :: Key (PersonMaybeAgeGeneric backend) -> Text

FromHttpApiData (BackendKey backend) => FromHttpApiData (Key (PersonMaybeAgeGeneric backend))

Methods

parseUrlPiece :: Text -> Either Text (Key (PersonMaybeAgeGeneric backend))

parseHeader :: ByteString -> Either Text (Key (PersonMaybeAgeGeneric backend))

parseQueryParam :: Text -> Either Text (Key (PersonMaybeAgeGeneric backend))

PathPiece (BackendKey backend) => PathPiece (Key (PersonMaybeAgeGeneric backend))

Methods

fromPathPiece :: Text -> Maybe (Key (PersonMaybeAgeGeneric backend))

toPathPiece :: Key (PersonMaybeAgeGeneric backend) -> Text

PersistFieldSql (BackendKey backend) => PersistFieldSql (Key (PersonMaybeAgeGeneric backend))

Methods

sqlType :: Proxy * (Key (PersonMaybeAgeGeneric backend)) -> SqlType

PersistStore backend => PersistFieldSql (PersonMaybeAgeGeneric backend)

Methods

sqlType :: Proxy * (PersonMaybeAgeGeneric backend) -> SqlType

PersistStore backend => PersistEntity (PersonMaybeAgeGeneric backend)

Associated Types

type PersistEntityBackend (PersonMaybeAgeGeneric backend) :: *

data Key (PersonMaybeAgeGeneric backend) :: *

data EntityField (PersonMaybeAgeGeneric backend) a :: *

data Unique (PersonMaybeAgeGeneric backend) :: *

Methods

keyToValues :: Key (PersonMaybeAgeGeneric backend) -> [PersistValue]

keyFromValues :: [PersistValue] -> Either Text (Key (PersonMaybeAgeGeneric backend))

persistIdField :: EntityField (PersonMaybeAgeGeneric backend) (Key (PersonMaybeAgeGeneric backend))

entityDef :: Monad m => m (PersonMaybeAgeGeneric backend) -> EntityDef

persistFieldDef :: EntityField (PersonMaybeAgeGeneric backend) typ -> FieldDef

toPersistFields :: PersonMaybeAgeGeneric backend -> [SomePersistField]

fromPersistValues :: [PersistValue] -> Either Text (PersonMaybeAgeGeneric backend)

persistUniqueKeys :: PersonMaybeAgeGeneric backend -> [Unique (PersonMaybeAgeGeneric backend)]

persistUniqueToFieldNames :: Unique (PersonMaybeAgeGeneric backend) -> [(HaskellName, DBName)]

persistUniqueToValues :: Unique (PersonMaybeAgeGeneric backend) -> [PersistValue]

fieldLens :: EntityField (PersonMaybeAgeGeneric backend) field -> forall (f :: * -> *). Functor f => (field -> f field) -> Entity (PersonMaybeAgeGeneric backend) -> f (Entity (PersonMaybeAgeGeneric backend))

PersistField (BackendKey backend) => PersistField (Key (PersonMaybeAgeGeneric backend))

Methods

toPersistValue :: Key (PersonMaybeAgeGeneric backend) -> PersistValue

fromPersistValue :: PersistValue -> Either Text (Key (PersonMaybeAgeGeneric backend))

PersistStore backend => PersistField (PersonMaybeAgeGeneric backend)

Methods

toPersistValue :: PersonMaybeAgeGeneric backend -> PersistValue

fromPersistValue :: PersistValue -> Either Text (PersonMaybeAgeGeneric backend)

(PersistQuery backend, (~) * (PersistEntityBackend (PersonMaybeAgeGeneric backend)) (BaseBackend backend)) => DeleteCascade (PersonMaybeAgeGeneric backend) backend

Methods

deleteCascade :: MonadIO m => Key (PersonMaybeAgeGeneric backend) -> ReaderT * backend m ()

data Unique (PersonMaybeAgeGeneric backend)

data Unique (PersonMaybeAgeGeneric backend)

data EntityField (PersonMaybeAgeGeneric backend)

data EntityField (PersonMaybeAgeGeneric backend) where

• PersonMaybeAgeId :: EntityField (PersonMaybeAgeGeneric backend) typ
• PersonMaybeAgeName :: EntityField (PersonMaybeAgeGeneric backend) typ
• PersonMaybeAgeAge :: EntityField (PersonMaybeAgeGeneric backend) typ

data Key (PersonMaybeAgeGeneric backend)

data Key (PersonMaybeAgeGeneric backend) = PersonMaybeAgeKey {

• unPersonMaybeAgeKey :: BackendKey backend

}

type PersistEntityBackend (PersonMaybeAgeGeneric backend)

type PersistEntityBackend (PersonMaybeAgeGeneric backend) = backend

type PersonMaybeAge = PersonMaybeAgeGeneric SqlBackend

type PersonMaybeAgeId = Key PersonMaybeAge

data PersonMayGeneric backend

Constructors

PersonMay

Fields

• personMayName :: !(Maybe Text)
• personMayColor :: !(Maybe Text)

Instances

PersistStore backend => ToBackendKey backend (PersonMayGeneric backend)

Methods

toBackendKey :: Key (PersonMayGeneric backend) -> BackendKey backend

fromBackendKey :: BackendKey backend -> Key (PersonMayGeneric backend)

Eq (BackendKey backend) => Eq (Key (PersonMayGeneric backend))

Methods

(==) :: Key (PersonMayGeneric backend) -> Key (PersonMayGeneric backend) -> Bool

(/=) :: Key (PersonMayGeneric backend) -> Key (PersonMayGeneric backend) -> Bool

Eq (PersonMayGeneric backend)

Methods

(==) :: PersonMayGeneric backend -> PersonMayGeneric backend -> Bool

(/=) :: PersonMayGeneric backend -> PersonMayGeneric backend -> Bool

Ord (BackendKey backend) => Ord (Key (PersonMayGeneric backend))

Methods

compare :: Key (PersonMayGeneric backend) -> Key (PersonMayGeneric backend) -> Ordering

(<) :: Key (PersonMayGeneric backend) -> Key (PersonMayGeneric backend) -> Bool

(<=) :: Key (PersonMayGeneric backend) -> Key (PersonMayGeneric backend) -> Bool

(>) :: Key (PersonMayGeneric backend) -> Key (PersonMayGeneric backend) -> Bool

(>=) :: Key (PersonMayGeneric backend) -> Key (PersonMayGeneric backend) -> Bool

max :: Key (PersonMayGeneric backend) -> Key (PersonMayGeneric backend) -> Key (PersonMayGeneric backend)

min :: Key (PersonMayGeneric backend) -> Key (PersonMayGeneric backend) -> Key (PersonMayGeneric backend)

Read (BackendKey backend) => Read (Key (PersonMayGeneric backend))

Methods

readsPrec :: Int -> ReadS (Key (PersonMayGeneric backend))

readList :: ReadS [Key (PersonMayGeneric backend)]

readPrec :: ReadPrec (Key (PersonMayGeneric backend))

readListPrec :: ReadPrec [Key (PersonMayGeneric backend)]

Show (BackendKey backend) => Show (Key (PersonMayGeneric backend))

Methods

showsPrec :: Int -> Key (PersonMayGeneric backend) -> ShowS

show :: Key (PersonMayGeneric backend) -> String

showList :: [Key (PersonMayGeneric backend)] -> ShowS

Show (PersonMayGeneric backend)

Methods

showsPrec :: Int -> PersonMayGeneric backend -> ShowS

show :: PersonMayGeneric backend -> String

showList :: [PersonMayGeneric backend] -> ShowS

ToJSON (BackendKey backend) => ToJSON (Key (PersonMayGeneric backend))

Methods

toJSON :: Key (PersonMayGeneric backend) -> Value

toEncoding :: Key (PersonMayGeneric backend) -> Encoding

toJSONList :: [Key (PersonMayGeneric backend)] -> Value

toEncodingList :: [Key (PersonMayGeneric backend)] -> Encoding

PersistStore backend => ToJSON (Entity (PersonMayGeneric backend))

Methods

toJSON :: Entity (PersonMayGeneric backend) -> Value

toEncoding :: Entity (PersonMayGeneric backend) -> Encoding

toJSONList :: [Entity (PersonMayGeneric backend)] -> Value

toEncodingList :: [Entity (PersonMayGeneric backend)] -> Encoding

PersistStore backend => ToJSON (PersonMayGeneric backend)

Methods

toJSON :: PersonMayGeneric backend -> Value

toEncoding :: PersonMayGeneric backend -> Encoding

toJSONList :: [PersonMayGeneric backend] -> Value

toEncodingList :: [PersonMayGeneric backend] -> Encoding

FromJSON (BackendKey backend) => FromJSON (Key (PersonMayGeneric backend))

Methods

parseJSON :: Value -> Parser (Key (PersonMayGeneric backend))

parseJSONList :: Value -> Parser [Key (PersonMayGeneric backend)]

PersistStore backend => FromJSON (Entity (PersonMayGeneric backend))

Methods

parseJSON :: Value -> Parser (Entity (PersonMayGeneric backend))

parseJSONList :: Value -> Parser [Entity (PersonMayGeneric backend)]

PersistStore backend => FromJSON (PersonMayGeneric backend)

Methods

parseJSON :: Value -> Parser (PersonMayGeneric backend)

parseJSONList :: Value -> Parser [PersonMayGeneric backend]

ToHttpApiData (BackendKey backend) => ToHttpApiData (Key (PersonMayGeneric backend))

Methods

toUrlPiece :: Key (PersonMayGeneric backend) -> Text

toEncodedUrlPiece :: Key (PersonMayGeneric backend) -> Builder

toHeader :: Key (PersonMayGeneric backend) -> ByteString

toQueryParam :: Key (PersonMayGeneric backend) -> Text

FromHttpApiData (BackendKey backend) => FromHttpApiData (Key (PersonMayGeneric backend))

Methods

parseUrlPiece :: Text -> Either Text (Key (PersonMayGeneric backend))

parseHeader :: ByteString -> Either Text (Key (PersonMayGeneric backend))

parseQueryParam :: Text -> Either Text (Key (PersonMayGeneric backend))

PathPiece (BackendKey backend) => PathPiece (Key (PersonMayGeneric backend))

Methods

fromPathPiece :: Text -> Maybe (Key (PersonMayGeneric backend))

toPathPiece :: Key (PersonMayGeneric backend) -> Text

PersistFieldSql (BackendKey backend) => PersistFieldSql (Key (PersonMayGeneric backend))

Methods

sqlType :: Proxy * (Key (PersonMayGeneric backend)) -> SqlType

PersistStore backend => PersistFieldSql (PersonMayGeneric backend)

Methods

sqlType :: Proxy * (PersonMayGeneric backend) -> SqlType

PersistStore backend => PersistEntity (PersonMayGeneric backend)

Associated Types

type PersistEntityBackend (PersonMayGeneric backend) :: *

data Key (PersonMayGeneric backend) :: *

data EntityField (PersonMayGeneric backend) a :: *

data Unique (PersonMayGeneric backend) :: *

Methods

keyToValues :: Key (PersonMayGeneric backend) -> [PersistValue]

keyFromValues :: [PersistValue] -> Either Text (Key (PersonMayGeneric backend))

persistIdField :: EntityField (PersonMayGeneric backend) (Key (PersonMayGeneric backend))

entityDef :: Monad m => m (PersonMayGeneric backend) -> EntityDef

persistFieldDef :: EntityField (PersonMayGeneric backend) typ -> FieldDef

toPersistFields :: PersonMayGeneric backend -> [SomePersistField]

fromPersistValues :: [PersistValue] -> Either Text (PersonMayGeneric backend)

persistUniqueKeys :: PersonMayGeneric backend -> [Unique (PersonMayGeneric backend)]

persistUniqueToFieldNames :: Unique (PersonMayGeneric backend) -> [(HaskellName, DBName)]

persistUniqueToValues :: Unique (PersonMayGeneric backend) -> [PersistValue]

fieldLens :: EntityField (PersonMayGeneric backend) field -> forall (f :: * -> *). Functor f => (field -> f field) -> Entity (PersonMayGeneric backend) -> f (Entity (PersonMayGeneric backend))

PersistField (BackendKey backend) => PersistField (Key (PersonMayGeneric backend))

Methods

toPersistValue :: Key (PersonMayGeneric backend) -> PersistValue

fromPersistValue :: PersistValue -> Either Text (Key (PersonMayGeneric backend))

PersistStore backend => PersistField (PersonMayGeneric backend)

Methods

toPersistValue :: PersonMayGeneric backend -> PersistValue

fromPersistValue :: PersistValue -> Either Text (PersonMayGeneric backend)

(PersistQuery backend, (~) * (PersistEntityBackend (PersonMayGeneric backend)) (BaseBackend backend)) => DeleteCascade (PersonMayGeneric backend) backend

Methods

deleteCascade :: MonadIO m => Key (PersonMayGeneric backend) -> ReaderT * backend m ()

data Unique (PersonMayGeneric backend)

data Unique (PersonMayGeneric backend)

data EntityField (PersonMayGeneric backend)

data EntityField (PersonMayGeneric backend) where

• PersonMayId :: EntityField (PersonMayGeneric backend) typ
• PersonMayName :: EntityField (PersonMayGeneric backend) typ
• PersonMayColor :: EntityField (PersonMayGeneric backend) typ

data Key (PersonMayGeneric backend)

data Key (PersonMayGeneric backend) = PersonMayKey {

• unPersonMayKey :: BackendKey backend

}

type PersistEntityBackend (PersonMayGeneric backend)

type PersistEntityBackend (PersonMayGeneric backend) = backend

type PersonMay = PersonMayGeneric SqlBackend

type PersonMayId = Key PersonMay

data PetGeneric backend

Constructors

Pet

Fields

• petOwnerId :: !(Key (PersonGeneric backend))
• petName :: !Text
• petType :: !PetType

Instances

PersistStore backend => ToBackendKey backend (PetGeneric backend)

Methods

toBackendKey :: Key (PetGeneric backend) -> BackendKey backend

fromBackendKey :: BackendKey backend -> Key (PetGeneric backend)

Eq (BackendKey backend) => Eq (Key (PetGeneric backend))

Methods

(==) :: Key (PetGeneric backend) -> Key (PetGeneric backend) -> Bool

(/=) :: Key (PetGeneric backend) -> Key (PetGeneric backend) -> Bool

Eq (BackendKey backend) => Eq (PetGeneric backend)

Methods

(==) :: PetGeneric backend -> PetGeneric backend -> Bool

(/=) :: PetGeneric backend -> PetGeneric backend -> Bool

Ord (BackendKey backend) => Ord (Key (PetGeneric backend))

Methods

compare :: Key (PetGeneric backend) -> Key (PetGeneric backend) -> Ordering

(<) :: Key (PetGeneric backend) -> Key (PetGeneric backend) -> Bool

(<=) :: Key (PetGeneric backend) -> Key (PetGeneric backend) -> Bool

(>) :: Key (PetGeneric backend) -> Key (PetGeneric backend) -> Bool

(>=) :: Key (PetGeneric backend) -> Key (PetGeneric backend) -> Bool

max :: Key (PetGeneric backend) -> Key (PetGeneric backend) -> Key (PetGeneric backend)

min :: Key (PetGeneric backend) -> Key (PetGeneric backend) -> Key (PetGeneric backend)

Read (BackendKey backend) => Read (Key (PetGeneric backend))

Methods

readsPrec :: Int -> ReadS (Key (PetGeneric backend))

readList :: ReadS [Key (PetGeneric backend)]

readPrec :: ReadPrec (Key (PetGeneric backend))

readListPrec :: ReadPrec [Key (PetGeneric backend)]

Show (BackendKey backend) => Show (Key (PetGeneric backend))

Methods

showsPrec :: Int -> Key (PetGeneric backend) -> ShowS

show :: Key (PetGeneric backend) -> String

showList :: [Key (PetGeneric backend)] -> ShowS

Show (BackendKey backend) => Show (PetGeneric backend)

Methods

showsPrec :: Int -> PetGeneric backend -> ShowS

show :: PetGeneric backend -> String

showList :: [PetGeneric backend] -> ShowS

ToJSON (BackendKey backend) => ToJSON (Key (PetGeneric backend))

Methods

toJSON :: Key (PetGeneric backend) -> Value

toEncoding :: Key (PetGeneric backend) -> Encoding

toJSONList :: [Key (PetGeneric backend)] -> Value

toEncodingList :: [Key (PetGeneric backend)] -> Encoding

FromJSON (BackendKey backend) => FromJSON (Key (PetGeneric backend))

Methods

parseJSON :: Value -> Parser (Key (PetGeneric backend))

parseJSONList :: Value -> Parser [Key (PetGeneric backend)]

ToHttpApiData (BackendKey backend) => ToHttpApiData (Key (PetGeneric backend))

Methods

toUrlPiece :: Key (PetGeneric backend) -> Text

toEncodedUrlPiece :: Key (PetGeneric backend) -> Builder

toHeader :: Key (PetGeneric backend) -> ByteString

toQueryParam :: Key (PetGeneric backend) -> Text

FromHttpApiData (BackendKey backend) => FromHttpApiData (Key (PetGeneric backend))

Methods

parseUrlPiece :: Text -> Either Text (Key (PetGeneric backend))

parseHeader :: ByteString -> Either Text (Key (PetGeneric backend))

parseQueryParam :: Text -> Either Text (Key (PetGeneric backend))

PathPiece (BackendKey backend) => PathPiece (Key (PetGeneric backend))

Methods

fromPathPiece :: Text -> Maybe (Key (PetGeneric backend))

toPathPiece :: Key (PetGeneric backend) -> Text

PersistFieldSql (BackendKey backend) => PersistFieldSql (Key (PetGeneric backend))

Methods

sqlType :: Proxy * (Key (PetGeneric backend)) -> SqlType

PersistStore backend => PersistFieldSql (PetGeneric backend)

Methods

sqlType :: Proxy * (PetGeneric backend) -> SqlType

PersistStore backend => PersistEntity (PetGeneric backend)

Associated Types

type PersistEntityBackend (PetGeneric backend) :: *

data Key (PetGeneric backend) :: *

data EntityField (PetGeneric backend) a :: *

data Unique (PetGeneric backend) :: *

Methods

keyToValues :: Key (PetGeneric backend) -> [PersistValue]

keyFromValues :: [PersistValue] -> Either Text (Key (PetGeneric backend))

persistIdField :: EntityField (PetGeneric backend) (Key (PetGeneric backend))

entityDef :: Monad m => m (PetGeneric backend) -> EntityDef

persistFieldDef :: EntityField (PetGeneric backend) typ -> FieldDef

toPersistFields :: PetGeneric backend -> [SomePersistField]

fromPersistValues :: [PersistValue] -> Either Text (PetGeneric backend)

persistUniqueKeys :: PetGeneric backend -> [Unique (PetGeneric backend)]

persistUniqueToFieldNames :: Unique (PetGeneric backend) -> [(HaskellName, DBName)]

persistUniqueToValues :: Unique (PetGeneric backend) -> [PersistValue]

fieldLens :: EntityField (PetGeneric backend) field -> forall (f :: * -> *). Functor f => (field -> f field) -> Entity (PetGeneric backend) -> f (Entity (PetGeneric backend))

PersistField (BackendKey backend) => PersistField (Key (PetGeneric backend))

Methods

toPersistValue :: Key (PetGeneric backend) -> PersistValue

fromPersistValue :: PersistValue -> Either Text (Key (PetGeneric backend))

PersistStore backend => PersistField (PetGeneric backend)

Methods

toPersistValue :: PetGeneric backend -> PersistValue

fromPersistValue :: PersistValue -> Either Text (PetGeneric backend)

(PersistQuery backend, (~) * (PersistEntityBackend (PetGeneric backend)) (BaseBackend backend)) => DeleteCascade (PetGeneric backend) backend

Methods

deleteCascade :: MonadIO m => Key (PetGeneric backend) -> ReaderT * backend m ()

data Unique (PetGeneric backend)

data Unique (PetGeneric backend)

data EntityField (PetGeneric backend)

data EntityField (PetGeneric backend) where

• PetId :: EntityField (PetGeneric backend) typ
• PetOwnerId :: EntityField (PetGeneric backend) typ
• PetName :: EntityField (PetGeneric backend) typ
• PetType :: EntityField (PetGeneric backend) typ

data Key (PetGeneric backend)

data Key (PetGeneric backend) = PetKey {

• unPetKey :: BackendKey backend

}

type PersistEntityBackend (PetGeneric backend)

type PersistEntityBackend (PetGeneric backend) = backend

type Pet = PetGeneric SqlBackend

type PetId = Key Pet

data MaybeOwnedPetGeneric backend

Constructors

MaybeOwnedPet

Fields

• maybeOwnedPetOwnerId :: !(Maybe (Key (PersonGeneric backend)))
• maybeOwnedPetName :: !Text
• maybeOwnedPetType :: !PetType

Instances

PersistStore backend => ToBackendKey backend (MaybeOwnedPetGeneric backend)

Methods

toBackendKey :: Key (MaybeOwnedPetGeneric backend) -> BackendKey backend

fromBackendKey :: BackendKey backend -> Key (MaybeOwnedPetGeneric backend)

Eq (BackendKey backend) => Eq (Key (MaybeOwnedPetGeneric backend))

Methods

(==) :: Key (MaybeOwnedPetGeneric backend) -> Key (MaybeOwnedPetGeneric backend) -> Bool

(/=) :: Key (MaybeOwnedPetGeneric backend) -> Key (MaybeOwnedPetGeneric backend) -> Bool

Ord (BackendKey backend) => Ord (Key (MaybeOwnedPetGeneric backend))

Methods

compare :: Key (MaybeOwnedPetGeneric backend) -> Key (MaybeOwnedPetGeneric backend) -> Ordering

(<) :: Key (MaybeOwnedPetGeneric backend) -> Key (MaybeOwnedPetGeneric backend) -> Bool

(<=) :: Key (MaybeOwnedPetGeneric backend) -> Key (MaybeOwnedPetGeneric backend) -> Bool

(>) :: Key (MaybeOwnedPetGeneric backend) -> Key (MaybeOwnedPetGeneric backend) -> Bool

(>=) :: Key (MaybeOwnedPetGeneric backend) -> Key (MaybeOwnedPetGeneric backend) -> Bool

max :: Key (MaybeOwnedPetGeneric backend) -> Key (MaybeOwnedPetGeneric backend) -> Key (MaybeOwnedPetGeneric backend)

min :: Key (MaybeOwnedPetGeneric backend) -> Key (MaybeOwnedPetGeneric backend) -> Key (MaybeOwnedPetGeneric backend)

Read (BackendKey backend) => Read (Key (MaybeOwnedPetGeneric backend))

Methods

readsPrec :: Int -> ReadS (Key (MaybeOwnedPetGeneric backend))

readList :: ReadS [Key (MaybeOwnedPetGeneric backend)]

readPrec :: ReadPrec (Key (MaybeOwnedPetGeneric backend))

readListPrec :: ReadPrec [Key (MaybeOwnedPetGeneric backend)]

Show (BackendKey backend) => Show (Key (MaybeOwnedPetGeneric backend))

Methods

showsPrec :: Int -> Key (MaybeOwnedPetGeneric backend) -> ShowS

show :: Key (MaybeOwnedPetGeneric backend) -> String

showList :: [Key (MaybeOwnedPetGeneric backend)] -> ShowS

ToJSON (BackendKey backend) => ToJSON (Key (MaybeOwnedPetGeneric backend))

Methods

toJSON :: Key (MaybeOwnedPetGeneric backend) -> Value

toEncoding :: Key (MaybeOwnedPetGeneric backend) -> Encoding

toJSONList :: [Key (MaybeOwnedPetGeneric backend)] -> Value

toEncodingList :: [Key (MaybeOwnedPetGeneric backend)] -> Encoding

FromJSON (BackendKey backend) => FromJSON (Key (MaybeOwnedPetGeneric backend))

Methods

parseJSON :: Value -> Parser (Key (MaybeOwnedPetGeneric backend))

parseJSONList :: Value -> Parser [Key (MaybeOwnedPetGeneric backend)]

ToHttpApiData (BackendKey backend) => ToHttpApiData (Key (MaybeOwnedPetGeneric backend))

Methods

toUrlPiece :: Key (MaybeOwnedPetGeneric backend) -> Text

toEncodedUrlPiece :: Key (MaybeOwnedPetGeneric backend) -> Builder

toHeader :: Key (MaybeOwnedPetGeneric backend) -> ByteString

toQueryParam :: Key (MaybeOwnedPetGeneric backend) -> Text

FromHttpApiData (BackendKey backend) => FromHttpApiData (Key (MaybeOwnedPetGeneric backend))

Methods

parseUrlPiece :: Text -> Either Text (Key (MaybeOwnedPetGeneric backend))

parseHeader :: ByteString -> Either Text (Key (MaybeOwnedPetGeneric backend))

parseQueryParam :: Text -> Either Text (Key (MaybeOwnedPetGeneric backend))

PathPiece (BackendKey backend) => PathPiece (Key (MaybeOwnedPetGeneric backend))

Methods

fromPathPiece :: Text -> Maybe (Key (MaybeOwnedPetGeneric backend))

toPathPiece :: Key (MaybeOwnedPetGeneric backend) -> Text

PersistFieldSql (BackendKey backend) => PersistFieldSql (Key (MaybeOwnedPetGeneric backend))

Methods

sqlType :: Proxy * (Key (MaybeOwnedPetGeneric backend)) -> SqlType

PersistStore backend => PersistFieldSql (MaybeOwnedPetGeneric backend)

Methods

sqlType :: Proxy * (MaybeOwnedPetGeneric backend) -> SqlType

PersistStore backend => PersistEntity (MaybeOwnedPetGeneric backend)

Associated Types

type PersistEntityBackend (MaybeOwnedPetGeneric backend) :: *

data Key (MaybeOwnedPetGeneric backend) :: *

data EntityField (MaybeOwnedPetGeneric backend) a :: *

data Unique (MaybeOwnedPetGeneric backend) :: *

Methods

keyToValues :: Key (MaybeOwnedPetGeneric backend) -> [PersistValue]

keyFromValues :: [PersistValue] -> Either Text (Key (MaybeOwnedPetGeneric backend))

persistIdField :: EntityField (MaybeOwnedPetGeneric backend) (Key (MaybeOwnedPetGeneric backend))

entityDef :: Monad m => m (MaybeOwnedPetGeneric backend) -> EntityDef

persistFieldDef :: EntityField (MaybeOwnedPetGeneric backend) typ -> FieldDef

toPersistFields :: MaybeOwnedPetGeneric backend -> [SomePersistField]

fromPersistValues :: [PersistValue] -> Either Text (MaybeOwnedPetGeneric backend)

persistUniqueKeys :: MaybeOwnedPetGeneric backend -> [Unique (MaybeOwnedPetGeneric backend)]

persistUniqueToFieldNames :: Unique (MaybeOwnedPetGeneric backend) -> [(HaskellName, DBName)]

persistUniqueToValues :: Unique (MaybeOwnedPetGeneric backend) -> [PersistValue]

fieldLens :: EntityField (MaybeOwnedPetGeneric backend) field -> forall (f :: * -> *). Functor f => (field -> f field) -> Entity (MaybeOwnedPetGeneric backend) -> f (Entity (MaybeOwnedPetGeneric backend))

PersistField (BackendKey backend) => PersistField (Key (MaybeOwnedPetGeneric backend))

Methods

toPersistValue :: Key (MaybeOwnedPetGeneric backend) -> PersistValue

fromPersistValue :: PersistValue -> Either Text (Key (MaybeOwnedPetGeneric backend))

PersistStore backend => PersistField (MaybeOwnedPetGeneric backend)

Methods

toPersistValue :: MaybeOwnedPetGeneric backend -> PersistValue

fromPersistValue :: PersistValue -> Either Text (MaybeOwnedPetGeneric backend)

(PersistQuery backend, (~) * (PersistEntityBackend (MaybeOwnedPetGeneric backend)) (BaseBackend backend)) => DeleteCascade (MaybeOwnedPetGeneric backend) backend

Methods

deleteCascade :: MonadIO m => Key (MaybeOwnedPetGeneric backend) -> ReaderT * backend m ()

data Unique (MaybeOwnedPetGeneric backend)

data Unique (MaybeOwnedPetGeneric backend)

data EntityField (MaybeOwnedPetGeneric backend)

data EntityField (MaybeOwnedPetGeneric backend) where

• MaybeOwnedPetId :: EntityField (MaybeOwnedPetGeneric backend) typ
• MaybeOwnedPetOwnerId :: EntityField (MaybeOwnedPetGeneric backend) typ
• MaybeOwnedPetName :: EntityField (MaybeOwnedPetGeneric backend) typ
• MaybeOwnedPetType :: EntityField (MaybeOwnedPetGeneric backend) typ

data Key (MaybeOwnedPetGeneric backend)

data Key (MaybeOwnedPetGeneric backend) = MaybeOwnedPetKey {

• unMaybeOwnedPetKey :: BackendKey backend

}

type PersistEntityBackend (MaybeOwnedPetGeneric backend)

type PersistEntityBackend (MaybeOwnedPetGeneric backend) = backend

type MaybeOwnedPet = MaybeOwnedPetGeneric SqlBackend

type MaybeOwnedPetId = Key MaybeOwnedPet

data NeedsPetGeneric backend

Constructors

NeedsPet

Fields

• needsPetPetKey :: !(Key (PetGeneric backend))

Instances

PersistStore backend => ToBackendKey backend (NeedsPetGeneric backend)

Methods

toBackendKey :: Key (NeedsPetGeneric backend) -> BackendKey backend

fromBackendKey :: BackendKey backend -> Key (NeedsPetGeneric backend)

Eq (BackendKey backend) => Eq (Key (NeedsPetGeneric backend))

Methods

(==) :: Key (NeedsPetGeneric backend) -> Key (NeedsPetGeneric backend) -> Bool

(/=) :: Key (NeedsPetGeneric backend) -> Key (NeedsPetGeneric backend) -> Bool

Ord (BackendKey backend) => Ord (Key (NeedsPetGeneric backend))

Methods

compare :: Key (NeedsPetGeneric backend) -> Key (NeedsPetGeneric backend) -> Ordering

(<) :: Key (NeedsPetGeneric backend) -> Key (NeedsPetGeneric backend) -> Bool

(<=) :: Key (NeedsPetGeneric backend) -> Key (NeedsPetGeneric backend) -> Bool

(>) :: Key (NeedsPetGeneric backend) -> Key (NeedsPetGeneric backend) -> Bool

(>=) :: Key (NeedsPetGeneric backend) -> Key (NeedsPetGeneric backend) -> Bool

max :: Key (NeedsPetGeneric backend) -> Key (NeedsPetGeneric backend) -> Key (NeedsPetGeneric backend)

min :: Key (NeedsPetGeneric backend) -> Key (NeedsPetGeneric backend) -> Key (NeedsPetGeneric backend)

Read (BackendKey backend) => Read (Key (NeedsPetGeneric backend))

Methods

readsPrec :: Int -> ReadS (Key (NeedsPetGeneric backend))

readList :: ReadS [Key (NeedsPetGeneric backend)]

readPrec :: ReadPrec (Key (NeedsPetGeneric backend))

readListPrec :: ReadPrec [Key (NeedsPetGeneric backend)]

Show (BackendKey backend) => Show (Key (NeedsPetGeneric backend))

Methods

showsPrec :: Int -> Key (NeedsPetGeneric backend) -> ShowS

show :: Key (NeedsPetGeneric backend) -> String

showList :: [Key (NeedsPetGeneric backend)] -> ShowS

ToJSON (BackendKey backend) => ToJSON (Key (NeedsPetGeneric backend))

Methods

toJSON :: Key (NeedsPetGeneric backend) -> Value

toEncoding :: Key (NeedsPetGeneric backend) -> Encoding

toJSONList :: [Key (NeedsPetGeneric backend)] -> Value

toEncodingList :: [Key (NeedsPetGeneric backend)] -> Encoding

FromJSON (BackendKey backend) => FromJSON (Key (NeedsPetGeneric backend))

Methods

parseJSON :: Value -> Parser (Key (NeedsPetGeneric backend))

parseJSONList :: Value -> Parser [Key (NeedsPetGeneric backend)]

ToHttpApiData (BackendKey backend) => ToHttpApiData (Key (NeedsPetGeneric backend))

Methods

toUrlPiece :: Key (NeedsPetGeneric backend) -> Text

toEncodedUrlPiece :: Key (NeedsPetGeneric backend) -> Builder

toHeader :: Key (NeedsPetGeneric backend) -> ByteString

toQueryParam :: Key (NeedsPetGeneric backend) -> Text

FromHttpApiData (BackendKey backend) => FromHttpApiData (Key (NeedsPetGeneric backend))

Methods

parseUrlPiece :: Text -> Either Text (Key (NeedsPetGeneric backend))

parseHeader :: ByteString -> Either Text (Key (NeedsPetGeneric backend))

parseQueryParam :: Text -> Either Text (Key (NeedsPetGeneric backend))

PathPiece (BackendKey backend) => PathPiece (Key (NeedsPetGeneric backend))

Methods

fromPathPiece :: Text -> Maybe (Key (NeedsPetGeneric backend))

toPathPiece :: Key (NeedsPetGeneric backend) -> Text

PersistFieldSql (BackendKey backend) => PersistFieldSql (Key (NeedsPetGeneric backend))

Methods

sqlType :: Proxy * (Key (NeedsPetGeneric backend)) -> SqlType

PersistStore backend => PersistFieldSql (NeedsPetGeneric backend)

Methods

sqlType :: Proxy * (NeedsPetGeneric backend) -> SqlType

PersistStore backend => PersistEntity (NeedsPetGeneric backend)

Associated Types

type PersistEntityBackend (NeedsPetGeneric backend) :: *

data Key (NeedsPetGeneric backend) :: *

data EntityField (NeedsPetGeneric backend) a :: *

data Unique (NeedsPetGeneric backend) :: *

Methods

keyToValues :: Key (NeedsPetGeneric backend) -> [PersistValue]

keyFromValues :: [PersistValue] -> Either Text (Key (NeedsPetGeneric backend))

persistIdField :: EntityField (NeedsPetGeneric backend) (Key (NeedsPetGeneric backend))

entityDef :: Monad m => m (NeedsPetGeneric backend) -> EntityDef

persistFieldDef :: EntityField (NeedsPetGeneric backend) typ -> FieldDef

toPersistFields :: NeedsPetGeneric backend -> [SomePersistField]

fromPersistValues :: [PersistValue] -> Either Text (NeedsPetGeneric backend)

persistUniqueKeys :: NeedsPetGeneric backend -> [Unique (NeedsPetGeneric backend)]

persistUniqueToFieldNames :: Unique (NeedsPetGeneric backend) -> [(HaskellName, DBName)]

persistUniqueToValues :: Unique (NeedsPetGeneric backend) -> [PersistValue]

fieldLens :: EntityField (NeedsPetGeneric backend) field -> forall (f :: * -> *). Functor f => (field -> f field) -> Entity (NeedsPetGeneric backend) -> f (Entity (NeedsPetGeneric backend))

PersistField (BackendKey backend) => PersistField (Key (NeedsPetGeneric backend))

Methods

toPersistValue :: Key (NeedsPetGeneric backend) -> PersistValue

fromPersistValue :: PersistValue -> Either Text (Key (NeedsPetGeneric backend))

PersistStore backend => PersistField (NeedsPetGeneric backend)

Methods

toPersistValue :: NeedsPetGeneric backend -> PersistValue

fromPersistValue :: PersistValue -> Either Text (NeedsPetGeneric backend)

(PersistQuery backend, (~) * (PersistEntityBackend (NeedsPetGeneric backend)) (BaseBackend backend)) => DeleteCascade (NeedsPetGeneric backend) backend

Methods

deleteCascade :: MonadIO m => Key (NeedsPetGeneric backend) -> ReaderT * backend m ()

data Unique (NeedsPetGeneric backend)

data Unique (NeedsPetGeneric backend)

data EntityField (NeedsPetGeneric backend)

data EntityField (NeedsPetGeneric backend) where

• NeedsPetId :: EntityField (NeedsPetGeneric backend) typ
• NeedsPetPetKey :: EntityField (NeedsPetGeneric backend) typ

data Key (NeedsPetGeneric backend)

data Key (NeedsPetGeneric backend) = NeedsPetKey {

• unNeedsPetKey :: BackendKey backend

}

type PersistEntityBackend (NeedsPetGeneric backend)

type PersistEntityBackend (NeedsPetGeneric backend) = backend

type NeedsPet = NeedsPetGeneric SqlBackend

type NeedsPetId = Key NeedsPet

data OutdoorPetGeneric backend

Constructors

OutdoorPet

Fields

• outdoorPetOwnerId :: !(Key (PersonGeneric backend))
• outdoorPetCollar :: !PetCollar
• outdoorPetType :: !PetType

Instances

PersistStore backend => ToBackendKey backend (OutdoorPetGeneric backend)

Methods

toBackendKey :: Key (OutdoorPetGeneric backend) -> BackendKey backend

fromBackendKey :: BackendKey backend -> Key (OutdoorPetGeneric backend)

Eq (BackendKey backend) => Eq (Key (OutdoorPetGeneric backend))

Methods

(==) :: Key (OutdoorPetGeneric backend) -> Key (OutdoorPetGeneric backend) -> Bool

(/=) :: Key (OutdoorPetGeneric backend) -> Key (OutdoorPetGeneric backend) -> Bool

Ord (BackendKey backend) => Ord (Key (OutdoorPetGeneric backend))

Methods

compare :: Key (OutdoorPetGeneric backend) -> Key (OutdoorPetGeneric backend) -> Ordering

(<) :: Key (OutdoorPetGeneric backend) -> Key (OutdoorPetGeneric backend) -> Bool

(<=) :: Key (OutdoorPetGeneric backend) -> Key (OutdoorPetGeneric backend) -> Bool

(>) :: Key (OutdoorPetGeneric backend) -> Key (OutdoorPetGeneric backend) -> Bool

(>=) :: Key (OutdoorPetGeneric backend) -> Key (OutdoorPetGeneric backend) -> Bool

max :: Key (OutdoorPetGeneric backend) -> Key (OutdoorPetGeneric backend) -> Key (OutdoorPetGeneric backend)

min :: Key (OutdoorPetGeneric backend) -> Key (OutdoorPetGeneric backend) -> Key (OutdoorPetGeneric backend)

Read (BackendKey backend) => Read (Key (OutdoorPetGeneric backend))

Methods

readsPrec :: Int -> ReadS (Key (OutdoorPetGeneric backend))

readList :: ReadS [Key (OutdoorPetGeneric backend)]

readPrec :: ReadPrec (Key (OutdoorPetGeneric backend))

readListPrec :: ReadPrec [Key (OutdoorPetGeneric backend)]

Show (BackendKey backend) => Show (Key (OutdoorPetGeneric backend))

Methods

showsPrec :: Int -> Key (OutdoorPetGeneric backend) -> ShowS

show :: Key (OutdoorPetGeneric backend) -> String

showList :: [Key (OutdoorPetGeneric backend)] -> ShowS

ToJSON (BackendKey backend) => ToJSON (Key (OutdoorPetGeneric backend))

Methods

toJSON :: Key (OutdoorPetGeneric backend) -> Value

toEncoding :: Key (OutdoorPetGeneric backend) -> Encoding

toJSONList :: [Key (OutdoorPetGeneric backend)] -> Value

toEncodingList :: [Key (OutdoorPetGeneric backend)] -> Encoding

FromJSON (BackendKey backend) => FromJSON (Key (OutdoorPetGeneric backend))

Methods

parseJSON :: Value -> Parser (Key (OutdoorPetGeneric backend))

parseJSONList :: Value -> Parser [Key (OutdoorPetGeneric backend)]

ToHttpApiData (BackendKey backend) => ToHttpApiData (Key (OutdoorPetGeneric backend))

Methods

toUrlPiece :: Key (OutdoorPetGeneric backend) -> Text

toEncodedUrlPiece :: Key (OutdoorPetGeneric backend) -> Builder

toHeader :: Key (OutdoorPetGeneric backend) -> ByteString

toQueryParam :: Key (OutdoorPetGeneric backend) -> Text

FromHttpApiData (BackendKey backend) => FromHttpApiData (Key (OutdoorPetGeneric backend))

Methods

parseUrlPiece :: Text -> Either Text (Key (OutdoorPetGeneric backend))

parseHeader :: ByteString -> Either Text (Key (OutdoorPetGeneric backend))

parseQueryParam :: Text -> Either Text (Key (OutdoorPetGeneric backend))

PathPiece (BackendKey backend) => PathPiece (Key (OutdoorPetGeneric backend))

Methods

fromPathPiece :: Text -> Maybe (Key (OutdoorPetGeneric backend))

toPathPiece :: Key (OutdoorPetGeneric backend) -> Text

PersistFieldSql (BackendKey backend) => PersistFieldSql (Key (OutdoorPetGeneric backend))

Methods

sqlType :: Proxy * (Key (OutdoorPetGeneric backend)) -> SqlType

PersistStore backend => PersistFieldSql (OutdoorPetGeneric backend)

Methods

sqlType :: Proxy * (OutdoorPetGeneric backend) -> SqlType

PersistStore backend => PersistEntity (OutdoorPetGeneric backend)

Associated Types

type PersistEntityBackend (OutdoorPetGeneric backend) :: *

data Key (OutdoorPetGeneric backend) :: *

data EntityField (OutdoorPetGeneric backend) a :: *

data Unique (OutdoorPetGeneric backend) :: *

Methods

keyToValues :: Key (OutdoorPetGeneric backend) -> [PersistValue]

keyFromValues :: [PersistValue] -> Either Text (Key (OutdoorPetGeneric backend))

persistIdField :: EntityField (OutdoorPetGeneric backend) (Key (OutdoorPetGeneric backend))

entityDef :: Monad m => m (OutdoorPetGeneric backend) -> EntityDef

persistFieldDef :: EntityField (OutdoorPetGeneric backend) typ -> FieldDef

toPersistFields :: OutdoorPetGeneric backend -> [SomePersistField]

fromPersistValues :: [PersistValue] -> Either Text (OutdoorPetGeneric backend)

persistUniqueKeys :: OutdoorPetGeneric backend -> [Unique (OutdoorPetGeneric backend)]

persistUniqueToFieldNames :: Unique (OutdoorPetGeneric backend) -> [(HaskellName, DBName)]

persistUniqueToValues :: Unique (OutdoorPetGeneric backend) -> [PersistValue]

fieldLens :: EntityField (OutdoorPetGeneric backend) field -> forall (f :: * -> *). Functor f => (field -> f field) -> Entity (OutdoorPetGeneric backend) -> f (Entity (OutdoorPetGeneric backend))

PersistField (BackendKey backend) => PersistField (Key (OutdoorPetGeneric backend))

Methods

toPersistValue :: Key (OutdoorPetGeneric backend) -> PersistValue

fromPersistValue :: PersistValue -> Either Text (Key (OutdoorPetGeneric backend))

PersistStore backend => PersistField (OutdoorPetGeneric backend)

Methods

toPersistValue :: OutdoorPetGeneric backend -> PersistValue

fromPersistValue :: PersistValue -> Either Text (OutdoorPetGeneric backend)

(PersistQuery backend, (~) * (PersistEntityBackend (OutdoorPetGeneric backend)) (BaseBackend backend)) => DeleteCascade (OutdoorPetGeneric backend) backend

Methods

deleteCascade :: MonadIO m => Key (OutdoorPetGeneric backend) -> ReaderT * backend m ()

data Unique (OutdoorPetGeneric backend)

data Unique (OutdoorPetGeneric backend)

data EntityField (OutdoorPetGeneric backend)

data EntityField (OutdoorPetGeneric backend) where

• OutdoorPetId :: EntityField (OutdoorPetGeneric backend) typ
• OutdoorPetOwnerId :: EntityField (OutdoorPetGeneric backend) typ
• OutdoorPetCollar :: EntityField (OutdoorPetGeneric backend) typ
• OutdoorPetType :: EntityField (OutdoorPetGeneric backend) typ

data Key (OutdoorPetGeneric backend)

data Key (OutdoorPetGeneric backend) = OutdoorPetKey {

• unOutdoorPetKey :: BackendKey backend

}

type PersistEntityBackend (OutdoorPetGeneric backend)

type PersistEntityBackend (OutdoorPetGeneric backend) = backend

type OutdoorPet = OutdoorPetGeneric SqlBackend

type OutdoorPetId = Key OutdoorPet

data UserPTGeneric backend

Constructors

UserPT

Fields

• userPTIdent :: !Text
• userPTPassword :: !(Maybe Text)

Instances

PersistStore backend => ToBackendKey backend (UserPTGeneric backend)

Methods

toBackendKey :: Key (UserPTGeneric backend) -> BackendKey backend

fromBackendKey :: BackendKey backend -> Key (UserPTGeneric backend)

Eq (BackendKey backend) => Eq (Key (UserPTGeneric backend))

Methods

(==) :: Key (UserPTGeneric backend) -> Key (UserPTGeneric backend) -> Bool

(/=) :: Key (UserPTGeneric backend) -> Key (UserPTGeneric backend) -> Bool

Ord (BackendKey backend) => Ord (Key (UserPTGeneric backend))

Methods

compare :: Key (UserPTGeneric backend) -> Key (UserPTGeneric backend) -> Ordering

(<) :: Key (UserPTGeneric backend) -> Key (UserPTGeneric backend) -> Bool

(<=) :: Key (UserPTGeneric backend) -> Key (UserPTGeneric backend) -> Bool

(>) :: Key (UserPTGeneric backend) -> Key (UserPTGeneric backend) -> Bool

(>=) :: Key (UserPTGeneric backend) -> Key (UserPTGeneric backend) -> Bool

max :: Key (UserPTGeneric backend) -> Key (UserPTGeneric backend) -> Key (UserPTGeneric backend)

min :: Key (UserPTGeneric backend) -> Key (UserPTGeneric backend) -> Key (UserPTGeneric backend)

Read (BackendKey backend) => Read (Key (UserPTGeneric backend))

Methods

readsPrec :: Int -> ReadS (Key (UserPTGeneric backend))

readList :: ReadS [Key (UserPTGeneric backend)]

readPrec :: ReadPrec (Key (UserPTGeneric backend))

readListPrec :: ReadPrec [Key (UserPTGeneric backend)]

Show (BackendKey backend) => Show (Key (UserPTGeneric backend))

Methods

showsPrec :: Int -> Key (UserPTGeneric backend) -> ShowS

show :: Key (UserPTGeneric backend) -> String

showList :: [Key (UserPTGeneric backend)] -> ShowS

ToJSON (BackendKey backend) => ToJSON (Key (UserPTGeneric backend))

Methods

toJSON :: Key (UserPTGeneric backend) -> Value

toEncoding :: Key (UserPTGeneric backend) -> Encoding

toJSONList :: [Key (UserPTGeneric backend)] -> Value

toEncodingList :: [Key (UserPTGeneric backend)] -> Encoding

FromJSON (BackendKey backend) => FromJSON (Key (UserPTGeneric backend))

Methods

parseJSON :: Value -> Parser (Key (UserPTGeneric backend))

parseJSONList :: Value -> Parser [Key (UserPTGeneric backend)]

ToHttpApiData (BackendKey backend) => ToHttpApiData (Key (UserPTGeneric backend))

Methods

toUrlPiece :: Key (UserPTGeneric backend) -> Text

toEncodedUrlPiece :: Key (UserPTGeneric backend) -> Builder

toHeader :: Key (UserPTGeneric backend) -> ByteString

toQueryParam :: Key (UserPTGeneric backend) -> Text

FromHttpApiData (BackendKey backend) => FromHttpApiData (Key (UserPTGeneric backend))

Methods

parseUrlPiece :: Text -> Either Text (Key (UserPTGeneric backend))

parseHeader :: ByteString -> Either Text (Key (UserPTGeneric backend))

parseQueryParam :: Text -> Either Text (Key (UserPTGeneric backend))

PathPiece (BackendKey backend) => PathPiece (Key (UserPTGeneric backend))

Methods

fromPathPiece :: Text -> Maybe (Key (UserPTGeneric backend))

toPathPiece :: Key (UserPTGeneric backend) -> Text

PersistFieldSql (BackendKey backend) => PersistFieldSql (Key (UserPTGeneric backend))

Methods

sqlType :: Proxy * (Key (UserPTGeneric backend)) -> SqlType

PersistStore backend => PersistFieldSql (UserPTGeneric backend)

Methods

sqlType :: Proxy * (UserPTGeneric backend) -> SqlType

PersistStore backend => PersistEntity (UserPTGeneric backend)

Associated Types

type PersistEntityBackend (UserPTGeneric backend) :: *

data Key (UserPTGeneric backend) :: *

data EntityField (UserPTGeneric backend) a :: *

data Unique (UserPTGeneric backend) :: *

Methods

keyToValues :: Key (UserPTGeneric backend) -> [PersistValue]

keyFromValues :: [PersistValue] -> Either Text (Key (UserPTGeneric backend))

persistIdField :: EntityField (UserPTGeneric backend) (Key (UserPTGeneric backend))

entityDef :: Monad m => m (UserPTGeneric backend) -> EntityDef

persistFieldDef :: EntityField (UserPTGeneric backend) typ -> FieldDef

toPersistFields :: UserPTGeneric backend -> [SomePersistField]

fromPersistValues :: [PersistValue] -> Either Text (UserPTGeneric backend)

persistUniqueKeys :: UserPTGeneric backend -> [Unique (UserPTGeneric backend)]

persistUniqueToFieldNames :: Unique (UserPTGeneric backend) -> [(HaskellName, DBName)]

persistUniqueToValues :: Unique (UserPTGeneric backend) -> [PersistValue]

fieldLens :: EntityField (UserPTGeneric backend) field -> forall (f :: * -> *). Functor f => (field -> f field) -> Entity (UserPTGeneric backend) -> f (Entity (UserPTGeneric backend))

PersistField (BackendKey backend) => PersistField (Key (UserPTGeneric backend))

Methods

toPersistValue :: Key (UserPTGeneric backend) -> PersistValue

fromPersistValue :: PersistValue -> Either Text (Key (UserPTGeneric backend))

PersistStore backend => PersistField (UserPTGeneric backend)

Methods

toPersistValue :: UserPTGeneric backend -> PersistValue

fromPersistValue :: PersistValue -> Either Text (UserPTGeneric backend)

(PersistQuery backend, (~) * (PersistEntityBackend (UserPTGeneric backend)) (BaseBackend backend)) => DeleteCascade (UserPTGeneric backend) backend

Methods

deleteCascade :: MonadIO m => Key (UserPTGeneric backend) -> ReaderT * backend m ()

data Unique (UserPTGeneric backend)

data Unique (UserPTGeneric backend) = UniqueUserPT Text

data EntityField (UserPTGeneric backend)

data EntityField (UserPTGeneric backend) where

• UserPTId :: EntityField (UserPTGeneric backend) typ
• UserPTIdent :: EntityField (UserPTGeneric backend) typ
• UserPTPassword :: EntityField (UserPTGeneric backend) typ

data Key (UserPTGeneric backend)

data Key (UserPTGeneric backend) = UserPTKey {

• unUserPTKey :: BackendKey backend

}

type PersistEntityBackend (UserPTGeneric backend)

type PersistEntityBackend (UserPTGeneric backend) = backend

type UserPT = UserPTGeneric SqlBackend

type UserPTId = Key UserPT

data EmailPTGeneric backend

Constructors

EmailPT

Fields

• emailPTEmail :: !Text
• emailPTUser :: !(Maybe (Key (UserPTGeneric backend)))
• emailPTVerkey :: !(Maybe Text)

Instances

PersistStore backend => ToBackendKey backend (EmailPTGeneric backend)

Methods

toBackendKey :: Key (EmailPTGeneric backend) -> BackendKey backend

fromBackendKey :: BackendKey backend -> Key (EmailPTGeneric backend)

Eq (BackendKey backend) => Eq (Key (EmailPTGeneric backend))

Methods

(==) :: Key (EmailPTGeneric backend) -> Key (EmailPTGeneric backend) -> Bool

(/=) :: Key (EmailPTGeneric backend) -> Key (EmailPTGeneric backend) -> Bool

Ord (BackendKey backend) => Ord (Key (EmailPTGeneric backend))

Methods

compare :: Key (EmailPTGeneric backend) -> Key (EmailPTGeneric backend) -> Ordering

(<) :: Key (EmailPTGeneric backend) -> Key (EmailPTGeneric backend) -> Bool

(<=) :: Key (EmailPTGeneric backend) -> Key (EmailPTGeneric backend) -> Bool

(>) :: Key (EmailPTGeneric backend) -> Key (EmailPTGeneric backend) -> Bool

(>=) :: Key (EmailPTGeneric backend) -> Key (EmailPTGeneric backend) -> Bool

max :: Key (EmailPTGeneric backend) -> Key (EmailPTGeneric backend) -> Key (EmailPTGeneric backend)

min :: Key (EmailPTGeneric backend) -> Key (EmailPTGeneric backend) -> Key (EmailPTGeneric backend)

Read (BackendKey backend) => Read (Key (EmailPTGeneric backend))

Methods

readsPrec :: Int -> ReadS (Key (EmailPTGeneric backend))

readList :: ReadS [Key (EmailPTGeneric backend)]

readPrec :: ReadPrec (Key (EmailPTGeneric backend))

readListPrec :: ReadPrec [Key (EmailPTGeneric backend)]

Show (BackendKey backend) => Show (Key (EmailPTGeneric backend))

Methods

showsPrec :: Int -> Key (EmailPTGeneric backend) -> ShowS

show :: Key (EmailPTGeneric backend) -> String

showList :: [Key (EmailPTGeneric backend)] -> ShowS

ToJSON (BackendKey backend) => ToJSON (Key (EmailPTGeneric backend))

Methods

toJSON :: Key (EmailPTGeneric backend) -> Value

toEncoding :: Key (EmailPTGeneric backend) -> Encoding

toJSONList :: [Key (EmailPTGeneric backend)] -> Value

toEncodingList :: [Key (EmailPTGeneric backend)] -> Encoding

FromJSON (BackendKey backend) => FromJSON (Key (EmailPTGeneric backend))

Methods

parseJSON :: Value -> Parser (Key (EmailPTGeneric backend))

parseJSONList :: Value -> Parser [Key (EmailPTGeneric backend)]

ToHttpApiData (BackendKey backend) => ToHttpApiData (Key (EmailPTGeneric backend))

Methods

toUrlPiece :: Key (EmailPTGeneric backend) -> Text

toEncodedUrlPiece :: Key (EmailPTGeneric backend) -> Builder

toHeader :: Key (EmailPTGeneric backend) -> ByteString

toQueryParam :: Key (EmailPTGeneric backend) -> Text

FromHttpApiData (BackendKey backend) => FromHttpApiData (Key (EmailPTGeneric backend))

Methods

parseUrlPiece :: Text -> Either Text (Key (EmailPTGeneric backend))

parseHeader :: ByteString -> Either Text (Key (EmailPTGeneric backend))

parseQueryParam :: Text -> Either Text (Key (EmailPTGeneric backend))

PathPiece (BackendKey backend) => PathPiece (Key (EmailPTGeneric backend))

Methods

fromPathPiece :: Text -> Maybe (Key (EmailPTGeneric backend))

toPathPiece :: Key (EmailPTGeneric backend) -> Text

PersistFieldSql (BackendKey backend) => PersistFieldSql (Key (EmailPTGeneric backend))

Methods

sqlType :: Proxy * (Key (EmailPTGeneric backend)) -> SqlType

PersistStore backend => PersistFieldSql (EmailPTGeneric backend)

Methods

sqlType :: Proxy * (EmailPTGeneric backend) -> SqlType

PersistStore backend => PersistEntity (EmailPTGeneric backend)

Associated Types

type PersistEntityBackend (EmailPTGeneric backend) :: *

data Key (EmailPTGeneric backend) :: *

data EntityField (EmailPTGeneric backend) a :: *

data Unique (EmailPTGeneric backend) :: *

Methods

keyToValues :: Key (EmailPTGeneric backend) -> [PersistValue]

keyFromValues :: [PersistValue] -> Either Text (Key (EmailPTGeneric backend))

persistIdField :: EntityField (EmailPTGeneric backend) (Key (EmailPTGeneric backend))

entityDef :: Monad m => m (EmailPTGeneric backend) -> EntityDef

persistFieldDef :: EntityField (EmailPTGeneric backend) typ -> FieldDef

toPersistFields :: EmailPTGeneric backend -> [SomePersistField]

fromPersistValues :: [PersistValue] -> Either Text (EmailPTGeneric backend)

persistUniqueKeys :: EmailPTGeneric backend -> [Unique (EmailPTGeneric backend)]

persistUniqueToFieldNames :: Unique (EmailPTGeneric backend) -> [(HaskellName, DBName)]

persistUniqueToValues :: Unique (EmailPTGeneric backend) -> [PersistValue]

fieldLens :: EntityField (EmailPTGeneric backend) field -> forall (f :: * -> *). Functor f => (field -> f field) -> Entity (EmailPTGeneric backend) -> f (Entity (EmailPTGeneric backend))

PersistField (BackendKey backend) => PersistField (Key (EmailPTGeneric backend))

Methods

toPersistValue :: Key (EmailPTGeneric backend) -> PersistValue

fromPersistValue :: PersistValue -> Either Text (Key (EmailPTGeneric backend))

PersistStore backend => PersistField (EmailPTGeneric backend)

Methods

toPersistValue :: EmailPTGeneric backend -> PersistValue

fromPersistValue :: PersistValue -> Either Text (EmailPTGeneric backend)

(PersistQuery backend, (~) * (PersistEntityBackend (EmailPTGeneric backend)) (BaseBackend backend)) => DeleteCascade (EmailPTGeneric backend) backend

Methods

deleteCascade :: MonadIO m => Key (EmailPTGeneric backend) -> ReaderT * backend m ()

data Unique (EmailPTGeneric backend)

data Unique (EmailPTGeneric backend) = UniqueEmailPT Text

data EntityField (EmailPTGeneric backend)

data EntityField (EmailPTGeneric backend) where

• EmailPTId :: EntityField (EmailPTGeneric backend) typ
• EmailPTEmail :: EntityField (EmailPTGeneric backend) typ
• EmailPTUser :: EntityField (EmailPTGeneric backend) typ
• EmailPTVerkey :: EntityField (EmailPTGeneric backend) typ

data Key (EmailPTGeneric backend)

data Key (EmailPTGeneric backend) = EmailPTKey {

• unEmailPTKey :: BackendKey backend

}

type PersistEntityBackend (EmailPTGeneric backend)

type PersistEntityBackend (EmailPTGeneric backend) = backend

type EmailPT = EmailPTGeneric SqlBackend

type EmailPTId = Key EmailPT

data UpsertGeneric backend

Constructors

Upsert

Fields

• upsertEmail :: !Text
• upsertAttr :: !Text
• upsertExtra :: !Text
• upsertAge :: !Int

Instances

PersistStore backend => ToBackendKey backend (UpsertGeneric backend)

Methods

toBackendKey :: Key (UpsertGeneric backend) -> BackendKey backend

fromBackendKey :: BackendKey backend -> Key (UpsertGeneric backend)

Eq (BackendKey backend) => Eq (Key (UpsertGeneric backend))

Methods

(==) :: Key (UpsertGeneric backend) -> Key (UpsertGeneric backend) -> Bool

(/=) :: Key (UpsertGeneric backend) -> Key (UpsertGeneric backend) -> Bool

Eq (UpsertGeneric backend)

Methods

(==) :: UpsertGeneric backend -> UpsertGeneric backend -> Bool

(/=) :: UpsertGeneric backend -> UpsertGeneric backend -> Bool

Ord (BackendKey backend) => Ord (Key (UpsertGeneric backend))

Methods

compare :: Key (UpsertGeneric backend) -> Key (UpsertGeneric backend) -> Ordering

(<) :: Key (UpsertGeneric backend) -> Key (UpsertGeneric backend) -> Bool

(<=) :: Key (UpsertGeneric backend) -> Key (UpsertGeneric backend) -> Bool

(>) :: Key (UpsertGeneric backend) -> Key (UpsertGeneric backend) -> Bool

(>=) :: Key (UpsertGeneric backend) -> Key (UpsertGeneric backend) -> Bool

max :: Key (UpsertGeneric backend) -> Key (UpsertGeneric backend) -> Key (UpsertGeneric backend)

min :: Key (UpsertGeneric backend) -> Key (UpsertGeneric backend) -> Key (UpsertGeneric backend)

Read (BackendKey backend) => Read (Key (UpsertGeneric backend))

Methods

readsPrec :: Int -> ReadS (Key (UpsertGeneric backend))

readList :: ReadS [Key (UpsertGeneric backend)]

readPrec :: ReadPrec (Key (UpsertGeneric backend))

readListPrec :: ReadPrec [Key (UpsertGeneric backend)]

Show (BackendKey backend) => Show (Key (UpsertGeneric backend))

Methods

showsPrec :: Int -> Key (UpsertGeneric backend) -> ShowS

show :: Key (UpsertGeneric backend) -> String

showList :: [Key (UpsertGeneric backend)] -> ShowS

Show (UpsertGeneric backend)

Methods

showsPrec :: Int -> UpsertGeneric backend -> ShowS

show :: UpsertGeneric backend -> String

showList :: [UpsertGeneric backend] -> ShowS

ToJSON (BackendKey backend) => ToJSON (Key (UpsertGeneric backend))

Methods

toJSON :: Key (UpsertGeneric backend) -> Value

toEncoding :: Key (UpsertGeneric backend) -> Encoding

toJSONList :: [Key (UpsertGeneric backend)] -> Value

toEncodingList :: [Key (UpsertGeneric backend)] -> Encoding

FromJSON (BackendKey backend) => FromJSON (Key (UpsertGeneric backend))

Methods

parseJSON :: Value -> Parser (Key (UpsertGeneric backend))

parseJSONList :: Value -> Parser [Key (UpsertGeneric backend)]

ToHttpApiData (BackendKey backend) => ToHttpApiData (Key (UpsertGeneric backend))

Methods

toUrlPiece :: Key (UpsertGeneric backend) -> Text

toEncodedUrlPiece :: Key (UpsertGeneric backend) -> Builder

toHeader :: Key (UpsertGeneric backend) -> ByteString

toQueryParam :: Key (UpsertGeneric backend) -> Text

FromHttpApiData (BackendKey backend) => FromHttpApiData (Key (UpsertGeneric backend))

Methods

parseUrlPiece :: Text -> Either Text (Key (UpsertGeneric backend))

parseHeader :: ByteString -> Either Text (Key (UpsertGeneric backend))

parseQueryParam :: Text -> Either Text (Key (UpsertGeneric backend))

PathPiece (BackendKey backend) => PathPiece (Key (UpsertGeneric backend))

Methods

fromPathPiece :: Text -> Maybe (Key (UpsertGeneric backend))

toPathPiece :: Key (UpsertGeneric backend) -> Text

PersistFieldSql (BackendKey backend) => PersistFieldSql (Key (UpsertGeneric backend))

Methods

sqlType :: Proxy * (Key (UpsertGeneric backend)) -> SqlType

PersistStore backend => PersistFieldSql (UpsertGeneric backend)

Methods

sqlType :: Proxy * (UpsertGeneric backend) -> SqlType

PersistStore backend => PersistEntity (UpsertGeneric backend)

Associated Types

type PersistEntityBackend (UpsertGeneric backend) :: *

data Key (UpsertGeneric backend) :: *

data EntityField (UpsertGeneric backend) a :: *

data Unique (UpsertGeneric backend) :: *

Methods

keyToValues :: Key (UpsertGeneric backend) -> [PersistValue]

keyFromValues :: [PersistValue] -> Either Text (Key (UpsertGeneric backend))

persistIdField :: EntityField (UpsertGeneric backend) (Key (UpsertGeneric backend))

entityDef :: Monad m => m (UpsertGeneric backend) -> EntityDef

persistFieldDef :: EntityField (UpsertGeneric backend) typ -> FieldDef

toPersistFields :: UpsertGeneric backend -> [SomePersistField]

fromPersistValues :: [PersistValue] -> Either Text (UpsertGeneric backend)

persistUniqueKeys :: UpsertGeneric backend -> [Unique (UpsertGeneric backend)]

persistUniqueToFieldNames :: Unique (UpsertGeneric backend) -> [(HaskellName, DBName)]

persistUniqueToValues :: Unique (UpsertGeneric backend) -> [PersistValue]

fieldLens :: EntityField (UpsertGeneric backend) field -> forall (f :: * -> *). Functor f => (field -> f field) -> Entity (UpsertGeneric backend) -> f (Entity (UpsertGeneric backend))

PersistField (BackendKey backend) => PersistField (Key (UpsertGeneric backend))

Methods

toPersistValue :: Key (UpsertGeneric backend) -> PersistValue

fromPersistValue :: PersistValue -> Either Text (Key (UpsertGeneric backend))

PersistStore backend => PersistField (UpsertGeneric backend)

Methods

toPersistValue :: UpsertGeneric backend -> PersistValue

fromPersistValue :: PersistValue -> Either Text (UpsertGeneric backend)

(PersistQuery backend, (~) * (PersistEntityBackend (UpsertGeneric backend)) (BaseBackend backend)) => DeleteCascade (UpsertGeneric backend) backend

Methods

deleteCascade :: MonadIO m => Key (UpsertGeneric backend) -> ReaderT * backend m ()

data Unique (UpsertGeneric backend)

data Unique (UpsertGeneric backend) = UniqueUpsert Text

data EntityField (UpsertGeneric backend)

data EntityField (UpsertGeneric backend) where

• UpsertId :: EntityField (UpsertGeneric backend) typ
• UpsertEmail :: EntityField (UpsertGeneric backend) typ
• UpsertAttr :: EntityField (UpsertGeneric backend) typ
• UpsertExtra :: EntityField (UpsertGeneric backend) typ
• UpsertAge :: EntityField (UpsertGeneric backend) typ

data Key (UpsertGeneric backend)

data Key (UpsertGeneric backend) = UpsertKey {

• unUpsertKey :: BackendKey backend

}

type PersistEntityBackend (UpsertGeneric backend)

type PersistEntityBackend (UpsertGeneric backend) = backend

type Upsert = UpsertGeneric SqlBackend

type UpsertId = Key Upsert

data UpsertByGeneric backend

Constructors

UpsertBy

Fields

• upsertByEmail :: !Text
• upsertByCity :: !Text
• upsertByAttr :: !Text

Instances

PersistStore backend => ToBackendKey backend (UpsertByGeneric backend)

Methods

toBackendKey :: Key (UpsertByGeneric backend) -> BackendKey backend

fromBackendKey :: BackendKey backend -> Key (UpsertByGeneric backend)

Eq (BackendKey backend) => Eq (Key (UpsertByGeneric backend))

Methods

(==) :: Key (UpsertByGeneric backend) -> Key (UpsertByGeneric backend) -> Bool

(/=) :: Key (UpsertByGeneric backend) -> Key (UpsertByGeneric backend) -> Bool

Eq (UpsertByGeneric backend)

Methods

(==) :: UpsertByGeneric backend -> UpsertByGeneric backend -> Bool

(/=) :: UpsertByGeneric backend -> UpsertByGeneric backend -> Bool

Ord (BackendKey backend) => Ord (Key (UpsertByGeneric backend))

Methods

compare :: Key (UpsertByGeneric backend) -> Key (UpsertByGeneric backend) -> Ordering

(<) :: Key (UpsertByGeneric backend) -> Key (UpsertByGeneric backend) -> Bool

(<=) :: Key (UpsertByGeneric backend) -> Key (UpsertByGeneric backend) -> Bool

(>) :: Key (UpsertByGeneric backend) -> Key (UpsertByGeneric backend) -> Bool

(>=) :: Key (UpsertByGeneric backend) -> Key (UpsertByGeneric backend) -> Bool

max :: Key (UpsertByGeneric backend) -> Key (UpsertByGeneric backend) -> Key (UpsertByGeneric backend)

min :: Key (UpsertByGeneric backend) -> Key (UpsertByGeneric backend) -> Key (UpsertByGeneric backend)

Read (BackendKey backend) => Read (Key (UpsertByGeneric backend))

Methods

readsPrec :: Int -> ReadS (Key (UpsertByGeneric backend))

readList :: ReadS [Key (UpsertByGeneric backend)]

readPrec :: ReadPrec (Key (UpsertByGeneric backend))

readListPrec :: ReadPrec [Key (UpsertByGeneric backend)]

Show (BackendKey backend) => Show (Key (UpsertByGeneric backend))

Methods

showsPrec :: Int -> Key (UpsertByGeneric backend) -> ShowS

show :: Key (UpsertByGeneric backend) -> String

showList :: [Key (UpsertByGeneric backend)] -> ShowS

Show (UpsertByGeneric backend)

Methods

showsPrec :: Int -> UpsertByGeneric backend -> ShowS

show :: UpsertByGeneric backend -> String

showList :: [UpsertByGeneric backend] -> ShowS

ToJSON (BackendKey backend) => ToJSON (Key (UpsertByGeneric backend))

Methods

toJSON :: Key (UpsertByGeneric backend) -> Value

toEncoding :: Key (UpsertByGeneric backend) -> Encoding

toJSONList :: [Key (UpsertByGeneric backend)] -> Value

toEncodingList :: [Key (UpsertByGeneric backend)] -> Encoding

FromJSON (BackendKey backend) => FromJSON (Key (UpsertByGeneric backend))

Methods

parseJSON :: Value -> Parser (Key (UpsertByGeneric backend))

parseJSONList :: Value -> Parser [Key (UpsertByGeneric backend)]

ToHttpApiData (BackendKey backend) => ToHttpApiData (Key (UpsertByGeneric backend))

Methods

toUrlPiece :: Key (UpsertByGeneric backend) -> Text

toEncodedUrlPiece :: Key (UpsertByGeneric backend) -> Builder

toHeader :: Key (UpsertByGeneric backend) -> ByteString

toQueryParam :: Key (UpsertByGeneric backend) -> Text

FromHttpApiData (BackendKey backend) => FromHttpApiData (Key (UpsertByGeneric backend))

Methods

parseUrlPiece :: Text -> Either Text (Key (UpsertByGeneric backend))

parseHeader :: ByteString -> Either Text (Key (UpsertByGeneric backend))

parseQueryParam :: Text -> Either Text (Key (UpsertByGeneric backend))

PathPiece (BackendKey backend) => PathPiece (Key (UpsertByGeneric backend))

Methods

fromPathPiece :: Text -> Maybe (Key (UpsertByGeneric backend))

toPathPiece :: Key (UpsertByGeneric backend) -> Text

PersistFieldSql (BackendKey backend) => PersistFieldSql (Key (UpsertByGeneric backend))

Methods

sqlType :: Proxy * (Key (UpsertByGeneric backend)) -> SqlType

PersistStore backend => PersistFieldSql (UpsertByGeneric backend)

Methods

sqlType :: Proxy * (UpsertByGeneric backend) -> SqlType

PersistStore backend => PersistEntity (UpsertByGeneric backend)

Associated Types

type PersistEntityBackend (UpsertByGeneric backend) :: *

data Key (UpsertByGeneric backend) :: *

data EntityField (UpsertByGeneric backend) a :: *

data Unique (UpsertByGeneric backend) :: *

Methods

keyToValues :: Key (UpsertByGeneric backend) -> [PersistValue]

keyFromValues :: [PersistValue] -> Either Text (Key (UpsertByGeneric backend))

persistIdField :: EntityField (UpsertByGeneric backend) (Key (UpsertByGeneric backend))

entityDef :: Monad m => m (UpsertByGeneric backend) -> EntityDef

persistFieldDef :: EntityField (UpsertByGeneric backend) typ -> FieldDef

toPersistFields :: UpsertByGeneric backend -> [SomePersistField]

fromPersistValues :: [PersistValue] -> Either Text (UpsertByGeneric backend)

persistUniqueKeys :: UpsertByGeneric backend -> [Unique (UpsertByGeneric backend)]

persistUniqueToFieldNames :: Unique (UpsertByGeneric backend) -> [(HaskellName, DBName)]

persistUniqueToValues :: Unique (UpsertByGeneric backend) -> [PersistValue]

fieldLens :: EntityField (UpsertByGeneric backend) field -> forall (f :: * -> *). Functor f => (field -> f field) -> Entity (UpsertByGeneric backend) -> f (Entity (UpsertByGeneric backend))

PersistField (BackendKey backend) => PersistField (Key (UpsertByGeneric backend))

Methods

toPersistValue :: Key (UpsertByGeneric backend) -> PersistValue

fromPersistValue :: PersistValue -> Either Text (Key (UpsertByGeneric backend))

PersistStore backend => PersistField (UpsertByGeneric backend)

Methods

toPersistValue :: UpsertByGeneric backend -> PersistValue

fromPersistValue :: PersistValue -> Either Text (UpsertByGeneric backend)

(PersistQuery backend, (~) * (PersistEntityBackend (UpsertByGeneric backend)) (BaseBackend backend)) => DeleteCascade (UpsertByGeneric backend) backend

Methods

deleteCascade :: MonadIO m => Key (UpsertByGeneric backend) -> ReaderT * backend m ()

data Unique (UpsertByGeneric backend)

data Unique (UpsertByGeneric backend)

• = UniqueUpsertBy Text
• | UniqueUpsertByCity Text

data EntityField (UpsertByGeneric backend)

data EntityField (UpsertByGeneric backend) where

• UpsertById :: EntityField (UpsertByGeneric backend) typ
• UpsertByEmail :: EntityField (UpsertByGeneric backend) typ
• UpsertByCity :: EntityField (UpsertByGeneric backend) typ
• UpsertByAttr :: EntityField (UpsertByGeneric backend) typ

data Key (UpsertByGeneric backend)

data Key (UpsertByGeneric backend) = UpsertByKey {

• unUpsertByKey :: BackendKey backend

}

type PersistEntityBackend (UpsertByGeneric backend)

type PersistEntityBackend (UpsertByGeneric backend) = backend

type UpsertBy = UpsertByGeneric SqlBackend

type UpsertById = Key UpsertBy

data StrictGeneric backend

Constructors

Strict

Fields

• strictYes :: !Int
• strictNo :: Int
• strictDef :: !Int

Instances

PersistStore backend => ToBackendKey backend (StrictGeneric backend)

Methods

toBackendKey :: Key (StrictGeneric backend) -> BackendKey backend

fromBackendKey :: BackendKey backend -> Key (StrictGeneric backend)

Eq (BackendKey backend) => Eq (Key (StrictGeneric backend))

Methods

(==) :: Key (StrictGeneric backend) -> Key (StrictGeneric backend) -> Bool

(/=) :: Key (StrictGeneric backend) -> Key (StrictGeneric backend) -> Bool

Ord (BackendKey backend) => Ord (Key (StrictGeneric backend))

Methods

compare :: Key (StrictGeneric backend) -> Key (StrictGeneric backend) -> Ordering

(<) :: Key (StrictGeneric backend) -> Key (StrictGeneric backend) -> Bool

(<=) :: Key (StrictGeneric backend) -> Key (StrictGeneric backend) -> Bool

(>) :: Key (StrictGeneric backend) -> Key (StrictGeneric backend) -> Bool

(>=) :: Key (StrictGeneric backend) -> Key (StrictGeneric backend) -> Bool

max :: Key (StrictGeneric backend) -> Key (StrictGeneric backend) -> Key (StrictGeneric backend)

min :: Key (StrictGeneric backend) -> Key (StrictGeneric backend) -> Key (StrictGeneric backend)

Read (BackendKey backend) => Read (Key (StrictGeneric backend))

Methods

readsPrec :: Int -> ReadS (Key (StrictGeneric backend))

readList :: ReadS [Key (StrictGeneric backend)]

readPrec :: ReadPrec (Key (StrictGeneric backend))

readListPrec :: ReadPrec [Key (StrictGeneric backend)]

Show (BackendKey backend) => Show (Key (StrictGeneric backend))

Methods

showsPrec :: Int -> Key (StrictGeneric backend) -> ShowS

show :: Key (StrictGeneric backend) -> String

showList :: [Key (StrictGeneric backend)] -> ShowS

ToJSON (BackendKey backend) => ToJSON (Key (StrictGeneric backend))

Methods

toJSON :: Key (StrictGeneric backend) -> Value

toEncoding :: Key (StrictGeneric backend) -> Encoding

toJSONList :: [Key (StrictGeneric backend)] -> Value

toEncodingList :: [Key (StrictGeneric backend)] -> Encoding

FromJSON (BackendKey backend) => FromJSON (Key (StrictGeneric backend))

Methods

parseJSON :: Value -> Parser (Key (StrictGeneric backend))

parseJSONList :: Value -> Parser [Key (StrictGeneric backend)]

ToHttpApiData (BackendKey backend) => ToHttpApiData (Key (StrictGeneric backend))

Methods

toUrlPiece :: Key (StrictGeneric backend) -> Text

toEncodedUrlPiece :: Key (StrictGeneric backend) -> Builder

toHeader :: Key (StrictGeneric backend) -> ByteString

toQueryParam :: Key (StrictGeneric backend) -> Text

FromHttpApiData (BackendKey backend) => FromHttpApiData (Key (StrictGeneric backend))

Methods

parseUrlPiece :: Text -> Either Text (Key (StrictGeneric backend))

parseHeader :: ByteString -> Either Text (Key (StrictGeneric backend))

parseQueryParam :: Text -> Either Text (Key (StrictGeneric backend))

PathPiece (BackendKey backend) => PathPiece (Key (StrictGeneric backend))

Methods

fromPathPiece :: Text -> Maybe (Key (StrictGeneric backend))

toPathPiece :: Key (StrictGeneric backend) -> Text

PersistFieldSql (BackendKey backend) => PersistFieldSql (Key (StrictGeneric backend))

Methods

sqlType :: Proxy * (Key (StrictGeneric backend)) -> SqlType

PersistStore backend => PersistFieldSql (StrictGeneric backend)

Methods

sqlType :: Proxy * (StrictGeneric backend) -> SqlType

PersistStore backend => PersistEntity (StrictGeneric backend)

Associated Types

type PersistEntityBackend (StrictGeneric backend) :: *

data Key (StrictGeneric backend) :: *

data EntityField (StrictGeneric backend) a :: *

data Unique (StrictGeneric backend) :: *

Methods

keyToValues :: Key (StrictGeneric backend) -> [PersistValue]

keyFromValues :: [PersistValue] -> Either Text (Key (StrictGeneric backend))

persistIdField :: EntityField (StrictGeneric backend) (Key (StrictGeneric backend))

entityDef :: Monad m => m (StrictGeneric backend) -> EntityDef

persistFieldDef :: EntityField (StrictGeneric backend) typ -> FieldDef

toPersistFields :: StrictGeneric backend -> [SomePersistField]

fromPersistValues :: [PersistValue] -> Either Text (StrictGeneric backend)

persistUniqueKeys :: StrictGeneric backend -> [Unique (StrictGeneric backend)]

persistUniqueToFieldNames :: Unique (StrictGeneric backend) -> [(HaskellName, DBName)]

persistUniqueToValues :: Unique (StrictGeneric backend) -> [PersistValue]

fieldLens :: EntityField (StrictGeneric backend) field -> forall (f :: * -> *). Functor f => (field -> f field) -> Entity (StrictGeneric backend) -> f (Entity (StrictGeneric backend))

PersistField (BackendKey backend) => PersistField (Key (StrictGeneric backend))

Methods

toPersistValue :: Key (StrictGeneric backend) -> PersistValue

fromPersistValue :: PersistValue -> Either Text (Key (StrictGeneric backend))

PersistStore backend => PersistField (StrictGeneric backend)

Methods

toPersistValue :: StrictGeneric backend -> PersistValue

fromPersistValue :: PersistValue -> Either Text (StrictGeneric backend)

(PersistQuery backend, (~) * (PersistEntityBackend (StrictGeneric backend)) (BaseBackend backend)) => DeleteCascade (StrictGeneric backend) backend

Methods

deleteCascade :: MonadIO m => Key (StrictGeneric backend) -> ReaderT * backend m ()

data Unique (StrictGeneric backend)

data Unique (StrictGeneric backend)

data EntityField (StrictGeneric backend)

data EntityField (StrictGeneric backend) where

• StrictId :: EntityField (StrictGeneric backend) typ
• StrictYes :: EntityField (StrictGeneric backend) typ
• StrictNo :: EntityField (StrictGeneric backend) typ
• StrictDef :: EntityField (StrictGeneric backend) typ

data Key (StrictGeneric backend)

data Key (StrictGeneric backend) = StrictKey {

• unStrictKey :: BackendKey backend

}

type PersistEntityBackend (StrictGeneric backend)

type PersistEntityBackend (StrictGeneric backend) = backend

type Strict = StrictGeneric SqlBackend

type StrictId = Key Strict

_ignoredSave :: [EntityDef]

testMigrate :: Migration

data NoPrefix1

Constructors

NoPrefix1

Fields

• someFieldName :: !Int

Instances

Eq NoPrefix1

Methods

(==) :: NoPrefix1 -> NoPrefix1 -> Bool

(/=) :: NoPrefix1 -> NoPrefix1 -> Bool

Show NoPrefix1

Methods

showsPrec :: Int -> NoPrefix1 -> ShowS

show :: NoPrefix1 -> String

showList :: [NoPrefix1] -> ShowS

PersistFieldSql NoPrefix1

Methods

sqlType :: Proxy * NoPrefix1 -> SqlType

PersistEntity NoPrefix1

Associated Types

type PersistEntityBackend NoPrefix1 :: *

data Key NoPrefix1 :: *

data EntityField NoPrefix1 a :: *

data Unique NoPrefix1 :: *

Methods

keyToValues :: Key NoPrefix1 -> [PersistValue]

keyFromValues :: [PersistValue] -> Either Text (Key NoPrefix1)

persistIdField :: EntityField NoPrefix1 (Key NoPrefix1)

entityDef :: Monad m => m NoPrefix1 -> EntityDef

persistFieldDef :: EntityField NoPrefix1 typ -> FieldDef

toPersistFields :: NoPrefix1 -> [SomePersistField]

fromPersistValues :: [PersistValue] -> Either Text NoPrefix1

persistUniqueKeys :: NoPrefix1 -> [Unique NoPrefix1]

persistUniqueToFieldNames :: Unique NoPrefix1 -> [(HaskellName, DBName)]

persistUniqueToValues :: Unique NoPrefix1 -> [PersistValue]

fieldLens :: EntityField NoPrefix1 field -> forall (f :: * -> *). Functor f => (field -> f field) -> Entity NoPrefix1 -> f (Entity NoPrefix1)

PersistField NoPrefix1

Methods

toPersistValue :: NoPrefix1 -> PersistValue

fromPersistValue :: PersistValue -> Either Text NoPrefix1

ToBackendKey SqlBackend NoPrefix1

Methods

toBackendKey :: Key NoPrefix1 -> BackendKey SqlBackend

fromBackendKey :: BackendKey SqlBackend -> Key NoPrefix1

Eq (Key NoPrefix1)

Methods

(==) :: Key NoPrefix1 -> Key NoPrefix1 -> Bool

(/=) :: Key NoPrefix1 -> Key NoPrefix1 -> Bool

Ord (Key NoPrefix1)

Methods

compare :: Key NoPrefix1 -> Key NoPrefix1 -> Ordering

(<) :: Key NoPrefix1 -> Key NoPrefix1 -> Bool

(<=) :: Key NoPrefix1 -> Key NoPrefix1 -> Bool

(>) :: Key NoPrefix1 -> Key NoPrefix1 -> Bool

(>=) :: Key NoPrefix1 -> Key NoPrefix1 -> Bool

max :: Key NoPrefix1 -> Key NoPrefix1 -> Key NoPrefix1

min :: Key NoPrefix1 -> Key NoPrefix1 -> Key NoPrefix1

Read (Key NoPrefix1)

Methods

readsPrec :: Int -> ReadS (Key NoPrefix1)

readList :: ReadS [Key NoPrefix1]

readPrec :: ReadPrec (Key NoPrefix1)

readListPrec :: ReadPrec [Key NoPrefix1]

Show (Key NoPrefix1)

Methods

showsPrec :: Int -> Key NoPrefix1 -> ShowS

show :: Key NoPrefix1 -> String

showList :: [Key NoPrefix1] -> ShowS

ToJSON (Key NoPrefix1)

Methods

toJSON :: Key NoPrefix1 -> Value

toEncoding :: Key NoPrefix1 -> Encoding

toJSONList :: [Key NoPrefix1] -> Value

toEncodingList :: [Key NoPrefix1] -> Encoding

FromJSON (Key NoPrefix1)

Methods

parseJSON :: Value -> Parser (Key NoPrefix1)

parseJSONList :: Value -> Parser [Key NoPrefix1]

ToHttpApiData (Key NoPrefix1)

Methods

toUrlPiece :: Key NoPrefix1 -> Text

toEncodedUrlPiece :: Key NoPrefix1 -> Builder

toHeader :: Key NoPrefix1 -> ByteString

toQueryParam :: Key NoPrefix1 -> Text

FromHttpApiData (Key NoPrefix1)

Methods

parseUrlPiece :: Text -> Either Text (Key NoPrefix1)

parseHeader :: ByteString -> Either Text (Key NoPrefix1)

parseQueryParam :: Text -> Either Text (Key NoPrefix1)

PathPiece (Key NoPrefix1)

Methods

fromPathPiece :: Text -> Maybe (Key NoPrefix1)

toPathPiece :: Key NoPrefix1 -> Text

PersistFieldSql (Key NoPrefix1)

Methods

sqlType :: Proxy * (Key NoPrefix1) -> SqlType

PersistField (Key NoPrefix1)

Methods

toPersistValue :: Key NoPrefix1 -> PersistValue

fromPersistValue :: PersistValue -> Either Text (Key NoPrefix1)

data Unique NoPrefix1

data Unique NoPrefix1

data EntityField NoPrefix1

data EntityField NoPrefix1 where

• NoPrefix1Id :: EntityField NoPrefix1 typ
• SomeFieldName :: EntityField NoPrefix1 typ

data Key NoPrefix1

data Key NoPrefix1 = NoPrefix1Key {

• unNoPrefix1Key :: BackendKey SqlBackend

}

type PersistEntityBackend NoPrefix1

type PersistEntityBackend NoPrefix1 = SqlBackend

type NoPrefix1Id = Key NoPrefix1

data NoPrefix2

Constructors

NoPrefix2

Fields

• someOtherFieldName :: !Int
• unprefixedRef :: !(Key NoPrefix1)

Instances

Eq NoPrefix2

Methods

(==) :: NoPrefix2 -> NoPrefix2 -> Bool

(/=) :: NoPrefix2 -> NoPrefix2 -> Bool

Show NoPrefix2

Methods

showsPrec :: Int -> NoPrefix2 -> ShowS

show :: NoPrefix2 -> String

showList :: [NoPrefix2] -> ShowS

PersistFieldSql NoPrefix2

Methods

sqlType :: Proxy * NoPrefix2 -> SqlType

PersistEntity NoPrefix2

Associated Types

type PersistEntityBackend NoPrefix2 :: *

data Key NoPrefix2 :: *

data EntityField NoPrefix2 a :: *

data Unique NoPrefix2 :: *

Methods

keyToValues :: Key NoPrefix2 -> [PersistValue]

keyFromValues :: [PersistValue] -> Either Text (Key NoPrefix2)

persistIdField :: EntityField NoPrefix2 (Key NoPrefix2)

entityDef :: Monad m => m NoPrefix2 -> EntityDef

persistFieldDef :: EntityField NoPrefix2 typ -> FieldDef

toPersistFields :: NoPrefix2 -> [SomePersistField]

fromPersistValues :: [PersistValue] -> Either Text NoPrefix2

persistUniqueKeys :: NoPrefix2 -> [Unique NoPrefix2]

persistUniqueToFieldNames :: Unique NoPrefix2 -> [(HaskellName, DBName)]

persistUniqueToValues :: Unique NoPrefix2 -> [PersistValue]

fieldLens :: EntityField NoPrefix2 field -> forall (f :: * -> *). Functor f => (field -> f field) -> Entity NoPrefix2 -> f (Entity NoPrefix2)

PersistField NoPrefix2

Methods

toPersistValue :: NoPrefix2 -> PersistValue

fromPersistValue :: PersistValue -> Either Text NoPrefix2

ToBackendKey SqlBackend NoPrefix2

Methods

toBackendKey :: Key NoPrefix2 -> BackendKey SqlBackend

fromBackendKey :: BackendKey SqlBackend -> Key NoPrefix2

Eq (Key NoPrefix2)

Methods

(==) :: Key NoPrefix2 -> Key NoPrefix2 -> Bool

(/=) :: Key NoPrefix2 -> Key NoPrefix2 -> Bool

Ord (Key NoPrefix2)

Methods

compare :: Key NoPrefix2 -> Key NoPrefix2 -> Ordering

(<) :: Key NoPrefix2 -> Key NoPrefix2 -> Bool

(<=) :: Key NoPrefix2 -> Key NoPrefix2 -> Bool

(>) :: Key NoPrefix2 -> Key NoPrefix2 -> Bool

(>=) :: Key NoPrefix2 -> Key NoPrefix2 -> Bool

max :: Key NoPrefix2 -> Key NoPrefix2 -> Key NoPrefix2

min :: Key NoPrefix2 -> Key NoPrefix2 -> Key NoPrefix2

Read (Key NoPrefix2)

Methods

readsPrec :: Int -> ReadS (Key NoPrefix2)

readList :: ReadS [Key NoPrefix2]

readPrec :: ReadPrec (Key NoPrefix2)

readListPrec :: ReadPrec [Key NoPrefix2]

Show (Key NoPrefix2)

Methods

showsPrec :: Int -> Key NoPrefix2 -> ShowS

show :: Key NoPrefix2 -> String

showList :: [Key NoPrefix2] -> ShowS

ToJSON (Key NoPrefix2)

Methods

toJSON :: Key NoPrefix2 -> Value

toEncoding :: Key NoPrefix2 -> Encoding

toJSONList :: [Key NoPrefix2] -> Value

toEncodingList :: [Key NoPrefix2] -> Encoding

FromJSON (Key NoPrefix2)

Methods

parseJSON :: Value -> Parser (Key NoPrefix2)

parseJSONList :: Value -> Parser [Key NoPrefix2]

ToHttpApiData (Key NoPrefix2)

Methods

toUrlPiece :: Key NoPrefix2 -> Text

toEncodedUrlPiece :: Key NoPrefix2 -> Builder

toHeader :: Key NoPrefix2 -> ByteString

toQueryParam :: Key NoPrefix2 -> Text

FromHttpApiData (Key NoPrefix2)

Methods

parseUrlPiece :: Text -> Either Text (Key NoPrefix2)

parseHeader :: ByteString -> Either Text (Key NoPrefix2)

parseQueryParam :: Text -> Either Text (Key NoPrefix2)

PathPiece (Key NoPrefix2)

Methods

fromPathPiece :: Text -> Maybe (Key NoPrefix2)

toPathPiece :: Key NoPrefix2 -> Text

PersistFieldSql (Key NoPrefix2)

Methods

sqlType :: Proxy * (Key NoPrefix2) -> SqlType

PersistField (Key NoPrefix2)

Methods

toPersistValue :: Key NoPrefix2 -> PersistValue

fromPersistValue :: PersistValue -> Either Text (Key NoPrefix2)

data Unique NoPrefix2

data Unique NoPrefix2

data EntityField NoPrefix2

data EntityField NoPrefix2 where

• NoPrefix2Id :: EntityField NoPrefix2 typ
• SomeOtherFieldName :: EntityField NoPrefix2 typ
• UnprefixedRef :: EntityField NoPrefix2 typ

data Key NoPrefix2

data Key NoPrefix2 = NoPrefix2Key {

• unNoPrefix2Key :: BackendKey SqlBackend

}

type PersistEntityBackend NoPrefix2

type PersistEntityBackend NoPrefix2 = SqlBackend

type NoPrefix2Id = Key NoPrefix2

data NoPrefixSum

Constructors

UnprefixedLeftSum Int

UnprefixedRightSum String

Instances

Eq NoPrefixSum

Methods

(==) :: NoPrefixSum -> NoPrefixSum -> Bool

(/=) :: NoPrefixSum -> NoPrefixSum -> Bool

Show NoPrefixSum

Methods

showsPrec :: Int -> NoPrefixSum -> ShowS

show :: NoPrefixSum -> String

showList :: [NoPrefixSum] -> ShowS

PersistFieldSql NoPrefixSum

Methods

sqlType :: Proxy * NoPrefixSum -> SqlType

PersistEntity NoPrefixSum

Associated Types

type PersistEntityBackend NoPrefixSum :: *

data Key NoPrefixSum :: *

data EntityField NoPrefixSum a :: *

data Unique NoPrefixSum :: *

Methods

keyToValues :: Key NoPrefixSum -> [PersistValue]

keyFromValues :: [PersistValue] -> Either Text (Key NoPrefixSum)

persistIdField :: EntityField NoPrefixSum (Key NoPrefixSum)

entityDef :: Monad m => m NoPrefixSum -> EntityDef

persistFieldDef :: EntityField NoPrefixSum typ -> FieldDef

toPersistFields :: NoPrefixSum -> [SomePersistField]

fromPersistValues :: [PersistValue] -> Either Text NoPrefixSum

persistUniqueKeys :: NoPrefixSum -> [Unique NoPrefixSum]

persistUniqueToFieldNames :: Unique NoPrefixSum -> [(HaskellName, DBName)]

persistUniqueToValues :: Unique NoPrefixSum -> [PersistValue]

fieldLens :: EntityField NoPrefixSum field -> forall (f :: * -> *). Functor f => (field -> f field) -> Entity NoPrefixSum -> f (Entity NoPrefixSum)

PersistField NoPrefixSum

Methods

toPersistValue :: NoPrefixSum -> PersistValue

fromPersistValue :: PersistValue -> Either Text NoPrefixSum

ToBackendKey SqlBackend NoPrefixSum

Methods

toBackendKey :: Key NoPrefixSum -> BackendKey SqlBackend

fromBackendKey :: BackendKey SqlBackend -> Key NoPrefixSum

Eq (Key NoPrefixSum)

Methods

(==) :: Key NoPrefixSum -> Key NoPrefixSum -> Bool

(/=) :: Key NoPrefixSum -> Key NoPrefixSum -> Bool

Ord (Key NoPrefixSum)

Methods

compare :: Key NoPrefixSum -> Key NoPrefixSum -> Ordering

(<) :: Key NoPrefixSum -> Key NoPrefixSum -> Bool

(<=) :: Key NoPrefixSum -> Key NoPrefixSum -> Bool

(>) :: Key NoPrefixSum -> Key NoPrefixSum -> Bool

(>=) :: Key NoPrefixSum -> Key NoPrefixSum -> Bool

max :: Key NoPrefixSum -> Key NoPrefixSum -> Key NoPrefixSum

min :: Key NoPrefixSum -> Key NoPrefixSum -> Key NoPrefixSum

Read (Key NoPrefixSum)

Methods

readsPrec :: Int -> ReadS (Key NoPrefixSum)

readList :: ReadS [Key NoPrefixSum]

readPrec :: ReadPrec (Key NoPrefixSum)

readListPrec :: ReadPrec [Key NoPrefixSum]

Show (Key NoPrefixSum)

Methods

showsPrec :: Int -> Key NoPrefixSum -> ShowS

show :: Key NoPrefixSum -> String

showList :: [Key NoPrefixSum] -> ShowS

ToJSON (Key NoPrefixSum)

Methods

toJSON :: Key NoPrefixSum -> Value

toEncoding :: Key NoPrefixSum -> Encoding

toJSONList :: [Key NoPrefixSum] -> Value

toEncodingList :: [Key NoPrefixSum] -> Encoding

FromJSON (Key NoPrefixSum)

Methods

parseJSON :: Value -> Parser (Key NoPrefixSum)

parseJSONList :: Value -> Parser [Key NoPrefixSum]

ToHttpApiData (Key NoPrefixSum)

Methods

toUrlPiece :: Key NoPrefixSum -> Text

toEncodedUrlPiece :: Key NoPrefixSum -> Builder

toHeader :: Key NoPrefixSum -> ByteString

toQueryParam :: Key NoPrefixSum -> Text

FromHttpApiData (Key NoPrefixSum)

Methods

parseUrlPiece :: Text -> Either Text (Key NoPrefixSum)

parseHeader :: ByteString -> Either Text (Key NoPrefixSum)

parseQueryParam :: Text -> Either Text (Key NoPrefixSum)

PathPiece (Key NoPrefixSum)

Methods

fromPathPiece :: Text -> Maybe (Key NoPrefixSum)

toPathPiece :: Key NoPrefixSum -> Text

PersistFieldSql (Key NoPrefixSum)

Methods

sqlType :: Proxy * (Key NoPrefixSum) -> SqlType

PersistField (Key NoPrefixSum)

Methods

toPersistValue :: Key NoPrefixSum -> PersistValue

fromPersistValue :: PersistValue -> Either Text (Key NoPrefixSum)

data Unique NoPrefixSum

data Unique NoPrefixSum

data EntityField NoPrefixSum

data EntityField NoPrefixSum where

• NoPrefixSumId :: EntityField NoPrefixSum typ
• UnprefixedLeft :: EntityField NoPrefixSum typ
• UnprefixedRight :: EntityField NoPrefixSum typ

data Key NoPrefixSum

data Key NoPrefixSum = NoPrefixSumKey {

• unNoPrefixSumKey :: BackendKey SqlBackend

}

type PersistEntityBackend NoPrefixSum

type PersistEntityBackend NoPrefixSum = SqlBackend

type NoPrefixSumId = Key NoPrefixSum

noPrefixMigrate :: Migration

cleanDB :: (MonadIO m, PersistQuery backend, PersistEntityBackend EmailPT ~ backend) => ReaderT backend m ()

catchPersistException :: MonadUnliftIO m => m a -> b -> m b

specs :: Spec

newtype ReverseFieldOrder a

Reverses the order of the fields of an entity. Used to test ?? placeholders of rawSql.

Constructors

RFO

Fields

• unRFO :: a

Instances

Eq (Key (ReverseFieldOrder a))

Methods

(==) :: Key (ReverseFieldOrder a) -> Key (ReverseFieldOrder a) -> Bool

(/=) :: Key (ReverseFieldOrder a) -> Key (ReverseFieldOrder a) -> Bool

Eq a => Eq (ReverseFieldOrder a)

Methods

(==) :: ReverseFieldOrder a -> ReverseFieldOrder a -> Bool

(/=) :: ReverseFieldOrder a -> ReverseFieldOrder a -> Bool

Ord (Key (ReverseFieldOrder a))

Methods

compare :: Key (ReverseFieldOrder a) -> Key (ReverseFieldOrder a) -> Ordering

(<) :: Key (ReverseFieldOrder a) -> Key (ReverseFieldOrder a) -> Bool

(<=) :: Key (ReverseFieldOrder a) -> Key (ReverseFieldOrder a) -> Bool

(>) :: Key (ReverseFieldOrder a) -> Key (ReverseFieldOrder a) -> Bool

(>=) :: Key (ReverseFieldOrder a) -> Key (ReverseFieldOrder a) -> Bool

max :: Key (ReverseFieldOrder a) -> Key (ReverseFieldOrder a) -> Key (ReverseFieldOrder a)

min :: Key (ReverseFieldOrder a) -> Key (ReverseFieldOrder a) -> Key (ReverseFieldOrder a)

Read (Key (ReverseFieldOrder a))

Methods

readsPrec :: Int -> ReadS (Key (ReverseFieldOrder a))

readList :: ReadS [Key (ReverseFieldOrder a)]

readPrec :: ReadPrec (Key (ReverseFieldOrder a))

readListPrec :: ReadPrec [Key (ReverseFieldOrder a)]

Show (Key (ReverseFieldOrder a))

Methods

showsPrec :: Int -> Key (ReverseFieldOrder a) -> ShowS

show :: Key (ReverseFieldOrder a) -> String

showList :: [Key (ReverseFieldOrder a)] -> ShowS

Show a => Show (ReverseFieldOrder a)

Methods

showsPrec :: Int -> ReverseFieldOrder a -> ShowS

show :: ReverseFieldOrder a -> String

showList :: [ReverseFieldOrder a] -> ShowS

ToJSON (Key (ReverseFieldOrder a))

Methods

toJSON :: Key (ReverseFieldOrder a) -> Value

toEncoding :: Key (ReverseFieldOrder a) -> Encoding

toJSONList :: [Key (ReverseFieldOrder a)] -> Value

toEncodingList :: [Key (ReverseFieldOrder a)] -> Encoding

FromJSON (Key (ReverseFieldOrder a))

Methods

parseJSON :: Value -> Parser (Key (ReverseFieldOrder a))

parseJSONList :: Value -> Parser [Key (ReverseFieldOrder a)]

PersistFieldSql (Key (ReverseFieldOrder a))

Methods

sqlType :: Proxy * (Key (ReverseFieldOrder a)) -> SqlType

PersistEntity a => PersistEntity (ReverseFieldOrder a)

Associated Types

type PersistEntityBackend (ReverseFieldOrder a) :: *

data Key (ReverseFieldOrder a) :: *

data EntityField (ReverseFieldOrder a) a :: *

data Unique (ReverseFieldOrder a) :: *

Methods

keyToValues :: Key (ReverseFieldOrder a) -> [PersistValue]

keyFromValues :: [PersistValue] -> Either Text (Key (ReverseFieldOrder a))

persistIdField :: EntityField (ReverseFieldOrder a) (Key (ReverseFieldOrder a))

entityDef :: Monad m => m (ReverseFieldOrder a) -> EntityDef

persistFieldDef :: EntityField (ReverseFieldOrder a) typ -> FieldDef

toPersistFields :: ReverseFieldOrder a -> [SomePersistField]

fromPersistValues :: [PersistValue] -> Either Text (ReverseFieldOrder a)

persistUniqueKeys :: ReverseFieldOrder a -> [Unique (ReverseFieldOrder a)]

persistUniqueToFieldNames :: Unique (ReverseFieldOrder a) -> [(HaskellName, DBName)]

persistUniqueToValues :: Unique (ReverseFieldOrder a) -> [PersistValue]

fieldLens :: EntityField (ReverseFieldOrder a) field -> forall (f :: * -> *). Functor f => (field -> f field) -> Entity (ReverseFieldOrder a) -> f (Entity (ReverseFieldOrder a))

PersistField (Key (ReverseFieldOrder a))

Methods

toPersistValue :: Key (ReverseFieldOrder a) -> PersistValue

fromPersistValue :: PersistValue -> Either Text (Key (ReverseFieldOrder a))

data Unique (ReverseFieldOrder a)

data Unique (ReverseFieldOrder a) = URFO {

• unURFO :: Unique a

}

data EntityField (ReverseFieldOrder a)

data EntityField (ReverseFieldOrder a) = EFRFO {

• unEFRFO :: EntityField a b

}

data Key (ReverseFieldOrder a)

data Key (ReverseFieldOrder a) = RFOKey {

• unRFOKey :: BackendKey SqlBackend

}

type PersistEntityBackend (ReverseFieldOrder a)

type PersistEntityBackend (ReverseFieldOrder a) = PersistEntityBackend a

caseCommitRollback :: Assertion

_polymorphic :: (MonadIO m, PersistQuery backend, BaseBackend backend ~ PersistEntityBackend Pet) => ReaderT backend m ()

type ASetter s t a b = (a -> Identity b) -> s -> Identity t

set :: ASetter s t a b -> b -> s -> t

type Getting r s t a b = (a -> Constant r b) -> s -> Constant r t

view :: s -> Getting a s t a b -> a