rio-0.1.18.0: A standard library for Haskell

Safe Haskell | None
Language | Haskell2010

RIO.Prelude

Contents

- `Bool`
- `Maybe`
- `Either`
- Tuples
- `Eq`
- `Ord`
- `Enum`
- `Bounded`
- `Num`
- `Real`
- `Integral`
- `Fractional`
- `Floating`
- `RealFrac`
- `RealFloat`
- `Word`
- `Semigroup`
- `Monoid`
- `Functor`
- `Applicative`
- `Monad`
- `Foldable`
- `Traversable`
- `Alternative`
- `Bifunctor`
- `Bifoldable`
- `Bitraverse`
- `MonadPlus`
- `Arrow`
- `Function`
- Miscellaneous functions
- List
- `String`
  - `Show`
  - `Read`
- `NFData`
- `Void`
- `Reader`
- `ByteString`
- `ShortByteString`
- `Text`
- `PrimMonad`

Synopsis

- module RIO.Prelude.Types
- (||) :: Bool -> Bool -> Bool
- (&&) :: Bool -> Bool -> Bool
- not :: Bool -> Bool
- otherwise :: Bool
- bool :: a -> a -> Bool -> a
- maybe :: b -> (a -> b) -> Maybe a -> b
- fromMaybe :: a -> Maybe a -> a
- fromFirst :: a -> First a -> a
- isJust :: Maybe a -> Bool
- isNothing :: 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]
- mapMaybeM :: Monad m => (a -> m (Maybe b)) -> [a] -> m [b]
- forMaybeA :: Applicative f => [a] -> (a -> f (Maybe b)) -> f [b]
- forMaybeM :: Monad m => [a] -> (a -> m (Maybe b)) -> m [b]
- 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
- lefts :: [Either a b] -> [a]
- partitionEithers :: [Either a b] -> ([a], [b])
- rights :: [Either a b] -> [b]
- fst :: (a, b) -> a
- snd :: (a, b) -> b
- curry :: ((a, b) -> c) -> a -> b -> c
- uncurry :: (a -> b -> c) -> (a, b) -> c
- (==) :: Eq a => a -> a -> Bool
- (/=) :: Eq a => a -> a -> Bool
- (<) :: 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 = Down a
- fromEnum :: Enum a => a -> Int
- minBound :: Bounded a => a
- maxBound :: Bounded a => a
- (+) :: 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
- toRational :: Real a => a -> Rational
- 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)
- toInteger :: Integral a => a -> Integer
- 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 a => a -> a -> a
- (^^) :: (Fractional a, Integral b) => a -> b -> a
- recip :: Fractional a => a -> a
- fromRational :: Fractional a => Rational -> a
- realToFrac :: (Real a, Fractional b) => a -> b
- 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
- 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
- floatRadix :: RealFloat a => a -> Integer
- floatDigits :: RealFloat a => a -> Int
- floatRange :: RealFloat a => a -> (Int, Int)
- decodeFloat :: RealFloat a => a -> (Integer, Int)
- encodeFloat :: RealFloat a => Integer -> Int -> a
- 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
- isDenormalized :: RealFloat a => a -> Bool
- isNegativeZero :: RealFloat a => a -> Bool
- isIEEE :: RealFloat a => a -> Bool
- atan2 :: RealFloat a => a -> a -> a
- byteSwap16 :: Word16 -> Word16
- byteSwap32 :: Word32 -> Word32
- byteSwap64 :: Word64 -> Word64
- (<>) :: Semigroup a => a -> a -> a
- sappend :: Semigroup s => s -> s -> s
- mempty :: Monoid a => a
- mappend :: Monoid a => a -> a -> a
- mconcat :: Monoid a => [a] -> a
- 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
- 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 ()
- 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 ()
- unlessM :: Monad m => m Bool -> m () -> m ()
- 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 ()
- 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
- 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]
- 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 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 ()
- 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
- 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]
- biand :: Bifoldable t => t Bool Bool -> Bool
- 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 :: (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)
- 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 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
- 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
- ($!) :: forall (r :: RuntimeRep) a (b :: TYPE r). (a -> b) -> a -> b
- seq :: 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
- (++) :: [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]
- fromString :: IsString a => String -> a
- lines :: String -> [String]
- unlines :: [String] -> String
- unwords :: [String] -> String
- words :: String -> [String]
- show :: Show a => a -> String
- readMaybe :: Read a => String -> Maybe a
- ($!!) :: NFData a => (a -> b) -> a -> b
- rnf :: NFData a => a -> ()
- deepseq :: NFData a => a -> b -> b
- force :: NFData a => a -> a
- absurd :: Void -> a
- 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
- toStrictBytes :: LByteString -> ByteString
- fromStrictBytes :: ByteString -> LByteString
- toShort :: ByteString -> ShortByteString
- fromShort :: ShortByteString -> ByteString
- tshow :: Show a => a -> Text
- decodeUtf8Lenient :: ByteString -> Text
- decodeUtf8' :: ByteString -> Either UnicodeException Text
- decodeUtf8With :: OnDecodeError -> ByteString -> Text
- encodeUtf8 :: Text -> ByteString
- encodeUtf8Builder :: Text -> Builder
- lenientDecode :: OnDecodeError
- primitive :: PrimMonad m => (State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a
- runST :: (forall s. ST s a) -> a

# Documentation

module RIO.Prelude.Types

# `Bool`

Re-exported from Data.Bool:

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

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

not :: Bool -> Bool #

otherwise :: 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 #

isNothing :: 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 #

    forMaybeA == flip mapMaybeA

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

    forMaybeM == flip mapMaybeM

# `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

Instances details

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 #
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 #

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)) Source #

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

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

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

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

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

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

