ModuleCabal-syntax-3.18.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.

Contents

Types
LensLike
rank-1 types
Getter
Setter
Fold
Lens
Common lenses
Operators
Internal Comonads
Cabal developer info

Synopsis

type Lens
type Lens'
type Traversal
type Traversal'
type LensLike
type LensLike'
type Getting
type AGetter
type ASetter
type ALens
type ALens'
value view
value use
value getting
value set
value over
value toDListOf
value toListOf
value toSetOf
value cloneLens
value aview
value _1
value _2
value &
value ^.
value .~
value ?~
value %~
value .=
value ?=
value %=
value ^#
value #~
value #%~
data Pretext

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

Types

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

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

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

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

Source#

Example1 expression

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

Setter

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

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

Fold

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

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

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

Common lenses

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

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

Source#

& 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

datadata Pretext a b t

Source#

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.18.1.0 · Distribution.Compat.Lens

Cabal developer info

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.