ModuleCabal-syntax-3.12.1.0Haskell2010

Distribution.Compat.Lens

This module provides very basic lens functionality, without extra dependencies.

For the documentation of the combinators see lens package. This module uses the same vocabulary.

12 types
23 values

PackageCabal-syntax-3.12.1.0
Exports35
LanguageHaskell2010
LicenceBSD-3-Clause
SourceLens.hs

Types

4 declarations

typetype Lens s t a b = forall (f :: Type -> Type). Functor f => LensLike f s t a b

typetype Lens' s a = Lens s s a a

typetype Traversal s t a b = forall (f :: Type -> Type). Applicative f => LensLike f s t a b

typetype Traversal' s a = Traversal s s a a

LensLike

typetype LensLike (f :: Type -> Type) s t a b = (a -> f b) -> s -> f t

typetype LensLike' (f :: Type -> Type) s a = (a -> f a) -> s -> f s

rank-1 types

typetype Getting r s a = LensLike (Const r) s s a a

typetype AGetter s a = LensLike (Const a) s s a a

typetype ASetter s t a b = LensLike Identity s t a b

typetype ALens s t a b = LensLike (Pretext a b) s t a b

typetype ALens' s a = ALens s s a a

Getter

3 declarations

valueview :: Getting a s a -> s -> a

valueuse :: MonadState s m => Getting a s a -> m a

valuegetting :: (s -> a) -> Getting r s a

Example1 expression

>>> (3 :: Int) ^. getting (+2) . getting show"5"

Setter

2 declarations

valueset :: ASetter s t a b -> b -> s -> t

valueover :: ASetter s t a b -> (a -> b) -> s -> t

Fold

3 declarations

valuetoDListOf :: Getting (DList a) s a -> s -> DList a

valuetoListOf :: Getting (DList a) s a -> s -> [a]

valuetoSetOf :: Getting (Set a) s a -> s -> Set a

Lens

2 declarations

valuecloneLens :: Functor f => ALens s t a b -> LensLike f s t a b

valueaview :: ALens s t a b -> s -> a

Common lenses

2 declarations

value_1 :: Functor f => LensLike f (a, c) (b, c) a b

value_2 :: Functor f => LensLike f (c, a) (c, b) a b

Operators

11 declarations

value(&) :: a -> (a -> b) -> b

& is a reverse application operator

value(^.) :: s -> Getting a s a -> a

value(.~) :: ASetter s t a b -> b -> s -> t

value(?~) :: ASetter s t a (Maybe b) -> b -> s -> t

value(%~) :: ASetter s t a b -> (a -> b) -> s -> t

value(.=) :: MonadState s m => ASetter s s a b -> b -> m ()

value(?=) :: MonadState s m => ASetter s s a (Maybe b) -> b -> m ()

value(%=) :: MonadState s m => ASetter s s a b -> (a -> b) -> m ()

value(^#) :: s -> ALens s t a b -> a

value(#~) :: ALens s t a b -> b -> s -> t

value(#%~) :: ALens s t a b -> (a -> b) -> s -> t

Internal Comonads

1 declaration

datadata Pretext a b t

lens variant is also parametrised by profunctor.

Constructors

Pretext
- runPretext :: forall (f :: Type -> Type). Functor f => (a -> f b) -> f t

Instances1Functor

Functor (Pretext a b)Defined in Cabal-syntax-3.12.1.0 · Distribution.Compat.Lens

Cabal developer info

0 declarations

We cannot depend on template-haskell, because Cabal is a boot library. This fact makes defining optics a manual task. Here is a small recipe to make the process less tedious.

First start a repl

cabal new-repl Cabal-tests:hackage-tests

Because --extra-package isn't yet implemented, we use a test-suite with generics-sop dependency.

In the repl, we load a helper script:

:l ../generics-sop-lens.hs

Now we are set up to derive lenses!

:m +Distribution.Types.SourceRepo
putStr $ genericLenses (Proxy :: Proxy SourceRepo)

repoKind :: Lens' SourceRepo RepoKind
repoKind f s = fmap (\x -> s { T.repoKind = x }) (f (T.repoKind s))
{-# INLINE repoKind #-}
...

Note: You may need to adjust type-aliases, e.g. String to FilePath.