Changelog of @hackage/effectful-core 2.7.1.0

effectful-core-2.7.1.0 (2026-08-24)

  • Export seqForkUnliftIO and add unsafeSeqForkUnliftIO in Effectful.Dispatch.Static for the SeqForkUnlift strategy.
  • Export type (++) from Effectful.Dispatch.Dynamic.
  • Remove an unnecessary HasCallStack constraint from handleJust.

effectful-core-2.7.0.0 (2026-08-24)

  • Add the Input effect (Effectful.Input.Dynamic, Effectful.Input.Static, Effectful.Input.Static.Action and Effectful.Labeled.Input) for access to values.
  • Add the Output effect (Effectful.Output.Dynamic, Effectful.Output.Static.Action, Effectful.Output.Static.Local.Array, Effectful.Output.Static.Local.List, Effectful.Output.Static.Shared.Array, Effectful.Output.Static.Shared.List and Effectful.Labeled.Output) for accumulation of values.
  • Add the ReturnWith effect (Effectful.ReturnWith.Dynamic, Effectful.ReturnWith.Static and Effectful.Labeled.ReturnWith) for early return from a computation.
  • Make the Provider and ProviderList effects dynamically dispatched and export their operations.
  • Add Effectful.Labeled.Provider and Effectful.Labeled.Provider.List with labeled versions of the Provider and ProviderList effects.
  • Re-export Labeled(..) from all Effectful.Labeled.* modules.
  • Drop support for GHC < 9.6.
  • Add definitions of rethrowM to MonadThrow and catchNoPropagate to MonadCatch instances for Eff when appropriate (exceptions >= 0.10.11).
  • If the cleanup action of bracket, bracket_, bracketOnError, finally or onException from Effectful.Exception throws, the original exception is no longer lost - it is preserved in a WhileHandling annotation of the new one (base >= 4.21).
  • Rename Effectful.Internal.MTL module to Effectful.Internal.Effect.Dynamic.
  • Deprecate withLiftMap as its misuse in a multithreaded environment results in undefined behavior that cannot be detected at runtime. Use localLiftUnlift with an appropriate UnliftStrategy instead.
  • Deprecate stateM and modifyM from Effectful.State.Static.Local, Effectful.State.Static.Shared, Effectful.State.Dynamic and Effectful.Labeled.State as well as the StateM operation of the dynamic State effect. The shared variant pins the state to a lock-based implementation, yet deadlocks when operations of the same State effect are used within the callback, while the local variant silently discards state modifications made this way. If you need atomic effectful updates of shared state, use an explicit MVar.
  • Deprecate runStateMVar, evalStateMVar and execStateMVar from Effectful.State.Static.Shared so that the internal representation of the shared State effect is not tied to an MVar. If you need access to the state from outside of the effect, manage an explicit MVar yourself.
  • Tighten pre-requisites for unconsEnv and unreplaceEnv.
  • Add localLendBorrow to Effectful.Dispatch.Dynamic.
  • Add rethrowErrorWith, rethrowError and rethrowError_ (along with the corresponding RethrowErrorWith operation of the dynamic Error effect) for throwing errors with a given CallStack.
  • Document why the MonadThrow, MonadCatch and MonadMask instances for Eff are available without any effect requirements.
  • Require primitive >= 0.9.0.0.
  • Require strict-mutable-base >= 2.0.0.0.
  • Remove SharedSuffix constraints from functions in Effectful.Dispatch.Dynamic and deprecate the class, as runtime sanity checks make it unnecessary.
  • Breaking changes:
    • Remove the handlerEs type parameter of LocalEnv as it was only needed to support SharedSuffix constraints.
    • Remove the KnownEffects class as it's no longer used; handlers of the ProviderList effect now require the KnownSubset constraint instead.
  • Bugfixes:
    • restoreStorageData no longer shrinks the capacity of the storage, which could result in out of bounds reads when out of date references to the environment were accessed after the rollback, e.g. by the unlifting function that escaped its scope.
    • Unlifting functions created by localLiftUnlift with SeqForkUnlift or ConcUnlift Persistent strategy now correctly share the effect storage and the thread limit now applies jointly to both functions.
    • OnEmptyRollback strategy of the NonDet effect now correctly rolls back local state of statically dispatched effects stored in mutable variables.
    • Thread registration in unlifting functions created with the ConcUnlift Persistent strategy interrupted by an asynchronous exception no longer leaks a finalizer that corrupts the thread limit accounting when the thread dies.
    • Running the computation given to the setup function of reinterpret or impose in a cloned environment (e.g. by unlifting it with the SeqForkUnlift strategy and running it outside of the scope of the setup function) now results in an immediate, accurate error instead of corruption of the environment of the call site.

effectful-core-2.6.1.0 (2025-08-30)

  • Add MonadError, MonadReader, MonadState and MonadWriter instances for Eff for compatibility with existing code.

effectful-core-2.6.0.0 (2025-06-13)

  • Adjust generalBracket with base >= 4.21 to make use of the new exception annotation mechanism.
  • Add withException to Effectful.Exception.
  • Deprecate Effectful.Reader.Dynamic.withReader as it doesn't work correctly for all potential interpreters.
  • Breaking changes:
    • Change the order of type parameters in raise for better usability.
    • Effectful.Error.Static.ErrorWrapper is no longer caught by catchSync.
    • Remove deprecated function Effectful.withConcEffToIO.

effectful-core-2.5.1.0 (2024-11-27)

  • Add passthrough to Effectful.Dispatch.Dynamic for passing operations to the upstream handler within interpose and impose without having to fully pattern match on them.
  • Bugfixes:

