effectful 2.5.1.0 → 2.6.0.0

raw patch · 6 files changed

+39/−27 lines, 6 filesdep ~effectful-coredep ~fused-effectsPVP ok

version bump matches the API change (PVP)

Dependency ranges changed: effectful-core, fused-effects

API changes (from Hackage documentation)

+ Effectful.Concurrent: data ThreadId

- Effectful.Concurrent: data Concurrent :: Effect

+ Effectful.Concurrent: data Concurrent (a :: Type -> Type) b

- Effectful.Concurrent: forkFinally :: (HasCallStack, Concurrent :> es) => Eff es a -> (Either SomeException a -> Eff es ()) -> Eff es ThreadId

+ Effectful.Concurrent: forkFinally :: forall (es :: [Effect]) a. (HasCallStack, Concurrent :> es) => Eff es a -> (Either SomeException a -> Eff es ()) -> Eff es ThreadId

- Effectful.Concurrent: forkIO :: (HasCallStack, Concurrent :> es) => Eff es () -> Eff es ThreadId

+ Effectful.Concurrent: forkIO :: forall (es :: [Effect]). (HasCallStack, Concurrent :> es) => Eff es () -> Eff es ThreadId

- Effectful.Concurrent: forkIOWithUnmask :: (HasCallStack, Concurrent :> es) => ((forall a. Eff es a -> Eff es a) -> Eff es ()) -> Eff es ThreadId

+ Effectful.Concurrent: forkIOWithUnmask :: forall (es :: [Effect]). (HasCallStack, Concurrent :> es) => ((forall a. () => Eff es a -> Eff es a) -> Eff es ()) -> Eff es ThreadId

- Effectful.Concurrent: forkOS :: (HasCallStack, Concurrent :> es) => Eff es () -> Eff es ThreadId

+ Effectful.Concurrent: forkOS :: forall (es :: [Effect]). (HasCallStack, Concurrent :> es) => Eff es () -> Eff es ThreadId

- Effectful.Concurrent: forkOSWithUnmask :: (HasCallStack, Concurrent :> es) => ((forall a. Eff es a -> Eff es a) -> Eff es ()) -> Eff es ThreadId

+ Effectful.Concurrent: forkOSWithUnmask :: forall (es :: [Effect]). (HasCallStack, Concurrent :> es) => ((forall a. () => Eff es a -> Eff es a) -> Eff es ()) -> Eff es ThreadId

- Effectful.Concurrent: forkOn :: (HasCallStack, Concurrent :> es) => Int -> Eff es () -> Eff es ThreadId

+ Effectful.Concurrent: forkOn :: forall (es :: [Effect]). (HasCallStack, Concurrent :> es) => Int -> Eff es () -> Eff es ThreadId

- Effectful.Concurrent: forkOnWithUnmask :: (HasCallStack, Concurrent :> es) => Int -> ((forall a. Eff es a -> Eff es a) -> Eff es ()) -> Eff es ThreadId

+ Effectful.Concurrent: forkOnWithUnmask :: forall (es :: [Effect]). (HasCallStack, Concurrent :> es) => Int -> ((forall a. () => Eff es a -> Eff es a) -> Eff es ()) -> Eff es ThreadId

- Effectful.Concurrent: getNumCapabilities :: Concurrent :> es => Eff es Int

+ Effectful.Concurrent: getNumCapabilities :: forall (es :: [Effect]). Concurrent :> es => Eff es Int

- Effectful.Concurrent: getNumProcessors :: Concurrent :> es => Eff es Int

+ Effectful.Concurrent: getNumProcessors :: forall (es :: [Effect]). Concurrent :> es => Eff es Int

- Effectful.Concurrent: isCurrentThreadBound :: Concurrent :> es => Eff es Bool

+ Effectful.Concurrent: isCurrentThreadBound :: forall (es :: [Effect]). Concurrent :> es => Eff es Bool

- Effectful.Concurrent: killThread :: Concurrent :> es => ThreadId -> Eff es ()

+ Effectful.Concurrent: killThread :: forall (es :: [Effect]). Concurrent :> es => ThreadId -> Eff es ()

- Effectful.Concurrent: mkWeakThreadId :: Concurrent :> es => ThreadId -> Eff es (Weak ThreadId)

+ Effectful.Concurrent: mkWeakThreadId :: forall (es :: [Effect]). Concurrent :> es => ThreadId -> Eff es (Weak ThreadId)

- Effectful.Concurrent: myThreadId :: Concurrent :> es => Eff es ThreadId

+ Effectful.Concurrent: myThreadId :: forall (es :: [Effect]). Concurrent :> es => Eff es ThreadId

- Effectful.Concurrent: runConcurrent :: (HasCallStack, IOE :> es) => Eff (Concurrent : es) a -> Eff es a

