Safe Haskell	None
Language	Haskell2010

Bio.Prelude

Synopsis

Documentation

module Bio.Base

module BasePrelude

module System.IO

module System.Posix.Files

module System.Posix.IO

module System.Posix.Types

type Bytes = ByteString Source #

type LazyBytes = ByteString Source #

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

Eq2 HashMap
Methods liftEq2 :: (a -> b -> Bool) -> (c -> d -> Bool) -> HashMap a c -> HashMap b d -> Bool #
Show2 HashMap
Methods liftShowsPrec2 :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> (Int -> b -> ShowS) -> ([b] -> ShowS) -> Int -> HashMap a b -> ShowS # liftShowList2 :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> (Int -> b -> ShowS) -> ([b] -> ShowS) -> [HashMap a b] -> ShowS #
Hashable2 HashMap
Methods liftHashWithSalt2 :: (Int -> a -> Int) -> (Int -> b -> Int) -> Int -> HashMap a b -> Int #
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) #
Eq k => Eq1 (HashMap k)
Methods liftEq :: (a -> b -> Bool) -> HashMap k a -> HashMap k b -> Bool #
(Eq k, Hashable k, Read k) => Read1 (HashMap k)
Methods liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (HashMap k a) # liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [HashMap k a] # liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (HashMap k a) # liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [HashMap k a] #
Show k => Show1 (HashMap k)
Methods liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> HashMap k a -> ShowS # liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [HashMap k a] -> ShowS #
Hashable k => Hashable1 (HashMap k)
Methods liftHashWithSalt :: (Int -> a -> Int) -> Int -> HashMap k a -> Int #
(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 #
(NFData k, NFData v) => NFData (HashMap k v)
Methods rnf :: HashMap k v -> () #
(Hashable k, Hashable v) => Hashable (HashMap k v)
Methods hashWithSalt :: Int -> HashMap k v -> Int # hash :: HashMap k v -> Int #
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 #
Eq1 HashSet
Methods liftEq :: (a -> b -> Bool) -> HashSet a -> HashSet b -> Bool #
Show1 HashSet
Methods liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> HashSet a -> ShowS # liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [HashSet a] -> ShowS #
Hashable1 HashSet
Methods liftHashWithSalt :: (Int -> a -> Int) -> Int -> HashSet a -> Int #
(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)] #
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 #
NFData a => NFData (HashSet a)
Methods rnf :: HashSet a -> () #
Hashable a => Hashable (HashSet a)
Methods hashWithSalt :: Int -> HashSet a -> Int # hash :: HashSet a -> Int #
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) #
Eq1 IntMap
Methods liftEq :: (a -> b -> Bool) -> IntMap a -> IntMap b -> Bool #
Ord1 IntMap
Methods liftCompare :: (a -> b -> Ordering) -> IntMap a -> IntMap b -> Ordering #
Read1 IntMap
Methods liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (IntMap a) # liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [IntMap a] # liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (IntMap a) # liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [IntMap a] #
Show1 IntMap
Methods liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> IntMap a -> ShowS # liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [IntMap a] -> ShowS #
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 #
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 #
NFData IntSet
Methods rnf :: IntSet -> () #
type Item IntSet
type Item IntSet = Key

data Text :: * #

A space efficient, packed, unboxed Unicode text type.

Instances

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 #
Hashable Text
Methods hashWithSalt :: Int -> Text -> Int # hash :: Text -> Int #
Unpack Text Source #
Methods unpack :: Text -> String Source #
type State Text
type State Text = Buffer
type ChunkElem Text
type ChunkElem Text = Char
type Item Text
type Item Text = Char

type LazyText = Text Source #

data Pair a b Source #

A strict pair.

Constructors

!a :!: !b infixl 2

Instances

(Bounded b, Bounded a) => Bounded (Pair a b) Source #
Methods minBound :: Pair a b # maxBound :: Pair a b #
(Eq b, Eq a) => Eq (Pair a b) Source #
Methods (==) :: Pair a b -> Pair a b -> Bool # (/=) :: Pair a b -> Pair a b -> Bool #
(Ord b, Ord a) => Ord (Pair a b) Source #
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 b, Read a) => Read (Pair a b) Source #
Methods readsPrec :: Int -> ReadS (Pair a b) # readList :: ReadS [Pair a b] # readPrec :: ReadPrec (Pair a b) # readListPrec :: ReadPrec [Pair a b] #
(Show b, Show a) => Show (Pair a b) Source #
Methods showsPrec :: Int -> Pair a b -> ShowS # show :: Pair a b -> String # showList :: [Pair a b] -> ShowS #
(Ix b, Ix a) => Ix (Pair a b) Source #
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 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 #

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

Minimal implementation: hashWithSalt.

Methods

hashWithSalt :: Int -> a -> Int infixl 0 #

Return a hash value for the argument, using the given salt.

The general contract of hashWithSalt is:

