Hoogle Search

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

SharedLock :: LockMode

ghc-internal GHC.Internal.IO.Handle

No documentation available.
SharedLock :: LockMode

ghc-internal GHC.Internal.IO.Handle.Lock

No documentation available.
Shared :: SharedExclusive

filelock System.FileLock

Other process can hold a shared lock at the same time.
data SharedExclusive

filelock System.FileLock

A type of lock to be taken.
SharedMemoryBaseName :: ByteString -> Option

mysql Database.MySQL.Base

No documentation available.
SharedMemoryBaseName :: ByteString -> Option

mysql Database.MySQL.Base.Types

No documentation available.
module Graphics.GL.EXT.SharedTexturePalette

No documentation available.

ghc-internal	GHC.Internal.IO.Handle

ghc-internal	GHC.Internal.IO.Handle.Lock

filelock	System.FileLock

filelock	System.FileLock

mysql	Database.MySQL.Base

mysql	Database.MySQL.Base.Types

class SharedSuffix (es1 :: [Effect]) (es2 :: [Effect])

effectful-core	Effectful.Dispatch.Dynamic

Require that both effect stacks share an opaque suffix. Functions from the localUnlift family utilize this constraint to guarantee sensible usage of unlifting functions. As an example, consider the following higher order effect:

>>> :{
data E :: Effect where
E :: m a -> E m a
type instance DispatchOf E = Dynamic
:}

Running local actions in a more specific environment is fine:

>>> :{
runE1 :: Eff (E : es) a -> Eff es a
runE1 = interpret $ \env -> \case
E m -> runReader () $ do
localSeqUnlift env $ \unlift -> unlift m
:}

Running local actions in a more general environment is fine:

>>> :{
runE2 :: Eff (E : es) a -> Eff es a
runE2 = reinterpret (runReader ()) $ \env -> \case
E m -> raise $ do
localSeqUnlift env $ \unlift -> unlift m
:}

However, running local actions in an unrelated environment is not fine as this would make it possible to run anything within runPureEff:

>>> :{
runE3 :: Eff (E : es) a -> Eff es a
runE3 = reinterpret (runReader ()) $ \env -> \case
E m -> pure . runPureEff $ do
localSeqUnlift env $ \unlift -> unlift m
:}
...
...Could not deduce ...SharedSuffix '[] es...
...

Running local actions in a monomorphic effect stack is also not fine as this makes a special case of the above possible:

>>> :{
runE4 :: Eff [E, IOE] a -> Eff '[IOE] a
runE4 = interpret $ \env -> \case
E m -> pure . runPureEff $ do
localSeqUnlift env $ \unlift -> unlift m
:}
...
...Running local actions in monomorphic effect stacks is not supported...
...

module Effectful.State.Static.Shared

Support for access to a shared, mutable value of a particular type. The value is shared between multiple threads. If you want each thead to manage its own version of the value, use Effectful.State.Static.Local. Note: unlike the StateT monad transformer from the transformers library, the State effect doesn't discard state updates when an exception is received:
```
>>> import Control.Exception (ErrorCall)

>>> import Control.Monad.Catch

>>> import Control.Monad.Trans.State.Strict qualified as S
```
```
>>> :{
(`S.execStateT` "Hi") . handle (\(_::ErrorCall) -> pure ()) $ do
S.modify (++ " there!")
error "oops"
:}
"Hi"
```
```
>>> :{
runEff . execState "Hi" . handle (\(_::ErrorCall) -> pure ()) $ do
modify (++ " there!")
error "oops"
:}
"Hi there!"
```
module Effectful.Writer.Static.Shared

Support for access to a write only value of a particular type. The value is shared between multiple threads. If you want each thead to manage its own version of the value, use Effectful.Writer.Static.Local. Warning: Writer's state will be accumulated via left-associated uses of <>, which makes it unsuitable for use with types for which such pattern is inefficient. This applies, in particular, to the standard list type, which makes the Writer effect pretty niche. Note: while the Writer from the transformers package includes additional operations pass and censor, they don't cooperate with runtime exceptions very well, so they're deliberately omitted here.

Page 12 of many | Previous | Next