Safe Haskell  SafeInferred 

Language  Haskell2010 
See Turtle.Tutorial to learn how to use this library or Turtle.Prelude for a quickstart guide.
Here is the recommended way to import this library:
{# LANGUAGE OverloadedStrings #} import Turtle import Prelude hiding (FilePath)
This module reexports the rest of the library and also reexports useful
modules from base
:
Turtle.Format provides typesafe string formatting
Turtle.Pattern provides Pattern
s, which are like more powerful regular
expressions
Turtle.Shell provides a Shell
abstraction for building streaming,
exceptionsafe pipelines
Turtle.Prelude provides a library of Unixlike utilities to get you started with basic shelllike programming within Haskell
Control.Applicative provides two classes:
Applicative
, which works withFold
,Pattern
,Managed
, andShell
Alternative
, which works withPattern
andShell
Control.Monad provides two classes:
Control.Monad.IO.Class provides one class:
Data.Monoid provides one class:
Control.Monad.Managed.Safe provides Managed
resources
Additionally, you might also want to import the following modules qualified:
 Options.Applicative from
optparseapplicative
for commandline option parsing  Control.Foldl (for predefined folds)
 Control.Foldl.Text (for
Text
specific folds)  Data.Text (for
Text
manipulation utilities)  Data.Text.IO (for reading and writing
Text
)
Synopsis
 module Turtle.Format
 module Turtle.Pattern
 module Turtle.Options
 module Turtle.Shell
 module Turtle.Line
 module Turtle.Prelude
 class Functor f => Applicative (f :: Type > Type) where
 optional :: Alternative f => f a > f (Maybe a)
 (<$>) :: Functor f => (a > b) > f a > f b
 class Applicative f => Alternative (f :: Type > Type) where
 guard :: Alternative f => Bool > f ()
 join :: Monad m => m (m a) > m a
 unless :: Applicative f => Bool > f () > f ()
 replicateM_ :: Applicative m => Int > m a > m ()
 mfilter :: MonadPlus m => (a > Bool) > m a > m a
 forever :: Applicative f => f a > f b
 (>=>) :: Monad m => (a > m b) > (b > m c) > a > m c
 (<=<) :: Monad m => (b > m c) > (a > m b) > a > m c
 msum :: (Foldable t, MonadPlus m) => t (m a) > m a
 void :: Functor f => f a > f ()
 class (Alternative m, Monad m) => MonadPlus (m :: Type > Type) where
 when :: Applicative f => Bool > f () > f ()
 class Monad m => MonadIO (m :: Type > Type) where
 (<>) :: Semigroup a => a > a > a
 class Semigroup a => Monoid a where
 runManaged :: Managed () > IO ()
 with :: Managed a > (a > IO r) > IO r
 managed :: MonadManaged m => (forall r. (a > IO r) > IO r) > m a
 data Managed a
 type FilePath = String
 (</>) :: FilePath > FilePath > FilePath
 isRelative :: FilePath > Bool
 isAbsolute :: FilePath > Bool
 hasExtension :: FilePath > Bool
 dropExtension :: FilePath > FilePath
 (<.>) :: FilePath > String > FilePath
 toText :: FilePath > Either Text Text
 fromText :: Text > FilePath
 decodeString :: String > FilePath
 encodeString :: FilePath > String
 commonPrefix :: [FilePath] > FilePath
 stripPrefix :: FilePath > FilePath > Maybe FilePath
 collapse :: FilePath > FilePath
 root :: FilePath > FilePath
 parent :: FilePath > FilePath
 directory :: FilePath > FilePath
 filename :: FilePath > FilePath
 dirname :: FilePath > FilePath
 basename :: FilePath > String
 absolute :: FilePath > Bool
 relative :: FilePath > Bool
 splitDirectories :: FilePath > [FilePath]
 extension :: FilePath > Maybe String
 splitExtension :: FilePath > (String, Maybe String)
 splitExtensions :: FilePath > (String, [String])
 data Fold a b = Fold (x > a > x) x (x > b)
 data FoldM (m :: Type > Type) a b = FoldM (x > a > m x) (m x) (x > m b)
 data Text
 data UTCTime
 data NominalDiffTime
 data Handle
 data ExitCode
 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
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:
As a consequence of these laws, the Functor
instance for f
will satisfy
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
(which implies that pure
and <*>
satisfy the applicative functor laws).
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.
Example
Used in combination with (
, <$>
)(
can be used to build a record.<*>
)
>>>
data MyState = MyState {arg1 :: Foo, arg2 :: Bar, arg3 :: Baz}
>>>
produceFoo :: Applicative f => f Foo
>>>
produceBar :: Applicative f => f Bar
>>>
produceBaz :: Applicative f => f Baz
>>>
mkState :: Applicative f => f MyState
>>>
mkState = MyState <$> produceFoo <*> produceBar <*> produceBaz
liftA2 :: (a > b > c) > f a > f b > f c #
Lift a binary function to actions.
Some functors support an implementation of liftA2
that is more
efficient than the default one. In particular, if fmap
is an
expensive operation, it is likely better to use liftA2
than to
fmap
over the structure and then use <*>
.
This became a typeclass method in 4.10.0.0. Prior to that, it was
a function defined in terms of <*>
and fmap
.
Example
>>>
liftA2 (,) (Just 3) (Just 5)
Just (3,5)
(*>) :: f a > f b > f b infixl 4 #
Sequence actions, discarding the value of the first argument.
Examples
If used in conjunction with the Applicative instance for Maybe
,
you can chain Maybe computations, with a possible "early return"
in case of Nothing
.
>>>
Just 2 *> Just 3
Just 3
>>>
Nothing *> Just 3
Nothing
Of course a more interesting use case would be to have effectful computations instead of just returning pure values.
>>>
import Data.Char
>>>
import Text.ParserCombinators.ReadP
>>>
let p = string "my name is " *> munch1 isAlpha <* eof
>>>
readP_to_S p "my name is Simon"
[("Simon","")]
(<*) :: f a > f b > f a infixl 4 #
Sequence actions, discarding the value of the second argument.
Instances
Applicative Concurrently  
Defined in Control.Concurrent.Async 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 ZipList  f <$> ZipList xs1 <*> ... <*> ZipList xsN = ZipList (zipWithN f xs1 ... xsN) where (\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: base2.1 
Applicative Complex  Since: base4.9.0.0 
Applicative Identity  Since: base4.8.0.0 
Applicative First  Since: base4.8.0.0 
Applicative Last  Since: base4.8.0.0 
Applicative Down  Since: base4.11.0.0 
Applicative First  Since: base4.9.0.0 
Applicative Last  Since: base4.9.0.0 
Applicative Max  Since: base4.9.0.0 
Applicative Min  Since: base4.9.0.0 
Applicative Dual  Since: base4.8.0.0 
Applicative Product  Since: base4.8.0.0 
Applicative Sum  Since: base4.8.0.0 
Applicative STM  Since: base4.8.0.0 
Applicative Par1  Since: base4.9.0.0 
Applicative P  Since: base4.5.0.0 
Applicative ReadP  Since: base4.6.0.0 
Applicative ReadPrec  Since: base4.6.0.0 
Applicative Put  
Applicative Seq  Since: containers0.5.4 
Applicative Tree  
Applicative IO  Since: base2.1 
Applicative Managed  
Applicative Optional  
Applicative Parser  
Applicative ParserM  
Applicative ParserResult  
Defined in Options.Applicative.Types pure :: a > ParserResult a # (<*>) :: ParserResult (a > b) > ParserResult a > ParserResult b # liftA2 :: (a > b > c) > ParserResult a > ParserResult b > ParserResult c # (*>) :: ParserResult a > ParserResult b > ParserResult b # (<*) :: ParserResult a > ParserResult b > ParserResult a #  
Applicative ReadM  
Applicative Q  
Applicative Pattern Source #  
Applicative Shell Source #  
Applicative Id  
Applicative Stream  
Applicative NonEmpty  Since: base4.9.0.0 
Applicative Maybe  Since: base2.1 
Applicative Solo  Since: base4.15 
Applicative []  Since: base2.1 
Monad m => Applicative (WrappedMonad m)  Since: base2.1 
Defined in Control.Applicative 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: base4.6.0.0 
Defined in Control.Arrow 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 (Either e)  Since: base3.0 
Applicative (Proxy :: Type > Type)  Since: base4.7.0.0 
Applicative (U1 :: Type > Type)  Since: base4.9.0.0 
Applicative (Fold a)  
(Functor m, Monad m) => Applicative (MaybeT m)  
Monoid a => Applicative ((,) a)  For tuples, the ("hello ", (+15)) <*> ("world!", 2002) ("hello world!",2017) Since: base2.1 
Arrow a => Applicative (WrappedArrow a b)  Since: base2.1 
Defined in Control.Applicative 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 #  
Applicative m => Applicative (Kleisli m a)  Since: base4.14.0.0 
Defined in Control.Arrow  
Monoid m => Applicative (Const m :: Type > Type)  Since: base2.0.1 
Applicative f => Applicative (Ap f)  Since: base4.12.0.0 
Applicative f => Applicative (Alt f)  Since: base4.8.0.0 
Applicative f => Applicative (Rec1 f)  Since: base4.9.0.0 
Applicative (Mag a b)  
Biapplicative p => Applicative (Join p)  
(Applicative f, Monad f) => Applicative (WhenMissing f x)  Equivalent to Since: containers0.5.9 
Defined in Data.IntMap.Internal pure :: a > WhenMissing f x a # (<*>) :: WhenMissing f x (a > b) > WhenMissing f x a > WhenMissing f x b # liftA2 :: (a > b > c) > WhenMissing f x a > WhenMissing f x b > WhenMissing f x c # (*>) :: WhenMissing f x a > WhenMissing f x b > WhenMissing f x b # (<*) :: WhenMissing f x a > WhenMissing f x b > WhenMissing f x a #  
Applicative m => Applicative (FoldM m a)  
Applicative (Tagged s)  
(Functor m, Monad m) => Applicative (ErrorT e m)  
Defined in Control.Monad.Trans.Error  
(Functor m, Monad m) => Applicative (ExceptT e m)  
Defined in Control.Monad.Trans.Except  
Applicative m => Applicative (IdentityT m)  
Defined in Control.Monad.Trans.Identity  
Applicative m => Applicative (ReaderT r m)  
Defined in Control.Monad.Trans.Reader  
(Functor m, Monad m) => Applicative (StateT s m)  
Defined in Control.Monad.Trans.State.Lazy  
(Functor m, Monad m) => Applicative (StateT s m)  
Defined in Control.Monad.Trans.State.Strict  
(Monoid w, Applicative m) => Applicative (WriterT w m)  
Defined in Control.Monad.Trans.Writer.Lazy  
(Monoid w, Applicative m) => Applicative (WriterT w m)  
Defined in Control.Monad.Trans.Writer.Strict  
(Monoid a, Monoid b) => Applicative ((,,) a b)  Since: base4.14.0.0 
(Applicative f, Applicative g) => Applicative (Product f g)  Since: base4.9.0.0 
Defined in Data.Functor.Product  
(Applicative f, Applicative g) => Applicative (f :*: g)  Since: base4.9.0.0 
Monoid c => Applicative (K1 i c :: Type > Type)  Since: base4.12.0.0 
(Monad f, Applicative f) => Applicative (WhenMatched f x y)  Equivalent to Since: containers0.5.9 
Defined in Data.IntMap.Internal 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 Since: containers0.5.9 
Defined in Data.Map.Internal 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)  
(Monoid a, Monoid b, Monoid c) => Applicative ((,,,) a b c)  Since: base4.14.0.0 
Defined in GHC.Base  
Applicative ((>) r)  Since: base2.1 
(Applicative f, Applicative g) => Applicative (Compose f g)  Since: base4.9.0.0 
Defined in Data.Functor.Compose  
(Applicative f, Applicative g) => Applicative (f :.: g)  Since: base4.9.0.0 
Applicative f => Applicative (M1 i c f)  Since: base4.9.0.0 
(Monad f, Applicative f) => Applicative (WhenMatched f k x y)  Equivalent to Since: containers0.5.9 
Defined in Data.Map.Internal 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)  
Defined in Control.Monad.Trans.RWS.Lazy  
(Monoid w, Functor m, Monad m) => Applicative (RWST r w s m)  
Defined in Control.Monad.Trans.RWS.Strict 
optional :: Alternative f => f a > f (Maybe a) #
One or none.
It is useful for modelling any computation that is allowed to fail.
Examples
Using the Alternative
instance of Control.Monad.Except, the following functions:
>>>
import Control.Monad.Except
>>>
canFail = throwError "it failed" :: Except String Int
>>>
final = return 42 :: Except String Int
Can be combined by allowing the first function to fail:
>>>
runExcept $ canFail *> final
Left "it failed">>>
runExcept $ optional canFail *> final
Right 42
(<$>) :: 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
Convert from a
to a Maybe
Int
using Maybe
String
show
:
>>>
show <$> Nothing
Nothing>>>
show <$> Just 3
Just "3"
Convert from an
to an
Either
Int
Int
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:
The identity of <>
(<>) :: f a > f a > f a infixl 3 #
An associative binary operation
One or more.
Zero or more.
Instances
guard :: Alternative f => Bool > f () #
Conditional failure of Alternative
computations. Defined by
guard True =pure
() guard False =empty
Examples
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
otherwise. For example:Just
(x `div`
y)
>>>
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.
'
' can be understood as the join
bssdo
expression
do bs < bss bs
Examples
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
unless :: Applicative f => Bool > f () > f () #
The reverse of when
.
replicateM_ :: Applicative m => Int > m a > m () #
forever :: Applicative f => f a > f b #
Repeat an action indefinitely.
Examples
A common use of forever
is to process input from network sockets,
Handle
s, and channels
(e.g. MVar
and
Chan
).
For example, here is how we might implement an echo
server, using
forever
both to listen for client connections on a network socket
and to echo client input on client connection handles:
echoServer :: Socket > IO () echoServer socket =forever
$ do client < accept socketforkFinally
(echo client) (\_ > hClose client) where echo :: Handle > IO () echo client =forever
$ hGetLine client >>= hPutStrLn client
Note that "forever" isn't necessarily nonterminating.
If the action is in a
and shortcircuits after some number of iterations.
then MonadPlus
actually returns forever
mzero
, effectively shortcircuiting its caller.
(>=>) :: Monad m => (a > m b) > (b > m c) > a > m c infixr 1 #
Lefttoright composition of Kleisli arrows.
'(bs
' can be understood as the >=>
cs) ado
expression
do b < bs a cs b
void :: Functor f => f a > f () #
discards or ignores the result of evaluation, such
as the return value of an void
valueIO
action.
Examples
Replace the contents of a
with unit:Maybe
Int
>>>
void Nothing
Nothing>>>
void (Just 3)
Just ()
Replace the contents of an
with unit, resulting in an Either
Int
Int
: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
class (Alternative m, Monad m) => MonadPlus (m :: Type > Type) where #
Monads that also support choice and failure.
Nothing
The identity of mplus
. It should also satisfy the equations
mzero >>= f = mzero v >> mzero = mzero
The default definition is
mzero = empty
An associative operation. The default definition is
mplus = (<>
)
Instances
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 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:
Lift a computation from the IO
monad.
This allows us to run IO computations in any monadic stack, so long as it supports these kinds of operations
(i.e. IO
is the base monad for the stack).
Example
import Control.Monad.Trans.State  from the "transformers" library printState :: Show s => StateT s IO () printState = do state < get liftIO $ print state
Had we omitted
, we would have ended up with this error:liftIO
• Couldn't match type ‘IO’ with ‘StateT s IO’ Expected type: StateT s IO () Actual type: IO ()
The important part here is the mismatch between StateT s IO ()
and
.IO
()
Luckily, we know of a function that takes an
and returns an IO
a(m a)
:
,
enabling us to run the program and see the expected results:liftIO
> evalStateT printState "hello" "hello" > evalStateT printState 3 3
Instances
(<>) :: Semigroup a => a > a > a infixr 6 #
An associative operation.
>>>
[1,2,3] <> [4,5,6]
[1,2,3,4,5,6]
class Semigroup a => Monoid a where #
The class of monoids (types with an associative binary operation that has an identity). Instances should satisfy the following:
 Right identity
