Safe Haskell	None
Language	Haskell2010

Init

Contents

Orphan instances

Synopsis

Documentation

(@/=) :: (Eq a, Show a, MonadIO m) => a -> a -> m () infix 1 Source #

(@==) :: (Eq a, Show a, MonadIO m) => a -> a -> m () infix 1 Source #

(==@) :: (Eq a, Show a, MonadIO m) => a -> a -> m () infix 1 Source #

assertNotEqual :: (Eq a, Show a) => String -> a -> a -> Assertion Source #

assertNotEmpty :: (Monad m, MonadIO m) => [a] -> m () Source #

assertEmpty :: (Monad m, MonadIO m) => [a] -> m () Source #

isTravis :: IO Bool Source #

type BackendMonad = SqlBackend Source #

runConn :: MonadUnliftIO m => SqlPersistT (LoggingT m) t -> m () Source #

class Monad m => MonadIO (m :: * -> *) where #

Monads in which IO computations may be embedded. Any monad built by applying a sequence of monad transformers to the IO monad will be an instance of this class.

Instances should satisfy the following laws, which state that liftIO is a transformer of monads:

```
liftIO . return = return
```

liftIO (m >>= f) = liftIO m >>= (liftIO . f)

Minimal complete definition

liftIO

Methods

liftIO :: IO a -> m a #

Lift a computation from the IO monad.

Instances

MonadIO IO	Since: 4.9.0.0
Methods liftIO :: IO a -> IO a #
MonadIO m => MonadIO (ResourceT m)
Methods liftIO :: IO a -> ResourceT m a #
MonadIO m => MonadIO (NoLoggingT m)
Methods liftIO :: IO a -> NoLoggingT m a #
MonadIO m => MonadIO (WriterLoggingT m)
Methods liftIO :: IO a -> WriterLoggingT m a #
MonadIO m => MonadIO (LoggingT m)
Methods liftIO :: IO a -> LoggingT m a #
(Monoid w, MonadIO m) => MonadIO (WriterT w m)
Methods liftIO :: IO a -> WriterT w m a #
(Error e, MonadIO m) => MonadIO (ErrorT e m)
Methods liftIO :: IO a -> ErrorT e m a #
MonadIO m => MonadIO (IdentityT * m)
Methods liftIO :: IO a -> IdentityT * m a #
MonadIO m => MonadIO (ReaderT * r m)
Methods liftIO :: IO a -> ReaderT * r m a #
MonadIO m => MonadIO (ConduitT i o m)
Methods liftIO :: IO a -> ConduitT i o m a #
MonadIO m => MonadIO (Pipe l i o u m)
Methods liftIO :: IO a -> Pipe l i o u m a #

persistSettings :: MkPersistSettings Source #

data MkPersistSettings :: * #

Settings to be passed to the mkPersist function.

db :: SqlPersistT (LoggingT (ResourceT IO)) () -> Assertion Source #

sqlite_database :: SqliteConnectionInfo Source #

sqlite_database_file :: Text Source #

data family BackendKey backend :: * #

Instances

data BackendKey SqlBackend
data BackendKey SqlBackend = SqlBackendKey { unSqlBackendKey :: Int64 }
data BackendKey SqlReadBackend
data BackendKey SqlReadBackend = SqlReadBackendKey { unSqlReadBackendKey :: Int64 }
data BackendKey SqlWriteBackend
data BackendKey SqlWriteBackend = SqlWriteBackendKey { unSqlWriteBackendKey :: Int64 }

generateKey :: IO (BackendKey SqlBackend) Source #

(<$>) :: Functor f => (a -> b) -> f a -> f b infixl 4 #

An infix synonym for fmap.

The name of this operator is an allusion to $. Note the similarities between their types:

 ($)  ::              (a -> b) ->   a ->   b
(<$>) :: Functor f => (a -> b) -> f a -> f b

Whereas $ is function application, <$> is function application lifted over a Functor.

Examples

Convert from a Maybe Int to a Maybe String using show:

>>> show <$> Nothing
Nothing
>>> show <$> Just 3
Just "3"

