microlens-platform-0.4.4.1: microlens + all batteries included (best for apps)
Copyright(C) 2013-2016 Edward Kmett 2015-2016 Artyom Kazak 2018 Monadfix
LicenseBSD-style (see the file LICENSE)
Safe HaskellTrustworthy
LanguageHaskell2010

Lens.Micro.Platform

Description

This module is an approximation for Control.Lens from lens; by importing it you get all functions and instances from microlens, microlens-mtl, microlens-ghc, as well as the following instances:

Synopsis

Documentation

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

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

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

Flipped version of <$>.

(<&>) = flip fmap

Examples

Expand

Apply (+1) to a list, a Just and a Right:

>>> Just 2 <&> (+1)
Just 3

>>> [1,2,3] <&> (+1)
[2,3,4]

>>> Right 3 <&> (+1)
Right 4

Since: base-4.11.0.0

(&) :: a -> (a -> b) -> b infixl 1 Source #

& is a reverse application operator. This provides notational convenience. Its precedence is one higher than that of the forward application operator $, which allows & to be nested in $.

This is a version of flip id, where id is specialized from a -> a to (a -> b) -> (a -> b) which by the associativity of (->) is (a -> b) -> a -> b. flipping this yields a -> (a -> b) -> b which is the type signature of &

Examples

Expand
>>> 5 & (+1) & show
"6"

>>> sqrt $ [1 / n^2 | n <- [1..1000]] & sum & (*6)
3.1406380562059946

Since: base-4.8.0.0

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

over :: 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 #

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

worded :: Traversal' String String #

lined :: Traversal' String String #

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

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

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

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

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

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

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

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

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

Flipped version of <$>.

(<&>) = flip fmap

Examples

Expand

Apply (+1) to a list, a Just and a Right:

>>> Just 2 <&> (+1)
Just 3

>>> [1,2,3] <&> (+1)
[2,3,4]

>>> Right 3 <&> (+1)
Right 4

Since: base-4.11.0.0

(&) :: a -> (a -> b) -> b infixl 1 Source #

& is a reverse application operator. This provides notational convenience. Its precedence is one higher than that of the forward application operator $, which allows & to be nested in $.

This is a version of flip id, where id is specialized from a -> a to (a -> b) -> (a -> b) which by the associativity of (->) is (a -> b) -> a -> b. flipping this yields a -> (a -> b) -> b which is the type signature of &

Examples

Expand
>>> 5 & (+1) & show
"6"

>>> sqrt $ [1 / n^2 | n <- [1..1000]] & sum & (*6)
3.1406380562059946

Since: base-4.8.0.0

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

over :: 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 #

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

worded :: Traversal' String String #

lined :: Traversal' String String #

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

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

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

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

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

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

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

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

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

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

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

view :: MonadReader s m => Getting a s a -> m a #

preview :: MonadReader s m => Getting (First a) s a -> m (Maybe a) #

(+=) :: (MonadState s m, Num a) => ASetter s s a a -> a -> m () #

use :: MonadState s m => Getting a s a -> m a #

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

magnify :: Magnify m n b a => LensLike' (Magnified m c) a b -> m c -> n c #

zoom :: Zoom m n s t => LensLike' (Zoomed m c) t s -> m c -> n c #

type family Zoomed (m :: Type -> Type) :: Type -> Type -> Type #

Instances

Instances details
type Zoomed (MaybeT m) 
Instance details

Defined in Lens.Micro.Mtl.Internal

type Zoomed (MaybeT m) = FocusingMay (Zoomed m)
type Zoomed (ExceptT e m) 
Instance details

Defined in Lens.Micro.Mtl.Internal

type Zoomed (ExceptT e m) = FocusingErr e (Zoomed m)
type Zoomed (IdentityT m) 
Instance details

Defined in Lens.Micro.Mtl.Internal

type Zoomed (IdentityT m) = Zoomed m
type Zoomed (ReaderT e m) 
Instance details

Defined in Lens.Micro.Mtl.Internal

type Zoomed (ReaderT e m) = Zoomed m
type Zoomed (StateT s z) 
Instance details

Defined in Lens.Micro.Mtl.Internal

type Zoomed (StateT s z) = Focusing z
type Zoomed (StateT s z) 
Instance details

Defined in Lens.Micro.Mtl.Internal

type Zoomed (StateT s z) = Focusing z
type Zoomed (WriterT w m) 
Instance details

Defined in Lens.Micro.Mtl.Internal

type Zoomed (WriterT w m) = FocusingPlus w (Zoomed m)
type Zoomed (WriterT w m) 
Instance details

Defined in Lens.Micro.Mtl.Internal

type Zoomed (WriterT w m) = FocusingPlus w (Zoomed m)
type Zoomed (RWST r w s z) 
Instance details

Defined in Lens.Micro.Mtl.Internal

type Zoomed (RWST r w s z) = FocusingWith w z
type Zoomed (RWST r w s z) 
Instance details

Defined in Lens.Micro.Mtl.Internal

type Zoomed (RWST r w s z) = FocusingWith w z

preuse :: MonadState s m => Getting (First a) s a -> m (Maybe a) #

(&~) :: s -> State s a -> s #

assign :: MonadState s m => ASetter s s a b -> b -> m () #

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

(<~) :: MonadState s m => ASetter s s a b -> m b -> m () #

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

modifying :: MonadState s m => ASetter s s a b -> (a -> b) -> m () #

(-=) :: (MonadState s m, Num a) => ASetter s s a a -> a -> m () #

(*=) :: (MonadState s m, Num a) => ASetter s s a a -> a -> m () #

