Effectful Core

https://hackage-content.haskell.org/package/effectful-core-2.6.1.0
Admin
Effectful Core is an easy to use, performant extensible effects library for Haskell with seamless...
Tokens:276,760
Snippets:1,784
Trust Score:9.7
Update:1 month ago
Show doc for...
Tokens:
Raw
### Writer examples

Source: https://hackage-content.haskell.org/package/effectful-core-2.6.1.0/docs/Effectful-Writer-Static-Local.html

Code examples from the Effectful.Writer.Static.Local documentation.

```haskell
runEff . execWriter @String $ do
    tell "Hi"
    handle (\(_::ErrorCall) -> pure ((), "")) $ do
      tell " there"
      listen $ do
        tell "!"
        error "oops"
:}
"Hi there!"
```

```haskell
listens f m ≡ second f <$> listen m
```

--------------------------------

### SeqForkUnlift examples

Source: https://hackage-content.haskell.org/package/effectful-core-2.6.1.0/src/src/Effectful/Internal/Unlift.hs

Haskell code examples demonstrating the behavior of SeqForkUnlift strategy with state effects.

```haskell
import Effectful
import Effectful.State.Dynamic

:{
 action :: (IOE :> es, State Int :> es) => Eff es ()
 action = do
   modify @Int (+1)
   withEffToIO SeqForkUnlift $ \unlift -> unlift $ modify @Int (+2)
   modify @Int (+4)
:}

>>> runEff . execStateLocal @Int 0 $ action
5

>>> runEff . execStateShared @Int 0 $ action
7
```

```haskell
>>> :{
  delayed :: UnliftStrategy -> IO (IO String)
  delayed strategy = runEff . evalStateLocal "Hey" $ do
    r <- withEffToIO strategy $ \unlift -> pure $ unlift get
    modify (++ "!!!")
    pure r
:}

>>> join $ delayed SeqUnlift
*** Exception: version (...) /= storageVersion (0)
...

>>> join $ delayed SeqForkUnlift
"Hey"
```

--------------------------------

### Import statements for Provider example

Source: https://hackage-content.haskell.org/package/effectful-core-2.6.1.0/docs/Effectful-Provider.html

Imports needed for the example: Control.Monad.IO.Class, Data.Map.Strict, Effectful.Dispatch.Dynamic, and Effectful.State.Static.Local.

```haskell
>>> **import Control.Monad.IO.Class
>>> **import Data.Map.Strict qualified as M
>>> **import Effectful.Dispatch.Dynamic
>>> **import Effectful.State.Static.Local

```

--------------------------------

### SeqForkUnlift example with State

Source: https://hackage-content.haskell.org/package/effectful-core-2.6.1.0/docs/Effectful-Internal-Unlift.html

Shows how SeqForkUnlift forks thread-local state, so modifications in unlifted actions do not affect the main thread. The example uses State Int and prints results for execStateLocal and execStateShared.

```haskell
>>> **import Effectful
>>> **import Effectful.State.Dynamic
>>> **:{
 action :: (IOE :> es, State Int :> es) => Eff es ()
 action = do
   modify @Int (+1)
   withEffToIO SeqForkUnlift $ \unlift -> unlift $ modify @Int (+2)
   modify @Int (+4)
:}

```

```haskell
>>> **runEff . execStateLocal @Int 0 $ action
**5

```

```haskell
>>> **runEff . execStateShared @Int 0 $ action
**7

```

--------------------------------

### Example: Handler for D with localSeqLend (works)

Source: https://hackage-content.haskell.org/package/effectful-core-2.6.1.0/src/src/Effectful/Dispatch/Dynamic.hs

Shows a handler for `D` that uses `localSeqLend` to provide `IOE` to the local environment, allowing `runE` to be used.

