Safe Haskell | Safe-Inferred |
---|---|
Language | Haskell2010 |
RIO.Prelude
Contents
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
- 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
- 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 {
- getDown :: 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 :: 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
- (++) :: [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:
Maybe
Re-exported from Data.Maybe:
listToMaybe :: [a] -> Maybe a #
maybeToList :: Maybe a -> [a] #
mapMaybeA :: Applicative f => (a -> f (Maybe b)) -> [a] -> f [b] #
Applicative mapMaybe
.
Either
Re-exported from Data.Either:
partitionEithers :: [Either a b] -> ([a], [b]) #
Tuples
Re-exported from Data.Tuple:
Eq
Re-exported from Data.Eq:
Ord
Re-exported from Data.Ord:
Instances
Foldable Down | |
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 # elem :: Eq a => a -> Down a -> Bool # maximum :: Ord a => Down a -> a # | |
Traversable Down | |
Applicative Down | |
Functor Down | |
Monad Down | |
NFData1 Down | |
Defined in Control.DeepSeq | |
Generic1 Down | |
Unbox a => Vector Vector (Down a) | |
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 () # | |
Unbox a => MVector MVector (Down a) | |
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) | |
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) | |
Monoid a => Monoid (Down a) | |
Semigroup a => Semigroup (Down a) | |
Bits a => Bits (Down a) | |
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 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 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 | |
FiniteBits a => FiniteBits (Down a) | |
Defined in Data.Ord Methods finiteBitSize :: Down a -> Int countLeadingZeros :: Down a -> Int countTrailingZeros :: Down a -> Int | |
Bounded a => Bounded (Down a) | |
(Enum a, Bounded a, Eq a) => Enum (Down a) | |
Defined in Data.Ord | |
Floating a => Floating (Down a) | |
RealFloat a => RealFloat (Down a) | |
Defined in Data.Ord Methods floatRadix :: Down a -> Integer # floatDigits :: Down a -> Int # floatRange :: Down a -> (Int, Int) # decodeFloat :: Down a -> (Integer, Int) # encodeFloat :: Integer -> Int -> Down a # significand :: Down a -> Down a # scaleFloat :: Int -> Down a -> Down a # isInfinite :: Down a -> Bool # isDenormalized :: Down a -> Bool # isNegativeZero :: Down a -> Bool # | |
Generic (Down a) | |
Ix a => Ix (Down a) | |
Num a => Num (Down a) | |
Read a => Read (Down a) | |
Fractional a => Fractional (Down a) | |
Real a => Real (Down a) | |
Defined in Data.Ord Methods toRational :: Down a -> Rational # | |
RealFrac a => RealFrac (Down a) | |
Show a => Show (Down a) | |
NFData a => NFData (Down a) | |
Defined in Control.DeepSeq | |
Eq a => Eq (Down a) | |
Ord a => Ord (Down a) | |
Unbox a => Unbox (Down a) | |
Defined in Data.Vector.Unboxed.Base | |
type Rep1 Down | |
Defined in GHC.Generics | |
newtype MVector s (Down a) | |
Defined in Data.Vector.Unboxed.Base | |
type Rep (Down a) | |
Defined in GHC.Generics | |
newtype Vector (Down a) | |
Defined in Data.Vector.Unboxed.Base |
Enum
Re-exported from Prelude:
Bounded
Re-exported from Prelude:
Num
Re-exported from Prelude:
fromInteger :: Num a => Integer -> a #
Real
Re-exported from Prelude:
toRational :: Real a => a -> Rational #
Integral
Re-exported from Prelude:
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:
RealFrac
Re-exported from Prelude:
properFraction :: (RealFrac a, Integral b) => a -> (b, a) #
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 #
significand :: RealFloat a => a -> a #
scaleFloat :: RealFloat a => Int -> a -> a #
isInfinite :: RealFloat a => a -> Bool #
isDenormalized :: RealFloat a => a -> Bool #
isNegativeZero :: RealFloat a => a -> Bool #
Word
Re-exported from Data.Word:
byteSwap16 :: Word16 -> Word16 #
byteSwap32 :: Word32 -> Word32 #
byteSwap64 :: Word64 -> Word64 #
Semigroup
Re-exported from Data.Semigroup:
Monoid
Re-exported from Data.Monoid:
Functor
Re-exported from Data.Functor:
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:
Foldable
Re-exported from Data.Foldable:
foldMapM :: (Monad m, Monoid w, Foldable t) => (a -> m w) -> t a -> m w #
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
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:
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] #
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:
Arrow
Re-exported from Control.Arrow and Control.Category:
Function
Re-exported from Data.Function:
Miscellaneous functions
error :: forall (r :: RuntimeRep) (a :: TYPE r). HasCallStack => [Char] -> a #
undefined :: forall (r :: RuntimeRep) (a :: TYPE r). HasCallStack => a #
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:
String
Re-exported from Data.String:
fromString :: IsString a => String -> a #
Show
Re-exported from Text.Show:
Read
Re-exported from Text.Read:
NFData
Re-exported from Control.DeepSeq:
Void
Re-exported from Data.Void:
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 #
runReaderT :: ReaderT r m a -> r -> m a #
ByteString
Helper synonyms for converting bewteen lazy and strict ByteString
s
toStrictBytes :: LByteString -> ByteString #
ShortByteString
Re-exported from Data.ByteString.Short:
toShort :: ByteString -> ShortByteString #
fromShort :: ShortByteString -> ByteString #
Text
decodeUtf8Lenient :: ByteString -> Text #
Re-exported from Data.Text.Encoding:
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 #
Execute a primitive operation.
Re-exported from Control.Monad.ST: