Hoogle Search

Within LTS Haskell 24.2 (ghc-9.10.2)

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

Exact lookup

1. atomically :: STM a -> IO a

   TCache	Data.TCache

   Perform a series of STM actions atomically. Using atomically inside an unsafePerformIO or unsafeInterleaveIO subverts some of guarantees that STM provides. It makes it possible to run a transaction inside of another transaction, depending on when the thunk is evaluated. If a nested transaction is attempted, an exception is thrown by the runtime. It is possible to safely use atomically inside unsafePerformIO or unsafeInterleaveIO, but the typechecker does not rule out programs that may attempt nested transactions, meaning that the programmer must take special care to prevent these. However, there are functions for creating transactional variables that can always be safely called in unsafePerformIO. See: newTVarIO, newTChanIO, newBroadcastTChanIO, newTQueueIO, newTBQueueIO, and newTMVarIO. Using unsafePerformIO inside of atomically is also dangerous but for different reasons. See unsafeIOToSTM for more on this.

2. atomically :: MonadIO m => STM a -> m a

   classy-prelude-yesod	ClassyPrelude.Yesod

   Lifted version of atomically

3. atomically :: STM a -> IO a

   stateref	Data.MRef.Instances

   Perform a series of STM actions atomically. Using atomically inside an unsafePerformIO or unsafeInterleaveIO subverts some of guarantees that STM provides. It makes it possible to run a transaction inside of another transaction, depending on when the thunk is evaluated. If a nested transaction is attempted, an exception is thrown by the runtime. It is possible to safely use atomically inside unsafePerformIO or unsafeInterleaveIO, but the typechecker does not rule out programs that may attempt nested transactions, meaning that the programmer must take special care to prevent these. However, there are functions for creating transactional variables that can always be safely called in unsafePerformIO. See: newTVarIO, newTChanIO, newBroadcastTChanIO, newTQueueIO, newTBQueueIO, and newTMVarIO. Using unsafePerformIO inside of atomically is also dangerous but for different reasons. See unsafeIOToSTM for more on this.

4. atomically :: STM a -> IO a

   stateref	Data.StateRef.Instances

   Perform a series of STM actions atomically. Using atomically inside an unsafePerformIO or unsafeInterleaveIO subverts some of guarantees that STM provides. It makes it possible to run a transaction inside of another transaction, depending on when the thunk is evaluated. If a nested transaction is attempted, an exception is thrown by the runtime. It is possible to safely use atomically inside unsafePerformIO or unsafeInterleaveIO, but the typechecker does not rule out programs that may attempt nested transactions, meaning that the programmer must take special care to prevent these. However, there are functions for creating transactional variables that can always be safely called in unsafePerformIO. See: newTVarIO, newTChanIO, newBroadcastTChanIO, newTQueueIO, newTBQueueIO, and newTMVarIO. Using unsafePerformIO inside of atomically is also dangerous but for different reasons. See unsafeIOToSTM for more on this.

5. atomically :: STM a -> IO a

   verset	Verset

   Perform a series of STM actions atomically. Using atomically inside an unsafePerformIO or unsafeInterleaveIO subverts some of guarantees that STM provides. It makes it possible to run a transaction inside of another transaction, depending on when the thunk is evaluated. If a nested transaction is attempted, an exception is thrown by the runtime. It is possible to safely use atomically inside unsafePerformIO or unsafeInterleaveIO, but the typechecker does not rule out programs that may attempt nested transactions, meaning that the programmer must take special care to prevent these. However, there are functions for creating transactional variables that can always be safely called in unsafePerformIO. See: newTVarIO, newTChanIO, newBroadcastTChanIO, newTQueueIO, newTBQueueIO, and newTMVarIO. Using unsafePerformIO inside of atomically is also dangerous but for different reasons. See unsafeIOToSTM for more on this.

6. atomically# :: (State# RealWorld -> (# State# RealWorld, a_levpoly #)) -> State# RealWorld -> (# State# RealWorld, a_levpoly #)

   ghc-prim	GHC.PrimopWrappers

   No documentation available.

7. atomicallyFrameCode :: GenStackFrame b -> !b

   ghc-lib-parser	GHC.Exts.Heap.Closures

   No documentation available.

8. atomically' :: MonadIO io => STM result -> io result

   nvim-hs	Neovim.RPC.FunctionCall

   Lifted variant of atomically.

9. atomicallyFrameCode :: GenStackFrame b -> !b

   ghc-heap	GHC.Exts.Heap.Closures

   No documentation available.

10. atomicallySync :: STM a -> IO a

    TCache	Data.TCache

    Perform a synchronization of the cache with permanent storage once executed the STM transaction when syncWrite policy is Synchronous

Page 2 of many | Previous | Next