```haskell
runD :: IOE :> es => Eff (D : es) a -> Eff es a
runD = interpret $ \env -> \case
  D -> localSeqUnlift env $ \unlift -> do
    localSeqLend @'[IOE] env $ \useIOE -> do
      unlift . useIOE . runE $ pure ()
```

--------------------------------

### Example: Run action with IO interpreter

Source: https://hackage-content.haskell.org/package/effectful-core-2.6.1.0/docs/src/Effectful.Provider.html

Runs the action with the IO-based interpreter using runProvider_. The output shows the printed lines.

```haskell
runEff
  . runProvider_ runWriteIO
  $ action
```

```text
in.txt: hi
in.txt: there
out.txt: good
out.txt: bye
```

--------------------------------

### listen with exception partial output example

Source: https://hackage-content.haskell.org/package/effectful-core-2.6.1.0/docs/src/Effectful.Writer.Static.Shared.html

Shows that listen appends partial output even when an exception occurs inside the listened action. The example uses runEff, execWriter, tell, handle, and listen; the output is "Hi there!".

```haskell
runEff . execWriter @String $ do
  tell "Hi"
  handle (\(_::ErrorCall) -> pure ((), "")) $ do
    tell " there"
    listen $ do
      tell "!"
      error "oops"
```

--------------------------------

### Imports for effToHandler example

Source: https://hackage-content.haskell.org/package/effectful-core-2.6.1.0/docs/Effectful.html

Imports Effectful.Error.Static and Effectful.State.Static.Local for the effToHandler example.

```haskell
>>> **import Effectful.Error.Static
>>> **import Effectful.State.Static.Local
```

--------------------------------

### Example output of putStrLnWithCallStack

Source: https://hackage-content.haskell.org/package/effectful-core-2.6.1.0/docs/Effectful-Labeled-Error.html

Shows the formatted output when calling the function.

```haskell
putStrLnWithCallStack "hello"
hello
CallStack (from HasCallStack):
  putStrLnWithCallStack, called at <interactive>:... in interactive:Ghci...
```

--------------------------------

### Effectful.Provider example - run action with runProvider_

Source: https://hackage-content.haskell.org/package/effectful-core-2.6.1.0/src/src/Effectful/Provider.hs

Shows how to run the `action` with `runProvider_` using a `runWriteIO` handler, and the associated output.

```haskell
>>> :{
  runEff
    . runProvider_ runWriteIO
    $ action
:}
```

--------------------------------

### Equivalence laws for asks and local

Source: https://hackage-content.haskell.org/package/effectful-core-2.6.1.0/docs/Effectful-Labeled-Reader.html

Two code examples showing the equivalence of asks and local with respect to ask and runReader.

```haskell
asks f ≡ f <$> ask
```

```haskell
runReader r (local f m) ≡ runReader (f r) m
```

--------------------------------

### Example usage of Profiling effect

Source: https://hackage-content.haskell.org/package/effectful-core-2.6.1.0/docs/Effectful-Dispatch-Dynamic.html

Shows how to use the Profiling effect with a simple action, and the output when run with the profiling and no-profiling interpreters.

```haskell
action = profile "greet" . liftIO $ putStrLn "Hello!"
```

```haskell
:t action
action :: (Profiling :> es, IOE :> es) => Eff es ()
```

```haskell
runEff . runProfiling $ action
Hello!
Action 'greet' took ... seconds.
```

```haskell
runEff . runNoProfiling $ action
Hello!
```

--------------------------------

### Using localSeqLend to lend effects to the local environment

Source: https://hackage-content.haskell.org/package/effectful-core-2.6.1.0/docs/src/Effectful.Dispatch.Dynamic.html

These examples illustrate the problem that localSeqLend solves: an effect handler that needs to run an auxiliary effect requiring additional effects (IOE and D) fails because only IOE :> es is available. The final example shows how to use localSeqLend to lend IOE to the local environment, enabling the auxiliary effect to run.

```haskell
data D :: Effect where
  D :: D m ()
type instance DispatchOf D = Dynamic
```

