heftia 0.6.0.0 → 0.7.0.0

raw patch · 3 files changed

+75/−47 lines, 3 filesdep ~data-effectsPVP ok

version bump matches the API change (PVP)

Dependency ranges changed: data-effects

API changes (from Hackage documentation)

Files

• README.md +40/−35
• heftia.cabal +3/−3
• src/Control/Monad/Hefty.hs +32/−9

@@ -1,25 +1,29 @@-# Heftia: higher-order algebraic effects done right+# Heftia: A theory‑backed, ultra type‑safe algebraic effects  [![Hackage](https://img.shields.io/hackage/v/heftia.svg?logo=haskell&label=heftia)](https://hackage.haskell.org/package/heftia) [![Hackage](https://img.shields.io/hackage/v/heftia-effects.svg?logo=haskell&label=heftia-effects)](https://hackage.haskell.org/package/heftia-effects) [![Stackage LTS](https://www.stackage.org/package/heftia-effects/badge/lts)](https://www.stackage.org/lts/package/heftia-effects) [![Stackage Nightly](https://www.stackage.org/package/heftia-effects/badge/nightly)](https://www.stackage.org/nightly/package/heftia-effects)-[![Build status](https://img.shields.io/github/actions/workflow/status/sayo-hs/heftia/haskell.yml?branch=develop)](https://github.com/sayo-hs/heftia/actions)+[![Build status](https://img.shields.io/github/actions/workflow/status/sayo-hs/heftia/haskell.yml?branch=master)](https://github.com/sayo-hs/heftia/actions) -Heftia is an extensible effects library for Haskell that generalizes "Algebraic Effects and Handlers" to higher-order effects, providing users with maximum flexibility and delivering standard and reasonable speed.-In its generalization, the focus is on ensuring predictable results based on simple, consistent semantics, while preserving soundness.+Heftia is a Haskell library for algebraic effects grounded in solid theoretical foundations. -Please refer to the [Haddock documentation](https://hackage.haskell.org/package/heftia-0.6.0.0/docs/Control-Monad-Hefty.html) for usage and semantics.-For information on performance, please refer to [performance.md](https://github.com/sayo-hs/heftia/blob/v0.6.0/benchmark/performance.md).+It is the only library that fully supports higher-order algebraic effects with complete type safety. +Say goodbye to runtime errors and unsound semantics.++This library provides a simple interface, predictable behavior, and maximum flexibility while delivering standard, practical performance.++Please refer to the [Haddock documentation](https://hackage.haskell.org/package/heftia-0.7.0.0/docs/Control-Monad-Hefty.html) for usage and semantics.+For information on performance, please refer to [performance.md](https://github.com/sayo-hs/heftia/blob/v0.7.0.0/benchmark/performance.md).+ This library is inspired by the paper:-* Casper Bach Poulsen and Cas van der Rest. 2023. Hefty Algebras: Modular-    Elaboration of Higher-Order Algebraic Effects. Proc. ACM Program. Lang. 7,-    POPL, Article 62 (January 2023), 31 pages. <https://doi.org/10.1145/3571255>+* [Hefty Algebras: Modular Elaboration of Higher-Order Algebraic Effects. Casper Bach Poulsen & Cas van der Rest, POPL 2023.](https://doi.org/10.1145/3571255) -The *elaboration* approach proposed in the above paper allows for a straightforward treatment of higher-order effects.+The elaboration approach proposed in that paper allows for a straightforward treatment of higher-order effects. -Heftia's data structure is an extension of the Freer monad, designed to be theoretically straightforward by eliminating ad-hoc elements.+Heftia is also grounded in the following theory:+* [A Framework for Higher-Order Effects & Handlers. Birthe van den Berg & Tom Schrijvers, Sci. Comput. Program. 2024.](https://doi.org/10.1016/j.scico.2024.103086)  ## Why choose this library over others? This library is based on algebraic effects. Currently, **none of the practical effect libraries other than this one are "algebraic."** So, why is being *algebraic* important?@@ -44,7 +48,7 @@ If performance is particularly important, [`effectful`](https://github.com/haskell-effectful/effectful) would be the best alternative to this library.  [^8]: MonadUnliftIO instance allows escape https://github.com/tomjaguarpaw/bluefin/issues/29-[^9]: [heftia-effects/test/Test/UnliftIO.hs](https://github.com/sayo-hs/heftia/blob/v0.6.0/heftia-effects/test/Test/UnliftIO.hs)+[^9]: [heftia-effects/test/Test/UnliftIO.hs](https://github.com/sayo-hs/heftia/blob/v0.7.0.0/heftia-effects/test/Test/UnliftIO.hs)  ## Key Features @@ -60,34 +64,34 @@     * Higher-order effects         * [`MonadUnliftIO`](https://hackage.haskell.org/package/unliftio)             * to prevent resource leaks due to runtime exceptions-            * [heftia-effects/Example/UnliftIO/Main.hs](https://github.com/sayo-hs/heftia/blob/v0.6.0/heftia-effects/Example/UnliftIO/Main.hs)-            * [heftia-effects/Example/Stream/Main.hs](https://github.com/sayo-hs/heftia/blob/v0.6.0/heftia-effects/Example/Stream/Main.hs)+            * [heftia-effects/Example/UnliftIO/Main.hs](https://github.com/sayo-hs/heftia/blob/v0.7.0.0/heftia-effects/Example/UnliftIO/Main.hs)+            * [heftia-effects/Example/Stream/Main.hs](https://github.com/sayo-hs/heftia/blob/v0.7.0.0/heftia-effects/Example/Stream/Main.hs)         * [`Provider`](https://hackage.haskell.org/package/effectful-core-2.5.0.0/docs/Effectful-Provider.html) a.k.a. [`Scoped`](https://hackage.haskell.org/package/polysemy-1.9.2.0/docs/Polysemy-Scoped.html)             * to prevent [resource handles from leaking out of scopes](https://h2.jaguarpaw.co.uk/posts/bluefin-prevents-handles-leaking/)-            * [Control.Monad.Hefty.Concurrent.Subprocess](https://hackage.haskell.org/package/heftia-effects-0.6.0.0/docs/Control-Monad-Hefty-Concurrent-Subprocess.html)-            * [heftia-effects/Example/Subprocess/Main.hs](https://github.com/sayo-hs/heftia/blob/v0.6.0/heftia-effects/Example/Subprocess/Main.hs)-            * [heftia-effects/Example/FileSystemProvider/Main.hs](https://github.com/sayo-hs/heftia/blob/v0.6.0/heftia-effects/Example/FileSystemProvider/Main.hs)+            * [Control.Monad.Hefty.Concurrent.Subprocess](https://hackage.haskell.org/package/heftia-effects-0.7.0.0/docs/Control-Monad-Hefty-Concurrent-Subprocess.html)+            * [heftia-effects/Example/Subprocess/Main.hs](https://github.com/sayo-hs/heftia/blob/v0.7.0.0/heftia-effects/Example/Subprocess/Main.hs)+            * [heftia-effects/Example/DatabaseProvider/Main.hs](https://github.com/sayo-hs/heftia/blob/v0.7.0.0/heftia-effects/Example/DatabaseProvider/Main.hs)         * [Applicative-style Parallelism](https://medium.com/@PerrottaFrancisco/learning-cats-effects-parallel-execution-f617f883e390)             * like `cats-effect` in Scala-            * [Data.Effect.Concurrent.Parallel](https://hackage.haskell.org/package/data-effects-0.3.0.1/docs/Data-Effect-Concurrent-Parallel.html)-            * [Control.Monad.Hefty.Concurrent.Parallel](https://hackage.haskell.org/package/heftia-effects-0.6.0.0/docs/Control-Monad-Hefty-Concurrent-Parallel.html)-            * [heftia-effects/test/Test/Concurrent.hs](https://github.com/sayo-hs/heftia/blob/v0.6.0/heftia-effects/test/Test/Concurrent.hs)+            * [Data.Effect.Concurrent.Parallel](https://hackage.haskell.org/package/data-effects-0.4.2.0/docs/Data-Effect-Concurrent-Parallel.html)+            * [Control.Monad.Hefty.Concurrent.Parallel](https://hackage.haskell.org/package/heftia-effects-0.7.0.0/docs/Control-Monad-Hefty-Concurrent-Parallel.html)+            * [heftia-effects/test/Test/Concurrent.hs](https://github.com/sayo-hs/heftia/blob/v0.7.0.0/heftia-effects/test/Test/Concurrent.hs)      All of these interact through a simple, consistent, and predictable semantics based on algebraic effects.  * **Easy and Concise Implementation for Custom Effect Interpreters** -    As you can see from the implementations of basic effect interpreters such as [State](https://hackage.haskell.org/package/heftia-effects-0.6.0.0/docs/src/Control.Monad.Hefty.State.html#runState), [Throw/Catch](https://hackage.haskell.org/package/heftia-effects-0.6.0.0/docs/src/Control.Monad.Hefty.Except.html#runThrow), [Writer](https://hackage.haskell.org/package/heftia-effects-0.6.0.0/docs/src/Control.Monad.Hefty.Writer.html#runTell), [NonDet](https://hackage.haskell.org/package/heftia-effects-0.6.0.0/docs/src/Control.Monad.Hefty.NonDet.html#runNonDet), and [Coroutine](https://hackage.haskell.org/package/heftia-effects-0.6.0.0/docs/src/Control.Monad.Hefty.Coroutine.html#runCoroutine), they can be implemented in just a few lines, or even a single line. Even for effects like NonDet and Coroutine, which involve continuations and might seem difficult to implement at first glance, this is exactly how simple it can be. This is the power of algebraic effects. Users can quickly define experimental and innovative custom effects using continuations.+    As you can see from the implementations of basic effect interpreters such as [State](https://hackage.haskell.org/package/heftia-effects-0.7.0.0/docs/src/Control.Monad.Hefty.State.html#runState), [Throw/Catch](https://hackage.haskell.org/package/heftia-effects-0.7.0.0/docs/src/Control.Monad.Hefty.Except.html#runThrow), [Writer](https://hackage.haskell.org/package/heftia-effects-0.7.0.0/docs/src/Control.Monad.Hefty.Writer.html#runTell), [NonDet](https://hackage.haskell.org/package/heftia-effects-0.7.0.0/docs/src/Control.Monad.Hefty.NonDet.html#runNonDet), and [Coroutine](https://hackage.haskell.org/package/heftia-effects-0.7.0.0/docs/src/Control.Monad.Hefty.Coroutine.html#runCoroutine), they can be implemented in just a few lines, or even a single line. Even for effects like NonDet and Coroutine, which involve continuations and might seem difficult to implement at first glance, this is exactly how simple it can be. This is the power of algebraic effects. Users can quickly define experimental and innovative custom effects using continuations.  * **Standard and Reasonable Performance** -    It operates at a speed positioned roughly in the middle between faster libraries (like `effectful` or `eveff`) and relatively slower ones (like `polysemy` or `fused-effects`): [performance.md](https://github.com/sayo-hs/heftia/blob/v0.6.0/benchmark/performance.md).+    It operates at a speed roughly on par with `effectful` and significantly faster than `mtl` and `polysemy`: [performance.md](https://github.com/sayo-hs/heftia/blob/v0.7.0.0/benchmark/performance.md).  * **Type Safety and Purity**      * Does not depend on the IO monad and can use any monad as the base monad.     * Semantics are isolated from the IO monad, meaning that aspects like asynchronous exceptions and threads do not affect the behavior of effects.-    * The constructors of the `Eff` monad are [exposed](https://hackage.haskell.org/package/heftia-0.6.0.0/docs/Control-Monad-Hefty.html#t:Eff), and users can manipulate them directly without any safety concerns. Still, the semantics remain intact.+    * The constructors of the `Eff` monad are [exposed](https://hackage.haskell.org/package/heftia-0.7.0.0/docs/Control-Monad-Hefty.html#t:Eff), and users can manipulate them directly without any safety concerns. Still, the semantics remain intact.     * These are in contrast to libraries like `effectful` and `eff`, making this library more **Haskell-ish and purely functional**.     * **This design effectively prevents obscure behaviors and potential runtime errors.** @@ -124,7 +128,7 @@     ```console     $ cabal update     ```-2. Add `heftia-effects ^>= 0.6` to the build dependencies. Enable the `GHC2021` and the following language extensions as needed:+2. Add `heftia-effects ^>= 0.7` to the build dependencies. Enable the `GHC2021` and the following language extensions as needed:      * `LambdaCase`     * `DerivingStrategies`@@ -142,7 +146,7 @@ ...     build-depends:         ...-        heftia-effects ^>= 0.6,+        heftia-effects ^>= 0.7,      default-language: GHC2021 @@ -265,11 +269,11 @@  * `End` is displayed just after the first sequence ends and before the second sequence starts. This demonstrates that the `bracket_` function based on `MonadUnliftIO` for safe resource release works in such a way that resources are released immediately at the correct timing—even if the stream is still in progress—rather than waiting until the entire stream (including the second sequence) has completed. Existing stream libraries like [`pipes`](https://hackage.haskell.org/package/pipes) and [`conduit`](https://hackage.haskell.org/package/conduit) have the issue that immediate resource release like this is not possible. This problem was first addressed by the effect system library [`bluefin`](https://github.com/tomjaguarpaw/bluefin). For more details, please refer to [Bluefin streams finalize promptly](https://h2.jaguarpaw.co.uk/posts/bluefin-streams-finalize-promptly/). -The complete code example can be found at [heftia-effects/Example/Stream/Main.hs](https://github.com/sayo-hs/heftia/blob/v0.6.0/heftia-effects/Example/Stream/Main.hs).+The complete code example can be found at [heftia-effects/Example/Stream/Main.hs](https://github.com/sayo-hs/heftia/blob/v0.7.0.0/heftia-effects/Example/Stream/Main.hs).  ### Aggregating File Sizes Using Non-Deterministic Computation -The following is an extract of the main parts from an example of non-deterministic computation. For the full code, please refer to [heftia-effects/Example/NonDet/Main.hs](https://github.com/sayo-hs/heftia/blob/v0.6.0/heftia-effects/Example/NonDet/Main.hs).+The following is an extract of the main parts from an example of non-deterministic computation. For the full code, please refer to [heftia-effects/Example/NonDet/Main.hs](https://github.com/sayo-hs/heftia/blob/v0.7.0.0/heftia-effects/Example/NonDet/Main.hs).  ```haskell -- | Aggregate the sizes of all files under the given path@@ -340,8 +344,8 @@ ```  ## Documentation-A detailed explanation of usage and semantics is available in [Haddock](https://hackage.haskell.org/package/heftia-0.6.0.0/docs/Control-Monad-Hefty.html).-The example codes are located in the [heftia-effects/Example/](https://github.com/sayo-hs/heftia/tree/v0.6.0/heftia-effects/Example) directory.+A detailed explanation of usage and semantics is available in [Haddock](https://hackage.haskell.org/package/heftia-0.7.0.0/docs/Control-Monad-Hefty.html).+The example codes are located in the [heftia-effects/Example/](https://github.com/sayo-hs/heftia/tree/v0.7.0.0/heftia-effects/Example) directory. Also, the following *HeftWorld* example (outdated): https://github.com/sayo-hs/HeftWorld  About the internal *elaboration* mechanism: https://sayo-hs.github.io/jekyll/update/2024/09/04/how-the-heftia-extensible-effects-library-works.html@@ -368,7 +372,7 @@ | `freer-simple`      | ❌                   | Multi-shot             | ✅            | ✅                                | ✅                       | Algebraic Effects                | | `polysemy`          | ✅                   | ❌                     | ✅            | ✅                                | ✅                       | Weaving-based (functorial state) | | `effectful`         | ✅                   | ❌                     | ✅            | ❌ (based on the `IO` monad)      | ✅                       | IO-fused                         |-| `bluefin`           | ❌[^7]               | ❌                     | ✅            | ❌ (based on the `IO` monad)      | [^5]                     | IO-fused                         |+| `bluefin`           | ✅[^7][^10]          | ❌                     | ✅            | ❌ (based on the `IO` monad)      | ✅[^5]                   | IO-fused                         | | `eff`               | ✅                   | Multi-shot             | ✅            | ❌ (based on the `IO` monad)      | ✅                       | Algebraic Effects & IO-fused [^6]| | `speff`             | ✅                   | Multi-shot (restriction: [^4]) | ✅    | ❌ (based on the `IO` monad)      | ✅                       | Algebraic Effects & IO-fused     | | `mtl`               | ✅                   | Multi-shot (`ContT`)   | ✅            | ✅                                | ❌                       | Carrier dependent                |@@ -383,6 +387,7 @@ [^5]: https://discourse.haskell.org/t/bluefin-compared-to-effectful-video/10723/27?u=ymdfield [^6]: https://github.com/hasura/eff/issues/12 [^7]: https://discourse.haskell.org/t/what-is-a-higher-order-effect/10744+[^10]: https://github.com/tomjaguarpaw/bluefin/pull/27  Heftia can simply be described as a higher-order version of `freer-simple`. This is indeed true in terms of its internal mechanisms as well.@@ -399,10 +404,10 @@  ### Performance -Overall, the performance of this library is positioned roughly in the middle between the fast (`effectful`, `eveff`, etc.) and slow (`polysemy`, `fused-effects`, etc.) libraries, and can be considered average.-In all benchmarks, the speed is nearly equivalent to `freer-simple`, only slightly slower.+Overall, the performance of this library is roughly on par with `effectful`, or only slightly slower.+`heftia` runs significantly faster compared to existing effect systems such as `mtl` and `polysemy`. -For more details, please refer to [performance.md](https://github.com/sayo-hs/heftia/blob/v0.6.0/benchmark/performance.md).+For more details, please refer to [performance.md](https://github.com/sayo-hs/heftia/blob/v0.7.0.0/benchmark/performance.md).  ### Interoperability with other libraries @@ -435,13 +440,13 @@ * (Support for [Linear](https://hackage.haskell.org/package/linear-base) effects?)  ## License-The license is MPL 2.0. Please refer to the [NOTICE](https://github.com/sayo-hs/heftia/blob/v0.6.0/NOTICE).+The license is MPL 2.0. Please refer to the [NOTICE](https://github.com/sayo-hs/heftia/blob/v0.7.0.0/NOTICE). Additionally, the code from `freer-simple` has been modified and used internally within this library. Therefore, some modules are licensed under both `MPL-2.0 AND BSD-3-Clause`. For details on licenses and copyrights, please refer to the module's Haddock documentation.  ## Your contributions are welcome!-Please see [CONTRIBUTING.md](https://github.com/sayo-hs/heftia/blob/v0.6.0/CONTRIBUTING.md).+Please see [CONTRIBUTING.md](https://github.com/sayo-hs/heftia/blob/v0.7.0.0/CONTRIBUTING.md).  ## Acknowledgements, citations, and related work The following is a non-exhaustive list of people and works that have had a significant impact, directly or indirectly, on Heftia’s design and implementation:

