extensible-effects: An Alternative to Monad Transformers

This is a package candidate release! Here you can preview how this package release will appear once published to the main package index (which can be accomplished via the 'maintain' link below). Please note that once a package has been published to the main package index it cannot be undone! Please consult the package uploading documentation for more information.

[maintain] [Publish]

This package introduces datatypes for typeclass-constrained effects, as an alternative to monad-transformer based (datatype-constrained) approach of multi-layered effects. For more information, see the original paper at http://okmij.org/ftp/Haskell/extensible/exteff.pdf. Any help is appreciated!

[Skip to Readme]

Properties

Versions	1.0, 1.1.0, 1.2.0, 1.2.1, 1.4.1, 1.5.0, 1.6.0, 1.7.1, 1.7.1.0, 1.7.1.1, 1.7.1.2, 1.7.2.1, 1.8.0.0, 1.8.1.0, 1.9.0.0, 1.9.0.1, 1.9.1.0, 1.9.2.2, 1.10.0.1, 1.11.0.0, 1.11.0.1, 1.11.0.2, 1.11.0.3, 1.11.0.4, 1.11.1.0, 2.0.0.0, 2.0.0.1, 2.0.0.2, 2.0.1.0, 2.1.0.0, 2.2.1.0, 2.3.0.0, 2.3.0.1, 2.4.0.0, 2.5.0.0, 2.5.1.0, 2.5.1.2, 2.5.2.0, 2.5.3.0, 2.6.0.0, 2.6.0.1, 2.6.0.2, 2.6.0.3, 2.6.1.0, 2.6.1.1, 2.6.2.0, 2.6.3.0, 3.0.0.0, 3.1.0.0, 3.1.0.1, 3.1.0.2, 4.0.0.0, 5.0.0.0, 5.0.0.1
Change log	None available
Dependencies	base (>=4.6 && <5), transformers (>=0.3 && <0.6), transformers-base (>=0.4 && <0.5), type-aligned (>=0.9.3) [details]
License	MIT
Author	Oleg Kiselyov, Amr Sabry, Cameron Swords, Ben Foppa
Maintainer	suhailshergill@gmail.com
Category	Control, Effect
Home page	https://github.com/suhailshergill/extensible-effects
Source repo	head: git clone https://github.com/suhailshergill/extensible-effects.git
Uploaded	by shergill at 2017-11-19T07:50:17Z

Modules

Control
- Control.Eff
  - Control.Eff.Choose
  - Control.Eff.Coroutine
  - Control.Eff.Example
  - Control.Eff.Exception
  - Control.Eff.Fresh
  - Control.Eff.Lift
  - Control.Eff.NdetEff
  - Control.Eff.Operational
    - Control.Eff.Operational.Example
  - Reader
    - Control.Eff.Reader.Lazy
    - Control.Eff.Reader.Strict
  - State
    - Control.Eff.State.Lazy
    - Control.Eff.State.LazyState
    - Control.Eff.State.Strict
  - Control.Eff.Trace
  - Writer
    - Control.Eff.Writer.Lazy
    - Control.Eff.Writer.Strict
Data
- Data.OpenUnion

Flags

Manual Flags

Name	Description	Default
lib-werror		Disabled
force-openunion-51	Force usage of OpenUnion51.hs implementation	Enabled

Use -f <flag> to enable a flag, or -f -<flag> to disable that flag. More info

Downloads

extensible-effects-2.0.0.1.tar.gz [browse] (Cabal source package)
Package description (as included in the package)

Maintainer's Corner

Package maintainers

BenFoppa, SvenHeyll, shergill, sickmind

For package maintainers and hackage trustees

edit package information

Readme for extensible-effects-2.0.0.1

[back to package description]

extensible-effects is based on the work Extensible Effects: An Alternative to Monad Transformers. Please read the paper and the followup freer paper for details. Additional explanation behind the approach can be found on Oleg's website.

[![Join the chat at https://gitter.im/suhailshergill/extensible-effects](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/suhailshergill/extensible-effects?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)

Advantages

Effects can be added, removed, and interwoven without changes to code not dealing with those effects.

Disadvantages

Current implementation only supports GHC version 7.8 and above

Ambiguity-Flexibility tradeoff

The extensibility comes at the cost of some ambiguity. Note, however, that the extensibility can be traded back, but that detracts from some of the advantages. For details see section 4.1 in the paper. This issue manifests itself in a few ways:
- Common functions can't be grouped using typeclasses, e.g. the ask and getState functions can't be grouped with some
```
class Get t a where
  ask :: Member (t a) r => Eff r a
```
  ask is inherently ambiguous, since the type signature only provides a constraint on t, and nothing more. To specify fully, a parameter involving the type t would need to be added, which would defeat the point of having the grouping in the first place.
- Code requires greater number of type annotations. For details see #31.