```haskell
data E :: Effect
runE :: (IOE :> es, D :> es) => Eff (E : es) a -> Eff es a
runE = error "runE"
```

```haskell
runD :: IOE :> es => Eff (D : es) a -> Eff es a
runD = interpret $ \env -> \case
  D -> localSeqUnlift env $ \unlift -> do
    unlift . runE $ pure ()
-- ...
-- ...Could not deduce ...IOE :> localEs... arising from a use of ‘runE’
-- ...from the context: IOE :> es
-- ...
```

```haskell
runD :: IOE :> es => Eff (D : es) a -> Eff es a
runD = interpret $ \env -> \case
  D -> localSeqUnlift env $ \unlift -> do
    localSeqLend @'[IOE] env $ \useIOE -> do
      unlift . useIOE . runE $ pure ()
```

--------------------------------

### Example: Define an IO-based interpreter for Write

Source: https://hackage-content.haskell.org/package/effectful-core-2.6.1.0/docs/src/Effectful.Provider.html

Defines an interpreter for the Write effect that prints the message to stdout with the file path prefix.

```haskell
runWriteIO
  :: IOE :> es
  => FilePath
  -> Eff (Write : es) a
  -> Eff es a
runWriteIO fp = interpret_ $ \case
  Write msg -> liftIO . putStrLn $ fp ++ ": " ++ msg
```

--------------------------------

### sizeEnv: Get the current environment size

Source: https://hackage-content.haskell.org/package/effectful-core-2.6.1.0/docs/src/Effectful.Internal.Env.html

Returns the number of effects in the environment by subtracting the offset from the size of the refs array.

```haskell
-- | Get the current size of the environment.
sizeEnv :: Env es -> IO Int
sizeEnv :: forall (es :: [Effect]). Env es -> IO Int
sizeEnv (Env Int
offset PrimArray Ref
refs IORef' Storage
_) = do
  Int -> IO Int
forall a. a -> IO a
forall (f :: Type -> Type) a. Applicative f => a -> f a
pure (Int -> IO Int) -> Int -> IO Int
forall a b. (a -> b) -> a -> b
$ PrimArray Ref -> Int
forall a. Prim a => PrimArray a -> Int
sizeofPrimArray PrimArray Ref
refs Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
offset
```

--------------------------------

### gets operation

Source: https://hackage-content.haskell.org/package/effectful-core-2.6.1.0/src/src/Effectful/State/Static/Local.hs

Gets a function of the current state. Equivalent to @'gets' f ≡ f '<$>' 'get'@.

```haskell
gets
  :: (HasCallStack, State s :> es)
  => (s -> a) -- ^ The function to apply to the state.
  -> Eff es a
gets f = f <$> get
```

--------------------------------

### Example: Run action with pure interpreter

Source: https://hackage-content.haskell.org/package/effectful-core-2.6.1.0/docs/src/Effectful.Provider.html

Runs the action with the pure interpreter using runProvider_ and execState. The output shows the resulting state map.

```haskell
runPureEff
  . fmap (fmap reverse)
  . execState @(M.Map FilePath [String]) M.empty
  . runProvider_ runWritePure
  $ action
```

```text
fromList [("in.txt",["hi","there"]),("out.txt",["good","bye"])]
```

--------------------------------

### Example: runEff with execWriter and listen

Source: https://hackage-content.haskell.org/package/effectful-core-2.6.1.0/docs/Effectful-Writer-Static-Shared.html

Shows how to use runEff, execWriter, tell, listen, and handle to demonstrate that partial output is appended even when an exception occurs. The output is "Hi there!".

```haskell
>>> **:{
**  runEff . execWriter @String $ do
    tell "Hi"
    handle (\(_::ErrorCall) -> pure ((), "")) $ do
      tell " there"
      listen $ do
        tell "!"
        error "oops"
:}
"Hi there!"

```