If two values are equal according to the == method, then applying the hashWithSalt method on each of the two values must produce the same integer result if the same salt is used in each case.
It is not required that if two values are unequal according to the == method, then applying the hashWithSalt method on each of the two values must produce distinct integer results. However, the programmer should be aware that producing distinct integer results for unequal values may improve the performance of hashing-based data structures.
This method can be used to compute different hash values for the same input by providing a different salt in each application of the method. This implies that any instance that defines hashWithSalt must make use of the salt in its implementation.

hash :: a -> Int #

Like hashWithSalt, but no salt is used. The default implementation uses hashWithSalt with some default salt. Instances might want to implement this method to provide a more efficient implementation than the default implementation.

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 Natural
Methods hashWithSalt :: Int -> Natural -> Int # hash :: Natural -> 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 SomeTypeRep
Methods hashWithSalt :: Int -> SomeTypeRep -> Int # hash :: SomeTypeRep -> Int #
Hashable ()
Methods hashWithSalt :: Int -> () -> Int # hash :: () -> Int #
Hashable ThreadId
Methods hashWithSalt :: Int -> ThreadId -> Int # hash :: ThreadId -> Int #
Hashable ByteString
Methods hashWithSalt :: Int -> ByteString -> Int # hash :: ByteString -> Int #
Hashable ByteString
Methods hashWithSalt :: Int -> ByteString -> Int # hash :: ByteString -> Int #
Hashable Text
Methods hashWithSalt :: Int -> Text -> Int # hash :: Text -> Int #
Hashable Text
Methods hashWithSalt :: Int -> Text -> Int # hash :: Text -> Int #
Hashable BigNat
Methods hashWithSalt :: Int -> BigNat -> Int # hash :: BigNat -> Int #
Hashable Void
Methods hashWithSalt :: Int -> Void -> Int # hash :: Void -> Int #
Hashable Unique
Methods hashWithSalt :: Int -> Unique -> Int # hash :: Unique -> Int #
Hashable Version
Methods hashWithSalt :: Int -> Version -> Int # hash :: Version -> Int #
Hashable WordPtr
Methods hashWithSalt :: Int -> WordPtr -> Int # hash :: WordPtr -> Int #
Hashable IntPtr
Methods hashWithSalt :: Int -> IntPtr -> Int # hash :: IntPtr -> 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 (Ptr a)
Methods hashWithSalt :: Int -> Ptr a -> Int # hash :: Ptr a -> Int #
Hashable (FunPtr a)
Methods hashWithSalt :: Int -> FunPtr a -> Int # hash :: FunPtr a -> Int #
Hashable (Fixed a)
Methods hashWithSalt :: Int -> Fixed a -> Int # hash :: Fixed 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 (StableName a)
Methods hashWithSalt :: Int -> StableName a -> Int # hash :: StableName a -> Int #
Hashable a => Hashable (Identity a)
Methods hashWithSalt :: Int -> Identity a -> Int # hash :: Identity a -> Int #
Hashable (Hashed a)
Methods hashWithSalt :: Int -> Hashed a -> Int # hash :: Hashed 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 (TypeRep k a)
Methods hashWithSalt :: Int -> TypeRep k a -> Int # hash :: TypeRep k a -> Int #
(Hashable a1, Hashable a2) => Hashable (a1, a2)
Methods hashWithSalt :: Int -> (a1, a2) -> Int # hash :: (a1, a2) -> Int #
(Hashable a, Hashable b) => Hashable (Arg a b)
Methods hashWithSalt :: Int -> Arg a b -> Int # hash :: Arg a b -> Int #
Hashable (Proxy k a)
Methods hashWithSalt :: Int -> Proxy k a -> Int # hash :: Proxy k a -> Int #
(Hashable k, Hashable v) => Hashable (HashMap k v)
Methods hashWithSalt :: Int -> HashMap k v -> Int # hash :: HashMap k v -> Int #
(Hashable a1, Hashable a2, Hashable a3) => Hashable (a1, a2, a3)
Methods hashWithSalt :: Int -> (a1, a2, a3) -> Int # hash :: (a1, a2, a3) -> Int #
Hashable a => Hashable (Const k a b)
Methods hashWithSalt :: Int -> Const k a b -> Int # hash :: Const k a b -> 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 #
(Hashable1 f, Hashable1 g, Hashable a) => Hashable (Product * f g a)
Methods hashWithSalt :: Int -> Product * f g a -> Int # hash :: Product * f g a -> Int #
(Hashable1 f, Hashable1 g, Hashable a) => Hashable (Sum * f g a)
Methods hashWithSalt :: Int -> Sum * f g a -> Int # hash :: Sum * f g a -> 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 #
(Hashable1 f, Hashable1 g, Hashable a) => Hashable (Compose * * f g a)	In general, `hash (Compose x) ≠ hash x`. However, `hashWithSalt` satisfies its variant of this equivalence.
Methods hashWithSalt :: Int -> Compose * * f g a -> Int # hash :: Compose * * f g a -> 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 Source #

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

Minimal complete definition

unpack

Methods

unpack :: s -> String Source #

Instances

Unpack ByteString Source #
Methods unpack :: ByteString -> String Source #
Unpack Text Source #
Methods unpack :: Text -> String Source #
Unpack String Source #
Methods unpack :: String -> String Source #

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

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

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