Bio.Prelude

Documentation

module Bio.Base

module BasePrelude

module System.IO

module System.Posix.Files

module System.Posix.IO

module System.Posix.Types

type Bytes = ByteString

type LazyBytes = ByteString

data HashMap k v :: * -> * -> *

A map from keys to values. A map cannot contain duplicate keys; each key can map to at most one value.

Instances

Functor (HashMap k)

Methods

fmap :: (a -> b) -> HashMap k a -> HashMap k b

(<$) :: a -> HashMap k b -> HashMap k a

Foldable (HashMap k)

Methods

fold :: Monoid m => HashMap k m -> m

foldMap :: Monoid m => (a -> m) -> HashMap k a -> m

foldr :: (a -> b -> b) -> b -> HashMap k a -> b

foldr' :: (a -> b -> b) -> b -> HashMap k a -> b

foldl :: (b -> a -> b) -> b -> HashMap k a -> b

foldl' :: (b -> a -> b) -> b -> HashMap k a -> b

foldr1 :: (a -> a -> a) -> HashMap k a -> a

foldl1 :: (a -> a -> a) -> HashMap k a -> a

toList :: HashMap k a -> [a]

null :: HashMap k a -> Bool

length :: HashMap k a -> Int

elem :: Eq a => a -> HashMap k a -> Bool

maximum :: Ord a => HashMap k a -> a

minimum :: Ord a => HashMap k a -> a

sum :: Num a => HashMap k a -> a

product :: Num a => HashMap k a -> a

Traversable (HashMap k)

Methods

traverse :: Applicative f => (a -> f b) -> HashMap k a -> f (HashMap k b)

sequenceA :: Applicative f => HashMap k (f a) -> f (HashMap k a)

mapM :: Monad m => (a -> m b) -> HashMap k a -> m (HashMap k b)

sequence :: Monad m => HashMap k (m a) -> m (HashMap k a)

(FromJSONKey k, Eq k, Hashable k) => FromJSON1 (HashMap k)

Methods

liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (HashMap k a)

liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [HashMap k a]

ToJSONKey k => ToJSON1 (HashMap k)

Methods

liftToJSON :: (a -> Value) -> ([a] -> Value) -> HashMap k a -> Value

liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [HashMap k a] -> Value

liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> HashMap k a -> Encoding

liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [HashMap k a] -> Encoding

(Eq k, Hashable k) => IsList (HashMap k v)

Associated Types

type Item (HashMap k v) :: *

Methods

fromList :: [Item (HashMap k v)] -> HashMap k v

fromListN :: Int -> [Item (HashMap k v)] -> HashMap k v

toList :: HashMap k v -> [Item (HashMap k v)]

(Eq k, Eq v) => Eq (HashMap k v)

Methods

(==) :: HashMap k v -> HashMap k v -> Bool

(/=) :: HashMap k v -> HashMap k v -> Bool

(Data k, Data v, Eq k, Hashable k) => Data (HashMap k v)

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HashMap k v -> c (HashMap k v)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HashMap k v)

toConstr :: HashMap k v -> Constr

dataTypeOf :: HashMap k v -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (HashMap k v))

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HashMap k v))

gmapT :: (forall b. Data b => b -> b) -> HashMap k v -> HashMap k v

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HashMap k v -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HashMap k v -> r

gmapQ :: (forall d. Data d => d -> u) -> HashMap k v -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> HashMap k v -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HashMap k v -> m (HashMap k v)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HashMap k v -> m (HashMap k v)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HashMap k v -> m (HashMap k v)

(Eq k, Hashable k, Read k, Read e) => Read (HashMap k e)

Methods

readsPrec :: Int -> ReadS (HashMap k e)

readList :: ReadS [HashMap k e]

readPrec :: ReadPrec (HashMap k e)

readListPrec :: ReadPrec [HashMap k e]

(Show k, Show v) => Show (HashMap k v)

Methods

showsPrec :: Int -> HashMap k v -> ShowS

show :: HashMap k v -> String

showList :: [HashMap k v] -> ShowS

(Eq k, Hashable k) => Semigroup (HashMap k v)

Methods

(<>) :: HashMap k v -> HashMap k v -> HashMap k v

sconcat :: NonEmpty (HashMap k v) -> HashMap k v

stimes :: Integral b => b -> HashMap k v -> HashMap k v

(Eq k, Hashable k) => Monoid (HashMap k v)

Methods