x
<>
mempty
= x Left identity
mempty
<>
x = x Associativity
x
(<>
(y<>
z) = (x<>
y)<>
zSemigroup
law) Concatenation
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 newtype
s and make those instances
of Monoid
, e.g. Sum
and Product
.
NOTE: Semigroup
is a superclass of Monoid
since base4.11.0.0.
Identity of mappend
>>>
"Hello world" <> mempty
"Hello world"
An associative operation
NOTE: This method is redundant and has the default
implementation
since base4.11.0.0.
Should it be implemented manually, since mappend
= (<>
)mappend
is a synonym for
(<>
), it is expected that the two functions are defined the same
way. In a future GHC release mappend
will be removed from Monoid
.
Fold a list using the monoid.
For most types, the default definition for mconcat
will be
used, but the function is included in the class definition so
that an optimized version can be provided for specific types.
>>>
mconcat ["Hello", " ", "Haskell", "!"]
"Hello Haskell!"
Instances
Monoid All  Since: base2.1 
Monoid Any  Since: base2.1 
Monoid Builder  
Monoid ByteString  
Defined in Data.ByteString.Internal mempty :: ByteString # mappend :: ByteString > ByteString > ByteString # mconcat :: [ByteString] > ByteString #  
Monoid ByteString  
Defined in Data.ByteString.Lazy.Internal mempty :: ByteString # mappend :: ByteString > ByteString > ByteString # mconcat :: [ByteString] > ByteString #  
Monoid ShortByteString  
Defined in Data.ByteString.Short.Internal mappend :: ShortByteString > ShortByteString > ShortByteString # mconcat :: [ShortByteString] > ShortByteString #  
Monoid IntSet  
Monoid ByteArray  
Monoid Ordering  Since: base2.1 
Monoid PrefsMod  
Monoid Completer  
Monoid ParseError  
Defined in Options.Applicative.Types mempty :: ParseError # mappend :: ParseError > ParseError > ParseError # mconcat :: [ParseError] > ParseError #  
Monoid Doc  
Monoid AnsiStyle 

