Popularity

4.7

Declining

Activity

0.0

Stable

Stars 6

Watchers 4

Forks 0

Last Commit about 8 years ago

Monthly Downloads: 6

Programming language: Haskell

License: MIT License

Tags: Control Monad

Latest version: v0.1.0.1

monad-levels alternatives and similar packages

Based on the "monad" category.
Alternatively, view monad-levels alternatives based on common mentions on social networks and blogs.

monad-control

9.1 0.0 monad-levels VS monad-control

Lift control operations, like exception catching, through monad transformers
monad-validate

9.1 0.0 monad-levels VS monad-validate

(NOTE: REPOSITORY MOVED TO NEW OWNER: https://github.com/lexi-lambda/monad-validate) A Haskell monad transformer library for data validation

Access the most powerful time series database as a service

Ingest, store, & analyze all types of time series data in a fully-managed, purpose-built database. Keep data forever with low-cost storage and superior data compression.

Promo www.influxdata.com

monad-time

8.9 0.0 monad-levels VS monad-time

Type class for monads which carry the notion of the current time.
monad-unlift

8.4 0.0 monad-levels VS monad-unlift

Typeclasses for representing monad (transformer) morphisms
monad-metrics

8.4 0.0 monad-levels VS monad-metrics

haskell metrics
monad-unlift-ref

8.4 0.0 monad-levels VS monad-unlift-ref

Typeclasses for representing monad (transformer) morphisms
monad-loops

8.3 0.0 monad-levels VS monad-loops

Some useful control operators for looping
monad-memo

7.7 0.0 monad-levels VS monad-memo

Memoization monad transformer
monad-skeleton

7.7 0.0 monad-levels VS monad-skeleton

Operational monad library
monad-logger-prefix

7.7 0.0 monad-levels VS monad-logger-prefix

Easily add a prefix to your MonadLogger output.
monad-batcher

7.3 0.0 monad-levels VS monad-batcher

An applicative monad that batches commands for later more efficient execution
monad-ste

6.7 0.0 monad-levels VS monad-ste

ST with efficient exceptions
monad-supply

6.4 1.5 monad-levels VS monad-supply

Support for computations which consume values from a (possibly infinite) supply.
monad-classes

6.1 0.0 monad-levels VS monad-classes

A more flexible mtl
monad-io-adapter

6.1 0.0 monad-levels VS monad-io-adapter

A Haskell package that adapts between MonadIO and MonadBase IO
monad-st

4.9 0.0 monad-levels VS monad-st

A basic monad for lifting ST actions
monad-task

4.7 0.0 monad-levels VS monad-task

Task monad transformer that turns event processing into co-routines programming.
monad-journal

4.7 0.0 monad-levels VS monad-journal

Pure logger typeclass and monad transformer
monad-extras

4.5 0.0 monad-levels VS monad-extras

Extra utility functions for working with monads
monad-resumption

4.0 0.0 monad-levels VS monad-resumption

Resumption and Reactive-Resumption Monads for the Haskell programming language.
monad-loops-stm

3.8 0.0 monad-levels VS monad-loops-stm

STM-specific control operators (split out of monad-loops as of version 0.4)
monad-introspect

2.9 0.0 monad-levels VS monad-introspect

A reader monad that gives the environment access to the entire transformer stack
monad-interleave

2.6 0.0 monad-levels VS monad-interleave

Monads with an unsaveInterleaveIO-like operation
monad-control-aligned

2.2 0.0 monad-levels VS monad-control-aligned

Lift control operations, like exception catching, through monad transformers
monad-control-identity

2.1 0.0 monad-levels VS monad-control-identity

Stronger classes than monad-control
io-manager

2.1 0.0 monad-levels VS io-manager

Skeleton library around the IO monad.
monad-open

1.9 0.0 monad-levels VS monad-open

Open-ended computation for when you need it (open recursion)
monad-peel

1.9 0.0 monad-levels VS monad-peel

Lift control operations like exception catching through monad transformers
monad-var

1.3 0.0 monad-levels VS monad-var

Generic operations over variables
monad-finally

1.3 0.0 monad-levels VS monad-finally

Guard monadic computations with cleanup actions
monad-markov

0.5 0.0 monad-levels VS monad-markov

Markov process monad

Do you think we are missing an alternative of monad-levels or a related project?

Add another 'monad' Package

Popular Comparisons

README

`monad-levels`

Why not mtl?

The oft-spouted problem with the standard monad transformer library mtl and similar libraries is that instances are quadratic: you need a separate instance for each valid combination of transformer + typeclass.

For end users, this isn't really a problem: after all, all the required instances have already been written for you!

But what happens if you have a custom transformer, or a custom typeclass?

What about if you want to have something like MonadIO but for a different base monad?

Then you need to write all those extra instances.

What makes it more frustrating is that many of the instance definitions are identical: typically for every transformer (using StateT s m as an example) it becomes a matter of:

Possibly unwrap the transformer from a monadic value to get the lower monad (e.g. StateT s m a -> m (a,s));
Possibly add internal values (e.g. m a -> m (a,s));
Wrap the lower monad from the result of the computation back up into the transformer (e.g. m (a,s) -> StateT s m a).

The solution

Ideally, instead we'd have something along the lines of (simplified):


class (Monad m) => MonadBase m where
  type BaseMonad m :: * -> *

  liftBase :: BaseMonad m a -> m a

class (MonadBase m) => MonadLevel m where

  type LowerMonad m :: * -> *

  type InnerValue m a :: *

  -- A continuation-based approach for how to lift/lower a monadic value.
  wrap :: (    (m a -> LowerMonad m (InnerValue m a)             -- unwrap
            -> (LowerMonad m a -> LowerMonad m (InnerValue m a)) -- addInternal
            -> LowerMonad m (InnerValue m a)
          )
          -> m a

With these two classes, we could then use Advanced Type Hackery (TM) to let us instead just specify instances for the transformers/monads that do have direct implementations for a typeclass, and then have the rest defined for us!

It turns out that this approach is even powerful enough to make liftBase redundant, and it isn't limited to just lifting a monad but can instead be used for arbitrary functions.

Advantages

Minimal specification required for adding new typeclasses: just specify the instances for monads that satisfy it, and then use the provided machinery to lift/lower methods to other transformers in the monadic stack.
Works even for polyvariadic functions.
Still allows specifying whether certain transformers do not allow some constraints to pass through (e.g. ContT does not allow access to a WriterT).

Disadvantages

Requires a lot of GHC extensions.
Requires usage of proxies when lifting/lowering typeclass methods.
Large usage of associated types means type errors can be difficult to decipher.
Due to usage of closed type-families, it is not possible to add extra instances to typeclasses (i.e. it is not possible to use a custom State monad/monad-transformer with Control.Monad.Levels.State).
Currently un-benchmarked; as such, it's not known how much of a performance penalty this approach takes.
Lowering polyvariadic functions requires specifying the type of the function using a specific grammar (though the common m a -> m a case is pre-defined).

monad-levels

Level-based interpretation of monad transformers