mempty :: HashMap k v

mappend :: HashMap k v -> HashMap k v -> HashMap k v

mconcat :: [HashMap k v] -> HashMap k v

(Hashable k, Hashable v) => Hashable (HashMap k v)

Methods

hashWithSalt :: Int -> HashMap k v -> Int

hash :: HashMap k v -> Int

(FromJSON v, FromJSONKey k, Eq k, Hashable k) => FromJSON (HashMap k v)

Methods

parseJSON :: Value -> Parser (HashMap k v)

parseJSONList :: Value -> Parser [HashMap k v]

(ToJSON v, ToJSONKey k) => ToJSON (HashMap k v)

Methods

toJSON :: HashMap k v -> Value

toEncoding :: HashMap k v -> Encoding

toJSONList :: [HashMap k v] -> Value

toEncodingList :: [HashMap k v] -> Encoding

(NFData k, NFData v) => NFData (HashMap k v)

Methods

rnf :: HashMap k v -> ()

type Item (HashMap k v)

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

data HashSet a :: * -> *

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

Instances

Foldable HashSet

Methods

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

toList :: HashSet a -> [a]

null :: HashSet a -> Bool

length :: HashSet a -> Int

elem :: Eq a => a -> HashSet a -> Bool

maximum :: Ord a => HashSet a -> a

minimum :: Ord a => HashSet a -> a

sum :: Num a => HashSet a -> a

product :: Num a => HashSet a -> a

ToJSON1 HashSet

Methods

liftToJSON :: (a -> Value) -> ([a] -> Value) -> HashSet a -> Value

liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [HashSet a] -> Value

liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> HashSet a -> Encoding

liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [HashSet a] -> Encoding

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

Associated Types

type Item (HashSet a) :: *

Methods

fromList :: [Item (HashSet a)] -> HashSet a

fromListN :: Int -> [Item (HashSet a)] -> HashSet a

toList :: HashSet a -> [Item (HashSet a)]

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

Methods

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

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

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

Methods

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)

Methods

readsPrec :: Int -> ReadS (HashSet a)

readList :: ReadS [HashSet a]

readPrec :: ReadPrec (HashSet a)

readListPrec :: ReadPrec [HashSet a]

Show a => Show (HashSet a)

Methods

showsPrec :: Int -> HashSet a -> ShowS

show :: HashSet a -> String

showList :: [HashSet a] -> ShowS

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

Methods

(<>) :: HashSet a -> HashSet a -> HashSet a

sconcat :: NonEmpty (HashSet a) -> HashSet a

stimes :: Integral b => b -> HashSet a -> HashSet a

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

Methods

mempty :: HashSet a

mappend :: HashSet a -> HashSet a -> HashSet a

mconcat :: [HashSet a] -> HashSet a

Hashable a => Hashable (HashSet a)

Methods

hashWithSalt :: Int -> HashSet a -> Int

hash :: HashSet a -> Int

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

Methods

parseJSON :: Value -> Parser (HashSet a)

parseJSONList :: Value -> Parser [HashSet a]

ToJSON a => ToJSON (HashSet a)

Methods

toJSON :: HashSet a -> Value

toEncoding :: HashSet a -> Encoding

toJSONList :: [HashSet a] -> Value

toEncodingList :: [HashSet a] -> Encoding

NFData a => NFData (HashSet a)

Methods

rnf :: HashSet a -> ()

type Item (HashSet a)

type Item (HashSet a) = a

data IntMap a :: * -> *

A map of integers to values a.

Instances

Functor IntMap

Methods

fmap :: (a -> b) -> IntMap a -> IntMap b

(<$) :: a -> IntMap b -> IntMap a

Foldable IntMap

Methods

fold :: Monoid m => IntMap m -> m

foldMap :: Monoid m => (a -> m) -> IntMap a -> m

foldr :: (a -> b -> b) -> b -> IntMap a -> b

foldr' :: (a -> b -> b) -> b -> IntMap a -> b

foldl :: (b -> a -> b) -> b -> IntMap a -> b

foldl' :: (b -> a -> b) -> b -> IntMap a -> b

foldr1 :: (a -> a -> a) -> IntMap a -> a

foldl1 :: (a -> a -> a) -> IntMap a -> a

toList :: IntMap a -> [a]

null :: IntMap a -> Bool

length :: IntMap a -> Int

elem :: Eq a => a -> IntMap a -> Bool