Monoid Line Source #  
Monoid ()  Since: base2.1 
(Semigroup a, Monoid a) => Monoid (Concurrently a)  Since: async2.1.0 
Defined in Control.Concurrent.Async mempty :: Concurrently a # mappend :: Concurrently a > Concurrently a > Concurrently a # mconcat :: [Concurrently a] > Concurrently a #  
Monoid a => Monoid (Identity a)  Since: base4.9.0.0 
Monoid (First a)  Since: base2.1 
Monoid (Last a)  Since: base2.1 
Monoid a => Monoid (Down a)  Since: base4.11.0.0 
(Ord a, Bounded a) => Monoid (Max a)  Since: base4.9.0.0 
(Ord a, Bounded a) => Monoid (Min a)  Since: base4.9.0.0 
Monoid m => Monoid (WrappedMonoid m)  Since: base4.9.0.0 
Defined in Data.Semigroup mempty :: WrappedMonoid m # mappend :: WrappedMonoid m > WrappedMonoid m > WrappedMonoid m # mconcat :: [WrappedMonoid m] > WrappedMonoid m #  
Monoid a => Monoid (Dual a)  Since: base2.1 
Monoid (Endo a)  Since: base2.1 
Num a => Monoid (Product a)  Since: base2.1 
Num a => Monoid (Sum a)  Since: base2.1 
Monoid p => Monoid (Par1 p)  Since: base4.12.0.0 
Num a => Monoid (AlphaColour a)  
Defined in Data.Colour.Internal mempty :: AlphaColour a # mappend :: AlphaColour a > AlphaColour a > AlphaColour a # mconcat :: [AlphaColour a] > AlphaColour a #  
Num a => Monoid (Colour a)  
Monoid (IntMap a)  
Monoid (Seq a)  
Monoid (MergeSet a)  
Ord a => Monoid (Set a)  
Monoid a => Monoid (IO a)  Since: base4.9.0.0 
Monoid a => Monoid (Managed a)  
Monoid a => Monoid (Optional a)  
Monoid (InfoMod a)  
Monoid (DefaultProp a)  
Defined in Options.Applicative.Builder.Internal mempty :: DefaultProp a # mappend :: DefaultProp a > DefaultProp a > DefaultProp a # mconcat :: [DefaultProp a] > DefaultProp a #  
Monoid (Doc a)  
Monoid (Doc ann) 

