| Safe Haskell | Safe-Inferred |
|---|---|
| Language | GHC2021 |
Hydra.Prelude
Synopsis
- data Int
- data Float = F# Float#
- data Char
- data IO a
- data Word8
- data Handle
- data Bool
- data Double = D# Double#
- data Word
- data Ordering
- data Maybe a
- class a ~# b => (a :: k) ~ (b :: k)
- class a ~R# b => Coercible (a :: k) (b :: k)
- class One x where
- data Natural
- data Integer
- type Type = TYPE LiftedRep
- type Constraint = CONSTRAINT LiftedRep
- newtype Any = Any {}
- data Word64
- data Word32
- data Word16
- data Either a b
- class (forall a. Functor (p a)) => Bifunctor (p :: Type -> Type -> Type) where
- newtype Sum a = Sum {
- getSum :: a
- newtype Product a = Product {
- getProduct :: a
- class IsString a where
- fromString :: String -> a
- class (Real a, Enum a) => Integral a where
- type Rational = Ratio Integer
- type String = [Char]
- class (Alternative m, Monad m) => MonadPlus (m :: Type -> Type) where
- class Read a
- class Show a
- data Int8
- data Int16
- data Int32
- data Int64
- newtype Last a = Last {}
- newtype First a = First {}
- class (Typeable e, Show e) => Exception e where
- toException :: e -> SomeException
- fromException :: SomeException -> Maybe e
- displayException :: e -> String
- class Monad m => MonadIO (m :: Type -> Type) where
- newtype Compose (f :: k -> Type) (g :: k1 -> k) (a :: k1) = Compose {
- getCompose :: f (g a)
- class IsList l where
- class Bounded a where
- class Enum a where
- succ :: a -> a
- pred :: a -> a
- toEnum :: Int -> a
- fromEnum :: a -> Int
- enumFrom :: a -> [a]
- enumFromThen :: a -> a -> [a]
- enumFromTo :: a -> a -> [a]
- enumFromThenTo :: a -> a -> a -> [a]
- class Eq a where
- class Fractional a => Floating a where
- class Num a => Fractional a where
- (/) :: a -> a -> a
- recip :: a -> a
- fromRational :: Rational -> a
- class Applicative m => Monad (m :: Type -> Type) where
- class Functor (f :: Type -> Type) where
- class Num a where
- class Eq a => Ord a where
- class (Num a, Ord a) => Real a where
- toRational :: a -> Rational
- class (RealFrac a, Floating a) => RealFloat a where
- floatRadix :: a -> Integer
- floatDigits :: a -> Int
- floatRange :: a -> (Int, Int)
- decodeFloat :: a -> (Integer, Int)
- encodeFloat :: Integer -> Int -> a
- isNaN :: a -> Bool
- isInfinite :: a -> Bool
- isDenormalized :: a -> Bool
- isNegativeZero :: a -> Bool
- isIEEE :: a -> Bool
- atan2 :: a -> a -> a
- class (Real a, Fractional a) => RealFrac a where
- class Typeable (a :: k)
- class Monad m => MonadFail (m :: Type -> Type) where
- class Functor f => Applicative (f :: Type -> Type) where
- class Foldable (t :: Type -> Type) where
- class (Functor t, Foldable t) => Traversable (t :: Type -> Type) where
- traverse :: Applicative f => (a -> f b) -> t a -> f (t b)
- sequenceA :: Applicative f => t (f a) -> f (t a)
- mapM :: Monad m => (a -> m b) -> t a -> m (t b)
- sequence :: Monad m => t (m a) -> m (t a)
- class Generic a
- class KnownNat (n :: Nat)
- class Semigroup a where
- class Semigroup a => Monoid a where
- data Ratio a
- data Void
- data NonEmpty a = a :| [a]
- data CallStack
- type family CmpNat (a :: Natural) (b :: Natural) :: Ordering where ...
- data Text
- type HasCallStack = ?callStack :: CallStack
- data SomeException = Exception e => SomeException e
- class Applicative f => Alternative (f :: Type -> Type) where
- newtype Down a = Down {
- getDown :: a
- data Proxy (t :: k) = Proxy
- data IOMode
- data SomeNat = KnownNat n => SomeNat (Proxy n)
- newtype Alt (f :: k -> Type) (a :: k) = Alt {
- getAlt :: f a
- newtype All = All {}
- newtype Endo a = Endo {
- appEndo :: a -> a
- newtype Dual a = Dual {
- getDual :: a
- newtype Ap (f :: k -> Type) (a :: k) = Ap {
- getAp :: f a
- newtype Const a (b :: k) = Const {
- getConst :: a
- type FilePath = String
- data IORef a
- data BufferMode
- newtype Identity a = Identity {
- runIdentity :: a
- newtype ZipList a = ZipList {
- getZipList :: [a]
- class IsLabel (x :: Symbol) a where
- fromLabel :: a
- class Bifoldable (p :: Type -> Type -> Type) where
- class (Bifunctor t, Bifoldable t) => Bitraversable (t :: Type -> Type -> Type) where
- bitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> t a b -> f (t c d)
- data WrappedMonoid m
- newtype Op a b = Op {
- getOp :: b -> a
- newtype Equivalence a = Equivalence {
- getEquivalence :: a -> a -> Bool
- newtype Comparison a = Comparison {
- getComparison :: a -> a -> Ordering
- newtype Predicate a = Predicate {
- getPredicate :: a -> Bool
- class Contravariant (f :: Type -> Type) where
- newtype StateT s (m :: Type -> Type) a = StateT {
- runStateT :: s -> m (a, s)
- data ByteString
- data ShortByteString
- data Map k a
- data Set a
- type State s = StateT s Identity
- data Seq a
- data IntSet
- data IntMap a
- class NFData a where
- rnf :: a -> ()
- newtype ExceptT e (m :: Type -> Type) a = ExceptT (m (Either e a))
- newtype MaybeT (m :: Type -> Type) a = MaybeT {}
- class Monad m => MonadState s (m :: Type -> Type) | m -> s where
- newtype ReaderT r (m :: Type -> Type) a = ReaderT {
- runReaderT :: r -> m a
- type Reader r = ReaderT r Identity
- class Monad m => MonadReader r (m :: Type -> Type) | m -> r where
- class (forall (m :: Type -> Type). Monad m => Monad (t m)) => MonadTrans (t :: (Type -> Type) -> Type -> Type) where
- data IdentityT (f :: k -> Type) (a :: k)
- data UnicodeException
- type OnDecodeError = OnError Word8 Char
- type OnError a b = String -> Maybe a -> Maybe b
- type family OneItem x
- data Undefined = Undefined
- data Bug = Bug SomeException CallStack
- class ConvertUtf8 a b where
- encodeUtf8 :: a -> b
- decodeUtf8 :: b -> a
- decodeUtf8Strict :: b -> Either UnicodeException a
- type LByteString = ByteString
- type LText = Text
- class LazyStrict l s | l -> s, s -> l where
- class ToLText a where
- class ToString a where
- class ToText a where
- class Eq a => Hashable a where
- hashWithSalt :: Int -> a -> Int
- data HashMap k v
- data HashSet a
- pattern Exc :: Exception e => e -> SomeException
- deepseq :: NFData a => a -> b -> b
- error :: forall (r :: RuntimeRep) (a :: TYPE r) t. (HasCallStack, IsText t) => t -> a
- callStack :: HasCallStack => CallStack
- zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
- show :: forall b a. (Show a, IsString b) => a -> b
- even :: Integral a => a -> Bool
- (<$>) :: Functor f => (a -> b) -> f a -> f b
- stimesIdempotent :: Integral b => b -> a -> a
- stimesIdempotentMonoid :: (Integral b, Monoid a) => b -> a -> a
- ($) :: forall (r :: RuntimeRep) a (b :: TYPE r). (a -> b) -> a -> b
- sortBy :: (a -> a -> Ordering) -> [a] -> [a]
- fst :: (a, b) -> a
- bool :: a -> a -> Bool -> a
- readMaybe :: Read a => String -> Maybe a
- genericLength :: Num i => [a] -> i
- genericReplicate :: Integral i => i -> a -> [a]
- genericTake :: Integral i => i -> [a] -> [a]
- genericDrop :: Integral i => i -> [a] -> [a]
- genericSplitAt :: Integral i => i -> [a] -> ([a], [a])
- uncurry :: (a -> b -> c) -> (a, b) -> c
- coerce :: forall {k :: RuntimeRep} (a :: TYPE k) (b :: TYPE k). Coercible a b => a -> b
- ord :: Char -> Int
- chr :: Int -> Char
- id :: a -> a
- head :: IsNonEmpty f a a "head" => f a -> a
- group :: Eq a => [a] -> [[a]]
- forM :: (Traversable t, Monad m) => t a -> (a -> m b) -> m (t b)
- atomicWriteIORef :: MonadIO m => IORef a -> a -> m ()
- atomicModifyIORef :: MonadIO m => IORef a -> (a -> (a, b)) -> m b
- stdout :: Handle
- stdin :: Handle
- stderr :: Handle
- forever :: Applicative f => f a -> f b
- hFlush :: MonadIO m => Handle -> m ()
- readFile' :: MonadIO m => FilePath -> m String
- writeFile :: MonadIO m => FilePath -> String -> m ()
- getLine :: MonadIO m => m Text
- putStrLn :: MonadIO m => String -> m ()
- getArgs :: MonadIO m => m [String]
- filter :: (a -> Bool) -> [a] -> [a]
- lookupEnv :: MonadIO m => String -> m (Maybe String)
- unfoldr :: (b -> Maybe (a, b)) -> b -> [a]
- transpose :: [[a]] -> [[a]]
- bifor :: (Bitraversable t, Applicative f) => t a b -> (a -> f c) -> (b -> f d) -> f (t c d)
- bisequence :: (Bitraversable t, Applicative f) => t (f a) (f b) -> f (t a b)
- exitWith :: MonadIO m => ExitCode -> m a
- sortOn :: Ord b => (a -> b) -> [a] -> [a]
- cycle :: [a] -> [a]
- (++) :: [a] -> [a] -> [a]
- seq :: forall {r :: RuntimeRep} a (b :: TYPE r). a -> b -> b
- concat :: Foldable t => t [a] -> [a]
- zip :: [a] -> [b] -> [(a, b)]
- print :: forall a m. (MonadIO m, Show a) => a -> m ()
- otherwise :: Bool
- trace :: String -> a -> a
- map :: (a -> b) -> [a] -> [b]
- (>>>) :: forall {k} cat (a :: k) (b :: k) (c :: k). Category cat => cat a b -> cat b c -> cat a c
- fromIntegral :: (Integral a, Num b) => a -> b
- realToFrac :: (Real a, Fractional b) => a -> b
- guard :: Alternative f => Bool -> f ()
- join :: Monad m => m (m a) -> m a
- (^) :: (Num a, Integral b) => a -> b -> a
- (&&) :: Bool -> Bool -> Bool
- (||) :: Bool -> Bool -> Bool
- not :: Bool -> Bool
- getCallStack :: CallStack -> [([Char], SrcLoc)]
- undefined :: forall (r :: RuntimeRep) (a :: TYPE r). HasCallStack => a
- absurd :: Void -> a
- vacuous :: Functor f => f Void -> f a
- (<**>) :: Applicative f => f a -> f (a -> b) -> f b
- liftA3 :: Applicative f => (a -> b -> c -> d) -> f a -> f b -> f c -> f d
- (=<<) :: Monad m => (a -> m b) -> m a -> m b
- when :: Applicative f => Bool -> f () -> f ()
- minInt :: Int
- maxInt :: Int
- const :: a -> b -> a
- (.) :: (b -> c) -> (a -> b) -> a -> c
- flip :: (a -> b -> c) -> b -> a -> c
- ($!) :: forall (r :: RuntimeRep) a (b :: TYPE r). (a -> b) -> a -> b
- asTypeOf :: a -> a -> a
- currentCallStack :: IO [String]
- subtract :: Num a => a -> a -> a
- maybe :: b -> (a -> b) -> Maybe a -> b
- isJust :: Maybe a -> Bool
- isNothing :: Maybe a -> Bool
- fromMaybe :: a -> Maybe a -> a
- maybeToList :: Maybe a -> [a]
- listToMaybe :: [a] -> Maybe a
- catMaybes :: [Maybe a] -> [a]
- mapMaybe :: (a -> Maybe b) -> [a] -> [b]
- uncons :: [a] -> Maybe (a, [a])
- tail :: IsNonEmpty f a [a] "tail" => f a -> [a]
- last :: IsNonEmpty f a a "last" => f a -> a
- init :: IsNonEmpty f a [a] "init" => f a -> [a]
- sum :: forall a f. (Foldable f, Num a) => f a -> a
- product :: forall a f. (Foldable f, Num a) => f a -> a
- scanl :: (b -> a -> b) -> b -> [a] -> [b]
- scanl1 :: (a -> a -> a) -> [a] -> [a]
- scanl' :: (b -> a -> b) -> b -> [a] -> [b]
- scanr :: (a -> b -> b) -> b -> [a] -> [b]
- scanr1 :: (a -> a -> a) -> [a] -> [a]
- iterate :: (a -> a) -> a -> [a]
- repeat :: a -> [a]
- replicate :: Int -> a -> [a]
- takeWhile :: (a -> Bool) -> [a] -> [a]
- dropWhile :: (a -> Bool) -> [a] -> [a]
- take :: Int -> [a] -> [a]
- drop :: Int -> [a] -> [a]
- splitAt :: Int -> [a] -> ([a], [a])
- span :: (a -> Bool) -> [a] -> ([a], [a])
- break :: (a -> Bool) -> [a] -> ([a], [a])
- reverse :: [a] -> [a]
- and :: Foldable t => t Bool -> Bool
- or :: Foldable t => t Bool -> Bool
- any :: Foldable t => (a -> Bool) -> t a -> Bool
- all :: Foldable t => (a -> Bool) -> t a -> Bool
- elem :: (Foldable f, DisallowElem f, Eq a) => a -> f a -> Bool
- notElem :: (Foldable f, DisallowElem f, Eq a) => a -> f a -> Bool
- concatMap :: Foldable t => (a -> [b]) -> t a -> [b]
- zip3 :: [a] -> [b] -> [c] -> [(a, b, c)]
- unzip :: [(a, b)] -> ([a], [b])
- unzip3 :: [(a, b, c)] -> ([a], [b], [c])
- boundedEnumFrom :: (Enum a, Bounded a) => a -> [a]
- boundedEnumFromThen :: (Enum a, Bounded a) => a -> a -> [a]
- numerator :: Ratio a -> a
- denominator :: Ratio a -> a
- odd :: Integral a => a -> Bool
- (^^) :: (Fractional a, Integral b) => a -> b -> a
- gcd :: Integral a => a -> a -> a
- lcm :: Integral a => a -> a -> a
- xor :: Bits a => a -> a -> a
- toIntegralSized :: (Integral a, Integral b, Bits a, Bits b) => a -> Maybe b
- byteSwap16 :: Word16 -> Word16
- byteSwap32 :: Word32 -> Word32
- byteSwap64 :: Word64 -> Word64
- snd :: (a, b) -> b
- curry :: ((a, b) -> c) -> a -> b -> c
- swap :: (a, b) -> (b, a)
- (<&>) :: Functor f => f a -> (a -> b) -> f b
- ($>) :: Functor f => f a -> b -> f b
- void :: Functor f => f a -> f ()
- fix :: (a -> a) -> a
- on :: (b -> b -> c) -> (a -> b) -> a -> a -> c
- (&) :: a -> (a -> b) -> b
- optional :: Alternative f => f a -> f (Maybe a)
- either :: (a -> c) -> (b -> c) -> Either a b -> c
- lefts :: [Either a b] -> [a]
- rights :: [Either a b] -> [b]
- partitionEithers :: [Either a b] -> ([a], [b])
- isLeft :: Either a b -> Bool
- isRight :: Either a b -> Bool
- fromLeft :: a -> Either a b -> a
- fromRight :: b -> Either a b -> b
- reads :: Read a => ReadS a
- readEither :: Read a => String -> Either Text a
- comparing :: Ord a => (b -> a) -> b -> b -> Ordering
- (<<<) :: forall {k} cat (b :: k) (c :: k) (a :: k). Category cat => cat b c -> cat a b -> cat a c
- natVal :: forall (n :: Nat) proxy. KnownNat n => proxy n -> Natural
- someNatVal :: Natural -> SomeNat
- stimesMonoid :: (Integral b, Monoid a) => b -> a -> a
- foldlM :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m b
- traverse_ :: (Foldable t, Applicative f) => (a -> f b) -> t a -> f ()
- for_ :: (Foldable t, Applicative f) => t a -> (a -> f b) -> f ()
- mapM_ :: (Foldable t, Monad m) => (a -> m b) -> t a -> m ()
- forM_ :: (Foldable t, Monad m) => t a -> (a -> m b) -> m ()
- sequenceA_ :: (Foldable t, Applicative f) => t (f a) -> f ()
- sequence_ :: (Foldable t, Monad m) => t (m a) -> m ()
- asum :: (Foldable t, Alternative f) => t (f a) -> f a
- find :: Foldable t => (a -> Bool) -> t a -> Maybe a
- isPrefixOf :: Eq a => [a] -> [a] -> Bool
- intersperse :: a -> [a] -> [a]
- intercalate :: [a] -> [[a]] -> [a]
- mapAccumL :: Traversable t => (s -> a -> (s, b)) -> s -> t a -> (s, t b)
- mapAccumR :: Traversable t => (s -> a -> (s, b)) -> s -> t a -> (s, t b)
- inits :: [a] -> [[a]]
- tails :: [a] -> [[a]]
- subsequences :: [a] -> [[a]]
- permutations :: [a] -> [[a]]
- sort :: Ord a => [a] -> [a]
- lines :: IsText t "lines" => t -> [t]
- unlines :: IsText t "unlines" => [t] -> t
- words :: IsText t "words" => t -> [t]
- unwords :: IsText t "unwords" => [t] -> t
- prettySrcLoc :: SrcLoc -> String
- prettyCallStack :: CallStack -> String
- newIORef :: MonadIO m => a -> m (IORef a)
- readIORef :: MonadIO m => IORef a -> m a
- writeIORef :: MonadIO m => IORef a -> a -> m ()
- atomicModifyIORef'_ :: MonadIO m => IORef a -> (a -> a) -> m ()
- atomicModifyIORef' :: MonadIO m => IORef a -> (a -> (a, b)) -> m b
- modifyIORef :: MonadIO m => IORef a -> (a -> a) -> m ()
- modifyIORef' :: MonadIO m => IORef a -> (a -> a) -> m ()
- hIsEOF :: MonadIO m => Handle -> m Bool
- hSetBuffering :: MonadIO m => Handle -> BufferMode -> m ()
- hGetBuffering :: MonadIO m => Handle -> m BufferMode
- putStr :: MonadIO m => String -> m ()
- readFile :: MonadIO m => FilePath -> m String
- appendFile :: MonadIO m => FilePath -> String -> m ()
- (&&&) :: Arrow a => a b c -> a b c' -> a b (c, c')
- filterM :: Applicative m => (a -> m Bool) -> [a] -> m [a]
- (>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c
- (<=<) :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c
- mapAndUnzipM :: Applicative m => (a -> m (b, c)) -> [a] -> m ([b], [c])
- zipWithM :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m [c]
- zipWithM_ :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m ()
- replicateM :: Applicative m => Int -> m a -> m [a]
- replicateM_ :: Applicative m => Int -> m a -> m ()
- unless :: Applicative f => Bool -> f () -> f ()
- (<$!>) :: Monad m => (a -> b) -> m a -> m b
- mfilter :: MonadPlus m => (a -> Bool) -> m a -> m a
- exitFailure :: MonadIO m => m a
- exitSuccess :: MonadIO m => m a
- die :: MonadIO m => String -> m a
- withFrozenCallStack :: HasCallStack => (HasCallStack => a) -> a
- traceShowM :: (Show a, Applicative f) => a -> f ()
- traceShowId :: Show a => a -> a
- traceShow :: Show a => a -> b -> b
- traceId :: String -> String
- traceShowWith :: Show b => (a -> b) -> a -> a
- getStackTrace :: IO (Maybe [Location])
- showStackTrace :: IO (Maybe String)
- nonEmpty :: [a] -> Maybe (NonEmpty a)
- sortWith :: Ord b => (a -> b) -> [a] -> [a]
- bifoldr' :: Bifoldable t => (a -> c -> c) -> (b -> c -> c) -> c -> t a b -> c
- 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
- 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
- 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
- bifind :: Bifoldable t => (a -> Bool) -> t a a -> Maybe a
- bimapDefault :: Bitraversable t => (a -> b) -> (c -> d) -> t a c -> t b d
- bifoldMapDefault :: (Bitraversable t, Monoid m) => (a -> m) -> (b -> m) -> t a b -> m
- cycle1 :: Semigroup m => m -> m
- mtimesDefault :: (Integral b, Monoid a) => b -> a -> a
- phantom :: (Functor f, Contravariant f) => f a -> f b
- ($<) :: Contravariant f => f b -> b -> f a
- (>$<) :: Contravariant f => (a -> b) -> f b -> f a
- (>$$<) :: Contravariant f => f b -> (a -> b) -> f a
- defaultComparison :: Ord a => Comparison a
- defaultEquivalence :: Eq a => Equivalence a
- comparisonEquivalence :: Comparison a -> Equivalence a
- integerToNatural :: Integer -> Maybe Natural
- fromShort :: ShortByteString -> ByteString
- fromStrict :: LazyStrict l s => s -> l
- toShort :: ByteString -> ShortByteString
- runState :: State s a -> s -> (a, s)
- execState :: State s a -> s -> s
- ($!!) :: NFData a => (a -> b) -> a -> b
- force :: NFData a => a -> a
- andM :: (Foldable f, Monad m) => f (m Bool) -> m Bool
- runExceptT :: ExceptT e m a -> m (Either e a)
- runReader :: Reader r a -> r -> a
- withReader :: (r' -> r) -> Reader r a -> Reader r' a
- withReaderT :: forall r' r (m :: Type -> Type) a. (r' -> r) -> ReaderT r m a -> ReaderT r' m a
- evalState :: State s a -> s -> a
- withState :: (s -> s) -> State s a -> State s a
- evalStateT :: Monad m => StateT s m a -> s -> m a
- execStateT :: Monad m => StateT s m a -> s -> m s
- asks :: MonadReader r m => (r -> a) -> m a
- modify :: MonadState s m => (s -> s) -> m ()
- modify' :: MonadState s m => (s -> s) -> m ()
- gets :: MonadState s m => (s -> a) -> m a
- pass :: Applicative f => f ()
- decodeUtf8With :: OnDecodeError -> ByteString -> Text
- strictDecode :: OnDecodeError
- lenientDecode :: OnDecodeError
- decodeUtf8' :: ByteString -> Either UnicodeException Text
- hoistMaybe :: forall (m :: Type -> Type) a. Applicative m => Maybe a -> MaybeT m a
- maybeToExceptT :: forall (m :: Type -> Type) e a. Functor m => e -> MaybeT m a -> ExceptT e m a
- exceptToMaybeT :: forall (m :: Type -> Type) e a. Functor m => ExceptT e m a -> MaybeT m a
- appliedTo :: Applicative f => f a -> f (a -> b) -> f b
- (&&^) :: Monad m => m Bool -> m Bool -> m Bool
- guardM :: MonadPlus m => m Bool -> m ()
- guarded :: Alternative f => (a -> Bool) -> a -> f a
- ifM :: Monad m => m Bool -> m a -> m a -> m a
- unlessM :: Monad m => m Bool -> m () -> m ()
- whenM :: Monad m => m Bool -> m () -> m ()
- (||^) :: Monad m => m Bool -> m Bool -> m Bool
- evaluateNF :: (NFData a, MonadIO m) => a -> m a
- evaluateNF_ :: (NFData a, MonadIO m) => a -> m ()
- evaluateWHNF :: MonadIO m => a -> m a
- evaluateWHNF_ :: MonadIO m => a -> m ()
- inverseMap :: (Bounded a, Enum a, Ord k) => (a -> k) -> k -> Maybe a
- universe :: (Bounded a, Enum a) => [a]
- universeNonEmpty :: (Bounded a, Enum a) => NonEmpty a
- bug :: (HasCallStack, Exception e) => e -> a
- appendFileBS :: MonadIO m => FilePath -> ByteString -> m ()
- appendFileLBS :: MonadIO m => FilePath -> LByteString -> m ()
- appendFileLText :: MonadIO m => FilePath -> LText -> m ()
- appendFileText :: MonadIO m => FilePath -> Text -> m ()
- readFileBS :: MonadIO m => FilePath -> m ByteString
- readFileLBS :: MonadIO m => FilePath -> m LByteString
- readFileLText :: MonadIO m => FilePath -> m LText
- readFileText :: MonadIO m => FilePath -> m Text
- writeFileBS :: MonadIO m => FilePath -> ByteString -> m ()
- writeFileLBS :: MonadIO m => FilePath -> LByteString -> m ()
- writeFileLText :: MonadIO m => FilePath -> LText -> m ()
- writeFileText :: MonadIO m => FilePath -> Text -> m ()
- allM :: (Foldable f, Monad m) => (a -> m Bool) -> f a -> m Bool
- anyM :: (Foldable f, Monad m) => (a -> m Bool) -> f a -> m Bool
- asumMap :: forall b m f a. (Foldable f, Alternative m) => (a -> m b) -> f a -> m b
- flipfoldl' :: Foldable f => (a -> b -> b) -> b -> f a -> b
- foldMapA :: (Semigroup b, Monoid b, Applicative m, Foldable f) => (a -> m b) -> f a -> m b
- foldMapM :: (Monoid b, Monad m, Foldable f) => (a -> m b) -> f a -> m b
- orM :: (Foldable f, Monad m) => f (m Bool) -> m Bool
- identity :: a -> a
- (<<$>>) :: (Functor f, Functor g) => (a -> b) -> f (g a) -> f (g b)
- (??) :: Functor f => f (a -> b) -> a -> f b
- flap :: Functor f => f (a -> b) -> a -> f b
- atomicModifyIORef_ :: MonadIO m => IORef a -> (a -> a) -> m ()
- (!!?) :: [a] -> Int -> Maybe a
- maybeAt :: Int -> [a] -> Maybe a
- partitionWith :: (a -> Either b c) -> [a] -> ([b], [c])
- viaNonEmpty :: (NonEmpty a -> b) -> [a] -> Maybe b
- whenNotNull :: Applicative f => [a] -> (NonEmpty a -> f ()) -> f ()
- whenNotNullM :: Monad m => m [a] -> (NonEmpty a -> m ()) -> m ()
- chainedTo :: Monad m => (a -> m b) -> m a -> m b
- infinitely :: Applicative f => f a -> f Void
- leftToMaybe :: Either l r -> Maybe l
- maybeToLeft :: r -> Maybe l -> Either l r
- maybeToRight :: l -> Maybe r -> Either l r
- rightToMaybe :: Either l r -> Maybe r
- whenLeft :: Applicative f => a -> Either l r -> (l -> f a) -> f a
- whenLeftM :: Monad m => a -> m (Either l r) -> (l -> m a) -> m a
- whenLeftM_ :: Monad m => m (Either l r) -> (l -> m ()) -> m ()
- whenLeft_ :: Applicative f => Either l r -> (l -> f ()) -> f ()
- whenRight :: Applicative f => a -> Either l r -> (r -> f a) -> f a
- whenRightM :: Monad m => a -> m (Either l r) -> (r -> m a) -> m a
- whenRightM_ :: Monad m => m (Either l r) -> (r -> m ()) -> m ()
- whenRight_ :: Applicative f => Either l r -> (r -> f ()) -> f ()
- (?:) :: Maybe a -> a -> a
- mapMaybeM :: Monad m => (a -> m (Maybe b)) -> [a] -> m [b]
- whenJust :: Applicative f => Maybe a -> (a -> f ()) -> f ()
- whenJustM :: Monad m => m (Maybe a) -> (a -> m ()) -> m ()
- whenNothing :: Applicative f => Maybe a -> f a -> f a
- whenNothingM :: Monad m => m (Maybe a) -> m a -> m a
- whenNothingM_ :: Monad m => m (Maybe a) -> m () -> m ()
- whenNothing_ :: Applicative f => Maybe a -> f () -> f ()
- etaReaderT :: forall r (m :: Type -> Type) a. ReaderT r m a -> ReaderT r m a
- evaluatingState :: s -> State s a -> a
- evaluatingStateT :: Functor f => s -> StateT s f a -> f a
- executingState :: s -> State s a -> s
- executingStateT :: Functor f => s -> StateT s f a -> f s
- hoistEither :: forall (m :: Type -> Type) e a. Applicative m => Either e a -> ExceptT e m a
- usingReader :: r -> Reader r a -> a
- usingReaderT :: r -> ReaderT r m a -> m a
- usingState :: s -> State s a -> (a, s)
- usingStateT :: s -> StateT s m a -> m (a, s)
- maybeToMonoid :: Monoid m => Maybe m -> m
- memptyIfFalse :: Monoid m => Bool -> m -> m
- memptyIfTrue :: Monoid m => Bool -> m -> m
- hashNub :: Hashable a => [a] -> [a]
- intNub :: [Int] -> [Int]
- intNubOn :: (a -> Int) -> [a] -> [a]
- ordNub :: Ord a => [a] -> [a]
- ordNubOn :: Ord b => (a -> b) -> [a] -> [a]
- sortNub :: Ord a => [a] -> [a]
- unstableNub :: Hashable a => [a] -> [a]
- integerToBounded :: (Integral a, Bounded a) => Integer -> Maybe a
- putBS :: MonadIO m => ByteString -> m ()
- putBSLn :: MonadIO m => ByteString -> m ()
- putLBS :: MonadIO m => LByteString -> m ()
- putLBSLn :: MonadIO m => LByteString -> m ()
- putLText :: MonadIO m => LText -> m ()
- putLTextLn :: MonadIO m => LText -> m ()
- putText :: MonadIO m => Text -> m ()
- putTextLn :: MonadIO m => Text -> m ()
- fromLazy :: LazyStrict l s => l -> s
- class (Monad m, Monad (STM m)) => MonadSTM (m :: Type -> Type) where
- type STM (m :: Type -> Type) = (stm :: Type -> Type) | stm -> m
- atomically :: HasCallStack => STM m a -> m a
- type family STM (m :: Type -> Type) = (stm :: Type -> Type) | stm -> m
- data DiffTime
- data NominalDiffTime
- data UTCTime
- class MonadMonotonicTimeNSec m => MonadMonotonicTime (m :: Type -> Type) where
- getMonotonicTime :: m Time
- class Monad m => MonadTime (m :: Type -> Type) where
- getCurrentTime :: m UTCTime
- newtype Time = Time DiffTime
- addUTCTime :: NominalDiffTime -> UTCTime -> UTCTime
- diffUTCTime :: UTCTime -> UTCTime -> NominalDiffTime
- addTime :: DiffTime -> Time -> Time
- diffTime :: Time -> Time -> DiffTime
- class PrimMonad m => MonadST (m :: Type -> Type)
- class (MonadSTM m, MonadThread m) => MonadAsync (m :: Type -> Type) where
- withAsync :: m a -> (Async m a -> m b) -> m b
- race :: m a -> m b -> m (Either a b)
- race_ :: m a -> m b -> m ()
- concurrently :: m a -> m b -> m (a, b)
- concurrently_ :: m a -> m b -> m ()
- class Monad m => MonadEventlog (m :: Type -> Type)
- class (MonadDelay m, MonadMonotonicTime m) => MonadDelay (m :: Type -> Type) where
- threadDelay :: DiffTime -> m ()
- class (MonadTimer m, MonadMonotonicTime m) => MonadTimer (m :: Type -> Type) where
- registerDelay :: DiffTime -> m (TVar m Bool)
- registerDelayCancellable :: DiffTime -> m (STM m TimeoutState, m ())
- timeout :: DiffTime -> m a -> m (Maybe a)
- class MonadThread m => MonadFork (m :: Type -> Type)
- class (Monad m, Eq (ThreadId m), Ord (ThreadId m), Show (ThreadId m)) => MonadThread (m :: Type -> Type)
- class MonadCatch m => MonadMask (m :: Type -> Type) where
- mask :: ((forall a. m a -> m a) -> m b) -> m b
- uninterruptibleMask :: ((forall a. m a -> m a) -> m b) -> m b
- mask_ :: m a -> m a
- uninterruptibleMask_ :: m a -> m a
- class MonadThrow m => MonadCatch (m :: Type -> Type) where
- catch :: Exception e => m a -> (e -> m a) -> m a
- catchJust :: Exception e => (e -> Maybe b) -> m a -> (b -> m a) -> m a
- try :: Exception e => m a -> m (Either e a)
- tryJust :: Exception e => (e -> Maybe b) -> m a -> m (Either b a)
- handle :: Exception e => (e -> m a) -> m a -> m a
- handleJust :: Exception e => (e -> Maybe b) -> (b -> m a) -> m a -> m a
- onException :: m a -> m b -> m a
- bracketOnError :: m a -> (a -> m b) -> (a -> m c) -> m c
- generalBracket :: m a -> (a -> ExitCase b -> m c) -> (a -> m b) -> m (b, c)
- class Monad m => MonadThrow (m :: Type -> Type) where
- class MonadThrow m => MonadEvaluate (m :: Type -> Type) where
- evaluate :: a -> m a
- type family TBQueue (m :: Type -> Type) :: Type -> Type
- type family TBQueue (m :: Type -> Type) :: Type -> Type
- type family TMVar (m :: Type -> Type) :: Type -> Type
- type family TMVar (m :: Type -> Type) :: Type -> Type
- type family TQueue (m :: Type -> Type) :: Type -> Type
- type family TQueue (m :: Type -> Type) :: Type -> Type
- type family TVar (m :: Type -> Type) :: Type -> Type
- readTVar :: MonadSTM m => TVar m a -> STM m a
- type family TVar (m :: Type -> Type) :: Type -> Type
- class StaticMap t where
- class StaticMap t => DynamicMap t where
- keys :: (IsList t, Item t ~ (a, b)) => t -> [a]
- elems :: (IsList t, Item t ~ (a, b)) => t -> [b]
- class Typeable a => FromCBOR a where
- class Typeable a => ToCBOR a where
- toCBOR :: a -> Encoding
- encodedSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size) -> Proxy a -> Size
- encodedListSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size) -> Proxy [a] -> Size
- class FromJSON a where
- parseJSON :: Value -> Parser a
- parseJSONList :: Value -> Parser [a]
- omittedField :: Maybe a
- class ToJSON a where
- toJSON :: a -> Value
- toEncoding :: a -> Encoding
- toJSONList :: [a] -> Value
- toEncodingList :: [a] -> Encoding
- omitField :: a -> Bool
- encodePretty :: ToJSON a => a -> ByteString
- data Gen a
- class Arbitrary a where
- genericArbitrary :: (Generic a, GA UnsizedOpts (Rep a), UniformWeight (Weights_ (Rep a))) => Gen a
- genericShrink :: (Generic a, RecursivelyShrink (Rep a), GSubterms (Rep a) a) => a -> [a]
- generateWith :: Gen a -> Int -> a
- shrinkListAggressively :: [a] -> [[a]]
- reasonablySized :: Gen a -> Gen a
- newtype ReasonablySized a = ReasonablySized a
- padLeft :: Char -> Int -> Text -> Text
- padRight :: Char -> Int -> Text -> Text
- type Except e = ExceptT e Identity
- decodeBase16 :: MonadFail f => Text -> f ByteString
- (?>) :: Maybe a -> e -> Either e a
- withFile :: FilePath -> IOMode -> (Handle -> IO a) -> IO a
- spy :: Show a => a -> a
- spy' :: Show a => String -> a -> a
Documentation
A fixed-precision integer type with at least the range [-2^29 .. 2^29-1].
The exact range for a given implementation can be determined by using
minBound and maxBound from the Bounded class.
Instances
| Arbitrary Int | |
| CoArbitrary Int | |
Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Int -> Gen b -> Gen b | |
| FromJSON Int | |
Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Int # parseJSONList :: Value -> Parser [Int] # omittedField :: Maybe Int # | |
| FromJSONKey Int | |
Defined in Data.Aeson.Types.FromJSON | |
| ToJSON Int | |
Defined in Data.Aeson.Types.ToJSON | |
| ToJSONKey Int | |
Defined in Data.Aeson.Types.ToJSON | |
| Bits Int | Since: base-2.1 |
Defined in GHC.Bits Methods (.&.) :: Int -> Int -> Int Source # (.|.) :: Int -> Int -> Int Source # xor :: Int -> Int -> Int Source # complement :: Int -> Int Source # shift :: Int -> Int -> Int Source # rotate :: Int -> Int -> Int Source # setBit :: Int -> Int -> Int Source # clearBit :: Int -> Int -> Int Source # complementBit :: Int -> Int -> Int Source # testBit :: Int -> Int -> Bool Source # bitSizeMaybe :: Int -> Maybe Int Source # bitSize :: Int -> Int Source # isSigned :: Int -> Bool Source # shiftL :: Int -> Int -> Int Source # unsafeShiftL :: Int -> Int -> Int Source # shiftR :: Int -> Int -> Int Source # unsafeShiftR :: Int -> Int -> Int Source # rotateL :: Int -> Int -> Int Source # | |
| FiniteBits Int | Since: base-4.6.0.0 |
| Bounded Int | Since: base-2.1 |
| Enum Int | Since: base-2.1 |
Defined in GHC.Enum | |
| Num Int | Since: base-2.1 |
| Read Int | Since: base-2.1 |
| Integral Int | Since: base-2.0.1 |
| Real Int | Since: base-2.0.1 |
| Show Int | Since: base-2.1 |
| FromCBOR Int | |
| ToCBOR Int | |
| NFData Int | |
Defined in Control.DeepSeq | |
| Eq Int | |
| Ord Int | |
| Hashable Int | |
Defined in Data.Hashable.Class | |
| Pretty Int | |
Defined in Prettyprinter.Internal | |
| Uniform Int | |
Defined in System.Random.Internal | |
| UniformRange Int | |
Defined in System.Random.Internal | |
| ByteSource Int | |
Defined in Data.UUID.Types.Internal.Builder | |
| Unbox Int | |
Defined in Data.Vector.Unboxed.Base | |
| Lift Int | |
| Vector Vector Int | |
Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: Mutable Vector s Int -> ST s (Vector Int) basicUnsafeThaw :: Vector Int -> ST s (Mutable Vector s Int) basicLength :: Vector Int -> Int basicUnsafeSlice :: Int -> Int -> Vector Int -> Vector Int basicUnsafeIndexM :: Vector Int -> Int -> Box Int basicUnsafeCopy :: Mutable Vector s Int -> Vector Int -> ST s () | |
| MVector MVector Int | |
Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Int -> Int basicUnsafeSlice :: Int -> Int -> MVector s Int -> MVector s Int basicOverlaps :: MVector s Int -> MVector s Int -> Bool basicUnsafeNew :: Int -> ST s (MVector s Int) basicInitialize :: MVector s Int -> ST s () basicUnsafeReplicate :: Int -> Int -> ST s (MVector s Int) basicUnsafeRead :: MVector s Int -> Int -> ST s Int basicUnsafeWrite :: MVector s Int -> Int -> Int -> ST s () basicClear :: MVector s Int -> ST s () basicSet :: MVector s Int -> Int -> ST s () basicUnsafeCopy :: MVector s Int -> MVector s Int -> ST s () basicUnsafeMove :: MVector s Int -> MVector s Int -> ST s () basicUnsafeGrow :: MVector s Int -> Int -> ST s (MVector s Int) | |
| y ~ 'Just 0 => BaseCaseSearch Int z y e | |
Defined in Generic.Random.Internal.BaseCase Methods baseCaseSearch :: prox y -> proxy '(z, e) -> IfM y Gen Proxy Int | |
| Generic1 (URec Int :: k -> Type) | |
| Foldable (UInt :: Type -> Type) | Since: base-4.9.0.0 |
Defined in Data.Foldable Methods fold :: Monoid m => UInt m -> m Source # foldMap :: Monoid m => (a -> m) -> UInt a -> m Source # foldMap' :: Monoid m => (a -> m) -> UInt a -> m Source # foldr :: (a -> b -> b) -> b -> UInt a -> b Source # foldr' :: (a -> b -> b) -> b -> UInt a -> b Source # foldl :: (b -> a -> b) -> b -> UInt a -> b Source # foldl' :: (b -> a -> b) -> b -> UInt a -> b Source # foldr1 :: (a -> a -> a) -> UInt a -> a Source # foldl1 :: (a -> a -> a) -> UInt a -> a Source # toList :: UInt a -> [a] Source # null :: UInt a -> Bool Source # length :: UInt a -> Int Source # elem :: Eq a => a -> UInt a -> Bool Source # maximum :: Ord a => UInt a -> a Source # minimum :: Ord a => UInt a -> a Source # | |
| Traversable (UInt :: Type -> Type) | Since: base-4.9.0.0 |
| Functor (URec Int :: Type -> Type) | Since: base-4.9.0.0 |
| Generic (URec Int p) | |
| Show (URec Int p) | Since: base-4.9.0.0 |
| WeightBuilder a => WeightBuilder' (a, Int, r) | |
| Eq (URec Int p) | Since: base-4.9.0.0 |
| Ord (URec Int p) | Since: base-4.9.0.0 |
Defined in GHC.Generics Methods compare :: URec Int p -> URec Int p -> Ordering Source # (<) :: URec Int p -> URec Int p -> Bool Source # (<=) :: URec Int p -> URec Int p -> Bool Source # (>) :: URec Int p -> URec Int p -> Bool Source # (>=) :: URec Int p -> URec Int p -> Bool Source # | |
| newtype Vector Int | |
Defined in Data.Vector.Unboxed.Base | |
| data URec Int (p :: k) | Used for marking occurrences of Since: base-4.9.0.0 |
| type ByteSink Int g | |
Defined in Data.UUID.Types.Internal.Builder type ByteSink Int g = Takes4Bytes g | |
| newtype MVector s Int | |
Defined in Data.Vector.Unboxed.Base | |
| type Rep1 (URec Int :: k -> Type) | Since: base-4.9.0.0 |
Defined in GHC.Generics | |
| type Rep (URec Int p) | Since: base-4.9.0.0 |
Defined in GHC.Generics | |
Single-precision floating point numbers. It is desirable that this type be at least equal in range and precision to the IEEE single-precision type.
Instances
| Arbitrary Float | |
| CoArbitrary Float | |
Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Float -> Gen b -> Gen b | |
| FromJSON Float | |
Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Float # parseJSONList :: Value -> Parser [Float] # omittedField :: Maybe Float # | |
| FromJSONKey Float | |
Defined in Data.Aeson.Types.FromJSON | |
| ToJSON Float | |
Defined in Data.Aeson.Types.ToJSON | |
| ToJSONKey Float | |
Defined in Data.Aeson.Types.ToJSON | |
| Floating Float | Since: base-2.1 |
Defined in GHC.Float Methods exp :: Float -> Float Source # log :: Float -> Float Source # sqrt :: Float -> Float Source # (**) :: Float -> Float -> Float Source # logBase :: Float -> Float -> Float Source # sin :: Float -> Float Source # cos :: Float -> Float Source # tan :: Float -> Float Source # asin :: Float -> Float Source # acos :: Float -> Float Source # atan :: Float -> Float Source # sinh :: Float -> Float Source # cosh :: Float -> Float Source # tanh :: Float -> Float Source # asinh :: Float -> Float Source # acosh :: Float -> Float Source # atanh :: Float -> Float Source # log1p :: Float -> Float Source # expm1 :: Float -> Float Source # | |
| RealFloat Float | Since: base-2.1 |
Defined in GHC.Float Methods floatRadix :: Float -> Integer Source # floatDigits :: Float -> Int Source # floatRange :: Float -> (Int, Int) Source # decodeFloat :: Float -> (Integer, Int) Source # encodeFloat :: Integer -> Int -> Float Source # exponent :: Float -> Int Source # significand :: Float -> Float Source # scaleFloat :: Int -> Float -> Float Source # isNaN :: Float -> Bool Source # isInfinite :: Float -> Bool Source # isDenormalized :: Float -> Bool Source # isNegativeZero :: Float -> Bool Source # | |
| Read Float | Since: base-2.1 |
| FromCBOR Float | |
| ToCBOR Float | |
| NFData Float | |
Defined in Control.DeepSeq | |
| Eq Float | Note that due to the presence of
Also note that
|
| Ord Float | Note that due to the presence of
Also note that, due to the same,
|
Defined in GHC.Classes | |
| Hashable Float | |
Defined in Data.Hashable.Class | |
| Pretty Float | |
Defined in Prettyprinter.Internal | |
| UniformRange Float | |
Defined in System.Random.Internal | |
| Unbox Float | |
Defined in Data.Vector.Unboxed.Base | |
| Lift Float | |
| Vector Vector Float | |
Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: Mutable Vector s Float -> ST s (Vector Float) basicUnsafeThaw :: Vector Float -> ST s (Mutable Vector s Float) basicLength :: Vector Float -> Int basicUnsafeSlice :: Int -> Int -> Vector Float -> Vector Float basicUnsafeIndexM :: Vector Float -> Int -> Box Float basicUnsafeCopy :: Mutable Vector s Float -> Vector Float -> ST s () | |
| MVector MVector Float | |
Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Float -> Int basicUnsafeSlice :: Int -> Int -> MVector s Float -> MVector s Float basicOverlaps :: MVector s Float -> MVector s Float -> Bool basicUnsafeNew :: Int -> ST s (MVector s Float) basicInitialize :: MVector s Float -> ST s () basicUnsafeReplicate :: Int -> Float -> ST s (MVector s Float) basicUnsafeRead :: MVector s Float -> Int -> ST s Float basicUnsafeWrite :: MVector s Float -> Int -> Float -> ST s () basicClear :: MVector s Float -> ST s () basicSet :: MVector s Float -> Float -> ST s () basicUnsafeCopy :: MVector s Float -> MVector s Float -> ST s () basicUnsafeMove :: MVector s Float -> MVector s Float -> ST s () basicUnsafeGrow :: MVector s Float -> Int -> ST s (MVector s Float) | |
| y ~ 'Just 0 => BaseCaseSearch Float z y e | |
Defined in Generic.Random.Internal.BaseCase Methods baseCaseSearch :: prox y -> proxy '(z, e) -> IfM y Gen Proxy Float | |
| Generic1 (URec Float :: k -> Type) | |
| Foldable (UFloat :: Type -> Type) | Since: base-4.9.0.0 |
Defined in Data.Foldable Methods fold :: Monoid m => UFloat m -> m Source # foldMap :: Monoid m => (a -> m) -> UFloat a -> m Source # foldMap' :: Monoid m => (a -> m) -> UFloat a -> m Source # foldr :: (a -> b -> b) -> b -> UFloat a -> b Source # foldr' :: (a -> b -> b) -> b -> UFloat a -> b Source # foldl :: (b -> a -> b) -> b -> UFloat a -> b Source # foldl' :: (b -> a -> b) -> b -> UFloat a -> b Source # foldr1 :: (a -> a -> a) -> UFloat a -> a Source # foldl1 :: (a -> a -> a) -> UFloat a -> a Source # toList :: UFloat a -> [a] Source # null :: UFloat a -> Bool Source # length :: UFloat a -> Int Source # elem :: Eq a => a -> UFloat a -> Bool Source # maximum :: Ord a => UFloat a -> a Source # minimum :: Ord a => UFloat a -> a Source # | |
| Traversable (UFloat :: Type -> Type) | Since: base-4.9.0.0 |
Defined in Data.Traversable | |
| Functor (URec Float :: Type -> Type) | Since: base-4.9.0.0 |
| Generic (URec Float p) | |
| Show (URec Float p) | |
| Eq (URec Float p) | |
| Ord (URec Float p) | |
Defined in GHC.Generics Methods compare :: URec Float p -> URec Float p -> Ordering Source # (<) :: URec Float p -> URec Float p -> Bool Source # (<=) :: URec Float p -> URec Float p -> Bool Source # (>) :: URec Float p -> URec Float p -> Bool Source # (>=) :: URec Float p -> URec Float p -> Bool Source # max :: URec Float p -> URec Float p -> URec Float p Source # min :: URec Float p -> URec Float p -> URec Float p Source # | |
| type ForeignFloating Float | |
Defined in Data.Double.Conversion.Internal.FFI | |
| newtype Vector Float | |
Defined in Data.Vector.Unboxed.Base | |
| data URec Float (p :: k) | Used for marking occurrences of Since: base-4.9.0.0 |
| newtype MVector s Float | |
Defined in Data.Vector.Unboxed.Base | |
| type Rep1 (URec Float :: k -> Type) | Since: base-4.9.0.0 |
Defined in GHC.Generics | |
| type Rep (URec Float p) | |
Defined in GHC.Generics | |
The character type Char is an enumeration whose values represent
Unicode (or equivalently ISO/IEC 10646) code points (i.e. characters, see
http://www.unicode.org/ for details). This set extends the ISO 8859-1
(Latin-1) character set (the first 256 characters), which is itself an extension
of the ASCII character set (the first 128 characters). A character literal in
Haskell has type Char.
To convert a Char to or from the corresponding Int value defined
by Unicode, use toEnum and fromEnum from the
Enum class respectively (or equivalently ord and
chr).
Instances
A value of type IO aa.
There is really only one way to "perform" an I/O action: bind it to
Main.main in your program. When your program is run, the I/O will
be performed. It isn't possible to perform I/O from an arbitrary
function, unless that function is itself in the IO monad and called
at some point, directly or indirectly, from Main.main.
IO is a monad, so IO actions can be combined using either the do-notation
or the >> and >>= operations from the Monad
class.
Instances
8-bit unsigned integer type
Instances
Haskell defines operations to read and write characters from and to files,
represented by values of type Handle. Each value of this type is a
handle: a record used by the Haskell run-time system to manage I/O
with file system objects. A handle has at least the following properties:
- whether it manages input or output or both;
- whether it is open, closed or semi-closed;
- whether the object is seekable;
- whether buffering is disabled, or enabled on a line or block basis;
- a buffer (whose length may be zero).
Most handles will also have a current I/O position indicating where the next
input or output operation will occur. A handle is readable if it
manages only input or both input and output; likewise, it is writable if
it manages only output or both input and output. A handle is open when
first allocated.
Once it is closed it can no longer be used for either input or output,
though an implementation cannot re-use its storage while references
remain to it. Handles are in the Show and Eq classes. The string
produced by showing a handle is system dependent; it should include
enough information to identify the handle for debugging. A handle is
equal according to == only to itself; no attempt
is made to compare the internal state of different handles for equality.
Instances
Double-precision floating point numbers. It is desirable that this type be at least equal in range and precision to the IEEE double-precision type.
Instances
Instances
| Arbitrary Word | |
| CoArbitrary Word | |
Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Word -> Gen b -> Gen b | |
| FromJSON Word | |
Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Word # parseJSONList :: Value -> Parser [Word] # omittedField :: Maybe Word # | |
| FromJSONKey Word | |
Defined in Data.Aeson.Types.FromJSON | |
| ToJSON Word | |
Defined in Data.Aeson.Types.ToJSON | |
| ToJSONKey Word | |
Defined in Data.Aeson.Types.ToJSON | |
| Bits Word | Since: base-2.1 |
Defined in GHC.Bits Methods (.&.) :: Word -> Word -> Word Source # (.|.) :: Word -> Word -> Word Source # xor :: Word -> Word -> Word Source # complement :: Word -> Word Source # shift :: Word -> Int -> Word Source # rotate :: Word -> Int -> Word Source # setBit :: Word -> Int -> Word Source # clearBit :: Word -> Int -> Word Source # complementBit :: Word -> Int -> Word Source # testBit :: Word -> Int -> Bool Source # bitSizeMaybe :: Word -> Maybe Int Source # bitSize :: Word -> Int Source # isSigned :: Word -> Bool Source # shiftL :: Word -> Int -> Word Source # unsafeShiftL :: Word -> Int -> Word Source # shiftR :: Word -> Int -> Word Source # unsafeShiftR :: Word -> Int -> Word Source # rotateL :: Word -> Int -> Word Source # | |
| FiniteBits Word | Since: base-4.6.0.0 |
| Bounded Word | Since: base-2.1 |
| Enum Word | Since: base-2.1 |
| Num Word | Since: base-2.1 |
| Read Word | Since: base-4.5.0.0 |
| Integral Word | Since: base-2.1 |
Defined in GHC.Real | |
| Real Word | Since: base-2.1 |
| Show Word | Since: base-2.1 |
| FromCBOR Word | |
| ToCBOR Word | |
| NFData Word | |
Defined in Control.DeepSeq | |
| Eq Word | |
| Ord Word | |
| Hashable Word | |
Defined in Data.Hashable.Class | |
| Pretty Word | |
Defined in Prettyprinter.Internal | |
| Uniform Word | |
Defined in System.Random.Internal | |
| UniformRange Word | |
Defined in System.Random.Internal | |
| Unbox Word | |
Defined in Data.Vector.Unboxed.Base | |
| Lift Word | |
| Vector Vector Word | |
Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: Mutable Vector s Word -> ST s (Vector Word) basicUnsafeThaw :: Vector Word -> ST s (Mutable Vector s Word) basicLength :: Vector Word -> Int basicUnsafeSlice :: Int -> Int -> Vector Word -> Vector Word basicUnsafeIndexM :: Vector Word -> Int -> Box Word basicUnsafeCopy :: Mutable Vector s Word -> Vector Word -> ST s () | |
| MVector MVector Word | |
Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Word -> Int basicUnsafeSlice :: Int -> Int -> MVector s Word -> MVector s Word basicOverlaps :: MVector s Word -> MVector s Word -> Bool basicUnsafeNew :: Int -> ST s (MVector s Word) basicInitialize :: MVector s Word -> ST s () basicUnsafeReplicate :: Int -> Word -> ST s (MVector s Word) basicUnsafeRead :: MVector s Word -> Int -> ST s Word basicUnsafeWrite :: MVector s Word -> Int -> Word -> ST s () basicClear :: MVector s Word -> ST s () basicSet :: MVector s Word -> Word -> ST s () basicUnsafeCopy :: MVector s Word -> MVector s Word -> ST s () basicUnsafeMove :: MVector s Word -> MVector s Word -> ST s () basicUnsafeGrow :: MVector s Word -> Int -> ST s (MVector s Word) | |
| y ~ 'Just 0 => BaseCaseSearch Word z y e | |
Defined in Generic.Random.Internal.BaseCase Methods baseCaseSearch :: prox y -> proxy '(z, e) -> IfM y Gen Proxy Word | |
| Generic1 (URec Word :: k -> Type) | |
| Foldable (UWord :: Type -> Type) | Since: base-4.9.0.0 |
Defined in Data.Foldable Methods fold :: Monoid m => UWord m -> m Source # foldMap :: Monoid m => (a -> m) -> UWord a -> m Source # foldMap' :: Monoid m => (a -> m) -> UWord a -> m Source # foldr :: (a -> b -> b) -> b -> UWord a -> b Source # foldr' :: (a -> b -> b) -> b -> UWord a -> b Source # foldl :: (b -> a -> b) -> b -> UWord a -> b Source # foldl' :: (b -> a -> b) -> b -> UWord a -> b Source # foldr1 :: (a -> a -> a) -> UWord a -> a Source # foldl1 :: (a -> a -> a) -> UWord a -> a Source # toList :: UWord a -> [a] Source # null :: UWord a -> Bool Source # length :: UWord a -> Int Source # elem :: Eq a => a -> UWord a -> Bool Source # maximum :: Ord a => UWord a -> a Source # minimum :: Ord a => UWord a -> a Source # | |
| Traversable (UWord :: Type -> Type) | Since: base-4.9.0.0 |
| Functor (URec Word :: Type -> Type) | Since: base-4.9.0.0 |
| Generic (URec Word p) | |
| Show (URec Word p) | Since: base-4.9.0.0 |
| Eq (URec Word p) | Since: base-4.9.0.0 |
| Ord (URec Word p) | Since: base-4.9.0.0 |
Defined in GHC.Generics Methods compare :: URec Word p -> URec Word p -> Ordering Source # (<) :: URec Word p -> URec Word p -> Bool Source # (<=) :: URec Word p -> URec Word p -> Bool Source # (>) :: URec Word p -> URec Word p -> Bool Source # (>=) :: URec Word p -> URec Word p -> Bool Source # | |
| newtype Vector Word | |
Defined in Data.Vector.Unboxed.Base | |
| data URec Word (p :: k) | Used for marking occurrences of Since: base-4.9.0.0 |
| newtype MVector s Word | |
Defined in Data.Vector.Unboxed.Base | |
| type Rep1 (URec Word :: k -> Type) | Since: base-4.9.0.0 |
Defined in GHC.Generics | |
| type Rep (URec Word p) | Since: base-4.9.0.0 |
Defined in GHC.Generics | |
Instances
| Arbitrary Ordering | |
| CoArbitrary Ordering | |
Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Ordering -> Gen b -> Gen b | |
| FromJSON Ordering | |
Defined in Data.Aeson.Types.FromJSON | |
| ToJSON Ordering | |
Defined in Data.Aeson.Types.ToJSON | |
| Monoid Ordering | Since: base-2.1 |
| Semigroup Ordering | Since: base-4.9.0.0 |
| Bounded Ordering | Since: base-2.1 |
| Enum Ordering | Since: base-2.1 |
Defined in GHC.Enum Methods succ :: Ordering -> Ordering Source # pred :: Ordering -> Ordering Source # toEnum :: Int -> Ordering Source # fromEnum :: Ordering -> Int Source # enumFrom :: Ordering -> [Ordering] Source # enumFromThen :: Ordering -> Ordering -> [Ordering] Source # enumFromTo :: Ordering -> Ordering -> [Ordering] Source # enumFromThenTo :: Ordering -> Ordering -> Ordering -> [Ordering] Source # | |
| Generic Ordering | |
| Read Ordering | Since: base-2.1 |
| Show Ordering | Since: base-2.1 |
| NFData Ordering | |
Defined in Control.DeepSeq | |
| Eq Ordering | |
| Ord Ordering | |
Defined in GHC.Classes | |
| Hashable Ordering | |
Defined in Data.Hashable.Class | |
| y ~ 'Just 0 => BaseCaseSearch Ordering z y e | |
Defined in Generic.Random.Internal.BaseCase Methods baseCaseSearch :: prox y -> proxy '(z, e) -> IfM y Gen Proxy Ordering | |
| GBCSSumCompare (f :: k1 -> Type) (g :: k1 -> Type) (z :: k2) (e :: k3) 'EQ | |
Defined in Generic.Random.Internal.BaseCase Methods gbcsSumCompare :: forall proxy0 proxy (p :: k). proxy0 'EQ -> proxy '(z, e) -> Weighted (f p) -> Weighted (g p) -> Weighted ((f :+: g) p) | |
| GBCSSumCompare (f :: k1 -> Type) (g :: k1 -> Type) (z :: k2) (e :: k3) 'GT | |
Defined in Generic.Random.Internal.BaseCase Methods gbcsSumCompare :: forall proxy0 proxy (p :: k). proxy0 'GT -> proxy '(z, e) -> Weighted (f p) -> Weighted (g p) -> Weighted ((f :+: g) p) | |
| GBCSSumCompare (f :: k1 -> Type) (g :: k1 -> Type) (z :: k2) (e :: k3) 'LT | |
Defined in Generic.Random.Internal.BaseCase Methods gbcsSumCompare :: forall proxy0 proxy (p :: k). proxy0 'LT -> proxy '(z, e) -> Weighted (f p) -> Weighted (g p) -> Weighted ((f :+: g) p) | |
| type Rep Ordering | Since: base-4.6.0.0 |
The Maybe type encapsulates an optional value. A value of type
Maybe aa (represented as Just aNothing). Using Maybe is a good way to
deal with errors or exceptional cases without resorting to drastic
measures such as error.
The Maybe type is also a monad. It is a simple kind of error
monad, where all errors are represented by Nothing. A richer
error monad can be built using the Either type.
Instances
| Arbitrary1 Maybe | |
Defined in Test.QuickCheck.Arbitrary | |
| FromJSON1 Maybe | |
Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON :: Maybe a -> (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (Maybe a) liftParseJSONList :: Maybe a -> (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [Maybe a] liftOmittedField :: Maybe a -> Maybe (Maybe a) | |
| ToJSON1 Maybe | |
Defined in Data.Aeson.Types.ToJSON Methods liftToJSON :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> Maybe a -> Value liftToJSONList :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> [Maybe a] -> Value liftToEncoding :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> Maybe a -> Encoding liftToEncodingList :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> [Maybe a] -> Encoding liftOmitField :: (a -> Bool) -> Maybe a -> Bool | |
| MonadFail Maybe | Since: base-4.9.0.0 |
| Foldable Maybe | Since: base-2.1 |
Defined in Data.Foldable Methods fold :: Monoid m => Maybe m -> m Source # foldMap :: Monoid m => (a -> m) -> Maybe a -> m Source # foldMap' :: Monoid m => (a -> m) -> Maybe a -> m Source # foldr :: (a -> b -> b) -> b -> Maybe a -> b Source # foldr' :: (a -> b -> b) -> b -> Maybe a -> b Source # foldl :: (b -> a -> b) -> b -> Maybe a -> b Source # foldl' :: (b -> a -> b) -> b -> Maybe a -> b Source # foldr1 :: (a -> a -> a) -> Maybe a -> a Source # foldl1 :: (a -> a -> a) -> Maybe a -> a Source # toList :: Maybe a -> [a] Source # null :: Maybe a -> Bool Source # length :: Maybe a -> Int Source # elem :: Eq a => a -> Maybe a -> Bool Source # maximum :: Ord a => Maybe a -> a Source # minimum :: Ord a => Maybe a -> a Source # | |
| Traversable Maybe | Since: base-2.1 |
| Alternative Maybe | Picks the leftmost Since: base-2.1 |
| Applicative Maybe | Since: base-2.1 |
| Functor Maybe | Since: base-2.1 |
| Monad Maybe | Since: base-2.1 |
| MonadPlus Maybe | Picks the leftmost Since: base-2.1 |
| NFData1 Maybe | Since: deepseq-1.4.3.0 |
Defined in Control.DeepSeq | |
| Hashable1 Maybe | |
Defined in Data.Hashable.Class | |
| Generic1 Maybe | |
| Lift a => Lift (Maybe a :: Type) | |
| Arbitrary a => Arbitrary (Maybe a) | |