mtl (Monad Transformer Library)

MTL (Monad Transformer Library) extends the transformers package by providing type classes that define monadic operations for various transformers.

MTL follows a consistent naming convention for a transformer (e.g., Foo):

1. Module: Control.Monad.Foo contains the interface.
2. Type Class: MonadFoo defines the operations available within the transformer.
3. Data Type: FooT is the actual transformer implementation (usually from the transformers package) for which MTL provides instances.
4. Runner: Functions like runFooT are used to execute the transformed computation.

In mtl-2.3.x, many re-exports that overlapped with base were removed to achieve PVP compliance and clean up the library design. If your code relies on functions that were previously available via mtl re-exports, you must now import the original modules explicitly.

Steps to migrate:

1. Update dependencies: Update your .cabal file to require mtl-2.3.1 or configure your cabal.project to use the specific git tag.
2. Fix imports: If you encounter compilation errors stating that functions are missing, identify which module they belong to and add an explicit import for that module (e.g., import Control.Monad directly instead of relying on an mtl module to re-export it).

# Update cabal.project to use mtl-2.3.1 via git
source-repository-package
  type: git
  location: https://github.com/haskell/mtl
  tag: v2.3.1

allow-newer:
  *:mtl

When working with monad transformers, you often need to take an action from an inner monad m and wrap it in the transformer t. This is achieved using the lift function from the MonadTrans class in Control.Monad.Trans.Class.

Signature:

lift :: (Monad m, MonadTrans t) => m a -> t m a

Example: Lifting an IO action into an ExceptT transformer:

data MyError = EmptyLine

mightFail :: ExceptT MyError IO ()
mightFail = do
  l <- lift getLine
  when (null l) (throwError EmptyLine)

The WriterT transformer represents a computation that produces a stream of data (typically a Monoid) in addition to the computed values. This is useful for logging or accumulating values.

• Class: Control.Monad.Writer.Class.MonadWriter
• Lazy transformers: Control.Monad.Writer.Lazy.WriterT
• Strict transformers: Control.Monad.Writer.Strict.WriterT

The StateT transformer represents a computation that can read and write internal state values. If you only need to read values, use Reader instead.

• Class: Control.Monad.State.Class.MonadState
• Lazy transformer: Control.Monad.State.Lazy.StateT (default)
• Strict transformer: Control.Monad.State.Strict.StateT

The ReaderT transformer represents a computation that can read values from a shared environment.

• Class: Control.Monad.Reader.Class.MonadReader
• Transformer: Control.Monad.Reader.ReaderT

The ExceptT transformer adds the ability to fail with an error in a monadic computation. Use the MonadError class to interact with it. This replaces the deprecated Control.Monad.Error.

• Class: Control.Monad.Except.Class.MonadError
• Transformer: Control.Monad.Except.ExceptT