Monoid a => Monoid (Q a)  Since: templatehaskell2.17.0.0 
Monoid a => Monoid (Pattern a) Source #  
Monoid a => Monoid (Shell a) Source #  
(Hashable a, Eq a) => Monoid (HashSet a)  \(O(n+m)\) To obtain good performance, the smaller set must be presented as the first argument. Examples

Semigroup a => Monoid (Maybe a)  Lift a semigroup into Since 4.11.0: constraint on inner Since: base2.1 
Monoid a => Monoid (a)  Since: base4.15 
Monoid [a]  Since: base2.1 
Monoid (Proxy s)  Since: base4.7.0.0 
Monoid (U1 p)  Since: base4.12.0.0 
Ord k => Monoid (Map k v)  
Monad m => Monoid (EndoM m a)  
Monoid b => Monoid (Fold a b)  
Monoid (Mod f a)  
(Eq k, Hashable k) => Monoid (HashMap k v)  If a key occurs in both maps, the mapping from the first will be the mapping in the result. Examples

Monoid b => Monoid (a > b)  Since: base2.1 
(Monoid a, Monoid b) => Monoid (a, b)  Since: base2.1 
Monoid a => Monoid (Const a b)  Since: base4.9.0.0 
(Applicative f, Monoid a) => Monoid (Ap f a)  Since: base4.12.0.0 
Alternative f => Monoid (Alt f a)  Since: base4.8.0.0 
Monoid (f p) => Monoid (Rec1 f p)  Since: base4.12.0.0 
(Monoid b, Monad m) => Monoid (FoldM m a b)  
(Semigroup a, Monoid a) => Monoid (Tagged s a)  
(Monoid a, Monoid b, Monoid c) => Monoid (a, b, c)  Since: base2.1 
(Monoid (f a), Monoid (g a)) => Monoid (Product f g a)  Since: base4.16.0.0 
(Monoid (f p), Monoid (g p)) => Monoid ((f :*: g) p)  Since: base4.12.0.0 
Monoid c => Monoid (K1 i c p)  Since: base4.12.0.0 
(Monoid a, Monoid b, Monoid c, Monoid d) => Monoid (a, b, c, d)  Since: base2.1 
Monoid (f (g a)) => Monoid (Compose f g a)  Since: base4.16.0.0 
Monoid (f (g p)) => Monoid ((f :.: g) p)  Since: base4.12.0.0 
Monoid (f p) => Monoid (M1 i c f p)  Since: base4.12.0.0 
(Monoid a, Monoid b, Monoid c, Monoid d, Monoid e) => Monoid (a, b, c, d, e)  Since: base2.1 
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.
A managed resource that you acquire using with
Instances
File and directory names are values of type String
, whose precise
meaning is operating system dependent. Files can be opened, yielding a
handle which can then be used to operate on the contents of that file.
(</>) :: FilePath > FilePath > FilePath infixr 5 #
Combine two paths with a path separator.
If the second path starts with a path separator or a drive letter, then it returns the second.
The intention is that readFile (dir
will access the same file as
</>
file)setCurrentDirectory dir; readFile file
.
Posix: "/directory" </> "file.ext" == "/directory/file.ext" Windows: "/directory" </> "file.ext" == "/directory\\file.ext" "directory" </> "/file.ext" == "/file.ext" Valid x => (takeDirectory x </> takeFileName x) `equalFilePath` x
Combined:
Posix: "/" </> "test" == "/test" Posix: "home" </> "bob" == "home/bob" Posix: "x:" </> "foo" == "x:/foo" Windows: "C:\\foo" </> "bar" == "C:\\foo\\bar" Windows: "home" </> "bob" == "home\\bob"
Not combined:
Posix: "home" </> "/bob" == "/bob" Windows: "home" </> "C:\\bob" == "C:\\bob"
Not combined (tricky):
On Windows, if a filepath starts with a single slash, it is relative to the
root of the current drive. In [1], this is (confusingly) referred to as an
absolute path.
The current behavior of </>
is to never combine these forms.
Windows: "home" </> "/bob" == "/bob" Windows: "home" </> "\\bob" == "\\bob" Windows: "C:\\home" </> "\\bob" == "\\bob"
On Windows, from [1]: "If a file name begins with only a disk designator
but not the backslash after the colon, it is interpreted as a relative path
to the current directory on the drive with the specified letter."
The current behavior of </>
is to never combine these forms.
Windows: "D:\\foo" </> "C:bar" == "C:bar" Windows: "C:\\foo" </> "C:bar" == "C:bar"
isRelative :: FilePath > Bool #
Is a path relative, or is it fixed to the root?
Windows: isRelative "path\\test" == True Windows: isRelative "c:\\test" == False Windows: isRelative "c:test" == True Windows: isRelative "c:\\" == False Windows: isRelative "c:/" == False Windows: isRelative "c:" == True Windows: isRelative "\\\\foo" == False Windows: isRelative "\\\\?\\foo" == False Windows: isRelative "\\\\?\\UNC\\foo" == False Windows: isRelative "/foo" == True Windows: isRelative "\\foo" == True Posix: isRelative "test/path" == True Posix: isRelative "/test" == False Posix: isRelative "/" == False
According to [1]:
 "A UNC name of any format [is never relative]."
 "You cannot use the "\?" prefix with a relative path."