Convert from an Either Int Int to an Either Int String using show:

>>> show <$> Left 17
Left 17
>>> show <$> Right 17
Right "17"

Double each element of a list:

>>> (*2) <$> [1,2,3]
[2,4,6]

Apply even to the second element of a pair:

>>> even <$> (2,2)
(2,True)

(<*>) :: Applicative f => forall a b. f (a -> b) -> f a -> f b infixl 4 #

Sequential application.

A few functors support an implementation of <*> that is more efficient than the default one.

module Database.Persist

module Test.Hspec

module Test.HUnit

liftIO :: MonadIO m => forall a. IO a -> m a #

Lift a computation from the IO monad.

mkPersist :: MkPersistSettings -> [EntityDef] -> Q [Dec] #

Create data types and appropriate PersistEntity instances for the given EntityDefs. Works well with the persist quasi-quoter.

mkMigrate :: String -> [EntityDef] -> Q [Dec] #

Creates a single function to perform all migrations for the entities defined here. One thing to be aware of is dependencies: if you have entities with foreign references, make sure to place those definitions after the entities they reference.

share :: [[EntityDef] -> Q [Dec]] -> [EntityDef] -> Q [Dec] #

Apply the given list of functions to the same EntityDefs.

This function is useful for cases such as:

>>> share [mkSave "myDefs", mkPersist sqlSettings] [persistLowerCase|...|]

sqlSettings :: MkPersistSettings #

Use the SqlPersist backend.

persistLowerCase :: QuasiQuoter #

Apply persistWith to lowerCaseSettings.

persistUpperCase :: QuasiQuoter #

Apply persistWith to upperCaseSettings.

data Int32 :: * #

32-bit signed integer type

Instances