@@ -1,6 +1,6 @@ cabal-version:      3.0 name:               heftia-version:            0.6.0.0+version:            0.7.0.0  -- A short (one-line) description of the package. synopsis: higher-order algebraic effects done right@@ -51,7 +51,7 @@ source-repository head     type: git     location: https://github.com/sayo-hs/heftia-    tag: v0.6.0+    tag: v0.7.0.0     subdir: heftia  library@@ -79,7 +79,7 @@     -- other-extensions:     build-depends:         base                          >= 4.17 && < 4.22,-        data-effects                  ^>= 0.4,+        data-effects                  ^>= 0.4.2,         mtl                           >= 2.2.2 && < 2.4,         unliftio                      ^>= 0.2, 

@@ -27,11 +27,11 @@ import Prelude hiding (log, span)  data Log :: t'Effect' where-    Log :: String -> Log ()+    Log :: String -> Log f () 'makeEffectF' ''Log  data Span :: t'Effect' where-    Span :: String -> m a -> Span m a+    Span :: String -> f a -> Span f a 'makeEffectH' ''Span  runLog :: (@t'Emb'@ 'IO' t'Data.Effect.OpenUnion.:>' es) => 'Eff' (Log ': es) t'Control.Effect.~>' 'Eff' es@@ -78,10 +78,10 @@ By ignoring the continuation argument, it allows for global escapes like the 'Data.Effect.Except.Throw' effect.  @-[runThrow](https://hackage.haskell.org/package/heftia-effects-0.6.0.0/docs/Control-Monad-Hefty-Except.html#v:runThrow) :: ('FOEs' es) => 'Eff' (@t'Data.Effect.Except.Throw'@ e ': es) a -> 'Eff' es ('Either' e a)+[runThrow](https://hackage.haskell.org/package/heftia-effects-0.7.0.0/docs/Control-Monad-Hefty-Except.html#v:runThrow) :: ('FOEs' es) => 'Eff' (@t'Data.Effect.Except.Throw'@ e ': es) a -> 'Eff' es ('Either' e a) runThrow = 'interpretBy' ('pure' '.' 'Right') handleThrow -[handleThrow](https://hackage.haskell.org/package/heftia-effects-0.6.0.0/docs/Control-Monad-Hefty-Except.html#v:handleThrow) :: 'Applicative' g => 'AlgHandler' (@t'Data.Effect.Except.Throw'@ e) f g ('Either' e a)+[handleThrow](https://hackage.haskell.org/package/heftia-effects-0.7.0.0/docs/Control-Monad-Hefty-Except.html#v:handleThrow) :: 'Applicative' g => 'AlgHandler' (@t'Data.Effect.Except.Throw'@ e) f g ('Either' e a) handleThrow (@v'Data.Effect.Except.Throw'@ e) _ = 'pure' $ 'Left' e @ @@ -90,7 +90,7 @@ By calling the continuation argument multiple times, it allows for non-deterministic computations like the "Data.Effect.NonDet" effect.  @-[runNonDet](https://hackage.haskell.org/package/heftia-effects-0.6.0.0/docs/Control-Monad-Hefty-NonDet.html#v:runNonDet)+[runNonDet](https://hackage.haskell.org/package/heftia-effects-0.7.0.0/docs/Control-Monad-Hefty-NonDet.html#v:runNonDet)     :: ('Alternative' f)     => 'Eff' (@t'Data.Effect.NonDet.Choose'@ ': t'Data.Effect.NonDet.Empty' ': es) a     -> 'Eff' es (f a)@@ -167,10 +167,10 @@ Let's revisit the definition of @runCatch@:  @-[runCatch](https://hackage.haskell.org/package/heftia-effects-0.6.0.0/docs/Control-Monad-Hefty-Except.html#v:runCatch) :: (@t'Data.Effect.Except.Throw'@ e `@t'Data.Effect.OpenUnion.In'@` es, 'FOEs' es) => 'Eff' (@t'Data.Effect.Except.Catch'@ e ': es) t'Control.Effect.~>' 'Eff' es-runCatch = 'interpret' elabCatch+[runCatch](https://hackage.haskell.org/package/heftia-effects-0.7.0.0/docs/Control-Monad-Hefty-Except.html#v:runCatch) :: (@t'Data.Effect.Except.Throw'@ e `@t'Data.Effect.OpenUnion.In'@` es, 'FOEs' es) => 'Eff' (@t'Data.Effect.Except.Catch'@ e ': es) t'Control.Effect.~>' 'Eff' es+runCatch = 'interpret' handleCatch -[handleCatch](https://hackage.haskell.org/package/heftia-effects-0.6.0.0/docs/Control-Monad-Hefty-Except.html#v:handleCatch) :: (@t'Data.Effect.Except.Throw'@ e `@t'Data.Effect.OpenUnion.In'@` es, 'FOEs' es) => t'Data.Effect.Except.Catch' e t'Control.Monad.Hefty.~~>' 'Eff' es+[handleCatch](https://hackage.haskell.org/package/heftia-effects-0.7.0.0/docs/Control-Monad-Hefty-Except.html#v:handleCatch) :: (@t'Data.Effect.Except.Throw'@ e `@t'Data.Effect.OpenUnion.In'@` es, 'FOEs' es) => t'Data.Effect.Except.Catch' e t'Control.Monad.Hefty.~~>' 'Eff' es handleCatch (@v'Data.Effect.Except.Catch'@ action hdl) = action & 'interposeWith' \\(@v'Data.Effect.Except.Throw'@ e) _ -> hdl e @ @@ -305,6 +305,8 @@     type (~>),     type (~~>),     FOEs,+    PolyHFunctor,+    PolyHFunctors,     type (:>),     type In,     type Has,@@ -402,6 +404,9 @@     onlyFOEs,     WeakenHOEs,     RemoveHOEs,+    onlyPolys,+    WeakenExps,+    RemoveExps,     raisePrefix,     raiseSuffix,     raisePrefix1,@@ -427,6 +432,7 @@ import Control.Effect.Interpret (interposeIn, interposeOn, interprets, reinterprets) import Control.Effect.Transform (     onlyFOEs,+    onlyPolys,     raise,     raisePrefix,     raisePrefix1,@@ -489,7 +495,24 @@ import Control.Monad.IO.Class (liftIO) import Data.Effect import Data.Effect.HFunctor.TH-import Data.Effect.OpenUnion (FOEs, Has, In, KnownOrder, RemoveHOEs, Suffix, SuffixUnder, WeakenHOEs, nil, (!++), (!:), (:>), type (++))+import Data.Effect.OpenUnion (+    FOEs,+    Has,+    In,+    KnownOrder,+    PolyHFunctors,+    RemoveExps,+    RemoveHOEs,+    Suffix,+    SuffixUnder,+    WeakenExps,+    WeakenHOEs,+    nil,+    (!++),+    (!:),+    (:>),+    type (++),+ ) import Data.Effect.TH import Data.Effect.Tag import Data.Kind (Type)