isAbsolute :: FilePath > Bool #
not . isRelative
isAbsolute x == not (isRelative x)
hasExtension :: FilePath > Bool #
Does the given filename have an extension?
hasExtension "/directory/path.ext" == True hasExtension "/directory/path" == False null (takeExtension x) == not (hasExtension x)
dropExtension :: FilePath > FilePath #
Remove last extension, and the "." preceding it.
dropExtension "/directory/path.ext" == "/directory/path" dropExtension x == fst (splitExtension x)
(<.>) :: FilePath > String > FilePath infixr 7 #
Add an extension, even if there is already one there, equivalent to addExtension
.
"/directory/path" <.> "ext" == "/directory/path.ext" "/directory/path" <.> ".ext" == "/directory/path.ext"
commonPrefix :: [FilePath] > FilePath Source #
Find the greatest common prefix between a list of FilePath
s
collapse :: FilePath > FilePath Source #
Deprecated: Use System.FilePath.normalise instead
Normalise a path
absolute :: FilePath > Bool Source #
Deprecated: Use System.FilePath.isAbsolute instead
Test whether a path is absolute
relative :: FilePath > Bool Source #
Deprecated: Use System.FilePath.isRelative instead
Test whether a path is relative
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.
Fold (x > a > x) x (x > b) 

