cornea: classy optical monadic state

[ lens, library ] [ Propose Tags ]

Please see the README on GitHub at

[Skip to Readme]


Maintainer's Corner

Package maintainers

For package maintainers and hackage trustees


Versions [RSS],,,,,,,,, (info)
Dependencies base (>=4 && <5), either (>=5.0.1), lens (>=4), lifted-base (<0.3), monad-control (>=1.0), mtl, relude (>=0.7), template-haskell, th-abstraction (>=0.3), transformers [details]
License BSD-2-Clause-Patent
Copyright 2021 Torsten Schmits
Author Torsten Schmits
Category Lens
Home page
Bug tracker
Source repo head: git clone
Uploaded by tek at 2022-02-05T14:43:57Z
Distributions NixOS:
Reverse Dependencies 3 direct, 4 indirect [details]
Downloads 2355 total (26 in the last 30 days)
Rating 2.0 (votes: 1) [estimated by Bayesian average]
Your Rating
  • λ
  • λ
  • λ
Status Docs uploaded by user
Build status unknown [no reports yet]

Readme for cornea-

[back to package description]


Classes for accessing and mutating nested data types with corresponding adapter classes for MonadState, MonadReader and MonadError. Inspired by the next level mtl with classy optics talk.



Lenses and Prisms from lens are autogenerated with TH by splicing with deepPrisms and deepLenses. The generator recurses into single-field constructors and record fields if there are instances of DeepPrisms or DeepLenses for their parameter types.


For MonadError:

{-# LANGUAGE TemplateHaskell #-}

import Cornea (MonadDeepError(throwHoist))
import Control.Monad.Trans.Except (runExceptT)
import Data.DeepPrisms (deepPrisms)

newtype Error = Error String

newtype Inner = Inner Error
deepPrisms ''Inner

data Mid = Mid Inner
deepPrisms ''Mid

newtype Outer = Outer Mid
deepPrisms ''Outer

throwDeep :: MonadDeepError e Inner m => m ()
throwDeep = throwHoist (Inner (Error "boom"))

main :: IO (Either Outer ())
main = runExceptT throwDeep

In main, MonadError Outer IO and DeepPrisms Outer Inner are summoned.

Analogously for MonadState:

{-# LANGUAGE TemplateHaskell #-}

import Cornea (MonadDeepState(get, gets, put))
import Control.Monad.Trans.State (execStateT)
import Data.DeepLenses (deepLenses)

newtype S = S Int

newtype Inner = Inner { _innerS :: S }
deepLenses ''Inner

data Mid = Mid { _midInner :: Inner }
deepLenses ''Mid

newtype Outer = Outer { _outerMid :: Mid }
deepLenses ''Outer

stateDeep :: MonadDeepState s Inner m => m ()
stateDeep = do
  (Inner (S a)) <- get
  b <- gets $ \(Inner (S b)) -> b
  put (Inner (S (a + b + 3)))

main :: IO Outer
main = do
  execStateT stateDeep (Outer (Mid (Inner (S 5))))

MonadReader works basically the same as MonadState.