Hoogle Search

Within LTS Haskell 24.3 (ghc-9.10.2)

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

Exact lookup

1. bracket :: Process a -> (a -> Process b) -> (a -> Process c) -> Process c

   distributed-process	Control.Distributed.Process.Internal.Primitives

   Deprecated: Use Control.Monad.Catch.bracket instead

2. bracket :: forall (r :: EffectRow) a c b . Member Resource r => Sem r a -> (a -> Sem r c) -> (a -> Sem r b) -> Sem r b

   polysemy	Polysemy.Resource

   Allocate a resource, use it, and clean it up afterwards.

3. 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 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.

4. bracket :: IO a -> (a -> IO b) -> (a -> IO c) -> IO c

   ghc-internal	GHC.Internal.Control.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 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.

5. bracket :: IO a -> (a -> IO b) -> (a -> IO c) -> IO c

   ghc-internal	GHC.Internal.Control.Exception.Base

   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 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.

6. bracket :: IO a -> (a -> IO b) -> (a -> IO c) -> IO c

   ghc-internal	GHC.Internal.IO

   No documentation available.

7. 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 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.

8. 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

9. bracket :: (HasCallStack, MonadMask m) => m a -> (a -> m c) -> (a -> m b) -> m b

   jsaddle	Language.Javascript.JSaddle.Monad

   Generalized abstracted pattern of safe resource acquisition and release in the face of errors. The first action "acquires" some value, which is "released" by the second action at the end. The third action "uses" the value and its result is the result of the bracket. If an error is thrown during the use, the release still happens before the error is rethrown. Note that this is essentially a type-specialized version of generalBracket. This function has a more common signature (matching the signature from Control.Exception), and is often more convenient to use. By contrast, generalBracket is more expressive, allowing us to implement other functions like bracketOnError.

10. bracket :: MonadAsyncException m => m a -> (a -> m b) -> (a -> m c) -> m c

    exception-transformers	Control.Monad.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).

Page 2 of many | Previous | Next