Instances
Choice Fold  
Costrong Fold  
Profunctor Fold  
Defined in Control.Foldl  
Cosieve Fold []  
Defined in Control.Foldl  
Semigroupoid Fold  
Applicative (Fold a)  
Functor (Fold a)  
Comonad (Fold a)  
Extend (Fold a)  
Monoid b => Monoid (Fold a b)  
Semigroup b => Semigroup (Fold a b)  
Floating b => Floating (Fold a b)  
Defined in Control.Foldl 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 # 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 #  
Num b => Num (Fold a b)  
Fractional b => Fractional (Fold a b)  
data FoldM (m :: Type > Type) a b #
Like Fold
, but monadic.
A 'FoldM
m a b' processes elements of type a and
results in a monadic value of type m b.
FoldM (x > a > m x) (m x) (x > m b) 

Instances
Functor m => Profunctor (FoldM m)  
Defined in Control.Foldl dimap :: (a > b) > (c > d) > FoldM m b c > FoldM m a d # lmap :: (a > b) > FoldM m b c > FoldM m a c # rmap :: (b > c) > FoldM m a b > FoldM m a c # (#.) :: forall a b c q. Coercible c b => q b c > FoldM m a b > FoldM m a c # (.#) :: forall a b c q. Coercible b a => FoldM m b c > q a b > FoldM m a c #  
Applicative m => Applicative (FoldM m a)  
Functor m => Functor (FoldM m a)  
Monad m => Extend (FoldM m a)  
(Monoid b, Monad m) => Monoid (FoldM m a b)  
(Semigroup b, Monad m) => Semigroup (FoldM m a b)  
(Monad m, Floating b) => Floating (FoldM m a b)  
Defined in Control.Foldl 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 #  
(Monad m, Num b) => Num (FoldM m a b)  
Defined in Control.Foldl (+) :: FoldM m a b > FoldM m a b > FoldM m a b # () :: FoldM m a b > FoldM m a b > FoldM m a b # (*) :: FoldM m a b > FoldM m a b > FoldM m a b # negate :: FoldM m a b > FoldM m a b # abs :: FoldM m a b > FoldM m a b # signum :: FoldM m a b > FoldM m a b # fromInteger :: Integer > FoldM m a b #  
(Monad m, Fractional b) => Fractional (FoldM m a b)  
A space efficient, packed, unboxed Unicode text type.
Instances
Hashable Text  
Defined in Data.Hashable.Class  
Pretty Text  Automatically converts all newlines to
Note that
Manually use 
Defined in Prettyprinter.Internal  
type Item Text  
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
Data UTCTime  
Defined in Data.Time.Clock.Internal.UTCTime gfoldl :: (forall d b. Data d => c (d > b) > d > c b) > (forall g. g > c g) > UTCTime > c UTCTime # gunfold :: (forall b r. Data b => c (b > r) > c r) > (forall r. r > c r) > Constr > c UTCTime # toConstr :: UTCTime > Constr # dataTypeOf :: UTCTime > DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) > Maybe (c UTCTime) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) > Maybe (c UTCTime) # gmapT :: (forall b. Data b => b > b) > UTCTime > UTCTime # gmapQl :: (r > r' > r) > r > (forall d. Data d => d > r') > UTCTime > r # gmapQr :: forall r r'. (r' > r > r) > r > (forall d. Data d => d > r') > UTCTime > r # gmapQ :: (forall d. Data d => d > u) > UTCTime > [u] # gmapQi :: Int > (forall d. Data d => d > u) > UTCTime > u # gmapM :: Monad m => (forall d. Data d => d > m d) > UTCTime > m UTCTime # gmapMp :: MonadPlus m => (forall d. Data d => d > m d) > UTCTime > m UTCTime # gmapMo :: MonadPlus m => (forall d. Data d => d > m d) > UTCTime > m UTCTime #  
NFData UTCTime  
Defined in Data.Time.Clock.Internal.UTCTime  
Eq UTCTime  
Ord UTCTime  
Defined in Data.Time.Clock.Internal.UTCTime 
data NominalDiffTime #
This is a length of time, as measured by UTC. It has a precision of 10^12 s.
Conversion functions such as fromInteger
and realToFrac
will treat it as seconds.
For example, (0.010 :: NominalDiffTime)
corresponds to 10 milliseconds.
It has a precision of one picosecond (= 10^12 s). Enumeration functions will treat it as picoseconds.
It ignores leapseconds, 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 leapsecond intervened.
Instances
Haskell defines operations to read and write characters from and to files,
represented by values of type Handle
. Each value of this type is a
handle: a record used by the Haskell runtime 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 semiclosed;
 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 reuse 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.
Defines the exit codes that a program can return.
ExitSuccess  indicates successful termination; 
ExitFailure Int  indicates program failure with an exit code. The exact interpretation of the code is operatingsystem dependent. In particular, some values may be prohibited (e.g. 0 on a POSIXcompliant system). 
Instances
Exception ExitCode  Since: base4.1.0.0 
Defined in GHC.IO.Exception toException :: ExitCode > SomeException # fromException :: SomeException > Maybe ExitCode # displayException :: ExitCode > String #  
Generic ExitCode  
Read ExitCode  
Show ExitCode  
Eq ExitCode  
Ord ExitCode  
Defined in GHC.IO.Exception  
type Rep ExitCode  
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 for stringlike datastructures; used by the overloaded string extension (XOverloadedStrings in GHC).
fromString :: String > a #