rio-0.1.14.0: A standard library for Haskell

Safe HaskellNone
LanguageHaskell2010

RIO.Prelude

Contents

Synopsis

Documentation

Bool

Re-exported from Data.Bool:

(||) :: Bool -> Bool -> Bool #

(&&) :: Bool -> Bool -> Bool #

not :: Bool -> Bool #

bool :: a -> a -> Bool -> a #

Maybe

Re-exported from Data.Maybe:

maybe :: b -> (a -> b) -> Maybe a -> b #

fromMaybe :: a -> Maybe a -> a #

fromFirst :: a -> First a -> a Source #

Get a First value with a default fallback

isJust :: Maybe a -> Bool #

listToMaybe :: [a] -> Maybe a #

maybeToList :: Maybe a -> [a] #

catMaybes :: [Maybe a] -> [a] #

mapMaybe :: (a -> Maybe b) -> [a] -> [b] #

mapMaybeA :: Applicative f => (a -> f (Maybe b)) -> [a] -> f [b] Source #

Applicative mapMaybe.

mapMaybeM :: Monad m => (a -> m (Maybe b)) -> [a] -> m [b] Source #

Monadic mapMaybe.

forMaybeA :: Applicative f => [a] -> (a -> f (Maybe b)) -> f [b] Source #

forMaybeM :: Monad m => [a] -> (a -> m (Maybe b)) -> m [b] Source #

Either

Re-exported from Data.Either:

either :: (a -> c) -> (b -> c) -> Either a b -> c #

isLeft :: Either a b -> Bool #

isRight :: Either a b -> Bool #

mapLeft :: (a1 -> a2) -> Either a1 b -> Either a2 b Source #

Apply a function to a Left constructor

lefts :: [Either a b] -> [a] #

partitionEithers :: [Either a b] -> ([a], [b]) #

rights :: [Either a b] -> [b] #

Tuples

Re-exported from Data.Tuple:

fst :: (a, b) -> a #

snd :: (a, b) -> b #

curry :: ((a, b) -> c) -> a -> b -> c #

uncurry :: (a -> b -> c) -> (a, b) -> c #

Eq

Re-exported from Data.Eq:

(==) :: Eq a => a -> a -> Bool #

(/=) :: Eq a => a -> a -> Bool #

Ord

Re-exported from Data.Ord:

(<) :: Ord a => a -> a -> Bool #

(<=) :: Ord a => a -> a -> Bool #

(>) :: Ord a => a -> a -> Bool #

(>=) :: Ord a => a -> a -> Bool #

max :: Ord a => a -> a -> a #

min :: Ord a => a -> a -> a #

compare :: Ord a => a -> a -> Ordering #

comparing :: Ord a => (b -> a) -> b -> b -> Ordering #

newtype Down a #

Constructors

Down a 
Instances
Monad Down 
Instance details

Defined in Data.Ord

Methods

(>>=) :: Down a -> (a -> Down b) -> Down b #

(>>) :: Down a -> Down b -> Down b #

return :: a -> Down a #

fail :: String -> Down a #

Functor Down 
Instance details

Defined in Data.Ord

Methods

fmap :: (a -> b) -> Down a -> Down b #

(<$) :: a -> Down b -> Down a #

Applicative Down 
Instance details

Defined in Data.Ord

Methods

pure :: a -> Down a #

(<*>) :: Down (a -> b) -> Down a -> Down b #

liftA2 :: (a -> b -> c) -> Down a -> Down b -> Down c #

(*>) :: Down a -> Down b -> Down b #

(<*) :: Down a -> Down b -> Down a #

Foldable Down 
Instance details

Defined in Data.Foldable

Methods

fold :: Monoid m => Down m -> m #

foldMap :: Monoid m => (a -> m) -> Down a -> m #

foldr :: (a -> b -> b) -> b -> Down a -> b #

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

foldl :: (b -> a -> b) -> b -> Down a -> b #