Unbox a => MVector MVector (Down a) |

Instance details

Defined in Data.Vector.Unboxed.Base

Methods

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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 #
Prim a => Prim (Down a) | Since: primitive-0.6.5.0

Instance details

Defined in Data.Primitive.Types

Methods

sizeOf# :: Down a -> Int# Source #

alignment# :: Down a -> Int# Source #

indexByteArray# :: ByteArray# -> Int# -> Down a Source #

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Down a #) Source #

writeByteArray# :: MutableByteArray# s -> Int# -> Down a -> State# s -> State# s Source #

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Down a -> State# s -> State# s Source #

indexOffAddr# :: Addr# -> Int# -> Down a Source #

readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Down a #) Source #

writeOffAddr# :: Addr# -> Int# -> Down a -> State# s -> State# s Source #

setOffAddr# :: Addr# -> Int# -> Int# -> Down a -> State# s -> State# s Source #

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 :: forall (a :: k). Down a -> Rep1 Down a to1 :: forall (a :: k). 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) #

toInteger :: Integral a => a -> Integer #

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 #

fromRational :: Fractional a => Rational -> 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:

floatRadix :: RealFloat a => a -> Integer #

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

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

decodeFloat :: RealFloat a => a -> (Integer, Int) #

encodeFloat :: RealFloat a => Integer -> Int -> a #

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 #

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

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

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

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

# `Word`

Re-exported from Data.Word:

byteSwap16 :: Word16 -> Word16 #

byteSwap32 :: Word32 -> Word32 #

byteSwap64 :: Word64 -> Word64 #

# `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] #

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

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 :: 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:

fromString :: IsString a => String -> a #

lines :: String -> [String] #

unlines :: [String] -> String #

unwords :: [String] -> String #

words :: String -> [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 `ByteString`s

toStrictBytes :: LByteString -> ByteString Source #

fromStrictBytes :: ByteString -> LByteString Source #

# `ShortByteString`

Re-exported from Data.ByteString.Short:

toShort :: ByteString -> ShortByteString #

fromShort :: ShortByteString -> ByteString #

# `Text`

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

decodeUtf8Lenient :: ByteString -> Text Source #

Re-exported from Data.Text.Encoding:

decodeUtf8' :: ByteString -> Either UnicodeException Text #

decodeUtf8With :: OnDecodeError -> ByteString -> Text #

encodeUtf8 :: Text -> ByteString #

encodeUtf8Builder :: Text -> Builder #

lenientDecode :: OnDecodeError #

# `PrimMonad`

Re-exported from Control.Monad.Primitive:

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

Execute a primitive operation

Re-exported from Control.Monad.ST:

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