Hoogle Search

Within LTS Haskell 24.34 (ghc-9.10.3)

Note that Stackage only displays results for the latest LTS and Nightly snapshot. Learn more.

Exact lookup

1. mapTasksE :: Traversable t => TaskGroup -> t (IO a) -> IO (t (Either SomeException a))

   async-pool	Control.Concurrent.Async.Pool

   Execute a group of tasks within the given task group, returning the results in order as an Either type to represent exceptions from actions. The order of execution is random, but the results are returned in order.

2. mapTasksE_ :: Traversable t => TaskGroup -> t (IO a) -> IO (t (Maybe SomeException))

   async-pool	Control.Concurrent.Async.Pool

   Execute a group of tasks within the given task group, ignoring results, but returning a list of all exceptions.

3. mapTasks_ :: Foldable t => TaskGroup -> t (IO a) -> IO ()

   async-pool	Control.Concurrent.Async.Pool

   Execute a group of tasks within the given task group, ignoring results.

4. mappendMultipartData :: MultipartData tag -> MultipartData tag -> MultipartData tag

   autodocodec-servant-multipart	Autodocodec.Multipart

   No documentation available.

5. mapBBDB :: (BBDB -> BBDB) -> [BBDBFile] -> [BBDBFile]

   bbdb	Database.BBDB

   This and filterBBDB are the main functions you should use to manipulate a set of BBDB entries. You supply a function that applies a transformation on a BBDB record, and this function will apply that transformation to every BBDBEntry in a BBDB file. Sample usage:

   starCompanies = do
   b <- readBBDB "/home/henry/.bbdb"
   writeFile "/home/henry/.bbdb-new" $ asLisp . mapBBDB starCompany $ b
   where
   starCompany x = case (company x) of
   Nothing -> x
   Just y -> x { company = Just ("*" ++ y) }
   

   Prepend a star ("*") to each company field of a BBDB file and write the result out as a new bbdb file.

6. mapWithKey :: (BKey -> a -> b) -> BDictMap a -> BDictMap b

   bencoding	Data.BEncode.BDict

   O(n). Map a function over all keys/value pairs in the dictionary.

7. mapHandle :: forall (e :: Effects) (es :: Effects) . (Handle h, e :> es) => h e -> h es

   bluefin	Bluefin.Compound

   Used to create compound effects, i.e. handles that contain other handles.

8. mappend' :: forall (n :: Natural) s (m :: Natural) . PokeKnownLen n s -> PokeKnownLen m s -> PokeKnownLen (n + m) s

   bytezap	Bytezap.Poke.KnownLen

   No documentation available.

9. mapAccumS :: forall (m :: Type -> Type) a s b . Monad m => (a -> s -> ConduitT b Void m s) -> s -> ConduitT () b m () -> ConduitT a Void m s

   classy-prelude-yesod	ClassyPrelude.Yesod

   Consume a source with a strict accumulator, in a way piecewise defined by a controlling stream. The latter will be evaluated until it terminates.

   >>> let f a s = liftM (:s) $ mapC (*a) =$ CL.take a
   
   >>> reverse $ runIdentity $ yieldMany [0..3] $$ mapAccumS f [] (yieldMany [1..])
   [[],[1],[4,6],[12,15,18]] :: [[Int]]
   

10. mapAccumWhileC :: forall (m :: Type -> Type) a s b . Monad m => (a -> s -> Either s (s, b)) -> s -> ConduitT a b m s

    classy-prelude-yesod	ClassyPrelude.Yesod

    mapWhileC with a break condition dependent on a strict accumulator. Equivalently, mapAccum as long as the result is Right. Instead of producing a leftover, the breaking input determines the resulting accumulator via Left.

Page 335 of many | Previous | Next