maximum :: Ord a => IntMap a -> a

minimum :: Ord a => IntMap a -> a

sum :: Num a => IntMap a -> a

product :: Num a => IntMap a -> a

Traversable IntMap

Methods

traverse :: Applicative f => (a -> f b) -> IntMap a -> f (IntMap b)

sequenceA :: Applicative f => IntMap (f a) -> f (IntMap a)

mapM :: Monad m => (a -> m b) -> IntMap a -> m (IntMap b)

sequence :: Monad m => IntMap (m a) -> m (IntMap a)

FromJSON1 IntMap

Methods

liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (IntMap a)

liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [IntMap a]

ToJSON1 IntMap

Methods

liftToJSON :: (a -> Value) -> ([a] -> Value) -> IntMap a -> Value

liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [IntMap a] -> Value

liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> IntMap a -> Encoding

liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [IntMap a] -> Encoding

IsList (IntMap a)

Associated Types

type Item (IntMap a) :: *

Methods

fromList :: [Item (IntMap a)] -> IntMap a

fromListN :: Int -> [Item (IntMap a)] -> IntMap a

toList :: IntMap a -> [Item (IntMap a)]

Eq a => Eq (IntMap a)

Methods

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

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

Data a => Data (IntMap a)

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> IntMap a -> c (IntMap a)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (IntMap a)

toConstr :: IntMap a -> Constr

dataTypeOf :: IntMap a -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (IntMap a))

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (IntMap a))

gmapT :: (forall b. Data b => b -> b) -> IntMap a -> IntMap a

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IntMap a -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IntMap a -> r

gmapQ :: (forall d. Data d => d -> u) -> IntMap a -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> IntMap a -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> IntMap a -> m (IntMap a)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> IntMap a -> m (IntMap a)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> IntMap a -> m (IntMap a)

Ord a => Ord (IntMap a)

Methods

compare :: IntMap a -> IntMap a -> Ordering

(<) :: IntMap a -> IntMap a -> Bool

(<=) :: IntMap a -> IntMap a -> Bool

(>) :: IntMap a -> IntMap a -> Bool

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

max :: IntMap a -> IntMap a -> IntMap a

min :: IntMap a -> IntMap a -> IntMap a

Read e => Read (IntMap e)

Methods

readsPrec :: Int -> ReadS (IntMap e)

readList :: ReadS [IntMap e]

readPrec :: ReadPrec (IntMap e)

readListPrec :: ReadPrec [IntMap e]

Show a => Show (IntMap a)

Methods

showsPrec :: Int -> IntMap a -> ShowS

show :: IntMap a -> String

showList :: [IntMap a] -> ShowS

Semigroup (IntMap a)

Methods

(<>) :: IntMap a -> IntMap a -> IntMap a

sconcat :: NonEmpty (IntMap a) -> IntMap a

stimes :: Integral b => b -> IntMap a -> IntMap a

Monoid (IntMap a)

Methods

mempty :: IntMap a

mappend :: IntMap a -> IntMap a -> IntMap a

mconcat :: [IntMap a] -> IntMap a

FromJSON a => FromJSON (IntMap a)

Methods

parseJSON :: Value -> Parser (IntMap a)

parseJSONList :: Value -> Parser [IntMap a]

ToJSON a => ToJSON (IntMap a)

Methods

toJSON :: IntMap a -> Value

toEncoding :: IntMap a -> Encoding

toJSONList :: [IntMap a] -> Value

toEncodingList :: [IntMap a] -> Encoding

Binary e => Binary (IntMap e)

Methods

put :: IntMap e -> Put

get :: Get (IntMap e)

putList :: [IntMap e] -> Put

NFData a => NFData (IntMap a)

Methods

rnf :: IntMap a -> ()

type Item (IntMap a)

type Item (IntMap a) = (Key, a)

data IntSet :: *

A set of integers.

Instances

IsList IntSet

Associated Types

type Item IntSet :: *

Methods

fromList :: [Item IntSet] -> IntSet

fromListN :: Int -> [Item IntSet] -> IntSet

toList :: IntSet -> [Item IntSet]

Eq IntSet

Methods

(==) :: IntSet -> IntSet -> Bool

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

Data IntSet

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> IntSet -> c IntSet

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c IntSet

toConstr :: IntSet -> Constr

dataTypeOf :: IntSet -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c IntSet)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c IntSet)

gmapT :: (forall b. Data b => b -> b) -> IntSet -> IntSet

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IntSet -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IntSet -> r

