turtle-1.6.2: Shell programming, Haskell-style

Safe Haskell | None
Language | Haskell2010

Turtle

Contents

- Modules

Description

See Turtle.Tutorial to learn how to use this library or Turtle.Prelude for a quick-start guide.

Here is the recommended way to import this library:

    {-# LANGUAGE OverloadedStrings #-}

    import Turtle
    import Prelude hiding (FilePath)

This module re-exports the rest of the library and also re-exports useful modules from `base`:

Turtle.Format provides type-safe string formatting

Turtle.Pattern provides `Pattern`s, which are like more powerful regular expressions

Turtle.Shell provides a `Shell` abstraction for building streaming, exception-safe pipelines

Turtle.Prelude provides a library of Unix-like utilities to get you started with basic shell-like programming within Haskell

Control.Applicative provides two classes:

- `Applicative`, which works with `Fold`, `Pattern`, `Managed`, and `Shell`
- `Alternative`, which works with `Pattern` and `Shell`

Control.Monad provides two classes:

- `Monad`, which works with `Pattern`, `Managed` and `Shell`
- `MonadPlus`, which works with `Pattern` and `Shell`

Control.Monad.IO.Class provides one class:

- `MonadIO`, which works with `Managed` and `Shell`

Data.Monoid provides one class:

- `Monoid`, which works with `Fold`, `Pattern`, `Managed`, and `Shell`

Control.Monad.Managed.Safe provides `Managed` resources

Additionally, you might also want to import the following modules qualified:

- Options.Applicative from `optparse-applicative` for command-line option parsing
- Control.Foldl (for predefined folds)
- Control.Foldl.Text (for `Text`-specific folds)
- Data.Text (for `Text`-manipulation utilities)
- Data.Text.IO (for reading and writing `Text`)

Synopsis

- module Turtle.Format
- module Turtle.Pattern
- module Turtle.Options
- module Turtle.Shell
- module Turtle.Line
- module Turtle.Prelude
- class Functor f => Applicative (f :: Type -> Type) where
  - pure :: a -> f a
  - (<*>) :: f (a -> b) -> f a -> f b
  - liftA2 :: (a -> b -> c) -> f a -> f b -> f c
  - (*>) :: f a -> f b -> f b
  - (<*) :: f a -> f b -> f a
- class Applicative f => Alternative (f :: Type -> Type) where
  - empty :: f a
  - (<|>) :: f a -> f a -> f a
  - some :: f a -> f [a]
  - many :: f a -> f [a]
- (<$>) :: Functor f => (a -> b) -> f a -> f b
- optional :: Alternative f => f a -> f (Maybe a)
- join :: Monad m => m (m a) -> m a
- guard :: Alternative f => Bool -> f ()
- class (Alternative m, Monad m) => MonadPlus (m :: Type -> Type) where
  - mzero :: m a
  - mplus :: m a -> m a -> m a
- when :: Applicative f => Bool -> f () -> f ()
- void :: Functor f => f a -> f ()
- msum :: (Foldable t, MonadPlus m) => t (m 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
- forever :: Applicative f => f a -> f b
- replicateM_ :: Applicative m => Int -> m a -> m ()
- unless :: Applicative f => Bool -> f () -> f ()
- mfilter :: MonadPlus m => (a -> Bool) -> m a -> m a
- module Control.Monad.IO.Class
- class Semigroup a => Monoid a where
  - mempty :: a
  - mappend :: a -> a -> a
  - mconcat :: [a] -> a
- (<>) :: Semigroup a => a -> a -> a
- managed :: MonadManaged m => (forall r. (a -> IO r) -> IO r) -> m a
- with :: Managed a -> (a -> IO r) -> IO r
- data Managed a
- runManaged :: Managed () -> IO ()
- (</>) :: FilePath -> FilePath -> FilePath
- type FilePath = String
- (<.>) :: FilePath -> String -> FilePath
- dropExtension :: FilePath -> FilePath
- hasExtension :: FilePath -> Bool
- isRelative :: FilePath -> Bool
- isAbsolute :: FilePath -> Bool
- directory :: FilePath -> FilePath
- stripPrefix :: FilePath -> FilePath -> Maybe FilePath
- splitExtension :: FilePath -> (String, Maybe String)
- splitExtensions :: FilePath -> (String, [String])
- splitDirectories :: FilePath -> [FilePath]
- toText :: FilePath -> Either Text Text
- fromText :: Text -> FilePath
- root :: FilePath -> FilePath
- parent :: FilePath -> FilePath
- filename :: FilePath -> FilePath
- dirname :: FilePath -> FilePath
- basename :: FilePath -> String
- absolute :: FilePath -> Bool
- relative :: FilePath -> Bool
- commonPrefix :: [FilePath] -> FilePath
- collapse :: FilePath -> FilePath
- extension :: FilePath -> Maybe String
- encodeString :: FilePath -> String
- decodeString :: String -> FilePath
- data Fold a b = Fold (x -> a -> x) x (x -> b)
- data FoldM (m :: Type -> Type) a b = FoldM (x -> a -> m x) (m x) (x -> m b)
- data Text
- data UTCTime
- data NominalDiffTime
- data Handle
- data ExitCode
  - = ExitSuccess
  - | ExitFailure Int
- class IsString a where
  - fromString :: String -> a
- (&) :: a -> (a -> b) -> b
- (<&>) :: Functor f => f a -> (a -> b) -> f b

# Modules

module Turtle.Format

module Turtle.Pattern

module Turtle.Options

module Turtle.Shell

module Turtle.Line

module Turtle.Prelude

class Functor f => Applicative (f :: Type -> Type) where #

A functor with application, providing operations to

- embed pure expressions (`pure`), and
- sequence computations and combine their results (`<*>` and `liftA2`).

A minimal complete definition must include implementations of `pure` and of either `<*>` or `liftA2`. If it defines both, then they must behave the same as their default definitions:

    (<*>) = liftA2 id

    liftA2 f x y = f <$> x <*> y

Further, any definition must satisfy the following:

Identity

      pure id <*> v = v

Composition

      pure (.) <*> u <*> v <*> w = u <*> (v <*> w)

Homomorphism

      pure f <*> pure x = pure (f x)

Interchange

      u <*> pure y = pure ($ y) <*> u

The other methods have the following default definitions, which may be overridden with equivalent specialized implementations:

-     u *> v = (id <$ u) <*> v

-     u <* v = liftA2 const u v

As a consequence of these laws, the `Functor` instance for `f` will satisfy

-     fmap f x = pure f <*> x

It may be useful to note that supposing

    forall x y. p (q x y) = f x . g y

it follows from the above that

    liftA2 p (liftA2 q u v) = liftA2 f u . liftA2 g v

If `f` is also a `Monad`, it should satisfy

-     pure = return

-     m1 <*> m2 = m1 >>= (\x1 -> m2 >>= (\x2 -> return (x1 x2)))

-     (*>) = (>>)

(which implies that `pure` and `<*>` satisfy the applicative functor laws).

Minimal complete definition

pure, ((<*>) | liftA2)

Methods

pure :: a -> f a #

Lift a value into the Structure.

#### Examples

Expand

    >>> pure 1 :: Maybe Int
    Just 1

    >>> pure 'z' :: [Char]
    "z"

    >>> pure (pure ":D") :: Maybe [String]
    Just [":D"]

(<*>) :: f (a -> b) -> f a -> f b infixl 4 #

Sequential application.

A few functors support an implementation of `<*>` that is more efficient than the default one.

#### Example

Expand

Used in combination with ``(<$>)``, ``(<*>)`` can be used to build a record.

    >>> data MyState = MyState {arg1 :: Foo, arg2 :: Bar, arg3 :: Baz}

    >>> produceFoo :: Applicative f => f Foo
    >>> produceBar :: Applicative f => f Bar
    >>> produceBaz :: Applicative f => f Baz

    >>> mkState :: Applicative f => f MyState
    >>> mkState = MyState <$> produceFoo <*> produceBar <*> produceBaz

liftA2 :: (a -> b -> c) -> f a -> f b -> f c #

Lift a binary function to actions.

Some functors support an implementation of `liftA2` that is more efficient than the default one. In particular, if `fmap` is an expensive operation, it is likely better to use `liftA2` than to `fmap` over the structure and then use `<*>`.

This became a typeclass method in 4.10.0.0. Prior to that, it was a function defined in terms of `<*>` and `fmap`.

#### Example

Expand

    >>> liftA2 (,) (Just 3) (Just 5)
    Just (3,5)

    >>> liftA2 (+) [1, 2, 3] [4, 5, 6]
    [5,6,7,6,7,8,7,8,9]

(*>) :: f a -> f b -> f b infixl 4 #

Sequence actions, discarding the value of the first argument.

#### Examples

Expand

If used in conjunction with the Applicative instance for `Maybe`, you can chain Maybe computations, with a possible "early return" in case of `Nothing`.

    >>> Just 2 *> Just 3
    Just 3

    >>> Nothing *> Just 3
    Nothing

Of course a more interesting use case would be to have effectful computations instead of just returning pure values.

    >>> import Data.Char
    >>> import GHC.Internal.Text.ParserCombinators.ReadP
    >>> let p = string "my name is " *> munch1 isAlpha <* eof
    >>> readP_to_S p "my name is Simon"
    [("Simon","")]

(<*) :: f a -> f b -> f a infixl 4 #

Sequence actions, discarding the value of the second argument.

#### Instances

Instances details

Applicative Concurrently |
Instance details Defined in Control.Concurrent.Async.Internal Methods pure :: a -> Concurrently a # (<*>) :: Concurrently (a -> b) -> Concurrently a -> Concurrently b # liftA2 :: (a -> b -> c) -> Concurrently a -> Concurrently b -> Concurrently c # (*>) :: Concurrently a -> Concurrently b -> Concurrently b # (<*) :: Concurrently a -> Concurrently b -> Concurrently a #
Applicative Complex | Since: base-4.9.0.0
Instance details Defined in Data.Complex Methods pure :: a -> Complex a # (<*>) :: Complex (a -> b) -> Complex a -> Complex b # liftA2 :: (a -> b -> c) -> Complex a -> Complex b -> Complex c # (*>) :: Complex a -> Complex b -> Complex b # (<*) :: Complex a -> Complex b -> Complex a #
Applicative First | Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods pure :: a -> First a # (<*>) :: First (a -> b) -> First a -> First b # liftA2 :: (a -> b -> c) -> First a -> First b -> First c # (*>) :: First a -> First b -> First b # (<*) :: First a -> First b -> First a #
Applicative Last | Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods pure :: a -> Last a # (<*>) :: Last (a -> b) -> Last a -> Last b # liftA2 :: (a -> b -> c) -> Last a -> Last b -> Last c # (*>) :: Last a -> Last b -> Last b # (<*) :: Last a -> Last b -> Last a #
Applicative Max | Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods pure :: a -> Max a # (<*>) :: Max (a -> b) -> Max a -> Max b # liftA2 :: (a -> b -> c) -> Max a -> Max b -> Max c # (*>) :: Max a -> Max b -> Max b # (<*) :: Max a -> Max b -> Max a #
Applicative Min | Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods pure :: a -> Min a # (<*>) :: Min (a -> b) -> Min a -> Min b # liftA2 :: (a -> b -> c) -> Min a -> Min b -> Min c # (*>) :: Min a -> Min b -> Min b # (<*) :: Min a -> Min b -> Min a #
Applicative Put |
Instance details Defined in Data.ByteString.Builder.Internal Methods pure :: a -> Put a # (<*>) :: Put (a -> b) -> Put a -> Put b # liftA2 :: (a -> b -> c) -> Put a -> Put b -> Put c # (*>) :: Put a -> Put b -> Put b # (<*) :: Put a -> Put b -> Put a #
Applicative Seq | Since: containers-0.5.4
Instance details Defined in Data.Sequence.Internal Methods pure :: a -> Seq a # (<*>) :: Seq (a -> b) -> Seq a -> Seq b # liftA2 :: (a -> b -> c) -> Seq a -> Seq b -> Seq c # (*>) :: Seq a -> Seq b -> Seq b # (<*) :: Seq a -> Seq b -> Seq a #
Applicative Tree |
Instance details Defined in Data.Tree Methods pure :: a -> Tree a # (<*>) :: Tree (a -> b) -> Tree a -> Tree b # liftA2 :: (a -> b -> c) -> Tree a -> Tree b -> Tree c # (*>) :: Tree a -> Tree b -> Tree b # (<*) :: Tree a -> Tree b -> Tree a #
Applicative NonEmpty | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Base Methods pure :: a -> NonEmpty a # (<*>) :: NonEmpty (a -> b) -> NonEmpty a -> NonEmpty b # liftA2 :: (a -> b -> c) -> NonEmpty a -> NonEmpty b -> NonEmpty c # (*>) :: NonEmpty a -> NonEmpty b -> NonEmpty b # (<*) :: NonEmpty a -> NonEmpty b -> NonEmpty a #
Applicative STM | @since base-4.8.0.0
Instance details Defined in GHC.Internal.Conc.Sync Methods pure :: a -> STM a # (<*>) :: STM (a -> b) -> STM a -> STM b # liftA2 :: (a -> b -> c) -> STM a -> STM b -> STM c # (*>) :: STM a -> STM b -> STM b # (<*) :: STM a -> STM b -> STM a #
Applicative Down | @since base-4.11.0.0
Instance details Defined in GHC.Internal.Data.Ord Methods pure :: a -> Down a # (<*>) :: Down (a -> b) -> Down a -> Down b # liftA2 :: (a -> b -> c) -> Down a -> Down b -> Down c # (*>) :: Down a -> Down b -> Down b # (<*) :: Down a -> Down b -> Down a #
Applicative Dual | @since base-4.8.0.0
Instance details Defined in GHC.Internal.Data.Semigroup.Internal Methods pure :: a -> Dual a # (<*>) :: Dual (a -> b) -> Dual a -> Dual b # liftA2 :: (a -> b -> c) -> Dual a -> Dual b -> Dual c # (*>) :: Dual a -> Dual b -> Dual b # (<*) :: Dual a -> Dual b -> Dual a #
Applicative Product | @since base-4.8.0.0
Instance details Defined in GHC.Internal.Data.Semigroup.Internal Methods pure :: a -> Product a # (<*>) :: Product (a -> b) -> Product a -> Product b # liftA2 :: (a -> b -> c) -> Product a -> Product b -> Product c # (*>) :: Product a -> Product b -> Product b # (<*) :: Product a -> Product b -> Product a #
Applicative Sum | @since base-4.8.0.0
Instance details Defined in GHC.Internal.Data.Semigroup.Internal Methods pure :: a -> Sum a # (<*>) :: Sum (a -> b) -> Sum a -> Sum b # liftA2 :: (a -> b -> c) -> Sum a -> Sum b -> Sum c # (*>) :: Sum a -> Sum b -> Sum b # (<*) :: Sum a -> Sum b -> Sum a #
Applicative Par1 | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Generics Methods pure :: a -> Par1 a # (<*>) :: Par1 (a -> b) -> Par1 a -> Par1 b # liftA2 :: (a -> b -> c) -> Par1 a -> Par1 b -> Par1 c # (*>) :: Par1 a -> Par1 b -> Par1 b # (<*) :: Par1 a -> Par1 b -> Par1 a #
Applicative P | @since base-4.5.0.0
Instance details Defined in GHC.Internal.Text.ParserCombinators.ReadP Methods pure :: a -> P a # (<*>) :: P (a -> b) -> P a -> P b # liftA2 :: (a -> b -> c) -> P a -> P b -> P c # (*>) :: P a -> P b -> P b # (<*) :: P a -> P b -> P a #
Applicative ReadP | @since base-4.6.0.0
Instance details Defined in GHC.Internal.Text.ParserCombinators.ReadP Methods pure :: a -> ReadP a # (<*>) :: ReadP (a -> b) -> ReadP a -> ReadP b # liftA2 :: (a -> b -> c) -> ReadP a -> ReadP b -> ReadP c # (*>) :: ReadP a -> ReadP b -> ReadP b # (<*) :: ReadP a -> ReadP b -> ReadP a #
Applicative ReadPrec | @since base-4.6.0.0
Instance details Defined in GHC.Internal.Text.ParserCombinators.ReadPrec Methods pure :: a -> ReadPrec a # (<*>) :: ReadPrec (a -> b) -> ReadPrec a -> ReadPrec b # liftA2 :: (a -> b -> c) -> ReadPrec a -> ReadPrec b -> ReadPrec c # (*>) :: ReadPrec a -> ReadPrec b -> ReadPrec b # (<*) :: ReadPrec a -> ReadPrec b -> ReadPrec a #
Applicative IO | @since base-2.01
Instance details Defined in GHC.Internal.Base Methods pure :: a -> IO a # (<*>) :: IO (a -> b) -> IO a -> IO b # liftA2 :: (a -> b -> c) -> IO a -> IO b -> IO c # (*>) :: IO a -> IO b -> IO b # (<*) :: IO a -> IO b -> IO a #
Applicative Managed |
Instance details Defined in Control.Monad.Managed Methods pure :: a -> Managed a # (<*>) :: Managed (a -> b) -> Managed a -> Managed b # liftA2 :: (a -> b -> c) -> Managed a -> Managed b -> Managed c # (*>) :: Managed a -> Managed b -> Managed b # (<*) :: Managed a -> Managed b -> Managed a #
Applicative Optional |
Instance details Defined in Data.Optional Methods pure :: a -> Optional a # (<*>) :: Optional (a -> b) -> Optional a -> Optional b # liftA2 :: (a -> b -> c) -> Optional a -> Optional b -> Optional c # (*>) :: Optional a -> Optional b -> Optional b # (<*) :: Optional a -> Optional b -> Optional a #
Applicative Chunk |
Instance details Defined in Options.Applicative.Help.Chunk Methods pure :: a -> Chunk a # (<*>) :: Chunk (a -> b) -> Chunk a -> Chunk b # liftA2 :: (a -> b -> c) -> Chunk a -> Chunk b -> Chunk c # (*>) :: Chunk a -> Chunk b -> Chunk b # (<*) :: Chunk a -> Chunk b -> Chunk a #
Applicative ComplResult |
Instance details Defined in Options.Applicative.Internal Methods pure :: a -> ComplResult a # (<*>) :: ComplResult (a -> b) -> ComplResult a -> ComplResult b # liftA2 :: (a -> b -> c) -> ComplResult a -> ComplResult b -> ComplResult c # (*>) :: ComplResult a -> ComplResult b -> ComplResult b # (<*) :: ComplResult a -> ComplResult b -> ComplResult a #
Applicative Completion |
Instance details Defined in Options.Applicative.Internal Methods pure :: a -> Completion a # (<*>) :: Completion (a -> b) -> Completion a -> Completion b # liftA2 :: (a -> b -> c) -> Completion a -> Completion b -> Completion c # (*>) :: Completion a -> Completion b -> Completion b # (<*) :: Completion a -> Completion b -> Completion a #
Applicative P |
Instance details Defined in Options.Applicative.Internal Methods pure :: a -> P a # (<*>) :: P (a -> b) -> P a -> P b # liftA2 :: (a -> b -> c) -> P a -> P b -> P c # (*>) :: P a -> P b -> P b # (<*) :: P a -> P b -> P a #
Applicative Parser |
Instance details Defined in Options.Applicative.Types Methods pure :: a -> Parser a # (<*>) :: Parser (a -> b) -> Parser a -> Parser b # liftA2 :: (a -> b -> c) -> Parser a -> Parser b -> Parser c # (*>) :: Parser a -> Parser b -> Parser b # (<*) :: Parser a -> Parser b -> Parser a #
Applicative ParserM |
Instance details Defined in Options.Applicative.Types Methods pure :: a -> ParserM a # (<*>) :: ParserM (a -> b) -> ParserM a -> ParserM b # liftA2 :: (a -> b -> c) -> ParserM a -> ParserM b -> ParserM c # (*>) :: ParserM a -> ParserM b -> ParserM b # (<*) :: ParserM a -> ParserM b -> ParserM a #
Applicative ParserResult |
Instance details Defined in Options.Applicative.Types Methods pure :: a -> ParserResult a # (<*>) :: ParserResult (a -> b) -> ParserResult a -> ParserResult b # liftA2 :: (a -> b -> c) -> ParserResult a -> ParserResult b -> ParserResult c # (*>) :: ParserResult a -> ParserResult b -> ParserResult b # (<*) :: ParserResult a -> ParserResult b -> ParserResult a #
Applicative ReadM |
Instance details Defined in Options.Applicative.Types Methods pure :: a -> ReadM a # (<*>) :: ReadM (a -> b) -> ReadM a -> ReadM b # liftA2 :: (a -> b -> c) -> ReadM a -> ReadM b -> ReadM c # (*>) :: ReadM a -> ReadM b -> ReadM b # (<*) :: ReadM a -> ReadM b -> ReadM a #
Applicative Array |
Instance details Defined in Data.Primitive.Array Methods pure :: a -> Array a # (<*>) :: Array (a -> b) -> Array a -> Array b # liftA2 :: (a -> b -> c) -> Array a -> Array b -> Array c # (*>) :: Array a -> Array b -> Array b # (<*) :: Array a -> Array b -> Array a #
Applicative SmallArray |
Instance details Defined in Data.Primitive.SmallArray Methods pure :: a -> SmallArray a # (<*>) :: SmallArray (a -> b) -> SmallArray a -> SmallArray b # liftA2 :: (a -> b -> c) -> SmallArray a -> SmallArray b -> SmallArray c # (*>) :: SmallArray a -> SmallArray b -> SmallArray b # (<*) :: SmallArray a -> SmallArray b -> SmallArray a #
Applicative Q |
Instance details Defined in Language.Haskell.TH.Syntax Methods pure :: a -> Q a # (<*>) :: Q (a -> b) -> Q a -> Q b # liftA2 :: (a -> b -> c) -> Q a -> Q b -> Q c # (*>) :: Q a -> Q b -> Q b # (<*) :: Q a -> Q b -> Q a #
Applicative Pattern # |
Instance details Defined in Turtle.Pattern Methods pure :: a -> Pattern a # (<*>) :: Pattern (a -> b) -> Pattern a -> Pattern b # liftA2 :: (a -> b -> c) -> Pattern a -> Pattern b -> Pattern c # (*>) :: Pattern a -> Pattern b -> Pattern b # (<*) :: Pattern a -> Pattern b -> Pattern a #
Applicative Shell # |
Instance details Defined in Turtle.Shell Methods pure :: a -> Shell a # (<*>) :: Shell (a -> b) -> Shell a -> Shell b # liftA2 :: (a -> b -> c) -> Shell a -> Shell b -> Shell c # (*>) :: Shell a -> Shell b -> Shell b # (<*) :: Shell a -> Shell b -> Shell a #
Applicative Stream |
Instance details Defined in Codec.Compression.Zlib.Stream Methods pure :: a -> Stream a # (<*>) :: Stream (a -> b) -> Stream a -> Stream b # liftA2 :: (a -> b -> c) -> Stream a -> Stream b -> Stream c # (*>) :: Stream a -> Stream b -> Stream b # (<*) :: Stream a -> Stream b -> Stream a #
Applicative Maybe | @since base-2.01
Instance details Defined in GHC.Internal.Base Methods pure :: a -> Maybe a # (<*>) :: Maybe (a -> b) -> Maybe a -> Maybe b # liftA2 :: (a -> b -> c) -> Maybe a -> Maybe b -> Maybe c # (*>) :: Maybe a -> Maybe b -> Maybe b # (<*) :: Maybe a -> Maybe b -> Maybe a #
Applicative Solo | @since base-4.15
Instance details Defined in GHC.Internal.Base Methods pure :: a -> Solo a # (<*>) :: Solo (a -> b) -> Solo a -> Solo b # liftA2 :: (a -> b -> c) -> Solo a -> Solo b -> Solo c # (*>) :: Solo a -> Solo b -> Solo b # (<*) :: Solo a -> Solo b -> Solo a #
Applicative [] | @since base-2.01
Instance details Defined in GHC.Internal.Base Methods pure :: a -> [a] # (<*>) :: [a -> b] -> [a] -> [b] # liftA2 :: (a -> b -> c) -> [a] -> [b] -> [c] # (*>) :: [a] -> [b] -> [b] # (<*) :: [a] -> [b] -> [a] #
Applicative (ConcurrentlyE e) |
Instance details Defined in Control.Concurrent.Async.Internal Methods pure :: a -> ConcurrentlyE e a # (<*>) :: ConcurrentlyE e (a -> b) -> ConcurrentlyE e a -> ConcurrentlyE e b # liftA2 :: (a -> b -> c) -> ConcurrentlyE e a -> ConcurrentlyE e b -> ConcurrentlyE e c # (*>) :: ConcurrentlyE e a -> ConcurrentlyE e b -> ConcurrentlyE e b # (<*) :: ConcurrentlyE e a -> ConcurrentlyE e b -> ConcurrentlyE e a #
Monad m => Applicative (WrappedMonad m) | Since: base-2.1
Instance details Defined in Control.Applicative Methods pure :: a -> WrappedMonad m a # (<*>) :: WrappedMonad m (a -> b) -> WrappedMonad m a -> WrappedMonad m b # liftA2 :: (a -> b -> c) -> WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m c # (*>) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m b # (<*) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m a #
Applicative (SetM s) |
Instance details Defined in Data.Graph Methods pure :: a -> SetM s a # (<*>) :: SetM s (a -> b) -> SetM s a -> SetM s b # liftA2 :: (a -> b -> c) -> SetM s a -> SetM s b -> SetM s c # (*>) :: SetM s a -> SetM s b -> SetM s b # (<*) :: SetM s a -> SetM s b -> SetM s a #
Monad m => Applicative (CatchT m) |
Instance details Defined in Control.Monad.Catch.Pure Methods pure :: a -> CatchT m a # (<*>) :: CatchT m (a -> b) -> CatchT m a -> CatchT m b # liftA2 :: (a -> b -> c) -> CatchT m a -> CatchT m b -> CatchT m c # (*>) :: CatchT m a -> CatchT m b -> CatchT m b # (<*) :: CatchT m a -> CatchT m b -> CatchT m a #
Applicative (Fold a) |
Instance details Defined in Control.Foldl Methods pure :: a0 -> Fold a a0 # (<*>) :: Fold a (a0 -> b) -> Fold a a0 -> Fold a b # liftA2 :: (a0 -> b -> c) -> Fold a a0 -> Fold a b -> Fold a c # (*>) :: Fold a a0 -> Fold a b -> Fold a b # (<*) :: Fold a a0 -> Fold a b -> Fold a a0 #
Applicative (Fold1 a) |
Instance details Defined in Control.Foldl.NonEmpty Methods pure :: a0 -> Fold1 a a0 # (<*>) :: Fold1 a (a0 -> b) -> Fold1 a a0 -> Fold1 a b # liftA2 :: (a0 -> b -> c) -> Fold1 a a0 -> Fold1 a b -> Fold1 a c # (*>) :: Fold1 a a0 -> Fold1 a b -> Fold1 a b # (<*) :: Fold1 a a0 -> Fold1 a b -> Fold1 a a0 #
Applicative (ReverseState s) |
Instance details Defined in Control.Scanl Methods pure :: a -> ReverseState s a # (<*>) :: ReverseState s (a -> b) -> ReverseState s a -> ReverseState s b # liftA2 :: (a -> b -> c) -> ReverseState s a -> ReverseState s b -> ReverseState s c # (*>) :: ReverseState s a -> ReverseState s b -> ReverseState s b # (<*) :: ReverseState s a -> ReverseState s b -> ReverseState s a #
Applicative (Scan a) |
Instance details Defined in Control.Scanl Methods pure :: a0 -> Scan a a0 # (<*>) :: Scan a (a0 -> b) -> Scan a a0 -> Scan a b # liftA2 :: (a0 -> b -> c) -> Scan a a0 -> Scan a b -> Scan a c # (*>) :: Scan a a0 -> Scan a b -> Scan a b # (<*) :: Scan a a0 -> Scan a b -> Scan a a0 #
Applicative (Either e) | @since base-3.0
Instance details Defined in GHC.Internal.Data.Either Methods pure :: a -> Either e a # (<*>) :: Either e (a -> b) -> Either e a -> Either e b # liftA2 :: (a -> b -> c) -> Either e a -> Either e b -> Either e c # (*>) :: Either e a -> Either e b -> Either e b # (<*) :: Either e a -> Either e b -> Either e a #
Applicative (U1 :: Type -> Type) | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Generics Methods pure :: a -> U1 a # (<*>) :: U1 (a -> b) -> U1 a -> U1 b # liftA2 :: (a -> b -> c) -> U1 a -> U1 b -> U1 c # (*>) :: U1 a -> U1 b -> U1 b # (<*) :: U1 a -> U1 b -> U1 a #
Monad m => Applicative (ListT m) |
Instance details Defined in Options.Applicative.Internal Methods pure :: a -> ListT m a # (<*>) :: ListT m (a -> b) -> ListT m a -> ListT m b # liftA2 :: (a -> b -> c) -> ListT m a -> ListT m b -> ListT m c # (*>) :: ListT m a -> ListT m b -> ListT m b # (<*) :: ListT m a -> ListT m b -> ListT m a #
Monad m => Applicative (NondetT m) |
Instance details Defined in Options.Applicative.Internal Methods pure :: a -> NondetT m a # (<*>) :: NondetT m (a -> b) -> NondetT m a -> NondetT m b # liftA2 :: (a -> b -> c) -> NondetT m a -> NondetT m b -> NondetT m c # (*>) :: NondetT m a -> NondetT m b -> NondetT m b # (<*) :: NondetT m a -> NondetT m b -> NondetT m a #
Applicative (IParser t) |
Instance details Defined in Data.Text.Internal.Read Methods pure :: a -> IParser t a # (<*>) :: IParser t (a -> b) -> IParser t a -> IParser t b # liftA2 :: (a -> b -> c) -> IParser t a -> IParser t b -> IParser t c # (*>) :: IParser t a -> IParser t b -> IParser t b # (<*) :: IParser t a -> IParser t b -> IParser t a #
Applicative f => Applicative (Lift f) | A combination is `Pure` only if both parts are.
Instance details Defined in Control.Applicative.Lift Methods pure :: a -> Lift f a # (<*>) :: Lift f (a -> b) -> Lift f a -> Lift f b # liftA2 :: (a -> b -> c) -> Lift f a -> Lift f b -> Lift f c # (*>) :: Lift f a -> Lift f b -> Lift f b # (<*) :: Lift f a -> Lift f b -> Lift f a #
(Functor m, Monad m) => Applicative (MaybeT m) |
Instance details Defined in Control.Monad.Trans.Maybe Methods pure :: a -> MaybeT m a # (<*>) :: MaybeT m (a -> b) -> MaybeT m a -> MaybeT m b # liftA2 :: (a -> b -> c) -> MaybeT m a -> MaybeT m b -> MaybeT m c # (*>) :: MaybeT m a -> MaybeT m b -> MaybeT m b # (<*) :: MaybeT m a -> MaybeT m b -> MaybeT m a #
Monoid a => Applicative ((,) a) | For tuples, the `Monoid` constraint on `a` determines how the first values merge. For example, `String`s concatenate:
    ("hello ", (+15)) <*> ("world!", 2002)
    ("hello world!",2017)
@since base-2.01
Instance details Defined in GHC.Internal.Base Methods pure :: a0 -> (a, a0) # (<*>) :: (a, a0 -> b) -> (a, a0) -> (a, b) # liftA2 :: (a0 -> b -> c) -> (a, a0) -> (a, b) -> (a, c) # (*>) :: (a, a0) -> (a, b) -> (a, b) # (<*) :: (a, a0) -> (a, b) -> (a, a0) #
Arrow a => Applicative (WrappedArrow a b) | Since: base-2.1
Instance details Defined in Control.Applicative Methods pure :: a0 -> WrappedArrow a b a0 # (<*>) :: WrappedArrow a b (a0 -> b0) -> WrappedArrow a b a0 -> WrappedArrow a b b0 # liftA2 :: (a0 -> b0 -> c) -> WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b c # (*>) :: WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b b0 # (<*) :: WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b a0 #
Biapplicative p => Applicative (Join p) |
Instance details Defined in Data.Bifunctor.Join Methods pure :: a -> Join p a # (<*>) :: Join p (a -> b) -> Join p a -> Join p b # liftA2 :: (a -> b -> c) -> Join p a -> Join p b -> Join p c # (*>) :: Join p a -> Join p b -> Join p b # (<*) :: Join p a -> Join p b -> Join p a #
(Applicative f, Monad f) => Applicative (WhenMissing f x) | Equivalent to `ReaderT k (ReaderT x (MaybeT f))`. Since: containers-0.5.9
Instance details Defined in Data.IntMap.Internal Methods pure :: a -> WhenMissing f x a # (<*>) :: WhenMissing f x (a -> b) -> WhenMissing f x a -> WhenMissing f x b # liftA2 :: (a -> b -> c) -> WhenMissing f x a -> WhenMissing f x b -> WhenMissing f x c # (*>) :: WhenMissing f x a -> WhenMissing f x b -> WhenMissing f x b # (<*) :: WhenMissing f x a -> WhenMissing f x b -> WhenMissing f x a #
Applicative m => Applicative (FoldM m a) |
Instance details Defined in Control.Foldl Methods pure :: a0 -> FoldM m a a0 # (<*>) :: FoldM m a (a0 -> b) -> FoldM m a a0 -> FoldM m a b # liftA2 :: (a0 -> b -> c) -> FoldM m a a0 -> FoldM m a b -> FoldM m a c # (*>) :: FoldM m a a0 -> FoldM m a b -> FoldM m a b # (<*) :: FoldM m a a0 -> FoldM m a b -> FoldM m a a0 #
Applicative m => Applicative (ScanM m a) |
Instance details Defined in Control.Scanl Methods pure :: a0 -> ScanM m a a0 # (<*>) :: ScanM m a (a0 -> b) -> ScanM m a a0 -> ScanM m a b # liftA2 :: (a0 -> b -> c) -> ScanM m a a0 -> ScanM m a b -> ScanM m a c # (*>) :: ScanM m a a0 -> ScanM m a b -> ScanM m a b # (<*) :: ScanM m a a0 -> ScanM m a b -> ScanM m a a0 #
Monoid m => Applicative (Const m :: Type -> Type) | @since base-2.0.1
Instance details Defined in GHC.Internal.Data.Functor.Const Methods pure :: a -> Const m a # (<*>) :: Const m (a -> b) -> Const m a -> Const m b # liftA2 :: (a -> b -> c) -> Const m a -> Const m b -> Const m c # (*>) :: Const m a -> Const m b -> Const m b # (<*) :: Const m a -> Const m b -> Const m a #
Applicative f => Applicative (Alt f) | @since base-4.8.0.0
Instance details Defined in GHC.Internal.Data.Semigroup.Internal Methods pure :: a -> Alt f a # (<*>) :: Alt f (a -> b) -> Alt f a -> Alt f b # liftA2 :: (a -> b -> c) -> Alt f a -> Alt f b -> Alt f c # (*>) :: Alt f a -> Alt f b -> Alt f b # (<*) :: Alt f a -> Alt f b -> Alt f a #
(Generic1 f, Applicative (Rep1 f)) => Applicative (Generically1 f) | @since base-4.17.0.0
Instance details Defined in GHC.Internal.Generics Methods pure :: a -> Generically1 f a # (<*>) :: Generically1 f (a -> b) -> Generically1 f a -> Generically1 f b # liftA2 :: (a -> b -> c) -> Generically1 f a -> Generically1 f b -> Generically1 f c # (*>) :: Generically1 f a -> Generically1 f b -> Generically1 f b # (<*) :: Generically1 f a -> Generically1 f b -> Generically1 f a #
Applicative f => Applicative (Rec1 f) | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Generics Methods pure :: a -> Rec1 f a # (<*>) :: Rec1 f (a -> b) -> Rec1 f a -> Rec1 f b # liftA2 :: (a -> b -> c) -> Rec1 f a -> Rec1 f b -> Rec1 f c # (*>) :: Rec1 f a -> Rec1 f b -> Rec1 f b # (<*) :: Rec1 f a -> Rec1 f b -> Rec1 f a #
Applicative (Tagged s) |
Instance details Defined in Data.Tagged Methods pure :: a -> Tagged s a # (<*>) :: Tagged s (a -> b) -> Tagged s a -> Tagged s b # liftA2 :: (a -> b -> c) -> Tagged s a -> Tagged s b -> Tagged s c # (*>) :: Tagged s a -> Tagged s b -> Tagged s b # (<*) :: Tagged s a -> Tagged s b -> Tagged s a #
Applicative f => Applicative (Backwards f) | Apply `f`-actions in the reverse order.
Instance details Defined in Control.Applicative.Backwards Methods pure :: a -> Backwards f a # (<*>) :: Backwards f (a -> b) -> Backwards f a -> Backwards f b # liftA2 :: (a -> b -> c) -> Backwards f a -> Backwards f b -> Backwards f c # (*>) :: Backwards f a -> Backwards f b -> Backwards f b # (<*) :: Backwards f a -> Backwards f b -> Backwards f a #
(Monoid w, Functor m, Monad m) => Applicative (AccumT w m) |
Instance details Defined in Control.Monad.Trans.Accum Methods pure :: a -> AccumT w m a # (<*>) :: AccumT w m (a -> b) -> AccumT w m a -> AccumT w m b # liftA2 :: (a -> b -> c) -> AccumT w m a -> AccumT w m b -> AccumT w m c # (*>) :: AccumT w m a -> AccumT w m b -> AccumT w m b # (<*) :: AccumT w m a -> AccumT w m b -> AccumT w m a #
(Functor m, Monad m) => Applicative (ExceptT e m) |
Instance details Defined in Control.Monad.Trans.Except Methods pure :: a -> ExceptT e m a # (<*>) :: ExceptT e m (a -> b) -> ExceptT e m a -> ExceptT e m b # liftA2 :: (a -> b -> c) -> ExceptT e m a -> ExceptT e m b -> ExceptT e m c # (*>) :: ExceptT e m a -> ExceptT e m b -> ExceptT e m b # (<*) :: ExceptT e m a -> ExceptT e m b -> ExceptT e m a #
Applicative m => Applicative (IdentityT m) |
Instance details Defined in Control.Monad.Trans.Identity Methods pure :: a -> IdentityT m a # (<*>) :: IdentityT m (a -> b) -> IdentityT m a -> IdentityT m b # liftA2 :: (a -> b -> c) -> IdentityT m a -> IdentityT m b -> IdentityT m c # (*>) :: IdentityT m a -> IdentityT m b -> IdentityT m b # (<*) :: IdentityT m a -> IdentityT m b -> IdentityT m a #
Applicative m => Applicative (ReaderT r m) |
Instance details Defined in Control.Monad.Trans.Reader Methods pure :: a -> ReaderT r m a # (<*>) :: ReaderT r m (a -> b) -> ReaderT r m a -> ReaderT r m b # liftA2 :: (a -> b -> c) -> ReaderT r m a -> ReaderT r m b -> ReaderT r m c # (*>) :: ReaderT r m a -> ReaderT r m b -> ReaderT r m b # (<*) :: ReaderT r m a -> ReaderT r m b -> ReaderT r m a #
(Functor m, Monad m) => Applicative (SelectT r m) |
Instance details Defined in Control.Monad.Trans.Select Methods pure :: a -> SelectT r m a # (<*>) :: SelectT r m (a -> b) -> SelectT r m a -> SelectT r m b # liftA2 :: (a -> b -> c) -> SelectT r m a -> SelectT r m b -> SelectT r m c # (*>) :: SelectT r m a -> SelectT r m b -> SelectT r m b # (<*) :: SelectT r m a -> SelectT r m b -> SelectT r m a #
(Functor m, Monad m) => Applicative (StateT s m) |
Instance details Defined in Control.Monad.Trans.State.Lazy Methods pure :: a -> StateT s m a # (<*>) :: StateT s m (a -> b) -> StateT s m a -> StateT s m b # liftA2 :: (a -> b -> c) -> StateT s m a -> StateT s m b -> StateT s m c # (*>) :: StateT s m a -> StateT s m b -> StateT s m b # (<*) :: StateT s m a -> StateT s m b -> StateT s m a #
(Functor m, Monad m) => Applicative (StateT s m) |
Instance details Defined in Control.Monad.Trans.State.Strict Methods pure :: a -> StateT s m a # (<*>) :: StateT s m (a -> b) -> StateT s m a -> StateT s m b # liftA2 :: (a -> b -> c) -> StateT s m a -> StateT s m b -> StateT s m c # (*>) :: StateT s m a -> StateT s m b -> StateT s m b # (<*) :: StateT s m a -> StateT s m b -> StateT s m a #
(Functor m, Monad m) => Applicative (WriterT w m) |
Instance details Defined in Control.Monad.Trans.Writer.CPS Methods pure :: a -> WriterT w m a # (<*>) :: WriterT w m (a -> b) -> WriterT w m a -> WriterT w m b # liftA2 :: (a -> b -> c) -> WriterT w m a -> WriterT w m b -> WriterT w m c # (*>) :: WriterT w m a -> WriterT w m b -> WriterT w m b # (<*) :: WriterT w m a -> WriterT w m b -> WriterT w m a #
(Monoid w, Applicative m) => Applicative (WriterT w m) |
Instance details Defined in Control.Monad.Trans.Writer.Lazy Methods pure :: a -> WriterT w m a # (<*>) :: WriterT w m (a -> b) -> WriterT w m a -> WriterT w m b # liftA2 :: (a -> b -> c) -> WriterT w m a -> WriterT w m b -> WriterT w m c # (*>) :: WriterT w m a -> WriterT w m b -> WriterT w m b # (<*) :: WriterT w m a -> WriterT w m b -> WriterT w m a #
(Monoid w, Applicative m) => Applicative (WriterT w m) |
Instance details Defined in Control.Monad.Trans.Writer.Strict Methods pure :: a -> WriterT w m a # (<*>) :: WriterT w m (a -> b) -> WriterT w m a -> WriterT w m b # liftA2 :: (a -> b -> c) -> WriterT w m a -> WriterT w m b -> WriterT w m c # (*>) :: WriterT w m a -> WriterT w m b -> WriterT w m b # (<*) :: WriterT w m a -> WriterT w m b -> WriterT w m a #
Monoid a => Applicative (Constant a :: Type -> Type) |
Instance details Defined in Data.Functor.Constant Methods pure :: a0 -> Constant a a0 # (<*>) :: Constant a (a0 -> b) -> Constant a a0 -> Constant a b # liftA2 :: (a0 -> b -> c) -> Constant a a0 -> Constant a b -> Constant a c # (*>) :: Constant a a0 -> Constant a b -> Constant a b # (<*) :: Constant a a0 -> Constant a b -> Constant a a0 #
Applicative f => Applicative (Reverse f) | Derived instance.
Instance details Defined in Data.Functor.Reverse Methods pure :: a -> Reverse f a # (<*>) :: Reverse f (a -> b) -> Reverse f a -> Reverse f b # liftA2 :: (a -> b -> c) -> Reverse f a -> Reverse f b -> Reverse f c # (*>) :: Reverse f a -> Reverse f b -> Reverse f b # (<*) :: Reverse f a -> Reverse f b -> Reverse f a #
(Monoid a, Monoid b) => Applicative ((,,) a b) | @since base-4.14.0.0
Instance details Defined in GHC.Internal.Base Methods pure :: a0 -> (a, b, a0) # (<*>) :: (a, b, a0 -> b0) -> (a, b, a0) -> (a, b, b0) # liftA2 :: (a0 -> b0 -> c) -> (a, b, a0) -> (a, b, b0) -> (a, b, c) # (*>) :: (a, b, a0) -> (a, b, b0) -> (a, b, b0) # (<*) :: (a, b, a0) -> (a, b, b0) -> (a, b, a0) #
(Applicative f, Applicative g) => Applicative (Product f g) | Since: base-4.9.0.0
Instance details Defined in Data.Functor.Product Methods pure :: a -> Product f g a # (<*>) :: Product f g (a -> b) -> Product f g a -> Product f g b # liftA2 :: (a -> b -> c) -> Product f g a -> Product f g b -> Product f g c # (*>) :: Product f g a -> Product f g b -> Product f g b # (<*) :: Product f g a -> Product f g b -> Product f g a #
(Monad f, Applicative f) => Applicative (WhenMatched f x y) | Equivalent to `ReaderT Key (ReaderT x (ReaderT y (MaybeT f)))` Since: containers-0.5.9
Instance details Defined in Data.IntMap.Internal Methods pure :: a -> WhenMatched f x y a # (<*>) :: WhenMatched f x y (a -> b) -> WhenMatched f x y a -> WhenMatched f x y b # liftA2 :: (a -> b -> c) -> WhenMatched f x y a -> WhenMatched f x y b -> WhenMatched f x y c # (*>) :: WhenMatched f x y a -> WhenMatched f x y b -> WhenMatched f x y b # (<*) :: WhenMatched f x y a -> WhenMatched f x y b -> WhenMatched f x y a #
(Applicative f, Monad f) => Applicative (WhenMissing f k x) | Equivalent to `ReaderT k (ReaderT x (MaybeT f))` . Since: containers-0.5.9
Instance details Defined in Data.Map.Internal Methods pure :: a -> WhenMissing f k x a # (<*>) :: WhenMissing f k x (a -> b) -> WhenMissing f k x a -> WhenMissing f k x b # liftA2 :: (a -> b -> c) -> WhenMissing f k x a -> WhenMissing f k x b -> WhenMissing f k x c # (*>) :: WhenMissing f k x a -> WhenMissing f k x b -> WhenMissing f k x b # (<*) :: WhenMissing f k x a -> WhenMissing f k x b -> WhenMissing f k x a #
(Applicative f, Applicative g) => Applicative (f :*: g) | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Generics Methods pure :: a -> (f :*: g) a # (<*>) :: (f :*: g) (a -> b) -> (f :*: g) a -> (f :*: g) b # liftA2 :: (a -> b -> c) -> (f :*: g) a -> (f :*: g) b -> (f :*: g) c # (*>) :: (f :*: g) a -> (f :*: g) b -> (f :*: g) b # (<*) :: (f :*: g) a -> (f :*: g) b -> (f :*: g) a #
Monoid c => Applicative (K1 i c :: Type -> Type) | @since base-4.12.0.0
Instance details Defined in GHC.Internal.Generics Methods pure :: a -> K1 i c a # (<*>) :: K1 i c (a -> b) -> K1 i c a -> K1 i c b # liftA2 :: (a -> b -> c0) -> K1 i c a -> K1 i c b -> K1 i c c0 # (*>) :: K1 i c a -> K1 i c b -> K1 i c b # (<*) :: K1 i c a -> K1 i c b -> K1 i c a #
Applicative (ContT r m) |
Instance details Defined in Control.Monad.Trans.Cont Methods pure :: a -> ContT r m a # (<*>) :: ContT r m (a -> b) -> ContT r m a -> ContT r m b # liftA2 :: (a -> b -> c) -> ContT r m a -> ContT r m b -> ContT r m c # (*>) :: ContT r m a -> ContT r m b -> ContT r m b # (<*) :: ContT r m a -> ContT r m b -> ContT r m a #
(Monoid a, Monoid b, Monoid c) => Applicative ((,,,) a b c) | @since base-4.14.0.0
Instance details Defined in GHC.Internal.Base Methods pure :: a0 -> (a, b, c, a0) # (<*>) :: (a, b, c, a0 -> b0) -> (a, b, c, a0) -> (a, b, c, b0) # liftA2 :: (a0 -> b0 -> c0) -> (a, b, c, a0) -> (a, b, c, b0) -> (a, b, c, c0) # (*>) :: (a, b, c, a0) -> (a, b, c, b0) -> (a, b, c, b0) # (<*) :: (a, b, c, a0) -> (a, b, c, b0) -> (a, b, c, a0) #
Applicative ((->) r) | @since base-2.01
Instance details Defined in GHC.Internal.Base Methods pure :: a -> r -> a # (<*>) :: (r -> (a -> b)) -> (r -> a) -> r -> b # liftA2 :: (a -> b -> c) -> (r -> a) -> (r -> b) -> r -> c # (*>) :: (r -> a) -> (r -> b) -> r -> b # (<*) :: (r -> a) -> (r -> b) -> r -> a #
(Applicative f, Applicative g) => Applicative (Compose f g) | Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose Methods pure :: a -> Compose f g a # (<*>) :: Compose f g (a -> b) -> Compose f g a -> Compose f g b # liftA2 :: (a -> b -> c) -> Compose f g a -> Compose f g b -> Compose f g c # (*>) :: Compose f g a -> Compose f g b -> Compose f g b # (<*) :: Compose f g a -> Compose f g b -> Compose f g a #
(Monad f, Applicative f) => Applicative (WhenMatched f k x y) | Equivalent to `ReaderT k (ReaderT x (ReaderT y (MaybeT f)))` Since: containers-0.5.9
Instance details Defined in Data.Map.Internal Methods pure :: a -> WhenMatched f k x y a # (<*>) :: WhenMatched f k x y (a -> b) -> WhenMatched f k x y a -> WhenMatched f k x y b # liftA2 :: (a -> b -> c) -> WhenMatched f k x y a -> WhenMatched f k x y b -> WhenMatched f k x y c # (*>) :: WhenMatched f k x y a -> WhenMatched f k x y b -> WhenMatched f k x y b # (<*) :: WhenMatched f k x y a -> WhenMatched f k x y b -> WhenMatched f k x y a #
(Applicative f, Applicative g) => Applicative (f :.: g) | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Generics Methods pure :: a -> (f :.: g) a # (<*>) :: (f :.: g) (a -> b) -> (f :.: g) a -> (f :.: g) b # liftA2 :: (a -> b -> c) -> (f :.: g) a -> (f :.: g) b -> (f :.: g) c # (*>) :: (f :.: g) a -> (f :.: g) b -> (f :.: g) b # (<*) :: (f :.: g) a -> (f :.: g) b -> (f :.: g) a #
Applicative f => Applicative (M1 i c f) | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Generics Methods pure :: a -> M1 i c f a # (<*>) :: M1 i c f (a -> b) -> M1 i c f a -> M1 i c f b # liftA2 :: (a -> b -> c0) -> M1 i c f a -> M1 i c f b -> M1 i c f c0 # (*>) :: M1 i c f a -> M1 i c f b -> M1 i c f b # (<*) :: M1 i c f a -> M1 i c f b -> M1 i c f a #
(Functor m, Monad m) => Applicative (RWST r w s m) |
Instance details Defined in Control.Monad.Trans.RWS.CPS Methods pure :: a -> RWST r w s m a # (<*>) :: RWST r w s m (a -> b) -> RWST r w s m a -> RWST r w s m b # liftA2 :: (a -> b -> c) -> RWST r w s m a -> RWST r w s m b -> RWST r w s m c # (*>) :: RWST r w s m a -> RWST r w s m b -> RWST r w s m b # (<*) :: RWST r w s m a -> RWST r w s m b -> RWST r w s m a #
(Monoid w, Functor m, Monad m) => Applicative (RWST r w s m) |
Instance details Defined in Control.Monad.Trans.RWS.Lazy Methods pure :: a -> RWST r w s m a # (<*>) :: RWST r w s m (a -> b) -> RWST r w s m a -> RWST r w s m b # liftA2 :: (a -> b -> c) -> RWST r w s m a -> RWST r w s m b -> RWST r w s m c # (*>) :: RWST r w s m a -> RWST r w s m b -> RWST r w s m b # (<*) :: RWST r w s m a -> RWST r w s m b -> RWST r w s m a #
(Monoid w, Functor m, Monad m) => Applicative (RWST r w s m) |
Instance details Defined in Control.Monad.Trans.RWS.Strict Methods pure :: a -> RWST r w s m a # (<*>) :: RWST r w s m (a -> b) -> RWST r w s m a -> RWST r w s m b # liftA2 :: (a -> b -> c) -> RWST r w s m a -> RWST r w s m b -> RWST r w s m c # (*>) :: RWST r w s m a -> RWST r w s m b -> RWST r w s m b # (<*) :: RWST r w s m a -> RWST r w s m b -> RWST r w s m a #

class Applicative f => Alternative (f :: Type -> Type) where #

A monoid on applicative functors.

If defined, `some` and `many` should be the least solutions of the equations:

-     some v = (:) <$> v <*> many v

-     many v = some v <|> pure []

#### Examples

Expand

    >>> Nothing <|> Just 42
    Just 42

    >>> [1, 2] <|> [3, 4]
    [1,2,3,4]

    >>> empty <|> print (2^15)
    32768

Minimal complete definition

empty, (<|>)

Methods

empty :: f a #

The identity of `<|>`

    empty <|> a     == a
    a     <|> empty == a

(<|>) :: f a -> f a -> f a infixl 3 #

An associative binary operation

some :: f a -> f [a] #

One or more.

#### Examples

Expand

    >>> some (putStr "la")
    lalalalalalalalala... * goes on forever *

    >>> some Nothing
    nothing

    >>> take 5 <$> some (Just 1)
    * hangs forever *

Note that this function can be used with Parsers based on Applicatives. In that case `some parser` will attempt to parse `parser` one or more times until it fails.

many :: f a -> f [a] #

Zero or more.

#### Examples

Expand

    >>> many (putStr "la")
    lalalalalalalalala... * goes on forever *

    >>> many Nothing
    Just []

    >>> take 5 <$> many (Just 1)
    * hangs forever *

Note that this function can be used with Parsers based on Applicatives. In that case `many parser` will attempt to parse `parser` zero or more times until it fails.

#### Instances

Instances details

Alternative Concurrently | `empty` waits forever. `<|>` returns the first to finish and `cancel`s the other.
Instance details Defined in Control.Concurrent.Async.Internal Methods empty :: Concurrently a # (<|>) :: Concurrently a -> Concurrently a -> Concurrently a # some :: Concurrently a -> Concurrently [a] # many :: Concurrently a -> Concurrently [a] #
Alternative Seq | Since: containers-0.5.4
Instance details Defined in Data.Sequence.Internal Methods empty :: Seq a # (<|>) :: Seq a -> Seq a -> Seq a # some :: Seq a -> Seq [a] # many :: Seq a -> Seq [a] #
Alternative STM | Takes the first non-`retry`ing `STM` action. @since base-4.8.0.0
Instance details Defined in GHC.Internal.Conc.Sync Methods empty :: STM a # (<|>) :: STM a -> STM a -> STM a # some :: STM a -> STM [a] # many :: STM a -> STM [a] #
Alternative P | @since base-4.5.0.0
Instance details Defined in GHC.Internal.Text.ParserCombinators.ReadP Methods empty :: P a # (<|>) :: P a -> P a -> P a # some :: P a -> P [a] # many :: P a -> P [a] #
Alternative ReadP | @since base-4.6.0.0
Instance details Defined in GHC.Internal.Text.ParserCombinators.ReadP Methods empty :: ReadP a # (<|>) :: ReadP a -> ReadP a -> ReadP a # some :: ReadP a -> ReadP [a] # many :: ReadP a -> ReadP [a] #
Alternative ReadPrec | @since base-4.6.0.0
Instance details Defined in GHC.Internal.Text.ParserCombinators.ReadPrec Methods empty :: ReadPrec a # (<|>) :: ReadPrec a -> ReadPrec a -> ReadPrec a # some :: ReadPrec a -> ReadPrec [a] # many :: ReadPrec a -> ReadPrec [a] #
Alternative IO | Takes the first non-throwing `IO` action's result. `empty` throws an exception. @since base-4.9.0.0
Instance details Defined in GHC.Internal.Base Methods empty :: IO a # (<|>) :: IO a -> IO a -> IO a # some :: IO a -> IO [a] # many :: IO a -> IO [a] #
Alternative Optional |
Instance details Defined in Data.Optional Methods empty :: Optional a # (<|>) :: Optional a -> Optional a -> Optional a # some :: Optional a -> Optional [a] # many :: Optional a -> Optional [a] #
Alternative Chunk |
Instance details Defined in Options.Applicative.Help.Chunk Methods empty :: Chunk a # (<|>) :: Chunk a -> Chunk a -> Chunk a # some :: Chunk a -> Chunk [a] # many :: Chunk a -> Chunk [a] #
Alternative Completion |
Instance details Defined in Options.Applicative.Internal Methods empty :: Completion a # (<|>) :: Completion a -> Completion a -> Completion a # some :: Completion a -> Completion [a] # many :: Completion a -> Completion [a] #
Alternative P |
Instance details Defined in Options.Applicative.Internal Methods empty :: P a # (<|>) :: P a -> P a -> P a # some :: P a -> P [a] # many :: P a -> P [a] #
Alternative Parser |
Instance details Defined in Options.Applicative.Types Methods empty :: Parser a # (<|>) :: Parser a -> Parser a -> Parser a # some :: Parser a -> Parser [a] # many :: Parser a -> Parser [a] #
Alternative ReadM |
Instance details Defined in Options.Applicative.Types Methods empty :: ReadM a # (<|>) :: ReadM a -> ReadM a -> ReadM a # some :: ReadM a -> ReadM [a] # many :: ReadM a -> ReadM [a] #
Alternative Array |
Instance details Defined in Data.Primitive.Array Methods empty :: Array a # (<|>) :: Array a -> Array a -> Array a # some :: Array a -> Array [a] # many :: Array a -> Array [a] #
Alternative SmallArray |
Instance details Defined in Data.Primitive.SmallArray Methods empty :: SmallArray a # (<|>) :: SmallArray a -> SmallArray a -> SmallArray a # some :: SmallArray a -> SmallArray [a] # many :: SmallArray a -> SmallArray [a] #
Alternative Pattern # |
Instance details Defined in Turtle.Pattern Methods empty :: Pattern a # (<|>) :: Pattern a -> Pattern a -> Pattern a # some :: Pattern a -> Pattern [a] # many :: Pattern a -> Pattern [a] #
Alternative Shell # |
Instance details Defined in Turtle.Shell Methods empty :: Shell a # (<|>) :: Shell a -> Shell a -> Shell a # some :: Shell a -> Shell [a] # many :: Shell a -> Shell [a] #
Alternative Maybe | Picks the leftmost `Just` value, or, alternatively, `Nothing`. @since base-2.01
Instance details Defined in GHC.Internal.Base Methods empty :: Maybe a # (<|>) :: Maybe a -> Maybe a -> Maybe a # some :: Maybe a -> Maybe [a] # many :: Maybe a -> Maybe [a] #
Alternative [] | Combines lists by concatenation, starting from the empty list. @since base-2.01
Instance details Defined in GHC.Internal.Base Methods empty :: [a] # (<|>) :: [a] -> [a] -> [a] # some :: [a] -> [[a]] # many :: [a] -> [[a]] #
MonadPlus m => Alternative (WrappedMonad m) | Since: base-2.1
Instance details Defined in Control.Applicative Methods empty :: WrappedMonad m a # (<|>) :: WrappedMonad m a -> WrappedMonad m a -> WrappedMonad m a # some :: WrappedMonad m a -> WrappedMonad m [a] # many :: WrappedMonad m a -> WrappedMonad m [a] #
Monad m => Alternative (CatchT m) |
Instance details Defined in Control.Monad.Catch.Pure Methods empty :: CatchT m a # (<|>) :: CatchT m a -> CatchT m a -> CatchT m a # some :: CatchT m a -> CatchT m [a] # many :: CatchT m a -> CatchT m [a] #
Alternative (U1 :: Type -> Type) | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Generics Methods empty :: U1 a # (<|>) :: U1 a -> U1 a -> U1 a # some :: U1 a -> U1 [a] # many :: U1 a -> U1 [a] #
Monad m => Alternative (ListT m) |
Instance details Defined in Options.Applicative.Internal Methods empty :: ListT m a # (<|>) :: ListT m a -> ListT m a -> ListT m a # some :: ListT m a -> ListT m [a] # many :: ListT m a -> ListT m [a] #
Monad m => Alternative (NondetT m) |
Instance details Defined in Options.Applicative.Internal Methods empty :: NondetT m a # (<|>) :: NondetT m a -> NondetT m a -> NondetT m a # some :: NondetT m a -> NondetT m [a] # many :: NondetT m a -> NondetT m [a] #
Alternative f => Alternative (Lift f) | A combination is `Pure` only either part is.
Instance details Defined in Control.Applicative.Lift Methods empty :: Lift f a # (<|>) :: Lift f a -> Lift f a -> Lift f a # some :: Lift f a -> Lift f [a] # many :: Lift f a -> Lift f [a] #
(Functor m, Monad m) => Alternative (MaybeT m) |
Instance details Defined in Control.Monad.Trans.Maybe Methods empty :: MaybeT m a # (<|>) :: MaybeT m a -> MaybeT m a -> MaybeT m a # some :: MaybeT m a -> MaybeT m [a] # many :: MaybeT m a -> MaybeT m [a] #
(ArrowZero a, ArrowPlus a) => Alternative (WrappedArrow a b) | Since: base-2.1
Instance details Defined in Control.Applicative Methods empty :: WrappedArrow a b a0 # (<|>) :: WrappedArrow a b a0 -> WrappedArrow a b a0 -> WrappedArrow a b a0 # some :: WrappedArrow a b a0 -> WrappedArrow a b [a0] # many :: WrappedArrow a b a0 -> WrappedArrow a b [a0] #
Alternative f => Alternative (Alt f) | @since base-4.8.0.0
Instance details Defined in GHC.Internal.Data.Semigroup.Internal Methods empty :: Alt f a # (<|>) :: Alt f a -> Alt f a -> Alt f a # some :: Alt f a -> Alt f [a] # many :: Alt f a -> Alt f [a] #
(Generic1 f, Alternative (Rep1 f)) => Alternative (Generically1 f) | @since base-4.17.0.0
Instance details Defined in GHC.Internal.Generics Methods empty :: Generically1 f a # (<|>) :: Generically1 f a -> Generically1 f a -> Generically1 f a # some :: Generically1 f a -> Generically1 f [a] # many :: Generically1 f a -> Generically1 f [a] #
Alternative f => Alternative (Rec1 f) | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Generics Methods empty :: Rec1 f a # (<|>) :: Rec1 f a -> Rec1 f a -> Rec1 f a # some :: Rec1 f a -> Rec1 f [a] # many :: Rec1 f a -> Rec1 f [a] #
Alternative f => Alternative (Backwards f) | Try alternatives in the same order as `f`.
Instance details Defined in Control.Applicative.Backwards Methods empty :: Backwards f a # (<|>) :: Backwards f a -> Backwards f a -> Backwards f a # some :: Backwards f a -> Backwards f [a] # many :: Backwards f a -> Backwards f [a] #
(Monoid w, Functor m, MonadPlus m) => Alternative (AccumT w m) |
Instance details Defined in Control.Monad.Trans.Accum Methods empty :: AccumT w m a # (<|>) :: AccumT w m a -> AccumT w m a -> AccumT w m a # some :: AccumT w m a -> AccumT w m [a] # many :: AccumT w m a -> AccumT w m [a] #
(Functor m, Monad m, Monoid e) => Alternative (ExceptT e m) |
Instance details Defined in Control.Monad.Trans.Except Methods empty :: ExceptT e m a # (<|>) :: ExceptT e m a -> ExceptT e m a -> ExceptT e m a # some :: ExceptT e m a -> ExceptT e m [a] # many :: ExceptT e m a -> ExceptT e m [a] #
Alternative m => Alternative (IdentityT m) |
Instance details Defined in Control.Monad.Trans.Identity Methods empty :: IdentityT m a # (<|>) :: IdentityT m a -> IdentityT m a -> IdentityT m a # some :: IdentityT m a -> IdentityT m [a] # many :: IdentityT m a -> IdentityT m [a] #
Alternative m => Alternative (ReaderT r m) |
Instance details Defined in Control.Monad.Trans.Reader Methods empty :: ReaderT r m a # (<|>) :: ReaderT r m a -> ReaderT r m a -> ReaderT r m a # some :: ReaderT r m a -> ReaderT r m [a] # many :: ReaderT r m a -> ReaderT r m [a] #
(Functor m, MonadPlus m) => Alternative (SelectT r m) |
Instance details Defined in Control.Monad.Trans.Select Methods empty :: SelectT r m a # (<|>) :: SelectT r m a -> SelectT r m a -> SelectT r m a # some :: SelectT r m a -> SelectT r m [a] # many :: SelectT r m a -> SelectT r m [a] #
(Functor m, MonadPlus m) => Alternative (StateT s m) |
Instance details Defined in Control.Monad.Trans.State.Lazy Methods empty :: StateT s m a # (<|>) :: StateT s m a -> StateT s m a -> StateT s m a # some :: StateT s m a -> StateT s m [a] # many :: StateT s m a -> StateT s m [a] #
(Functor m, MonadPlus m) => Alternative (StateT s m) |
Instance details Defined in Control.Monad.Trans.State.Strict Methods empty :: StateT s m a # (<|>) :: StateT s m a -> StateT s m a -> StateT s m a # some :: StateT s m a -> StateT s m [a] # many :: StateT s m a -> StateT s m [a] #
(Functor m, MonadPlus m) => Alternative (WriterT w m) |
Instance details Defined in Control.Monad.Trans.Writer.CPS Methods empty :: WriterT w m a # (<|>) :: WriterT w m a -> WriterT w m a -> WriterT w m a # some :: WriterT w m a -> WriterT w m [a] # many :: WriterT w m a -> WriterT w m [a] #
(Monoid w, Alternative m) => Alternative (WriterT w m) |
Instance details Defined in Control.Monad.Trans.Writer.Lazy Methods empty :: WriterT w m a # (<|>) :: WriterT w m a -> WriterT w m a -> WriterT w m a # some :: WriterT w m a -> WriterT w m [a] # many :: WriterT w m a -> WriterT w m [a] #
(Monoid w, Alternative m) => Alternative (WriterT w m) |
Instance details Defined in Control.Monad.Trans.Writer.Strict Methods empty :: WriterT w m a # (<|>) :: WriterT w m a -> WriterT w m a -> WriterT w m a # some :: WriterT w m a -> WriterT w m [a] # many :: WriterT w m a -> WriterT w m [a] #
Alternative f => Alternative (Reverse f) | Derived instance.
Instance details Defined in Data.Functor.Reverse Methods empty :: Reverse f a # (<|>) :: Reverse f a -> Reverse f a -> Reverse f a # some :: Reverse f a -> Reverse f [a] # many :: Reverse f a -> Reverse f [a] #
(Alternative f, Alternative g) => Alternative (Product f g) | Since: base-4.9.0.0
Instance details Defined in Data.Functor.Product Methods empty :: Product f g a # (<|>) :: Product f g a -> Product f g a -> Product f g a # some :: Product f g a -> Product f g [a] # many :: Product f g a -> Product f g [a] #
(Alternative f, Alternative g) => Alternative (f :*: g) | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Generics Methods empty :: (f :*: g) a # (<|>) :: (f :*: g) a -> (f :*: g) a -> (f :*: g) a # some :: (f :*: g) a -> (f :*: g) [a] # many :: (f :*: g) a -> (f :*: g) [a] #
(Alternative f, Applicative g) => Alternative (Compose f g) | Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose Methods empty :: Compose f g a # (<|>) :: Compose f g a -> Compose f g a -> Compose f g a # some :: Compose f g a -> Compose f g [a] # many :: Compose f g a -> Compose f g [a] #
(Alternative f, Applicative g) => Alternative (f :.: g) | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Generics Methods empty :: (f :.: g) a # (<|>) :: (f :.: g) a -> (f :.: g) a -> (f :.: g) a # some :: (f :.: g) a -> (f :.: g) [a] # many :: (f :.: g) a -> (f :.: g) [a] #
Alternative f => Alternative (M1 i c f) | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Generics Methods empty :: M1 i c f a # (<|>) :: M1 i c f a -> M1 i c f a -> M1 i c f a # some :: M1 i c f a -> M1 i c f [a] # many :: M1 i c f a -> M1 i c f [a] #
(Functor m, MonadPlus m) => Alternative (RWST r w s m) |
Instance details Defined in Control.Monad.Trans.RWS.CPS Methods empty :: RWST r w s m a # (<|>) :: RWST r w s m a -> RWST r w s m a -> RWST r w s m a # some :: RWST r w s m a -> RWST r w s m [a] # many :: RWST r w s m a -> RWST r w s m [a] #
(Monoid w, Functor m, MonadPlus m) => Alternative (RWST r w s m) |
Instance details Defined in Control.Monad.Trans.RWS.Lazy Methods empty :: RWST r w s m a # (<|>) :: RWST r w s m a -> RWST r w s m a -> RWST r w s m a # some :: RWST r w s m a -> RWST r w s m [a] # many :: RWST r w s m a -> RWST r w s m [a] #
(Monoid w, Functor m, MonadPlus m) => Alternative (RWST r w s m) |
Instance details Defined in Control.Monad.Trans.RWS.Strict Methods empty :: RWST r w s m a # (<|>) :: RWST r w s m a -> RWST r w s m a -> RWST r w s m a # some :: RWST r w s m a -> RWST r w s m [a] # many :: RWST r w s m a -> RWST r w s m [a] #

(<$>) :: Functor f => (a -> b) -> f a -> f b infixl 4 #

An infix synonym for `fmap`.

The name of this operator is an allusion to `$`. Note the similarities between their types:

     ($)  ::              (a -> b) ->   a ->   b
    (<$>) :: Functor f => (a -> b) -> f a -> f b

Whereas `$` is function application, `<$>` is function application lifted over a `Functor`.

#### Examples

Expand

Convert from a ``Maybe` `Int`` to a ``Maybe` `String`` using `show`:

    >>> show <$> Nothing
    Nothing

    >>> show <$> Just 3
    Just "3"

Convert from an ``Either` `Int` `Int`` to an ``Either` `Int`` `String` using `show`:

    >>> show <$> Left 17
    Left 17

    >>> show <$> Right 17
    Right "17"

Double each element of a list:

    >>> (*2) <$> [1,2,3]
    [2,4,6]

Apply `even` to the second element of a pair:

    >>> even <$> (2,2)
    (2,True)

optional :: Alternative f => f a -> f (Maybe a) #

One or none.

It is useful for modelling any computation that is allowed to fail.

#### Examples

Expand

Using the `Alternative` instance of Control.Monad.Except, the following functions:

    >>> import Control.Monad.Except

    >>> canFail = throwError "it failed" :: Except String Int
    >>> final = return 42                :: Except String Int

Can be combined by allowing the first function to fail:

    >>> runExcept $ canFail *> final
    Left "it failed"

    >>> runExcept $ optional canFail *> final
    Right 42

join :: Monad m => m (m a) -> m a #

The `join` function is the conventional monad join operator. It is used to remove one level of monadic structure, projecting its bound argument into the outer level.

'``join` bss`' can be understood as the `do` expression

    do bs <- bss
       bs

#### Examples

Expand

    >>> join [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
    [1,2,3,4,5,6,7,8,9]

    >>> join (Just (Just 3))
    Just 3

A common use of `join` is to run an `IO` computation returned from an `STM` transaction, since `STM` transactions can't perform `IO` directly. Recall that

    atomically :: STM a -> IO a

is used to run `STM` transactions atomically. So, by specializing the types of `atomically` and `join` to

    atomically :: STM (IO b) -> IO (IO b)
    join       :: IO (IO b)  -> IO b

we can compose them as

    join . atomically :: STM (IO b) -> IO b

to run an `STM` transaction and the `IO` action it returns.

guard :: Alternative f => Bool -> f () #

Conditional failure of `Alternative` computations. Defined by

    guard True  = pure ()
    guard False = empty

#### Examples

Expand

Common uses of `guard` include conditionally signalling an error in an error monad and conditionally rejecting the current choice in an `Alternative`-based parser.

As an example of signalling an error in the error monad `Maybe`, consider a safe division function `safeDiv x y` that returns `Nothing` when the denominator `y` is zero and ``Just` (x `div` y)` otherwise. For example:

    >>> safeDiv 4 0
    Nothing

    >>> safeDiv 4 2
    Just 2

A definition of `safeDiv` using guards, but not `guard`:

    safeDiv :: Int -> Int -> Maybe Int
    safeDiv x y | y /= 0    = Just (x `div` y)
                | otherwise = Nothing

A definition of `safeDiv` using `guard` and `Monad` `do`-notation:

    safeDiv :: Int -> Int -> Maybe Int
    safeDiv x y = do
      guard (y /= 0)
      return (x `div` y)

class (Alternative m, Monad m) => MonadPlus (m :: Type -> Type) where #

Monads that also support choice and failure.

Minimal complete definition

Nothing

Methods

mzero :: m a #

The identity of `mplus`. It should also satisfy the equations

    mzero >>= f  =  mzero
    v >> mzero   =  mzero

The default definition is

    mzero = empty

mplus :: m a -> m a -> m a #

An associative operation. The default definition is

    mplus = (<|>)

#### Instances

Instances details

MonadPlus Seq |
Instance details Defined in Data.Sequence.Internal Methods mzero :: Seq a # mplus :: Seq a -> Seq a -> Seq a #
MonadPlus STM | Takes the first non-`retry`ing `STM` action. @since base-4.3.0.0
Instance details Defined in GHC.Internal.Conc.Sync Methods mzero :: STM a # mplus :: STM a -> STM a -> STM a #
MonadPlus P | @since base-2.01
Instance details Defined in GHC.Internal.Text.ParserCombinators.ReadP Methods mzero :: P a # mplus :: P a -> P a -> P a #
MonadPlus ReadP | @since base-2.01
Instance details Defined in GHC.Internal.Text.ParserCombinators.ReadP Methods mzero :: ReadP a # mplus :: ReadP a -> ReadP a -> ReadP a #
MonadPlus ReadPrec | @since base-2.01
Instance details Defined in GHC.Internal.Text.ParserCombinators.ReadPrec Methods mzero :: ReadPrec a # mplus :: ReadPrec a -> ReadPrec a -> ReadPrec a #
MonadPlus IO | Takes the first non-throwing `IO` action's result. `mzero` throws an exception. @since base-4.9.0.0
Instance details Defined in GHC.Internal.Base Methods mzero :: IO a # mplus :: IO a -> IO a -> IO a #
MonadPlus Optional |
Instance details Defined in Data.Optional Methods mzero :: Optional a # mplus :: Optional a -> Optional a -> Optional a #
MonadPlus Chunk |
Instance details Defined in Options.Applicative.Help.Chunk Methods mzero :: Chunk a # mplus :: Chunk a -> Chunk a -> Chunk a #
MonadPlus Completion |
Instance details Defined in Options.Applicative.Internal Methods mzero :: Completion a # mplus :: Completion a -> Completion a -> Completion a #
MonadPlus P |
Instance details Defined in Options.Applicative.Internal Methods mzero :: P a # mplus :: P a -> P a -> P a #
MonadPlus ReadM |
Instance details Defined in Options.Applicative.Types Methods mzero :: ReadM a # mplus :: ReadM a -> ReadM a -> ReadM a #
MonadPlus Array |
Instance details Defined in Data.Primitive.Array Methods mzero :: Array a # mplus :: Array a -> Array a -> Array a #
MonadPlus SmallArray |
Instance details Defined in Data.Primitive.SmallArray Methods mzero :: SmallArray a # mplus :: SmallArray a -> SmallArray a -> SmallArray a #
MonadPlus Pattern # |
Instance details Defined in Turtle.Pattern Methods mzero :: Pattern a # mplus :: Pattern a -> Pattern a -> Pattern a #
MonadPlus Shell # |
Instance details Defined in Turtle.Shell Methods mzero :: Shell a # mplus :: Shell a -> Shell a -> Shell a #
MonadPlus Maybe | Picks the leftmost `Just` value, or, alternatively, `Nothing`. @since base-2.01
Instance details Defined in GHC.Internal.Base Methods mzero :: Maybe a # mplus :: Maybe a -> Maybe a -> Maybe a #
MonadPlus [] | Combines lists by concatenation, starting from the empty list. @since base-2.01
Instance details Defined in GHC.Internal.Base Methods mzero :: [a] # mplus :: [a] -> [a] -> [a] #
Monad m => MonadPlus (CatchT m) |
Instance details Defined in Control.Monad.Catch.Pure Methods mzero :: CatchT m a # mplus :: CatchT m a -> CatchT m a -> CatchT m a #
MonadPlus (U1 :: Type -> Type) | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Generics Methods mzero :: U1 a # mplus :: U1 a -> U1 a -> U1 a #
Monad m => MonadPlus (ListT m) |
Instance details Defined in Options.Applicative.Internal Methods mzero :: ListT m a # mplus :: ListT m a -> ListT m a -> ListT m a #
Monad m => MonadPlus (NondetT m) |
Instance details Defined in Options.Applicative.Internal Methods mzero :: NondetT m a # mplus :: NondetT m a -> NondetT m a -> NondetT m a #
Monad m => MonadPlus (MaybeT m) |
Instance details Defined in Control.Monad.Trans.Maybe Methods mzero :: MaybeT m a # mplus :: MaybeT m a -> MaybeT m a -> MaybeT m a #
MonadPlus f => MonadPlus (Alt f) | @since base-4.8.0.0
Instance details Defined in GHC.Internal.Data.Semigroup.Internal Methods mzero :: Alt f a # mplus :: Alt f a -> Alt f a -> Alt f a #
MonadPlus f => MonadPlus (Rec1 f) | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Generics Methods mzero :: Rec1 f a # mplus :: Rec1 f a -> Rec1 f a -> Rec1 f a #
(Monoid w, Functor m, MonadPlus m) => MonadPlus (AccumT w m) |
Instance details Defined in Control.Monad.Trans.Accum Methods mzero :: AccumT w m a # mplus :: AccumT w m a -> AccumT w m a -> AccumT w m a #
(Monad m, Monoid e) => MonadPlus (ExceptT e m) |
Instance details Defined in Control.Monad.Trans.Except Methods mzero :: ExceptT e m a # mplus :: ExceptT e m a -> ExceptT e m a -> ExceptT e m a #
MonadPlus m => MonadPlus (IdentityT m) |
Instance details Defined in Control.Monad.Trans.Identity Methods mzero :: IdentityT m a # mplus :: IdentityT m a -> IdentityT m a -> IdentityT m a #
MonadPlus m => MonadPlus (ReaderT r m) |
Instance details Defined in Control.Monad.Trans.Reader Methods mzero :: ReaderT r m a # mplus :: ReaderT r m a -> ReaderT r m a -> ReaderT r m a #
MonadPlus m => MonadPlus (SelectT r m) |
Instance details Defined in Control.Monad.Trans.Select Methods mzero :: SelectT r m a # mplus :: SelectT r m a -> SelectT r m a -> SelectT r m a #
MonadPlus m => MonadPlus (StateT s m) |
Instance details Defined in Control.Monad.Trans.State.Lazy Methods mzero :: StateT s m a # mplus :: StateT s m a -> StateT s m a -> StateT s m a #
MonadPlus m => MonadPlus (StateT s m) |
Instance details Defined in Control.Monad.Trans.State.Strict Methods mzero :: StateT s m a # mplus :: StateT s m a -> StateT s m a -> StateT s m a #
(Functor m, MonadPlus m) => MonadPlus (WriterT w m) |
Instance details Defined in Control.Monad.Trans.Writer.CPS Methods mzero :: WriterT w m a # mplus :: WriterT w m a -> WriterT w m a -> WriterT w m a #
(Monoid w, MonadPlus m) => MonadPlus (WriterT w m) |
Instance details Defined in Control.Monad.Trans.Writer.Lazy Methods mzero :: WriterT w m a # mplus :: WriterT w m a -> WriterT w m a -> WriterT w m a #
(Monoid w, MonadPlus m) => MonadPlus (WriterT w m) |
Instance details Defined in Control.Monad.Trans.Writer.Strict Methods mzero :: WriterT w m a # mplus :: WriterT w m a -> WriterT w m a -> WriterT w m a #
MonadPlus m => MonadPlus (Reverse m) | Derived instance.
Instance details Defined in Data.Functor.Reverse Methods mzero :: Reverse m a # mplus :: Reverse m a -> Reverse m a -> Reverse m a #
(MonadPlus f, MonadPlus g) => MonadPlus (Product f g) | Since: base-4.9.0.0
Instance details Defined in Data.Functor.Product Methods mzero :: Product f g a # mplus :: Product f g a -> Product f g a -> Product f g a #
(MonadPlus f, MonadPlus g) => MonadPlus (f :*: g) | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Generics Methods mzero :: (f :*: g) a # mplus :: (f :*: g) a -> (f :*: g) a -> (f :*: g) a #
MonadPlus f => MonadPlus (M1 i c f) | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Generics Methods mzero :: M1 i c f a # mplus :: M1 i c f a -> M1 i c f a -> M1 i c f a #
(Functor m, MonadPlus m) => MonadPlus (RWST r w s m) |
Instance details Defined in Control.Monad.Trans.RWS.CPS Methods mzero :: RWST r w s m a # mplus :: RWST r w s m a -> RWST r w s m a -> RWST r w s m a #
(Monoid w, MonadPlus m) => MonadPlus (RWST r w s m) |
Instance details Defined in Control.Monad.Trans.RWS.Lazy Methods mzero :: RWST r w s m a # mplus :: RWST r w s m a -> RWST r w s m a -> RWST r w s m a #
(Monoid w, MonadPlus m) => MonadPlus (RWST r w s m) |
Instance details Defined in Control.Monad.Trans.RWS.Strict Methods mzero :: RWST r w s m a # mplus :: RWST r w s m a -> RWST r w s m a -> RWST r w s m a #

when :: Applicative f => Bool -> f () -> f () #

Conditional execution of `Applicative` expressions. For example,

#### Examples

Expand

    when debug (putStrLn "Debugging")

will output the string `Debugging` if the Boolean value `debug` is `True`, and otherwise do nothing.

    >>> putStr "pi:" >> when False (print 3.14159)
    pi:

void :: Functor f => f a -> f () #

``void` value` discards or ignores the result of evaluation, such as the return value of an `IO` action.

#### Examples

Expand

Replace the contents of a ``Maybe` `Int`` with unit:

    >>> void Nothing
    Nothing

    >>> void (Just 3)
    Just ()

Replace the contents of an ``Either` `Int` `Int`` with unit, resulting in an ``Either` `Int` `()``:

    >>> void (Left 8675309)
    Left 8675309

    >>> void (Right 8675309)
    Right ()

Replace every element of a list with unit:

    >>> void [1,2,3]
    [(),(),()]

Replace the second element of a pair with unit:

    >>> void (1,2)
    (1,())

Discard the result of an `IO` action:

    >>> mapM print [1,2]
    1
    2
    [(),()]

    >>> void $ mapM print [1,2]
    1
    2

msum :: (Foldable t, MonadPlus m) => t (m a) -> m a #

The sum of a collection of actions using `(<|>)`, generalizing `concat`.

`msum` is just like `asum`, but specialised to `MonadPlus`.

#### Examples

Expand

Basic usage, using the `MonadPlus` instance for `Maybe`:

    >>> msum [Just "Hello", Nothing, Just "World"]
    Just "Hello"

(>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c infixr 1 #

Left-to-right composition of `Kleisli` arrows.

'`(bs `>=>` cs) a`' can be understood as the `do` expression

    do b <- bs a
       cs b

or in terms of ``(>>=)`` as

    bs a >>= cs

(<=<) :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c infixr 1 #

Right-to-left composition of Kleisli arrows. `(`>=>`)`, with the arguments flipped.

Note how this operator resembles function composition `(`.`)`:

    (.)   ::            (b ->   c) -> (a ->   b) -> a ->   c
    (<=<) :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c

forever :: Applicative f => f a -> f b #

Repeat an action indefinitely.

#### Examples

Expand

A common use of `forever` is to process input from network sockets, `Handle`s, and channels (e.g. `MVar` and `Chan`).

For example, here is how we might implement an echo server, using `forever` both to listen for client connections on a network socket and to echo client input on client connection handles:

    echoServer :: Socket -> IO ()
    echoServer socket = forever $ do
      client <- accept socket
      forkFinally (echo client) (\_ -> hClose client)
      where
        echo :: Handle -> IO ()
        echo client = forever $
          hGetLine client >>= hPutStrLn client

Note that "forever" isn't necessarily non-terminating. If the action is in a ``MonadPlus`` and short-circuits after some number of iterations. then ``forever`` actually returns `mzero`, effectively short-circuiting its caller.

replicateM_ :: Applicative m => Int -> m a -> m () #

Like `replicateM`, but discards the result.

#### Examples

Expand

    >>> replicateM_ 3 (putStr "a")
    aaa

unless :: Applicative f => Bool -> f () -> f () #

The reverse of `when`.

#### Examples

Expand

    >>> do x <- getLine
           unless (x == "hi") (putStrLn "hi!")
    comingupwithexamplesisdifficult
    hi!

    >>> unless (pi > exp 1) Nothing
    Just ()

mfilter :: MonadPlus m => (a -> Bool) -> m a -> m a #

Direct `MonadPlus` equivalent of `filter`.

#### Examples

Expand

The `filter` function is just `mfilter` specialized to the list monad:

    filter = ( mfilter :: (a -> Bool) -> [a] -> [a] )

An example using `mfilter` with the `Maybe` monad:

    >>> mfilter odd (Just 1)
    Just 1
    >>> mfilter odd (Just 2)
    Nothing

module Control.Monad.IO.Class

class Semigroup a => Monoid a where #

The class of monoids (types with an associative binary operation that has an identity). Instances should satisfy the following:

Right identity
  `x `<>` `mempty` = x`
Left identity
  ``mempty` `<>` x = x`
Associativity
  `x `<>` (y `<>` z) = (x `<>` y) `<>` z` (`Semigroup` law)
Concatenation
  ``mconcat` = `foldr` (`<>`) `mempty``

You can alternatively define `mconcat` instead of `mempty`, in which case the laws are:

Unit
  ``mconcat` (`pure` x) = x`
Multiplication
  ``mconcat` (`join` xss) = `mconcat` (`fmap` `mconcat` xss)`
Subclass
  ``mconcat` (`toList` xs) = `sconcat` xs`

The method names refer to the monoid of lists under concatenation, but there are many other instances.

Some types can be viewed as a monoid in more than one way, e.g. both addition and multiplication on numbers. In such cases we often define `newtype`s and make those instances of `Monoid`, e.g. `Sum` and `Product`.

NOTE: `Semigroup` is a superclass of `Monoid` since base-4.11.0.0.

Minimal complete definition

mempty | mconcat

Methods

mempty :: a #

Identity of `mappend`

#### Examples

Expand

    >>> "Hello world" <> mempty
    "Hello world"

    >>> mempty <> [1, 2, 3]
    [1,2,3]

mappend :: a -> a -> a #

An associative operation

NOTE: This method is redundant and has the default implementation ``mappend` = (`<>`)` since base-4.11.0.0. Should it be implemented manually, since `mappend` is a synonym for (`<>`), it is expected that the two functions are defined the same way. In a future GHC release `mappend` will be removed from `Monoid`.

mconcat :: [a] -> a #

Fold a list using the monoid.

For most types, the default definition for `mconcat` will be used, but the function is included in the class definition so that an optimized version can be provided for specific types.

    >>> mconcat ["Hello", " ", "Haskell", "!"]
    "Hello Haskell!"

#### Instances

Instances details

Monoid ByteArray | Since: base-4.17.0.0
Instance details Defined in Data.Array.Byte Methods mempty :: ByteArray # mappend :: ByteArray -> ByteArray -> ByteArray # mconcat :: [ByteArray] -> ByteArray #
Monoid Builder |
Instance details Defined in Data.ByteString.Builder.Internal Methods mempty :: Builder # mappend :: Builder -> Builder -> Builder # mconcat :: [Builder] -> Builder #
Monoid ByteString |
Instance details Defined in Data.ByteString.Internal.Type Methods mempty :: ByteString # mappend :: ByteString -> ByteString -> ByteString # mconcat :: [ByteString] -> ByteString #
Monoid ByteString |
Instance details Defined in Data.ByteString.Lazy.Internal Methods mempty :: ByteString # mappend :: ByteString -> ByteString -> ByteString # mconcat :: [ByteString] -> ByteString #
Monoid ShortByteString |
Instance details Defined in Data.ByteString.Short.Internal Methods mempty :: ShortByteString # mappend :: ShortByteString -> ShortByteString -> ShortByteString # mconcat :: [ShortByteString] -> ShortByteString #
Monoid IntSet |
Instance details Defined in Data.IntSet.Internal Methods mempty :: IntSet # mappend :: IntSet -> IntSet -> IntSet # mconcat :: [IntSet] -> IntSet #
Monoid All | @since base-2.01
Instance details Defined in GHC.Internal.Data.Semigroup.Internal Methods mempty :: All # mappend :: All -> All -> All # mconcat :: [All] -> All #
Monoid Any | @since base-2.01
Instance details Defined in GHC.Internal.Data.Semigroup.Internal Methods mempty :: Any # mappend :: Any -> Any -> Any # mconcat :: [Any] -> Any #
Monoid Ordering | @since base-2.01
Instance details Defined in GHC.Internal.Base Methods mempty :: Ordering # mappend :: Ordering -> Ordering -> Ordering # mconcat :: [Ordering] -> Ordering #
Monoid PrefsMod |
Instance details Defined in Options.Applicative.Builder Methods mempty :: PrefsMod # mappend :: PrefsMod -> PrefsMod -> PrefsMod # mconcat :: [PrefsMod] -> PrefsMod #
Monoid ParserHelp |
Instance details Defined in Options.Applicative.Help.Types Methods mempty :: ParserHelp # mappend :: ParserHelp -> ParserHelp -> ParserHelp # mconcat :: [ParserHelp] -> ParserHelp #
Monoid Completer |
Instance details Defined in Options.Applicative.Types Methods mempty :: Completer # mappend :: Completer -> Completer -> Completer # mconcat :: [Completer] -> Completer #
Monoid ParseError |
Instance details Defined in Options.Applicative.Types Methods mempty :: ParseError # mappend :: ParseError -> ParseError -> ParseError # mconcat :: [ParseError] -> ParseError #
Monoid OsString | "String-Concatenation" for `OsString`. This is not the same as `(</>)`.
Instance details Defined in System.OsString.Internal.Types Methods mempty :: OsString # mappend :: OsString -> OsString -> OsString # mconcat :: [OsString] -> OsString #
Monoid PosixString |
Instance details Defined in System.OsString.Internal.Types Methods mempty :: PosixString # mappend :: PosixString -> PosixString -> PosixString # mconcat :: [PosixString] -> PosixString #
Monoid WindowsString |
Instance details Defined in System.OsString.Internal.Types Methods mempty :: WindowsString # mappend :: WindowsString -> WindowsString -> WindowsString # mconcat :: [WindowsString] -> WindowsString #
Monoid Doc |
Instance details Defined in Text.PrettyPrint.HughesPJ Methods mempty :: Doc # mappend :: Doc -> Doc -> Doc # mconcat :: [Doc] -> Doc #
Monoid AnsiStyle | `mempty` does nothing, which is equivalent to inheriting the style of the surrounding doc, or the terminal’s default if no style has been set yet.
Instance details Defined in Prettyprinter.Render.Terminal.Internal Methods mempty :: AnsiStyle # mappend :: AnsiStyle -> AnsiStyle -> AnsiStyle # mconcat :: [AnsiStyle] -> AnsiStyle #
Monoid Builder |
Instance details Defined in Data.Text.Internal.Builder Methods mempty :: Builder # mappend :: Builder -> Builder -> Builder # mconcat :: [Builder] -> Builder #
Monoid StrictBuilder |
Instance details Defined in Data.Text.Internal.StrictBuilder Methods mempty :: StrictBuilder # mappend :: StrictBuilder -> StrictBuilder -> StrictBuilder # mconcat :: [StrictBuilder] -> StrictBuilder #
Monoid Line # |
Instance details Defined in Turtle.Line Methods mempty :: Line # mappend :: Line -> Line -> Line # mconcat :: [Line] -> Line #
Monoid StatxFlags |
Instance details Defined in System.Posix.Files.Common Methods mempty :: StatxFlags # mappend :: StatxFlags -> StatxFlags -> StatxFlags # mconcat :: [StatxFlags] -> StatxFlags #
Monoid StatxMask |
Instance details Defined in System.Posix.Files.Common Methods mempty :: StatxMask # mappend :: StatxMask -> StatxMask -> StatxMask # mconcat :: [StatxMask] -> StatxMask #
Monoid () | @since base-2.01
Instance details Defined in GHC.Internal.Base Methods mempty :: () # mappend :: () -> () -> () # mconcat :: [()] -> () #
(Semigroup a, Monoid a) => Monoid (Concurrently a) | Since: async-2.1.0
Instance details Defined in Control.Concurrent.Async.Internal Methods mempty :: Concurrently a # mappend :: Concurrently a -> Concurrently a -> Concurrently a # mconcat :: [Concurrently a] -> Concurrently a #
Monoid (Comparison a) | ``mempty`` on comparisons always returns `EQ`. Without newtypes this equals ``pure` (`pure` EQ)`.
    mempty :: Comparison a
    mempty = Comparison _ _ -> EQ
Instance details Defined in Data.Functor.Contravariant Methods mempty :: Comparison a # mappend :: Comparison a -> Comparison a -> Comparison a # mconcat :: [Comparison a] -> Comparison a #
Monoid (Equivalence a) | ``mempty`` on equivalences always returns `True`. Without newtypes this equals ``pure` (`pure` True)`.
    mempty :: Equivalence a
    mempty = Equivalence _ _ -> True
Instance details Defined in Data.Functor.Contravariant Methods mempty :: Equivalence a # mappend :: Equivalence a -> Equivalence a -> Equivalence a # mconcat :: [Equivalence a] -> Equivalence a #
Monoid (Predicate a) | ``mempty`` on predicates always returns `True`. Without newtypes this equals ``pure` True`.
    mempty :: Predicate a
    mempty = _ -> True
Instance details Defined in Data.Functor.Contravariant Methods mempty :: Predicate a # mappend :: Predicate a -> Predicate a -> Predicate a # mconcat :: [Predicate a] -> Predicate a #
(Ord a, Bounded a) => Monoid (Max a) | Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods mempty :: Max a # mappend :: Max a -> Max a -> Max a # mconcat :: [Max a] -> Max a #
(Ord a, Bounded a) => Monoid (Min a) | Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods mempty :: Min a # mappend :: Min a -> Min a -> Min a # mconcat :: [Min a] -> Min a #
Monoid m => Monoid (WrappedMonoid m) | Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods mempty :: WrappedMonoid m # mappend :: WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m # mconcat :: [WrappedMonoid m] -> WrappedMonoid m #
Monoid (IntMap a) |
Instance details Defined in Data.IntMap.Internal Methods mempty :: IntMap a # mappend :: IntMap a -> IntMap a -> IntMap a # mconcat :: [IntMap a] -> IntMap a #
Monoid (Seq a) |
Instance details Defined in Data.Sequence.Internal Methods mempty :: Seq a # mappend :: Seq a -> Seq a -> Seq a # mconcat :: [Seq a] -> Seq a #
Monoid (MergeSet a) |
Instance details Defined in Data.Set.Internal Methods mempty :: MergeSet a # mappend :: MergeSet a -> MergeSet a -> MergeSet a # mconcat :: [MergeSet a] -> MergeSet a #
Ord a => Monoid (Set a) |
Instance details Defined in Data.Set.Internal Methods mempty :: Set a # mappend :: Set a -> Set a -> Set a # mconcat :: [Set a] -> Set a #
Monoid a => Monoid (STM a) | @since base-4.17.0.0
Instance details Defined in GHC.Internal.Conc.Sync Methods mempty :: STM a # mappend :: STM a -> STM a -> STM a # mconcat :: [STM a] -> STM a #
Monoid a => Monoid (Down a) | @since base-4.11.0.0
Instance details Defined in GHC.Internal.Data.Ord Methods mempty :: Down a # mappend :: Down a -> Down a -> Down a # mconcat :: [Down a] -> Down a #
Monoid a => Monoid (Dual a) | @since base-2.01
Instance details Defined in GHC.Internal.Data.Semigroup.Internal Methods mempty :: Dual a # mappend :: Dual a -> Dual a -> Dual a # mconcat :: [Dual a] -> Dual a #
Monoid (Endo a) | @since base-2.01
Instance details Defined in GHC.Internal.Data.Semigroup.Internal Methods mempty :: Endo a # mappend :: Endo a -> Endo a -> Endo a # mconcat :: [Endo a] -> Endo a #
Num a => Monoid (Product a) | @since base-2.01
Instance details Defined in GHC.Internal.Data.Semigroup.Internal Methods mempty :: Product a # mappend :: Product a -> Product a -> Product a # mconcat :: [Product a] -> Product a #
Num a => Monoid (Sum a) | @since base-2.01
Instance details Defined in GHC.Internal.Data.Semigroup.Internal Methods mempty :: Sum a # mappend :: Sum a -> Sum a -> Sum a # mconcat :: [Sum a] -> Sum a #
(Generic a, Monoid (Rep a ())) => Monoid (Generically a) | @since base-4.17.0.0
Instance details Defined in GHC.Internal.Generics Methods mempty :: Generically a # mappend :: Generically a -> Generically a -> Generically a # mconcat :: [Generically a] -> Generically a #
Monoid p => Monoid (Par1 p) | @since base-4.12.0.0
Instance details Defined in GHC.Internal.Generics Methods mempty :: Par1 p # mappend :: Par1 p -> Par1 p -> Par1 p # mconcat :: [Par1 p] -> Par1 p #
Monoid a => Monoid (IO a) | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Base Methods mempty :: IO a # mappend :: IO a -> IO a -> IO a # mconcat :: [IO a] -> IO a #
Monoid a => Monoid (Managed a) |
Instance details Defined in Control.Monad.Managed Methods mempty :: Managed a # mappend :: Managed a -> Managed a -> Managed a # mconcat :: [Managed a] -> Managed a #
Monoid a => Monoid (Optional a) |
Instance details Defined in Data.Optional Methods mempty :: Optional a # mappend :: Optional a -> Optional a -> Optional a # mconcat :: [Optional a] -> Optional a #
Monoid (InfoMod a) |
Instance details Defined in Options.Applicative.Builder Methods mempty :: InfoMod a # mappend :: InfoMod a -> InfoMod a -> InfoMod a # mconcat :: [InfoMod a] -> InfoMod a #
Monoid (DefaultProp a) |
Instance details Defined in Options.Applicative.Builder.Internal Methods mempty :: DefaultProp a # mappend :: DefaultProp a -> DefaultProp a -> DefaultProp a # mconcat :: [DefaultProp a] -> DefaultProp a #
Semigroup a => Monoid (Chunk a) |
Instance details Defined in Options.Applicative.Help.Chunk Methods mempty :: Chunk a # mappend :: Chunk a -> Chunk a -> Chunk a # mconcat :: [Chunk a] -> Chunk a #
Monoid (Doc a) |
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Methods mempty :: Doc a # mappend :: Doc a -> Doc a -> Doc a # mconcat :: [Doc a] -> Doc a #
Monoid (Doc ann) |
    mempty = emptyDoc
    mconcat = hcat
    >>> mappend "hello" "world" :: Doc ann
    helloworld
Instance details Defined in Prettyprinter.Internal Methods mempty :: Doc ann # mappend :: Doc ann -> Doc ann -> Doc ann # mconcat :: [Doc ann] -> Doc ann #
Monoid (Array a) |
Instance details Defined in Data.Primitive.Array Methods mempty :: Array a # mappend :: Array a -> Array a -> Array a # mconcat :: [Array a] -> Array a #
Monoid (PrimArray a) | Since: primitive-0.6.4.0
Instance details Defined in Data.Primitive.PrimArray Methods mempty :: PrimArray a # mappend :: PrimArray a -> PrimArray a -> PrimArray a # mconcat :: [PrimArray a] -> PrimArray a #
Monoid (SmallArray a) |
Instance details Defined in Data.Primitive.SmallArray Methods mempty :: SmallArray a # mappend :: SmallArray a -> SmallArray a -> SmallArray a # mconcat :: [SmallArray a] -> SmallArray a #
Monoid a => Monoid (Q a) | Since: template-haskell-2.17.0.0
Instance details Defined in Language.Haskell.TH.Syntax Methods mempty :: Q a # mappend :: Q a -> Q a -> Q a # mconcat :: [Q a] -> Q a #
Monoid a => Monoid (Pattern a) # |
Instance details Defined in Turtle.Pattern Methods mempty :: Pattern a # mappend :: Pattern a -> Pattern a -> Pattern a # mconcat :: [Pattern a] -> Pattern a #
Monoid a => Monoid (Shell a) # |
Instance details Defined in Turtle.Shell Methods mempty :: Shell a # mappend :: Shell a -> Shell a -> Shell a # mconcat :: [Shell a] -> Shell a #
(Hashable a, Eq a) => Monoid (HashSet a) | `mempty` = `empty` `mappend` = `union` \(O(n+m)\) To obtain good performance, the smaller set must be presented as the first argument. #### Examples Expand
    >>> mappend (fromList [1,2]) (fromList [2,3])
    fromList [1,2,3]
Instance details Defined in Data.HashSet.Internal Methods mempty :: HashSet a # mappend :: HashSet a -> HashSet a -> HashSet a # mconcat :: [HashSet a] -> HashSet a #
Semigroup a => Monoid (Maybe a) | Lift a semigroup into `Maybe` forming a `Monoid` according to http://en.wikipedia.org/wiki/Monoid: "Any semigroup `S` may be turned into a monoid simply by adjoining an element `e` not in `S` and defining `e*e = e` and `e*s = s = s*e` for all `s ∈ S`." Since 4.11.0: constraint on inner `a` value generalised from `Monoid` to `Semigroup`. @since base-2.01
Instance details Defined in GHC.Internal.Base Methods mempty :: Maybe a # mappend :: Maybe a -> Maybe a -> Maybe a # mconcat :: [Maybe a] -> Maybe a #
Monoid a => Monoid (Solo a) | @since base-4.15
Instance details Defined in GHC.Internal.Base Methods mempty :: Solo a # mappend :: Solo a -> Solo a -> Solo a # mconcat :: [Solo a] -> Solo a #
Monoid [a] | @since base-2.01
Instance details Defined in GHC.Internal.Base Methods mempty :: [a] # mappend :: [a] -> [a] -> [a] # mconcat :: [[a]] -> [a] #
(Semigroup a, Monoid a) => Monoid (ConcurrentlyE e a) |
Instance details Defined in Control.Concurrent.Async.Internal Methods mempty :: ConcurrentlyE e a # mappend :: ConcurrentlyE e a -> ConcurrentlyE e a -> ConcurrentlyE e a # mconcat :: [ConcurrentlyE e a] -> ConcurrentlyE e a #
Monoid a => Monoid (Op a b) | ``mempty` @(Op a b)` without newtypes is `mempty @(b->a)` = `_ -> mempty`.
    mempty :: Op a b
    mempty = Op _ -> mempty
Instance details Defined in Data.Functor.Contravariant Methods mempty :: Op a b # mappend :: Op a b -> Op a b -> Op a b # mconcat :: [Op a b] -> Op a b #
Ord k => Monoid (Map k v) |
Instance details Defined in Data.Map.Internal Methods mempty :: Map k v # mappend :: Map k v -> Map k v -> Map k v # mconcat :: [Map k v] -> Map k v #
Monad m => Monoid (EndoM m a) |
Instance details Defined in Control.Foldl Methods mempty :: EndoM m a # mappend :: EndoM m a -> EndoM m a -> EndoM m a # mconcat :: [EndoM m a] -> EndoM m a #
Monoid b => Monoid (Fold a b) |
Instance details Defined in Control.Foldl Methods mempty :: Fold a b # mappend :: Fold a b -> Fold a b -> Fold a b # mconcat :: [Fold a b] -> Fold a b #
Monoid b => Monoid (Fold1 a b) |
Instance details Defined in Control.Foldl.NonEmpty Methods mempty :: Fold1 a b # mappend :: Fold1 a b -> Fold1 a b -> Fold1 a b # mconcat :: [Fold1 a b] -> Fold1 a b #
Monoid b => Monoid (Scan a b) |
Instance details Defined in Control.Scanl Methods mempty :: Scan a b # mappend :: Scan a b -> Scan a b -> Scan a b # mconcat :: [Scan a b] -> Scan a b #
Monoid (U1 p) | @since base-4.12.0.0
Instance details Defined in GHC.Internal.Generics Methods mempty :: U1 p # mappend :: U1 p -> U1 p -> U1 p # mconcat :: [U1 p] -> U1 p #
Monoid (Mod f a) |
Instance details Defined in Options.Applicative.Builder.Internal Methods mempty :: Mod f a # mappend :: Mod f a -> Mod f a -> Mod f a # mconcat :: [Mod f a] -> Mod f a #
(Eq k, Hashable k) => Monoid (HashMap k v) | `mempty` = `empty` `mappend` = `union` If a key occurs in both maps, the mapping from the first will be the mapping in the result. #### Examples Expand
    >>> mappend (fromList [(1,'a'),(2,'b')]) (fromList [(2,'c'),(3,'d')])
    fromList [(1,'a'),(2,'b'),(3,'d')]
Instance details Defined in Data.HashMap.Internal Methods mempty :: HashMap k v # mappend :: HashMap k v -> HashMap k v -> HashMap k v # mconcat :: [HashMap k v] -> HashMap k v #
(Monoid a, Monoid b) => Monoid (a, b) | @since base-2.01
Instance details Defined in GHC.Internal.Base Methods mempty :: (a, b) # mappend :: (a, b) -> (a, b) -> (a, b) # mconcat :: [(a, b)] -> (a, b) #
Monoid b => Monoid (a -> b) | @since base-2.01
Instance details Defined in GHC.Internal.Base Methods mempty :: a -> b # mappend :: (a -> b) -> (a -> b) -> a -> b # mconcat :: [a -> b] -> a -> b #
(Monoid b, Monad m) => Monoid (FoldM m a b) |
Instance details Defined in Control.Foldl Methods mempty :: FoldM m a b # mappend :: FoldM m a b -> FoldM m a b -> FoldM m a b # mconcat :: [FoldM m a b] -> FoldM m a b #
(Monad m, Monoid b) => Monoid (ScanM m a b) |
Instance details Defined in Control.Scanl Methods mempty :: ScanM m a b # mappend :: ScanM m a b -> ScanM m a b -> ScanM m a b # mconcat :: [ScanM m a b] -> ScanM m a b #
Monoid a => Monoid (Const a b) | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Data.Functor.Const Methods mempty :: Const a b # mappend :: Const a b -> Const a b -> Const a b # mconcat :: [Const a b] -> Const a b #
Alternative f => Monoid (Alt f a) | @since base-4.8.0.0
Instance details Defined in GHC.Internal.Data.Semigroup.Internal Methods mempty :: Alt f a # mappend :: Alt f a -> Alt f a -> Alt f a # mconcat :: [Alt f a] -> Alt f a #
Monoid (f p) => Monoid (Rec1 f p) | @since base-4.12.0.0
Instance details Defined in GHC.Internal.Generics Methods mempty :: Rec1 f p # mappend :: Rec1 f p -> Rec1 f p -> Rec1 f p # mconcat :: [Rec1 f p] -> Rec1 f p #
(Semigroup a, Monoid a) => Monoid (Tagged s a) |
Instance details Defined in Data.Tagged Methods mempty :: Tagged s a # mappend :: Tagged s a -> Tagged s a -> Tagged s a # mconcat :: [Tagged s a] -> Tagged s a #
Monoid a => Monoid (Constant a b) |
Instance details Defined in Data.Functor.Constant Methods mempty :: Constant a b # mappend :: Constant a b -> Constant a b -> Constant a b # mconcat :: [Constant a b] -> Constant a b #
(Monoid a, Monoid b, Monoid c) => Monoid (a, b, c) | @since base-2.01
Instance details Defined in GHC.Internal.Base Methods mempty :: (a, b, c) # mappend :: (a, b, c) -> (a, b, c) -> (a, b, c) # mconcat :: [(a, b, c)] -> (a, b, c) #
(Monoid (f a), Monoid (g a)) => Monoid (Product f g a) | Since: base-4.16.0.0
Instance details Defined in Data.Functor.Product Methods mempty :: Product f g a # mappend :: Product f g a -> Product f g a -> Product f g a # mconcat :: [Product f g a] -> Product f g a #
(Monoid (f p), Monoid (g p)) => Monoid ((f :*: g) p) | @since base-4.12.0.0
Instance details Defined in GHC.Internal.Generics Methods mempty :: (f :*: g) p # mappend :: (f :*: g) p -> (f :*: g) p -> (f :*: g) p # mconcat :: [(f :*: g) p] -> (f :*: g) p #
Monoid c => Monoid (K1 i c p) | @since base-4.12.0.0
Instance details Defined in GHC.Internal.Generics Methods mempty :: K1 i c p # mappend :: K1 i c p -> K1 i c p -> K1 i c p # mconcat :: [K1 i c p] -> K1 i c p #
(Monoid a, Monoid b, Monoid c, Monoid d) => Monoid (a, b, c, d) | @since base-2.01
Instance details Defined in GHC.Internal.Base Methods mempty :: (a, b, c, d) # mappend :: (a, b, c, d) -> (a, b, c, d) -> (a, b, c, d) # mconcat :: [(a, b, c, d)] -> (a, b, c, d) #
Monoid (f (g a)) => Monoid (Compose f g a) | Since: base-4.16.0.0
Instance details Defined in Data.Functor.Compose Methods mempty :: Compose f g a # mappend :: Compose f g a -> Compose f g a -> Compose f g a # mconcat :: [Compose f g a] -> Compose f g a #
Monoid (f (g p)) => Monoid ((f :.: g) p) | @since base-4.12.0.0
Instance details Defined in GHC.Internal.Generics Methods mempty :: (f :.: g) p # mappend :: (f :.: g) p -> (f :.: g) p -> (f :.: g) p # mconcat :: [(f :.: g) p] -> (f :.: g) p #
Monoid (f p) => Monoid (M1 i c f p) | @since base-4.12.0.0
Instance details Defined in GHC.Internal.Generics Methods mempty :: M1 i c f p # mappend :: M1 i c f p -> M1 i c f p -> M1 i c f p # mconcat :: [M1 i c f p] -> M1 i c f p #
(Monoid a, Monoid b, Monoid c, Monoid d, Monoid e) => Monoid (a, b, c, d, e) | @since base-2.01
Instance details Defined in GHC.Internal.Base Methods mempty :: (a, b, c, d, e) # mappend :: (a, b, c, d, e) -> (a, b, c, d, e) -> (a, b, c, d, e) # mconcat :: [(a, b, c, d, e)] -> (a, b, c, d, e) #

(<>) :: Semigroup a => a -> a -> a infixr 6 #

An associative operation.

#### Examples

Expand

    >>> [1,2,3] <> [4,5,6]
    [1,2,3,4,5,6]

    >>> Just [1, 2, 3] <> Just [4, 5, 6]
    Just [1,2,3,4,5,6]

    >>> putStr "Hello, " <> putStrLn "World!"
    Hello, World!

managed :: MonadManaged m => (forall r. (a -> IO r) -> IO r) -> m a #

Build a `Managed` value

with :: Managed a -> (a -> IO r) -> IO r #

Acquire a `Managed` value

This is a potentially unsafe function since it allows a resource to escape its scope. For example, you might use `Managed` to safely acquire a file handle, like this:

    import qualified System.IO as IO

    example :: Managed Handle
    example = managed (IO.withFile "foo.txt" IO.ReadMode)

... and if you never used the `with` function then you would never run the risk of accessing the `Handle` after the file was closed. However, if you use `with` then you can incorrectly access the handle after the handle is closed, like this:

    bad :: IO ()
    bad = do
        handle <- with example return
        IO.hPutStrLn handle "bar"  -- This will fail because the handle is closed

... so only use `with` if you know what you are doing and you're returning a value that is not a resource being managed.

data Managed a #

A managed resource that you acquire using `with`

#### Instances

Instances details

MonadIO Managed |
Instance details Defined in Control.Monad.Managed Methods liftIO :: IO a -> Managed a #
Applicative Managed |
Instance details Defined in Control.Monad.Managed Methods pure :: a -> Managed a # (<*>) :: Managed (a -> b) -> Managed a -> Managed b # liftA2 :: (a -> b -> c) -> Managed a -> Managed b -> Managed c # (*>) :: Managed a -> Managed b -> Managed b # (<*) :: Managed a -> Managed b -> Managed a #
Functor Managed |
Instance details Defined in Control.Monad.Managed Methods fmap :: (a -> b) -> Managed a -> Managed b # (<$) :: a -> Managed b -> Managed a #
Monad Managed |
Instance details Defined in Control.Monad.Managed Methods (>>=) :: Managed a -> (a -> Managed b) -> Managed b # (>>) :: Managed a -> Managed b -> Managed b # return :: a -> Managed a #
MonadFail Managed |
Instance details Defined in Control.Monad.Managed Methods fail :: String -> Managed a #
MonadManaged Managed |
Instance details Defined in Control.Monad.Managed Methods using :: Managed a -> Managed a #
Monoid a => Monoid (Managed a) |
Instance details Defined in Control.Monad.Managed Methods mempty :: Managed a # mappend :: Managed a -> Managed a -> Managed a # mconcat :: [Managed a] -> Managed a #
Semigroup a => Semigroup (Managed a) |
Instance details Defined in Control.Monad.Managed Methods (<>) :: Managed a -> Managed a -> Managed a # sconcat :: NonEmpty (Managed a) -> Managed a # stimes :: Integral b => b -> Managed a -> Managed a #
Floating a => Floating (Managed a) |
Instance details Defined in Control.Monad.Managed Methods pi :: Managed a # exp :: Managed a -> Managed a # log :: Managed a -> Managed a # sqrt :: Managed a -> Managed a # (**) :: Managed a -> Managed a -> Managed a # logBase :: Managed a -> Managed a -> Managed a # sin :: Managed a -> Managed a # cos :: Managed a -> Managed a # tan :: Managed a -> Managed a # asin :: Managed a -> Managed a # acos :: Managed a -> Managed a # atan :: Managed a -> Managed a # sinh :: Managed a -> Managed a # cosh :: Managed a -> Managed a # tanh :: Managed a -> Managed a # asinh :: Managed a -> Managed a # acosh :: Managed a -> Managed a # atanh :: Managed a -> Managed a # log1p :: Managed a -> Managed a # expm1 :: Managed a -> Managed a # log1pexp :: Managed a -> Managed a # log1mexp :: Managed a -> Managed a #
Num a => Num (Managed a) |
Instance details Defined in Control.Monad.Managed Methods (+) :: Managed a -> Managed a -> Managed a # (-) :: Managed a -> Managed a -> Managed a # (*) :: Managed a -> Managed a -> Managed a # negate :: Managed a -> Managed a # abs :: Managed a -> Managed a # signum :: Managed a -> Managed a # fromInteger :: Integer -> Managed a #
Fractional a => Fractional (Managed a) |
Instance details Defined in Control.Monad.Managed Methods (/) :: Managed a -> Managed a -> Managed a # recip :: Managed a -> Managed a # fromRational :: Rational -> Managed a #

runManaged :: Managed () -> IO () #

Run a `Managed` computation, enforcing that no acquired resources leak

(</>) :: FilePath -> FilePath -> FilePath infixr 5 #

Combine two paths with a path separator. If the second path starts with a path separator or a drive letter, then it returns the second. The intention is that `readFile (dir `</>` file)` will access the same file as `setCurrentDirectory dir; readFile file`.

    Posix:   "/directory" </> "file.ext" == "/directory/file.ext"
    Windows: "/directory" </> "file.ext" == "/directory\\file.ext"
             "directory" </> "/file.ext" == "/file.ext"
    Valid x => (takeDirectory x </> takeFileName x) `equalFilePath` x

Combined:

    Posix:   "/" </> "test" == "/test"
    Posix:   "home" </> "bob" == "home/bob"
    Posix:   "x:" </> "foo" == "x:/foo"
    Windows: "C:\\foo" </> "bar" == "C:\\foo\\bar"
    Windows: "home" </> "bob" == "home\\bob"

Not combined:

    Posix:   "home" </> "/bob" == "/bob"
    Windows: "home" </> "C:\\bob" == "C:\\bob"

Not combined (tricky):

On Windows, if a filepath starts with a single slash, it is relative to the root of the current drive. In [1], this is (confusingly) referred to as an absolute path. The current behavior of `</>` is to never combine these forms.

    Windows: "home" </> "/bob" == "/bob"
    Windows: "home" </> "\\bob" == "\\bob"
    Windows: "C:\\home" </> "\\bob" == "\\bob"

On Windows, from [1]: "If a file name begins with only a disk designator but not the backslash after the colon, it is interpreted as a relative path to the current directory on the drive with the specified letter." The current behavior of `</>` is to never combine these forms.

    Windows: "D:\\foo" </> "C:bar" == "C:bar"
    Windows: "C:\\foo" </> "C:bar" == "C:bar"

type FilePath = String #

File and directory names are values of type `String`, whose precise meaning is operating system dependent. Files can be opened, yielding a handle which can then be used to operate on the contents of that file.

(<.>) :: FilePath -> String -> FilePath infixr 7 #

Add an extension, even if there is already one there, equivalent to `addExtension`.

    "/directory/path" <.> "ext" == "/directory/path.ext"
    "/directory/path" <.> ".ext" == "/directory/path.ext"

dropExtension :: FilePath -> FilePath #

Remove last extension, and the "." preceding it.

    dropExtension "/directory/path.ext" == "/directory/path"
    dropExtension x == fst (splitExtension x)

hasExtension :: FilePath -> Bool #

Does the given filename have an extension?

    hasExtension "/directory/path.ext" == True
    hasExtension "/directory/path" == False
    null (takeExtension x) == not (hasExtension x)

isRelative :: FilePath -> Bool #

Is a path relative, or is it fixed to the root?

    Windows: isRelative "path\\test" == True
    Windows: isRelative "c:\\test" == False
    Windows: isRelative "c:test" == True
    Windows: isRelative "c:\\" == False
    Windows: isRelative "c:/" == False
    Windows: isRelative "c:" == True
    Windows: isRelative "\\\\foo" == False
    Windows: isRelative "\\\\?\\foo" == False
    Windows: isRelative "\\\\?\\UNC\\foo" == False
    Windows: isRelative "/foo" == True
    Windows: isRelative "\\foo" == True
    Posix:   isRelative "test/path" == True
    Posix:   isRelative "/test" == False
    Posix:   isRelative "/" == False

According to [1]:

- "A UNC name of any format [is never relative]."
- "You cannot use the "\?" prefix with a relative path."

isAbsolute :: FilePath -> Bool #

    not . isRelative

    isAbsolute x == not (isRelative x)

directory :: FilePath -> FilePath #

Retrieves the `FilePath`'s directory

stripPrefix :: FilePath -> FilePath -> Maybe FilePath #

Remove a prefix from a path

splitExtension :: FilePath -> (String, Maybe String) #

Split a `FilePath` on its extension

splitExtensions :: FilePath -> (String, [String]) #

Split a `FilePath` on its extensions

splitDirectories :: FilePath -> [FilePath] #

Split a `FilePath` into its components

toText :: FilePath -> Either Text Text #

Deprecated: Use Data.Text.pack instead

Convert a `FilePath` to human-readable `Text`

Note that even though the type says `Either` this utility actually always succeeds and returns a `Right` value. The only reason for the `Either` is compatibility with the old type from the `system-filepath` package.

fromText :: Text -> FilePath #

Deprecated: Use Data.Text.unpack instead

Convert `Text` to a `FilePath`

root :: FilePath -> FilePath #

Retrieves the `FilePath`'s root

parent :: FilePath -> FilePath #

Retrieves the `FilePath`'s parent directory

filename :: FilePath -> FilePath #

Retrieves the `FilePath`'s filename component

dirname :: FilePath -> FilePath #

Retrieve a `FilePath`'s directory name

basename :: FilePath -> String #

Retrieve a `FilePath`'s basename component

absolute :: FilePath -> Bool #

Deprecated: Use System.FilePath.isAbsolute instead

Test whether a path is absolute

relative :: FilePath -> Bool #

Deprecated: Use System.FilePath.isRelative instead

Test whether a path is relative

commonPrefix :: [FilePath] -> FilePath #

Find the greatest common prefix between a list of `FilePath`s

collapse :: FilePath -> FilePath #

Deprecated: Use System.FilePath.normalise instead

Normalise a path

extension :: FilePath -> Maybe String #

Get a `FilePath`'s last extension, or `Nothing` if it has no extension

encodeString :: FilePath -> String #

Deprecated: Use id instead

Convert a `FilePath` to a `String`

decodeString :: String -> FilePath #

Deprecated: Use id instead

Convert a `String` to a `FilePath`

data Fold a b #

Efficient representation of a left fold that preserves the fold's step function, initial accumulator, and extraction function

This allows the `Applicative` instance to assemble derived folds that traverse the container only once

A '`Fold` a b' processes elements of type a and results in a value of type b.

Constructors

Fold (x -> a -> x) x (x -> b) | `Fold` `step` `initial` `extract`

#### Instances

Instances details

Choice Fold |
Instance details Defined in Control.Foldl Methods left' :: Fold a b -> Fold (Either a c) (Either b c) # right' :: Fold a b -> Fold (Either c a) (Either c b) #
Closed Fold |
Instance details Defined in Control.Foldl Methods closed :: Fold a b -> Fold (x -> a) (x -> b) #
Costrong Fold |
Instance details Defined in Control.Foldl Methods unfirst :: Fold (a, d) (b, d) -> Fold a b # unsecond :: Fold (d, a) (d, b) -> Fold a b #
Profunctor Fold |
Instance details Defined in Control.Foldl Methods dimap :: (a -> b) -> (c -> d) -> Fold b c -> Fold a d # lmap :: (a -> b) -> Fold b c -> Fold a c # rmap :: (b -> c) -> Fold a b -> Fold a c # (#.) :: forall a b c q. Coercible c b => q b c -> Fold a b -> Fold a c # (.#) :: forall a b c q. Coercible b a => Fold b c -> q a b -> Fold a c #
Cosieve Fold [] |
Instance details Defined in Control.Foldl Methods cosieve :: Fold a b -> [a] -> b #
Semigroupoid Fold |
Instance details Defined in Control.Foldl Methods o :: Fold j k1 -> Fold i j -> Fold i k1 #
Comonad (Fold a) |
Instance details Defined in Control.Foldl Methods extract :: Fold a a0 -> a0 # duplicate :: Fold a a0 -> Fold a (Fold a a0) # extend :: (Fold a a0 -> b) -> Fold a a0 -> Fold a b #
Applicative (Fold a) |
Instance details Defined in Control.Foldl Methods pure :: a0 -> Fold a a0 # (<*>) :: Fold a (a0 -> b) -> Fold a a0 -> Fold a b # liftA2 :: (a0 -> b -> c) -> Fold a a0 -> Fold a b -> Fold a c # (*>) :: Fold a a0 -> Fold a b -> Fold a b # (<*) :: Fold a a0 -> Fold a b -> Fold a a0 #
Functor (Fold a) |
Instance details Defined in Control.Foldl Methods fmap :: (a0 -> b) -> Fold a a0 -> Fold a b # (<$) :: a0 -> Fold a b -> Fold a a0 #
Extend (Fold a) |
Instance details Defined in Control.Foldl Methods duplicated :: Fold a a0 -> Fold a (Fold a a0) # extended :: (Fold a a0 -> b) -> Fold a a0 -> Fold a b #
Monoid b => Monoid (Fold a b) |
Instance details Defined in Control.Foldl Methods mempty :: Fold a b # mappend :: Fold a b -> Fold a b -> Fold a b # mconcat :: [Fold a b] -> Fold a b #
Semigroup b => Semigroup (Fold a b) |
Instance details Defined in Control.Foldl Methods (<>) :: Fold a b -> Fold a b -> Fold a b # sconcat :: NonEmpty (Fold a b) -> Fold a b # stimes :: Integral b0 => b0 -> Fold a b -> Fold a b #
Floating b => Floating (Fold a b) |
Instance details Defined in Control.Foldl Methods pi :: Fold a b # exp :: Fold a b -> Fold a b # log :: Fold a b -> Fold a b # sqrt :: Fold a b -> Fold a b # (**) :: Fold a b -> Fold a b -> Fold a b # logBase :: Fold a b -> Fold a b -> Fold a b # sin :: Fold a b -> Fold a b # cos :: Fold a b -> Fold a b # tan :: Fold a b -> Fold a b # asin :: Fold a b -> Fold a b # acos :: Fold a b -> Fold a b # atan :: Fold a b -> Fold a b # sinh :: Fold a b -> Fold a b # cosh :: Fold a b -> Fold a b # tanh :: Fold a b -> Fold a b # asinh :: Fold a b -> Fold a b # acosh :: Fold a b -> Fold a b # atanh :: Fold a b -> Fold a b # log1p :: Fold a b -> Fold a b # expm1 :: Fold a b -> Fold a b # log1pexp :: Fold a b -> Fold a b # log1mexp :: Fold a b -> Fold a b #
Num b => Num (Fold a b) |
Instance details Defined in Control.Foldl Methods (+) :: Fold a b -> Fold a b -> Fold a b # (-) :: Fold a b -> Fold a b -> Fold a b # (*) :: Fold a b -> Fold a b -> Fold a b # negate :: Fold a b -> Fold a b # abs :: Fold a b -> Fold a b # signum :: Fold a b -> Fold a b # fromInteger :: Integer -> Fold a b #
Fractional b => Fractional (Fold a b) |
Instance details Defined in Control.Foldl Methods (/) :: Fold a b -> Fold a b -> Fold a b # recip :: Fold a b -> Fold a b # fromRational :: Rational -> Fold a b #

data FoldM (m :: Type -> Type) a b #

Like `Fold`, but monadic.

A '`FoldM` m a b' processes elements of type a and results in a monadic value of type m b.

Constructors

FoldM (x -> a -> m x) (m x) (x -> m b) | `FoldM` `step` `initial` `extract`

#### Instances

Instances details

Functor m => Profunctor (FoldM m) |
Instance details Defined in Control.Foldl Methods dimap :: (a -> b) -> (c -> d) -> FoldM m b c -> FoldM m a d # lmap :: (a -> b) -> FoldM m b c -> FoldM m a c # rmap :: (b -> c) -> FoldM m a b -> FoldM m a c # (#.) :: forall a b c q. Coercible c b => q b c -> FoldM m a b -> FoldM m a c # (.#) :: forall a b c q. Coercible b a => FoldM m b c -> q a b -> FoldM m a c #
Applicative m => Applicative (FoldM m a) |
Instance details Defined in Control.Foldl Methods pure :: a0 -> FoldM m a a0 # (<*>) :: FoldM m a (a0 -> b) -> FoldM m a a0 -> FoldM m a b # liftA2 :: (a0 -> b -> c) -> FoldM m a a0 -> FoldM m a b -> FoldM m a c # (*>) :: FoldM m a a0 -> FoldM m a b -> FoldM m a b # (<*) :: FoldM m a a0 -> FoldM m a b -> FoldM m a a0 #
Functor m => Functor (FoldM m a) |
Instance details Defined in Control.Foldl Methods fmap :: (a0 -> b) -> FoldM m a a0 -> FoldM m a b # (<$) :: a0 -> FoldM m a b -> FoldM m a a0 #
Monad m => Extend (FoldM m a) |
Instance details Defined in Control.Foldl Methods duplicated :: FoldM m a a0 -> FoldM m a (FoldM m a a0) # extended :: (FoldM m a a0 -> b) -> FoldM m a a0 -> FoldM m a b #
(Monoid b, Monad m) => Monoid (FoldM m a b) |
Instance details Defined in Control.Foldl Methods mempty :: FoldM m a b # mappend :: FoldM m a b -> FoldM m a b -> FoldM m a b # mconcat :: [FoldM m a b] -> FoldM m a b #
(Semigroup b, Monad m) => Semigroup (FoldM m a b) |
Instance details Defined in Control.Foldl Methods (<>) :: FoldM m a b -> FoldM m a b -> FoldM m a b # sconcat :: NonEmpty (FoldM m a b) -> FoldM m a b # stimes :: Integral b0 => b0 -> FoldM m a b -> FoldM m a b #
(Monad m, Floating b) => Floating (FoldM m a b) |
Instance details Defined in Control.Foldl Methods pi :: FoldM m a b # exp :: FoldM m a b -> FoldM m a b # log :: FoldM m a b -> FoldM m a b # sqrt :: FoldM m a b -> FoldM m a b # (**) :: FoldM m a b -> FoldM m a b -> FoldM m a b # logBase :: FoldM m a b -> FoldM m a b -> FoldM m a b # sin :: FoldM m a b -> FoldM m a b # cos :: FoldM m a b -> FoldM m a b # tan :: FoldM m a b -> FoldM m a b # asin :: FoldM m a b -> FoldM m a b # acos :: FoldM m a b -> FoldM m a b # atan :: FoldM m a b -> FoldM m a b # sinh :: FoldM m a b -> FoldM m a b # cosh :: FoldM m a b -> FoldM m a b # tanh :: FoldM m a b -> FoldM m a b # asinh :: FoldM m a b -> FoldM m a b # acosh :: FoldM m a b -> FoldM m a b # atanh :: FoldM m a b -> FoldM m a b # log1p :: FoldM m a b -> FoldM m a b # expm1 :: FoldM m a b -> FoldM m a b # log1pexp :: FoldM m a b -> FoldM m a b # log1mexp :: FoldM m a b -> FoldM m a b #
(Monad m, Num b) => Num (FoldM m a b) |
Instance details Defined in Control.Foldl Methods (+) :: FoldM m a b -> FoldM m a b -> FoldM m a b # (-) :: FoldM m a b -> FoldM m a b -> FoldM m a b # (*) :: FoldM m a b -> FoldM m a b -> FoldM m a b # negate :: FoldM m a b -> FoldM m a b # abs :: FoldM m a b -> FoldM m a b # signum :: FoldM m a b -> FoldM m a b # fromInteger :: Integer -> FoldM m a b #
(Monad m, Fractional b) => Fractional (FoldM m a b) |
Instance details Defined in Control.Foldl Methods (/) :: FoldM m a b -> FoldM m a b -> FoldM m a b # recip :: FoldM m a b -> FoldM m a b # fromRational :: Rational -> FoldM m a b #

data Text #

A space efficient, packed, unboxed Unicode text type.

#### Instances

Instances details

Hashable Text |
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Text -> Int # hash :: Text -> Int #
Pretty Text | Automatically converts all newlines to ``line``.
    >>> pretty ("hello\nworld" :: Text)
    hello
    world
Note that ``line`` can be undone by ``group``:
    >>> group (pretty ("hello\nworld" :: Text))
    hello world
Manually use ``hardline`` if you definitely want newlines.
Instance details Defined in Prettyprinter.Internal Methods pretty :: Text -> Doc ann # prettyList :: [Text] -> Doc ann #
type Item Text |
Instance details Defined in Data.Text type Item Text = Char

data UTCTime #

This is the simplest representation of UTC. It consists of the day number, and a time offset from midnight. Note that if a day has a leap second added to it, it will have 86401 seconds.

#### Instances

Instances details

NFData UTCTime |
Instance details Defined in Data.Time.Clock.Internal.UTCTime Methods rnf :: UTCTime -> () #
Data UTCTime |
Instance details Defined in Data.Time.Clock.Internal.UTCTime Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UTCTime -> c UTCTime # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c UTCTime # toConstr :: UTCTime -> Constr # dataTypeOf :: UTCTime -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c UTCTime) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c UTCTime) # gmapT :: (forall b. Data b => b -> b) -> UTCTime -> UTCTime # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UTCTime -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UTCTime -> r # gmapQ :: (forall d. Data d => d -> u) -> UTCTime -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> UTCTime -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> UTCTime -> m UTCTime # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UTCTime -> m UTCTime # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UTCTime -> m UTCTime #
Eq UTCTime |
Instance details Defined in Data.Time.Clock.Internal.UTCTime Methods (==) :: UTCTime -> UTCTime -> Bool # (/=) :: UTCTime -> UTCTime -> Bool #
Ord UTCTime |
Instance details Defined in Data.Time.Clock.Internal.UTCTime Methods compare :: UTCTime -> UTCTime -> Ordering # (<) :: UTCTime -> UTCTime -> Bool # (<=) :: UTCTime -> UTCTime -> Bool # (>) :: UTCTime -> UTCTime -> Bool # (>=) :: UTCTime -> UTCTime -> Bool # max :: UTCTime -> UTCTime -> UTCTime # min :: UTCTime -> UTCTime -> UTCTime #
ISO8601 UTCTime | `yyyy-mm-ddThh:mm:ss[.sss]Z` (ISO 8601:2004(E) sec. 4.3.2 extended format)
Instance details Defined in Data.Time.Format.ISO8601 Methods iso8601Format :: Format UTCTime #

data NominalDiffTime #

This is a length of time, as measured by UTC. It has a precision of 10^-12 s.

Conversion functions such as `fromInteger` and `realToFrac` will treat it as seconds. For example, `(0.010 :: NominalDiffTime)` corresponds to 10 milliseconds.

It has a precision of one picosecond (= 10^-12 s). Enumeration functions will treat it as picoseconds.

It ignores leap-seconds, so it's not necessarily a fixed amount of clock time. For instance, 23:00 UTC + 2 hours of NominalDiffTime = 01:00 UTC (+ 1 day), regardless of whether a leap-second intervened.

#### Instances

Instances details

NFData NominalDiffTime |
Instance details Defined in Data.Time.Clock.Internal.NominalDiffTime Methods rnf :: NominalDiffTime -> () #
Data NominalDiffTime |
Instance details Defined in Data.Time.Clock.Internal.NominalDiffTime Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> NominalDiffTime -> c NominalDiffTime # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c NominalDiffTime # toConstr :: NominalDiffTime -> Constr # dataTypeOf :: NominalDiffTime -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c NominalDiffTime) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NominalDiffTime) # gmapT :: (forall b. Data b => b -> b) -> NominalDiffTime -> NominalDiffTime # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NominalDiffTime -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NominalDiffTime -> r # gmapQ :: (forall d. Data d => d -> u) -> NominalDiffTime -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> NominalDiffTime -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> NominalDiffTime -> m NominalDiffTime # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NominalDiffTime -> m NominalDiffTime # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NominalDiffTime -> m NominalDiffTime #
Enum NominalDiffTime |
Instance details Defined in Data.Time.Clock.Internal.NominalDiffTime Methods succ :: NominalDiffTime -> NominalDiffTime # pred :: NominalDiffTime -> NominalDiffTime # toEnum :: Int -> NominalDiffTime # fromEnum :: NominalDiffTime -> Int # enumFrom :: NominalDiffTime -> [NominalDiffTime] # enumFromThen :: NominalDiffTime -> NominalDiffTime -> [NominalDiffTime] # enumFromTo :: NominalDiffTime -> NominalDiffTime -> [NominalDiffTime] # enumFromThenTo :: NominalDiffTime -> NominalDiffTime -> NominalDiffTime -> [NominalDiffTime] #
Num NominalDiffTime |
Instance details Defined in Data.Time.Clock.Internal.NominalDiffTime Methods (+) :: NominalDiffTime -> NominalDiffTime -> NominalDiffTime # (-) :: NominalDiffTime -> NominalDiffTime -> NominalDiffTime # (*) :: NominalDiffTime -> NominalDiffTime -> NominalDiffTime # negate :: NominalDiffTime -> NominalDiffTime # abs :: NominalDiffTime -> NominalDiffTime # signum :: NominalDiffTime -> NominalDiffTime # fromInteger :: Integer -> NominalDiffTime #
Read NominalDiffTime |
Instance details Defined in Data.Time.Clock.Internal.NominalDiffTime Methods readsPrec :: Int -> ReadS NominalDiffTime # readList :: ReadS [NominalDiffTime] # readPrec :: ReadPrec NominalDiffTime # readListPrec :: ReadPrec [NominalDiffTime] #
Fractional NominalDiffTime |
Instance details Defined in Data.Time.Clock.Internal.NominalDiffTime Methods (/) :: NominalDiffTime -> NominalDiffTime -> NominalDiffTime # recip :: NominalDiffTime -> NominalDiffTime # fromRational :: Rational -> NominalDiffTime #
Real NominalDiffTime |
Instance details Defined in Data.Time.Clock.Internal.NominalDiffTime Methods toRational :: NominalDiffTime -> Rational #
RealFrac NominalDiffTime |
Instance details Defined in Data.Time.Clock.Internal.NominalDiffTime Methods properFraction :: Integral b => NominalDiffTime -> (b, NominalDiffTime) # truncate :: Integral b => NominalDiffTime -> b # round :: Integral b => NominalDiffTime -> b # ceiling :: Integral b => NominalDiffTime -> b # floor :: Integral b => NominalDiffTime -> b #
Show NominalDiffTime |
Instance details Defined in Data.Time.Clock.Internal.NominalDiffTime Methods showsPrec :: Int -> NominalDiffTime -> ShowS # show :: NominalDiffTime -> String # showList :: [NominalDiffTime] -> ShowS #
Eq NominalDiffTime |
Instance details Defined in Data.Time.Clock.Internal.NominalDiffTime Methods (==) :: NominalDiffTime -> NominalDiffTime -> Bool # (/=) :: NominalDiffTime -> NominalDiffTime -> Bool #
Ord NominalDiffTime |
Instance details Defined in Data.Time.Clock.Internal.NominalDiffTime Methods compare :: NominalDiffTime -> NominalDiffTime -> Ordering # (<) :: NominalDiffTime -> NominalDiffTime -> Bool # (<=) :: NominalDiffTime -> NominalDiffTime -> Bool # (>) :: NominalDiffTime -> NominalDiffTime -> Bool # (>=) :: NominalDiffTime -> NominalDiffTime -> Bool # max :: NominalDiffTime -> NominalDiffTime -> NominalDiffTime # min :: NominalDiffTime -> NominalDiffTime -> NominalDiffTime #

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.

#### Instances

Instances details

Show Handle | @since base-4.1.0.0
Instance details Defined in GHC.Internal.IO.Handle.Types Methods showsPrec :: Int -> Handle -> ShowS # show :: Handle -> String # showList :: [Handle] -> ShowS #
Eq Handle | @since base-4.1.0.0
Instance details Defined in GHC.Internal.IO.Handle.Types Methods (==) :: Handle -> Handle -> Bool # (/=) :: Handle -> Handle -> Bool #
InputSource Handle |
Instance details Defined in Data.Streaming.Process.Internal Methods isStdStream :: (Maybe Handle -> IO Handle, Maybe StdStream) #
OutputSink Handle |
Instance details Defined in Data.Streaming.Process.Internal Methods osStdStream :: (Maybe Handle -> IO Handle, Maybe StdStream) #

data ExitCode #

Defines the exit codes that a program can return.

Constructors

ExitSuccess | indicates successful termination;
ExitFailure Int | indicates program failure with an exit code. The exact interpretation of the code is operating-system dependent. In particular, some values may be prohibited (e.g. 0 on a POSIX-compliant system).

#### Instances

Instances details

NFData ExitCode | Since: deepseq-1.4.2.0
Instance details Defined in Control.DeepSeq Methods rnf :: ExitCode -> () #
Exception ExitCode | @since base-4.1.0.0
Instance details Defined in GHC.Internal.IO.Exception Methods toException :: ExitCode -> SomeException # fromException :: SomeException -> Maybe ExitCode # displayException :: ExitCode -> String # backtraceDesired :: ExitCode -> Bool #
Generic ExitCode |
Instance details Defined in GHC.Internal.IO.Exception Associated Types
type Rep ExitCode |
Instance details Defined in GHC.Internal.IO.Exception type Rep ExitCode = D1 ('MetaData "ExitCode" "GHC.Internal.IO.Exception" "ghc-internal" 'False) (C1 ('MetaCons "ExitSuccess" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "ExitFailure" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Int)))
Methods from :: ExitCode -> Rep ExitCode x # to :: Rep ExitCode x -> ExitCode #
Read ExitCode |
Instance details Defined in GHC.Internal.IO.Exception Methods readsPrec :: Int -> ReadS ExitCode # readList :: ReadS [ExitCode] # readPrec :: ReadPrec ExitCode # readListPrec :: ReadPrec [ExitCode] #
Show ExitCode |
Instance details Defined in GHC.Internal.IO.Exception Methods showsPrec :: Int -> ExitCode -> ShowS # show :: ExitCode -> String # showList :: [ExitCode] -> ShowS #
Eq ExitCode |
Instance details Defined in GHC.Internal.IO.Exception Methods (==) :: ExitCode -> ExitCode -> Bool # (/=) :: ExitCode -> ExitCode -> Bool #
Ord ExitCode |
Instance details Defined in GHC.Internal.IO.Exception Methods compare :: ExitCode -> ExitCode -> Ordering # (<) :: ExitCode -> ExitCode -> Bool # (<=) :: ExitCode -> ExitCode -> Bool # (>) :: ExitCode -> ExitCode -> Bool # (>=) :: ExitCode -> ExitCode -> Bool # max :: ExitCode -> ExitCode -> ExitCode # min :: ExitCode -> ExitCode -> ExitCode #
type Rep ExitCode |
Instance details Defined in GHC.Internal.IO.Exception type Rep ExitCode = D1 ('MetaData "ExitCode" "GHC.Internal.IO.Exception" "ghc-internal" 'False) (C1 ('MetaCons "ExitSuccess" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "ExitFailure" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Int)))

class IsString a where #

`IsString` is used in combination with the `-XOverloadedStrings` language extension to convert the literals to different string types.

For example, if you use the text package, you can say

    {-# LANGUAGE OverloadedStrings  #-}

    myText = "hello world" :: Text

Internally, the extension will convert this to the equivalent of

    myText = fromString @Text ("hello world" :: String)

Note: You can use `fromString` in normal code as well, but the usual performance/memory efficiency problems with `String` apply.

Methods

fromString :: String -> a #

#### Instances

Instances details

IsString ByteString | Beware: `fromString` truncates multi-byte characters to octets. e.g. "枯朶に烏のとまりけり秋の暮" becomes �6k�nh~�Q��n�
Instance details Defined in Data.ByteString.Internal.Type Methods fromString :: String -> ByteString #
IsString ByteString | Beware: `fromString` truncates multi-byte characters to octets. e.g. "枯朶に烏のとまりけり秋の暮" becomes �6k�nh~�Q��n�
Instance details Defined in Data.ByteString.Lazy.Internal Methods fromString :: String -> ByteString #
IsString ShortByteString | Beware: `fromString` truncates multi-byte characters to octets. e.g. "枯朶に烏のとまりけり秋の暮" becomes �6k�nh~�Q��n�
Instance details Defined in Data.ByteString.Short.Internal Methods fromString :: String -> ShortByteString #
IsString Doc |
Instance details Defined in Text.PrettyPrint.HughesPJ Methods fromString :: String -> Doc #
IsString CmdSpec | construct a `ShellCommand` from a string literal Since: process-1.2.1.0
Instance details Defined in System.Process.Common Methods fromString :: String -> CmdSpec #
IsString HostPreference |
Instance details Defined in Data.Streaming.Network.Internal Methods fromString :: String -> HostPreference #
IsString Builder | Performs replacement on invalid scalar values:
    >>> :set -XOverloadedStrings
    >>> "\55555" :: Builder
    "\65533"
Instance details Defined in Data.Text.Internal.Builder Methods fromString :: String -> Builder #
IsString Line # |
Instance details Defined in Turtle.Line Methods fromString :: String -> Line #
IsString ArgName # |
Instance details Defined in Turtle.Options Methods fromString :: String -> ArgName #
IsString CommandName # |
Instance details Defined in Turtle.Options Methods fromString :: String -> CommandName #
IsString Description # |
Instance details Defined in Turtle.Options Methods fromString :: String -> Description #
IsString HelpMessage # |
Instance details Defined in Turtle.Options Methods fromString :: String -> HelpMessage #
a ~ Char => IsString (Seq a) | Since: containers-0.5.7
Instance details Defined in Data.Sequence.Internal Methods fromString :: String -> Seq a #
IsString a => IsString (Identity a) | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Data.String Methods fromString :: String -> Identity a #
(IsString a, Hashable a) => IsString (Hashed a) |
Instance details Defined in Data.Hashable.Class Methods fromString :: String -> Hashed a #
IsString a => IsString (Optional a) |
Instance details Defined in Data.Optional Methods fromString :: String -> Optional a #
IsString (Doc a) |
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Methods fromString :: String -> Doc a #
IsString (Doc ann) |
    >>> pretty ("hello\nworld")
    hello
    world
This instance uses the `Pretty` `Text` instance, and uses the same newline to `line` conversion.
Instance details Defined in Prettyprinter.Internal Methods fromString :: String -> Doc ann #
a ~ Text => IsString (Pattern a) # |
Instance details Defined in Turtle.Pattern Methods fromString :: String -> Pattern a #
IsString a => IsString (Shell a) # |
Instance details Defined in Turtle.Shell Methods fromString :: String -> Shell a #
a ~ Char => IsString [a] | `(a ~ Char)` context was introduced in `4.9.0.0` @since base-2.01
Instance details Defined in GHC.Internal.Data.String Methods fromString :: String -> [a] #
a ~ b => IsString (Format a b) # |
Instance details Defined in Turtle.Format Methods fromString :: String -> Format a b #
IsString a => IsString (Const a b) | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Data.String Methods fromString :: String -> Const a b #
IsString a => IsString (Tagged s a) |
Instance details Defined in Data.Tagged Methods fromString :: String -> Tagged s a #

(&) :: a -> (a -> b) -> b infixl 1 #

`&` is a reverse application operator. This provides notational convenience. Its precedence is one higher than that of the forward application operator `$`, which allows `&` to be nested in `$`.

This is a version of ``flip` `id``, where `id` is specialized from `a -> a` to `(a -> b) -> (a -> b)` which by the associativity of `(->)` is `(a -> b) -> a -> b`. flipping this yields `a -> (a -> b) -> b` which is the type signature of `&`

#### Examples

Expand

    >>> 5 & (+1) & show
    "6"

    >>> sqrt $ [1 / n^2 | n <- [1..1000]] & sum & (*6)
    3.1406380562059946

@since base-4.8.0.0

(<&>) :: Functor f => f a -> (a -> b) -> f b infixl 1 #

Flipped version of `<$>`.

    (<&>) = flip fmap

@since base-4.11.0.0

#### Examples

Expand

Apply `(+1)` to a list, a `Just` and a `Right`:

    >>> Just 2 <&> (+1)
    Just 3

    >>> [1,2,3] <&> (+1)
    [2,3,4]

    >>> Right 3 <&> (+1)
    Right 4