diff --git a/CHANGELOG.md b/CHANGELOG.md --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,3 +1,21 @@ +# effectful-2.6.1.0 (2025-08-30) +* Add `MonadError`, `MonadReader`, `MonadState` and `MonadWriter` instances for + `Eff` for compatibility with existing code. +* Re-export `writeTMVar` from `stm-2.5.1.0` in `Effectful.Concurrent.STM`. +* Add `cancelMany` to `Effectful.Concurrent.Async`. + +# 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. +* Re-export `ThreadId` from `Effectful.Concurrent` for convenience. +* **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-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 diff --git a/README.md b/README.md --- a/README.md +++ b/README.md @@ -1,12 +1,12 @@ # effectful -[![Build Status](https://github.com/haskell-effectful/effectful/workflows/Haskell-CI/badge.svg?branch=master)](https://github.com/haskell-effectful/effectful/actions?query=branch%3Amaster) +[![CI](https://github.com/haskell-effectful/effectful/actions/workflows/haskell-ci.yml/badge.svg?branch=master)](https://github.com/haskell-effectful/effectful/actions/workflows/haskell-ci.yml) [![Hackage](https://img.shields.io/hackage/v/effectful.svg)](https://hackage.haskell.org/package/effectful) [![Stackage LTS](https://www.stackage.org/package/effectful/badge/lts)](https://www.stackage.org/lts/package/effectful) [![Stackage Nightly](https://www.stackage.org/package/effectful/badge/nightly)](https://www.stackage.org/nightly/package/effectful) - + An easy to use, fast extensible effects library with seamless integration with the existing Haskell ecosystem. diff --git a/bench/FileSizes.hs b/bench/FileSizes.hs --- a/bench/FileSizes.hs +++ b/bench/FileSizes.hs @@ -1,6 +1,5 @@ {-# LANGUAGE BlockArguments #-} {-# LANGUAGE CPP #-} -{-# LANGUAGE UndecidableInstances #-} module FileSizes where import Control.Exception diff --git a/effectful.cabal b/effectful.cabal --- a/effectful.cabal +++ b/effectful.cabal @@ -1,7 +1,7 @@ cabal-version: 3.0 build-type: Simple name: effectful -version: 2.5.1.0 +version: 2.6.1.0 license: BSD-3-Clause license-file: LICENSE category: Control @@ -22,7 +22,7 @@ CHANGELOG.md README.md -tested-with: GHC == { 8.10.7, 9.0.2, 9.2.8, 9.4.8, 9.6.5, 9.8.3, 9.10.1, 9.12.1 } +tested-with: GHC == { 8.10.7, 9.0.2, 9.2.8, 9.4.8, 9.6.7, 9.8.4, 9.10.2, 9.12.2, 9.14.1 } bug-reports: https://github.com/haskell-effectful/effectful/issues source-repository head @@ -66,19 +66,20 @@ TypeApplications TypeFamilies TypeOperators + UndecidableInstances library import: language build-depends: base >= 4.14 && < 5 - , async >= 2.2.2 + , async >= 2.2.5 , bytestring >= 0.10 , directory >= 1.3.2 - , effectful-core >= 2.5.1.0 && < 2.5.2.0 + , effectful-core >= 2.6.1.0 && < 2.6.2.0 , process >= 1.6.9 , strict-mutable-base >= 1.1.0.0 , time >= 1.9.2 - , stm >= 2.5.0.0 + , stm >= 2.5.1.0 , unliftio >= 0.2.20 hs-source-dirs: src @@ -188,10 +189,10 @@ if impl(ghc < 9.9) build-depends: freer-simple >= 1.2.1.2 - if impl(ghc < 9.11) - build-depends: fused-effects >= 1.1.2.2 + if impl(ghc < 9.15) + build-depends: fused-effects >= 1.1.2.3 - if impl(ghc < 9.11) + if impl(ghc < 9.15) build-depends: polysemy >= 1.9.2.0 build-depends: base diff --git a/src/Effectful/Concurrent.hs b/src/Effectful/Concurrent.hs --- a/src/Effectful/Concurrent.hs +++ b/src/Effectful/Concurrent.hs @@ -20,6 +20,7 @@ , runConcurrent -- * Basic concurrency operations + , C.ThreadId , myThreadId , forkIO , forkFinally diff --git a/src/Effectful/Concurrent/Async.hs b/src/Effectful/Concurrent/Async.hs --- a/src/Effectful/Concurrent/Async.hs +++ b/src/Effectful/Concurrent/Async.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE UndecidableInstances #-} -- | Lifted "Control.Concurrent.Async". module Effectful.Concurrent.Async ( -- * Effect @@ -18,7 +17,8 @@ -- ** Querying 'Async's , wait, poll, waitCatch, A.asyncThreadId - , cancel, uninterruptibleCancel, cancelWith, A.AsyncCancelled(..) + , cancel, cancelMany, uninterruptibleCancel, cancelWith + , A.AsyncCancelled(..) , A.compareAsyncs -- ** High-level utilities @@ -173,6 +173,12 @@ -- | Lifted 'A.cancel'. cancel :: Concurrent :> es => Async a -> Eff es () cancel = unsafeEff_ . A.cancel + +-- | Lifted 'A.cancelMany'. +-- +-- @since 2.6.1.0 +cancelMany :: Concurrent :> es => [Async a] -> Eff es () +cancelMany = unsafeEff_ . A.cancelMany -- | Lifted 'A.cancelWith'. cancelWith :: (Exception e, Concurrent :> es) => Async a -> e -> Eff es () diff --git a/src/Effectful/Concurrent/STM.hs b/src/Effectful/Concurrent/STM.hs --- a/src/Effectful/Concurrent/STM.hs +++ b/src/Effectful/Concurrent/STM.hs @@ -37,6 +37,7 @@ , STM.takeTMVar , STM.putTMVar , STM.readTMVar + , STM.writeTMVar , STM.tryReadTMVar , STM.swapTMVar , STM.tryTakeTMVar diff --git a/src/Effectful/FileSystem/IO/ByteString.hs b/src/Effectful/FileSystem/IO/ByteString.hs --- a/src/Effectful/FileSystem/IO/ByteString.hs +++ b/src/Effectful/FileSystem/IO/ByteString.hs @@ -36,7 +36,6 @@ ) where import Data.ByteString (ByteString) -import Data.ByteString qualified as BS import Data.ByteString.Char8 qualified as BS8 import Prelude hiding (appendFile, readFile, writeFile) import System.IO (Handle) @@ -44,6 +43,10 @@ import Effectful import Effectful.Dispatch.Static import Effectful.FileSystem + +#if MIN_VERSION_bytestring(0,11,2) +import Data.ByteString qualified as BS +#endif ---------------------------------------- -- Introducing and eliminating ByteStrings diff --git a/tests/ReaderTests.hs b/tests/ReaderTests.hs --- a/tests/ReaderTests.hs +++ b/tests/ReaderTests.hs @@ -5,13 +5,14 @@ import Effectful import Effectful.Dispatch.Dynamic -import Effectful.Reader.Dynamic +import Effectful.Reader.Dynamic qualified as D +import Effectful.Reader.Static qualified as S import Utils qualified as U readerTests :: TestTree readerTests = testGroup "Reader" - [ testCase "local works in handlers (dynamic/static)" $ test_localInHandler runReader - , testCase "local works in handlers (dynamic/pure)" $ test_localInHandler runPureReader + [ testCase "local works in handlers (static)" test_localInHandlerStatic + , testCase "local works in handlers (dynamic)" test_localInHandlerDynamic ] data SomeEff :: Effect where @@ -19,21 +20,16 @@ type instance DispatchOf SomeEff = Dynamic -test_localInHandler - :: (forall r es a. r -> Eff (Reader r : es) a -> Eff es a) - -> Assertion -test_localInHandler runR = runEff . runR "global" . interpret f $ do - local (const "local") $ send SomeAction +test_localInHandlerStatic :: Assertion +test_localInHandlerStatic = runEff . S.runReader "global" . interpret f $ do + S.local (const "local") $ send SomeAction where - f :: (IOE :> es, Reader String :> es) => EffectHandler SomeEff es - f _ SomeAction = U.assertEqual "expected result" "local" =<< ask + f :: (IOE :> es, S.Reader String :> es) => EffectHandler SomeEff es + f _ SomeAction = U.assertEqual "expected result" "local" =<< S.ask --- | Purely dynamic Reader for testing purposes. -runPureReader :: r -> Eff (Reader r : es) a -> Eff es a -runPureReader r0 = interpret (handler r0) +test_localInHandlerDynamic :: Assertion +test_localInHandlerDynamic = runEff . D.runReader "global" . interpret f $ do + D.local (const "local") $ send SomeAction where - handler :: r -> EffectHandler (Reader r) handlerEs - handler r env = \case - Ask -> pure r - Local f m -> localSeqUnlift env $ \unlift -> do - unlift $ interpose (handler $ f r) m + f :: (IOE :> es, D.Reader String :> es) => EffectHandler SomeEff es + f _ SomeAction = U.assertEqual "expected result" "local" =<< D.ask