--------------------------------

### gets equivalence

Source: https://hackage-content.haskell.org/package/effectful-core-2.6.1.0/docs/Effectful-State-Static-Local.html

Shows the equivalence of gets and fmap get.

```haskell
gets f ≡ f <$> get
```

--------------------------------

### gets

Source: https://hackage-content.haskell.org/package/effectful-core-2.6.1.0/docs/src/Effectful.State.Static.Local.html

The `gets` function applies a pure function to the current state, returning the result. It is defined as `gets f = f <$> get`.

```haskell
gets
  :: (HasCallStack, State s :> es)
  => (s -> a) -- ^ The function to apply to the state.
  -> Eff es a
gets s -> a
f = s -> a
f (s -> a) -> Eff es s -> Eff es a
forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
<$> Eff es s
forall s (es :: [(Type -> Type) -> Type -> Type]).
(HasCallStack, State s :> es) =>
Eff es s
get
```

--------------------------------

### gets

Source: https://hackage-content.haskell.org/package/effectful-core-2.6.1.0/docs/Effectful-State-Dynamic.html

Gets a function of the current state.

```APIDOC
## gets

### Description
Get a function of the current state.

### Signature
```haskell
gets :: (HasCallStack, State s :> es) => (s -> a) -> Eff es a
```

### Parameters
- `(s -> a)` - Function to apply to the current state.

### Returns
- `Eff es a` - The result of applying the function to the current state.

### Note
`gets f ≡ f <$> get`
```

--------------------------------

### provideListWith

Source: https://hackage-content.haskell.org/package/effectful-core-2.6.1.0/docs/Effectful-Provider-List.html

Runs the handler with a given input.

```APIDOC
## provideListWith

### Description
Runs the handler with a given input value and returns the result wrapped in the `f` functor.

### Signature
```haskell
provideListWith
  :: forall providedEs input f es a.
     (HasCallStack, ProviderList providedEs input f :> es)
  => input
  -> Eff (providedEs ++ es) a
  -> Eff es (f a)
```

### Parameters
- **input** (input) - Required - The input to the handler.
- **action** (Eff) - Required - The effectful computation to run.

### Returns
- **Eff es (f a)** - The result of running the action with the handler, wrapped in `f`.
```

--------------------------------

### gets

Source: https://hackage-content.haskell.org/package/effectful-core-2.6.1.0/docs/src/Effectful.Labeled.State.html

Returns a function of the current state, equivalent to `f <$> get`.

```APIDOC
## gets

### Description
Get a function of the current state.

```haskell
@'gets' f ≡ f '<$>' 'get'@
```

### Signature
```haskell
gets
  :: forall label s es a
   . (HasCallStack, Labeled label (State s) :> es)
  => (s -> a)
  -> Eff es a
```

### Parameters
- `f` (function from `s` to `a`) - A function to apply to the current state.
```

--------------------------------

### Effectful.Provider example - run action with runProvider_ using runWritePure

Source: https://hackage-content.haskell.org/package/effectful-core-2.6.1.0/src/src/Effectful/Provider.hs

Shows how to run the `action` with `runProvider_` using the `runWritePure` handler, with an `execState` and a `fmap reverse` to reorder the list. The resulting map is printed.

```haskell
>>> :{
  runPureEff
    . fmap (fmap reverse)
    . execState @(M.Map FilePath [String]) M.empty
    . runProvider_ runWritePure
    $ action
:}
fromList [("in.txt",["hi","there"]),("out.txt",["good","bye"])]
```

--------------------------------

### Imports for Handler monad example

Source: https://hackage-content.haskell.org/package/effectful-core-2.6.1.0/docs/Effectful.html

Imports Control.Monad.State and Control.Monad.Except qualified for the Handler newtype example.

```haskell
>>> **import Control.Monad.State qualified as T
>>> **import Control.Monad.Except qualified as T
```

--------------------------------

