Data.Bond.Types

Documentation

newtype Blob

Bond "blob" type

Constructors

Blob ByteString

Instances

Eq Blob

Ord Blob

Show Blob

Hashable Blob

BondType Blob

Default Blob

data Bonded a :: * -> *

Constructors

BondedStream ByteString

BondedObject a

Instances

(BondStruct a, Eq a) => Eq (Bonded a)

Show a => Show (Bonded a)

BondStruct a => BondType (Bonded a)

Default a => Default (Bonded a)

data Bool :: *

Instances

Bounded Bool

Enum Bool

Eq Bool

Data Bool

Ord Bool

Show Bool

Ix Bool

Generic Bool

Storable Bool

Bits Bool

FiniteBits Bool

Hashable Bool

Unbox Bool

BondType Bool

Default Bool

IArray UArray Bool

Vector Vector Bool

MVector MVector Bool

MArray (STUArray s) Bool (ST s)

type Rep Bool = D1 D1Bool ((:+:) (C1 C1_0Bool U1) (C1 C1_1Bool U1))

data Vector Bool = V_Bool (Vector Word8)

data MVector s Bool = MV_Bool (MVector s Word8)

type (==) Bool a b = EqBool a b

data Double :: *

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.

Instances

Eq Double

Floating Double

Data Double

Ord Double

RealFloat Double

Generic Double

Storable Double

Hashable Double

Prim Double

Unbox Double

BondType Double

Default Double

IArray UArray Double

Vector Vector Double

MVector MVector Double

MArray (STUArray s) Double (ST s)

type Rep Double = D1 D_Double (C1 C_Double (S1 NoSelector (Rec0 Double)))

data Vector Double = V_Double (Vector Double)

data MVector s Double = MV_Double (MVector s Double)

class IsString a => EncodedString a where

Bond string/wstring transformations from/to String and Text.

Minimal complete definition

fromText, toText

Methods

toString :: a -> String

Convert to String

fromText :: Text -> a

Make bond string from Text

toText :: a -> Text

Convert to Text

Instances

EncodedString Utf16

EncodedString Utf8

data Float :: *

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.

Instances

Eq Float

Floating Float

Data Float

Ord Float

RealFloat Float

Generic Float

Storable Float

Hashable Float

Prim Float

Unbox Float

BondType Float

Default Float

IArray UArray Float

Vector Vector Float

MVector MVector Float

MArray (STUArray s) Float (ST s)

type Rep Float = D1 D_Float (C1 C_Float (S1 NoSelector (Rec0 Float)))

data Vector Float = V_Float (Vector Float)

data MVector s Float = MV_Float (MVector s Float)

data HashSet a :: * -> *

A set of values. A set cannot contain duplicate values.

Instances

Foldable HashSet

(Eq a, Hashable a) => IsList (HashSet a)

(Hashable a, Eq a) => Eq (HashSet a)

(Data a, Eq a, Hashable a) => Data (HashSet a)

(Eq a, Hashable a, Read a) => Read (HashSet a)

Show a => Show (HashSet a)

(Hashable a, Eq a) => Monoid (HashSet a)

NFData a => NFData (HashSet a)

(Eq a, Hashable a, BondType a) => BondType (HashSet a)

Default (HashSet a)

type Item (HashSet a) = a

data Set a :: * -> *

A set of values a.

Instances

Foldable Set

Ord a => IsList (Set a)

Eq a => Eq (Set a)

(Data a, Ord a) => Data (Set a)

Ord a => Ord (Set a)

(Read a, Ord a) => Read (Set a)

Show a => Show (Set a)

Ord a => Monoid (Set a)

NFData a => NFData (Set a)

(Ord a, BondType a) => BondType (Set a)

Default (Set a)

type Item (Set a) = a

data Int :: *

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.

Instances

Bounded Int

Enum Int

Eq Int

Integral Int

Data Int

Num Int

Ord Int

Real Int

Show Int

Ix Int

Generic Int

Storable Int

Bits Int

FiniteBits Int

Hashable Int

Prim Int

Unbox Int

IArray UArray Int

Vector Vector Int

MVector MVector Int

MArray (STUArray s) Int (ST s)

type Rep Int = D1 D_Int (C1 C_Int (S1 NoSelector (Rec0 Int)))