gmapQ :: (forall d. Data d => d -> u) -> IntSet -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> IntSet -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> IntSet -> m IntSet

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> IntSet -> m IntSet

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> IntSet -> m IntSet

Ord IntSet

Methods

compare :: IntSet -> IntSet -> Ordering

(<) :: IntSet -> IntSet -> Bool

(<=) :: IntSet -> IntSet -> Bool

(>) :: IntSet -> IntSet -> Bool

(>=) :: IntSet -> IntSet -> Bool

max :: IntSet -> IntSet -> IntSet

min :: IntSet -> IntSet -> IntSet

Read IntSet

Methods

readsPrec :: Int -> ReadS IntSet

readList :: ReadS [IntSet]

readPrec :: ReadPrec IntSet

readListPrec :: ReadPrec [IntSet]

Show IntSet

Methods

showsPrec :: Int -> IntSet -> ShowS

show :: IntSet -> String

showList :: [IntSet] -> ShowS

Semigroup IntSet

Methods

(<>) :: IntSet -> IntSet -> IntSet

sconcat :: NonEmpty IntSet -> IntSet

stimes :: Integral b => b -> IntSet -> IntSet

Monoid IntSet

Methods

mempty :: IntSet

mappend :: IntSet -> IntSet -> IntSet

mconcat :: [IntSet] -> IntSet

FromJSON IntSet

Methods

parseJSON :: Value -> Parser IntSet

parseJSONList :: Value -> Parser [IntSet]

ToJSON IntSet

Methods

toJSON :: IntSet -> Value

toEncoding :: IntSet -> Encoding

toJSONList :: [IntSet] -> Value

toEncodingList :: [IntSet] -> Encoding

Binary IntSet

Methods

put :: IntSet -> Put

get :: Get IntSet

putList :: [IntSet] -> Put

NFData IntSet

Methods

rnf :: IntSet -> ()

type Item IntSet

type Item IntSet = Key

data Text :: *

A space efficient, packed, unboxed Unicode text type.

Instances

Hashable Text

Methods

hashWithSalt :: Int -> Text -> Int

hash :: Text -> Int

FromJSON Text

Methods

parseJSON :: Value -> Parser Text

parseJSONList :: Value -> Parser [Text]

FromJSONKey Text

Methods

fromJSONKey :: FromJSONKeyFunction Text

fromJSONKeyList :: FromJSONKeyFunction [Text]

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]

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

Unpack Text

Methods

unpack :: Text -> String

type State Text

type State Text = Buffer

type ChunkElem Text

type ChunkElem Text = Char

type Item Text

type Item Text = Char

type LazyText = Text

data Pair a b

A strict pair.

Constructors

!a :!: !b infixl 2

Instances

(Bounded a, Bounded b) => Bounded (Pair a b)

Methods

minBound :: Pair a b

maxBound :: Pair a b

(Eq a, Eq b) => Eq (Pair a b)

Methods

(==) :: Pair a b -> Pair a b -> Bool

(/=) :: Pair a b -> Pair a b -> Bool

(Ord a, Ord b) => Ord (Pair a b)

Methods

compare :: Pair a b -> Pair a b -> Ordering

(<) :: Pair a b -> Pair a b -> Bool

(<=) :: Pair a b -> Pair a b -> Bool

(>) :: Pair a b -> Pair a b -> Bool

(>=) :: Pair a b -> Pair a b -> Bool

max :: Pair a b -> Pair a b -> Pair a b

min :: Pair a b -> Pair a b -> Pair a b

(Read a, Read b) => Read (Pair a b)

Methods

readsPrec :: Int -> ReadS (Pair a b)

readList :: ReadS [Pair a b]

readPrec :: ReadPrec (Pair a b)

readListPrec :: ReadPrec [Pair a b]

(Show a, Show b) => Show (Pair a b)

Methods

showsPrec :: Int -> Pair a b -> ShowS

show :: Pair a b -> String

showList :: [Pair a b] -> ShowS

(Ix a, Ix b) => Ix (Pair a b)

Methods

range :: (Pair a b, Pair a b) -> [Pair a b]

index :: (Pair a b, Pair a b) -> Pair a b -> Int

unsafeIndex :: (Pair a b, Pair a b) -> Pair a b -> Int

inRange :: (Pair a b, Pair a b) -> Pair a b -> Bool

