classy-effects-base: An interface for a handler-independent, typeclass-based effect system.

[ control, deprecated, effect, library, mpl ] [ Propose Tags ]
Deprecated in favor of data-effects-core

This library provides definitions for CEPs (classy-effects protocols) to standardize and unify the definition of effects in Haskell in a backend-library-agnostic manner. Please refer to CEPs for details.

This library provides only the fundamental definitions for classy-effects. Please also refer to the classy-effects package, which offers standard effect definitions compliant with CEPs, and the classy-effects-th package, which enables automatic compliance with CEPs.

This 'classy-effects' project was abandoned due to the discovery of fundamental difficulties. The reasons are as follows: As an alternative, consider using 'sayo-hs/data-effects', a GADTs-based common effect representation foundation:

[Skip to Readme]


Maintainer's Corner

Package maintainers

For package maintainers and hackage trustees


  • No Candidates
Versions [RSS],
Change log
Dependencies base (>= && <4.17), compdata (>=0.13 && <0.14) [details]
License MPL-2.0
Copyright 2023 Yamada Ryo, 2023 Casper Bach Poulsen and Cas van der Rest
Author Yamada Ryo <>
Maintainer Yamada Ryo <>
Category Control, Effect
Bug tracker
Source repo head: git clone v0.1.0)(classy-effects-base)
Uploaded by YamadaRyo at 2024-07-09T11:04:52Z
Reverse Dependencies 3 direct, 1 indirect [details]
Downloads 53 total (15 in the last 30 days)
Rating (no votes yet) [estimated by Bayesian average]
Your Rating
  • λ
  • λ
  • λ
Status Docs uploaded by user
Build status unknown [no reports yet]

Readme for classy-effects-base-

[back to package description]

Status (2024) : This classy-effects project was abandoned due to the discovery of fundamental difficulties.

The reasons are as follows:

As an alternative, consider using sayo-hs/data-effects, a GADTs-based common effect representation foundation:


Hackage Hackage Hackage

This repository is for CEPs and its associated Haskell library.

CEPs (Classy-Effects Protocols) are a collection of protocols for expressing and defining effects in Haskell, aimed at the fist objective in the Sayo Project:

Exploring ways to improve interoperability among the myriad Haskell effect system libraries

For more details, please refer to CEPs/


In Haskell, there are numerous libraries to realize an effect system. The issue here is interoperability between these libraries. For instance, the Reader effect in fused-effects and the Reader effect in polysemy have completely identical definitions. If we could extract and define effects purely as interfaces, eliminating this redundancy in effect definitions, then an effectful program could be handled by both effect system library A and effect system library B. The specific mechanisms for handling effects vary from one library to another, and unifying them isn't the goal. We're specifically looking to unify the overlapping and common definitions of effects as interfaces.

Based on this idea, CEPs (classy-effects protocols) were developed. CEPs propose a convention (protocol) for unified effect definitions in Haskell. It's expected that effects defined in accordance with CEPs will be usable across various effect systems and backends.

Encoding of Effect

First, for the representation of effects, there is the GADTs encoding typical in Extensible Effects and the type-class encoding typical in the monad transformer approach. In principle, if the type class representing the effect is decided, GADTs can be automatically generated, and the reverse is probably also possible. There's a kind of symmetry here. However, type classes have the advantage of expressing inclusion relationships of effects naturally by specifying superclasses. From this perspective, CEPs primarily adopt type class representation for effects. Moreover, a mechanism has been implemented to derive GADTs from type classes1, and from GADTs and the type classes that cast them to monads (SendIns, SendSig), to automatically derive instances of the effect's type class (classy-effects-th). This allows compliance with CEPs automatically by just writing the type class that represents the effect.


Examples of using classy-effects combined with the Heftia effect handler backend can be found here.

Your contributions are welcome!

Please see


Parts of this project have been adapted or inspired by the following resources:

  • Hefty Algebras -- The Artifact

    • Copyright (c) 2023 Casper Bach Poulsen and Cas van der Rest
    • License: MIT
    • Modifications: The inspiration for the idea of Heftia. Code was used in the definition of LiftIns.
  • effet

    • Copyright (c) 2020 Michael Szvetits
    • License: BSD-3-Clause
    • Modifications: Used TemplateHaskell code to handle the effect type class.
  • compdata

    • Copyright (c) 2010--2011 Patrick Bahr, Tom Hvitved
    • License: BSD-3-Clause
    • Modifications: Used TemplateHaskell code to derive instances of the HFunctor type class.

In the future, we might also consider implementing the derivation of type classes from GADTs.