rio-0.1.22.0: A standard library for Haskell
Safe HaskellSafe-Inferred
LanguageHaskell2010

RIO.Prelude

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 #

fromLeft :: a -> Either a b -> a #

fromRight :: b -> Either a b -> b #

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 

Fields

Instances

Instances details
Foldable Down 
Instance details

Defined in Data.Foldable

Methods

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

foldMap :: Monoid m => (a -> m) -> Down a -> 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) #

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 #

Functor Down 
Instance details

Defined in Data.Ord

Methods

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

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

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 #

NFData1 Down 
Instance details

Defined in Control.DeepSeq

Methods

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

Generic1 Down 
Instance details

Defined in GHC.Generics

Associated Types

type Rep1 Down :: k -> Type

Methods

from1 :: forall (a :: k). Down a -> Rep1 Down a

to1 :: forall (a :: k). Rep1 Down a -> Down a

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

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: Mutable Vector s (Down a) -> ST s (Vector (Down a)) #

basicUnsafeThaw :: Vector (Down a) -> ST s (Mutable Vector s (Down a)) #

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

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

basicUnsafeIndexM :: Vector (Down a) -> Int -> Box (Down a) #

basicUnsafeCopy :: Mutable Vector s (Down a) -> Vector (Down a) -> ST s () #

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 :: Int -> ST s (MVector s (Down a))

basicInitialize :: MVector s (Down a) -> ST s ()

basicUnsafeReplicate :: Int -> Down a -> ST s (MVector s (Down a))

basicUnsafeRead :: MVector s (Down a) -> Int -> ST s (Down a)

basicUnsafeWrite :: MVector s (Down a) -> Int -> Down a -> ST s ()

basicClear :: MVector s (Down a) -> ST s ()

basicSet :: MVector s (Down a) -> Down a -> ST s ()

basicUnsafeCopy :: MVector s (Down a) -> MVector s (Down a) -> ST s ()

basicUnsafeMove :: MVector s (Down a) -> MVector s (Down a) -> ST s ()

basicUnsafeGrow :: MVector s (Down a) -> Int -> ST s (MVector s (Down a))

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 :: forall r r'. (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) #

Storable a => Storable (Down a) 
Instance details

Defined in Data.Ord

Methods

sizeOf :: Down a -> Int

alignment :: Down a -> Int

peekElemOff :: Ptr (Down a) -> Int -> IO (Down a)

pokeElemOff :: Ptr (Down a) -> Int -> Down a -> IO ()

peekByteOff :: Ptr b -> Int -> IO (Down a)

pokeByteOff :: Ptr b -> Int -> Down a -> IO ()

peek :: Ptr (Down a) -> IO (Down a)

poke :: Ptr (Down a) -> Down a -> IO ()

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 #

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

Bits a => Bits (Down a) 
Instance details

Defined in Data.Ord

Methods

(.&.) :: Down a -> Down a -> Down a

(.|.) :: Down a -> Down a -> Down a

xor :: Down a -> Down a -> Down a

complement :: Down a -> Down a

shift :: Down a -> Int -> Down a

rotate :: Down a -> Int -> Down a

zeroBits :: Down a

bit :: Int -> Down a

setBit :: Down a -> Int -> Down a

clearBit :: Down a -> Int -> Down a

complementBit :: Down a -> Int -> Down a

testBit :: Down a -> Int -> Bool

bitSizeMaybe :: Down a -> Maybe Int

bitSize :: Down a -> Int

isSigned :: Down a -> Bool

shiftL :: Down a -> Int -> Down a

unsafeShiftL :: Down a -> Int -> Down a

shiftR :: Down a -> Int -> Down a

unsafeShiftR :: Down a -> Int -> Down a

rotateL :: Down a -> Int -> Down a

rotateR :: Down a -> Int -> Down a

popCount :: Down a -> Int

FiniteBits a => FiniteBits (Down a) 
Instance details

Defined in Data.Ord

Bounded a => Bounded (Down a) 
Instance details

Defined in Data.Ord

Methods

minBound :: Down a #

maxBound :: Down a #

Floating a => Floating (Down a) 
Instance details

Defined in Data.Ord

Methods

pi :: Down a #

exp :: Down a -> Down a #

log :: Down a -> Down a #

sqrt :: Down a -> Down a #

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

logBase :: Down a -> Down a -> Down a #

sin :: Down a -> Down a #

cos :: Down a -> Down a #

tan :: Down a -> Down a #

asin :: Down a -> Down a #

acos :: Down a -> Down a #

atan :: Down a -> Down a #

sinh :: Down a -> Down a #

cosh :: Down a -> Down a #

tanh :: Down a -> Down a #

asinh :: Down a -> Down a #

acosh :: Down a -> Down a #

atanh :: Down a -> Down a #

log1p :: Down a -> Down a

expm1 :: Down a -> Down a

log1pexp :: Down a -> Down a

log1mexp :: Down a -> Down a

RealFloat a => RealFloat (Down a) 
Instance details

Defined in Data.Ord

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

Ix a => Ix (Down a) 
Instance details

Defined in Data.Ord

Methods

range :: (Down a, Down a) -> [Down a]

index :: (Down a, Down a) -> Down a -> Int

unsafeIndex :: (Down a, Down a) -> Down a -> Int

inRange :: (Down a, Down a) -> Down a -> Bool

rangeSize :: (Down a, Down a) -> Int

unsafeRangeSize :: (Down a, Down a) -> Int

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 #

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]

Fractional a => Fractional (Down a) 
Instance details

Defined in Data.Ord

Methods

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

recip :: Down a -> Down a #

fromRational :: Rational -> Down a #

Real a => Real (Down a) 
Instance details

Defined in Data.Ord

Methods

