Hoogle Search

Within LTS Haskell 8.12 (ghc-8.0.2)

  1. safeIOToSTM :: IO a -> STM a

    TCache Data.TCache

    Assures that the IO computation finalizes no matter if the STM transaction is aborted or retried. The IO computation run in a different thread. The STM transaction wait until the completion of the IO procedure (or retry as usual). It can be retried if the embedding STM computation is retried so the IO computation must be idempotent. Exceptions are bubbled up to the STM transaction

  2. unsafeIOToSTM :: IO a -> STM a

    base GHC.Conc

    Unsafely performs IO in the STM monad. Beware: this is a highly dangerous thing to do.

    • The STM implementation will often run transactions multiple times, so you need to be prepared for this if your IO has any side effects.
    • The STM implementation will abort transactions that are known to be invalid and need to be restarted. This may happen in the middle of unsafeIOToSTM, so make sure you don't acquire any resources that need releasing (exception handlers are ignored when aborting the transaction). That includes doing any IO using Handles, for example. Getting this wrong will probably lead to random deadlocks.
    • The transaction may have seen an inconsistent view of memory when the IO runs. Invariants that you expect to be true throughout your program may not be true inside a transaction, due to the way transactions are implemented. Normally this wouldn't be visible to the programmer, but using unsafeIOToSTM can expose it.

  3. unsafeIOToSTM :: IO a -> STM a

    base GHC.Conc.Sync

    Unsafely performs IO in the STM monad. Beware: this is a highly dangerous thing to do.

    • The STM implementation will often run transactions multiple times, so you need to be prepared for this if your IO has any side effects.
    • The STM implementation will abort transactions that are known to be invalid and need to be restarted. This may happen in the middle of unsafeIOToSTM, so make sure you don't acquire any resources that need releasing (exception handlers are ignored when aborting the transaction). That includes doing any IO using Handles, for example. Getting this wrong will probably lead to random deadlocks.
    • The transaction may have seen an inconsistent view of memory when the IO runs. Invariants that you expect to be true throughout your program may not be true inside a transaction, due to the way transactions are implemented. Normally this wouldn't be visible to the programmer, but using unsafeIOToSTM can expose it.

  4. unsafeIOToSTM :: IO a -> STM a

    TCache Data.TCache

    Unsafely performs IO in the STM monad. Beware: this is a highly dangerous thing to do.

    • The STM implementation will often run transactions multiple times, so you need to be prepared for this if your IO has any side effects.
    • The STM implementation will abort transactions that are known to be invalid and need to be restarted. This may happen in the middle of unsafeIOToSTM, so make sure you don't acquire any resources that need releasing (exception handlers are ignored when aborting the transaction). That includes doing any IO using Handles, for example. Getting this wrong will probably lead to random deadlocks.
    • The transaction may have seen an inconsistent view of memory when the IO runs. Invariants that you expect to be true throughout your program may not be true inside a transaction, due to the way transactions are implemented. Normally this wouldn't be visible to the programmer, but using unsafeIOToSTM can expose it.

Page 1 of 1