Safe Haskell | None |
---|---|
Language | Haskell98 |
- undefined :: a
- (++) :: Monoid m => m -> m -> m
- class Semigroup a where
- data WrappedMonoid m :: * -> *
- module Data.Functor
- module Control.Applicative
- module Control.Monad
- whenM :: Monad m => m Bool -> m () -> m ()
- unlessM :: Monad m => m Bool -> m () -> m ()
- atomically :: MonadIO m => STM a -> m a
- alwaysSTM :: STM Bool -> STM ()
- alwaysSucceedsSTM :: STM a -> STM ()
- retrySTM :: STM a
- orElseSTM :: STM a -> STM a -> STM a
- checkSTM :: Bool -> STM ()
- class Monad m => PrimMonad m where
- type PrimState m :: *
- type family PrimState m :: *
- primToPrim :: (PrimMonad m1, PrimMonad m2, (~) * (PrimState m1) (PrimState m2)) => m1 a -> m2 a
- primToIO :: (PrimMonad m, (~) * (PrimState m) RealWorld) => m a -> IO a
- primToST :: PrimMonad m => m a -> ST (PrimState m) a
- class Prim a
- trace :: String -> a -> a
- traceShow :: Show a => a -> b -> b
- traceId :: String -> String
- traceM :: Monad m => String -> m ()
- traceShowId :: Show a => a -> a
- traceShowM :: (Show a, Monad m) => a -> m ()
- assert :: Bool -> a -> a
- module Data.Time
- defaultTimeLocale :: TimeLocale
- class Generic a
- newtype Identity a :: * -> * = Identity {
- runIdentity :: a
- class Monad m => MonadReader r m | m -> r where
- ask :: m r
- ask :: MonadReader r m => m r
- newtype ReaderT r m a :: * -> (* -> *) -> * -> * = ReaderT {
- runReaderT :: r -> m a
- type Reader r = ReaderT r Identity
- module Data.Foldable
- module Data.Traversable
- data Handle :: *
- stdin :: Handle
- stdout :: Handle
- stderr :: Handle
- map :: Functor f => (a -> b) -> f a -> f b
- concat :: (MonoFoldable c, Monoid (Element c)) => c -> Element c
- concatMap :: (Monoid m, MonoFoldable c) => (Element c -> m) -> c -> m
- foldMap :: (Monoid m, MonoFoldable c) => (Element c -> m) -> c -> m
- fold :: (Monoid (Element c), MonoFoldable c) => c -> Element c
- length :: MonoFoldable c => c -> Int
- null :: MonoFoldable c => c -> Bool
- pack :: IsSequence c => [Element c] -> c
- unpack :: MonoFoldable c => c -> [Element c]
- repack :: (MonoFoldable a, IsSequence b, Element a ~ Element b) => a -> b
- toList :: MonoFoldable c => c -> [Element c]
- mapM_ :: (Monad m, MonoFoldable c) => (Element c -> m ()) -> c -> m ()
- sequence_ :: (Monad m, MonoFoldable mono, Element mono ~ m a) => mono -> m ()
- forM_ :: (Monad m, MonoFoldable c) => c -> (Element c -> m ()) -> m ()
- any :: MonoFoldable c => (Element c -> Bool) -> c -> Bool
- all :: MonoFoldable c => (Element c -> Bool) -> c -> Bool
- and :: (MonoFoldable mono, Element mono ~ Bool) => mono -> Bool
- or :: (MonoFoldable mono, Element mono ~ Bool) => mono -> Bool
- foldl' :: MonoFoldable c => (a -> Element c -> a) -> a -> c -> a
- foldr :: MonoFoldable c => (Element c -> b -> b) -> b -> c -> b
- foldM :: (Monad m, MonoFoldable c) => (a -> Element c -> m a) -> a -> c -> m a
- elem :: MonoFoldableEq c => Element c -> c -> Bool
- readMay :: (Element c ~ Char, MonoFoldable c, Read a) => c -> Maybe a
- intercalate :: (Monoid (Element c), IsSequence c) => Element c -> c -> Element c
- zip :: Zip f => forall a b. f a -> f b -> f (a, b)
- zip3 :: Zip3 f => forall a b c. f a -> f b -> f c -> f (a, b, c)
- zip4 :: Zip4 f => forall a b c d. f a -> f b -> f c -> f d -> f (a, b, c, d)
- zip5 :: Zip5 f => forall a b c d e. f a -> f b -> f c -> f d -> f e -> f (a, b, c, d, e)
- zip6 :: Zip6 f => forall a b c d e g. f a -> f b -> f c -> f d -> f e -> f g -> f (a, b, c, d, e, g)
- zip7 :: Zip7 f => forall a b c d e g h. f a -> f b -> f c -> f d -> f e -> f g -> f h -> f (a, b, c, d, e, g, h)
- unzip :: Zip f => forall a b. f (a, b) -> (f a, f b)
- unzip3 :: Zip3 f => forall a b c. f (a, b, c) -> (f a, f b, f c)
- unzip4 :: Zip4 f => forall a b c d. f (a, b, c, d) -> (f a, f b, f c, f d)
- unzip5 :: Zip5 f => forall a b c d e. f (a, b, c, d, e) -> (f a, f b, f c, f d, f e)
- unzip6 :: Zip6 f => forall a b c d e g. f (a, b, c, d, e, g) -> (f a, f b, f c, f d, f e, f g)
- unzip7 :: Zip7 f => forall a b c d e g h. f (a, b, c, d, e, g, h) -> (f a, f b, f c, f d, f e, f g, f h)
- zipWith :: Zip f => forall a b c. (a -> b -> c) -> f a -> f b -> f c
- zipWith3 :: Zip3 f => forall a b c d. (a -> b -> c -> d) -> f a -> f b -> f c -> f d
- zipWith4 :: Zip4 f => forall a b c d e. (a -> b -> c -> d -> e) -> f a -> f b -> f c -> f d -> f e
- zipWith5 :: Zip5 f => forall a b c d e g. (a -> b -> c -> d -> e -> g) -> f a -> f b -> f c -> f d -> f e -> f g
- zipWith6 :: Zip6 f => forall a b c d e g h. (a -> b -> c -> d -> e -> g -> h) -> f a -> f b -> f c -> f d -> f e -> f g -> f h
- zipWith7 :: Zip7 f => forall a b c d e g h i. (a -> b -> c -> d -> e -> g -> h -> i) -> f a -> f b -> f c -> f d -> f e -> f g -> f h -> f i
- hashNub :: (Hashable a, Eq a) => [a] -> [a]
- ordNub :: Ord a => [a] -> [a]
- ordNubBy :: Ord b => (a -> b) -> (a -> a -> Bool) -> [a] -> [a]
- sortWith :: (Ord a, IsSequence c) => (Element c -> a) -> c -> c
- compareLength :: (Integral i, MonoFoldable c) => c -> i -> Ordering
- sum :: (MonoFoldable c, Num (Element c)) => c -> Element c
- product :: (MonoFoldable c, Num (Element c)) => c -> Element c
- repeat :: a -> [a]
- (\\) :: SetContainer a => a -> a -> a
- intersect :: SetContainer a => a -> a -> a
- unions :: (MonoFoldable c, SetContainer (Element c)) => c -> Element c
- class Show a where
- tshow :: Show a => a -> Text
- tlshow :: Show a => a -> LText
- charToLower :: Char -> Char
- charToUpper :: Char -> Char
- class IsSequence a => IOData a where
- readFile :: MonadIO m => FilePath -> m a
- writeFile :: MonadIO m => FilePath -> a -> m ()
- getLine :: MonadIO m => m a
- hGetContents :: MonadIO m => Handle -> m a
- hGetLine :: MonadIO m => Handle -> m a
- hPut :: MonadIO m => Handle -> a -> m ()
- hPutStrLn :: MonadIO m => Handle -> a -> m ()
- hGetChunk :: MonadIO m => Handle -> m a
- print :: (Show a, MonadIO m) => a -> m ()
- hClose :: Handle -> IO ()
- fpToString :: FilePath -> String
- fpFromString :: String -> FilePath
- fpToText :: FilePath -> Text
- fpFromText :: Text -> FilePath
- fpToTextWarn :: MonadIO m => FilePath -> m Text
- fpToTextEx :: FilePath -> Text
- data DList a :: * -> *
- asDList :: DList a -> DList a
- applyDList :: DList a -> [a] -> [a]
- class Monad m => MonadThrow m where
- class MonadThrow m => MonadCatch m
- class MonadCatch m => MonadMask m
- asByteString :: ByteString -> ByteString
- asLByteString :: LByteString -> LByteString
- asHashMap :: HashMap k v -> HashMap k v
- asHashSet :: HashSet a -> HashSet a
- asText :: Text -> Text
- asLText :: LText -> LText
- asList :: [a] -> [a]
- asMap :: Map k v -> Map k v
- asIntMap :: IntMap v -> IntMap v
- asMaybe :: Maybe a -> Maybe a
- asSet :: Set a -> Set a
- asIntSet :: IntSet -> IntSet
- asVector :: Vector a -> Vector a
- asUVector :: UVector a -> UVector a
- asSVector :: SVector a -> SVector a
- asString :: [Char] -> [Char]
CorePrelude
Deprecated: It is highly recommended that you either avoid partial functions or provide meaningful error messages
We define our own undefined
which is marked as deprecated. This makes it
useful to use during development, but let's you more easily getting
notification if you accidentally ship partial code in production.
The classy prelude recommendation for when you need to really have a partial
function in production is to use error
with a very descriptive message so
that, in case an exception is thrown, you get more information than
Prelude.
.undefined
Since 0.5.5
Standard
Monoid
Semigroup
class Semigroup a where
Nothing
data WrappedMonoid m :: * -> *
Generic1 WrappedMonoid | |
Bounded a => Bounded (WrappedMonoid a) | |
Enum a => Enum (WrappedMonoid a) | |
Eq m => Eq (WrappedMonoid m) | |
Data m => Data (WrappedMonoid m) | |
Ord m => Ord (WrappedMonoid m) | |
Read m => Read (WrappedMonoid m) | |
Show m => Show (WrappedMonoid m) | |
Generic (WrappedMonoid m) | |
Monoid m => Monoid (WrappedMonoid m) | |
NFData m => NFData (WrappedMonoid m) | |
Monoid m => Semigroup (WrappedMonoid m) | |
Hashable a => Hashable (WrappedMonoid a) | |
Typeable (* -> *) WrappedMonoid | |
type Rep1 WrappedMonoid = D1 D1WrappedMonoid (C1 C1_0WrappedMonoid (S1 S1_0_0WrappedMonoid Par1)) | |
type Rep (WrappedMonoid m) = D1 D1WrappedMonoid (C1 C1_0WrappedMonoid (S1 S1_0_0WrappedMonoid (Rec0 m))) |
Functor
module Data.Functor
Applicative
module Control.Applicative
Monad
module Control.Monad
whenM :: Monad m => m Bool -> m () -> m () Source
Only perform the action if the predicate returns True
.
Since 0.9.2
unlessM :: Monad m => m Bool -> m () -> m () Source
Only perform the action if the predicate returns False
.
Since 0.9.2
Mutable references
atomically :: MonadIO m => STM a -> m a Source
Generalized version of atomically
.
alwaysSucceedsSTM :: STM a -> STM () Source
Synonym for alwaysSucceeds
.
Primitive (exported since 0.9.4)
primToPrim :: (PrimMonad m1, PrimMonad m2, (~) * (PrimState m1) (PrimState m2)) => m1 a -> m2 a
class Prim a
sizeOf#, alignment#, indexByteArray#, readByteArray#, writeByteArray#, setByteArray#, indexOffAddr#, readOffAddr#, writeOffAddr#, setOffAddr#
Debugging
The trace
function outputs the trace message given as its first argument,
before returning the second argument as its result.
For example, this returns the value of f x
but first outputs the message.
trace ("calling f with x = " ++ show x) (f x)
The trace
function should only be used for debugging, or for monitoring
execution. The function is not referentially transparent: its type indicates
that it is a pure function but it has the side effect of outputting the
trace message.
traceShowId :: Show a => a -> a Source
Since 0.5.9
traceShowM :: (Show a, Monad m) => a -> m () Source
Since 0.5.9
If the first argument evaluates to True
, then the result is the
second argument. Otherwise an AssertionFailed
exception is raised,
containing a String
with the source file and line number of the
call to assert
.
Assertions can normally be turned on or off with a compiler flag
(for GHC, assertions are normally on unless optimisation is turned on
with -O
or the -fignore-asserts
option is given). When assertions are turned off, the first
argument to assert
is ignored, and the second argument is
returned as the result.
Time (since 0.6.1)
module Data.Time
Generics (since 0.8.1)
class Generic a
Representable types of kind *. This class is derivable in GHC with the DeriveGeneric flag on.
Generic Bool | |
Generic Char | |
Generic Double | |
Generic Float | |
Generic Int | |
Generic Ordering | |
Generic () | |
Generic All | |
Generic Any | |
Generic Arity | |
Generic Fixity | |
Generic Associativity | |
Generic Void | |
Generic [a] | |
Generic (U1 p) | |
Generic (Par1 p) | |
Generic (ZipList a) | |
Generic (Dual a) | |
Generic (Endo a) | |
Generic (Sum a) | |
Generic (Product a) | |
Generic (First a) | |
Generic (Last a) | |
Generic (Maybe a) | |
Generic (NonEmpty a) | |
Generic (Option a) | |
Generic (WrappedMonoid m) | |
Generic (Min a) | |
Generic (Max a) | |
Generic (Last a) | |
Generic (First a) | |
Generic (Either a b) | |
Generic (Rec1 f p) | |
Generic (a, b) | |
Generic (Const a b) | |
Generic (WrappedMonad m a) | |
Generic (Proxy * t) | |
Generic (Arg a b) | |
Generic (K1 i c p) | |
Generic ((:+:) f g p) | |
Generic ((:*:) f g p) | |
Generic ((:.:) f g p) | |
Generic (a, b, c) | |
Generic (WrappedArrow a b c) | |
Generic (M1 i c f p) | |
Generic (a, b, c, d) | |
Generic (a, b, c, d, e) | |
Generic (a, b, c, d, e, f) | |
Generic (a, b, c, d, e, f, g) |
Transformers (since 0.9.4)
newtype Identity a :: * -> *
Identity functor and monad.
Identity | |
|
Monad Identity | |
Functor Identity | |
MonadFix Identity | |
Applicative Identity | |
Foldable Identity | |
Traversable Identity | |
ZipWithKey Identity | |
Zip Identity | |
TraversableWithKey Identity | |
Lookup Identity | |
Keyed Identity | |
Indexable Identity | |
FoldableWithKey Identity | |
Bind Identity | |
Apply Identity | |
Adjustable Identity | |
Show1 Identity | |
Read1 Identity | |
Ord1 Identity | |
Eq1 Identity | |
Comonad Identity | |
Representable Identity | |
TraversableWithKey1 Identity | |
FoldableWithKey1 Identity | |
ComonadApply Identity | |
MonadBaseControl Identity Identity | |
Eq a => Eq (Identity a) | |
Ord a => Ord (Identity a) | |
Read a => Read (Identity a) | |
Show a => Show (Identity a) | |
Eq a => MonoFoldableEq (Identity a) | |
Ord a => MonoFoldableOrd (Identity a) | |
MonoPointed (Identity a) | |
MonoTraversable (Identity a) | |
MonoFoldable (Identity a) | |
MonoFunctor (Identity a) | |
type Key Identity = () | |
type Rep Identity = () | |
type StM Identity a = a | |
type Element (Identity a) = a |
class Monad m => MonadReader r m | m -> r where
ask, local
ask :: m r
MonadReader r m => MonadReader r (MaybeT m) | |
MonadReader r m => MonadReader r (ListT m) | |
MonadReader r m => MonadReader r (IdentityT m) | |
MonadReader r ((->) r) | |
(Representable f, (~) * (Rep f) a) => MonadReader a (Co f) | |
(Monoid w, MonadReader r m) => MonadReader r (WriterT w m) | |
(Monoid w, MonadReader r m) => MonadReader r (WriterT w m) | |
MonadReader r m => MonadReader r (StateT s m) | |
MonadReader r m => MonadReader r (StateT s m) | |
Monad m => MonadReader r (ReaderT r m) | |
(Error e, MonadReader r m) => MonadReader r (ErrorT e m) | |
MonadReader r' m => MonadReader r' (ContT r m) | |
MonadReader r m => MonadReader r (ExceptT e m) | |
(Monad m, Monoid w) => MonadReader r (RWST r w s m) | |
(Monad m, Monoid w) => MonadReader r (RWST r w s m) |
ask :: MonadReader r m => m r
newtype ReaderT r m a :: * -> (* -> *) -> * -> *
The reader monad transformer, which adds a read-only environment to the given monad.
The return
function ignores the environment, while >>=
passes
the inherited environment to both subcomputations.
ReaderT | |
|
MonadBaseControl b m => MonadBaseControl b (ReaderT r m) | |
Monad m => MonadReader r (ReaderT r m) | |
MonadTrans (ReaderT r) | |
MonadTransControl (ReaderT r) | |
Alternative m => Alternative (ReaderT r m) | |
Monad m => Monad (ReaderT r m) | |
Functor m => Functor (ReaderT r m) | |
MonadFix m => MonadFix (ReaderT r m) | |
MonadPlus m => MonadPlus (ReaderT r m) | |
Applicative m => Applicative (ReaderT r m) | |
MonadIO m => MonadIO (ReaderT r m) | |
MonadThrow m => MonadThrow (ReaderT r m) | |
MonadMask m => MonadMask (ReaderT r m) | |
MonadCatch m => MonadCatch (ReaderT r m) | |
ZipWithKey m => ZipWithKey (ReaderT e m) | |
Zip m => Zip (ReaderT e m) | |
Lookup m => Lookup (ReaderT e m) | |
Keyed m => Keyed (ReaderT e m) | |
Indexable m => Indexable (ReaderT e m) | |
Bind m => Bind (ReaderT e m) | |
Apply m => Apply (ReaderT e m) | |
Zip m => Zip (ReaderT e m) | |
Representable m => Representable (ReaderT e m) | |
Applicative m => MonoPointed (ReaderT r m a) | |
Functor m => MonoFunctor (ReaderT r m a) | |
type StT (ReaderT r) a = a | |
type Key (ReaderT e m) = (e, Key m) | |
type Rep (ReaderT e m) = (e, Rep m) | |
type StM (ReaderT r m) a = ComposeSt (ReaderT r) m a | |
type Element (ReaderT r m a) = a |
type Reader r = ReaderT r Identity
The parameterizable reader monad.
Computations are functions of a shared environment.
The return
function ignores the environment, while >>=
passes
the inherited environment to both subcomputations.
Poly hierarchy
module Data.Foldable
module Data.Traversable
Bifunctor (since 0.10.0)
Mono hierarchy
I/O
data Handle :: *
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.
Non-standard
List-like classes
repack :: (MonoFoldable a, IsSequence b, Element a ~ Element b) => a -> b Source
Repack from one type to another, dropping to a list in the middle.
repack = pack . unpack
.
intercalate :: (Monoid (Element c), IsSequence c) => Element c -> c -> Element c Source
zip :: Zip f => forall a b. f a -> f b -> f (a, b)
zip3 :: Zip3 f => forall a b c. f a -> f b -> f c -> f (a, b, c)
zip4 :: Zip4 f => forall a b c d. f a -> f b -> f c -> f d -> f (a, b, c, d)
zip5 :: Zip5 f => forall a b c d e. f a -> f b -> f c -> f d -> f e -> f (a, b, c, d, e)
zip6 :: Zip6 f => forall a b c d e g. f a -> f b -> f c -> f d -> f e -> f g -> f (a, b, c, d, e, g)
zip7 :: Zip7 f => forall a b c d e g h. f a -> f b -> f c -> f d -> f e -> f g -> f h -> f (a, b, c, d, e, g, h)
unzip :: Zip f => forall a b. f (a, b) -> (f a, f b)
unzip3 :: Zip3 f => forall a b c. f (a, b, c) -> (f a, f b, f c)
unzip4 :: Zip4 f => forall a b c d. f (a, b, c, d) -> (f a, f b, f c, f d)
unzip5 :: Zip5 f => forall a b c d e. f (a, b, c, d, e) -> (f a, f b, f c, f d, f e)
unzip6 :: Zip6 f => forall a b c d e g. f (a, b, c, d, e, g) -> (f a, f b, f c, f d, f e, f g)
unzip7 :: Zip7 f => forall a b c d e g h. f (a, b, c, d, e, g, h) -> (f a, f b, f c, f d, f e, f g, f h)
zipWith :: Zip f => forall a b c. (a -> b -> c) -> f a -> f b -> f c
zipWith3 :: Zip3 f => forall a b c d. (a -> b -> c -> d) -> f a -> f b -> f c -> f d
zipWith4 :: Zip4 f => forall a b c d e. (a -> b -> c -> d -> e) -> f a -> f b -> f c -> f d -> f e
zipWith5 :: Zip5 f => forall a b c d e g. (a -> b -> c -> d -> e -> g) -> f a -> f b -> f c -> f d -> f e -> f g
zipWith6 :: Zip6 f => forall a b c d e g h. (a -> b -> c -> d -> e -> g -> h) -> f a -> f b -> f c -> f d -> f e -> f g -> f h
zipWith7 :: Zip7 f => forall a b c d e g h i. (a -> b -> c -> d -> e -> g -> h -> i) -> f a -> f b -> f c -> f d -> f e -> f g -> f h -> f i
ordNubBy :: Ord b => (a -> b) -> (a -> a -> Bool) -> [a] -> [a] Source
sortWith :: (Ord a, IsSequence c) => (Element c -> a) -> c -> c Source
Sort elements using the user supplied function to project something out of each element. Inspired by http://hackage.haskell.org/packages/archive/base/latest/doc/html/GHC-Exts.html#v:sortWith.
compareLength :: (Integral i, MonoFoldable c) => c -> i -> Ordering Source
Set-like
Text-like
class Show a where
Conversion of values to readable String
s.
Minimal complete definition: showsPrec
or show
.
Derived instances of Show
have the following properties, which
are compatible with derived instances of Read
:
- The result of
show
is a syntactically correct Haskell expression containing only constants, given the fixity declarations in force at the point where the type is declared. It contains only the constructor names defined in the data type, parentheses, and spaces. When labelled constructor fields are used, braces, commas, field names, and equal signs are also used. - If the constructor is defined to be an infix operator, then
showsPrec
will produce infix applications of the constructor. - the representation will be enclosed in parentheses if the
precedence of the top-level constructor in
x
is less thand
(associativity is ignored). Thus, ifd
is0
then the result is never surrounded in parentheses; ifd
is11
it is always surrounded in parentheses, unless it is an atomic expression. - If the constructor is defined using record syntax, then
show
will produce the record-syntax form, with the fields given in the same order as the original declaration.
For example, given the declarations
infixr 5 :^: data Tree a = Leaf a | Tree a :^: Tree a
the derived instance of Show
is equivalent to
instance (Show a) => Show (Tree a) where showsPrec d (Leaf m) = showParen (d > app_prec) $ showString "Leaf " . showsPrec (app_prec+1) m where app_prec = 10 showsPrec d (u :^: v) = showParen (d > up_prec) $ showsPrec (up_prec+1) u . showString " :^: " . showsPrec (up_prec+1) v where up_prec = 5
Note that right-associativity of :^:
is ignored. For example,
produces the stringshow
(Leaf 1 :^: Leaf 2 :^: Leaf 3)"Leaf 1 :^: (Leaf 2 :^: Leaf 3)"
.
:: Int | the operator precedence of the enclosing
context (a number from |
-> a | the value to be converted to a |
-> ShowS |
Convert a value to a readable String
.
showsPrec
should satisfy the law
showsPrec d x r ++ s == showsPrec d x (r ++ s)
Derived instances of Read
and Show
satisfy the following:
That is, readsPrec
parses the string produced by
showsPrec
, and delivers the value that showsPrec
started with.
Show Bool | |
Show Char | |
Show Double | |
Show Float | |
Show Int | |
Show Int8 | |
Show Int16 | |
Show Int32 | |
Show Int64 | |
Show Integer | |
Show Ordering | |
Show Word | |
Show Word8 | |
Show Word16 | |
Show Word32 | |
Show Word64 | |
Show () | |
Show Handle | |
Show HandleType | |
Show HandlePosn | |
Show ThreadId | |
Show BlockReason | |
Show ThreadStatus | |
Show BufferMode | |
Show Newline | |
Show NewlineMode | |
Show GeneralCategory | |
Show All | |
Show Any | |
Show Arity | |
Show Fixity | |
Show Associativity | |
Show TypeRep | |
Show TyCon | |
Show ByteString | |
Show ShortByteString | |
Show ByteString | |
Show IntSet | |
Show TimeLocale | |
Show Padding | |
Show DateFormatSpec | |
Show LocalTime | |
Show ZonedTime | |
Show UTCTime | |
Show Day | |
Show Text | |
Show Text | |
Show FilePath | |
Show Root | |
Show Void | |
Show a => Show [a] | |
(Integral a, Show a) => Show (Ratio a) | |
Show (U1 p) | |
Show p => Show (Par1 p) | |
Show a => Show (ZipList a) | |
Show a => Show (Dual a) | |
Show a => Show (Sum a) | |
Show a => Show (Product a) | |
Show a => Show (First a) | |
Show a => Show (Last a) | |
Show a => Show (Down a) | |
Show a => Show (Maybe a) | |
Show a => Show (IntMap a) | |
Show a => Show (Set a) | |
Show a => Show (Tree a) | |
Show a => Show (Seq a) | |
Show a => Show (ViewL a) | |
Show a => Show (ViewR a) | |
Show a => Show (Identity a) | |
(Show a, Unbox a) => Show (Vector a) | |
Show a => Show (NonEmpty a) | |
(Show a, Storable a) => Show (Vector a) | |
(Show a, Prim a) => Show (Vector a) | |
Show a => Show (Vector a) | |
Show a => Show (HashSet a) | |
Show a => Show (DList a) | |
Show a => Show (Option a) | |
Show (Rules a) | |
Show m => Show (WrappedMonoid m) | |
Show a => Show (Min a) | |
Show a => Show (Max a) | |
Show a => Show (Last a) | |
Show a => Show (First a) | |
(Show a, Show b) => Show (Either a b) | |
Show (f p) => Show (Rec1 f p) | |
(Show a, Show b) => Show (a, b) | |
Show (ST s a) | |
(Show k, Show a) => Show (Map k a) | |
(Show1 f, Show a) => Show (Reverse f a) | |
(Show1 f, Show a) => Show (Backwards f a) | |
(Show1 f, Show a) => Show (Lift f a) | |
Show a => Show (Constant a b) | |
(Show1 m, Show a) => Show (MaybeT m a) | |
(Show1 m, Show a) => Show (ListT m a) | |
(Show1 f, Show a) => Show (IdentityT f a) | |
(Show k, Show v) => Show (HashMap k v) | |
Show mono => Show (MinLen nat mono) | |
(Show a, Show b) => Show (Arg a b) | |
(Show1 g, Show a) => Show (Apply g a) | |
Show c => Show (K1 i c p) | |
(Show (f p), Show (g p)) => Show ((:+:) f g p) | |
(Show (f p), Show (g p)) => Show ((:*:) f g p) | |
Show (f (g p)) => Show ((:.:) f g p) | |
(Show a, Show b, Show c) => Show (a, b, c) | |
Show (Coercion k a b) | |
Show ((:~:) k a b) | |
(Show w, Show1 m, Show a) => Show (WriterT w m a) | |
(Show w, Show1 m, Show a) => Show (WriterT w m a) | |
(Show e, Show1 m, Show a) => Show (ErrorT e m a) | |
(Functor f, Show1 f, Show1 g, Show a) => Show (Compose f g a) | |
(Show1 f, Show1 g, Show a) => Show (Product f g a) | |
(Show e, Show1 m, Show a) => Show (ExceptT e m a) | |
Show (f p) => Show (M1 i c f p) | |
(Show a, Show b, Show c, Show d) => Show (a, b, c, d) | |
(Show a, Show b, Show c, Show d, Show e) => Show (a, b, c, d, e) | |
(Show a, Show b, Show c, Show d, Show e, Show f) => Show (a, b, c, d, e, f) | |
(Show a, Show b, Show c, Show d, Show e, Show f, Show g) => Show (a, b, c, d, e, f, g) | |
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h) => Show (a, b, c, d, e, f, g, h) | |
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i) => Show (a, b, c, d, e, f, g, h, i) | |
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j) => Show (a, b, c, d, e, f, g, h, i, j) | |
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k) => Show (a, b, c, d, e, f, g, h, i, j, k) | |
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k, Show l) => Show (a, b, c, d, e, f, g, h, i, j, k, l) | |
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k, Show l, Show m) => Show (a, b, c, d, e, f, g, h, i, j, k, l, m) | |
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k, Show l, Show m, Show n) => Show (a, b, c, d, e, f, g, h, i, j, k, l, m, n) | |
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k, Show l, Show m, Show n, Show o) => Show (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) |
Case conversion
charToLower :: Char -> Char Source
Convert a character to lower case.
Character-based case conversion is lossy in comparison to string-based toLower
.
For instance, İ will be converted to i, instead of i̇.
charToUpper :: Char -> Char Source
Convert a character to upper case.
Character-based case conversion is lossy in comparison to string-based toUpper
.
For instance, ß won't be converted to SS.
IO
class IsSequence a => IOData a where
readFile :: MonadIO m => FilePath -> m a
writeFile :: MonadIO m => FilePath -> a -> m ()
hGetContents :: MonadIO m => Handle -> m a
hGetLine :: MonadIO m => Handle -> m a
hPut :: MonadIO m => Handle -> a -> m ()
IOData ByteString | |
IOData ByteString | |
IOData Text | |
IOData Text | |
(~) * Char c => IOData [c] |
Computation hClose
hdl
makes handle hdl
closed. Before the
computation finishes, if hdl
is writable its buffer is flushed as
for hFlush
.
Performing hClose
on a handle that has already been closed has no effect;
doing so is not an error. All other operations on a closed handle will fail.
If hClose
fails for any reason, any further operations (apart from
hClose
) on the handle will still fail as if hdl
had been successfully
closed.
FilePath
fpToString :: FilePath -> String Source
fpFromString :: String -> FilePath Source
fpToText :: FilePath -> Text Source
Translates a FilePath
to a Text
This translation is not correct for a (unix) filename
which can contain arbitrary (non-unicode) bytes: those bytes will be discarded.
This means you cannot translate the Text
back to the original file name.
If you control or otherwise understand the filenames
and believe them to be unicode valid consider using fpToTextEx
or fpToTextWarn
fpFromText :: Text -> FilePath Source
fpToTextWarn :: MonadIO m => FilePath -> m Text Source
Translates a FilePath
to a Text
Warns if there are non-unicode sequences in the file name
fpToTextEx :: FilePath -> Text Source
Translates a FilePath
to a Text
Throws an exception if there are non-unicode sequences in the file name
Use this to assert that you know
a filename will translate properly into a Text
.
If you created the filename, this should be the case.
Difference lists
data DList a :: * -> *
Alternative DList | |
Monad DList | |
Functor DList | |
MonadPlus DList | |
Applicative DList | |
Foldable DList | |
IsList (DList a) | |
Eq a => Eq (DList a) | |
Ord a => Ord (DList a) | |
Read a => Read (DList a) | |
Show a => Show (DList a) | |
IsString (DList Char) | |
Monoid (DList a) | |
NFData a => NFData (DList a) | |
IsSequence (DList a) | |
Semigroup (DList a) | |
Eq a => MonoFoldableEq (DList a) | |
Ord a => MonoFoldableOrd (DList a) | |
MonoPointed (DList a) | |
MonoTraversable (DList a) | |
MonoFoldable (DList a) | |
GrowingAppend (DList a) | |
SemiSequence (DList a) | |
MonoFunctor (DList a) | |
type Item (DList a) = a | |
type Element (DList a) = a | |
type Index (DList a) = Int |
applyDList :: DList a -> [a] -> [a] Source
Synonym for apply
Since 0.11.0
Exceptions
class Monad m => MonadThrow m where
MonadThrow [] | |
MonadThrow IO | |
MonadThrow STM | |
MonadThrow Maybe | |
(~) * e SomeException => MonadThrow (Either e) | |
MonadThrow m => MonadThrow (MaybeT m) | |
MonadThrow m => MonadThrow (ListT m) | |
MonadThrow m => MonadThrow (IdentityT m) | |
(MonadThrow m, Monoid w) => MonadThrow (WriterT w m) | |
(MonadThrow m, Monoid w) => MonadThrow (WriterT w m) | |
MonadThrow m => MonadThrow (StateT s m) | |
MonadThrow m => MonadThrow (StateT s m) | |
MonadThrow m => MonadThrow (ReaderT r m) | |
(Error e, MonadThrow m) => MonadThrow (ErrorT e m) | |
MonadThrow m => MonadThrow (ContT r m) | |
MonadThrow m => MonadThrow (ExceptT e m) | |
(MonadThrow m, Monoid w) => MonadThrow (RWST r w s m) | |
(MonadThrow m, Monoid w) => MonadThrow (RWST r w s m) |
class MonadThrow m => MonadCatch m
catch
MonadCatch IO | |
MonadCatch STM | |
MonadCatch m => MonadCatch (MaybeT m) | |
MonadCatch m => MonadCatch (ListT m) | |
MonadCatch m => MonadCatch (IdentityT m) | |
(MonadCatch m, Monoid w) => MonadCatch (WriterT w m) | |
(MonadCatch m, Monoid w) => MonadCatch (WriterT w m) | |
MonadCatch m => MonadCatch (StateT s m) | |
MonadCatch m => MonadCatch (StateT s m) | |
MonadCatch m => MonadCatch (ReaderT r m) | |
(Error e, MonadCatch m) => MonadCatch (ErrorT e m) | |
MonadCatch m => MonadCatch (ExceptT e m) | |
(MonadCatch m, Monoid w) => MonadCatch (RWST r w s m) | |
(MonadCatch m, Monoid w) => MonadCatch (RWST r w s m) |
class MonadCatch m => MonadMask m
mask, uninterruptibleMask
MonadMask IO | |
MonadMask m => MonadMask (IdentityT m) | |
(MonadMask m, Monoid w) => MonadMask (WriterT w m) | |
(MonadMask m, Monoid w) => MonadMask (WriterT w m) | |
MonadMask m => MonadMask (StateT s m) | |
MonadMask m => MonadMask (StateT s m) | |
MonadMask m => MonadMask (ReaderT r m) | |
(MonadMask m, Monoid w) => MonadMask (RWST r w s m) | |
(MonadMask m, Monoid w) => MonadMask (RWST r w s m) |
Force types
Helper functions for situations where type inferer gets confused.
asLByteString :: LByteString -> LByteString Source