+ Effectful.Concurrent: runConcurrent :: forall (es :: [Effect]) a. (HasCallStack, IOE :> es) => Eff (Concurrent ': es) a -> Eff es a

- Effectful.Concurrent: runInBoundThread :: (HasCallStack, Concurrent :> es) => Eff es a -> Eff es a

+ Effectful.Concurrent: runInBoundThread :: forall (es :: [Effect]) a. (HasCallStack, Concurrent :> es) => Eff es a -> Eff es a

- Effectful.Concurrent: runInUnboundThread :: (HasCallStack, Concurrent :> es) => Eff es a -> Eff es a

+ Effectful.Concurrent: runInUnboundThread :: forall (es :: [Effect]) a. (HasCallStack, Concurrent :> es) => Eff es a -> Eff es a

- Effectful.Concurrent: setNumCapabilities :: Concurrent :> es => Int -> Eff es ()

+ Effectful.Concurrent: setNumCapabilities :: forall (es :: [Effect]). Concurrent :> es => Int -> Eff es ()

- Effectful.Concurrent: threadCapability :: Concurrent :> es => ThreadId -> Eff es (Int, Bool)

+ Effectful.Concurrent: threadCapability :: forall (es :: [Effect]). Concurrent :> es => ThreadId -> Eff es (Int, Bool)

- Effectful.Concurrent: threadDelay :: Concurrent :> es => Int -> Eff es ()

+ Effectful.Concurrent: threadDelay :: forall (es :: [Effect]). Concurrent :> es => Int -> Eff es ()

- Effectful.Concurrent: threadWaitRead :: Concurrent :> es => Fd -> Eff es ()

+ Effectful.Concurrent: threadWaitRead :: forall (es :: [Effect]). Concurrent :> es => Fd -> Eff es ()

- Effectful.Concurrent: threadWaitReadSTM :: Concurrent :> es => Fd -> Eff es (STM (), Eff es ())

+ Effectful.Concurrent: threadWaitReadSTM :: forall (es :: [Effect]). Concurrent :> es => Fd -> Eff es (STM (), Eff es ())

- Effectful.Concurrent: threadWaitWrite :: Concurrent :> es => Fd -> Eff es ()

+ Effectful.Concurrent: threadWaitWrite :: forall (es :: [Effect]). Concurrent :> es => Fd -> Eff es ()

- Effectful.Concurrent: threadWaitWriteSTM :: Concurrent :> es => Fd -> Eff es (STM (), Eff es ())

+ Effectful.Concurrent: threadWaitWriteSTM :: forall (es :: [Effect]). Concurrent :> es => Fd -> Eff es (STM (), Eff es ())

- Effectful.Concurrent: throwTo :: (Concurrent :> es, Exception e) => ThreadId -> e -> Eff es ()

+ Effectful.Concurrent: throwTo :: forall (es :: [Effect]) e. (Concurrent :> es, Exception e) => ThreadId -> e -> Eff es ()

- Effectful.Concurrent: yield :: Concurrent :> es => Eff es ()

+ Effectful.Concurrent: yield :: forall (es :: [Effect]). Concurrent :> es => Eff es ()

- Effectful.Concurrent.Async: Concurrently :: Eff es a -> Concurrently es a

+ Effectful.Concurrent.Async: Concurrently :: Eff es a -> Concurrently (es :: [Effect]) a

- Effectful.Concurrent.Async: [runConcurrently] :: Concurrently es a -> Eff es a

+ Effectful.Concurrent.Async: [runConcurrently] :: Concurrently (es :: [Effect]) a -> Eff es a

- Effectful.Concurrent.Async: async :: (HasCallStack, Concurrent :> es) => Eff es a -> Eff es (Async a)

+ Effectful.Concurrent.Async: async :: forall (es :: [Effect]) a. (HasCallStack, Concurrent :> es) => Eff es a -> Eff es (Async a)

- Effectful.Concurrent.Async: asyncBound :: (HasCallStack, Concurrent :> es) => Eff es a -> Eff es (Async a)

+ Effectful.Concurrent.Async: asyncBound :: forall (es :: [Effect]) a. (HasCallStack, Concurrent :> es) => Eff es a -> Eff es (Async a)

- Effectful.Concurrent.Async: asyncOn :: (HasCallStack, Concurrent :> es) => Int -> Eff es a -> Eff es (Async a)

+ Effectful.Concurrent.Async: asyncOn :: forall (es :: [Effect]) a. (HasCallStack, Concurrent :> es) => Int -> Eff es a -> Eff es (Async a)

- Effectful.Concurrent.Async: asyncOnWithUnmask :: (HasCallStack, Concurrent :> es) => Int -> ((forall b. Eff es b -> Eff es b) -> Eff es a) -> Eff es (Async a)

+ Effectful.Concurrent.Async: asyncOnWithUnmask :: forall (es :: [Effect]) a. (HasCallStack, Concurrent :> es) => Int -> ((forall b. () => Eff es b -> Eff es b) -> Eff es a) -> Eff es (Async a)

- Effectful.Concurrent.Async: asyncWithUnmask :: (HasCallStack, Concurrent :> es) => ((forall b. Eff es b -> Eff es b) -> Eff es a) -> Eff es (Async a)

+ Effectful.Concurrent.Async: asyncWithUnmask :: forall (es :: [Effect]) a. (HasCallStack, Concurrent :> es) => ((forall b. () => Eff es b -> Eff es b) -> Eff es a) -> Eff es (Async a)

- Effectful.Concurrent.Async: cancel :: Concurrent :> es => Async a -> Eff es ()

+ Effectful.Concurrent.Async: cancel :: forall (es :: [Effect]) a. Concurrent :> es => Async a -> Eff es ()

- Effectful.Concurrent.Async: cancelWith :: (Exception e, Concurrent :> es) => Async a -> e -> Eff es ()

+ Effectful.Concurrent.Async: cancelWith :: forall e (es :: [Effect]) a. (Exception e, Concurrent :> es) => Async a -> e -> Eff es ()

- Effectful.Concurrent.Async: conc :: Eff es a -> Conc es a

+ Effectful.Concurrent.Async: conc :: forall (es :: [Effect]) a. Eff es a -> Conc es a

- Effectful.Concurrent.Async: concurrently :: (HasCallStack, Concurrent :> es) => Eff es a -> Eff es b -> Eff es (a, b)

+ Effectful.Concurrent.Async: concurrently :: forall (es :: [Effect]) a b. (HasCallStack, Concurrent :> es) => Eff es a -> Eff es b -> Eff es (a, b)

- Effectful.Concurrent.Async: concurrently_ :: (HasCallStack, Concurrent :> es) => Eff es a -> Eff es b -> Eff es ()

+ Effectful.Concurrent.Async: concurrently_ :: forall (es :: [Effect]) a b. (HasCallStack, Concurrent :> es) => Eff es a -> Eff es b -> Eff es ()

- Effectful.Concurrent.Async: data () => Async a

+ Effectful.Concurrent.Async: data Async a

- Effectful.Concurrent.Async: data () => AsyncCancelled

+ Effectful.Concurrent.Async: data AsyncCancelled

- Effectful.Concurrent.Async: data Conc :: [Effect] -> Type -> Type

+ Effectful.Concurrent.Async: data Conc (a :: [Effect]) b

- Effectful.Concurrent.Async: data () => ConcException

+ Effectful.Concurrent.Async: data ConcException

- Effectful.Concurrent.Async: data Concurrent :: Effect

+ Effectful.Concurrent.Async: data Concurrent (a :: Type -> Type) b

- Effectful.Concurrent.Async: data () => ExceptionInLinkedThread

+ Effectful.Concurrent.Async: data ExceptionInLinkedThread

- Effectful.Concurrent.Async: forConcurrently :: (HasCallStack, Traversable f, Concurrent :> es) => f a -> (a -> Eff es b) -> Eff es (f b)

+ Effectful.Concurrent.Async: forConcurrently :: forall f (es :: [Effect]) a b. (HasCallStack, Traversable f, Concurrent :> es) => f a -> (a -> Eff es b) -> Eff es (f b)

- Effectful.Concurrent.Async: forConcurrently_ :: (HasCallStack, Foldable f, Concurrent :> es) => f a -> (a -> Eff es b) -> Eff es ()

+ Effectful.Concurrent.Async: forConcurrently_ :: forall f (es :: [Effect]) a b. (HasCallStack, Foldable f, Concurrent :> es) => f a -> (a -> Eff es b) -> Eff es ()

- Effectful.Concurrent.Async: link :: Concurrent :> es => Async a -> Eff es ()

+ Effectful.Concurrent.Async: link :: forall (es :: [Effect]) a. Concurrent :> es => Async a -> Eff es ()

- Effectful.Concurrent.Async: link2 :: Concurrent :> es => Async a -> Async b -> Eff es ()

+ Effectful.Concurrent.Async: link2 :: forall (es :: [Effect]) a b. Concurrent :> es => Async a -> Async b -> Eff es ()

- Effectful.Concurrent.Async: link2Only :: Concurrent :> es => (SomeException -> Bool) -> Async a -> Async b -> Eff es ()

+ Effectful.Concurrent.Async: link2Only :: forall (es :: [Effect]) a b. Concurrent :> es => (SomeException -> Bool) -> Async a -> Async b -> Eff es ()

- Effectful.Concurrent.Async: linkOnly :: Concurrent :> es => (SomeException -> Bool) -> Async a -> Eff es ()

+ Effectful.Concurrent.Async: linkOnly :: forall (es :: [Effect]) a. Concurrent :> es => (SomeException -> Bool) -> Async a -> Eff es ()

- Effectful.Concurrent.Async: mapConcurrently :: (HasCallStack, Traversable f, Concurrent :> es) => (a -> Eff es b) -> f a -> Eff es (f b)

+ Effectful.Concurrent.Async: mapConcurrently :: forall f (es :: [Effect]) a b. (HasCallStack, Traversable f, Concurrent :> es) => (a -> Eff es b) -> f a -> Eff es (f b)

- Effectful.Concurrent.Async: mapConcurrently_ :: (HasCallStack, Foldable f, Concurrent :> es) => (a -> Eff es b) -> f a -> Eff es ()

+ Effectful.Concurrent.Async: mapConcurrently_ :: forall f (es :: [Effect]) a b. (HasCallStack, Foldable f, Concurrent :> es) => (a -> Eff es b) -> f a -> Eff es ()

- Effectful.Concurrent.Async: newtype Concurrently es a

+ Effectful.Concurrent.Async: newtype Concurrently (es :: [Effect]) a

- Effectful.Concurrent.Async: poll :: Concurrent :> es => Async a -> Eff es (Maybe (Either SomeException a))

+ Effectful.Concurrent.Async: poll :: forall (es :: [Effect]) a. Concurrent :> es => Async a -> Eff es (Maybe (Either SomeException a))

- Effectful.Concurrent.Async: pooledForConcurrently :: (HasCallStack, Concurrent :> es, Traversable t) => t a -> (a -> Eff es b) -> Eff es (t b)

+ Effectful.Concurrent.Async: pooledForConcurrently :: forall (es :: [Effect]) t a b. (HasCallStack, Concurrent :> es, Traversable t) => t a -> (a -> Eff es b) -> Eff es (t b)

- Effectful.Concurrent.Async: pooledForConcurrentlyN :: (HasCallStack, Concurrent :> es, Traversable t) => Int -> t a -> (a -> Eff es b) -> Eff es (t b)

+ Effectful.Concurrent.Async: pooledForConcurrentlyN :: forall (es :: [Effect]) t a b. (HasCallStack, Concurrent :> es, Traversable t) => Int -> t a -> (a -> Eff es b) -> Eff es (t b)

- Effectful.Concurrent.Async: pooledForConcurrentlyN_ :: (HasCallStack, Concurrent :> es, Foldable f) => Int -> f a -> (a -> Eff es b) -> Eff es ()

+ Effectful.Concurrent.Async: pooledForConcurrentlyN_ :: forall (es :: [Effect]) f a b. (HasCallStack, Concurrent :> es, Foldable f) => Int -> f a -> (a -> Eff es b) -> Eff es ()

- Effectful.Concurrent.Async: pooledForConcurrently_ :: (HasCallStack, Concurrent :> es, Foldable f) => f a -> (a -> Eff es b) -> Eff es ()

+ Effectful.Concurrent.Async: pooledForConcurrently_ :: forall (es :: [Effect]) f a b. (HasCallStack, Concurrent :> es, Foldable f) => f a -> (a -> Eff es b) -> Eff es ()

- Effectful.Concurrent.Async: pooledMapConcurrently :: (HasCallStack, Concurrent :> es, Traversable t) => (a -> Eff es b) -> t a -> Eff es (t b)

+ Effectful.Concurrent.Async: pooledMapConcurrently :: forall (es :: [Effect]) t a b. (HasCallStack, Concurrent :> es, Traversable t) => (a -> Eff es b) -> t a -> Eff es (t b)

- Effectful.Concurrent.Async: pooledMapConcurrentlyN :: (HasCallStack, Concurrent :> es, Traversable t) => Int -> (a -> Eff es b) -> t a -> Eff es (t b)

+ Effectful.Concurrent.Async: pooledMapConcurrentlyN :: forall (es :: [Effect]) t a b. (HasCallStack, Concurrent :> es, Traversable t) => Int -> (a -> Eff es b) -> t a -> Eff es (t b)

- Effectful.Concurrent.Async: pooledMapConcurrentlyN_ :: (HasCallStack, Concurrent :> es, Foldable f) => Int -> (a -> Eff es b) -> f a -> Eff es ()

+ Effectful.Concurrent.Async: pooledMapConcurrentlyN_ :: forall (es :: [Effect]) f a b. (HasCallStack, Concurrent :> es, Foldable f) => Int -> (a -> Eff es b) -> f a -> Eff es ()

- Effectful.Concurrent.Async: pooledMapConcurrently_ :: (HasCallStack, Concurrent :> es, Foldable f) => (a -> Eff es b) -> f a -> Eff es ()

+ Effectful.Concurrent.Async: pooledMapConcurrently_ :: forall (es :: [Effect]) f a b. (HasCallStack, Concurrent :> es, Foldable f) => (a -> Eff es b) -> f a -> Eff es ()

- Effectful.Concurrent.Async: pooledReplicateConcurrently :: (HasCallStack, Concurrent :> es) => Int -> Eff es a -> Eff es [a]

+ Effectful.Concurrent.Async: pooledReplicateConcurrently :: forall (es :: [Effect]) a. (HasCallStack, Concurrent :> es) => Int -> Eff es a -> Eff es [a]

- Effectful.Concurrent.Async: pooledReplicateConcurrentlyN :: (HasCallStack, Concurrent :> es) => Int -> Int -> Eff es a -> Eff es [a]

+ Effectful.Concurrent.Async: pooledReplicateConcurrentlyN :: forall (es :: [Effect]) a. (HasCallStack, Concurrent :> es) => Int -> Int -> Eff es a -> Eff es [a]

- Effectful.Concurrent.Async: pooledReplicateConcurrentlyN_ :: (HasCallStack, Concurrent :> es) => Int -> Int -> Eff es a -> Eff es ()

+ Effectful.Concurrent.Async: pooledReplicateConcurrentlyN_ :: forall (es :: [Effect]) a. (HasCallStack, Concurrent :> es) => Int -> Int -> Eff es a -> Eff es ()

- Effectful.Concurrent.Async: pooledReplicateConcurrently_ :: (HasCallStack, Concurrent :> es) => Int -> Eff es a -> Eff es ()

+ Effectful.Concurrent.Async: pooledReplicateConcurrently_ :: forall (es :: [Effect]) a. (HasCallStack, Concurrent :> es) => Int -> Eff es a -> Eff es ()

- Effectful.Concurrent.Async: race :: (HasCallStack, Concurrent :> es) => Eff es a -> Eff es b -> Eff es (Either a b)

+ Effectful.Concurrent.Async: race :: forall (es :: [Effect]) a b. (HasCallStack, Concurrent :> es) => Eff es a -> Eff es b -> Eff es (Either a b)

- Effectful.Concurrent.Async: race_ :: (HasCallStack, Concurrent :> es) => Eff es a -> Eff es b -> Eff es ()

+ Effectful.Concurrent.Async: race_ :: forall (es :: [Effect]) a b. (HasCallStack, Concurrent :> es) => Eff es a -> Eff es b -> Eff es ()

- Effectful.Concurrent.Async: replicateConcurrently :: (HasCallStack, Concurrent :> es) => Int -> Eff es a -> Eff es [a]

+ Effectful.Concurrent.Async: replicateConcurrently :: forall (es :: [Effect]) a. (HasCallStack, Concurrent :> es) => Int -> Eff es a -> Eff es [a]

- Effectful.Concurrent.Async: replicateConcurrently_ :: (HasCallStack, Concurrent :> es) => Int -> Eff es a -> Eff es ()

+ Effectful.Concurrent.Async: replicateConcurrently_ :: forall (es :: [Effect]) a. (HasCallStack, Concurrent :> es) => Int -> Eff es a -> Eff es ()

- Effectful.Concurrent.Async: runConc :: (HasCallStack, Concurrent :> es) => Conc es a -> Eff es a

+ Effectful.Concurrent.Async: runConc :: forall (es :: [Effect]) a. (HasCallStack, Concurrent :> es) => Conc es a -> Eff es a

- Effectful.Concurrent.Async: runConcurrent :: (HasCallStack, IOE :> es) => Eff (Concurrent : es) a -> Eff es a

+ Effectful.Concurrent.Async: runConcurrent :: forall (es :: [Effect]) a. (HasCallStack, IOE :> es) => Eff (Concurrent ': es) a -> Eff es a

- Effectful.Concurrent.Async: uninterruptibleCancel :: Concurrent :> es => Async a -> Eff es ()

+ Effectful.Concurrent.Async: uninterruptibleCancel :: forall (es :: [Effect]) a. Concurrent :> es => Async a -> Eff es ()

- Effectful.Concurrent.Async: wait :: Concurrent :> es => Async a -> Eff es a

+ Effectful.Concurrent.Async: wait :: forall (es :: [Effect]) a. Concurrent :> es => Async a -> Eff es a

- Effectful.Concurrent.Async: waitAny :: Concurrent :> es => [Async a] -> Eff es (Async a, a)

+ Effectful.Concurrent.Async: waitAny :: forall (es :: [Effect]) a. Concurrent :> es => [Async a] -> Eff es (Async a, a)

- Effectful.Concurrent.Async: waitAnyCancel :: Concurrent :> es => [Async a] -> Eff es (Async a, a)

+ Effectful.Concurrent.Async: waitAnyCancel :: forall (es :: [Effect]) a. Concurrent :> es => [Async a] -> Eff es (Async a, a)

- Effectful.Concurrent.Async: waitAnyCatch :: Concurrent :> es => [Async a] -> Eff es (Async a, Either SomeException a)

+ Effectful.Concurrent.Async: waitAnyCatch :: forall (es :: [Effect]) a. Concurrent :> es => [Async a] -> Eff es (Async a, Either SomeException a)

- Effectful.Concurrent.Async: waitAnyCatchCancel :: Concurrent :> es => [Async a] -> Eff es (Async a, Either SomeException a)

+ Effectful.Concurrent.Async: waitAnyCatchCancel :: forall (es :: [Effect]) a. Concurrent :> es => [Async a] -> Eff es (Async a, Either SomeException a)

- Effectful.Concurrent.Async: waitBoth :: Concurrent :> es => Async a -> Async b -> Eff es (a, b)

+ Effectful.Concurrent.Async: waitBoth :: forall (es :: [Effect]) a b. Concurrent :> es => Async a -> Async b -> Eff es (a, b)

- Effectful.Concurrent.Async: waitCatch :: Concurrent :> es => Async a -> Eff es (Either SomeException a)

+ Effectful.Concurrent.Async: waitCatch :: forall (es :: [Effect]) a. Concurrent :> es => Async a -> Eff es (Either SomeException a)

- Effectful.Concurrent.Async: waitEither :: Concurrent :> es => Async a -> Async b -> Eff es (Either a b)

+ Effectful.Concurrent.Async: waitEither :: forall (es :: [Effect]) a b. Concurrent :> es => Async a -> Async b -> Eff es (Either a b)

- Effectful.Concurrent.Async: waitEitherCancel :: Concurrent :> es => Async a -> Async b -> Eff es (Either a b)

+ Effectful.Concurrent.Async: waitEitherCancel :: forall (es :: [Effect]) a b. Concurrent :> es => Async a -> Async b -> Eff es (Either a b)

- Effectful.Concurrent.Async: waitEitherCatch :: Concurrent :> es => Async a -> Async b -> Eff es (Either (Either SomeException a) (Either SomeException b))

+ Effectful.Concurrent.Async: waitEitherCatch :: forall (es :: [Effect]) a b. Concurrent :> es => Async a -> Async b -> Eff es (Either (Either SomeException a) (Either SomeException b))

- Effectful.Concurrent.Async: waitEitherCatchCancel :: Concurrent :> es => Async a -> Async b -> Eff es (Either (Either SomeException a) (Either SomeException b))

+ Effectful.Concurrent.Async: waitEitherCatchCancel :: forall (es :: [Effect]) a b. Concurrent :> es => Async a -> Async b -> Eff es (Either (Either SomeException a) (Either SomeException b))

- Effectful.Concurrent.Async: waitEither_ :: Concurrent :> es => Async a -> Async b -> Eff es ()

+ Effectful.Concurrent.Async: waitEither_ :: forall (es :: [Effect]) a b. Concurrent :> es => Async a -> Async b -> Eff es ()

- Effectful.Concurrent.Async: withAsync :: (HasCallStack, Concurrent :> es) => Eff es a -> (Async a -> Eff es b) -> Eff es b

+ Effectful.Concurrent.Async: withAsync :: forall (es :: [Effect]) a b. (HasCallStack, Concurrent :> es) => Eff es a -> (Async a -> Eff es b) -> Eff es b

- Effectful.Concurrent.Async: withAsyncBound :: (HasCallStack, Concurrent :> es) => Eff es a -> (Async a -> Eff es b) -> Eff es b

+ Effectful.Concurrent.Async: withAsyncBound :: forall (es :: [Effect]) a b. (HasCallStack, Concurrent :> es) => Eff es a -> (Async a -> Eff es b) -> Eff es b

- Effectful.Concurrent.Async: withAsyncOn :: (HasCallStack, Concurrent :> es) => Int -> Eff es a -> (Async a -> Eff es b) -> Eff es b

+ Effectful.Concurrent.Async: withAsyncOn :: forall (es :: [Effect]) a b. (HasCallStack, Concurrent :> es) => Int -> Eff es a -> (Async a -> Eff es b) -> Eff es b

- Effectful.Concurrent.Async: withAsyncOnWithUnmask :: (HasCallStack, Concurrent :> es) => Int -> ((forall c. Eff es c -> Eff es c) -> Eff es a) -> (Async a -> Eff es b) -> Eff es b

+ Effectful.Concurrent.Async: withAsyncOnWithUnmask :: forall (es :: [Effect]) a b. (HasCallStack, Concurrent :> es) => Int -> ((forall c. () => Eff es c -> Eff es c) -> Eff es a) -> (Async a -> Eff es b) -> Eff es b

- Effectful.Concurrent.Async: withAsyncWithUnmask :: (HasCallStack, Concurrent :> es) => ((forall c. Eff es c -> Eff es c) -> Eff es a) -> (Async a -> Eff es b) -> Eff es b

+ Effectful.Concurrent.Async: withAsyncWithUnmask :: forall (es :: [Effect]) a b. (HasCallStack, Concurrent :> es) => ((forall c. () => Eff es c -> Eff es c) -> Eff es a) -> (Async a -> Eff es b) -> Eff es b

- Effectful.Concurrent.Chan: data () => Chan a

+ Effectful.Concurrent.Chan: data Chan a

- Effectful.Concurrent.Chan: data Concurrent :: Effect

+ Effectful.Concurrent.Chan: data Concurrent (a :: Type -> Type) b

- Effectful.Concurrent.Chan: dupChan :: Concurrent :> es => Chan a -> Eff es (Chan a)

+ Effectful.Concurrent.Chan: dupChan :: forall (es :: [Effect]) a. Concurrent :> es => Chan a -> Eff es (Chan a)

- Effectful.Concurrent.Chan: getChanContents :: Concurrent :> es => Chan a -> Eff es [a]

+ Effectful.Concurrent.Chan: getChanContents :: forall (es :: [Effect]) a. Concurrent :> es => Chan a -> Eff es [a]

- Effectful.Concurrent.Chan: newChan :: Concurrent :> es => Eff es (Chan a)

+ Effectful.Concurrent.Chan: newChan :: forall (es :: [Effect]) a. Concurrent :> es => Eff es (Chan a)

- Effectful.Concurrent.Chan: readChan :: Concurrent :> es => Chan a -> Eff es a

+ Effectful.Concurrent.Chan: readChan :: forall (es :: [Effect]) a. Concurrent :> es => Chan a -> Eff es a

- Effectful.Concurrent.Chan: runConcurrent :: (HasCallStack, IOE :> es) => Eff (Concurrent : es) a -> Eff es a

+ Effectful.Concurrent.Chan: runConcurrent :: forall (es :: [Effect]) a. (HasCallStack, IOE :> es) => Eff (Concurrent ': es) a -> Eff es a

- Effectful.Concurrent.Chan: writeChan :: Concurrent :> es => Chan a -> a -> Eff es ()

+ Effectful.Concurrent.Chan: writeChan :: forall (es :: [Effect]) a. Concurrent :> es => Chan a -> a -> Eff es ()

- Effectful.Concurrent.Chan: writeList2Chan :: Concurrent :> es => Chan a -> [a] -> Eff es ()

+ Effectful.Concurrent.Chan: writeList2Chan :: forall (es :: [Effect]) a. Concurrent :> es => Chan a -> [a] -> Eff es ()

- Effectful.Concurrent.Chan.Strict: data () => Chan' a

+ Effectful.Concurrent.Chan.Strict: data Chan' a

- Effectful.Concurrent.Chan.Strict: data Concurrent :: Effect

+ Effectful.Concurrent.Chan.Strict: data Concurrent (a :: Type -> Type) b

- Effectful.Concurrent.Chan.Strict: dupChan' :: Concurrent :> es => Chan' a -> Eff es (Chan' a)

+ Effectful.Concurrent.Chan.Strict: dupChan' :: forall (es :: [Effect]) a. Concurrent :> es => Chan' a -> Eff es (Chan' a)

- Effectful.Concurrent.Chan.Strict: getChan'Contents :: Concurrent :> es => Chan' a -> Eff es [a]

+ Effectful.Concurrent.Chan.Strict: getChan'Contents :: forall (es :: [Effect]) a. Concurrent :> es => Chan' a -> Eff es [a]

- Effectful.Concurrent.Chan.Strict: newChan' :: Concurrent :> es => Eff es (Chan' a)

+ Effectful.Concurrent.Chan.Strict: newChan' :: forall (es :: [Effect]) a. Concurrent :> es => Eff es (Chan' a)

- Effectful.Concurrent.Chan.Strict: readChan' :: Concurrent :> es => Chan' a -> Eff es a

+ Effectful.Concurrent.Chan.Strict: readChan' :: forall (es :: [Effect]) a. Concurrent :> es => Chan' a -> Eff es a

- Effectful.Concurrent.Chan.Strict: runConcurrent :: (HasCallStack, IOE :> es) => Eff (Concurrent : es) a -> Eff es a

+ Effectful.Concurrent.Chan.Strict: runConcurrent :: forall (es :: [Effect]) a. (HasCallStack, IOE :> es) => Eff (Concurrent ': es) a -> Eff es a

- Effectful.Concurrent.Chan.Strict: writeChan' :: Concurrent :> es => Chan' a -> a -> Eff es ()

+ Effectful.Concurrent.Chan.Strict: writeChan' :: forall (es :: [Effect]) a. Concurrent :> es => Chan' a -> a -> Eff es ()

- Effectful.Concurrent.Chan.Strict: writeList2Chan' :: Concurrent :> es => Chan' a -> [a] -> Eff es ()

+ Effectful.Concurrent.Chan.Strict: writeList2Chan' :: forall (es :: [Effect]) a. Concurrent :> es => Chan' a -> [a] -> Eff es ()

- Effectful.Concurrent.MVar: data Concurrent :: Effect

+ Effectful.Concurrent.MVar: data Concurrent (a :: Type -> Type) b

- Effectful.Concurrent.MVar: data () => MVar a

+ Effectful.Concurrent.MVar: data MVar a

- Effectful.Concurrent.MVar: isEmptyMVar :: Concurrent :> es => MVar a -> Eff es Bool

+ Effectful.Concurrent.MVar: isEmptyMVar :: forall (es :: [Effect]) a. Concurrent :> es => MVar a -> Eff es Bool

- Effectful.Concurrent.MVar: mkWeakMVar :: (HasCallStack, Concurrent :> es) => MVar a -> Eff es () -> Eff es (Weak (MVar a))

+ Effectful.Concurrent.MVar: mkWeakMVar :: forall (es :: [Effect]) a. (HasCallStack, Concurrent :> es) => MVar a -> Eff es () -> Eff es (Weak (MVar a))

- Effectful.Concurrent.MVar: modifyMVar :: Concurrent :> es => MVar a -> (a -> Eff es (a, b)) -> Eff es b

+ Effectful.Concurrent.MVar: modifyMVar :: forall (es :: [Effect]) a b. Concurrent :> es => MVar a -> (a -> Eff es (a, b)) -> Eff es b

- Effectful.Concurrent.MVar: modifyMVarMasked :: Concurrent :> es => MVar a -> (a -> Eff es (a, b)) -> Eff es b

+ Effectful.Concurrent.MVar: modifyMVarMasked :: forall (es :: [Effect]) a b. Concurrent :> es => MVar a -> (a -> Eff es (a, b)) -> Eff es b

- Effectful.Concurrent.MVar: modifyMVarMasked_ :: Concurrent :> es => MVar a -> (a -> Eff es a) -> Eff es ()

+ Effectful.Concurrent.MVar: modifyMVarMasked_ :: forall (es :: [Effect]) a. Concurrent :> es => MVar a -> (a -> Eff es a) -> Eff es ()

- Effectful.Concurrent.MVar: modifyMVar_ :: Concurrent :> es => MVar a -> (a -> Eff es a) -> Eff es ()

+ Effectful.Concurrent.MVar: modifyMVar_ :: forall (es :: [Effect]) a. Concurrent :> es => MVar a -> (a -> Eff es a) -> Eff es ()

- Effectful.Concurrent.MVar: newEmptyMVar :: Concurrent :> es => Eff es (MVar a)

+ Effectful.Concurrent.MVar: newEmptyMVar :: forall (es :: [Effect]) a. Concurrent :> es => Eff es (MVar a)

- Effectful.Concurrent.MVar: newMVar :: Concurrent :> es => a -> Eff es (MVar a)

+ Effectful.Concurrent.MVar: newMVar :: forall (es :: [Effect]) a. Concurrent :> es => a -> Eff es (MVar a)

- Effectful.Concurrent.MVar: putMVar :: Concurrent :> es => MVar a -> a -> Eff es ()

+ Effectful.Concurrent.MVar: putMVar :: forall (es :: [Effect]) a. Concurrent :> es => MVar a -> a -> Eff es ()

- Effectful.Concurrent.MVar: readMVar :: Concurrent :> es => MVar a -> Eff es a

+ Effectful.Concurrent.MVar: readMVar :: forall (es :: [Effect]) a. Concurrent :> es => MVar a -> Eff es a

- Effectful.Concurrent.MVar: runConcurrent :: (HasCallStack, IOE :> es) => Eff (Concurrent : es) a -> Eff es a

+ Effectful.Concurrent.MVar: runConcurrent :: forall (es :: [Effect]) a. (HasCallStack, IOE :> es) => Eff (Concurrent ': es) a -> Eff es a

- Effectful.Concurrent.MVar: swapMVar :: Concurrent :> es => MVar a -> a -> Eff es a

+ Effectful.Concurrent.MVar: swapMVar :: forall (es :: [Effect]) a. Concurrent :> es => MVar a -> a -> Eff es a

- Effectful.Concurrent.MVar: takeMVar :: Concurrent :> es => MVar a -> Eff es a

+ Effectful.Concurrent.MVar: takeMVar :: forall (es :: [Effect]) a. Concurrent :> es => MVar a -> Eff es a

- Effectful.Concurrent.MVar: tryPutMVar :: Concurrent :> es => MVar a -> a -> Eff es Bool

+ Effectful.Concurrent.MVar: tryPutMVar :: forall (es :: [Effect]) a. Concurrent :> es => MVar a -> a -> Eff es Bool

- Effectful.Concurrent.MVar: tryReadMVar :: Concurrent :> es => MVar a -> Eff es (Maybe a)

+ Effectful.Concurrent.MVar: tryReadMVar :: forall (es :: [Effect]) a. Concurrent :> es => MVar a -> Eff es (Maybe a)

- Effectful.Concurrent.MVar: tryTakeMVar :: Concurrent :> es => MVar a -> Eff es (Maybe a)

+ Effectful.Concurrent.MVar: tryTakeMVar :: forall (es :: [Effect]) a. Concurrent :> es => MVar a -> Eff es (Maybe a)

- Effectful.Concurrent.MVar: withMVar :: Concurrent :> es => MVar a -> (a -> Eff es b) -> Eff es b

+ Effectful.Concurrent.MVar: withMVar :: forall (es :: [Effect]) a b. Concurrent :> es => MVar a -> (a -> Eff es b) -> Eff es b

- Effectful.Concurrent.MVar: withMVarMasked :: Concurrent :> es => MVar a -> (a -> Eff es b) -> Eff es b

+ Effectful.Concurrent.MVar: withMVarMasked :: forall (es :: [Effect]) a b. Concurrent :> es => MVar a -> (a -> Eff es b) -> Eff es b

- Effectful.Concurrent.MVar.Strict: data Concurrent :: Effect

+ Effectful.Concurrent.MVar.Strict: data Concurrent (a :: Type -> Type) b

- Effectful.Concurrent.MVar.Strict: data () => MVar' a

+ Effectful.Concurrent.MVar.Strict: data MVar' a

- Effectful.Concurrent.MVar.Strict: isEmptyMVar' :: Concurrent :> es => MVar' a -> Eff es Bool

+ Effectful.Concurrent.MVar.Strict: isEmptyMVar' :: forall (es :: [Effect]) a. Concurrent :> es => MVar' a -> Eff es Bool

- Effectful.Concurrent.MVar.Strict: mkWeakMVar' :: (HasCallStack, Concurrent :> es) => MVar' a -> Eff es () -> Eff es (Weak (MVar' a))

+ Effectful.Concurrent.MVar.Strict: mkWeakMVar' :: forall (es :: [Effect]) a. (HasCallStack, Concurrent :> es) => MVar' a -> Eff es () -> Eff es (Weak (MVar' a))

- Effectful.Concurrent.MVar.Strict: modifyMVar' :: Concurrent :> es => MVar' a -> (a -> Eff es (a, b)) -> Eff es b

+ Effectful.Concurrent.MVar.Strict: modifyMVar' :: forall (es :: [Effect]) a b. Concurrent :> es => MVar' a -> (a -> Eff es (a, b)) -> Eff es b

- Effectful.Concurrent.MVar.Strict: modifyMVar'Masked :: Concurrent :> es => MVar' a -> (a -> Eff es (a, b)) -> Eff es b

+ Effectful.Concurrent.MVar.Strict: modifyMVar'Masked :: forall (es :: [Effect]) a b. Concurrent :> es => MVar' a -> (a -> Eff es (a, b)) -> Eff es b

- Effectful.Concurrent.MVar.Strict: modifyMVar'Masked_ :: Concurrent :> es => MVar' a -> (a -> Eff es a) -> Eff es ()

+ Effectful.Concurrent.MVar.Strict: modifyMVar'Masked_ :: forall (es :: [Effect]) a. Concurrent :> es => MVar' a -> (a -> Eff es a) -> Eff es ()

- Effectful.Concurrent.MVar.Strict: modifyMVar'_ :: Concurrent :> es => MVar' a -> (a -> Eff es a) -> Eff es ()

+ Effectful.Concurrent.MVar.Strict: modifyMVar'_ :: forall (es :: [Effect]) a. Concurrent :> es => MVar' a -> (a -> Eff es a) -> Eff es ()

- Effectful.Concurrent.MVar.Strict: newEmptyMVar' :: Concurrent :> es => Eff es (MVar' a)

+ Effectful.Concurrent.MVar.Strict: newEmptyMVar' :: forall (es :: [Effect]) a. Concurrent :> es => Eff es (MVar' a)

- Effectful.Concurrent.MVar.Strict: newMVar' :: Concurrent :> es => a -> Eff es (MVar' a)

+ Effectful.Concurrent.MVar.Strict: newMVar' :: forall (es :: [Effect]) a. Concurrent :> es => a -> Eff es (MVar' a)

- Effectful.Concurrent.MVar.Strict: putMVar' :: Concurrent :> es => MVar' a -> a -> Eff es ()

+ Effectful.Concurrent.MVar.Strict: putMVar' :: forall (es :: [Effect]) a. Concurrent :> es => MVar' a -> a -> Eff es ()

- Effectful.Concurrent.MVar.Strict: readMVar' :: Concurrent :> es => MVar' a -> Eff es a

+ Effectful.Concurrent.MVar.Strict: readMVar' :: forall (es :: [Effect]) a. Concurrent :> es => MVar' a -> Eff es a

- Effectful.Concurrent.MVar.Strict: runConcurrent :: (HasCallStack, IOE :> es) => Eff (Concurrent : es) a -> Eff es a

+ Effectful.Concurrent.MVar.Strict: runConcurrent :: forall (es :: [Effect]) a. (HasCallStack, IOE :> es) => Eff (Concurrent ': es) a -> Eff es a

- Effectful.Concurrent.MVar.Strict: swapMVar' :: Concurrent :> es => MVar' a -> a -> Eff es a

+ Effectful.Concurrent.MVar.Strict: swapMVar' :: forall (es :: [Effect]) a. Concurrent :> es => MVar' a -> a -> Eff es a

- Effectful.Concurrent.MVar.Strict: takeMVar' :: Concurrent :> es => MVar' a -> Eff es a

+ Effectful.Concurrent.MVar.Strict: takeMVar' :: forall (es :: [Effect]) a. Concurrent :> es => MVar' a -> Eff es a

- Effectful.Concurrent.MVar.Strict: tryPutMVar' :: Concurrent :> es => MVar' a -> a -> Eff es Bool

+ Effectful.Concurrent.MVar.Strict: tryPutMVar' :: forall (es :: [Effect]) a. Concurrent :> es => MVar' a -> a -> Eff es Bool

- Effectful.Concurrent.MVar.Strict: tryReadMVar' :: Concurrent :> es => MVar' a -> Eff es (Maybe a)

+ Effectful.Concurrent.MVar.Strict: tryReadMVar' :: forall (es :: [Effect]) a. Concurrent :> es => MVar' a -> Eff es (Maybe a)

- Effectful.Concurrent.MVar.Strict: tryTakeMVar' :: Concurrent :> es => MVar' a -> Eff es (Maybe a)

+ Effectful.Concurrent.MVar.Strict: tryTakeMVar' :: forall (es :: [Effect]) a. Concurrent :> es => MVar' a -> Eff es (Maybe a)

- Effectful.Concurrent.MVar.Strict: withMVar' :: Concurrent :> es => MVar' a -> (a -> Eff es b) -> Eff es b

+ Effectful.Concurrent.MVar.Strict: withMVar' :: forall (es :: [Effect]) a b. Concurrent :> es => MVar' a -> (a -> Eff es b) -> Eff es b

- Effectful.Concurrent.MVar.Strict: withMVar'Masked :: Concurrent :> es => MVar' a -> (a -> Eff es b) -> Eff es b

+ Effectful.Concurrent.MVar.Strict: withMVar'Masked :: forall (es :: [Effect]) a b. Concurrent :> es => MVar' a -> (a -> Eff es b) -> Eff es b

- Effectful.Concurrent.MVar.Strict.Compat: data Concurrent :: Effect

+ Effectful.Concurrent.MVar.Strict.Compat: data Concurrent (a :: Type -> Type) b

- Effectful.Concurrent.MVar.Strict.Compat: data () => MVar a

+ Effectful.Concurrent.MVar.Strict.Compat: data MVar a

- Effectful.Concurrent.MVar.Strict.Compat: isEmptyMVar :: Concurrent :> es => MVar a -> Eff es Bool

+ Effectful.Concurrent.MVar.Strict.Compat: isEmptyMVar :: forall (es :: [Effect]) a. Concurrent :> es => MVar a -> Eff es Bool

- Effectful.Concurrent.MVar.Strict.Compat: mkWeakMVar :: (HasCallStack, Concurrent :> es) => MVar a -> Eff es () -> Eff es (Weak (MVar a))

+ Effectful.Concurrent.MVar.Strict.Compat: mkWeakMVar :: forall (es :: [Effect]) a. (HasCallStack, Concurrent :> es) => MVar a -> Eff es () -> Eff es (Weak (MVar a))

- Effectful.Concurrent.MVar.Strict.Compat: modifyMVar :: Concurrent :> es => MVar a -> (a -> Eff es (a, b)) -> Eff es b

+ Effectful.Concurrent.MVar.Strict.Compat: modifyMVar :: forall (es :: [Effect]) a b. Concurrent :> es => MVar a -> (a -> Eff es (a, b)) -> Eff es b

- Effectful.Concurrent.MVar.Strict.Compat: modifyMVarMasked :: Concurrent :> es => MVar a -> (a -> Eff es (a, b)) -> Eff es b

+ Effectful.Concurrent.MVar.Strict.Compat: modifyMVarMasked :: forall (es :: [Effect]) a b. Concurrent :> es => MVar a -> (a -> Eff es (a, b)) -> Eff es b

- Effectful.Concurrent.MVar.Strict.Compat: modifyMVarMasked_ :: Concurrent :> es => MVar a -> (a -> Eff es a) -> Eff es ()

+ Effectful.Concurrent.MVar.Strict.Compat: modifyMVarMasked_ :: forall (es :: [Effect]) a. Concurrent :> es => MVar a -> (a -> Eff es a) -> Eff es ()

- Effectful.Concurrent.MVar.Strict.Compat: modifyMVar_ :: Concurrent :> es => MVar a -> (a -> Eff es a) -> Eff es ()

+ Effectful.Concurrent.MVar.Strict.Compat: modifyMVar_ :: forall (es :: [Effect]) a. Concurrent :> es => MVar a -> (a -> Eff es a) -> Eff es ()

- Effectful.Concurrent.MVar.Strict.Compat: newEmptyMVar :: Concurrent :> es => Eff es (MVar a)

+ Effectful.Concurrent.MVar.Strict.Compat: newEmptyMVar :: forall (es :: [Effect]) a. Concurrent :> es => Eff es (MVar a)

- Effectful.Concurrent.MVar.Strict.Compat: newMVar :: Concurrent :> es => a -> Eff es (MVar a)

+ Effectful.Concurrent.MVar.Strict.Compat: newMVar :: forall (es :: [Effect]) a. Concurrent :> es => a -> Eff es (MVar a)

- Effectful.Concurrent.MVar.Strict.Compat: putMVar :: Concurrent :> es => MVar a -> a -> Eff es ()

+ Effectful.Concurrent.MVar.Strict.Compat: putMVar :: forall (es :: [Effect]) a. Concurrent :> es => MVar a -> a -> Eff es ()

- Effectful.Concurrent.MVar.Strict.Compat: readMVar :: Concurrent :> es => MVar a -> Eff es a

+ Effectful.Concurrent.MVar.Strict.Compat: readMVar :: forall (es :: [Effect]) a. Concurrent :> es => MVar a -> Eff es a

- Effectful.Concurrent.MVar.Strict.Compat: runConcurrent :: (HasCallStack, IOE :> es) => Eff (Concurrent : es) a -> Eff es a

+ Effectful.Concurrent.MVar.Strict.Compat: runConcurrent :: forall (es :: [Effect]) a. (HasCallStack, IOE :> es) => Eff (Concurrent ': es) a -> Eff es a

- Effectful.Concurrent.MVar.Strict.Compat: swapMVar :: Concurrent :> es => MVar a -> a -> Eff es a

+ Effectful.Concurrent.MVar.Strict.Compat: swapMVar :: forall (es :: [Effect]) a. Concurrent :> es => MVar a -> a -> Eff es a

- Effectful.Concurrent.MVar.Strict.Compat: takeMVar :: Concurrent :> es => MVar a -> Eff es a

+ Effectful.Concurrent.MVar.Strict.Compat: takeMVar :: forall (es :: [Effect]) a. Concurrent :> es => MVar a -> Eff es a

- Effectful.Concurrent.MVar.Strict.Compat: tryPutMVar :: Concurrent :> es => MVar a -> a -> Eff es Bool

+ Effectful.Concurrent.MVar.Strict.Compat: tryPutMVar :: forall (es :: [Effect]) a. Concurrent :> es => MVar a -> a -> Eff es Bool

- Effectful.Concurrent.MVar.Strict.Compat: tryReadMVar :: Concurrent :> es => MVar a -> Eff es (Maybe a)

+ Effectful.Concurrent.MVar.Strict.Compat: tryReadMVar :: forall (es :: [Effect]) a. Concurrent :> es => MVar a -> Eff es (Maybe a)

- Effectful.Concurrent.MVar.Strict.Compat: tryTakeMVar :: Concurrent :> es => MVar a -> Eff es (Maybe a)

+ Effectful.Concurrent.MVar.Strict.Compat: tryTakeMVar :: forall (es :: [Effect]) a. Concurrent :> es => MVar a -> Eff es (Maybe a)

- Effectful.Concurrent.MVar.Strict.Compat: withMVar :: Concurrent :> es => MVar a -> (a -> Eff es b) -> Eff es b

+ Effectful.Concurrent.MVar.Strict.Compat: withMVar :: forall (es :: [Effect]) a b. Concurrent :> es => MVar a -> (a -> Eff es b) -> Eff es b

- Effectful.Concurrent.MVar.Strict.Compat: withMVarMasked :: Concurrent :> es => MVar a -> (a -> Eff es b) -> Eff es b

+ Effectful.Concurrent.MVar.Strict.Compat: withMVarMasked :: forall (es :: [Effect]) a b. Concurrent :> es => MVar a -> (a -> Eff es b) -> Eff es b

- Effectful.Concurrent.QSem: data Concurrent :: Effect

+ Effectful.Concurrent.QSem: data Concurrent (a :: Type -> Type) b

- Effectful.Concurrent.QSem: data () => QSem

+ Effectful.Concurrent.QSem: data QSem

- Effectful.Concurrent.QSem: newQSem :: Concurrent :> es => Int -> Eff es QSem

+ Effectful.Concurrent.QSem: newQSem :: forall (es :: [Effect]). Concurrent :> es => Int -> Eff es QSem

- Effectful.Concurrent.QSem: runConcurrent :: (HasCallStack, IOE :> es) => Eff (Concurrent : es) a -> Eff es a

+ Effectful.Concurrent.QSem: runConcurrent :: forall (es :: [Effect]) a. (HasCallStack, IOE :> es) => Eff (Concurrent ': es) a -> Eff es a

- Effectful.Concurrent.QSem: signalQSem :: Concurrent :> es => QSem -> Eff es ()

+ Effectful.Concurrent.QSem: signalQSem :: forall (es :: [Effect]). Concurrent :> es => QSem -> Eff es ()

- Effectful.Concurrent.QSem: waitQSem :: Concurrent :> es => QSem -> Eff es ()

+ Effectful.Concurrent.QSem: waitQSem :: forall (es :: [Effect]). Concurrent :> es => QSem -> Eff es ()

- Effectful.Concurrent.QSemN: data Concurrent :: Effect

+ Effectful.Concurrent.QSemN: data Concurrent (a :: Type -> Type) b

- Effectful.Concurrent.QSemN: data () => QSemN

+ Effectful.Concurrent.QSemN: data QSemN

- Effectful.Concurrent.QSemN: newQSemN :: Concurrent :> es => Int -> Eff es QSemN

+ Effectful.Concurrent.QSemN: newQSemN :: forall (es :: [Effect]). Concurrent :> es => Int -> Eff es QSemN

- Effectful.Concurrent.QSemN: runConcurrent :: (HasCallStack, IOE :> es) => Eff (Concurrent : es) a -> Eff es a

+ Effectful.Concurrent.QSemN: runConcurrent :: forall (es :: [Effect]) a. (HasCallStack, IOE :> es) => Eff (Concurrent ': es) a -> Eff es a

- Effectful.Concurrent.QSemN: signalQSemN :: Concurrent :> es => QSemN -> Int -> Eff es ()

+ Effectful.Concurrent.QSemN: signalQSemN :: forall (es :: [Effect]). Concurrent :> es => QSemN -> Int -> Eff es ()

- Effectful.Concurrent.QSemN: waitQSemN :: Concurrent :> es => QSemN -> Int -> Eff es ()

+ Effectful.Concurrent.QSemN: waitQSemN :: forall (es :: [Effect]). Concurrent :> es => QSemN -> Int -> Eff es ()

- Effectful.Concurrent.STM: atomically :: Concurrent :> es => STM a -> Eff es a

+ Effectful.Concurrent.STM: atomically :: forall (es :: [Effect]) a. Concurrent :> es => STM a -> Eff es a

- Effectful.Concurrent.STM: data Concurrent :: Effect

+ Effectful.Concurrent.STM: data Concurrent (a :: Type -> Type) b

- Effectful.Concurrent.STM: data () => STM a

+ Effectful.Concurrent.STM: data STM a

- Effectful.Concurrent.STM: data () => TBQueue a

+ Effectful.Concurrent.STM: data TBQueue a

- Effectful.Concurrent.STM: data () => TChan a

+ Effectful.Concurrent.STM: data TChan a

- Effectful.Concurrent.STM: data () => TMVar a

+ Effectful.Concurrent.STM: data TMVar a

- Effectful.Concurrent.STM: data () => TQueue a

+ Effectful.Concurrent.STM: data TQueue a

- Effectful.Concurrent.STM: data () => TVar a

+ Effectful.Concurrent.STM: data TVar a

- Effectful.Concurrent.STM: mkWeakTMVar :: (HasCallStack, Concurrent :> es) => TMVar a -> Eff es () -> Eff es (Weak (TMVar a))

+ Effectful.Concurrent.STM: mkWeakTMVar :: forall (es :: [Effect]) a. (HasCallStack, Concurrent :> es) => TMVar a -> Eff es () -> Eff es (Weak (TMVar a))

- Effectful.Concurrent.STM: mkWeakTVar :: (HasCallStack, Concurrent :> es) => TVar a -> Eff es () -> Eff es (Weak (TVar a))

+ Effectful.Concurrent.STM: mkWeakTVar :: forall (es :: [Effect]) a. (HasCallStack, Concurrent :> es) => TVar a -> Eff es () -> Eff es (Weak (TVar a))

- Effectful.Concurrent.STM: newBroadcastTChanIO :: Concurrent :> es => Eff es (TChan a)

+ Effectful.Concurrent.STM: newBroadcastTChanIO :: forall (es :: [Effect]) a. Concurrent :> es => Eff es (TChan a)

- Effectful.Concurrent.STM: newEmptyTMVarIO :: Concurrent :> es => Eff es (TMVar a)

+ Effectful.Concurrent.STM: newEmptyTMVarIO :: forall (es :: [Effect]) a. Concurrent :> es => Eff es (TMVar a)

- Effectful.Concurrent.STM: newTBQueueIO :: Concurrent :> es => Natural -> Eff es (TBQueue a)

+ Effectful.Concurrent.STM: newTBQueueIO :: forall (es :: [Effect]) a. Concurrent :> es => Natural -> Eff es (TBQueue a)

- Effectful.Concurrent.STM: newTChanIO :: Concurrent :> es => Eff es (TChan a)

+ Effectful.Concurrent.STM: newTChanIO :: forall (es :: [Effect]) a. Concurrent :> es => Eff es (TChan a)

- Effectful.Concurrent.STM: newTMVarIO :: Concurrent :> es => a -> Eff es (TMVar a)

+ Effectful.Concurrent.STM: newTMVarIO :: forall (es :: [Effect]) a. Concurrent :> es => a -> Eff es (TMVar a)

- Effectful.Concurrent.STM: newTQueueIO :: Concurrent :> es => Eff es (TQueue a)

+ Effectful.Concurrent.STM: newTQueueIO :: forall (es :: [Effect]) a. Concurrent :> es => Eff es (TQueue a)

- Effectful.Concurrent.STM: newTVarIO :: Concurrent :> es => a -> Eff es (TVar a)

+ Effectful.Concurrent.STM: newTVarIO :: forall (es :: [Effect]) a. Concurrent :> es => a -> Eff es (TVar a)

- Effectful.Concurrent.STM: readTVarIO :: Concurrent :> es => TVar a -> Eff es a

+ Effectful.Concurrent.STM: readTVarIO :: forall (es :: [Effect]) a. Concurrent :> es => TVar a -> Eff es a

- Effectful.Concurrent.STM: registerDelay :: Concurrent :> es => Int -> Eff es (TVar Bool)

+ Effectful.Concurrent.STM: registerDelay :: forall (es :: [Effect]). Concurrent :> es => Int -> Eff es (TVar Bool)

- Effectful.Concurrent.STM: runConcurrent :: (HasCallStack, IOE :> es) => Eff (Concurrent : es) a -> Eff es a

+ Effectful.Concurrent.STM: runConcurrent :: forall (es :: [Effect]) a. (HasCallStack, IOE :> es) => Eff (Concurrent ': es) a -> Eff es a

- Effectful.Console.ByteString: data Console :: Effect

+ Effectful.Console.ByteString: data Console (a :: Type -> Type) b

- Effectful.Console.ByteString: getContents :: Console :> es => Eff es ByteString

+ Effectful.Console.ByteString: getContents :: forall (es :: [Effect]). Console :> es => Eff es ByteString

- Effectful.Console.ByteString: getLine :: Console :> es => Eff es ByteString

+ Effectful.Console.ByteString: getLine :: forall (es :: [Effect]). Console :> es => Eff es ByteString

- Effectful.Console.ByteString: interact :: Console :> es => (ByteString -> ByteString) -> Eff es ()

+ Effectful.Console.ByteString: interact :: forall (es :: [Effect]). Console :> es => (ByteString -> ByteString) -> Eff es ()

- Effectful.Console.ByteString: putStr :: Console :> es => ByteString -> Eff es ()

+ Effectful.Console.ByteString: putStr :: forall (es :: [Effect]). Console :> es => ByteString -> Eff es ()

- Effectful.Console.ByteString: putStrLn :: Console :> es => ByteString -> Eff es ()

+ Effectful.Console.ByteString: putStrLn :: forall (es :: [Effect]). Console :> es => ByteString -> Eff es ()

- Effectful.Console.ByteString: runConsole :: (HasCallStack, IOE :> es) => Eff (Console : es) a -> Eff es a

+ Effectful.Console.ByteString: runConsole :: forall (es :: [Effect]) a. (HasCallStack, IOE :> es) => Eff (Console ': es) a -> Eff es a

- Effectful.Console.ByteString.Lazy: data Console :: Effect

+ Effectful.Console.ByteString.Lazy: data Console (a :: Type -> Type) b

- Effectful.Console.ByteString.Lazy: getContents :: Console :> es => Eff es ByteString

+ Effectful.Console.ByteString.Lazy: getContents :: forall (es :: [Effect]). Console :> es => Eff es ByteString

- Effectful.Console.ByteString.Lazy: interact :: Console :> es => (ByteString -> ByteString) -> Eff es ()

+ Effectful.Console.ByteString.Lazy: interact :: forall (es :: [Effect]). Console :> es => (ByteString -> ByteString) -> Eff es ()

- Effectful.Console.ByteString.Lazy: putStr :: Console :> es => ByteString -> Eff es ()

+ Effectful.Console.ByteString.Lazy: putStr :: forall (es :: [Effect]). Console :> es => ByteString -> Eff es ()

- Effectful.Console.ByteString.Lazy: putStrLn :: Console :> es => ByteString -> Eff es ()

+ Effectful.Console.ByteString.Lazy: putStrLn :: forall (es :: [Effect]). Console :> es => ByteString -> Eff es ()

- Effectful.Console.ByteString.Lazy: runConsole :: (HasCallStack, IOE :> es) => Eff (Console : es) a -> Eff es a

+ Effectful.Console.ByteString.Lazy: runConsole :: forall (es :: [Effect]) a. (HasCallStack, IOE :> es) => Eff (Console ': es) a -> Eff es a

- Effectful.Environment: data Environment :: Effect

+ Effectful.Environment: data Environment (a :: Type -> Type) b

- Effectful.Environment: getArgs :: Environment :> es => Eff es [String]

+ Effectful.Environment: getArgs :: forall (es :: [Effect]). Environment :> es => Eff es [String]

- Effectful.Environment: getEnv :: Environment :> es => String -> Eff es String

+ Effectful.Environment: getEnv :: forall (es :: [Effect]). Environment :> es => String -> Eff es String

- Effectful.Environment: getEnvironment :: Environment :> es => Eff es [(String, String)]

+ Effectful.Environment: getEnvironment :: forall (es :: [Effect]). Environment :> es => Eff es [(String, String)]

- Effectful.Environment: getExecutablePath :: Environment :> es => Eff es FilePath

+ Effectful.Environment: getExecutablePath :: forall (es :: [Effect]). Environment :> es => Eff es FilePath

- Effectful.Environment: getProgName :: Environment :> es => Eff es String

+ Effectful.Environment: getProgName :: forall (es :: [Effect]). Environment :> es => Eff es String

- Effectful.Environment: lookupEnv :: Environment :> es => String -> Eff es (Maybe String)

+ Effectful.Environment: lookupEnv :: forall (es :: [Effect]). Environment :> es => String -> Eff es (Maybe String)

- Effectful.Environment: runEnvironment :: (HasCallStack, IOE :> es) => Eff (Environment : es) a -> Eff es a

+ Effectful.Environment: runEnvironment :: forall (es :: [Effect]) a. (HasCallStack, IOE :> es) => Eff (Environment ': es) a -> Eff es a

- Effectful.Environment: setEnv :: Environment :> es => String -> String -> Eff es ()

+ Effectful.Environment: setEnv :: forall (es :: [Effect]). Environment :> es => String -> String -> Eff es ()

- Effectful.Environment: unsetEnv :: Environment :> es => String -> Eff es ()

+ Effectful.Environment: unsetEnv :: forall (es :: [Effect]). Environment :> es => String -> Eff es ()

- Effectful.Environment: withArgs :: Environment :> es => [String] -> Eff es a -> Eff es a

+ Effectful.Environment: withArgs :: forall (es :: [Effect]) a. Environment :> es => [String] -> Eff es a -> Eff es a

- Effectful.Environment: withProgName :: Environment :> es => String -> Eff es a -> Eff es a

+ Effectful.Environment: withProgName :: forall (es :: [Effect]) a. Environment :> es => String -> Eff es a -> Eff es a

- Effectful.FileSystem: canonicalizePath :: FileSystem :> es => FilePath -> Eff es FilePath

+ Effectful.FileSystem: canonicalizePath :: forall (es :: [Effect]). FileSystem :> es => FilePath -> Eff es FilePath

- Effectful.FileSystem: copyFile :: FileSystem :> es => FilePath -> FilePath -> Eff es ()

+ Effectful.FileSystem: copyFile :: forall (es :: [Effect]). FileSystem :> es => FilePath -> FilePath -> Eff es ()

- Effectful.FileSystem: copyFileWithMetadata :: FileSystem :> es => FilePath -> FilePath -> Eff es ()

+ Effectful.FileSystem: copyFileWithMetadata :: forall (es :: [Effect]). FileSystem :> es => FilePath -> FilePath -> Eff es ()

- Effectful.FileSystem: copyPermissions :: FileSystem :> es => FilePath -> FilePath -> Eff es ()

+ Effectful.FileSystem: copyPermissions :: forall (es :: [Effect]). FileSystem :> es => FilePath -> FilePath -> Eff es ()

- Effectful.FileSystem: createDirectory :: FileSystem :> es => FilePath -> Eff es ()

+ Effectful.FileSystem: createDirectory :: forall (es :: [Effect]). FileSystem :> es => FilePath -> Eff es ()

- Effectful.FileSystem: createDirectoryIfMissing :: FileSystem :> es => Bool -> FilePath -> Eff es ()

+ Effectful.FileSystem: createDirectoryIfMissing :: forall (es :: [Effect]). FileSystem :> es => Bool -> FilePath -> Eff es ()

- Effectful.FileSystem: createDirectoryLink :: FileSystem :> es => FilePath -> FilePath -> Eff es ()

+ Effectful.FileSystem: createDirectoryLink :: forall (es :: [Effect]). FileSystem :> es => FilePath -> FilePath -> Eff es ()

- Effectful.FileSystem: createFileLink :: FileSystem :> es => FilePath -> FilePath -> Eff es ()

+ Effectful.FileSystem: createFileLink :: forall (es :: [Effect]). FileSystem :> es => FilePath -> FilePath -> Eff es ()

- Effectful.FileSystem: data FileSystem :: Effect

+ Effectful.FileSystem: data FileSystem (a :: Type -> Type) b

- Effectful.FileSystem: data () => Permissions

+ Effectful.FileSystem: data Permissions

- Effectful.FileSystem: data () => XdgDirectory

+ Effectful.FileSystem: data XdgDirectory

- Effectful.FileSystem: data () => XdgDirectoryList

+ Effectful.FileSystem: data XdgDirectoryList

- Effectful.FileSystem: doesDirectoryExist :: FileSystem :> es => FilePath -> Eff es Bool

+ Effectful.FileSystem: doesDirectoryExist :: forall (es :: [Effect]). FileSystem :> es => FilePath -> Eff es Bool

- Effectful.FileSystem: doesFileExist :: FileSystem :> es => FilePath -> Eff es Bool

+ Effectful.FileSystem: doesFileExist :: forall (es :: [Effect]). FileSystem :> es => FilePath -> Eff es Bool

- Effectful.FileSystem: doesPathExist :: FileSystem :> es => FilePath -> Eff es Bool

+ Effectful.FileSystem: doesPathExist :: forall (es :: [Effect]). FileSystem :> es => FilePath -> Eff es Bool

- Effectful.FileSystem: findExecutable :: FileSystem :> es => String -> Eff es (Maybe FilePath)

+ Effectful.FileSystem: findExecutable :: forall (es :: [Effect]). FileSystem :> es => String -> Eff es (Maybe FilePath)

- Effectful.FileSystem: findExecutables :: FileSystem :> es => String -> Eff es [FilePath]

+ Effectful.FileSystem: findExecutables :: forall (es :: [Effect]). FileSystem :> es => String -> Eff es [FilePath]

- Effectful.FileSystem: findExecutablesInDirectories :: FileSystem :> es => [FilePath] -> String -> Eff es [FilePath]

+ Effectful.FileSystem: findExecutablesInDirectories :: forall (es :: [Effect]). FileSystem :> es => [FilePath] -> String -> Eff es [FilePath]

- Effectful.FileSystem: findFile :: FileSystem :> es => [FilePath] -> String -> Eff es (Maybe FilePath)

+ Effectful.FileSystem: findFile :: forall (es :: [Effect]). FileSystem :> es => [FilePath] -> String -> Eff es (Maybe FilePath)

- Effectful.FileSystem: findFileWith :: FileSystem :> es => (FilePath -> Eff es Bool) -> [FilePath] -> String -> Eff es (Maybe FilePath)

+ Effectful.FileSystem: findFileWith :: forall (es :: [Effect]). FileSystem :> es => (FilePath -> Eff es Bool) -> [FilePath] -> String -> Eff es (Maybe FilePath)

- Effectful.FileSystem: findFiles :: FileSystem :> es => [FilePath] -> String -> Eff es [FilePath]

+ Effectful.FileSystem: findFiles :: forall (es :: [Effect]). FileSystem :> es => [FilePath] -> String -> Eff es [FilePath]

- Effectful.FileSystem: findFilesWith :: FileSystem :> es => (FilePath -> Eff es Bool) -> [FilePath] -> String -> Eff es [FilePath]

+ Effectful.FileSystem: findFilesWith :: forall (es :: [Effect]). FileSystem :> es => (FilePath -> Eff es Bool) -> [FilePath] -> String -> Eff es [FilePath]

- Effectful.FileSystem: getAccessTime :: FileSystem :> es => FilePath -> Eff es UTCTime

+ Effectful.FileSystem: getAccessTime :: forall (es :: [Effect]). FileSystem :> es => FilePath -> Eff es UTCTime

- Effectful.FileSystem: getAppUserDataDirectory :: FileSystem :> es => FilePath -> Eff es FilePath

+ Effectful.FileSystem: getAppUserDataDirectory :: forall (es :: [Effect]). FileSystem :> es => FilePath -> Eff es FilePath

- Effectful.FileSystem: getCurrentDirectory :: FileSystem :> es => Eff es FilePath

+ Effectful.FileSystem: getCurrentDirectory :: forall (es :: [Effect]). FileSystem :> es => Eff es FilePath

- Effectful.FileSystem: getDirectoryContents :: FileSystem :> es => FilePath -> Eff es [FilePath]

+ Effectful.FileSystem: getDirectoryContents :: forall (es :: [Effect]). FileSystem :> es => FilePath -> Eff es [FilePath]

- Effectful.FileSystem: getFileSize :: FileSystem :> es => FilePath -> Eff es Integer

+ Effectful.FileSystem: getFileSize :: forall (es :: [Effect]). FileSystem :> es => FilePath -> Eff es Integer

- Effectful.FileSystem: getHomeDirectory :: FileSystem :> es => Eff es FilePath

+ Effectful.FileSystem: getHomeDirectory :: forall (es :: [Effect]). FileSystem :> es => Eff es FilePath

- Effectful.FileSystem: getModificationTime :: FileSystem :> es => FilePath -> Eff es UTCTime

+ Effectful.FileSystem: getModificationTime :: forall (es :: [Effect]). FileSystem :> es => FilePath -> Eff es UTCTime

- Effectful.FileSystem: getPermissions :: FileSystem :> es => FilePath -> Eff es Permissions

+ Effectful.FileSystem: getPermissions :: forall (es :: [Effect]). FileSystem :> es => FilePath -> Eff es Permissions

- Effectful.FileSystem: getSymbolicLinkTarget :: FileSystem :> es => FilePath -> Eff es FilePath

+ Effectful.FileSystem: getSymbolicLinkTarget :: forall (es :: [Effect]). FileSystem :> es => FilePath -> Eff es FilePath

- Effectful.FileSystem: getTemporaryDirectory :: FileSystem :> es => Eff es FilePath

+ Effectful.FileSystem: getTemporaryDirectory :: forall (es :: [Effect]). FileSystem :> es => Eff es FilePath

- Effectful.FileSystem: getUserDocumentsDirectory :: FileSystem :> es => Eff es FilePath

+ Effectful.FileSystem: getUserDocumentsDirectory :: forall (es :: [Effect]). FileSystem :> es => Eff es FilePath

- Effectful.FileSystem: getXdgDirectory :: FileSystem :> es => XdgDirectory -> FilePath -> Eff es FilePath

+ Effectful.FileSystem: getXdgDirectory :: forall (es :: [Effect]). FileSystem :> es => XdgDirectory -> FilePath -> Eff es FilePath

- Effectful.FileSystem: getXdgDirectoryList :: FileSystem :> es => XdgDirectoryList -> Eff es [FilePath]

+ Effectful.FileSystem: getXdgDirectoryList :: forall (es :: [Effect]). FileSystem :> es => XdgDirectoryList -> Eff es [FilePath]

- Effectful.FileSystem: listDirectory :: FileSystem :> es => FilePath -> Eff es [FilePath]

+ Effectful.FileSystem: listDirectory :: forall (es :: [Effect]). FileSystem :> es => FilePath -> Eff es [FilePath]

- Effectful.FileSystem: makeAbsolute :: FileSystem :> es => FilePath -> Eff es FilePath

+ Effectful.FileSystem: makeAbsolute :: forall (es :: [Effect]). FileSystem :> es => FilePath -> Eff es FilePath

- Effectful.FileSystem: makeRelativeToCurrentDirectory :: FileSystem :> es => FilePath -> Eff es FilePath

+ Effectful.FileSystem: makeRelativeToCurrentDirectory :: forall (es :: [Effect]). FileSystem :> es => FilePath -> Eff es FilePath

- Effectful.FileSystem: pathIsSymbolicLink :: FileSystem :> es => FilePath -> Eff es Bool

+ Effectful.FileSystem: pathIsSymbolicLink :: forall (es :: [Effect]). FileSystem :> es => FilePath -> Eff es Bool

- Effectful.FileSystem: removeDirectory :: FileSystem :> es => FilePath -> Eff es ()

+ Effectful.FileSystem: removeDirectory :: forall (es :: [Effect]). FileSystem :> es => FilePath -> Eff es ()

- Effectful.FileSystem: removeDirectoryLink :: FileSystem :> es => FilePath -> Eff es ()

+ Effectful.FileSystem: removeDirectoryLink :: forall (es :: [Effect]). FileSystem :> es => FilePath -> Eff es ()

- Effectful.FileSystem: removeDirectoryRecursive :: FileSystem :> es => FilePath -> Eff es ()

+ Effectful.FileSystem: removeDirectoryRecursive :: forall (es :: [Effect]). FileSystem :> es => FilePath -> Eff es ()

- Effectful.FileSystem: removeFile :: FileSystem :> es => FilePath -> Eff es ()

+ Effectful.FileSystem: removeFile :: forall (es :: [Effect]). FileSystem :> es => FilePath -> Eff es ()

- Effectful.FileSystem: removePathForcibly :: FileSystem :> es => FilePath -> Eff es ()

+ Effectful.FileSystem: removePathForcibly :: forall (es :: [Effect]). FileSystem :> es => FilePath -> Eff es ()

- Effectful.FileSystem: renameDirectory :: FileSystem :> es => FilePath -> FilePath -> Eff es ()

+ Effectful.FileSystem: renameDirectory :: forall (es :: [Effect]). FileSystem :> es => FilePath -> FilePath -> Eff es ()

- Effectful.FileSystem: renameFile :: FileSystem :> es => FilePath -> FilePath -> Eff es ()

+ Effectful.FileSystem: renameFile :: forall (es :: [Effect]). FileSystem :> es => FilePath -> FilePath -> Eff es ()

- Effectful.FileSystem: renamePath :: FileSystem :> es => FilePath -> FilePath -> Eff es ()

+ Effectful.FileSystem: renamePath :: forall (es :: [Effect]). FileSystem :> es => FilePath -> FilePath -> Eff es ()

- Effectful.FileSystem: runFileSystem :: (HasCallStack, IOE :> es) => Eff (FileSystem : es) a -> Eff es a

+ Effectful.FileSystem: runFileSystem :: forall (es :: [Effect]) a. (HasCallStack, IOE :> es) => Eff (FileSystem ': es) a -> Eff es a

- Effectful.FileSystem: setAccessTime :: FileSystem :> es => FilePath -> UTCTime -> Eff es ()

+ Effectful.FileSystem: setAccessTime :: forall (es :: [Effect]). FileSystem :> es => FilePath -> UTCTime -> Eff es ()

- Effectful.FileSystem: setCurrentDirectory :: FileSystem :> es => FilePath -> Eff es ()

+ Effectful.FileSystem: setCurrentDirectory :: forall (es :: [Effect]). FileSystem :> es => FilePath -> Eff es ()

- Effectful.FileSystem: setModificationTime :: FileSystem :> es => FilePath -> UTCTime -> Eff es ()

+ Effectful.FileSystem: setModificationTime :: forall (es :: [Effect]). FileSystem :> es => FilePath -> UTCTime -> Eff es ()

- Effectful.FileSystem: setPermissions :: FileSystem :> es => FilePath -> Permissions -> Eff es ()

+ Effectful.FileSystem: setPermissions :: forall (es :: [Effect]). FileSystem :> es => FilePath -> Permissions -> Eff es ()

- Effectful.FileSystem: withCurrentDirectory :: FileSystem :> es => FilePath -> Eff es a -> Eff es a

+ Effectful.FileSystem: withCurrentDirectory :: forall (es :: [Effect]) a. FileSystem :> es => FilePath -> Eff es a -> Eff es a

- Effectful.FileSystem.IO: data () => BufferMode

+ Effectful.FileSystem.IO: data BufferMode

- Effectful.FileSystem.IO: data FileSystem :: Effect

+ Effectful.FileSystem.IO: data FileSystem (a :: Type -> Type) b

- Effectful.FileSystem.IO: data () => Handle

+ Effectful.FileSystem.IO: data Handle

- Effectful.FileSystem.IO: data () => IOMode

+ Effectful.FileSystem.IO: data IOMode

- Effectful.FileSystem.IO: data () => SeekMode

+ Effectful.FileSystem.IO: data SeekMode

- Effectful.FileSystem.IO: hClose :: FileSystem :> es => Handle -> Eff es ()

+ Effectful.FileSystem.IO: hClose :: forall (es :: [Effect]). FileSystem :> es => Handle -> Eff es ()

- Effectful.FileSystem.IO: hFileSize :: FileSystem :> es => Handle -> Eff es Integer

+ Effectful.FileSystem.IO: hFileSize :: forall (es :: [Effect]). FileSystem :> es => Handle -> Eff es Integer

- Effectful.FileSystem.IO: hFlush :: FileSystem :> es => Handle -> Eff es ()

+ Effectful.FileSystem.IO: hFlush :: forall (es :: [Effect]). FileSystem :> es => Handle -> Eff es ()

- Effectful.FileSystem.IO: hGetBuffering :: FileSystem :> es => Handle -> Eff es BufferMode

+ Effectful.FileSystem.IO: hGetBuffering :: forall (es :: [Effect]). FileSystem :> es => Handle -> Eff es BufferMode

- Effectful.FileSystem.IO: hGetEcho :: FileSystem :> es => Handle -> Eff es Bool

+ Effectful.FileSystem.IO: hGetEcho :: forall (es :: [Effect]). FileSystem :> es => Handle -> Eff es Bool

- Effectful.FileSystem.IO: hIsClosed :: FileSystem :> es => Handle -> Eff es Bool

+ Effectful.FileSystem.IO: hIsClosed :: forall (es :: [Effect]). FileSystem :> es => Handle -> Eff es Bool

- Effectful.FileSystem.IO: hIsEOF :: FileSystem :> es => Handle -> Eff es Bool

+ Effectful.FileSystem.IO: hIsEOF :: forall (es :: [Effect]). FileSystem :> es => Handle -> Eff es Bool

- Effectful.FileSystem.IO: hIsOpen :: FileSystem :> es => Handle -> Eff es Bool

+ Effectful.FileSystem.IO: hIsOpen :: forall (es :: [Effect]). FileSystem :> es => Handle -> Eff es Bool

- Effectful.FileSystem.IO: hIsReadable :: FileSystem :> es => Handle -> Eff es Bool

+ Effectful.FileSystem.IO: hIsReadable :: forall (es :: [Effect]). FileSystem :> es => Handle -> Eff es Bool

- Effectful.FileSystem.IO: hIsSeekable :: FileSystem :> es => Handle -> Eff es Bool

+ Effectful.FileSystem.IO: hIsSeekable :: forall (es :: [Effect]). FileSystem :> es => Handle -> Eff es Bool

- Effectful.FileSystem.IO: hIsTerminalDevice :: FileSystem :> es => Handle -> Eff es Bool

+ Effectful.FileSystem.IO: hIsTerminalDevice :: forall (es :: [Effect]). FileSystem :> es => Handle -> Eff es Bool

- Effectful.FileSystem.IO: hIsWritable :: FileSystem :> es => Handle -> Eff es Bool

+ Effectful.FileSystem.IO: hIsWritable :: forall (es :: [Effect]). FileSystem :> es => Handle -> Eff es Bool

- Effectful.FileSystem.IO: hReady :: FileSystem :> es => Handle -> Eff es Bool

+ Effectful.FileSystem.IO: hReady :: forall (es :: [Effect]). FileSystem :> es => Handle -> Eff es Bool

- Effectful.FileSystem.IO: hSeek :: FileSystem :> es => Handle -> SeekMode -> Integer -> Eff es ()

+ Effectful.FileSystem.IO: hSeek :: forall (es :: [Effect]). FileSystem :> es => Handle -> SeekMode -> Integer -> Eff es ()

- Effectful.FileSystem.IO: hSetBuffering :: FileSystem :> es => Handle -> BufferMode -> Eff es ()

+ Effectful.FileSystem.IO: hSetBuffering :: forall (es :: [Effect]). FileSystem :> es => Handle -> BufferMode -> Eff es ()

- Effectful.FileSystem.IO: hSetEcho :: FileSystem :> es => Handle -> Bool -> Eff es ()

+ Effectful.FileSystem.IO: hSetEcho :: forall (es :: [Effect]). FileSystem :> es => Handle -> Bool -> Eff es ()

- Effectful.FileSystem.IO: hSetFileSize :: FileSystem :> es => Handle -> Integer -> Eff es ()

+ Effectful.FileSystem.IO: hSetFileSize :: forall (es :: [Effect]). FileSystem :> es => Handle -> Integer -> Eff es ()

- Effectful.FileSystem.IO: hTell :: FileSystem :> es => Handle -> Eff es Integer

+ Effectful.FileSystem.IO: hTell :: forall (es :: [Effect]). FileSystem :> es => Handle -> Eff es Integer

- Effectful.FileSystem.IO: hWaitForInput :: FileSystem :> es => Handle -> Int -> Eff es Bool

+ Effectful.FileSystem.IO: hWaitForInput :: forall (es :: [Effect]). FileSystem :> es => Handle -> Int -> Eff es Bool

- Effectful.FileSystem.IO: openFile :: FileSystem :> es => FilePath -> IOMode -> Eff es Handle

+ Effectful.FileSystem.IO: openFile :: forall (es :: [Effect]). FileSystem :> es => FilePath -> IOMode -> Eff es Handle

- Effectful.FileSystem.IO: runFileSystem :: (HasCallStack, IOE :> es) => Eff (FileSystem : es) a -> Eff es a

+ Effectful.FileSystem.IO: runFileSystem :: forall (es :: [Effect]) a. (HasCallStack, IOE :> es) => Eff (FileSystem ': es) a -> Eff es a

- Effectful.FileSystem.IO: withBinaryFile :: FileSystem :> es => FilePath -> IOMode -> (Handle -> Eff es a) -> Eff es a

+ Effectful.FileSystem.IO: withBinaryFile :: forall (es :: [Effect]) a. FileSystem :> es => FilePath -> IOMode -> (Handle -> Eff es a) -> Eff es a

- Effectful.FileSystem.IO: withFile :: FileSystem :> es => FilePath -> IOMode -> (Handle -> Eff es a) -> Eff es a

+ Effectful.FileSystem.IO: withFile :: forall (es :: [Effect]) a. FileSystem :> es => FilePath -> IOMode -> (Handle -> Eff es a) -> Eff es a

- Effectful.FileSystem.IO.ByteString: appendFile :: FileSystem :> es => FilePath -> ByteString -> Eff es ()

+ Effectful.FileSystem.IO.ByteString: appendFile :: forall (es :: [Effect]). FileSystem :> es => FilePath -> ByteString -> Eff es ()

- Effectful.FileSystem.IO.ByteString: fromFilePath :: FileSystem :> es => FilePath -> Eff es ByteString

+ Effectful.FileSystem.IO.ByteString: fromFilePath :: forall (es :: [Effect]). FileSystem :> es => FilePath -> Eff es ByteString

- Effectful.FileSystem.IO.ByteString: hGet :: FileSystem :> es => Handle -> Int -> Eff es ByteString

+ Effectful.FileSystem.IO.ByteString: hGet :: forall (es :: [Effect]). FileSystem :> es => Handle -> Int -> Eff es ByteString

- Effectful.FileSystem.IO.ByteString: hGetContents :: FileSystem :> es => Handle -> Eff es ByteString

+ Effectful.FileSystem.IO.ByteString: hGetContents :: forall (es :: [Effect]). FileSystem :> es => Handle -> Eff es ByteString

- Effectful.FileSystem.IO.ByteString: hGetLine :: FileSystem :> es => Handle -> Eff es ByteString

+ Effectful.FileSystem.IO.ByteString: hGetLine :: forall (es :: [Effect]). FileSystem :> es => Handle -> Eff es ByteString

- Effectful.FileSystem.IO.ByteString: hGetNonBlocking :: FileSystem :> es => Handle -> Int -> Eff es ByteString

+ Effectful.FileSystem.IO.ByteString: hGetNonBlocking :: forall (es :: [Effect]). FileSystem :> es => Handle -> Int -> Eff es ByteString

- Effectful.FileSystem.IO.ByteString: hGetSome :: FileSystem :> es => Handle -> Int -> Eff es ByteString

+ Effectful.FileSystem.IO.ByteString: hGetSome :: forall (es :: [Effect]). FileSystem :> es => Handle -> Int -> Eff es ByteString

- Effectful.FileSystem.IO.ByteString: hPut :: FileSystem :> es => Handle -> ByteString -> Eff es ()

+ Effectful.FileSystem.IO.ByteString: hPut :: forall (es :: [Effect]). FileSystem :> es => Handle -> ByteString -> Eff es ()

- Effectful.FileSystem.IO.ByteString: hPutNonBlocking :: FileSystem :> es => Handle -> ByteString -> Eff es ByteString

+ Effectful.FileSystem.IO.ByteString: hPutNonBlocking :: forall (es :: [Effect]). FileSystem :> es => Handle -> ByteString -> Eff es ByteString

- Effectful.FileSystem.IO.ByteString: hPutStr :: FileSystem :> es => Handle -> ByteString -> Eff es ()

+ Effectful.FileSystem.IO.ByteString: hPutStr :: forall (es :: [Effect]). FileSystem :> es => Handle -> ByteString -> Eff es ()

- Effectful.FileSystem.IO.ByteString: hPutStrLn :: FileSystem :> es => Handle -> ByteString -> Eff es ()

+ Effectful.FileSystem.IO.ByteString: hPutStrLn :: forall (es :: [Effect]). FileSystem :> es => Handle -> ByteString -> Eff es ()

- Effectful.FileSystem.IO.ByteString: readFile :: FileSystem :> es => FilePath -> Eff es ByteString

+ Effectful.FileSystem.IO.ByteString: readFile :: forall (es :: [Effect]). FileSystem :> es => FilePath -> Eff es ByteString

- Effectful.FileSystem.IO.ByteString: toFilePath :: FileSystem :> es => ByteString -> Eff es FilePath

+ Effectful.FileSystem.IO.ByteString: toFilePath :: forall (es :: [Effect]). FileSystem :> es => ByteString -> Eff es FilePath

- Effectful.FileSystem.IO.ByteString: writeFile :: FileSystem :> es => FilePath -> ByteString -> Eff es ()

+ Effectful.FileSystem.IO.ByteString: writeFile :: forall (es :: [Effect]). FileSystem :> es => FilePath -> ByteString -> Eff es ()

- Effectful.FileSystem.IO.ByteString.Builder: hPutBuilder :: FileSystem :> es => Handle -> Builder -> Eff es ()

+ Effectful.FileSystem.IO.ByteString.Builder: hPutBuilder :: forall (es :: [Effect]). FileSystem :> es => Handle -> Builder -> Eff es ()

- Effectful.FileSystem.IO.ByteString.Builder: writeFile :: FileSystem :> es => FilePath -> Builder -> Eff es ()

+ Effectful.FileSystem.IO.ByteString.Builder: writeFile :: forall (es :: [Effect]). FileSystem :> es => FilePath -> Builder -> Eff es ()

- Effectful.FileSystem.IO.ByteString.Lazy: appendFile :: FileSystem :> es => FilePath -> ByteString -> Eff es ()

+ Effectful.FileSystem.IO.ByteString.Lazy: appendFile :: forall (es :: [Effect]). FileSystem :> es => FilePath -> ByteString -> Eff es ()

- Effectful.FileSystem.IO.ByteString.Lazy: hGet :: FileSystem :> es => Handle -> Int -> Eff es ByteString

+ Effectful.FileSystem.IO.ByteString.Lazy: hGet :: forall (es :: [Effect]). FileSystem :> es => Handle -> Int -> Eff es ByteString

- Effectful.FileSystem.IO.ByteString.Lazy: hGetContents :: FileSystem :> es => Handle -> Eff es ByteString

+ Effectful.FileSystem.IO.ByteString.Lazy: hGetContents :: forall (es :: [Effect]). FileSystem :> es => Handle -> Eff es ByteString

- Effectful.FileSystem.IO.ByteString.Lazy: hGetNonBlocking :: FileSystem :> es => Handle -> Int -> Eff es ByteString

+ Effectful.FileSystem.IO.ByteString.Lazy: hGetNonBlocking :: forall (es :: [Effect]). FileSystem :> es => Handle -> Int -> Eff es ByteString

- Effectful.FileSystem.IO.ByteString.Lazy: hPut :: FileSystem :> es => Handle -> ByteString -> Eff es ()

+ Effectful.FileSystem.IO.ByteString.Lazy: hPut :: forall (es :: [Effect]). FileSystem :> es => Handle -> ByteString -> Eff es ()

- Effectful.FileSystem.IO.ByteString.Lazy: hPutNonBlocking :: FileSystem :> es => Handle -> ByteString -> Eff es ByteString

+ Effectful.FileSystem.IO.ByteString.Lazy: hPutNonBlocking :: forall (es :: [Effect]). FileSystem :> es => Handle -> ByteString -> Eff es ByteString

- Effectful.FileSystem.IO.ByteString.Lazy: hPutStr :: FileSystem :> es => Handle -> ByteString -> Eff es ()

+ Effectful.FileSystem.IO.ByteString.Lazy: hPutStr :: forall (es :: [Effect]). FileSystem :> es => Handle -> ByteString -> Eff es ()

- Effectful.FileSystem.IO.ByteString.Lazy: hPutStrLn :: FileSystem :> es => Handle -> ByteString -> Eff es ()

+ Effectful.FileSystem.IO.ByteString.Lazy: hPutStrLn :: forall (es :: [Effect]). FileSystem :> es => Handle -> ByteString -> Eff es ()

- Effectful.FileSystem.IO.ByteString.Lazy: readFile :: FileSystem :> es => FilePath -> Eff es ByteString

+ Effectful.FileSystem.IO.ByteString.Lazy: readFile :: forall (es :: [Effect]). FileSystem :> es => FilePath -> Eff es ByteString

- Effectful.FileSystem.IO.ByteString.Lazy: writeFile :: FileSystem :> es => FilePath -> ByteString -> Eff es ()

+ Effectful.FileSystem.IO.ByteString.Lazy: writeFile :: forall (es :: [Effect]). FileSystem :> es => FilePath -> ByteString -> Eff es ()

- Effectful.FileSystem.IO.File: ensureFileDurable :: FileSystem :> es => FilePath -> Eff es ()

+ Effectful.FileSystem.IO.File: ensureFileDurable :: forall (es :: [Effect]). FileSystem :> es => FilePath -> Eff es ()

- Effectful.FileSystem.IO.File: withBinaryFile :: FileSystem :> es => FilePath -> IOMode -> (Handle -> Eff es a) -> Eff es a

+ Effectful.FileSystem.IO.File: withBinaryFile :: forall (es :: [Effect]) a. FileSystem :> es => FilePath -> IOMode -> (Handle -> Eff es a) -> Eff es a

- Effectful.FileSystem.IO.File: withBinaryFileAtomic :: FileSystem :> es => FilePath -> IOMode -> (Handle -> Eff es a) -> Eff es a

+ Effectful.FileSystem.IO.File: withBinaryFileAtomic :: forall (es :: [Effect]) a. FileSystem :> es => FilePath -> IOMode -> (Handle -> Eff es a) -> Eff es a

- Effectful.FileSystem.IO.File: withBinaryFileDurable :: FileSystem :> es => FilePath -> IOMode -> (Handle -> Eff es a) -> Eff es a

+ Effectful.FileSystem.IO.File: withBinaryFileDurable :: forall (es :: [Effect]) a. FileSystem :> es => FilePath -> IOMode -> (Handle -> Eff es a) -> Eff es a

- Effectful.FileSystem.IO.File: withBinaryFileDurableAtomic :: FileSystem :> es => FilePath -> IOMode -> (Handle -> Eff es a) -> Eff es a

+ Effectful.FileSystem.IO.File: withBinaryFileDurableAtomic :: forall (es :: [Effect]) a. FileSystem :> es => FilePath -> IOMode -> (Handle -> Eff es a) -> Eff es a

- Effectful.FileSystem.IO.File: writeBinaryFile :: FileSystem :> es => FilePath -> ByteString -> Eff es ()

+ Effectful.FileSystem.IO.File: writeBinaryFile :: forall (es :: [Effect]). FileSystem :> es => FilePath -> ByteString -> Eff es ()

- Effectful.FileSystem.IO.File: writeBinaryFileAtomic :: FileSystem :> es => FilePath -> ByteString -> Eff es ()

+ Effectful.FileSystem.IO.File: writeBinaryFileAtomic :: forall (es :: [Effect]). FileSystem :> es => FilePath -> ByteString -> Eff es ()

- Effectful.FileSystem.IO.File: writeBinaryFileDurable :: FileSystem :> es => FilePath -> ByteString -> Eff es ()

+ Effectful.FileSystem.IO.File: writeBinaryFileDurable :: forall (es :: [Effect]). FileSystem :> es => FilePath -> ByteString -> Eff es ()

- Effectful.FileSystem.IO.File: writeBinaryFileDurableAtomic :: FileSystem :> es => FilePath -> ByteString -> Eff es ()

+ Effectful.FileSystem.IO.File: writeBinaryFileDurableAtomic :: forall (es :: [Effect]). FileSystem :> es => FilePath -> ByteString -> Eff es ()

- Effectful.Prim.IORef: atomicModifyIORef :: Prim :> es => IORef a -> (a -> (a, b)) -> Eff es b

+ Effectful.Prim.IORef: atomicModifyIORef :: forall (es :: [Effect]) a b. Prim :> es => IORef a -> (a -> (a, b)) -> Eff es b

- Effectful.Prim.IORef: atomicModifyIORef' :: Prim :> es => IORef a -> (a -> (a, b)) -> Eff es b

+ Effectful.Prim.IORef: atomicModifyIORef' :: forall (es :: [Effect]) a b. Prim :> es => IORef a -> (a -> (a, b)) -> Eff es b

- Effectful.Prim.IORef: atomicWriteIORef :: Prim :> es => IORef a -> a -> Eff es ()

+ Effectful.Prim.IORef: atomicWriteIORef :: forall (es :: [Effect]) a. Prim :> es => IORef a -> a -> Eff es ()

- Effectful.Prim.IORef: data () => IORef a

+ Effectful.Prim.IORef: data IORef a

- Effectful.Prim.IORef: data () => Prim (a :: Type -> Type) b

+ Effectful.Prim.IORef: data Prim (a :: Type -> Type) b

- Effectful.Prim.IORef: mkWeakIORef :: (HasCallStack, Prim :> es) => IORef a -> Eff es () -> Eff es (Weak (IORef a))

+ Effectful.Prim.IORef: mkWeakIORef :: forall (es :: [Effect]) a. (HasCallStack, Prim :> es) => IORef a -> Eff es () -> Eff es (Weak (IORef a))

- Effectful.Prim.IORef: modifyIORef :: Prim :> es => IORef a -> (a -> a) -> Eff es ()

+ Effectful.Prim.IORef: modifyIORef :: forall (es :: [Effect]) a. Prim :> es => IORef a -> (a -> a) -> Eff es ()

- Effectful.Prim.IORef: modifyIORef' :: Prim :> es => IORef a -> (a -> a) -> Eff es ()

+ Effectful.Prim.IORef: modifyIORef' :: forall (es :: [Effect]) a. Prim :> es => IORef a -> (a -> a) -> Eff es ()

- Effectful.Prim.IORef: newIORef :: Prim :> es => a -> Eff es (IORef a)

+ Effectful.Prim.IORef: newIORef :: forall (es :: [Effect]) a. Prim :> es => a -> Eff es (IORef a)

- Effectful.Prim.IORef: readIORef :: Prim :> es => IORef a -> Eff es a

+ Effectful.Prim.IORef: readIORef :: forall (es :: [Effect]) a. Prim :> es => IORef a -> Eff es a

- Effectful.Prim.IORef: writeIORef :: Prim :> es => IORef a -> a -> Eff es ()

+ Effectful.Prim.IORef: writeIORef :: forall (es :: [Effect]) a. Prim :> es => IORef a -> a -> Eff es ()

- Effectful.Prim.IORef.Strict: atomicModifyIORef' :: Prim :> es => IORef' a -> (a -> (a, b)) -> Eff es b

+ Effectful.Prim.IORef.Strict: atomicModifyIORef' :: forall (es :: [Effect]) a b. Prim :> es => IORef' a -> (a -> (a, b)) -> Eff es b

- Effectful.Prim.IORef.Strict: atomicWriteIORef' :: Prim :> es => IORef' a -> a -> Eff es ()

+ Effectful.Prim.IORef.Strict: atomicWriteIORef' :: forall (es :: [Effect]) a. Prim :> es => IORef' a -> a -> Eff es ()

- Effectful.Prim.IORef.Strict: data () => IORef' a

+ Effectful.Prim.IORef.Strict: data IORef' a

- Effectful.Prim.IORef.Strict: data () => Prim (a :: Type -> Type) b

+ Effectful.Prim.IORef.Strict: data Prim (a :: Type -> Type) b

- Effectful.Prim.IORef.Strict: mkWeakIORef' :: (HasCallStack, Prim :> es) => IORef' a -> Eff es () -> Eff es (Weak (IORef' a))

+ Effectful.Prim.IORef.Strict: mkWeakIORef' :: forall (es :: [Effect]) a. (HasCallStack, Prim :> es) => IORef' a -> Eff es () -> Eff es (Weak (IORef' a))

- Effectful.Prim.IORef.Strict: modifyIORef' :: Prim :> es => IORef' a -> (a -> a) -> Eff es ()

+ Effectful.Prim.IORef.Strict: modifyIORef' :: forall (es :: [Effect]) a. Prim :> es => IORef' a -> (a -> a) -> Eff es ()

- Effectful.Prim.IORef.Strict: newIORef' :: Prim :> es => a -> Eff es (IORef' a)

+ Effectful.Prim.IORef.Strict: newIORef' :: forall (es :: [Effect]) a. Prim :> es => a -> Eff es (IORef' a)

- Effectful.Prim.IORef.Strict: readIORef' :: Prim :> es => IORef' a -> Eff es a

+ Effectful.Prim.IORef.Strict: readIORef' :: forall (es :: [Effect]) a. Prim :> es => IORef' a -> Eff es a

- Effectful.Prim.IORef.Strict: writeIORef' :: Prim :> es => IORef' a -> a -> Eff es ()

+ Effectful.Prim.IORef.Strict: writeIORef' :: forall (es :: [Effect]) a. Prim :> es => IORef' a -> a -> Eff es ()

- Effectful.Process: callCommand :: Process :> es => String -> Eff es ()

+ Effectful.Process: callCommand :: forall (es :: [Effect]). Process :> es => String -> Eff es ()

- Effectful.Process: callProcess :: Process :> es => FilePath -> [String] -> Eff es ()

+ Effectful.Process: callProcess :: forall (es :: [Effect]). Process :> es => FilePath -> [String] -> Eff es ()

- Effectful.Process: cleanupProcess :: Process :> es => (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle) -> Eff es ()

+ Effectful.Process: cleanupProcess :: forall (es :: [Effect]). Process :> es => (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle) -> Eff es ()

- Effectful.Process: createPipe :: Process :> es => Eff es (Handle, Handle)

+ Effectful.Process: createPipe :: forall (es :: [Effect]). Process :> es => Eff es (Handle, Handle)

- Effectful.Process: createPipeFd :: Process :> es => Eff es (FD, FD)

+ Effectful.Process: createPipeFd :: forall (es :: [Effect]). Process :> es => Eff es (FD, FD)

- Effectful.Process: createProcess :: Process :> es => CreateProcess -> Eff es (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle)

+ Effectful.Process: createProcess :: forall (es :: [Effect]). Process :> es => CreateProcess -> Eff es (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle)

- Effectful.Process: createProcess_ :: Process :> es => String -> CreateProcess -> Eff es (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle)

+ Effectful.Process: createProcess_ :: forall (es :: [Effect]). Process :> es => String -> CreateProcess -> Eff es (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle)

- Effectful.Process: data () => CmdSpec

+ Effectful.Process: data CmdSpec

- Effectful.Process: data () => CreateProcess

+ Effectful.Process: data CreateProcess

- Effectful.Process: data Process :: Effect

+ Effectful.Process: data Process (a :: Type -> Type) b

- Effectful.Process: data () => ProcessHandle

+ Effectful.Process: data ProcessHandle

- Effectful.Process: data () => StdStream

+ Effectful.Process: data StdStream

- Effectful.Process: getCurrentPid :: Process :> es => Eff es Pid

+ Effectful.Process: getCurrentPid :: forall (es :: [Effect]). Process :> es => Eff es Pid

- Effectful.Process: getPid :: Process :> es => ProcessHandle -> Eff es (Maybe Pid)

+ Effectful.Process: getPid :: forall (es :: [Effect]). Process :> es => ProcessHandle -> Eff es (Maybe Pid)

- Effectful.Process: getProcessExitCode :: Process :> es => ProcessHandle -> Eff es (Maybe ExitCode)

+ Effectful.Process: getProcessExitCode :: forall (es :: [Effect]). Process :> es => ProcessHandle -> Eff es (Maybe ExitCode)

- Effectful.Process: interruptProcessGroupOf :: Process :> es => ProcessHandle -> Eff es ()

+ Effectful.Process: interruptProcessGroupOf :: forall (es :: [Effect]). Process :> es => ProcessHandle -> Eff es ()

- Effectful.Process: readCreateProcess :: Process :> es => CreateProcess -> String -> Eff es String

+ Effectful.Process: readCreateProcess :: forall (es :: [Effect]). Process :> es => CreateProcess -> String -> Eff es String

- Effectful.Process: readCreateProcessWithExitCode :: Process :> es => CreateProcess -> String -> Eff es (ExitCode, String, String)

+ Effectful.Process: readCreateProcessWithExitCode :: forall (es :: [Effect]). Process :> es => CreateProcess -> String -> Eff es (ExitCode, String, String)

- Effectful.Process: readProcess :: Process :> es => FilePath -> [String] -> String -> Eff es String

+ Effectful.Process: readProcess :: forall (es :: [Effect]). Process :> es => FilePath -> [String] -> String -> Eff es String

- Effectful.Process: readProcessWithExitCode :: Process :> es => FilePath -> [String] -> String -> Eff es (ExitCode, String, String)

+ Effectful.Process: readProcessWithExitCode :: forall (es :: [Effect]). Process :> es => FilePath -> [String] -> String -> Eff es (ExitCode, String, String)

- Effectful.Process: runProcess :: (HasCallStack, IOE :> es) => Eff (Process : es) a -> Eff es a

+ Effectful.Process: runProcess :: forall (es :: [Effect]) a. (HasCallStack, IOE :> es) => Eff (Process ': es) a -> Eff es a

- Effectful.Process: spawnCommand :: Process :> es => String -> Eff es ProcessHandle

+ Effectful.Process: spawnCommand :: forall (es :: [Effect]). Process :> es => String -> Eff es ProcessHandle

- Effectful.Process: spawnProcess :: Process :> es => FilePath -> [String] -> Eff es ProcessHandle

+ Effectful.Process: spawnProcess :: forall (es :: [Effect]). Process :> es => FilePath -> [String] -> Eff es ProcessHandle

- Effectful.Process: terminateProcess :: Process :> es => ProcessHandle -> Eff es ()

+ Effectful.Process: terminateProcess :: forall (es :: [Effect]). Process :> es => ProcessHandle -> Eff es ()

- Effectful.Process: waitForProcess :: Process :> es => ProcessHandle -> Eff es ExitCode

+ Effectful.Process: waitForProcess :: forall (es :: [Effect]). Process :> es => ProcessHandle -> Eff es ExitCode

- Effectful.Process: withCreateProcess :: Process :> es => CreateProcess -> (Maybe Handle -> Maybe Handle -> Maybe Handle -> ProcessHandle -> Eff es a) -> Eff es a

+ Effectful.Process: withCreateProcess :: forall (es :: [Effect]) a. Process :> es => CreateProcess -> (Maybe Handle -> Maybe Handle -> Maybe Handle -> ProcessHandle -> Eff es a) -> Eff es a

- Effectful.Temporary: data Temporary :: Effect

+ Effectful.Temporary: data Temporary (a :: Type -> Type) b

- Effectful.Temporary: runTemporary :: (HasCallStack, IOE :> es) => Eff (Temporary : es) a -> Eff es a

+ Effectful.Temporary: runTemporary :: forall (es :: [Effect]) a. (HasCallStack, IOE :> es) => Eff (Temporary ': es) a -> Eff es a

- Effectful.Temporary: withSystemTempDirectory :: Temporary :> es => String -> (FilePath -> Eff es a) -> Eff es a

+ Effectful.Temporary: withSystemTempDirectory :: forall (es :: [Effect]) a. Temporary :> es => String -> (FilePath -> Eff es a) -> Eff es a

- Effectful.Temporary: withSystemTempFile :: Temporary :> es => String -> (FilePath -> Handle -> Eff es a) -> Eff es a

+ Effectful.Temporary: withSystemTempFile :: forall (es :: [Effect]) a. Temporary :> es => String -> (FilePath -> Handle -> Eff es a) -> Eff es a

- Effectful.Temporary: withTempDirectory :: Temporary :> es => FilePath -> String -> (FilePath -> Eff es a) -> Eff es a

+ Effectful.Temporary: withTempDirectory :: forall (es :: [Effect]) a. Temporary :> es => FilePath -> String -> (FilePath -> Eff es a) -> Eff es a

- Effectful.Temporary: withTempFile :: Temporary :> es => FilePath -> String -> (FilePath -> Handle -> Eff es a) -> Eff es a

+ Effectful.Temporary: withTempFile :: forall (es :: [Effect]) a. Temporary :> es => FilePath -> String -> (FilePath -> Handle -> Eff es a) -> Eff es a

- Effectful.Timeout: data Timeout :: Effect

+ Effectful.Timeout: data Timeout (a :: Type -> Type) b

- Effectful.Timeout: runTimeout :: (HasCallStack, IOE :> es) => Eff (Timeout : es) a -> Eff es a

+ Effectful.Timeout: runTimeout :: forall (es :: [Effect]) a. (HasCallStack, IOE :> es) => Eff (Timeout ': es) a -> Eff es a

- Effectful.Timeout: timeout :: Timeout :> es => Int -> Eff es a -> Eff es (Maybe a)

+ Effectful.Timeout: timeout :: forall (es :: [Effect]) a. Timeout :> es => Int -> Eff es a -> Eff es (Maybe a)

Files

CHANGELOG.md +12/−0
README.md +2/−2
effectful.cabal +6/−6
src/Effectful/Concurrent.hs +1/−0
src/Effectful/FileSystem/IO/ByteString.hs +4/−1
tests/ReaderTests.hs +14/−18

CHANGELOG.md view

@@ -1,3 +1,15 @@+# 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

README.md view

@@ -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)  -<img src="https://user-images.githubusercontent.com/387658/127747903-f728437f-2ee4-47b8-9f0c-5102fd44c8e4.png" width="128">+<img src="https://raw.githubusercontent.com/haskell-effectful/effectful/master/logo.svg" width="150">  An easy to use, fast extensible effects library with seamless integration with the existing Haskell ecosystem.

effectful.cabal view

@@ -1,7 +1,7 @@ cabal-version:      3.0 build-type:         Simple name:               effectful-version:            2.5.1.0+version:            2.6.0.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 }  bug-reports:   https://github.com/haskell-effectful/effectful/issues source-repository head@@ -74,7 +74,7 @@                     , async               >= 2.2.2                     , bytestring          >= 0.10                     , directory           >= 1.3.2-                    , effectful-core      >= 2.5.1.0   && < 2.5.2.0+                    , effectful-core      >= 2.6.0.0   && < 2.6.1.0                     , process             >= 1.6.9                     , strict-mutable-base >= 1.1.0.0                     , time                >= 1.9.2@@ -188,10 +188,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.13)+          build-depends: fused-effects >= 1.1.2.3 -       if impl(ghc < 9.11)+       if impl(ghc < 9.13)           build-depends: polysemy >= 1.9.2.0      build-depends:    base

src/Effectful/Concurrent.hs view

@@ -20,6 +20,7 @@   , runConcurrent      -- * Basic concurrency operations+  , C.ThreadId   , myThreadId   , forkIO   , forkFinally

src/Effectful/FileSystem/IO/ByteString.hs view

@@ -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

tests/ReaderTests.hs view

@@ -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