effectful-core-2.5.0.0 (2024-10-23)

  • Add plusEff (specialized version of <|>) to Effectful.NonDet and make emptyEff and sumEff generate better call stacks.
  • Explicitly define setByteArray# and setOffAddr# in the Prim instance of Ref for primitive < 0.9.0.0.
  • Bugfixes:
    • OnEmptyRollback strategy of the NonDet effect is no longer broken.
  • Breaking changes:
    • Remove restoreEnv function from Effectful.Dispatch.Static.Primitive since it was broken.
    • Base Effectful.Exception on Control.Exception instead of the safe-exceptions library for consistency with provided MonadThrow and MonadCatch instances.

effectful-core-2.4.0.0 (2024-10-08)

  • Add utility functions for handling effects that take the effect handler as the last parameter to Effectful.Dispatch.Dynamic.
  • Add utility functions for handling first order effects to Effectful.Dispatch.Dynamic.
  • Improve Effectful.Labeled, add Effectful.Labeled.Error, Effectful.Labeled.Reader, Effectful.Labeled.State and Effectful.Labeled.Writer.
  • Add throwErrorWith and throwError_ to Effectful.Error.Static and Effectful.Error.Dynamic.
  • Add HasCallStack constraints where appropriate for better debugging experience.
  • Add a SeqForkUnlift strategy to support running unlifting functions outside of the scope of effects they capture.
  • Add Effectful.Exception with appropriate re-exports from the safe-exceptions library.
  • Bugfixes:
    • Ensure that a LocalEnv is only used in a thread it belongs to.
    • Properly roll back changes made to the environment when OnEmptyRollback policy for the NonDet effect is selected.
    • Fix a bug in stateM and modifyM of thread local State effect that might've caused dropped state updates (#237).
  • Breaking changes:
    • localSeqLend, localLend, localSeqBorrow and localBorrow now take a list of effects instead of a single one.
    • Effectful.Error.Static.throwError now requires the error type to have a Show constraint. If this is not the case for some of your error types, use throwError_ for them.
    • ThrowError operation from the dynamic version of the Error effect was replaced with ThrowErrorWith.
    • stateEnv and modifyEnv now take pure modification functions. If you rely on their old forms, switch to a combination of getEnv and putEnv.
    • runStateMVar, evalStateMVar and execStateMVar now take a strict MVar' from the strict-mutable-base package.

effectful-core-2.3.1.0 (2024-06-07)

  • Drop support for GHC 8.8.
  • Remove inaccurate information from the Show instance of ErrorWrapper.
  • Add Effectful.Provider.List, generalization of Effectful.Provider.
  • Respect withFrozenCallStack used by callers of send.
  • Support exchange of effects between the environment of the handler and the local one via localSeqLend, localLend, localSeqBorrow and localBorrow from Effectful.Dispatch.Dynamic.

effectful-core-2.3.0.1 (2023-11-13)

  • Prevent internal functions from appending call stack frames to handlers.

effectful-core-2.3.0.0 (2023-09-13)

  • Deprecate withConcEffToIO.
  • Make withEffToIO take an explicit unlifting strategy for the sake of consistency with unlifting functions from Effectful.Dispatch.Dynamic and easier to understand API.
  • Add support for turning an effect handler into an effectful operation via the Provider effect.
  • Add runErrorWith and runErrorNoCallStackWith to Effectful.Error.Dynamic and Effectful.Error.Static.
  • Add support for having multiple effects of the same type in scope via the Labeled effect.

effectful-core-2.2.2.2 (2023-03-13)

  • Allow inject to turn a monomorphic effect stack into a polymorphic one.
  • Use C sources only with GHC < 9.
  • Force inlining of bracket early to work around excessive inlining problem with GHC 9.6 (https://gitlab.haskell.org/ghc/ghc/-/issues/22824).

effectful-core-2.2.2.1 (2023-01-12)

  • Stop using the internal library because of bugs in stack.

effectful-core-2.2.2.0 (2023-01-11)

  • Add withSeqEffToIO and withConcEffToIO to Effectful.
  • Use strict IORef and MVar variants where appropriate.
  • Make inject work with effect stacks sharing a polymorphic suffix.

effectful-core-2.2.1.0 (2022-11-09)

  • Add localSeqLift and localLift to Effectful.Dispatch.Dynamic.

effectful-core-2.2.0.0 (2022-10-24)

  • Change PrimState for Eff from RealWorld to PrimStateEff to prevent the Prim effect from executing arbitrary IO actions via ioToPrim.
  • Deprecate (:>>) as GHC can't efficiently deal with type families.
  • Add support for the Alternative and MonadPlus instances for Eff via the NonDet effect.

effectful-core-2.1.0.0 (2022-08-22)

  • Include the e :> localEs constraint in the EffectHandler to allow more flexibility in handling higher order effects.
  • Do not include internal stack frames in throwError from Effectful.Error.Dynamic.

effectful-core-2.0.0.0 (2022-08-12)

  • Make storage references in the environment immutable.
  • Remove checkSizeEnv and forkEnv from Effectful.Dispatch.Static.Primitive.
  • Add internal versioning of effects to prevent leakage of unsafeCoerce.
  • Make interpose and impose properly interact with other handlers.

effectful-core-1.2.0.0 (2022-07-28)

  • Change SuffixOf to SharedSuffix and make it behave as advertised.
  • Add raiseWith.

effectful-core-1.1.0.0 (2022-07-19)

  • Don't reset the UnliftStrategy to SeqUnlift inside the continuation of withEffToIO.
  • Add withReader.

effectful-core-1.0.0.0 (2022-07-13)

  • Initial release.