Safe Haskell	None
Language	Haskell2010

Bio.Prelude

Synopsis

Documentation

module Bio.Base

module BasePrelude

type Bytes = ByteString Source

type LazyBytes = ByteString Source

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

Instances

Functor (HashMap k)
Foldable (HashMap k)
Traversable (HashMap k)
(Eq k, Hashable k) => IsList (HashMap k v)
(Eq k, Eq v) => Eq (HashMap k v)
(Data k, Data v, Eq k, Hashable k) => Data (HashMap k v)
(Eq k, Hashable k, Read k, Read e) => Read (HashMap k e)
(Show k, Show v) => Show (HashMap k v)
(Eq k, Hashable k) => Monoid (HashMap k v)
(Hashable k, Eq k) => Semigroup (HashMap k a)
(NFData k, NFData v) => NFData (HashMap k v)
type Item (HashMap k v) = (k, v)

data HashSet a :: * -> *

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)
(Hashable a, Eq a) => Semigroup (HashSet a)
NFData a => NFData (HashSet a)
type Item (HashSet a) = a

data IntMap a :: * -> *

Instances

Functor IntMap
Foldable IntMap
Traversable IntMap
IsList (IntMap a)
Eq a => Eq (IntMap a)
Data a => Data (IntMap a)
Ord a => Ord (IntMap a)
Read e => Read (IntMap e)
Show a => Show (IntMap a)
Monoid (IntMap a)
Semigroup (IntMap v)
NFData a => NFData (IntMap a)
type Item (IntMap a) = (Key, a)

data IntSet :: *

Instances

IsList IntSet
Eq IntSet
Data IntSet
Ord IntSet
Read IntSet
Show IntSet
Monoid IntSet
Semigroup IntSet
NFData IntSet
type Item IntSet = Key

data Text :: *

Instances

Semigroup Text
Hashable Text
Unpack Text Source
Chunk Text
type Item Text = Char
type State Text = Buffer
type ChunkElem Text = Char

type LazyText = Text Source

data Pair a b Source

A strict pair.

Constructors

!a :!: !b infixl 2

Instances

(Bounded a, Bounded b) => Bounded (Pair a b) Source
(Eq a, Eq b) => Eq (Pair a b) Source
(Ord a, Ord b) => Ord (Pair a b) Source
(Read a, Read b) => Read (Pair a b) Source
(Show a, Show b) => Show (Pair a b) Source
(Ix a, Ix b) => Ix (Pair a b) Source

type (:!:) = Pair infixl 2 Source

decodeBytes :: Bytes -> Text Source

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 Source

Converts Text into Bytes. This uses UTF8.

class Hashable a where

Minimal complete definition

Nothing

Methods

hashWithSalt :: Int -> a -> Int

hash :: a -> Int

Instances

Hashable Bool
Hashable Char
Hashable Double
Hashable Float
Hashable Int
Hashable Int8
Hashable Int16
Hashable Int32
Hashable Int64
Hashable Integer
Hashable Ordering
Hashable Word
Hashable Word8
Hashable Word16
Hashable Word32
Hashable Word64
Hashable TypeRep
Hashable ()
Hashable ByteString
Hashable Scientific
Hashable ByteString
Hashable Text
Hashable Value
Hashable ThreadId
Hashable BigNat
Hashable Void
Hashable Natural
Hashable Text
Hashable ShortByteString
Hashable a => Hashable [a]
(Integral a, Hashable a) => Hashable (Ratio a)
Hashable a => Hashable (Maybe a)
Hashable (StableName a)
Hashable a => Hashable (Min a)
Hashable a => Hashable (Max a)
Hashable a => Hashable (First a)
Hashable a => Hashable (Last a)
Hashable a => Hashable (WrappedMonoid a)
Hashable a => Hashable (Option a)
Hashable a => Hashable (NonEmpty a)
(Hashable a, Hashable b) => Hashable (Either a b)
(Hashable a1, Hashable a2) => Hashable (a1, a2)
(Hashable a, Hashable b) => Hashable (Arg a b)
(Hashable a1, Hashable a2, Hashable a3) => Hashable (a1, a2, a3)
(Hashable a1, Hashable a2, Hashable a3, Hashable a4) => Hashable (a1, a2, a3, a4)
(Hashable a1, Hashable a2, Hashable a3, Hashable a4, Hashable a5) => Hashable (a1, a2, a3, a4, a5)
(Hashable a1, Hashable a2, Hashable a3, Hashable a4, Hashable a5, Hashable a6) => Hashable (a1, a2, a3, a4, a5, a6)
(Hashable a1, Hashable a2, Hashable a3, Hashable a4, Hashable a5, Hashable a6, Hashable a7) => Hashable (a1, a2, a3, a4, a5, a6, a7)

class Unpack s where Source

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

Methods

unpack :: s -> String Source

Instances

Unpack String Source
Unpack ByteString Source
Unpack Text Source

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

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

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