Bounded Int32	Since: 2.1
Methods minBound :: Int32 # maxBound :: Int32 #
Enum Int32	Since: 2.1
Methods succ :: Int32 -> Int32 # pred :: Int32 -> Int32 # toEnum :: Int -> Int32 # fromEnum :: Int32 -> Int # enumFrom :: Int32 -> [Int32] # enumFromThen :: Int32 -> Int32 -> [Int32] # enumFromTo :: Int32 -> Int32 -> [Int32] # enumFromThenTo :: Int32 -> Int32 -> Int32 -> [Int32] #
Eq Int32	Since: 2.1
Methods (==) :: Int32 -> Int32 -> Bool # (/=) :: Int32 -> Int32 -> Bool #
Integral Int32	Since: 2.1
Methods quot :: Int32 -> Int32 -> Int32 # rem :: Int32 -> Int32 -> Int32 # div :: Int32 -> Int32 -> Int32 # mod :: Int32 -> Int32 -> Int32 # quotRem :: Int32 -> Int32 -> (Int32, Int32) # divMod :: Int32 -> Int32 -> (Int32, Int32) # toInteger :: Int32 -> Integer #
Num Int32	Since: 2.1
Methods (+) :: Int32 -> Int32 -> Int32 # (-) :: Int32 -> Int32 -> Int32 # (*) :: Int32 -> Int32 -> Int32 # negate :: Int32 -> Int32 # abs :: Int32 -> Int32 # signum :: Int32 -> Int32 # fromInteger :: Integer -> Int32 #
Ord Int32	Since: 2.1
Methods compare :: Int32 -> Int32 -> Ordering # (<) :: Int32 -> Int32 -> Bool # (<=) :: Int32 -> Int32 -> Bool # (>) :: Int32 -> Int32 -> Bool # (>=) :: Int32 -> Int32 -> Bool # max :: Int32 -> Int32 -> Int32 # min :: Int32 -> Int32 -> Int32 #
Read Int32	Since: 2.1
Methods readsPrec :: Int -> ReadS Int32 # readList :: ReadS [Int32] # readPrec :: ReadPrec Int32 # readListPrec :: ReadPrec [Int32] #
Real Int32	Since: 2.1
Methods toRational :: Int32 -> Rational #
Show Int32	Since: 2.1
Methods showsPrec :: Int -> Int32 -> ShowS # show :: Int32 -> String # showList :: [Int32] -> ShowS #
Ix Int32	Since: 2.1
Methods range :: (Int32, Int32) -> [Int32] # index :: (Int32, Int32) -> Int32 -> Int # unsafeIndex :: (Int32, Int32) -> Int32 -> Int inRange :: (Int32, Int32) -> Int32 -> Bool # rangeSize :: (Int32, Int32) -> Int # unsafeRangeSize :: (Int32, Int32) -> Int
Lift Int32
Methods lift :: Int32 -> Q Exp #
Arbitrary Int32
Methods arbitrary :: Gen Int32 # shrink :: Int32 -> [Int32] #
CoArbitrary Int32
Methods coarbitrary :: Int32 -> Gen b -> Gen b #
Hashable Int32
Methods hashWithSalt :: Int -> Int32 -> Int # hash :: Int32 -> Int #
ToJSON Int32
Methods toJSON :: Int32 -> Value # toEncoding :: Int32 -> Encoding # toJSONList :: [Int32] -> Value # toEncodingList :: [Int32] -> Encoding #
ToJSONKey Int32
Methods toJSONKey :: ToJSONKeyFunction Int32 # toJSONKeyList :: ToJSONKeyFunction [Int32] #
FromJSON Int32
Methods parseJSON :: Value -> Parser Int32 # parseJSONList :: Value -> Parser [Int32] #
FromJSONKey Int32
Methods fromJSONKey :: FromJSONKeyFunction Int32 # fromJSONKeyList :: FromJSONKeyFunction [Int32] #
Storable Int32	Since: 2.1
Methods sizeOf :: Int32 -> Int # alignment :: Int32 -> Int # peekElemOff :: Ptr Int32 -> Int -> IO Int32 # pokeElemOff :: Ptr Int32 -> Int -> Int32 -> IO () # peekByteOff :: Ptr b -> Int -> IO Int32 # pokeByteOff :: Ptr b -> Int -> Int32 -> IO () # peek :: Ptr Int32 -> IO Int32 # poke :: Ptr Int32 -> Int32 -> IO () #
Bits Int32	Since: 2.1
Methods (.&.) :: Int32 -> Int32 -> Int32 # (.\|.) :: Int32 -> Int32 -> Int32 # xor :: Int32 -> Int32 -> Int32 # complement :: Int32 -> Int32 # shift :: Int32 -> Int -> Int32 # rotate :: Int32 -> Int -> Int32 # zeroBits :: Int32 # bit :: Int -> Int32 # setBit :: Int32 -> Int -> Int32 # clearBit :: Int32 -> Int -> Int32 # complementBit :: Int32 -> Int -> Int32 # testBit :: Int32 -> Int -> Bool # bitSizeMaybe :: Int32 -> Maybe Int # bitSize :: Int32 -> Int # isSigned :: Int32 -> Bool # shiftL :: Int32 -> Int -> Int32 # unsafeShiftL :: Int32 -> Int -> Int32 # shiftR :: Int32 -> Int -> Int32 # unsafeShiftR :: Int32 -> Int -> Int32 # rotateL :: Int32 -> Int -> Int32 # rotateR :: Int32 -> Int -> Int32 # popCount :: Int32 -> Int #
FiniteBits Int32	Since: 4.6.0.0
Methods finiteBitSize :: Int32 -> Int # countLeadingZeros :: Int32 -> Int # countTrailingZeros :: Int32 -> Int #
ToValue Int32
Methods toValue :: Int32 -> AttributeValue # preEscapedToValue :: Int32 -> AttributeValue #
ToMarkup Int32
Methods toMarkup :: Int32 -> Markup # preEscapedToMarkup :: Int32 -> Markup #
ToHttpApiData Int32
Methods toUrlPiece :: Int32 -> Text # toEncodedUrlPiece :: Int32 -> Builder # toHeader :: Int32 -> ByteString # toQueryParam :: Int32 -> Text #
FromHttpApiData Int32
Methods parseUrlPiece :: Text -> Either Text Int32 # parseHeader :: ByteString -> Either Text Int32 # parseQueryParam :: Text -> Either Text Int32 #
PathPiece Int32
Methods fromPathPiece :: Text -> Maybe Int32 # toPathPiece :: Int32 -> Text #
PersistFieldSql Int32
Methods sqlType :: Proxy * Int32 -> SqlType #
PersistField Int32
Methods toPersistValue :: Int32 -> PersistValue # fromPersistValue :: PersistValue -> Either Text Int32 #
Prim Int32
Methods sizeOf# :: Int32 -> Int# # alignment# :: Int32 -> Int# # indexByteArray# :: ByteArray# -> Int# -> Int32 # readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Int32#) # writeByteArray# :: MutableByteArray# s -> Int# -> Int32 -> State# s -> State# s # setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Int32 -> State# s -> State# s # indexOffAddr# :: Addr# -> Int# -> Int32 # readOffAddr# :: Addr# -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Int32#) # writeOffAddr# :: Addr# -> Int# -> Int32 -> State# s -> State# s # setOffAddr# :: Addr# -> Int# -> Int# -> Int32 -> State# s -> State# s #
Random Int32
Methods randomR :: RandomGen g => (Int32, Int32) -> g -> (Int32, g) # random :: RandomGen g => g -> (Int32, g) # randomRs :: RandomGen g => (Int32, Int32) -> g -> [Int32] # randoms :: RandomGen g => g -> [Int32] # randomRIO :: (Int32, Int32) -> IO Int32 # randomIO :: IO Int32 #
Unbox Int32

