microlens-ghc-0.4.15.0: microlens + array, bytestring, containers, transformers
Copyright(C) 2013-2016 Edward Kmett 2015-2016 Artyom Kazak 2018 Monadfix
LicenseBSD-style (see the file LICENSE)
Safe HaskellTrustworthy
LanguageHaskell2010

Lens.Micro.GHC

Description

By importing this module you get all functions and types from microlens, as well as the following instances:

  • at for Map, Set, IntMap and IntSet
  • ix for

  • each for the same as above, excluding Set and IntSet
  • _head, _tail, _init, _last for

    • Seq
    • strict and lazy bytestrings
  • strict and lazy for

    • bytestrings
    • StateT, WriterT, RWST
Synopsis

Documentation

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

type Lens' s a = Lens s s a a #

type Traversal' s a = Traversal s s a a #

sets :: ((a -> b) -> s -> t) -> ASetter s t a b #

type ASetter' s a = ASetter s s a a #

type Getting r s a = (a -> Const r a) -> s -> Const r s #

_1 :: Field1 s t a b => Lens s t a b #

_2 :: Field2 s t a b => Lens s t a b #

_3 :: Field3 s t a b => Lens s t a b #

_4 :: Field4 s t a b => Lens s t a b #

_5 :: Field5 s t a b => Lens s t a b #

at :: At m => Index m -> Lens' m (Maybe (IxValue m)) #

each :: Each s t a b => Traversal s t a b #

foldMapOf :: Getting r s a -> (a -> r) -> s -> r #

folded :: forall (f :: Type -> Type) a. Foldable f => SimpleFold (f a) a #

ix :: Ixed m => Index m -> Traversal' m (IxValue m) #

lazy :: Strict lazy strict => Lens' strict lazy #

strict :: Strict lazy strict => Lens' lazy strict #

traversed :: forall (f :: Type -> Type) a b. Traversable f => Traversal (f a) (f b) a b #

type ASetter s t a b = (a -> Identity b) -> s -> Identity t #

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

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

type SimpleFold s a = forall r. Monoid r => Getting r s a #

type SimpleGetter s a = forall r. Getting r s a #

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

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

(+~) :: Num a => ASetter s t a a -> a -> s -> t #

(-~) :: Num a => ASetter s t a a -> a -> s -> t #

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

(<%~) :: LensLike ((,) b) s t a b -> (a -> b) -> s -> (b, t) #

(<<%~) :: LensLike ((,) a) s t a b -> (a -> b) -> s -> (a, t) #

(<<.~) :: LensLike ((,) a) s t a b -> b -> s -> (a, t) #

(<>~) :: Monoid a => ASetter s t a a -> a -> s -> t #

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

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

(^..) :: s -> Getting (Endo [a]) s a -> [a] #

(^?) :: s -> Getting (First a) s a -> Maybe a #

(^?!) :: HasCallStack => s -> Getting (Endo a) s a -> a #

failing :: Traversal s t a b -> Traversal s t a b -> Traversal s t a b #

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

(<&>) :: Functor f => f a -> (a -> b) -> f b #