### Example: Handler for D without localSeqLend (fails)

Source: https://hackage-content.haskell.org/package/effectful-core-2.6.1.0/src/src/Effectful/Dispatch/Dynamic.hs

Shows a handler for `D` that attempts to use `runE` inside the handler, which fails because `IOE` is not available in the local environment.

```haskell
runD :: IOE :> es => Eff (D : es) a -> Eff es a
runD = interpret $ \env -> \case
  D -> localSeqUnlift env $ \unlift -> do
    unlift . runE $ pure ()
```

--------------------------------

### Define Get effect data type

Source: https://hackage-content.haskell.org/package/effectful-core-2.6.1.0/src/src/Effectful/Dispatch/Dynamic.hs

Defines a Get effect data type for splitting a state effect.

```haskell
:{
 data Get s :: Effect where
   Get :: Get s m s
 type instance DispatchOf (Get s) = Dynamic
:}
```

--------------------------------

### provideListWith

Source: https://hackage-content.haskell.org/package/effectful-core-2.6.1.0/src/src/Effectful/Provider/List.hs

Runs the handler with a given input. The handler can change the return type.

```APIDOC
## provideListWith

### Description
Runs the handler with a given input. The handler can change the return type.

### Signature
```haskell
provideListWith
  :: forall providedEs input f es a
   . (HasCallStack, ProviderList providedEs input f :> es)
  => input
  -> Eff (providedEs ++ es) a
  -> Eff es (f a)
```

### Parameters
- **input** (input) - Required - The input to the handler.
- **action** (Eff) - Required - The effectful computation to run with the provided handler.

### Returns
- **Eff es (f a)** - The result of running the action with the handler, with the return type transformed by f.
```

--------------------------------

### get operation for State effect

Source: https://hackage-content.haskell.org/package/effectful-core-2.6.1.0/docs/src/Effectful.State.Static.Local.html

Defines the get operation that fetches the current state value from the State effect.

```haskell
-- | Fetch the current value of the state.
get :: (HasCallStack, State s :> es) => Eff es s
get :: forall s (es :: [(Type -> Type) -> Type -> Type]).
(HasCallStack, State s :> es) =>
Eff es s
get = do
  State s
s <- Eff es (StaticRep (State s))
forall (e :: (Type -> Type) -> Type -> Type)
       (sideEffects :: SideEffects)
       (es :: [(Type -> Type) -> Type -> Type]).
(HasCallStack, DispatchOf e ~ 'Static sideEffects, e :> es) =>
Eff es (StaticRep e)
getStaticRep
  s -> Eff es s
forall a. a -> Eff es a
forall (f :: Type -> Type) a. Applicative f => a -> f a
pure s
s
```

--------------------------------

### Define and use profiled action

Source: https://hackage-content.haskell.org/package/effectful-core-2.6.1.0/src/src/Effectful/Dispatch/Dynamic.hs

Shows constructing a simple action that uses profile with IOE and liftIO, checking its type, and running it with the configured interpreters. The output shows printing Hello! and a timing line with ... in place of the measured seconds.

```haskell
action = profile "greet" . liftIO $ putStrLn "Hello!"
```

```haskell
:t action
```

```haskell
runEff . runProfiling $ action
Hello!
Action 'greet' took ... seconds.
```

```haskell
runEff . runNoProfiling $ action
Hello!
```

--------------------------------

### Error Effect Examples

Source: https://hackage-content.haskell.org/package/effectful-core-2.6.1.0/docs/src/Effectful.Error.Static.html

Examples demonstrating the behavior of the Error effect, including catching regular exceptions, using bracket, and comparing with ExceptT.

```haskell
>>> import Effectful.Exception qualified as E

>>> boom = error "BOOM!"

>>> runEff . runError @ErrorCall $ boom `catchError` \_ (_::ErrorCall) -> pure "caught"
*** Exception: BOOM!
...
```