foldl' :: (b -> a -> b) -> b -> Down a -> b #

foldr1 :: (a -> a -> a) -> Down a -> a #

foldl1 :: (a -> a -> a) -> Down a -> a #

toList :: Down a -> [a] #

null :: Down a -> Bool #

length :: Down a -> Int #

elem :: Eq a => a -> Down a -> Bool #

maximum :: Ord a => Down a -> a #

minimum :: Ord a => Down a -> a #

sum :: Num a => Down a -> a #

product :: Num a => Down a -> a #

Traversable Down 
Instance details

Defined in Data.Traversable

Methods

traverse :: Applicative f => (a -> f b) -> Down a -> f (Down b) #

sequenceA :: Applicative f => Down (f a) -> f (Down a) #

mapM :: Monad m => (a -> m b) -> Down a -> m (Down b) #

sequence :: Monad m => Down (m a) -> m (Down a) #

Eq1 Down 
Instance details

Defined in Data.Functor.Classes

Methods

liftEq :: (a -> b -> Bool) -> Down a -> Down b -> Bool

Ord1 Down 
Instance details

Defined in Data.Functor.Classes

Methods

liftCompare :: (a -> b -> Ordering) -> Down a -> Down b -> Ordering

Read1 Down 
Instance details

Defined in Data.Functor.Classes

Methods

liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Down a)

liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Down a]

liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (Down a)

liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [Down a]

Show1 Down 
Instance details

Defined in Data.Functor.Classes

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Down a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Down a] -> ShowS

NFData1 Down 
Instance details

Defined in Control.DeepSeq

Methods

liftRnf :: (a -> ()) -> Down a -> ()

Unbox a => Vector Vector (Down a) 
Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (Down a) -> m (Vector (Down a)) #

basicUnsafeThaw :: PrimMonad m => Vector (Down a) -> m (Mutable Vector (PrimState m) (Down a)) #

basicLength :: Vector (Down a) -> Int #

basicUnsafeSlice :: Int -> Int -> Vector (Down a) -> Vector (Down a) #

basicUnsafeIndexM :: Monad m => Vector (Down a) -> Int -> m (Down a) #

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (Down a) -> Vector (Down a) -> m () #

elemseq :: Vector (Down a) -> Down a -> b -> b #

Unbox a => MVector MVector (Down a) 
Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s (Down a) -> Int

basicUnsafeSlice :: Int -> Int -> MVector s (Down a) -> MVector s (Down a)

basicOverlaps :: MVector s (Down a) -> MVector s (Down a) -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (Down a))

basicInitialize :: PrimMonad m => MVector (PrimState m) (Down a) -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Down a -> m (MVector (PrimState m) (Down a))

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (Down a) -> Int -> m (Down a)

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (Down a) -> Int -> Down a -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) (Down a) -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) (Down a) -> Down a -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (Down a) -> MVector (PrimState m) (Down a) -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (Down a) -> MVector (PrimState m) (Down a) -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (Down a) -> Int -> m (MVector (PrimState m) (Down a))

Eq a => Eq (Down a) 
Instance details

Defined in Data.Ord

Methods

(==) :: Down a -> Down a -> Bool #

(/=) :: Down a -> Down a -> Bool #

Data a => Data (Down a) 
Instance details

Defined in Data.Data

Methods

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

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

toConstr :: Down a -> Constr #

dataTypeOf :: Down a -> DataType #

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

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

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

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

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

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

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

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

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

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

Num a => Num (Down a) 
Instance details

Defined in Data.Ord

Methods

(+) :: Down a -> Down a -> Down a #

(-) :: Down a -> Down a -> Down a #

(*) :: Down a -> Down a -> Down a #

negate :: Down a -> Down a #

abs :: Down a -> Down a #

signum :: Down a -> Down a #

fromInteger :: Integer -> Down a #

Ord a => Ord (Down a) 
Instance details

Defined in Data.Ord

