Hoogle Search

Within LTS Haskell 22.18 (ghc-9.6.4)

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

bracket :: MonadSafe m => Base m a -> (a -> Base m b) -> (a -> m c) -> m c

pipes-safe Pipes.Safe

Analogous to bracket from Control.Monad.Catch, except this also protects against premature termination
bracket :: forall r_avzl a_X0 c_X1 b_avxb . Member Resource r_avzl => Sem r_avzl a_X0 -> (a_X0 -> Sem r_avzl c_X1) -> (a_X0 -> Sem r_avzl b_avxb) -> Sem r_avzl b_avxb

polysemy Polysemy.Resource

Allocate a resource, use it, and clean it up afterwards.
bracket :: IO a -> (a -> IO b) -> (a -> IO c) -> IO c

graphviz Data.GraphViz.Exception

When you want to acquire a resource, do some work with it, and then release the resource, it is a good idea to use bracket, because bracket will install the necessary exception handler to release the resource in the event that an exception is raised during the computation. If an exception is raised, then bracket will re-raise the exception (after performing the release). A common example is opening a file:
```
bracket
(openFile "filename" ReadMode)
(hClose)
(\fileHandle -> do { ... })
```
The arguments to bracket are in this order so that we can partially apply it, e.g.:
```
withFile name mode = bracket (openFile name mode) hClose
```
Bracket wraps the release action with mask, which is sufficient to ensure that the release action executes to completion when it does not invoke any interruptible actions, even in the presence of asynchronous exceptions. For example, hClose is uninterruptible when it is not racing other uses of the handle. Similarly, closing a socket (from "network" package) is also uninterruptible under similar conditions. An example of an interruptible action is killThread. Completion of interruptible release actions can be ensured by wrapping them in in uninterruptibleMask_, but this risks making the program non-responsive to Control-C, or timeouts. Another option is to run the release action asynchronously in its own thread:
```
void $ uninterruptibleMask_ $ forkIO $ do { ... }
```
The resource will be released as soon as possible, but the thread that invoked bracket will not block in an uninterruptible state.
bracket :: PolyParse p => p bra -> p ket -> p a -> p a

graphviz Data.GraphViz.Parsing

Parse a bracketed item, discarding the brackets. If everything matches except the closing bracket, the whole parse fails soft, which can give less-than-satisfying error messages. If you want better error messages, try calling with e.g. bracket open (commit close) item
bracket :: IO a -> (a -> IO b) -> (a -> IO c) -> IO c

protolude Protolude

When you want to acquire a resource, do some work with it, and then release the resource, it is a good idea to use bracket, because bracket will install the necessary exception handler to release the resource in the event that an exception is raised during the computation. If an exception is raised, then bracket will re-raise the exception (after performing the release). A common example is opening a file:
```
bracket
(openFile "filename" ReadMode)
(hClose)
(\fileHandle -> do { ... })
```
The arguments to bracket are in this order so that we can partially apply it, e.g.:
```
withFile name mode = bracket (openFile name mode) hClose
```
Bracket wraps the release action with mask, which is sufficient to ensure that the release action executes to completion when it does not invoke any interruptible actions, even in the presence of asynchronous exceptions. For example, hClose is uninterruptible when it is not racing other uses of the handle. Similarly, closing a socket (from "network" package) is also uninterruptible under similar conditions. An example of an interruptible action is killThread. Completion of interruptible release actions can be ensured by wrapping them in in uninterruptibleMask_, but this risks making the program non-responsive to Control-C, or timeouts. Another option is to run the release action asynchronously in its own thread:
```
void $ uninterruptibleMask_ $ forkIO $ do { ... }
```
The resource will be released as soon as possible, but the thread that invoked bracket will not block in an uninterruptible state.
bracket :: Gen Char

checkers Test.QuickCheck.Instances.Char

Generates one or other of '[' and ']'.
bracket :: Parser a -> Parser b -> Parser c -> Parser b

polyparse Text.ParserCombinators.HuttonMeijer

No documentation available.
bracket :: (Show p, Show t) => Parser s (p, t) e a -> Parser s (p, t) e b -> Parser s (p, t) e c -> Parser s (p, t) e b

polyparse Text.ParserCombinators.HuttonMeijerWallace

No documentation available.
bracket :: PolyParse p => p bra -> p ket -> p a -> p a

polyparse Text.ParserCombinators.Poly.Base

Parse a bracketed item, discarding the brackets. If everything matches except the closing bracket, the whole parse fails soft, which can give less-than-satisfying error messages. If you want better error messages, try calling with e.g. bracket open (commit close) item
bracket :: PolyParse p => p bra -> p ket -> p a -> p a

polyparse Text.ParserCombinators.Poly.StateLazy

Parse a bracketed item, discarding the brackets. If everything matches except the closing bracket, the whole parse fails soft, which can give less-than-satisfying error messages. If you want better error messages, try calling with e.g. bracket open (commit close) item

pipes-safe	Pipes.Safe

polysemy	Polysemy.Resource

graphviz	Data.GraphViz.Exception

graphviz	Data.GraphViz.Parsing

protolude	Protolude

checkers	Test.QuickCheck.Instances.Char

polyparse	Text.ParserCombinators.HuttonMeijer

polyparse	Text.ParserCombinators.HuttonMeijerWallace

polyparse	Text.ParserCombinators.Poly.Base

polyparse	Text.ParserCombinators.Poly.StateLazy

Page 2 of many | Previous | Next