```haskell
>>> runEff $ boom `E.catch` \(_::ErrorCall) -> pure "caught"
"caught"
```

```haskell
>>> msg = liftIO . putStrLn

>>> :{
runEff . runErrorNoCallStack @String $ do
  E.bracket_ (msg "Beginning.")
             (msg "Cleaning up.")
             (msg "Computing." >> throwError "oops" >> msg "More.")
:}
Beginning.
Computing.
Cleaning up.
Left "oops"
```

```haskell
>>> import Control.Monad.State.Strict qualified as T
>>> import Control.Monad.Except qualified as T

>>> m1 = (T.modify (++ " there!") >> T.throwError "oops") `T.catchError` \_ -> pure ()

>>> (`T.runStateT` "Hi") . T.runExceptT $ m1
(Right (),
"Hi there!")

>>> T.runExceptT . (`T.runStateT` "Hi") $ m1
Right ((),"Hi")
```

```haskell
>>> import Effectful.State.Static.Local

>>> m2 = (modify (++ " there!") >> throwError "oops") `catchError` \_ (_::String) -> pure ()

>>> runEff . runState "Hi" . runError @String $ m2
(Right (),
"Hi there!")
```

--------------------------------

### emptyEnv

Source: https://hackage-content.haskell.org/package/effectful-core-2.6.1.0/docs/Effectful-Dispatch-Static-Primitive.html

Creates an empty environment.

