Hoogle Search

Within LTS Haskell 22.25 (ghc-9.6.5)

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

Exact lookup

1. finally :: Program τ α -> Program τ γ -> Program τ α

   core-program	Core.Program.Exceptions

   Run an action and then, run a finalizer afterwards. The second action will run whether or not an exception was raised by the first one. This is like bracket above, but can be used when you know you have cleanup steps to take after your computation which do have to be run even if (especially if!) an exception is thrown but that that cleanup doesn't depend on the result of that computation or the resources used to do it. The return value γ of the subsequent action is ignored.

2. finally :: (HasCallStack, MonadMask m) => m a -> m b -> m a

   faktory	Faktory.Prelude

   Async safe version of finally

3. finally :: MonadPeelIO m => m a -> m b -> m a

   monad-peel	Control.Exception.Peel

   Generalized version of finally. Note, any monadic side effects in m of the "afterward" computation will be discarded.

4. finally :: forall m a . (MonadException m, MonadTunnelIO m) => m a -> m () -> m a

   monadology	Control.Monad.Ology.General.Exception

   Variant of bracket.

5. finally :: Controller s a -> Controller s b -> Controller s a

   simple	Web.Simple.Controller.Exception

   No documentation available.

6. finally :: MonadUnliftIO m => m a -> m b -> m a

   stack	Stack.Prelude

   Perform thing, guaranteeing that after will run after, even if an exception occurs. Same interruptible vs uninterrupible points apply as with bracket. See base's finally for more information.

7. finally :: (MonadAsync m, MonadCatch m) => m b -> Stream m a -> Stream m a

   streamly	Streamly.Data.Stream.Prelude

   Run the action m b whenever the stream Stream m a stops normally, aborts due to an exception or if it is garbage collected after a partial lazy evaluation. The semantics of running the action m b are similar to the cleanup action semantics described in bracket.

   >>> finally action xs = Stream.bracket (return ()) (const action) (const xs)
   

   See also finally_ Inhibits stream fusion

8. finally :: (IsStream t, MonadAsync m, MonadCatch m) => m b -> t m a -> t m a

   streamly	Streamly.Internal.Data.Stream.IsStream

   Run the action m b whenever the stream t m a stops normally, aborts due to an exception or if it is garbage collected after a partial lazy evaluation. The semantics of running the action m b are similar to the cleanup action semantics described in bracket. See also finally_ Inhibits stream fusion

9. finally :: (MonadAsync m, MonadCatch m) => m b -> Stream m a -> Stream m a

   streamly	Streamly.Internal.Data.Stream.Prelude

   Run the action m b whenever the stream Stream m a stops normally, aborts due to an exception or if it is garbage collected after a partial lazy evaluation. The semantics of running the action m b are similar to the cleanup action semantics described in bracket.

   >>> finally action xs = Stream.bracket (return ()) (const action) (const xs)
   

   See also finally_ Inhibits stream fusion

10. finally :: (MonadAsync m, MonadCatch m) => (a -> m c) -> Unfold m a b -> Unfold m a b

    streamly	Streamly.Internal.Data.Unfold.Prelude

    Unfold the input a using Unfold m a b, run an action on a whenever the unfold stops normally, aborts due to an exception or if it is garbage collected after a partial lazy evaluation. The semantics of the action a -> m c are similar to the cleanup action semantics in bracket.

    finally release = bracket return release
    

    See also finally_ Inhibits stream fusion Pre-release

Page 3 of many | Previous | Next