Vector Vector Int32
Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Int32 -> m (Vector Int32) # basicUnsafeThaw :: PrimMonad m => Vector Int32 -> m (Mutable Vector (PrimState m) Int32) # basicLength :: Vector Int32 -> Int # basicUnsafeSlice :: Int -> Int -> Vector Int32 -> Vector Int32 # basicUnsafeIndexM :: Monad m => Vector Int32 -> Int -> m Int32 # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Int32 -> Vector Int32 -> m () # elemseq :: Vector Int32 -> Int32 -> b -> b #
MVector MVector Int32
Methods basicLength :: MVector s Int32 -> Int # basicUnsafeSlice :: Int -> Int -> MVector s Int32 -> MVector s Int32 # basicOverlaps :: MVector s Int32 -> MVector s Int32 -> Bool # basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Int32) # basicInitialize :: PrimMonad m => MVector (PrimState m) Int32 -> m () # basicUnsafeReplicate :: PrimMonad m => Int -> Int32 -> m (MVector (PrimState m) Int32) # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Int32 -> Int -> m Int32 # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Int32 -> Int -> Int32 -> m () # basicClear :: PrimMonad m => MVector (PrimState m) Int32 -> m () # basicSet :: PrimMonad m => MVector (PrimState m) Int32 -> Int32 -> m () # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Int32 -> MVector (PrimState m) Int32 -> m () # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Int32 -> MVector (PrimState m) Int32 -> m () # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Int32 -> Int -> m (MVector (PrimState m) Int32) #
data Vector Int32
data Vector Int32 = V_Int32 (Vector Int32)
data MVector s Int32
data MVector s Int32 = MV_Int32 (MVector s Int32)

data Int64 :: * #

64-bit signed integer type

Instances