data Vector Int = V_Int (Vector Int)

data MVector s Int = MV_Int (MVector s Int)

data Int16 :: *

16-bit signed integer type

Instances

Bounded Int16

Enum Int16

Eq Int16

Integral Int16

Data Int16

Num Int16

Ord Int16

Read Int16

Real Int16

Show Int16

Ix Int16

Storable Int16

Bits Int16

FiniteBits Int16

Hashable Int16

Prim Int16

Unbox Int16

ZigZagable Int16

BondType Int16

Default Int16

IArray UArray Int16

Vector Vector Int16

MVector MVector Int16

MArray (STUArray s) Int16 (ST s)

data Vector Int16 = V_Int16 (Vector Int16)

data MVector s Int16 = MV_Int16 (MVector s Int16)

data Int32 :: *

32-bit signed integer type

Instances

Bounded Int32

Enum Int32

Eq Int32

Integral Int32

Data Int32

Num Int32

Ord Int32

Read Int32

Real Int32

Show Int32

Ix Int32

Storable Int32

Bits Int32

FiniteBits Int32

Hashable Int32

Prim Int32

Unbox Int32

ZigZagable Int32

BondType Int32

Default Int32

IArray UArray Int32

Vector Vector Int32

MVector MVector Int32

MArray (STUArray s) Int32 (ST s)

data Vector Int32 = V_Int32 (Vector Int32)

data MVector s Int32 = MV_Int32 (MVector s Int32)

data Int64 :: *

64-bit signed integer type

Instances

Bounded Int64

Enum Int64

Eq Int64

Integral Int64

Data Int64

Num Int64

Ord Int64

Read Int64

Real Int64

Show Int64

Ix Int64

Storable Int64

Bits Int64

FiniteBits Int64

Hashable Int64

Prim Int64

Unbox Int64

ZigZagable Int64

BondType Int64

Default Int64

IArray UArray Int64

Vector Vector Int64

MVector MVector Int64

MArray (STUArray s) Int64 (ST s)

data Vector Int64 = V_Int64 (Vector Int64)

data MVector s Int64 = MV_Int64 (MVector s Int64)

data Int8 :: *

8-bit signed integer type

Instances

Bounded Int8

Enum Int8

Eq Int8

Integral Int8

Data Int8

Num Int8

Ord Int8

Read Int8

Real Int8

Show Int8

Ix Int8

Storable Int8

Bits Int8

FiniteBits Int8

Hashable Int8

Prim Int8

Unbox Int8

BondType Int8

Default Int8

IArray UArray Int8

Vector Vector Int8

MVector MVector Int8

MArray (STUArray s) Int8 (ST s)

data Vector Int8 = V_Int8 (Vector Int8)

data MVector s Int8 = MV_Int8 (MVector s Int8)

data Maybe a :: * -> *

The Maybe type encapsulates an optional value. A value of type Maybe a either contains a value of type a (represented as Just a), or it is empty (represented as Nothing). 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.

Instances

Monad Maybe

Functor Maybe

Applicative Maybe

Foldable Maybe

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)

Ord a => Ord (Maybe a)

Show a => Show (Maybe a)

Generic (Maybe a)

Monoid a => Monoid (Maybe a)

Lift a semigroup into Maybe forming a Monoid according to http://en.wikipedia.org/wiki/Monoid: "Any semigroup S may be turned into a monoid simply by adjoining an element e not in S and defining e*e = e and e*s = s = s*e for all s ∈ S." Since there is no "Semigroup" typeclass providing just mappend, we use Monoid instead.

Hashable a => Hashable (Maybe a)

BondType a => BondType (Maybe a)

Default (Maybe a)

(Selector s, ToJSON a) => RecordToPairs (S1 s (K1 i (Maybe a)))

(Selector s, FromJSON a) => FromRecord (S1 s (K1 i (Maybe a)))

type Rep1 Maybe = D1 D1Maybe ((:+:) (C1 C1_0Maybe U1) (C1 C1_1Maybe (S1 NoSelector Par1)))

type Rep (Maybe a) = D1 D1Maybe ((:+:) (C1 C1_0Maybe U1) (C1 C1_1Maybe (S1 NoSelector (Rec0 a))))

