Maybe -base -parsec

module Control.Monad.Trans.Maybe
transformers Control.Monad.Trans.Maybe
The MaybeT monad transformer adds the ability to fail to a monad. A sequence of actions succeeds, producing a value, only if all the actions in the sequence are successful. If one fails, the rest of the sequence is skipped and the composite action fails. For a variant allowing a range of error values, see Control.Monad.Trans.Error.
MaybeT :: m (Maybe a) -> MaybeT m a
transformers Control.Monad.Trans.Maybe
newtype MaybeT m a
transformers Control.Monad.Trans.Maybe
The parameterizable maybe monad, obtained by composing an arbitrary monad with the Maybe monad. Computations are actions that may produce a value or fail. The return function yields a successful computation, while >>= sequences two subcomputations, failing on the first error.
package MaybeT
package
Support for computations with failures. Version 0.1.2
package MaybeT-monads-tf
package
Support for computations with failures. This is a fork of the MaybeT package by Eric Kidd, but compatible with the type-family based monad classes of the monads-tf package. This package is deprecated: the MaybeT transformer exists in the transformers package nowadays, and the only advantage this package provides over that one is the presence of a MonadFix instance, but it's incorrect anyway. Version 0.2.0.1
package MaybeT-transformers
package
Support for computations with failures. This package is a fork from the MaybeT package by Eric Kidd, changed to depend on transformers instead of mtl. It also adds a few more utility functions. Version 0.2
package maybench
package
Maybench is a tool for comparing the performance between two versions of the same program, on a series of benchmarks that you design. Maybench aims to be easy to use, almost as easy as running "time your-program arg1..arg2". Ideally, it should be a simple matter for outsiders to write timing tests for your programming project and contribute them as part of your performance testing suite. The Darcs repository is available at http://code.haskell.org/maybench. Version 0.2.4.1
maybeRead :: Read a => String -> Maybe a
cgi Network.CGI.Protocol
mapMaybe :: (a -> Maybe b) -> IntMap a -> IntMap b
containers Data.IntMap.Strict, containers Data.IntMap.Lazy
O(n). Map values and collect the Just results. > let f x = if x == "a" then Just "new a" else Nothing > mapMaybe f (fromList [(5,"a"), (3,"b")]) == singleton 5 "new a"
mapMaybe :: (a -> Maybe b) -> Map k a -> Map k b
containers Data.Map.Lazy, containers Data.Map.Strict
O(n). Map values and collect the Just results. > let f x = if x == "a" then Just "new a" else Nothing > mapMaybe f (fromList [(5,"a"), (3,"b")]) == singleton 5 "new a"
mapMaybeT :: (m (Maybe a) -> n (Maybe b)) -> MaybeT m a -> MaybeT n b
transformers Control.Monad.Trans.Maybe
Transform the computation inside a MaybeT. *  (mapMaybeT f m) = f (runMaybeT >  
mapMaybeWithKey :: (Key -> a -> Maybe b) -> IntMap a -> IntMap b
containers Data.IntMap.Strict, containers Data.IntMap.Lazy
O(n). Map keys/values and collect the Just results. > let f k _ = if k < 5 then Just ("key (:) " ++ (show k)) else Nothing > mapMaybeWithKey f (fromList [(5,"a"), (3,"b")]) == singleton 3 "key (:) 3"
mapMaybeWithKey :: (k -> a -> Maybe b) -> Map k a -> Map k b
containers Data.Map.Lazy, containers Data.Map.Strict
O(n). Map keys/values and collect the Just results. > let f k _ = if k < 5 then Just ("key (:) " ++ (show k)) else Nothing > mapMaybeWithKey f (fromList [(5,"a"), (3,"b")]) == singleton 3 "key (:) 3"
pprMaybeExp :: Precedence -> Maybe Exp -> Doc
template-haskell Language.Haskell.TH.Ppr
runMaybeT :: MaybeT m a -> m (Maybe a)
transformers Control.Monad.Trans.Maybe
suchThatMaybe :: Gen a -> (a -> Bool) -> Gen (Maybe a)
QuickCheck Test.QuickCheck.Gen, QuickCheck Test.QuickCheck
Tries to generate a value that satisfies a predicate.
threadMaybe :: (i -> r -> a) -> Split t i r -> SplitM t j i -> SplitM t j a
fgl Data.Graph.Inductive.Internal.Thread
threadMaybe' :: (r -> a) -> Split t i r -> Split t j (Maybe i) -> Split t j (Maybe a)
fgl Data.Graph.Inductive.Internal.Thread