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 Patterns, 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

Filesystem.Path.CurrentOS provides FilePath-manipulation utilities

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)
Filesystem.Path.CurrentOS (for the remaining FilePath utilities)

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
optional :: Alternative f => f a -> f (Maybe a)
(<$>) :: Functor f => (a -> b) -> f a -> f b
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]
guard :: Alternative f => Bool -> f ()
join :: Monad m => m (m a) -> m a
mfilter :: MonadPlus m => (a -> Bool) -> m a -> m a
unless :: Applicative f => Bool -> f () -> f ()
replicateM_ :: Applicative m => Int -> m a -> m ()
forever :: Applicative f => f a -> f b
(<=<) :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c
(>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c
msum :: (Foldable t, MonadPlus m) => t (m a) -> m a
void :: Functor f => f a -> f ()
when :: Applicative f => Bool -> f () -> f ()
class (Alternative m, Monad m) => MonadPlus (m :: Type -> Type) where
- mzero :: m a
- mplus :: m a -> m a -> m a
class Monad m => MonadIO (m :: Type -> Type) where
- liftIO :: IO a -> m a
(<>) :: Semigroup a => a -> a -> a
class Semigroup a => Monoid a where
- mempty :: a
- mappend :: a -> a -> a
- mconcat :: [a] -> a
runManaged :: Managed () -> IO ()
with :: Managed a -> (a -> IO r) -> IO r
managed :: (forall r. (a -> IO r) -> IO r) -> Managed a
data Managed a
data FilePath
decodeString :: String -> FilePath
encodeString :: FilePath -> String
fromText :: Text -> FilePath
toText :: FilePath -> Either Text Text
splitExtension :: FilePath -> (FilePath, Maybe Text)
dropExtension :: FilePath -> FilePath
(<.>) :: FilePath -> Text -> FilePath
hasExtension :: FilePath -> Text -> Bool
extension :: FilePath -> Maybe Text
splitDirectories :: FilePath -> [FilePath]
collapse :: FilePath -> FilePath
stripPrefix :: FilePath -> FilePath -> Maybe FilePath
commonPrefix :: [FilePath] -> FilePath
(</>) :: FilePath -> FilePath -> FilePath
relative :: FilePath -> Bool
absolute :: FilePath -> Bool
basename :: FilePath -> FilePath
dirname :: FilePath -> FilePath
filename :: FilePath -> FilePath
parent :: FilePath -> FilePath
directory :: FilePath -> FilePath
root :: FilePath -> FilePath
data Fold a b where
- Fold :: forall a b x. (x -> a -> x) -> x -> (x -> b) -> Fold a b
data FoldM (m :: Type -> Type) a b where
- FoldM :: forall (m :: Type -> Type) a b x. (x -> a -> m x) -> m x -> (x -> m b) -> FoldM m a 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
```
```
(<*>) = ap
```
```
(*>) = (>>)
```

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

Minimal complete definition

pure, ((<*>) | liftA2)

Methods

pure :: a -> f a #

Lift a value.

(<*>) :: 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.

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 <*>.

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

Sequence actions, discarding the value of the first argument.

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

Sequence actions, discarding the value of the second argument.

Instances

Applicative []	Since: base-2.1
Instance details Defined in GHC.Base Methods pure :: a -> [a] # (<>) :: [a -> b] -> [a] -> [b] # liftA2 :: (a -> b -> c) -> [a] -> [b] -> [c] # (>) :: [a] -> [b] -> [b] # (<*) :: [a] -> [b] -> [a] #
Applicative Maybe	Since: base-2.1
Instance details Defined in GHC.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 IO	Since: base-2.1
Instance details Defined in GHC.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 Par1	Since: base-4.9.0.0
Instance details Defined in GHC.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 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 Concurrently
Instance details Defined in Control.Concurrent.Async 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 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 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 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 Option	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods pure :: a -> Option a # (<>) :: Option (a -> b) -> Option a -> Option b # liftA2 :: (a -> b -> c) -> Option a -> Option b -> Option c # (>) :: Option a -> Option b -> Option b # (<*) :: Option a -> Option b -> Option a #
Applicative ZipList	f '<$>' 'ZipList' xs1 '<>' ... '<>' 'ZipList' xsN = 'ZipList' (zipWithN f xs1 ... xsN) where `zipWithN` refers to the `zipWith` function of the appropriate arity (`zipWith`, `zipWith3`, `zipWith4`, ...). For example: (\a b c -> stimes c [a, b]) <$> ZipList "abcd" <> ZipList "567" <> ZipList [1..] = ZipList (zipWith3 (\a b c -> stimes c [a, b]) "abcd" "567" [1..]) = ZipList {getZipList = ["a5","b6b6","c7c7c7"]} Since: base-2.1
Instance details Defined in Control.Applicative Methods pure :: a -> ZipList a # (<>) :: ZipList (a -> b) -> ZipList a -> ZipList b # liftA2 :: (a -> b -> c) -> ZipList a -> ZipList b -> ZipList c # (>) :: ZipList a -> ZipList b -> ZipList b # (<*) :: ZipList a -> ZipList b -> ZipList a #
Applicative Identity	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods pure :: a -> Identity a # (<>) :: Identity (a -> b) -> Identity a -> Identity b # liftA2 :: (a -> b -> c) -> Identity a -> Identity b -> Identity c # (>) :: Identity a -> Identity b -> Identity b # (<*) :: Identity a -> Identity b -> Identity a #
Applicative STM	Since: base-4.8.0.0
Instance details Defined in GHC.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 First	Since: base-4.8.0.0
Instance details Defined in Data.Monoid 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.8.0.0
Instance details Defined in Data.Monoid 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 Dual	Since: base-4.8.0.0
Instance details Defined in 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 Sum	Since: base-4.8.0.0
Instance details Defined in 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 Product	Since: base-4.8.0.0
Instance details Defined in 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 Down	Since: base-4.11.0.0
Instance details Defined in 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 ReadPrec	Since: base-4.6.0.0
Instance details Defined in 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 ReadP	Since: base-4.6.0.0
Instance details Defined in 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 NonEmpty	Since: base-4.9.0.0
Instance details Defined in GHC.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 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 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 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 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 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 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 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 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 Id
Instance details Defined in Data.Vector.Fusion.Util Methods pure :: a -> Id a # (<>) :: Id (a -> b) -> Id a -> Id b # liftA2 :: (a -> b -> c) -> Id a -> Id b -> Id c # (>) :: Id a -> Id b -> Id b # (<*) :: Id a -> Id b -> Id a #
Applicative Box
Instance details Defined in Data.Vector.Fusion.Util Methods pure :: a -> Box a # (<>) :: Box (a -> b) -> Box a -> Box b # liftA2 :: (a -> b -> c) -> Box a -> Box b -> Box c # (>) :: Box a -> Box b -> Box b # (<*) :: Box a -> Box b -> Box a #
Applicative P	Since: base-4.5.0.0
Instance details Defined in 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 Pattern Source #
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 Source #
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 (Either e)	Since: base-3.0
Instance details Defined in 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.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 #
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.1*
Instance details Defined in GHC.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) #
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 #
Arrow a => Applicative (ArrowMonad a)	Since: base-4.6.0.0
Instance details Defined in Control.Arrow Methods pure :: a0 -> ArrowMonad a a0 # (<>) :: ArrowMonad a (a0 -> b) -> ArrowMonad a a0 -> ArrowMonad a b # liftA2 :: (a0 -> b -> c) -> ArrowMonad a a0 -> ArrowMonad a b -> ArrowMonad a c # (>) :: ArrowMonad a a0 -> ArrowMonad a b -> ArrowMonad a b # (<*) :: ArrowMonad a a0 -> ArrowMonad a b -> ArrowMonad a a0 #
Applicative (Proxy :: Type -> Type)	Since: base-4.7.0.0
Instance details Defined in Data.Proxy Methods pure :: a -> Proxy a # (<>) :: Proxy (a -> b) -> Proxy a -> Proxy b # liftA2 :: (a -> b -> c) -> Proxy a -> Proxy b -> Proxy c # (>) :: Proxy a -> Proxy b -> Proxy b # (<*) :: Proxy a -> Proxy b -> Proxy 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 #
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 f => Applicative (Rec1 f)	Since: base-4.9.0.0
Instance details Defined in GHC.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 #
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 #
Monoid m => Applicative (Const m :: Type -> Type)	Since: base-2.0.1
Instance details Defined in 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 (Ap f)	Since: base-4.12.0.0
Instance details Defined in Data.Monoid Methods pure :: a -> Ap f a # (<>) :: Ap f (a -> b) -> Ap f a -> Ap f b # liftA2 :: (a -> b -> c) -> Ap f a -> Ap f b -> Ap f c # (>) :: Ap f a -> Ap f b -> Ap f b # (<*) :: Ap f a -> Ap f b -> Ap f a #
Applicative f => Applicative (Alt f)	Since: base-4.8.0.0
Instance details Defined in 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 #
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 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 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 #
(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 (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, Monad m) => Applicative (ErrorT e m)
Instance details Defined in Control.Monad.Trans.Error Methods pure :: a -> ErrorT e m a # (<>) :: ErrorT e m (a -> b) -> ErrorT e m a -> ErrorT e m b # liftA2 :: (a -> b -> c) -> ErrorT e m a -> ErrorT e m b -> ErrorT e m c # (>) :: ErrorT e m a -> ErrorT e m b -> ErrorT e m b # (<*) :: ErrorT e m a -> ErrorT e m b -> ErrorT e 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 #
(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 #
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 (Mag a b)
Instance details Defined in Data.Biapplicative Methods pure :: a0 -> Mag a b a0 # (<>) :: Mag a b (a0 -> b0) -> Mag a b a0 -> Mag a b b0 # liftA2 :: (a0 -> b0 -> c) -> Mag a b a0 -> Mag a b b0 -> Mag a b c # (>) :: Mag a b a0 -> Mag a b b0 -> Mag a b b0 # (<*) :: Mag a b a0 -> Mag a b b0 -> Mag a b a0 #
Applicative ((->) a :: Type -> Type)	Since: base-2.1
Instance details Defined in GHC.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 #
Monoid c => Applicative (K1 i c :: Type -> Type)	Since: base-4.12.0.0
Instance details Defined in GHC.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 f, Applicative g) => Applicative (f :*: g)	Since: base-4.9.0.0
Instance details Defined in GHC.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 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 (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 #
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 #
Applicative f => Applicative (M1 i c f)	Since: base-4.9.0.0
Instance details Defined in GHC.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 #
(Applicative f, Applicative g) => Applicative (f :.: g)	Since: base-4.9.0.0
Instance details Defined in GHC.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 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 #
(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 #

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

One or none.

(<$>) :: 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)

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 []
```

Minimal complete definition

empty, (<|>)

Methods

empty :: f a #

The identity of <|>

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

An associative binary operation

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

One or more.

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

Zero or more.

Instances

Alternative []	Since: base-2.1
Instance details Defined in GHC.Base Methods empty :: [a] # (<\|>) :: [a] -> [a] -> [a] # some :: [a] -> [[a]] # many :: [a] -> [[a]] #
Alternative Maybe	Since: base-2.1
Instance details Defined in GHC.Base Methods empty :: Maybe a # (<\|>) :: Maybe a -> Maybe a -> Maybe a # some :: Maybe a -> Maybe [a] # many :: Maybe a -> Maybe [a] #
Alternative IO	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods empty :: IO a # (<\|>) :: IO a -> IO a -> IO a # some :: IO a -> IO [a] # many :: IO a -> IO [a] #
Alternative Concurrently
Instance details Defined in Control.Concurrent.Async Methods empty :: Concurrently a # (<\|>) :: Concurrently a -> Concurrently a -> Concurrently a # some :: Concurrently a -> Concurrently [a] # many :: Concurrently a -> Concurrently [a] #
Alternative Option	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods empty :: Option a # (<\|>) :: Option a -> Option a -> Option a # some :: Option a -> Option [a] # many :: Option a -> Option [a] #
Alternative ZipList	Since: base-4.11.0.0
Instance details Defined in Control.Applicative Methods empty :: ZipList a # (<\|>) :: ZipList a -> ZipList a -> ZipList a # some :: ZipList a -> ZipList [a] # many :: ZipList a -> ZipList [a] #
Alternative STM	Since: base-4.8.0.0
Instance details Defined in GHC.Conc.Sync Methods empty :: STM a # (<\|>) :: STM a -> STM a -> STM a # some :: STM a -> STM [a] # many :: STM a -> STM [a] #
Alternative ReadPrec	Since: base-4.6.0.0
Instance details Defined in Text.ParserCombinators.ReadPrec Methods empty :: ReadPrec a # (<\|>) :: ReadPrec a -> ReadPrec a -> ReadPrec a # some :: ReadPrec a -> ReadPrec [a] # many :: ReadPrec a -> ReadPrec [a] #
Alternative ReadP	Since: base-4.6.0.0
Instance details Defined in Text.ParserCombinators.ReadP Methods empty :: ReadP a # (<\|>) :: ReadP a -> ReadP a -> ReadP a # some :: ReadP a -> ReadP [a] # many :: ReadP a -> ReadP [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 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 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 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 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 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 P	Since: base-4.5.0.0
Instance details Defined in Text.ParserCombinators.ReadP Methods empty :: P a # (<\|>) :: P a -> P a -> P a # some :: P a -> P [a] # many :: P a -> P [a] #
Alternative Pattern Source #
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 Source #
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 (U1 :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods empty :: U1 a # (<\|>) :: U1 a -> U1 a -> U1 a # some :: U1 a -> U1 [a] # many :: U1 a -> U1 [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] #
ArrowPlus a => Alternative (ArrowMonad a)	Since: base-4.6.0.0
Instance details Defined in Control.Arrow Methods empty :: ArrowMonad a a0 # (<\|>) :: ArrowMonad a a0 -> ArrowMonad a a0 -> ArrowMonad a a0 # some :: ArrowMonad a a0 -> ArrowMonad a [a0] # many :: ArrowMonad a a0 -> ArrowMonad a [a0] #
Alternative (Proxy :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Proxy Methods empty :: Proxy a # (<\|>) :: Proxy a -> Proxy a -> Proxy a # some :: Proxy a -> Proxy [a] # many :: Proxy a -> Proxy [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] #
Alternative f => Alternative (Rec1 f)	Since: base-4.9.0.0
Instance details Defined in GHC.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] #
(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 (Ap f)	Since: base-4.12.0.0
Instance details Defined in Data.Monoid Methods empty :: Ap f a # (<\|>) :: Ap f a -> Ap f a -> Ap f a # some :: Ap f a -> Ap f [a] # many :: Ap f a -> Ap f [a] #
Alternative f => Alternative (Alt f)	Since: base-4.8.0.0
Instance details Defined in 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] #
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] #
(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] #
(Functor m, Monad m, Error e) => Alternative (ErrorT e m)
Instance details Defined in Control.Monad.Trans.Error Methods empty :: ErrorT e m a # (<\|>) :: ErrorT e m a -> ErrorT e m a -> ErrorT e m a # some :: ErrorT e m a -> ErrorT e m [a] # many :: ErrorT e m a -> ErrorT e 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] #
(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 g) => Alternative (f :*: g)	Since: base-4.9.0.0
Instance details Defined in GHC.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 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 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] #
Alternative f => Alternative (M1 i c f)	Since: base-4.9.0.0
Instance details Defined in GHC.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] #
(Alternative f, Applicative g) => Alternative (f :.: g)	Since: base-4.9.0.0
Instance details Defined in GHC.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] #
(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] #

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 signaling an error in an error monad and conditionally rejecting the current choice in an Alternative-based parser.