_Just :: forall a a' f. Applicative f => (a -> f a') -> Maybe a -> f (Maybe a') #

_Left :: forall a b a' f. Applicative f => (a -> f a') -> Either a b -> f (Either a' b) #

_Nothing :: forall a f. Applicative f => (() -> f ()) -> Maybe a -> f (Maybe a) #

_Right :: forall a b b' f. Applicative f => (b -> f b') -> Either a b -> f (Either a b') #

_Show :: (Show a, Read a) => Traversal' String a #

_head :: Cons s s a a => Traversal' s a #

_init :: Snoc s s a a => Traversal' s s #

_last :: Snoc s s a a => Traversal' s a #

_tail :: Cons s s a a => Traversal' s s #

allOf :: Getting All s a -> (a -> Bool) -> s -> Bool #

anyOf :: Getting Any s a -> (a -> Bool) -> s -> Bool #

both :: forall a b f. Applicative f => (a -> f b) -> (a, a) -> f (b, b) #

cosmosOf :: Traversal a t a t -> Traversal a t a b' #

filtered :: (a -> Bool) -> Traversal' a a #

folding :: Foldable f => (s -> f a) -> SimpleFold s a #

forOf :: LensLike f s t a b -> s -> (a -> f b) -> f t #

forOf_ :: Functor f => Getting (Traversed r f) s a -> s -> (a -> f r) -> f () #

has :: Getting Any s a -> s -> Bool #

lens :: (s -> a) -> (s -> b -> t) -> Lens s t a b #

lined :: Traversal' String String #

mapAccumLOf :: LensLike (State acc) s t a b -> (acc -> a -> (acc, b)) -> acc -> s -> (acc, t) #

mapMOf :: LensLike (WrappedMonad m) s t a b -> (a -> m b) -> s -> m t #

mapped :: Functor f => ASetter (f a) (f b) a b #

non :: Eq a => a -> Lens' (Maybe a) a #

noneOf :: Getting Any s a -> (a -> Bool) -> s -> Bool #

over :: ASetter s t a b -> (a -> b) -> s -> t #

rewriteMOf :: Monad m => LensLike (WrappedMonad m) a b a b -> (b -> m (Maybe a)) -> a -> m b #

rewriteOf :: ASetter a b a b -> (b -> Maybe a) -> a -> b #

set :: ASetter s t a b -> b -> s -> t #

singular :: HasCallStack => Traversal s t a a -> Lens s t a a #

to :: (s -> a) -> SimpleGetter s a #

toListOf :: Getting (Endo [a]) s a -> s -> [a] #

transformMOf :: Monad m => LensLike (WrappedMonad m) a b a b -> (b -> m b) -> a -> m b #

transformOf :: ASetter a b a b -> (b -> b) -> a -> b #

traverseOf :: LensLike f s t a b -> (a -> f b) -> s -> f t #

traverseOf_ :: Functor f => Getting (Traversed r f) s a -> (a -> f r) -> s -> f () #

worded :: Traversal' String String #

packedBytes :: IsByteString t => Lens' [Word8] t Source #

Treat a list of bytes as a strict or lazy ByteString.

unpackedBytes :: IsByteString t => Lens' t [Word8] Source #

Treat a strict or lazy ByteString as a list of bytes.

packedChars :: IsByteString t => Lens' String t Source #

Treat a String as a strict or lazy ByteString. (Note that it will garble characters above 0xFF, same as pack does.)

unpackedChars :: IsByteString t => Lens' t String Source #

Treat a strict or lazy ByteString as a String. (Just as packedChars, it will garble characters above 0xFF.)

chars :: IsByteString t => Traversal' t Char Source #

Traverse characters in a strict or lazy ByteString (to traverse bytes instead of characters, use each).

Orphan instances

At IntSet Source # 
Instance details

Methods

at :: Index IntSet -> Lens' IntSet (Maybe (IxValue IntSet)) #

Ixed ByteString Source # 
Instance details

Methods

ix :: Index ByteString -> Traversal' ByteString (IxValue ByteString) #

Ixed ByteString Source # 
Instance details

Methods

ix :: Index ByteString -> Traversal' ByteString (IxValue ByteString) #

Ixed IntSet Source # 
Instance details

Methods

ix :: Index IntSet -> Traversal' IntSet (IxValue IntSet) #

Strict ByteString ByteString Source # 
Instance details

Methods

strict :: Lens' ByteString ByteString #

lazy :: Lens' ByteString ByteString #

Cons ByteString ByteString Word8 Word8 Source # 
Instance details

Methods

_Cons :: Traversal ByteString ByteString (Word8, ByteString) (Word8, ByteString)

Cons ByteString ByteString Word8 Word8 Source # 
Instance details

Methods

_Cons :: Traversal ByteString ByteString (Word8, ByteString) (Word8, ByteString)

(a ~ Word8, b ~ Word8) => Each ByteString ByteString a b Source # 
Instance details

Methods

each :: Traversal ByteString ByteString a b #

(a ~ Word8, b ~ Word8) => Each ByteString ByteString a b Source # 
Instance details

Methods

each :: Traversal ByteString ByteString a b #

Snoc ByteString ByteString Word8 Word8 Source # 
Instance details

Methods

_Snoc :: Traversal ByteString ByteString (ByteString, Word8) (ByteString, Word8)

Snoc ByteString ByteString Word8 Word8 Source # 
Instance details

Methods

_Snoc :: Traversal ByteString ByteString (ByteString, Word8) (ByteString, Word8)

At (IntMap a) Source # 
Instance details

Methods

at :: Index (IntMap a) -> Lens' (IntMap a) (Maybe (IxValue (IntMap a))) #

Ord k => At (Set k) Source # 
Instance details

Methods

at :: Index (Set k) -> Lens' (Set k) (Maybe (IxValue (Set k))) #

Ixed (IntMap a) Source # 
Instance details

Methods

ix :: Index (IntMap a) -> Traversal' (IntMap a) (IxValue (IntMap a)) #

Ixed (Seq a) Source # 
Instance details

Methods

ix :: Index (Seq a) -> Traversal' (Seq a) (IxValue (Seq a)) #

Ord k => Ixed (Set k) Source # 
Instance details

Methods

ix :: Index (Set k) -> Traversal' (Set k) (IxValue (Set k)) #

Ixed (Tree a) Source # 
Instance details

Methods

ix :: Index (Tree a) -> Traversal' (Tree a) (IxValue (Tree a)) #

Cons (Seq a) (Seq b) a b Source # 
Instance details

Methods

_Cons :: Traversal (Seq a) (Seq b) (a, Seq a) (b, Seq b)

Each (IntMap a) (IntMap b) a b Source # 
Instance details

Methods

each :: Traversal (IntMap a) (IntMap b) a b #

Each (Seq a) (Seq b) a b Source # 
Instance details

Methods

each :: Traversal (Seq a) (Seq b) a b #

Each (Tree a) (Tree b) a b Source # 
Instance details

Methods

each :: Traversal (Tree a) (Tree b) a b #

Snoc (Seq a) (Seq b) a b Source # 
Instance details

Methods

_Snoc :: Traversal (Seq a) (Seq b) (Seq a, a) (Seq b, b)

Ord k => At (Map k a) Source # 
Instance details

Methods

at :: Index (Map k a) -> Lens' (Map k a) (Maybe (IxValue (Map k a))) #

(IArray UArray e, Ix i) => Ixed (UArray i e) Source # 
Instance details

Methods

ix :: Index (UArray i e) -> Traversal' (UArray i e) (IxValue (UArray i e)) #

Ord k => Ixed (Map k a) Source # 
Instance details

Methods

ix :: Index (Map k a) -> Traversal' (Map k a) (IxValue (Map k a)) #

Ix i => Ixed (Array i e) Source # 
Instance details

Methods

ix :: Index (Array i e) -> Traversal' (Array i e) (IxValue (Array i e)) #

(Ix i, IArray UArray a, IArray UArray b, i ~ j) => Each (UArray i a) (UArray j b) a b Source # 
Instance details

Methods

each :: Traversal (UArray i a) (UArray j b) a b #

c ~ d => Each (Map c a) (Map d b) a b Source # 
Instance details

Methods

each :: Traversal (Map c a) (Map d b) a b #

(Ix i, i ~ j) => Each (Array i a) (Array j b) a b Source # 
Instance details

Methods

each :: Traversal (Array i a) (Array j b) a b #

Strict (StateT s m a) (StateT s m a) Source # 
Instance details

Methods

strict :: Lens' (StateT s m a) (StateT s m a) #

lazy :: Lens' (StateT s m a) (StateT s m a) #

Strict (WriterT w m a) (WriterT w m a) Source # 
Instance details

Methods

strict :: Lens' (WriterT w m a) (WriterT w m a) #

lazy :: Lens' (WriterT w m a) (WriterT w m a) #

Strict (RWST r w s m a) (RWST r w s m a) Source # 
Instance details

Methods

strict :: Lens' (RWST r w s m a) (RWST r w s m a) #

lazy :: Lens' (RWST r w s m a) (RWST r w s m a) #