rangeSize :: (Pair a b, Pair a b) -> Int

unsafeRangeSize :: (Pair a b, Pair a b) -> Int

type (:!:) = Pair infixl 2

decodeBytes :: Bytes -> Text

Converts Bytes into Text. This uses UTF8, but if there is an error, it pretends it was Latin1. Evil as this is, it tends to Just Work on files where nobody ever wasted a thought on encodings.

encodeBytes :: Text -> Bytes

Converts Text into Bytes. This uses UTF8.

class Hashable a where

The class of types that can be converted to a hash value.

Minimal implementation: hashWithSalt.

Minimal complete definition

Nothing

Instances

Hashable Bool

Methods

hashWithSalt :: Int -> Bool -> Int

hash :: Bool -> Int

Hashable Char

Methods

hashWithSalt :: Int -> Char -> Int

hash :: Char -> Int

Hashable Double

Methods

hashWithSalt :: Int -> Double -> Int

hash :: Double -> Int

Hashable Float

Methods

hashWithSalt :: Int -> Float -> Int

hash :: Float -> Int

Hashable Int

Methods

hashWithSalt :: Int -> Int -> Int

hash :: Int -> Int

Hashable Int8

Methods

hashWithSalt :: Int -> Int8 -> Int

hash :: Int8 -> Int

Hashable Int16

Methods

hashWithSalt :: Int -> Int16 -> Int

hash :: Int16 -> Int

Hashable Int32

Methods

hashWithSalt :: Int -> Int32 -> Int

hash :: Int32 -> Int

Hashable Int64

Methods

hashWithSalt :: Int -> Int64 -> Int

hash :: Int64 -> Int

Hashable Integer

Methods

hashWithSalt :: Int -> Integer -> Int

hash :: Integer -> Int

Hashable Ordering

Methods

hashWithSalt :: Int -> Ordering -> Int

hash :: Ordering -> Int

Hashable Word

Methods

hashWithSalt :: Int -> Word -> Int

hash :: Word -> Int

Hashable Word8

Methods

hashWithSalt :: Int -> Word8 -> Int

hash :: Word8 -> Int

Hashable Word16

Methods

hashWithSalt :: Int -> Word16 -> Int

hash :: Word16 -> Int

Hashable Word32

Methods

hashWithSalt :: Int -> Word32 -> Int

hash :: Word32 -> Int

Hashable Word64

Methods

hashWithSalt :: Int -> Word64 -> Int

hash :: Word64 -> Int

Hashable TypeRep

Methods

hashWithSalt :: Int -> TypeRep -> Int

hash :: TypeRep -> Int

Hashable ()

Methods

hashWithSalt :: Int -> () -> Int

hash :: () -> Int

Hashable ByteString

Methods

hashWithSalt :: Int -> ByteString -> Int

hash :: ByteString -> Int

Hashable ByteString

Methods

hashWithSalt :: Int -> ByteString -> Int

hash :: ByteString -> Int

Hashable Scientific

Methods

hashWithSalt :: Int -> Scientific -> Int

hash :: Scientific -> Int

Hashable Text

Methods

hashWithSalt :: Int -> Text -> Int

hash :: Text -> Int

Hashable Value

Methods

hashWithSalt :: Int -> Value -> Int

hash :: Value -> Int

Hashable ThreadId

Methods

hashWithSalt :: Int -> ThreadId -> Int

hash :: ThreadId -> Int

Hashable Text

Methods

hashWithSalt :: Int -> Text -> Int

hash :: Text -> Int

Hashable BigNat

Methods

hashWithSalt :: Int -> BigNat -> Int

hash :: BigNat -> Int

Hashable Natural

Methods

hashWithSalt :: Int -> Natural -> Int

hash :: Natural -> Int

Hashable Void

Methods

hashWithSalt :: Int -> Void -> Int

hash :: Void -> Int

Hashable Version

Methods

hashWithSalt :: Int -> Version -> Int

hash :: Version -> Int

Hashable Unique

Methods

hashWithSalt :: Int -> Unique -> Int

hash :: Unique -> Int

Hashable ShortByteString

Methods

hashWithSalt :: Int -> ShortByteString -> Int

hash :: ShortByteString -> Int

Hashable a => Hashable [a]

Methods

hashWithSalt :: Int -> [a] -> Int

hash :: [a] -> Int

Hashable a => Hashable (Maybe a)

Methods

hashWithSalt :: Int -> Maybe a -> Int