Bounded Int64	Since: 2.1
Methods minBound :: Int64 # maxBound :: Int64 #
Enum Int64	Since: 2.1
Methods succ :: Int64 -> Int64 # pred :: Int64 -> Int64 # toEnum :: Int -> Int64 # fromEnum :: Int64 -> Int # enumFrom :: Int64 -> [Int64] # enumFromThen :: Int64 -> Int64 -> [Int64] # enumFromTo :: Int64 -> Int64 -> [Int64] # enumFromThenTo :: Int64 -> Int64 -> Int64 -> [Int64] #
Eq Int64	Since: 2.1
Methods (==) :: Int64 -> Int64 -> Bool # (/=) :: Int64 -> Int64 -> Bool #
Integral Int64	Since: 2.1
Methods quot :: Int64 -> Int64 -> Int64 # rem :: Int64 -> Int64 -> Int64 # div :: Int64 -> Int64 -> Int64 # mod :: Int64 -> Int64 -> Int64 # quotRem :: Int64 -> Int64 -> (Int64, Int64) # divMod :: Int64 -> Int64 -> (Int64, Int64) # toInteger :: Int64 -> Integer #
Num Int64	Since: 2.1
Methods (+) :: Int64 -> Int64 -> Int64 # (-) :: Int64 -> Int64 -> Int64 # (*) :: Int64 -> Int64 -> Int64 # negate :: Int64 -> Int64 # abs :: Int64 -> Int64 # signum :: Int64 -> Int64 # fromInteger :: Integer -> Int64 #
Ord Int64	Since: 2.1
Methods compare :: Int64 -> Int64 -> Ordering # (<) :: Int64 -> Int64 -> Bool # (<=) :: Int64 -> Int64 -> Bool # (>) :: Int64 -> Int64 -> Bool # (>=) :: Int64 -> Int64 -> Bool # max :: Int64 -> Int64 -> Int64 # min :: Int64 -> Int64 -> Int64 #
Read Int64	Since: 2.1
Methods readsPrec :: Int -> ReadS Int64 # readList :: ReadS [Int64] # readPrec :: ReadPrec Int64 # readListPrec :: ReadPrec [Int64] #
Real Int64	Since: 2.1
Methods toRational :: Int64 -> Rational #
Show Int64	Since: 2.1
Methods showsPrec :: Int -> Int64 -> ShowS # show :: Int64 -> String # showList :: [Int64] -> ShowS #
Ix Int64	Since: 2.1
Methods range :: (Int64, Int64) -> [Int64] # index :: (Int64, Int64) -> Int64 -> Int # unsafeIndex :: (Int64, Int64) -> Int64 -> Int inRange :: (Int64, Int64) -> Int64 -> Bool # rangeSize :: (Int64, Int64) -> Int # unsafeRangeSize :: (Int64, Int64) -> Int
Lift Int64
Methods lift :: Int64 -> Q Exp #
Arbitrary Int64
Methods arbitrary :: Gen Int64 # shrink :: Int64 -> [Int64] #
CoArbitrary Int64
Methods coarbitrary :: Int64 -> Gen b -> Gen b #
Hashable Int64
Methods hashWithSalt :: Int -> Int64 -> Int # hash :: Int64 -> Int #
ToJSON Int64
Methods toJSON :: Int64 -> Value # toEncoding :: Int64 -> Encoding # toJSONList :: [Int64] -> Value # toEncodingList :: [Int64] -> Encoding #
ToJSONKey Int64
Methods toJSONKey :: ToJSONKeyFunction Int64 # toJSONKeyList :: ToJSONKeyFunction [Int64] #
FromJSON Int64
Methods parseJSON :: Value -> Parser Int64 # parseJSONList :: Value -> Parser [Int64] #
FromJSONKey Int64
Methods fromJSONKey :: FromJSONKeyFunction Int64 # fromJSONKeyList :: FromJSONKeyFunction [Int64] #
Storable Int64	Since: 2.1
Methods sizeOf :: Int64 -> Int # alignment :: Int64 -> Int # peekElemOff :: Ptr Int64 -> Int -> IO Int64 # pokeElemOff :: Ptr Int64 -> Int -> Int64 -> IO () # peekByteOff :: Ptr b -> Int -> IO Int64 # pokeByteOff :: Ptr b -> Int -> Int64 -> IO () # peek :: Ptr Int64 -> IO Int64 # poke :: Ptr Int64 -> Int64 -> IO () #
Bits Int64	Since: 2.1
Methods (.&.) :: Int64 -> Int64 -> Int64 # (.\|.) :: Int64 -> Int64 -> Int64 # xor :: Int64 -> Int64 -> Int64 # complement :: Int64 -> Int64 # shift :: Int64 -> Int -> Int64 # rotate :: Int64 -> Int -> Int64 # zeroBits :: Int64 # bit :: Int -> Int64 # setBit :: Int64 -> Int -> Int64 # clearBit :: Int64 -> Int -> Int64 # complementBit :: Int64 -> Int -> Int64 # testBit :: Int64 -> Int -> Bool # bitSizeMaybe :: Int64 -> Maybe Int # bitSize :: Int64 -> Int # isSigned :: Int64 -> Bool # shiftL :: Int64 -> Int -> Int64 # unsafeShiftL :: Int64 -> Int -> Int64 # shiftR :: Int64 -> Int -> Int64 # unsafeShiftR :: Int64 -> Int -> Int64 # rotateL :: Int64 -> Int -> Int64 # rotateR :: Int64 -> Int -> Int64 # popCount :: Int64 -> Int #
FiniteBits Int64	Since: 4.6.0.0
Methods finiteBitSize :: Int64 -> Int # countLeadingZeros :: Int64 -> Int # countTrailingZeros :: Int64 -> Int #
ToValue Int64
Methods toValue :: Int64 -> AttributeValue # preEscapedToValue :: Int64 -> AttributeValue #
ToMarkup Int64
Methods toMarkup :: Int64 -> Markup # preEscapedToMarkup :: Int64 -> Markup #
ToHttpApiData Int64
Methods toUrlPiece :: Int64 -> Text # toEncodedUrlPiece :: Int64 -> Builder # toHeader :: Int64 -> ByteString # toQueryParam :: Int64 -> Text #
FromHttpApiData Int64
Methods parseUrlPiece :: Text -> Either Text Int64 # parseHeader :: ByteString -> Either Text Int64 # parseQueryParam :: Text -> Either Text Int64 #
PathPiece Int64
Methods fromPathPiece :: Text -> Maybe Int64 # toPathPiece :: Int64 -> Text #
PersistFieldSql Int64
Methods sqlType :: Proxy * Int64 -> SqlType #
PersistField Int64
Methods toPersistValue :: Int64 -> PersistValue # fromPersistValue :: PersistValue -> Either Text Int64 #
Prim Int64
Methods sizeOf# :: Int64 -> Int# # alignment# :: Int64 -> Int# # indexByteArray# :: ByteArray# -> Int# -> Int64 # readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Int64#) # writeByteArray# :: MutableByteArray# s -> Int# -> Int64 -> State# s -> State# s # setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Int64 -> State# s -> State# s # indexOffAddr# :: Addr# -> Int# -> Int64 # readOffAddr# :: Addr# -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Int64#) # writeOffAddr# :: Addr# -> Int# -> Int64 -> State# s -> State# s # setOffAddr# :: Addr# -> Int# -> Int# -> Int64 -> State# s -> State# s #
Random Int64
Methods randomR :: RandomGen g => (Int64, Int64) -> g -> (Int64, g) # random :: RandomGen g => g -> (Int64, g) # randomRs :: RandomGen g => (Int64, Int64) -> g -> [Int64] # randoms :: RandomGen g => g -> [Int64] # randomRIO :: (Int64, Int64) -> IO Int64 # randomIO :: IO Int64 #
Unbox Int64

