|
|
|
|
Synopsis |
|
|
|
Documentation |
|
map :: (a -> b) -> [a] -> [b] |
map f xs is the list obtained by applying f to each element
of xs, i.e.,
map f [x1, x2, ..., xn] == [f x1, f x2, ..., f xn]
map f [x1, x2, ...] == [f x1, f x2, ...]
|
|
class Monad m where |
The Monad class defines the basic operations over a monad,
a concept from a branch of mathematics known as category theory.
From the perspective of a Haskell programmer, however, it is best to
think of a monad as an abstract datatype of actions.
Haskell's do expressions provide a convenient syntax for writing
monadic expressions.
Minimal complete definition: >>= and return.
Instances of Monad should satisfy the following laws:
return a >>= k == k a
m >>= return == m
m >>= (\x -> k x >>= h) == (m >>= k) >>= h
Instances of both Monad and Functor should additionally satisfy the law:
fmap f xs == xs >>= return . f
The instances of Monad for lists, Data.Maybe.Maybe and System.IO.IO
defined in the Prelude satisfy these laws.
| | Methods | (>>=) :: m a -> (a -> m b) -> m b | Sequentially compose two actions, passing any value produced
by the first as an argument to the second.
| | (>>) :: m a -> m b -> m b | Sequentially compose two actions, discarding any value produced
by the first, like sequencing operators (such as the semicolon)
in imperative languages.
| | return :: a -> m a | Inject a value into the monadic type.
| | fail :: String -> m a | Fail with a message. This operation is not part of the
mathematical definition of a monad, but is invoked on pattern-match
failure in a do expression.
|
| | Instances | |
|
|
runInteractiveProcess |
:: FilePath | Filename of the executable
| -> [String] | Arguments to pass to the executable
| -> Maybe FilePath | Optional path to the working directory
| -> Maybe [(String, String)] | Optional environment (otherwise inherit)
| -> IO (Handle, Handle, Handle, ProcessHandle) | | Runs a raw command, and returns Handles that may be used to communicate
with the process via its stdin, stdout and stderr respectively.
For example, to start a process and feed a string to its stdin:
(inp,out,err,pid) <- runInteractiveProcess "..."
forkIO (hPutStr inp str)
The Handles are initially in binary mode; if you need them to be
in text mode then use hSetBinaryMode.
|
|
|
Produced by Haddock version 2.7.2 |