toRational :: Down a -> Rational #

RealFrac a => RealFrac (Down a) 
Instance details

Defined in Data.Ord

Methods

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

truncate :: Integral b => Down a -> b #

round :: Integral b => Down a -> b #

ceiling :: Integral b => Down a -> b #

floor :: Integral b => Down a -> b #

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

NFData a => NFData (Down a) 
Instance details

Defined in Control.DeepSeq

Methods

rnf :: Down a -> () #

Eq a => Eq (Down a) 
Instance details

Defined in Data.Ord

Methods

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

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

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 #

Unbox a => Unbox (Down a) 
Instance details

Defined in Data.Vector.Unboxed.Base

type Rep1 Down 
Instance details

Defined in GHC.Generics

type Rep1 Down = D1 ('MetaData "Down" "Data.Ord" "base" 'True) (C1 ('MetaCons "Down" 'PrefixI 'True) (S1 ('MetaSel ('Just "getDown") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1))
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 'True) (S1 ('MetaSel ('Just "getDown") '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)

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 :: MonadFail 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 () #

Bifunctor

Re-exported from Data.Bifunctor:

bimap :: Bifunctor p => (a -> b) -> (c -> d) -> p a c -> p b d #

first :: Bifunctor p => (a -> b) -> p a c -> p b c #

second :: Bifunctor p => (b -> c) -> p a b -> p a c #

Bifoldable

Re-exported from Data.Bifoldable:

bifold :: (Bifoldable p, Monoid m) => p m m -> m #

bifoldMap :: (Bifoldable p, Monoid m) => (a -> m) -> (b -> m) -> p a b -> m #

bifoldr :: Bifoldable p => (a -> c -> c) -> (b -> c -> c) -> c -> p a b -> c #

bifoldl :: Bifoldable p => (c -> a -> c) -> (c -> b -> c) -> c -> p a b -> c #

bifoldr' :: Bifoldable t => (a -> c -> c) -> (b -> c -> c) -> c -> t a b -> c #

bifoldr1 :: Bifoldable t => (a -> a -> a) -> t a a -> a #

bifoldrM :: (Bifoldable t, Monad m) => (a -> c -> m c) -> (b -> c -> m c) -> c -> t a b -> m c #

bifoldl' :: Bifoldable t => (a -> b -> a) -> (a -> c -> a) -> a -> t b c -> a #

bifoldl1 :: Bifoldable t => (a -> a -> a) -> t a a -> a #

bifoldlM :: (Bifoldable t, Monad m) => (a -> b -> m a) -> (a -> c -> m a) -> a -> t b c -> m a #

bitraverse_ :: (Bifoldable t, Applicative f) => (a -> f c) -> (b -> f d) -> t a b -> f () #

bifor_ :: (Bifoldable t, Applicative f) => t a b -> (a -> f c) -> (b -> f d) -> f () #

bisequence_ :: (Bifoldable t, Applicative f) => t (f a) (f b) -> f () #

biasum :: (Bifoldable t, Alternative f) => t (f a) (f a) -> f a #

biList :: Bifoldable t => t a a -> [a] #

binull :: Bifoldable t => t a b -> Bool #

bilength :: Bifoldable t => t a b -> Int #

bielem :: (Bifoldable t, Eq a) => a -> t a a -> Bool #

bimaximum :: (Bifoldable t, Ord a) => t a a -> a #

biminimum :: (Bifoldable t, Ord a) => t a a -> a #

bisum :: (Bifoldable t, Num a) => t a a -> a #

biproduct :: (Bifoldable t, Num a) => t a a -> a #

biconcat :: Bifoldable t => t [a] [a] -> [a] #

biconcatMap :: Bifoldable t => (a -> [c]) -> (b -> [c]) -> t a b -> [c] #

bior :: Bifoldable t => t Bool Bool -> Bool #

biany :: Bifoldable t => (a -> Bool) -> (b -> Bool) -> t a b -> Bool #

biall :: Bifoldable t => (a -> Bool) -> (b -> Bool) -> t a b -> Bool #

bimaximumBy :: Bifoldable t => (a -> a -> Ordering) -> t a a -> a #

biminimumBy :: Bifoldable t => (a -> a -> Ordering) -> t a a -> a #

binotElem :: (Bifoldable t, Eq a) => a -> t a a -> Bool #

bifind :: Bifoldable t => (a -> Bool) -> t a a -> Maybe a #

Bitraverse

Re-exported from Data.Bitraversable:

bitraverse :: (Bitraversable t, Applicative f) => (a -> f c) -> (b -> f d) -> t a b -> f (t c d) #

bisequence :: (Bitraversable t, Applicative f) => t (f a) (f b) -> f (t a b) #

bifor :: (Bitraversable t, Applicative f) => t a b -> (a -> f c) -> (b -> f d) -> f (t c d) #

bimapAccumL :: Bitraversable t => (a -> b -> (a, c)) -> (a -> d -> (a, e)) -> a -> t b d -> (a, t c e) #

bimapAccumR :: Bitraversable t => (a -> b -> (a, c)) -> (a -> d -> (a, e)) -> a -> t b d -> (a, t c e) #

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:

(&&&) :: 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') #

(>>>) :: forall {k} cat (a :: k) (b :: k) (c :: k). 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 #

($) :: forall (r :: RuntimeRep) a (b :: TYPE r). (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

($!) :: forall (r :: RuntimeRep) a (b :: TYPE r). (a -> b) -> a -> b #

seq :: forall {r :: RuntimeRep} a (b :: TYPE r). a -> b -> b #

error :: forall (r :: RuntimeRep) (a :: TYPE r). HasCallStack => [Char] -> a #

undefined :: forall (r :: RuntimeRep) (a :: TYPE r). HasCallStack => 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 #