Vector Vector Int64
Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Int64 -> m (Vector Int64) # basicUnsafeThaw :: PrimMonad m => Vector Int64 -> m (Mutable Vector (PrimState m) Int64) # basicLength :: Vector Int64 -> Int # basicUnsafeSlice :: Int -> Int -> Vector Int64 -> Vector Int64 # basicUnsafeIndexM :: Monad m => Vector Int64 -> Int -> m Int64 # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Int64 -> Vector Int64 -> m () # elemseq :: Vector Int64 -> Int64 -> b -> b #
MVector MVector Int64
Methods basicLength :: MVector s Int64 -> Int # basicUnsafeSlice :: Int -> Int -> MVector s Int64 -> MVector s Int64 # basicOverlaps :: MVector s Int64 -> MVector s Int64 -> Bool # basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Int64) # basicInitialize :: PrimMonad m => MVector (PrimState m) Int64 -> m () # basicUnsafeReplicate :: PrimMonad m => Int -> Int64 -> m (MVector (PrimState m) Int64) # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Int64 -> Int -> m Int64 # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Int64 -> Int -> Int64 -> m () # basicClear :: PrimMonad m => MVector (PrimState m) Int64 -> m () # basicSet :: PrimMonad m => MVector (PrimState m) Int64 -> Int64 -> m () # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Int64 -> MVector (PrimState m) Int64 -> m () # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Int64 -> MVector (PrimState m) Int64 -> m () # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Int64 -> Int -> m (MVector (PrimState m) Int64) #
data Vector Int64
data Vector Int64 = V_Int64 (Vector Int64)
data MVector s Int64
data MVector s Int64 = MV_Int64 (MVector s Int64)

