Safe Haskell | None |
---|---|
Language | Haskell2010 |
- newtype Blob = Blob ByteString
- data Bonded a :: * -> *
- data Bool :: *
- data Double :: *
- class IsString a => EncodedString a where
- data Float :: *
- data HashSet a :: * -> *
- data Set a :: * -> *
- data Int :: *
- data Int16 :: *
- data Int32 :: *
- data Int64 :: *
- data Int8 :: *
- data Maybe a :: * -> *
- data Map k a :: * -> * -> *
- newtype Ordinal = Ordinal Word16
- newtype Utf16 = Utf16 ByteString
- newtype Utf8 = Utf8 ByteString
- data Vector a :: * -> *
- data Word16 :: *
- data Word32 :: *
- data Word64 :: *
- data Word8 :: *
- fromString :: IsString a => String -> a
Documentation
Bond "blob" type
Eq Blob Source # | |
Ord Blob Source # | |
Show Blob Source # | |
NFData Blob Source # | |
Hashable Blob Source # | |
BondType Blob Source # | |
bondGet :: (Functor (ReaderM t), Monad (ReaderM t), Protocol t) => BondGet t Blob Source # bondPut :: (Monad (BondPutM t), Protocol t) => Blob -> BondPut t Source # getName :: Proxy * Blob -> Text Source # getQualifiedName :: Proxy * Blob -> Text Source # getElementType :: Proxy * Blob -> ElementTypeInfo Source # | |
Default Blob | |
defaultValue :: Blob Source # equalToDefault :: FieldTypeInfo -> Blob -> Bool |
data Bonded a :: * -> * Source #
Double-precision floating point numbers. It is desirable that this type be at least equal in range and precision to the IEEE double-precision type.
class IsString a => EncodedString a where Source #
Single-precision floating point numbers. It is desirable that this type be at least equal in range and precision to the IEEE single-precision type.
A set of values. A set cannot contain duplicate values.
Foldable HashSet | |
fold :: Monoid m => HashSet m -> m # foldMap :: Monoid m => (a -> m) -> HashSet a -> m # foldr :: (a -> b -> b) -> b -> HashSet a -> b # foldr' :: (a -> b -> b) -> b -> HashSet a -> b # foldl :: (b -> a -> b) -> b -> HashSet a -> b # foldl' :: (b -> a -> b) -> b -> HashSet a -> b # foldr1 :: (a -> a -> a) -> HashSet a -> a # foldl1 :: (a -> a -> a) -> HashSet a -> a # elem :: Eq a => a -> HashSet a -> Bool # maximum :: Ord a => HashSet a -> a # minimum :: Ord a => HashSet a -> a # | |
(Eq a, Hashable a) => IsList (HashSet a) | |
(Hashable a, Eq a) => Eq (HashSet a) | |
(Data a, Eq a, Hashable a) => Data (HashSet a) | |
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HashSet a -> c (HashSet a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HashSet a) # toConstr :: HashSet a -> Constr # dataTypeOf :: HashSet a -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (HashSet a)) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HashSet a)) # gmapT :: (forall b. Data b => b -> b) -> HashSet a -> HashSet a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HashSet a -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HashSet a -> r # gmapQ :: (forall d. Data d => d -> u) -> HashSet a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> HashSet a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HashSet a -> m (HashSet a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HashSet a -> m (HashSet a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HashSet a -> m (HashSet a) # | |
(Eq a, Hashable a, Read a) => Read (HashSet a) | |
Show a => Show (HashSet a) | |
(Hashable a, Eq a) => Semigroup (HashSet a) | |
(Hashable a, Eq a) => Monoid (HashSet a) | |
NFData a => NFData (HashSet a) | |
Hashable a => Hashable (HashSet a) | |
(Eq a, Hashable a, BondType a) => BondType (HashSet a) Source # | |
bondGet :: (Functor (ReaderM t), Monad (ReaderM t), Protocol t) => BondGet t (HashSet a) Source # bondPut :: (Monad (BondPutM t), Protocol t) => HashSet a -> BondPut t Source # getName :: Proxy * (HashSet a) -> Text Source # getQualifiedName :: Proxy * (HashSet a) -> Text Source # getElementType :: Proxy * (HashSet a) -> ElementTypeInfo Source # | |
Default (HashSet a) | |
defaultValue :: HashSet a Source # equalToDefault :: FieldTypeInfo -> HashSet a -> Bool | |
type Item (HashSet a) | |
A set of values a
.
Foldable Set | |
fold :: Monoid m => Set m -> m # foldMap :: Monoid m => (a -> m) -> Set a -> m # foldr :: (a -> b -> b) -> b -> Set a -> b # foldr' :: (a -> b -> b) -> b -> Set a -> b # foldl :: (b -> a -> b) -> b -> Set a -> b # foldl' :: (b -> a -> b) -> b -> Set a -> b # foldr1 :: (a -> a -> a) -> Set a -> a # foldl1 :: (a -> a -> a) -> Set a -> a # elem :: Eq a => a -> Set a -> Bool # maximum :: Ord a => Set a -> a # | |
Ord a => IsList (Set a) | |
Eq a => Eq (Set a) | |
(Data a, Ord a) => Data (Set a) | |
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Set a -> c (Set a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Set a) # dataTypeOf :: Set a -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Set a)) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Set a)) # gmapT :: (forall b. Data b => b -> b) -> Set a -> Set a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Set a -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Set a -> r # gmapQ :: (forall d. Data d => d -> u) -> Set a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Set a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Set a -> m (Set a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Set a -> m (Set a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Set a -> m (Set a) # | |
Ord a => Ord (Set a) | |
(Read a, Ord a) => Read (Set a) | |
Show a => Show (Set a) | |
Ord a => Semigroup (Set a) | |
Ord a => Monoid (Set a) | |
NFData a => NFData (Set a) | |
(Ord a, BondType a) => BondType (Set a) Source # | |
bondGet :: (Functor (ReaderM t), Monad (ReaderM t), Protocol t) => BondGet t (Set a) Source # bondPut :: (Monad (BondPutM t), Protocol t) => Set a -> BondPut t Source # getName :: Proxy * (Set a) -> Text Source # getQualifiedName :: Proxy * (Set a) -> Text Source # getElementType :: Proxy * (Set a) -> ElementTypeInfo Source # | |
Default (Set a) | |
defaultValue :: Set a Source # equalToDefault :: FieldTypeInfo -> Set a -> Bool | |
type Item (Set a) | |
A fixed-precision integer type with at least the range [-2^29 .. 2^29-1]
.
The exact range for a given implementation can be determined by using
minBound
and maxBound
from the Bounded
class.
16-bit signed integer type
32-bit signed integer type
64-bit signed integer type
8-bit signed integer type
The Maybe
type encapsulates an optional value. A value of type
either contains a value of type Maybe
aa
(represented as
),
or it is empty (represented as Just
aNothing
). Using Maybe
is a good way to
deal with errors or exceptional cases without resorting to drastic
measures such as error
.
The Maybe
type is also a monad. It is a simple kind of error
monad, where all errors are represented by Nothing
. A richer
error monad can be built using the Either
type.
Monad Maybe | |
Functor Maybe | |
Applicative Maybe | |
Foldable Maybe | |
fold :: Monoid m => Maybe m -> m # foldMap :: Monoid m => (a -> m) -> Maybe a -> m # foldr :: (a -> b -> b) -> b -> Maybe a -> b # foldr' :: (a -> b -> b) -> b -> Maybe a -> b # foldl :: (b -> a -> b) -> b -> Maybe a -> b # foldl' :: (b -> a -> b) -> b -> Maybe a -> b # foldr1 :: (a -> a -> a) -> Maybe a -> a # foldl1 :: (a -> a -> a) -> Maybe a -> a # elem :: Eq a => a -> Maybe a -> Bool # maximum :: Ord a => Maybe a -> a # minimum :: Ord a => Maybe a -> a # | |
Traversable Maybe | |
Generic1 Maybe | |
Alternative Maybe | |
MonadPlus Maybe | |
Eq1 Maybe | |
Ord1 Maybe | |
Read1 Maybe | |
Show1 Maybe | |
Eq a => Eq (Maybe a) | |
Data a => Data (Maybe a) | |
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Maybe a -> c (Maybe a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Maybe a) # toConstr :: Maybe a -> Constr # dataTypeOf :: Maybe a -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Maybe a)) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Maybe a)) # gmapT :: (forall b. Data b => b -> b) -> Maybe a -> Maybe a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Maybe a -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Maybe a -> r # gmapQ :: (forall d. Data d => d -> u) -> Maybe a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Maybe a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Maybe a -> m (Maybe a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Maybe a -> m (Maybe a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Maybe a -> m (Maybe a) # | |
Ord a => Ord (Maybe a) | |
Show a => Show (Maybe a) | |
Generic (Maybe a) | |
Semigroup a => Semigroup (Maybe a) | |
Monoid a => Monoid (Maybe a) | Lift a semigroup into |
Lift a => Lift (Maybe a) | |
NFData a => NFData (Maybe a) | |
Hashable a => Hashable (Maybe a) | |
BondType a => BondType (Maybe a) Source # | |
bondGet :: (Functor (ReaderM t), Monad (ReaderM t), Protocol t) => BondGet t (Maybe a) Source # bondPut :: (Monad (BondPutM t), Protocol t) => Maybe a -> BondPut t Source # getName :: Proxy * (Maybe a) -> Text Source # getQualifiedName :: Proxy * (Maybe a) -> Text Source # getElementType :: Proxy * (Maybe a) -> ElementTypeInfo Source # | |
Default (Maybe a) | |
defaultValue :: Maybe a Source # equalToDefault :: FieldTypeInfo -> Maybe a -> Bool | |
SingI (Maybe a) (Nothing a) | |
SingKind a (KProxy a) => SingKind (Maybe a) (KProxy (Maybe a)) | |
SingI a a1 => SingI (Maybe a) (Just a a1) | |
(Selector Meta s, ToJSON a) => RecordToPairs (S1 s (K1 i (Maybe a))) | |
(Selector Meta s, ToJSON a) => RecordToEncoding (S1 s (K1 i (Maybe a))) | |
(Selector Meta s, FromJSON a) => FromRecord (S1 s (K1 i (Maybe a))) | |
type Rep1 Maybe | |
type Rep (Maybe a) | |
data Sing (Maybe a) | |
type (==) (Maybe k) a b | |
type DemoteRep (Maybe a) (KProxy (Maybe a)) | |
A Map from keys k
to values a
.
Functor (Map k) | |
Foldable (Map k) | |
fold :: Monoid m => Map k m -> m # foldMap :: Monoid m => (a -> m) -> Map k a -> m # foldr :: (a -> b -> b) -> b -> Map k a -> b # foldr' :: (a -> b -> b) -> b -> Map k a -> b # foldl :: (b -> a -> b) -> b -> Map k a -> b # foldl' :: (b -> a -> b) -> b -> Map k a -> b # foldr1 :: (a -> a -> a) -> Map k a -> a # foldl1 :: (a -> a -> a) -> Map k a -> a # elem :: Eq a => a -> Map k a -> Bool # maximum :: Ord a => Map k a -> a # minimum :: Ord a => Map k a -> a # | |
Traversable (Map k) | |
Ord k => IsList (Map k v) | |
(Eq k, Eq a) => Eq (Map k a) | |
(Data k, Data a, Ord k) => Data (Map k a) | |
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Map k a -> c (Map k a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Map k a) # toConstr :: Map k a -> Constr # dataTypeOf :: Map k a -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Map k a)) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Map k a)) # gmapT :: (forall b. Data b => b -> b) -> Map k a -> Map k a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Map k a -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Map k a -> r # gmapQ :: (forall d. Data d => d -> u) -> Map k a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Map k a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Map k a -> m (Map k a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Map k a -> m (Map k a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Map k a -> m (Map k a) # | |
(Ord k, Ord v) => Ord (Map k v) | |
(Ord k, Read k, Read e) => Read (Map k e) | |
(Show k, Show a) => Show (Map k a) | |
Ord k => Semigroup (Map k v) | |
Ord k => Monoid (Map k v) | |
(NFData k, NFData a) => NFData (Map k a) | |
(Ord k, BondType k, BondType v) => BondType (Map k v) Source # | |
bondGet :: (Functor (ReaderM t), Monad (ReaderM t), Protocol t) => BondGet t (Map k v) Source # bondPut :: (Monad (BondPutM t), Protocol t) => Map k v -> BondPut t Source # getName :: Proxy * (Map k v) -> Text Source # getQualifiedName :: Proxy * (Map k v) -> Text Source # getElementType :: Proxy * (Map k v) -> ElementTypeInfo Source # | |
Default (Map a b) | |
defaultValue :: Map a b Source # equalToDefault :: FieldTypeInfo -> Map a b -> Bool | |
type Item (Map k v) | |
Bond structure field ordinal.
Bond "wstring" type
Eq Utf16 Source # | |
Ord Utf16 Source # | |
Show Utf16 Source # | |
IsString Utf16 Source # | |
fromString :: String -> Utf16 # | |
NFData Utf16 Source # | |
Hashable Utf16 Source # | |
BondType Utf16 Source # | |
bondGet :: (Functor (ReaderM t), Monad (ReaderM t), Protocol t) => BondGet t Utf16 Source # bondPut :: (Monad (BondPutM t), Protocol t) => Utf16 -> BondPut t Source # getName :: Proxy * Utf16 -> Text Source # getQualifiedName :: Proxy * Utf16 -> Text Source # getElementType :: Proxy * Utf16 -> ElementTypeInfo Source # | |
EncodedString Utf16 Source # | |
Default Utf16 | |
defaultValue :: Utf16 Source # equalToDefault :: FieldTypeInfo -> Utf16 -> Bool |
Bond "string" type
Eq Utf8 Source # | |
Ord Utf8 Source # | |
Show Utf8 Source # | |
IsString Utf8 Source # | |
fromString :: String -> Utf8 # | |
NFData Utf8 Source # | |
Hashable Utf8 Source # | |
BondType Utf8 Source # | |
bondGet :: (Functor (ReaderM t), Monad (ReaderM t), Protocol t) => BondGet t Utf8 Source # bondPut :: (Monad (BondPutM t), Protocol t) => Utf8 -> BondPut t Source # getName :: Proxy * Utf8 -> Text Source # getQualifiedName :: Proxy * Utf8 -> Text Source # getElementType :: Proxy * Utf8 -> ElementTypeInfo Source # | |
EncodedString Utf8 Source # | |
Default Utf8 | |
defaultValue :: Utf8 Source # equalToDefault :: FieldTypeInfo -> Utf8 -> Bool |
Boxed vectors, supporting efficient slicing.
Monad Vector | |
Functor Vector | |
Applicative Vector | |
Foldable Vector | |
fold :: Monoid m => Vector m -> m # foldMap :: Monoid m => (a -> m) -> Vector a -> m # foldr :: (a -> b -> b) -> b -> Vector a -> b # foldr' :: (a -> b -> b) -> b -> Vector a -> b # foldl :: (b -> a -> b) -> b -> Vector a -> b # foldl' :: (b -> a -> b) -> b -> Vector a -> b # foldr1 :: (a -> a -> a) -> Vector a -> a # foldl1 :: (a -> a -> a) -> Vector a -> a # elem :: Eq a => a -> Vector a -> Bool # maximum :: Ord a => Vector a -> a # minimum :: Ord a => Vector a -> a # | |
Traversable Vector | |
Alternative Vector | |
MonadPlus Vector | |
Vector Vector a | |
basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) a -> m (Vector a) # basicUnsafeThaw :: PrimMonad m => Vector a -> m (Mutable Vector (PrimState m) a) # basicLength :: Vector a -> Int # basicUnsafeSlice :: Int -> Int -> Vector a -> Vector a # basicUnsafeIndexM :: Monad m => Vector a -> Int -> m a # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) a -> Vector a -> m () # | |
IsList (Vector a) | |
Eq a => Eq (Vector a) | |
Data a => Data (Vector a) | |
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Vector a -> c (Vector a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Vector a) # toConstr :: Vector a -> Constr # dataTypeOf :: Vector a -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Vector a)) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Vector a)) # gmapT :: (forall b. Data b => b -> b) -> Vector a -> Vector a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Vector a -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Vector a -> r # gmapQ :: (forall d. Data d => d -> u) -> Vector a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Vector a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Vector a -> m (Vector a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Vector a -> m (Vector a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Vector a -> m (Vector a) # | |
Ord a => Ord (Vector a) | |
Read a => Read (Vector a) | |
Show a => Show (Vector a) | |
Monoid (Vector a) | |
NFData a => NFData (Vector a) | |
BondType a => BondType (Vector a) Source # | |
bondGet :: (Functor (ReaderM t), Monad (ReaderM t), Protocol t) => BondGet t (Vector a) Source # bondPut :: (Monad (BondPutM t), Protocol t) => Vector a -> BondPut t Source # getName :: Proxy * (Vector a) -> Text Source # getQualifiedName :: Proxy * (Vector a) -> Text Source # getElementType :: Proxy * (Vector a) -> ElementTypeInfo Source # | |
Default (Vector a) | |
defaultValue :: Vector a Source # equalToDefault :: FieldTypeInfo -> Vector a -> Bool | |
type Mutable Vector | |
type Item (Vector a) | |
16-bit unsigned integer type
32-bit unsigned integer type
64-bit unsigned integer type
8-bit unsigned integer type
fromString :: IsString a => String -> a #