```APIDOC
## emptyEnv

### Description
Creates an empty environment.

### Method
Function

### Signature
```haskell
emptyEnv :: HasCallStack => IO (Env '[])
```

### Return Value
IO (Env '[]) - An empty environment.
```

--------------------------------

### reinterpret_

Source: https://hackage-content.haskell.org/package/effectful-core-2.6.1.0/docs/src/Effectful.Dispatch.Dynamic.html

Reinterprets a first-order effect with dynamic dispatch, allowing a setup function to encapsulate additional effects. Takes a setup function, an effect handler, and an action.

```APIDOC
## reinterpret_

### Description
Reinterprets a first-order effect with dynamic dispatch, allowing a setup function to encapsulate additional effects. Takes a setup function, an effect handler, and an action.

### Signature
```haskell
reinterpret_
  :: (HasCallStack, DispatchOf e ~ Dynamic)
  => (Eff handlerEs a -> Eff es b)
  -- ^ Setup of effects encapsulated in the handler.
  -> EffectHandler_ e handlerEs
  -- ^ The effect handler.
  -> Eff (e : es) a
  -> Eff      es  b
```

### Parameters
- **runSetup** (Eff handlerEs a -> Eff es b) - Required - Setup of effects encapsulated in the handler.
- **handler** (EffectHandler_ e handlerEs) - Required - The effect handler.
- **action** (Eff (e : es) a) - Required - The action to reinterpret.

### Returns
- **Eff es b** - The resulting action with the effect handled.

### Since
2.4.0.0
```

--------------------------------

### handleIO

Source: https://hackage-content.haskell.org/package/effectful-core-2.6.1.0/docs/Effectful-Exception.html

Flipped version of catchIO.

```APIDOC
## handleIO

### Description
Flipped version of `catchIO`.

### Signature
```haskell
handleIO :: (IOException -> Eff es a) -> Eff es a -> Eff es a
```

### Parameters
- `(IOException -> Eff es a)` - The exception handler.
- `Eff es a` - The action to run.

### Returns
- `Eff es a` - The result of the action or handler.
```

--------------------------------

### Effectful.Provider example - Define an effect with Write

Source: https://hackage-content.haskell.org/package/effectful-core-2.6.1.0/src/src/Effectful/Provider.hs

Defines a custom effect `Write` using `Effectful.Dispatch.Dynamic` with a single operation `Write` that takes a `String`. This is part of the provided worked example.

```haskell
-- $example
--
-- >>> import Control.Monad.IO.Class
-- >>> import Data.Map.Strict qualified as M
-- >>> import Effectful.Dispatch.Dynamic
-- >>> import Effectful.State.Static.Local
--
-- Given an effect:
--
-- >>> :{
--   data Write :: Effect where
--     Write :: String -> Write m ()
--   type instance DispatchOf Write = Dynamic
-- :}
```

--------------------------------

### Splitting a State effect with Get and Put

Source: https://hackage-content.haskell.org/package/effectful-core-2.6.1.0/docs/Effectful-Dispatch-Dynamic.html

Defines Get and Put effects, imports the State module, and defines runGetPut that uses a private State effect and inject to hide it from downstream code.

```haskell
>>> **:{
** data Get s :: Effect where
   Get :: Get s m s
 type instance DispatchOf (Get s) = Dynamic
:}

```

```haskell
>>> **:{
** data Put s :: Effect where
   Put :: s -> Put s m ()
 type instance DispatchOf (Put s) = Dynamic
:}

```

```haskell
>>> **import Effectful.State.Static.Local qualified as S
**

```

```haskell
>>> **:{
** runGetPut :: forall s es a. s -> Eff (Get s : Put s : es) a -> Eff es (a, s)
 runGetPut s0
   = S.runState s0
   . interpret_ @(Put s) (\(Put s) -> S.put s)
   . interpret_ @(Get s) (\Get -> S.get)
   . inject
:}

```

--------------------------------

### get

Source: https://hackage-content.haskell.org/package/effectful-core-2.6.1.0/docs/Effectful-State-Dynamic.html

Fetches the current value of the state.

```APIDOC
## get

### Description
Fetch the current value of the state.

### Signature
```haskell
get :: (HasCallStack, State s :> es) => Eff es s
```

### Returns
- `Eff es s` - The current state value.
```

--------------------------------

### provideListWith_

Source: https://hackage-content.haskell.org/package/effectful-core-2.6.1.0/docs/Effectful-Provider-List.html

Runs the handler with a given input and unchanged return type.

```APIDOC
## provideListWith_

### Description
Runs the handler with a given input value and returns the result unchanged.

### Signature
```haskell
provideListWith_
  :: forall providedEs input es a.
     (HasCallStack, ProviderList_ providedEs input :> es)
  => input
  -> Eff (providedEs ++ es) a
  -> Eff es a
```

### Parameters
- **input** (input) - Required - The input to the handler.
- **action** (Eff) - Required - The effectful computation to run.

### Returns
- **Eff es a** - The result of running the action with the handler.
```

--------------------------------

### get

Source: https://hackage-content.haskell.org/package/effectful-core-2.6.1.0/docs/Effectful-State-Static-Shared.html

Retrieves the current state value.

```APIDOC
## get

### Description
Retrieves the current state value.

### Signature
get :: (HasCallStack, State s :> es) => Eff es s

### Returns
- **Eff es s** - The current state value.
```

--------------------------------

### sizeEnv

Source: https://hackage-content.haskell.org/package/effectful-core-2.6.1.0/docs/Effectful-Dispatch-Static-Primitive.html

Gets the current size of the environment.

```APIDOC
## sizeEnv

### Description
Gets the current size of the environment.

### Method
Function

### Signature
```haskell
sizeEnv :: Env es -> IO Int
```

### Parameters
- **Env es** - The environment to query.

### Return Value
IO Int - The size of the environment.
```

--------------------------------

### ask

Source: https://hackage-content.haskell.org/package/effectful-core-2.6.1.0/docs/Effectful-Labeled-Reader.html

Fetches the value of the environment.

```APIDOC
## ask

### Description
Fetch the value of the environment.

### Signature
```haskell
ask :: forall label r es. (HasCallStack, Labeled label (Reader r) :> es) => Eff es r
```

### Returns
- `Eff es r` - The environment value.
```

--------------------------------

### seqUnliftIO

Source: https://hackage-content.haskell.org/package/effectful-core-2.6.1.0/docs/Effectful-Dispatch-Static.html

Unlifts an effectful computation to IO, running it sequentially.

```APIDOC
## seqUnliftIO

### Description
Unlifts an effectful computation to IO, running it sequentially.

### Signature
```haskell
seqUnliftIO :: HasCallStack => Env es -> ((forall r. Eff es r -> IO r) -> IO a) -> IO a
```

### Parameters
- `Env es` - The environment.
- `((forall r. Eff es r -> IO r) -> IO a)` - A function that receives an unlifting function and returns an IO action.

### Returns
- `IO a` - The result of the IO action.
```

--------------------------------

### get operation

Source: https://hackage-content.haskell.org/package/effectful-core-2.6.1.0/src/src/Effectful/State/Static/Local.hs

Fetches the current value of the state.

```haskell
get :: (HasCallStack, State s :> es) => Eff es s
get = do
  State s <- getStaticRep
  pure s
```

--------------------------------

### get

Source: https://hackage-content.haskell.org/package/effectful-core-2.6.1.0/src/src/Effectful/Labeled/State.hs

Fetches the current value of the labeled state.

```APIDOC
## get

### Description
Fetch the current value of the state.

### Signature
```haskell
get
  :: forall label s es
   . (HasCallStack, Labeled label (State s) :> es)
  => Eff es s
```

### Returns
- `Eff es s` - The current state value.
```

--------------------------------

### localSeqUnliftIO

Source: https://hackage-content.haskell.org/package/effectful-core-2.6.1.0/src/src/Effectful/Dispatch/Dynamic.hs

Creates a local unlifting function with the sequential unlifting strategy, running the continuation in IO.

```APIDOC
## localSeqUnliftIO

### Description
Creates a local unlifting function using the `SeqUnlift` strategy, but the continuation runs in `IO`. Requires `IOE` in the effect stack.

### Signature
```haskell
localSeqUnliftIO
  :: (HasCallStack, SharedSuffix es handlerEs, IOE :> es)
  => LocalEnv localEs handlerEs
  -> ((forall r. Eff localEs r -> IO r) -> IO a)
  -> Eff es a
```

### Parameters
- **LocalEnv** (`LocalEnv localEs handlerEs`) - Local environment.
- **Continuation** (`(forall r. Eff localEs r -> IO r) -> IO a`) - Continuation with the unlifting function in scope.

### Returns
- **Eff es a** - The result of the continuation.

### Since
Unspecified
```

--------------------------------

### gets

Source: https://hackage-content.haskell.org/package/effectful-core-2.6.1.0/docs/Effectful-Labeled-State.html

Applies a function to the current state and returns the result.

```APIDOC
## gets

### Description
Applies a function to the current state and returns the result.

### Signature
```haskell
gets :: forall label s es a. (HasCallStack, Labeled label (State s) :> es) => (s -> a) -> Eff es a
```

### Parameters
- `label` (type-level) - The label identifying the state effect.
- `s` (type) - The state type.
- `es` (type-level list) - The effect stack.
- `a` (type) - The result type.
- `(s -> a)` - The function to apply to the state.

### Returns
- `Eff es a` - The result of applying the function.

```

--------------------------------

### Run listen with exception handling in GHCi

Source: https://hackage-content.haskell.org/package/effectful-core-2.6.1.0/docs/src/Effectful.Writer.Static.Local.html

Shows how listen captures the writer output while handling an exception. If an exception occurs, the partial output before the exception is still appended. In this example, the error is handled and the output is "Hi there!".

```haskell
>>> :{
  runEff . execWriter @String $ do
    tell "Hi"
    handle (\(_::ErrorCall) -> pure ((), "")) $ do
      tell " there"
      listen $ do
        tell "!"
        error "oops"
:}
-- "Hi there!"
```
Tokens:
Raw