type (==) (Maybe k) a b = EqMaybe k a b

data Map k a :: * -> * -> *

A Map from keys k to values a.

Instances

Functor (Map k)

Foldable (Map k)

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)

(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 => Monoid (Map k v)

(NFData k, NFData a) => NFData (Map k a)

(Ord k, BondType k, BondType v) => BondType (Map k v)

Default (Map a b)

type Item (Map k v) = (k, v)

newtype Ordinal

Bond structure field ordinal.

Constructors

Ordinal Word16

Instances

Eq Ordinal

Ord Ordinal

Show Ordinal

Hashable Ordinal

newtype Utf16

Bond "wstring" type

Constructors

Utf16 ByteString

Instances

Eq Utf16

Ord Utf16

Show Utf16

IsString Utf16

Hashable Utf16

BondType Utf16

EncodedString Utf16

Default Utf16

newtype Utf8

Bond "string" type

Constructors

Utf8 ByteString

Instances

Eq Utf8

Ord Utf8

Show Utf8

IsString Utf8

Hashable Utf8

BondType Utf8

EncodedString Utf8

Default Utf8

data Vector a :: * -> *

Boxed vectors, supporting efficient slicing.

Instances

Monad Vector

Functor Vector

Applicative Vector

Foldable Vector

Traversable Vector

Alternative Vector

MonadPlus Vector

Vector Vector a

IsList (Vector a)

Eq a => Eq (Vector a)

Data a => Data (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)

Default (Vector a)

type Mutable Vector = MVector

type Item (Vector a) = a

data Word16 :: *

16-bit unsigned integer type

Instances

Bounded Word16

Enum Word16

Eq Word16

Integral Word16

Data Word16

Num Word16

Ord Word16

Read Word16

Real Word16

Show Word16

Ix Word16

Storable Word16

Bits Word16

FiniteBits Word16

Hashable Word16

Prim Word16

Unbox Word16

BondType Word16

Default Word16

IArray UArray Word16

Vector Vector Word16

MVector MVector Word16

MArray (STUArray s) Word16 (ST s)

data Vector Word16 = V_Word16 (Vector Word16)

data MVector s Word16 = MV_Word16 (MVector s Word16)

data Word32 :: *

32-bit unsigned integer type

Instances

Bounded Word32

Enum Word32

Eq Word32

Integral Word32

Data Word32

Num Word32

Ord Word32

Read Word32

Real Word32

Show Word32

Ix Word32

Storable Word32

Bits Word32

FiniteBits Word32

Hashable Word32

Prim Word32

Unbox Word32

BondType Word32

Default Word32

IArray UArray Word32

Vector Vector Word32

MVector MVector Word32

MArray (STUArray s) Word32 (ST s)

data Vector Word32 = V_Word32 (Vector Word32)

data MVector s Word32 = MV_Word32 (MVector s Word32)

data Word64 :: *

64-bit unsigned integer type

Instances

Bounded Word64

Enum Word64

Eq Word64

Integral Word64

Data Word64

Num Word64

Ord Word64

Read Word64

Real Word64

Show Word64

Ix Word64

Storable Word64

Bits Word64

FiniteBits Word64

Hashable Word64

Prim Word64

Unbox Word64

BondType Word64

Default Word64

IArray UArray Word64

Vector Vector Word64

MVector MVector Word64

MArray (STUArray s) Word64 (ST s)

data Vector Word64 = V_Word64 (Vector Word64)

data MVector s Word64 = MV_Word64 (MVector s Word64)

data Word8 :: *

8-bit unsigned integer type

Instances

Bounded Word8

Enum Word8

Eq Word8

Integral Word8

Data Word8

Num Word8

Ord Word8

Read Word8

Real Word8

Show Word8

Ix Word8

Storable Word8

Bits Word8

FiniteBits Word8

Hashable Word8

Prim Word8

Unbox Word8

BondType Word8

Default Word8

IArray UArray Word8

Vector Vector Word8

MVector MVector Word8

MArray (STUArray s) Word8 (ST s)

data Vector Word8 = V_Word8 (Vector Word8)

data MVector s Word8 = MV_Word8 (MVector s Word8)

fromString :: IsString a => String -> a