Methods

compare :: Down a -> Down a -> Ordering #

(<) :: Down a -> Down a -> Bool #

(<=) :: Down a -> Down a -> Bool #

(>) :: Down a -> Down a -> Bool #

(>=) :: Down a -> Down a -> Bool #

max :: Down a -> Down a -> Down a #

min :: Down a -> Down a -> Down a #

Read a => Read (Down a) 
Instance details

Defined in Data.Ord

Methods

readsPrec :: Int -> ReadS (Down a)

readList :: ReadS [Down a]

readPrec :: ReadPrec (Down a)

readListPrec :: ReadPrec [Down a]

Show a => Show (Down a) 
Instance details

Defined in Data.Ord

Methods

showsPrec :: Int -> Down a -> ShowS

show :: Down a -> String #

showList :: [Down a] -> ShowS

Generic (Down a) 
Instance details

Defined in GHC.Generics

Associated Types

type Rep (Down a) :: Type -> Type

Methods

from :: Down a -> Rep (Down a) x

to :: Rep (Down a) x -> Down a

Semigroup a => Semigroup (Down a) 
Instance details

Defined in Data.Ord

Methods

(<>) :: Down a -> Down a -> Down a #

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

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

Monoid a => Monoid (Down a) 
Instance details

Defined in Data.Ord

Methods

mempty :: Down a #

mappend :: Down a -> Down a -> Down a #

mconcat :: [Down a] -> Down a #

NFData a => NFData (Down a) 
Instance details

Defined in Control.DeepSeq

Methods

rnf :: Down a -> () #

Unbox a => Unbox (Down a) 
Instance details

Defined in Data.Vector.Unboxed.Base

Generic1 Down 
Instance details

Defined in GHC.Generics

Associated Types

type Rep1 Down :: k -> Type

Methods

from1 :: Down a -> Rep1 Down a

to1 :: Rep1 Down a -> Down a

newtype MVector s (Down a) 
Instance details

Defined in Data.Vector.Unboxed.Base

newtype MVector s (Down a) = MV_Down (MVector s a)
type Rep (Down a) 
Instance details

Defined in GHC.Generics

type Rep (Down a) = D1 (MetaData "Down" "Data.Ord" "base" True) (C1 (MetaCons "Down" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))
newtype Vector (Down a) 
Instance details

Defined in Data.Vector.Unboxed.Base

newtype Vector (Down a) = V_Down (Vector a)
type Rep1 Down 
Instance details

Defined in GHC.Generics