data Text :: * #

A space efficient, packed, unboxed Unicode text type.

Instances

Hashable Text
Methods hashWithSalt :: Int -> Text -> Int # hash :: Text -> Int #
ToJSON Text
Methods toJSON :: Text -> Value # toEncoding :: Text -> Encoding # toJSONList :: [Text] -> Value # toEncodingList :: [Text] -> Encoding #
KeyValue Pair
Methods (.=) :: ToJSON v => Text -> v -> Pair #
ToJSONKey Text
Methods toJSONKey :: ToJSONKeyFunction Text # toJSONKeyList :: ToJSONKeyFunction [Text] #
FromJSON Text
Methods parseJSON :: Value -> Parser Text # parseJSONList :: Value -> Parser [Text] #
FromJSONKey Text
Methods fromJSONKey :: FromJSONKeyFunction Text # fromJSONKeyList :: FromJSONKeyFunction [Text] #
Chunk Text
Associated Types type ChunkElem Text :: * # Methods nullChunk :: Text -> Bool # pappendChunk :: State Text -> Text -> State Text # atBufferEnd :: Text -> State Text -> Pos # bufferElemAt :: Text -> Pos -> State Text -> Maybe (ChunkElem Text, Int) # chunkElemToChar :: Text -> ChunkElem Text -> Char #
ToValue Text
Methods toValue :: Text -> AttributeValue # preEscapedToValue :: Text -> AttributeValue #
ToMarkup Text
Methods toMarkup :: Text -> Markup # preEscapedToMarkup :: Text -> Markup #
ToLogStr Text
Methods toLogStr :: Text -> LogStr #
ToHttpApiData Text
Methods toUrlPiece :: Text -> Text # toEncodedUrlPiece :: Text -> Builder # toHeader :: Text -> ByteString # toQueryParam :: Text -> Text #
FromHttpApiData Text
Methods parseUrlPiece :: Text -> Either Text Text # parseHeader :: ByteString -> Either Text Text # parseQueryParam :: Text -> Either Text Text #
PathPiece Text
Methods fromPathPiece :: Text -> Maybe Text # toPathPiece :: Text -> Text #
PersistFieldSql Text
Methods sqlType :: Proxy * Text -> SqlType #
PersistField Text
Methods toPersistValue :: Text -> PersistValue # fromPersistValue :: PersistValue -> Either Text Text #
Lift' Text
Methods lift' :: Text -> Q Exp
FromPairs Value (DList Pair)
Methods fromPairs :: DList Pair -> Value
ToJSON v => GKeyValue v (DList Pair)
Methods gPair :: String -> v -> DList Pair
PersistFieldSql v => PersistFieldSql (Map Text v)
Methods sqlType :: Proxy * (Map Text v) -> SqlType #
PersistField v => PersistField (Map Text v)
Methods toPersistValue :: Map Text v -> PersistValue # fromPersistValue :: PersistValue -> Either Text (Map Text v) #
type State Text
type State Text = Buffer
type ChunkElem Text
type ChunkElem Text = Char
type Item Text
type Item Text = Char

module Control.Monad.Trans.Reader

module Control.Monad