hash :: Maybe a -> Int

Hashable a => Hashable (Ratio a)

Methods

hashWithSalt :: Int -> Ratio a -> Int

hash :: Ratio a -> Int

Hashable a => Hashable (Min a)

Methods

hashWithSalt :: Int -> Min a -> Int

hash :: Min a -> Int

Hashable a => Hashable (Max a)

Methods

hashWithSalt :: Int -> Max a -> Int

hash :: Max a -> Int

Hashable a => Hashable (First a)

Methods

hashWithSalt :: Int -> First a -> Int

hash :: First a -> Int

Hashable a => Hashable (Last a)

Methods

hashWithSalt :: Int -> Last a -> Int

hash :: Last a -> Int

Hashable a => Hashable (WrappedMonoid a)

Methods

hashWithSalt :: Int -> WrappedMonoid a -> Int

hash :: WrappedMonoid a -> Int

Hashable a => Hashable (Option a)

Methods

hashWithSalt :: Int -> Option a -> Int

hash :: Option a -> Int

Hashable a => Hashable (NonEmpty a)

Methods

hashWithSalt :: Int -> NonEmpty a -> Int

hash :: NonEmpty a -> Int

Hashable (Fixed a)

Methods

hashWithSalt :: Int -> Fixed a -> Int

hash :: Fixed a -> Int

Hashable (StableName a)

Methods

hashWithSalt :: Int -> StableName a -> Int

hash :: StableName a -> Int

Hashable a => Hashable (HashSet a)

Methods

hashWithSalt :: Int -> HashSet a -> Int

hash :: HashSet a -> Int

(Hashable a, Hashable b) => Hashable (Either a b)

Methods

hashWithSalt :: Int -> Either a b -> Int

hash :: Either a b -> Int

(Hashable a1, Hashable a2) => Hashable (a1, a2)

Methods

hashWithSalt :: Int -> (a1, a2) -> Int

hash :: (a1, a2) -> Int

(Hashable k, Hashable v) => Hashable (HashMap k v)

Methods

hashWithSalt :: Int -> HashMap k v -> Int

hash :: HashMap k v -> Int

(Hashable a, Hashable b) => Hashable (Arg a b)

Methods

hashWithSalt :: Int -> Arg a b -> Int

hash :: Arg a b -> Int

(Hashable a1, Hashable a2, Hashable a3) => Hashable (a1, a2, a3)

Methods

hashWithSalt :: Int -> (a1, a2, a3) -> Int

hash :: (a1, a2, a3) -> Int

(Hashable a1, Hashable a2, Hashable a3, Hashable a4) => Hashable (a1, a2, a3, a4)

Methods

hashWithSalt :: Int -> (a1, a2, a3, a4) -> Int

hash :: (a1, a2, a3, a4) -> Int

(Hashable a1, Hashable a2, Hashable a3, Hashable a4, Hashable a5) => Hashable (a1, a2, a3, a4, a5)

Methods

hashWithSalt :: Int -> (a1, a2, a3, a4, a5) -> Int

hash :: (a1, a2, a3, a4, a5) -> Int

(Hashable a1, Hashable a2, Hashable a3, Hashable a4, Hashable a5, Hashable a6) => Hashable (a1, a2, a3, a4, a5, a6)

Methods

hashWithSalt :: Int -> (a1, a2, a3, a4, a5, a6) -> Int

hash :: (a1, a2, a3, a4, a5, a6) -> Int

(Hashable a1, Hashable a2, Hashable a3, Hashable a4, Hashable a5, Hashable a6, Hashable a7) => Hashable (a1, a2, a3, a4, a5, a6, a7)

Methods

hashWithSalt :: Int -> (a1, a2, a3, a4, a5, a6, a7) -> Int

hash :: (a1, a2, a3, a4, a5, a6, a7) -> Int

class Unpack s where

Class of things that can be unpacked into Strings. Kind of the opposite of IsString.

Minimal complete definition

unpack

Methods

unpack :: s -> String

Instances

Unpack String

Methods

unpack :: String -> String

Unpack ByteString

Methods

unpack :: ByteString -> String

Unpack Text

Methods

unpack :: Text -> String

fdPut :: Fd -> Bytes -> IO ()

fdPutLazy :: Fd -> LazyBytes -> IO ()

withFd :: FilePath -> OpenMode -> Maybe FileMode -> OpenFileFlags -> (Fd -> IO a) -> IO a