| Safe Haskell | None |
|---|---|
| Language | Haskell98 |
ClassyPrelude
- module CorePrelude
- undefined :: a
- (++) :: Monoid m => m -> m -> m
- class Semigroup a where
- data WrappedMonoid m :: * -> *
- module Data.Functor
- module Control.Applicative
- (<&&>) :: Applicative a => a Bool -> a Bool -> a Bool
- (<||>) :: Applicative a => a Bool -> a Bool -> a Bool
- module Control.Monad
- module Control.Monad.Trans.Unlift
- whenM :: Monad m => m Bool -> m () -> m ()
- unlessM :: Monad m => m Bool -> m () -> m ()
- module Control.Concurrent.MVar.Lifted
- module Control.Concurrent.Chan.Lifted
- module Control.Concurrent.STM
- 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 ()
- module Data.IORef.Lifted
- module Data.Mutable
- primToPrim :: (PrimBase m1, PrimMonad m2, (~) * (PrimState m1) (PrimState m2)) => m1 a -> m2 a
- primToIO :: (PrimBase m, (~) * (PrimState m) RealWorld) => m a -> IO a
- primToST :: PrimBase m => m a -> ST (PrimState m) a
- module Data.Primitive.MutVar
- 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
- asks :: MonadReader r m => (r -> a) -> m a
- newtype ReaderT k r m a :: forall k. * -> (k -> *) -> k -> * = ReaderT {
- runReaderT :: r -> m a
- type Reader r = ReaderT * r Identity
- module Data.Foldable
- module Data.Traversable
- module Data.Bifunctor
- module Data.MonoTraversable
- module Data.MonoTraversable.Unprefixed
- module Data.Sequences
- module Data.Containers
- module Data.Builder
- module Data.NonNull
- toByteVector :: ByteString -> SVector Word8
- fromByteVector :: SVector Word8 -> ByteString
- data Handle :: *
- stdin :: Handle
- stdout :: Handle
- stderr :: Handle
- module Control.Concurrent.Lifted
- yieldThread :: MonadBase IO m => m ()
- module Control.Concurrent.Async
- module Control.Concurrent.Async.Lifted.Safe
- waitAsync :: MonadIO m => Async a -> m a
- pollAsync :: MonadIO m => Async a -> m (Maybe (Either SomeException a))
- waitCatchAsync :: MonadIO m => Async a -> m (Either SomeException a)
- cancel :: MonadIO m => Async a -> m ()
- cancelWith :: (MonadIO m, Exception e) => Async a -> e -> m ()
- linkAsync :: MonadIO m => Async a -> m ()
- link2Async :: MonadIO m => Async a -> Async b -> m ()
- map :: Functor f => (a -> b) -> f a -> f b
- readMay :: (Element c ~ Char, MonoFoldable c, Read a) => c -> Maybe a
- 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
- repeat :: a -> [a]
- (\\) :: SetContainer a => a -> a -> a
- intersect :: SetContainer a => a -> a -> a
- class Show a where
- tshow :: Show a => a -> Text
- tlshow :: Show a => a -> LText
- charToLower :: Char -> Char
- charToUpper :: Char -> Char
- class 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 ()
- data DList a :: * -> *
- asDList :: DList a -> DList a
- applyDList :: DList a -> [a] -> [a]
- module Control.Exception.Safe
- module Control.DeepSeq
- 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
module 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 lets you more easily get
notifications 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
The class of semigroups (types with an associative binary operation).
Since: 4.9.0.0
Minimal complete definition
Nothing
Instances
data WrappedMonoid m :: * -> * #
Provide a Semigroup for an arbitrary Monoid.
Instances
| 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 => Semigroup (WrappedMonoid m) | |
| Monoid m => Monoid (WrappedMonoid m) | |
| Hashable a => Hashable (WrappedMonoid a) | |
| NFData m => NFData (WrappedMonoid m) | Since: 1.4.2.0 |
| type Rep1 WrappedMonoid | |
| type Rep (WrappedMonoid m) | |
Functor
module Data.Functor
Applicative
module Control.Applicative
(<&&>) :: Applicative a => a Bool -> a Bool -> a Bool infixr 3 Source #
&& lifted to an Applicative.
Since: 0.12.8
(<||>) :: Applicative a => a Bool -> a Bool -> a Bool infixr 2 Source #
|| lifted to an Applicative.
Since: 0.12.8
Monad
module Control.Monad
module Control.Monad.Trans.Unlift
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
module Control.Concurrent.STM
atomically :: MonadIO m => STM a -> m a Source #
Generalized version of atomically.
alwaysSucceedsSTM :: STM a -> STM () Source #
Synonym for alwaysSucceeds.
module Data.IORef.Lifted
module Data.Mutable
Primitive (exported since 0.9.4)
primToPrim :: (PrimBase m1, PrimMonad m2, (~) * (PrimState m1) (PrimState m2)) => m1 a -> m2 a #
Convert a PrimBase to another monad with the same state token.
module Data.Primitive.MutVar
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
defaultTimeLocale :: TimeLocale #
Locale representing American usage.
knownTimeZones contains only the ten time-zones mentioned in RFC 822 sec. 5:
"UT", "GMT", "EST", "EDT", "CST", "CDT", "MST", "MDT", "PST", "PDT".
Note that the parsing functions will regardless parse single-letter military time-zones and +HHMM format.
Generics (since 0.8.1)
Representable types of kind *. This class is derivable in GHC with the DeriveGeneric flag on.
Instances
Transformers (since 0.9.4)
newtype Identity a :: * -> * #
Identity functor and monad. (a non-strict monad)
Since: 4.8.0.0
Constructors
| Identity | |
Fields
| |
Instances
class Monad m => MonadReader r m | m -> r where #
See examples in Control.Monad.Reader.
Note, the partially applied function type (->) r is a simple reader monad.
See the instance declaration below.
Instances
| MonadReader r m => MonadReader r (MaybeT m) | |
| MonadReader r m => MonadReader r (ListT m) | |
| MonadReader r ((->) r) | |
| (Functor m, MonadReader e m) => MonadReader e (Free m) | |
| (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) | |
| MonadReader r m => MonadReader r (IdentityT * m) | |
| MonadReader r m => MonadReader r (ExceptT e m) | |
| (Error e, MonadReader r m) => MonadReader r (ErrorT e m) | |
| Monad m => MonadReader r (ReaderT * r m) | |
| MonadReader r' m => MonadReader r' (ContT * r 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 #
Retrieves the monad environment.
Arguments
| :: MonadReader r m | |
| => (r -> a) | The selector function to apply to the environment. |
| -> m a |
Retrieves a function of the current environment.
newtype ReaderT k r m a :: forall k. * -> (k -> *) -> k -> * #
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.
Constructors
| ReaderT | |
Fields
| |
Instances
| MonadBaseControl b m => MonadBaseControl b (ReaderT * r m) | |
| MonadBase b m => MonadBase b (ReaderT * r m) | |
| Monad m => MonadReader r (ReaderT * r m) | |
| MonadTransControl (ReaderT * r) | |
| MonadTrans (ReaderT * r) | |
| Monad m => Monad (ReaderT * r m) | |
| Functor m => Functor (ReaderT * r m) | |
| MonadFix m => MonadFix (ReaderT * r m) | |
| MonadFail m => MonadFail (ReaderT * r m) | |
| Applicative m => Applicative (ReaderT * r m) | |
| MonadZip m => MonadZip (ReaderT * r m) | |
| MonadIO m => MonadIO (ReaderT * r m) | |
| Alternative m => Alternative (ReaderT * r m) | |
| MonadPlus m => MonadPlus (ReaderT * r m) | |
| Zip m => Zip (ReaderT * e m) | |
| PrimMonad m => PrimMonad (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) | |
| Representable m => Representable (ReaderT * e m) | |
| Functor m => MonoFunctor (ReaderT * r m a) | |
| Applicative m => MonoPointed (ReaderT * r m a) | |
| type StT (ReaderT * r) a | |
| type PrimState (ReaderT * r m) | |
| type Key (ReaderT * e m) | |
| type Rep (ReaderT * e m) | |
| type StM (ReaderT * r m) a | |
| type Element (ReaderT * r m 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)
module Data.Bifunctor
Mono hierarchy
module Data.MonoTraversable
module Data.Sequences
module Data.Containers
module Data.Builder
module Data.NonNull
toByteVector :: ByteString -> SVector Word8 Source #
Convert a ByteString into a storable Vector.
fromByteVector :: SVector Word8 -> ByteString Source #
Convert a storable Vector into a ByteString.
I/O
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.
Concurrency
module Control.Concurrent.Lifted
module Control.Concurrent.Async
waitCatchAsync :: MonadIO m => Async a -> m (Either SomeException a) Source #
waitCatchSTM for any MonadIO
Since: 1.0.0
cancelWith :: (MonadIO m, Exception e) => Async a -> e -> m () Source #
cancel an Async with the given exception. It is converted to
an async exception via toAsyncException first.
Since: 1.0.0
Non-standard
List-like classes
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) #
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) #
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.
Set-like
(\\) :: SetContainer a => a -> a -> a infixl 9 Source #
An alias for difference.
intersect :: SetContainer a => a -> a -> a Source #
An alias for intersection.
Text-like
Conversion of values to readable Strings.
Derived instances of Show have the following properties, which
are compatible with derived instances of Read:
- The result of
showis 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
showsPrecwill produce infix applications of the constructor. - the representation will be enclosed in parentheses if the
precedence of the top-level constructor in
xis less thand(associativity is ignored). Thus, ifdis0then the result is never surrounded in parentheses; ifdis11it is always surrounded in parentheses, unless it is an atomic expression. - If the constructor is defined using record syntax, then
showwill 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 = 5Note that right-associativity of :^: is ignored. For example,
show(Leaf 1 :^: Leaf 2 :^: Leaf 3)"Leaf 1 :^: (Leaf 2 :^: Leaf 3)".
Instances
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
Data which can be read to and from files and handles.
Note that, for lazy sequences, these operations may perform lazy I/O.
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.
Difference lists
A difference list is a function that, given a list, returns the original contents of the difference list prepended to the given list.
This structure supports O(1) append and snoc operations on lists, making it
very useful for append-heavy uses (esp. left-nested uses of ++), such
as logging and pretty printing.
Here is an example using DList as the state type when printing a tree with the Writer monad:
import Control.Monad.Writer
import Data.DList
data Tree a = Leaf a | Branch (Tree a) (Tree a)
flatten_writer :: Tree x -> DList x
flatten_writer = snd . runWriter . flatten
where
flatten (Leaf x) = tell (singleton x)
flatten (Branch x y) = flatten x >> flatten yInstances
| Monad DList | |
| Functor DList | |
| Applicative DList | |
| Foldable DList | |
| Alternative DList | |
| MonadPlus DList | |
| IsList (DList a) | |
| Eq a => Eq (DList a) | |
| Ord a => Ord (DList a) | |
| Read a => Read (DList a) | |
| Show a => Show (DList a) | |
| (~) * a Char => IsString (DList a) | |
| Semigroup (DList a) | |
| Monoid (DList a) | |
| NFData a => NFData (DList a) | |
| type Item (DList a) | |
| type Index (DList a) | |
| type Element (DList a) | |
applyDList :: DList a -> [a] -> [a] Source #
Synonym for apply
Since 0.11.0
Exceptions
module Control.Exception.Safe
module Control.DeepSeq
Force types
Helper functions for situations where type inferer gets confused.
asByteString :: ByteString -> ByteString Source #