module Database.Persist.Sql

data ByteString :: * #

A space-efficient representation of a Word8 vector, supporting many efficient operations.

A ByteString contains 8-bit bytes, or by using the operations from Data.ByteString.Char8 it can be interpreted as containing 8-bit characters.

Instances

Eq ByteString
Methods (==) :: ByteString -> ByteString -> Bool # (/=) :: ByteString -> ByteString -> Bool #
Data ByteString
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ByteString -> c ByteString # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ByteString # toConstr :: ByteString -> Constr # dataTypeOf :: ByteString -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c ByteString) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ByteString) # gmapT :: (forall b. Data b => b -> b) -> ByteString -> ByteString # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ByteString -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ByteString -> r # gmapQ :: (forall d. Data d => d -> u) -> ByteString -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ByteString -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ByteString -> m ByteString # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ByteString -> m ByteString # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ByteString -> m ByteString #
Ord ByteString
Methods compare :: ByteString -> ByteString -> Ordering # (<) :: ByteString -> ByteString -> Bool # (<=) :: ByteString -> ByteString -> Bool # (>) :: ByteString -> ByteString -> Bool # (>=) :: ByteString -> ByteString -> Bool # max :: ByteString -> ByteString -> ByteString # min :: ByteString -> ByteString -> ByteString #
Read ByteString
Methods readsPrec :: Int -> ReadS ByteString # readList :: ReadS [ByteString] # readPrec :: ReadPrec ByteString # readListPrec :: ReadPrec [ByteString] #
Show ByteString
Methods showsPrec :: Int -> ByteString -> ShowS # show :: ByteString -> String # showList :: [ByteString] -> ShowS #
IsString ByteString
Methods fromString :: String -> ByteString #
Semigroup ByteString
Methods (<>) :: ByteString -> ByteString -> ByteString # sconcat :: NonEmpty ByteString -> ByteString # stimes :: Integral b => b -> ByteString -> ByteString #
Monoid ByteString
Methods mempty :: ByteString # mappend :: ByteString -> ByteString -> ByteString # mconcat :: [ByteString] -> ByteString #
Hashable ByteString
Methods hashWithSalt :: Int -> ByteString -> Int # hash :: ByteString -> Int #
Chunk ByteString
Associated Types type ChunkElem ByteString :: * # Methods nullChunk :: ByteString -> Bool # pappendChunk :: State ByteString -> ByteString -> State ByteString # atBufferEnd :: ByteString -> State ByteString -> Pos # bufferElemAt :: ByteString -> Pos -> State ByteString -> Maybe (ChunkElem ByteString, Int) # chunkElemToChar :: ByteString -> ChunkElem ByteString -> Char #
NFData ByteString
Methods rnf :: ByteString -> () #
ToLogStr ByteString
Methods toLogStr :: ByteString -> LogStr #
PersistFieldSql ByteString
Methods sqlType :: Proxy * ByteString -> SqlType #
PersistField ByteString
Methods toPersistValue :: ByteString -> PersistValue # fromPersistValue :: PersistValue -> Either Text ByteString #
type State ByteString
type State ByteString = Buffer
type ChunkElem ByteString
type ChunkElem ByteString = Word8

data SomeException :: * #

The SomeException type is the root of the exception type hierarchy. When an exception of type e is thrown, behind the scenes it is encapsulated in a SomeException.

Instances

Show SomeException	Since: 3.0
Methods showsPrec :: Int -> SomeException -> ShowS # show :: SomeException -> String # showList :: [SomeException] -> ShowS #
Exception SomeException	Since: 3.0
Methods toException :: SomeException -> SomeException # fromException :: SomeException -> Maybe SomeException # displayException :: SomeException -> String #

Orphan instances

Arbitrary PersistValue Source #
Methods arbitrary :: Gen PersistValue # shrink :: PersistValue -> [PersistValue] #
PersistStore backend => Arbitrary (BackendKey backend) Source #
Methods arbitrary :: Gen (BackendKey backend) # shrink :: BackendKey backend -> [BackendKey backend] #