As an example of signaling 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)

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.

Examples

Expand

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.

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

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

The reverse of when.

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

Like replicateM, but discards the result.

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, Handles, 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

(<=<) :: 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

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

Left-to-right composition of Kleisli arrows.

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

The sum of a collection of actions, generalizing concat. As of base 4.8.0.0, msum is just asum, specialized to MonadPlus.

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

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

Conditional execution of Applicative expressions. For example,

when debug (putStrLn "Debugging")

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

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

MonadPlus []	Since: base-2.1
Instance details Defined in GHC.Base Methods mzero :: [a] # mplus :: [a] -> [a] -> [a] #
MonadPlus Maybe	Since: base-2.1
Instance details Defined in GHC.Base Methods mzero :: Maybe a # mplus :: Maybe a -> Maybe a -> Maybe a #
MonadPlus IO	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods mzero :: IO a # mplus :: IO a -> IO a -> IO a #
MonadPlus Option	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods mzero :: Option a # mplus :: Option a -> Option a -> Option a #
MonadPlus STM	Since: base-4.3.0.0
Instance details Defined in GHC.Conc.Sync Methods mzero :: STM a # mplus :: STM a -> STM a -> STM a #
MonadPlus ReadPrec	Since: base-2.1
Instance details Defined in Text.ParserCombinators.ReadPrec Methods mzero :: ReadPrec a # mplus :: ReadPrec a -> ReadPrec a -> ReadPrec a #
MonadPlus ReadP	Since: base-2.1
Instance details Defined in Text.ParserCombinators.ReadP Methods mzero :: ReadP a # mplus :: ReadP a -> ReadP a -> ReadP a #
MonadPlus Seq
Instance details Defined in Data.Sequence.Internal Methods mzero :: Seq a # mplus :: Seq a -> Seq a -> Seq a #
MonadPlus Optional
Instance details Defined in Data.Optional Methods mzero :: Optional a # mplus :: Optional a -> Optional a -> Optional a #
MonadPlus ReadM
Instance details Defined in Options.Applicative.Types Methods mzero :: ReadM a # mplus :: ReadM a -> ReadM a -> ReadM a #
MonadPlus SmallArray
Instance details Defined in Data.Primitive.SmallArray Methods mzero :: SmallArray a # mplus :: SmallArray a -> SmallArray a -> SmallArray a #
MonadPlus Array
Instance details Defined in Data.Primitive.Array Methods mzero :: Array a # mplus :: Array a -> Array a -> Array a #
MonadPlus P	Since: base-2.1
Instance details Defined in Text.ParserCombinators.ReadP Methods mzero :: P a # mplus :: P a -> P a -> P a #
MonadPlus Pattern Source #
Instance details Defined in Turtle.Pattern Methods mzero :: Pattern a # mplus :: Pattern a -> Pattern a -> Pattern a #
MonadPlus Shell Source #
Instance details Defined in Turtle.Shell Methods mzero :: Shell a # mplus :: Shell a -> Shell a -> Shell a #
MonadPlus (U1 :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods mzero :: U1 a # mplus :: U1 a -> U1 a -> U1 a #
(ArrowApply a, ArrowPlus a) => MonadPlus (ArrowMonad a)	Since: base-4.6.0.0
Instance details Defined in Control.Arrow Methods mzero :: ArrowMonad a a0 # mplus :: ArrowMonad a a0 -> ArrowMonad a a0 -> ArrowMonad a a0 #
MonadPlus (Proxy :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Proxy Methods mzero :: Proxy a # mplus :: Proxy a -> Proxy a -> Proxy 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 (Rec1 f)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods mzero :: Rec1 f a # mplus :: Rec1 f a -> Rec1 f a -> Rec1 f a #
MonadPlus f => MonadPlus (Ap f)	Since: base-4.12.0.0
Instance details Defined in Data.Monoid Methods mzero :: Ap f a # mplus :: Ap f a -> Ap f a -> Ap f a #
MonadPlus f => MonadPlus (Alt f)	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods mzero :: Alt f a # mplus :: Alt f a -> Alt f a -> Alt f 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 #
(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 #
(Monad m, Error e) => MonadPlus (ErrorT e m)
Instance details Defined in Control.Monad.Trans.Error Methods mzero :: ErrorT e m a # mplus :: ErrorT e m a -> ErrorT e m a -> ErrorT e 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 #
(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 f, MonadPlus g) => MonadPlus (f :*: g)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods mzero :: (f :: g) a # mplus :: (f :: g) a -> (f :: g) a -> (f :: g) 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 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 f => MonadPlus (M1 i c f)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods mzero :: M1 i c f a # mplus :: M1 i c f a -> M1 i c f a -> M1 i c f 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 #

class Monad m => MonadIO (m :: Type -> Type) where #

Monads in which IO computations may be embedded. Any monad built by applying a sequence of monad transformers to the IO monad will be an instance of this class.

Instances should satisfy the following laws, which state that liftIO is a transformer of monads:

```
liftIO . return = return
```

liftIO (m >>= f) = liftIO m >>= (liftIO . f)

Methods

liftIO :: IO a -> m a #

Lift a computation from the IO monad.

Instances

MonadIO IO	Since: base-4.9.0.0
Instance details Defined in Control.Monad.IO.Class Methods liftIO :: IO a -> IO a #
MonadIO Q
Instance details Defined in Language.Haskell.TH.Syntax Methods liftIO :: IO a -> Q a #
MonadIO Managed
Instance details Defined in Control.Monad.Managed Methods liftIO :: IO a -> Managed a #
MonadIO Shell Source #
Instance details Defined in Turtle.Shell Methods liftIO :: IO a -> Shell a #
MonadIO m => MonadIO (MaybeT m)
Instance details Defined in Control.Monad.Trans.Maybe Methods liftIO :: IO a -> MaybeT m a #
MonadIO m => MonadIO (IdentityT m)
Instance details Defined in Control.Monad.Trans.Identity Methods liftIO :: IO a -> IdentityT m a #
MonadIO m => MonadIO (ExceptT e m)
Instance details Defined in Control.Monad.Trans.Except Methods liftIO :: IO a -> ExceptT e m a #
(Error e, MonadIO m) => MonadIO (ErrorT e m)
Instance details Defined in Control.Monad.Trans.Error Methods liftIO :: IO a -> ErrorT e m a #
MonadIO m => MonadIO (StateT s m)
Instance details Defined in Control.Monad.Trans.State.Lazy Methods liftIO :: IO a -> StateT s m a #
MonadIO m => MonadIO (StateT s m)
Instance details Defined in Control.Monad.Trans.State.Strict Methods liftIO :: IO a -> StateT s m a #
(Monoid w, MonadIO m) => MonadIO (WriterT w m)
Instance details Defined in Control.Monad.Trans.Writer.Lazy Methods liftIO :: IO a -> WriterT w m a #
(Monoid w, MonadIO m) => MonadIO (WriterT w m)
Instance details Defined in Control.Monad.Trans.Writer.Strict Methods liftIO :: IO a -> WriterT w m a #
MonadIO m => MonadIO (ContT r m)
Instance details Defined in Control.Monad.Trans.Cont Methods liftIO :: IO a -> ContT r m a #
MonadIO m => MonadIO (ReaderT r m)
Instance details Defined in Control.Monad.Trans.Reader Methods liftIO :: IO a -> ReaderT r m a #
(Monoid w, MonadIO m) => MonadIO (RWST r w s m)
Instance details Defined in Control.Monad.Trans.RWS.Lazy Methods liftIO :: IO a -> RWST r w s m a #
(Monoid w, MonadIO m) => MonadIO (RWST r w s m)
Instance details Defined in Control.Monad.Trans.RWS.Strict Methods liftIO :: IO a -> RWST r w s m a #

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

An associative operation.

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 laws:

```
x <> mempty = x
```
```
mempty <> x = x
```
x <> (y <> z) = (x <> y) <> z (Semigroup law)
```
mconcat = foldr '(<>)' mempty
```

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 newtypes 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

Methods

mempty :: a #

Identity of mappend

mappend :: a -> a -> a #

An associative operation

NOTE: This method is redundant and has the default implementation mappend = '(<>)' since base-4.11.0.0.

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.

Instances

Monoid Ordering	Since: base-2.1
Instance details Defined in GHC.Base Methods mempty :: Ordering # mappend :: Ordering -> Ordering -> Ordering # mconcat :: [Ordering] -> Ordering #
Monoid ()	Since: base-2.1
Instance details Defined in GHC.Base Methods mempty :: () # mappend :: () -> () -> () # mconcat :: [()] -> () #
Monoid Doc
Instance details Defined in Text.PrettyPrint.ANSI.Leijen.Internal Methods mempty :: Doc # mappend :: Doc -> Doc -> Doc # mconcat :: [Doc] -> Doc #
Monoid All	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods mempty :: All # mappend :: All -> All -> All # mconcat :: [All] -> All #
Monoid Any	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods mempty :: Any # mappend :: Any -> Any -> Any # mconcat :: [Any] -> Any #
Monoid ByteString
Instance details Defined in Data.ByteString.Internal Methods mempty :: ByteString # mappend :: ByteString -> ByteString -> ByteString # mconcat :: [ByteString] -> ByteString #
Monoid Builder
Instance details Defined in Data.ByteString.Builder.Internal Methods mempty :: Builder # mappend :: Builder -> Builder -> Builder # mconcat :: [Builder] -> Builder #
Monoid IntSet
Instance details Defined in Data.IntSet.Internal Methods mempty :: IntSet # mappend :: IntSet -> IntSet -> IntSet # mconcat :: [IntSet] -> IntSet #
Monoid PrefsMod
Instance details Defined in Options.Applicative.Builder Methods mempty :: PrefsMod # mappend :: PrefsMod -> PrefsMod -> PrefsMod # mconcat :: [PrefsMod] -> PrefsMod #
Monoid ParseError
Instance details Defined in Options.Applicative.Types Methods mempty :: ParseError # mappend :: ParseError -> ParseError -> ParseError # mconcat :: [ParseError] -> ParseError #
Monoid Completer
Instance details Defined in Options.Applicative.Types Methods mempty :: Completer # mappend :: Completer -> Completer -> Completer # mconcat :: [Completer] -> Completer #
Monoid Doc
Instance details Defined in Text.PrettyPrint.HughesPJ Methods mempty :: Doc # mappend :: Doc -> Doc -> Doc # mconcat :: [Doc] -> Doc #
Monoid ByteArray
Instance details Defined in Data.Primitive.ByteArray Methods mempty :: ByteArray # mappend :: ByteArray -> ByteArray -> ByteArray # mconcat :: [ByteArray] -> ByteArray #
Monoid Line Source #
Instance details Defined in Turtle.Line Methods mempty :: Line # mappend :: Line -> Line -> Line # mconcat :: [Line] -> Line #
Monoid [a]	Since: base-2.1
Instance details Defined in GHC.Base Methods mempty :: [a] # mappend :: [a] -> [a] -> [a] # mconcat :: [[a]] -> [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 `ee = e` and `es = s = se` for all `s ∈ S`." Since 4.11.0: constraint on inner `a` value generalised from `Monoid` to `Semigroup`. Since: base-2.1*
Instance details Defined in GHC.Base Methods mempty :: Maybe a # mappend :: Maybe a -> Maybe a -> Maybe a # mconcat :: [Maybe a] -> Maybe a #
Monoid a => Monoid (IO a)	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods mempty :: IO a # mappend :: IO a -> IO a -> IO a # mconcat :: [IO a] -> IO a #
Monoid p => Monoid (Par1 p)	Since: base-4.12.0.0
Instance details Defined in GHC.Generics Methods mempty :: Par1 p # mappend :: Par1 p -> Par1 p -> Par1 p # mconcat :: [Par1 p] -> Par1 p #
(Semigroup a, Monoid a) => Monoid (Concurrently a)	Since: async-2.1.0
Instance details Defined in Control.Concurrent.Async Methods mempty :: Concurrently a # mappend :: Concurrently a -> Concurrently a -> Concurrently a # mconcat :: [Concurrently a] -> Concurrently 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 #
(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 #
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 #
Semigroup a => Monoid (Option a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods mempty :: Option a # mappend :: Option a -> Option a -> Option a # mconcat :: [Option a] -> Option a #
Monoid a => Monoid (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods mempty :: Identity a # mappend :: Identity a -> Identity a -> Identity a # mconcat :: [Identity a] -> Identity a #
Monoid (First a)	Since: base-2.1
Instance details Defined in Data.Monoid Methods mempty :: First a # mappend :: First a -> First a -> First a # mconcat :: [First a] -> First a #
Monoid (Last a)	Since: base-2.1
Instance details Defined in Data.Monoid Methods mempty :: Last a # mappend :: Last a -> Last a -> Last a # mconcat :: [Last a] -> Last a #
Monoid a => Monoid (Dual a)	Since: base-2.1
Instance details Defined in 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.1
Instance details Defined in Data.Semigroup.Internal Methods mempty :: Endo a # mappend :: Endo a -> Endo a -> Endo a # mconcat :: [Endo a] -> Endo a #
Num a => Monoid (Sum a)	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods mempty :: Sum a # mappend :: Sum a -> Sum a -> Sum a # mconcat :: [Sum a] -> Sum a #
Num a => Monoid (Product a)	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods mempty :: Product a # mappend :: Product a -> Product a -> Product a # mconcat :: [Product a] -> Product a #
Monoid a => Monoid (Down a)	Since: base-4.11.0.0
Instance details Defined in Data.Ord Methods mempty :: Down a # mappend :: Down a -> Down a -> Down a # mconcat :: [Down a] -> Down a #
Num a => Monoid (Colour a)
Instance details Defined in Data.Colour.Internal Methods mempty :: Colour a # mappend :: Colour a -> Colour a -> Colour a # mconcat :: [Colour a] -> Colour a #
Num a => Monoid (AlphaColour a)
Instance details Defined in Data.Colour.Internal Methods mempty :: AlphaColour a # mappend :: AlphaColour a -> AlphaColour a -> AlphaColour a # mconcat :: [AlphaColour a] -> AlphaColour a #
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 #
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 (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 #
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 #
PrimUnlifted a => Monoid (UnliftedArray a)	Since: primitive-0.6.4.0
Instance details Defined in Data.Primitive.UnliftedArray Methods mempty :: UnliftedArray a # mappend :: UnliftedArray a -> UnliftedArray a -> UnliftedArray a # mconcat :: [UnliftedArray a] -> UnliftedArray 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 (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 #
(Hashable a, Eq a) => Monoid (HashSet a)
Instance details Defined in Data.HashSet Methods mempty :: HashSet a # mappend :: HashSet a -> HashSet a -> HashSet a # mconcat :: [HashSet a] -> HashSet a #
Prim a => Monoid (Vector a)
Instance details Defined in Data.Vector.Primitive Methods mempty :: Vector a # mappend :: Vector a -> Vector a -> Vector a # mconcat :: [Vector a] -> Vector a #
Monoid a => Monoid (Pattern a) Source #
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) Source #
Instance details Defined in Turtle.Shell Methods mempty :: Shell a # mappend :: Shell a -> Shell a -> Shell a # mconcat :: [Shell a] -> Shell 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 #
Monoid b => Monoid (a -> b)	Since: base-2.1
Instance details Defined in GHC.Base Methods mempty :: a -> b # mappend :: (a -> b) -> (a -> b) -> a -> b # mconcat :: [a -> b] -> a -> b #
Monoid (U1 p)	Since: base-4.12.0.0
Instance details Defined in GHC.Generics Methods mempty :: U1 p # mappend :: U1 p -> U1 p -> U1 p # mconcat :: [U1 p] -> U1 p #
(Monoid a, Monoid b) => Monoid (a, b)	Since: base-2.1
Instance details Defined in GHC.Base Methods mempty :: (a, b) # mappend :: (a, b) -> (a, b) -> (a, b) # mconcat :: [(a, b)] -> (a, b) #
Monoid (Proxy s)	Since: base-4.7.0.0
Instance details Defined in Data.Proxy Methods mempty :: Proxy s # mappend :: Proxy s -> Proxy s -> Proxy s # mconcat :: [Proxy s] -> Proxy s #
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 #
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 #
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 (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)
Instance details Defined in Data.HashMap.Base Methods mempty :: HashMap k v # mappend :: HashMap k v -> HashMap k v -> HashMap k v # mconcat :: [HashMap k v] -> HashMap k v #
Monoid (f p) => Monoid (Rec1 f p)	Since: base-4.12.0.0
Instance details Defined in GHC.Generics Methods mempty :: Rec1 f p # mappend :: Rec1 f p -> Rec1 f p -> Rec1 f p # mconcat :: [Rec1 f p] -> Rec1 f p #
(Monoid a, Monoid b, Monoid c) => Monoid (a, b, c)	Since: base-2.1
Instance details Defined in GHC.Base Methods mempty :: (a, b, c) # mappend :: (a, b, c) -> (a, b, c) -> (a, b, c) # mconcat :: [(a, b, c)] -> (a, b, c) #
Monoid a => Monoid (Const a b)	Since: base-4.9.0.0
Instance details Defined in 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 #
(Applicative f, Monoid a) => Monoid (Ap f a)	Since: base-4.12.0.0
Instance details Defined in Data.Monoid Methods mempty :: Ap f a # mappend :: Ap f a -> Ap f a -> Ap f a # mconcat :: [Ap f a] -> Ap f a #
Alternative f => Monoid (Alt f a)	Since: base-4.8.0.0
Instance details Defined in 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 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 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 c => Monoid (K1 i c p)	Since: base-4.12.0.0
Instance details Defined in GHC.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 (f p), Monoid (g p)) => Monoid ((f :*: g) p)	Since: base-4.12.0.0
Instance details Defined in GHC.Generics Methods mempty :: (f :: g) p # mappend :: (f :: g) p -> (f :: g) p -> (f :: g) p # mconcat :: [(f :: g) p] -> (f :: g) p #
(Monoid a, Monoid b, Monoid c, Monoid d) => Monoid (a, b, c, d)	Since: base-2.1
Instance details Defined in GHC.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 p) => Monoid (M1 i c f p)	Since: base-4.12.0.0
Instance details Defined in GHC.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 (f (g p)) => Monoid ((f :.: g) p)	Since: base-4.12.0.0
Instance details Defined in GHC.Generics Methods mempty :: (f :.: g) p # mappend :: (f :.: g) p -> (f :.: g) p -> (f :.: g) p # mconcat :: [(f :.: g) p] -> (f :.: g) p #
(Monoid a, Monoid b, Monoid c, Monoid d, Monoid e) => Monoid (a, b, c, d, e)	Since: base-2.1
Instance details Defined in GHC.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) #

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

Run a Managed computation, enforcing that no acquired resources leak

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.

managed :: (forall r. (a -> IO r) -> IO r) -> Managed a #

Build a Managed value

data Managed a #

A managed resource that you acquire using with

Instances

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 # fail :: String -> Managed a #
Functor Managed
Instance details Defined in Control.Monad.Managed Methods fmap :: (a -> b) -> Managed a -> Managed b # (<$) :: a -> Managed b -> 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 #
MonadIO Managed
Instance details Defined in Control.Monad.Managed Methods liftIO :: IO a -> Managed a #
MonadManaged Managed
Instance details Defined in Control.Monad.Managed Methods using :: 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 #
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 #
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 #
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 #
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 #

data FilePath #

Instances

Eq FilePath
Instance details Defined in Filesystem.Path.Internal Methods (==) :: FilePath -> FilePath -> Bool # (/=) :: FilePath -> FilePath -> Bool #
Data FilePath
Instance details Defined in Filesystem.Path.Internal Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FilePath -> c FilePath # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c FilePath # toConstr :: FilePath -> Constr # dataTypeOf :: FilePath -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c FilePath) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FilePath) # gmapT :: (forall b. Data b => b -> b) -> FilePath -> FilePath # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FilePath -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FilePath -> r # gmapQ :: (forall d. Data d => d -> u) -> FilePath -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> FilePath -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> FilePath -> m FilePath # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FilePath -> m FilePath # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FilePath -> m FilePath #
Ord FilePath
Instance details Defined in Filesystem.Path.Internal Methods compare :: FilePath -> FilePath -> Ordering # (<) :: FilePath -> FilePath -> Bool # (<=) :: FilePath -> FilePath -> Bool # (>) :: FilePath -> FilePath -> Bool # (>=) :: FilePath -> FilePath -> Bool # max :: FilePath -> FilePath -> FilePath # min :: FilePath -> FilePath -> FilePath #
NFData FilePath
Instance details Defined in Filesystem.Path.Internal Methods rnf :: FilePath -> () #

decodeString :: String -> FilePath #

Attempt to parse a FilePath from a string suitable for use with functions in System.IO. Do not use this function for parsing human‐readable paths, as the character set decoding is platform‐dependent. For converting human‐readable text to a FilePath, use fromText.

Since: 0.3.1

encodeString :: FilePath -> String #

Attempt to convert a FilePath to a string suitable for use with functions in System.IO. The contents of this string are platform‐dependent, and are not guaranteed to be human‐readable. For converting FilePaths to a human‐readable format, use toText.

Since: 0.3.1

fromText :: Text -> FilePath #

Convert human‐readable text into a FilePath.

This function ignores the user’s locale, and assumes all file paths are encoded in UTF8. If you need to create file paths with an unusual or obscure encoding, encode them manually and then use decode.

Since: 0.2

toText :: FilePath -> Either Text Text #

Attempt to convert a FilePath to human‐readable text.

If the path is decoded successfully, the result is a Right containing the decoded text. Successfully decoded text can be converted back to the original path using fromText.

If the path cannot be decoded, the result is a Left containing an approximation of the original path. If displayed to the user, this value should be accompanied by some warning that the path has an invalid encoding. Approximated text cannot be converted back to the original path.

This function ignores the user’s locale, and assumes all file paths are encoded in UTF8. If you need to display file paths with an unusual or obscure encoding, use encode and then decode them manually.

Since: 0.2

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

splitExtension p = (dropExtension p, extension p)

dropExtension :: FilePath -> FilePath #

Remove a FilePath’s last extension.

(<.>) :: FilePath -> Text -> FilePath #

An alias for addExtension.

hasExtension :: FilePath -> Text -> Bool #

Get whether a FilePath’s last extension is the predicate.

extension :: FilePath -> Maybe Text #

Get a FilePath’s last extension, or Nothing if it has no extensions.

splitDirectories :: FilePath -> [FilePath] #

expand a FilePath into a list of the root name, directories, and file name

Since: 0.4.7

collapse :: FilePath -> FilePath #

Remove intermediate "." and ".." directories from a path.

collapse "/foo/./bar" == "/foo/bar"
collapse "/foo/bar/../baz" == "/foo/baz"
collapse "/foo/../../bar" == "/bar"
collapse "./foo/bar" == "./foo/baz"

Note that if any of the elements are symbolic links, collapse may change which file the path resolves to.

Since: 0.2

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

Remove a prefix from a path.

stripPrefix "/foo/" "/foo/bar/baz.txt" == Just "bar/baz.txt"
stripPrefix "/foo/" "/bar/baz.txt" == Nothing

This function operates on logical prefixes, rather than by counting characters. The prefix "/foo/bar/baz" is interpreted the path ("/foo/bar/", "baz"), and will be stripped accordingly:

stripPrefix "/foo/bar/baz" "/foo/bar/baz/qux" == Nothing
stripPrefix "/foo/bar/baz" "/foo/bar/baz.txt" == Just ".txt"

Since: 0.4.1

commonPrefix :: [FilePath] -> FilePath #

Find the greatest common prefix between a list of FilePaths.

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

An alias for append.

relative :: FilePath -> Bool #

Test whether a path is relative.

absolute :: FilePath -> Bool #

Test whether a path is absolute.

basename :: FilePath -> FilePath #

Retrieve a FilePath’s basename component.

basename "foo/bar.txt" == "bar"

dirname :: FilePath -> FilePath #

Retrieve a FilePath’s directory name. This is only the file name of the directory, not its full path.

dirname "foo/bar/baz.txt" == "bar"
dirname "/" == ""

Since: 0.4.1

filename :: FilePath -> FilePath #

Retrieve a FilePath’s filename component.

filename "foo/bar.txt" == "bar.txt"

parent :: FilePath -> FilePath #

Retrieves the FilePath’s parent directory.

directory :: FilePath -> FilePath #

Retrieves the FilePath’s directory. If the path is already a directory, it is returned unchanged.

root :: FilePath -> FilePath #

Retrieves the FilePath’s root.

data Fold a b where #

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 :: forall a b x. (x -> a -> x) -> x -> (x -> b) -> Fold a b

Fold step initial extract

Instances

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) #
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 # (#.) :: Coercible c b => q b c -> Fold a b -> Fold a c # (.#) :: Coercible b a => Fold b c -> q a b -> Fold a c #
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 #
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 #
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 #
Semigroupoid Fold
Instance details Defined in Control.Foldl Methods o :: Fold j k1 -> Fold i j -> Fold i k1 #
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 #
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 #
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 #
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 #
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 #

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

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 :: forall (m :: Type -> Type) a b x. (x -> a -> m x) -> m x -> (x -> m b) -> FoldM m a b

FoldM step initial extract

Instances

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 # (#.) :: Coercible c b => q b c -> FoldM m a b -> FoldM m a c # (.#) :: Coercible b a => FoldM m b c -> q a b -> FoldM m a c #
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 #
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 #
(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, 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 #
(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 #
(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 #
(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 #

data Text #

A space efficient, packed, unboxed Unicode text type.

Instances

Hashable Text
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Text -> Int # hash :: Text -> Int #
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

Eq UTCTime
Instance details Defined in Data.Time.Clock.Internal.UTCTime Methods (==) :: UTCTime -> UTCTime -> Bool # (/=) :: UTCTime -> UTCTime -> Bool #
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 :: (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 #
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 #
NFData UTCTime
Instance details Defined in Data.Time.Clock.Internal.UTCTime Methods rnf :: UTCTime -> () #
ParseTime UTCTime
Instance details Defined in Data.Time.Format.Parse Methods buildTime :: TimeLocale -> [(Char, String)] -> Maybe UTCTime #

data NominalDiffTime #

This is a length of time, as measured by UTC. Conversion functions will treat it as seconds. It has a precision of 10^-12 s. 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

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] #
Eq NominalDiffTime
Instance details Defined in Data.Time.Clock.Internal.NominalDiffTime Methods (==) :: NominalDiffTime -> NominalDiffTime -> Bool # (/=) :: NominalDiffTime -> NominalDiffTime -> Bool #
Fractional NominalDiffTime
Instance details Defined in Data.Time.Clock.Internal.NominalDiffTime Methods (/) :: NominalDiffTime -> NominalDiffTime -> NominalDiffTime # recip :: NominalDiffTime -> NominalDiffTime # fromRational :: Rational -> 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 :: (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 #
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 #
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 #
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 #
NFData NominalDiffTime
Instance details Defined in Data.Time.Clock.Internal.NominalDiffTime Methods rnf :: 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

Eq Handle	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Handle.Types Methods (==) :: Handle -> Handle -> Bool # (/=) :: Handle -> Handle -> Bool #
Show Handle	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Handle.Types Methods showsPrec :: Int -> Handle -> ShowS # show :: Handle -> String # showList :: [Handle] -> ShowS #

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

Eq ExitCode
Instance details Defined in GHC.IO.Exception Methods (==) :: ExitCode -> ExitCode -> Bool # (/=) :: ExitCode -> ExitCode -> Bool #
Ord ExitCode
Instance details Defined in GHC.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 #
Read ExitCode
Instance details Defined in GHC.IO.Exception Methods readsPrec :: Int -> ReadS ExitCode # readList :: ReadS [ExitCode] # readPrec :: ReadPrec ExitCode # readListPrec :: ReadPrec [ExitCode] #
Show ExitCode
Instance details Defined in GHC.IO.Exception Methods showsPrec :: Int -> ExitCode -> ShowS # show :: ExitCode -> String # showList :: [ExitCode] -> ShowS #
Generic ExitCode
Instance details Defined in GHC.IO.Exception Associated Types type Rep ExitCode :: Type -> Type # Methods from :: ExitCode -> Rep ExitCode x # to :: Rep ExitCode x -> ExitCode #
Exception ExitCode	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: ExitCode -> SomeException # fromException :: SomeException -> Maybe ExitCode # displayException :: ExitCode -> String #
type Rep ExitCode
Instance details Defined in GHC.IO.Exception type Rep ExitCode = D1 (MetaData "ExitCode" "GHC.IO.Exception" "base" 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 #

Class for string-like datastructures; used by the overloaded string extension (-XOverloadedStrings in GHC).

Methods

fromString :: String -> a #

Instances

IsString Doc
Instance details Defined in Text.PrettyPrint.ANSI.Leijen.Internal Methods fromString :: String -> Doc #
IsString ByteString
Instance details Defined in Data.ByteString.Internal Methods fromString :: String -> ByteString #
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 Line Source #
Instance details Defined in Turtle.Line Methods fromString :: String -> Line #
IsString HelpMessage Source #
Instance details Defined in Turtle.Options Methods fromString :: String -> HelpMessage #
IsString Description Source #
Instance details Defined in Turtle.Options Methods fromString :: String -> Description #
IsString CommandName Source #
Instance details Defined in Turtle.Options Methods fromString :: String -> CommandName #
IsString ArgName Source #
Instance details Defined in Turtle.Options Methods fromString :: String -> ArgName #
a ~ Char => IsString [a]	`(a ~ Char)` context was introduced in `4.9.0.0` Since: base-2.1
Instance details Defined in Data.String Methods fromString :: String -> [a] #
IsString a => IsString (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.String Methods fromString :: String -> Identity a #
a ~ Char => IsString (Seq a)	Since: containers-0.5.7
Instance details Defined in Data.Sequence.Internal Methods fromString :: String -> Seq 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 #
a ~ Text => IsString (Pattern a) Source #
Instance details Defined in Turtle.Pattern Methods fromString :: String -> Pattern a #
IsString a => IsString (Shell a) Source #
Instance details Defined in Turtle.Shell Methods fromString :: String -> Shell a #
a ~ b => IsString (Format a b) Source #
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 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 $.

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

Since: base-4.8.0.0

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

Flipped version of <$>.

(<&>) = flip fmap

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

Since: 4.11.0.0