type Rep1 Down = D1 (MetaData "Down" "Data.Ord" "base" True) (C1 (MetaCons "Down" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

Enum

Re-exported from Prelude:

fromEnum :: Enum a => a -> Int #

Bounded

Re-exported from Prelude:

minBound :: Bounded a => a #

maxBound :: Bounded a => a #

Num

Re-exported from Prelude:

(+) :: Num a => a -> a -> a #

(-) :: Num a => a -> a -> a #

(*) :: Num a => a -> a -> a #

(^) :: (Num a, Integral b) => a -> b -> a #

negate :: Num a => a -> a #

abs :: Num a => a -> a #

signum :: Num a => a -> a #

fromInteger :: Num a => Integer -> a #

subtract :: Num a => a -> a -> a #

Real

Re-exported from Prelude:

toRational :: Real a => a -> Rational #

Integral

Re-exported from Prelude:

quot :: Integral a => a -> a -> a #

rem :: Integral a => a -> a -> a #

div :: Integral a => a -> a -> a #

mod :: Integral a => a -> a -> a #

quotRem :: Integral a => a -> a -> (a, a) #

divMod :: Integral a => a -> a -> (a, a) #

even :: Integral a => a -> Bool #

odd :: Integral a => a -> Bool #

gcd :: Integral a => a -> a -> a #

lcm :: Integral a => a -> a -> a #

fromIntegral :: (Integral a, Num b) => a -> b #

Fractional

Re-exported from Prelude:

(/) :: Fractional a => a -> a -> a #

(^^) :: (Fractional a, Integral b) => a -> b -> a #

recip :: Fractional a => a -> a #

realToFrac :: (Real a, Fractional b) => a -> b #

Floating

Re-exported from Prelude:

pi :: Floating a => a #

exp :: Floating a => a -> a #

log :: Floating a => a -> a #

sqrt :: Floating a => a -> a #

(**) :: Floating a => a -> a -> a #

logBase :: Floating a => a -> a -> a #

sin :: Floating a => a -> a #

cos :: Floating a => a -> a #

tan :: Floating a => a -> a #

asin :: Floating a => a -> a #

acos :: Floating a => a -> a #

atan :: Floating a => a -> a #

sinh :: Floating a => a -> a #

cosh :: Floating a => a -> a #

tanh :: Floating a => a -> a #

asinh :: Floating a => a -> a #

acosh :: Floating a => a -> a #

atanh :: Floating a => a -> a #

RealFrac

Re-exported from Prelude:

properFraction :: (RealFrac a, Integral b) => a -> (b, a) #

truncate :: (RealFrac a, Integral b) => a -> b #

round :: (RealFrac a, Integral b) => a -> b #

ceiling :: (RealFrac a, Integral b) => a -> b #

floor :: (RealFrac a, Integral b) => a -> b #

RealFloat

Re-exported from Prelude:

floatDigits :: RealFloat a => a -> Int #

floatRange :: RealFloat a => a -> (Int, Int) #

exponent :: RealFloat a => a -> Int #

significand :: RealFloat a => a -> a #

scaleFloat :: RealFloat a => Int -> a -> a #

isNaN :: RealFloat a => a -> Bool #

isInfinite :: RealFloat a => a -> Bool #

isIEEE :: RealFloat a => a -> Bool #

atan2 :: RealFloat a => a -> a -> a #

Word

Re-exported from Data.Word:

Semigroup

Re-exported from Data.Semigroup:

(<>) :: Semigroup a => a -> a -> a #

sappend :: Semigroup s => s -> s -> s Source #

Monoid

Re-exported from Data.Monoid:

mempty :: Monoid a => a #

mappend :: Monoid a => a -> a -> a #

mconcat :: Monoid a => [a] -> a #

Functor

Re-exported from Data.Functor:

fmap :: Functor f => (a -> b) -> f a -> f b #

(<$>) :: Functor f => (a -> b) -> f a -> f b #

(<$) :: Functor f => a -> f b -> f a #

($>) :: Functor f => f a -> b -> f b #

void :: Functor f => f a -> f () #

(<&>) :: Functor f => f a -> (a -> b) -> f b #

Applicative

Re-exported from Control.Applicative:

pure :: Applicative f => a -> f a #

(<*>) :: Applicative f => f (a -> b) -> f a -> f b #

(<*) :: Applicative f => f a -> f b -> f a #

(*>) :: Applicative f => f a -> f b -> f b #

liftA :: Applicative f => (a -> b) -> f a -> f b #

liftA2 :: Applicative f => (a -> b -> c) -> f a -> f b -> f c #

liftA3 :: Applicative f => (a -> b -> c -> d) -> f a -> f b -> f c -> f d #

forever :: Applicative f => f a -> f b #

traverse_ :: (Foldable t, Applicative f) => (a -> f b) -> t a -> f () #

for_ :: (Foldable t, Applicative f) => t a -> (a -> f b) -> f () #

sequenceA_ :: (Foldable t, Applicative f) => t (f a) -> f () #

filterM :: Applicative m => (a -> m Bool) -> [a] -> m [a] #

replicateM_ :: Applicative m => Int -> m a -> m () #

zipWithM :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m [c] #

zipWithM_ :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m () #

Monad

Re-exported from Control.Monad:

return :: Monad m => a -> m a #

join :: Monad m => m (m a) -> m a #

fail :: Monad m => String -> m a #

(>>=) :: Monad m => m a -> (a -> m b) -> m b #

(>>) :: Monad m => m a -> m b -> m b #

(=<<) :: Monad m => (a -> m b) -> m a -> m b #

(>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c #

(<=<) :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c #

(<$!>) :: Monad m => (a -> b) -> m a -> m b #

liftM :: Monad m => (a1 -> r) -> m a1 -> m r #

liftM2 :: Monad m => (a1 -> a2 -> r) -> m a1 -> m a2 -> m r #

whenM :: Monad m => m Bool -> m () -> m () Source #

Run the second value if the first value returns True

unlessM :: Monad m => m Bool -> m () -> m () Source #

Run the second value if the first value returns False

mapM_ :: (Foldable t, Monad m) => (a -> m b) -> t a -> m () #

forM_ :: (Foldable t, Monad m) => t a -> (a -> m b) -> m () #

sequence_ :: (Foldable t, Monad m) => t (m a) -> m () #

foldM :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m b #

foldM_ :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m () #

Foldable

Re-exported from Data.Foldable:

foldr :: Foldable t => (a -> b -> b) -> b -> t a -> b #

foldl' :: Foldable t => (b -> a -> b) -> b -> t a -> b #

fold :: (Foldable t, Monoid m) => t m -> m #

foldMap :: (Foldable t, Monoid m) => (a -> m) -> t a -> m #

foldMapM :: (Monad m, Monoid w, Foldable t) => (a -> m w) -> t a -> m w Source #

Extend foldMap to allow side effects.

Internally, this is implemented using a strict left fold. This is used for performance reasons. It also necessitates that this function has a Monad constraint and not just an Applicative constraint. For more information, see https://github.com/commercialhaskell/rio/pull/99#issuecomment-394179757.

Since: 0.1.3.0

elem :: (Foldable t, Eq a) => a -> t a -> Bool #

notElem :: (Foldable t, Eq a) => a -> t a -> Bool #

null :: Foldable t => t a -> Bool #

length :: Foldable t => t a -> Int #

sum :: (Foldable t, Num a) => t a -> a #

product :: (Foldable t, Num a) => t a -> a #

all :: Foldable t => (a -> Bool) -> t a -> Bool #

any :: Foldable t => (a -> Bool) -> t a -> Bool #

and :: Foldable t => t Bool -> Bool #

or :: Foldable t => t Bool -> Bool #

toList :: Foldable t => t a -> [a] #

concat :: Foldable t => t [a] -> [a] #

concatMap :: Foldable t => (a -> [b]) -> t a -> [b] #

Traversable

Re-exported from Data.Traversable:

traverse :: (Traversable t, Applicative f) => (a -> f b) -> t a -> f (t b) #

for :: (Traversable t, Applicative f) => t a -> (a -> f b) -> f (t b) #

sequenceA :: (Traversable t, Applicative f) => t (f a) -> f (t a) #

mapM :: (Traversable t, Monad m) => (a -> m b) -> t a -> m (t b) #

forM :: (Traversable t, Monad m) => t a -> (a -> m b) -> m (t b) #

sequence :: (Traversable t, Monad m) => t (m a) -> m (t a) #

Alternative

Re-exported from Control.Applicative:

(<|>) :: Alternative f => f a -> f a -> f a #

some :: Alternative f => f a -> f [a] #

many :: Alternative f => f a -> f [a] #

optional :: Alternative f => f a -> f (Maybe a) #

asum :: (Foldable t, Alternative f) => t (f a) -> f a #

guard :: Alternative f => Bool -> f () #

when :: Applicative f => Bool -> f () -> f () #

unless :: Applicative f => Bool -> f () -> f () #

MonadPlus

Re-exported from Control.Monad:

mzero :: MonadPlus m => m a #

mplus :: MonadPlus m => m a -> m a -> m a #

msum :: (Foldable t, MonadPlus m) => t (m a) -> m a #

mfilter :: MonadPlus m => (a -> Bool) -> m a -> m a #

Arrow

Re-exported from Control.Arrow and Control.Category:

first :: Arrow a => a b c -> a (b, d) (c, d) #

second :: Arrow a => a b c -> a (d, b) (d, c) #

(&&&) :: Arrow a => a b c -> a b c' -> a b (c, c') #

(***) :: Arrow a => a b c -> a b' c' -> a (b, b') (c, c') #

(>>>) :: Category cat => cat a b -> cat b c -> cat a c #

Function

Re-exported from Data.Function:

id :: a -> a #

const :: a -> b -> a #

(.) :: (b -> c) -> (a -> b) -> a -> c #

($) :: (a -> b) -> a -> b #

(&) :: a -> (a -> b) -> b #

flip :: (a -> b -> c) -> b -> a -> c #

fix :: (a -> a) -> a #

on :: (b -> b -> c) -> (a -> b) -> a -> a -> c #

Miscellaneous functions

($!) :: (a -> b) -> a -> b #

seq :: a -> b -> b #

error :: HasCallStack => [Char] -> a #

asTypeOf :: a -> a -> a #

asIO :: IO a -> IO a Source #

Helper function to force an action to run in IO. Especially useful for overly general contexts, like hspec tests.

Since: 0.1.3.0

List

Re-exported from Data.List:

(++) :: [a] -> [a] -> [a] #

break :: (a -> Bool) -> [a] -> ([a], [a]) #

drop :: Int -> [a] -> [a] #

dropWhile :: (a -> Bool) -> [a] -> [a] #

filter :: (a -> Bool) -> [a] -> [a] #

lookup :: Eq a => a -> [(a, b)] -> Maybe b #

map :: (a -> b) -> [a] -> [b] #

replicate :: Int -> a -> [a] #

reverse :: [a] -> [a] #

span :: (a -> Bool) -> [a] -> ([a], [a]) #

take :: Int -> [a] -> [a] #

takeWhile :: (a -> Bool) -> [a] -> [a] #

zip :: [a] -> [b] -> [(a, b)] #

zipWith :: (a -> b -> c) -> [a] -> [b] -> [c] #

nubOrd :: Ord a => [a] -> [a] Source #

Strip out duplicates

String

Re-exported from Data.String:

Show

Re-exported from Text.Show:

show :: Show a => a -> String #

Read

Re-exported from Text.Read:

readMaybe :: Read a => String -> Maybe a #

NFData

Re-exported from Control.DeepSeq:

($!!) :: NFData a => (a -> b) -> a -> b #

rnf :: NFData a => a -> () #

deepseq :: NFData a => a -> b -> b #

force :: NFData a => a -> a #

Void

Re-exported from Data.Void:

absurd :: Void -> a #

Reader

Re-exported from Control.Monad.Reader:

lift :: (MonadTrans t, Monad m) => m a -> t m a #

ask :: MonadReader r m => m r #

asks :: MonadReader r m => (r -> a) -> m a #

local :: MonadReader r m => (r -> r) -> m a -> m a #

runReader :: Reader r a -> r -> a #

runReaderT :: ReaderT r m a -> r -> m a #

ByteString

Helper synonyms for converting bewteen lazy and strict ByteStrings

ShortByteString

Re-exported from Data.ByteString.Short:

Text

tshow :: Show a => a -> Text Source #

Re-exported from Data.Text.Encoding:

decodeUtf8With :: OnDecodeError -> ByteString -> Text #

lenientDecode :: OnDecodeError #

PrimMonad

Re-exported from Control.Monad.Primitive:

primitive :: PrimMonad m => (State# (PrimState m) -> (#State# (PrimState m), a#)) -> m a #

Re-exported from Control.Monad.ST:

runST :: (forall s. ST s a) -> a #