(//=) :: (MonadState s m, Fractional a) => ASetter s s a a -> a -> m () #

(<%=) :: MonadState s m => LensLike ((,) b) s s a b -> (a -> b) -> m b #

(<<%=) :: MonadState s m => LensLike ((,) a) s s a b -> (a -> b) -> m a #

(<<.=) :: MonadState s m => LensLike ((,) a) s s a b -> b -> m a #

(<.=) :: MonadState s m => LensLike ((,) b) s s a b -> b -> m b #

(<?=) :: MonadState s m => LensLike ((,) b) s s a (Maybe b) -> b -> m b #

data DefName #

Constructors

TopName Name 
MethodName Name Name 

Instances

Instances details
Show DefName 
Instance details

Defined in Lens.Micro.TH

Methods

showsPrec :: Int -> DefName -> ShowS Source #

show :: DefName -> String Source #

showList :: [DefName] -> ShowS Source #

Eq DefName 
Instance details

Defined in Lens.Micro.TH

Methods

(==) :: DefName -> DefName -> Bool Source #

(/=) :: DefName -> DefName -> Bool Source #

Ord DefName 
Instance details

Defined in Lens.Micro.TH

Methods

compare :: DefName -> DefName -> Ordering Source #

(<) :: DefName -> DefName -> Bool Source #

(<=) :: DefName -> DefName -> Bool Source #

(>) :: DefName -> DefName -> Bool Source #

(>=) :: DefName -> DefName -> Bool Source #

max :: DefName -> DefName -> DefName Source #

min :: DefName -> DefName -> DefName Source #

data LensRules #

makeLenses :: Name -> DecsQ #

makeLensesFor :: [(String, String)] -> Name -> DecsQ #

makeLensesWith :: LensRules -> Name -> DecsQ #

makeFields :: Name -> DecsQ #

makeClassy :: Name -> DecsQ #

simpleLenses :: Lens' LensRules Bool #

generateSignatures :: Lens' LensRules Bool #

generateUpdateableOptics :: Lens' LensRules Bool #

generateLazyPatterns :: Lens' LensRules Bool #

lensField :: Lens' LensRules (Name -> [Name] -> Name -> [DefName]) #

lensClass :: Lens' LensRules (Name -> Maybe (Name, Name)) #

createClass :: Lens' LensRules Bool #

lensRules :: LensRules #

lensRulesFor :: [(String, String)] -> LensRules #

camelCaseFields :: LensRules #

abbreviatedFields :: LensRules #

classyRules :: LensRules #

packed :: IsText t => Lens' String t Source #

packed lets you convert between String and Text (strict or lazy). It can be used as a replacement for pack or as a way to modify some String if you have a function like Text -> Text.

unpacked :: IsText t => Lens' t String Source #

unpacked is like packed but works in the opposite direction.

Orphan instances

Ixed Text Source # 
Instance details

Methods

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

Ixed Text Source # 
Instance details

Methods

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

Strict Text Text Source # 
Instance details

Methods

strict :: Lens' Text Text #

lazy :: Lens' Text Text #

Cons Text Text Char Char Source # 
Instance details

Methods

_Cons :: Traversal Text Text (Char, Text) (Char, Text)

Cons Text Text Char Char Source # 
Instance details

Methods

_Cons :: Traversal Text Text (Char, Text) (Char, Text)

(a ~ Char, b ~ Char) => Each Text Text a b Source # 
Instance details

Methods

each :: Traversal Text Text a b #

(a ~ Char, b ~ Char) => Each Text Text a b Source # 
Instance details

Methods

each :: Traversal Text Text a b #

Snoc Text Text Char Char Source # 
Instance details

Methods

_Snoc :: Traversal Text Text (Text, Char) (Text, Char)

Snoc Text Text Char Char Source # 
Instance details

Methods

_Snoc :: Traversal Text Text (Text, Char) (Text, Char)

(Eq k, Hashable k) => At (HashSet k) Source # 
Instance details

Methods

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

(Eq k, Hashable k) => Ixed (HashSet k) Source # 
Instance details

Methods

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

Ixed (Vector a) Source # 
Instance details

Methods

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

Prim a => Ixed (Vector a) Source # 
Instance details

Methods

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

Storable a => Ixed (Vector a) Source # 
Instance details

Methods

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

Unbox a => Ixed (Vector a) Source # 
Instance details

Methods

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

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

Methods

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

(Prim a, Prim b) => Cons (Vector a) (Vector b) a b Source # 
Instance details

Methods

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

(Storable a, Storable b) => Cons (Vector a) (Vector b) a b Source # 
Instance details

Methods

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

(Unbox a, Unbox b) => Cons (Vector a) (Vector b) a b Source # 
Instance details

Methods

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

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

Methods

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

(Prim a, Prim b) => Each (Vector a) (Vector b) a b Source # 
Instance details

Methods

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

(Storable a, Storable b) => Each (Vector a) (Vector b) a b Source # 
Instance details

Methods

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

(Unbox a, Unbox b) => Each (Vector a) (Vector b) a b Source # 
Instance details

Methods

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

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

Methods

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

(Prim a, Prim b) => Snoc (Vector a) (Vector b) a b Source # 
Instance details

Methods

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

(Storable a, Storable b) => Snoc (Vector a) (Vector b) a b Source # 
Instance details

Methods

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

(Unbox a, Unbox b) => Snoc (Vector a) (Vector b) a b Source # 
Instance details

Methods

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

(Eq k, Hashable k) => At (HashMap k a) Source # 
Instance details

Methods

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

(Eq k, Hashable k) => Ixed (HashMap k a) Source # 
Instance details

Methods

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

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

Methods

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