Safe Haskell	None
Language	Haskell2010

SitePipe

Contents

SitePipe
Running SitePipe
Loaders
Writers
Loader/Writers
Readers
- Built-in
- Reader Generators
Utilities
Types
Exports

Synopsis

site :: SiteM () -> IO ()
siteWithGlobals :: Value -> SiteM () -> IO ()
resourceLoader :: (String -> IO String) -> [GlobPattern] -> SiteM [Value]
writeWith :: ToJSON a => (a -> SiteM String) -> [a] -> SiteM ()
writeTemplate :: ToJSON a => FilePath -> [a] -> SiteM ()
textWriter :: ToJSON a => [a] -> SiteM ()
copyFiles :: [GlobPattern] -> SiteM [Value]
copyFilesWith :: (FilePath -> FilePath) -> [GlobPattern] -> SiteM [Value]
markdownReader :: String -> IO String
textReader :: String -> PandocIO String
mkPandocReader :: (ReaderOptions -> String -> PandocIO Pandoc) -> String -> IO String
setExt :: String -> FilePath -> FilePath
addPrefix :: String -> FilePath -> FilePath
getTags :: (String -> String) -> [Value] -> [Value]
module SitePipe.Types
class (Functor t, Foldable t) => Traversable (t :: Type -> Type) where
- traverse :: Applicative f => (a -> f b) -> t a -> f (t b)
type FilePath = String
newtype Const a (b :: k) :: forall k. Type -> k -> Type = Const {
- getConst :: a
}
newtype Identity a = Identity {
- runIdentity :: a
}
class Contravariant (f :: Type -> Type) where
- contramap :: (a -> b) -> f b -> f a
- (>$) :: b -> f b -> f a
eitherDecodeFileStrict' :: FromJSON a => FilePath -> IO (Either String a)
eitherDecodeStrict' :: FromJSON a => ByteString -> Either String a
eitherDecode' :: FromJSON a => ByteString -> Either String a
eitherDecodeFileStrict :: FromJSON a => FilePath -> IO (Either String a)
eitherDecodeStrict :: FromJSON a => ByteString -> Either String a
eitherDecode :: FromJSON a => ByteString -> Either String a
decodeFileStrict' :: FromJSON a => FilePath -> IO (Maybe a)
decodeStrict' :: FromJSON a => ByteString -> Maybe a
decode' :: FromJSON a => ByteString -> Maybe a
decodeFileStrict :: FromJSON a => FilePath -> IO (Maybe a)
decodeStrict :: FromJSON a => ByteString -> Maybe a
decode :: FromJSON a => ByteString -> Maybe a
encodeFile :: ToJSON a => FilePath -> a -> IO ()
encode :: ToJSON a => a -> ByteString
foldable :: (Foldable t, ToJSON a) => t a -> Encoding
type GToJSON = GToJSON Value
type GToEncoding = GToJSON Encoding
toEncoding2 :: (ToJSON2 f, ToJSON a, ToJSON b) => f a b -> Encoding
toJSON2 :: (ToJSON2 f, ToJSON a, ToJSON b) => f a b -> Value
toEncoding1 :: (ToJSON1 f, ToJSON a) => f a -> Encoding
toJSON1 :: (ToJSON1 f, ToJSON a) => f a -> Value
genericToJSONKey :: (Generic a, GToJSONKey (Rep a)) => JSONKeyOptions -> ToJSONKeyFunction a
genericLiftToEncoding :: (Generic1 f, GToJSON Encoding One (Rep1 f)) => Options -> (a -> Encoding) -> ([a] -> Encoding) -> f a -> Encoding
genericToEncoding :: (Generic a, GToJSON Encoding Zero (Rep a)) => Options -> a -> Encoding
genericLiftToJSON :: (Generic1 f, GToJSON Value One (Rep1 f)) => Options -> (a -> Value) -> ([a] -> Value) -> f a -> Value
genericToJSON :: (Generic a, GToJSON Value Zero (Rep a)) => Options -> a -> Value
data ToArgs res arity a where
- NoToArgs :: forall res arity a. ToArgs res Zero a
- To1Args :: forall res arity a. (a -> res) -> ([a] -> res) -> ToArgs res One a
class ToJSON a where
- toJSON :: a -> Value
- toEncoding :: a -> Encoding
- toJSONList :: [a] -> Value
- toEncodingList :: [a] -> Encoding
class KeyValue kv where
- (.=) :: ToJSON v => Text -> v -> kv
class ToJSONKey a where
- toJSONKey :: ToJSONKeyFunction a
- toJSONKeyList :: ToJSONKeyFunction [a]
data ToJSONKeyFunction a
- = ToJSONKeyText !(a -> Text) !(a -> Encoding' Text)
- | ToJSONKeyValue !(a -> Value) !(a -> Encoding)
class GetConName f => GToJSONKey (f :: k -> Type)
class ToJSON1 (f :: Type -> Type) where
- liftToJSON :: (a -> Value) -> ([a] -> Value) -> f a -> Value
- liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [f a] -> Value
- liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> f a -> Encoding
- liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [f a] -> Encoding
class ToJSON2 (f :: Type -> Type -> Type) where
- liftToJSON2 :: (a -> Value) -> ([a] -> Value) -> (b -> Value) -> ([b] -> Value) -> f a b -> Value
- liftToJSONList2 :: (a -> Value) -> ([a] -> Value) -> (b -> Value) -> ([b] -> Value) -> [f a b] -> Value
- liftToEncoding2 :: (a -> Encoding) -> ([a] -> Encoding) -> (b -> Encoding) -> ([b] -> Encoding) -> f a b -> Encoding
- liftToEncodingList2 :: (a -> Encoding) -> ([a] -> Encoding) -> (b -> Encoding) -> ([b] -> Encoding) -> [f a b] -> Encoding
pairs :: Series -> Encoding
fromEncoding :: Encoding' tag -> Builder
type Encoding = Encoding' Value
data Series
(.!=) :: Parser (Maybe a) -> a -> Parser a
(.:!) :: FromJSON a => Object -> Text -> Parser (Maybe a)
(.:?) :: FromJSON a => Object -> Text -> Parser (Maybe a)
(.:) :: FromJSON a => Object -> Text -> Parser a
fromJSON :: FromJSON a => Value -> Result a
withEmbeddedJSON :: String -> (Value -> Parser a) -> Value -> Parser a
withBool :: String -> (Bool -> Parser a) -> Value -> Parser a
withScientific :: String -> (Scientific -> Parser a) -> Value -> Parser a
withArray :: String -> (Array -> Parser a) -> Value -> Parser a
withText :: String -> (Text -> Parser a) -> Value -> Parser a
withObject :: String -> (Object -> Parser a) -> Value -> Parser a
parseJSON2 :: (FromJSON2 f, FromJSON a, FromJSON b) => Value -> Parser (f a b)
parseJSON1 :: (FromJSON1 f, FromJSON a) => Value -> Parser (f a)
genericFromJSONKey :: (Generic a, GFromJSONKey (Rep a)) => JSONKeyOptions -> FromJSONKeyFunction a
genericLiftParseJSON :: (Generic1 f, GFromJSON One (Rep1 f)) => Options -> (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (f a)
genericParseJSON :: (Generic a, GFromJSON Zero (Rep a)) => Options -> Value -> Parser a
parseIndexedJSON :: (Value -> Parser a) -> Int -> Value -> Parser a
class GFromJSON arity (f :: Type -> Type) where
- gParseJSON :: Options -> FromArgs arity a -> Value -> Parser (f a)
data FromArgs arity a where
- NoFromArgs :: forall arity a. FromArgs Zero a
- From1Args :: forall arity a. (Value -> Parser a) -> (Value -> Parser [a]) -> FromArgs One a
class FromJSON a where
- parseJSON :: Value -> Parser a
- parseJSONList :: Value -> Parser [a]
class FromJSONKey a where
- fromJSONKey :: FromJSONKeyFunction a
- fromJSONKeyList :: FromJSONKeyFunction [a]
data FromJSONKeyFunction a
- = FromJSONKeyCoerce !(CoerceText a)
- | FromJSONKeyText !(Text -> a)
- | FromJSONKeyTextParser !(Text -> Parser a)
- | FromJSONKeyValue !(Value -> Parser a)
class (ConstructorNames f, SumFromString f) => GFromJSONKey (f :: Type -> Type)
class FromJSON1 (f :: Type -> Type) where
- liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (f a)
- liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [f a]
class FromJSON2 (f :: Type -> Type -> Type) where
- liftParseJSON2 :: (Value -> Parser a) -> (Value -> Parser [a]) -> (Value -> Parser b) -> (Value -> Parser [b]) -> Value -> Parser (f a b)
- liftParseJSONList2 :: (Value -> Parser a) -> (Value -> Parser [a]) -> (Value -> Parser b) -> (Value -> Parser [b]) -> Value -> Parser [f a b]
json' :: Parser Value
json :: Parser Value
camelTo2 :: Char -> String -> String
defaultJSONKeyOptions :: JSONKeyOptions
defaultTaggedObject :: SumEncoding
defaultOptions :: Options
(<?>) :: Parser a -> JSONPathElement -> Parser a
object :: [Pair] -> Value
type JSONPath = [JSONPathElement]
data Result a
- = Error String
- | Success a
type Object = HashMap Text Value
type Array = Vector Value
data Value
- = Object !Object
- | Array !Array
- | String !Text
- | Number !Scientific
- | Bool !Bool
- | Null
newtype DotNetTime = DotNetTime {
- fromDotNetTime :: UTCTime
}
data Options
data SumEncoding
- = TaggedObject {
  - tagFieldName :: String
  - contentsFieldName :: String
  }
- | UntaggedValue
- | ObjectWithSingleField
- | TwoElemArray
data JSONKeyOptions
data Zero
data One
class Bifunctor (p :: Type -> Type -> Type) where
- bimap :: (a -> b) -> (c -> d) -> p a c -> p b d
data (a :: k) :~: (b :: k) :: forall k. k -> k -> Type where
- Refl :: forall k (a :: k) (b :: k). a :~: a
(&) :: a -> (a -> b) -> b
(<&>) :: Functor f => f a -> (a -> b) -> f b
(</>) :: FilePath -> FilePath -> FilePath
makeRelative :: FilePath -> FilePath -> FilePath
dropTrailingPathSeparator :: FilePath -> FilePath
normalise :: FilePath -> FilePath
isAbsolute :: FilePath -> Bool
isRelative :: FilePath -> Bool
makeValid :: FilePath -> FilePath
isValid :: FilePath -> Bool
equalFilePath :: FilePath -> FilePath -> Bool
joinPath :: [FilePath] -> FilePath
splitDirectories :: FilePath -> [FilePath]
splitPath :: FilePath -> [FilePath]
combine :: FilePath -> FilePath -> FilePath
replaceDirectory :: FilePath -> String -> FilePath
takeDirectory :: FilePath -> FilePath
addTrailingPathSeparator :: FilePath -> FilePath
hasTrailingPathSeparator :: FilePath -> Bool
replaceBaseName :: FilePath -> String -> FilePath
takeBaseName :: FilePath -> String
takeFileName :: FilePath -> FilePath
dropFileName :: FilePath -> FilePath
replaceFileName :: FilePath -> String -> FilePath
splitFileName :: FilePath -> (String, String)
isDrive :: FilePath -> Bool
hasDrive :: FilePath -> Bool
dropDrive :: FilePath -> FilePath
takeDrive :: FilePath -> FilePath
joinDrive :: FilePath -> FilePath -> FilePath
splitDrive :: FilePath -> (FilePath, FilePath)
replaceExtensions :: FilePath -> String -> FilePath
takeExtensions :: FilePath -> String
dropExtensions :: FilePath -> FilePath
splitExtensions :: FilePath -> (FilePath, String)
stripExtension :: String -> FilePath -> Maybe FilePath
isExtensionOf :: String -> FilePath -> Bool
hasExtension :: FilePath -> Bool
addExtension :: FilePath -> String -> FilePath
dropExtension :: FilePath -> FilePath
(<.>) :: FilePath -> String -> FilePath
replaceExtension :: FilePath -> String -> FilePath
(-<.>) :: FilePath -> String -> FilePath
takeExtension :: FilePath -> String
splitExtension :: FilePath -> (String, String)
getSearchPath :: IO [FilePath]
splitSearchPath :: String -> [FilePath]
isExtSeparator :: Char -> Bool
extSeparator :: Char
isSearchPathSeparator :: Char -> Bool
searchPathSeparator :: Char
isPathSeparator :: Char -> Bool
pathSeparators :: [Char]
pathSeparator :: Char
class Profunctor (p :: Type -> Type -> Type) where
- dimap :: (a -> b) -> (c -> d) -> p b c -> p a d
- lmap :: (a -> b) -> p b c -> p a c
- rmap :: (b -> c) -> p a b -> p a c
defaultFieldRules :: LensRules
makeFieldsNoPrefix :: Name -> DecsQ
makeFields :: Name -> DecsQ
abbreviatedNamer :: FieldNamer
abbreviatedFields :: LensRules
classUnderscoreNoPrefixNamer :: FieldNamer
classUnderscoreNoPrefixFields :: LensRules
camelCaseNamer :: FieldNamer
camelCaseFields :: LensRules
underscoreNamer :: FieldNamer
underscoreFields :: LensRules
makeWrapped :: Name -> DecsQ
declareLensesWith :: LensRules -> DecsQ -> DecsQ
declareFields :: DecsQ -> DecsQ
declareWrapped :: DecsQ -> DecsQ
declarePrisms :: DecsQ -> DecsQ
declareClassyFor :: [(String, (String, String))] -> [(String, String)] -> DecsQ -> DecsQ
declareClassy :: DecsQ -> DecsQ
declareLensesFor :: [(String, String)] -> DecsQ -> DecsQ
declareLenses :: DecsQ -> DecsQ
makeLensesWith :: LensRules -> Name -> DecsQ
makeClassyFor :: String -> String -> [(String, String)] -> Name -> DecsQ
makeLensesFor :: [(String, String)] -> Name -> DecsQ
makeClassy_ :: Name -> DecsQ
makeClassy :: Name -> DecsQ
makeLenses :: Name -> DecsQ
classyRules_ :: LensRules
classyRules :: LensRules
mappingNamer :: (String -> [String]) -> FieldNamer
lookingupNamer :: [(String, String)] -> FieldNamer
lensRulesFor :: [(String, String)] -> LensRules
underscoreNoPrefixNamer :: FieldNamer
lensRules :: LensRules
lensClass :: Lens' LensRules ClassyNamer
lensField :: Lens' LensRules FieldNamer
createClass :: Lens' LensRules Bool
generateLazyPatterns :: Lens' LensRules Bool
generateUpdateableOptics :: Lens' LensRules Bool
generateSignatures :: Lens' LensRules Bool
simpleLenses :: Lens' LensRules Bool
data LensRules
type FieldNamer = Name -> [Name] -> Name -> [DefName]
data DefName
- = TopName Name
- | MethodName Name Name
type ClassyNamer = Name -> Maybe (Name, Name)
makeClassyPrisms :: Name -> DecsQ
makePrisms :: Name -> DecsQ
iat :: At m => Index m -> IndexedLens' (Index m) m (Maybe (IxValue m))
sans :: At m => Index m -> m -> m
ixAt :: At m => Index m -> Traversal' m (IxValue m)
iix :: Ixed m => Index m -> IndexedTraversal' (Index m) m (IxValue m)
icontains :: Contains m => Index m -> IndexedLens' (Index m) m Bool
type family Index s :: Type
class Contains m where
- contains :: Index m -> Lens' m Bool
type family IxValue m :: Type
class Ixed m where
- ix :: Index m -> Traversal' m (IxValue m)
class Ixed m => At m where
- at :: Index m -> Lens' m (Maybe (IxValue m))
class Each s t a b | s -> a, t -> b, s b -> t, t a -> s where
- each :: Traversal s t a b
gplate1 :: (Generic1 f, GPlated1 f (Rep1 f)) => Traversal' (f a) (f a)
gplate :: (Generic a, GPlated a (Rep a)) => Traversal' a a
parts :: Plated a => Lens' a [a]
composOpFold :: Plated a => b -> (b -> b -> b) -> (a -> b) -> a -> b
para :: Plated a => (a -> [r] -> r) -> a -> r
paraOf :: Getting (Endo [a]) a a -> (a -> [r] -> r) -> a -> r
holesOnOf :: Conjoined p => LensLike (Bazaar p r r) s t a b -> Over p (Bazaar p r r) a b r r -> s -> [Pretext p r r t]
holesOn :: Conjoined p => Over p (Bazaar p a a) s t a a -> s -> [Pretext p a a t]
holes :: Plated a => a -> [Pretext ((->) :: Type -> Type -> Type) a a a]
contextsOnOf :: ATraversal s t a a -> ATraversal' a a -> s -> [Context a a t]
contextsOn :: Plated a => ATraversal s t a a -> s -> [Context a a t]
contextsOf :: ATraversal' a a -> a -> [Context a a a]
contexts :: Plated a => a -> [Context a a a]
transformMOnOf :: Monad m => LensLike (WrappedMonad m) s t a b -> LensLike (WrappedMonad m) a b a b -> (b -> m b) -> s -> m t
transformMOf :: Monad m => LensLike (WrappedMonad m) a b a b -> (b -> m b) -> a -> m b
transformMOn :: (Monad m, Plated a) => LensLike (WrappedMonad m) s t a a -> (a -> m a) -> s -> m t
transformM :: (Monad m, Plated a) => (a -> m a) -> a -> m a
transformOnOf :: ASetter s t a b -> ASetter a b a b -> (b -> b) -> s -> t
transformOf :: ASetter a b a b -> (b -> b) -> a -> b
transformOn :: Plated a => ASetter s t a a -> (a -> a) -> s -> t
transform :: Plated a => (a -> a) -> a -> a
cosmosOnOf :: (Applicative f, Contravariant f) => LensLike' f s a -> LensLike' f a a -> LensLike' f s a
cosmosOn :: (Applicative f, Contravariant f, Plated a) => LensLike' f s a -> LensLike' f s a
cosmosOf :: (Applicative f, Contravariant f) => LensLike' f a a -> LensLike' f a a
cosmos :: Plated a => Fold a a
universeOnOf :: Getting [a] s a -> Getting [a] a a -> s -> [a]
universeOn :: Plated a => Getting [a] s a -> s -> [a]
universeOf :: Getting [a] a a -> a -> [a]
universe :: Plated a => a -> [a]
rewriteMOnOf :: Monad m => LensLike (WrappedMonad m) s t a b -> LensLike (WrappedMonad m) a b a b -> (b -> m (Maybe a)) -> s -> m t
rewriteMOn :: (Monad m, Plated a) => LensLike (WrappedMonad m) s t a a -> (a -> m (Maybe a)) -> s -> m t
rewriteMOf :: Monad m => LensLike (WrappedMonad m) a b a b -> (b -> m (Maybe a)) -> a -> m b
rewriteM :: (Monad m, Plated a) => (a -> m (Maybe a)) -> a -> m a
rewriteOnOf :: ASetter s t a b -> ASetter a b a b -> (b -> Maybe a) -> s -> t
rewriteOn :: Plated a => ASetter s t a a -> (a -> Maybe a) -> s -> t
rewriteOf :: ASetter a b a b -> (b -> Maybe a) -> a -> b
rewrite :: Plated a => (a -> Maybe a) -> a -> a
children :: Plated a => a -> [a]
deep :: (Conjoined p, Applicative f, Plated s) => Traversing p f s s a b -> Over p f s s a b
(...) :: (Applicative f, Plated c) => LensLike f s t c c -> Over p f c c a b -> Over p f s t a b
class Plated a where
- plate :: Traversal' a a
class GPlated a (g :: k -> Type)
class GPlated1 (f :: k -> Type) (g :: k -> Type)
type family Zoomed (m :: Type -> Type) :: Type -> Type -> Type
type family Magnified (m :: Type -> Type) :: Type -> Type -> Type
class (MonadState s m, MonadState t n) => Zoom (m :: Type -> Type) (n :: Type -> Type) s t | m -> s, n -> t, m t -> n, n s -> m where
- zoom :: LensLike' (Zoomed m c) t s -> m c -> n c
class (Magnified m ~ Magnified n, MonadReader b m, MonadReader a n) => Magnify (m :: Type -> Type) (n :: Type -> Type) b a | m -> b, n -> a, m a -> n, n b -> m where
- magnify :: (Functor (Magnified m c) -> Contravariant (Magnified m c) -> LensLike' (Magnified m c) a b) -> m c -> n c
alaf :: (Functor f, Functor g, Rewrapping s t) => (Unwrapped s -> s) -> (f t -> g s) -> f (Unwrapped t) -> g (Unwrapped s)
ala :: (Functor f, Rewrapping s t) => (Unwrapped s -> s) -> ((Unwrapped t -> t) -> f s) -> f (Unwrapped s)
_Unwrapping :: Rewrapping s t => (Unwrapped s -> s) -> Iso (Unwrapped t) (Unwrapped s) t s
_Wrapping :: Rewrapping s t => (Unwrapped s -> s) -> Iso s t (Unwrapped s) (Unwrapped t)
_Unwrapping' :: Wrapped s => (Unwrapped s -> s) -> Iso' (Unwrapped s) s
_Wrapping' :: Wrapped s => (Unwrapped s -> s) -> Iso' s (Unwrapped s)
op :: Wrapped s => (Unwrapped s -> s) -> s -> Unwrapped s
_Unwrapped :: Rewrapping s t => Iso (Unwrapped t) (Unwrapped s) t s
_Wrapped :: Rewrapping s t => Iso s t (Unwrapped s) (Unwrapped t)
_Unwrapped' :: Wrapped s => Iso' (Unwrapped s) s
_GWrapped' :: (Generic s, D1 d (C1 c (S1 s' (Rec0 a))) ~ Rep s, Unwrapped s ~ GUnwrapped (Rep s)) => Iso' s (Unwrapped s)
pattern Wrapped :: forall s. Rewrapped s s => Unwrapped s -> s
pattern Unwrapped :: forall t. Rewrapped t t => t -> Unwrapped t
class Wrapped s where
- type Unwrapped s :: Type
- _Wrapped' :: Iso' s (Unwrapped s)
class Wrapped s => Rewrapped s t
class (Rewrapped s t, Rewrapped t s) => Rewrapping s t
unsnoc :: Snoc s s a a => s -> Maybe (s, a)
snoc :: Snoc s s a a => s -> a -> s
(|>) :: Snoc s s a a => s -> a -> s
_last :: Snoc s s a a => Traversal' s a
_init :: Snoc s s a a => Traversal' s s
_tail :: Cons s s a a => Traversal' s s
_head :: Cons s s a a => Traversal' s a
uncons :: Cons s s a a => s -> Maybe (a, s)
cons :: Cons s s a a => a -> s -> s
(<|) :: Cons s s a a => a -> s -> s
pattern (:<) :: forall b a. Cons b b a a => a -> b -> b
pattern (:>) :: forall a b. Snoc a a b b => a -> b -> a
class Cons s t a b | s -> a, t -> b, s b -> t, t a -> s where
- _Cons :: Prism s t (a, s) (b, t)
class Snoc s t a b | s -> a, t -> b, s b -> t, t a -> s where
- _Snoc :: Prism s t (s, a) (t, b)
pattern Empty :: forall s. AsEmpty s => s
class AsEmpty a where
- _Empty :: Prism' a ()
coerced :: (Coercible s a, Coercible t b) => Iso s t a b
seconding :: (Bifunctor f, Bifunctor g) => AnIso s t a b -> Iso (f x s) (g y t) (f x a) (g y b)
firsting :: (Bifunctor f, Bifunctor g) => AnIso s t a b -> Iso (f s x) (g t y) (f a x) (g b y)
bimapping :: (Bifunctor f, Bifunctor g) => AnIso s t a b -> AnIso s' t' a' b' -> Iso (f s s') (g t t') (f a a') (g b b')
rmapping :: (Profunctor p, Profunctor q) => AnIso s t a b -> Iso (p x s) (q y t) (p x a) (q y b)
lmapping :: (Profunctor p, Profunctor q) => AnIso s t a b -> Iso (p a x) (q b y) (p s x) (q t y)
dimapping :: (Profunctor p, Profunctor q) => AnIso s t a b -> AnIso s' t' a' b' -> Iso (p a s') (q b t') (p s a') (q t b')
contramapping :: Contravariant f => AnIso s t a b -> Iso (f a) (f b) (f s) (f t)
imagma :: Over (Indexed i) (Molten i a b) s t a b -> Iso s t' (Magma i t b a) (Magma j t' c c)
magma :: LensLike (Mafic a b) s t a b -> Iso s u (Magma Int t b a) (Magma j u c c)
involuted :: (a -> a) -> Iso' a a
reversed :: Reversing a => Iso' a a
lazy :: Strict lazy strict => Iso' strict lazy
flipped :: Iso (a -> b -> c) (a' -> b' -> c') (b -> a -> c) (b' -> a' -> c')
uncurried :: Iso (a -> b -> c) (d -> e -> f) ((a, b) -> c) ((d, e) -> f)
curried :: Iso ((a, b) -> c) ((d, e) -> f) (a -> b -> c) (d -> e -> f)
anon :: a -> (a -> Bool) -> Iso' (Maybe a) a
non' :: APrism' a () -> Iso' (Maybe a) a
non :: Eq a => a -> Iso' (Maybe a) a
mapping :: (Functor f, Functor g) => AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
enum :: Enum a => Iso' Int a
under :: AnIso s t a b -> (t -> s) -> b -> a
xplatf :: Optic (Costar f) g s t a b -> (f a -> g b) -> f s -> g t
xplat :: Optic (Costar ((->) s :: Type -> Type)) g s t a b -> ((s -> a) -> g b) -> g t
auf :: (Functor f, Functor g) => AnIso s t a b -> (f t -> g s) -> f b -> g a
au :: Functor f => AnIso s t a b -> ((b -> t) -> f s) -> f a
cloneIso :: AnIso s t a b -> Iso s t a b
withIso :: AnIso s t a b -> ((s -> a) -> (b -> t) -> r) -> r
from :: AnIso s t a b -> Iso b a t s
iso :: (s -> a) -> (b -> t) -> Iso s t a b
pattern Strict :: forall s t. Strict s t => t -> s
pattern Lazy :: forall t s. Strict t s => t -> s
pattern Swapped :: forall (p :: Type -> Type -> Type) c d. Swapped p => p d c -> p c d
pattern Reversed :: forall t. Reversing t => t -> t
pattern List :: forall l. IsList l => [Item l] -> l
type AnIso s t a b = Exchange a b a (Identity b) -> Exchange a b s (Identity t)
type AnIso' s a = AnIso s s a a
class Bifunctor p => Swapped (p :: Type -> Type -> Type) where
- swapped :: Iso (p a b) (p c d) (p b a) (p d c)
class Strict lazy strict | lazy -> strict, strict -> lazy where
- strict :: Iso' lazy strict
withEquality :: AnEquality s t a b -> ((s :~: a) -> (b :~: t) -> r) -> r
fromLeibniz' :: ((s :~: s) -> s :~: a) -> Equality' s a
fromLeibniz :: (Identical a b a b -> Identical a b s t) -> Equality s t a b
underEquality :: AnEquality s t a b -> p t s -> p b a
overEquality :: AnEquality s t a b -> p a b -> p s t
equality' :: (a :~: b) -> Equality' a b
equality :: (s :~: a) -> (b :~: t) -> Equality s t a b
cloneEquality :: AnEquality s t a b -> Equality s t a b
simple :: Equality' a a
simply :: (Optic' p f s a -> r) -> Optic' p f s a -> r
fromEq :: AnEquality s t a b -> Equality b a t s
mapEq :: AnEquality s t a b -> f s -> f a
substEq :: AnEquality s t a b -> ((s ~ a) -> (t ~ b) -> r) -> r
runEq :: AnEquality s t a b -> Identical s t a b
data Identical (a :: k) (b :: k1) (s :: k) (t :: k1) :: forall k k1. k -> k1 -> k -> k1 -> Type where
- Identical :: forall k k1 (a :: k) (b :: k1) (s :: k) (t :: k1). Identical a b a b
type AnEquality (s :: k1) (t :: k2) (a :: k1) (b :: k2) = Identical a (Proxy b) a (Proxy b) -> Identical a (Proxy b) s (Proxy t)
type AnEquality' (s :: k2) (a :: k2) = AnEquality s s a a
itraverseByOf :: IndexedTraversal i s t a b -> (forall x. x -> f x) -> (forall x y. f (x -> y) -> f x -> f y) -> (i -> a -> f b) -> s -> f t
itraverseBy :: TraversableWithIndex i t => (forall x. x -> f x) -> (forall x y. f (x -> y) -> f x -> f y) -> (i -> a -> f b) -> t a -> f (t b)
ifoldMapByOf :: IndexedFold i t a -> (r -> r -> r) -> r -> (i -> a -> r) -> t -> r
ifoldMapBy :: FoldableWithIndex i t => (r -> r -> r) -> r -> (i -> a -> r) -> t a -> r
imapAccumL :: TraversableWithIndex i t => (i -> s -> a -> (s, b)) -> s -> t a -> (s, t b)
imapAccumR :: TraversableWithIndex i t => (i -> s -> a -> (s, b)) -> s -> t a -> (s, t b)
iforM :: (TraversableWithIndex i t, Monad m) => t a -> (i -> a -> m b) -> m (t b)
imapM :: (TraversableWithIndex i t, Monad m) => (i -> a -> m b) -> t a -> m (t b)
ifor :: (TraversableWithIndex i t, Applicative f) => t a -> (i -> a -> f b) -> f (t b)
itoList :: FoldableWithIndex i f => f a -> [(i, a)]
ifoldlM :: (FoldableWithIndex i f, Monad m) => (i -> b -> a -> m b) -> b -> f a -> m b
ifoldrM :: (FoldableWithIndex i f, Monad m) => (i -> a -> b -> m b) -> b -> f a -> m b
ifind :: FoldableWithIndex i f => (i -> a -> Bool) -> f a -> Maybe (i, a)
iconcatMap :: FoldableWithIndex i f => (i -> a -> [b]) -> f a -> [b]
iforM_ :: (FoldableWithIndex i t, Monad m) => t a -> (i -> a -> m b) -> m ()
imapM_ :: (FoldableWithIndex i t, Monad m) => (i -> a -> m b) -> t a -> m ()
ifor_ :: (FoldableWithIndex i t, Applicative f) => t a -> (i -> a -> f b) -> f ()
itraverse_ :: (FoldableWithIndex i t, Applicative f) => (i -> a -> f b) -> t a -> f ()
none :: Foldable f => (a -> Bool) -> f a -> Bool
inone :: FoldableWithIndex i f => (i -> a -> Bool) -> f a -> Bool
iall :: FoldableWithIndex i f => (i -> a -> Bool) -> f a -> Bool
iany :: FoldableWithIndex i f => (i -> a -> Bool) -> f a -> Bool
index :: (Indexable i p, Eq i, Applicative f) => i -> Optical' p (Indexed i) f a a
indices :: (Indexable i p, Applicative f) => (i -> Bool) -> Optical' p (Indexed i) f a a
icompose :: Indexable p c => (i -> j -> p) -> (Indexed i s t -> r) -> (Indexed j a b -> s -> t) -> c a b -> r
reindexed :: Indexable j p => (i -> j) -> (Indexed i a b -> r) -> p a b -> r
selfIndex :: Indexable a p => p a fb -> a -> fb
(.>) :: (st -> r) -> (kab -> st) -> kab -> r
(<.) :: Indexable i p => (Indexed i s t -> r) -> ((a -> b) -> s -> t) -> p a b -> r
class Functor f => FunctorWithIndex i (f :: Type -> Type) | f -> i where
- imap :: (i -> a -> b) -> f a -> f b
- imapped :: IndexedSetter i (f a) (f b) a b
class Foldable f => FoldableWithIndex i (f :: Type -> Type) | f -> i where
- ifoldMap :: Monoid m => (i -> a -> m) -> f a -> m
- ifolded :: IndexedFold i (f a) a
- ifoldr :: (i -> a -> b -> b) -> b -> f a -> b
- ifoldl :: (i -> b -> a -> b) -> b -> f a -> b
- ifoldr' :: (i -> a -> b -> b) -> b -> f a -> b
- ifoldl' :: (i -> b -> a -> b) -> b -> f a -> b
class (FunctorWithIndex i t, FoldableWithIndex i t, Traversable t) => TraversableWithIndex i (t :: Type -> Type) | t -> i where
- itraverse :: Applicative f => (i -> a -> f b) -> t a -> f (t b)
- itraversed :: IndexedTraversal i (t a) (t b) a b
newtype ReifiedLens s t a b = Lens {
- runLens :: Lens s t a b
}
type ReifiedLens' s a = ReifiedLens s s a a
newtype ReifiedIndexedLens i s t a b = IndexedLens {
- runIndexedLens :: IndexedLens i s t a b
}
type ReifiedIndexedLens' i s a = ReifiedIndexedLens i s s a a
newtype ReifiedIndexedTraversal i s t a b = IndexedTraversal {
- runIndexedTraversal :: IndexedTraversal i s t a b
}
type ReifiedIndexedTraversal' i s a = ReifiedIndexedTraversal i s s a a
newtype ReifiedTraversal s t a b = Traversal {
- runTraversal :: Traversal s t a b
}
type ReifiedTraversal' s a = ReifiedTraversal s s a a
newtype ReifiedGetter s a = Getter {
- runGetter :: Getter s a
}
newtype ReifiedIndexedGetter i s a = IndexedGetter {
- runIndexedGetter :: IndexedGetter i s a
}
newtype ReifiedFold s a = Fold {
- runFold :: Fold s a
}
newtype ReifiedIndexedFold i s a = IndexedFold {
- runIndexedFold :: IndexedFold i s a
}
newtype ReifiedSetter s t a b = Setter {
- runSetter :: Setter s t a b
}
type ReifiedSetter' s a = ReifiedSetter s s a a
newtype ReifiedIndexedSetter i s t a b = IndexedSetter {
- runIndexedSetter :: IndexedSetter i s t a b
}
type ReifiedIndexedSetter' i s a = ReifiedIndexedSetter i s s a a
newtype ReifiedIso s t a b = Iso {
- runIso :: Iso s t a b
}
type ReifiedIso' s a = ReifiedIso s s a a
newtype ReifiedPrism s t a b = Prism {
- runPrism :: Prism s t a b
}
type ReifiedPrism' s a = ReifiedPrism s s a a
ilevels :: Applicative f => Traversing (Indexed i) f s t a b -> IndexedLensLike Int f s t (Level i a) (Level j b)
levels :: Applicative f => Traversing ((->) :: Type -> Type -> Type) f s t a b -> IndexedLensLike Int f s t (Level () a) (Level () b)
sequenceByOf :: Traversal s t (f b) b -> (forall x. x -> f x) -> (forall x y. f (x -> y) -> f x -> f y) -> s -> f t
traverseByOf :: Traversal s t a b -> (forall x. x -> f x) -> (forall x y. f (x -> y) -> f x -> f y) -> (a -> f b) -> s -> f t
confusing :: Applicative f => LensLike (Curried (Yoneda f) (Yoneda f)) s t a b -> LensLike f s t a b
deepOf :: (Conjoined p, Applicative f) => LensLike f s t s t -> Traversing p f s t a b -> Over p f s t a b
failing :: (Conjoined p, Applicative f) => Traversing p f s t a b -> Over p f s t a b -> Over p f s t a b
ifailover :: Alternative m => Over (Indexed i) ((,) Any) s t a b -> (i -> a -> b) -> s -> m t
failover :: Alternative m => LensLike ((,) Any) s t a b -> (a -> b) -> s -> m t
elements :: Traversable t => (Int -> Bool) -> IndexedTraversal' Int (t a) a
elementsOf :: Applicative f => LensLike (Indexing f) s t a a -> (Int -> Bool) -> IndexedLensLike Int f s t a a
element :: Traversable t => Int -> IndexedTraversal' Int (t a) a
elementOf :: Applicative f => LensLike (Indexing f) s t a a -> Int -> IndexedLensLike Int f s t a a
ignored :: Applicative f => pafb -> s -> f s
traversed64 :: Traversable f => IndexedTraversal Int64 (f a) (f b) a b
traversed1 :: Traversable1 f => IndexedTraversal1 Int (f a) (f b) a b
traversed :: Traversable f => IndexedTraversal Int (f a) (f b) a b
imapAccumLOf :: Over (Indexed i) (State acc) s t a b -> (i -> acc -> a -> (acc, b)) -> acc -> s -> (acc, t)
imapAccumROf :: Over (Indexed i) (Backwards (State acc)) s t a b -> (i -> acc -> a -> (acc, b)) -> acc -> s -> (acc, t)
iforMOf :: (Indexed i a (WrappedMonad m b) -> s -> WrappedMonad m t) -> s -> (i -> a -> m b) -> m t
imapMOf :: Over (Indexed i) (WrappedMonad m) s t a b -> (i -> a -> m b) -> s -> m t
iforOf :: (Indexed i a (f b) -> s -> f t) -> s -> (i -> a -> f b) -> f t
itraverseOf :: (Indexed i a (f b) -> s -> f t) -> (i -> a -> f b) -> s -> f t
cloneIndexedTraversal1 :: AnIndexedTraversal1 i s t a b -> IndexedTraversal1 i s t a b
cloneIndexPreservingTraversal1 :: ATraversal1 s t a b -> IndexPreservingTraversal1 s t a b
cloneTraversal1 :: ATraversal1 s t a b -> Traversal1 s t a b
cloneIndexedTraversal :: AnIndexedTraversal i s t a b -> IndexedTraversal i s t a b
cloneIndexPreservingTraversal :: ATraversal s t a b -> IndexPreservingTraversal s t a b
cloneTraversal :: ATraversal s t a b -> Traversal s t a b
dropping :: (Conjoined p, Applicative f) => Int -> Over p (Indexing f) s t a a -> Over p f s t a a
taking :: (Conjoined p, Applicative f) => Int -> Traversing p f s t a a -> Over p f s t a a
beside :: (Representable q, Applicative (Rep q), Applicative f, Bitraversable r) => Optical p q f s t a b -> Optical p q f s' t' a b -> Optical p q f (r s s') (r t t') a b
both1 :: Bitraversable1 r => Traversal1 (r a a) (r b b) a b
both :: Bitraversable r => Traversal (r a a) (r b b) a b
holes1Of :: Conjoined p => Over p (Bazaar1 p a a) s t a a -> s -> NonEmpty (Pretext p a a t)
holesOf :: Conjoined p => Over p (Bazaar p a a) s t a a -> s -> [Pretext p a a t]
unsafeSingular :: (HasCallStack, Conjoined p, Functor f) => Traversing p f s t a b -> Over p f s t a b
singular :: (HasCallStack, Conjoined p, Functor f) => Traversing p f s t a a -> Over p f s t a a
iunsafePartsOf' :: Over (Indexed i) (Bazaar (Indexed i) a b) s t a b -> IndexedLens [i] s t [a] [b]
unsafePartsOf' :: ATraversal s t a b -> Lens s t [a] [b]
iunsafePartsOf :: (Indexable [i] p, Functor f) => Traversing (Indexed i) f s t a b -> Over p f s t [a] [b]
unsafePartsOf :: Functor f => Traversing ((->) :: Type -> Type -> Type) f s t a b -> LensLike f s t [a] [b]
ipartsOf' :: (Indexable [i] p, Functor f) => Over (Indexed i) (Bazaar' (Indexed i) a) s t a a -> Over p f s t [a] [a]
partsOf' :: ATraversal s t a a -> Lens s t [a] [a]
ipartsOf :: (Indexable [i] p, Functor f) => Traversing (Indexed i) f s t a a -> Over p f s t [a] [a]
partsOf :: Functor f => Traversing ((->) :: Type -> Type -> Type) f s t a a -> LensLike f s t [a] [a]
iloci :: IndexedTraversal i (Bazaar (Indexed i) a c s) (Bazaar (Indexed i) b c s) a b
loci :: Traversal (Bazaar ((->) :: Type -> Type -> Type) a c s) (Bazaar ((->) :: Type -> Type -> Type) b c s) a b
scanl1Of :: LensLike (State (Maybe a)) s t a a -> (a -> a -> a) -> s -> t
scanr1Of :: LensLike (Backwards (State (Maybe a))) s t a a -> (a -> a -> a) -> s -> t
mapAccumLOf :: LensLike (State acc) s t a b -> (acc -> a -> (acc, b)) -> acc -> s -> (acc, t)
mapAccumROf :: LensLike (Backwards (State acc)) s t a b -> (acc -> a -> (acc, b)) -> acc -> s -> (acc, t)
transposeOf :: LensLike ZipList s t [a] a -> s -> [t]
sequenceOf :: LensLike (WrappedMonad m) s t (m b) b -> s -> m t
forMOf :: LensLike (WrappedMonad m) s t a b -> s -> (a -> m b) -> m t
mapMOf :: LensLike (WrappedMonad m) s t a b -> (a -> m b) -> s -> m t
sequenceAOf :: LensLike f s t (f b) b -> s -> f t
forOf :: LensLike f s t a b -> s -> (a -> f b) -> f t
traverseOf :: LensLike f s t a b -> (a -> f b) -> s -> f t
type ATraversal s t a b = LensLike (Bazaar ((->) :: Type -> Type -> Type) a b) s t a b
type ATraversal' s a = ATraversal s s a a
type ATraversal1 s t a b = LensLike (Bazaar1 ((->) :: Type -> Type -> Type) a b) s t a b
type ATraversal1' s a = ATraversal1 s s a a
type AnIndexedTraversal i s t a b = Over (Indexed i) (Bazaar (Indexed i) a b) s t a b
type AnIndexedTraversal1 i s t a b = Over (Indexed i) (Bazaar1 (Indexed i) a b) s t a b
type AnIndexedTraversal' i s a = AnIndexedTraversal i s s a a
type AnIndexedTraversal1' i s a = AnIndexedTraversal1 i s s a a
type Traversing (p :: Type -> Type -> Type) (f :: Type -> Type) s t a b = Over p (BazaarT p f a b) s t a b
type Traversing1 (p :: Type -> Type -> Type) (f :: Type -> Type) s t a b = Over p (BazaarT1 p f a b) s t a b
type Traversing' (p :: Type -> Type -> Type) (f :: Type -> Type) s a = Traversing p f s s a a
type Traversing1' (p :: Type -> Type -> Type) (f :: Type -> Type) s a = Traversing1 p f s s a a
class Ord k => TraverseMin k (m :: Type -> Type) | m -> k where
- traverseMin :: IndexedTraversal' k (m v) v
class Ord k => TraverseMax k (m :: Type -> Type) | m -> k where
- traverseMax :: IndexedTraversal' k (m v) v
foldMapByOf :: Fold s a -> (r -> r -> r) -> r -> (a -> r) -> s -> r
foldByOf :: Fold s a -> (a -> a -> a) -> a -> s -> a
idroppingWhile :: (Indexable i p, Profunctor q, Applicative f) => (i -> a -> Bool) -> Optical (Indexed i) q (Compose (State Bool) f) s t a a -> Optical p q f s t a a
itakingWhile :: (Indexable i p, Profunctor q, Contravariant f, Applicative f) => (i -> a -> Bool) -> Optical' (Indexed i) q (Const (Endo (f s)) :: Type -> Type) s a -> Optical' p q f s a
ifiltered :: (Indexable i p, Applicative f) => (i -> a -> Bool) -> Optical' p (Indexed i) f a a
findIndicesOf :: IndexedGetting i (Endo [i]) s a -> (a -> Bool) -> s -> [i]
findIndexOf :: IndexedGetting i (First i) s a -> (a -> Bool) -> s -> Maybe i
elemIndicesOf :: Eq a => IndexedGetting i (Endo [i]) s a -> a -> s -> [i]
elemIndexOf :: Eq a => IndexedGetting i (First i) s a -> a -> s -> Maybe i
(^@?!) :: HasCallStack => s -> IndexedGetting i (Endo (i, a)) s a -> (i, a)
(^@?) :: s -> IndexedGetting i (Endo (Maybe (i, a))) s a -> Maybe (i, a)
(^@..) :: s -> IndexedGetting i (Endo [(i, a)]) s a -> [(i, a)]
itoListOf :: IndexedGetting i (Endo [(i, a)]) s a -> s -> [(i, a)]
ifoldlMOf :: Monad m => IndexedGetting i (Endo (r -> m r)) s a -> (i -> r -> a -> m r) -> r -> s -> m r
ifoldrMOf :: Monad m => IndexedGetting i (Dual (Endo (r -> m r))) s a -> (i -> a -> r -> m r) -> r -> s -> m r
ifoldlOf' :: IndexedGetting i (Endo (r -> r)) s a -> (i -> r -> a -> r) -> r -> s -> r
ifoldrOf' :: IndexedGetting i (Dual (Endo (r -> r))) s a -> (i -> a -> r -> r) -> r -> s -> r
ifindMOf :: Monad m => IndexedGetting i (Endo (m (Maybe a))) s a -> (i -> a -> m Bool) -> s -> m (Maybe a)
ifindOf :: IndexedGetting i (Endo (Maybe a)) s a -> (i -> a -> Bool) -> s -> Maybe a
iconcatMapOf :: IndexedGetting i [r] s a -> (i -> a -> [r]) -> s -> [r]
iforMOf_ :: Monad m => IndexedGetting i (Sequenced r m) s a -> s -> (i -> a -> m r) -> m ()
imapMOf_ :: Monad m => IndexedGetting i (Sequenced r m) s a -> (i -> a -> m r) -> s -> m ()
iforOf_ :: Functor f => IndexedGetting i (Traversed r f) s a -> s -> (i -> a -> f r) -> f ()
itraverseOf_ :: Functor f => IndexedGetting i (Traversed r f) s a -> (i -> a -> f r) -> s -> f ()
inoneOf :: IndexedGetting i Any s a -> (i -> a -> Bool) -> s -> Bool
iallOf :: IndexedGetting i All s a -> (i -> a -> Bool) -> s -> Bool
ianyOf :: IndexedGetting i Any s a -> (i -> a -> Bool) -> s -> Bool
ifoldlOf :: IndexedGetting i (Dual (Endo r)) s a -> (i -> r -> a -> r) -> r -> s -> r
ifoldrOf :: IndexedGetting i (Endo r) s a -> (i -> a -> r -> r) -> r -> s -> r
ifoldMapOf :: IndexedGetting i m s a -> (i -> a -> m) -> s -> m
backwards :: (Profunctor p, Profunctor q) => Optical p q (Backwards f) s t a b -> Optical p q f s t a b
ipreuses :: MonadState s m => IndexedGetting i (First r) s a -> (i -> a -> r) -> m (Maybe r)
preuses :: MonadState s m => Getting (First r) s a -> (a -> r) -> m (Maybe r)
ipreuse :: MonadState s m => IndexedGetting i (First (i, a)) s a -> m (Maybe (i, a))
preuse :: MonadState s m => Getting (First a) s a -> m (Maybe a)
ipreviews :: MonadReader s m => IndexedGetting i (First r) s a -> (i -> a -> r) -> m (Maybe r)
previews :: MonadReader s m => Getting (First r) s a -> (a -> r) -> m (Maybe r)
ipreview :: MonadReader s m => IndexedGetting i (First (i, a)) s a -> m (Maybe (i, a))
preview :: MonadReader s m => Getting (First a) s a -> m (Maybe a)
ipre :: IndexedGetting i (First (i, a)) s a -> IndexPreservingGetter s (Maybe (i, a))
pre :: Getting (First a) s a -> IndexPreservingGetter s (Maybe a)
hasn't :: Getting All s a -> s -> Bool
has :: Getting Any s a -> s -> Bool
foldlMOf :: Monad m => Getting (Endo (r -> m r)) s a -> (r -> a -> m r) -> r -> s -> m r
foldrMOf :: Monad m => Getting (Dual (Endo (r -> m r))) s a -> (a -> r -> m r) -> r -> s -> m r
foldl1Of' :: HasCallStack => Getting (Endo (Endo (Maybe a))) s a -> (a -> a -> a) -> s -> a
foldr1Of' :: HasCallStack => Getting (Dual (Endo (Endo (Maybe a)))) s a -> (a -> a -> a) -> s -> a
foldlOf' :: Getting (Endo (Endo r)) s a -> (r -> a -> r) -> r -> s -> r
foldrOf' :: Getting (Dual (Endo (Endo r))) s a -> (a -> r -> r) -> r -> s -> r
foldl1Of :: HasCallStack => Getting (Dual (Endo (Maybe a))) s a -> (a -> a -> a) -> s -> a
foldr1Of :: HasCallStack => Getting (Endo (Maybe a)) s a -> (a -> a -> a) -> s -> a
lookupOf :: Eq k => Getting (Endo (Maybe v)) s (k, v) -> k -> s -> Maybe v
findMOf :: Monad m => Getting (Endo (m (Maybe a))) s a -> (a -> m Bool) -> s -> m (Maybe a)
findOf :: Getting (Endo (Maybe a)) s a -> (a -> Bool) -> s -> Maybe a
minimumByOf :: Getting (Endo (Endo (Maybe a))) s a -> (a -> a -> Ordering) -> s -> Maybe a
maximumByOf :: Getting (Endo (Endo (Maybe a))) s a -> (a -> a -> Ordering) -> s -> Maybe a
minimum1Of :: Ord a => Getting (Min a) s a -> s -> a
minimumOf :: Ord a => Getting (Endo (Endo (Maybe a))) s a -> s -> Maybe a
maximum1Of :: Ord a => Getting (Max a) s a -> s -> a
maximumOf :: Ord a => Getting (Endo (Endo (Maybe a))) s a -> s -> Maybe a
notNullOf :: Getting Any s a -> s -> Bool
nullOf :: Getting All s a -> s -> Bool
last1Of :: Getting (Last a) s a -> s -> a
lastOf :: Getting (Rightmost a) s a -> s -> Maybe a
first1Of :: Getting (First a) s a -> s -> a
firstOf :: Getting (Leftmost a) s a -> s -> Maybe a
(^?!) :: HasCallStack => s -> Getting (Endo a) s a -> a
(^?) :: s -> Getting (First a) s a -> Maybe a
lengthOf :: Getting (Endo (Endo Int)) s a -> s -> Int
concatOf :: Getting [r] s [r] -> s -> [r]
concatMapOf :: Getting [r] s a -> (a -> [r]) -> s -> [r]
notElemOf :: Eq a => Getting All s a -> a -> s -> Bool
elemOf :: Eq a => Getting Any s a -> a -> s -> Bool
msumOf :: MonadPlus m => Getting (Endo (m a)) s (m a) -> s -> m a
asumOf :: Alternative f => Getting (Endo (f a)) s (f a) -> s -> f a
sequenceOf_ :: Monad m => Getting (Sequenced a m) s (m a) -> s -> m ()
forMOf_ :: Monad m => Getting (Sequenced r m) s a -> s -> (a -> m r) -> m ()
mapMOf_ :: Monad m => Getting (Sequenced r m) s a -> (a -> m r) -> s -> m ()
sequence1Of_ :: Functor f => Getting (TraversedF a f) s (f a) -> s -> f ()
for1Of_ :: Functor f => Getting (TraversedF r f) s a -> s -> (a -> f r) -> f ()
traverse1Of_ :: Functor f => Getting (TraversedF r f) s a -> (a -> f r) -> s -> f ()
sequenceAOf_ :: Functor f => Getting (Traversed a f) s (f a) -> s -> f ()
forOf_ :: Functor f => Getting (Traversed r f) s a -> s -> (a -> f r) -> f ()
traverseOf_ :: Functor f => Getting (Traversed r f) s a -> (a -> f r) -> s -> f ()
sumOf :: Num a => Getting (Endo (Endo a)) s a -> s -> a
productOf :: Num a => Getting (Endo (Endo a)) s a -> s -> a
noneOf :: Getting Any s a -> (a -> Bool) -> s -> Bool
allOf :: Getting All s a -> (a -> Bool) -> s -> Bool
anyOf :: Getting Any s a -> (a -> Bool) -> s -> Bool
orOf :: Getting Any s Bool -> s -> Bool
andOf :: Getting All s Bool -> s -> Bool
(^..) :: s -> Getting (Endo [a]) s a -> [a]
toNonEmptyOf :: Getting (NonEmptyDList a) s a -> s -> NonEmpty a
toListOf :: Getting (Endo [a]) s a -> s -> [a]
foldlOf :: Getting (Dual (Endo r)) s a -> (r -> a -> r) -> r -> s -> r
foldrOf :: Getting (Endo r) s a -> (a -> r -> r) -> r -> s -> r
foldOf :: Getting a s a -> s -> a
foldMapOf :: Getting r s a -> (a -> r) -> s -> r
lined :: Applicative f => IndexedLensLike' Int f String String
worded :: Applicative f => IndexedLensLike' Int f String String
droppingWhile :: (Conjoined p, Profunctor q, Applicative f) => (a -> Bool) -> Optical p q (Compose (State Bool) f) s t a a -> Optical p q f s t a a
takingWhile :: (Conjoined p, Applicative f) => (a -> Bool) -> Over p (TakingWhile p f a a) s t a a -> Over p f s t a a
filteredBy :: (Indexable i p, Applicative f) => Getting (First i) a i -> p a (f a) -> a -> f a
filtered :: (Choice p, Applicative f) => (a -> Bool) -> Optic' p f a a
iterated :: Apply f => (a -> a) -> LensLike' f a a
unfolded :: (b -> Maybe (a, b)) -> Fold b a
cycled :: Apply f => LensLike f s t a b -> LensLike f s t a b
replicated :: Int -> Fold a a
repeated :: Apply f => LensLike' f a a
folded64 :: Foldable f => IndexedFold Int64 (f a) a
folded :: Foldable f => IndexedFold Int (f a) a
ifoldring :: (Indexable i p, Contravariant f, Applicative f) => ((i -> a -> f a -> f a) -> f a -> s -> f a) -> Over p f s t a b
foldring :: (Contravariant f, Applicative f) => ((a -> f a -> f a) -> f a -> s -> f a) -> LensLike f s t a b
ifolding :: (Foldable f, Indexable i p, Contravariant g, Applicative g) => (s -> f (i, a)) -> Over p g s t a b
folding :: Foldable f => (s -> f a) -> Fold s a
_Show :: (Read a, Show a) => Prism' String a
nearly :: a -> (a -> Bool) -> Prism' a ()
only :: Eq a => a -> Prism' a ()
_Void :: Prism s s a Void
_Nothing :: Prism' (Maybe a) ()
_Just :: Prism (Maybe a) (Maybe b) a b
_Right :: Prism (Either c a) (Either c b) a b
_Left :: Prism (Either a c) (Either b c) a b
matching :: APrism s t a b -> s -> Either t a
isn't :: APrism s t a b -> s -> Bool
below :: Traversable f => APrism' s a -> Prism' (f s) (f a)
aside :: APrism s t a b -> Prism (e, s) (e, t) (e, a) (e, b)
without :: APrism s t a b -> APrism u v c d -> Prism (Either s u) (Either t v) (Either a c) (Either b d)
outside :: Representable p => APrism s t a b -> Lens (p t r) (p s r) (p b r) (p a r)
prism' :: (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism :: (b -> t) -> (s -> Either t a) -> Prism s t a b
clonePrism :: APrism s t a b -> Prism s t a b
withPrism :: APrism s t a b -> ((b -> t) -> (s -> Either t a) -> r) -> r
type APrism s t a b = Market a b a (Identity b) -> Market a b s (Identity t)
type APrism' s a = APrism s s a a
reuses :: MonadState b m => AReview t b -> (t -> r) -> m r
reuse :: MonadState b m => AReview t b -> m t
reviews :: MonadReader b m => AReview t b -> (t -> r) -> m r
(#) :: AReview t b -> b -> t
review :: MonadReader b m => AReview t b -> m t
re :: AReview t b -> Getter b t
un :: (Profunctor p, Bifunctor p, Functor f) => Getting a s a -> Optic' p f a s
unto :: (Profunctor p, Bifunctor p, Functor f) => (b -> t) -> Optic p f s t a b
getting :: (Profunctor p, Profunctor q, Functor f, Contravariant f) => Optical p q f s t a b -> Optical' p q f s a
(^@.) :: s -> IndexedGetting i (i, a) s a -> (i, a)
iuses :: MonadState s m => IndexedGetting i r s a -> (i -> a -> r) -> m r
iuse :: MonadState s m => IndexedGetting i (i, a) s a -> m (i, a)
iviews :: MonadReader s m => IndexedGetting i r s a -> (i -> a -> r) -> m r
iview :: MonadReader s m => IndexedGetting i (i, a) s a -> m (i, a)
ilistenings :: MonadWriter w m => IndexedGetting i v w u -> (i -> u -> v) -> m a -> m (a, v)
listenings :: MonadWriter w m => Getting v w u -> (u -> v) -> m a -> m (a, v)
ilistening :: MonadWriter w m => IndexedGetting i (i, u) w u -> m a -> m (a, (i, u))
listening :: MonadWriter w m => Getting u w u -> m a -> m (a, u)
uses :: MonadState s m => LensLike' (Const r :: Type -> Type) s a -> (a -> r) -> m r
use :: MonadState s m => Getting a s a -> m a
(^.) :: s -> Getting a s a -> a
views :: MonadReader s m => LensLike' (Const r :: Type -> Type) s a -> (a -> r) -> m r
view :: MonadReader s m => Getting a s a -> m a
ilike :: (Indexable i p, Contravariant f, Functor f) => i -> a -> Over' p f s a
like :: (Profunctor p, Contravariant f, Functor f) => a -> Optic' p f s a
ito :: (Indexable i p, Contravariant f) => (s -> (i, a)) -> Over' p f s a
to :: (Profunctor p, Contravariant f) => (s -> a) -> Optic' p f s a
type Getting r s a = (a -> Const r a) -> s -> Const r s
type IndexedGetting i m s a = Indexed i a (Const m a) -> s -> Const m s
type Accessing (p :: Type -> Type -> Type) m s a = p a (Const m a) -> s -> Const m s
_19' :: Field19 s t a b => Lens s t a b
_18' :: Field18 s t a b => Lens s t a b
_17' :: Field17 s t a b => Lens s t a b
_16' :: Field16 s t a b => Lens s t a b
_15' :: Field15 s t a b => Lens s t a b
_14' :: Field14 s t a b => Lens s t a b
_13' :: Field13 s t a b => Lens s t a b
_12' :: Field12 s t a b => Lens s t a b
_11' :: Field11 s t a b => Lens s t a b
_10' :: Field10 s t a b => Lens s t a b
_9' :: Field9 s t a b => Lens s t a b
_8' :: Field8 s t a b => Lens s t a b
_7' :: Field7 s t a b => Lens s t a b
_6' :: Field6 s t a b => Lens s t a b
_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
class Field1 s t a b | s -> a, t -> b, s b -> t, t a -> s where
- _1 :: Lens s t a b
class Field2 s t a b | s -> a, t -> b, s b -> t, t a -> s where
- _2 :: Lens s t a b
class Field3 s t a b | s -> a, t -> b, s b -> t, t a -> s where
- _3 :: Lens s t a b
class Field4 s t a b | s -> a, t -> b, s b -> t, t a -> s where
- _4 :: Lens s t a b
class Field5 s t a b | s -> a, t -> b, s b -> t, t a -> s where
- _5 :: Lens s t a b
class Field6 s t a b | s -> a, t -> b, s b -> t, t a -> s where
- _6 :: Lens s t a b
class Field7 s t a b | s -> a, t -> b, s b -> t, t a -> s where
- _7 :: Lens s t a b
class Field8 s t a b | s -> a, t -> b, s b -> t, t a -> s where
- _8 :: Lens s t a b
class Field9 s t a b | s -> a, t -> b, s b -> t, t a -> s where
- _9 :: Lens s t a b
class Field10 s t a b | s -> a, t -> b, s b -> t, t a -> s where
- _10 :: Lens s t a b
class Field11 s t a b | s -> a, t -> b, s b -> t, t a -> s where
- _11 :: Lens s t a b
class Field12 s t a b | s -> a, t -> b, s b -> t, t a -> s where
- _12 :: Lens s t a b
class Field13 s t a b | s -> a, t -> b, s b -> t, t a -> s where
- _13 :: Lens s t a b
class Field14 s t a b | s -> a, t -> b, s b -> t, t a -> s where
- _14 :: Lens s t a b
class Field15 s t a b | s -> a, t -> b, s b -> t, t a -> s where
- _15 :: Lens s t a b
class Field16 s t a b | s -> a, t -> b, s b -> t, t a -> s where
- _16 :: Lens s t a b
class Field17 s t a b | s -> a, t -> b, s b -> t, t a -> s where
- _17 :: Lens s t a b
class Field18 s t a b | s -> a, t -> b, s b -> t, t a -> s where
- _18 :: Lens s t a b
class Field19 s t a b | s -> a, t -> b, s b -> t, t a -> s where
- _19 :: Lens s t a b
fusing :: Functor f => LensLike (Yoneda f) s t a b -> LensLike f s t a b
last1 :: Traversable1 t => Lens' (t a) a
head1 :: Traversable1 t => Lens' (t a) a
united :: Lens' a ()
devoid :: Over p f Void Void a b
(<#=) :: MonadState s m => ALens s s a b -> b -> m b
(<#~) :: ALens s t a b -> b -> s -> (b, t)
(#%%=) :: MonadState s m => ALens s s a b -> (a -> (r, b)) -> m r
(<#%=) :: MonadState s m => ALens s s a b -> (a -> b) -> m b
(<#%~) :: ALens s t a b -> (a -> b) -> s -> (b, t)
(#%=) :: MonadState s m => ALens s s a b -> (a -> b) -> m ()
(#=) :: MonadState s m => ALens s s a b -> b -> m ()
(#%%~) :: Functor f => ALens s t a b -> (a -> f b) -> s -> f t
(#%~) :: ALens s t a b -> (a -> b) -> s -> t
(#~) :: ALens s t a b -> b -> s -> t
storing :: ALens s t a b -> b -> s -> t
(^#) :: s -> ALens s t a b -> a
(<<%@=) :: MonadState s m => Over (Indexed i) ((,) a) s s a b -> (i -> a -> b) -> m a
(<%@=) :: MonadState s m => Over (Indexed i) ((,) b) s s a b -> (i -> a -> b) -> m b
(%%@=) :: MonadState s m => Over (Indexed i) ((,) r) s s a b -> (i -> a -> (r, b)) -> m r
(%%@~) :: Over (Indexed i) f s t a b -> (i -> a -> f b) -> s -> f t
(<<%@~) :: Over (Indexed i) ((,) a) s t a b -> (i -> a -> b) -> s -> (a, t)
(<%@~) :: Over (Indexed i) ((,) b) s t a b -> (i -> a -> b) -> s -> (b, t)
overA :: Arrow ar => LensLike (Context a b) s t a b -> ar a b -> ar s t
(<<>=) :: (MonadState s m, Monoid r) => LensLike' ((,) r) s r -> r -> m r
(<<>~) :: Monoid m => LensLike ((,) m) s t m m -> m -> s -> (m, t)
(<<~) :: MonadState s m => ALens s s a b -> m b -> m b
(<<<>=) :: (MonadState s m, Monoid r) => LensLike' ((,) r) s r -> r -> m r
(<<&&=) :: MonadState s m => LensLike' ((,) Bool) s Bool -> Bool -> m Bool
(<<||=) :: MonadState s m => LensLike' ((,) Bool) s Bool -> Bool -> m Bool
(<<**=) :: (MonadState s m, Floating a) => LensLike' ((,) a) s a -> a -> m a
(<<^^=) :: (MonadState s m, Fractional a, Integral e) => LensLike' ((,) a) s a -> e -> m a
(<<^=) :: (MonadState s m, Num a, Integral e) => LensLike' ((,) a) s a -> e -> m a
(<<//=) :: (MonadState s m, Fractional a) => LensLike' ((,) a) s a -> a -> m a
(<<*=) :: (MonadState s m, Num a) => LensLike' ((,) a) s a -> a -> m a
(<<-=) :: (MonadState s m, Num a) => LensLike' ((,) a) s a -> a -> m a
(<<+=) :: (MonadState s m, Num a) => LensLike' ((,) a) s a -> a -> m a
(<<?=) :: MonadState s m => LensLike ((,) a) s s a (Maybe b) -> b -> m a
(<<.=) :: MonadState s m => LensLike ((,) a) s s a b -> b -> m a
(<<%=) :: (Strong p, MonadState s m) => Over p ((,) a) s s a b -> p a b -> m a
(<&&=) :: MonadState s m => LensLike' ((,) Bool) s Bool -> Bool -> m Bool
(<||=) :: MonadState s m => LensLike' ((,) Bool) s Bool -> Bool -> m Bool
(<**=) :: (MonadState s m, Floating a) => LensLike' ((,) a) s a -> a -> m a
(<^^=) :: (MonadState s m, Fractional a, Integral e) => LensLike' ((,) a) s a -> e -> m a
(<^=) :: (MonadState s m, Num a, Integral e) => LensLike' ((,) a) s a -> e -> m a
(<//=) :: (MonadState s m, Fractional a) => LensLike' ((,) a) s a -> a -> m a
(<*=) :: (MonadState s m, Num a) => LensLike' ((,) a) s a -> a -> m a
(<-=) :: (MonadState s m, Num a) => LensLike' ((,) a) s a -> a -> m a
(<+=) :: (MonadState s m, Num a) => LensLike' ((,) a) s a -> a -> m a
(<%=) :: MonadState s m => LensLike ((,) b) s s a b -> (a -> b) -> m b
(<<<>~) :: Monoid r => LensLike' ((,) r) s r -> r -> s -> (r, s)
(<<&&~) :: LensLike' ((,) Bool) s Bool -> Bool -> s -> (Bool, s)
(<<||~) :: LensLike' ((,) Bool) s Bool -> Bool -> s -> (Bool, s)
(<<**~) :: Floating a => LensLike' ((,) a) s a -> a -> s -> (a, s)
(<<^^~) :: (Fractional a, Integral e) => LensLike' ((,) a) s a -> e -> s -> (a, s)
(<<^~) :: (Num a, Integral e) => LensLike' ((,) a) s a -> e -> s -> (a, s)
(<<//~) :: Fractional a => LensLike' ((,) a) s a -> a -> s -> (a, s)
(<<*~) :: Num a => LensLike' ((,) a) s a -> a -> s -> (a, s)
(<<-~) :: Num a => LensLike' ((,) a) s a -> a -> s -> (a, s)
(<<+~) :: Num a => LensLike' ((,) a) s a -> a -> s -> (a, s)
(<<?~) :: LensLike ((,) a) s t a (Maybe b) -> b -> s -> (a, t)
(<<.~) :: LensLike ((,) a) s t a b -> b -> s -> (a, t)
(<<%~) :: LensLike ((,) a) s t a b -> (a -> b) -> s -> (a, t)
(<&&~) :: LensLike ((,) Bool) s t Bool Bool -> Bool -> s -> (Bool, t)
(<||~) :: LensLike ((,) Bool) s t Bool Bool -> Bool -> s -> (Bool, t)
(<**~) :: Floating a => LensLike ((,) a) s t a a -> a -> s -> (a, t)
(<^^~) :: (Fractional a, Integral e) => LensLike ((,) a) s t a a -> e -> s -> (a, t)
(<^~) :: (Num a, Integral e) => LensLike ((,) a) s t a a -> e -> s -> (a, t)
(<//~) :: Fractional a => LensLike ((,) a) s t a a -> a -> s -> (a, t)
(<*~) :: Num a => LensLike ((,) a) s t a a -> a -> s -> (a, t)
(<-~) :: Num a => LensLike ((,) a) s t a a -> a -> s -> (a, t)
(<+~) :: Num a => LensLike ((,) a) s t a a -> a -> s -> (a, t)
(<%~) :: LensLike ((,) b) s t a b -> (a -> b) -> s -> (b, t)
cloneIndexedLens :: AnIndexedLens i s t a b -> IndexedLens i s t a b
cloneIndexPreservingLens :: ALens s t a b -> IndexPreservingLens s t a b
cloneLens :: ALens s t a b -> Lens s t a b
locus :: IndexedComonadStore p => Lens (p a c s) (p b c s) a b
alongside :: LensLike (AlongsideLeft f b') s t a b -> LensLike (AlongsideRight f t) s' t' a' b' -> LensLike f (s, s') (t, t') (a, a') (b, b')
chosen :: IndexPreservingLens (Either a a) (Either b b) a b
choosing :: Functor f => LensLike f s t a b -> LensLike f s' t' a b -> LensLike f (Either s s') (Either t t') a b
inside :: Corepresentable p => ALens s t a b -> Lens (p e s) (p e t) (p e a) (p e b)
(??) :: Functor f => f (a -> b) -> a -> f b
(%%=) :: MonadState s m => Over p ((,) r) s s a b -> p a (r, b) -> m r
(%%~) :: LensLike f s t a b -> (a -> f b) -> s -> f t
(&~) :: s -> State s a -> s
ilens :: (s -> (i, a)) -> (s -> b -> t) -> IndexedLens i s t a b
iplens :: (s -> a) -> (s -> b -> t) -> IndexPreservingLens s t a b
withLens :: ALens s t a b -> ((s -> a) -> (s -> b -> t) -> r) -> r
lens :: (s -> a) -> (s -> b -> t) -> Lens s t a b
type ALens s t a b = LensLike (Pretext ((->) :: Type -> Type -> Type) a b) s t a b
type ALens' s a = ALens s s a a
type AnIndexedLens i s t a b = Optical (Indexed i) ((->) :: Type -> Type -> Type) (Pretext (Indexed i) a b) s t a b
type AnIndexedLens' i s a = AnIndexedLens i s s a a
imapOf :: AnIndexedSetter i s t a b -> (i -> a -> b) -> s -> t
mapOf :: ASetter s t a b -> (a -> b) -> s -> t
assignA :: Arrow p => ASetter s t a b -> p s b -> p s t
(.@=) :: MonadState s m => AnIndexedSetter i s s a b -> (i -> b) -> m ()
imodifying :: MonadState s m => AnIndexedSetter i s s a b -> (i -> a -> b) -> m ()
(%@=) :: MonadState s m => AnIndexedSetter i s s a b -> (i -> a -> b) -> m ()
(.@~) :: AnIndexedSetter i s t a b -> (i -> b) -> s -> t
(%@~) :: AnIndexedSetter i s t a b -> (i -> a -> b) -> s -> t
isets :: ((i -> a -> b) -> s -> t) -> IndexedSetter i s t a b
iset :: AnIndexedSetter i s t a b -> (i -> b) -> s -> t
iover :: AnIndexedSetter i s t a b -> (i -> a -> b) -> s -> t
ilocally :: MonadReader s m => AnIndexedSetter i s s a b -> (i -> a -> b) -> m r -> m r
locally :: MonadReader s m => ASetter s s a b -> (a -> b) -> m r -> m r
icensoring :: MonadWriter w m => IndexedSetter i w w u v -> (i -> u -> v) -> m a -> m a
censoring :: MonadWriter w m => Setter w w u v -> (u -> v) -> m a -> m a
ipassing :: MonadWriter w m => IndexedSetter i w w u v -> m (a, i -> u -> v) -> m a
passing :: MonadWriter w m => Setter w w u v -> m (a, u -> v) -> m a
scribe :: (MonadWriter t m, Monoid s) => ASetter s t a b -> b -> m ()
(<>=) :: (MonadState s m, Monoid a) => ASetter' s a -> a -> m ()
(<>~) :: Monoid a => ASetter s t a a -> a -> s -> t
(<?=) :: MonadState s m => ASetter s s a (Maybe b) -> b -> m b
(<.=) :: MonadState s m => ASetter s s a b -> b -> m b
(<~) :: MonadState s m => ASetter s s a b -> m b -> m ()
(||=) :: MonadState s m => ASetter' s Bool -> Bool -> m ()
(&&=) :: MonadState s m => ASetter' s Bool -> Bool -> m ()
(**=) :: (MonadState s m, Floating a) => ASetter' s a -> a -> m ()
(^^=) :: (MonadState s m, Fractional a, Integral e) => ASetter' s a -> e -> m ()
(^=) :: (MonadState s m, Num a, Integral e) => ASetter' s a -> e -> m ()
(//=) :: (MonadState s m, Fractional a) => ASetter' s a -> a -> m ()
(*=) :: (MonadState s m, Num a) => ASetter' s a -> a -> m ()
(-=) :: (MonadState s m, Num a) => ASetter' s a -> a -> m ()
(+=) :: (MonadState s m, Num a) => ASetter' s a -> a -> m ()
(?=) :: MonadState s m => ASetter s s a (Maybe b) -> b -> m ()
modifying :: MonadState s m => ASetter s s a b -> (a -> b) -> m ()
(%=) :: MonadState s m => ASetter s s a b -> (a -> b) -> m ()
assign :: MonadState s m => ASetter s s a b -> b -> m ()
(&&~) :: ASetter s t Bool Bool -> Bool -> s -> t
(||~) :: ASetter s t Bool Bool -> Bool -> s -> t
(**~) :: Floating a => ASetter s t a a -> a -> s -> t
(^^~) :: (Fractional a, Integral e) => ASetter s t a a -> e -> s -> t
(^~) :: (Num a, Integral e) => ASetter s t a a -> e -> s -> t
(//~) :: Fractional a => ASetter s t a a -> a -> s -> t
(-~) :: Num a => ASetter s t a a -> a -> 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 (Maybe b) -> b -> s -> (b, t)
(<.~) :: ASetter s t a b -> b -> s -> (b, t)
(?~) :: ASetter s t a (Maybe b) -> b -> s -> t
(.~) :: ASetter s t a b -> b -> s -> t
(%~) :: ASetter s t a b -> (a -> b) -> s -> t
set' :: ASetter' s a -> a -> s -> s
set :: ASetter s t a b -> b -> s -> t
over :: ASetter s t a b -> (a -> b) -> s -> t
cloneIndexedSetter :: AnIndexedSetter i s t a b -> IndexedSetter i s t a b
cloneIndexPreservingSetter :: ASetter s t a b -> IndexPreservingSetter s t a b
cloneSetter :: ASetter s t a b -> Setter s t a b
sets :: (Profunctor p, Profunctor q, Settable f) => (p a b -> q s t) -> Optical p q f s t a b
setting :: ((a -> b) -> s -> t) -> IndexPreservingSetter s t a b
argument :: Profunctor p => Setter (p b r) (p a r) a b
contramapped :: Contravariant f => Setter (f b) (f a) a b
lifted :: Monad m => Setter (m a) (m b) a b
mapped :: Functor f => Setter (f a) (f b) a b
type ASetter s t a b = (a -> Identity b) -> s -> Identity t
type ASetter' s a = ASetter s s a a
type AnIndexedSetter i s t a b = Indexed i a (Identity b) -> s -> Identity t
type AnIndexedSetter' i s a = AnIndexedSetter i s s a a
type Setting (p :: Type -> Type -> Type) s t a b = p a (Identity b) -> s -> Identity t
type Setting' (p :: Type -> Type -> Type) s a = Setting p s s a a
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 IndexedLens i s t a b = forall (f :: Type -> Type) (p :: Type -> Type -> Type). (Indexable i p, Functor f) => p a (f b) -> s -> f t
type IndexedLens' i s a = IndexedLens i s s a a
type IndexPreservingLens s t a b = forall (p :: Type -> Type -> Type) (f :: Type -> Type). (Conjoined p, Functor f) => p a (f b) -> p s (f t)
type IndexPreservingLens' s a = IndexPreservingLens s s a a
type Traversal s t a b = forall (f :: Type -> Type). Applicative f => (a -> f b) -> s -> f t
type Traversal' s a = Traversal s s a a
type Traversal1 s t a b = forall (f :: Type -> Type). Apply f => (a -> f b) -> s -> f t
type Traversal1' s a = Traversal1 s s a a
type IndexedTraversal i s t a b = forall (p :: Type -> Type -> Type) (f :: Type -> Type). (Indexable i p, Applicative f) => p a (f b) -> s -> f t
type IndexedTraversal' i s a = IndexedTraversal i s s a a
type IndexedTraversal1 i s t a b = forall (p :: Type -> Type -> Type) (f :: Type -> Type). (Indexable i p, Apply f) => p a (f b) -> s -> f t
type IndexedTraversal1' i s a = IndexedTraversal1 i s s a a
type IndexPreservingTraversal s t a b = forall (p :: Type -> Type -> Type) (f :: Type -> Type). (Conjoined p, Applicative f) => p a (f b) -> p s (f t)
type IndexPreservingTraversal' s a = IndexPreservingTraversal s s a a
type IndexPreservingTraversal1 s t a b = forall (p :: Type -> Type -> Type) (f :: Type -> Type). (Conjoined p, Apply f) => p a (f b) -> p s (f t)
type IndexPreservingTraversal1' s a = IndexPreservingTraversal1 s s a a
type Setter s t a b = forall (f :: Type -> Type). Settable f => (a -> f b) -> s -> f t
type Setter' s a = Setter s s a a
type IndexedSetter i s t a b = forall (f :: Type -> Type) (p :: Type -> Type -> Type). (Indexable i p, Settable f) => p a (f b) -> s -> f t
type IndexedSetter' i s a = IndexedSetter i s s a a
type IndexPreservingSetter s t a b = forall (p :: Type -> Type -> Type) (f :: Type -> Type). (Conjoined p, Settable f) => p a (f b) -> p s (f t)
type IndexPreservingSetter' s a = IndexPreservingSetter s s a a
type Iso s t a b = forall (p :: Type -> Type -> Type) (f :: Type -> Type). (Profunctor p, Functor f) => p a (f b) -> p s (f t)
type Iso' s a = Iso s s a a
type Review t b = forall (p :: Type -> Type -> Type) (f :: Type -> Type). (Choice p, Bifunctor p, Settable f) => Optic' p f t b
type AReview t b = Optic' (Tagged :: Type -> Type -> Type) Identity t b
type Prism s t a b = forall (p :: Type -> Type -> Type) (f :: Type -> Type). (Choice p, Applicative f) => p a (f b) -> p s (f t)
type Prism' s a = Prism s s a a
type Equality (s :: k1) (t :: k2) (a :: k1) (b :: k2) = forall k3 (p :: k1 -> k3 -> Type) (f :: k2 -> k3). p a (f b) -> p s (f t)
type Equality' (s :: k2) (a :: k2) = Equality s s a a
type As (a :: k2) = Equality' a a
type Getter s a = forall (f :: Type -> Type). (Contravariant f, Functor f) => (a -> f a) -> s -> f s
type IndexedGetter i s a = forall (p :: Type -> Type -> Type) (f :: Type -> Type). (Indexable i p, Contravariant f, Functor f) => p a (f a) -> s -> f s
type IndexPreservingGetter s a = forall (p :: Type -> Type -> Type) (f :: Type -> Type). (Conjoined p, Contravariant f, Functor f) => p a (f a) -> p s (f s)
type Fold s a = forall (f :: Type -> Type). (Contravariant f, Applicative f) => (a -> f a) -> s -> f s
type IndexedFold i s a = forall (p :: Type -> Type -> Type) (f :: Type -> Type). (Indexable i p, Contravariant f, Applicative f) => p a (f a) -> s -> f s
type IndexPreservingFold s a = forall (p :: Type -> Type -> Type) (f :: Type -> Type). (Conjoined p, Contravariant f, Applicative f) => p a (f a) -> p s (f s)
type Fold1 s a = forall (f :: Type -> Type). (Contravariant f, Apply f) => (a -> f a) -> s -> f s
type IndexedFold1 i s a = forall (p :: Type -> Type -> Type) (f :: Type -> Type). (Indexable i p, Contravariant f, Apply f) => p a (f a) -> s -> f s
type IndexPreservingFold1 s a = forall (p :: Type -> Type -> Type) (f :: Type -> Type). (Conjoined p, Contravariant f, Apply f) => p a (f a) -> p s (f s)
type Simple (f :: k -> k -> k1 -> k1 -> k2) (s :: k) (a :: k1) = f s s a a
type Optic (p :: k1 -> k -> Type) (f :: k2 -> k) (s :: k1) (t :: k2) (a :: k1) (b :: k2) = p a (f b) -> p s (f t)
type Optic' (p :: k1 -> k -> Type) (f :: k1 -> k) (s :: k1) (a :: k1) = Optic p f s s a a
type Optical (p :: k2 -> k -> Type) (q :: k1 -> k -> Type) (f :: k3 -> k) (s :: k1) (t :: k3) (a :: k2) (b :: k3) = p a (f b) -> q s (f t)
type Optical' (p :: k1 -> k -> Type) (q :: k1 -> k -> Type) (f :: k1 -> k) (s :: k1) (a :: k1) = Optical p q f s s a a
type LensLike (f :: k -> Type) s (t :: k) a (b :: k) = (a -> f b) -> s -> f t
type LensLike' (f :: Type -> Type) s a = LensLike f s s a a
type IndexedLensLike i (f :: k -> Type) s (t :: k) a (b :: k) = forall (p :: Type -> Type -> Type). Indexable i p => p a (f b) -> s -> f t
type IndexedLensLike' i (f :: Type -> Type) s a = IndexedLensLike i f s s a a
type Over (p :: k -> Type -> Type) (f :: k1 -> Type) s (t :: k1) (a :: k) (b :: k1) = p a (f b) -> s -> f t
type Over' (p :: Type -> Type -> Type) (f :: Type -> Type) s a = Over p f s s a a
class (Applicative f, Distributive f, Traversable f) => Settable (f :: Type -> Type)
retagged :: (Profunctor p, Bifunctor p) => p a b -> p s b
class (Profunctor p, Bifunctor p) => Reviewable (p :: Type -> Type -> Type)
data Magma i t b a
data Level i a
class Reversing t where
- reversing :: t -> t
newtype Bazaar (p :: Type -> Type -> Type) a b t = Bazaar {
- runBazaar :: forall (f :: Type -> Type). Applicative f => p a (f b) -> f t
}
type Bazaar' (p :: Type -> Type -> Type) a = Bazaar p a a
newtype Bazaar1 (p :: Type -> Type -> Type) a b t = Bazaar1 {
- runBazaar1 :: forall (f :: Type -> Type). Apply f => p a (f b) -> f t
}
type Bazaar1' (p :: Type -> Type -> Type) a = Bazaar1 p a a
data Context a b t = Context (b -> t) a
type Context' a = Context a a
asIndex :: (Indexable i p, Contravariant f, Functor f) => p i (f i) -> Indexed i s (f s)
withIndex :: (Indexable i p, Functor f) => p (i, s) (f (j, t)) -> Indexed i s (f t)
indexing64 :: Indexable Int64 p => ((a -> Indexing64 f b) -> s -> Indexing64 f t) -> p a (f b) -> s -> f t
indexing :: Indexable Int p => ((a -> Indexing f b) -> s -> Indexing f t) -> p a (f b) -> s -> f t
class (Choice p, Corepresentable p, Comonad (Corep p), Traversable (Corep p), Strong p, Representable p, Monad (Rep p), MonadFix (Rep p), Distributive (Rep p), Costrong p, ArrowLoop p, ArrowApply p, ArrowChoice p, Closed p) => Conjoined (p :: Type -> Type -> Type) where
- distrib :: Functor f => p a b -> p (f a) (f b)
- conjoined :: ((p ~ ((->) :: Type -> Type -> Type)) -> q (a -> b) r) -> q (p a b) r -> q (p a b) r
class Conjoined p => Indexable i (p :: Type -> Type -> Type) where
- indexed :: p a b -> i -> a -> b
newtype Indexed i a b = Indexed {
- runIndexed :: i -> a -> b
}
data Traversed a (f :: Type -> Type)
data Sequenced a (m :: Type -> Type)
data Leftmost a
data Rightmost a
class (Foldable1 t, Traversable t) => Traversable1 (t :: Type -> Type) where
- traverse1 :: Apply f => (a -> f b) -> t a -> f (t b)
foldBy :: Foldable t => (a -> a -> a) -> a -> t a -> a
foldMapBy :: Foldable t => (r -> r -> r) -> r -> (a -> r) -> t a -> r
traverseBy :: Traversable t => (forall x. x -> f x) -> (forall x y. f (x -> y) -> f x -> f y) -> (a -> f b) -> t a -> f (t b)
sequenceBy :: Traversable t => (forall x. x -> f x) -> (forall x y. f (x -> y) -> f x -> f y) -> t (f a) -> f (t a)
class Profunctor p => Choice (p :: Type -> Type -> Type) where
- left' :: p a b -> p (Either a c) (Either b c)
- right' :: p a b -> p (Either c a) (Either c b)
_JSON' :: (AsJSON t, FromJSON a, ToJSON a) => Prism' t a
values :: AsValue t => IndexedTraversal' Int t Value
nth :: AsValue t => Int -> Traversal' t Value
members :: AsValue t => IndexedTraversal' Text t Value
key :: AsValue t => Text -> Traversal' t Value
nonNull :: Prism' Value Value
_Integral :: (AsNumber t, Integral a) => Prism' t a
pattern JSON :: forall a t. (FromJSON a, ToJSON a, AsJSON t) => a -> t
pattern Value_ :: forall a. (FromJSON a, ToJSON a) => a -> Value
pattern Number_ :: forall t. AsNumber t => Scientific -> t
pattern Double :: forall t. AsNumber t => Double -> t
pattern Integer :: forall t. AsNumber t => Integer -> t
pattern Integral :: forall t a. (AsNumber t, Integral a) => a -> t
pattern Primitive :: forall t. AsPrimitive t => Primitive -> t
pattern Bool_ :: forall t. AsPrimitive t => Bool -> t
pattern String_ :: forall t. AsPrimitive t => Text -> t
pattern Null_ :: forall t. AsPrimitive t => t
class AsNumber t where
- _Number :: Prism' t Scientific
- _Double :: Prism' t Double
- _Integer :: Prism' t Integer
data Primitive
- = StringPrim !Text
- | NumberPrim !Scientific
- | BoolPrim !Bool
- | NullPrim
class AsNumber t => AsPrimitive t where
- _Primitive :: Prism' t Primitive
- _String :: Prism' t Text
- _Bool :: Prism' t Bool
- _Null :: Prism' t ()
class AsPrimitive t => AsValue t where
- _Value :: Prism' t Value
- _Object :: Prism' t (HashMap Text Value)
- _Array :: Prism' t (Vector Value)
class AsJSON t where
- _JSON :: (FromJSON a, ToJSON b) => Prism t t a b
liftIO :: MonadIO m => IO a -> m a

SitePipe

This module re-exports everything you need to build a site. In addition to exporting all of SitePipe it also exports Data.Aeson, Data.Aeson.Lens, Control.Lens, System.FilePath.Posix, and liftIO

Running SitePipe

site :: SiteM () -> IO () Source #

Build a site generator from a set of rules embedded in a SiteM. Use this in your main function.

main :: IO ()
main = site $ do
  posts <- resourceLoader markdownReader ["posts/*.md"]
  writeTemplate "templates/post.html" posts

siteWithGlobals :: Value -> SiteM () -> IO () Source #

Like site, but allows you to pass an Value Object which consists of an environment which is available inside your templates.

This is useful for globally providing utility functions for use in your templates.

import qualified Text.Mustache as MT
import qualified Text.Mustache.Types as MT
utilityFuncs :: MT.Value
utilityFuncs = MT.object
  ["truncate" MT.~> MT.overText (T.take 30)
  ]

main :: IO ()
main = siteWithGlobals utilityFuncs $ do
 -- your site ...

<!-- in your template -->
{{#truncate}}
  Anything inside this block will be truncated to 30 chars.
  {{vars}} are interpolated before applying the function.
{{/truncate}}

Loaders

resourceLoader Source #

Arguments

:: (String -> IO String)	A reader which processes file contents
-> [GlobPattern]	File glob; relative to the `site` directory
-> SiteM [Value]	Returns a list of Aeson objects

Given a resource reader (see SitePipe.Readers) this function finds all files matching any of the provided list of fileglobs (according to srcGlob) and returns a list of loaded resources as Aeson Values.

Writers

writeWith Source #

Arguments

:: ToJSON a
=> (a -> SiteM String)	A function which renders a resource to a string.
-> [a]	List of resources to write
-> SiteM ()

Write a list of resources using the given processing function from a resource to a string.

writeTemplate Source #

Arguments

:: ToJSON a
=> FilePath	Path to template (relative to site dir)
-> [a]	List of resources to write
-> SiteM ()

Given a path to a mustache template file (relative to your source directory); this writes a list of resources to the output directory by applying each one to the template.

textWriter Source #

Arguments

:: ToJSON a
=> [a]	List of resources to write
-> SiteM ()

Writes the content of the given resources without using a template.

Loader/Writers

copyFiles :: [GlobPattern] -> SiteM [Value] Source #

Given a list of file or directory globs (see srcGlob) we copy matching files and directories as-is from the source directory to the output directory maintaining their relative filepath.

For convenience this also returns a list of the files copied as Values with "src" and "url" keys which represent the source path and the url.of the copied file respectively.

copyFilesWith :: (FilePath -> FilePath) -> [GlobPattern] -> SiteM [Value] Source #

Runs copyFiles but using a filepath transforming function to determine the output filepath. The filepath transformation accepts and should return a relative path.

See copyFiles for more information.

Readers

Built-in

markdownReader :: String -> IO String Source #

Reads markdown files into html

textReader :: String -> PandocIO String Source #

Reads text files without processing

Reader Generators

mkPandocReader :: (ReaderOptions -> String -> PandocIO Pandoc) -> String -> IO String Source #

Given any standard pandoc reader (see Text.Pandoc; e.g. readMarkdown, readDocX) makes a resource reader compatible with resourceLoader.

docs <- resourceLoader (mkPandocReader readDocX) ["docs/*.docx"]

Utilities

setExt :: String -> FilePath -> FilePath Source #

Set the extension of a filepath or url to the given extension. Use setExt "" to remove any extension.

addPrefix :: String -> FilePath -> FilePath Source #

Add a prefix to a filepath or url

getTags Source #

Arguments

:: (String -> String)	Accept a tagname and create a url
-> [Value]	List of posts
-> [Value]

Given a function which creates a url from a tag name and a list of posts (which have a tags property which is a list of strings) this returns a list of tags which contain:

name: The tag name
url: The tag's url
posts: The list of posts matching that tag

Types

module SitePipe.Types

Exports

class (Functor t, Foldable t) => Traversable (t :: Type -> Type) where #

Functors representing data structures that can be traversed from left to right.

A definition of traverse must satisfy the following laws:

naturality: t . traverse f = traverse (t . f) for every applicative transformation t
identity: traverse Identity = Identity
composition: traverse (Compose . fmap g . f) = Compose . fmap (traverse g) . traverse f

A definition of sequenceA must satisfy the following laws:

naturality: t . sequenceA = sequenceA . fmap t for every applicative transformation t
identity: sequenceA . fmap Identity = Identity
composition: sequenceA . fmap Compose = Compose . fmap sequenceA . sequenceA

where an applicative transformation is a function

t :: (Applicative f, Applicative g) => f a -> g a

preserving the Applicative operations, i.e.

```
t (pure x) = pure x
```
```
t (x <*> y) = t x <*> t y
```

and the identity functor Identity and composition of functors Compose are defined as

  newtype Identity a = Identity a

  instance Functor Identity where
    fmap f (Identity x) = Identity (f x)

  instance Applicative Identity where
    pure x = Identity x
    Identity f <*> Identity x = Identity (f x)

  newtype Compose f g a = Compose (f (g a))

  instance (Functor f, Functor g) => Functor (Compose f g) where
    fmap f (Compose x) = Compose (fmap (fmap f) x)

  instance (Applicative f, Applicative g) => Applicative (Compose f g) where
    pure x = Compose (pure (pure x))
    Compose f <*> Compose x = Compose ((<*>) <$> f <*> x)

(The naturality law is implied by parametricity.)

Instances are similar to Functor, e.g. given a data type

data Tree a = Empty | Leaf a | Node (Tree a) a (Tree a)

a suitable instance would be

instance Traversable Tree where
   traverse f Empty = pure Empty
   traverse f (Leaf x) = Leaf <$> f x
   traverse f (Node l k r) = Node <$> traverse f l <*> f k <*> traverse f r

This is suitable even for abstract types, as the laws for <*> imply a form of associativity.

The superclass instances should satisfy the following:

In the Functor instance, fmap should be equivalent to traversal with the identity applicative functor (fmapDefault).
In the Foldable instance, foldMap should be equivalent to traversal with a constant applicative functor (foldMapDefault).

Minimal complete definition

traverse | sequenceA

Methods

traverse :: Applicative f => (a -> f b) -> t a -> f (t b) #

Map each element of a structure to an action, evaluate these actions from left to right, and collect the results. For a version that ignores the results see traverse_.

Instances

Traversable []	Since: base-2.1
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> [a] -> f [b] # sequenceA :: Applicative f => [f a] -> f [a] # mapM :: Monad m => (a -> m b) -> [a] -> m [b] # sequence :: Monad m => [m a] -> m [a] #
Traversable Maybe	Since: base-2.1
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Maybe a -> f (Maybe b) # sequenceA :: Applicative f => Maybe (f a) -> f (Maybe a) # mapM :: Monad m => (a -> m b) -> Maybe a -> m (Maybe b) # sequence :: Monad m => Maybe (m a) -> m (Maybe a) #
Traversable Par1	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Par1 a -> f (Par1 b) # sequenceA :: Applicative f => Par1 (f a) -> f (Par1 a) # mapM :: Monad m => (a -> m b) -> Par1 a -> m (Par1 b) # sequence :: Monad m => Par1 (m a) -> m (Par1 a) #
Traversable Identity	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Identity a -> f (Identity b) # sequenceA :: Applicative f => Identity (f a) -> f (Identity a) # mapM :: Monad m => (a -> m b) -> Identity a -> m (Identity b) # sequence :: Monad m => Identity (m a) -> m (Identity a) #
Traversable ZipList	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> ZipList a -> f (ZipList b) # sequenceA :: Applicative f => ZipList (f a) -> f (ZipList a) # mapM :: Monad m => (a -> m b) -> ZipList a -> m (ZipList b) # sequence :: Monad m => ZipList (m a) -> m (ZipList a) #
Traversable IResult
Instance details Defined in Data.Aeson.Types.Internal Methods traverse :: Applicative f => (a -> f b) -> IResult a -> f (IResult b) # sequenceA :: Applicative f => IResult (f a) -> f (IResult a) # mapM :: Monad m => (a -> m b) -> IResult a -> m (IResult b) # sequence :: Monad m => IResult (m a) -> m (IResult a) #
Traversable Result
Instance details Defined in Data.Aeson.Types.Internal Methods traverse :: Applicative f => (a -> f b) -> Result a -> f (Result b) # sequenceA :: Applicative f => Result (f a) -> f (Result a) # mapM :: Monad m => (a -> m b) -> Result a -> m (Result b) # sequence :: Monad m => Result (m a) -> m (Result a) #
Traversable Complex	Since: base-4.9.0.0
Instance details Defined in Data.Complex Methods traverse :: Applicative f => (a -> f b) -> Complex a -> f (Complex b) # sequenceA :: Applicative f => Complex (f a) -> f (Complex a) # mapM :: Monad m => (a -> m b) -> Complex a -> m (Complex b) # sequence :: Monad m => Complex (m a) -> m (Complex a) #
Traversable Min	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods traverse :: Applicative f => (a -> f b) -> Min a -> f (Min b) # sequenceA :: Applicative f => Min (f a) -> f (Min a) # mapM :: Monad m => (a -> m b) -> Min a -> m (Min b) # sequence :: Monad m => Min (m a) -> m (Min a) #
Traversable Max	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods traverse :: Applicative f => (a -> f b) -> Max a -> f (Max b) # sequenceA :: Applicative f => Max (f a) -> f (Max a) # mapM :: Monad m => (a -> m b) -> Max a -> m (Max b) # sequence :: Monad m => Max (m a) -> m (Max a) #
Traversable First	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods traverse :: Applicative f => (a -> f b) -> First a -> f (First b) # sequenceA :: Applicative f => First (f a) -> f (First a) # mapM :: Monad m => (a -> m b) -> First a -> m (First b) # sequence :: Monad m => First (m a) -> m (First a) #
Traversable Last	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods traverse :: Applicative f => (a -> f b) -> Last a -> f (Last b) # sequenceA :: Applicative f => Last (f a) -> f (Last a) # mapM :: Monad m => (a -> m b) -> Last a -> m (Last b) # sequence :: Monad m => Last (m a) -> m (Last a) #
Traversable Option	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods traverse :: Applicative f => (a -> f b) -> Option a -> f (Option b) # sequenceA :: Applicative f => Option (f a) -> f (Option a) # mapM :: Monad m => (a -> m b) -> Option a -> m (Option b) # sequence :: Monad m => Option (m a) -> m (Option a) #
Traversable First	Since: base-4.8.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> First a -> f (First b) # sequenceA :: Applicative f => First (f a) -> f (First a) # mapM :: Monad m => (a -> m b) -> First a -> m (First b) # sequence :: Monad m => First (m a) -> m (First a) #
Traversable Last	Since: base-4.8.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Last a -> f (Last b) # sequenceA :: Applicative f => Last (f a) -> f (Last a) # mapM :: Monad m => (a -> m b) -> Last a -> m (Last b) # sequence :: Monad m => Last (m a) -> m (Last a) #
Traversable Dual	Since: base-4.8.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Dual a -> f (Dual b) # sequenceA :: Applicative f => Dual (f a) -> f (Dual a) # mapM :: Monad m => (a -> m b) -> Dual a -> m (Dual b) # sequence :: Monad m => Dual (m a) -> m (Dual a) #
Traversable Sum	Since: base-4.8.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Sum a -> f (Sum b) # sequenceA :: Applicative f => Sum (f a) -> f (Sum a) # mapM :: Monad m => (a -> m b) -> Sum a -> m (Sum b) # sequence :: Monad m => Sum (m a) -> m (Sum a) #
Traversable Product	Since: base-4.8.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Product a -> f (Product b) # sequenceA :: Applicative f => Product (f a) -> f (Product a) # mapM :: Monad m => (a -> m b) -> Product a -> m (Product b) # sequence :: Monad m => Product (m a) -> m (Product a) #
Traversable Down	Since: base-4.12.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Down a -> f (Down b) # sequenceA :: Applicative f => Down (f a) -> f (Down a) # mapM :: Monad m => (a -> m b) -> Down a -> m (Down b) # sequence :: Monad m => Down (m a) -> m (Down a) #
Traversable NonEmpty	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> NonEmpty a -> f (NonEmpty b) # sequenceA :: Applicative f => NonEmpty (f a) -> f (NonEmpty a) # mapM :: Monad m => (a -> m b) -> NonEmpty a -> m (NonEmpty b) # sequence :: Monad m => NonEmpty (m a) -> m (NonEmpty a) #
Traversable IntMap
Instance details Defined in Data.IntMap.Internal Methods traverse :: Applicative f => (a -> f b) -> IntMap a -> f (IntMap b) # sequenceA :: Applicative f => IntMap (f a) -> f (IntMap a) # mapM :: Monad m => (a -> m b) -> IntMap a -> m (IntMap b) # sequence :: Monad m => IntMap (m a) -> m (IntMap a) #
Traversable Tree
Instance details Defined in Data.Tree Methods traverse :: Applicative f => (a -> f b) -> Tree a -> f (Tree b) # sequenceA :: Applicative f => Tree (f a) -> f (Tree a) # mapM :: Monad m => (a -> m b) -> Tree a -> m (Tree b) # sequence :: Monad m => Tree (m a) -> m (Tree a) #
Traversable Seq
Instance details Defined in Data.Sequence.Internal Methods traverse :: Applicative f => (a -> f b) -> Seq a -> f (Seq b) # sequenceA :: Applicative f => Seq (f a) -> f (Seq a) # mapM :: Monad m => (a -> m b) -> Seq a -> m (Seq b) # sequence :: Monad m => Seq (m a) -> m (Seq a) #
Traversable FingerTree
Instance details Defined in Data.Sequence.Internal Methods traverse :: Applicative f => (a -> f b) -> FingerTree a -> f (FingerTree b) # sequenceA :: Applicative f => FingerTree (f a) -> f (FingerTree a) # mapM :: Monad m => (a -> m b) -> FingerTree a -> m (FingerTree b) # sequence :: Monad m => FingerTree (m a) -> m (FingerTree a) #
Traversable Digit
Instance details Defined in Data.Sequence.Internal Methods traverse :: Applicative f => (a -> f b) -> Digit a -> f (Digit b) # sequenceA :: Applicative f => Digit (f a) -> f (Digit a) # mapM :: Monad m => (a -> m b) -> Digit a -> m (Digit b) # sequence :: Monad m => Digit (m a) -> m (Digit a) #
Traversable Node
Instance details Defined in Data.Sequence.Internal Methods traverse :: Applicative f => (a -> f b) -> Node a -> f (Node b) # sequenceA :: Applicative f => Node (f a) -> f (Node a) # mapM :: Monad m => (a -> m b) -> Node a -> m (Node b) # sequence :: Monad m => Node (m a) -> m (Node a) #
Traversable Elem
Instance details Defined in Data.Sequence.Internal Methods traverse :: Applicative f => (a -> f b) -> Elem a -> f (Elem b) # sequenceA :: Applicative f => Elem (f a) -> f (Elem a) # mapM :: Monad m => (a -> m b) -> Elem a -> m (Elem b) # sequence :: Monad m => Elem (m a) -> m (Elem a) #
Traversable ViewL
Instance details Defined in Data.Sequence.Internal Methods traverse :: Applicative f => (a -> f b) -> ViewL a -> f (ViewL b) # sequenceA :: Applicative f => ViewL (f a) -> f (ViewL a) # mapM :: Monad m => (a -> m b) -> ViewL a -> m (ViewL b) # sequence :: Monad m => ViewL (m a) -> m (ViewL a) #
Traversable ViewR
Instance details Defined in Data.Sequence.Internal Methods traverse :: Applicative f => (a -> f b) -> ViewR a -> f (ViewR b) # sequenceA :: Applicative f => ViewR (f a) -> f (ViewR a) # mapM :: Monad m => (a -> m b) -> ViewR a -> m (ViewR b) # sequence :: Monad m => ViewR (m a) -> m (ViewR a) #
Traversable HistoriedResponse
Instance details Defined in Network.HTTP.Client Methods traverse :: Applicative f => (a -> f b) -> HistoriedResponse a -> f (HistoriedResponse b) # sequenceA :: Applicative f => HistoriedResponse (f a) -> f (HistoriedResponse a) # mapM :: Monad m => (a -> m b) -> HistoriedResponse a -> m (HistoriedResponse b) # sequence :: Monad m => HistoriedResponse (m a) -> m (HistoriedResponse a) #
Traversable Response
Instance details Defined in Network.HTTP.Client.Types Methods traverse :: Applicative f => (a -> f b) -> Response a -> f (Response b) # sequenceA :: Applicative f => Response (f a) -> f (Response a) # mapM :: Monad m => (a -> m b) -> Response a -> m (Response b) # sequence :: Monad m => Response (m a) -> m (Response a) #
Traversable Vector
Instance details Defined in Data.Vector Methods traverse :: Applicative f => (a -> f b) -> Vector a -> f (Vector b) # sequenceA :: Applicative f => Vector (f a) -> f (Vector a) # mapM :: Monad m => (a -> m b) -> Vector a -> m (Vector b) # sequence :: Monad m => Vector (m a) -> m (Vector a) #
Traversable Many
Instance details Defined in Text.Pandoc.Builder Methods traverse :: Applicative f => (a -> f b) -> Many a -> f (Many b) # sequenceA :: Applicative f => Many (f a) -> f (Many a) # mapM :: Monad m => (a -> m b) -> Many a -> m (Many b) # sequence :: Monad m => Many (m a) -> m (Many a) #
Traversable SmallArray
Instance details Defined in Data.Primitive.SmallArray Methods traverse :: Applicative f => (a -> f b) -> SmallArray a -> f (SmallArray b) # sequenceA :: Applicative f => SmallArray (f a) -> f (SmallArray a) # mapM :: Monad m => (a -> m b) -> SmallArray a -> m (SmallArray b) # sequence :: Monad m => SmallArray (m a) -> m (SmallArray a) #
Traversable Array
Instance details Defined in Data.Primitive.Array Methods traverse :: Applicative f => (a -> f b) -> Array a -> f (Array b) # sequenceA :: Applicative f => Array (f a) -> f (Array a) # mapM :: Monad m => (a -> m b) -> Array a -> m (Array b) # sequence :: Monad m => Array (m a) -> m (Array a) #
Traversable (Either a)	Since: base-4.7.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a0 -> f b) -> Either a a0 -> f (Either a b) # sequenceA :: Applicative f => Either a (f a0) -> f (Either a a0) # mapM :: Monad m => (a0 -> m b) -> Either a a0 -> m (Either a b) # sequence :: Monad m => Either a (m a0) -> m (Either a a0) #
Traversable (V1 :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> V1 a -> f (V1 b) # sequenceA :: Applicative f => V1 (f a) -> f (V1 a) # mapM :: Monad m => (a -> m b) -> V1 a -> m (V1 b) # sequence :: Monad m => V1 (m a) -> m (V1 a) #
Traversable (U1 :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> U1 a -> f (U1 b) # sequenceA :: Applicative f => U1 (f a) -> f (U1 a) # mapM :: Monad m => (a -> m b) -> U1 a -> m (U1 b) # sequence :: Monad m => U1 (m a) -> m (U1 a) #
Traversable ((,) a)	Since: base-4.7.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a0 -> f b) -> (a, a0) -> f (a, b) # sequenceA :: Applicative f => (a, f a0) -> f (a, a0) # mapM :: Monad m => (a0 -> m b) -> (a, a0) -> m (a, b) # sequence :: Monad m => (a, m a0) -> m (a, a0) #
Traversable (Map k)
Instance details Defined in Data.Map.Internal Methods traverse :: Applicative f => (a -> f b) -> Map k a -> f (Map k b) # sequenceA :: Applicative f => Map k (f a) -> f (Map k a) # mapM :: Monad m => (a -> m b) -> Map k a -> m (Map k b) # sequence :: Monad m => Map k (m a) -> m (Map k a) #
Traversable (HashMap k)
Instance details Defined in Data.HashMap.Base Methods traverse :: Applicative f => (a -> f b) -> HashMap k a -> f (HashMap k b) # sequenceA :: Applicative f => HashMap k (f a) -> f (HashMap k a) # mapM :: Monad m => (a -> m b) -> HashMap k a -> m (HashMap k b) # sequence :: Monad m => HashMap k (m a) -> m (HashMap k a) #
Ix i => Traversable (Array i)	Since: base-2.1
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Array i a -> f (Array i b) # sequenceA :: Applicative f => Array i (f a) -> f (Array i a) # mapM :: Monad m => (a -> m b) -> Array i a -> m (Array i b) # sequence :: Monad m => Array i (m a) -> m (Array i a) #
Traversable (Arg a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods traverse :: Applicative f => (a0 -> f b) -> Arg a a0 -> f (Arg a b) # sequenceA :: Applicative f => Arg a (f a0) -> f (Arg a a0) # mapM :: Monad m => (a0 -> m b) -> Arg a a0 -> m (Arg a b) # sequence :: Monad m => Arg a (m a0) -> m (Arg a a0) #
Traversable (Proxy :: Type -> Type)	Since: base-4.7.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Proxy a -> f (Proxy b) # sequenceA :: Applicative f => Proxy (f a) -> f (Proxy a) # mapM :: Monad m => (a -> m b) -> Proxy a -> m (Proxy b) # sequence :: Monad m => Proxy (m a) -> m (Proxy a) #
Traversable f => Traversable (MaybeT f)
Instance details Defined in Control.Monad.Trans.Maybe Methods traverse :: Applicative f0 => (a -> f0 b) -> MaybeT f a -> f0 (MaybeT f b) # sequenceA :: Applicative f0 => MaybeT f (f0 a) -> f0 (MaybeT f a) # mapM :: Monad m => (a -> m b) -> MaybeT f a -> m (MaybeT f b) # sequence :: Monad m => MaybeT f (m a) -> m (MaybeT f a) #
Traversable f => Traversable (Cofree f)
Instance details Defined in Control.Comonad.Cofree Methods traverse :: Applicative f0 => (a -> f0 b) -> Cofree f a -> f0 (Cofree f b) # sequenceA :: Applicative f0 => Cofree f (f0 a) -> f0 (Cofree f a) # mapM :: Monad m => (a -> m b) -> Cofree f a -> m (Cofree f b) # sequence :: Monad m => Cofree f (m a) -> m (Cofree f a) #
Traversable f => Traversable (Free f)
Instance details Defined in Control.Monad.Free Methods traverse :: Applicative f0 => (a -> f0 b) -> Free f a -> f0 (Free f b) # sequenceA :: Applicative f0 => Free f (f0 a) -> f0 (Free f a) # mapM :: Monad m => (a -> m b) -> Free f a -> m (Free f b) # sequence :: Monad m => Free f (m a) -> m (Free f a) #
Traversable f => Traversable (Yoneda f)
Instance details Defined in Data.Functor.Yoneda Methods traverse :: Applicative f0 => (a -> f0 b) -> Yoneda f a -> f0 (Yoneda f b) # sequenceA :: Applicative f0 => Yoneda f (f0 a) -> f0 (Yoneda f a) # mapM :: Monad m => (a -> m b) -> Yoneda f a -> m (Yoneda f b) # sequence :: Monad m => Yoneda f (m a) -> m (Yoneda f a) #
Traversable (Level i)
Instance details Defined in Control.Lens.Internal.Level Methods traverse :: Applicative f => (a -> f b) -> Level i a -> f (Level i b) # sequenceA :: Applicative f => Level i (f a) -> f (Level i a) # mapM :: Monad m => (a -> m b) -> Level i a -> m (Level i b) # sequence :: Monad m => Level i (m a) -> m (Level i a) #
Traversable f => Traversable (ListT f)
Instance details Defined in Control.Monad.Trans.List Methods traverse :: Applicative f0 => (a -> f0 b) -> ListT f a -> f0 (ListT f b) # sequenceA :: Applicative f0 => ListT f (f0 a) -> f0 (ListT f a) # mapM :: Monad m => (a -> m b) -> ListT f a -> m (ListT f b) # sequence :: Monad m => ListT f (m a) -> m (ListT f a) #
Traversable f => Traversable (Rec1 f)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f0 => (a -> f0 b) -> Rec1 f a -> f0 (Rec1 f b) # sequenceA :: Applicative f0 => Rec1 f (f0 a) -> f0 (Rec1 f a) # mapM :: Monad m => (a -> m b) -> Rec1 f a -> m (Rec1 f b) # sequence :: Monad m => Rec1 f (m a) -> m (Rec1 f a) #
Traversable (URec Char :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> URec Char a -> f (URec Char b) # sequenceA :: Applicative f => URec Char (f a) -> f (URec Char a) # mapM :: Monad m => (a -> m b) -> URec Char a -> m (URec Char b) # sequence :: Monad m => URec Char (m a) -> m (URec Char a) #
Traversable (URec Double :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> URec Double a -> f (URec Double b) # sequenceA :: Applicative f => URec Double (f a) -> f (URec Double a) # mapM :: Monad m => (a -> m b) -> URec Double a -> m (URec Double b) # sequence :: Monad m => URec Double (m a) -> m (URec Double a) #
Traversable (URec Float :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> URec Float a -> f (URec Float b) # sequenceA :: Applicative f => URec Float (f a) -> f (URec Float a) # mapM :: Monad m => (a -> m b) -> URec Float a -> m (URec Float b) # sequence :: Monad m => URec Float (m a) -> m (URec Float a) #
Traversable (URec Int :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> URec Int a -> f (URec Int b) # sequenceA :: Applicative f => URec Int (f a) -> f (URec Int a) # mapM :: Monad m => (a -> m b) -> URec Int a -> m (URec Int b) # sequence :: Monad m => URec Int (m a) -> m (URec Int a) #
Traversable (URec Word :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> URec Word a -> f (URec Word b) # sequenceA :: Applicative f => URec Word (f a) -> f (URec Word a) # mapM :: Monad m => (a -> m b) -> URec Word a -> m (URec Word b) # sequence :: Monad m => URec Word (m a) -> m (URec Word a) #
Traversable (URec (Ptr ()) :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> URec (Ptr ()) a -> f (URec (Ptr ()) b) # sequenceA :: Applicative f => URec (Ptr ()) (f a) -> f (URec (Ptr ()) a) # mapM :: Monad m => (a -> m b) -> URec (Ptr ()) a -> m (URec (Ptr ()) b) # sequence :: Monad m => URec (Ptr ()) (m a) -> m (URec (Ptr ()) a) #
Traversable f => Traversable (IdentityT f)
Instance details Defined in Control.Monad.Trans.Identity Methods traverse :: Applicative f0 => (a -> f0 b) -> IdentityT f a -> f0 (IdentityT f b) # sequenceA :: Applicative f0 => IdentityT f (f0 a) -> f0 (IdentityT f a) # mapM :: Monad m => (a -> m b) -> IdentityT f a -> m (IdentityT f b) # sequence :: Monad m => IdentityT f (m a) -> m (IdentityT f a) #
Traversable (Const m :: Type -> Type)	Since: base-4.7.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Const m a -> f (Const m b) # sequenceA :: Applicative f => Const m (f a) -> f (Const m a) # mapM :: Monad m0 => (a -> m0 b) -> Const m a -> m0 (Const m b) # sequence :: Monad m0 => Const m (m0 a) -> m0 (Const m a) #
Traversable f => Traversable (Ap f)	Since: base-4.12.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f0 => (a -> f0 b) -> Ap f a -> f0 (Ap f b) # sequenceA :: Applicative f0 => Ap f (f0 a) -> f0 (Ap f a) # mapM :: Monad m => (a -> m b) -> Ap f a -> m (Ap f b) # sequence :: Monad m => Ap f (m a) -> m (Ap f a) #
Traversable f => Traversable (Alt f)	Since: base-4.12.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f0 => (a -> f0 b) -> Alt f a -> f0 (Alt f b) # sequenceA :: Applicative f0 => Alt f (f0 a) -> f0 (Alt f a) # mapM :: Monad m => (a -> m b) -> Alt f a -> m (Alt f b) # sequence :: Monad m => Alt f (m a) -> m (Alt f a) #
Bitraversable p => Traversable (Join p)
Instance details Defined in Data.Bifunctor.Join Methods traverse :: Applicative f => (a -> f b) -> Join p a -> f (Join p b) # sequenceA :: Applicative f => Join p (f a) -> f (Join p a) # mapM :: Monad m => (a -> m b) -> Join p a -> m (Join p b) # sequence :: Monad m => Join p (m a) -> m (Join p a) #
Bitraversable p => Traversable (Fix p)
Instance details Defined in Data.Bifunctor.Fix Methods traverse :: Applicative f => (a -> f b) -> Fix p a -> f (Fix p b) # sequenceA :: Applicative f => Fix p (f a) -> f (Fix p a) # mapM :: Monad m => (a -> m b) -> Fix p a -> m (Fix p b) # sequence :: Monad m => Fix p (m a) -> m (Fix p a) #
Traversable f => Traversable (WriterT w f)
Instance details Defined in Control.Monad.Trans.Writer.Strict Methods traverse :: Applicative f0 => (a -> f0 b) -> WriterT w f a -> f0 (WriterT w f b) # sequenceA :: Applicative f0 => WriterT w f (f0 a) -> f0 (WriterT w f a) # mapM :: Monad m => (a -> m b) -> WriterT w f a -> m (WriterT w f b) # sequence :: Monad m => WriterT w f (m a) -> m (WriterT w f a) #
Traversable f => Traversable (WriterT w f)
Instance details Defined in Control.Monad.Trans.Writer.Lazy Methods traverse :: Applicative f0 => (a -> f0 b) -> WriterT w f a -> f0 (WriterT w f b) # sequenceA :: Applicative f0 => WriterT w f (f0 a) -> f0 (WriterT w f a) # mapM :: Monad m => (a -> m b) -> WriterT w f a -> m (WriterT w f b) # sequence :: Monad m => WriterT w f (m a) -> m (WriterT w f a) #
Traversable f => Traversable (ExceptT e f)
Instance details Defined in Control.Monad.Trans.Except Methods traverse :: Applicative f0 => (a -> f0 b) -> ExceptT e f a -> f0 (ExceptT e f b) # sequenceA :: Applicative f0 => ExceptT e f (f0 a) -> f0 (ExceptT e f a) # mapM :: Monad m => (a -> m b) -> ExceptT e f a -> m (ExceptT e f b) # sequence :: Monad m => ExceptT e f (m a) -> m (ExceptT e f a) #
Traversable f => Traversable (FreeF f a)
Instance details Defined in Control.Monad.Trans.Free Methods traverse :: Applicative f0 => (a0 -> f0 b) -> FreeF f a a0 -> f0 (FreeF f a b) # sequenceA :: Applicative f0 => FreeF f a (f0 a0) -> f0 (FreeF f a a0) # mapM :: Monad m => (a0 -> m b) -> FreeF f a a0 -> m (FreeF f a b) # sequence :: Monad m => FreeF f a (m a0) -> m (FreeF f a a0) #
(Monad m, Traversable m, Traversable f) => Traversable (FreeT f m)
Instance details Defined in Control.Monad.Trans.Free Methods traverse :: Applicative f0 => (a -> f0 b) -> FreeT f m a -> f0 (FreeT f m b) # sequenceA :: Applicative f0 => FreeT f m (f0 a) -> f0 (FreeT f m a) # mapM :: Monad m0 => (a -> m0 b) -> FreeT f m a -> m0 (FreeT f m b) # sequence :: Monad m0 => FreeT f m (m0 a) -> m0 (FreeT f m a) #
Traversable f => Traversable (CofreeF f a)
Instance details Defined in Control.Comonad.Trans.Cofree Methods traverse :: Applicative f0 => (a0 -> f0 b) -> CofreeF f a a0 -> f0 (CofreeF f a b) # sequenceA :: Applicative f0 => CofreeF f a (f0 a0) -> f0 (CofreeF f a a0) # mapM :: Monad m => (a0 -> m b) -> CofreeF f a a0 -> m (CofreeF f a b) # sequence :: Monad m => CofreeF f a (m a0) -> m (CofreeF f a a0) #
(Traversable f, Traversable w) => Traversable (CofreeT f w)
Instance details Defined in Control.Comonad.Trans.Cofree Methods traverse :: Applicative f0 => (a -> f0 b) -> CofreeT f w a -> f0 (CofreeT f w b) # sequenceA :: Applicative f0 => CofreeT f w (f0 a) -> f0 (CofreeT f w a) # mapM :: Monad m => (a -> m b) -> CofreeT f w a -> m (CofreeT f w b) # sequence :: Monad m => CofreeT f w (m a) -> m (CofreeT f w a) #
Traversable f => Traversable (ErrorT e f)
Instance details Defined in Control.Monad.Trans.Error Methods traverse :: Applicative f0 => (a -> f0 b) -> ErrorT e f a -> f0 (ErrorT e f b) # sequenceA :: Applicative f0 => ErrorT e f (f0 a) -> f0 (ErrorT e f a) # mapM :: Monad m => (a -> m b) -> ErrorT e f a -> m (ErrorT e f b) # sequence :: Monad m => ErrorT e f (m a) -> m (ErrorT e f a) #
Traversable f => Traversable (Backwards f)	Derived instance.
Instance details Defined in Control.Applicative.Backwards Methods traverse :: Applicative f0 => (a -> f0 b) -> Backwards f a -> f0 (Backwards f b) # sequenceA :: Applicative f0 => Backwards f (f0 a) -> f0 (Backwards f a) # mapM :: Monad m => (a -> m b) -> Backwards f a -> m (Backwards f b) # sequence :: Monad m => Backwards f (m a) -> m (Backwards f a) #
Traversable f => Traversable (AlongsideLeft f b)
Instance details Defined in Control.Lens.Internal.Getter Methods traverse :: Applicative f0 => (a -> f0 b0) -> AlongsideLeft f b a -> f0 (AlongsideLeft f b b0) # sequenceA :: Applicative f0 => AlongsideLeft f b (f0 a) -> f0 (AlongsideLeft f b a) # mapM :: Monad m => (a -> m b0) -> AlongsideLeft f b a -> m (AlongsideLeft f b b0) # sequence :: Monad m => AlongsideLeft f b (m a) -> m (AlongsideLeft f b a) #
Traversable f => Traversable (AlongsideRight f a)
Instance details Defined in Control.Lens.Internal.Getter Methods traverse :: Applicative f0 => (a0 -> f0 b) -> AlongsideRight f a a0 -> f0 (AlongsideRight f a b) # sequenceA :: Applicative f0 => AlongsideRight f a (f0 a0) -> f0 (AlongsideRight f a a0) # mapM :: Monad m => (a0 -> m b) -> AlongsideRight f a a0 -> m (AlongsideRight f a b) # sequence :: Monad m => AlongsideRight f a (m a0) -> m (AlongsideRight f a a0) #
Traversable (Forget r a)
Instance details Defined in Data.Profunctor.Types Methods traverse :: Applicative f => (a0 -> f b) -> Forget r a a0 -> f (Forget r a b) # sequenceA :: Applicative f => Forget r a (f a0) -> f (Forget r a a0) # mapM :: Monad m => (a0 -> m b) -> Forget r a a0 -> m (Forget r a b) # sequence :: Monad m => Forget r a (m a0) -> m (Forget r a a0) #
Traversable (Tagged s)
Instance details Defined in Data.Tagged Methods traverse :: Applicative f => (a -> f b) -> Tagged s a -> f (Tagged s b) # sequenceA :: Applicative f => Tagged s (f a) -> f (Tagged s a) # mapM :: Monad m => (a -> m b) -> Tagged s a -> m (Tagged s b) # sequence :: Monad m => Tagged s (m a) -> m (Tagged s a) #
Traversable (K1 i c :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> K1 i c a -> f (K1 i c b) # sequenceA :: Applicative f => K1 i c (f a) -> f (K1 i c a) # mapM :: Monad m => (a -> m b) -> K1 i c a -> m (K1 i c b) # sequence :: Monad m => K1 i c (m a) -> m (K1 i c a) #
(Traversable f, Traversable g) => Traversable (f :+: g)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f0 => (a -> f0 b) -> (f :+: g) a -> f0 ((f :+: g) b) # sequenceA :: Applicative f0 => (f :+: g) (f0 a) -> f0 ((f :+: g) a) # mapM :: Monad m => (a -> m b) -> (f :+: g) a -> m ((f :+: g) b) # sequence :: Monad m => (f :+: g) (m a) -> m ((f :+: g) a) #
(Traversable f, Traversable g) => Traversable (f :*: g)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f0 => (a -> f0 b) -> (f :: g) a -> f0 ((f :: g) b) # sequenceA :: Applicative f0 => (f :: g) (f0 a) -> f0 ((f :: g) a) # mapM :: Monad m => (a -> m b) -> (f :: g) a -> m ((f :: g) b) # sequence :: Monad m => (f :: g) (m a) -> m ((f :: g) a) #
(Traversable f, Traversable g) => Traversable (Product f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Product Methods traverse :: Applicative f0 => (a -> f0 b) -> Product f g a -> f0 (Product f g b) # sequenceA :: Applicative f0 => Product f g (f0 a) -> f0 (Product f g a) # mapM :: Monad m => (a -> m b) -> Product f g a -> m (Product f g b) # sequence :: Monad m => Product f g (m a) -> m (Product f g a) #
(Traversable f, Traversable g) => Traversable (Sum f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Sum Methods traverse :: Applicative f0 => (a -> f0 b) -> Sum f g a -> f0 (Sum f g b) # sequenceA :: Applicative f0 => Sum f g (f0 a) -> f0 (Sum f g a) # mapM :: Monad m => (a -> m b) -> Sum f g a -> m (Sum f g b) # sequence :: Monad m => Sum f g (m a) -> m (Sum f g a) #
Traversable (Magma i t b)
Instance details Defined in Control.Lens.Internal.Magma Methods traverse :: Applicative f => (a -> f b0) -> Magma i t b a -> f (Magma i t b b0) # sequenceA :: Applicative f => Magma i t b (f a) -> f (Magma i t b a) # mapM :: Monad m => (a -> m b0) -> Magma i t b a -> m (Magma i t b b0) # sequence :: Monad m => Magma i t b (m a) -> m (Magma i t b a) #
Traversable f => Traversable (M1 i c f)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f0 => (a -> f0 b) -> M1 i c f a -> f0 (M1 i c f b) # sequenceA :: Applicative f0 => M1 i c f (f0 a) -> f0 (M1 i c f a) # mapM :: Monad m => (a -> m b) -> M1 i c f a -> m (M1 i c f b) # sequence :: Monad m => M1 i c f (m a) -> m (M1 i c f a) #
(Traversable f, Traversable g) => Traversable (f :.: g)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f0 => (a -> f0 b) -> (f :.: g) a -> f0 ((f :.: g) b) # sequenceA :: Applicative f0 => (f :.: g) (f0 a) -> f0 ((f :.: g) a) # mapM :: Monad m => (a -> m b) -> (f :.: g) a -> m ((f :.: g) b) # sequence :: Monad m => (f :.: g) (m a) -> m ((f :.: g) a) #
(Traversable f, Traversable g) => Traversable (Compose f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose Methods traverse :: Applicative f0 => (a -> f0 b) -> Compose f g a -> f0 (Compose f g b) # sequenceA :: Applicative f0 => Compose f g (f0 a) -> f0 (Compose f g a) # mapM :: Monad m => (a -> m b) -> Compose f g a -> m (Compose f g b) # sequence :: Monad m => Compose f g (m a) -> m (Compose f g a) #
Bitraversable p => Traversable (WrappedBifunctor p a)
Instance details Defined in Data.Bifunctor.Wrapped Methods traverse :: Applicative f => (a0 -> f b) -> WrappedBifunctor p a a0 -> f (WrappedBifunctor p a b) # sequenceA :: Applicative f => WrappedBifunctor p a (f a0) -> f (WrappedBifunctor p a a0) # mapM :: Monad m => (a0 -> m b) -> WrappedBifunctor p a a0 -> m (WrappedBifunctor p a b) # sequence :: Monad m => WrappedBifunctor p a (m a0) -> m (WrappedBifunctor p a a0) #
Traversable g => Traversable (Joker g a)
Instance details Defined in Data.Bifunctor.Joker Methods traverse :: Applicative f => (a0 -> f b) -> Joker g a a0 -> f (Joker g a b) # sequenceA :: Applicative f => Joker g a (f a0) -> f (Joker g a a0) # mapM :: Monad m => (a0 -> m b) -> Joker g a a0 -> m (Joker g a b) # sequence :: Monad m => Joker g a (m a0) -> m (Joker g a a0) #
Bitraversable p => Traversable (Flip p a)
Instance details Defined in Data.Bifunctor.Flip Methods traverse :: Applicative f => (a0 -> f b) -> Flip p a a0 -> f (Flip p a b) # sequenceA :: Applicative f => Flip p a (f a0) -> f (Flip p a a0) # mapM :: Monad m => (a0 -> m b) -> Flip p a a0 -> m (Flip p a b) # sequence :: Monad m => Flip p a (m a0) -> m (Flip p a a0) #
Traversable (Clown f a :: Type -> Type)
Instance details Defined in Data.Bifunctor.Clown Methods traverse :: Applicative f0 => (a0 -> f0 b) -> Clown f a a0 -> f0 (Clown f a b) # sequenceA :: Applicative f0 => Clown f a (f0 a0) -> f0 (Clown f a a0) # mapM :: Monad m => (a0 -> m b) -> Clown f a a0 -> m (Clown f a b) # sequence :: Monad m => Clown f a (m a0) -> m (Clown f a a0) #
(Traversable f, Bitraversable p) => Traversable (Tannen f p a)
Instance details Defined in Data.Bifunctor.Tannen Methods traverse :: Applicative f0 => (a0 -> f0 b) -> Tannen f p a a0 -> f0 (Tannen f p a b) # sequenceA :: Applicative f0 => Tannen f p a (f0 a0) -> f0 (Tannen f p a a0) # mapM :: Monad m => (a0 -> m b) -> Tannen f p a a0 -> m (Tannen f p a b) # sequence :: Monad m => Tannen f p a (m a0) -> m (Tannen f p a a0) #
(Bitraversable p, Traversable g) => Traversable (Biff p f g a)
Instance details Defined in Data.Bifunctor.Biff Methods traverse :: Applicative f0 => (a0 -> f0 b) -> Biff p f g a a0 -> f0 (Biff p f g a b) # sequenceA :: Applicative f0 => Biff p f g a (f0 a0) -> f0 (Biff p f g a a0) # mapM :: Monad m => (a0 -> m b) -> Biff p f g a a0 -> m (Biff p f g a b) # sequence :: Monad m => Biff p f g a (m a0) -> m (Biff p f g a a0) #

type FilePath = String #

File and directory names are values of type String, whose precise meaning is operating system dependent. Files can be opened, yielding a handle which can then be used to operate on the contents of that file.

newtype Const a (b :: k) :: forall k. Type -> k -> Type #

The Const functor.

Constructors

Const
Fields getConst :: a

Instances

Generic1 (Const a :: k -> Type)
Instance details Defined in Data.Functor.Const Associated Types type Rep1 (Const a) :: k -> Type # Methods from1 :: Const a a0 -> Rep1 (Const a) a0 # to1 :: Rep1 (Const a) a0 -> Const a a0 #
ToJSON2 (Const :: Type -> Type -> Type)
Instance details Defined in Data.Aeson.Types.ToJSON Methods liftToJSON2 :: (a -> Value) -> ([a] -> Value) -> (b -> Value) -> ([b] -> Value) -> Const a b -> Value # liftToJSONList2 :: (a -> Value) -> ([a] -> Value) -> (b -> Value) -> ([b] -> Value) -> [Const a b] -> Value # liftToEncoding2 :: (a -> Encoding) -> ([a] -> Encoding) -> (b -> Encoding) -> ([b] -> Encoding) -> Const a b -> Encoding # liftToEncodingList2 :: (a -> Encoding) -> ([a] -> Encoding) -> (b -> Encoding) -> ([b] -> Encoding) -> [Const a b] -> Encoding #
FromJSON2 (Const :: Type -> Type -> Type)
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON2 :: (Value -> Parser a) -> (Value -> Parser [a]) -> (Value -> Parser b) -> (Value -> Parser [b]) -> Value -> Parser (Const a b) # liftParseJSONList2 :: (Value -> Parser a) -> (Value -> Parser [a]) -> (Value -> Parser b) -> (Value -> Parser [b]) -> Value -> Parser [Const a b] #
Bitraversable (Const :: Type -> Type -> Type)	Since: base-4.10.0.0
Instance details Defined in Data.Bitraversable Methods bitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> Const a b -> f (Const c d) #
Bifunctor (Const :: Type -> Type -> Type)	Since: base-4.8.0.0
Instance details Defined in Data.Bifunctor Methods bimap :: (a -> b) -> (c -> d) -> Const a c -> Const b d # first :: (a -> b) -> Const a c -> Const b c # second :: (b -> c) -> Const a b -> Const a c #
Eq2 (Const :: Type -> Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Classes Methods liftEq2 :: (a -> b -> Bool) -> (c -> d -> Bool) -> Const a c -> Const b d -> Bool #
Ord2 (Const :: Type -> Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Classes Methods liftCompare2 :: (a -> b -> Ordering) -> (c -> d -> Ordering) -> Const a c -> Const b d -> Ordering #
Read2 (Const :: Type -> Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Classes Methods liftReadsPrec2 :: (Int -> ReadS a) -> ReadS [a] -> (Int -> ReadS b) -> ReadS [b] -> Int -> ReadS (Const a b) # liftReadList2 :: (Int -> ReadS a) -> ReadS [a] -> (Int -> ReadS b) -> ReadS [b] -> ReadS [Const a b] # liftReadPrec2 :: ReadPrec a -> ReadPrec [a] -> ReadPrec b -> ReadPrec [b] -> ReadPrec (Const a b) # liftReadListPrec2 :: ReadPrec a -> ReadPrec [a] -> ReadPrec b -> ReadPrec [b] -> ReadPrec [Const a b] #
Show2 (Const :: Type -> Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Classes Methods liftShowsPrec2 :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> (Int -> b -> ShowS) -> ([b] -> ShowS) -> Int -> Const a b -> ShowS # liftShowList2 :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> (Int -> b -> ShowS) -> ([b] -> ShowS) -> [Const a b] -> ShowS #
Biapplicative (Const :: Type -> Type -> Type)
Instance details Defined in Data.Biapplicative Methods bipure :: a -> b -> Const a b # (<<>>) :: Const (a -> b) (c -> d) -> Const a c -> Const b d # biliftA2 :: (a -> b -> c) -> (d -> e -> f) -> Const a d -> Const b e -> Const c f # (>>) :: Const a b -> Const c d -> Const c d # (<<*) :: Const a b -> Const c d -> Const a b #
Hashable2 (Const :: Type -> Type -> Type)
Instance details Defined in Data.Hashable.Class Methods liftHashWithSalt2 :: (Int -> a -> Int) -> (Int -> b -> Int) -> Int -> Const a b -> Int #
Bitraversable1 (Const :: Type -> Type -> Type)
Instance details Defined in Data.Semigroup.Traversable.Class Methods bitraverse1 :: Apply f => (a -> f b) -> (c -> f d) -> Const a c -> f (Const b d) # bisequence1 :: Apply f => Const (f a) (f b) -> f (Const a b) #
Biapply (Const :: Type -> Type -> Type)
Instance details Defined in Data.Functor.Bind.Class Methods (<<.>>) :: Const (a -> b) (c -> d) -> Const a c -> Const b d # (.>>) :: Const a b -> Const c d -> Const c d # (<<.) :: Const a b -> Const c d -> Const a b #
Functor (Const m :: Type -> Type)	Since: base-2.1
Instance details Defined in Data.Functor.Const Methods fmap :: (a -> b) -> Const m a -> Const m b # (<$) :: a -> Const m b -> Const m a #
Monoid m => Applicative (Const m :: Type -> Type)	Since: base-2.0.1
Instance details Defined in Data.Functor.Const Methods pure :: a -> Const m a # (<>) :: Const m (a -> b) -> Const m a -> Const m b # liftA2 :: (a -> b -> c) -> Const m a -> Const m b -> Const m c # (>) :: Const m a -> Const m b -> Const m b # (<*) :: Const m a -> Const m b -> Const m a #
Foldable (Const m :: Type -> Type)	Since: base-4.7.0.0
Instance details Defined in Data.Functor.Const Methods fold :: Monoid m0 => Const m m0 -> m0 # foldMap :: Monoid m0 => (a -> m0) -> Const m a -> m0 # foldr :: (a -> b -> b) -> b -> Const m a -> b # foldr' :: (a -> b -> b) -> b -> Const m a -> b # foldl :: (b -> a -> b) -> b -> Const m a -> b # foldl' :: (b -> a -> b) -> b -> Const m a -> b # foldr1 :: (a -> a -> a) -> Const m a -> a # foldl1 :: (a -> a -> a) -> Const m a -> a # toList :: Const m a -> [a] # null :: Const m a -> Bool # length :: Const m a -> Int # elem :: Eq a => a -> Const m a -> Bool # maximum :: Ord a => Const m a -> a # minimum :: Ord a => Const m a -> a # sum :: Num a => Const m a -> a # product :: Num a => Const m a -> a #
Traversable (Const m :: Type -> Type)	Since: base-4.7.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Const m a -> f (Const m b) # sequenceA :: Applicative f => Const m (f a) -> f (Const m a) # mapM :: Monad m0 => (a -> m0 b) -> Const m a -> m0 (Const m b) # sequence :: Monad m0 => Const m (m0 a) -> m0 (Const m a) #
Contravariant (Const a :: Type -> Type)
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a0 -> b) -> Const a b -> Const a a0 # (>$) :: b -> Const a b -> Const a a0 #
ToJSON a => ToJSON1 (Const a :: Type -> Type)
Instance details Defined in Data.Aeson.Types.ToJSON Methods liftToJSON :: (a0 -> Value) -> ([a0] -> Value) -> Const a a0 -> Value # liftToJSONList :: (a0 -> Value) -> ([a0] -> Value) -> [Const a a0] -> Value # liftToEncoding :: (a0 -> Encoding) -> ([a0] -> Encoding) -> Const a a0 -> Encoding # liftToEncodingList :: (a0 -> Encoding) -> ([a0] -> Encoding) -> [Const a a0] -> Encoding #
FromJSON a => FromJSON1 (Const a :: Type -> Type)
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> Value -> Parser (Const a a0) # liftParseJSONList :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> Value -> Parser [Const a a0] #
Eq a => Eq1 (Const a :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Classes Methods liftEq :: (a0 -> b -> Bool) -> Const a a0 -> Const a b -> Bool #
Ord a => Ord1 (Const a :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Classes Methods liftCompare :: (a0 -> b -> Ordering) -> Const a a0 -> Const a b -> Ordering #
Read a => Read1 (Const a :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Classes Methods liftReadsPrec :: (Int -> ReadS a0) -> ReadS [a0] -> Int -> ReadS (Const a a0) # liftReadList :: (Int -> ReadS a0) -> ReadS [a0] -> ReadS [Const a a0] # liftReadPrec :: ReadPrec a0 -> ReadPrec [a0] -> ReadPrec (Const a a0) # liftReadListPrec :: ReadPrec a0 -> ReadPrec [a0] -> ReadPrec [Const a a0] #
Show a => Show1 (Const a :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Classes Methods liftShowsPrec :: (Int -> a0 -> ShowS) -> ([a0] -> ShowS) -> Int -> Const a a0 -> ShowS # liftShowList :: (Int -> a0 -> ShowS) -> ([a0] -> ShowS) -> [Const a a0] -> ShowS #
Hashable a => Hashable1 (Const a :: Type -> Type)
Instance details Defined in Data.Hashable.Class Methods liftHashWithSalt :: (Int -> a0 -> Int) -> Int -> Const a a0 -> Int #
Semigroup m => Apply (Const m :: Type -> Type)
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: Const m (a -> b) -> Const m a -> Const m b # (.>) :: Const m a -> Const m b -> Const m b # (<.) :: Const m a -> Const m b -> Const m a # liftF2 :: (a -> b -> c) -> Const m a -> Const m b -> Const m c #
Bounded a => Bounded (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods minBound :: Const a b # maxBound :: Const a b #
Enum a => Enum (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods succ :: Const a b -> Const a b # pred :: Const a b -> Const a b # toEnum :: Int -> Const a b # fromEnum :: Const a b -> Int # enumFrom :: Const a b -> [Const a b] # enumFromThen :: Const a b -> Const a b -> [Const a b] # enumFromTo :: Const a b -> Const a b -> [Const a b] # enumFromThenTo :: Const a b -> Const a b -> Const a b -> [Const a b] #
Eq a => Eq (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods (==) :: Const a b -> Const a b -> Bool # (/=) :: Const a b -> Const a b -> Bool #
Floating a => Floating (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods pi :: Const a b # exp :: Const a b -> Const a b # log :: Const a b -> Const a b # sqrt :: Const a b -> Const a b # (**) :: Const a b -> Const a b -> Const a b # logBase :: Const a b -> Const a b -> Const a b # sin :: Const a b -> Const a b # cos :: Const a b -> Const a b # tan :: Const a b -> Const a b # asin :: Const a b -> Const a b # acos :: Const a b -> Const a b # atan :: Const a b -> Const a b # sinh :: Const a b -> Const a b # cosh :: Const a b -> Const a b # tanh :: Const a b -> Const a b # asinh :: Const a b -> Const a b # acosh :: Const a b -> Const a b # atanh :: Const a b -> Const a b # log1p :: Const a b -> Const a b # expm1 :: Const a b -> Const a b # log1pexp :: Const a b -> Const a b # log1mexp :: Const a b -> Const a b #
Fractional a => Fractional (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods (/) :: Const a b -> Const a b -> Const a b # recip :: Const a b -> Const a b # fromRational :: Rational -> Const a b #
Integral a => Integral (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods quot :: Const a b -> Const a b -> Const a b # rem :: Const a b -> Const a b -> Const a b # div :: Const a b -> Const a b -> Const a b # mod :: Const a b -> Const a b -> Const a b # quotRem :: Const a b -> Const a b -> (Const a b, Const a b) # divMod :: Const a b -> Const a b -> (Const a b, Const a b) # toInteger :: Const a b -> Integer #
Num a => Num (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods (+) :: Const a b -> Const a b -> Const a b # (-) :: Const a b -> Const a b -> Const a b # (*) :: Const a b -> Const a b -> Const a b # negate :: Const a b -> Const a b # abs :: Const a b -> Const a b # signum :: Const a b -> Const a b # fromInteger :: Integer -> Const a b #
Ord a => Ord (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods compare :: Const a b -> Const a b -> Ordering # (<) :: Const a b -> Const a b -> Bool # (<=) :: Const a b -> Const a b -> Bool # (>) :: Const a b -> Const a b -> Bool # (>=) :: Const a b -> Const a b -> Bool # max :: Const a b -> Const a b -> Const a b # min :: Const a b -> Const a b -> Const a b #
Read a => Read (Const a b)	This instance would be equivalent to the derived instances of the `Const` newtype if the `runConst` field were removed Since: base-4.8.0.0
Instance details Defined in Data.Functor.Const Methods readsPrec :: Int -> ReadS (Const a b) # readList :: ReadS [Const a b] # readPrec :: ReadPrec (Const a b) # readListPrec :: ReadPrec [Const a b] #
Real a => Real (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods toRational :: Const a b -> Rational #
RealFloat a => RealFloat (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods floatRadix :: Const a b -> Integer # floatDigits :: Const a b -> Int # floatRange :: Const a b -> (Int, Int) # decodeFloat :: Const a b -> (Integer, Int) # encodeFloat :: Integer -> Int -> Const a b # exponent :: Const a b -> Int # significand :: Const a b -> Const a b # scaleFloat :: Int -> Const a b -> Const a b # isNaN :: Const a b -> Bool # isInfinite :: Const a b -> Bool # isDenormalized :: Const a b -> Bool # isNegativeZero :: Const a b -> Bool # isIEEE :: Const a b -> Bool # atan2 :: Const a b -> Const a b -> Const a b #
RealFrac a => RealFrac (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods properFraction :: Integral b0 => Const a b -> (b0, Const a b) # truncate :: Integral b0 => Const a b -> b0 # round :: Integral b0 => Const a b -> b0 # ceiling :: Integral b0 => Const a b -> b0 # floor :: Integral b0 => Const a b -> b0 #
Show a => Show (Const a b)	This instance would be equivalent to the derived instances of the `Const` newtype if the `runConst` field were removed Since: base-4.8.0.0
Instance details Defined in Data.Functor.Const Methods showsPrec :: Int -> Const a b -> ShowS # show :: Const a b -> String # showList :: [Const a b] -> ShowS #
Ix a => Ix (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods range :: (Const a b, Const a b) -> [Const a b] # index :: (Const a b, Const a b) -> Const a b -> Int # unsafeIndex :: (Const a b, Const a b) -> Const a b -> Int inRange :: (Const a b, Const a b) -> Const a b -> Bool # rangeSize :: (Const a b, Const a b) -> Int # unsafeRangeSize :: (Const a b, Const a b) -> Int
IsString a => IsString (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.String Methods fromString :: String -> Const a b #
Generic (Const a b)
Instance details Defined in Data.Functor.Const Associated Types type Rep (Const a b) :: Type -> Type # Methods from :: Const a b -> Rep (Const a b) x # to :: Rep (Const a b) x -> Const a b #
Semigroup a => Semigroup (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods (<>) :: Const a b -> Const a b -> Const a b # sconcat :: NonEmpty (Const a b) -> Const a b # stimes :: Integral b0 => b0 -> Const a b -> Const a b #
Monoid a => Monoid (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods mempty :: Const a b # mappend :: Const a b -> Const a b -> Const a b # mconcat :: [Const a b] -> Const a b #
Hashable a => Hashable (Const a b)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Const a b -> Int # hash :: Const a b -> Int #
ToJSON a => ToJSON (Const a b)
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Const a b -> Value # toEncoding :: Const a b -> Encoding # toJSONList :: [Const a b] -> Value # toEncodingList :: [Const a b] -> Encoding #
FromJSON a => FromJSON (Const a b)
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Const a b) # parseJSONList :: Value -> Parser [Const a b] #
Storable a => Storable (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods sizeOf :: Const a b -> Int # alignment :: Const a b -> Int # peekElemOff :: Ptr (Const a b) -> Int -> IO (Const a b) # pokeElemOff :: Ptr (Const a b) -> Int -> Const a b -> IO () # peekByteOff :: Ptr b0 -> Int -> IO (Const a b) # pokeByteOff :: Ptr b0 -> Int -> Const a b -> IO () # peek :: Ptr (Const a b) -> IO (Const a b) # poke :: Ptr (Const a b) -> Const a b -> IO () #
Bits a => Bits (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods (.&.) :: Const a b -> Const a b -> Const a b # (.\|.) :: Const a b -> Const a b -> Const a b # xor :: Const a b -> Const a b -> Const a b # complement :: Const a b -> Const a b # shift :: Const a b -> Int -> Const a b # rotate :: Const a b -> Int -> Const a b # zeroBits :: Const a b # bit :: Int -> Const a b # setBit :: Const a b -> Int -> Const a b # clearBit :: Const a b -> Int -> Const a b # complementBit :: Const a b -> Int -> Const a b # testBit :: Const a b -> Int -> Bool # bitSizeMaybe :: Const a b -> Maybe Int # bitSize :: Const a b -> Int # isSigned :: Const a b -> Bool # shiftL :: Const a b -> Int -> Const a b # unsafeShiftL :: Const a b -> Int -> Const a b # shiftR :: Const a b -> Int -> Const a b # unsafeShiftR :: Const a b -> Int -> Const a b # rotateL :: Const a b -> Int -> Const a b # rotateR :: Const a b -> Int -> Const a b # popCount :: Const a b -> Int #
FiniteBits a => FiniteBits (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods finiteBitSize :: Const a b -> Int # countLeadingZeros :: Const a b -> Int # countTrailingZeros :: Const a b -> Int #
Prim a => Prim (Const a b)	Since: primitive-0.6.5.0
Instance details Defined in Data.Primitive.Types Methods sizeOf# :: Const a b -> Int# # alignment# :: Const a b -> Int# # indexByteArray# :: ByteArray# -> Int# -> Const a b # readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, Const a b#) # writeByteArray# :: MutableByteArray# s -> Int# -> Const a b -> State# s -> State# s # setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Const a b -> State# s -> State# s # indexOffAddr# :: Addr# -> Int# -> Const a b # readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, Const a b#) # writeOffAddr# :: Addr# -> Int# -> Const a b -> State# s -> State# s # setOffAddr# :: Addr# -> Int# -> Int# -> Const a b -> State# s -> State# s #
Wrapped (Const a x)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (Const a x) :: Type # Methods _Wrapped' :: Iso' (Const a x) (Unwrapped (Const a x)) #
t ~ Const a' x' => Rewrapped (Const a x) t
Instance details Defined in Control.Lens.Wrapped
type Rep1 (Const a :: k -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const type Rep1 (Const a :: k -> Type) = D1 (MetaData "Const" "Data.Functor.Const" "base" True) (C1 (MetaCons "Const" PrefixI True) (S1 (MetaSel (Just "getConst") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))
type Rep (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const type Rep (Const a b) = D1 (MetaData "Const" "Data.Functor.Const" "base" True) (C1 (MetaCons "Const" PrefixI True) (S1 (MetaSel (Just "getConst") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))
type Unwrapped (Const a x)
Instance details Defined in Control.Lens.Wrapped type Unwrapped (Const a x) = a

newtype Identity a #

Identity functor and monad. (a non-strict monad)

Since: base-4.8.0.0

Constructors

Identity
Fields runIdentity :: a

Instances

Monad Identity	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods (>>=) :: Identity a -> (a -> Identity b) -> Identity b # (>>) :: Identity a -> Identity b -> Identity b # return :: a -> Identity a # fail :: String -> Identity a #
Functor Identity	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods fmap :: (a -> b) -> Identity a -> Identity b # (<$) :: a -> Identity b -> Identity a #
MonadFix Identity	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods mfix :: (a -> Identity a) -> Identity a #
Applicative Identity	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods pure :: a -> Identity a # (<>) :: Identity (a -> b) -> Identity a -> Identity b # liftA2 :: (a -> b -> c) -> Identity a -> Identity b -> Identity c # (>) :: Identity a -> Identity b -> Identity b # (<*) :: Identity a -> Identity b -> Identity a #
Foldable Identity	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods fold :: Monoid m => Identity m -> m # foldMap :: Monoid m => (a -> m) -> Identity a -> m # foldr :: (a -> b -> b) -> b -> Identity a -> b # foldr' :: (a -> b -> b) -> b -> Identity a -> b # foldl :: (b -> a -> b) -> b -> Identity a -> b # foldl' :: (b -> a -> b) -> b -> Identity a -> b # foldr1 :: (a -> a -> a) -> Identity a -> a # foldl1 :: (a -> a -> a) -> Identity a -> a # toList :: Identity a -> [a] # null :: Identity a -> Bool # length :: Identity a -> Int # elem :: Eq a => a -> Identity a -> Bool # maximum :: Ord a => Identity a -> a # minimum :: Ord a => Identity a -> a # sum :: Num a => Identity a -> a # product :: Num a => Identity a -> a #
Traversable Identity	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Identity a -> f (Identity b) # sequenceA :: Applicative f => Identity (f a) -> f (Identity a) # mapM :: Monad m => (a -> m b) -> Identity a -> m (Identity b) # sequence :: Monad m => Identity (m a) -> m (Identity a) #
Representable Identity
Instance details Defined in Data.Functor.Rep Associated Types type Rep Identity :: Type # Methods tabulate :: (Rep Identity -> a) -> Identity a # index :: Identity a -> Rep Identity -> a #
ToJSON1 Identity
Instance details Defined in Data.Aeson.Types.ToJSON Methods liftToJSON :: (a -> Value) -> ([a] -> Value) -> Identity a -> Value # liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [Identity a] -> Value # liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> Identity a -> Encoding # liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [Identity a] -> Encoding #
FromJSON1 Identity
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (Identity a) # liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [Identity a] #
Eq1 Identity	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Classes Methods liftEq :: (a -> b -> Bool) -> Identity a -> Identity b -> Bool #
Ord1 Identity	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Classes Methods liftCompare :: (a -> b -> Ordering) -> Identity a -> Identity b -> Ordering #
Read1 Identity	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Classes Methods liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Identity a) # liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Identity a] # liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (Identity a) # liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [Identity a] #
Show1 Identity	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Classes Methods liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Identity a -> ShowS # liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Identity a] -> ShowS #
Hashable1 Identity
Instance details Defined in Data.Hashable.Class Methods liftHashWithSalt :: (Int -> a -> Int) -> Int -> Identity a -> Int #
Apply Identity
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: Identity (a -> b) -> Identity a -> Identity b # (.>) :: Identity a -> Identity b -> Identity b # (<.) :: Identity a -> Identity b -> Identity a # liftF2 :: (a -> b -> c) -> Identity a -> Identity b -> Identity c #
Settable Identity	So you can pass our `Setter` into combinators from other lens libraries.
Instance details Defined in Control.Lens.Internal.Setter Methods untainted :: Identity a -> a # untaintedDot :: Profunctor p => p a (Identity b) -> p a b # taintedDot :: Profunctor p => p a b -> p a (Identity b) #
Traversable1 Identity
Instance details Defined in Data.Semigroup.Traversable.Class Methods traverse1 :: Apply f => (a -> f b) -> Identity a -> f (Identity b) # sequence1 :: Apply f => Identity (f b) -> f (Identity b) #
Bind Identity
Instance details Defined in Data.Functor.Bind.Class Methods (>>-) :: Identity a -> (a -> Identity b) -> Identity b # join :: Identity (Identity a) -> Identity a #
FunctorWithIndex () Identity
Instance details Defined in Control.Lens.Indexed Methods imap :: (() -> a -> b) -> Identity a -> Identity b # imapped :: IndexedSetter () (Identity a) (Identity b) a b #
FoldableWithIndex () Identity
Instance details Defined in Control.Lens.Indexed Methods ifoldMap :: Monoid m => (() -> a -> m) -> Identity a -> m # ifolded :: IndexedFold () (Identity a) a # ifoldr :: (() -> a -> b -> b) -> b -> Identity a -> b # ifoldl :: (() -> b -> a -> b) -> b -> Identity a -> b # ifoldr' :: (() -> a -> b -> b) -> b -> Identity a -> b # ifoldl' :: (() -> b -> a -> b) -> b -> Identity a -> b #
TraversableWithIndex () Identity
Instance details Defined in Control.Lens.Indexed Methods itraverse :: Applicative f => (() -> a -> f b) -> Identity a -> f (Identity b) # itraversed :: IndexedTraversal () (Identity a) (Identity b) a b #
MonadBaseControl Identity Identity
Instance details Defined in Control.Monad.Trans.Control Associated Types type StM Identity a :: Type # Methods liftBaseWith :: (RunInBase Identity Identity -> Identity a) -> Identity a # restoreM :: StM Identity a -> Identity a #
Sieve ReifiedGetter Identity
Instance details Defined in Control.Lens.Reified Methods sieve :: ReifiedGetter a b -> a -> Identity b #
Cosieve ReifiedGetter Identity
Instance details Defined in Control.Lens.Reified Methods cosieve :: ReifiedGetter a b -> Identity a -> b #
Bounded a => Bounded (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods minBound :: Identity a # maxBound :: Identity a #
Enum a => Enum (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods succ :: Identity a -> Identity a # pred :: Identity a -> Identity a # toEnum :: Int -> Identity a # fromEnum :: Identity a -> Int # enumFrom :: Identity a -> [Identity a] # enumFromThen :: Identity a -> Identity a -> [Identity a] # enumFromTo :: Identity a -> Identity a -> [Identity a] # enumFromThenTo :: Identity a -> Identity a -> Identity a -> [Identity a] #
Eq a => Eq (Identity a)	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods (==) :: Identity a -> Identity a -> Bool # (/=) :: Identity a -> Identity a -> Bool #
Floating a => Floating (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods pi :: Identity a # exp :: Identity a -> Identity a # log :: Identity a -> Identity a # sqrt :: Identity a -> Identity a # (**) :: Identity a -> Identity a -> Identity a # logBase :: Identity a -> Identity a -> Identity a # sin :: Identity a -> Identity a # cos :: Identity a -> Identity a # tan :: Identity a -> Identity a # asin :: Identity a -> Identity a # acos :: Identity a -> Identity a # atan :: Identity a -> Identity a # sinh :: Identity a -> Identity a # cosh :: Identity a -> Identity a # tanh :: Identity a -> Identity a # asinh :: Identity a -> Identity a # acosh :: Identity a -> Identity a # atanh :: Identity a -> Identity a # log1p :: Identity a -> Identity a # expm1 :: Identity a -> Identity a # log1pexp :: Identity a -> Identity a # log1mexp :: Identity a -> Identity a #
Fractional a => Fractional (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods (/) :: Identity a -> Identity a -> Identity a # recip :: Identity a -> Identity a # fromRational :: Rational -> Identity a #
Integral a => Integral (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods quot :: Identity a -> Identity a -> Identity a # rem :: Identity a -> Identity a -> Identity a # div :: Identity a -> Identity a -> Identity a # mod :: Identity a -> Identity a -> Identity a # quotRem :: Identity a -> Identity a -> (Identity a, Identity a) # divMod :: Identity a -> Identity a -> (Identity a, Identity a) # toInteger :: Identity a -> Integer #
Num a => Num (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods (+) :: Identity a -> Identity a -> Identity a # (-) :: Identity a -> Identity a -> Identity a # (*) :: Identity a -> Identity a -> Identity a # negate :: Identity a -> Identity a # abs :: Identity a -> Identity a # signum :: Identity a -> Identity a # fromInteger :: Integer -> Identity a #
Ord a => Ord (Identity a)	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods compare :: Identity a -> Identity a -> Ordering # (<) :: Identity a -> Identity a -> Bool # (<=) :: Identity a -> Identity a -> Bool # (>) :: Identity a -> Identity a -> Bool # (>=) :: Identity a -> Identity a -> Bool # max :: Identity a -> Identity a -> Identity a # min :: Identity a -> Identity a -> Identity a #
Read a => Read (Identity a)	This instance would be equivalent to the derived instances of the `Identity` newtype if the `runIdentity` field were removed Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods readsPrec :: Int -> ReadS (Identity a) # readList :: ReadS [Identity a] # readPrec :: ReadPrec (Identity a) # readListPrec :: ReadPrec [Identity a] #
Real a => Real (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods toRational :: Identity a -> Rational #
RealFloat a => RealFloat (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods floatRadix :: Identity a -> Integer # floatDigits :: Identity a -> Int # floatRange :: Identity a -> (Int, Int) # decodeFloat :: Identity a -> (Integer, Int) # encodeFloat :: Integer -> Int -> Identity a # exponent :: Identity a -> Int # significand :: Identity a -> Identity a # scaleFloat :: Int -> Identity a -> Identity a # isNaN :: Identity a -> Bool # isInfinite :: Identity a -> Bool # isDenormalized :: Identity a -> Bool # isNegativeZero :: Identity a -> Bool # isIEEE :: Identity a -> Bool # atan2 :: Identity a -> Identity a -> Identity a #
RealFrac a => RealFrac (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods properFraction :: Integral b => Identity a -> (b, Identity a) # truncate :: Integral b => Identity a -> b # round :: Integral b => Identity a -> b # ceiling :: Integral b => Identity a -> b # floor :: Integral b => Identity a -> b #
Show a => Show (Identity a)	This instance would be equivalent to the derived instances of the `Identity` newtype if the `runIdentity` field were removed Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods showsPrec :: Int -> Identity a -> ShowS # show :: Identity a -> String # showList :: [Identity a] -> ShowS #
Ix a => Ix (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods range :: (Identity a, Identity a) -> [Identity a] # index :: (Identity a, Identity a) -> Identity a -> Int # unsafeIndex :: (Identity a, Identity a) -> Identity a -> Int inRange :: (Identity a, Identity a) -> Identity a -> Bool # rangeSize :: (Identity a, Identity a) -> Int # unsafeRangeSize :: (Identity a, Identity a) -> Int
IsString a => IsString (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.String Methods fromString :: String -> Identity a #
Generic (Identity a)
Instance details Defined in Data.Functor.Identity Associated Types type Rep (Identity a) :: Type -> Type # Methods from :: Identity a -> Rep (Identity a) x # to :: Rep (Identity a) x -> Identity a #
Semigroup a => Semigroup (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods (<>) :: Identity a -> Identity a -> Identity a # sconcat :: NonEmpty (Identity a) -> Identity a # stimes :: Integral b => b -> Identity a -> Identity a #
Monoid a => Monoid (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods mempty :: Identity a # mappend :: Identity a -> Identity a -> Identity a # mconcat :: [Identity a] -> Identity a #
Hashable a => Hashable (Identity a)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Identity a -> Int # hash :: Identity a -> Int #
ToJSON a => ToJSON (Identity a)
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Identity a -> Value # toEncoding :: Identity a -> Encoding # toJSONList :: [Identity a] -> Value # toEncodingList :: [Identity a] -> Encoding #
ToJSONKey a => ToJSONKey (Identity a)
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSONKey :: ToJSONKeyFunction (Identity a) # toJSONKeyList :: ToJSONKeyFunction [Identity a] #
FromJSON a => FromJSON (Identity a)
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Identity a) # parseJSONList :: Value -> Parser [Identity a] #
FromJSONKey a => FromJSONKey (Identity a)
Instance details Defined in Data.Aeson.Types.FromJSON Methods fromJSONKey :: FromJSONKeyFunction (Identity a) # fromJSONKeyList :: FromJSONKeyFunction [Identity a] #
Storable a => Storable (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods sizeOf :: Identity a -> Int # alignment :: Identity a -> Int # peekElemOff :: Ptr (Identity a) -> Int -> IO (Identity a) # pokeElemOff :: Ptr (Identity a) -> Int -> Identity a -> IO () # peekByteOff :: Ptr b -> Int -> IO (Identity a) # pokeByteOff :: Ptr b -> Int -> Identity a -> IO () # peek :: Ptr (Identity a) -> IO (Identity a) # poke :: Ptr (Identity a) -> Identity a -> IO () #
Bits a => Bits (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods (.&.) :: Identity a -> Identity a -> Identity a # (.\|.) :: Identity a -> Identity a -> Identity a # xor :: Identity a -> Identity a -> Identity a # complement :: Identity a -> Identity a # shift :: Identity a -> Int -> Identity a # rotate :: Identity a -> Int -> Identity a # zeroBits :: Identity a # bit :: Int -> Identity a # setBit :: Identity a -> Int -> Identity a # clearBit :: Identity a -> Int -> Identity a # complementBit :: Identity a -> Int -> Identity a # testBit :: Identity a -> Int -> Bool # bitSizeMaybe :: Identity a -> Maybe Int # bitSize :: Identity a -> Int # isSigned :: Identity a -> Bool # shiftL :: Identity a -> Int -> Identity a # unsafeShiftL :: Identity a -> Int -> Identity a # shiftR :: Identity a -> Int -> Identity a # unsafeShiftR :: Identity a -> Int -> Identity a # rotateL :: Identity a -> Int -> Identity a # rotateR :: Identity a -> Int -> Identity a # popCount :: Identity a -> Int #
FiniteBits a => FiniteBits (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods finiteBitSize :: Identity a -> Int # countLeadingZeros :: Identity a -> Int # countTrailingZeros :: Identity a -> Int #
Prim a => Prim (Identity a)	Since: primitive-0.6.5.0
Instance details Defined in Data.Primitive.Types Methods sizeOf# :: Identity a -> Int# # alignment# :: Identity a -> Int# # indexByteArray# :: ByteArray# -> Int# -> Identity a # readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, Identity a#) # writeByteArray# :: MutableByteArray# s -> Int# -> Identity a -> State# s -> State# s # setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Identity a -> State# s -> State# s # indexOffAddr# :: Addr# -> Int# -> Identity a # readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, Identity a#) # writeOffAddr# :: Addr# -> Int# -> Identity a -> State# s -> State# s # setOffAddr# :: Addr# -> Int# -> Int# -> Identity a -> State# s -> State# s #
Ixed (Identity a)
Instance details Defined in Control.Lens.At Methods ix :: Index (Identity a) -> Traversal' (Identity a) (IxValue (Identity a)) #
Wrapped (Identity a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (Identity a) :: Type # Methods _Wrapped' :: Iso' (Identity a) (Unwrapped (Identity a)) #
Generic1 Identity
Instance details Defined in Data.Functor.Identity Associated Types type Rep1 Identity :: k -> Type # Methods from1 :: Identity a -> Rep1 Identity a # to1 :: Rep1 Identity a -> Identity a #
t ~ Identity b => Rewrapped (Identity a) t
Instance details Defined in Control.Lens.Wrapped
Each (Identity a) (Identity b) a b	`each` :: `Traversal` (`Identity` a) (`Identity` b) a b
Instance details Defined in Control.Lens.Each Methods each :: Traversal (Identity a) (Identity b) a b #
Field1 (Identity a) (Identity b) a b
Instance details Defined in Control.Lens.Tuple Methods _1 :: Lens (Identity a) (Identity b) a b #
type Rep Identity
Instance details Defined in Data.Functor.Rep type Rep Identity = ()
type StM Identity a
Instance details Defined in Control.Monad.Trans.Control type StM Identity a = a
type Rep (Identity a)	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity type Rep (Identity a) = D1 (MetaData "Identity" "Data.Functor.Identity" "base" True) (C1 (MetaCons "Identity" PrefixI True) (S1 (MetaSel (Just "runIdentity") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))
type Index (Identity a)
Instance details Defined in Control.Lens.At type Index (Identity a) = ()
type IxValue (Identity a)
Instance details Defined in Control.Lens.At type IxValue (Identity a) = a
type Unwrapped (Identity a)
Instance details Defined in Control.Lens.Wrapped type Unwrapped (Identity a) = a
type Rep1 Identity	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity type Rep1 Identity = D1 (MetaData "Identity" "Data.Functor.Identity" "base" True) (C1 (MetaCons "Identity" PrefixI True) (S1 (MetaSel (Just "runIdentity") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

class Contravariant (f :: Type -> Type) where #

The class of contravariant functors.

Whereas in Haskell, one can think of a Functor as containing or producing values, a contravariant functor is a functor that can be thought of as consuming values.

As an example, consider the type of predicate functions a -> Bool. One such predicate might be negative x = x < 0, which classifies integers as to whether they are negative. However, given this predicate, we can re-use it in other situations, providing we have a way to map values to integers. For instance, we can use the negative predicate on a person's bank balance to work out if they are currently overdrawn:

newtype Predicate a = Predicate { getPredicate :: a -> Bool }

instance Contravariant Predicate where
  contramap f (Predicate p) = Predicate (p . f)
                                         |   `- First, map the input...
                                         `----- then apply the predicate.

overdrawn :: Predicate Person
overdrawn = contramap personBankBalance negative

Any instance should be subject to the following laws:

contramap id = id
contramap f . contramap g = contramap (g . f)

Note, that the second law follows from the free theorem of the type of contramap and the first law, so you need only check that the former condition holds.

Minimal complete definition

contramap

Methods

contramap :: (a -> b) -> f b -> f a #

(>$) :: b -> f b -> f a infixl 4 #

Replace all locations in the output with the same value. The default definition is contramap . const, but this may be overridden with a more efficient version.

Instances

Contravariant ToJSONKeyFunction
Instance details Defined in Data.Aeson.Types.ToJSON Methods contramap :: (a -> b) -> ToJSONKeyFunction b -> ToJSONKeyFunction a # (>$) :: b -> ToJSONKeyFunction b -> ToJSONKeyFunction a #
Contravariant Predicate	A `Predicate` is a `Contravariant` `Functor`, because `contramap` can apply its function argument to the input of the predicate.
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a -> b) -> Predicate b -> Predicate a # (>$) :: b -> Predicate b -> Predicate a #
Contravariant Comparison	A `Comparison` is a `Contravariant` `Functor`, because `contramap` can apply its function argument to each input of the comparison function.
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a -> b) -> Comparison b -> Comparison a # (>$) :: b -> Comparison b -> Comparison a #
Contravariant Equivalence	Equivalence relations are `Contravariant`, because you can apply the contramapped function to each input to the equivalence relation.
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a -> b) -> Equivalence b -> Equivalence a # (>$) :: b -> Equivalence b -> Equivalence a #
Contravariant (V1 :: Type -> Type)
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a -> b) -> V1 b -> V1 a # (>$) :: b -> V1 b -> V1 a #
Contravariant (U1 :: Type -> Type)
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a -> b) -> U1 b -> U1 a # (>$) :: b -> U1 b -> U1 a #
Contravariant (Op a)
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a0 -> b) -> Op a b -> Op a a0 # (>$) :: b -> Op a b -> Op a a0 #
Contravariant (Proxy :: Type -> Type)
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a -> b) -> Proxy b -> Proxy a # (>$) :: b -> Proxy b -> Proxy a #
Contravariant m => Contravariant (MaybeT m)
Instance details Defined in Control.Monad.Trans.Maybe Methods contramap :: (a -> b) -> MaybeT m b -> MaybeT m a # (>$) :: b -> MaybeT m b -> MaybeT m a #
Contravariant f => Contravariant (Indexing f)
Instance details Defined in Control.Lens.Internal.Indexed Methods contramap :: (a -> b) -> Indexing f b -> Indexing f a # (>$) :: b -> Indexing f b -> Indexing f a #
Contravariant f => Contravariant (Indexing64 f)
Instance details Defined in Control.Lens.Internal.Indexed Methods contramap :: (a -> b) -> Indexing64 f b -> Indexing64 f a # (>$) :: b -> Indexing64 f b -> Indexing64 f a #
Contravariant m => Contravariant (ListT m)
Instance details Defined in Control.Monad.Trans.List Methods contramap :: (a -> b) -> ListT m b -> ListT m a # (>$) :: b -> ListT m b -> ListT m a #
Contravariant f => Contravariant (Rec1 f)
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a -> b) -> Rec1 f b -> Rec1 f a # (>$) :: b -> Rec1 f b -> Rec1 f a #
Contravariant f => Contravariant (IdentityT f)
Instance details Defined in Control.Monad.Trans.Identity Methods contramap :: (a -> b) -> IdentityT f b -> IdentityT f a # (>$) :: b -> IdentityT f b -> IdentityT f a #
Contravariant (Const a :: Type -> Type)
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a0 -> b) -> Const a b -> Const a a0 # (>$) :: b -> Const a b -> Const a a0 #
Contravariant f => Contravariant (Alt f)
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a -> b) -> Alt f b -> Alt f a # (>$) :: b -> Alt f b -> Alt f a #
Contravariant m => Contravariant (WriterT w m)
Instance details Defined in Control.Monad.Trans.Writer.Strict Methods contramap :: (a -> b) -> WriterT w m b -> WriterT w m a # (>$) :: b -> WriterT w m b -> WriterT w m a #
Contravariant m => Contravariant (WriterT w m)
Instance details Defined in Control.Monad.Trans.Writer.Lazy Methods contramap :: (a -> b) -> WriterT w m b -> WriterT w m a # (>$) :: b -> WriterT w m b -> WriterT w m a #
Contravariant m => Contravariant (StateT s m)
Instance details Defined in Control.Monad.Trans.State.Strict Methods contramap :: (a -> b) -> StateT s m b -> StateT s m a # (>$) :: b -> StateT s m b -> StateT s m a #
Contravariant m => Contravariant (StateT s m)
Instance details Defined in Control.Monad.Trans.State.Lazy Methods contramap :: (a -> b) -> StateT s m b -> StateT s m a # (>$) :: b -> StateT s m b -> StateT s m a #
Contravariant m => Contravariant (ExceptT e m)
Instance details Defined in Control.Monad.Trans.Except Methods contramap :: (a -> b) -> ExceptT e m b -> ExceptT e m a # (>$) :: b -> ExceptT e m b -> ExceptT e m a #
Contravariant m => Contravariant (ErrorT e m)
Instance details Defined in Control.Monad.Trans.Error Methods contramap :: (a -> b) -> ErrorT e m b -> ErrorT e m a # (>$) :: b -> ErrorT e m b -> ErrorT e m a #
Contravariant f => Contravariant (Backwards f)	Derived instance.
Instance details Defined in Control.Applicative.Backwards Methods contramap :: (a -> b) -> Backwards f b -> Backwards f a # (>$) :: b -> Backwards f b -> Backwards f a #
Contravariant f => Contravariant (AlongsideLeft f b)
Instance details Defined in Control.Lens.Internal.Getter Methods contramap :: (a -> b0) -> AlongsideLeft f b b0 -> AlongsideLeft f b a # (>$) :: b0 -> AlongsideLeft f b b0 -> AlongsideLeft f b a #
Contravariant f => Contravariant (AlongsideRight f a)
Instance details Defined in Control.Lens.Internal.Getter Methods contramap :: (a0 -> b) -> AlongsideRight f a b -> AlongsideRight f a a0 # (>$) :: b -> AlongsideRight f a b -> AlongsideRight f a a0 #
Contravariant f => Contravariant (Star f a)
Instance details Defined in Data.Profunctor.Types Methods contramap :: (a0 -> b) -> Star f a b -> Star f a a0 # (>$) :: b -> Star f a b -> Star f a a0 #
Contravariant (Forget r a)
Instance details Defined in Data.Profunctor.Types Methods contramap :: (a0 -> b) -> Forget r a b -> Forget r a a0 # (>$) :: b -> Forget r a b -> Forget r a a0 #
Contravariant (K1 i c :: Type -> Type)
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a -> b) -> K1 i c b -> K1 i c a # (>$) :: b -> K1 i c b -> K1 i c a #
(Contravariant f, Contravariant g) => Contravariant (f :+: g)
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a -> b) -> (f :+: g) b -> (f :+: g) a # (>$) :: b -> (f :+: g) b -> (f :+: g) a #
(Contravariant f, Contravariant g) => Contravariant (f :*: g)
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a -> b) -> (f :: g) b -> (f :: g) a # (>$) :: b -> (f :: g) b -> (f :: g) a #
(Contravariant f, Contravariant g) => Contravariant (Product f g)
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a -> b) -> Product f g b -> Product f g a # (>$) :: b -> Product f g b -> Product f g a #
(Contravariant f, Contravariant g) => Contravariant (Sum f g)
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a -> b) -> Sum f g b -> Sum f g a # (>$) :: b -> Sum f g b -> Sum f g a #
Contravariant m => Contravariant (ReaderT r m)
Instance details Defined in Control.Monad.Trans.Reader Methods contramap :: (a -> b) -> ReaderT r m b -> ReaderT r m a # (>$) :: b -> ReaderT r m b -> ReaderT r m a #
Contravariant f => Contravariant (M1 i c f)
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a -> b) -> M1 i c f b -> M1 i c f a # (>$) :: b -> M1 i c f b -> M1 i c f a #
(Functor f, Contravariant g) => Contravariant (f :.: g)
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a -> b) -> (f :.: g) b -> (f :.: g) a # (>$) :: b -> (f :.: g) b -> (f :.: g) a #
(Functor f, Contravariant g) => Contravariant (Compose f g)
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a -> b) -> Compose f g b -> Compose f g a # (>$) :: b -> Compose f g b -> Compose f g a #
Contravariant m => Contravariant (RWST r w s m)
Instance details Defined in Control.Monad.Trans.RWS.Strict Methods contramap :: (a -> b) -> RWST r w s m b -> RWST r w s m a # (>$) :: b -> RWST r w s m b -> RWST r w s m a #
Contravariant m => Contravariant (RWST r w s m)
Instance details Defined in Control.Monad.Trans.RWS.Lazy Methods contramap :: (a -> b) -> RWST r w s m b -> RWST r w s m a # (>$) :: b -> RWST r w s m b -> RWST r w s m a #
Contravariant f => Contravariant (TakingWhile p f a b)
Instance details Defined in Control.Lens.Internal.Magma Methods contramap :: (a0 -> b0) -> TakingWhile p f a b b0 -> TakingWhile p f a b a0 # (>$) :: b0 -> TakingWhile p f a b b0 -> TakingWhile p f a b a0 #
(Profunctor p, Contravariant g) => Contravariant (BazaarT p g a b)
Instance details Defined in Control.Lens.Internal.Bazaar Methods contramap :: (a0 -> b0) -> BazaarT p g a b b0 -> BazaarT p g a b a0 # (>$) :: b0 -> BazaarT p g a b b0 -> BazaarT p g a b a0 #
(Profunctor p, Contravariant g) => Contravariant (BazaarT1 p g a b)
Instance details Defined in Control.Lens.Internal.Bazaar Methods contramap :: (a0 -> b0) -> BazaarT1 p g a b b0 -> BazaarT1 p g a b a0 # (>$) :: b0 -> BazaarT1 p g a b b0 -> BazaarT1 p g a b a0 #
(Profunctor p, Contravariant g) => Contravariant (PretextT p g a b)
Instance details Defined in Control.Lens.Internal.Context Methods contramap :: (a0 -> b0) -> PretextT p g a b b0 -> PretextT p g a b a0 # (>$) :: b0 -> PretextT p g a b b0 -> PretextT p g a b a0 #

eitherDecodeFileStrict' :: FromJSON a => FilePath -> IO (Either String a) #

Like decodeFileStrict' but returns an error message when decoding fails.

eitherDecodeStrict' :: FromJSON a => ByteString -> Either String a #

Like decodeStrict' but returns an error message when decoding fails.

eitherDecode' :: FromJSON a => ByteString -> Either String a #

Like decode' but returns an error message when decoding fails.

eitherDecodeFileStrict :: FromJSON a => FilePath -> IO (Either String a) #

Like decodeFileStrict but returns an error message when decoding fails.

eitherDecodeStrict :: FromJSON a => ByteString -> Either String a #

Like decodeStrict but returns an error message when decoding fails.

eitherDecode :: FromJSON a => ByteString -> Either String a #

Like decode but returns an error message when decoding fails.

decodeFileStrict' :: FromJSON a => FilePath -> IO (Maybe a) #

Efficiently deserialize a JSON value from a file. If this fails due to incomplete or invalid input, Nothing is returned.

The input file's content must consist solely of a JSON document, with no trailing data except for whitespace.

This function parses and performs conversion immediately. See json' for details.

decodeStrict' :: FromJSON a => ByteString -> Maybe a #

Efficiently deserialize a JSON value from a strict ByteString. If this fails due to incomplete or invalid input, Nothing is returned.

The input must consist solely of a JSON document, with no trailing data except for whitespace.

This function parses and performs conversion immediately. See json' for details.

decode' :: FromJSON a => ByteString -> Maybe a #

Efficiently deserialize a JSON value from a lazy ByteString. If this fails due to incomplete or invalid input, Nothing is returned.

The input must consist solely of a JSON document, with no trailing data except for whitespace.

This function parses and performs conversion immediately. See json' for details.

decodeFileStrict :: FromJSON a => FilePath -> IO (Maybe a) #

Efficiently deserialize a JSON value from a file. If this fails due to incomplete or invalid input, Nothing is returned.

The input file's content must consist solely of a JSON document, with no trailing data except for whitespace.

This function parses immediately, but defers conversion. See json for details.

decodeStrict :: FromJSON a => ByteString -> Maybe a #

Efficiently deserialize a JSON value from a strict ByteString. If this fails due to incomplete or invalid input, Nothing is returned.

The input must consist solely of a JSON document, with no trailing data except for whitespace.

This function parses immediately, but defers conversion. See json for details.

decode :: FromJSON a => ByteString -> Maybe a #

Efficiently deserialize a JSON value from a lazy ByteString. If this fails due to incomplete or invalid input, Nothing is returned.

The input must consist solely of a JSON document, with no trailing data except for whitespace.

This function parses immediately, but defers conversion. See json for details.

encodeFile :: ToJSON a => FilePath -> a -> IO () #

Efficiently serialize a JSON value as a lazy ByteString and write it to a file.

encode :: ToJSON a => a -> ByteString #

Efficiently serialize a JSON value as a lazy ByteString.

This is implemented in terms of the ToJSON class's toEncoding method.

foldable :: (Foldable t, ToJSON a) => t a -> Encoding #

Encode a Foldable as a JSON array.

type GToJSON = GToJSON Value #

type GToEncoding = GToJSON Encoding #

toEncoding2 :: (ToJSON2 f, ToJSON a, ToJSON b) => f a b -> Encoding #

Lift the standard toEncoding function through the type constructor.

toJSON2 :: (ToJSON2 f, ToJSON a, ToJSON b) => f a b -> Value #

Lift the standard toJSON function through the type constructor.

toEncoding1 :: (ToJSON1 f, ToJSON a) => f a -> Encoding #

Lift the standard toEncoding function through the type constructor.

toJSON1 :: (ToJSON1 f, ToJSON a) => f a -> Value #

Lift the standard toJSON function through the type constructor.

genericToJSONKey :: (Generic a, GToJSONKey (Rep a)) => JSONKeyOptions -> ToJSONKeyFunction a #

genericLiftToEncoding :: (Generic1 f, GToJSON Encoding One (Rep1 f)) => Options -> (a -> Encoding) -> ([a] -> Encoding) -> f a -> Encoding #

A configurable generic JSON encoder. This function applied to defaultOptions is used as the default for liftToEncoding when the type is an instance of Generic1.

genericToEncoding :: (Generic a, GToJSON Encoding Zero (Rep a)) => Options -> a -> Encoding #

A configurable generic JSON encoder. This function applied to defaultOptions is used as the default for toEncoding when the type is an instance of Generic.

genericLiftToJSON :: (Generic1 f, GToJSON Value One (Rep1 f)) => Options -> (a -> Value) -> ([a] -> Value) -> f a -> Value #

A configurable generic JSON creator. This function applied to defaultOptions is used as the default for liftToJSON when the type is an instance of Generic1.

genericToJSON :: (Generic a, GToJSON Value Zero (Rep a)) => Options -> a -> Value #

A configurable generic JSON creator. This function applied to defaultOptions is used as the default for toJSON when the type is an instance of Generic.

data ToArgs res arity a where #

A ToArgs value either stores nothing (for ToJSON) or it stores the two function arguments that encode occurrences of the type parameter (for ToJSON1).

Constructors

NoToArgs :: forall res arity a. ToArgs res Zero a
To1Args :: forall res arity a. (a -> res) -> ([a] -> res) -> ToArgs res One a

class ToJSON a where #

A type that can be converted to JSON.

Instances in general must specify toJSON and should (but don't need to) specify toEncoding.

An example type and instance:

-- Allow ourselves to write Text literals.
{-# LANGUAGE OverloadedStrings #-}

data Coord = Coord { x :: Double, y :: Double }

instance ToJSON Coord where
  toJSON (Coord x y) = object ["x" .= x, "y" .= y]

  toEncoding (Coord x y) = pairs ("x" .= x <> "y" .= y)

Instead of manually writing your ToJSON instance, there are two options to do it automatically:

Data.Aeson.TH provides Template Haskell functions which will derive an instance at compile time. The generated instance is optimized for your type so it will probably be more efficient than the following option.
The compiler can provide a default generic implementation for toJSON.

To use the second, simply add a deriving Generic clause to your datatype and declare a ToJSON instance. If you require nothing other than defaultOptions, it is sufficient to write (and this is the only alternative where the default toJSON implementation is sufficient):

{-# LANGUAGE DeriveGeneric #-}

import GHC.Generics

data Coord = Coord { x :: Double, y :: Double } deriving Generic

instance ToJSON Coord where
    toEncoding = genericToEncoding defaultOptions

If on the other hand you wish to customize the generic decoding, you have to implement both methods:

customOptions = defaultOptions
                { fieldLabelModifier = map toUpper
                }

instance ToJSON Coord where
    toJSON     = genericToJSON customOptions
    toEncoding = genericToEncoding customOptions

Previous versions of this library only had the toJSON method. Adding toEncoding had two reasons:

toEncoding is more efficient for the common case that the output of toJSON is directly serialized to a ByteString. Further, expressing either method in terms of the other would be non-optimal.
The choice of defaults allows a smooth transition for existing users: Existing instances that do not define toEncoding still compile and have the correct semantics. This is ensured by making the default implementation of toEncoding use toJSON. This produces correct results, but since it performs an intermediate conversion to a Value, it will be less efficient than directly emitting an Encoding. (this also means that specifying nothing more than instance ToJSON Coord would be sufficient as a generically decoding instance, but there probably exists no good reason to not specify toEncoding in new instances.)

Minimal complete definition

Nothing

Methods

toJSON :: a -> Value #

Convert a Haskell value to a JSON-friendly intermediate type.

toEncoding :: a -> Encoding #

Encode a Haskell value as JSON.

The default implementation of this method creates an intermediate Value using toJSON. This provides source-level compatibility for people upgrading from older versions of this library, but obviously offers no performance advantage.

To benefit from direct encoding, you must provide an implementation for this method. The easiest way to do so is by having your types implement Generic using the DeriveGeneric extension, and then have GHC generate a method body as follows.

instance ToJSON Coord where
    toEncoding = genericToEncoding defaultOptions

toJSONList :: [a] -> Value #

toEncodingList :: [a] -> Encoding #

Instances

ToJSON Bool
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Bool -> Value # toEncoding :: Bool -> Encoding # toJSONList :: [Bool] -> Value # toEncodingList :: [Bool] -> Encoding #
ToJSON Char
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Char -> Value # toEncoding :: Char -> Encoding # toJSONList :: [Char] -> Value # toEncodingList :: [Char] -> Encoding #
ToJSON Double
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Double -> Value # toEncoding :: Double -> Encoding # toJSONList :: [Double] -> Value # toEncodingList :: [Double] -> Encoding #
ToJSON Float
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Float -> Value # toEncoding :: Float -> Encoding # toJSONList :: [Float] -> Value # toEncodingList :: [Float] -> Encoding #
ToJSON Int
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Int -> Value # toEncoding :: Int -> Encoding # toJSONList :: [Int] -> Value # toEncodingList :: [Int] -> Encoding #
ToJSON Int8
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Int8 -> Value # toEncoding :: Int8 -> Encoding # toJSONList :: [Int8] -> Value # toEncodingList :: [Int8] -> Encoding #
ToJSON Int16
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Int16 -> Value # toEncoding :: Int16 -> Encoding # toJSONList :: [Int16] -> Value # toEncodingList :: [Int16] -> Encoding #
ToJSON Int32
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Int32 -> Value # toEncoding :: Int32 -> Encoding # toJSONList :: [Int32] -> Value # toEncodingList :: [Int32] -> Encoding #
ToJSON Int64
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Int64 -> Value # toEncoding :: Int64 -> Encoding # toJSONList :: [Int64] -> Value # toEncodingList :: [Int64] -> Encoding #
ToJSON Integer
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Integer -> Value # toEncoding :: Integer -> Encoding # toJSONList :: [Integer] -> Value # toEncodingList :: [Integer] -> Encoding #
ToJSON Natural
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Natural -> Value # toEncoding :: Natural -> Encoding # toJSONList :: [Natural] -> Value # toEncodingList :: [Natural] -> Encoding #
ToJSON Ordering
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Ordering -> Value # toEncoding :: Ordering -> Encoding # toJSONList :: [Ordering] -> Value # toEncodingList :: [Ordering] -> Encoding #
ToJSON Word
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Word -> Value # toEncoding :: Word -> Encoding # toJSONList :: [Word] -> Value # toEncodingList :: [Word] -> Encoding #
ToJSON Word8
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Word8 -> Value # toEncoding :: Word8 -> Encoding # toJSONList :: [Word8] -> Value # toEncodingList :: [Word8] -> Encoding #
ToJSON Word16
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Word16 -> Value # toEncoding :: Word16 -> Encoding # toJSONList :: [Word16] -> Value # toEncodingList :: [Word16] -> Encoding #
ToJSON Word32
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Word32 -> Value # toEncoding :: Word32 -> Encoding # toJSONList :: [Word32] -> Value # toEncodingList :: [Word32] -> Encoding #
ToJSON Word64
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Word64 -> Value # toEncoding :: Word64 -> Encoding # toJSONList :: [Word64] -> Value # toEncodingList :: [Word64] -> Encoding #
ToJSON ()
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: () -> Value # toEncoding :: () -> Encoding # toJSONList :: [()] -> Value # toEncodingList :: [()] -> Encoding #
ToJSON Text
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Text -> Value # toEncoding :: Text -> Encoding # toJSONList :: [Text] -> Value # toEncodingList :: [Text] -> Encoding #
ToJSON Version
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Version -> Value # toEncoding :: Version -> Encoding # toJSONList :: [Version] -> Value # toEncodingList :: [Version] -> Encoding #
ToJSON Scientific
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Scientific -> Value # toEncoding :: Scientific -> Encoding # toJSONList :: [Scientific] -> Value # toEncodingList :: [Scientific] -> Encoding #
ToJSON UTCTime
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: UTCTime -> Value # toEncoding :: UTCTime -> Encoding # toJSONList :: [UTCTime] -> Value # toEncodingList :: [UTCTime] -> Encoding #
ToJSON Value
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Value -> Value # toEncoding :: Value -> Encoding # toJSONList :: [Value] -> Value # toEncodingList :: [Value] -> Encoding #
ToJSON DotNetTime
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: DotNetTime -> Value # toEncoding :: DotNetTime -> Encoding # toJSONList :: [DotNetTime] -> Value # toEncodingList :: [DotNetTime] -> Encoding #
ToJSON Text
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Text -> Value # toEncoding :: Text -> Encoding # toJSONList :: [Text] -> Value # toEncodingList :: [Text] -> Encoding #
ToJSON Number
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Number -> Value # toEncoding :: Number -> Encoding # toJSONList :: [Number] -> Value # toEncodingList :: [Number] -> Encoding #
ToJSON Void
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Void -> Value # toEncoding :: Void -> Encoding # toJSONList :: [Void] -> Value # toEncodingList :: [Void] -> Encoding #
ToJSON CTime
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: CTime -> Value # toEncoding :: CTime -> Encoding # toJSONList :: [CTime] -> Value # toEncodingList :: [CTime] -> Encoding #
ToJSON IntSet
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: IntSet -> Value # toEncoding :: IntSet -> Encoding # toJSONList :: [IntSet] -> Value # toEncodingList :: [IntSet] -> Encoding #
ToJSON DiffTime
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: DiffTime -> Value # toEncoding :: DiffTime -> Encoding # toJSONList :: [DiffTime] -> Value # toEncodingList :: [DiffTime] -> Encoding #
ToJSON Source
Instance details Defined in Data.Ipynb Methods toJSON :: Source -> Value # toEncoding :: Source -> Encoding # toJSONList :: [Source] -> Value # toEncodingList :: [Source] -> Encoding #
ToJSON MimeBundle
Instance details Defined in Data.Ipynb Methods toJSON :: MimeBundle -> Value # toEncoding :: MimeBundle -> Encoding # toJSONList :: [MimeBundle] -> Value # toEncodingList :: [MimeBundle] -> Encoding #
ToJSON CitationMode
Instance details Defined in Text.Pandoc.Definition Methods toJSON :: CitationMode -> Value # toEncoding :: CitationMode -> Encoding # toJSONList :: [CitationMode] -> Value # toEncodingList :: [CitationMode] -> Encoding #
ToJSON Citation
Instance details Defined in Text.Pandoc.Definition Methods toJSON :: Citation -> Value # toEncoding :: Citation -> Encoding # toJSONList :: [Citation] -> Value # toEncodingList :: [Citation] -> Encoding #
ToJSON MathType
Instance details Defined in Text.Pandoc.Definition Methods toJSON :: MathType -> Value # toEncoding :: MathType -> Encoding # toJSONList :: [MathType] -> Value # toEncodingList :: [MathType] -> Encoding #
ToJSON QuoteType
Instance details Defined in Text.Pandoc.Definition Methods toJSON :: QuoteType -> Value # toEncoding :: QuoteType -> Encoding # toJSONList :: [QuoteType] -> Value # toEncodingList :: [QuoteType] -> Encoding #
ToJSON Block
Instance details Defined in Text.Pandoc.Definition Methods toJSON :: Block -> Value # toEncoding :: Block -> Encoding # toJSONList :: [Block] -> Value # toEncodingList :: [Block] -> Encoding #
ToJSON Format
Instance details Defined in Text.Pandoc.Definition Methods toJSON :: Format -> Value # toEncoding :: Format -> Encoding # toJSONList :: [Format] -> Value # toEncodingList :: [Format] -> Encoding #
ToJSON ListNumberDelim
Instance details Defined in Text.Pandoc.Definition Methods toJSON :: ListNumberDelim -> Value # toEncoding :: ListNumberDelim -> Encoding # toJSONList :: [ListNumberDelim] -> Value # toEncodingList :: [ListNumberDelim] -> Encoding #
ToJSON Alignment
Instance details Defined in Text.Pandoc.Definition Methods toJSON :: Alignment -> Value # toEncoding :: Alignment -> Encoding # toJSONList :: [Alignment] -> Value # toEncodingList :: [Alignment] -> Encoding #
ToJSON MetaValue
Instance details Defined in Text.Pandoc.Definition Methods toJSON :: MetaValue -> Value # toEncoding :: MetaValue -> Encoding # toJSONList :: [MetaValue] -> Value # toEncodingList :: [MetaValue] -> Encoding #
ToJSON Inline
Instance details Defined in Text.Pandoc.Definition Methods toJSON :: Inline -> Value # toEncoding :: Inline -> Encoding # toJSONList :: [Inline] -> Value # toEncodingList :: [Inline] -> Encoding #
ToJSON ListNumberStyle
Instance details Defined in Text.Pandoc.Definition Methods toJSON :: ListNumberStyle -> Value # toEncoding :: ListNumberStyle -> Encoding # toJSONList :: [ListNumberStyle] -> Value # toEncodingList :: [ListNumberStyle] -> Encoding #
ToJSON Pandoc
Instance details Defined in Text.Pandoc.Definition Methods toJSON :: Pandoc -> Value # toEncoding :: Pandoc -> Encoding # toJSONList :: [Pandoc] -> Value # toEncodingList :: [Pandoc] -> Encoding #
ToJSON Meta
Instance details Defined in Text.Pandoc.Definition Methods toJSON :: Meta -> Value # toEncoding :: Meta -> Encoding # toJSONList :: [Meta] -> Value # toEncodingList :: [Meta] -> Encoding #
ToJSON ReaderOptions
Instance details Defined in Text.Pandoc.Options Methods toJSON :: ReaderOptions -> Value # toEncoding :: ReaderOptions -> Encoding # toJSONList :: [ReaderOptions] -> Value # toEncodingList :: [ReaderOptions] -> Encoding #
ToJSON HTMLMathMethod
Instance details Defined in Text.Pandoc.Options Methods toJSON :: HTMLMathMethod -> Value # toEncoding :: HTMLMathMethod -> Encoding # toJSONList :: [HTMLMathMethod] -> Value # toEncodingList :: [HTMLMathMethod] -> Encoding #
ToJSON CiteMethod
Instance details Defined in Text.Pandoc.Options Methods toJSON :: CiteMethod -> Value # toEncoding :: CiteMethod -> Encoding # toJSONList :: [CiteMethod] -> Value # toEncodingList :: [CiteMethod] -> Encoding #
ToJSON ObfuscationMethod
Instance details Defined in Text.Pandoc.Options Methods toJSON :: ObfuscationMethod -> Value # toEncoding :: ObfuscationMethod -> Encoding # toJSONList :: [ObfuscationMethod] -> Value # toEncodingList :: [ObfuscationMethod] -> Encoding #
ToJSON HTMLSlideVariant
Instance details Defined in Text.Pandoc.Options Methods toJSON :: HTMLSlideVariant -> Value # toEncoding :: HTMLSlideVariant -> Encoding # toJSONList :: [HTMLSlideVariant] -> Value # toEncodingList :: [HTMLSlideVariant] -> Encoding #
ToJSON TrackChanges
Instance details Defined in Text.Pandoc.Options Methods toJSON :: TrackChanges -> Value # toEncoding :: TrackChanges -> Encoding # toJSONList :: [TrackChanges] -> Value # toEncodingList :: [TrackChanges] -> Encoding #
ToJSON WrapOption
Instance details Defined in Text.Pandoc.Options Methods toJSON :: WrapOption -> Value # toEncoding :: WrapOption -> Encoding # toJSONList :: [WrapOption] -> Value # toEncodingList :: [WrapOption] -> Encoding #
ToJSON TopLevelDivision
Instance details Defined in Text.Pandoc.Options Methods toJSON :: TopLevelDivision -> Value # toEncoding :: TopLevelDivision -> Encoding # toJSONList :: [TopLevelDivision] -> Value # toEncodingList :: [TopLevelDivision] -> Encoding #
ToJSON ReferenceLocation
Instance details Defined in Text.Pandoc.Options Methods toJSON :: ReferenceLocation -> Value # toEncoding :: ReferenceLocation -> Encoding # toJSONList :: [ReferenceLocation] -> Value # toEncodingList :: [ReferenceLocation] -> Encoding #
ToJSON Verbosity
Instance details Defined in Text.Pandoc.Logging Methods toJSON :: Verbosity -> Value # toEncoding :: Verbosity -> Encoding # toJSONList :: [Verbosity] -> Value # toEncodingList :: [Verbosity] -> Encoding #
ToJSON LogMessage
Instance details Defined in Text.Pandoc.Logging Methods toJSON :: LogMessage -> Value # toEncoding :: LogMessage -> Encoding # toJSONList :: [LogMessage] -> Value # toEncodingList :: [LogMessage] -> Encoding #
ToJSON Extensions
Instance details Defined in Text.Pandoc.Extensions Methods toJSON :: Extensions -> Value # toEncoding :: Extensions -> Encoding # toJSONList :: [Extensions] -> Value # toEncodingList :: [Extensions] -> Encoding #
ToJSON Extension
Instance details Defined in Text.Pandoc.Extensions Methods toJSON :: Extension -> Value # toEncoding :: Extension -> Encoding # toJSONList :: [Extension] -> Value # toEncodingList :: [Extension] -> Encoding #
ToJSON Style
Instance details Defined in Skylighting.Types Methods toJSON :: Style -> Value # toEncoding :: Style -> Encoding # toJSONList :: [Style] -> Value # toEncodingList :: [Style] -> Encoding #
ToJSON RE
Instance details Defined in Skylighting.Regex Methods toJSON :: RE -> Value # toEncoding :: RE -> Encoding # toJSONList :: [RE] -> Value # toEncodingList :: [RE] -> Encoding #
ToJSON Color
Instance details Defined in Skylighting.Types Methods toJSON :: Color -> Value # toEncoding :: Color -> Encoding # toJSONList :: [Color] -> Value # toEncodingList :: [Color] -> Encoding #
ToJSON TokenStyle
Instance details Defined in Skylighting.Types Methods toJSON :: TokenStyle -> Value # toEncoding :: TokenStyle -> Encoding # toJSONList :: [TokenStyle] -> Value # toEncodingList :: [TokenStyle] -> Encoding #
ToJSON TokenType
Instance details Defined in Skylighting.Types Methods toJSON :: TokenType -> Value # toEncoding :: TokenType -> Encoding # toJSONList :: [TokenType] -> Value # toEncodingList :: [TokenType] -> Encoding #
ToJSON ZonedTime
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: ZonedTime -> Value # toEncoding :: ZonedTime -> Encoding # toJSONList :: [ZonedTime] -> Value # toEncodingList :: [ZonedTime] -> Encoding #
ToJSON LocalTime
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: LocalTime -> Value # toEncoding :: LocalTime -> Encoding # toJSONList :: [LocalTime] -> Value # toEncodingList :: [LocalTime] -> Encoding #
ToJSON TimeOfDay
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: TimeOfDay -> Value # toEncoding :: TimeOfDay -> Encoding # toJSONList :: [TimeOfDay] -> Value # toEncodingList :: [TimeOfDay] -> Encoding #
ToJSON SystemTime	Encoded as number
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: SystemTime -> Value # toEncoding :: SystemTime -> Encoding # toJSONList :: [SystemTime] -> Value # toEncodingList :: [SystemTime] -> Encoding #
ToJSON NominalDiffTime
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: NominalDiffTime -> Value # toEncoding :: NominalDiffTime -> Encoding # toJSONList :: [NominalDiffTime] -> Value # toEncodingList :: [NominalDiffTime] -> Encoding #
ToJSON Day
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Day -> Value # toEncoding :: Day -> Encoding # toJSONList :: [Day] -> Value # toEncodingList :: [Day] -> Encoding #
ToJSON CalendarDiffTime
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: CalendarDiffTime -> Value # toEncoding :: CalendarDiffTime -> Encoding # toJSONList :: [CalendarDiffTime] -> Value # toEncodingList :: [CalendarDiffTime] -> Encoding #
ToJSON CalendarDiffDays
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: CalendarDiffDays -> Value # toEncoding :: CalendarDiffDays -> Encoding # toJSONList :: [CalendarDiffDays] -> Value # toEncodingList :: [CalendarDiffDays] -> Encoding #
ToJSON DayOfWeek
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: DayOfWeek -> Value # toEncoding :: DayOfWeek -> Encoding # toJSONList :: [DayOfWeek] -> Value # toEncodingList :: [DayOfWeek] -> Encoding #
ToJSON UUID
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: UUID -> Value # toEncoding :: UUID -> Encoding # toJSONList :: [UUID] -> Value # toEncodingList :: [UUID] -> Encoding #
ToJSON a => ToJSON [a]
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: [a] -> Value # toEncoding :: [a] -> Encoding # toJSONList :: [[a]] -> Value # toEncodingList :: [[a]] -> Encoding #
ToJSON a => ToJSON (Maybe a)
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Maybe a -> Value # toEncoding :: Maybe a -> Encoding # toJSONList :: [Maybe a] -> Value # toEncodingList :: [Maybe a] -> Encoding #
(ToJSON a, Integral a) => ToJSON (Ratio a)
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Ratio a -> Value # toEncoding :: Ratio a -> Encoding # toJSONList :: [Ratio a] -> Value # toEncodingList :: [Ratio a] -> Encoding #
ToJSON a => ToJSON (Set a)
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Set a -> Value # toEncoding :: Set a -> Encoding # toJSONList :: [Set a] -> Value # toEncodingList :: [Set a] -> Encoding #
ToJSON a => ToJSON (Identity a)
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Identity a -> Value # toEncoding :: Identity a -> Encoding # toJSONList :: [Identity a] -> Value # toEncodingList :: [Identity a] -> Encoding #
(Storable a, ToJSON a) => ToJSON (Vector a)
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Vector a -> Value # toEncoding :: Vector a -> Encoding # toJSONList :: [Vector a] -> Value # toEncodingList :: [Vector a] -> Encoding #
HasResolution a => ToJSON (Fixed a)
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Fixed a -> Value # toEncoding :: Fixed a -> Encoding # toJSONList :: [Fixed a] -> Value # toEncodingList :: [Fixed a] -> Encoding #
ToJSON a => ToJSON (Min a)
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Min a -> Value # toEncoding :: Min a -> Encoding # toJSONList :: [Min a] -> Value # toEncodingList :: [Min a] -> Encoding #
ToJSON a => ToJSON (Max a)
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Max a -> Value # toEncoding :: Max a -> Encoding # toJSONList :: [Max a] -> Value # toEncodingList :: [Max a] -> Encoding #
ToJSON a => ToJSON (First a)
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: First a -> Value # toEncoding :: First a -> Encoding # toJSONList :: [First a] -> Value # toEncodingList :: [First a] -> Encoding #
ToJSON a => ToJSON (Last a)
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Last a -> Value # toEncoding :: Last a -> Encoding # toJSONList :: [Last a] -> Value # toEncodingList :: [Last a] -> Encoding #
ToJSON a => ToJSON (WrappedMonoid a)
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: WrappedMonoid a -> Value # toEncoding :: WrappedMonoid a -> Encoding # toJSONList :: [WrappedMonoid a] -> Value # toEncodingList :: [WrappedMonoid a] -> Encoding #
ToJSON a => ToJSON (Option a)
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Option a -> Value # toEncoding :: Option a -> Encoding # toJSONList :: [Option a] -> Value # toEncodingList :: [Option a] -> Encoding #
ToJSON a => ToJSON (First a)
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: First a -> Value # toEncoding :: First a -> Encoding # toJSONList :: [First a] -> Value # toEncodingList :: [First a] -> Encoding #
ToJSON a => ToJSON (Last a)
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Last a -> Value # toEncoding :: Last a -> Encoding # toJSONList :: [Last a] -> Value # toEncodingList :: [Last a] -> Encoding #
ToJSON a => ToJSON (Dual a)
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Dual a -> Value # toEncoding :: Dual a -> Encoding # toJSONList :: [Dual a] -> Value # toEncodingList :: [Dual a] -> Encoding #
ToJSON a => ToJSON (NonEmpty a)
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: NonEmpty a -> Value # toEncoding :: NonEmpty a -> Encoding # toJSONList :: [NonEmpty a] -> Value # toEncodingList :: [NonEmpty a] -> Encoding #
ToJSON a => ToJSON (IntMap a)
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: IntMap a -> Value # toEncoding :: IntMap a -> Encoding # toJSONList :: [IntMap a] -> Value # toEncodingList :: [IntMap a] -> Encoding #
ToJSON v => ToJSON (Tree v)
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Tree v -> Value # toEncoding :: Tree v -> Encoding # toJSONList :: [Tree v] -> Value # toEncodingList :: [Tree v] -> Encoding #
ToJSON a => ToJSON (Seq a)
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Seq a -> Value # toEncoding :: Seq a -> Encoding # toJSONList :: [Seq a] -> Value # toEncodingList :: [Seq a] -> Encoding #
ToJSON a => ToJSON (DList a)
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: DList a -> Value # toEncoding :: DList a -> Encoding # toJSONList :: [DList a] -> Value # toEncodingList :: [DList a] -> Encoding #
ToJSON (Notebook NbV3)
Instance details Defined in Data.Ipynb Methods toJSON :: Notebook NbV3 -> Value # toEncoding :: Notebook NbV3 -> Encoding # toJSONList :: [Notebook NbV3] -> Value # toEncodingList :: [Notebook NbV3] -> Encoding #
ToJSON (Notebook NbV4)
Instance details Defined in Data.Ipynb Methods toJSON :: Notebook NbV4 -> Value # toEncoding :: Notebook NbV4 -> Encoding # toJSONList :: [Notebook NbV4] -> Value # toEncodingList :: [Notebook NbV4] -> Encoding #
ToJSON (Cell NbV3)
Instance details Defined in Data.Ipynb Methods toJSON :: Cell NbV3 -> Value # toEncoding :: Cell NbV3 -> Encoding # toJSONList :: [Cell NbV3] -> Value # toEncodingList :: [Cell NbV3] -> Encoding #
ToJSON (Cell NbV4)
Instance details Defined in Data.Ipynb Methods toJSON :: Cell NbV4 -> Value # toEncoding :: Cell NbV4 -> Encoding # toJSONList :: [Cell NbV4] -> Value # toEncodingList :: [Cell NbV4] -> Encoding #
ToJSON (Output NbV3)
Instance details Defined in Data.Ipynb Methods toJSON :: Output NbV3 -> Value # toEncoding :: Output NbV3 -> Encoding # toJSONList :: [Output NbV3] -> Value # toEncodingList :: [Output NbV3] -> Encoding #
ToJSON (Output NbV4)
Instance details Defined in Data.Ipynb Methods toJSON :: Output NbV4 -> Value # toEncoding :: Output NbV4 -> Encoding # toJSONList :: [Output NbV4] -> Value # toEncodingList :: [Output NbV4] -> Encoding #
(Prim a, ToJSON a) => ToJSON (Vector a)
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Vector a -> Value # toEncoding :: Vector a -> Encoding # toJSONList :: [Vector a] -> Value # toEncodingList :: [Vector a] -> Encoding #
(Vector Vector a, ToJSON a) => ToJSON (Vector a)
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Vector a -> Value # toEncoding :: Vector a -> Encoding # toJSONList :: [Vector a] -> Value # toEncodingList :: [Vector a] -> Encoding #
ToJSON a => ToJSON (HashSet a)
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: HashSet a -> Value # toEncoding :: HashSet a -> Encoding # toJSONList :: [HashSet a] -> Value # toEncodingList :: [HashSet a] -> Encoding #
ToJSON a => ToJSON (Vector a)
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Vector a -> Value # toEncoding :: Vector a -> Encoding # toJSONList :: [Vector a] -> Value # toEncodingList :: [Vector a] -> Encoding #
(Prim a, ToJSON a) => ToJSON (PrimArray a)
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: PrimArray a -> Value # toEncoding :: PrimArray a -> Encoding # toJSONList :: [PrimArray a] -> Value # toEncodingList :: [PrimArray a] -> Encoding #
ToJSON a => ToJSON (SmallArray a)
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: SmallArray a -> Value # toEncoding :: SmallArray a -> Encoding # toJSONList :: [SmallArray a] -> Value # toEncodingList :: [SmallArray a] -> Encoding #
ToJSON a => ToJSON (Array a)
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Array a -> Value # toEncoding :: Array a -> Encoding # toJSONList :: [Array a] -> Value # toEncodingList :: [Array a] -> Encoding #
(ToJSON a, ToJSON b) => ToJSON (Either a b)
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Either a b -> Value # toEncoding :: Either a b -> Encoding # toJSONList :: [Either a b] -> Value # toEncodingList :: [Either a b] -> Encoding #
(ToJSON a, ToJSON b) => ToJSON (a, b)
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: (a, b) -> Value # toEncoding :: (a, b) -> Encoding # toJSONList :: [(a, b)] -> Value # toEncodingList :: [(a, b)] -> Encoding #
(ToJSON v, ToJSONKey k) => ToJSON (Map k v)
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Map k v -> Value # toEncoding :: Map k v -> Encoding # toJSONList :: [Map k v] -> Value # toEncodingList :: [Map k v] -> Encoding #
(ToJSON v, ToJSONKey k) => ToJSON (HashMap k v)
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: HashMap k v -> Value # toEncoding :: HashMap k v -> Encoding # toJSONList :: [HashMap k v] -> Value # toEncodingList :: [HashMap k v] -> Encoding #
ToJSON (Proxy a)
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Proxy a -> Value # toEncoding :: Proxy a -> Encoding # toJSONList :: [Proxy a] -> Value # toEncodingList :: [Proxy a] -> Encoding #
(ToJSON a, ToJSON b, ToJSON c) => ToJSON (a, b, c)
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: (a, b, c) -> Value # toEncoding :: (a, b, c) -> Encoding # toJSONList :: [(a, b, c)] -> Value # toEncodingList :: [(a, b, c)] -> Encoding #
ToJSON a => ToJSON (Const a b)
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Const a b -> Value # toEncoding :: Const a b -> Encoding # toJSONList :: [Const a b] -> Value # toEncodingList :: [Const a b] -> Encoding #
ToJSON b => ToJSON (Tagged a b)
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Tagged a b -> Value # toEncoding :: Tagged a b -> Encoding # toJSONList :: [Tagged a b] -> Value # toEncodingList :: [Tagged a b] -> Encoding #
(ToJSON a, ToJSON b, ToJSON c, ToJSON d) => ToJSON (a, b, c, d)
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: (a, b, c, d) -> Value # toEncoding :: (a, b, c, d) -> Encoding # toJSONList :: [(a, b, c, d)] -> Value # toEncodingList :: [(a, b, c, d)] -> Encoding #
(ToJSON1 f, ToJSON1 g, ToJSON a) => ToJSON (Product f g a)
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Product f g a -> Value # toEncoding :: Product f g a -> Encoding # toJSONList :: [Product f g a] -> Value # toEncodingList :: [Product f g a] -> Encoding #
(ToJSON1 f, ToJSON1 g, ToJSON a) => ToJSON (Sum f g a)
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Sum f g a -> Value # toEncoding :: Sum f g a -> Encoding # toJSONList :: [Sum f g a] -> Value # toEncodingList :: [Sum f g a] -> Encoding #
(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e) => ToJSON (a, b, c, d, e)
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: (a, b, c, d, e) -> Value # toEncoding :: (a, b, c, d, e) -> Encoding # toJSONList :: [(a, b, c, d, e)] -> Value # toEncodingList :: [(a, b, c, d, e)] -> Encoding #
(ToJSON1 f, ToJSON1 g, ToJSON a) => ToJSON (Compose f g a)
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Compose f g a -> Value # toEncoding :: Compose f g a -> Encoding # toJSONList :: [Compose f g a] -> Value # toEncodingList :: [Compose f g a] -> Encoding #
(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e, ToJSON f) => ToJSON (a, b, c, d, e, f)
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: (a, b, c, d, e, f) -> Value # toEncoding :: (a, b, c, d, e, f) -> Encoding # toJSONList :: [(a, b, c, d, e, f)] -> Value # toEncodingList :: [(a, b, c, d, e, f)] -> Encoding #
(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e, ToJSON f, ToJSON g) => ToJSON (a, b, c, d, e, f, g)
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: (a, b, c, d, e, f, g) -> Value # toEncoding :: (a, b, c, d, e, f, g) -> Encoding # toJSONList :: [(a, b, c, d, e, f, g)] -> Value # toEncodingList :: [(a, b, c, d, e, f, g)] -> Encoding #
(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e, ToJSON f, ToJSON g, ToJSON h) => ToJSON (a, b, c, d, e, f, g, h)
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: (a, b, c, d, e, f, g, h) -> Value # toEncoding :: (a, b, c, d, e, f, g, h) -> Encoding # toJSONList :: [(a, b, c, d, e, f, g, h)] -> Value # toEncodingList :: [(a, b, c, d, e, f, g, h)] -> Encoding #
(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e, ToJSON f, ToJSON g, ToJSON h, ToJSON i) => ToJSON (a, b, c, d, e, f, g, h, i)
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: (a, b, c, d, e, f, g, h, i) -> Value # toEncoding :: (a, b, c, d, e, f, g, h, i) -> Encoding # toJSONList :: [(a, b, c, d, e, f, g, h, i)] -> Value # toEncodingList :: [(a, b, c, d, e, f, g, h, i)] -> Encoding #
(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e, ToJSON f, ToJSON g, ToJSON h, ToJSON i, ToJSON j) => ToJSON (a, b, c, d, e, f, g, h, i, j)
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: (a, b, c, d, e, f, g, h, i, j) -> Value # toEncoding :: (a, b, c, d, e, f, g, h, i, j) -> Encoding # toJSONList :: [(a, b, c, d, e, f, g, h, i, j)] -> Value # toEncodingList :: [(a, b, c, d, e, f, g, h, i, j)] -> Encoding #
(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e, ToJSON f, ToJSON g, ToJSON h, ToJSON i, ToJSON j, ToJSON k) => ToJSON (a, b, c, d, e, f, g, h, i, j, k)
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: (a, b, c, d, e, f, g, h, i, j, k) -> Value # toEncoding :: (a, b, c, d, e, f, g, h, i, j, k) -> Encoding # toJSONList :: [(a, b, c, d, e, f, g, h, i, j, k)] -> Value # toEncodingList :: [(a, b, c, d, e, f, g, h, i, j, k)] -> Encoding #
(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e, ToJSON f, ToJSON g, ToJSON h, ToJSON i, ToJSON j, ToJSON k, ToJSON l) => ToJSON (a, b, c, d, e, f, g, h, i, j, k, l)
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: (a, b, c, d, e, f, g, h, i, j, k, l) -> Value # toEncoding :: (a, b, c, d, e, f, g, h, i, j, k, l) -> Encoding # toJSONList :: [(a, b, c, d, e, f, g, h, i, j, k, l)] -> Value # toEncodingList :: [(a, b, c, d, e, f, g, h, i, j, k, l)] -> Encoding #
(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e, ToJSON f, ToJSON g, ToJSON h, ToJSON i, ToJSON j, ToJSON k, ToJSON l, ToJSON m) => ToJSON (a, b, c, d, e, f, g, h, i, j, k, l, m)
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Value # toEncoding :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Encoding # toJSONList :: [(a, b, c, d, e, f, g, h, i, j, k, l, m)] -> Value # toEncodingList :: [(a, b, c, d, e, f, g, h, i, j, k, l, m)] -> Encoding #
(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e, ToJSON f, ToJSON g, ToJSON h, ToJSON i, ToJSON j, ToJSON k, ToJSON l, ToJSON m, ToJSON n) => ToJSON (a, b, c, d, e, f, g, h, i, j, k, l, m, n)
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Value # toEncoding :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Encoding # toJSONList :: [(a, b, c, d, e, f, g, h, i, j, k, l, m, n)] -> Value # toEncodingList :: [(a, b, c, d, e, f, g, h, i, j, k, l, m, n)] -> Encoding #
(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e, ToJSON f, ToJSON g, ToJSON h, ToJSON i, ToJSON j, ToJSON k, ToJSON l, ToJSON m, ToJSON n, ToJSON o) => ToJSON (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Value # toEncoding :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Encoding # toJSONList :: [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)] -> Value # toEncodingList :: [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)] -> Encoding #

class KeyValue kv where #

A key-value pair for encoding a JSON object.

Methods

(.=) :: ToJSON v => Text -> v -> kv infixr 8 #

Instances

KeyValue Series
Instance details Defined in Data.Aeson.Types.ToJSON Methods (.=) :: ToJSON v => Text -> v -> Series #
KeyValue Object	Constructs a singleton `HashMap`. For calling functions that demand an `Object` for constructing objects. To be used in conjunction with `mconcat`. Prefer to use `object` where possible.
Instance details Defined in Data.Aeson.Types.ToJSON Methods (.=) :: ToJSON v => Text -> v -> Object #
KeyValue Pair
Instance details Defined in Data.Aeson.Types.ToJSON Methods (.=) :: ToJSON v => Text -> v -> Pair #

class ToJSONKey a where #

Typeclass for types that can be used as the key of a map-like container (like Map or HashMap). For example, since Text has a ToJSONKey instance and Char has a ToJSON instance, we can encode a value of type Map Text Char:

>>> LBC8.putStrLn $ encode $ Map.fromList [("foo" :: Text, 'a')]
{"foo":"a"}

Since Int also has a ToJSONKey instance, we can similarly write:

>>> LBC8.putStrLn $ encode $ Map.fromList [(5 :: Int, 'a')]
{"5":"a"}

JSON documents only accept strings as object keys. For any type from base that has a natural textual representation, it can be expected that its ToJSONKey instance will choose that representation.

For data types that lack a natural textual representation, an alternative is provided. The map-like container is represented as a JSON array instead of a JSON object. Each value in the array is an array with exactly two values. The first is the key and the second is the value.

For example, values of type '[Text]' cannot be encoded to a string, so a Map with keys of type '[Text]' is encoded as follows:

>>> LBC8.putStrLn $ encode $ Map.fromList [(["foo","bar","baz" :: Text], 'a')]
[[["foo","bar","baz"],"a"]]

The default implementation of ToJSONKey chooses this method of encoding a key, using the ToJSON instance of the type.

To use your own data type as the key in a map, all that is needed is to write a ToJSONKey (and possibly a FromJSONKey) instance for it. If the type cannot be trivially converted to and from Text, it is recommended that ToJSONKeyValue is used. Since the default implementations of the typeclass methods can build this from a ToJSON instance, there is nothing that needs to be written:

data Foo = Foo { fooAge :: Int, fooName :: Text }
  deriving (Eq,Ord,Generic)
instance ToJSON Foo
instance ToJSONKey Foo

That's it. We can now write:

>>> let m = Map.fromList [(Foo 4 "bar",'a'),(Foo 6 "arg",'b')]
>>> LBC8.putStrLn $ encode m
[[{"fooName":"bar","fooAge":4},"a"],[{"fooName":"arg","fooAge":6},"b"]]

The next case to consider is if we have a type that is a newtype wrapper around Text. The recommended approach is to use generalized newtype deriving:

newtype RecordId = RecordId { getRecordId :: Text }
  deriving (Eq,Ord,ToJSONKey)

Then we may write:

>>> LBC8.putStrLn $ encode $ Map.fromList [(RecordId "abc",'a')]
{"abc":"a"}

Simple sum types are a final case worth considering. Suppose we have:

data Color = Red | Green | Blue
  deriving (Show,Read,Eq,Ord)

It is possible to get the ToJSONKey instance for free as we did with Foo. However, in this case, we have a natural way to go to and from Text that does not require any escape sequences. So ToJSONKeyText can be used instead of ToJSONKeyValue to encode maps as objects instead of arrays of pairs. This instance may be implemented using generics as follows:

instance ToJSONKey Color where
  toJSONKey = genericToJSONKey defaultJSONKeyOptions

Low-level implementations

Expand

The Show instance can be used to help write ToJSONKey:

instance ToJSONKey Color where
  toJSONKey = ToJSONKeyText f g
    where f = Text.pack . show
          g = text . Text.pack . show
          -- text function is from Data.Aeson.Encoding

The situation of needing to turning function a -> Text into a ToJSONKeyFunction is common enough that a special combinator is provided for it. The above instance can be rewritten as:

instance ToJSONKey Color where
  toJSONKey = toJSONKeyText (Text.pack . show)

The performance of the above instance can be improved by not using Value as an intermediate step when converting to Text. One option for improving performance would be to use template haskell machinery from the text-show package. However, even with the approach, the Encoding (a wrapper around a bytestring builder) is generated by encoding the Text to a ByteString, an intermediate step that could be avoided. The fastest possible implementation would be:

-- Assuming that OverloadedStrings is enabled
instance ToJSONKey Color where
  toJSONKey = ToJSONKeyText f g
    where f x = case x of {Red -> "Red";Green ->"Green";Blue -> "Blue"}
          g x = case x of {Red -> text "Red";Green -> text "Green";Blue -> text "Blue"}
          -- text function is from Data.Aeson.Encoding

This works because GHC can lift the encoded values out of the case statements, which means that they are only evaluated once. This approach should only be used when there is a serious need to maximize performance.

Minimal complete definition

Nothing

Methods

toJSONKey :: ToJSONKeyFunction a #

Strategy for rendering the key for a map-like container.

toJSONKeyList :: ToJSONKeyFunction [a] #

This is similar in spirit to the showsList method of Show. It makes it possible to give Value keys special treatment without using OverlappingInstances. End users should always be able to use the default implementation of this method.

Instances

ToJSONKey Bool
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSONKey :: ToJSONKeyFunction Bool # toJSONKeyList :: ToJSONKeyFunction [Bool] #
ToJSONKey Char
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSONKey :: ToJSONKeyFunction Char # toJSONKeyList :: ToJSONKeyFunction [Char] #
ToJSONKey Double
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSONKey :: ToJSONKeyFunction Double # toJSONKeyList :: ToJSONKeyFunction [Double] #
ToJSONKey Float
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSONKey :: ToJSONKeyFunction Float # toJSONKeyList :: ToJSONKeyFunction [Float] #
ToJSONKey Int
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSONKey :: ToJSONKeyFunction Int # toJSONKeyList :: ToJSONKeyFunction [Int] #
ToJSONKey Int8
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSONKey :: ToJSONKeyFunction Int8 # toJSONKeyList :: ToJSONKeyFunction [Int8] #
ToJSONKey Int16
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSONKey :: ToJSONKeyFunction Int16 # toJSONKeyList :: ToJSONKeyFunction [Int16] #
ToJSONKey Int32
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSONKey :: ToJSONKeyFunction Int32 # toJSONKeyList :: ToJSONKeyFunction [Int32] #
ToJSONKey Int64
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSONKey :: ToJSONKeyFunction Int64 # toJSONKeyList :: ToJSONKeyFunction [Int64] #
ToJSONKey Integer
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSONKey :: ToJSONKeyFunction Integer # toJSONKeyList :: ToJSONKeyFunction [Integer] #
ToJSONKey Natural
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSONKey :: ToJSONKeyFunction Natural # toJSONKeyList :: ToJSONKeyFunction [Natural] #
ToJSONKey Word
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSONKey :: ToJSONKeyFunction Word # toJSONKeyList :: ToJSONKeyFunction [Word] #
ToJSONKey Word8
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSONKey :: ToJSONKeyFunction Word8 # toJSONKeyList :: ToJSONKeyFunction [Word8] #
ToJSONKey Word16
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSONKey :: ToJSONKeyFunction Word16 # toJSONKeyList :: ToJSONKeyFunction [Word16] #
ToJSONKey Word32
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSONKey :: ToJSONKeyFunction Word32 # toJSONKeyList :: ToJSONKeyFunction [Word32] #
ToJSONKey Word64
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSONKey :: ToJSONKeyFunction Word64 # toJSONKeyList :: ToJSONKeyFunction [Word64] #
ToJSONKey Text
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSONKey :: ToJSONKeyFunction Text # toJSONKeyList :: ToJSONKeyFunction [Text] #
ToJSONKey Version
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSONKey :: ToJSONKeyFunction Version # toJSONKeyList :: ToJSONKeyFunction [Version] #
ToJSONKey Scientific
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSONKey :: ToJSONKeyFunction Scientific # toJSONKeyList :: ToJSONKeyFunction [Scientific] #
ToJSONKey UTCTime
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSONKey :: ToJSONKeyFunction UTCTime # toJSONKeyList :: ToJSONKeyFunction [UTCTime] #
ToJSONKey Text
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSONKey :: ToJSONKeyFunction Text # toJSONKeyList :: ToJSONKeyFunction [Text] #
ToJSONKey TokenType
Instance details Defined in Skylighting.Types Methods toJSONKey :: ToJSONKeyFunction TokenType # toJSONKeyList :: ToJSONKeyFunction [TokenType] #
ToJSONKey ZonedTime
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSONKey :: ToJSONKeyFunction ZonedTime # toJSONKeyList :: ToJSONKeyFunction [ZonedTime] #
ToJSONKey LocalTime
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSONKey :: ToJSONKeyFunction LocalTime # toJSONKeyList :: ToJSONKeyFunction [LocalTime] #
ToJSONKey TimeOfDay
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSONKey :: ToJSONKeyFunction TimeOfDay # toJSONKeyList :: ToJSONKeyFunction [TimeOfDay] #
ToJSONKey Day
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSONKey :: ToJSONKeyFunction Day # toJSONKeyList :: ToJSONKeyFunction [Day] #
ToJSONKey DayOfWeek
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSONKey :: ToJSONKeyFunction DayOfWeek # toJSONKeyList :: ToJSONKeyFunction [DayOfWeek] #
ToJSONKey UUID
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSONKey :: ToJSONKeyFunction UUID # toJSONKeyList :: ToJSONKeyFunction [UUID] #
(ToJSONKey a, ToJSON a) => ToJSONKey [a]
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSONKey :: ToJSONKeyFunction [a] # toJSONKeyList :: ToJSONKeyFunction [[a]] #
ToJSONKey a => ToJSONKey (Identity a)
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSONKey :: ToJSONKeyFunction (Identity a) # toJSONKeyList :: ToJSONKeyFunction [Identity a] #
HasResolution a => ToJSONKey (Fixed a)
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSONKey :: ToJSONKeyFunction (Fixed a) # toJSONKeyList :: ToJSONKeyFunction [Fixed a] #
(ToJSON a, ToJSON b) => ToJSONKey (a, b)
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSONKey :: ToJSONKeyFunction (a, b) # toJSONKeyList :: ToJSONKeyFunction [(a, b)] #
(ToJSON a, ToJSON b, ToJSON c) => ToJSONKey (a, b, c)
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSONKey :: ToJSONKeyFunction (a, b, c) # toJSONKeyList :: ToJSONKeyFunction [(a, b, c)] #
ToJSONKey b => ToJSONKey (Tagged a b)
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSONKey :: ToJSONKeyFunction (Tagged a b) # toJSONKeyList :: ToJSONKeyFunction [Tagged a b] #
(ToJSON a, ToJSON b, ToJSON c, ToJSON d) => ToJSONKey (a, b, c, d)
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSONKey :: ToJSONKeyFunction (a, b, c, d) # toJSONKeyList :: ToJSONKeyFunction [(a, b, c, d)] #

data ToJSONKeyFunction a #

Constructors

ToJSONKeyText !(a -> Text) !(a -> Encoding' Text)	key is encoded to string, produces object
ToJSONKeyValue !(a -> Value) !(a -> Encoding)	key is encoded to value, produces array

Instances

Contravariant ToJSONKeyFunction
Instance details Defined in Data.Aeson.Types.ToJSON Methods contramap :: (a -> b) -> ToJSONKeyFunction b -> ToJSONKeyFunction a # (>$) :: b -> ToJSONKeyFunction b -> ToJSONKeyFunction a #

class GetConName f => GToJSONKey (f :: k -> Type) #

Instances

GetConName f => GToJSONKey (f :: k -> Type)
Instance details Defined in Data.Aeson.Types.ToJSON

class ToJSON1 (f :: Type -> Type) where #

Lifting of the ToJSON class to unary type constructors.

Instead of manually writing your ToJSON1 instance, there are two options to do it automatically:

Data.Aeson.TH provides Template Haskell functions which will derive an instance at compile time. The generated instance is optimized for your type so it will probably be more efficient than the following option.
The compiler can provide a default generic implementation for toJSON1.

To use the second, simply add a deriving Generic1 clause to your datatype and declare a ToJSON1 instance for your datatype without giving definitions for liftToJSON or liftToEncoding.

For example:

{-# LANGUAGE DeriveGeneric #-}

import GHC.Generics

data Pair = Pair { pairFst :: a, pairSnd :: b } deriving Generic1

instance ToJSON a => ToJSON1 (Pair a)

If the default implementation doesn't give exactly the results you want, you can customize the generic encoding with only a tiny amount of effort, using genericLiftToJSON and genericLiftToEncoding with your preferred Options:

customOptions = defaultOptions
                { fieldLabelModifier = map toUpper
                }

instance ToJSON a => ToJSON1 (Pair a) where
    liftToJSON     = genericLiftToJSON customOptions
    liftToEncoding = genericLiftToEncoding customOptions

Error message example

withBool "MyType" f (String "oops")
-- Error: "parsing MyType failed, expected Boolean, but encountered String"

withScientific :: String -> (Scientific -> Parser a) -> Value -> Parser a #

withScientific name f value applies f to the Scientific number when value is a Number and fails using typeMismatch otherwise.

Warning: If you are converting from a scientific to an unbounded type such as Integer you may want to add a restriction on the size of the exponent (see withBoundedScientific) to prevent malicious input from filling up the memory of the target system.

Error message example

withScientific "MyType" f (String "oops")
-- Error: "parsing MyType failed, expected Number, but encountered String"

withArray :: String -> (Array -> Parser a) -> Value -> Parser a #

withArray expected f value applies f to the Array when value is an Array and fails otherwise.

Error message example

withArray "MyType" f (String "oops")
-- Error: "parsing MyType failed, expected Array, but encountered String"

withText :: String -> (Text -> Parser a) -> Value -> Parser a #

withText name f value applies f to the Text when value is a String and fails otherwise.

Error message example

withText "MyType" f Null
-- Error: "parsing MyType failed, expected String, but encountered Null"

withObject :: String -> (Object -> Parser a) -> Value -> Parser a #

withObject name f value applies f to the Object when value is an Object and fails otherwise.

Error message example

withObject "MyType" f (String "oops")
-- Error: "parsing MyType failed, expected Object, but encountered String"

parseJSON2 :: (FromJSON2 f, FromJSON a, FromJSON b) => Value -> Parser (f a b) #

Lift the standard parseJSON function through the type constructor.

parseJSON1 :: (FromJSON1 f, FromJSON a) => Value -> Parser (f a) #

Lift the standard parseJSON function through the type constructor.

genericFromJSONKey :: (Generic a, GFromJSONKey (Rep a)) => JSONKeyOptions -> FromJSONKeyFunction a #

fromJSONKey for Generic types. These types must be sums of nullary constructors, whose names will be used as keys for JSON objects.

Example

Expand

data Color = Red | Green | Blue
  deriving Generic

instance FromJSONKey Color where
  fromJSONKey = genericFromJSONKey defaultJSONKeyOptions

genericLiftParseJSON :: (Generic1 f, GFromJSON One (Rep1 f)) => Options -> (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (f a) #

A configurable generic JSON decoder. This function applied to defaultOptions is used as the default for liftParseJSON when the type is an instance of Generic1.

genericParseJSON :: (Generic a, GFromJSON Zero (Rep a)) => Options -> Value -> Parser a #

A configurable generic JSON decoder. This function applied to defaultOptions is used as the default for parseJSON when the type is an instance of Generic.

parseIndexedJSON :: (Value -> Parser a) -> Int -> Value -> Parser a #

class GFromJSON arity (f :: Type -> Type) where #

Class of generic representation types that can be converted from JSON.

Methods

gParseJSON :: Options -> FromArgs arity a -> Value -> Parser (f a) #

This method (applied to defaultOptions) is used as the default generic implementation of parseJSON (if the arity is Zero) or liftParseJSON (if the arity is One).

Instances

GFromJSON One Par1
Instance details Defined in Data.Aeson.Types.FromJSON Methods gParseJSON :: Options -> FromArgs One a -> Value -> Parser (Par1 a) #
GFromJSON arity (V1 :: Type -> Type)
Instance details Defined in Data.Aeson.Types.FromJSON Methods gParseJSON :: Options -> FromArgs arity a -> Value -> Parser (V1 a) #
FromJSON1 f => GFromJSON One (Rec1 f)
Instance details Defined in Data.Aeson.Types.FromJSON Methods gParseJSON :: Options -> FromArgs One a -> Value -> Parser (Rec1 f a) #
(GFromJSON' arity a, Datatype d) => GFromJSON arity (D1 d a)
Instance details Defined in Data.Aeson.Types.FromJSON Methods gParseJSON :: Options -> FromArgs arity a0 -> Value -> Parser (D1 d a a0) #
FromJSON a => GFromJSON arity (K1 i a :: Type -> Type)
Instance details Defined in Data.Aeson.Types.FromJSON Methods gParseJSON :: Options -> FromArgs arity a0 -> Value -> Parser (K1 i a a0) #
GFromJSON arity a => GFromJSON arity (M1 i c a)
Instance details Defined in Data.Aeson.Types.FromJSON Methods gParseJSON :: Options -> FromArgs arity a0 -> Value -> Parser (M1 i c a a0) #
(FromJSON1 f, GFromJSON One g) => GFromJSON One (f :.: g)
Instance details Defined in Data.Aeson.Types.FromJSON Methods gParseJSON :: Options -> FromArgs One a -> Value -> Parser ((f :.: g) a) #

data FromArgs arity a where #

A FromArgs value either stores nothing (for FromJSON) or it stores the two function arguments that decode occurrences of the type parameter (for FromJSON1).

Constructors

NoFromArgs :: forall arity a. FromArgs Zero a
From1Args :: forall arity a. (Value -> Parser a) -> (Value -> Parser [a]) -> FromArgs One a

class FromJSON a where #

A type that can be converted from JSON, with the possibility of failure.

In many cases, you can get the compiler to generate parsing code for you (see below). To begin, let's cover writing an instance by hand.

There are various reasons a conversion could fail. For example, an Object could be missing a required key, an Array could be of the wrong size, or a value could be of an incompatible type.

The basic ways to signal a failed conversion are as follows:

fail yields a custom error message: it is the recommended way of reporting a failure;
empty (or mzero) is uninformative: use it when the error is meant to be caught by some (<|>);
typeMismatch can be used to report a failure when the encountered value is not of the expected JSON type; unexpected is an appropriate alternative when more than one type may be expected, or to keep the expected type implicit.

prependFailure (or modifyFailure) add more information to a parser's error messages.

An example type and instance using typeMismatch and prependFailure:

-- Allow ourselves to write Text literals.
{-# LANGUAGE OverloadedStrings #-}

data Coord = Coord { x :: Double, y :: Double }

instance FromJSON Coord where
    parseJSON (Object v) = Coord
        <$> v .: "x"
        <*> v .: "y"

    -- We do not expect a non-Object value here.
    -- We could use empty to fail, but typeMismatch
    -- gives a much more informative error message.
    parseJSON invalid    =
        prependFailure "parsing Coord failed, "
            (typeMismatch "Object" invalid)

For this common case of only being concerned with a single type of JSON value, the functions withObject, withScientific, etc. are provided. Their use is to be preferred when possible, since they are more terse. Using withObject, we can rewrite the above instance (assuming the same language extension and data type) as:

instance FromJSON Coord where
    parseJSON = withObject "Coord" $ \v -> Coord
        <$> v .: "x"
        <*> v .: "y"

Instead of manually writing your FromJSON instance, there are two options to do it automatically:

Data.Aeson.TH provides Template Haskell functions which will derive an instance at compile time. The generated instance is optimized for your type so it will probably be more efficient than the following option.
The compiler can provide a default generic implementation for parseJSON.

To use the second, simply add a deriving Generic clause to your datatype and declare a FromJSON instance for your datatype without giving a definition for parseJSON.

For example, the previous example can be simplified to just:

{-# LANGUAGE DeriveGeneric #-}

import GHC.Generics

data Coord = Coord { x :: Double, y :: Double } deriving Generic

instance FromJSON Coord

The default implementation will be equivalent to parseJSON = genericParseJSON defaultOptions; if you need different options, you can customize the generic decoding by defining:

customOptions = defaultOptions
                { fieldLabelModifier = map toUpper
                }

instance FromJSON Coord where
    parseJSON = genericParseJSON customOptions

Minimal complete definition

Nothing

Methods

parseJSON :: Value -> Parser a #

parseJSONList :: Value -> Parser [a] #

Instances

FromJSON Bool
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Bool # parseJSONList :: Value -> Parser [Bool] #
FromJSON Char
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Char # parseJSONList :: Value -> Parser [Char] #
FromJSON Double
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Double # parseJSONList :: Value -> Parser [Double] #
FromJSON Float
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Float # parseJSONList :: Value -> Parser [Float] #
FromJSON Int
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Int # parseJSONList :: Value -> Parser [Int] #
FromJSON Int8
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Int8 # parseJSONList :: Value -> Parser [Int8] #
FromJSON Int16
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Int16 # parseJSONList :: Value -> Parser [Int16] #
FromJSON Int32
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Int32 # parseJSONList :: Value -> Parser [Int32] #
FromJSON Int64
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Int64 # parseJSONList :: Value -> Parser [Int64] #
FromJSON Integer	This instance includes a bounds check to prevent maliciously large inputs to fill up the memory of the target system. You can newtype `Scientific` and provide your own instance using `withScientific` if you want to allow larger inputs.
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Integer # parseJSONList :: Value -> Parser [Integer] #
FromJSON Natural
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Natural # parseJSONList :: Value -> Parser [Natural] #
FromJSON Ordering
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Ordering # parseJSONList :: Value -> Parser [Ordering] #
FromJSON Word
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Word # parseJSONList :: Value -> Parser [Word] #
FromJSON Word8
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Word8 # parseJSONList :: Value -> Parser [Word8] #
FromJSON Word16
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Word16 # parseJSONList :: Value -> Parser [Word16] #
FromJSON Word32
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Word32 # parseJSONList :: Value -> Parser [Word32] #
FromJSON Word64
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Word64 # parseJSONList :: Value -> Parser [Word64] #
FromJSON ()
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser () # parseJSONList :: Value -> Parser [()] #
FromJSON Text
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Text # parseJSONList :: Value -> Parser [Text] #
FromJSON Version
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Version # parseJSONList :: Value -> Parser [Version] #
FromJSON Scientific
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Scientific # parseJSONList :: Value -> Parser [Scientific] #
FromJSON UTCTime
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser UTCTime # parseJSONList :: Value -> Parser [UTCTime] #
FromJSON Value
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Value # parseJSONList :: Value -> Parser [Value] #
FromJSON DotNetTime
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser DotNetTime # parseJSONList :: Value -> Parser [DotNetTime] #
FromJSON Text
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Text # parseJSONList :: Value -> Parser [Text] #
FromJSON Void
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Void # parseJSONList :: Value -> Parser [Void] #
FromJSON CTime
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser CTime # parseJSONList :: Value -> Parser [CTime] #
FromJSON IntSet
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser IntSet # parseJSONList :: Value -> Parser [IntSet] #
FromJSON DiffTime	This instance includes a bounds check to prevent maliciously large inputs to fill up the memory of the target system. You can newtype `Scientific` and provide your own instance using `withScientific` if you want to allow larger inputs.
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser DiffTime # parseJSONList :: Value -> Parser [DiffTime] #
FromJSON Source
Instance details Defined in Data.Ipynb Methods parseJSON :: Value -> Parser Source # parseJSONList :: Value -> Parser [Source] #
FromJSON MimeBundle
Instance details Defined in Data.Ipynb Methods parseJSON :: Value -> Parser MimeBundle # parseJSONList :: Value -> Parser [MimeBundle] #
FromJSON CitationMode
Instance details Defined in Text.Pandoc.Definition Methods parseJSON :: Value -> Parser CitationMode # parseJSONList :: Value -> Parser [CitationMode] #
FromJSON Citation
Instance details Defined in Text.Pandoc.Definition Methods parseJSON :: Value -> Parser Citation # parseJSONList :: Value -> Parser [Citation] #
FromJSON MathType
Instance details Defined in Text.Pandoc.Definition Methods parseJSON :: Value -> Parser MathType # parseJSONList :: Value -> Parser [MathType] #
FromJSON QuoteType
Instance details Defined in Text.Pandoc.Definition Methods parseJSON :: Value -> Parser QuoteType # parseJSONList :: Value -> Parser [QuoteType] #
FromJSON Block
Instance details Defined in Text.Pandoc.Definition Methods parseJSON :: Value -> Parser Block # parseJSONList :: Value -> Parser [Block] #
FromJSON Format
Instance details Defined in Text.Pandoc.Definition Methods parseJSON :: Value -> Parser Format # parseJSONList :: Value -> Parser [Format] #
FromJSON ListNumberDelim
Instance details Defined in Text.Pandoc.Definition Methods parseJSON :: Value -> Parser ListNumberDelim # parseJSONList :: Value -> Parser [ListNumberDelim] #
FromJSON Alignment
Instance details Defined in Text.Pandoc.Definition Methods parseJSON :: Value -> Parser Alignment # parseJSONList :: Value -> Parser [Alignment] #
FromJSON MetaValue
Instance details Defined in Text.Pandoc.Definition Methods parseJSON :: Value -> Parser MetaValue # parseJSONList :: Value -> Parser [MetaValue] #
FromJSON Inline
Instance details Defined in Text.Pandoc.Definition Methods parseJSON :: Value -> Parser Inline # parseJSONList :: Value -> Parser [Inline] #
FromJSON ListNumberStyle
Instance details Defined in Text.Pandoc.Definition Methods parseJSON :: Value -> Parser ListNumberStyle # parseJSONList :: Value -> Parser [ListNumberStyle] #
FromJSON Pandoc
Instance details Defined in Text.Pandoc.Definition Methods parseJSON :: Value -> Parser Pandoc # parseJSONList :: Value -> Parser [Pandoc] #
FromJSON Term
Instance details Defined in Text.Pandoc.Translations Methods parseJSON :: Value -> Parser Term # parseJSONList :: Value -> Parser [Term] #
FromJSON Meta
Instance details Defined in Text.Pandoc.Definition Methods parseJSON :: Value -> Parser Meta # parseJSONList :: Value -> Parser [Meta] #
FromJSON Translations
Instance details Defined in Text.Pandoc.Translations Methods parseJSON :: Value -> Parser Translations # parseJSONList :: Value -> Parser [Translations] #
FromJSON ReaderOptions
Instance details Defined in Text.Pandoc.Options Methods parseJSON :: Value -> Parser ReaderOptions # parseJSONList :: Value -> Parser [ReaderOptions] #
FromJSON HTMLMathMethod
Instance details Defined in Text.Pandoc.Options Methods parseJSON :: Value -> Parser HTMLMathMethod # parseJSONList :: Value -> Parser [HTMLMathMethod] #
FromJSON CiteMethod
Instance details Defined in Text.Pandoc.Options Methods parseJSON :: Value -> Parser CiteMethod # parseJSONList :: Value -> Parser [CiteMethod] #
FromJSON ObfuscationMethod
Instance details Defined in Text.Pandoc.Options Methods parseJSON :: Value -> Parser ObfuscationMethod # parseJSONList :: Value -> Parser [ObfuscationMethod] #
FromJSON HTMLSlideVariant
Instance details Defined in Text.Pandoc.Options Methods parseJSON :: Value -> Parser HTMLSlideVariant # parseJSONList :: Value -> Parser [HTMLSlideVariant] #
FromJSON TrackChanges
Instance details Defined in Text.Pandoc.Options Methods parseJSON :: Value -> Parser TrackChanges # parseJSONList :: Value -> Parser [TrackChanges] #
FromJSON WrapOption
Instance details Defined in Text.Pandoc.Options Methods parseJSON :: Value -> Parser WrapOption # parseJSONList :: Value -> Parser [WrapOption] #
FromJSON TopLevelDivision
Instance details Defined in Text.Pandoc.Options Methods parseJSON :: Value -> Parser TopLevelDivision # parseJSONList :: Value -> Parser [TopLevelDivision] #
FromJSON ReferenceLocation
Instance details Defined in Text.Pandoc.Options Methods parseJSON :: Value -> Parser ReferenceLocation # parseJSONList :: Value -> Parser [ReferenceLocation] #
FromJSON Verbosity
Instance details Defined in Text.Pandoc.Logging Methods parseJSON :: Value -> Parser Verbosity # parseJSONList :: Value -> Parser [Verbosity] #
FromJSON Extensions
Instance details Defined in Text.Pandoc.Extensions Methods parseJSON :: Value -> Parser Extensions # parseJSONList :: Value -> Parser [Extensions] #
FromJSON Extension
Instance details Defined in Text.Pandoc.Extensions Methods parseJSON :: Value -> Parser Extension # parseJSONList :: Value -> Parser [Extension] #
FromJSON Style	The FromJSON instance for `Style` is designed so that a KDE syntax theme (JSON) can be decoded directly as a `Style`.
Instance details Defined in Skylighting.Types Methods parseJSON :: Value -> Parser Style # parseJSONList :: Value -> Parser [Style] #
FromJSON RE
Instance details Defined in Skylighting.Regex Methods parseJSON :: Value -> Parser RE # parseJSONList :: Value -> Parser [RE] #
FromJSON Color	JSON `"#1aff2b" corresponds to the color` RGB 0x1a 0xff 0x2b@.
Instance details Defined in Skylighting.Types Methods parseJSON :: Value -> Parser Color # parseJSONList :: Value -> Parser [Color] #
FromJSON TokenStyle	The keywords used in KDE syntax themes are used, e.g. `text-color` for default token color.
Instance details Defined in Skylighting.Types Methods parseJSON :: Value -> Parser TokenStyle # parseJSONList :: Value -> Parser [TokenStyle] #
FromJSON TokenType
Instance details Defined in Skylighting.Types Methods parseJSON :: Value -> Parser TokenType # parseJSONList :: Value -> Parser [TokenType] #
FromJSON ZonedTime	Supported string formats: `YYYY-MM-DD HH:MM Z` `YYYY-MM-DD HH:MM:SS Z` `YYYY-MM-DD HH:MM:SS.SSS Z` The first space may instead be a `T`, and the second space is optional. The `Z` represents UTC. The `Z` may be replaced with a time zone offset of the form `+0000` or `-08:00`, where the first two digits are hours, the `:` is optional and the second two digits (also optional) are minutes.
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser ZonedTime # parseJSONList :: Value -> Parser [ZonedTime] #
FromJSON LocalTime
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser LocalTime # parseJSONList :: Value -> Parser [LocalTime] #
FromJSON TimeOfDay
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser TimeOfDay # parseJSONList :: Value -> Parser [TimeOfDay] #
FromJSON SystemTime
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser SystemTime # parseJSONList :: Value -> Parser [SystemTime] #
FromJSON NominalDiffTime	This instance includes a bounds check to prevent maliciously large inputs to fill up the memory of the target system. You can newtype `Scientific` and provide your own instance using `withScientific` if you want to allow larger inputs.
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser NominalDiffTime # parseJSONList :: Value -> Parser [NominalDiffTime] #
FromJSON Day
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Day # parseJSONList :: Value -> Parser [Day] #
FromJSON CalendarDiffTime
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser CalendarDiffTime # parseJSONList :: Value -> Parser [CalendarDiffTime] #
FromJSON CalendarDiffDays
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser CalendarDiffDays # parseJSONList :: Value -> Parser [CalendarDiffDays] #
FromJSON DayOfWeek
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser DayOfWeek # parseJSONList :: Value -> Parser [DayOfWeek] #
FromJSON UUID
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser UUID # parseJSONList :: Value -> Parser [UUID] #
FromJSON a => FromJSON [a]
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser [a] # parseJSONList :: Value -> Parser [[a]] #
FromJSON a => FromJSON (Maybe a)
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Maybe a) # parseJSONList :: Value -> Parser [Maybe a] #
(FromJSON a, Integral a) => FromJSON (Ratio a)
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Ratio a) # parseJSONList :: Value -> Parser [Ratio a] #
(Ord a, FromJSON a) => FromJSON (Set a)
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Set a) # parseJSONList :: Value -> Parser [Set a] #
FromJSON a => FromJSON (Identity a)
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Identity a) # parseJSONList :: Value -> Parser [Identity a] #
(Storable a, FromJSON a) => FromJSON (Vector a)
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Vector a) # parseJSONList :: Value -> Parser [Vector a] #
HasResolution a => FromJSON (Fixed a)	This instance includes a bounds check to prevent maliciously large inputs to fill up the memory of the target system. You can newtype `Scientific` and provide your own instance using `withScientific` if you want to allow larger inputs.
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Fixed a) # parseJSONList :: Value -> Parser [Fixed a] #
FromJSON a => FromJSON (Min a)
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Min a) # parseJSONList :: Value -> Parser [Min a] #
FromJSON a => FromJSON (Max a)
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Max a) # parseJSONList :: Value -> Parser [Max a] #
FromJSON a => FromJSON (First a)
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (First a) # parseJSONList :: Value -> Parser [First a] #
FromJSON a => FromJSON (Last a)
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Last a) # parseJSONList :: Value -> Parser [Last a] #
FromJSON a => FromJSON (WrappedMonoid a)
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (WrappedMonoid a) # parseJSONList :: Value -> Parser [WrappedMonoid a] #
FromJSON a => FromJSON (Option a)
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Option a) # parseJSONList :: Value -> Parser [Option a] #
FromJSON a => FromJSON (First a)
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (First a) # parseJSONList :: Value -> Parser [First a] #
FromJSON a => FromJSON (Last a)
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Last a) # parseJSONList :: Value -> Parser [Last a] #
FromJSON a => FromJSON (Dual a)
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Dual a) # parseJSONList :: Value -> Parser [Dual a] #
FromJSON a => FromJSON (NonEmpty a)
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (NonEmpty a) # parseJSONList :: Value -> Parser [NonEmpty a] #
FromJSON a => FromJSON (IntMap a)
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (IntMap a) # parseJSONList :: Value -> Parser [IntMap a] #
FromJSON v => FromJSON (Tree v)
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Tree v) # parseJSONList :: Value -> Parser [Tree v] #
FromJSON a => FromJSON (Seq a)
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Seq a) # parseJSONList :: Value -> Parser [Seq a] #
FromJSON a => FromJSON (DList a)
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (DList a) # parseJSONList :: Value -> Parser [DList a] #
FromJSON (Notebook NbV3)
Instance details Defined in Data.Ipynb Methods parseJSON :: Value -> Parser (Notebook NbV3) # parseJSONList :: Value -> Parser [Notebook NbV3] #
FromJSON (Notebook NbV4)
Instance details Defined in Data.Ipynb Methods parseJSON :: Value -> Parser (Notebook NbV4) # parseJSONList :: Value -> Parser [Notebook NbV4] #
FromJSON (Cell NbV3)
Instance details Defined in Data.Ipynb Methods parseJSON :: Value -> Parser (Cell NbV3) # parseJSONList :: Value -> Parser [Cell NbV3] #
FromJSON (Cell NbV4)
Instance details Defined in Data.Ipynb Methods parseJSON :: Value -> Parser (Cell NbV4) # parseJSONList :: Value -> Parser [Cell NbV4] #
FromJSON (Output NbV3)
Instance details Defined in Data.Ipynb Methods parseJSON :: Value -> Parser (Output NbV3) # parseJSONList :: Value -> Parser [Output NbV3] #
FromJSON (Output NbV4)
Instance details Defined in Data.Ipynb Methods parseJSON :: Value -> Parser (Output NbV4) # parseJSONList :: Value -> Parser [Output NbV4] #
(Prim a, FromJSON a) => FromJSON (Vector a)
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Vector a) # parseJSONList :: Value -> Parser [Vector a] #
(Vector Vector a, FromJSON a) => FromJSON (Vector a)
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Vector a) # parseJSONList :: Value -> Parser [Vector a] #
(Eq a, Hashable a, FromJSON a) => FromJSON (HashSet a)
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (HashSet a) # parseJSONList :: Value -> Parser [HashSet a] #
FromJSON a => FromJSON (Vector a)
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Vector a) # parseJSONList :: Value -> Parser [Vector a] #
(Prim a, FromJSON a) => FromJSON (PrimArray a)
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (PrimArray a) # parseJSONList :: Value -> Parser [PrimArray a] #
FromJSON a => FromJSON (SmallArray a)
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (SmallArray a) # parseJSONList :: Value -> Parser [SmallArray a] #
FromJSON a => FromJSON (Array a)
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Array a) # parseJSONList :: Value -> Parser [Array a] #
(FromJSON a, FromJSON b) => FromJSON (Either a b)
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Either a b) # parseJSONList :: Value -> Parser [Either a b] #
(FromJSON a, FromJSON b) => FromJSON (a, b)
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (a, b) # parseJSONList :: Value -> Parser [(a, b)] #
(FromJSONKey k, Ord k, FromJSON v) => FromJSON (Map k v)
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Map k v) # parseJSONList :: Value -> Parser [Map k v] #
(FromJSON v, FromJSONKey k, Eq k, Hashable k) => FromJSON (HashMap k v)
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (HashMap k v) # parseJSONList :: Value -> Parser [HashMap k v] #
FromJSON (Proxy a)
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Proxy a) # parseJSONList :: Value -> Parser [Proxy a] #
(FromJSON a, FromJSON b, FromJSON c) => FromJSON (a, b, c)
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (a, b, c) # parseJSONList :: Value -> Parser [(a, b, c)] #
FromJSON a => FromJSON (Const a b)
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Const a b) # parseJSONList :: Value -> Parser [Const a b] #
FromJSON b => FromJSON (Tagged a b)
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Tagged a b) # parseJSONList :: Value -> Parser [Tagged a b] #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d) => FromJSON (a, b, c, d)
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (a, b, c, d) # parseJSONList :: Value -> Parser [(a, b, c, d)] #
(FromJSON1 f, FromJSON1 g, FromJSON a) => FromJSON (Product f g a)
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Product f g a) # parseJSONList :: Value -> Parser [Product f g a] #
(FromJSON1 f, FromJSON1 g, FromJSON a) => FromJSON (Sum f g a)
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Sum f g a) # parseJSONList :: Value -> Parser [Sum f g a] #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e) => FromJSON (a, b, c, d, e)
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (a, b, c, d, e) # parseJSONList :: Value -> Parser [(a, b, c, d, e)] #
(FromJSON1 f, FromJSON1 g, FromJSON a) => FromJSON (Compose f g a)
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Compose f g a) # parseJSONList :: Value -> Parser [Compose f g a] #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f) => FromJSON (a, b, c, d, e, f)
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (a, b, c, d, e, f) # parseJSONList :: Value -> Parser [(a, b, c, d, e, f)] #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f, FromJSON g) => FromJSON (a, b, c, d, e, f, g)
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (a, b, c, d, e, f, g) # parseJSONList :: Value -> Parser [(a, b, c, d, e, f, g)] #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f, FromJSON g, FromJSON h) => FromJSON (a, b, c, d, e, f, g, h)
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (a, b, c, d, e, f, g, h) # parseJSONList :: Value -> Parser [(a, b, c, d, e, f, g, h)] #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f, FromJSON g, FromJSON h, FromJSON i) => FromJSON (a, b, c, d, e, f, g, h, i)
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (a, b, c, d, e, f, g, h, i) # parseJSONList :: Value -> Parser [(a, b, c, d, e, f, g, h, i)] #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f, FromJSON g, FromJSON h, FromJSON i, FromJSON j) => FromJSON (a, b, c, d, e, f, g, h, i, j)
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (a, b, c, d, e, f, g, h, i, j) # parseJSONList :: Value -> Parser [(a, b, c, d, e, f, g, h, i, j)] #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f, FromJSON g, FromJSON h, FromJSON i, FromJSON j, FromJSON k) => FromJSON (a, b, c, d, e, f, g, h, i, j, k)
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (a, b, c, d, e, f, g, h, i, j, k) # parseJSONList :: Value -> Parser [(a, b, c, d, e, f, g, h, i, j, k)] #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f, FromJSON g, FromJSON h, FromJSON i, FromJSON j, FromJSON k, FromJSON l) => FromJSON (a, b, c, d, e, f, g, h, i, j, k, l)
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (a, b, c, d, e, f, g, h, i, j, k, l) # parseJSONList :: Value -> Parser [(a, b, c, d, e, f, g, h, i, j, k, l)] #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f, FromJSON g, FromJSON h, FromJSON i, FromJSON j, FromJSON k, FromJSON l, FromJSON m) => FromJSON (a, b, c, d, e, f, g, h, i, j, k, l, m)
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (a, b, c, d, e, f, g, h, i, j, k, l, m) # parseJSONList :: Value -> Parser [(a, b, c, d, e, f, g, h, i, j, k, l, m)] #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f, FromJSON g, FromJSON h, FromJSON i, FromJSON j, FromJSON k, FromJSON l, FromJSON m, FromJSON n) => FromJSON (a, b, c, d, e, f, g, h, i, j, k, l, m, n)
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (a, b, c, d, e, f, g, h, i, j, k, l, m, n) # parseJSONList :: Value -> Parser [(a, b, c, d, e, f, g, h, i, j, k, l, m, n)] #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f, FromJSON g, FromJSON h, FromJSON i, FromJSON j, FromJSON k, FromJSON l, FromJSON m, FromJSON n, FromJSON o) => FromJSON (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) # parseJSONList :: Value -> Parser [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)] #

class FromJSONKey a where #

Read the docs for ToJSONKey first. This class is a conversion in the opposite direction. If you have a newtype wrapper around Text, the recommended way to define instances is with generalized newtype deriving:

newtype SomeId = SomeId { getSomeId :: Text }
  deriving (Eq,Ord,Hashable,FromJSONKey)

If you have a sum of nullary constructors, you may use the generic implementation:

data Color = Red | Green | Blue
  deriving Generic

instance FromJSONKey Color where
  fromJSONKey = genericFromJSONKey defaultJSONKeyOptions

Minimal complete definition

Nothing

Methods

fromJSONKey :: FromJSONKeyFunction a #

Strategy for parsing the key of a map-like container.

fromJSONKeyList :: FromJSONKeyFunction [a] #

This is similar in spirit to the readList method of Read. It makes it possible to give Value keys special treatment without using OverlappingInstances. End users should always be able to use the default implementation of this method.

Instances

FromJSONKey Bool
Instance details Defined in Data.Aeson.Types.FromJSON Methods fromJSONKey :: FromJSONKeyFunction Bool # fromJSONKeyList :: FromJSONKeyFunction [Bool] #
FromJSONKey Char
Instance details Defined in Data.Aeson.Types.FromJSON Methods fromJSONKey :: FromJSONKeyFunction Char # fromJSONKeyList :: FromJSONKeyFunction [Char] #
FromJSONKey Double
Instance details Defined in Data.Aeson.Types.FromJSON Methods fromJSONKey :: FromJSONKeyFunction Double # fromJSONKeyList :: FromJSONKeyFunction [Double] #
FromJSONKey Float
Instance details Defined in Data.Aeson.Types.FromJSON Methods fromJSONKey :: FromJSONKeyFunction Float # fromJSONKeyList :: FromJSONKeyFunction [Float] #
FromJSONKey Int
Instance details Defined in Data.Aeson.Types.FromJSON Methods fromJSONKey :: FromJSONKeyFunction Int # fromJSONKeyList :: FromJSONKeyFunction [Int] #
FromJSONKey Int8
Instance details Defined in Data.Aeson.Types.FromJSON Methods fromJSONKey :: FromJSONKeyFunction Int8 # fromJSONKeyList :: FromJSONKeyFunction [Int8] #
FromJSONKey Int16
Instance details Defined in Data.Aeson.Types.FromJSON Methods fromJSONKey :: FromJSONKeyFunction Int16 # fromJSONKeyList :: FromJSONKeyFunction [Int16] #
FromJSONKey Int32
Instance details Defined in Data.Aeson.Types.FromJSON Methods fromJSONKey :: FromJSONKeyFunction Int32 # fromJSONKeyList :: FromJSONKeyFunction [Int32] #
FromJSONKey Int64
Instance details Defined in Data.Aeson.Types.FromJSON Methods fromJSONKey :: FromJSONKeyFunction Int64 # fromJSONKeyList :: FromJSONKeyFunction [Int64] #
FromJSONKey Integer
Instance details Defined in Data.Aeson.Types.FromJSON Methods fromJSONKey :: FromJSONKeyFunction Integer # fromJSONKeyList :: FromJSONKeyFunction [Integer] #
FromJSONKey Natural
Instance details Defined in Data.Aeson.Types.FromJSON Methods fromJSONKey :: FromJSONKeyFunction Natural # fromJSONKeyList :: FromJSONKeyFunction [Natural] #
FromJSONKey Word
Instance details Defined in Data.Aeson.Types.FromJSON Methods fromJSONKey :: FromJSONKeyFunction Word # fromJSONKeyList :: FromJSONKeyFunction [Word] #
FromJSONKey Word8
Instance details Defined in Data.Aeson.Types.FromJSON Methods fromJSONKey :: FromJSONKeyFunction Word8 # fromJSONKeyList :: FromJSONKeyFunction [Word8] #
FromJSONKey Word16
Instance details Defined in Data.Aeson.Types.FromJSON Methods fromJSONKey :: FromJSONKeyFunction Word16 # fromJSONKeyList :: FromJSONKeyFunction [Word16] #
FromJSONKey Word32
Instance details Defined in Data.Aeson.Types.FromJSON Methods fromJSONKey :: FromJSONKeyFunction Word32 # fromJSONKeyList :: FromJSONKeyFunction [Word32] #
FromJSONKey Word64
Instance details Defined in Data.Aeson.Types.FromJSON Methods fromJSONKey :: FromJSONKeyFunction Word64 # fromJSONKeyList :: FromJSONKeyFunction [Word64] #
FromJSONKey Text
Instance details Defined in Data.Aeson.Types.FromJSON Methods fromJSONKey :: FromJSONKeyFunction Text # fromJSONKeyList :: FromJSONKeyFunction [Text] #
FromJSONKey Version
Instance details Defined in Data.Aeson.Types.FromJSON Methods fromJSONKey :: FromJSONKeyFunction Version # fromJSONKeyList :: FromJSONKeyFunction [Version] #
FromJSONKey UTCTime
Instance details Defined in Data.Aeson.Types.FromJSON Methods fromJSONKey :: FromJSONKeyFunction UTCTime # fromJSONKeyList :: FromJSONKeyFunction [UTCTime] #
FromJSONKey Text
Instance details Defined in Data.Aeson.Types.FromJSON Methods fromJSONKey :: FromJSONKeyFunction Text # fromJSONKeyList :: FromJSONKeyFunction [Text] #
FromJSONKey TokenType	JSON `Keyword` corresponds to `KeywordTok`, and so on.
Instance details Defined in Skylighting.Types Methods fromJSONKey :: FromJSONKeyFunction TokenType # fromJSONKeyList :: FromJSONKeyFunction [TokenType] #
FromJSONKey ZonedTime
Instance details Defined in Data.Aeson.Types.FromJSON Methods fromJSONKey :: FromJSONKeyFunction ZonedTime # fromJSONKeyList :: FromJSONKeyFunction [ZonedTime] #
FromJSONKey LocalTime
Instance details Defined in Data.Aeson.Types.FromJSON Methods fromJSONKey :: FromJSONKeyFunction LocalTime # fromJSONKeyList :: FromJSONKeyFunction [LocalTime] #
FromJSONKey TimeOfDay
Instance details Defined in Data.Aeson.Types.FromJSON Methods fromJSONKey :: FromJSONKeyFunction TimeOfDay # fromJSONKeyList :: FromJSONKeyFunction [TimeOfDay] #
FromJSONKey Day
Instance details Defined in Data.Aeson.Types.FromJSON Methods fromJSONKey :: FromJSONKeyFunction Day # fromJSONKeyList :: FromJSONKeyFunction [Day] #
FromJSONKey DayOfWeek
Instance details Defined in Data.Aeson.Types.FromJSON Methods fromJSONKey :: FromJSONKeyFunction DayOfWeek # fromJSONKeyList :: FromJSONKeyFunction [DayOfWeek] #
FromJSONKey UUID
Instance details Defined in Data.Aeson.Types.FromJSON Methods fromJSONKey :: FromJSONKeyFunction UUID # fromJSONKeyList :: FromJSONKeyFunction [UUID] #
(FromJSONKey a, FromJSON a) => FromJSONKey [a]
Instance details Defined in Data.Aeson.Types.FromJSON Methods fromJSONKey :: FromJSONKeyFunction [a] # fromJSONKeyList :: FromJSONKeyFunction [[a]] #
FromJSONKey a => FromJSONKey (Identity a)
Instance details Defined in Data.Aeson.Types.FromJSON Methods fromJSONKey :: FromJSONKeyFunction (Identity a) # fromJSONKeyList :: FromJSONKeyFunction [Identity a] #
(FromJSON a, FromJSON b) => FromJSONKey (a, b)
Instance details Defined in Data.Aeson.Types.FromJSON Methods fromJSONKey :: FromJSONKeyFunction (a, b) # fromJSONKeyList :: FromJSONKeyFunction [(a, b)] #
(FromJSON a, FromJSON b, FromJSON c) => FromJSONKey (a, b, c)
Instance details Defined in Data.Aeson.Types.FromJSON Methods fromJSONKey :: FromJSONKeyFunction (a, b, c) # fromJSONKeyList :: FromJSONKeyFunction [(a, b, c)] #
FromJSONKey b => FromJSONKey (Tagged a b)
Instance details Defined in Data.Aeson.Types.FromJSON Methods fromJSONKey :: FromJSONKeyFunction (Tagged a b) # fromJSONKeyList :: FromJSONKeyFunction [Tagged a b] #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d) => FromJSONKey (a, b, c, d)
Instance details Defined in Data.Aeson.Types.FromJSON Methods fromJSONKey :: FromJSONKeyFunction (a, b, c, d) # fromJSONKeyList :: FromJSONKeyFunction [(a, b, c, d)] #

data FromJSONKeyFunction a #

This type is related to ToJSONKeyFunction. If FromJSONKeyValue is used in the FromJSONKey instance, then ToJSONKeyValue should be used in the ToJSONKey instance. The other three data constructors for this type all correspond to ToJSONKeyText. Strictly speaking, FromJSONKeyTextParser is more powerful than FromJSONKeyText, which is in turn more powerful than FromJSONKeyCoerce. For performance reasons, these exist as three options instead of one.

Constructors

FromJSONKeyCoerce !(CoerceText a)	uses `coerce` (`unsafeCoerce` in older GHCs)
FromJSONKeyText !(Text -> a)	conversion from `Text` that always succeeds
FromJSONKeyTextParser !(Text -> Parser a)	conversion from `Text` that may fail
FromJSONKeyValue !(Value -> Parser a)	conversion for non-textual keys

Instances

Functor FromJSONKeyFunction	Only law abiding up to interpretation
Instance details Defined in Data.Aeson.Types.FromJSON Methods fmap :: (a -> b) -> FromJSONKeyFunction a -> FromJSONKeyFunction b # (<$) :: a -> FromJSONKeyFunction b -> FromJSONKeyFunction a #

class (ConstructorNames f, SumFromString f) => GFromJSONKey (f :: Type -> Type) #

Instances

(ConstructorNames f, SumFromString f) => GFromJSONKey f
Instance details Defined in Data.Aeson.Types.FromJSON

class FromJSON1 (f :: Type -> Type) where #

Lifting of the FromJSON class to unary type constructors.

Instead of manually writing your FromJSON1 instance, there are two options to do it automatically:

Data.Aeson.TH provides Template Haskell functions which will derive an instance at compile time. The generated instance is optimized for your type so it will probably be more efficient than the following option.
The compiler can provide a default generic implementation for liftParseJSON.

To use the second, simply add a deriving Generic1 clause to your datatype and declare a FromJSON1 instance for your datatype without giving a definition for liftParseJSON.

For example:

{-# LANGUAGE DeriveGeneric #-}

import GHC.Generics

data Pair a b = Pair { pairFst :: a, pairSnd :: b } deriving Generic1

instance FromJSON a => FromJSON1 (Pair a)

If the default implementation doesn't give exactly the results you want, you can customize the generic decoding with only a tiny amount of effort, using genericLiftParseJSON with your preferred Options:

customOptions = defaultOptions
                { fieldLabelModifier = map toUpper
                }

instance FromJSON a => FromJSON1 (Pair a) where
    liftParseJSON = genericLiftParseJSON customOptions

Minimal complete definition

Nothing

Methods

liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (f a) #

liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [f a] #

Instances

FromJSON1 []
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [a] # liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [[a]] #
FromJSON1 Maybe
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (Maybe a) # liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [Maybe a] #
FromJSON1 Identity
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (Identity a) # liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [Identity a] #
FromJSON1 Min
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (Min a) # liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [Min a] #
FromJSON1 Max
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (Max a) # liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [Max a] #
FromJSON1 First
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (First a) # liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [First a] #
FromJSON1 Last
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (Last a) # liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [Last a] #
FromJSON1 WrappedMonoid
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (WrappedMonoid a) # liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [WrappedMonoid a] #
FromJSON1 Option
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (Option a) # liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [Option a] #
FromJSON1 First
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (First a) # liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [First a] #
FromJSON1 Last
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (Last a) # liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [Last a] #
FromJSON1 Dual
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (Dual a) # liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [Dual a] #
FromJSON1 NonEmpty
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (NonEmpty a) # liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [NonEmpty a] #
FromJSON1 IntMap
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (IntMap a) # liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [IntMap a] #
FromJSON1 Tree
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (Tree a) # liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [Tree a] #
FromJSON1 Seq
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (Seq a) # liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [Seq a] #
FromJSON1 DList
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (DList a) # liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [DList a] #
FromJSON1 Vector
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (Vector a) # liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [Vector a] #
FromJSON a => FromJSON1 (Either a)
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> Value -> Parser (Either a a0) # liftParseJSONList :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> Value -> Parser [Either a a0] #
FromJSON a => FromJSON1 ((,) a)
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> Value -> Parser (a, a0) # liftParseJSONList :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> Value -> Parser [(a, a0)] #
(FromJSONKey k, Ord k) => FromJSON1 (Map k)
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (Map k a) # liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [Map k a] #
(FromJSONKey k, Eq k, Hashable k) => FromJSON1 (HashMap k)
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (HashMap k a) # liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [HashMap k a] #
FromJSON1 (Proxy :: Type -> Type)
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (Proxy a) # liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [Proxy a] #
(FromJSON a, FromJSON b) => FromJSON1 ((,,) a b)
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> Value -> Parser (a, b, a0) # liftParseJSONList :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> Value -> Parser [(a, b, a0)] #
FromJSON a => FromJSON1 (Const a :: Type -> Type)
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> Value -> Parser (Const a a0) # liftParseJSONList :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> Value -> Parser [Const a a0] #
FromJSON1 (Tagged a)
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> Value -> Parser (Tagged a a0) # liftParseJSONList :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> Value -> Parser [Tagged a a0] #
(FromJSON a, FromJSON b, FromJSON c) => FromJSON1 ((,,,) a b c)
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> Value -> Parser (a, b, c, a0) # liftParseJSONList :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> Value -> Parser [(a, b, c, a0)] #
(FromJSON1 f, FromJSON1 g) => FromJSON1 (Product f g)
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (Product f g a) # liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [Product f g a] #
(FromJSON1 f, FromJSON1 g) => FromJSON1 (Sum f g)
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (Sum f g a) # liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [Sum f g a] #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d) => FromJSON1 ((,,,,) a b c d)
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> Value -> Parser (a, b, c, d, a0) # liftParseJSONList :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> Value -> Parser [(a, b, c, d, a0)] #
(FromJSON1 f, FromJSON1 g) => FromJSON1 (Compose f g)
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (Compose f g a) # liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [Compose f g a] #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e) => FromJSON1 ((,,,,,) a b c d e)
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> Value -> Parser (a, b, c, d, e, a0) # liftParseJSONList :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> Value -> Parser [(a, b, c, d, e, a0)] #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f) => FromJSON1 ((,,,,,,) a b c d e f)
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> Value -> Parser (a, b, c, d, e, f, a0) # liftParseJSONList :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> Value -> Parser [(a, b, c, d, e, f, a0)] #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f, FromJSON g) => FromJSON1 ((,,,,,,,) a b c d e f g)
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> Value -> Parser (a, b, c, d, e, f, g, a0) # liftParseJSONList :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> Value -> Parser [(a, b, c, d, e, f, g, a0)] #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f, FromJSON g, FromJSON h) => FromJSON1 ((,,,,,,,,) a b c d e f g h)
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> Value -> Parser (a, b, c, d, e, f, g, h, a0) # liftParseJSONList :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> Value -> Parser [(a, b, c, d, e, f, g, h, a0)] #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f, FromJSON g, FromJSON h, FromJSON i) => FromJSON1 ((,,,,,,,,,) a b c d e f g h i)
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> Value -> Parser (a, b, c, d, e, f, g, h, i, a0) # liftParseJSONList :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> Value -> Parser [(a, b, c, d, e, f, g, h, i, a0)] #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f, FromJSON g, FromJSON h, FromJSON i, FromJSON j) => FromJSON1 ((,,,,,,,,,,) a b c d e f g h i j)
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> Value -> Parser (a, b, c, d, e, f, g, h, i, j, a0) # liftParseJSONList :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> Value -> Parser [(a, b, c, d, e, f, g, h, i, j, a0)] #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f, FromJSON g, FromJSON h, FromJSON i, FromJSON j, FromJSON k) => FromJSON1 ((,,,,,,,,,,,) a b c d e f g h i j k)
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> Value -> Parser (a, b, c, d, e, f, g, h, i, j, k, a0) # liftParseJSONList :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> Value -> Parser [(a, b, c, d, e, f, g, h, i, j, k, a0)] #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f, FromJSON g, FromJSON h, FromJSON i, FromJSON j, FromJSON k, FromJSON l) => FromJSON1 ((,,,,,,,,,,,,) a b c d e f g h i j k l)
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> Value -> Parser (a, b, c, d, e, f, g, h, i, j, k, l, a0) # liftParseJSONList :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> Value -> Parser [(a, b, c, d, e, f, g, h, i, j, k, l, a0)] #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f, FromJSON g, FromJSON h, FromJSON i, FromJSON j, FromJSON k, FromJSON l, FromJSON m) => FromJSON1 ((,,,,,,,,,,,,,) a b c d e f g h i j k l m)
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> Value -> Parser (a, b, c, d, e, f, g, h, i, j, k, l, m, a0) # liftParseJSONList :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> Value -> Parser [(a, b, c, d, e, f, g, h, i, j, k, l, m, a0)] #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f, FromJSON g, FromJSON h, FromJSON i, FromJSON j, FromJSON k, FromJSON l, FromJSON m, FromJSON n) => FromJSON1 ((,,,,,,,,,,,,,,) a b c d e f g h i j k l m n)
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> Value -> Parser (a, b, c, d, e, f, g, h, i, j, k, l, m, n, a0) # liftParseJSONList :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> Value -> Parser [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, a0)] #

class FromJSON2 (f :: Type -> Type -> Type) where #

Lifting of the FromJSON class to binary type constructors.

Instead of manually writing your FromJSON2 instance, Data.Aeson.TH provides Template Haskell functions which will derive an instance at compile time.

Minimal complete definition

liftParseJSON2

Methods

liftParseJSON2 :: (Value -> Parser a) -> (Value -> Parser [a]) -> (Value -> Parser b) -> (Value -> Parser [b]) -> Value -> Parser (f a b) #

liftParseJSONList2 :: (Value -> Parser a) -> (Value -> Parser [a]) -> (Value -> Parser b) -> (Value -> Parser [b]) -> Value -> Parser [f a b] #

Instances

FromJSON2 Either
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON2 :: (Value -> Parser a) -> (Value -> Parser [a]) -> (Value -> Parser b) -> (Value -> Parser [b]) -> Value -> Parser (Either a b) # liftParseJSONList2 :: (Value -> Parser a) -> (Value -> Parser [a]) -> (Value -> Parser b) -> (Value -> Parser [b]) -> Value -> Parser [Either a b] #
FromJSON2 (,)
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON2 :: (Value -> Parser a) -> (Value -> Parser [a]) -> (Value -> Parser b) -> (Value -> Parser [b]) -> Value -> Parser (a, b) # liftParseJSONList2 :: (Value -> Parser a) -> (Value -> Parser [a]) -> (Value -> Parser b) -> (Value -> Parser [b]) -> Value -> Parser [(a, b)] #
FromJSON a => FromJSON2 ((,,) a)
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON2 :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> (Value -> Parser b) -> (Value -> Parser [b]) -> Value -> Parser (a, a0, b) # liftParseJSONList2 :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> (Value -> Parser b) -> (Value -> Parser [b]) -> Value -> Parser [(a, a0, b)] #
FromJSON2 (Const :: Type -> Type -> Type)
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON2 :: (Value -> Parser a) -> (Value -> Parser [a]) -> (Value -> Parser b) -> (Value -> Parser [b]) -> Value -> Parser (Const a b) # liftParseJSONList2 :: (Value -> Parser a) -> (Value -> Parser [a]) -> (Value -> Parser b) -> (Value -> Parser [b]) -> Value -> Parser [Const a b] #
FromJSON2 (Tagged :: Type -> Type -> Type)
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON2 :: (Value -> Parser a) -> (Value -> Parser [a]) -> (Value -> Parser b) -> (Value -> Parser [b]) -> Value -> Parser (Tagged a b) # liftParseJSONList2 :: (Value -> Parser a) -> (Value -> Parser [a]) -> (Value -> Parser b) -> (Value -> Parser [b]) -> Value -> Parser [Tagged a b] #
(FromJSON a, FromJSON b) => FromJSON2 ((,,,) a b)
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON2 :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> (Value -> Parser b0) -> (Value -> Parser [b0]) -> Value -> Parser (a, b, a0, b0) # liftParseJSONList2 :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> (Value -> Parser b0) -> (Value -> Parser [b0]) -> Value -> Parser [(a, b, a0, b0)] #
(FromJSON a, FromJSON b, FromJSON c) => FromJSON2 ((,,,,) a b c)
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON2 :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> (Value -> Parser b0) -> (Value -> Parser [b0]) -> Value -> Parser (a, b, c, a0, b0) # liftParseJSONList2 :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> (Value -> Parser b0) -> (Value -> Parser [b0]) -> Value -> Parser [(a, b, c, a0, b0)] #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d) => FromJSON2 ((,,,,,) a b c d)
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON2 :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> (Value -> Parser b0) -> (Value -> Parser [b0]) -> Value -> Parser (a, b, c, d, a0, b0) # liftParseJSONList2 :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> (Value -> Parser b0) -> (Value -> Parser [b0]) -> Value -> Parser [(a, b, c, d, a0, b0)] #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e) => FromJSON2 ((,,,,,,) a b c d e)
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON2 :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> (Value -> Parser b0) -> (Value -> Parser [b0]) -> Value -> Parser (a, b, c, d, e, a0, b0) # liftParseJSONList2 :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> (Value -> Parser b0) -> (Value -> Parser [b0]) -> Value -> Parser [(a, b, c, d, e, a0, b0)] #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f) => FromJSON2 ((,,,,,,,) a b c d e f)
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON2 :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> (Value -> Parser b0) -> (Value -> Parser [b0]) -> Value -> Parser (a, b, c, d, e, f, a0, b0) # liftParseJSONList2 :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> (Value -> Parser b0) -> (Value -> Parser [b0]) -> Value -> Parser [(a, b, c, d, e, f, a0, b0)] #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f, FromJSON g) => FromJSON2 ((,,,,,,,,) a b c d e f g)
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON2 :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> (Value -> Parser b0) -> (Value -> Parser [b0]) -> Value -> Parser (a, b, c, d, e, f, g, a0, b0) # liftParseJSONList2 :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> (Value -> Parser b0) -> (Value -> Parser [b0]) -> Value -> Parser [(a, b, c, d, e, f, g, a0, b0)] #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f, FromJSON g, FromJSON h) => FromJSON2 ((,,,,,,,,,) a b c d e f g h)
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON2 :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> (Value -> Parser b0) -> (Value -> Parser [b0]) -> Value -> Parser (a, b, c, d, e, f, g, h, a0, b0) # liftParseJSONList2 :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> (Value -> Parser b0) -> (Value -> Parser [b0]) -> Value -> Parser [(a, b, c, d, e, f, g, h, a0, b0)] #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f, FromJSON g, FromJSON h, FromJSON i) => FromJSON2 ((,,,,,,,,,,) a b c d e f g h i)
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON2 :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> (Value -> Parser b0) -> (Value -> Parser [b0]) -> Value -> Parser (a, b, c, d, e, f, g, h, i, a0, b0) # liftParseJSONList2 :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> (Value -> Parser b0) -> (Value -> Parser [b0]) -> Value -> Parser [(a, b, c, d, e, f, g, h, i, a0, b0)] #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f, FromJSON g, FromJSON h, FromJSON i, FromJSON j) => FromJSON2 ((,,,,,,,,,,,) a b c d e f g h i j)
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON2 :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> (Value -> Parser b0) -> (Value -> Parser [b0]) -> Value -> Parser (a, b, c, d, e, f, g, h, i, j, a0, b0) # liftParseJSONList2 :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> (Value -> Parser b0) -> (Value -> Parser [b0]) -> Value -> Parser [(a, b, c, d, e, f, g, h, i, j, a0, b0)] #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f, FromJSON g, FromJSON h, FromJSON i, FromJSON j, FromJSON k) => FromJSON2 ((,,,,,,,,,,,,) a b c d e f g h i j k)
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON2 :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> (Value -> Parser b0) -> (Value -> Parser [b0]) -> Value -> Parser (a, b, c, d, e, f, g, h, i, j, k, a0, b0) # liftParseJSONList2 :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> (Value -> Parser b0) -> (Value -> Parser [b0]) -> Value -> Parser [(a, b, c, d, e, f, g, h, i, j, k, a0, b0)] #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f, FromJSON g, FromJSON h, FromJSON i, FromJSON j, FromJSON k, FromJSON l) => FromJSON2 ((,,,,,,,,,,,,,) a b c d e f g h i j k l)
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON2 :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> (Value -> Parser b0) -> (Value -> Parser [b0]) -> Value -> Parser (a, b, c, d, e, f, g, h, i, j, k, l, a0, b0) # liftParseJSONList2 :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> (Value -> Parser b0) -> (Value -> Parser [b0]) -> Value -> Parser [(a, b, c, d, e, f, g, h, i, j, k, l, a0, b0)] #
(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f, FromJSON g, FromJSON h, FromJSON i, FromJSON j, FromJSON k, FromJSON l, FromJSON m) => FromJSON2 ((,,,,,,,,,,,,,,) a b c d e f g h i j k l m)
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON2 :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> (Value -> Parser b0) -> (Value -> Parser [b0]) -> Value -> Parser (a, b, c, d, e, f, g, h, i, j, k, l, m, a0, b0) # liftParseJSONList2 :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> (Value -> Parser b0) -> (Value -> Parser [b0]) -> Value -> Parser [(a, b, c, d, e, f, g, h, i, j, k, l, m, a0, b0)] #

json' :: Parser Value #

Parse any JSON value.

This is a strict version of json which avoids building up thunks during parsing; it performs all conversions immediately. Prefer this version if most of the JSON data needs to be accessed.

This function is an alias for value'. In aeson 0.8 and earlier, it parsed only object or array types, in conformance with the now-obsolete RFC 4627.

Warning

If an object contains duplicate keys, only the first one will be kept. For a more flexible alternative, see jsonWith'.

json :: Parser Value #

Parse any JSON value.

The conversion of a parsed value to a Haskell value is deferred until the Haskell value is needed. This may improve performance if only a subset of the results of conversions are needed, but at a cost in thunk allocation.

This function is an alias for value. In aeson 0.8 and earlier, it parsed only object or array types, in conformance with the now-obsolete RFC 4627.

Warning

If an object contains duplicate keys, only the first one will be kept. For a more flexible alternative, see jsonWith.

camelTo2 :: Char -> String -> String #

Better version of camelTo. Example where it works better:

camelTo '_' 'CamelAPICase' == "camel_apicase"
camelTo2 '_' 'CamelAPICase' == "camel_api_case"

defaultJSONKeyOptions :: JSONKeyOptions #

Default JSONKeyOptions:

defaultJSONKeyOptions = JSONKeyOptions
                        { keyModifier = id
                        }

defaultTaggedObject :: SumEncoding #

Default TaggedObject SumEncoding options:

defaultTaggedObject = TaggedObject
                      { tagFieldName      = "tag"
                      , contentsFieldName = "contents"
                      }

defaultOptions :: Options #

Default encoding Options:

Options
{ fieldLabelModifier      = id
, constructorTagModifier  = id
, allNullaryToStringTag   = True
, omitNothingFields       = False
, sumEncoding             = defaultTaggedObject
, unwrapUnaryRecords      = False
, tagSingleConstructors   = False
}

(<?>) :: Parser a -> JSONPathElement -> Parser a #

Add JSON Path context to a parser

When parsing a complex structure, it helps to annotate (sub)parsers with context, so that if an error occurs, you can find its location.

withObject "Person" $ \o ->
  Person
    <$> o .: "name" <?> Key "name"
    <*> o .: "age"  <?> Key "age"

(Standard methods like '(.:)' already do this.)

With such annotations, if an error occurs, you will get a JSON Path location of that error.

Since 0.10

object :: [Pair] -> Value #

Create a Value from a list of name/value Pairs. If duplicate keys arise, earlier keys and their associated values win.

type JSONPath = [JSONPathElement] #

data Result a #

The result of running a Parser.

Constructors

Error String
Success a

Instances

Monad Result
Instance details Defined in Data.Aeson.Types.Internal Methods (>>=) :: Result a -> (a -> Result b) -> Result b # (>>) :: Result a -> Result b -> Result b # return :: a -> Result a # fail :: String -> Result a #
Functor Result
Instance details Defined in Data.Aeson.Types.Internal Methods fmap :: (a -> b) -> Result a -> Result b # (<$) :: a -> Result b -> Result a #
MonadFail Result
Instance details Defined in Data.Aeson.Types.Internal Methods fail :: String -> Result a #
Applicative Result
Instance details Defined in Data.Aeson.Types.Internal Methods pure :: a -> Result a # (<>) :: Result (a -> b) -> Result a -> Result b # liftA2 :: (a -> b -> c) -> Result a -> Result b -> Result c # (>) :: Result a -> Result b -> Result b # (<*) :: Result a -> Result b -> Result a #
Foldable Result
Instance details Defined in Data.Aeson.Types.Internal Methods fold :: Monoid m => Result m -> m # foldMap :: Monoid m => (a -> m) -> Result a -> m # foldr :: (a -> b -> b) -> b -> Result a -> b # foldr' :: (a -> b -> b) -> b -> Result a -> b # foldl :: (b -> a -> b) -> b -> Result a -> b # foldl' :: (b -> a -> b) -> b -> Result a -> b # foldr1 :: (a -> a -> a) -> Result a -> a # foldl1 :: (a -> a -> a) -> Result a -> a # toList :: Result a -> [a] # null :: Result a -> Bool # length :: Result a -> Int # elem :: Eq a => a -> Result a -> Bool # maximum :: Ord a => Result a -> a # minimum :: Ord a => Result a -> a # sum :: Num a => Result a -> a # product :: Num a => Result a -> a #
Traversable Result
Instance details Defined in Data.Aeson.Types.Internal Methods traverse :: Applicative f => (a -> f b) -> Result a -> f (Result b) # sequenceA :: Applicative f => Result (f a) -> f (Result a) # mapM :: Monad m => (a -> m b) -> Result a -> m (Result b) # sequence :: Monad m => Result (m a) -> m (Result a) #
MonadPlus Result
Instance details Defined in Data.Aeson.Types.Internal Methods mzero :: Result a # mplus :: Result a -> Result a -> Result a #
Alternative Result
Instance details Defined in Data.Aeson.Types.Internal Methods empty :: Result a # (<\|>) :: Result a -> Result a -> Result a # some :: Result a -> Result [a] # many :: Result a -> Result [a] #
Eq a => Eq (Result a)
Instance details Defined in Data.Aeson.Types.Internal Methods (==) :: Result a -> Result a -> Bool # (/=) :: Result a -> Result a -> Bool #
Show a => Show (Result a)
Instance details Defined in Data.Aeson.Types.Internal Methods showsPrec :: Int -> Result a -> ShowS # show :: Result a -> String # showList :: [Result a] -> ShowS #
Semigroup (Result a)
Instance details Defined in Data.Aeson.Types.Internal Methods (<>) :: Result a -> Result a -> Result a # sconcat :: NonEmpty (Result a) -> Result a # stimes :: Integral b => b -> Result a -> Result a #
Monoid (Result a)
Instance details Defined in Data.Aeson.Types.Internal Methods mempty :: Result a # mappend :: Result a -> Result a -> Result a # mconcat :: [Result a] -> Result a #
NFData a => NFData (Result a)
Instance details Defined in Data.Aeson.Types.Internal Methods rnf :: Result a -> () #

type Object = HashMap Text Value #

A JSON "object" (key/value map).

type Array = Vector Value #

A JSON "array" (sequence).

data Value #

A JSON value represented as a Haskell value.

Constructors

Object !Object
Array !Array
String !Text
Number !Scientific
Bool !Bool
Null

Instances

Eq Value
Instance details Defined in Data.Aeson.Types.Internal Methods (==) :: Value -> Value -> Bool # (/=) :: Value -> Value -> Bool #
Data Value
Instance details Defined in Data.Aeson.Types.Internal Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Value -> c Value # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Value # toConstr :: Value -> Constr # dataTypeOf :: Value -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Value) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Value) # gmapT :: (forall b. Data b => b -> b) -> Value -> Value # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Value -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Value -> r # gmapQ :: (forall d. Data d => d -> u) -> Value -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Value -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Value -> m Value # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Value -> m Value # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Value -> m Value #
Read Value
Instance details Defined in Data.Aeson.Types.Internal Methods readsPrec :: Int -> ReadS Value # readList :: ReadS [Value] # readPrec :: ReadPrec Value # readListPrec :: ReadPrec [Value] #
Show Value
Instance details Defined in Data.Aeson.Types.Internal Methods showsPrec :: Int -> Value -> ShowS # show :: Value -> String # showList :: [Value] -> ShowS #
IsString Value
Instance details Defined in Data.Aeson.Types.Internal Methods fromString :: String -> Value #
Generic Value
Instance details Defined in Data.Aeson.Types.Internal Associated Types type Rep Value :: Type -> Type # Methods from :: Value -> Rep Value x # to :: Rep Value x -> Value #
Lift Value
Instance details Defined in Data.Aeson.Types.Internal Methods lift :: Value -> Q Exp #
Hashable Value
Instance details Defined in Data.Aeson.Types.Internal Methods hashWithSalt :: Int -> Value -> Int # hash :: Value -> Int #
ToJSON Value
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Value -> Value # toEncoding :: Value -> Encoding # toJSONList :: [Value] -> Value # toEncodingList :: [Value] -> Encoding #
KeyValue Object	Constructs a singleton `HashMap`. For calling functions that demand an `Object` for constructing objects. To be used in conjunction with `mconcat`. Prefer to use `object` where possible.
Instance details Defined in Data.Aeson.Types.ToJSON Methods (.=) :: ToJSON v => Text -> v -> Object #
KeyValue Pair
Instance details Defined in Data.Aeson.Types.ToJSON Methods (.=) :: ToJSON v => Text -> v -> Pair #
FromJSON Value
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Value # parseJSONList :: Value -> Parser [Value] #
NFData Value
Instance details Defined in Data.Aeson.Types.Internal Methods rnf :: Value -> () #
AsNumber Value
Instance details Defined in Data.Aeson.Lens Methods _Number :: Prism' Value Scientific # _Double :: Prism' Value Double # _Integer :: Prism' Value Integer #
AsPrimitive Value
Instance details Defined in Data.Aeson.Lens Methods _Primitive :: Prism' Value Primitive # _String :: Prism' Value Text # _Bool :: Prism' Value Bool # _Null :: Prism' Value () #
AsValue Value
Instance details Defined in Data.Aeson.Lens Methods _Value :: Prism' Value Value # _Object :: Prism' Value (HashMap Text Value) # _Array :: Prism' Value (Vector Value) #
AsJSON Value
Instance details Defined in Data.Aeson.Lens Methods _JSON :: (FromJSON a, ToJSON b) => Prism Value Value a b #
ToMustache Value
Instance details Defined in Text.Mustache.Internal.Types Methods toMustache :: Value -> Value0 # listToMustache :: [Value] -> Value0
FromString Encoding
Instance details Defined in Data.Aeson.Types.ToJSON Methods fromString :: String -> Encoding
FromString Value
Instance details Defined in Data.Aeson.Types.ToJSON Methods fromString :: String -> Value
GToJSON Encoding arity (U1 :: Type -> Type)
Instance details Defined in Data.Aeson.Types.ToJSON Methods gToJSON :: Options -> ToArgs Encoding arity a -> U1 a -> Encoding
GToJSON Value arity (V1 :: Type -> Type)
Instance details Defined in Data.Aeson.Types.ToJSON Methods gToJSON :: Options -> ToArgs Value arity a -> V1 a -> Value
GToJSON Value arity (U1 :: Type -> Type)
Instance details Defined in Data.Aeson.Types.ToJSON Methods gToJSON :: Options -> ToArgs Value arity a -> U1 a -> Value
ToJSON1 f => GToJSON Encoding One (Rec1 f)
Instance details Defined in Data.Aeson.Types.ToJSON Methods gToJSON :: Options -> ToArgs Encoding One a -> Rec1 f a -> Encoding
ToJSON1 f => GToJSON Value One (Rec1 f)
Instance details Defined in Data.Aeson.Types.ToJSON Methods gToJSON :: Options -> ToArgs Value One a -> Rec1 f a -> Value
ToJSON a => GToJSON Encoding arity (K1 i a :: Type -> Type)
Instance details Defined in Data.Aeson.Types.ToJSON Methods gToJSON :: Options -> ToArgs Encoding arity a0 -> K1 i a a0 -> Encoding
(EncodeProduct arity a, EncodeProduct arity b) => GToJSON Encoding arity (a :*: b)
Instance details Defined in Data.Aeson.Types.ToJSON Methods gToJSON :: Options -> ToArgs Encoding arity a0 -> (a :*: b) a0 -> Encoding
ToJSON a => GToJSON Value arity (K1 i a :: Type -> Type)
Instance details Defined in Data.Aeson.Types.ToJSON Methods gToJSON :: Options -> ToArgs Value arity a0 -> K1 i a a0 -> Value
(WriteProduct arity a, WriteProduct arity b, ProductSize a, ProductSize b) => GToJSON Value arity (a :*: b)
Instance details Defined in Data.Aeson.Types.ToJSON Methods gToJSON :: Options -> ToArgs Value arity a0 -> (a :*: b) a0 -> Value
(ToJSON1 f, GToJSON Encoding One g) => GToJSON Encoding One (f :.: g)
Instance details Defined in Data.Aeson.Types.ToJSON Methods gToJSON :: Options -> ToArgs Encoding One a -> (f :.: g) a -> Encoding
(ToJSON1 f, GToJSON Value One g) => GToJSON Value One (f :.: g)
Instance details Defined in Data.Aeson.Types.ToJSON Methods gToJSON :: Options -> ToArgs Value One a -> (f :.: g) a -> Value
FromPairs Value (DList Pair)
Instance details Defined in Data.Aeson.Types.ToJSON Methods fromPairs :: DList Pair -> Value
v ~ Value => KeyValuePair v (DList Pair)
Instance details Defined in Data.Aeson.Types.ToJSON Methods pair :: String -> v -> DList Pair
(GToJSON Encoding arity a, ConsToJSON Encoding arity a, Constructor c) => SumToJSON' TwoElemArray Encoding arity (C1 c a)
Instance details Defined in Data.Aeson.Types.ToJSON Methods sumToJSON' :: Options -> ToArgs Encoding arity a0 -> C1 c a a0 -> Tagged TwoElemArray Encoding
(GToJSON Value arity a, ConsToJSON Value arity a, Constructor c) => SumToJSON' TwoElemArray Value arity (C1 c a)
Instance details Defined in Data.Aeson.Types.ToJSON Methods sumToJSON' :: Options -> ToArgs Value arity a0 -> C1 c a a0 -> Tagged TwoElemArray Value
type Rep Value
Instance details Defined in Data.Aeson.Types.Internal type Rep Value = D1 (MetaData "Value" "Data.Aeson.Types.Internal" "aeson-1.4.6.0-1XnxcetEtfUG8O3EDchcas" False) ((C1 (MetaCons "Object" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 Object)) :+: (C1 (MetaCons "Array" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 Array)) :+: C1 (MetaCons "String" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 Text)))) :+: (C1 (MetaCons "Number" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 Scientific)) :+: (C1 (MetaCons "Bool" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 Bool)) :+: C1 (MetaCons "Null" PrefixI False) (U1 :: Type -> Type))))
type Index Value
Instance details Defined in Data.Aeson.Lens type Index Value = Text
type IxValue Value
Instance details Defined in Data.Aeson.Lens type IxValue Value = Value

newtype DotNetTime #

A newtype wrapper for UTCTime that uses the same non-standard serialization format as Microsoft .NET, whose System.DateTime type is by default serialized to JSON as in the following example:

/Date(1302547608878)/

The number represents milliseconds since the Unix epoch.

Constructors

DotNetTime
Fields fromDotNetTime :: UTCTime Acquire the underlying value.

Instances

Eq DotNetTime
Instance details Defined in Data.Aeson.Types.Internal Methods (==) :: DotNetTime -> DotNetTime -> Bool # (/=) :: DotNetTime -> DotNetTime -> Bool #
Ord DotNetTime
Instance details Defined in Data.Aeson.Types.Internal Methods compare :: DotNetTime -> DotNetTime -> Ordering # (<) :: DotNetTime -> DotNetTime -> Bool # (<=) :: DotNetTime -> DotNetTime -> Bool # (>) :: DotNetTime -> DotNetTime -> Bool # (>=) :: DotNetTime -> DotNetTime -> Bool # max :: DotNetTime -> DotNetTime -> DotNetTime # min :: DotNetTime -> DotNetTime -> DotNetTime #
Read DotNetTime
Instance details Defined in Data.Aeson.Types.Internal Methods readsPrec :: Int -> ReadS DotNetTime # readList :: ReadS [DotNetTime] # readPrec :: ReadPrec DotNetTime # readListPrec :: ReadPrec [DotNetTime] #
Show DotNetTime
Instance details Defined in Data.Aeson.Types.Internal Methods showsPrec :: Int -> DotNetTime -> ShowS # show :: DotNetTime -> String # showList :: [DotNetTime] -> ShowS #
ToJSON DotNetTime
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: DotNetTime -> Value # toEncoding :: DotNetTime -> Encoding # toJSONList :: [DotNetTime] -> Value # toEncodingList :: [DotNetTime] -> Encoding #
FromJSON DotNetTime
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser DotNetTime # parseJSONList :: Value -> Parser [DotNetTime] #
FormatTime DotNetTime
Instance details Defined in Data.Aeson.Types.Internal Methods formatCharacter :: Char -> Maybe (TimeLocale -> Maybe NumericPadOption -> Maybe Int -> DotNetTime -> String) #

data Options #

Options that specify how to encode/decode your datatype to/from JSON.

Options can be set using record syntax on defaultOptions with the fields below.

Instances

Show Options
Instance details Defined in Data.Aeson.Types.Internal Methods showsPrec :: Int -> Options -> ShowS # show :: Options -> String # showList :: [Options] -> ShowS #

data SumEncoding #

Specifies how to encode constructors of a sum datatype.

Constructors

TaggedObject	A constructor will be encoded to an object with a field `tagFieldName` which specifies the constructor tag (modified by the `constructorTagModifier`). If the constructor is a record the encoded record fields will be unpacked into this object. So make sure that your record doesn't have a field with the same label as the `tagFieldName`. Otherwise the tag gets overwritten by the encoded value of that field! If the constructor is not a record the encoded constructor contents will be stored under the `contentsFieldName` field.
Fields tagFieldName :: String contentsFieldName :: String
UntaggedValue	Constructor names won't be encoded. Instead only the contents of the constructor will be encoded as if the type had a single constructor. JSON encodings have to be disjoint for decoding to work properly. When decoding, constructors are tried in the order of definition. If some encodings overlap, the first one defined will succeed. Note: Nullary constructors are encoded as strings (using `constructorTagModifier`). Having a nullary constructor alongside a single field constructor that encodes to a string leads to ambiguity. Note: Only the last error is kept when decoding, so in the case of malformed JSON, only an error for the last constructor will be reported.
ObjectWithSingleField	A constructor will be encoded to an object with a single field named after the constructor tag (modified by the `constructorTagModifier`) which maps to the encoded contents of the constructor.
TwoElemArray	A constructor will be encoded to a 2-element array where the first element is the tag of the constructor (modified by the `constructorTagModifier`) and the second element the encoded contents of the constructor.

Instances

Eq SumEncoding
Instance details Defined in Data.Aeson.Types.Internal Methods (==) :: SumEncoding -> SumEncoding -> Bool # (/=) :: SumEncoding -> SumEncoding -> Bool #
Show SumEncoding
Instance details Defined in Data.Aeson.Types.Internal Methods showsPrec :: Int -> SumEncoding -> ShowS # show :: SumEncoding -> String # showList :: [SumEncoding] -> ShowS #

data JSONKeyOptions #

Options for encoding keys with genericFromJSONKey and genericToJSONKey.

data Zero #

A type-level indicator that ToJSON or FromJSON is being derived generically.

data One #

A type-level indicator that ToJSON1 or FromJSON1 is being derived generically.

Instances

GFromJSON One Par1
Instance details Defined in Data.Aeson.Types.FromJSON Methods gParseJSON :: Options -> FromArgs One a -> Value -> Parser (Par1 a) #
GToJSON enc One Par1
Instance details Defined in Data.Aeson.Types.ToJSON Methods gToJSON :: Options -> ToArgs enc One a -> Par1 a -> enc
ToJSON1 f => GToJSON Encoding One (Rec1 f)
Instance details Defined in Data.Aeson.Types.ToJSON Methods gToJSON :: Options -> ToArgs Encoding One a -> Rec1 f a -> Encoding
ToJSON1 f => GToJSON Value One (Rec1 f)
Instance details Defined in Data.Aeson.Types.ToJSON Methods gToJSON :: Options -> ToArgs Value One a -> Rec1 f a -> Value
(ToJSON1 f, GToJSON Encoding One g) => GToJSON Encoding One (f :.: g)
Instance details Defined in Data.Aeson.Types.ToJSON Methods gToJSON :: Options -> ToArgs Encoding One a -> (f :.: g) a -> Encoding
(ToJSON1 f, GToJSON Value One g) => GToJSON Value One (f :.: g)
Instance details Defined in Data.Aeson.Types.ToJSON Methods gToJSON :: Options -> ToArgs Value One a -> (f :.: g) a -> Value
FromJSON1 f => GFromJSON One (Rec1 f)
Instance details Defined in Data.Aeson.Types.FromJSON Methods gParseJSON :: Options -> FromArgs One a -> Value -> Parser (Rec1 f a) #
(FromJSON1 f, GFromJSON One g) => GFromJSON One (f :.: g)
Instance details Defined in Data.Aeson.Types.FromJSON Methods gParseJSON :: Options -> FromArgs One a -> Value -> Parser ((f :.: g) a) #

class Bifunctor (p :: Type -> Type -> Type) where #

A bifunctor is a type constructor that takes two type arguments and is a functor in both arguments. That is, unlike with Functor, a type constructor such as Either does not need to be partially applied for a Bifunctor instance, and the methods in this class permit mapping functions over the Left value or the Right value, or both at the same time.

Formally, the class Bifunctor represents a bifunctor from Hask -> Hask.

Intuitively it is a bifunctor where both the first and second arguments are covariant.

You can define a Bifunctor by either defining bimap or by defining both first and second.

If you supply bimap, you should ensure that:

bimap id id ≡ id

If you supply first and second, ensure:

first id ≡ id
second id ≡ id

If you supply both, you should also ensure:

bimap f g ≡ first f . second g

These ensure by parametricity:

bimap  (f . g) (h . i) ≡ bimap f h . bimap g i
first  (f . g) ≡ first  f . first  g
second (f . g) ≡ second f . second g

Since: base-4.8.0.0

Minimal complete definition

bimap | first, second

Methods

bimap :: (a -> b) -> (c -> d) -> p a c -> p b d #

Map over both arguments at the same time.

bimap f g ≡ first f . second g

Examples

Expand

>>> bimap toUpper (+1) ('j', 3)
('J',4)

>>> bimap toUpper (+1) (Left 'j')
Left 'J'

>>> bimap toUpper (+1) (Right 3)
Right 4

Instances

Bifunctor Either	Since: base-4.8.0.0
Instance details Defined in Data.Bifunctor Methods bimap :: (a -> b) -> (c -> d) -> Either a c -> Either b d # first :: (a -> b) -> Either a c -> Either b c # second :: (b -> c) -> Either a b -> Either a c #
Bifunctor (,)	Since: base-4.8.0.0
Instance details Defined in Data.Bifunctor Methods bimap :: (a -> b) -> (c -> d) -> (a, c) -> (b, d) # first :: (a -> b) -> (a, c) -> (b, c) # second :: (b -> c) -> (a, b) -> (a, c) #
Bifunctor Arg	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods bimap :: (a -> b) -> (c -> d) -> Arg a c -> Arg b d # first :: (a -> b) -> Arg a c -> Arg b c # second :: (b -> c) -> Arg a b -> Arg a c #
Bifunctor ((,,) x1)	Since: base-4.8.0.0
Instance details Defined in Data.Bifunctor Methods bimap :: (a -> b) -> (c -> d) -> (x1, a, c) -> (x1, b, d) # first :: (a -> b) -> (x1, a, c) -> (x1, b, c) # second :: (b -> c) -> (x1, a, b) -> (x1, a, c) #
Bifunctor (Const :: Type -> Type -> Type)	Since: base-4.8.0.0
Instance details Defined in Data.Bifunctor Methods bimap :: (a -> b) -> (c -> d) -> Const a c -> Const b d # first :: (a -> b) -> Const a c -> Const b c # second :: (b -> c) -> Const a b -> Const a c #
Functor f => Bifunctor (FreeF f)
Instance details Defined in Control.Monad.Trans.Free Methods bimap :: (a -> b) -> (c -> d) -> FreeF f a c -> FreeF f b d # first :: (a -> b) -> FreeF f a c -> FreeF f b c # second :: (b -> c) -> FreeF f a b -> FreeF f a c #
Functor f => Bifunctor (CofreeF f)
Instance details Defined in Control.Comonad.Trans.Cofree Methods bimap :: (a -> b) -> (c -> d) -> CofreeF f a c -> CofreeF f b d # first :: (a -> b) -> CofreeF f a c -> CofreeF f b c # second :: (b -> c) -> CofreeF f a b -> CofreeF f a c #
Functor f => Bifunctor (AlongsideLeft f)
Instance details Defined in Control.Lens.Internal.Getter Methods bimap :: (a -> b) -> (c -> d) -> AlongsideLeft f a c -> AlongsideLeft f b d # first :: (a -> b) -> AlongsideLeft f a c -> AlongsideLeft f b c # second :: (b -> c) -> AlongsideLeft f a b -> AlongsideLeft f a c #
Functor f => Bifunctor (AlongsideRight f)
Instance details Defined in Control.Lens.Internal.Getter Methods bimap :: (a -> b) -> (c -> d) -> AlongsideRight f a c -> AlongsideRight f b d # first :: (a -> b) -> AlongsideRight f a c -> AlongsideRight f b c # second :: (b -> c) -> AlongsideRight f a b -> AlongsideRight f a c #
Bifunctor (Tagged :: Type -> Type -> Type)
Instance details Defined in Data.Tagged Methods bimap :: (a -> b) -> (c -> d) -> Tagged a c -> Tagged b d # first :: (a -> b) -> Tagged a c -> Tagged b c # second :: (b -> c) -> Tagged a b -> Tagged a c #
Bifunctor (K1 i :: Type -> Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Bifunctor Methods bimap :: (a -> b) -> (c -> d) -> K1 i a c -> K1 i b d # first :: (a -> b) -> K1 i a c -> K1 i b c # second :: (b -> c) -> K1 i a b -> K1 i a c #
Bifunctor ((,,,) x1 x2)	Since: base-4.8.0.0
Instance details Defined in Data.Bifunctor Methods bimap :: (a -> b) -> (c -> d) -> (x1, x2, a, c) -> (x1, x2, b, d) # first :: (a -> b) -> (x1, x2, a, c) -> (x1, x2, b, c) # second :: (b -> c) -> (x1, x2, a, b) -> (x1, x2, a, c) #
Bifunctor ((,,,,) x1 x2 x3)	Since: base-4.8.0.0
Instance details Defined in Data.Bifunctor Methods bimap :: (a -> b) -> (c -> d) -> (x1, x2, x3, a, c) -> (x1, x2, x3, b, d) # first :: (a -> b) -> (x1, x2, x3, a, c) -> (x1, x2, x3, b, c) # second :: (b -> c) -> (x1, x2, x3, a, b) -> (x1, x2, x3, a, c) #
Bifunctor p => Bifunctor (WrappedBifunctor p)
Instance details Defined in Data.Bifunctor.Wrapped Methods bimap :: (a -> b) -> (c -> d) -> WrappedBifunctor p a c -> WrappedBifunctor p b d # first :: (a -> b) -> WrappedBifunctor p a c -> WrappedBifunctor p b c # second :: (b -> c) -> WrappedBifunctor p a b -> WrappedBifunctor p a c #
Functor g => Bifunctor (Joker g :: Type -> Type -> Type)
Instance details Defined in Data.Bifunctor.Joker Methods bimap :: (a -> b) -> (c -> d) -> Joker g a c -> Joker g b d # first :: (a -> b) -> Joker g a c -> Joker g b c # second :: (b -> c) -> Joker g a b -> Joker g a c #
Bifunctor p => Bifunctor (Flip p)
Instance details Defined in Data.Bifunctor.Flip Methods bimap :: (a -> b) -> (c -> d) -> Flip p a c -> Flip p b d # first :: (a -> b) -> Flip p a c -> Flip p b c # second :: (b -> c) -> Flip p a b -> Flip p a c #
Functor f => Bifunctor (Clown f :: Type -> Type -> Type)
Instance details Defined in Data.Bifunctor.Clown Methods bimap :: (a -> b) -> (c -> d) -> Clown f a c -> Clown f b d # first :: (a -> b) -> Clown f a c -> Clown f b c # second :: (b -> c) -> Clown f a b -> Clown f a c #
Bifunctor ((,,,,,) x1 x2 x3 x4)	Since: base-4.8.0.0
Instance details Defined in Data.Bifunctor Methods bimap :: (a -> b) -> (c -> d) -> (x1, x2, x3, x4, a, c) -> (x1, x2, x3, x4, b, d) # first :: (a -> b) -> (x1, x2, x3, x4, a, c) -> (x1, x2, x3, x4, b, c) # second :: (b -> c) -> (x1, x2, x3, x4, a, b) -> (x1, x2, x3, x4, a, c) #
(Bifunctor p, Bifunctor q) => Bifunctor (Sum p q)
Instance details Defined in Data.Bifunctor.Sum Methods bimap :: (a -> b) -> (c -> d) -> Sum p q a c -> Sum p q b d # first :: (a -> b) -> Sum p q a c -> Sum p q b c # second :: (b -> c) -> Sum p q a b -> Sum p q a c #
(Bifunctor f, Bifunctor g) => Bifunctor (Product f g)
Instance details Defined in Data.Bifunctor.Product Methods bimap :: (a -> b) -> (c -> d) -> Product f g a c -> Product f g b d # first :: (a -> b) -> Product f g a c -> Product f g b c # second :: (b -> c) -> Product f g a b -> Product f g a c #
Bifunctor ((,,,,,,) x1 x2 x3 x4 x5)	Since: base-4.8.0.0
Instance details Defined in Data.Bifunctor Methods bimap :: (a -> b) -> (c -> d) -> (x1, x2, x3, x4, x5, a, c) -> (x1, x2, x3, x4, x5, b, d) # first :: (a -> b) -> (x1, x2, x3, x4, x5, a, c) -> (x1, x2, x3, x4, x5, b, c) # second :: (b -> c) -> (x1, x2, x3, x4, x5, a, b) -> (x1, x2, x3, x4, x5, a, c) #
(Functor f, Bifunctor p) => Bifunctor (Tannen f p)
Instance details Defined in Data.Bifunctor.Tannen Methods bimap :: (a -> b) -> (c -> d) -> Tannen f p a c -> Tannen f p b d # first :: (a -> b) -> Tannen f p a c -> Tannen f p b c # second :: (b -> c) -> Tannen f p a b -> Tannen f p a c #
(Bifunctor p, Functor f, Functor g) => Bifunctor (Biff p f g)
Instance details Defined in Data.Bifunctor.Biff Methods bimap :: (a -> b) -> (c -> d) -> Biff p f g a c -> Biff p f g b d # first :: (a -> b) -> Biff p f g a c -> Biff p f g b c # second :: (b -> c) -> Biff p f g a b -> Biff p f g a c #

data (a :: k) :~: (b :: k) :: forall k. k -> k -> Type where infix 4 #

Propositional equality. If a :~: b is inhabited by some terminating value, then the type a is the same as the type b. To use this equality in practice, pattern-match on the a :~: b to get out the Refl constructor; in the body of the pattern-match, the compiler knows that a ~ b.

Since: base-4.7.0.0

Constructors

Refl :: forall k (a :: k) (b :: k). a :~: a

Instances

TestEquality ((:~:) a :: k -> Type)	Since: base-4.7.0.0
Instance details Defined in Data.Type.Equality Methods testEquality :: (a :~: a0) -> (a :~: b) -> Maybe (a0 :~: b) #
a ~ b => Bounded (a :~: b)	Since: base-4.7.0.0
Instance details Defined in Data.Type.Equality Methods minBound :: a :~: b # maxBound :: a :~: b #
a ~ b => Enum (a :~: b)	Since: base-4.7.0.0
Instance details Defined in Data.Type.Equality Methods succ :: (a :~: b) -> a :~: b # pred :: (a :~: b) -> a :~: b # toEnum :: Int -> a :~: b # fromEnum :: (a :~: b) -> Int # enumFrom :: (a :~: b) -> [a :~: b] # enumFromThen :: (a :~: b) -> (a :~: b) -> [a :~: b] # enumFromTo :: (a :~: b) -> (a :~: b) -> [a :~: b] # enumFromThenTo :: (a :~: b) -> (a :~: b) -> (a :~: b) -> [a :~: b] #
Eq (a :~: b)	Since: base-4.7.0.0
Instance details Defined in Data.Type.Equality Methods (==) :: (a :~: b) -> (a :~: b) -> Bool # (/=) :: (a :~: b) -> (a :~: b) -> Bool #
Ord (a :~: b)	Since: base-4.7.0.0
Instance details Defined in Data.Type.Equality Methods compare :: (a :~: b) -> (a :~: b) -> Ordering # (<) :: (a :~: b) -> (a :~: b) -> Bool # (<=) :: (a :~: b) -> (a :~: b) -> Bool # (>) :: (a :~: b) -> (a :~: b) -> Bool # (>=) :: (a :~: b) -> (a :~: b) -> Bool # max :: (a :~: b) -> (a :~: b) -> a :~: b # min :: (a :~: b) -> (a :~: b) -> a :~: b #
a ~ b => Read (a :~: b)	Since: base-4.7.0.0
Instance details Defined in Data.Type.Equality Methods readsPrec :: Int -> ReadS (a :~: b) # readList :: ReadS [a :~: b] # readPrec :: ReadPrec (a :~: b) # readListPrec :: ReadPrec [a :~: b] #
Show (a :~: b)	Since: base-4.7.0.0
Instance details Defined in Data.Type.Equality Methods showsPrec :: Int -> (a :~: b) -> ShowS # show :: (a :~: b) -> String # showList :: [a :~: b] -> ShowS #

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

& 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 $.

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

Since: base-4.8.0.0

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

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

(</>) :: FilePath -> FilePath -> FilePath infixr 5 #

Combine two paths with a path separator. If the second path starts with a path separator or a drive letter, then it returns the second. The intention is that readFile (dir </> file) will access the same file as setCurrentDirectory dir; readFile file.

Posix:   "/directory" </> "file.ext" == "/directory/file.ext"
Windows: "/directory" </> "file.ext" == "/directory\\file.ext"
         "directory" </> "/file.ext" == "/file.ext"
Valid x => (takeDirectory x </> takeFileName x) `equalFilePath` x

Combined:

Posix:   "/" </> "test" == "/test"
Posix:   "home" </> "bob" == "home/bob"
Posix:   "x:" </> "foo" == "x:/foo"
Windows: "C:\\foo" </> "bar" == "C:\\foo\\bar"
Windows: "home" </> "bob" == "home\\bob"

Not combined:

Posix:   "home" </> "/bob" == "/bob"
Windows: "home" </> "C:\\bob" == "C:\\bob"

Not combined (tricky):

On Windows, if a filepath starts with a single slash, it is relative to the root of the current drive. In [1], this is (confusingly) referred to as an absolute path. The current behavior of </> is to never combine these forms.

Windows: "home" </> "/bob" == "/bob"
Windows: "home" </> "\\bob" == "\\bob"
Windows: "C:\\home" </> "\\bob" == "\\bob"

On Windows, from [1]: "If a file name begins with only a disk designator but not the backslash after the colon, it is interpreted as a relative path to the current directory on the drive with the specified letter." The current behavior of </> is to never combine these forms.

Windows: "D:\\foo" </> "C:bar" == "C:bar"
Windows: "C:\\foo" </> "C:bar" == "C:bar"

makeRelative :: FilePath -> FilePath -> FilePath #

Contract a filename, based on a relative path. Note that the resulting path will never introduce .. paths, as the presence of symlinks means ../b may not reach a/b if it starts from a/c. For a worked example see this blog post.

The corresponding makeAbsolute function can be found in System.Directory.

         makeRelative "/directory" "/directory/file.ext" == "file.ext"
         Valid x => makeRelative (takeDirectory x) x `equalFilePath` takeFileName x
         makeRelative x x == "."
         Valid x y => equalFilePath x y || (isRelative x && makeRelative y x == x) || equalFilePath (y </> makeRelative y x) x
Windows: makeRelative "C:\\Home" "c:\\home\\bob" == "bob"
Windows: makeRelative "C:\\Home" "c:/home/bob" == "bob"
Windows: makeRelative "C:\\Home" "D:\\Home\\Bob" == "D:\\Home\\Bob"
Windows: makeRelative "C:\\Home" "C:Home\\Bob" == "C:Home\\Bob"
Windows: makeRelative "/Home" "/home/bob" == "bob"
Windows: makeRelative "/" "//" == "//"
Posix:   makeRelative "/Home" "/home/bob" == "/home/bob"
Posix:   makeRelative "/home/" "/home/bob/foo/bar" == "bob/foo/bar"
Posix:   makeRelative "/fred" "bob" == "bob"
Posix:   makeRelative "/file/test" "/file/test/fred" == "fred"
Posix:   makeRelative "/file/test" "/file/test/fred/" == "fred/"
Posix:   makeRelative "some/path" "some/path/a/b/c" == "a/b/c"

dropTrailingPathSeparator :: FilePath -> FilePath #

Remove any trailing path separators

dropTrailingPathSeparator "file/test/" == "file/test"
          dropTrailingPathSeparator "/" == "/"
Windows:  dropTrailingPathSeparator "\\" == "\\"
Posix:    not (hasTrailingPathSeparator (dropTrailingPathSeparator x)) || isDrive x

normalise :: FilePath -> FilePath #

Normalise a file

// outside of the drive can be made blank
/ -> pathSeparator
./ -> ""

Posix:   normalise "/file/\\test////" == "/file/\\test/"
Posix:   normalise "/file/./test" == "/file/test"
Posix:   normalise "/test/file/../bob/fred/" == "/test/file/../bob/fred/"
Posix:   normalise "../bob/fred/" == "../bob/fred/"
Posix:   normalise "./bob/fred/" == "bob/fred/"
Windows: normalise "c:\\file/bob\\" == "C:\\file\\bob\\"
Windows: normalise "c:\\" == "C:\\"
Windows: normalise "C:.\\" == "C:"
Windows: normalise "\\\\server\\test" == "\\\\server\\test"
Windows: normalise "//server/test" == "\\\\server\\test"
Windows: normalise "c:/file" == "C:\\file"
Windows: normalise "/file" == "\\file"
Windows: normalise "\\" == "\\"
Windows: normalise "/./" == "\\"
         normalise "." == "."
Posix:   normalise "./" == "./"
Posix:   normalise "./." == "./"
Posix:   normalise "/./" == "/"
Posix:   normalise "/" == "/"
Posix:   normalise "bob/fred/." == "bob/fred/"
Posix:   normalise "//home" == "/home"

isAbsolute :: FilePath -> Bool #

not . isRelative

isAbsolute x == not (isRelative x)

isRelative :: FilePath -> Bool #

Is a path relative, or is it fixed to the root?

Windows: isRelative "path\\test" == True
Windows: isRelative "c:\\test" == False
Windows: isRelative "c:test" == True
Windows: isRelative "c:\\" == False
Windows: isRelative "c:/" == False
Windows: isRelative "c:" == True
Windows: isRelative "\\\\foo" == False
Windows: isRelative "\\\\?\\foo" == False
Windows: isRelative "\\\\?\\UNC\\foo" == False
Windows: isRelative "/foo" == True
Windows: isRelative "\\foo" == True
Posix:   isRelative "test/path" == True
Posix:   isRelative "/test" == False
Posix:   isRelative "/" == False

According to [1]:

"A UNC name of any format [is never relative]."
"You cannot use the "\?" prefix with a relative path."

makeValid :: FilePath -> FilePath #

Take a FilePath and make it valid; does not change already valid FilePaths.

isValid (makeValid x)
isValid x ==> makeValid x == x
makeValid "" == "_"
makeValid "file\0name" == "file_name"
Windows: makeValid "c:\\already\\/valid" == "c:\\already\\/valid"
Windows: makeValid "c:\\test:of_test" == "c:\\test_of_test"
Windows: makeValid "test*" == "test_"
Windows: makeValid "c:\\test\\nul" == "c:\\test\\nul_"
Windows: makeValid "c:\\test\\prn.txt" == "c:\\test\\prn_.txt"
Windows: makeValid "c:\\test/prn.txt" == "c:\\test/prn_.txt"
Windows: makeValid "c:\\nul\\file" == "c:\\nul_\\file"
Windows: makeValid "\\\\\\foo" == "\\\\drive"
Windows: makeValid "\\\\?\\D:file" == "\\\\?\\D:\\file"
Windows: makeValid "nul .txt" == "nul _.txt"

isValid :: FilePath -> Bool #

Is a FilePath valid, i.e. could you create a file like it? This function checks for invalid names, and invalid characters, but does not check if length limits are exceeded, as these are typically filesystem dependent.

         isValid "" == False
         isValid "\0" == False
Posix:   isValid "/random_ path:*" == True
Posix:   isValid x == not (null x)
Windows: isValid "c:\\test" == True
Windows: isValid "c:\\test:of_test" == False
Windows: isValid "test*" == False
Windows: isValid "c:\\test\\nul" == False
Windows: isValid "c:\\test\\prn.txt" == False
Windows: isValid "c:\\nul\\file" == False
Windows: isValid "\\\\" == False
Windows: isValid "\\\\\\foo" == False
Windows: isValid "\\\\?\\D:file" == False
Windows: isValid "foo\tbar" == False
Windows: isValid "nul .txt" == False
Windows: isValid " nul.txt" == True

equalFilePath :: FilePath -> FilePath -> Bool #

Equality of two FilePaths. If you call System.Directory.canonicalizePath first this has a much better chance of working. Note that this doesn't follow symlinks or DOSNAM~1s.

         x == y ==> equalFilePath x y
         normalise x == normalise y ==> equalFilePath x y
         equalFilePath "foo" "foo/"
         not (equalFilePath "foo" "/foo")
Posix:   not (equalFilePath "foo" "FOO")
Windows: equalFilePath "foo" "FOO"
Windows: not (equalFilePath "C:" "C:/")

joinPath :: [FilePath] -> FilePath #

Join path elements back together.

joinPath ["/","directory/","file.ext"] == "/directory/file.ext"
Valid x => joinPath (splitPath x) == x
joinPath [] == ""
Posix: joinPath ["test","file","path"] == "test/file/path"

splitDirectories :: FilePath -> [FilePath] #

Just as splitPath, but don't add the trailing slashes to each element.

         splitDirectories "/directory/file.ext" == ["/","directory","file.ext"]
         splitDirectories "test/file" == ["test","file"]
         splitDirectories "/test/file" == ["/","test","file"]
Windows: splitDirectories "C:\\test\\file" == ["C:\\", "test", "file"]
         Valid x => joinPath (splitDirectories x) `equalFilePath` x
         splitDirectories "" == []
Windows: splitDirectories "C:\\test\\\\\\file" == ["C:\\", "test", "file"]
         splitDirectories "/test///file" == ["/","test","file"]

splitPath :: FilePath -> [FilePath] #

Split a path by the directory separator.

splitPath "/directory/file.ext" == ["/","directory/","file.ext"]
concat (splitPath x) == x
splitPath "test//item/" == ["test//","item/"]
splitPath "test/item/file" == ["test/","item/","file"]
splitPath "" == []
Windows: splitPath "c:\\test\\path" == ["c:\\","test\\","path"]
Posix:   splitPath "/file/test" == ["/","file/","test"]

combine :: FilePath -> FilePath -> FilePath #

An alias for </>.

replaceDirectory :: FilePath -> String -> FilePath #

Set the directory, keeping the filename the same.

replaceDirectory "root/file.ext" "/directory/" == "/directory/file.ext"
Valid x => replaceDirectory x (takeDirectory x) `equalFilePath` x

takeDirectory :: FilePath -> FilePath #

Get the directory name, move up one level.

          takeDirectory "/directory/other.ext" == "/directory"
          takeDirectory x `isPrefixOf` x || takeDirectory x == "."
          takeDirectory "foo" == "."
          takeDirectory "/" == "/"
          takeDirectory "/foo" == "/"
          takeDirectory "/foo/bar/baz" == "/foo/bar"
          takeDirectory "/foo/bar/baz/" == "/foo/bar/baz"
          takeDirectory "foo/bar/baz" == "foo/bar"
Windows:  takeDirectory "foo\\bar" == "foo"
Windows:  takeDirectory "foo\\bar\\\\" == "foo\\bar"
Windows:  takeDirectory "C:\\" == "C:\\"

addTrailingPathSeparator :: FilePath -> FilePath #

Add a trailing file path separator if one is not already present.

hasTrailingPathSeparator (addTrailingPathSeparator x)
hasTrailingPathSeparator x ==> addTrailingPathSeparator x == x
Posix:    addTrailingPathSeparator "test/rest" == "test/rest/"

hasTrailingPathSeparator :: FilePath -> Bool #

Is an item either a directory or the last character a path separator?

hasTrailingPathSeparator "test" == False
hasTrailingPathSeparator "test/" == True

replaceBaseName :: FilePath -> String -> FilePath #

Set the base name.

replaceBaseName "/directory/other.ext" "file" == "/directory/file.ext"
replaceBaseName "file/test.txt" "bob" == "file/bob.txt"
replaceBaseName "fred" "bill" == "bill"
replaceBaseName "/dave/fred/bob.gz.tar" "new" == "/dave/fred/new.tar"
Valid x => replaceBaseName x (takeBaseName x) == x

takeBaseName :: FilePath -> String #

Get the base name, without an extension or path.

takeBaseName "/directory/file.ext" == "file"
takeBaseName "file/test.txt" == "test"
takeBaseName "dave.ext" == "dave"
takeBaseName "" == ""
takeBaseName "test" == "test"
takeBaseName (addTrailingPathSeparator x) == ""
takeBaseName "file/file.tar.gz" == "file.tar"

takeFileName :: FilePath -> FilePath #

Get the file name.

takeFileName "/directory/file.ext" == "file.ext"
takeFileName "test/" == ""
takeFileName x `isSuffixOf` x
takeFileName x == snd (splitFileName x)
Valid x => takeFileName (replaceFileName x "fred") == "fred"
Valid x => takeFileName (x </> "fred") == "fred"
Valid x => isRelative (takeFileName x)

dropFileName :: FilePath -> FilePath #

Drop the filename. Unlike takeDirectory, this function will leave a trailing path separator on the directory.

dropFileName "/directory/file.ext" == "/directory/"
dropFileName x == fst (splitFileName x)

replaceFileName :: FilePath -> String -> FilePath #

Set the filename.

replaceFileName "/directory/other.txt" "file.ext" == "/directory/file.ext"
Valid x => replaceFileName x (takeFileName x) == x

splitFileName :: FilePath -> (String, String) #

Split a filename into directory and file. </> is the inverse. The first component will often end with a trailing slash.

splitFileName "/directory/file.ext" == ("/directory/","file.ext")
Valid x => uncurry (</>) (splitFileName x) == x || fst (splitFileName x) == "./"
Valid x => isValid (fst (splitFileName x))
splitFileName "file/bob.txt" == ("file/", "bob.txt")
splitFileName "file/" == ("file/", "")
splitFileName "bob" == ("./", "bob")
Posix:   splitFileName "/" == ("/","")
Windows: splitFileName "c:" == ("c:","")

isDrive :: FilePath -> Bool #

Is an element a drive

Posix:   isDrive "/" == True
Posix:   isDrive "/foo" == False
Windows: isDrive "C:\\" == True
Windows: isDrive "C:\\foo" == False
         isDrive "" == False

hasDrive :: FilePath -> Bool #

Does a path have a drive.

not (hasDrive x) == null (takeDrive x)
Posix:   hasDrive "/foo" == True
Windows: hasDrive "C:\\foo" == True
Windows: hasDrive "C:foo" == True
         hasDrive "foo" == False
         hasDrive "" == False

dropDrive :: FilePath -> FilePath #

Delete the drive, if it exists.

dropDrive x == snd (splitDrive x)

takeDrive :: FilePath -> FilePath #

Get the drive from a filepath.

takeDrive x == fst (splitDrive x)

joinDrive :: FilePath -> FilePath -> FilePath #

Join a drive and the rest of the path.

Valid x => uncurry joinDrive (splitDrive x) == x
Windows: joinDrive "C:" "foo" == "C:foo"
Windows: joinDrive "C:\\" "bar" == "C:\\bar"
Windows: joinDrive "\\\\share" "foo" == "\\\\share\\foo"
Windows: joinDrive "/:" "foo" == "/:\\foo"

splitDrive :: FilePath -> (FilePath, FilePath) #

Split a path into a drive and a path. On Posix, / is a Drive.

uncurry (++) (splitDrive x) == x
Windows: splitDrive "file" == ("","file")
Windows: splitDrive "c:/file" == ("c:/","file")
Windows: splitDrive "c:\\file" == ("c:\\","file")
Windows: splitDrive "\\\\shared\\test" == ("\\\\shared\\","test")
Windows: splitDrive "\\\\shared" == ("\\\\shared","")
Windows: splitDrive "\\\\?\\UNC\\shared\\file" == ("\\\\?\\UNC\\shared\\","file")
Windows: splitDrive "\\\\?\\UNCshared\\file" == ("\\\\?\\","UNCshared\\file")
Windows: splitDrive "\\\\?\\d:\\file" == ("\\\\?\\d:\\","file")
Windows: splitDrive "/d" == ("","/d")
Posix:   splitDrive "/test" == ("/","test")
Posix:   splitDrive "//test" == ("//","test")
Posix:   splitDrive "test/file" == ("","test/file")
Posix:   splitDrive "file" == ("","file")

replaceExtensions :: FilePath -> String -> FilePath #

Replace all extensions of a file with a new extension. Note that replaceExtension and addExtension both work for adding multiple extensions, so only required when you need to drop all extensions first.

replaceExtensions "file.fred.bob" "txt" == "file.txt"
replaceExtensions "file.fred.bob" "tar.gz" == "file.tar.gz"

takeExtensions :: FilePath -> String #

Get all extensions.

takeExtensions "/directory/path.ext" == ".ext"
takeExtensions "file.tar.gz" == ".tar.gz"

dropExtensions :: FilePath -> FilePath #

Drop all extensions.

dropExtensions "/directory/path.ext" == "/directory/path"
dropExtensions "file.tar.gz" == "file"
not $ hasExtension $ dropExtensions x
not $ any isExtSeparator $ takeFileName $ dropExtensions x

splitExtensions :: FilePath -> (FilePath, String) #

Split on all extensions.

splitExtensions "/directory/path.ext" == ("/directory/path",".ext")
splitExtensions "file.tar.gz" == ("file",".tar.gz")
uncurry (++) (splitExtensions x) == x
Valid x => uncurry addExtension (splitExtensions x) == x
splitExtensions "file.tar.gz" == ("file",".tar.gz")

stripExtension :: String -> FilePath -> Maybe FilePath #

Drop the given extension from a FilePath, and the "." preceding it. Returns Nothing if the FilePath does not have the given extension, or Just and the part before the extension if it does.

This function can be more predictable than dropExtensions, especially if the filename might itself contain . characters.

stripExtension "hs.o" "foo.x.hs.o" == Just "foo.x"
stripExtension "hi.o" "foo.x.hs.o" == Nothing
dropExtension x == fromJust (stripExtension (takeExtension x) x)
dropExtensions x == fromJust (stripExtension (takeExtensions x) x)
stripExtension ".c.d" "a.b.c.d"  == Just "a.b"
stripExtension ".c.d" "a.b..c.d" == Just "a.b."
stripExtension "baz"  "foo.bar"  == Nothing
stripExtension "bar"  "foobar"   == Nothing
stripExtension ""     x          == Just x

isExtensionOf :: String -> FilePath -> Bool #

Does the given filename have the specified extension?

"png" `isExtensionOf` "/directory/file.png" == True
".png" `isExtensionOf` "/directory/file.png" == True
".tar.gz" `isExtensionOf` "bar/foo.tar.gz" == True
"ar.gz" `isExtensionOf` "bar/foo.tar.gz" == False
"png" `isExtensionOf` "/directory/file.png.jpg" == False
"csv/table.csv" `isExtensionOf` "/data/csv/table.csv" == False

hasExtension :: FilePath -> Bool #

Does the given filename have an extension?

hasExtension "/directory/path.ext" == True
hasExtension "/directory/path" == False
null (takeExtension x) == not (hasExtension x)

addExtension :: FilePath -> String -> FilePath #

Add an extension, even if there is already one there, equivalent to <.>.

addExtension "/directory/path" "ext" == "/directory/path.ext"
addExtension "file.txt" "bib" == "file.txt.bib"
addExtension "file." ".bib" == "file..bib"
addExtension "file" ".bib" == "file.bib"
addExtension "/" "x" == "/.x"
addExtension x "" == x
Valid x => takeFileName (addExtension (addTrailingPathSeparator x) "ext") == ".ext"
Windows: addExtension "\\\\share" ".txt" == "\\\\share\\.txt"

dropExtension :: FilePath -> FilePath #

Remove last extension, and the "." preceding it.

dropExtension "/directory/path.ext" == "/directory/path"
dropExtension x == fst (splitExtension x)

(<.>) :: FilePath -> String -> FilePath infixr 7 #

Add an extension, even if there is already one there, equivalent to addExtension.

"/directory/path" <.> "ext" == "/directory/path.ext"
"/directory/path" <.> ".ext" == "/directory/path.ext"

replaceExtension :: FilePath -> String -> FilePath #

Set the extension of a file, overwriting one if already present, equivalent to -<.>.

replaceExtension "/directory/path.txt" "ext" == "/directory/path.ext"
replaceExtension "/directory/path.txt" ".ext" == "/directory/path.ext"
replaceExtension "file.txt" ".bob" == "file.bob"
replaceExtension "file.txt" "bob" == "file.bob"
replaceExtension "file" ".bob" == "file.bob"
replaceExtension "file.txt" "" == "file"
replaceExtension "file.fred.bob" "txt" == "file.fred.txt"
replaceExtension x y == addExtension (dropExtension x) y

(-<.>) :: FilePath -> String -> FilePath infixr 7 #

Remove the current extension and add another, equivalent to replaceExtension.

"/directory/path.txt" -<.> "ext" == "/directory/path.ext"
"/directory/path.txt" -<.> ".ext" == "/directory/path.ext"
"foo.o" -<.> "c" == "foo.c"

takeExtension :: FilePath -> String #

Get the extension of a file, returns "" for no extension, .ext otherwise.

takeExtension "/directory/path.ext" == ".ext"
takeExtension x == snd (splitExtension x)
Valid x => takeExtension (addExtension x "ext") == ".ext"
Valid x => takeExtension (replaceExtension x "ext") == ".ext"

splitExtension :: FilePath -> (String, String) #

Split on the extension. addExtension is the inverse.

splitExtension "/directory/path.ext" == ("/directory/path",".ext")
uncurry (++) (splitExtension x) == x
Valid x => uncurry addExtension (splitExtension x) == x
splitExtension "file.txt" == ("file",".txt")
splitExtension "file" == ("file","")
splitExtension "file/file.txt" == ("file/file",".txt")
splitExtension "file.txt/boris" == ("file.txt/boris","")
splitExtension "file.txt/boris.ext" == ("file.txt/boris",".ext")
splitExtension "file/path.txt.bob.fred" == ("file/path.txt.bob",".fred")
splitExtension "file/path.txt/" == ("file/path.txt/","")

getSearchPath :: IO [FilePath] #

Get a list of FilePaths in the $PATH variable.

splitSearchPath :: String -> [FilePath] #

Take a string, split it on the searchPathSeparator character. Blank items are ignored on Windows, and converted to . on Posix. On Windows path elements are stripped of quotes.

Follows the recommendations in http://www.opengroup.org/onlinepubs/009695399/basedefs/xbd_chap08.html

Posix:   splitSearchPath "File1:File2:File3"  == ["File1","File2","File3"]
Posix:   splitSearchPath "File1::File2:File3" == ["File1",".","File2","File3"]
Windows: splitSearchPath "File1;File2;File3"  == ["File1","File2","File3"]
Windows: splitSearchPath "File1;;File2;File3" == ["File1","File2","File3"]
Windows: splitSearchPath "File1;\"File2\";File3" == ["File1","File2","File3"]

isExtSeparator :: Char -> Bool #

Is the character an extension character?

isExtSeparator a == (a == extSeparator)

extSeparator :: Char #

File extension character

extSeparator == '.'

isSearchPathSeparator :: Char -> Bool #

Is the character a file separator?

isSearchPathSeparator a == (a == searchPathSeparator)

searchPathSeparator :: Char #

The character that is used to separate the entries in the $PATH environment variable.

Windows: searchPathSeparator == ';'
Posix:   searchPathSeparator == ':'

isPathSeparator :: Char -> Bool #

Rather than using (== pathSeparator), use this. Test if something is a path separator.

isPathSeparator a == (a `elem` pathSeparators)

pathSeparators :: [Char] #

The list of all possible separators.

Windows: pathSeparators == ['\\', '/']
Posix:   pathSeparators == ['/']
pathSeparator `elem` pathSeparators

pathSeparator :: Char #

The character that separates directories. In the case where more than one character is possible, pathSeparator is the 'ideal' one.

Windows: pathSeparator == '\\'
Posix:   pathSeparator ==  '/'
isPathSeparator pathSeparator

class Profunctor (p :: Type -> Type -> Type) where #

Formally, the class Profunctor represents a profunctor from Hask -> Hask.

Intuitively it is a bifunctor where the first argument is contravariant and the second argument is covariant.

You can define a Profunctor by either defining dimap or by defining both lmap and rmap.

If you supply dimap, you should ensure that:

dimap id id ≡ id

If you supply lmap and rmap, ensure:

lmap id ≡ id
rmap id ≡ id

If you supply both, you should also ensure:

dimap f g ≡ lmap f . rmap g

These ensure by parametricity:

dimap (f . g) (h . i) ≡ dimap g h . dimap f i
lmap (f . g) ≡ lmap g . lmap f
rmap (f . g) ≡ rmap f . rmap g

Minimal complete definition

dimap | lmap, rmap

Methods

dimap :: (a -> b) -> (c -> d) -> p b c -> p a d #

Map over both arguments at the same time.

dimap f g ≡ lmap f . rmap g

lmap :: (a -> b) -> p b c -> p a c #

Map the first argument contravariantly.

lmap f ≡ dimap f id

rmap :: (b -> c) -> p a b -> p a c #

Map the second argument covariantly.

rmap ≡ dimap id

Instances

Profunctor ReifiedGetter
Instance details Defined in Control.Lens.Reified Methods dimap :: (a -> b) -> (c -> d) -> ReifiedGetter b c -> ReifiedGetter a d # lmap :: (a -> b) -> ReifiedGetter b c -> ReifiedGetter a c # rmap :: (b -> c) -> ReifiedGetter a b -> ReifiedGetter a c # (#.) :: Coercible c b => q b c -> ReifiedGetter a b -> ReifiedGetter a c # (.#) :: Coercible b a => ReifiedGetter b c -> q a b -> ReifiedGetter a c #
Profunctor ReifiedFold
Instance details Defined in Control.Lens.Reified Methods dimap :: (a -> b) -> (c -> d) -> ReifiedFold b c -> ReifiedFold a d # lmap :: (a -> b) -> ReifiedFold b c -> ReifiedFold a c # rmap :: (b -> c) -> ReifiedFold a b -> ReifiedFold a c # (#.) :: Coercible c b => q b c -> ReifiedFold a b -> ReifiedFold a c # (.#) :: Coercible b a => ReifiedFold b c -> q a b -> ReifiedFold a c #
Monad m => Profunctor (Kleisli m)
Instance details Defined in Data.Profunctor.Unsafe Methods dimap :: (a -> b) -> (c -> d) -> Kleisli m b c -> Kleisli m a d # lmap :: (a -> b) -> Kleisli m b c -> Kleisli m a c # rmap :: (b -> c) -> Kleisli m a b -> Kleisli m a c # (#.) :: Coercible c b => q b c -> Kleisli m a b -> Kleisli m a c # (.#) :: Coercible b a => Kleisli m b c -> q a b -> Kleisli m a c #
Profunctor (ReifiedIndexedGetter i)
Instance details Defined in Control.Lens.Reified Methods dimap :: (a -> b) -> (c -> d) -> ReifiedIndexedGetter i b c -> ReifiedIndexedGetter i a d # lmap :: (a -> b) -> ReifiedIndexedGetter i b c -> ReifiedIndexedGetter i a c # rmap :: (b -> c) -> ReifiedIndexedGetter i a b -> ReifiedIndexedGetter i a c # (#.) :: Coercible c b => q b c -> ReifiedIndexedGetter i a b -> ReifiedIndexedGetter i a c # (.#) :: Coercible b a => ReifiedIndexedGetter i b c -> q a b -> ReifiedIndexedGetter i a c #
Profunctor (ReifiedIndexedFold i)
Instance details Defined in Control.Lens.Reified Methods dimap :: (a -> b) -> (c -> d) -> ReifiedIndexedFold i b c -> ReifiedIndexedFold i a d # lmap :: (a -> b) -> ReifiedIndexedFold i b c -> ReifiedIndexedFold i a c # rmap :: (b -> c) -> ReifiedIndexedFold i a b -> ReifiedIndexedFold i a c # (#.) :: Coercible c b => q b c -> ReifiedIndexedFold i a b -> ReifiedIndexedFold i a c # (.#) :: Coercible b a => ReifiedIndexedFold i b c -> q a b -> ReifiedIndexedFold i a c #
Profunctor (Indexed i)
Instance details Defined in Control.Lens.Internal.Indexed Methods dimap :: (a -> b) -> (c -> d) -> Indexed i b c -> Indexed i a d # lmap :: (a -> b) -> Indexed i b c -> Indexed i a c # rmap :: (b -> c) -> Indexed i a b -> Indexed i a c # (#.) :: Coercible c b => q b c -> Indexed i a b -> Indexed i a c # (.#) :: Coercible b a => Indexed i b c -> q a b -> Indexed i a c #
Profunctor p => Profunctor (TambaraSum p)
Instance details Defined in Data.Profunctor.Choice Methods dimap :: (a -> b) -> (c -> d) -> TambaraSum p b c -> TambaraSum p a d # lmap :: (a -> b) -> TambaraSum p b c -> TambaraSum p a c # rmap :: (b -> c) -> TambaraSum p a b -> TambaraSum p a c # (#.) :: Coercible c b => q b c -> TambaraSum p a b -> TambaraSum p a c # (.#) :: Coercible b a => TambaraSum p b c -> q a b -> TambaraSum p a c #
Profunctor (PastroSum p)
Instance details Defined in Data.Profunctor.Choice Methods dimap :: (a -> b) -> (c -> d) -> PastroSum p b c -> PastroSum p a d # lmap :: (a -> b) -> PastroSum p b c -> PastroSum p a c # rmap :: (b -> c) -> PastroSum p a b -> PastroSum p a c # (#.) :: Coercible c b => q b c -> PastroSum p a b -> PastroSum p a c # (.#) :: Coercible b a => PastroSum p b c -> q a b -> PastroSum p a c #
Profunctor (CotambaraSum p)
Instance details Defined in Data.Profunctor.Choice Methods dimap :: (a -> b) -> (c -> d) -> CotambaraSum p b c -> CotambaraSum p a d # lmap :: (a -> b) -> CotambaraSum p b c -> CotambaraSum p a c # rmap :: (b -> c) -> CotambaraSum p a b -> CotambaraSum p a c # (#.) :: Coercible c b => q b c -> CotambaraSum p a b -> CotambaraSum p a c # (.#) :: Coercible b a => CotambaraSum p b c -> q a b -> CotambaraSum p a c #
Profunctor (CopastroSum p)
Instance details Defined in Data.Profunctor.Choice Methods dimap :: (a -> b) -> (c -> d) -> CopastroSum p b c -> CopastroSum p a d # lmap :: (a -> b) -> CopastroSum p b c -> CopastroSum p a c # rmap :: (b -> c) -> CopastroSum p a b -> CopastroSum p a c # (#.) :: Coercible c b => q b c -> CopastroSum p a b -> CopastroSum p a c # (.#) :: Coercible b a => CopastroSum p b c -> q a b -> CopastroSum p a c #
Profunctor p => Profunctor (Tambara p)
Instance details Defined in Data.Profunctor.Strong Methods dimap :: (a -> b) -> (c -> d) -> Tambara p b c -> Tambara p a d # lmap :: (a -> b) -> Tambara p b c -> Tambara p a c # rmap :: (b -> c) -> Tambara p a b -> Tambara p a c # (#.) :: Coercible c b => q b c -> Tambara p a b -> Tambara p a c # (.#) :: Coercible b a => Tambara p b c -> q a b -> Tambara p a c #
Profunctor (Pastro p)
Instance details Defined in Data.Profunctor.Strong Methods dimap :: (a -> b) -> (c -> d) -> Pastro p b c -> Pastro p a d # lmap :: (a -> b) -> Pastro p b c -> Pastro p a c # rmap :: (b -> c) -> Pastro p a b -> Pastro p a c # (#.) :: Coercible c b => q b c -> Pastro p a b -> Pastro p a c # (.#) :: Coercible b a => Pastro p b c -> q a b -> Pastro p a c #
Profunctor (Cotambara p)
Instance details Defined in Data.Profunctor.Strong Methods dimap :: (a -> b) -> (c -> d) -> Cotambara p b c -> Cotambara p a d # lmap :: (a -> b) -> Cotambara p b c -> Cotambara p a c # rmap :: (b -> c) -> Cotambara p a b -> Cotambara p a c # (#.) :: Coercible c b => q b c -> Cotambara p a b -> Cotambara p a c # (.#) :: Coercible b a => Cotambara p b c -> q a b -> Cotambara p a c #
Profunctor (Copastro p)
Instance details Defined in Data.Profunctor.Strong Methods dimap :: (a -> b) -> (c -> d) -> Copastro p b c -> Copastro p a d # lmap :: (a -> b) -> Copastro p b c -> Copastro p a c # rmap :: (b -> c) -> Copastro p a b -> Copastro p a c # (#.) :: Coercible c b => q b c -> Copastro p a b -> Copastro p a c # (.#) :: Coercible b a => Copastro p b c -> q a b -> Copastro p a c #
Functor f => Profunctor (Star f)
Instance details Defined in Data.Profunctor.Types Methods dimap :: (a -> b) -> (c -> d) -> Star f b c -> Star f a d # lmap :: (a -> b) -> Star f b c -> Star f a c # rmap :: (b -> c) -> Star f a b -> Star f a c # (#.) :: Coercible c b => q b c -> Star f a b -> Star f a c # (.#) :: Coercible b a => Star f b c -> q a b -> Star f a c #
Functor f => Profunctor (Costar f)
Instance details Defined in Data.Profunctor.Types Methods dimap :: (a -> b) -> (c -> d) -> Costar f b c -> Costar f a d # lmap :: (a -> b) -> Costar f b c -> Costar f a c # rmap :: (b -> c) -> Costar f a b -> Costar f a c # (#.) :: Coercible c b => q b c -> Costar f a b -> Costar f a c # (.#) :: Coercible b a => Costar f b c -> q a b -> Costar f a c #
Arrow p => Profunctor (WrappedArrow p)
Instance details Defined in Data.Profunctor.Types Methods dimap :: (a -> b) -> (c -> d) -> WrappedArrow p b c -> WrappedArrow p a d # lmap :: (a -> b) -> WrappedArrow p b c -> WrappedArrow p a c # rmap :: (b -> c) -> WrappedArrow p a b -> WrappedArrow p a c # (#.) :: Coercible c b => q b c -> WrappedArrow p a b -> WrappedArrow p a c # (.#) :: Coercible b a => WrappedArrow p b c -> q a b -> WrappedArrow p a c #
Profunctor (Forget r)
Instance details Defined in Data.Profunctor.Types Methods dimap :: (a -> b) -> (c -> d) -> Forget r b c -> Forget r a d # lmap :: (a -> b) -> Forget r b c -> Forget r a c # rmap :: (b -> c) -> Forget r a b -> Forget r a c # (#.) :: Coercible c b => q b c -> Forget r a b -> Forget r a c # (.#) :: Coercible b a => Forget r b c -> q a b -> Forget r a c #
Profunctor (Tagged :: Type -> Type -> Type)
Instance details Defined in Data.Profunctor.Unsafe Methods dimap :: (a -> b) -> (c -> d) -> Tagged b c -> Tagged a d # lmap :: (a -> b) -> Tagged b c -> Tagged a c # rmap :: (b -> c) -> Tagged a b -> Tagged a c # (#.) :: Coercible c b => q b c -> Tagged a b -> Tagged a c # (.#) :: Coercible b a => Tagged b c -> q a b -> Tagged a c #
Profunctor ((->) :: Type -> Type -> Type)
Instance details Defined in Data.Profunctor.Unsafe Methods dimap :: (a -> b) -> (c -> d) -> (b -> c) -> a -> d # lmap :: (a -> b) -> (b -> c) -> a -> c # rmap :: (b -> c) -> (a -> b) -> a -> c # (#.) :: Coercible c b => q b c -> (a -> b) -> a -> c # (.#) :: Coercible b a => (b -> c) -> q a b -> a -> c #
Functor w => Profunctor (Cokleisli w)
Instance details Defined in Data.Profunctor.Unsafe Methods dimap :: (a -> b) -> (c -> d) -> Cokleisli w b c -> Cokleisli w a d # lmap :: (a -> b) -> Cokleisli w b c -> Cokleisli w a c # rmap :: (b -> c) -> Cokleisli w a b -> Cokleisli w a c # (#.) :: Coercible c b => q b c -> Cokleisli w a b -> Cokleisli w a c # (.#) :: Coercible b a => Cokleisli w b c -> q a b -> Cokleisli w a c #
Profunctor (Exchange a b)
Instance details Defined in Control.Lens.Internal.Iso Methods dimap :: (a0 -> b0) -> (c -> d) -> Exchange a b b0 c -> Exchange a b a0 d # lmap :: (a0 -> b0) -> Exchange a b b0 c -> Exchange a b a0 c # rmap :: (b0 -> c) -> Exchange a b a0 b0 -> Exchange a b a0 c # (#.) :: Coercible c b0 => q b0 c -> Exchange a b a0 b0 -> Exchange a b a0 c # (.#) :: Coercible b0 a0 => Exchange a b b0 c -> q a0 b0 -> Exchange a b a0 c #
(Profunctor p, Profunctor q) => Profunctor (Procompose p q)
Instance details Defined in Data.Profunctor.Composition Methods dimap :: (a -> b) -> (c -> d) -> Procompose p q b c -> Procompose p q a d # lmap :: (a -> b) -> Procompose p q b c -> Procompose p q a c # rmap :: (b -> c) -> Procompose p q a b -> Procompose p q a c # (#.) :: Coercible c b => q0 b c -> Procompose p q a b -> Procompose p q a c # (.#) :: Coercible b a => Procompose p q b c -> q0 a b -> Procompose p q a c #
(Profunctor p, Profunctor q) => Profunctor (Rift p q)
Instance details Defined in Data.Profunctor.Composition Methods dimap :: (a -> b) -> (c -> d) -> Rift p q b c -> Rift p q a d # lmap :: (a -> b) -> Rift p q b c -> Rift p q a c # rmap :: (b -> c) -> Rift p q a b -> Rift p q a c # (#.) :: Coercible c b => q0 b c -> Rift p q a b -> Rift p q a c # (.#) :: Coercible b a => Rift p q b c -> q0 a b -> Rift p q a c #
Functor f => Profunctor (Joker f :: Type -> Type -> Type)
Instance details Defined in Data.Profunctor.Unsafe Methods dimap :: (a -> b) -> (c -> d) -> Joker f b c -> Joker f a d # lmap :: (a -> b) -> Joker f b c -> Joker f a c # rmap :: (b -> c) -> Joker f a b -> Joker f a c # (#.) :: Coercible c b => q b c -> Joker f a b -> Joker f a c # (.#) :: Coercible b a => Joker f b c -> q a b -> Joker f a c #
Contravariant f => Profunctor (Clown f :: Type -> Type -> Type)
Instance details Defined in Data.Profunctor.Unsafe Methods dimap :: (a -> b) -> (c -> d) -> Clown f b c -> Clown f a d # lmap :: (a -> b) -> Clown f b c -> Clown f a c # rmap :: (b -> c) -> Clown f a b -> Clown f a c # (#.) :: Coercible c b => q b c -> Clown f a b -> Clown f a c # (.#) :: Coercible b a => Clown f b c -> q a b -> Clown f a c #
(Profunctor p, Profunctor q) => Profunctor (Sum p q)
Instance details Defined in Data.Profunctor.Unsafe Methods dimap :: (a -> b) -> (c -> d) -> Sum p q b c -> Sum p q a d # lmap :: (a -> b) -> Sum p q b c -> Sum p q a c # rmap :: (b -> c) -> Sum p q a b -> Sum p q a c # (#.) :: Coercible c b => q0 b c -> Sum p q a b -> Sum p q a c # (.#) :: Coercible b a => Sum p q b c -> q0 a b -> Sum p q a c #
(Profunctor p, Profunctor q) => Profunctor (Product p q)
Instance details Defined in Data.Profunctor.Unsafe Methods dimap :: (a -> b) -> (c -> d) -> Product p q b c -> Product p q a d # lmap :: (a -> b) -> Product p q b c -> Product p q a c # rmap :: (b -> c) -> Product p q a b -> Product p q a c # (#.) :: Coercible c b => q0 b c -> Product p q a b -> Product p q a c # (.#) :: Coercible b a => Product p q b c -> q0 a b -> Product p q a c #
(Functor f, Profunctor p) => Profunctor (Tannen f p)
Instance details Defined in Data.Profunctor.Unsafe Methods dimap :: (a -> b) -> (c -> d) -> Tannen f p b c -> Tannen f p a d # lmap :: (a -> b) -> Tannen f p b c -> Tannen f p a c # rmap :: (b -> c) -> Tannen f p a b -> Tannen f p a c # (#.) :: Coercible c b => q b c -> Tannen f p a b -> Tannen f p a c # (.#) :: Coercible b a => Tannen f p b c -> q a b -> Tannen f p a c #
(Profunctor p, Functor f, Functor g) => Profunctor (Biff p f g)
Instance details Defined in Data.Profunctor.Unsafe Methods dimap :: (a -> b) -> (c -> d) -> Biff p f g b c -> Biff p f g a d # lmap :: (a -> b) -> Biff p f g b c -> Biff p f g a c # rmap :: (b -> c) -> Biff p f g a b -> Biff p f g a c # (#.) :: Coercible c b => q b c -> Biff p f g a b -> Biff p f g a c # (.#) :: Coercible b a => Biff p f g b c -> q a b -> Biff p f g a c #

defaultFieldRules :: LensRules #

makeFieldsNoPrefix :: Name -> DecsQ #

Generate overloaded field accessors based on field names which are only prefixed with an underscore (e.g. _name), not additionally with the type name (e.g. _fooName).

This might be the desired behaviour in case the DuplicateRecordFields language extension is used in order to get rid of the necessity to prefix each field name with the type name.

As an example:

data Foo a  = Foo { _x :: Int, _y :: a }
newtype Bar = Bar { _x :: Char }
makeFieldsNoPrefix ''Foo
makeFieldsNoPrefix ''Bar

will create classes

class HasX s a | s -> a where
  x :: Lens' s a
class HasY s a | s -> a where
  y :: Lens' s a

together with instances

instance HasX (Foo a) Int
instance HasY (Foo a) a where
instance HasX Bar Char where

For details, see classUnderscoreNoPrefixFields.

makeFieldsNoPrefix = makeLensesWith classUnderscoreNoPrefixFields

makeFields :: Name -> DecsQ #

Generate overloaded field accessors.

e.g

data Foo a = Foo { _fooX :: Int, _fooY :: a }
newtype Bar = Bar { _barX :: Char }
makeFields ''Foo
makeFields ''Bar

will create

_fooXLens :: Lens' (Foo a) Int
_fooYLens :: Lens (Foo a) (Foo b) a b
class HasX s a | s -> a where
  x :: Lens' s a
instance HasX (Foo a) Int where
  x = _fooXLens
class HasY s a | s -> a where
  y :: Lens' s a
instance HasY (Foo a) a where
  y = _fooYLens
_barXLens :: Iso' Bar Char
instance HasX Bar Char where
  x = _barXLens

For details, see camelCaseFields.

makeFields = makeLensesWith defaultFieldRules

abbreviatedNamer :: FieldNamer #

A FieldNamer for abbreviatedFields.

abbreviatedFields :: LensRules #

Field rules fields in the form prefixFieldname or _prefixFieldname If you want all fields to be lensed, then there is no reason to use an _ before the prefix. If any of the record fields leads with an _ then it is assume a field without an _ should not have a lens created.

Note that prefix may be any string of characters that are not uppercase letters. (In particular, it may be arbitrary string of lowercase letters and numbers) This is the behavior that defaultFieldRules had in lens 4.4 and earlier.

classUnderscoreNoPrefixNamer :: FieldNamer #

A FieldNamer for classUnderscoreNoPrefixFields.

classUnderscoreNoPrefixFields :: LensRules #

Field rules for fields in the form _fieldname (the leading underscore is mandatory).

Note: The primary difference to camelCaseFields is that for classUnderscoreNoPrefixFields the field names are not expected to be prefixed with the type name. This might be the desired behaviour when the DuplicateRecordFields extension is enabled.

camelCaseNamer :: FieldNamer #

A FieldNamer for camelCaseFields.

camelCaseFields :: LensRules #

Field rules for fields in the form prefixFieldname or _prefixFieldname If you want all fields to be lensed, then there is no reason to use an _ before the prefix. If any of the record fields leads with an _ then it is assume a field without an _ should not have a lens created.

Note: The prefix must be the same as the typename (with the first letter lowercased). This is a change from lens versions before lens 4.5. If you want the old behaviour, use makeLensesWith abbreviatedFields

underscoreNamer :: FieldNamer #

A FieldNamer for underscoreFields.

underscoreFields :: LensRules #

Field rules for fields in the form _prefix_fieldname

makeWrapped :: Name -> DecsQ #

Build Wrapped instance for a given newtype

declareLensesWith :: LensRules -> DecsQ -> DecsQ #

Declare lenses for each records in the given declarations, using the specified LensRules. Any record syntax in the input will be stripped off.

declareFields :: DecsQ -> DecsQ #

 declareFields = declareLensesWith defaultFieldRules

declareWrapped :: DecsQ -> DecsQ #

Build Wrapped instance for each newtype.

declarePrisms :: DecsQ -> DecsQ #

Generate a Prism for each constructor of each data type.

e.g.

declarePrisms [d|
  data Exp = Lit Int | Var String | Lambda{ bound::String, body::Exp }
  |]

will create

data Exp = Lit Int | Var String | Lambda { bound::String, body::Exp }
_Lit :: Prism' Exp Int
_Var :: Prism' Exp String
_Lambda :: Prism' Exp (String, Exp)

declareClassyFor :: [(String, (String, String))] -> [(String, String)] -> DecsQ -> DecsQ #

Similar to makeClassyFor, but takes a declaration quote.

declareClassy :: DecsQ -> DecsQ #

For each record in the declaration quote, make lenses and traversals for it, and create a class when the type has no arguments. All record syntax in the input will be stripped off.

e.g.

declareClassy [d|
  data Foo = Foo { fooX, fooY :: Int }
    deriving Show
  |]

will create

data Foo = Foo Int Int deriving Show
class HasFoo t where
  foo :: Lens' t Foo
instance HasFoo Foo where foo = id
fooX, fooY :: HasFoo t => Lens' t Int

declareLensesFor :: [(String, String)] -> DecsQ -> DecsQ #

Similar to makeLensesFor, but takes a declaration quote.

declareLenses :: DecsQ -> DecsQ #

Make lenses for all records in the given declaration quote. All record syntax in the input will be stripped off.

e.g.

declareLenses [d|
  data Foo = Foo { fooX, fooY :: Int }
    deriving Show
  |]

will create

data Foo = Foo Int Int deriving Show
fooX, fooY :: Lens' Foo Int

makeLensesWith :: LensRules -> Name -> DecsQ #

Build lenses with a custom configuration.

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

Derive lenses and traversals, using a named wrapper class, and specifying explicit pairings of (fieldName, traversalName).

Example usage:

makeClassyFor "HasFoo" "foo" [("_foo", "fooLens"), ("bar", "lbar")] ''Foo

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

Derive lenses and traversals, specifying explicit pairings of (fieldName, lensName).

If you map multiple names to the same label, and it is present in the same constructor then this will generate a Traversal.

e.g.

makeLensesFor [("_foo", "fooLens"), ("baz", "lbaz")] ''Foo
makeLensesFor [("_barX", "bar"), ("_barY", "bar")] ''Bar

makeClassy_ :: Name -> DecsQ #

Make lenses and traversals for a type, and create a class when the type has no arguments. Works the same as makeClassy except that (a) it expects that record field names do not begin with an underscore, (b) all record fields are made into lenses, and (c) the resulting lens is prefixed with an underscore.

makeClassy :: Name -> DecsQ #

Make lenses and traversals for a type, and create a class when the type has no arguments.

e.g.

data Foo = Foo { _fooX, _fooY :: Int }
makeClassy ''Foo

will create

class HasFoo t where
  foo :: Lens' t Foo
  fooX :: Lens' t Int
  fooX = foo . go where go f (Foo x y) = (\x' -> Foo x' y) <$> f x
  fooY :: Lens' t Int
  fooY = foo . go where go f (Foo x y) = (\y' -> Foo x y') <$> f y
instance HasFoo Foo where
  foo = id

makeClassy = makeLensesWith classyRules

makeLenses :: Name -> DecsQ #

Build lenses (and traversals) with a sensible default configuration.

e.g.

data FooBar
  = Foo { _x, _y :: Int }
  | Bar { _x :: Int }
makeLenses ''FooBar

will create

x :: Lens' FooBar Int
x f (Foo a b) = (\a' -> Foo a' b) <$> f a
x f (Bar a)   = Bar <$> f a
y :: Traversal' FooBar Int
y f (Foo a b) = (\b' -> Foo a  b') <$> f b
y _ c@(Bar _) = pure c

makeLenses = makeLensesWith lensRules

classyRules_ :: LensRules #

A LensRules used by makeClassy_.

classyRules :: LensRules #

Rules for making lenses and traversals that precompose another Lens.

mappingNamer #

Arguments

:: (String -> [String])	A function that maps a `fieldName` to `lensName`s.
-> FieldNamer

Create a FieldNamer from a mapping function. If the function returns [], it creates no lens for the field.

lookingupNamer :: [(String, String)] -> FieldNamer #

Create a FieldNamer from explicit pairings of (fieldName, lensName).

lensRulesFor #

Arguments

:: [(String, String)]	(Field Name, Definition Name)
-> LensRules

Construct a LensRules value for generating top-level definitions using the given map from field names to definition names.

underscoreNoPrefixNamer :: FieldNamer #

A FieldNamer that strips the _ off of the field name, lowercases the name, and skips the field if it doesn't start with an '_'.

lensRules :: LensRules #

Rules for making fairly simple partial lenses, ignoring the special cases for isomorphisms and traversals, and not making any classes. It uses underscoreNoPrefixNamer.

lensClass :: Lens' LensRules ClassyNamer #

Lens' to access the option for naming "classy" lenses.

lensField :: Lens' LensRules FieldNamer #

Lens' to access the convention for naming fields in our LensRules.

createClass :: Lens' LensRules Bool #

Create the class if the constructor is Simple and the lensClass rule matches.

generateLazyPatterns :: Lens' LensRules Bool #

Generate optics using lazy pattern matches. This can allow fields of an undefined value to be initialized with lenses:

data Foo = Foo {_x :: Int, _y :: Bool}
  deriving Show

makeLensesWith (lensRules & generateLazyPatterns .~ True) ''Foo

> undefined & x .~ 8 & y .~ True
Foo {_x = 8, _y = True}

The downside of this flag is that it can lead to space-leaks and code-size/compile-time increases when generated for large records. By default this flag is turned off, and strict optics are generated.

When using lazy optics the strict optic can be recovered by composing with $!:

strictOptic = ($!) . lazyOptic

generateUpdateableOptics :: Lens' LensRules Bool #

Generate "updateable" optics when True. When False, Folds will be generated instead of Traversals and Getters will be generated instead of Lenses. This mode is intended to be used for types with invariants which must be maintained by "smart" constructors.

generateSignatures :: Lens' LensRules Bool #

Indicate whether or not to supply the signatures for the generated lenses.

Disabling this can be useful if you want to provide a more restricted type signature or if you want to supply hand-written haddocks.

simpleLenses :: Lens' LensRules Bool #

Generate "simple" optics even when type-changing optics are possible. (e.g. Lens' instead of Lens)

data LensRules #

Rules to construct lenses for data fields.

type FieldNamer #

Arguments

= Name	Name of the data type that lenses are being generated for.
-> [Name]	Names of all fields (including the field being named) in the data type.
-> Name	Name of the field being named.
-> [DefName]	Name(s) of the lens functions. If empty, no lens is created for that field.

The rule to create function names of lenses for data fields.

Although it's sometimes useful, you won't need the first two arguments most of the time.

data DefName #

Name to give to generated field optics.

Constructors

TopName Name	Simple top-level definiton name
MethodName Name Name	makeFields-style class name and method name

Instances

Eq DefName
Instance details Defined in Control.Lens.Internal.FieldTH Methods (==) :: DefName -> DefName -> Bool # (/=) :: DefName -> DefName -> Bool #
Ord DefName
Instance details Defined in Control.Lens.Internal.FieldTH Methods compare :: DefName -> DefName -> Ordering # (<) :: DefName -> DefName -> Bool # (<=) :: DefName -> DefName -> Bool # (>) :: DefName -> DefName -> Bool # (>=) :: DefName -> DefName -> Bool # max :: DefName -> DefName -> DefName # min :: DefName -> DefName -> DefName #
Show DefName
Instance details Defined in Control.Lens.Internal.FieldTH Methods showsPrec :: Int -> DefName -> ShowS # show :: DefName -> String # showList :: [DefName] -> ShowS #

type ClassyNamer #

Arguments

= Name	Name of the data type that lenses are being generated for.
-> Maybe (Name, Name)	Names of the class and the main method it generates, respectively.

The optional rule to create a class and method around a monomorphic data type. If this naming convention is provided, it generates a "classy" lens.

makeClassyPrisms #

Arguments

:: Name	Type constructor name
-> DecsQ

Generate a Prism for each constructor of a data type and combine them into a single class. No Isos are created. Reviews are created for constructors with existentially quantified constructors and GADTs.

e.g.

data FooBarBaz a
  = Foo Int
  | Bar a
  | Baz Int Char
makeClassyPrisms ''FooBarBaz

will create

class AsFooBarBaz s a | s -> a where
  _FooBarBaz :: Prism' s (FooBarBaz a)
  _Foo :: Prism' s Int
  _Bar :: Prism' s a
  _Baz :: Prism' s (Int,Char)

  _Foo = _FooBarBaz . _Foo
  _Bar = _FooBarBaz . _Bar
  _Baz = _FooBarBaz . _Baz

instance AsFooBarBaz (FooBarBaz a) a

Generate an As class of prisms. Names are selected by prefixing the constructor name with an underscore. Constructors with multiple fields will construct Prisms to tuples of those fields.

In the event that the name of a data type is also the name of one of its constructors, the name of the Prism generated for the data type will be prefixed with an extra _ (if the data type name is prefix) or . (if the name is infix) to disambiguate it from the Prism for the corresponding constructor. For example, this code:

data Quux = Quux Int | Fred Bool
makeClassyPrisms ''Quux

will create:

class AsQuux s where
  __Quux :: Prism' s Quux -- Data type prism
  _Quux :: Prism' s Int   -- Constructor prism
  _Fred :: Prism' s Bool

  _Quux = __Quux . _Quux
  _Fred = __Quux . _Fred

instance AsQuux Quux

makePrisms #

Arguments

:: Name	Type constructor name
-> DecsQ

Generate a Prism for each constructor of a data type. Isos generated when possible. Reviews are created for constructors with existentially quantified constructors and GADTs.

e.g.

data FooBarBaz a
  = Foo Int
  | Bar a
  | Baz Int Char
makePrisms ''FooBarBaz

will create

_Foo :: Prism' (FooBarBaz a) Int
_Bar :: Prism (FooBarBaz a) (FooBarBaz b) a b
_Baz :: Prism' (FooBarBaz a) (Int, Char)

iat :: At m => Index m -> IndexedLens' (Index m) m (Maybe (IxValue m)) #

An indexed version of at.

>>> Map.fromList [(1,"world")] ^@. iat 1
(1,Just "world")

>>> iat 1 %@~ (\i x -> if odd i then Just "hello" else Nothing) $ Map.empty
fromList [(1,"hello")]

>>> iat 2 %@~ (\i x -> if odd i then Just "hello" else Nothing) $ Map.empty
fromList []

sans :: At m => Index m -> m -> m #

Delete the value associated with a key in a Map-like container

sans k = at k .~ Nothing

ixAt :: At m => Index m -> Traversal' m (IxValue m) #

A definition of ix for types with an At instance. This is the default if you don't specify a definition for ix.

iix :: Ixed m => Index m -> IndexedTraversal' (Index m) m (IxValue m) #

An indexed version of ix.

>>> Seq.fromList [a,b,c,d] & iix 2 %@~ f'
fromList [a,b,f' 2 c,d]

>>> Seq.fromList [a,b,c,d] & iix 2 .@~ h
fromList [a,b,h 2,d]

>>> Seq.fromList [a,b,c,d] ^@? iix 2
Just (2,c)

>>> Seq.fromList [] ^@? iix 2
Nothing

icontains :: Contains m => Index m -> IndexedLens' (Index m) m Bool #

An indexed version of contains.

>>> IntSet.fromList [1,2,3,4] ^@. icontains 3
(3,True)

>>> IntSet.fromList [1,2,3,4] ^@. icontains 5
(5,False)

>>> IntSet.fromList [1,2,3,4] & icontains 3 %@~ \i x -> if odd i then not x else x
fromList [1,2,4]

>>> IntSet.fromList [1,2,3,4] & icontains 3 %@~ \i x -> if even i then not x else x
fromList [1,2,3,4]

type family Index s :: Type #

Instances

type Index ByteString
Instance details Defined in Control.Lens.At type Index ByteString = Int
type Index ByteString
Instance details Defined in Control.Lens.At type Index ByteString = Int64
type Index Text
Instance details Defined in Control.Lens.At type Index Text = Int
type Index Value
Instance details Defined in Data.Aeson.Lens type Index Value = Text
type Index Text
Instance details Defined in Control.Lens.At type Index Text = Int64
type Index IntSet
Instance details Defined in Control.Lens.At type Index IntSet = Int
type Index [a]
Instance details Defined in Control.Lens.At type Index [a] = Int
type Index (Maybe a)
Instance details Defined in Control.Lens.At type Index (Maybe a) = ()
type Index (Set a)
Instance details Defined in Control.Lens.At type Index (Set a) = a
type Index (Identity a)
Instance details Defined in Control.Lens.At type Index (Identity a) = ()
type Index (Vector a)
Instance details Defined in Control.Lens.At type Index (Vector a) = Int
type Index (Complex a)
Instance details Defined in Control.Lens.At type Index (Complex a) = Int
type Index (NonEmpty a)
Instance details Defined in Control.Lens.At type Index (NonEmpty a) = Int
type Index (IntMap a)
Instance details Defined in Control.Lens.At type Index (IntMap a) = Int
type Index (Tree a)
Instance details Defined in Control.Lens.At type Index (Tree a) = [Int]
type Index (Seq a)
Instance details Defined in Control.Lens.At type Index (Seq a) = Int
type Index (Vector a)
Instance details Defined in Control.Lens.At type Index (Vector a) = Int
type Index (Vector a)
Instance details Defined in Control.Lens.At type Index (Vector a) = Int
type Index (HashSet a)
Instance details Defined in Control.Lens.At type Index (HashSet a) = a
type Index (Vector a)
Instance details Defined in Control.Lens.At type Index (Vector a) = Int
type Index (e -> a)
Instance details Defined in Control.Lens.At type Index (e -> a) = e
type Index (a, b)
Instance details Defined in Control.Lens.At type Index (a, b) = Int
type Index (Map k a)
Instance details Defined in Control.Lens.At type Index (Map k a) = k
type Index (HashMap k a)
Instance details Defined in Control.Lens.At type Index (HashMap k a) = k
type Index (UArray i e)
Instance details Defined in Control.Lens.At type Index (UArray i e) = i
type Index (Array i e)
Instance details Defined in Control.Lens.At type Index (Array i e) = i
type Index (a, b, c)
Instance details Defined in Control.Lens.At type Index (a, b, c) = Int
type Index (a, b, c, d)
Instance details Defined in Control.Lens.At type Index (a, b, c, d) = Int
type Index (a, b, c, d, e)
Instance details Defined in Control.Lens.At type Index (a, b, c, d, e) = Int
type Index (a, b, c, d, e, f)
Instance details Defined in Control.Lens.At type Index (a, b, c, d, e, f) = Int
type Index (a, b, c, d, e, f, g)
Instance details Defined in Control.Lens.At type Index (a, b, c, d, e, f, g) = Int
type Index (a, b, c, d, e, f, g, h)
Instance details Defined in Control.Lens.At type Index (a, b, c, d, e, f, g, h) = Int
type Index (a, b, c, d, e, f, g, h, i)
Instance details Defined in Control.Lens.At type Index (a, b, c, d, e, f, g, h, i) = Int

class Contains m where #

This class provides a simple Lens that lets you view (and modify) information about whether or not a container contains a given Index.

Methods

contains :: Index m -> Lens' m Bool #

>>> IntSet.fromList [1,2,3,4] ^. contains 3
True

>>> IntSet.fromList [1,2,3,4] ^. contains 5
False

>>> IntSet.fromList [1,2,3,4] & contains 3 .~ False
fromList [1,2,4]

Instances

Contains IntSet
Instance details Defined in Control.Lens.At Methods contains :: Index IntSet -> Lens' IntSet Bool #
Ord a => Contains (Set a)
Instance details Defined in Control.Lens.At Methods contains :: Index (Set a) -> Lens' (Set a) Bool #
(Eq a, Hashable a) => Contains (HashSet a)
Instance details Defined in Control.Lens.At Methods contains :: Index (HashSet a) -> Lens' (HashSet a) Bool #

type family IxValue m :: Type #

This provides a common notion of a value at an index that is shared by both Ixed and At.

Instances

type IxValue ByteString
Instance details Defined in Control.Lens.At type IxValue ByteString = Word8
type IxValue ByteString
Instance details Defined in Control.Lens.At type IxValue ByteString = Word8
type IxValue Text
Instance details Defined in Control.Lens.At type IxValue Text = Char
type IxValue Value
Instance details Defined in Data.Aeson.Lens type IxValue Value = Value
type IxValue Text
Instance details Defined in Control.Lens.At type IxValue Text = Char
type IxValue IntSet
Instance details Defined in Control.Lens.At type IxValue IntSet = ()
type IxValue [a]
Instance details Defined in Control.Lens.At type IxValue [a] = a
type IxValue (Maybe a)
Instance details Defined in Control.Lens.At type IxValue (Maybe a) = a
type IxValue (Set k)
Instance details Defined in Control.Lens.At type IxValue (Set k) = ()
type IxValue (Identity a)
Instance details Defined in Control.Lens.At type IxValue (Identity a) = a
type IxValue (Vector a)
Instance details Defined in Control.Lens.At type IxValue (Vector a) = a
type IxValue (NonEmpty a)
Instance details Defined in Control.Lens.At type IxValue (NonEmpty a) = a
type IxValue (IntMap a)
Instance details Defined in Control.Lens.At type IxValue (IntMap a) = a
type IxValue (Tree a)
Instance details Defined in Control.Lens.At type IxValue (Tree a) = a
type IxValue (Seq a)
Instance details Defined in Control.Lens.At type IxValue (Seq a) = a
type IxValue (Vector a)
Instance details Defined in Control.Lens.At type IxValue (Vector a) = a
type IxValue (Vector a)
Instance details Defined in Control.Lens.At type IxValue (Vector a) = a
type IxValue (HashSet k)
Instance details Defined in Control.Lens.At type IxValue (HashSet k) = ()
type IxValue (Vector a)
Instance details Defined in Control.Lens.At type IxValue (Vector a) = a
type IxValue (e -> a)
Instance details Defined in Control.Lens.At type IxValue (e -> a) = a
type IxValue (a, a2)	`ix` :: `Int` -> `Traversal'` (a,a) a
Instance details Defined in Control.Lens.At type IxValue (a, a2) = a
type IxValue (Map k a)
Instance details Defined in Control.Lens.At type IxValue (Map k a) = a
type IxValue (HashMap k a)
Instance details Defined in Control.Lens.At type IxValue (HashMap k a) = a
type IxValue (UArray i e)
Instance details Defined in Control.Lens.At type IxValue (UArray i e) = e
type IxValue (Array i e)
Instance details Defined in Control.Lens.At type IxValue (Array i e) = e
type IxValue (a, a2, a3)	`ix` :: `Int` -> `Traversal'` (a,a,a) a
Instance details Defined in Control.Lens.At type IxValue (a, a2, a3) = a
type IxValue (a, a2, a3, a4)	`ix` :: `Int` -> `Traversal'` (a,a,a,a) a
Instance details Defined in Control.Lens.At type IxValue (a, a2, a3, a4) = a
type IxValue (a, a2, a3, a4, a5)	`ix` :: `Int` -> `Traversal'` (a,a,a,a,a) a
Instance details Defined in Control.Lens.At type IxValue (a, a2, a3, a4, a5) = a
type IxValue (a, a2, a3, a4, a5, a6)	`ix` :: `Int` -> `Traversal'` (a,a,a,a,a,a) a
Instance details Defined in Control.Lens.At type IxValue (a, a2, a3, a4, a5, a6) = a
type IxValue (a, a2, a3, a4, a5, a6, a7)	`ix` :: `Int` -> `Traversal'` (a,a,a,a,a,a,a) a
Instance details Defined in Control.Lens.At type IxValue (a, a2, a3, a4, a5, a6, a7) = a
type IxValue (a, a2, a3, a4, a5, a6, a7, a8)	`ix` :: `Int` -> `Traversal'` (a,a,a,a,a,a,a,a) a
Instance details Defined in Control.Lens.At type IxValue (a, a2, a3, a4, a5, a6, a7, a8) = a
type IxValue (a, a2, a3, a4, a5, a6, a7, a8, a9)	`ix` :: `Int` -> `Traversal'` (a,a,a,a,a,a,a,a,a) a
Instance details Defined in Control.Lens.At type IxValue (a, a2, a3, a4, a5, a6, a7, a8, a9) = a

class Ixed m where #

Provides a simple Traversal lets you traverse the value at a given key in a Map or element at an ordinal position in a list or Seq.

Minimal complete definition

Nothing

Methods

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

NB: Setting the value of this Traversal will only set the value in at if it is already present.

If you want to be able to insert missing values, you want at.

>>> Seq.fromList [a,b,c,d] & ix 2 %~ f
fromList [a,b,f c,d]

>>> Seq.fromList [a,b,c,d] & ix 2 .~ e
fromList [a,b,e,d]

>>> Seq.fromList [a,b,c,d] ^? ix 2
Just c

>>> Seq.fromList [] ^? ix 2
Nothing

Instances

Ixed ByteString
Instance details Defined in Control.Lens.At Methods ix :: Index ByteString -> Traversal' ByteString (IxValue ByteString) #
Ixed ByteString
Instance details Defined in Control.Lens.At Methods ix :: Index ByteString -> Traversal' ByteString (IxValue ByteString) #
Ixed Text
Instance details Defined in Control.Lens.At Methods ix :: Index Text -> Traversal' Text (IxValue Text) #
Ixed Text
Instance details Defined in Control.Lens.At Methods ix :: Index Text -> Traversal' Text (IxValue Text) #
Ixed IntSet
Instance details Defined in Control.Lens.At Methods ix :: Index IntSet -> Traversal' IntSet (IxValue IntSet) #
Ixed [a]
Instance details Defined in Control.Lens.At Methods ix :: Index [a] -> Traversal' [a] (IxValue [a]) #
Ixed (Maybe a)
Instance details Defined in Control.Lens.At Methods ix :: Index (Maybe a) -> Traversal' (Maybe a) (IxValue (Maybe a)) #
Ord k => Ixed (Set k)
Instance details Defined in Control.Lens.At Methods ix :: Index (Set k) -> Traversal' (Set k) (IxValue (Set k)) #
Ixed (Identity a)
Instance details Defined in Control.Lens.At Methods ix :: Index (Identity a) -> Traversal' (Identity a) (IxValue (Identity a)) #
Storable a => Ixed (Vector a)
Instance details Defined in Control.Lens.At Methods ix :: Index (Vector a) -> Traversal' (Vector a) (IxValue (Vector a)) #
Ixed (NonEmpty a)
Instance details Defined in Control.Lens.At Methods ix :: Index (NonEmpty a) -> Traversal' (NonEmpty a) (IxValue (NonEmpty a)) #
Ixed (IntMap a)
Instance details Defined in Control.Lens.At Methods ix :: Index (IntMap a) -> Traversal' (IntMap a) (IxValue (IntMap a)) #
Ixed (Tree a)
Instance details Defined in Control.Lens.At Methods ix :: Index (Tree a) -> Traversal' (Tree a) (IxValue (Tree a)) #
Ixed (Seq a)
Instance details Defined in Control.Lens.At Methods ix :: Index (Seq a) -> Traversal' (Seq a) (IxValue (Seq a)) #
Prim a => Ixed (Vector a)
Instance details Defined in Control.Lens.At Methods ix :: Index (Vector a) -> Traversal' (Vector a) (IxValue (Vector a)) #
Unbox a => Ixed (Vector a)
Instance details Defined in Control.Lens.At Methods ix :: Index (Vector a) -> Traversal' (Vector a) (IxValue (Vector a)) #
(Eq k, Hashable k) => Ixed (HashSet k)
Instance details Defined in Control.Lens.At Methods ix :: Index (HashSet k) -> Traversal' (HashSet k) (IxValue (HashSet k)) #
Ixed (Vector a)
Instance details Defined in Control.Lens.At Methods ix :: Index (Vector a) -> Traversal' (Vector a) (IxValue (Vector a)) #
Eq e => Ixed (e -> a)
Instance details Defined in Control.Lens.At Methods ix :: Index (e -> a) -> Traversal' (e -> a) (IxValue (e -> a)) #
a ~ a2 => Ixed (a, a2)
Instance details Defined in Control.Lens.At Methods ix :: Index (a, a2) -> Traversal' (a, a2) (IxValue (a, a2)) #
Ord k => Ixed (Map k a)
Instance details Defined in Control.Lens.At Methods ix :: Index (Map k a) -> Traversal' (Map k a) (IxValue (Map k a)) #
(Eq k, Hashable k) => Ixed (HashMap k a)
Instance details Defined in Control.Lens.At Methods ix :: Index (HashMap k a) -> Traversal' (HashMap k a) (IxValue (HashMap k a)) #
(IArray UArray e, Ix i) => Ixed (UArray i e)	arr `!` i ≡ arr `^.` `ix` i arr `//` [(i,e)] ≡ `ix` i `.~` e `$` arr
Instance details Defined in Control.Lens.At Methods ix :: Index (UArray i e) -> Traversal' (UArray i e) (IxValue (UArray i e)) #
Ix i => Ixed (Array i e)	arr `!` i ≡ arr `^.` `ix` i arr `//` [(i,e)] ≡ `ix` i `.~` e `$` arr
Instance details Defined in Control.Lens.At Methods ix :: Index (Array i e) -> Traversal' (Array i e) (IxValue (Array i e)) #
(a ~ a2, a ~ a3) => Ixed (a, a2, a3)
Instance details Defined in Control.Lens.At Methods ix :: Index (a, a2, a3) -> Traversal' (a, a2, a3) (IxValue (a, a2, a3)) #
(a ~ a2, a ~ a3, a ~ a4) => Ixed (a, a2, a3, a4)
Instance details Defined in Control.Lens.At Methods ix :: Index (a, a2, a3, a4) -> Traversal' (a, a2, a3, a4) (IxValue (a, a2, a3, a4)) #
(a ~ a2, a ~ a3, a ~ a4, a ~ a5) => Ixed (a, a2, a3, a4, a5)
Instance details Defined in Control.Lens.At Methods ix :: Index (a, a2, a3, a4, a5) -> Traversal' (a, a2, a3, a4, a5) (IxValue (a, a2, a3, a4, a5)) #
(a ~ a2, a ~ a3, a ~ a4, a ~ a5, a ~ a6) => Ixed (a, a2, a3, a4, a5, a6)
Instance details Defined in Control.Lens.At Methods ix :: Index (a, a2, a3, a4, a5, a6) -> Traversal' (a, a2, a3, a4, a5, a6) (IxValue (a, a2, a3, a4, a5, a6)) #
(a ~ a2, a ~ a3, a ~ a4, a ~ a5, a ~ a6, a ~ a7) => Ixed (a, a2, a3, a4, a5, a6, a7)
Instance details Defined in Control.Lens.At Methods ix :: Index (a, a2, a3, a4, a5, a6, a7) -> Traversal' (a, a2, a3, a4, a5, a6, a7) (IxValue (a, a2, a3, a4, a5, a6, a7)) #
(a ~ a2, a ~ a3, a ~ a4, a ~ a5, a ~ a6, a ~ a7, a ~ a8) => Ixed (a, a2, a3, a4, a5, a6, a7, a8)
Instance details Defined in Control.Lens.At Methods ix :: Index (a, a2, a3, a4, a5, a6, a7, a8) -> Traversal' (a, a2, a3, a4, a5, a6, a7, a8) (IxValue (a, a2, a3, a4, a5, a6, a7, a8)) #
(a ~ a2, a ~ a3, a ~ a4, a ~ a5, a ~ a6, a ~ a7, a ~ a8, a ~ a9) => Ixed (a, a2, a3, a4, a5, a6, a7, a8, a9)
Instance details Defined in Control.Lens.At Methods ix :: Index (a, a2, a3, a4, a5, a6, a7, a8, a9) -> Traversal' (a, a2, a3, a4, a5, a6, a7, a8, a9) (IxValue (a, a2, a3, a4, a5, a6, a7, a8, a9)) #

class Ixed m => At m where #

At provides a Lens that can be used to read, write or delete the value associated with a key in a Map-like container on an ad hoc basis.

An instance of At should satisfy:

ix k ≡ at k . traverse

Methods

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

>>> Map.fromList [(1,"world")] ^.at 1
Just "world"

>>> at 1 ?~ "hello" $ Map.empty
fromList [(1,"hello")]

Note: Map-like containers form a reasonable instance, but not Array-like ones, where you cannot satisfy the Lens laws.

Instances

At IntSet
Instance details Defined in Control.Lens.At Methods at :: Index IntSet -> Lens' IntSet (Maybe (IxValue IntSet)) #
At (Maybe a)
Instance details Defined in Control.Lens.At Methods at :: Index (Maybe a) -> Lens' (Maybe a) (Maybe (IxValue (Maybe a))) #
Ord k => At (Set k)
Instance details Defined in Control.Lens.At Methods at :: Index (Set k) -> Lens' (Set k) (Maybe (IxValue (Set k))) #
At (IntMap a)
Instance details Defined in Control.Lens.At Methods at :: Index (IntMap a) -> Lens' (IntMap a) (Maybe (IxValue (IntMap a))) #
(Eq k, Hashable k) => At (HashSet k)
Instance details Defined in Control.Lens.At Methods at :: Index (HashSet k) -> Lens' (HashSet k) (Maybe (IxValue (HashSet k))) #
Ord k => At (Map k a)
Instance details Defined in Control.Lens.At Methods at :: Index (Map k a) -> Lens' (Map k a) (Maybe (IxValue (Map k a))) #
(Eq k, Hashable k) => At (HashMap k a)
Instance details Defined in Control.Lens.At Methods at :: Index (HashMap k a) -> Lens' (HashMap k a) (Maybe (IxValue (HashMap k a))) #

class Each s t a b | s -> a, t -> b, s b -> t, t a -> s where #

Extract each element of a (potentially monomorphic) container.

Notably, when applied to a tuple, this generalizes both to arbitrary homogeneous tuples.

>>> (1,2,3) & each *~ 10
(10,20,30)

It can also be used on monomorphic containers like Text or ByteString.

>>> over each Char.toUpper ("hello"^.Text.packed)
"HELLO"

>>> ("hello","world") & each.each %~ Char.toUpper
("HELLO","WORLD")

Minimal complete definition

Nothing

Methods

each :: Traversal s t a b #

Instances

(a ~ Word8, b ~ Word8) => Each ByteString ByteString a b	`each` :: `Traversal` `ByteString` `ByteString` `Word8` `Word8`
Instance details Defined in Control.Lens.Each Methods each :: Traversal ByteString ByteString a b #
(a ~ Word8, b ~ Word8) => Each ByteString ByteString a b	`each` :: `Traversal` `ByteString` `ByteString` `Word8` `Word8`
Instance details Defined in Control.Lens.Each Methods each :: Traversal ByteString ByteString a b #
(a ~ Char, b ~ Char) => Each Text Text a b	`each` :: `Traversal` `Text` `Text` `Char` `Char`
Instance details Defined in Control.Lens.Each Methods each :: Traversal Text Text a b #
(a ~ Char, b ~ Char) => Each Text Text a b	`each` :: `Traversal` `Text` `Text` `Char` `Char`
Instance details Defined in Control.Lens.Each Methods each :: Traversal Text Text a b #
Each [a] [b] a b	`each` :: `Traversal` [a] [b] a b
Instance details Defined in Control.Lens.Each Methods each :: Traversal [a] [b] a b #
Each (Maybe a) (Maybe b) a b	`each` :: `Traversal` (`Maybe` a) (`Maybe` b) a b
Instance details Defined in Control.Lens.Each Methods each :: Traversal (Maybe a) (Maybe b) a b #
Each (Identity a) (Identity b) a b	`each` :: `Traversal` (`Identity` a) (`Identity` b) a b
Instance details Defined in Control.Lens.Each Methods each :: Traversal (Identity a) (Identity b) a b #
(Storable a, Storable b) => Each (Vector a) (Vector b) a b	`each` :: (`Storable` a, `Storable` b) => `Traversal` (`Vector` a) (`Vector` b) a b
Instance details Defined in Control.Lens.Each Methods each :: Traversal (Vector a) (Vector b) a b #
Each (Complex a) (Complex b) a b	`each` :: (`RealFloat` a, `RealFloat` b) => `Traversal` (`Complex` a) (`Complex` b) a b
Instance details Defined in Control.Lens.Each Methods each :: Traversal (Complex a) (Complex b) a b #
Each (NonEmpty a) (NonEmpty b) a b	`each` :: `Traversal` (NonEmpty a) (NonEmpty b) a b
Instance details Defined in Control.Lens.Each Methods each :: Traversal (NonEmpty a) (NonEmpty b) a b #
Each (IntMap a) (IntMap b) a b	`each` :: `Traversal` (`Map` c a) (`Map` c b) a b
Instance details Defined in Control.Lens.Each Methods each :: Traversal (IntMap a) (IntMap b) a b #
Each (Tree a) (Tree b) a b	`each` :: `Traversal` (`Tree` a) (`Tree` b) a b
Instance details Defined in Control.Lens.Each Methods each :: Traversal (Tree a) (Tree b) a b #
Each (Seq a) (Seq b) a b	`each` :: `Traversal` (`Seq` a) (`Seq` b) a b
Instance details Defined in Control.Lens.Each Methods each :: Traversal (Seq a) (Seq b) a b #
(Prim a, Prim b) => Each (Vector a) (Vector b) a b	`each` :: (`Prim` a, `Prim` b) => `Traversal` (`Vector` a) (`Vector` b) a b
Instance details Defined in Control.Lens.Each Methods each :: Traversal (Vector a) (Vector b) a b #
(Unbox a, Unbox b) => Each (Vector a) (Vector b) a b	`each` :: (`Unbox` a, `Unbox` b) => `Traversal` (`Vector` a) (`Vector` b) a b
Instance details Defined in Control.Lens.Each Methods each :: Traversal (Vector a) (Vector b) a b #
Each (Vector a) (Vector b) a b	`each` :: `Traversal` (`Vector` a) (`Vector` b) a b
Instance details Defined in Control.Lens.Each Methods each :: Traversal (Vector a) (Vector b) a b #
(a ~ a', b ~ b') => Each (Either a a') (Either b b') a b	`each` :: `Traversal` (`Either` a a) (`Either` b b) a b Since: lens-4.18
Instance details Defined in Control.Lens.Each Methods each :: Traversal (Either a a') (Either b b') a b #
(a ~ a', b ~ b') => Each (a, a') (b, b') a b	`each` :: `Traversal` (a,a) (b,b) a b
Instance details Defined in Control.Lens.Each Methods each :: Traversal (a, a') (b, b') a b #
c ~ d => Each (Map c a) (Map d b) a b	`each` :: `Traversal` (`Map` c a) (`Map` c b) a b
Instance details Defined in Control.Lens.Each Methods each :: Traversal (Map c a) (Map d b) a b #
c ~ d => Each (HashMap c a) (HashMap d b) a b	`each` :: `Traversal` (`HashMap` c a) (`HashMap` c b) a b
Instance details Defined in Control.Lens.Each Methods each :: Traversal (HashMap c a) (HashMap d b) a b #
(Ix i, IArray UArray a, IArray UArray b, i ~ j) => Each (UArray i a) (UArray j b) a b	`each` :: (`Ix` i, `IArray` `UArray` a, `IArray` `UArray` b) => `Traversal` (`Array` i a) (`Array` i b) a b
Instance details Defined in Control.Lens.Each Methods each :: Traversal (UArray i a) (UArray j b) a b #
(Ix i, i ~ j) => Each (Array i a) (Array j b) a b	`each` :: `Ix` i => `Traversal` (`Array` i a) (`Array` i b) a b
Instance details Defined in Control.Lens.Each Methods each :: Traversal (Array i a) (Array j b) a b #
(a ~ a2, a ~ a3, b ~ b2, b ~ b3) => Each (a, a2, a3) (b, b2, b3) a b	`each` :: `Traversal` (a,a,a) (b,b,b) a b
Instance details Defined in Control.Lens.Each Methods each :: Traversal (a, a2, a3) (b, b2, b3) a b #
(a ~ a2, a ~ a3, a ~ a4, b ~ b2, b ~ b3, b ~ b4) => Each (a, a2, a3, a4) (b, b2, b3, b4) a b	`each` :: `Traversal` (a,a,a,a) (b,b,b,b) a b
Instance details Defined in Control.Lens.Each Methods each :: Traversal (a, a2, a3, a4) (b, b2, b3, b4) a b #
(a ~ a2, a ~ a3, a ~ a4, a ~ a5, b ~ b2, b ~ b3, b ~ b4, b ~ b5) => Each (a, a2, a3, a4, a5) (b, b2, b3, b4, b5) a b	`each` :: `Traversal` (a,a,a,a,a) (b,b,b,b,b) a b
Instance details Defined in Control.Lens.Each Methods each :: Traversal (a, a2, a3, a4, a5) (b, b2, b3, b4, b5) a b #
(a ~ a2, a ~ a3, a ~ a4, a ~ a5, a ~ a6, b ~ b2, b ~ b3, b ~ b4, b ~ b5, b ~ b6) => Each (a, a2, a3, a4, a5, a6) (b, b2, b3, b4, b5, b6) a b	`each` :: `Traversal` (a,a,a,a,a,a) (b,b,b,b,b,b) a b
Instance details Defined in Control.Lens.Each Methods each :: Traversal (a, a2, a3, a4, a5, a6) (b, b2, b3, b4, b5, b6) a b #
(a ~ a2, a ~ a3, a ~ a4, a ~ a5, a ~ a6, a ~ a7, b ~ b2, b ~ b3, b ~ b4, b ~ b5, b ~ b6, b ~ b7) => Each (a, a2, a3, a4, a5, a6, a7) (b, b2, b3, b4, b5, b6, b7) a b	`each` :: `Traversal` (a,a,a,a,a,a,a) (b,b,b,b,b,b,b) a b
Instance details Defined in Control.Lens.Each Methods each :: Traversal (a, a2, a3, a4, a5, a6, a7) (b, b2, b3, b4, b5, b6, b7) a b #
(a ~ a2, a ~ a3, a ~ a4, a ~ a5, a ~ a6, a ~ a7, a ~ a8, b ~ b2, b ~ b3, b ~ b4, b ~ b5, b ~ b6, b ~ b7, b ~ b8) => Each (a, a2, a3, a4, a5, a6, a7, a8) (b, b2, b3, b4, b5, b6, b7, b8) a b	`each` :: `Traversal` (a,a,a,a,a,a,a,a) (b,b,b,b,b,b,b,b) a b
Instance details Defined in Control.Lens.Each Methods each :: Traversal (a, a2, a3, a4, a5, a6, a7, a8) (b, b2, b3, b4, b5, b6, b7, b8) a b #
(a ~ a2, a ~ a3, a ~ a4, a ~ a5, a ~ a6, a ~ a7, a ~ a8, a ~ a9, b ~ b2, b ~ b3, b ~ b4, b ~ b5, b ~ b6, b ~ b7, b ~ b8, b ~ b9) => Each (a, a2, a3, a4, a5, a6, a7, a8, a9) (b, b2, b3, b4, b5, b6, b7, b8, b9) a b	`each` :: `Traversal` (a,a,a,a,a,a,a,a,a) (b,b,b,b,b,b,b,b,b) a b
Instance details Defined in Control.Lens.Each Methods each :: Traversal (a, a2, a3, a4, a5, a6, a7, a8, a9) (b, b2, b3, b4, b5, b6, b7, b8, b9) a b #

gplate1 :: (Generic1 f, GPlated1 f (Rep1 f)) => Traversal' (f a) (f a) #

Implement plate operation for a type using its Generic1 instance.

gplate :: (Generic a, GPlated a (Rep a)) => Traversal' a a #

Implement plate operation for a type using its Generic instance.

parts :: Plated a => Lens' a [a] #

The original uniplate combinator, implemented in terms of Plated as a Lens.

parts ≡ partsOf plate

The resulting Lens is safer to use as it ignores 'over-application' and deals gracefully with under-application, but it is only a proper Lens if you don't change the list length!

composOpFold :: Plated a => b -> (b -> b -> b) -> (a -> b) -> a -> b #

Fold the immediate children of a Plated container.

composOpFold z c f = foldrOf plate (c . f) z

para :: Plated a => (a -> [r] -> r) -> a -> r #

Perform a fold-like computation on each value, technically a paramorphism.

para ≡ paraOf plate

paraOf :: Getting (Endo [a]) a a -> (a -> [r] -> r) -> a -> r #

Perform a fold-like computation on each value, technically a paramorphism.

paraOf :: Fold a a -> (a -> [r] -> r) -> a -> r

holesOnOf :: Conjoined p => LensLike (Bazaar p r r) s t a b -> Over p (Bazaar p r r) a b r r -> s -> [Pretext p r r t] #

Extract one level of holes from a container in a region specified by one Traversal, using another.

holesOnOf b l ≡ holesOf (b . l)

holesOnOf :: Iso' s a       -> Iso' a a                -> s -> [Pretext (->) a a s]
holesOnOf :: Lens' s a      -> Lens' a a               -> s -> [Pretext (->) a a s]
holesOnOf :: Traversal' s a -> Traversal' a a          -> s -> [Pretext (->) a a s]
holesOnOf :: Lens' s a      -> IndexedLens' i a a      -> s -> [Pretext (Indexed i) a a s]
holesOnOf :: Traversal' s a -> IndexedTraversal' i a a -> s -> [Pretext (Indexed i) a a s]

holesOn :: Conjoined p => Over p (Bazaar p a a) s t a a -> s -> [Pretext p a a t] #

An alias for holesOf, provided for consistency with the other combinators.

holesOn ≡ holesOf

holesOn :: Iso' s a                -> s -> [Pretext (->) a a s]
holesOn :: Lens' s a               -> s -> [Pretext (->) a a s]
holesOn :: Traversal' s a          -> s -> [Pretext (->) a a s]
holesOn :: IndexedLens' i s a      -> s -> [Pretext (Indexed i) a a s]
holesOn :: IndexedTraversal' i s a -> s -> [Pretext (Indexed i) a a s]

holes :: Plated a => a -> [Pretext ((->) :: Type -> Type -> Type) a a a] #

The one-level version of context. This extracts a list of the immediate children as editable contexts.

Given a context you can use pos to see the values, peek at what the structure would be like with an edited result, or simply extract the original structure.

propChildren x = children l x == map pos (holes l x)
propId x = all (== x) [extract w | w <- holes l x]

holes = holesOf plate

contextsOnOf :: ATraversal s t a a -> ATraversal' a a -> s -> [Context a a t] #

Return a list of all of the editable contexts for every location in the structure in an areas indicated by a user supplied Traversal, recursively using another user-supplied Traversal to walk each layer.

contextsOnOf :: Traversal' s a -> Traversal' a a -> s -> [Context a a s]

contextsOn :: Plated a => ATraversal s t a a -> s -> [Context a a t] #

Return a list of all of the editable contexts for every location in the structure in an areas indicated by a user supplied Traversal, recursively using plate.

contextsOn b ≡ contextsOnOf b plate

contextsOn :: Plated a => Traversal' s a -> s -> [Context a a s]

contextsOf :: ATraversal' a a -> a -> [Context a a a] #

Return a list of all of the editable contexts for every location in the structure, recursively, using a user-specified Traversal to walk each layer.

propUniverse l x = universeOf l x == map pos (contextsOf l x)
propId l x = all (== x) [extract w | w <- contextsOf l x]

contextsOf :: Traversal' a a -> a -> [Context a a a]

contexts :: Plated a => a -> [Context a a a] #

Return a list of all of the editable contexts for every location in the structure, recursively.

propUniverse x = universe x == map pos (contexts x)
propId x = all (== x) [extract w | w <- contexts x]

contexts ≡ contextsOf plate

transformMOnOf :: Monad m => LensLike (WrappedMonad m) s t a b -> LensLike (WrappedMonad m) a b a b -> (b -> m b) -> s -> m t #

Transform every element in a tree that lies in a region indicated by a supplied Traversal, walking with a user supplied Traversal in a bottom-up manner with a monadic effect.

transformMOnOf :: Monad m => Traversal' s a -> Traversal' a a -> (a -> m a) -> s -> m s

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

Transform every element in a tree using a user supplied Traversal in a bottom-up manner with a monadic effect.

transformMOf :: Monad m => Traversal' a a -> (a -> m a) -> a -> m a

transformMOn :: (Monad m, Plated a) => LensLike (WrappedMonad m) s t a a -> (a -> m a) -> s -> m t #

Transform every element in the tree in a region indicated by a supplied Traversal, in a bottom-up manner, monadically.

transformMOn :: (Monad m, Plated a) => Traversal' s a -> (a -> m a) -> s -> m s

transformM :: (Monad m, Plated a) => (a -> m a) -> a -> m a #

Transform every element in the tree, in a bottom-up manner, monadically.

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

Transform every element in a region indicated by a Setter by recursively applying another Setter in a bottom-up manner.

transformOnOf :: Setter' s a -> Traversal' a a -> (a -> a) -> s -> s
transformOnOf :: Setter' s a -> Setter' a a    -> (a -> a) -> s -> s

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

Transform every element by recursively applying a given Setter in a bottom-up manner.

transformOf :: Traversal' a a -> (a -> a) -> a -> a
transformOf :: Setter' a a    -> (a -> a) -> a -> a

transformOn :: Plated a => ASetter s t a a -> (a -> a) -> s -> t #

Transform every element in the tree in a bottom-up manner over a region indicated by a Setter.

transformOn :: Plated a => Traversal' s a -> (a -> a) -> s -> s
transformOn :: Plated a => Setter' s a    -> (a -> a) -> s -> s

transform :: Plated a => (a -> a) -> a -> a #

Transform every element in the tree, in a bottom-up manner.

For example, replacing negative literals with literals:

negLits = transform $ \x -> case x of
  Neg (Lit i) -> Lit (negate i)
  _           -> x

cosmosOnOf :: (Applicative f, Contravariant f) => LensLike' f s a -> LensLike' f a a -> LensLike' f s a #

Given a Fold that knows how to locate immediate children, fold all of the transitive descendants of a node, including itself that lie in a region indicated by another Fold.

cosmosOnOf :: Fold s a -> Fold a a -> Fold s a

cosmosOn :: (Applicative f, Contravariant f, Plated a) => LensLike' f s a -> LensLike' f s a #

Given a Fold that knows how to find Plated parts of a container fold them and all of their descendants, recursively.

cosmosOn :: Plated a => Fold s a -> Fold s a

cosmosOf :: (Applicative f, Contravariant f) => LensLike' f a a -> LensLike' f a a #

Given a Fold that knows how to locate immediate children, fold all of the transitive descendants of a node, including itself.

cosmosOf :: Fold a a -> Fold a a

cosmos :: Plated a => Fold a a #

Fold over all transitive descendants of a Plated container, including itself.

universeOnOf :: Getting [a] s a -> Getting [a] a a -> s -> [a] #

Given a Fold that knows how to locate immediate children, retrieve all of the transitive descendants of a node, including itself that lie in a region indicated by another Fold.

toListOf l ≡ universeOnOf l ignored

universeOn :: Plated a => Getting [a] s a -> s -> [a] #

Given a Fold that knows how to find Plated parts of a container retrieve them and all of their descendants, recursively.

universeOf :: Getting [a] a a -> a -> [a] #

Given a Fold that knows how to locate immediate children, retrieve all of the transitive descendants of a node, including itself.

universeOf :: Fold a a -> a -> [a]

universe :: Plated a => a -> [a] #

Retrieve all of the transitive descendants of a Plated container, including itself.

rewriteMOnOf :: Monad m => LensLike (WrappedMonad m) s t a b -> LensLike (WrappedMonad m) a b a b -> (b -> m (Maybe a)) -> s -> m t #

Rewrite by applying a monadic rule everywhere inside of a structure located by a user-specified Traversal, using a user-specified Traversal for recursion. Ensures that the rule cannot be applied anywhere in the result.

rewriteMOn :: (Monad m, Plated a) => LensLike (WrappedMonad m) s t a a -> (a -> m (Maybe a)) -> s -> m t #

Rewrite by applying a monadic rule everywhere inside of a structure located by a user-specified Traversal. Ensures that the rule cannot be applied anywhere in the result.

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

Rewrite by applying a monadic rule everywhere you recursing with a user-specified Traversal. Ensures that the rule cannot be applied anywhere in the result.

rewriteM :: (Monad m, Plated a) => (a -> m (Maybe a)) -> a -> m a #

Rewrite by applying a monadic rule everywhere you can. Ensures that the rule cannot be applied anywhere in the result.

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

Rewrite recursively over part of a larger structure using a specified Setter.

rewriteOnOf :: Iso' s a       -> Iso' a a       -> (a -> Maybe a) -> s -> s
rewriteOnOf :: Lens' s a      -> Lens' a a      -> (a -> Maybe a) -> s -> s
rewriteOnOf :: Traversal' s a -> Traversal' a a -> (a -> Maybe a) -> s -> s
rewriteOnOf :: Setter' s a    -> Setter' a a    -> (a -> Maybe a) -> s -> s

rewriteOn :: Plated a => ASetter s t a a -> (a -> Maybe a) -> s -> t #

Rewrite recursively over part of a larger structure.

rewriteOn :: Plated a => Iso' s a       -> (a -> Maybe a) -> s -> s
rewriteOn :: Plated a => Lens' s a      -> (a -> Maybe a) -> s -> s
rewriteOn :: Plated a => Traversal' s a -> (a -> Maybe a) -> s -> s
rewriteOn :: Plated a => ASetter' s a   -> (a -> Maybe a) -> s -> s

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

Rewrite by applying a rule everywhere you can. Ensures that the rule cannot be applied anywhere in the result:

propRewriteOf l r x = all (isNothing . r) (universeOf l (rewriteOf l r x))

Usually transformOf is more appropriate, but rewriteOf can give better compositionality. Given two single transformations f and g, you can construct \a -> f a <|> g a which performs both rewrites until a fixed point.

rewriteOf :: Iso' a a       -> (a -> Maybe a) -> a -> a
rewriteOf :: Lens' a a      -> (a -> Maybe a) -> a -> a
rewriteOf :: Traversal' a a -> (a -> Maybe a) -> a -> a
rewriteOf :: Setter' a a    -> (a -> Maybe a) -> a -> a

rewrite :: Plated a => (a -> Maybe a) -> a -> a #

Rewrite by applying a rule everywhere you can. Ensures that the rule cannot be applied anywhere in the result:

propRewrite r x = all (isNothing . r) (universe (rewrite r x))

Usually transform is more appropriate, but rewrite can give better compositionality. Given two single transformations f and g, you can construct \a -> f a <|> g a which performs both rewrites until a fixed point.

children :: Plated a => a -> [a] #

Extract the immediate descendants of a Plated container.

children ≡ toListOf plate

deep :: (Conjoined p, Applicative f, Plated s) => Traversing p f s s a b -> Over p f s s a b #

Try to apply a traversal to all transitive descendants of a Plated container, but do not recurse through matching descendants.

deep :: Plated s => Fold s a                 -> Fold s a
deep :: Plated s => IndexedFold s a          -> IndexedFold s a
deep :: Plated s => Traversal s s a b        -> Traversal s s a b
deep :: Plated s => IndexedTraversal s s a b -> IndexedTraversal s s a b

(...) :: (Applicative f, Plated c) => LensLike f s t c c -> Over p f c c a b -> Over p f s t a b infixr 9 #

Compose through a plate

class Plated a where #

A Plated type is one where we know how to extract its immediate self-similar children.

Example 1:

import Control.Applicative
import Control.Lens
import Control.Lens.Plated
import Data.Data
import Data.Data.Lens (uniplate)

data Expr
  = Val Int
  | Neg Expr
  | Add Expr Expr
  deriving (Eq,Ord,Show,Read,Data,Typeable)

instance Plated Expr where
  plate f (Neg e) = Neg <$> f e
  plate f (Add a b) = Add <$> f a <*> f b
  plate _ a = pure a

or

instance Plated Expr where
  plate = uniplate

Example 2:

import Control.Applicative
import Control.Lens
import Control.Lens.Plated
import Data.Data
import Data.Data.Lens (uniplate)

data Tree a
  = Bin (Tree a) (Tree a)
  | Tip a
  deriving (Eq,Ord,Show,Read,Data,Typeable)

instance Plated (Tree a) where
  plate f (Bin l r) = Bin <$> f l <*> f r
  plate _ t = pure t

or

instance Data a => Plated (Tree a) where
  plate = uniplate

Note the big distinction between these two implementations.

The former will only treat children directly in this tree as descendents, the latter will treat trees contained in the values under the tips also as descendants!

When in doubt, pick a Traversal and just use the various ...Of combinators rather than pollute Plated with orphan instances!

If you want to find something unplated and non-recursive with biplate use the ...OnOf variant with ignored, though those usecases are much better served in most cases by using the existing Lens combinators! e.g.

toListOf biplate ≡ universeOnOf biplate ignored

This same ability to explicitly pass the Traversal in question is why there is no analogue to uniplate's Biplate.

Moreover, since we can allow custom traversals, we implement reasonable defaults for polymorphic data types, that only traverse into themselves, and not their polymorphic arguments.

Minimal complete definition

Nothing

Methods

plate :: Traversal' a a #

Traversal of the immediate children of this structure.

If you're using GHC 7.2 or newer and your type has a Data instance, plate will default to uniplate and you can choose to not override it with your own definition.

Instances

Plated Exp
Instance details Defined in Control.Lens.Plated Methods plate :: Traversal' Exp Exp #
Plated Pat
Instance details Defined in Control.Lens.Plated Methods plate :: Traversal' Pat Pat #
Plated Type
Instance details Defined in Control.Lens.Plated Methods plate :: Traversal' Type Type #
Plated Dec
Instance details Defined in Control.Lens.Plated Methods plate :: Traversal' Dec Dec #
Plated Con
Instance details Defined in Control.Lens.Plated Methods plate :: Traversal' Con Con #
Plated Stmt
Instance details Defined in Control.Lens.Plated Methods plate :: Traversal' Stmt Stmt #
Plated [a]
Instance details Defined in Control.Lens.Plated Methods plate :: Traversal' [a] [a] #
Plated (Tree a)
Instance details Defined in Control.Lens.Plated Methods plate :: Traversal' (Tree a) (Tree a) #
Traversable f => Plated (Cofree f a)
Instance details Defined in Control.Lens.Plated Methods plate :: Traversal' (Cofree f a) (Cofree f a) #
Traversable f => Plated (F f a)
Instance details Defined in Control.Lens.Plated Methods plate :: Traversal' (F f a) (F f a) #
Traversable f => Plated (Free f a)
Instance details Defined in Control.Lens.Plated Methods plate :: Traversal' (Free f a) (Free f a) #
(Traversable f, Traversable m) => Plated (FreeT f m a)
Instance details Defined in Control.Lens.Plated Methods plate :: Traversal' (FreeT f m a) (FreeT f m a) #
(Traversable f, Traversable w) => Plated (CofreeT f w a)
Instance details Defined in Control.Lens.Plated Methods plate :: Traversal' (CofreeT f w a) (CofreeT f w a) #

class GPlated a (g :: k -> Type) #

Minimal complete definition

gplate'

Instances

GPlated a (V1 :: k -> Type)
Instance details Defined in Control.Lens.Plated Methods gplate' :: Traversal' (V1 p) a
GPlated a (U1 :: k -> Type)
Instance details Defined in Control.Lens.Plated Methods gplate' :: Traversal' (U1 p) a
GPlated a (URec b :: k -> Type)
Instance details Defined in Control.Lens.Plated Methods gplate' :: Traversal' (URec b p) a
GPlated a (K1 i a :: k -> Type)
Instance details Defined in Control.Lens.Plated Methods gplate' :: Traversal' (K1 i a p) a
GPlated a (K1 i b :: k -> Type)
Instance details Defined in Control.Lens.Plated Methods gplate' :: Traversal' (K1 i b p) a
(GPlated a f, GPlated a g) => GPlated a (f :+: g :: k -> Type)
Instance details Defined in Control.Lens.Plated Methods gplate' :: Traversal' ((f :+: g) p) a
(GPlated a f, GPlated a g) => GPlated a (f :*: g :: k -> Type)
Instance details Defined in Control.Lens.Plated Methods gplate' :: Traversal' ((f :*: g) p) a
GPlated a f => GPlated a (M1 i c f :: k -> Type)
Instance details Defined in Control.Lens.Plated Methods gplate' :: Traversal' (M1 i c f p) a

class GPlated1 (f :: k -> Type) (g :: k -> Type) #

Minimal complete definition

gplate1'

Instances

GPlated1 (f :: k -> Type) (V1 :: k -> Type)	ignored
Instance details Defined in Control.Lens.Plated Methods gplate1' :: Traversal' (V1 a) (f a)
GPlated1 (f :: k -> Type) (U1 :: k -> Type)	ignored
Instance details Defined in Control.Lens.Plated Methods gplate1' :: Traversal' (U1 a) (f a)
GPlated1 (f :: k -> Type) (URec a :: k -> Type)	ignored
Instance details Defined in Control.Lens.Plated Methods gplate1' :: Traversal' (URec a a0) (f a0)
GPlated1 (f :: k -> Type) (Rec1 f :: k -> Type)	match
Instance details Defined in Control.Lens.Plated Methods gplate1' :: Traversal' (Rec1 f a) (f a)
GPlated1 (f :: k -> Type) (Rec1 g :: k -> Type)	ignored
Instance details Defined in Control.Lens.Plated Methods gplate1' :: Traversal' (Rec1 g a) (f a)
GPlated1 (f :: k -> Type) (K1 i a :: k -> Type)	ignored
Instance details Defined in Control.Lens.Plated Methods gplate1' :: Traversal' (K1 i a a0) (f a0)
(GPlated1 f g, GPlated1 f h) => GPlated1 (f :: k -> Type) (g :+: h :: k -> Type)	recursive match
Instance details Defined in Control.Lens.Plated Methods gplate1' :: Traversal' ((g :+: h) a) (f a)
(GPlated1 f g, GPlated1 f h) => GPlated1 (f :: k -> Type) (g :*: h :: k -> Type)	recursive match
Instance details Defined in Control.Lens.Plated Methods gplate1' :: Traversal' ((g :*: h) a) (f a)
GPlated1 f g => GPlated1 (f :: k -> Type) (M1 i c g :: k -> Type)	recursive match
Instance details Defined in Control.Lens.Plated Methods gplate1' :: Traversal' (M1 i c g a) (f a)
(Traversable t, GPlated1 f g) => GPlated1 (f :: k1 -> Type) (t :.: g :: k1 -> Type)	recursive match under outer `Traversable` instance
Instance details Defined in Control.Lens.Plated Methods gplate1' :: Traversal' ((t :.: g) a) (f a)
GPlated1 (f :: Type -> Type) Par1	ignored
Instance details Defined in Control.Lens.Plated Methods gplate1' :: Traversal' (Par1 a) (f a)

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

This type family is used by Zoom to describe the common effect type.

Instances

type Zoomed (MaybeT m)
Instance details Defined in Control.Lens.Zoom type Zoomed (MaybeT m) = FocusingMay (Zoomed m)
type Zoomed (ListT m)
Instance details Defined in Control.Lens.Zoom type Zoomed (ListT m) = FocusingOn [] (Zoomed m)
type Zoomed (IdentityT m)
Instance details Defined in Control.Lens.Zoom type Zoomed (IdentityT m) = Zoomed m
type Zoomed (WriterT w m)
Instance details Defined in Control.Lens.Zoom type Zoomed (WriterT w m) = FocusingPlus w (Zoomed m)
type Zoomed (WriterT w m)
Instance details Defined in Control.Lens.Zoom type Zoomed (WriterT w m) = FocusingPlus w (Zoomed m)
type Zoomed (StateT s z)
Instance details Defined in Control.Lens.Zoom type Zoomed (StateT s z) = Focusing z
type Zoomed (StateT s z)
Instance details Defined in Control.Lens.Zoom type Zoomed (StateT s z) = Focusing z
type Zoomed (ExceptT e m)
Instance details Defined in Control.Lens.Zoom type Zoomed (ExceptT e m) = FocusingErr e (Zoomed m)
type Zoomed (FreeT f m)
Instance details Defined in Control.Lens.Zoom type Zoomed (FreeT f m) = FocusingFree f m (Zoomed m)
type Zoomed (ErrorT e m)
Instance details Defined in Control.Lens.Zoom type Zoomed (ErrorT e m) = FocusingErr e (Zoomed m)
type Zoomed (ReaderT e m)
Instance details Defined in Control.Lens.Zoom type Zoomed (ReaderT e m) = Zoomed m
type Zoomed (RWST r w s z)
Instance details Defined in Control.Lens.Zoom type Zoomed (RWST r w s z) = FocusingWith w z
type Zoomed (RWST r w s z)
Instance details Defined in Control.Lens.Zoom type Zoomed (RWST r w s z) = FocusingWith w z

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

This type family is used by Magnify to describe the common effect type.

Instances

type Magnified (IdentityT m)
Instance details Defined in Control.Lens.Zoom type Magnified (IdentityT m) = Magnified m
type Magnified ((->) b :: Type -> Type)
Instance details Defined in Control.Lens.Zoom type Magnified ((->) b :: Type -> Type) = (Const :: Type -> Type -> Type)
type Magnified (ReaderT b m)
Instance details Defined in Control.Lens.Zoom type Magnified (ReaderT b m) = Effect m
type Magnified (RWST a w s m)
Instance details Defined in Control.Lens.Zoom type Magnified (RWST a w s m) = EffectRWS w s m
type Magnified (RWST a w s m)
Instance details Defined in Control.Lens.Zoom type Magnified (RWST a w s m) = EffectRWS w s m

class (MonadState s m, MonadState t n) => Zoom (m :: Type -> Type) (n :: Type -> Type) s t | m -> s, n -> t, m t -> n, n s -> m where #

This class allows us to use zoom in, changing the State supplied by many different Monad transformers, potentially quite deep in a Monad transformer stack.

Methods

zoom :: LensLike' (Zoomed m c) t s -> m c -> n c infixr 2 #

Run a monadic action in a larger State than it was defined in, using a Lens' or Traversal'.

This is commonly used to lift actions in a simpler State Monad into a State Monad with a larger State type.

When applied to a Traversal' over multiple values, the actions for each target are executed sequentially and the results are aggregated.

This can be used to edit pretty much any Monad transformer stack with a State in it!

>>> flip State.evalState (a,b) $ zoom _1 $ use id
a

>>> flip State.execState (a,b) $ zoom _1 $ id .= c
(c,b)

>>> flip State.execState [(a,b),(c,d)] $ zoom traverse $ _2 %= f
[(a,f b),(c,f d)]

>>> flip State.runState [(a,b),(c,d)] $ zoom traverse $ _2 <%= f
(f b <> f d <> mempty,[(a,f b),(c,f d)])

>>> flip State.evalState (a,b) $ zoom both (use id)
a <> b

zoom :: Monad m             => Lens' s t      -> StateT t m a -> StateT s m a
zoom :: (Monad m, Monoid c) => Traversal' s t -> StateT t m c -> StateT s m c
zoom :: (Monad m, Monoid w)             => Lens' s t      -> RWST r w t m c -> RWST r w s m c
zoom :: (Monad m, Monoid w, Monoid c) => Traversal' s t -> RWST r w t m c -> RWST r w s m c
zoom :: (Monad m, Monoid w, Error e)  => Lens' s t      -> ErrorT e (RWST r w t m) c -> ErrorT e (RWST r w s m) c
zoom :: (Monad m, Monoid w, Monoid c, Error e) => Traversal' s t -> ErrorT e (RWST r w t m) c -> ErrorT e (RWST r w s m) c
...

Instances

Zoom m n s t => Zoom (MaybeT m) (MaybeT n) s t
Instance details Defined in Control.Lens.Zoom Methods zoom :: LensLike' (Zoomed (MaybeT m) c) t s -> MaybeT m c -> MaybeT n c #
Zoom m n s t => Zoom (ListT m) (ListT n) s t
Instance details Defined in Control.Lens.Zoom Methods zoom :: LensLike' (Zoomed (ListT m) c) t s -> ListT m c -> ListT n c #
Zoom m n s t => Zoom (IdentityT m) (IdentityT n) s t
Instance details Defined in Control.Lens.Zoom Methods zoom :: LensLike' (Zoomed (IdentityT m) c) t s -> IdentityT m c -> IdentityT n c #
(Monoid w, Zoom m n s t) => Zoom (WriterT w m) (WriterT w n) s t
Instance details Defined in Control.Lens.Zoom Methods zoom :: LensLike' (Zoomed (WriterT w m) c) t s -> WriterT w m c -> WriterT w n c #
(Monoid w, Zoom m n s t) => Zoom (WriterT w m) (WriterT w n) s t
Instance details Defined in Control.Lens.Zoom Methods zoom :: LensLike' (Zoomed (WriterT w m) c) t s -> WriterT w m c -> WriterT w n c #
Monad z => Zoom (StateT s z) (StateT t z) s t
Instance details Defined in Control.Lens.Zoom Methods zoom :: LensLike' (Zoomed (StateT s z) c) t s -> StateT s z c -> StateT t z c #
Monad z => Zoom (StateT s z) (StateT t z) s t
Instance details Defined in Control.Lens.Zoom Methods zoom :: LensLike' (Zoomed (StateT s z) c) t s -> StateT s z c -> StateT t z c #
Zoom m n s t => Zoom (ExceptT e m) (ExceptT e n) s t
Instance details Defined in Control.Lens.Zoom Methods zoom :: LensLike' (Zoomed (ExceptT e m) c) t s -> ExceptT e m c -> ExceptT e n c #
(Functor f, Zoom m n s t) => Zoom (FreeT f m) (FreeT f n) s t
Instance details Defined in Control.Lens.Zoom Methods zoom :: LensLike' (Zoomed (FreeT f m) c) t s -> FreeT f m c -> FreeT f n c #
(Error e, Zoom m n s t) => Zoom (ErrorT e m) (ErrorT e n) s t
Instance details Defined in Control.Lens.Zoom Methods zoom :: LensLike' (Zoomed (ErrorT e m) c) t s -> ErrorT e m c -> ErrorT e n c #
Zoom m n s t => Zoom (ReaderT e m) (ReaderT e n) s t
Instance details Defined in Control.Lens.Zoom Methods zoom :: LensLike' (Zoomed (ReaderT e m) c) t s -> ReaderT e m c -> ReaderT e n c #
(Monoid w, Monad z) => Zoom (RWST r w s z) (RWST r w t z) s t
Instance details Defined in Control.Lens.Zoom Methods zoom :: LensLike' (Zoomed (RWST r w s z) c) t s -> RWST r w s z c -> RWST r w t z c #
(Monoid w, Monad z) => Zoom (RWST r w s z) (RWST r w t z) s t
Instance details Defined in Control.Lens.Zoom Methods zoom :: LensLike' (Zoomed (RWST r w s z) c) t s -> RWST r w s z c -> RWST r w t z c #

class (Magnified m ~ Magnified n, MonadReader b m, MonadReader a n) => Magnify (m :: Type -> Type) (n :: Type -> Type) b a | m -> b, n -> a, m a -> n, n b -> m where #

This class allows us to use magnify part of the environment, changing the environment supplied by many different Monad transformers. Unlike zoom this can change the environment of a deeply nested Monad transformer.

Also, unlike zoom, this can be used with any valid Getter, but cannot be used with a Traversal or Fold.

Methods

magnify :: (Functor (Magnified m c) -> Contravariant (Magnified m c) -> LensLike' (Magnified m c) a b) -> m c -> n c infixr 2 #

Run a monadic action in a larger environment than it was defined in, using a Getter.

This acts like local, but can in many cases change the type of the environment as well.

This is commonly used to lift actions in a simpler Reader Monad into a Monad with a larger environment type.

This can be used to edit pretty much any Monad transformer stack with an environment in it:

>>> (1,2) & magnify _2 (+1)
3

>>> flip Reader.runReader (1,2) $ magnify _1 Reader.ask
1

>>> flip Reader.runReader (1,2,[10..20]) $ magnify (_3._tail) Reader.ask
[11,12,13,14,15,16,17,18,19,20]

The type can be read as

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

but the higher-rank constraints make it easier to apply magnify to a Getter in highly-polymorphic code.

magnify :: Getter s a -> (a -> r) -> s -> r
magnify :: Monoid r => Fold s a   -> (a -> r) -> s -> r

magnify :: Monoid w                 => Getter s t -> RWS t w st c -> RWS s w st c
magnify :: (Monoid w, Monoid c) => Fold s a   -> RWS a w st c -> RWS s w st c
...

Instances

Magnify m n b a => Magnify (IdentityT m) (IdentityT n) b a
Instance details Defined in Control.Lens.Zoom Methods magnify :: (Functor (Magnified (IdentityT m) c) -> Contravariant (Magnified (IdentityT m) c) -> LensLike' (Magnified (IdentityT m) c) a b) -> IdentityT m c -> IdentityT n c #
Magnify ((->) b :: Type -> Type) ((->) a :: Type -> Type) b a	`magnify` = `views`
Instance details Defined in Control.Lens.Zoom Methods magnify :: (Functor (Magnified ((->) b) c) -> Contravariant (Magnified ((->) b) c) -> LensLike' (Magnified ((->) b) c) a b) -> (b -> c) -> a -> c #
Monad m => Magnify (ReaderT b m) (ReaderT a m) b a
Instance details Defined in Control.Lens.Zoom Methods magnify :: (Functor (Magnified (ReaderT b m) c) -> Contravariant (Magnified (ReaderT b m) c) -> LensLike' (Magnified (ReaderT b m) c) a b) -> ReaderT b m c -> ReaderT a m c #
(Monad m, Monoid w) => Magnify (RWST b w s m) (RWST a w s m) b a
Instance details Defined in Control.Lens.Zoom Methods magnify :: (Functor (Magnified (RWST b w s m) c) -> Contravariant (Magnified (RWST b w s m) c) -> LensLike' (Magnified (RWST b w s m) c) a b) -> RWST b w s m c -> RWST a w s m c #
(Monad m, Monoid w) => Magnify (RWST b w s m) (RWST a w s m) b a
Instance details Defined in Control.Lens.Zoom Methods magnify :: (Functor (Magnified (RWST b w s m) c) -> Contravariant (Magnified (RWST b w s m) c) -> LensLike' (Magnified (RWST b w s m) c) a b) -> RWST b w s m c -> RWST a w s m c #

alaf :: (Functor f, Functor g, Rewrapping s t) => (Unwrapped s -> s) -> (f t -> g s) -> f (Unwrapped t) -> g (Unwrapped s) #

This combinator is based on ala' from Conor McBride's work on Epigram.

As with _Wrapping, the user supplied function for the newtype is ignored.

alaf :: Rewrapping s t => (Unwrapped s -> s) -> ((r -> t) -> e -> s) -> (r -> Unwrapped t) -> e -> Unwrapped s

>>> alaf Sum foldMap Prelude.length ["hello","world"]
10

ala :: (Functor f, Rewrapping s t) => (Unwrapped s -> s) -> ((Unwrapped t -> t) -> f s) -> f (Unwrapped s) #

This combinator is based on ala from Conor McBride's work on Epigram.

As with _Wrapping, the user supplied function for the newtype is ignored.

>>> ala Sum foldMap [1,2,3,4]
10

>>> ala All foldMap [True,True]
True

>>> ala All foldMap [True,False]
False

>>> ala Any foldMap [False,False]
False

>>> ala Any foldMap [True,False]
True

>>> ala Product foldMap [1,2,3,4]
24

You may want to think of this combinator as having the following, simpler, type.

ala :: Rewrapping s t => (Unwrapped s -> s) -> ((Unwrapped t -> t) -> e -> s) -> e -> Unwrapped s

_Unwrapping :: Rewrapping s t => (Unwrapped s -> s) -> Iso (Unwrapped t) (Unwrapped s) t s #

This is a convenient version of _Unwrapped with an argument that's ignored.

The user supplied function is ignored, merely its types are used.

_Wrapping :: Rewrapping s t => (Unwrapped s -> s) -> Iso s t (Unwrapped s) (Unwrapped t) #

This is a convenient version of _Wrapped with an argument that's ignored.

The user supplied function is ignored, merely its types are used.

_Unwrapping' :: Wrapped s => (Unwrapped s -> s) -> Iso' (Unwrapped s) s #

This is a convenient version of _Wrapped with an argument that's ignored.

The user supplied function is ignored, merely its type is used.

_Wrapping' :: Wrapped s => (Unwrapped s -> s) -> Iso' s (Unwrapped s) #

This is a convenient version of _Wrapped with an argument that's ignored.

The user supplied function is ignored, merely its type is used.

op :: Wrapped s => (Unwrapped s -> s) -> s -> Unwrapped s #

Given the constructor for a Wrapped type, return a deconstructor that is its inverse.

Assuming the Wrapped instance is legal, these laws hold:

op f . f ≡ id
f . op f ≡ id

>>> op Identity (Identity 4)
4

>>> op Const (Const "hello")
"hello"

_Unwrapped :: Rewrapping s t => Iso (Unwrapped t) (Unwrapped s) t s #

_Wrapped :: Rewrapping s t => Iso s t (Unwrapped s) (Unwrapped t) #

Work under a newtype wrapper.

>>> Const "hello" & _Wrapped %~ Prelude.length & getConst
5

_Wrapped   ≡ from _Unwrapped
_Unwrapped ≡ from _Wrapped

_Unwrapped' :: Wrapped s => Iso' (Unwrapped s) s #

_GWrapped' :: (Generic s, D1 d (C1 c (S1 s' (Rec0 a))) ~ Rep s, Unwrapped s ~ GUnwrapped (Rep s)) => Iso' s (Unwrapped s) #

Implement the _Wrapped operation for a type using its Generic instance.

pattern Wrapped :: forall s. Rewrapped s s => Unwrapped s -> s #

pattern Unwrapped :: forall t. Rewrapped t t => t -> Unwrapped t #

class Wrapped s where #

Wrapped provides isomorphisms to wrap and unwrap newtypes or data types with one constructor.

Minimal complete definition

Nothing

Associated Types

type Unwrapped s :: Type #

Methods

_Wrapped' :: Iso' s (Unwrapped s) #

An isomorphism between s and a.

If your type has a Generic instance, _Wrapped' will default to _GWrapped', and you can choose to not override it with your own definition.

Instances

Wrapped Fd
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped Fd :: Type # Methods _Wrapped' :: Iso' Fd (Unwrapped Fd) #
Wrapped CTimer
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped CTimer :: Type # Methods _Wrapped' :: Iso' CTimer (Unwrapped CTimer) #
Wrapped CKey
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped CKey :: Type # Methods _Wrapped' :: Iso' CKey (Unwrapped CKey) #
Wrapped CId
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped CId :: Type # Methods _Wrapped' :: Iso' CId (Unwrapped CId) #
Wrapped CFsFilCnt
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped CFsFilCnt :: Type # Methods _Wrapped' :: Iso' CFsFilCnt (Unwrapped CFsFilCnt) #
Wrapped CFsBlkCnt
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped CFsBlkCnt :: Type # Methods _Wrapped' :: Iso' CFsBlkCnt (Unwrapped CFsBlkCnt) #
Wrapped CClockId
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped CClockId :: Type # Methods _Wrapped' :: Iso' CClockId (Unwrapped CClockId) #
Wrapped CBlkCnt
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped CBlkCnt :: Type # Methods _Wrapped' :: Iso' CBlkCnt (Unwrapped CBlkCnt) #
Wrapped CBlkSize
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped CBlkSize :: Type # Methods _Wrapped' :: Iso' CBlkSize (Unwrapped CBlkSize) #
Wrapped CRLim
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped CRLim :: Type # Methods _Wrapped' :: Iso' CRLim (Unwrapped CRLim) #
Wrapped CTcflag
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped CTcflag :: Type # Methods _Wrapped' :: Iso' CTcflag (Unwrapped CTcflag) #
Wrapped CSpeed
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped CSpeed :: Type # Methods _Wrapped' :: Iso' CSpeed (Unwrapped CSpeed) #
Wrapped CCc
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped CCc :: Type # Methods _Wrapped' :: Iso' CCc (Unwrapped CCc) #
Wrapped CUid
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped CUid :: Type # Methods _Wrapped' :: Iso' CUid (Unwrapped CUid) #
Wrapped CNlink
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped CNlink :: Type # Methods _Wrapped' :: Iso' CNlink (Unwrapped CNlink) #
Wrapped CGid
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped CGid :: Type # Methods _Wrapped' :: Iso' CGid (Unwrapped CGid) #
Wrapped CSsize
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped CSsize :: Type # Methods _Wrapped' :: Iso' CSsize (Unwrapped CSsize) #
Wrapped CPid
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped CPid :: Type # Methods _Wrapped' :: Iso' CPid (Unwrapped CPid) #
Wrapped COff
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped COff :: Type # Methods _Wrapped' :: Iso' COff (Unwrapped COff) #
Wrapped CMode
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped CMode :: Type # Methods _Wrapped' :: Iso' CMode (Unwrapped CMode) #
Wrapped CIno
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped CIno :: Type # Methods _Wrapped' :: Iso' CIno (Unwrapped CIno) #
Wrapped CDev
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped CDev :: Type # Methods _Wrapped' :: Iso' CDev (Unwrapped CDev) #
Wrapped PatternMatchFail
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped PatternMatchFail :: Type # Methods _Wrapped' :: Iso' PatternMatchFail (Unwrapped PatternMatchFail) #
Wrapped RecSelError
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped RecSelError :: Type # Methods _Wrapped' :: Iso' RecSelError (Unwrapped RecSelError) #
Wrapped RecConError
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped RecConError :: Type # Methods _Wrapped' :: Iso' RecConError (Unwrapped RecConError) #
Wrapped RecUpdError
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped RecUpdError :: Type # Methods _Wrapped' :: Iso' RecUpdError (Unwrapped RecUpdError) #
Wrapped NoMethodError
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped NoMethodError :: Type # Methods _Wrapped' :: Iso' NoMethodError (Unwrapped NoMethodError) #
Wrapped TypeError
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped TypeError :: Type # Methods _Wrapped' :: Iso' TypeError (Unwrapped TypeError) #
Wrapped Errno
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped Errno :: Type # Methods _Wrapped' :: Iso' Errno (Unwrapped Errno) #
Wrapped CompactionFailed
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped CompactionFailed :: Type # Methods _Wrapped' :: Iso' CompactionFailed (Unwrapped CompactionFailed) #
Wrapped AssertionFailed
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped AssertionFailed :: Type # Methods _Wrapped' :: Iso' AssertionFailed (Unwrapped AssertionFailed) #
Wrapped ErrorCall
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped ErrorCall :: Type # Methods _Wrapped' :: Iso' ErrorCall (Unwrapped ErrorCall) #
Wrapped All
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped All :: Type # Methods _Wrapped' :: Iso' All (Unwrapped All) #
Wrapped Any
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped Any :: Type # Methods _Wrapped' :: Iso' Any (Unwrapped Any) #
Wrapped CChar
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped CChar :: Type # Methods _Wrapped' :: Iso' CChar (Unwrapped CChar) #
Wrapped CSChar
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped CSChar :: Type # Methods _Wrapped' :: Iso' CSChar (Unwrapped CSChar) #
Wrapped CUChar
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped CUChar :: Type # Methods _Wrapped' :: Iso' CUChar (Unwrapped CUChar) #
Wrapped CShort
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped CShort :: Type # Methods _Wrapped' :: Iso' CShort (Unwrapped CShort) #
Wrapped CUShort
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped CUShort :: Type # Methods _Wrapped' :: Iso' CUShort (Unwrapped CUShort) #
Wrapped CInt
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped CInt :: Type # Methods _Wrapped' :: Iso' CInt (Unwrapped CInt) #
Wrapped CUInt
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped CUInt :: Type # Methods _Wrapped' :: Iso' CUInt (Unwrapped CUInt) #
Wrapped CLong
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped CLong :: Type # Methods _Wrapped' :: Iso' CLong (Unwrapped CLong) #
Wrapped CULong
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped CULong :: Type # Methods _Wrapped' :: Iso' CULong (Unwrapped CULong) #
Wrapped CLLong
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped CLLong :: Type # Methods _Wrapped' :: Iso' CLLong (Unwrapped CLLong) #
Wrapped CULLong
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped CULLong :: Type # Methods _Wrapped' :: Iso' CULLong (Unwrapped CULLong) #
Wrapped CBool
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped CBool :: Type # Methods _Wrapped' :: Iso' CBool (Unwrapped CBool) #
Wrapped CFloat
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped CFloat :: Type # Methods _Wrapped' :: Iso' CFloat (Unwrapped CFloat) #
Wrapped CDouble
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped CDouble :: Type # Methods _Wrapped' :: Iso' CDouble (Unwrapped CDouble) #
Wrapped CPtrdiff
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped CPtrdiff :: Type # Methods _Wrapped' :: Iso' CPtrdiff (Unwrapped CPtrdiff) #
Wrapped CSize
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped CSize :: Type # Methods _Wrapped' :: Iso' CSize (Unwrapped CSize) #
Wrapped CWchar
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped CWchar :: Type # Methods _Wrapped' :: Iso' CWchar (Unwrapped CWchar) #
Wrapped CSigAtomic
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped CSigAtomic :: Type # Methods _Wrapped' :: Iso' CSigAtomic (Unwrapped CSigAtomic) #
Wrapped CClock
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped CClock :: Type # Methods _Wrapped' :: Iso' CClock (Unwrapped CClock) #
Wrapped CTime
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped CTime :: Type # Methods _Wrapped' :: Iso' CTime (Unwrapped CTime) #
Wrapped CUSeconds
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped CUSeconds :: Type # Methods _Wrapped' :: Iso' CUSeconds (Unwrapped CUSeconds) #
Wrapped CSUSeconds
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped CSUSeconds :: Type # Methods _Wrapped' :: Iso' CSUSeconds (Unwrapped CSUSeconds) #
Wrapped CIntPtr
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped CIntPtr :: Type # Methods _Wrapped' :: Iso' CIntPtr (Unwrapped CIntPtr) #
Wrapped CUIntPtr
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped CUIntPtr :: Type # Methods _Wrapped' :: Iso' CUIntPtr (Unwrapped CUIntPtr) #
Wrapped CIntMax
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped CIntMax :: Type # Methods _Wrapped' :: Iso' CIntMax (Unwrapped CIntMax) #
Wrapped CUIntMax
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped CUIntMax :: Type # Methods _Wrapped' :: Iso' CUIntMax (Unwrapped CUIntMax) #
Wrapped IntSet
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped IntSet :: Type # Methods _Wrapped' :: Iso' IntSet (Unwrapped IntSet) #
Wrapped (Par1 p)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (Par1 p) :: Type # Methods _Wrapped' :: Iso' (Par1 p) (Unwrapped (Par1 p)) #
Ord a => Wrapped (Set a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (Set a) :: Type # Methods _Wrapped' :: Iso' (Set a) (Unwrapped (Set a)) #
Wrapped (Identity a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (Identity a) :: Type # Methods _Wrapped' :: Iso' (Identity a) (Unwrapped (Identity a)) #
Wrapped (ZipList a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (ZipList a) :: Type # Methods _Wrapped' :: Iso' (ZipList a) (Unwrapped (ZipList a)) #
Storable a => Wrapped (Vector a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (Vector a) :: Type # Methods _Wrapped' :: Iso' (Vector a) (Unwrapped (Vector a)) #
Wrapped (Predicate a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (Predicate a) :: Type # Methods _Wrapped' :: Iso' (Predicate a) (Unwrapped (Predicate a)) #
Wrapped (Comparison a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (Comparison a) :: Type # Methods _Wrapped' :: Iso' (Comparison a) (Unwrapped (Comparison a)) #
Wrapped (Equivalence a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (Equivalence a) :: Type # Methods _Wrapped' :: Iso' (Equivalence a) (Unwrapped (Equivalence a)) #
Wrapped (Min a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (Min a) :: Type # Methods _Wrapped' :: Iso' (Min a) (Unwrapped (Min a)) #
Wrapped (Max a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (Max a) :: Type # Methods _Wrapped' :: Iso' (Max a) (Unwrapped (Max a)) #
Wrapped (First a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (First a) :: Type # Methods _Wrapped' :: Iso' (First a) (Unwrapped (First a)) #
Wrapped (Last a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (Last a) :: Type # Methods _Wrapped' :: Iso' (Last a) (Unwrapped (Last a)) #
Wrapped (WrappedMonoid a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (WrappedMonoid a) :: Type # Methods _Wrapped' :: Iso' (WrappedMonoid a) (Unwrapped (WrappedMonoid a)) #
Wrapped (Option a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (Option a) :: Type # Methods _Wrapped' :: Iso' (Option a) (Unwrapped (Option a)) #
Wrapped (First a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (First a) :: Type # Methods _Wrapped' :: Iso' (First a) (Unwrapped (First a)) #
Wrapped (Last a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (Last a) :: Type # Methods _Wrapped' :: Iso' (Last a) (Unwrapped (Last a)) #
Wrapped (Dual a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (Dual a) :: Type # Methods _Wrapped' :: Iso' (Dual a) (Unwrapped (Dual a)) #
Wrapped (Endo a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (Endo a) :: Type # Methods _Wrapped' :: Iso' (Endo a) (Unwrapped (Endo a)) #
Wrapped (Sum a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (Sum a) :: Type # Methods _Wrapped' :: Iso' (Sum a) (Unwrapped (Sum a)) #
Wrapped (Product a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (Product a) :: Type # Methods _Wrapped' :: Iso' (Product a) (Unwrapped (Product a)) #
Wrapped (Down a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (Down a) :: Type # Methods _Wrapped' :: Iso' (Down a) (Unwrapped (Down a)) #
Wrapped (NonEmpty a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (NonEmpty a) :: Type # Methods _Wrapped' :: Iso' (NonEmpty a) (Unwrapped (NonEmpty a)) #
Wrapped (IntMap a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (IntMap a) :: Type # Methods _Wrapped' :: Iso' (IntMap a) (Unwrapped (IntMap a)) #
Wrapped (Seq a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (Seq a) :: Type # Methods _Wrapped' :: Iso' (Seq a) (Unwrapped (Seq a)) #
Prim a => Wrapped (Vector a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (Vector a) :: Type # Methods _Wrapped' :: Iso' (Vector a) (Unwrapped (Vector a)) #
Unbox a => Wrapped (Vector a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (Vector a) :: Type # Methods _Wrapped' :: Iso' (Vector a) (Unwrapped (Vector a)) #
(Hashable a, Eq a) => Wrapped (HashSet a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (HashSet a) :: Type # Methods _Wrapped' :: Iso' (HashSet a) (Unwrapped (HashSet a)) #
Wrapped (Vector a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (Vector a) :: Type # Methods _Wrapped' :: Iso' (Vector a) (Unwrapped (Vector a)) #
Ord k => Wrapped (Map k a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (Map k a) :: Type # Methods _Wrapped' :: Iso' (Map k a) (Unwrapped (Map k a)) #
Wrapped (WrappedMonad m a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (WrappedMonad m a) :: Type # Methods _Wrapped' :: Iso' (WrappedMonad m a) (Unwrapped (WrappedMonad m a)) #
Wrapped (Op a b)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (Op a b) :: Type # Methods _Wrapped' :: Iso' (Op a b) (Unwrapped (Op a b)) #
(Hashable k, Eq k) => Wrapped (HashMap k a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (HashMap k a) :: Type # Methods _Wrapped' :: Iso' (HashMap k a) (Unwrapped (HashMap k a)) #
Wrapped (ArrowMonad m a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (ArrowMonad m a) :: Type # Methods _Wrapped' :: Iso' (ArrowMonad m a) (Unwrapped (ArrowMonad m a)) #
Wrapped (MaybeT m a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (MaybeT m a) :: Type # Methods _Wrapped' :: Iso' (MaybeT m a) (Unwrapped (MaybeT m a)) #
Wrapped (CatchT m a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (CatchT m a) :: Type # Methods _Wrapped' :: Iso' (CatchT m a) (Unwrapped (CatchT m a)) #
Wrapped (CoiterT w a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (CoiterT w a) :: Type # Methods _Wrapped' :: Iso' (CoiterT w a) (Unwrapped (CoiterT w a)) #
Wrapped (IterT m a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (IterT m a) :: Type # Methods _Wrapped' :: Iso' (IterT m a) (Unwrapped (IterT m a)) #
Wrapped (Alt f a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (Alt f a) :: Type # Methods _Wrapped' :: Iso' (Alt f a) (Unwrapped (Alt f a)) #
Wrapped (ListT m a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (ListT m a) :: Type # Methods _Wrapped' :: Iso' (ListT m a) (Unwrapped (ListT m a)) #
Wrapped (WrappedApplicative f a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (WrappedApplicative f a) :: Type # Methods _Wrapped' :: Iso' (WrappedApplicative f a) (Unwrapped (WrappedApplicative f a)) #
Wrapped (MaybeApply f a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (MaybeApply f a) :: Type # Methods _Wrapped' :: Iso' (MaybeApply f a) (Unwrapped (MaybeApply f a)) #
Wrapped (Rec1 f p)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (Rec1 f p) :: Type # Methods _Wrapped' :: Iso' (Rec1 f p) (Unwrapped (Rec1 f p)) #
Wrapped (IdentityT m a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (IdentityT m a) :: Type # Methods _Wrapped' :: Iso' (IdentityT m a) (Unwrapped (IdentityT m a)) #
Wrapped (Const a x)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (Const a x) :: Type # Methods _Wrapped' :: Iso' (Const a x) (Unwrapped (Const a x)) #
Wrapped (WrappedArrow a b c)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (WrappedArrow a b c) :: Type # Methods _Wrapped' :: Iso' (WrappedArrow a b c) (Unwrapped (WrappedArrow a b c)) #
Wrapped (Kleisli m a b)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (Kleisli m a b) :: Type # Methods _Wrapped' :: Iso' (Kleisli m a b) (Unwrapped (Kleisli m a b)) #
Wrapped (Ap f a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (Ap f a) :: Type # Methods _Wrapped' :: Iso' (Ap f a) (Unwrapped (Ap f a)) #
Wrapped (Alt f a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (Alt f a) :: Type # Methods _Wrapped' :: Iso' (Alt f a) (Unwrapped (Alt f a)) #
Wrapped (Join p a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (Join p a) :: Type # Methods _Wrapped' :: Iso' (Join p a) (Unwrapped (Join p a)) #
Wrapped (Fix p a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (Fix p a) :: Type # Methods _Wrapped' :: Iso' (Fix p a) (Unwrapped (Fix p a)) #
Wrapped (TracedT m w a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (TracedT m w a) :: Type # Methods _Wrapped' :: Iso' (TracedT m w a) (Unwrapped (TracedT m w a)) #
Wrapped (WriterT w m a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (WriterT w m a) :: Type # Methods _Wrapped' :: Iso' (WriterT w m a) (Unwrapped (WriterT w m a)) #
Wrapped (WriterT w m a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (WriterT w m a) :: Type # Methods _Wrapped' :: Iso' (WriterT w m a) (Unwrapped (WriterT w m a)) #
Wrapped (StateT s m a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (StateT s m a) :: Type # Methods _Wrapped' :: Iso' (StateT s m a) (Unwrapped (StateT s m a)) #
Wrapped (StateT s m a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (StateT s m a) :: Type # Methods _Wrapped' :: Iso' (StateT s m a) (Unwrapped (StateT s m a)) #
Wrapped (ExceptT e m a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (ExceptT e m a) :: Type # Methods _Wrapped' :: Iso' (ExceptT e m a) (Unwrapped (ExceptT e m a)) #
Wrapped (Compose f g a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (Compose f g a) :: Type # Methods _Wrapped' :: Iso' (Compose f g a) (Unwrapped (Compose f g a)) #
Wrapped (ComposeFC f g a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (ComposeFC f g a) :: Type # Methods _Wrapped' :: Iso' (ComposeFC f g a) (Unwrapped (ComposeFC f g a)) #
Wrapped (ComposeCF f g a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (ComposeCF f g a) :: Type # Methods _Wrapped' :: Iso' (ComposeCF f g a) (Unwrapped (ComposeCF f g a)) #
Wrapped (FreeT f m a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (FreeT f m a) :: Type # Methods _Wrapped' :: Iso' (FreeT f m a) (Unwrapped (FreeT f m a)) #
Wrapped (CofreeT f w a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (CofreeT f w a) :: Type # Methods _Wrapped' :: Iso' (CofreeT f w a) (Unwrapped (CofreeT f w a)) #
Wrapped (ApT f g a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (ApT f g a) :: Type # Methods _Wrapped' :: Iso' (ApT f g a) (Unwrapped (ApT f g a)) #
Wrapped (ErrorT e m a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (ErrorT e m a) :: Type # Methods _Wrapped' :: Iso' (ErrorT e m a) (Unwrapped (ErrorT e m a)) #
Wrapped (Backwards f a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (Backwards f a) :: Type # Methods _Wrapped' :: Iso' (Backwards f a) (Unwrapped (Backwards f a)) #
Wrapped (Star f d c)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (Star f d c) :: Type # Methods _Wrapped' :: Iso' (Star f d c) (Unwrapped (Star f d c)) #
Wrapped (Costar f d c)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (Costar f d c) :: Type # Methods _Wrapped' :: Iso' (Costar f d c) (Unwrapped (Costar f d c)) #
Wrapped (WrappedArrow p a b)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (WrappedArrow p a b) :: Type # Methods _Wrapped' :: Iso' (WrappedArrow p a b) (Unwrapped (WrappedArrow p a b)) #
Wrapped (Forget r a b)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (Forget r a b) :: Type # Methods _Wrapped' :: Iso' (Forget r a b) (Unwrapped (Forget r a b)) #
Wrapped (Static f a b)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (Static f a b) :: Type # Methods _Wrapped' :: Iso' (Static f a b) (Unwrapped (Static f a b)) #
Wrapped (Tagged s a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (Tagged s a) :: Type # Methods _Wrapped' :: Iso' (Tagged s a) (Unwrapped (Tagged s a)) #
Wrapped (Reverse f a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (Reverse f a) :: Type # Methods _Wrapped' :: Iso' (Reverse f a) (Unwrapped (Reverse f a)) #
Wrapped (Constant a b)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (Constant a b) :: Type # Methods _Wrapped' :: Iso' (Constant a b) (Unwrapped (Constant a b)) #
Wrapped (K1 i c p)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (K1 i c p) :: Type # Methods _Wrapped' :: Iso' (K1 i c p) (Unwrapped (K1 i c p)) #
Wrapped (ReaderT r m a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (ReaderT r m a) :: Type # Methods _Wrapped' :: Iso' (ReaderT r m a) (Unwrapped (ReaderT r m a)) #
Wrapped (ContT r m a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (ContT r m a) :: Type # Methods _Wrapped' :: Iso' (ContT r m a) (Unwrapped (ContT r m a)) #
Wrapped (Cayley f p a b)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (Cayley f p a b) :: Type # Methods _Wrapped' :: Iso' (Cayley f p a b) (Unwrapped (Cayley f p a b)) #
Wrapped (M1 i c f p)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (M1 i c f p) :: Type # Methods _Wrapped' :: Iso' (M1 i c f p) (Unwrapped (M1 i c f p)) #
Wrapped ((f :.: g) p)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped ((f :.: g) p) :: Type # Methods _Wrapped' :: Iso' ((f :.: g) p) (Unwrapped ((f :.: g) p)) #
Wrapped (Compose f g a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (Compose f g a) :: Type # Methods _Wrapped' :: Iso' (Compose f g a) (Unwrapped (Compose f g a)) #
Wrapped (WrappedBifunctor p a b)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (WrappedBifunctor p a b) :: Type # Methods _Wrapped' :: Iso' (WrappedBifunctor p a b) (Unwrapped (WrappedBifunctor p a b)) #
Wrapped (Joker g a b)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (Joker g a b) :: Type # Methods _Wrapped' :: Iso' (Joker g a b) (Unwrapped (Joker g a b)) #
Wrapped (Flip p a b)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (Flip p a b) :: Type # Methods _Wrapped' :: Iso' (Flip p a b) (Unwrapped (Flip p a b)) #
Wrapped (Clown f a b)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (Clown f a b) :: Type # Methods _Wrapped' :: Iso' (Clown f a b) (Unwrapped (Clown f a b)) #
Wrapped (RWST r w s m a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (RWST r w s m a) :: Type # Methods _Wrapped' :: Iso' (RWST r w s m a) (Unwrapped (RWST r w s m a)) #
Wrapped (RWST r w s m a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (RWST r w s m a) :: Type # Methods _Wrapped' :: Iso' (RWST r w s m a) (Unwrapped (RWST r w s m a)) #
Wrapped (Dual k3 a b)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (Dual k3 a b) :: Type # Methods _Wrapped' :: Iso' (Dual k3 a b) (Unwrapped (Dual k3 a b)) #
Wrapped (WrappedCategory k3 a b)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (WrappedCategory k3 a b) :: Type # Methods _Wrapped' :: Iso' (WrappedCategory k3 a b) (Unwrapped (WrappedCategory k3 a b)) #
Wrapped (Semi m a b)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (Semi m a b) :: Type # Methods _Wrapped' :: Iso' (Semi m a b) (Unwrapped (Semi m a b)) #
Wrapped (Tannen f p a b)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (Tannen f p a b) :: Type # Methods _Wrapped' :: Iso' (Tannen f p a b) (Unwrapped (Tannen f p a b)) #
Wrapped (Biff p f g a b)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (Biff p f g a b) :: Type # Methods _Wrapped' :: Iso' (Biff p f g a b) (Unwrapped (Biff p f g a b)) #

class Wrapped s => Rewrapped s t #

Instances

Rewrapped Fd t
Instance details Defined in Control.Lens.Wrapped
Rewrapped CTimer t
Instance details Defined in Control.Lens.Wrapped
Rewrapped CKey t
Instance details Defined in Control.Lens.Wrapped
Rewrapped CId t
Instance details Defined in Control.Lens.Wrapped
Rewrapped CFsFilCnt t
Instance details Defined in Control.Lens.Wrapped
Rewrapped CFsBlkCnt t
Instance details Defined in Control.Lens.Wrapped
Rewrapped CClockId t
Instance details Defined in Control.Lens.Wrapped
Rewrapped CBlkCnt t
Instance details Defined in Control.Lens.Wrapped
Rewrapped CBlkSize t
Instance details Defined in Control.Lens.Wrapped
Rewrapped CRLim t
Instance details Defined in Control.Lens.Wrapped
Rewrapped CTcflag t
Instance details Defined in Control.Lens.Wrapped
Rewrapped CSpeed t
Instance details Defined in Control.Lens.Wrapped
Rewrapped CCc t
Instance details Defined in Control.Lens.Wrapped
Rewrapped CUid t
Instance details Defined in Control.Lens.Wrapped
Rewrapped CNlink t
Instance details Defined in Control.Lens.Wrapped
Rewrapped CGid t
Instance details Defined in Control.Lens.Wrapped
Rewrapped CSsize t
Instance details Defined in Control.Lens.Wrapped
Rewrapped CPid t
Instance details Defined in Control.Lens.Wrapped
Rewrapped COff t
Instance details Defined in Control.Lens.Wrapped
Rewrapped CMode t
Instance details Defined in Control.Lens.Wrapped
Rewrapped CIno t
Instance details Defined in Control.Lens.Wrapped
Rewrapped CDev t
Instance details Defined in Control.Lens.Wrapped
t ~ PatternMatchFail => Rewrapped PatternMatchFail t
Instance details Defined in Control.Lens.Wrapped
t ~ RecSelError => Rewrapped RecSelError t
Instance details Defined in Control.Lens.Wrapped
t ~ RecConError => Rewrapped RecConError t
Instance details Defined in Control.Lens.Wrapped
t ~ RecUpdError => Rewrapped RecUpdError t
Instance details Defined in Control.Lens.Wrapped
t ~ NoMethodError => Rewrapped NoMethodError t
Instance details Defined in Control.Lens.Wrapped
t ~ TypeError => Rewrapped TypeError t
Instance details Defined in Control.Lens.Wrapped
Rewrapped Errno t
Instance details Defined in Control.Lens.Wrapped
t ~ CompactionFailed => Rewrapped CompactionFailed t
Instance details Defined in Control.Lens.Wrapped
t ~ AssertionFailed => Rewrapped AssertionFailed t
Instance details Defined in Control.Lens.Wrapped
t ~ ErrorCall => Rewrapped ErrorCall t
Instance details Defined in Control.Lens.Wrapped
t ~ All => Rewrapped All t
Instance details Defined in Control.Lens.Wrapped
t ~ Any => Rewrapped Any t
Instance details Defined in Control.Lens.Wrapped
Rewrapped CChar t
Instance details Defined in Control.Lens.Wrapped
Rewrapped CSChar t
Instance details Defined in Control.Lens.Wrapped
Rewrapped CUChar t
Instance details Defined in Control.Lens.Wrapped
Rewrapped CShort t
Instance details Defined in Control.Lens.Wrapped
Rewrapped CUShort t
Instance details Defined in Control.Lens.Wrapped
Rewrapped CInt t
Instance details Defined in Control.Lens.Wrapped
Rewrapped CUInt t
Instance details Defined in Control.Lens.Wrapped
Rewrapped CLong t
Instance details Defined in Control.Lens.Wrapped
Rewrapped CULong t
Instance details Defined in Control.Lens.Wrapped
Rewrapped CLLong t
Instance details Defined in Control.Lens.Wrapped
Rewrapped CULLong t
Instance details Defined in Control.Lens.Wrapped
Rewrapped CBool t
Instance details Defined in Control.Lens.Wrapped
Rewrapped CFloat t
Instance details Defined in Control.Lens.Wrapped
Rewrapped CDouble t
Instance details Defined in Control.Lens.Wrapped
Rewrapped CPtrdiff t
Instance details Defined in Control.Lens.Wrapped
Rewrapped CSize t
Instance details Defined in Control.Lens.Wrapped
Rewrapped CWchar t
Instance details Defined in Control.Lens.Wrapped
Rewrapped CSigAtomic t
Instance details Defined in Control.Lens.Wrapped
Rewrapped CClock t
Instance details Defined in Control.Lens.Wrapped
Rewrapped CTime t
Instance details Defined in Control.Lens.Wrapped
Rewrapped CUSeconds t
Instance details Defined in Control.Lens.Wrapped
Rewrapped CSUSeconds t
Instance details Defined in Control.Lens.Wrapped
Rewrapped CIntPtr t
Instance details Defined in Control.Lens.Wrapped
Rewrapped CUIntPtr t
Instance details Defined in Control.Lens.Wrapped
Rewrapped CIntMax t
Instance details Defined in Control.Lens.Wrapped
Rewrapped CUIntMax t
Instance details Defined in Control.Lens.Wrapped
t ~ IntSet => Rewrapped IntSet t	Use `wrapping fromList`. unwrapping returns a sorted list.
Instance details Defined in Control.Lens.Wrapped
t ~ Par1 p' => Rewrapped (Par1 p) t
Instance details Defined in Control.Lens.Wrapped
(t ~ Set a', Ord a) => Rewrapped (Set a) t	Use `wrapping fromList`. unwrapping returns a sorted list.
Instance details Defined in Control.Lens.Wrapped
t ~ Identity b => Rewrapped (Identity a) t
Instance details Defined in Control.Lens.Wrapped
t ~ ZipList b => Rewrapped (ZipList a) t
Instance details Defined in Control.Lens.Wrapped
(Storable a, t ~ Vector a') => Rewrapped (Vector a) t
Instance details Defined in Control.Lens.Wrapped
t ~ Predicate b => Rewrapped (Predicate a) t
Instance details Defined in Control.Lens.Wrapped
t ~ Comparison b => Rewrapped (Comparison a) t
Instance details Defined in Control.Lens.Wrapped
t ~ Equivalence b => Rewrapped (Equivalence a) t
Instance details Defined in Control.Lens.Wrapped
t ~ Min b => Rewrapped (Min a) t
Instance details Defined in Control.Lens.Wrapped
t ~ Max b => Rewrapped (Max a) t
Instance details Defined in Control.Lens.Wrapped
t ~ First b => Rewrapped (First a) t
Instance details Defined in Control.Lens.Wrapped
t ~ Last b => Rewrapped (Last a) t
Instance details Defined in Control.Lens.Wrapped
t ~ WrappedMonoid b => Rewrapped (WrappedMonoid a) t
Instance details Defined in Control.Lens.Wrapped
t ~ Option b => Rewrapped (Option a) t
Instance details Defined in Control.Lens.Wrapped
t ~ First b => Rewrapped (First a) t
Instance details Defined in Control.Lens.Wrapped
t ~ Last b => Rewrapped (Last a) t
Instance details Defined in Control.Lens.Wrapped
t ~ Dual b => Rewrapped (Dual a) t
Instance details Defined in Control.Lens.Wrapped
t ~ Endo b => Rewrapped (Endo a) t
Instance details Defined in Control.Lens.Wrapped
t ~ Sum b => Rewrapped (Sum a) t
Instance details Defined in Control.Lens.Wrapped
t ~ Product b => Rewrapped (Product a) t
Instance details Defined in Control.Lens.Wrapped
t ~ Down b => Rewrapped (Down a) t
Instance details Defined in Control.Lens.Wrapped
t ~ NonEmpty b => Rewrapped (NonEmpty a) t
Instance details Defined in Control.Lens.Wrapped
t ~ IntMap a' => Rewrapped (IntMap a) t	Use `wrapping fromList`. unwrapping returns a sorted list.
Instance details Defined in Control.Lens.Wrapped
t ~ Seq a' => Rewrapped (Seq a) t
Instance details Defined in Control.Lens.Wrapped
(Prim a, t ~ Vector a') => Rewrapped (Vector a) t
Instance details Defined in Control.Lens.Wrapped
(Unbox a, t ~ Vector a') => Rewrapped (Vector a) t
Instance details Defined in Control.Lens.Wrapped
(t ~ HashSet a', Hashable a, Eq a) => Rewrapped (HashSet a) t	Use `wrapping fromList`. Unwrapping returns some permutation of the list.
Instance details Defined in Control.Lens.Wrapped
t ~ Vector a' => Rewrapped (Vector a) t
Instance details Defined in Control.Lens.Wrapped
(t ~ Map k' a', Ord k) => Rewrapped (Map k a) t	Use `wrapping fromList`. unwrapping returns a sorted list.
Instance details Defined in Control.Lens.Wrapped
t ~ WrappedMonad m' a' => Rewrapped (WrappedMonad m a) t
Instance details Defined in Control.Lens.Wrapped
t ~ Op a' b' => Rewrapped (Op a b) t
Instance details Defined in Control.Lens.Wrapped
(t ~ HashMap k' a', Hashable k, Eq k) => Rewrapped (HashMap k a) t	Use `wrapping fromList`. Unwrapping returns some permutation of the list.
Instance details Defined in Control.Lens.Wrapped
t ~ ArrowMonad m' a' => Rewrapped (ArrowMonad m a) t
Instance details Defined in Control.Lens.Wrapped
t ~ MaybeT n b => Rewrapped (MaybeT m a) t
Instance details Defined in Control.Lens.Wrapped
t ~ CatchT m' a' => Rewrapped (CatchT m a) t
Instance details Defined in Control.Lens.Wrapped
t ~ CoiterT w' a' => Rewrapped (CoiterT w a) t
Instance details Defined in Control.Lens.Wrapped
t ~ IterT m' a' => Rewrapped (IterT m a) t
Instance details Defined in Control.Lens.Wrapped
t ~ Alt f' a' => Rewrapped (Alt f a) t
Instance details Defined in Control.Lens.Wrapped
t ~ ListT n b => Rewrapped (ListT m a) t
Instance details Defined in Control.Lens.Wrapped
t ~ WrappedApplicative f' a' => Rewrapped (WrappedApplicative f a) t
Instance details Defined in Control.Lens.Wrapped
t ~ MaybeApply f' a' => Rewrapped (MaybeApply f a) t
Instance details Defined in Control.Lens.Wrapped
t ~ Rec1 f' p' => Rewrapped (Rec1 f p) t
Instance details Defined in Control.Lens.Wrapped
t ~ IdentityT n b => Rewrapped (IdentityT m a) t
Instance details Defined in Control.Lens.Wrapped
t ~ Const a' x' => Rewrapped (Const a x) t
Instance details Defined in Control.Lens.Wrapped
t ~ WrappedArrow a' b' c' => Rewrapped (WrappedArrow a b c) t
Instance details Defined in Control.Lens.Wrapped
t ~ Kleisli m' a' b' => Rewrapped (Kleisli m a b) t
Instance details Defined in Control.Lens.Wrapped
t ~ Ap g b => Rewrapped (Ap f a) t
Instance details Defined in Control.Lens.Wrapped
t ~ Alt g b => Rewrapped (Alt f a) t
Instance details Defined in Control.Lens.Wrapped
t ~ Join p' a' => Rewrapped (Join p a) t
Instance details Defined in Control.Lens.Wrapped
t ~ Fix p' a' => Rewrapped (Fix p a) t
Instance details Defined in Control.Lens.Wrapped
t ~ TracedT m' w' a' => Rewrapped (TracedT m w a) t
Instance details Defined in Control.Lens.Wrapped
t ~ WriterT w' m' a' => Rewrapped (WriterT w m a) t
Instance details Defined in Control.Lens.Wrapped
t ~ WriterT w' m' a' => Rewrapped (WriterT w m a) t
Instance details Defined in Control.Lens.Wrapped
t ~ StateT s' m' a' => Rewrapped (StateT s m a) t
Instance details Defined in Control.Lens.Wrapped
t ~ StateT s' m' a' => Rewrapped (StateT s m a) t
Instance details Defined in Control.Lens.Wrapped
t ~ ExceptT e' m' a' => Rewrapped (ExceptT e m a) t
Instance details Defined in Control.Lens.Wrapped
t ~ Compose f' g' a' => Rewrapped (Compose f g a) t
Instance details Defined in Control.Lens.Wrapped
t ~ ComposeFC f' g' a' => Rewrapped (ComposeFC f g a) t
Instance details Defined in Control.Lens.Wrapped
t ~ ComposeCF f' g' a' => Rewrapped (ComposeCF f g a) t
Instance details Defined in Control.Lens.Wrapped
t ~ FreeT f' m' a' => Rewrapped (FreeT f m a) t
Instance details Defined in Control.Lens.Wrapped
t ~ CofreeT f' w' a' => Rewrapped (CofreeT f w a) t
Instance details Defined in Control.Lens.Wrapped
t ~ ApT f' g' a' => Rewrapped (ApT f g a) t
Instance details Defined in Control.Lens.Wrapped
t ~ ErrorT e' m' a' => Rewrapped (ErrorT e m a) t
Instance details Defined in Control.Lens.Wrapped
t ~ Backwards g b => Rewrapped (Backwards f a) t
Instance details Defined in Control.Lens.Wrapped
t ~ Star f' d' c' => Rewrapped (Star f d c) t
Instance details Defined in Control.Lens.Wrapped
t ~ Costar f' d' c' => Rewrapped (Costar f d c) t
Instance details Defined in Control.Lens.Wrapped
t ~ WrappedArrow p' a' b' => Rewrapped (WrappedArrow p a b) t
Instance details Defined in Control.Lens.Wrapped
t ~ Forget r' a' b' => Rewrapped (Forget r a b) t
Instance details Defined in Control.Lens.Wrapped
t ~ Static f' a' b' => Rewrapped (Static f a b) t
Instance details Defined in Control.Lens.Wrapped
t ~ Tagged s' a' => Rewrapped (Tagged s a) t
Instance details Defined in Control.Lens.Wrapped
t ~ Reverse g b => Rewrapped (Reverse f a) t
Instance details Defined in Control.Lens.Wrapped
t ~ Constant a' b' => Rewrapped (Constant a b) t
Instance details Defined in Control.Lens.Wrapped
t ~ K1 i' c' p' => Rewrapped (K1 i c p) t
Instance details Defined in Control.Lens.Wrapped
t ~ ReaderT s n b => Rewrapped (ReaderT r m a) t
Instance details Defined in Control.Lens.Wrapped
t ~ ContT r' m' a' => Rewrapped (ContT r m a) t
Instance details Defined in Control.Lens.Wrapped
t ~ Cayley f' p' a' b' => Rewrapped (Cayley f p a b) t
Instance details Defined in Control.Lens.Wrapped
t ~ M1 i' c' f' p' => Rewrapped (M1 i c f p) t
Instance details Defined in Control.Lens.Wrapped
t ~ (f' :.: g') p' => Rewrapped ((f :.: g) p) t
Instance details Defined in Control.Lens.Wrapped
t ~ Compose f' g' a' => Rewrapped (Compose f g a) t
Instance details Defined in Control.Lens.Wrapped
t ~ WrappedBifunctor p' a' b' => Rewrapped (WrappedBifunctor p a b) t
Instance details Defined in Control.Lens.Wrapped
t ~ Joker g' a' b' => Rewrapped (Joker g a b) t
Instance details Defined in Control.Lens.Wrapped
t ~ Flip p' a' b' => Rewrapped (Flip p a b) t
Instance details Defined in Control.Lens.Wrapped
t ~ Clown f' a' b' => Rewrapped (Clown f a b) t
Instance details Defined in Control.Lens.Wrapped
t ~ RWST r' w' s' m' a' => Rewrapped (RWST r w s m a) t
Instance details Defined in Control.Lens.Wrapped
t ~ RWST r' w' s' m' a' => Rewrapped (RWST r w s m a) t
Instance details Defined in Control.Lens.Wrapped
t ~ Dual k' a' b' => Rewrapped (Dual k6 a b) t
Instance details Defined in Control.Lens.Wrapped
t ~ WrappedCategory k' a' b' => Rewrapped (WrappedCategory k6 a b) t
Instance details Defined in Control.Lens.Wrapped
t ~ Semi m' a' b' => Rewrapped (Semi m a b) t
Instance details Defined in Control.Lens.Wrapped
t ~ Tannen f' p' a' b' => Rewrapped (Tannen f p a b) t
Instance details Defined in Control.Lens.Wrapped
t ~ Biff p' f' g' a' b' => Rewrapped (Biff p f g a b) t
Instance details Defined in Control.Lens.Wrapped

class (Rewrapped s t, Rewrapped t s) => Rewrapping s t #

Instances

(Rewrapped s t, Rewrapped t s) => Rewrapping s t
Instance details Defined in Control.Lens.Wrapped

unsnoc :: Snoc s s a a => s -> Maybe (s, a) #

Attempt to extract the right-most element from a container, and a version of the container without that element.

>>> unsnoc (LazyT.pack "hello!")
Just ("hello",'!')

>>> unsnoc (LazyT.pack "")
Nothing

>>> unsnoc (Seq.fromList [b,c,a])
Just (fromList [b,c],a)

>>> unsnoc (Seq.fromList [])
Nothing

snoc :: Snoc s s a a => s -> a -> s infixl 5 #

snoc an element onto the end of a container.

>>> snoc (Seq.fromList []) a
fromList [a]

>>> snoc (Seq.fromList [b, c]) a
fromList [b,c,a]

>>> snoc (LazyT.pack "hello") '!'
"hello!"

(|>) :: Snoc s s a a => s -> a -> s infixl 5 #

snoc an element onto the end of a container.

This is an infix alias for snoc.

>>> Seq.fromList [] |> a
fromList [a]

>>> Seq.fromList [b, c] |> a
fromList [b,c,a]

>>> LazyT.pack "hello" |> '!'
"hello!"

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

A Traversal reading and writing to the last element of a non-empty container.

>>> [a,b,c]^?!_last
c

>>> []^?_last
Nothing

>>> [a,b,c] & _last %~ f
[a,b,f c]

>>> [1,2]^?_last
Just 2

>>> [] & _last .~ 1
[]

>>> [0] & _last .~ 2
[2]

>>> [0,1] & _last .~ 2
[0,2]

This Traversal is not limited to lists, however. We can also work with other containers, such as a Vector.

>>> Vector.fromList "abcde" ^? _last
Just 'e'

>>> Vector.empty ^? _last
Nothing

>>> (Vector.fromList "abcde" & _last .~ 'Q') == Vector.fromList "abcdQ"
True

_last :: Traversal' [a] a
_last :: Traversal' (Seq a) a
_last :: Traversal' (Vector a) a

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

A Traversal reading and replacing all but the a last element of a non-empty container.

>>> [a,b,c,d]^?_init
Just [a,b,c]

>>> []^?_init
Nothing

>>> [a,b] & _init .~ [c,d,e]
[c,d,e,b]

>>> [] & _init .~ [a,b]
[]

>>> [a,b,c,d] & _init.traverse %~ f
[f a,f b,f c,d]

>>> [1,2,3]^?_init
Just [1,2]

>>> [1,2,3,4]^?!_init
[1,2,3]

>>> "hello"^._init
"hell"

>>> ""^._init
""

_init :: Traversal' [a] [a]
_init :: Traversal' (Seq a) (Seq a)
_init :: Traversal' (Vector a) (Vector a)

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

A Traversal reading and writing to the tail of a non-empty container.

>>> [a,b] & _tail .~ [c,d,e]
[a,c,d,e]

>>> [] & _tail .~ [a,b]
[]

>>> [a,b,c,d,e] & _tail.traverse %~ f
[a,f b,f c,f d,f e]

>>> [1,2] & _tail .~ [3,4,5]
[1,3,4,5]

>>> [] & _tail .~ [1,2]
[]

>>> [a,b,c]^?_tail
Just [b,c]

>>> [1,2]^?!_tail
[2]

>>> "hello"^._tail
"ello"

>>> ""^._tail
""

This isn't limited to lists. For instance you can also traverse the tail of a Seq.

>>> Seq.fromList [a,b] & _tail .~ Seq.fromList [c,d,e]
fromList [a,c,d,e]

>>> Seq.fromList [a,b,c] ^? _tail
Just (fromList [b,c])

>>> Seq.fromList [] ^? _tail
Nothing

_tail :: Traversal' [a] [a]
_tail :: Traversal' (Seq a) (Seq a)
_tail :: Traversal' (Vector a) (Vector a)

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

A Traversal reading and writing to the head of a non-empty container.

>>> [a,b,c]^? _head
Just a

>>> [a,b,c] & _head .~ d
[d,b,c]

>>> [a,b,c] & _head %~ f
[f a,b,c]

>>> [] & _head %~ f
[]

>>> [1,2,3]^?!_head
1

>>> []^?_head
Nothing

>>> [1,2]^?_head
Just 1

>>> [] & _head .~ 1
[]

>>> [0] & _head .~ 2
[2]

>>> [0,1] & _head .~ 2
[2,1]

This isn't limited to lists.

For instance you can also traverse the head of a Seq:

>>> Seq.fromList [a,b,c,d] & _head %~ f
fromList [f a,b,c,d]

>>> Seq.fromList [] ^? _head
Nothing

>>> Seq.fromList [a,b,c,d] ^? _head
Just a

_head :: Traversal' [a] a
_head :: Traversal' (Seq a) a
_head :: Traversal' (Vector a) a

uncons :: Cons s s a a => s -> Maybe (a, s) #

Attempt to extract the left-most element from a container, and a version of the container without that element.

>>> uncons []
Nothing

>>> uncons [a, b, c]
Just (a,[b,c])

cons :: Cons s s a a => a -> s -> s infixr 5 #

cons an element onto a container.

>>> cons a []
[a]

>>> cons a [b, c]
[a,b,c]

>>> cons a (Seq.fromList [])
fromList [a]

>>> cons a (Seq.fromList [b, c])
fromList [a,b,c]

(<|) :: Cons s s a a => a -> s -> s infixr 5 #

cons an element onto a container.

This is an infix alias for cons.

>>> a <| []
[a]

>>> a <| [b, c]
[a,b,c]

>>> a <| Seq.fromList []
fromList [a]

>>> a <| Seq.fromList [b, c]
fromList [a,b,c]

pattern (:<) :: forall b a. Cons b b a a => a -> b -> b infixr 5 #

pattern (:>) :: forall a b. Snoc a a b b => a -> b -> a infixl 5 #

class Cons s t a b | s -> a, t -> b, s b -> t, t a -> s where #

This class provides a way to attach or detach elements on the left side of a structure in a flexible manner.

Methods

_Cons :: Prism s t (a, s) (b, t) #

_Cons :: Prism [a] [b] (a, [a]) (b, [b])
_Cons :: Prism (Seq a) (Seq b) (a, Seq a) (b, Seq b)
_Cons :: Prism (Vector a) (Vector b) (a, Vector a) (b, Vector b)
_Cons :: Prism' String (Char, String)
_Cons :: Prism' Text (Char, Text)
_Cons :: Prism' ByteString (Word8, ByteString)

Instances

Cons ByteString ByteString Word8 Word8
Instance details Defined in Control.Lens.Cons Methods _Cons :: Prism ByteString ByteString (Word8, ByteString) (Word8, ByteString) #
Cons ByteString ByteString Word8 Word8
Instance details Defined in Control.Lens.Cons Methods _Cons :: Prism ByteString ByteString (Word8, ByteString) (Word8, ByteString) #
Cons Text Text Char Char
Instance details Defined in Control.Lens.Cons Methods _Cons :: Prism Text Text (Char, Text) (Char, Text) #
Cons Text Text Char Char
Instance details Defined in Control.Lens.Cons Methods _Cons :: Prism Text Text (Char, Text) (Char, Text) #
Cons [a] [b] a b
Instance details Defined in Control.Lens.Cons Methods _Cons :: Prism [a] [b] (a, [a]) (b, [b]) #
Cons (ZipList a) (ZipList b) a b
Instance details Defined in Control.Lens.Cons Methods _Cons :: Prism (ZipList a) (ZipList b) (a, ZipList a) (b, ZipList b) #
(Storable a, Storable b) => Cons (Vector a) (Vector b) a b
Instance details Defined in Control.Lens.Cons Methods _Cons :: Prism (Vector a) (Vector b) (a, Vector a) (b, Vector b) #
Cons (Seq a) (Seq b) a b
Instance details Defined in Control.Lens.Cons Methods _Cons :: Prism (Seq a) (Seq b) (a, Seq a) (b, Seq b) #
(Prim a, Prim b) => Cons (Vector a) (Vector b) a b
Instance details Defined in Control.Lens.Cons Methods _Cons :: Prism (Vector a) (Vector b) (a, Vector a) (b, Vector b) #
(Unbox a, Unbox b) => Cons (Vector a) (Vector b) a b
Instance details Defined in Control.Lens.Cons Methods _Cons :: Prism (Vector a) (Vector b) (a, Vector a) (b, Vector b) #
Cons (Vector a) (Vector b) a b
Instance details Defined in Control.Lens.Cons Methods _Cons :: Prism (Vector a) (Vector b) (a, Vector a) (b, Vector b) #

class Snoc s t a b | s -> a, t -> b, s b -> t, t a -> s where #

This class provides a way to attach or detach elements on the right side of a structure in a flexible manner.

Methods

_Snoc :: Prism s t (s, a) (t, b) #

_Snoc :: Prism [a] [b] ([a], a) ([b], b)
_Snoc :: Prism (Seq a) (Seq b) (Seq a, a) (Seq b, b)
_Snoc :: Prism (Vector a) (Vector b) (Vector a, a) (Vector b, b)
_Snoc :: Prism' String (String, Char)
_Snoc :: Prism' Text (Text, Char)
_Snoc :: Prism' ByteString (ByteString, Word8)

Instances

Snoc ByteString ByteString Word8 Word8
Instance details Defined in Control.Lens.Cons Methods _Snoc :: Prism ByteString ByteString (ByteString, Word8) (ByteString, Word8) #
Snoc ByteString ByteString Word8 Word8
Instance details Defined in Control.Lens.Cons Methods _Snoc :: Prism ByteString ByteString (ByteString, Word8) (ByteString, Word8) #
Snoc Text Text Char Char
Instance details Defined in Control.Lens.Cons Methods _Snoc :: Prism Text Text (Text, Char) (Text, Char) #
Snoc Text Text Char Char
Instance details Defined in Control.Lens.Cons Methods _Snoc :: Prism Text Text (Text, Char) (Text, Char) #
Snoc [a] [b] a b
Instance details Defined in Control.Lens.Cons Methods _Snoc :: Prism [a] [b] ([a], a) ([b], b) #
Snoc (ZipList a) (ZipList b) a b
Instance details Defined in Control.Lens.Cons Methods _Snoc :: Prism (ZipList a) (ZipList b) (ZipList a, a) (ZipList b, b) #
(Storable a, Storable b) => Snoc (Vector a) (Vector b) a b
Instance details Defined in Control.Lens.Cons Methods _Snoc :: Prism (Vector a) (Vector b) (Vector a, a) (Vector b, b) #
Snoc (Seq a) (Seq b) a b
Instance details Defined in Control.Lens.Cons Methods _Snoc :: Prism (Seq a) (Seq b) (Seq a, a) (Seq b, b) #
(Prim a, Prim b) => Snoc (Vector a) (Vector b) a b
Instance details Defined in Control.Lens.Cons Methods _Snoc :: Prism (Vector a) (Vector b) (Vector a, a) (Vector b, b) #
(Unbox a, Unbox b) => Snoc (Vector a) (Vector b) a b
Instance details Defined in Control.Lens.Cons Methods _Snoc :: Prism (Vector a) (Vector b) (Vector a, a) (Vector b, b) #
Snoc (Vector a) (Vector b) a b
Instance details Defined in Control.Lens.Cons Methods _Snoc :: Prism (Vector a) (Vector b) (Vector a, a) (Vector b, b) #

pattern Empty :: forall s. AsEmpty s => s #

class AsEmpty a where #

Minimal complete definition

Nothing

Methods

_Empty :: Prism' a () #

>>> isn't _Empty [1,2,3]
True

Instances

AsEmpty Ordering
Instance details Defined in Control.Lens.Empty Methods _Empty :: Prism' Ordering () #
AsEmpty ()
Instance details Defined in Control.Lens.Empty Methods _Empty :: Prism' () () #
AsEmpty ByteString
Instance details Defined in Control.Lens.Empty Methods _Empty :: Prism' ByteString () #
AsEmpty ByteString
Instance details Defined in Control.Lens.Empty Methods _Empty :: Prism' ByteString () #
AsEmpty Text
Instance details Defined in Control.Lens.Empty Methods _Empty :: Prism' Text () #
AsEmpty Text
Instance details Defined in Control.Lens.Empty Methods _Empty :: Prism' Text () #
AsEmpty Event
Instance details Defined in Control.Lens.Empty Methods _Empty :: Prism' Event () #
AsEmpty All
Instance details Defined in Control.Lens.Empty Methods _Empty :: Prism' All () #
AsEmpty Any
Instance details Defined in Control.Lens.Empty Methods _Empty :: Prism' Any () #
AsEmpty IntSet
Instance details Defined in Control.Lens.Empty Methods _Empty :: Prism' IntSet () #
AsEmpty [a]
Instance details Defined in Control.Lens.Empty Methods _Empty :: Prism' [a] () #
AsEmpty (Maybe a)
Instance details Defined in Control.Lens.Empty Methods _Empty :: Prism' (Maybe a) () #
AsEmpty (Set a)
Instance details Defined in Control.Lens.Empty Methods _Empty :: Prism' (Set a) () #
AsEmpty (ZipList a)
Instance details Defined in Control.Lens.Empty Methods _Empty :: Prism' (ZipList a) () #
Storable a => AsEmpty (Vector a)
Instance details Defined in Control.Lens.Empty Methods _Empty :: Prism' (Vector a) () #
AsEmpty (First a)
Instance details Defined in Control.Lens.Empty Methods _Empty :: Prism' (First a) () #
AsEmpty (Last a)
Instance details Defined in Control.Lens.Empty Methods _Empty :: Prism' (Last a) () #
AsEmpty a => AsEmpty (Dual a)
Instance details Defined in Control.Lens.Empty Methods _Empty :: Prism' (Dual a) () #
(Eq a, Num a) => AsEmpty (Sum a)
Instance details Defined in Control.Lens.Empty Methods _Empty :: Prism' (Sum a) () #
(Eq a, Num a) => AsEmpty (Product a)
Instance details Defined in Control.Lens.Empty Methods _Empty :: Prism' (Product a) () #
AsEmpty (IntMap a)
Instance details Defined in Control.Lens.Empty Methods _Empty :: Prism' (IntMap a) () #
AsEmpty (Seq a)
Instance details Defined in Control.Lens.Empty Methods _Empty :: Prism' (Seq a) () #
Unbox a => AsEmpty (Vector a)
Instance details Defined in Control.Lens.Empty Methods _Empty :: Prism' (Vector a) () #
AsEmpty (HashSet a)
Instance details Defined in Control.Lens.Empty Methods _Empty :: Prism' (HashSet a) () #
AsEmpty (Vector a)
Instance details Defined in Control.Lens.Empty Methods _Empty :: Prism' (Vector a) () #
(AsEmpty a, AsEmpty b) => AsEmpty (a, b)
Instance details Defined in Control.Lens.Empty Methods _Empty :: Prism' (a, b) () #
AsEmpty (Map k a)
Instance details Defined in Control.Lens.Empty Methods _Empty :: Prism' (Map k a) () #
AsEmpty (HashMap k a)
Instance details Defined in Control.Lens.Empty Methods _Empty :: Prism' (HashMap k a) () #
(AsEmpty a, AsEmpty b, AsEmpty c) => AsEmpty (a, b, c)
Instance details Defined in Control.Lens.Empty Methods _Empty :: Prism' (a, b, c) () #

coerced :: (Coercible s a, Coercible t b) => Iso s t a b #

Data types that are representationally equal are isomorphic.

This is only available on GHC 7.8+

Since: lens-4.13

seconding :: (Bifunctor f, Bifunctor g) => AnIso s t a b -> Iso (f x s) (g y t) (f x a) (g y b) #

Lift an Iso into the second argument of a Bifunctor. This is essentially the same as mapping, but it takes a 'Bifunctor p' constraint instead of a 'Functor (p a)' one.

seconding :: Bifunctor p => Iso s t a b -> Iso (p x s) (p y t) (p x a) (p y b)
seconding :: Bifunctor p => Iso' s a -> Iso' (p x s) (p x a)

firsting :: (Bifunctor f, Bifunctor g) => AnIso s t a b -> Iso (f s x) (g t y) (f a x) (g b y) #

Lift an Iso into the first argument of a Bifunctor.

firsting :: Bifunctor p => Iso s t a b -> Iso (p s x) (p t y) (p a x) (p b y)
firsting :: Bifunctor p => Iso' s a -> Iso' (p s x) (p a x)

bimapping :: (Bifunctor f, Bifunctor g) => AnIso s t a b -> AnIso s' t' a' b' -> Iso (f s s') (g t t') (f a a') (g b b') #

Lift two Isos into both arguments of a Bifunctor.

bimapping :: Bifunctor p => Iso s t a b -> Iso s' t' a' b' -> Iso (p s s') (p t t') (p a a') (p b b')
bimapping :: Bifunctor p => Iso' s a -> Iso' s' a' -> Iso' (p s s') (p a a')

rmapping :: (Profunctor p, Profunctor q) => AnIso s t a b -> Iso (p x s) (q y t) (p x a) (q y b) #

Lift an Iso covariantly into the right argument of a Profunctor.

rmapping :: Profunctor p => Iso s t a b -> Iso (p x s) (p y t) (p x a) (p y b)
rmapping :: Profunctor p => Iso' s a -> Iso' (p x s) (p x a)

lmapping :: (Profunctor p, Profunctor q) => AnIso s t a b -> Iso (p a x) (q b y) (p s x) (q t y) #

Lift an Iso contravariantly into the left argument of a Profunctor.

lmapping :: Profunctor p => Iso s t a b -> Iso (p a x) (p b y) (p s x) (p t y)
lmapping :: Profunctor p => Iso' s a -> Iso' (p a x) (p s x)

dimapping :: (Profunctor p, Profunctor q) => AnIso s t a b -> AnIso s' t' a' b' -> Iso (p a s') (q b t') (p s a') (q t b') #

Lift two Isos into both arguments of a Profunctor simultaneously.

dimapping :: Profunctor p => Iso s t a b -> Iso s' t' a' b' -> Iso (p a s') (p b t') (p s a') (p t b')
dimapping :: Profunctor p => Iso' s a -> Iso' s' a' -> Iso' (p a s') (p s a')

contramapping :: Contravariant f => AnIso s t a b -> Iso (f a) (f b) (f s) (f t) #

Lift an Iso into a Contravariant functor.

contramapping :: Contravariant f => Iso s t a b -> Iso (f a) (f b) (f s) (f t)
contramapping :: Contravariant f => Iso' s a -> Iso' (f a) (f s)

imagma :: Over (Indexed i) (Molten i a b) s t a b -> Iso s t' (Magma i t b a) (Magma j t' c c) #

This isomorphism can be used to inspect an IndexedTraversal to see how it associates the structure and it can also be used to bake the IndexedTraversal into a Magma so that you can traverse over it multiple times with access to the original indices.

magma :: LensLike (Mafic a b) s t a b -> Iso s u (Magma Int t b a) (Magma j u c c) #

This isomorphism can be used to inspect a Traversal to see how it associates the structure and it can also be used to bake the Traversal into a Magma so that you can traverse over it multiple times.

involuted :: (a -> a) -> Iso' a a #

Given a function that is its own inverse, this gives you an Iso using it in both directions.

involuted ≡ join iso

>>> "live" ^. involuted reverse
"evil"

>>> "live" & involuted reverse %~ ('d':)
"lived"

reversed :: Reversing a => Iso' a a #

An Iso between a list, ByteString, Text fragment, etc. and its reversal.

>>> "live" ^. reversed
"evil"

>>> "live" & reversed %~ ('d':)
"lived"

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

An Iso between the strict variant of a structure and its lazy counterpart.

lazy = from strict

See http://hackage.haskell.org/package/strict-base-types for an example use.

flipped :: Iso (a -> b -> c) (a' -> b' -> c') (b -> a -> c) (b' -> a' -> c') #

The isomorphism for flipping a function.

>>> ((,)^.flipped) 1 2
(2,1)

uncurried :: Iso (a -> b -> c) (d -> e -> f) ((a, b) -> c) ((d, e) -> f) #

The canonical isomorphism for uncurrying and currying a function.

uncurried = iso uncurry curry

uncurried = from curried

>>> ((+)^.uncurried) (1,2)
3

curried :: Iso ((a, b) -> c) ((d, e) -> f) (a -> b -> c) (d -> e -> f) #

The canonical isomorphism for currying and uncurrying a function.

curried = iso curry uncurry

>>> (fst^.curried) 3 4
3

>>> view curried fst 3 4
3

anon :: a -> (a -> Bool) -> Iso' (Maybe a) a #

anon a p generalizes non a to take any value and a predicate.

This function assumes that p a holds True and generates an isomorphism between Maybe (a | not (p a)) and a.

>>> Map.empty & at "hello" . anon Map.empty Map.null . at "world" ?~ "!!!"
fromList [("hello",fromList [("world","!!!")])]

>>> fromList [("hello",fromList [("world","!!!")])] & at "hello" . anon Map.empty Map.null . at "world" .~ Nothing
fromList []

non' :: APrism' a () -> Iso' (Maybe a) a #

non' p generalizes non (p # ()) to take any unit Prism

This function generates an isomorphism between Maybe (a | isn't p a) and a.

>>> Map.singleton "hello" Map.empty & at "hello" . non' _Empty . at "world" ?~ "!!!"
fromList [("hello",fromList [("world","!!!")])]

>>> fromList [("hello",fromList [("world","!!!")])] & at "hello" . non' _Empty . at "world" .~ Nothing
fromList []

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

If v is an element of a type a, and a' is a sans the element v, then non v is an isomorphism from Maybe a' to a.

non ≡ non' . only

Keep in mind this is only a real isomorphism if you treat the domain as being Maybe (a sans v).

This is practically quite useful when you want to have a Map where all the entries should have non-zero values.

>>> Map.fromList [("hello",1)] & at "hello" . non 0 +~ 2
fromList [("hello",3)]

>>> Map.fromList [("hello",1)] & at "hello" . non 0 -~ 1
fromList []

>>> Map.fromList [("hello",1)] ^. at "hello" . non 0
1

>>> Map.fromList [] ^. at "hello" . non 0
0

This combinator is also particularly useful when working with nested maps.

e.g. When you want to create the nested Map when it is missing:

>>> Map.empty & at "hello" . non Map.empty . at "world" ?~ "!!!"
fromList [("hello",fromList [("world","!!!")])]

and when have deleting the last entry from the nested Map mean that we should delete its entry from the surrounding one:

>>> fromList [("hello",fromList [("world","!!!")])] & at "hello" . non Map.empty . at "world" .~ Nothing
fromList []

It can also be used in reverse to exclude a given value:

>>> non 0 # rem 10 4
Just 2

>>> non 0 # rem 10 5
Nothing

mapping :: (Functor f, Functor g) => AnIso s t a b -> Iso (f s) (g t) (f a) (g b) #

This can be used to lift any Iso into an arbitrary Functor.

enum :: Enum a => Iso' Int a #

This isomorphism can be used to convert to or from an instance of Enum.

>>> LT^.from enum
0

>>> 97^.enum :: Char
'a'

Note: this is only an isomorphism from the numeric range actually used and it is a bit of a pleasant fiction, since there are questionable Enum instances for Double, and Float that exist solely for [1.0 .. 4.0] sugar and the instances for those and Integer don't cover all values in their range.

under :: AnIso s t a b -> (t -> s) -> b -> a #

The opposite of working over a Setter is working under an isomorphism.

under ≡ over . from

under :: Iso s t a b -> (t -> s) -> b -> a

xplatf :: Optic (Costar f) g s t a b -> (f a -> g b) -> f s -> g t #

xplatf = auf . from but with a nicer signature.

>>> xplatf (_Unwrapping Sum) (foldMapOf both) Prelude.length ("hello","world")
10

xplatf :: Iso s t a b -> ((r -> a) -> e -> b) -> (r -> s) -> e -> t

xplat :: Optic (Costar ((->) s :: Type -> Type)) g s t a b -> ((s -> a) -> g b) -> g t #

xplat = au . from but with a nicer signature.

auf :: (Functor f, Functor g) => AnIso s t a b -> (f t -> g s) -> f b -> g a #

Based on ala' from Conor McBride's work on Epigram.

This version is generalized to accept any Iso, not just a newtype.

For a version you pass the name of the newtype constructor to, see alaf.

>>> auf (_Wrapping Sum) (foldMapOf both) Prelude.length ("hello","world")
10

Mnemonically, the German auf plays a similar role to à la, and the combinator is au with an extra function argument:

auf :: Iso s t a b -> ((r -> t) -> e -> s) -> (r -> b) -> e -> a

but the signature is general.

Note: The direction of the Iso required for this function changed in lens 4.18 to match up with the behavior of au. For the old behavior use xplatf or for a version that is compatible across both old and new versions of lens you can just use coerce!

au :: Functor f => AnIso s t a b -> ((b -> t) -> f s) -> f a #

Based on ala from Conor McBride's work on Epigram.

This version is generalized to accept any Iso, not just a newtype.

>>> au (_Wrapping Sum) foldMap [1,2,3,4]
10

You may want to think of this combinator as having the following, simpler type:

au :: AnIso s t a b -> ((b -> t) -> e -> s) -> e -> a

au = xplat . from

cloneIso :: AnIso s t a b -> Iso s t a b #

Convert from AnIso back to any Iso.

This is useful when you need to store an isomorphism as a data type inside a container and later reconstitute it as an overloaded function.

See cloneLens or cloneTraversal for more information on why you might want to do this.

withIso :: AnIso s t a b -> ((s -> a) -> (b -> t) -> r) -> r #

Extract the two functions, one from s -> a and one from b -> t that characterize an Iso.

from :: AnIso s t a b -> Iso b a t s #

Invert an isomorphism.

from (from l) ≡ l

iso :: (s -> a) -> (b -> t) -> Iso s t a b #

Build a simple isomorphism from a pair of inverse functions.

view (iso f g) ≡ f
view (from (iso f g)) ≡ g
over (iso f g) h ≡ g . h . f
over (from (iso f g)) h ≡ f . h . g

pattern Strict :: forall s t. Strict s t => t -> s #

pattern Lazy :: forall t s. Strict t s => t -> s #

pattern Swapped :: forall (p :: Type -> Type -> Type) c d. Swapped p => p d c -> p c d #

pattern Reversed :: forall t. Reversing t => t -> t #

pattern List :: forall l. IsList l => [Item l] -> l #

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

When you see this as an argument to a function, it expects an Iso.

type AnIso' s a = AnIso s s a a #

A Simple AnIso.

class Bifunctor p => Swapped (p :: Type -> Type -> Type) where #

This class provides for symmetric bifunctors.

Methods

swapped :: Iso (p a b) (p c d) (p b a) (p d c) #

swapped . swapped ≡ id
first f . swapped = swapped . second f
second g . swapped = swapped . first g
bimap f g . swapped = swapped . bimap g f

>>> (1,2)^.swapped
(2,1)

Instances

Swapped Either
Instance details Defined in Control.Lens.Iso Methods swapped :: Iso (Either a b) (Either c d) (Either b a) (Either d c) #
Swapped (,)
Instance details Defined in Control.Lens.Iso Methods swapped :: Iso (a, b) (c, d) (b, a) (d, c) #
Swapped ((,,) x)
Instance details Defined in Control.Lens.Iso Methods swapped :: Iso (x, a, b) (x, c, d) (x, b, a) (x, d, c) #
Swapped ((,,,) x y)
Instance details Defined in Control.Lens.Iso Methods swapped :: Iso (x, y, a, b) (x, y, c, d) (x, y, b, a) (x, y, d, c) #
Swapped ((,,,,) x y z)
Instance details Defined in Control.Lens.Iso Methods swapped :: Iso (x, y, z, a, b) (x, y, z, c, d) (x, y, z, b, a) (x, y, z, d, c) #
Swapped p => Swapped (Flip p)
Instance details Defined in Control.Lens.Iso Methods swapped :: Iso (Flip p a b) (Flip p c d) (Flip p b a) (Flip p d c) #
Swapped ((,,,,,) x y z w)
Instance details Defined in Control.Lens.Iso Methods swapped :: Iso (x, y, z, w, a, b) (x, y, z, w, c, d) (x, y, z, w, b, a) (x, y, z, w, d, c) #
(Swapped p, Swapped q) => Swapped (Sum p q)
Instance details Defined in Control.Lens.Iso Methods swapped :: Iso (Sum p q a b) (Sum p q c d) (Sum p q b a) (Sum p q d c) #
(Swapped f, Swapped g) => Swapped (Product f g)
Instance details Defined in Control.Lens.Iso Methods swapped :: Iso (Product f g a b) (Product f g c d) (Product f g b a) (Product f g d c) #
Swapped ((,,,,,,) x y z w v)
Instance details Defined in Control.Lens.Iso Methods swapped :: Iso (x, y, z, w, v, a, b) (x, y, z, w, v, c, d) (x, y, z, w, v, b, a) (x, y, z, w, v, d, c) #
(Functor f, Swapped p) => Swapped (Tannen f p)
Instance details Defined in Control.Lens.Iso Methods swapped :: Iso (Tannen f p a b) (Tannen f p c d) (Tannen f p b a) (Tannen f p d c) #
(f ~ g, Functor f, Swapped p) => Swapped (Biff p f g)
Instance details Defined in Control.Lens.Iso Methods swapped :: Iso (Biff p f g a b) (Biff p f g c d) (Biff p f g b a) (Biff p f g d c) #

class Strict lazy strict | lazy -> strict, strict -> lazy where #

Ad hoc conversion between "strict" and "lazy" versions of a structure, such as Text or ByteString.

Methods

strict :: Iso' lazy strict #

Instances

Strict ByteString ByteString
Instance details Defined in Control.Lens.Iso Methods strict :: Iso' ByteString ByteString0 #
Strict Text Text
Instance details Defined in Control.Lens.Iso Methods strict :: Iso' Text Text0 #
Strict (ST s a) (ST s a)
Instance details Defined in Control.Lens.Iso Methods strict :: Iso' (ST s a) (ST0 s a) #
Strict (WriterT w m a) (WriterT w m a)
Instance details Defined in Control.Lens.Iso Methods strict :: Iso' (WriterT w m a) (WriterT0 w m a) #
Strict (StateT s m a) (StateT s m a)
Instance details Defined in Control.Lens.Iso Methods strict :: Iso' (StateT s m a) (StateT0 s m a) #
Strict (RWST r w s m a) (RWST r w s m a)
Instance details Defined in Control.Lens.Iso Methods strict :: Iso' (RWST r w s m a) (RWST0 r w s m a) #

withEquality :: AnEquality s t a b -> ((s :~: a) -> (b :~: t) -> r) -> r #

A version of substEq that provides explicit, rather than implicit, equality evidence.

fromLeibniz' :: ((s :~: s) -> s :~: a) -> Equality' s a #

Convert Leibniz equality to equality. Reverses mapEq in Simple cases.

The type should be understood as

fromLeibniz' :: (forall f. f s -> f a) -> Equality' s a

fromLeibniz :: (Identical a b a b -> Identical a b s t) -> Equality s t a b #

Convert a "profunctor lens" form of equality to an equality. Reverses overEquality.

The type should be understood as

fromLeibniz :: (forall p. p a b -> p s t) -> Equality s t a b

underEquality :: AnEquality s t a b -> p t s -> p b a #

The opposite of working overEquality is working underEquality.

overEquality :: AnEquality s t a b -> p a b -> p s t #

Recover a "profunctor lens" form of equality. Reverses fromLeibniz.

equality' :: (a :~: b) -> Equality' a b #

A Simple version of equality

equality :: (s :~: a) -> (b :~: t) -> Equality s t a b #

Construct an Equality from explicit equality evidence.

cloneEquality :: AnEquality s t a b -> Equality s t a b #

simple :: Equality' a a #

Composition with this isomorphism is occasionally useful when your Lens, Traversal or Iso has a constraint on an unused argument to force that argument to agree with the type of a used argument and avoid ScopedTypeVariables or other ugliness.

simply :: (Optic' p f s a -> r) -> Optic' p f s a -> r #

This is an adverb that can be used to modify many other Lens combinators to make them require simple lenses, simple traversals, simple prisms or simple isos as input.

fromEq :: AnEquality s t a b -> Equality b a t s #

Equality is symmetric.

mapEq :: AnEquality s t a b -> f s -> f a #

We can use Equality to do substitution into anything.

substEq :: AnEquality s t a b -> ((s ~ a) -> (t ~ b) -> r) -> r #

Substituting types with Equality.

runEq :: AnEquality s t a b -> Identical s t a b #

Extract a witness of type Equality.

data Identical (a :: k) (b :: k1) (s :: k) (t :: k1) :: forall k k1. k -> k1 -> k -> k1 -> Type where #

Provides witness that (s ~ a, b ~ t) holds.

Constructors

Identical :: forall k k1 (a :: k) (b :: k1) (s :: k) (t :: k1). Identical a b a b

type AnEquality (s :: k1) (t :: k2) (a :: k1) (b :: k2) = Identical a (Proxy b) a (Proxy b) -> Identical a (Proxy b) s (Proxy t) #

When you see this as an argument to a function, it expects an Equality.

type AnEquality' (s :: k2) (a :: k2) = AnEquality s s a a #

A Simple AnEquality.

itraverseByOf :: IndexedTraversal i s t a b -> (forall x. x -> f x) -> (forall x y. f (x -> y) -> f x -> f y) -> (i -> a -> f b) -> s -> f t #

itraverseBy :: TraversableWithIndex i t => (forall x. x -> f x) -> (forall x y. f (x -> y) -> f x -> f y) -> (i -> a -> f b) -> t a -> f (t b) #

ifoldMapByOf :: IndexedFold i t a -> (r -> r -> r) -> r -> (i -> a -> r) -> t -> r #

ifoldMapBy :: FoldableWithIndex i t => (r -> r -> r) -> r -> (i -> a -> r) -> t a -> r #

imapAccumL :: TraversableWithIndex i t => (i -> s -> a -> (s, b)) -> s -> t a -> (s, t b) #

Generalizes mapAccumL to add access to the index.

imapAccumLOf accumulates state from left to right.

mapAccumLOf ≡ imapAccumL . const

imapAccumR :: TraversableWithIndex i t => (i -> s -> a -> (s, b)) -> s -> t a -> (s, t b) #

Generalizes mapAccumR to add access to the index.

imapAccumROf accumulates state from right to left.

mapAccumR ≡ imapAccumR . const

iforM :: (TraversableWithIndex i t, Monad m) => t a -> (i -> a -> m b) -> m (t b) #

Map each element of a structure to a monadic action, evaluate these actions from left to right, and collect the results, with access its position (and the arguments flipped).

forM a ≡ iforM a . const
iforM ≡ flip imapM

imapM :: (TraversableWithIndex i t, Monad m) => (i -> a -> m b) -> t a -> m (t b) #

Map each element of a structure to a monadic action, evaluate these actions from left to right, and collect the results, with access the index.

When you don't need access to the index mapM is more liberal in what it can accept.

mapM ≡ imapM . const

ifor :: (TraversableWithIndex i t, Applicative f) => t a -> (i -> a -> f b) -> f (t b) #

Traverse with an index (and the arguments flipped).

for a ≡ ifor a . const
ifor ≡ flip itraverse

itoList :: FoldableWithIndex i f => f a -> [(i, a)] #

Extract the key-value pairs from a structure.

When you don't need access to the indices in the result, then toList is more flexible in what it accepts.

toList ≡ map snd . itoList

ifoldlM :: (FoldableWithIndex i f, Monad m) => (i -> b -> a -> m b) -> b -> f a -> m b #

Monadic fold over the elements of a structure with an index, associating to the left.

When you don't need access to the index then foldlM is more flexible in what it accepts.

foldlM ≡ ifoldlM . const

ifoldrM :: (FoldableWithIndex i f, Monad m) => (i -> a -> b -> m b) -> b -> f a -> m b #

Monadic fold right over the elements of a structure with an index.

When you don't need access to the index then foldrM is more flexible in what it accepts.

foldrM ≡ ifoldrM . const

ifind :: FoldableWithIndex i f => (i -> a -> Bool) -> f a -> Maybe (i, a) #

Searches a container with a predicate that is also supplied the index, returning the left-most element of the structure matching the predicate, or Nothing if there is no such element.

When you don't need access to the index then find is more flexible in what it accepts.

find ≡ ifind . const

iconcatMap :: FoldableWithIndex i f => (i -> a -> [b]) -> f a -> [b] #

Concatenate the results of a function of the elements of an indexed container with access to the index.

When you don't need access to the index then concatMap is more flexible in what it accepts.

concatMap ≡ iconcatMap . const
iconcatMap ≡ ifoldMap

iforM_ :: (FoldableWithIndex i t, Monad m) => t a -> (i -> a -> m b) -> m () #

Run monadic actions for each target of an IndexedFold or IndexedTraversal with access to the index, discarding the results (with the arguments flipped).

iforM_ ≡ flip imapM_

When you don't need access to the index then forMOf_ is more flexible in what it accepts.

forMOf_ l a ≡ iforMOf l a . const

imapM_ :: (FoldableWithIndex i t, Monad m) => (i -> a -> m b) -> t a -> m () #

Run monadic actions for each target of an IndexedFold or IndexedTraversal with access to the index, discarding the results.

When you don't need access to the index then mapMOf_ is more flexible in what it accepts.

mapM_ ≡ imapM . const

ifor_ :: (FoldableWithIndex i t, Applicative f) => t a -> (i -> a -> f b) -> f () #

Traverse elements with access to the index i, discarding the results (with the arguments flipped).

ifor_ ≡ flip itraverse_

When you don't need access to the index then for_ is more flexible in what it accepts.

for_ a ≡ ifor_ a . const

itraverse_ :: (FoldableWithIndex i t, Applicative f) => (i -> a -> f b) -> t a -> f () #

Traverse elements with access to the index i, discarding the results.

When you don't need access to the index then traverse_ is more flexible in what it accepts.

traverse_ l = itraverse . const

none :: Foldable f => (a -> Bool) -> f a -> Bool #

Determines whether no elements of the structure satisfy the predicate.

none f ≡ not . any f

inone :: FoldableWithIndex i f => (i -> a -> Bool) -> f a -> Bool #

Return whether or not none of the elements in a container satisfy a predicate, with access to the index i.

When you don't need access to the index then none is more flexible in what it accepts.

none ≡ inone . const
inone f ≡ not . iany f

iall :: FoldableWithIndex i f => (i -> a -> Bool) -> f a -> Bool #

Return whether or not all elements in a container satisfy a predicate, with access to the index i.

When you don't need access to the index then all is more flexible in what it accepts.

all ≡ iall . const

iany :: FoldableWithIndex i f => (i -> a -> Bool) -> f a -> Bool #

Return whether or not any element in a container satisfies a predicate, with access to the index i.

When you don't need access to the index then any is more flexible in what it accepts.

any ≡ iany . const

index :: (Indexable i p, Eq i, Applicative f) => i -> Optical' p (Indexed i) f a a #

This allows you to filter an IndexedFold, IndexedGetter, IndexedTraversal or IndexedLens based on an index.

>>> ["hello","the","world","!!!"]^?traversed.index 2
Just "world"

indices :: (Indexable i p, Applicative f) => (i -> Bool) -> Optical' p (Indexed i) f a a #

This allows you to filter an IndexedFold, IndexedGetter, IndexedTraversal or IndexedLens based on a predicate on the indices.

>>> ["hello","the","world","!!!"]^..traversed.indices even
["hello","world"]

>>> over (traversed.indices (>0)) Prelude.reverse $ ["He","was","stressed","o_O"]
["He","saw","desserts","O_o"]

icompose :: Indexable p c => (i -> j -> p) -> (Indexed i s t -> r) -> (Indexed j a b -> s -> t) -> c a b -> r #

Composition of Indexed functions with a user supplied function for combining indices.

reindexed :: Indexable j p => (i -> j) -> (Indexed i a b -> r) -> p a b -> r #

Remap the index.

selfIndex :: Indexable a p => p a fb -> a -> fb #

Use a value itself as its own index. This is essentially an indexed version of id.

Note: When used to modify the value, this can break the index requirements assumed by indices and similar, so this is only properly an IndexedGetter, but it can be used as more.

selfIndex :: IndexedGetter a a b

(.>) :: (st -> r) -> (kab -> st) -> kab -> r infixr 9 #

Compose a non-indexed function with an Indexed function.

Mnemonically, the > points to the indexing we want to preserve.

This is the same as (.).

f . g (and f .> g) gives you the index of g unless g is index-preserving, like a Prism, Iso or Equality, in which case it'll pass through the index of f.

>>> let nestedMap = (fmap Map.fromList . Map.fromList) [(1, [(10, "one,ten"), (20, "one,twenty")]), (2, [(30, "two,thirty"), (40,"two,forty")])]
>>> nestedMap^..(itraversed.>itraversed).withIndex
[(10,"one,ten"),(20,"one,twenty"),(30,"two,thirty"),(40,"two,forty")]

(<.) :: Indexable i p => (Indexed i s t -> r) -> ((a -> b) -> s -> t) -> p a b -> r infixr 9 #

Compose an Indexed function with a non-indexed function.

Mnemonically, the < points to the indexing we want to preserve.

>>> let nestedMap = (fmap Map.fromList . Map.fromList) [(1, [(10, "one,ten"), (20, "one,twenty")]), (2, [(30, "two,thirty"), (40,"two,forty")])]
>>> nestedMap^..(itraversed<.itraversed).withIndex
[(1,"one,ten"),(1,"one,twenty"),(2,"two,thirty"),(2,"two,forty")]

class Functor f => FunctorWithIndex i (f :: Type -> Type) | f -> i where #

A Functor with an additional index.

Instances must satisfy a modified form of the Functor laws:

imap f . imap g ≡ imap (\i -> f i . g i)
imap (\_ a -> a) ≡ id

Minimal complete definition

Nothing

Methods

imap :: (i -> a -> b) -> f a -> f b #

Map with access to the index.

imapped :: IndexedSetter i (f a) (f b) a b #

The IndexedSetter for a FunctorWithIndex.

If you don't need access to the index, then mapped is more flexible in what it accepts.

Instances

FunctorWithIndex Int []	The position in the list is available as the index.
Instance details Defined in Control.Lens.Indexed Methods imap :: (Int -> a -> b) -> [a] -> [b] # imapped :: IndexedSetter Int [a] [b] a b #
FunctorWithIndex Int ZipList	Same instance as for `[]`.
Instance details Defined in Control.Lens.Indexed Methods imap :: (Int -> a -> b) -> ZipList a -> ZipList b # imapped :: IndexedSetter Int (ZipList a) (ZipList b) a b #
FunctorWithIndex Int NonEmpty
Instance details Defined in Control.Lens.Indexed Methods imap :: (Int -> a -> b) -> NonEmpty a -> NonEmpty b # imapped :: IndexedSetter Int (NonEmpty a) (NonEmpty b) a b #
FunctorWithIndex Int IntMap
Instance details Defined in Control.Lens.Indexed Methods imap :: (Int -> a -> b) -> IntMap a -> IntMap b # imapped :: IndexedSetter Int (IntMap a) (IntMap b) a b #
FunctorWithIndex Int Seq	The position in the `Seq` is available as the index.
Instance details Defined in Control.Lens.Indexed Methods imap :: (Int -> a -> b) -> Seq a -> Seq b # imapped :: IndexedSetter Int (Seq a) (Seq b) a b #
FunctorWithIndex Int Vector
Instance details Defined in Control.Lens.Indexed Methods imap :: (Int -> a -> b) -> Vector a -> Vector b # imapped :: IndexedSetter Int (Vector a) (Vector b) a b #
FunctorWithIndex () Maybe
Instance details Defined in Control.Lens.Indexed Methods imap :: (() -> a -> b) -> Maybe a -> Maybe b # imapped :: IndexedSetter () (Maybe a) (Maybe b) a b #
FunctorWithIndex () Par1
Instance details Defined in Control.Lens.Indexed Methods imap :: (() -> a -> b) -> Par1 a -> Par1 b # imapped :: IndexedSetter () (Par1 a) (Par1 b) a b #
FunctorWithIndex () Identity
Instance details Defined in Control.Lens.Indexed Methods imap :: (() -> a -> b) -> Identity a -> Identity b # imapped :: IndexedSetter () (Identity a) (Identity b) a b #
FunctorWithIndex k (Map k)
Instance details Defined in Control.Lens.Indexed Methods imap :: (k -> a -> b) -> Map k a -> Map k b # imapped :: IndexedSetter k (Map k a) (Map k b) a b #
FunctorWithIndex k (HashMap k)
Instance details Defined in Control.Lens.Indexed Methods imap :: (k -> a -> b) -> HashMap k a -> HashMap k b # imapped :: IndexedSetter k (HashMap k a) (HashMap k b) a b #
FunctorWithIndex k ((,) k)
Instance details Defined in Control.Lens.Indexed Methods imap :: (k -> a -> b) -> (k, a) -> (k, b) # imapped :: IndexedSetter k (k, a) (k, b) a b #
FunctorWithIndex i (Level i)
Instance details Defined in Control.Lens.Indexed Methods imap :: (i -> a -> b) -> Level i a -> Level i b # imapped :: IndexedSetter i (Level i a) (Level i b) a b #
Ix i => FunctorWithIndex i (Array i)
Instance details Defined in Control.Lens.Indexed Methods imap :: (i -> a -> b) -> Array i a -> Array i b # imapped :: IndexedSetter i (Array i a) (Array i b) a b #
FunctorWithIndex Void (V1 :: Type -> Type)
Instance details Defined in Control.Lens.Indexed Methods imap :: (Void -> a -> b) -> V1 a -> V1 b # imapped :: IndexedSetter Void (V1 a) (V1 b) a b #
FunctorWithIndex Void (U1 :: Type -> Type)
Instance details Defined in Control.Lens.Indexed Methods imap :: (Void -> a -> b) -> U1 a -> U1 b # imapped :: IndexedSetter Void (U1 a) (U1 b) a b #
FunctorWithIndex Void (Proxy :: Type -> Type)
Instance details Defined in Control.Lens.Indexed Methods imap :: (Void -> a -> b) -> Proxy a -> Proxy b # imapped :: IndexedSetter Void (Proxy a) (Proxy b) a b #
FunctorWithIndex () (Tagged a)
Instance details Defined in Control.Lens.Indexed Methods imap :: (() -> a0 -> b) -> Tagged a a0 -> Tagged a b # imapped :: IndexedSetter () (Tagged a a0) (Tagged a b) a0 b #
FunctorWithIndex i f => FunctorWithIndex i (Reverse f)
Instance details Defined in Control.Lens.Indexed Methods imap :: (i -> a -> b) -> Reverse f a -> Reverse f b # imapped :: IndexedSetter i (Reverse f a) (Reverse f b) a b #
FunctorWithIndex i f => FunctorWithIndex i (Rec1 f)
Instance details Defined in Control.Lens.Indexed Methods imap :: (i -> a -> b) -> Rec1 f a -> Rec1 f b # imapped :: IndexedSetter i (Rec1 f a) (Rec1 f b) a b #
FunctorWithIndex i m => FunctorWithIndex i (IdentityT m)
Instance details Defined in Control.Lens.Indexed Methods imap :: (i -> a -> b) -> IdentityT m a -> IdentityT m b # imapped :: IndexedSetter i (IdentityT m a) (IdentityT m b) a b #
FunctorWithIndex i f => FunctorWithIndex i (Backwards f)
Instance details Defined in Control.Lens.Indexed Methods imap :: (i -> a -> b) -> Backwards f a -> Backwards f b # imapped :: IndexedSetter i (Backwards f a) (Backwards f b) a b #
FunctorWithIndex r ((->) r :: Type -> Type)
Instance details Defined in Control.Lens.Indexed Methods imap :: (r -> a -> b) -> (r -> a) -> r -> b # imapped :: IndexedSetter r (r -> a) (r -> b) a b #
FunctorWithIndex i (Magma i t b)
Instance details Defined in Control.Lens.Indexed Methods imap :: (i -> a -> b0) -> Magma i t b a -> Magma i t b b0 # imapped :: IndexedSetter i (Magma i t b a) (Magma i t b b0) a b0 #
FunctorWithIndex Void (K1 i c :: Type -> Type)
Instance details Defined in Control.Lens.Indexed Methods imap :: (Void -> a -> b) -> K1 i c a -> K1 i c b # imapped :: IndexedSetter Void (K1 i c a) (K1 i c b) a b #
FunctorWithIndex [Int] Tree
Instance details Defined in Control.Lens.Indexed Methods imap :: ([Int] -> a -> b) -> Tree a -> Tree b # imapped :: IndexedSetter [Int] (Tree a) (Tree b) a b #
FunctorWithIndex i f => FunctorWithIndex [i] (Free f)
Instance details Defined in Control.Lens.Indexed Methods imap :: ([i] -> a -> b) -> Free f a -> Free f b # imapped :: IndexedSetter [i] (Free f a) (Free f b) a b #
FunctorWithIndex i f => FunctorWithIndex [i] (Cofree f)
Instance details Defined in Control.Lens.Indexed Methods imap :: ([i] -> a -> b) -> Cofree f a -> Cofree f b # imapped :: IndexedSetter [i] (Cofree f a) (Cofree f b) a b #
FunctorWithIndex i w => FunctorWithIndex (s, i) (TracedT s w)
Instance details Defined in Control.Lens.Indexed Methods imap :: ((s, i) -> a -> b) -> TracedT s w a -> TracedT s w b # imapped :: IndexedSetter (s, i) (TracedT s w a) (TracedT s w b) a b #
(FunctorWithIndex i f, FunctorWithIndex j g) => FunctorWithIndex (Either i j) (Sum f g)
Instance details Defined in Control.Lens.Indexed Methods imap :: (Either i j -> a -> b) -> Sum f g a -> Sum f g b # imapped :: IndexedSetter (Either i j) (Sum f g a) (Sum f g b) a b #
(FunctorWithIndex i f, FunctorWithIndex j g) => FunctorWithIndex (Either i j) (Product f g)
Instance details Defined in Control.Lens.Indexed Methods imap :: (Either i j -> a -> b) -> Product f g a -> Product f g b # imapped :: IndexedSetter (Either i j) (Product f g a) (Product f g b) a b #
(FunctorWithIndex i f, FunctorWithIndex j g) => FunctorWithIndex (Either i j) (f :+: g)
Instance details Defined in Control.Lens.Indexed Methods imap :: (Either i j -> a -> b) -> (f :+: g) a -> (f :+: g) b # imapped :: IndexedSetter (Either i j) ((f :+: g) a) ((f :+: g) b) a b #
(FunctorWithIndex i f, FunctorWithIndex j g) => FunctorWithIndex (Either i j) (f :*: g)
Instance details Defined in Control.Lens.Indexed Methods imap :: (Either i j -> a -> b) -> (f :: g) a -> (f :: g) b # imapped :: IndexedSetter (Either i j) ((f :: g) a) ((f :: g) b) a b #
FunctorWithIndex i m => FunctorWithIndex (e, i) (ReaderT e m)
Instance details Defined in Control.Lens.Indexed Methods imap :: ((e, i) -> a -> b) -> ReaderT e m a -> ReaderT e m b # imapped :: IndexedSetter (e, i) (ReaderT e m a) (ReaderT e m b) a b #
(FunctorWithIndex i f, FunctorWithIndex j g) => FunctorWithIndex (i, j) (Compose f g)
Instance details Defined in Control.Lens.Indexed Methods imap :: ((i, j) -> a -> b) -> Compose f g a -> Compose f g b # imapped :: IndexedSetter (i, j) (Compose f g a) (Compose f g b) a b #
(FunctorWithIndex i f, FunctorWithIndex j g) => FunctorWithIndex (i, j) (f :.: g)
Instance details Defined in Control.Lens.Indexed Methods imap :: ((i, j) -> a -> b) -> (f :.: g) a -> (f :.: g) b # imapped :: IndexedSetter (i, j) ((f :.: g) a) ((f :.: g) b) a b #

class Foldable f => FoldableWithIndex i (f :: Type -> Type) | f -> i where #

A container that supports folding with an additional index.

Minimal complete definition

Nothing

Methods

ifoldMap :: Monoid m => (i -> a -> m) -> f a -> m #

Fold a container by mapping value to an arbitrary Monoid with access to the index i.

When you don't need access to the index then foldMap is more flexible in what it accepts.

foldMap ≡ ifoldMap . const

ifolded :: IndexedFold i (f a) a #

The IndexedFold of a FoldableWithIndex container.

ifolded . asIndex is a fold over the keys of a FoldableWithIndex.

>>> Data.Map.fromList [(2, "hello"), (1, "world")]^..ifolded.asIndex
[1,2]

ifoldr :: (i -> a -> b -> b) -> b -> f a -> b #

Right-associative fold of an indexed container with access to the index i.

When you don't need access to the index then foldr is more flexible in what it accepts.

foldr ≡ ifoldr . const

ifoldl :: (i -> b -> a -> b) -> b -> f a -> b #

Left-associative fold of an indexed container with access to the index i.

When you don't need access to the index then foldl is more flexible in what it accepts.

foldl ≡ ifoldl . const

ifoldr' :: (i -> a -> b -> b) -> b -> f a -> b #

Strictly fold right over the elements of a structure with access to the index i.

When you don't need access to the index then Foldable is more flexible in what it accepts.

Foldable ≡ ifoldr' . const

ifoldl' :: (i -> b -> a -> b) -> b -> f a -> b #

Fold over the elements of a structure with an index, associating to the left, but strictly.

When you don't need access to the index then foldlOf' is more flexible in what it accepts.

foldlOf' l ≡ ifoldlOf' l . const

Instances

FoldableWithIndex Int []
Instance details Defined in Control.Lens.Indexed Methods ifoldMap :: Monoid m => (Int -> a -> m) -> [a] -> m # ifolded :: IndexedFold Int [a] a # ifoldr :: (Int -> a -> b -> b) -> b -> [a] -> b # ifoldl :: (Int -> b -> a -> b) -> b -> [a] -> b # ifoldr' :: (Int -> a -> b -> b) -> b -> [a] -> b # ifoldl' :: (Int -> b -> a -> b) -> b -> [a] -> b #
FoldableWithIndex Int ZipList
Instance details Defined in Control.Lens.Indexed Methods ifoldMap :: Monoid m => (Int -> a -> m) -> ZipList a -> m # ifolded :: IndexedFold Int (ZipList a) a # ifoldr :: (Int -> a -> b -> b) -> b -> ZipList a -> b # ifoldl :: (Int -> b -> a -> b) -> b -> ZipList a -> b # ifoldr' :: (Int -> a -> b -> b) -> b -> ZipList a -> b # ifoldl' :: (Int -> b -> a -> b) -> b -> ZipList a -> b #
FoldableWithIndex Int NonEmpty
Instance details Defined in Control.Lens.Indexed Methods ifoldMap :: Monoid m => (Int -> a -> m) -> NonEmpty a -> m # ifolded :: IndexedFold Int (NonEmpty a) a # ifoldr :: (Int -> a -> b -> b) -> b -> NonEmpty a -> b # ifoldl :: (Int -> b -> a -> b) -> b -> NonEmpty a -> b # ifoldr' :: (Int -> a -> b -> b) -> b -> NonEmpty a -> b # ifoldl' :: (Int -> b -> a -> b) -> b -> NonEmpty a -> b #
FoldableWithIndex Int IntMap
Instance details Defined in Control.Lens.Indexed Methods ifoldMap :: Monoid m => (Int -> a -> m) -> IntMap a -> m # ifolded :: IndexedFold Int (IntMap a) a # ifoldr :: (Int -> a -> b -> b) -> b -> IntMap a -> b # ifoldl :: (Int -> b -> a -> b) -> b -> IntMap a -> b # ifoldr' :: (Int -> a -> b -> b) -> b -> IntMap a -> b # ifoldl' :: (Int -> b -> a -> b) -> b -> IntMap a -> b #
FoldableWithIndex Int Seq
Instance details Defined in Control.Lens.Indexed Methods ifoldMap :: Monoid m => (Int -> a -> m) -> Seq a -> m # ifolded :: IndexedFold Int (Seq a) a # ifoldr :: (Int -> a -> b -> b) -> b -> Seq a -> b # ifoldl :: (Int -> b -> a -> b) -> b -> Seq a -> b # ifoldr' :: (Int -> a -> b -> b) -> b -> Seq a -> b # ifoldl' :: (Int -> b -> a -> b) -> b -> Seq a -> b #
FoldableWithIndex Int Vector
Instance details Defined in Control.Lens.Indexed Methods ifoldMap :: Monoid m => (Int -> a -> m) -> Vector a -> m # ifolded :: IndexedFold Int (Vector a) a # ifoldr :: (Int -> a -> b -> b) -> b -> Vector a -> b # ifoldl :: (Int -> b -> a -> b) -> b -> Vector a -> b # ifoldr' :: (Int -> a -> b -> b) -> b -> Vector a -> b # ifoldl' :: (Int -> b -> a -> b) -> b -> Vector a -> b #
FoldableWithIndex () Maybe
Instance details Defined in Control.Lens.Indexed Methods ifoldMap :: Monoid m => (() -> a -> m) -> Maybe a -> m # ifolded :: IndexedFold () (Maybe a) a # ifoldr :: (() -> a -> b -> b) -> b -> Maybe a -> b # ifoldl :: (() -> b -> a -> b) -> b -> Maybe a -> b # ifoldr' :: (() -> a -> b -> b) -> b -> Maybe a -> b # ifoldl' :: (() -> b -> a -> b) -> b -> Maybe a -> b #
FoldableWithIndex () Par1
Instance details Defined in Control.Lens.Indexed Methods ifoldMap :: Monoid m => (() -> a -> m) -> Par1 a -> m # ifolded :: IndexedFold () (Par1 a) a # ifoldr :: (() -> a -> b -> b) -> b -> Par1 a -> b # ifoldl :: (() -> b -> a -> b) -> b -> Par1 a -> b # ifoldr' :: (() -> a -> b -> b) -> b -> Par1 a -> b # ifoldl' :: (() -> b -> a -> b) -> b -> Par1 a -> b #
FoldableWithIndex () Identity
Instance details Defined in Control.Lens.Indexed Methods ifoldMap :: Monoid m => (() -> a -> m) -> Identity a -> m # ifolded :: IndexedFold () (Identity a) a # ifoldr :: (() -> a -> b -> b) -> b -> Identity a -> b # ifoldl :: (() -> b -> a -> b) -> b -> Identity a -> b # ifoldr' :: (() -> a -> b -> b) -> b -> Identity a -> b # ifoldl' :: (() -> b -> a -> b) -> b -> Identity a -> b #
FoldableWithIndex k (Map k)
Instance details Defined in Control.Lens.Indexed Methods ifoldMap :: Monoid m => (k -> a -> m) -> Map k a -> m # ifolded :: IndexedFold k (Map k a) a # ifoldr :: (k -> a -> b -> b) -> b -> Map k a -> b # ifoldl :: (k -> b -> a -> b) -> b -> Map k a -> b # ifoldr' :: (k -> a -> b -> b) -> b -> Map k a -> b # ifoldl' :: (k -> b -> a -> b) -> b -> Map k a -> b #
FoldableWithIndex k (HashMap k)
Instance details Defined in Control.Lens.Indexed Methods ifoldMap :: Monoid m => (k -> a -> m) -> HashMap k a -> m # ifolded :: IndexedFold k (HashMap k a) a # ifoldr :: (k -> a -> b -> b) -> b -> HashMap k a -> b # ifoldl :: (k -> b -> a -> b) -> b -> HashMap k a -> b # ifoldr' :: (k -> a -> b -> b) -> b -> HashMap k a -> b # ifoldl' :: (k -> b -> a -> b) -> b -> HashMap k a -> b #
FoldableWithIndex k ((,) k)
Instance details Defined in Control.Lens.Indexed Methods ifoldMap :: Monoid m => (k -> a -> m) -> (k, a) -> m # ifolded :: IndexedFold k (k, a) a # ifoldr :: (k -> a -> b -> b) -> b -> (k, a) -> b # ifoldl :: (k -> b -> a -> b) -> b -> (k, a) -> b # ifoldr' :: (k -> a -> b -> b) -> b -> (k, a) -> b # ifoldl' :: (k -> b -> a -> b) -> b -> (k, a) -> b #
FoldableWithIndex i (Level i)
Instance details Defined in Control.Lens.Indexed Methods ifoldMap :: Monoid m => (i -> a -> m) -> Level i a -> m # ifolded :: IndexedFold i (Level i a) a # ifoldr :: (i -> a -> b -> b) -> b -> Level i a -> b # ifoldl :: (i -> b -> a -> b) -> b -> Level i a -> b # ifoldr' :: (i -> a -> b -> b) -> b -> Level i a -> b # ifoldl' :: (i -> b -> a -> b) -> b -> Level i a -> b #
Ix i => FoldableWithIndex i (Array i)
Instance details Defined in Control.Lens.Indexed Methods ifoldMap :: Monoid m => (i -> a -> m) -> Array i a -> m # ifolded :: IndexedFold i (Array i a) a # ifoldr :: (i -> a -> b -> b) -> b -> Array i a -> b # ifoldl :: (i -> b -> a -> b) -> b -> Array i a -> b # ifoldr' :: (i -> a -> b -> b) -> b -> Array i a -> b # ifoldl' :: (i -> b -> a -> b) -> b -> Array i a -> b #
FoldableWithIndex Void (V1 :: Type -> Type)
Instance details Defined in Control.Lens.Indexed Methods ifoldMap :: Monoid m => (Void -> a -> m) -> V1 a -> m # ifolded :: IndexedFold Void (V1 a) a # ifoldr :: (Void -> a -> b -> b) -> b -> V1 a -> b # ifoldl :: (Void -> b -> a -> b) -> b -> V1 a -> b # ifoldr' :: (Void -> a -> b -> b) -> b -> V1 a -> b # ifoldl' :: (Void -> b -> a -> b) -> b -> V1 a -> b #
FoldableWithIndex Void (U1 :: Type -> Type)
Instance details Defined in Control.Lens.Indexed Methods ifoldMap :: Monoid m => (Void -> a -> m) -> U1 a -> m # ifolded :: IndexedFold Void (U1 a) a # ifoldr :: (Void -> a -> b -> b) -> b -> U1 a -> b # ifoldl :: (Void -> b -> a -> b) -> b -> U1 a -> b # ifoldr' :: (Void -> a -> b -> b) -> b -> U1 a -> b # ifoldl' :: (Void -> b -> a -> b) -> b -> U1 a -> b #
FoldableWithIndex Void (Proxy :: Type -> Type)
Instance details Defined in Control.Lens.Indexed Methods ifoldMap :: Monoid m => (Void -> a -> m) -> Proxy a -> m # ifolded :: IndexedFold Void (Proxy a) a # ifoldr :: (Void -> a -> b -> b) -> b -> Proxy a -> b # ifoldl :: (Void -> b -> a -> b) -> b -> Proxy a -> b # ifoldr' :: (Void -> a -> b -> b) -> b -> Proxy a -> b # ifoldl' :: (Void -> b -> a -> b) -> b -> Proxy a -> b #
FoldableWithIndex () (Tagged a)
Instance details Defined in Control.Lens.Indexed Methods ifoldMap :: Monoid m => (() -> a0 -> m) -> Tagged a a0 -> m # ifolded :: IndexedFold () (Tagged a a0) a0 # ifoldr :: (() -> a0 -> b -> b) -> b -> Tagged a a0 -> b # ifoldl :: (() -> b -> a0 -> b) -> b -> Tagged a a0 -> b # ifoldr' :: (() -> a0 -> b -> b) -> b -> Tagged a a0 -> b # ifoldl' :: (() -> b -> a0 -> b) -> b -> Tagged a a0 -> b #
FoldableWithIndex i f => FoldableWithIndex i (Reverse f)
Instance details Defined in Control.Lens.Indexed Methods ifoldMap :: Monoid m => (i -> a -> m) -> Reverse f a -> m # ifolded :: IndexedFold i (Reverse f a) a # ifoldr :: (i -> a -> b -> b) -> b -> Reverse f a -> b # ifoldl :: (i -> b -> a -> b) -> b -> Reverse f a -> b # ifoldr' :: (i -> a -> b -> b) -> b -> Reverse f a -> b # ifoldl' :: (i -> b -> a -> b) -> b -> Reverse f a -> b #
FoldableWithIndex i f => FoldableWithIndex i (Rec1 f)
Instance details Defined in Control.Lens.Indexed Methods ifoldMap :: Monoid m => (i -> a -> m) -> Rec1 f a -> m # ifolded :: IndexedFold i (Rec1 f a) a # ifoldr :: (i -> a -> b -> b) -> b -> Rec1 f a -> b # ifoldl :: (i -> b -> a -> b) -> b -> Rec1 f a -> b # ifoldr' :: (i -> a -> b -> b) -> b -> Rec1 f a -> b # ifoldl' :: (i -> b -> a -> b) -> b -> Rec1 f a -> b #
FoldableWithIndex i m => FoldableWithIndex i (IdentityT m)
Instance details Defined in Control.Lens.Indexed Methods ifoldMap :: Monoid m0 => (i -> a -> m0) -> IdentityT m a -> m0 # ifolded :: IndexedFold i (IdentityT m a) a # ifoldr :: (i -> a -> b -> b) -> b -> IdentityT m a -> b # ifoldl :: (i -> b -> a -> b) -> b -> IdentityT m a -> b # ifoldr' :: (i -> a -> b -> b) -> b -> IdentityT m a -> b # ifoldl' :: (i -> b -> a -> b) -> b -> IdentityT m a -> b #
FoldableWithIndex i f => FoldableWithIndex i (Backwards f)
Instance details Defined in Control.Lens.Indexed Methods ifoldMap :: Monoid m => (i -> a -> m) -> Backwards f a -> m # ifolded :: IndexedFold i (Backwards f a) a # ifoldr :: (i -> a -> b -> b) -> b -> Backwards f a -> b # ifoldl :: (i -> b -> a -> b) -> b -> Backwards f a -> b # ifoldr' :: (i -> a -> b -> b) -> b -> Backwards f a -> b # ifoldl' :: (i -> b -> a -> b) -> b -> Backwards f a -> b #
FoldableWithIndex i (Magma i t b)
Instance details Defined in Control.Lens.Indexed Methods ifoldMap :: Monoid m => (i -> a -> m) -> Magma i t b a -> m # ifolded :: IndexedFold i (Magma i t b a) a # ifoldr :: (i -> a -> b0 -> b0) -> b0 -> Magma i t b a -> b0 # ifoldl :: (i -> b0 -> a -> b0) -> b0 -> Magma i t b a -> b0 # ifoldr' :: (i -> a -> b0 -> b0) -> b0 -> Magma i t b a -> b0 # ifoldl' :: (i -> b0 -> a -> b0) -> b0 -> Magma i t b a -> b0 #
FoldableWithIndex Void (K1 i c :: Type -> Type)
Instance details Defined in Control.Lens.Indexed Methods ifoldMap :: Monoid m => (Void -> a -> m) -> K1 i c a -> m # ifolded :: IndexedFold Void (K1 i c a) a # ifoldr :: (Void -> a -> b -> b) -> b -> K1 i c a -> b # ifoldl :: (Void -> b -> a -> b) -> b -> K1 i c a -> b # ifoldr' :: (Void -> a -> b -> b) -> b -> K1 i c a -> b # ifoldl' :: (Void -> b -> a -> b) -> b -> K1 i c a -> b #
FoldableWithIndex [Int] Tree
Instance details Defined in Control.Lens.Indexed Methods ifoldMap :: Monoid m => ([Int] -> a -> m) -> Tree a -> m # ifolded :: IndexedFold [Int] (Tree a) a # ifoldr :: ([Int] -> a -> b -> b) -> b -> Tree a -> b # ifoldl :: ([Int] -> b -> a -> b) -> b -> Tree a -> b # ifoldr' :: ([Int] -> a -> b -> b) -> b -> Tree a -> b # ifoldl' :: ([Int] -> b -> a -> b) -> b -> Tree a -> b #
FoldableWithIndex i f => FoldableWithIndex [i] (Free f)
Instance details Defined in Control.Lens.Indexed Methods ifoldMap :: Monoid m => ([i] -> a -> m) -> Free f a -> m # ifolded :: IndexedFold [i] (Free f a) a # ifoldr :: ([i] -> a -> b -> b) -> b -> Free f a -> b # ifoldl :: ([i] -> b -> a -> b) -> b -> Free f a -> b # ifoldr' :: ([i] -> a -> b -> b) -> b -> Free f a -> b # ifoldl' :: ([i] -> b -> a -> b) -> b -> Free f a -> b #
FoldableWithIndex i f => FoldableWithIndex [i] (Cofree f)
Instance details Defined in Control.Lens.Indexed Methods ifoldMap :: Monoid m => ([i] -> a -> m) -> Cofree f a -> m # ifolded :: IndexedFold [i] (Cofree f a) a # ifoldr :: ([i] -> a -> b -> b) -> b -> Cofree f a -> b # ifoldl :: ([i] -> b -> a -> b) -> b -> Cofree f a -> b # ifoldr' :: ([i] -> a -> b -> b) -> b -> Cofree f a -> b # ifoldl' :: ([i] -> b -> a -> b) -> b -> Cofree f a -> b #
(FoldableWithIndex i f, FoldableWithIndex j g) => FoldableWithIndex (Either i j) (Sum f g)
Instance details Defined in Control.Lens.Indexed Methods ifoldMap :: Monoid m => (Either i j -> a -> m) -> Sum f g a -> m # ifolded :: IndexedFold (Either i j) (Sum f g a) a # ifoldr :: (Either i j -> a -> b -> b) -> b -> Sum f g a -> b # ifoldl :: (Either i j -> b -> a -> b) -> b -> Sum f g a -> b # ifoldr' :: (Either i j -> a -> b -> b) -> b -> Sum f g a -> b # ifoldl' :: (Either i j -> b -> a -> b) -> b -> Sum f g a -> b #
(FoldableWithIndex i f, FoldableWithIndex j g) => FoldableWithIndex (Either i j) (Product f g)
Instance details Defined in Control.Lens.Indexed Methods ifoldMap :: Monoid m => (Either i j -> a -> m) -> Product f g a -> m # ifolded :: IndexedFold (Either i j) (Product f g a) a # ifoldr :: (Either i j -> a -> b -> b) -> b -> Product f g a -> b # ifoldl :: (Either i j -> b -> a -> b) -> b -> Product f g a -> b # ifoldr' :: (Either i j -> a -> b -> b) -> b -> Product f g a -> b # ifoldl' :: (Either i j -> b -> a -> b) -> b -> Product f g a -> b #
(FoldableWithIndex i f, FoldableWithIndex j g) => FoldableWithIndex (Either i j) (f :+: g)
Instance details Defined in Control.Lens.Indexed Methods ifoldMap :: Monoid m => (Either i j -> a -> m) -> (f :+: g) a -> m # ifolded :: IndexedFold (Either i j) ((f :+: g) a) a # ifoldr :: (Either i j -> a -> b -> b) -> b -> (f :+: g) a -> b # ifoldl :: (Either i j -> b -> a -> b) -> b -> (f :+: g) a -> b # ifoldr' :: (Either i j -> a -> b -> b) -> b -> (f :+: g) a -> b # ifoldl' :: (Either i j -> b -> a -> b) -> b -> (f :+: g) a -> b #
(FoldableWithIndex i f, FoldableWithIndex j g) => FoldableWithIndex (Either i j) (f :*: g)
Instance details Defined in Control.Lens.Indexed Methods ifoldMap :: Monoid m => (Either i j -> a -> m) -> (f :: g) a -> m # ifolded :: IndexedFold (Either i j) ((f :: g) a) a # ifoldr :: (Either i j -> a -> b -> b) -> b -> (f :: g) a -> b # ifoldl :: (Either i j -> b -> a -> b) -> b -> (f :: g) a -> b # ifoldr' :: (Either i j -> a -> b -> b) -> b -> (f :: g) a -> b # ifoldl' :: (Either i j -> b -> a -> b) -> b -> (f :: g) a -> b #
(FoldableWithIndex i f, FoldableWithIndex j g) => FoldableWithIndex (i, j) (Compose f g)
Instance details Defined in Control.Lens.Indexed Methods ifoldMap :: Monoid m => ((i, j) -> a -> m) -> Compose f g a -> m # ifolded :: IndexedFold (i, j) (Compose f g a) a # ifoldr :: ((i, j) -> a -> b -> b) -> b -> Compose f g a -> b # ifoldl :: ((i, j) -> b -> a -> b) -> b -> Compose f g a -> b # ifoldr' :: ((i, j) -> a -> b -> b) -> b -> Compose f g a -> b # ifoldl' :: ((i, j) -> b -> a -> b) -> b -> Compose f g a -> b #
(FoldableWithIndex i f, FoldableWithIndex j g) => FoldableWithIndex (i, j) (f :.: g)
Instance details Defined in Control.Lens.Indexed Methods ifoldMap :: Monoid m => ((i, j) -> a -> m) -> (f :.: g) a -> m # ifolded :: IndexedFold (i, j) ((f :.: g) a) a # ifoldr :: ((i, j) -> a -> b -> b) -> b -> (f :.: g) a -> b # ifoldl :: ((i, j) -> b -> a -> b) -> b -> (f :.: g) a -> b # ifoldr' :: ((i, j) -> a -> b -> b) -> b -> (f :.: g) a -> b # ifoldl' :: ((i, j) -> b -> a -> b) -> b -> (f :.: g) a -> b #

class (FunctorWithIndex i t, FoldableWithIndex i t, Traversable t) => TraversableWithIndex i (t :: Type -> Type) | t -> i where #

A Traversable with an additional index.

An instance must satisfy a (modified) form of the Traversable laws:

itraverse (const Identity) ≡ Identity
fmap (itraverse f) . itraverse g ≡ getCompose . itraverse (\i -> Compose . fmap (f i) . g i)

Minimal complete definition

Nothing

Methods

itraverse :: Applicative f => (i -> a -> f b) -> t a -> f (t b) #

Traverse an indexed container.

itraverse ≡ itraverseOf itraversed

itraversed :: IndexedTraversal i (t a) (t b) a b #

The IndexedTraversal of a TraversableWithIndex container.

Instances

TraversableWithIndex Int []
Instance details Defined in Control.Lens.Indexed Methods itraverse :: Applicative f => (Int -> a -> f b) -> [a] -> f [b] # itraversed :: IndexedTraversal Int [a] [b] a b #
TraversableWithIndex Int ZipList
Instance details Defined in Control.Lens.Indexed Methods itraverse :: Applicative f => (Int -> a -> f b) -> ZipList a -> f (ZipList b) # itraversed :: IndexedTraversal Int (ZipList a) (ZipList b) a b #
TraversableWithIndex Int NonEmpty
Instance details Defined in Control.Lens.Indexed Methods itraverse :: Applicative f => (Int -> a -> f b) -> NonEmpty a -> f (NonEmpty b) # itraversed :: IndexedTraversal Int (NonEmpty a) (NonEmpty b) a b #
TraversableWithIndex Int IntMap
Instance details Defined in Control.Lens.Indexed Methods itraverse :: Applicative f => (Int -> a -> f b) -> IntMap a -> f (IntMap b) # itraversed :: IndexedTraversal Int (IntMap a) (IntMap b) a b #
TraversableWithIndex Int Seq
Instance details Defined in Control.Lens.Indexed Methods itraverse :: Applicative f => (Int -> a -> f b) -> Seq a -> f (Seq b) # itraversed :: IndexedTraversal Int (Seq a) (Seq b) a b #
TraversableWithIndex Int Vector
Instance details Defined in Control.Lens.Indexed Methods itraverse :: Applicative f => (Int -> a -> f b) -> Vector a -> f (Vector b) # itraversed :: IndexedTraversal Int (Vector a) (Vector b) a b #
TraversableWithIndex () Maybe
Instance details Defined in Control.Lens.Indexed Methods itraverse :: Applicative f => (() -> a -> f b) -> Maybe a -> f (Maybe b) # itraversed :: IndexedTraversal () (Maybe a) (Maybe b) a b #
TraversableWithIndex () Par1
Instance details Defined in Control.Lens.Indexed Methods itraverse :: Applicative f => (() -> a -> f b) -> Par1 a -> f (Par1 b) # itraversed :: IndexedTraversal () (Par1 a) (Par1 b) a b #
TraversableWithIndex () Identity
Instance details Defined in Control.Lens.Indexed Methods itraverse :: Applicative f => (() -> a -> f b) -> Identity a -> f (Identity b) # itraversed :: IndexedTraversal () (Identity a) (Identity b) a b #
TraversableWithIndex k (Map k)
Instance details Defined in Control.Lens.Indexed Methods itraverse :: Applicative f => (k -> a -> f b) -> Map k a -> f (Map k b) # itraversed :: IndexedTraversal k (Map k a) (Map k b) a b #
TraversableWithIndex k (HashMap k)
Instance details Defined in Control.Lens.Indexed Methods itraverse :: Applicative f => (k -> a -> f b) -> HashMap k a -> f (HashMap k b) # itraversed :: IndexedTraversal k (HashMap k a) (HashMap k b) a b #
TraversableWithIndex k ((,) k)
Instance details Defined in Control.Lens.Indexed Methods itraverse :: Applicative f => (k -> a -> f b) -> (k, a) -> f (k, b) # itraversed :: IndexedTraversal k (k, a) (k, b) a b #
TraversableWithIndex i (Level i)
Instance details Defined in Control.Lens.Indexed Methods itraverse :: Applicative f => (i -> a -> f b) -> Level i a -> f (Level i b) # itraversed :: IndexedTraversal i (Level i a) (Level i b) a b #
Ix i => TraversableWithIndex i (Array i)
Instance details Defined in Control.Lens.Indexed Methods itraverse :: Applicative f => (i -> a -> f b) -> Array i a -> f (Array i b) # itraversed :: IndexedTraversal i (Array i a) (Array i b) a b #
TraversableWithIndex Void (V1 :: Type -> Type)
Instance details Defined in Control.Lens.Indexed Methods itraverse :: Applicative f => (Void -> a -> f b) -> V1 a -> f (V1 b) # itraversed :: IndexedTraversal Void (V1 a) (V1 b) a b #
TraversableWithIndex Void (U1 :: Type -> Type)
Instance details Defined in Control.Lens.Indexed Methods itraverse :: Applicative f => (Void -> a -> f b) -> U1 a -> f (U1 b) # itraversed :: IndexedTraversal Void (U1 a) (U1 b) a b #
TraversableWithIndex Void (Proxy :: Type -> Type)
Instance details Defined in Control.Lens.Indexed Methods itraverse :: Applicative f => (Void -> a -> f b) -> Proxy a -> f (Proxy b) # itraversed :: IndexedTraversal Void (Proxy a) (Proxy b) a b #
TraversableWithIndex () (Tagged a)
Instance details Defined in Control.Lens.Indexed Methods itraverse :: Applicative f => (() -> a0 -> f b) -> Tagged a a0 -> f (Tagged a b) # itraversed :: IndexedTraversal () (Tagged a a0) (Tagged a b) a0 b #
TraversableWithIndex i f => TraversableWithIndex i (Reverse f)
Instance details Defined in Control.Lens.Indexed Methods itraverse :: Applicative f0 => (i -> a -> f0 b) -> Reverse f a -> f0 (Reverse f b) # itraversed :: IndexedTraversal i (Reverse f a) (Reverse f b) a b #
TraversableWithIndex i f => TraversableWithIndex i (Rec1 f)
Instance details Defined in Control.Lens.Indexed Methods itraverse :: Applicative f0 => (i -> a -> f0 b) -> Rec1 f a -> f0 (Rec1 f b) # itraversed :: IndexedTraversal i (Rec1 f a) (Rec1 f b) a b #
TraversableWithIndex i m => TraversableWithIndex i (IdentityT m)
Instance details Defined in Control.Lens.Indexed Methods itraverse :: Applicative f => (i -> a -> f b) -> IdentityT m a -> f (IdentityT m b) # itraversed :: IndexedTraversal i (IdentityT m a) (IdentityT m b) a b #
TraversableWithIndex i f => TraversableWithIndex i (Backwards f)
Instance details Defined in Control.Lens.Indexed Methods itraverse :: Applicative f0 => (i -> a -> f0 b) -> Backwards f a -> f0 (Backwards f b) # itraversed :: IndexedTraversal i (Backwards f a) (Backwards f b) a b #
TraversableWithIndex i (Magma i t b)
Instance details Defined in Control.Lens.Indexed Methods itraverse :: Applicative f => (i -> a -> f b0) -> Magma i t b a -> f (Magma i t b b0) # itraversed :: IndexedTraversal i (Magma i t b a) (Magma i t b b0) a b0 #
TraversableWithIndex Void (K1 i c :: Type -> Type)
Instance details Defined in Control.Lens.Indexed Methods itraverse :: Applicative f => (Void -> a -> f b) -> K1 i c a -> f (K1 i c b) # itraversed :: IndexedTraversal Void (K1 i c a) (K1 i c b) a b #
TraversableWithIndex [Int] Tree
Instance details Defined in Control.Lens.Indexed Methods itraverse :: Applicative f => ([Int] -> a -> f b) -> Tree a -> f (Tree b) # itraversed :: IndexedTraversal [Int] (Tree a) (Tree b) a b #
TraversableWithIndex i f => TraversableWithIndex [i] (Free f)
Instance details Defined in Control.Lens.Indexed Methods itraverse :: Applicative f0 => ([i] -> a -> f0 b) -> Free f a -> f0 (Free f b) # itraversed :: IndexedTraversal [i] (Free f a) (Free f b) a b #
TraversableWithIndex i f => TraversableWithIndex [i] (Cofree f)
Instance details Defined in Control.Lens.Indexed Methods itraverse :: Applicative f0 => ([i] -> a -> f0 b) -> Cofree f a -> f0 (Cofree f b) # itraversed :: IndexedTraversal [i] (Cofree f a) (Cofree f b) a b #
(TraversableWithIndex i f, TraversableWithIndex j g) => TraversableWithIndex (Either i j) (Sum f g)
Instance details Defined in Control.Lens.Indexed Methods itraverse :: Applicative f0 => (Either i j -> a -> f0 b) -> Sum f g a -> f0 (Sum f g b) # itraversed :: IndexedTraversal (Either i j) (Sum f g a) (Sum f g b) a b #
(TraversableWithIndex i f, TraversableWithIndex j g) => TraversableWithIndex (Either i j) (Product f g)
Instance details Defined in Control.Lens.Indexed Methods itraverse :: Applicative f0 => (Either i j -> a -> f0 b) -> Product f g a -> f0 (Product f g b) # itraversed :: IndexedTraversal (Either i j) (Product f g a) (Product f g b) a b #
(TraversableWithIndex i f, TraversableWithIndex j g) => TraversableWithIndex (Either i j) (f :+: g)
Instance details Defined in Control.Lens.Indexed Methods itraverse :: Applicative f0 => (Either i j -> a -> f0 b) -> (f :+: g) a -> f0 ((f :+: g) b) # itraversed :: IndexedTraversal (Either i j) ((f :+: g) a) ((f :+: g) b) a b #
(TraversableWithIndex i f, TraversableWithIndex j g) => TraversableWithIndex (Either i j) (f :*: g)
Instance details Defined in Control.Lens.Indexed Methods itraverse :: Applicative f0 => (Either i j -> a -> f0 b) -> (f :: g) a -> f0 ((f :: g) b) # itraversed :: IndexedTraversal (Either i j) ((f :: g) a) ((f :: g) b) a b #
(TraversableWithIndex i f, TraversableWithIndex j g) => TraversableWithIndex (i, j) (Compose f g)
Instance details Defined in Control.Lens.Indexed Methods itraverse :: Applicative f0 => ((i, j) -> a -> f0 b) -> Compose f g a -> f0 (Compose f g b) # itraversed :: IndexedTraversal (i, j) (Compose f g a) (Compose f g b) a b #
(TraversableWithIndex i f, TraversableWithIndex j g) => TraversableWithIndex (i, j) (f :.: g)
Instance details Defined in Control.Lens.Indexed Methods itraverse :: Applicative f0 => ((i, j) -> a -> f0 b) -> (f :.: g) a -> f0 ((f :.: g) b) # itraversed :: IndexedTraversal (i, j) ((f :.: g) a) ((f :.: g) b) a b #

newtype ReifiedLens s t a b #

Reify a ReifiedLens so it can be stored safely in a container.

Constructors

Lens
Fields runLens :: Lens s t a b

type ReifiedLens' s a = ReifiedLens s s a a #

type ReifiedLens' = Simple ReifiedLens

newtype ReifiedIndexedLens i s t a b #

Reify an ReifiedIndexedLens so it can be stored safely in a container.

Constructors

IndexedLens
Fields runIndexedLens :: IndexedLens i s t a b

type ReifiedIndexedLens' i s a = ReifiedIndexedLens i s s a a #

type ReifiedIndexedLens' i = Simple (ReifiedIndexedLens i)

newtype ReifiedIndexedTraversal i s t a b #

Reify an ReifiedIndexedTraversal so it can be stored safely in a container.

Constructors

IndexedTraversal
Fields runIndexedTraversal :: IndexedTraversal i s t a b

type ReifiedIndexedTraversal' i s a = ReifiedIndexedTraversal i s s a a #

type ReifiedIndexedTraversal' i = Simple (ReifiedIndexedTraversal i)

newtype ReifiedTraversal s t a b #

A form of ReifiedTraversal that can be stored monomorphically in a container.

Constructors

Traversal
Fields runTraversal :: Traversal s t a b

type ReifiedTraversal' s a = ReifiedTraversal s s a a #

type ReifiedTraversal' = Simple ReifiedTraversal

newtype ReifiedGetter s a #

Reify a ReifiedGetter so it can be stored safely in a container.

This can also be useful when combining getters in novel ways, as ReifiedGetter is isomorphic to '(->)' and provides similar instances.

>>> ("hello","world","!!!")^.runGetter ((,) <$> Getter _2 <*> Getter (_1.to length))
("world",5)

Constructors

Getter
Fields runGetter :: Getter s a

Instances

Arrow ReifiedGetter
Instance details Defined in Control.Lens.Reified Methods arr :: (b -> c) -> ReifiedGetter b c # first :: ReifiedGetter b c -> ReifiedGetter (b, d) (c, d) # second :: ReifiedGetter b c -> ReifiedGetter (d, b) (d, c) # (***) :: ReifiedGetter b c -> ReifiedGetter b' c' -> ReifiedGetter (b, b') (c, c') # (&&&) :: ReifiedGetter b c -> ReifiedGetter b c' -> ReifiedGetter b (c, c') #
ArrowChoice ReifiedGetter
Instance details Defined in Control.Lens.Reified Methods left :: ReifiedGetter b c -> ReifiedGetter (Either b d) (Either c d) # right :: ReifiedGetter b c -> ReifiedGetter (Either d b) (Either d c) # (+++) :: ReifiedGetter b c -> ReifiedGetter b' c' -> ReifiedGetter (Either b b') (Either c c') # (\|\|\|) :: ReifiedGetter b d -> ReifiedGetter c d -> ReifiedGetter (Either b c) d #
ArrowApply ReifiedGetter
Instance details Defined in Control.Lens.Reified Methods app :: ReifiedGetter (ReifiedGetter b c, b) c #
ArrowLoop ReifiedGetter
Instance details Defined in Control.Lens.Reified Methods loop :: ReifiedGetter (b, d) (c, d) -> ReifiedGetter b c #
Profunctor ReifiedGetter
Instance details Defined in Control.Lens.Reified Methods dimap :: (a -> b) -> (c -> d) -> ReifiedGetter b c -> ReifiedGetter a d # lmap :: (a -> b) -> ReifiedGetter b c -> ReifiedGetter a c # rmap :: (b -> c) -> ReifiedGetter a b -> ReifiedGetter a c # (#.) :: Coercible c b => q b c -> ReifiedGetter a b -> ReifiedGetter a c # (.#) :: Coercible b a => ReifiedGetter b c -> q a b -> ReifiedGetter a c #
Representable ReifiedGetter
Instance details Defined in Control.Lens.Reified Associated Types type Rep ReifiedGetter :: Type -> Type # Methods tabulate :: (d -> Rep ReifiedGetter c) -> ReifiedGetter d c #
Corepresentable ReifiedGetter
Instance details Defined in Control.Lens.Reified Associated Types type Corep ReifiedGetter :: Type -> Type # Methods cotabulate :: (Corep ReifiedGetter d -> c) -> ReifiedGetter d c #
Conjoined ReifiedGetter
Instance details Defined in Control.Lens.Reified Methods distrib :: Functor f => ReifiedGetter a b -> ReifiedGetter (f a) (f b) # conjoined :: ((ReifiedGetter ~ (->)) -> q (a -> b) r) -> q (ReifiedGetter a b) r -> q (ReifiedGetter a b) r #
Choice ReifiedGetter
Instance details Defined in Control.Lens.Reified Methods left' :: ReifiedGetter a b -> ReifiedGetter (Either a c) (Either b c) # right' :: ReifiedGetter a b -> ReifiedGetter (Either c a) (Either c b) #
Closed ReifiedGetter
Instance details Defined in Control.Lens.Reified Methods closed :: ReifiedGetter a b -> ReifiedGetter (x -> a) (x -> b) #
Strong ReifiedGetter
Instance details Defined in Control.Lens.Reified Methods first' :: ReifiedGetter a b -> ReifiedGetter (a, c) (b, c) # second' :: ReifiedGetter a b -> ReifiedGetter (c, a) (c, b) #
Costrong ReifiedGetter
Instance details Defined in Control.Lens.Reified Methods unfirst :: ReifiedGetter (a, d) (b, d) -> ReifiedGetter a b # unsecond :: ReifiedGetter (d, a) (d, b) -> ReifiedGetter a b #
Sieve ReifiedGetter Identity
Instance details Defined in Control.Lens.Reified Methods sieve :: ReifiedGetter a b -> a -> Identity b #
Cosieve ReifiedGetter Identity
Instance details Defined in Control.Lens.Reified Methods cosieve :: ReifiedGetter a b -> Identity a -> b #
MonadReader s (ReifiedGetter s)
Instance details Defined in Control.Lens.Reified Methods ask :: ReifiedGetter s s # local :: (s -> s) -> ReifiedGetter s a -> ReifiedGetter s a # reader :: (s -> a) -> ReifiedGetter s a #
Monad (ReifiedGetter s)
Instance details Defined in Control.Lens.Reified Methods (>>=) :: ReifiedGetter s a -> (a -> ReifiedGetter s b) -> ReifiedGetter s b # (>>) :: ReifiedGetter s a -> ReifiedGetter s b -> ReifiedGetter s b # return :: a -> ReifiedGetter s a # fail :: String -> ReifiedGetter s a #
Functor (ReifiedGetter s)
Instance details Defined in Control.Lens.Reified Methods fmap :: (a -> b) -> ReifiedGetter s a -> ReifiedGetter s b # (<$) :: a -> ReifiedGetter s b -> ReifiedGetter s a #
Applicative (ReifiedGetter s)
Instance details Defined in Control.Lens.Reified Methods pure :: a -> ReifiedGetter s a # (<>) :: ReifiedGetter s (a -> b) -> ReifiedGetter s a -> ReifiedGetter s b # liftA2 :: (a -> b -> c) -> ReifiedGetter s a -> ReifiedGetter s b -> ReifiedGetter s c # (>) :: ReifiedGetter s a -> ReifiedGetter s b -> ReifiedGetter s b # (<*) :: ReifiedGetter s a -> ReifiedGetter s b -> ReifiedGetter s a #
Distributive (ReifiedGetter s)
Instance details Defined in Control.Lens.Reified Methods distribute :: Functor f => f (ReifiedGetter s a) -> ReifiedGetter s (f a) # collect :: Functor f => (a -> ReifiedGetter s b) -> f a -> ReifiedGetter s (f b) # distributeM :: Monad m => m (ReifiedGetter s a) -> ReifiedGetter s (m a) # collectM :: Monad m => (a -> ReifiedGetter s b) -> m a -> ReifiedGetter s (m b) #
Monoid s => Comonad (ReifiedGetter s)
Instance details Defined in Control.Lens.Reified Methods extract :: ReifiedGetter s a -> a # duplicate :: ReifiedGetter s a -> ReifiedGetter s (ReifiedGetter s a) # extend :: (ReifiedGetter s a -> b) -> ReifiedGetter s a -> ReifiedGetter s b #
Monoid s => ComonadApply (ReifiedGetter s)
Instance details Defined in Control.Lens.Reified Methods (<@>) :: ReifiedGetter s (a -> b) -> ReifiedGetter s a -> ReifiedGetter s b # (@>) :: ReifiedGetter s a -> ReifiedGetter s b -> ReifiedGetter s b # (<@) :: ReifiedGetter s a -> ReifiedGetter s b -> ReifiedGetter s a #
Apply (ReifiedGetter s)
Instance details Defined in Control.Lens.Reified Methods (<.>) :: ReifiedGetter s (a -> b) -> ReifiedGetter s a -> ReifiedGetter s b # (.>) :: ReifiedGetter s a -> ReifiedGetter s b -> ReifiedGetter s b # (<.) :: ReifiedGetter s a -> ReifiedGetter s b -> ReifiedGetter s a # liftF2 :: (a -> b -> c) -> ReifiedGetter s a -> ReifiedGetter s b -> ReifiedGetter s c #
Bind (ReifiedGetter s)
Instance details Defined in Control.Lens.Reified Methods (>>-) :: ReifiedGetter s a -> (a -> ReifiedGetter s b) -> ReifiedGetter s b # join :: ReifiedGetter s (ReifiedGetter s a) -> ReifiedGetter s a #
Semigroup s => Extend (ReifiedGetter s)
Instance details Defined in Control.Lens.Reified Methods duplicated :: ReifiedGetter s a -> ReifiedGetter s (ReifiedGetter s a) # extended :: (ReifiedGetter s a -> b) -> ReifiedGetter s a -> ReifiedGetter s b #
Category ReifiedGetter
Instance details Defined in Control.Lens.Reified Methods id :: ReifiedGetter a a # (.) :: ReifiedGetter b c -> ReifiedGetter a b -> ReifiedGetter a c #
type Rep ReifiedGetter
Instance details Defined in Control.Lens.Reified type Rep ReifiedGetter = Identity
type Corep ReifiedGetter
Instance details Defined in Control.Lens.Reified type Corep ReifiedGetter = Identity

newtype ReifiedIndexedGetter i s a #

Reify an ReifiedIndexedGetter so it can be stored safely in a container.

Constructors

IndexedGetter
Fields runIndexedGetter :: IndexedGetter i s a

Instances

Profunctor (ReifiedIndexedGetter i)
Instance details Defined in Control.Lens.Reified Methods dimap :: (a -> b) -> (c -> d) -> ReifiedIndexedGetter i b c -> ReifiedIndexedGetter i a d # lmap :: (a -> b) -> ReifiedIndexedGetter i b c -> ReifiedIndexedGetter i a c # rmap :: (b -> c) -> ReifiedIndexedGetter i a b -> ReifiedIndexedGetter i a c # (#.) :: Coercible c b => q b c -> ReifiedIndexedGetter i a b -> ReifiedIndexedGetter i a c # (.#) :: Coercible b a => ReifiedIndexedGetter i b c -> q a b -> ReifiedIndexedGetter i a c #
Representable (ReifiedIndexedGetter i)
Instance details Defined in Control.Lens.Reified Associated Types type Rep (ReifiedIndexedGetter i) :: Type -> Type # Methods tabulate :: (d -> Rep (ReifiedIndexedGetter i) c) -> ReifiedIndexedGetter i d c #
Strong (ReifiedIndexedGetter i)
Instance details Defined in Control.Lens.Reified Methods first' :: ReifiedIndexedGetter i a b -> ReifiedIndexedGetter i (a, c) (b, c) # second' :: ReifiedIndexedGetter i a b -> ReifiedIndexedGetter i (c, a) (c, b) #
Sieve (ReifiedIndexedGetter i) ((,) i)
Instance details Defined in Control.Lens.Reified Methods sieve :: ReifiedIndexedGetter i a b -> a -> (i, b) #
Functor (ReifiedIndexedGetter i s)
Instance details Defined in Control.Lens.Reified Methods fmap :: (a -> b) -> ReifiedIndexedGetter i s a -> ReifiedIndexedGetter i s b # (<$) :: a -> ReifiedIndexedGetter i s b -> ReifiedIndexedGetter i s a #
Semigroup i => Apply (ReifiedIndexedGetter i s)
Instance details Defined in Control.Lens.Reified Methods (<.>) :: ReifiedIndexedGetter i s (a -> b) -> ReifiedIndexedGetter i s a -> ReifiedIndexedGetter i s b # (.>) :: ReifiedIndexedGetter i s a -> ReifiedIndexedGetter i s b -> ReifiedIndexedGetter i s b # (<.) :: ReifiedIndexedGetter i s a -> ReifiedIndexedGetter i s b -> ReifiedIndexedGetter i s a # liftF2 :: (a -> b -> c) -> ReifiedIndexedGetter i s a -> ReifiedIndexedGetter i s b -> ReifiedIndexedGetter i s c #
type Rep (ReifiedIndexedGetter i)
Instance details Defined in Control.Lens.Reified type Rep (ReifiedIndexedGetter i) = (,) i

newtype ReifiedFold s a #

Reify a ReifiedFold so it can be stored safely in a container.

This can also be useful for creatively combining folds as ReifiedFold s is isomorphic to ReaderT s [] and provides similar instances.

>>> ("hello","world")^..runFold ((,) <$> Fold _2 <*> Fold both)
[("world","hello"),("world","world")]

Constructors

Fold
Fields runFold :: Fold s a

Instances

Arrow ReifiedFold
Instance details Defined in Control.Lens.Reified Methods arr :: (b -> c) -> ReifiedFold b c # first :: ReifiedFold b c -> ReifiedFold (b, d) (c, d) # second :: ReifiedFold b c -> ReifiedFold (d, b) (d, c) # (***) :: ReifiedFold b c -> ReifiedFold b' c' -> ReifiedFold (b, b') (c, c') # (&&&) :: ReifiedFold b c -> ReifiedFold b c' -> ReifiedFold b (c, c') #
ArrowChoice ReifiedFold
Instance details Defined in Control.Lens.Reified Methods left :: ReifiedFold b c -> ReifiedFold (Either b d) (Either c d) # right :: ReifiedFold b c -> ReifiedFold (Either d b) (Either d c) # (+++) :: ReifiedFold b c -> ReifiedFold b' c' -> ReifiedFold (Either b b') (Either c c') # (\|\|\|) :: ReifiedFold b d -> ReifiedFold c d -> ReifiedFold (Either b c) d #
ArrowApply ReifiedFold
Instance details Defined in Control.Lens.Reified Methods app :: ReifiedFold (ReifiedFold b c, b) c #
Profunctor ReifiedFold
Instance details Defined in Control.Lens.Reified Methods dimap :: (a -> b) -> (c -> d) -> ReifiedFold b c -> ReifiedFold a d # lmap :: (a -> b) -> ReifiedFold b c -> ReifiedFold a c # rmap :: (b -> c) -> ReifiedFold a b -> ReifiedFold a c # (#.) :: Coercible c b => q b c -> ReifiedFold a b -> ReifiedFold a c # (.#) :: Coercible b a => ReifiedFold b c -> q a b -> ReifiedFold a c #
Representable ReifiedFold
Instance details Defined in Control.Lens.Reified Associated Types type Rep ReifiedFold :: Type -> Type # Methods tabulate :: (d -> Rep ReifiedFold c) -> ReifiedFold d c #
Choice ReifiedFold
Instance details Defined in Control.Lens.Reified Methods left' :: ReifiedFold a b -> ReifiedFold (Either a c) (Either b c) # right' :: ReifiedFold a b -> ReifiedFold (Either c a) (Either c b) #
Strong ReifiedFold
Instance details Defined in Control.Lens.Reified Methods first' :: ReifiedFold a b -> ReifiedFold (a, c) (b, c) # second' :: ReifiedFold a b -> ReifiedFold (c, a) (c, b) #
Sieve ReifiedFold []
Instance details Defined in Control.Lens.Reified Methods sieve :: ReifiedFold a b -> a -> [b] #
MonadReader s (ReifiedFold s)
Instance details Defined in Control.Lens.Reified Methods ask :: ReifiedFold s s # local :: (s -> s) -> ReifiedFold s a -> ReifiedFold s a # reader :: (s -> a) -> ReifiedFold s a #
Monad (ReifiedFold s)
Instance details Defined in Control.Lens.Reified Methods (>>=) :: ReifiedFold s a -> (a -> ReifiedFold s b) -> ReifiedFold s b # (>>) :: ReifiedFold s a -> ReifiedFold s b -> ReifiedFold s b # return :: a -> ReifiedFold s a # fail :: String -> ReifiedFold s a #
Functor (ReifiedFold s)
Instance details Defined in Control.Lens.Reified Methods fmap :: (a -> b) -> ReifiedFold s a -> ReifiedFold s b # (<$) :: a -> ReifiedFold s b -> ReifiedFold s a #
Applicative (ReifiedFold s)
Instance details Defined in Control.Lens.Reified Methods pure :: a -> ReifiedFold s a # (<>) :: ReifiedFold s (a -> b) -> ReifiedFold s a -> ReifiedFold s b # liftA2 :: (a -> b -> c) -> ReifiedFold s a -> ReifiedFold s b -> ReifiedFold s c # (>) :: ReifiedFold s a -> ReifiedFold s b -> ReifiedFold s b # (<*) :: ReifiedFold s a -> ReifiedFold s b -> ReifiedFold s a #
MonadPlus (ReifiedFold s)
Instance details Defined in Control.Lens.Reified Methods mzero :: ReifiedFold s a # mplus :: ReifiedFold s a -> ReifiedFold s a -> ReifiedFold s a #
Alternative (ReifiedFold s)
Instance details Defined in Control.Lens.Reified Methods empty :: ReifiedFold s a # (<\|>) :: ReifiedFold s a -> ReifiedFold s a -> ReifiedFold s a # some :: ReifiedFold s a -> ReifiedFold s [a] # many :: ReifiedFold s a -> ReifiedFold s [a] #
Apply (ReifiedFold s)
Instance details Defined in Control.Lens.Reified Methods (<.>) :: ReifiedFold s (a -> b) -> ReifiedFold s a -> ReifiedFold s b # (.>) :: ReifiedFold s a -> ReifiedFold s b -> ReifiedFold s b # (<.) :: ReifiedFold s a -> ReifiedFold s b -> ReifiedFold s a # liftF2 :: (a -> b -> c) -> ReifiedFold s a -> ReifiedFold s b -> ReifiedFold s c #
Plus (ReifiedFold s)
Instance details Defined in Control.Lens.Reified Methods zero :: ReifiedFold s a #
Alt (ReifiedFold s)
Instance details Defined in Control.Lens.Reified Methods (<!>) :: ReifiedFold s a -> ReifiedFold s a -> ReifiedFold s a # some :: Applicative (ReifiedFold s) => ReifiedFold s a -> ReifiedFold s [a] # many :: Applicative (ReifiedFold s) => ReifiedFold s a -> ReifiedFold s [a] #
Bind (ReifiedFold s)
Instance details Defined in Control.Lens.Reified Methods (>>-) :: ReifiedFold s a -> (a -> ReifiedFold s b) -> ReifiedFold s b # join :: ReifiedFold s (ReifiedFold s a) -> ReifiedFold s a #
Category ReifiedFold
Instance details Defined in Control.Lens.Reified Methods id :: ReifiedFold a a # (.) :: ReifiedFold b c -> ReifiedFold a b -> ReifiedFold a c #
Semigroup (ReifiedFold s a)
Instance details Defined in Control.Lens.Reified Methods (<>) :: ReifiedFold s a -> ReifiedFold s a -> ReifiedFold s a # sconcat :: NonEmpty (ReifiedFold s a) -> ReifiedFold s a # stimes :: Integral b => b -> ReifiedFold s a -> ReifiedFold s a #
Monoid (ReifiedFold s a)
Instance details Defined in Control.Lens.Reified Methods mempty :: ReifiedFold s a # mappend :: ReifiedFold s a -> ReifiedFold s a -> ReifiedFold s a # mconcat :: [ReifiedFold s a] -> ReifiedFold s a #
type Rep ReifiedFold
Instance details Defined in Control.Lens.Reified type Rep ReifiedFold = []

newtype ReifiedIndexedFold i s a #

Constructors

IndexedFold
Fields runIndexedFold :: IndexedFold i s a

Instances

Profunctor (ReifiedIndexedFold i)
Instance details Defined in Control.Lens.Reified Methods dimap :: (a -> b) -> (c -> d) -> ReifiedIndexedFold i b c -> ReifiedIndexedFold i a d # lmap :: (a -> b) -> ReifiedIndexedFold i b c -> ReifiedIndexedFold i a c # rmap :: (b -> c) -> ReifiedIndexedFold i a b -> ReifiedIndexedFold i a c # (#.) :: Coercible c b => q b c -> ReifiedIndexedFold i a b -> ReifiedIndexedFold i a c # (.#) :: Coercible b a => ReifiedIndexedFold i b c -> q a b -> ReifiedIndexedFold i a c #
Representable (ReifiedIndexedFold i)
Instance details Defined in Control.Lens.Reified Associated Types type Rep (ReifiedIndexedFold i) :: Type -> Type # Methods tabulate :: (d -> Rep (ReifiedIndexedFold i) c) -> ReifiedIndexedFold i d c #
Strong (ReifiedIndexedFold i)
Instance details Defined in Control.Lens.Reified Methods first' :: ReifiedIndexedFold i a b -> ReifiedIndexedFold i (a, c) (b, c) # second' :: ReifiedIndexedFold i a b -> ReifiedIndexedFold i (c, a) (c, b) #
Sieve (ReifiedIndexedFold i) (Compose [] ((,) i))
Instance details Defined in Control.Lens.Reified Methods sieve :: ReifiedIndexedFold i a b -> a -> Compose [] ((,) i) b #
Functor (ReifiedIndexedFold i s)
Instance details Defined in Control.Lens.Reified Methods fmap :: (a -> b) -> ReifiedIndexedFold i s a -> ReifiedIndexedFold i s b # (<$) :: a -> ReifiedIndexedFold i s b -> ReifiedIndexedFold i s a #
Plus (ReifiedIndexedFold i s)
Instance details Defined in Control.Lens.Reified Methods zero :: ReifiedIndexedFold i s a #
Alt (ReifiedIndexedFold i s)
Instance details Defined in Control.Lens.Reified Methods (<!>) :: ReifiedIndexedFold i s a -> ReifiedIndexedFold i s a -> ReifiedIndexedFold i s a # some :: Applicative (ReifiedIndexedFold i s) => ReifiedIndexedFold i s a -> ReifiedIndexedFold i s [a] # many :: Applicative (ReifiedIndexedFold i s) => ReifiedIndexedFold i s a -> ReifiedIndexedFold i s [a] #
Semigroup (ReifiedIndexedFold i s a)
Instance details Defined in Control.Lens.Reified Methods (<>) :: ReifiedIndexedFold i s a -> ReifiedIndexedFold i s a -> ReifiedIndexedFold i s a # sconcat :: NonEmpty (ReifiedIndexedFold i s a) -> ReifiedIndexedFold i s a # stimes :: Integral b => b -> ReifiedIndexedFold i s a -> ReifiedIndexedFold i s a #
Monoid (ReifiedIndexedFold i s a)
Instance details Defined in Control.Lens.Reified Methods mempty :: ReifiedIndexedFold i s a # mappend :: ReifiedIndexedFold i s a -> ReifiedIndexedFold i s a -> ReifiedIndexedFold i s a # mconcat :: [ReifiedIndexedFold i s a] -> ReifiedIndexedFold i s a #
type Rep (ReifiedIndexedFold i)
Instance details Defined in Control.Lens.Reified type Rep (ReifiedIndexedFold i) = Compose [] ((,) i)

newtype ReifiedSetter s t a b #

Reify a ReifiedSetter so it can be stored safely in a container.

Constructors

Setter
Fields runSetter :: Setter s t a b

type ReifiedSetter' s a = ReifiedSetter s s a a #

type ReifiedSetter' = Simple ReifiedSetter

newtype ReifiedIndexedSetter i s t a b #

Reify an ReifiedIndexedSetter so it can be stored safely in a container.

Constructors

IndexedSetter
Fields runIndexedSetter :: IndexedSetter i s t a b

type ReifiedIndexedSetter' i s a = ReifiedIndexedSetter i s s a a #

type ReifiedIndexedSetter' i = Simple (ReifiedIndexedSetter i)

newtype ReifiedIso s t a b #

Reify an ReifiedIso so it can be stored safely in a container.

Constructors

Iso
Fields runIso :: Iso s t a b

type ReifiedIso' s a = ReifiedIso s s a a #

type ReifiedIso' = Simple ReifiedIso

newtype ReifiedPrism s t a b #

Reify a ReifiedPrism so it can be stored safely in a container.

Constructors

Prism
Fields runPrism :: Prism s t a b

type ReifiedPrism' s a = ReifiedPrism s s a a #

type ReifiedPrism' = Simple ReifiedPrism

ilevels :: Applicative f => Traversing (Indexed i) f s t a b -> IndexedLensLike Int f s t (Level i a) (Level j b) #

This provides a breadth-first Traversal or Fold of the individual levels of any other Traversal or Fold via iterative deepening depth-first search. The levels are returned to you in a compressed format.

This is similar to levels, but retains the index of the original IndexedTraversal, so you can access it when traversing the levels later on.

>>> ["dog","cat"]^@..ilevels (traversed<.>traversed).itraversed
[((0,0),'d'),((0,1),'o'),((1,0),'c'),((0,2),'g'),((1,1),'a'),((1,2),'t')]

The resulting Traversal of the levels which is indexed by the depth of each Level.

>>> ["dog","cat"]^@..ilevels (traversed<.>traversed)<.>itraversed
[((2,(0,0)),'d'),((3,(0,1)),'o'),((3,(1,0)),'c'),((4,(0,2)),'g'),((4,(1,1)),'a'),((5,(1,2)),'t')]

ilevels :: IndexedTraversal i s t a b      -> IndexedTraversal Int s t (Level i a) (Level i b)
ilevels :: IndexedFold i s a               -> IndexedFold Int s (Level i a)

Note: Internally this is implemented by using an illegal Applicative, as it extracts information in an order that violates the Applicative laws.

levels :: Applicative f => Traversing ((->) :: Type -> Type -> Type) f s t a b -> IndexedLensLike Int f s t (Level () a) (Level () b) #

This provides a breadth-first Traversal or Fold of the individual levels of any other Traversal or Fold via iterative deepening depth-first search. The levels are returned to you in a compressed format.

This can permit us to extract the levels directly:

>>> ["hello","world"]^..levels (traverse.traverse)
[Zero,Zero,One () 'h',Two 0 (One () 'e') (One () 'w'),Two 0 (One () 'l') (One () 'o'),Two 0 (One () 'l') (One () 'r'),Two 0 (One () 'o') (One () 'l'),One () 'd']

But we can also traverse them in turn:

>>> ["hello","world"]^..levels (traverse.traverse).traverse
"hewlolrold"

We can use this to traverse to a fixed depth in the tree of (<*>) used in the Traversal:

>>> ["hello","world"] & taking 4 (levels (traverse.traverse)).traverse %~ toUpper
["HEllo","World"]

Or we can use it to traverse the first n elements in found in that Traversal regardless of the depth at which they were found.

>>> ["hello","world"] & taking 4 (levels (traverse.traverse).traverse) %~ toUpper
["HELlo","World"]

The resulting Traversal of the levels which is indexed by the depth of each Level.

>>> ["dog","cat"]^@..levels (traverse.traverse) <. traverse
[(2,'d'),(3,'o'),(3,'c'),(4,'g'),(4,'a'),(5,'t')]

levels :: Traversal s t a b      -> IndexedTraversal Int s t (Level () a) (Level () b)
levels :: Fold s a               -> IndexedFold Int s (Level () a)

Note: Internally this is implemented by using an illegal Applicative, as it extracts information in an order that violates the Applicative laws.

sequenceByOf :: Traversal s t (f b) b -> (forall x. x -> f x) -> (forall x y. f (x -> y) -> f x -> f y) -> s -> f t #

Sequence a container using a specified Applicative.

This is like traverseBy where the Traversable instance can be specified by any Traversal

sequenceByOf traverse ≡ sequenceBy

traverseByOf :: Traversal s t a b -> (forall x. x -> f x) -> (forall x y. f (x -> y) -> f x -> f y) -> (a -> f b) -> s -> f t #

Traverse a container using a specified Applicative.

This is like traverseBy where the Traversable instance can be specified by any Traversal

traverseByOf traverse ≡ traverseBy

confusing :: Applicative f => LensLike (Curried (Yoneda f) (Yoneda f)) s t a b -> LensLike f s t a b #

Fuse a Traversal by reassociating all of the (<*>) operations to the left and fusing all of the fmap calls into one. This is particularly useful when constructing a Traversal using operations from GHC.Generics.

Given a pair of Traversals foo and bar,

confusing (foo.bar) = foo.bar

However, foo and bar are each going to use the Applicative they are given.

confusing exploits the Yoneda lemma to merge their separate uses of fmap into a single fmap. and it further exploits an interesting property of the right Kan lift (or Curried) to left associate all of the uses of (<*>) to make it possible to fuse together more fmaps.

This is particularly effective when the choice of functor f is unknown at compile time or when the Traversal foo.bar in the above description is recursive or complex enough to prevent inlining.

fusing is a version of this combinator suitable for fusing lenses.

confusing :: Traversal s t a b -> Traversal s t a b

deepOf :: (Conjoined p, Applicative f) => LensLike f s t s t -> Traversing p f s t a b -> Over p f s t a b #

Try the second traversal. If it returns no entries, try again with all entries from the first traversal, recursively.

deepOf :: Fold s s          -> Fold s a                   -> Fold s a
deepOf :: Traversal' s s    -> Traversal' s a             -> Traversal' s a
deepOf :: Traversal s t s t -> Traversal s t a b          -> Traversal s t a b
deepOf :: Fold s s          -> IndexedFold i s a          -> IndexedFold i s a
deepOf :: Traversal s t s t -> IndexedTraversal i s t a b -> IndexedTraversal i s t a b

failing :: (Conjoined p, Applicative f) => Traversing p f s t a b -> Over p f s t a b -> Over p f s t a b infixl 5 #

Try the first Traversal (or Fold), falling back on the second Traversal (or Fold) if it returns no entries.

This is only a valid Traversal if the second Traversal is disjoint from the result of the first or returns exactly the same results. These conditions are trivially met when given a Lens, Iso, Getter, Prism or "affine" Traversal -- one that has 0 or 1 target.

Mutatis mutandis for Fold.

>>> [0,1,2,3] ^? failing (ix 1) (ix 2)
Just 1

>>> [0,1,2,3] ^? failing (ix 42) (ix 2)
Just 2

failing :: Traversal s t a b -> Traversal s t a b -> Traversal s t a b
failing :: Prism s t a b     -> Prism s t a b     -> Traversal s t a b
failing :: Fold s a          -> Fold s a          -> Fold s a

These cases are also supported, trivially, but are boring, because the left hand side always succeeds.

failing :: Lens s t a b      -> Traversal s t a b -> Traversal s t a b
failing :: Iso s t a b       -> Traversal s t a b -> Traversal s t a b
failing :: Equality s t a b  -> Traversal s t a b -> Traversal s t a b
failing :: Getter s a        -> Fold s a          -> Fold s a

If both of the inputs are indexed, the result is also indexed, so you can apply this to a pair of indexed traversals or indexed folds, obtaining an indexed traversal or indexed fold.

failing :: IndexedTraversal i s t a b -> IndexedTraversal i s t a b -> IndexedTraversal i s t a b
failing :: IndexedFold i s a          -> IndexedFold i s a          -> IndexedFold i s a

These cases are also supported, trivially, but are boring, because the left hand side always succeeds.

failing :: IndexedLens i s t a b      -> IndexedTraversal i s t a b -> IndexedTraversal i s t a b
failing :: IndexedGetter i s a        -> IndexedGetter i s a        -> IndexedFold i s a

ifailover :: Alternative m => Over (Indexed i) ((,) Any) s t a b -> (i -> a -> b) -> s -> m t #

Try to map a function which uses the index over this IndexedTraversal, failing if the IndexedTraversal has no targets.

ifailover :: Alternative m => IndexedTraversal i s t a b -> (i -> a -> b) -> s -> m t

failover :: Alternative m => LensLike ((,) Any) s t a b -> (a -> b) -> s -> m t #

Try to map a function over this Traversal, failing if the Traversal has no targets.

>>> failover (element 3) (*2) [1,2] :: Maybe [Int]
Nothing

>>> failover _Left (*2) (Right 4) :: Maybe (Either Int Int)
Nothing

>>> failover _Right (*2) (Right 4) :: Maybe (Either Int Int)
Just (Right 8)

failover :: Alternative m => Traversal s t a b -> (a -> b) -> s -> m t

elements :: Traversable t => (Int -> Bool) -> IndexedTraversal' Int (t a) a #

Traverse elements of a Traversable container where their ordinal positions match a predicate.

elements ≡ elementsOf traverse

elementsOf :: Applicative f => LensLike (Indexing f) s t a a -> (Int -> Bool) -> IndexedLensLike Int f s t a a #

Traverse (or fold) selected elements of a Traversal (or Fold) where their ordinal positions match a predicate.

elementsOf :: Traversal' s a -> (Int -> Bool) -> IndexedTraversal' Int s a
elementsOf :: Fold s a       -> (Int -> Bool) -> IndexedFold Int s a

element :: Traversable t => Int -> IndexedTraversal' Int (t a) a #

Traverse the nth element of a Traversable container.

element ≡ elementOf traverse

elementOf :: Applicative f => LensLike (Indexing f) s t a a -> Int -> IndexedLensLike Int f s t a a #

Traverse the nth elementOf a Traversal, Lens or Iso if it exists.

>>> [[1],[3,4]] & elementOf (traverse.traverse) 1 .~ 5
[[1],[5,4]]

>>> [[1],[3,4]] ^? elementOf (folded.folded) 1
Just 3

>>> timingOut $ ['a'..] ^?! elementOf folded 5
'f'

>>> timingOut $ take 10 $ elementOf traverse 3 .~ 16 $ [0..]
[0,1,2,16,4,5,6,7,8,9]

elementOf :: Traversal' s a -> Int -> IndexedTraversal' Int s a
elementOf :: Fold s a       -> Int -> IndexedFold Int s a

ignored :: Applicative f => pafb -> s -> f s #

This is the trivial empty Traversal.

ignored :: IndexedTraversal i s s a b

ignored ≡ const pure

>>> 6 & ignored %~ absurd
6

traversed64 :: Traversable f => IndexedTraversal Int64 (f a) (f b) a b #

Traverse any Traversable container. This is an IndexedTraversal that is indexed by ordinal position.

traversed1 :: Traversable1 f => IndexedTraversal1 Int (f a) (f b) a b #

Traverse any Traversable1 container. This is an IndexedTraversal1 that is indexed by ordinal position.

traversed :: Traversable f => IndexedTraversal Int (f a) (f b) a b #

Traverse any Traversable container. This is an IndexedTraversal that is indexed by ordinal position.

imapAccumLOf :: Over (Indexed i) (State acc) s t a b -> (i -> acc -> a -> (acc, b)) -> acc -> s -> (acc, t) #

Generalizes mapAccumL to an arbitrary IndexedTraversal with access to the index.

imapAccumLOf accumulates state from left to right.

mapAccumLOf l ≡ imapAccumLOf l . const

imapAccumLOf :: IndexedLens i s t a b      -> (i -> acc -> a -> (acc, b)) -> acc -> s -> (acc, t)
imapAccumLOf :: IndexedTraversal i s t a b -> (i -> acc -> a -> (acc, b)) -> acc -> s -> (acc, t)

imapAccumROf :: Over (Indexed i) (Backwards (State acc)) s t a b -> (i -> acc -> a -> (acc, b)) -> acc -> s -> (acc, t) #

Generalizes mapAccumR to an arbitrary IndexedTraversal with access to the index.

imapAccumROf accumulates state from right to left.

mapAccumROf l ≡ imapAccumROf l . const

imapAccumROf :: IndexedLens i s t a b      -> (i -> acc -> a -> (acc, b)) -> acc -> s -> (acc, t)
imapAccumROf :: IndexedTraversal i s t a b -> (i -> acc -> a -> (acc, b)) -> acc -> s -> (acc, t)

iforMOf :: (Indexed i a (WrappedMonad m b) -> s -> WrappedMonad m t) -> s -> (i -> a -> m b) -> m t #

Map each element of a structure targeted by a Lens to a monadic action, evaluate these actions from left to right, and collect the results, with access its position (and the arguments flipped).

forMOf l a ≡ iforMOf l a . const
iforMOf ≡ flip . imapMOf

iforMOf :: Monad m => IndexedLens i s t a b      -> s -> (i -> a -> m b) -> m t
iforMOf :: Monad m => IndexedTraversal i s t a b -> s -> (i -> a -> m b) -> m t

imapMOf :: Over (Indexed i) (WrappedMonad m) s t a b -> (i -> a -> m b) -> s -> m t #

Map each element of a structure targeted by a Lens to a monadic action, evaluate these actions from left to right, and collect the results, with access its position.

When you don't need access to the index mapMOf is more liberal in what it can accept.

mapMOf l ≡ imapMOf l . const

imapMOf :: Monad m => IndexedLens       i s t a b -> (i -> a -> m b) -> s -> m t
imapMOf :: Monad m => IndexedTraversal  i s t a b -> (i -> a -> m b) -> s -> m t
imapMOf :: Bind  m => IndexedTraversal1 i s t a b -> (i -> a -> m b) -> s -> m t

iforOf :: (Indexed i a (f b) -> s -> f t) -> s -> (i -> a -> f b) -> f t #

Traverse with an index (and the arguments flipped).

forOf l a ≡ iforOf l a . const
iforOf ≡ flip . itraverseOf

iforOf :: Functor f     => IndexedLens i s t a b       -> s -> (i -> a -> f b) -> f t
iforOf :: Applicative f => IndexedTraversal i s t a b  -> s -> (i -> a -> f b) -> f t
iforOf :: Apply f       => IndexedTraversal1 i s t a b -> s -> (i -> a -> f b) -> f t

itraverseOf :: (Indexed i a (f b) -> s -> f t) -> (i -> a -> f b) -> s -> f t #

Traversal with an index.

NB: When you don't need access to the index then you can just apply your IndexedTraversal directly as a function!

itraverseOf ≡ withIndex
traverseOf l = itraverseOf l . const = id

itraverseOf :: Functor f     => IndexedLens i s t a b       -> (i -> a -> f b) -> s -> f t
itraverseOf :: Applicative f => IndexedTraversal i s t a b  -> (i -> a -> f b) -> s -> f t
itraverseOf :: Apply f       => IndexedTraversal1 i s t a b -> (i -> a -> f b) -> s -> f t

cloneIndexedTraversal1 :: AnIndexedTraversal1 i s t a b -> IndexedTraversal1 i s t a b #

Clone an IndexedTraversal1 yielding an IndexedTraversal1 with the same index.

cloneIndexPreservingTraversal1 :: ATraversal1 s t a b -> IndexPreservingTraversal1 s t a b #

Clone a Traversal1 yielding an IndexPreservingTraversal1 that passes through whatever index it is composed with.

cloneTraversal1 :: ATraversal1 s t a b -> Traversal1 s t a b #

A Traversal1 is completely characterized by its behavior on a Bazaar1.

cloneIndexedTraversal :: AnIndexedTraversal i s t a b -> IndexedTraversal i s t a b #

Clone an IndexedTraversal yielding an IndexedTraversal with the same index.

cloneIndexPreservingTraversal :: ATraversal s t a b -> IndexPreservingTraversal s t a b #

Clone a Traversal yielding an IndexPreservingTraversal that passes through whatever index it is composed with.

cloneTraversal :: ATraversal s t a b -> Traversal s t a b #

A Traversal is completely characterized by its behavior on a Bazaar.

Cloning a Traversal is one way to make sure you aren't given something weaker, such as a Fold and can be used as a way to pass around traversals that have to be monomorphic in f.

Note: This only accepts a proper Traversal (or Lens). To clone a Lens as such, use cloneLens.

Note: It is usually better to use ReifiedTraversal and runTraversal than to cloneTraversal. The former can execute at full speed, while the latter needs to round trip through the Bazaar.

>>> let foo l a = (view (getting (cloneTraversal l)) a, set (cloneTraversal l) 10 a)
>>> foo both ("hello","world")
("helloworld",(10,10))

cloneTraversal :: LensLike (Bazaar (->) a b) s t a b -> Traversal s t a b

dropping :: (Conjoined p, Applicative f) => Int -> Over p (Indexing f) s t a a -> Over p f s t a a #

Visit all but the first n targets of a Traversal, Fold, Getter or Lens.

>>> ("hello","world") ^? dropping 1 both
Just "world"

Dropping works on infinite traversals as well:

>>> [1..] ^? dropping 1 folded
Just 2

dropping :: Int -> Traversal' s a                   -> Traversal' s a
dropping :: Int -> Lens' s a                        -> Traversal' s a
dropping :: Int -> Iso' s a                         -> Traversal' s a
dropping :: Int -> Prism' s a                       -> Traversal' s a
dropping :: Int -> Getter s a                       -> Fold s a
dropping :: Int -> Fold s a                         -> Fold s a
dropping :: Int -> IndexedTraversal' i s a          -> IndexedTraversal' i s a
dropping :: Int -> IndexedLens' i s a               -> IndexedTraversal' i s a
dropping :: Int -> IndexedGetter i s a              -> IndexedFold i s a
dropping :: Int -> IndexedFold i s a                -> IndexedFold i s a

taking :: (Conjoined p, Applicative f) => Int -> Traversing p f s t a a -> Over p f s t a a #

Visit the first n targets of a Traversal, Fold, Getter or Lens.

>>> [("hello","world"),("!!!","!!!")]^.. taking 2 (traverse.both)
["hello","world"]

>>> timingOut $ [1..] ^.. taking 3 traverse
[1,2,3]

>>> over (taking 5 traverse) succ "hello world"
"ifmmp world"

taking :: Int -> Traversal' s a                   -> Traversal' s a
taking :: Int -> Lens' s a                        -> Traversal' s a
taking :: Int -> Iso' s a                         -> Traversal' s a
taking :: Int -> Prism' s a                       -> Traversal' s a
taking :: Int -> Getter s a                       -> Fold s a
taking :: Int -> Fold s a                         -> Fold s a
taking :: Int -> IndexedTraversal' i s a          -> IndexedTraversal' i s a
taking :: Int -> IndexedLens' i s a               -> IndexedTraversal' i s a
taking :: Int -> IndexedGetter i s a              -> IndexedFold i s a
taking :: Int -> IndexedFold i s a                -> IndexedFold i s a

beside :: (Representable q, Applicative (Rep q), Applicative f, Bitraversable r) => Optical p q f s t a b -> Optical p q f s' t' a b -> Optical p q f (r s s') (r t t') a b #

Apply a different Traversal or Fold to each side of a Bitraversable container.

beside :: Traversal s t a b                -> Traversal s' t' a b                -> Traversal (r s s') (r t t') a b
beside :: IndexedTraversal i s t a b       -> IndexedTraversal i s' t' a b       -> IndexedTraversal i (r s s') (r t t') a b
beside :: IndexPreservingTraversal s t a b -> IndexPreservingTraversal s' t' a b -> IndexPreservingTraversal (r s s') (r t t') a b

beside :: Traversal s t a b                -> Traversal s' t' a b                -> Traversal (s,s') (t,t') a b
beside :: Lens s t a b                     -> Lens s' t' a b                     -> Traversal (s,s') (t,t') a b
beside :: Fold s a                         -> Fold s' a                          -> Fold (s,s') a
beside :: Getter s a                       -> Getter s' a                        -> Fold (s,s') a

beside :: IndexedTraversal i s t a b       -> IndexedTraversal i s' t' a b       -> IndexedTraversal i (s,s') (t,t') a b
beside :: IndexedLens i s t a b            -> IndexedLens i s' t' a b            -> IndexedTraversal i (s,s') (t,t') a b
beside :: IndexedFold i s a                -> IndexedFold i s' a                 -> IndexedFold i (s,s') a
beside :: IndexedGetter i s a              -> IndexedGetter i s' a               -> IndexedFold i (s,s') a

beside :: IndexPreservingTraversal s t a b -> IndexPreservingTraversal s' t' a b -> IndexPreservingTraversal (s,s') (t,t') a b
beside :: IndexPreservingLens s t a b      -> IndexPreservingLens s' t' a b      -> IndexPreservingTraversal (s,s') (t,t') a b
beside :: IndexPreservingFold s a          -> IndexPreservingFold s' a           -> IndexPreservingFold (s,s') a
beside :: IndexPreservingGetter s a        -> IndexPreservingGetter s' a         -> IndexPreservingFold (s,s') a

>>> ("hello",["world","!!!"])^..beside id traverse
["hello","world","!!!"]

both1 :: Bitraversable1 r => Traversal1 (r a a) (r b b) a b #

Traverse both parts of a Bitraversable1 container with matching types.

Usually that type will be a pair.

both1 :: Traversal1 (a, a)       (b, b)       a b
both1 :: Traversal1 (Either a a) (Either b b) a b

both :: Bitraversable r => Traversal (r a a) (r b b) a b #

Traverse both parts of a Bitraversable container with matching types.

Usually that type will be a pair. Use each to traverse the elements of arbitrary homogeneous tuples.

>>> (1,2) & both *~ 10
(10,20)

>>> over both length ("hello","world")
(5,5)

>>> ("hello","world")^.both
"helloworld"

both :: Traversal (a, a)       (b, b)       a b
both :: Traversal (Either a a) (Either b b) a b

holes1Of :: Conjoined p => Over p (Bazaar1 p a a) s t a a -> s -> NonEmpty (Pretext p a a t) #

The non-empty version of holesOf. This extract a non-empty list of immediate children accroding to a given Traversal1 as editable contexts.

>>> let head1 f s = runPretext (NonEmpty.head $ holes1Of traversed1 s) f
>>> ('a' :| "bc") ^. head1
'a'

>>> ('a' :| "bc") & head1 %~ toUpper
'A' :| "bc"

holes1Of :: Iso' s a                 -> s -> NonEmpty (Pretext' (->) a s)
holes1Of :: Lens' s a                -> s -> NonEmpty (Pretext' (->) a s)
holes1Of :: Traversal1' s a          -> s -> NonEmpty (Pretext' (->) a s)
holes1Of :: IndexedLens' i s a       -> s -> NonEmpty (Pretext' (Indexed i) a s)
holes1Of :: IndexedTraversal1' i s a -> s -> NonEmpty (Pretext' (Indexed i) a s)

holesOf :: Conjoined p => Over p (Bazaar p a a) s t a a -> s -> [Pretext p a a t] #

The one-level version of contextsOf. This extracts a list of the immediate children according to a given Traversal as editable contexts.

Given a context you can use pos to see the values, peek at what the structure would be like with an edited result, or simply extract the original structure.

propChildren l x = toListOf l x == map pos (holesOf l x)
propId l x = all (== x) [extract w | w <- holesOf l x]

holesOf :: Iso' s a                -> s -> [Pretext' (->) a s]
holesOf :: Lens' s a               -> s -> [Pretext' (->) a s]
holesOf :: Traversal' s a          -> s -> [Pretext' (->) a s]
holesOf :: IndexedLens' i s a      -> s -> [Pretext' (Indexed i) a s]
holesOf :: IndexedTraversal' i s a -> s -> [Pretext' (Indexed i) a s]

unsafeSingular :: (HasCallStack, Conjoined p, Functor f) => Traversing p f s t a b -> Over p f s t a b #

This converts a Traversal that you "know" will target only one element to a Lens. It can also be used to transform a Fold into a Getter.

The resulting Lens or Getter will be partial if the Traversal targets nothing or more than one element.

>>> Left (ErrorCall "unsafeSingular: empty traversal") <- try (evaluate ([] & unsafeSingular traverse .~ 0)) :: IO (Either ErrorCall [Integer])

unsafeSingular :: Traversal s t a b          -> Lens s t a b
unsafeSingular :: Fold s a                   -> Getter s a
unsafeSingular :: IndexedTraversal i s t a b -> IndexedLens i s t a b
unsafeSingular :: IndexedFold i s a          -> IndexedGetter i s a

singular :: (HasCallStack, Conjoined p, Functor f) => Traversing p f s t a a -> Over p f s t a a #

This converts a Traversal that you "know" will target one or more elements to a Lens. It can also be used to transform a non-empty Fold into a Getter.

The resulting Lens or Getter will be partial if the supplied Traversal returns no results.

>>> [1,2,3] ^. singular _head
1

>>> Left (ErrorCall "singular: empty traversal") <- try (evaluate ([] ^. singular _head)) :: IO (Either ErrorCall ())

>>> Left 4 ^. singular _Left
4

>>> [1..10] ^. singular (ix 7)
8

>>> [] & singular traverse .~ 0
[]

singular :: Traversal s t a a          -> Lens s t a a
singular :: Fold s a                   -> Getter s a
singular :: IndexedTraversal i s t a a -> IndexedLens i s t a a
singular :: IndexedFold i s a          -> IndexedGetter i s a

iunsafePartsOf' :: Over (Indexed i) (Bazaar (Indexed i) a b) s t a b -> IndexedLens [i] s t [a] [b] #

unsafePartsOf' :: ATraversal s t a b -> Lens s t [a] [b] #

iunsafePartsOf :: (Indexable [i] p, Functor f) => Traversing (Indexed i) f s t a b -> Over p f s t [a] [b] #

An indexed version of unsafePartsOf that receives the entire list of indices as its index.

unsafePartsOf :: Functor f => Traversing ((->) :: Type -> Type -> Type) f s t a b -> LensLike f s t [a] [b] #

unsafePartsOf turns a Traversal into a uniplate (or biplate) family.

If you do not need the types of s and t to be different, it is recommended that you use partsOf.

It is generally safer to traverse with the Bazaar rather than use this combinator. However, it is sometimes convenient.

This is unsafe because if you don't supply at least as many b's as you were given a's, then the reconstruction of t will result in an error!

When applied to a Fold the result is merely a Getter (and becomes safe).

unsafePartsOf :: Iso s t a b       -> Lens s t [a] [b]
unsafePartsOf :: Lens s t a b      -> Lens s t [a] [b]
unsafePartsOf :: Traversal s t a b -> Lens s t [a] [b]
unsafePartsOf :: Fold s a          -> Getter s [a]
unsafePartsOf :: Getter s a        -> Getter s [a]

ipartsOf' :: (Indexable [i] p, Functor f) => Over (Indexed i) (Bazaar' (Indexed i) a) s t a a -> Over p f s t [a] [a] #

A type-restricted version of ipartsOf that can only be used with an IndexedTraversal.

partsOf' :: ATraversal s t a a -> Lens s t [a] [a] #

A type-restricted version of partsOf that can only be used with a Traversal.

ipartsOf :: (Indexable [i] p, Functor f) => Traversing (Indexed i) f s t a a -> Over p f s t [a] [a] #

An indexed version of partsOf that receives the entire list of indices as its index.

partsOf :: Functor f => Traversing ((->) :: Type -> Type -> Type) f s t a a -> LensLike f s t [a] [a] #

partsOf turns a Traversal into a Lens that resembles an early version of the uniplate (or biplate) type.

Note: You should really try to maintain the invariant of the number of children in the list.

>>> (a,b,c) & partsOf each .~ [x,y,z]
(x,y,z)

Any extras will be lost. If you do not supply enough, then the remainder will come from the original structure.

>>> (a,b,c) & partsOf each .~ [w,x,y,z]
(w,x,y)

>>> (a,b,c) & partsOf each .~ [x,y]
(x,y,c)

>>> ('b', 'a', 'd', 'c') & partsOf each %~ sort
('a','b','c','d')

So technically, this is only a Lens if you do not change the number of results it returns.

When applied to a Fold the result is merely a Getter.

partsOf :: Iso' s a       -> Lens' s [a]
partsOf :: Lens' s a      -> Lens' s [a]
partsOf :: Traversal' s a -> Lens' s [a]
partsOf :: Fold s a       -> Getter s [a]
partsOf :: Getter s a     -> Getter s [a]

iloci :: IndexedTraversal i (Bazaar (Indexed i) a c s) (Bazaar (Indexed i) b c s) a b #

This IndexedTraversal allows you to traverse the individual stores in a Bazaar with access to their indices.

loci :: Traversal (Bazaar ((->) :: Type -> Type -> Type) a c s) (Bazaar ((->) :: Type -> Type -> Type) b c s) a b #

This Traversal allows you to traverse the individual stores in a Bazaar.

scanl1Of :: LensLike (State (Maybe a)) s t a a -> (a -> a -> a) -> s -> t #

This permits the use of scanl1 over an arbitrary Traversal or Lens.

scanl1 ≡ scanl1Of traverse

scanl1Of :: Iso s t a a       -> (a -> a -> a) -> s -> t
scanl1Of :: Lens s t a a      -> (a -> a -> a) -> s -> t
scanl1Of :: Traversal s t a a -> (a -> a -> a) -> s -> t

scanr1Of :: LensLike (Backwards (State (Maybe a))) s t a a -> (a -> a -> a) -> s -> t #

This permits the use of scanr1 over an arbitrary Traversal or Lens.

scanr1 ≡ scanr1Of traverse

scanr1Of :: Iso s t a a       -> (a -> a -> a) -> s -> t
scanr1Of :: Lens s t a a      -> (a -> a -> a) -> s -> t
scanr1Of :: Traversal s t a a -> (a -> a -> a) -> s -> t

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

This generalizes mapAccumL to an arbitrary Traversal.

mapAccumL ≡ mapAccumLOf traverse

mapAccumLOf accumulates State from left to right.

mapAccumLOf :: Iso s t a b       -> (acc -> a -> (acc, b)) -> acc -> s -> (acc, t)
mapAccumLOf :: Lens s t a b      -> (acc -> a -> (acc, b)) -> acc -> s -> (acc, t)
mapAccumLOf :: Traversal s t a b -> (acc -> a -> (acc, b)) -> acc -> s -> (acc, t)

mapAccumLOf :: LensLike (State acc) s t a b -> (acc -> a -> (acc, b)) -> acc -> s -> (acc, t)
mapAccumLOf l f acc0 s = swap (runState (l (a -> state (acc -> swap (f acc a))) s) acc0)

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

This generalizes mapAccumR to an arbitrary Traversal.

mapAccumR ≡ mapAccumROf traverse

mapAccumROf accumulates State from right to left.

mapAccumROf :: Iso s t a b       -> (acc -> a -> (acc, b)) -> acc -> s -> (acc, t)
mapAccumROf :: Lens s t a b      -> (acc -> a -> (acc, b)) -> acc -> s -> (acc, t)
mapAccumROf :: Traversal s t a b -> (acc -> a -> (acc, b)) -> acc -> s -> (acc, t)

mapAccumROf :: LensLike (Backwards (State acc)) s t a b -> (acc -> a -> (acc, b)) -> acc -> s -> (acc, t)

transposeOf :: LensLike ZipList s t [a] a -> s -> [t] #

This generalizes transpose to an arbitrary Traversal.

Note: transpose handles ragged inputs more intelligently, but for non-ragged inputs:

>>> transposeOf traverse [[1,2,3],[4,5,6]]
[[1,4],[2,5],[3,6]]

transpose ≡ transposeOf traverse

Since every Lens is a Traversal, we can use this as a form of monadic strength as well:

transposeOf _2 :: (b, [a]) -> [(b, a)]

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

Sequence the (monadic) effects targeted by a Lens in a container from left to right.

>>> sequenceOf each ([1,2],[3,4],[5,6])
[(1,3,5),(1,3,6),(1,4,5),(1,4,6),(2,3,5),(2,3,6),(2,4,5),(2,4,6)]

sequence ≡ sequenceOf traverse
sequenceOf l ≡ mapMOf l id
sequenceOf l ≡ unwrapMonad . l WrapMonad

sequenceOf :: Monad m => Iso s t (m b) b       -> s -> m t
sequenceOf :: Monad m => Lens s t (m b) b      -> s -> m t
sequenceOf :: Monad m => Traversal s t (m b) b -> s -> m t

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

forMOf is a flipped version of mapMOf, consistent with the definition of forM.

>>> forMOf both (1,3) $ \x -> [x, x + 1]
[(1,3),(1,4),(2,3),(2,4)]

forM ≡ forMOf traverse
forMOf l ≡ flip (mapMOf l)
iforMOf l s ≡ forM l s . Indexed

forMOf :: Monad m => Iso s t a b       -> s -> (a -> m b) -> m t
forMOf :: Monad m => Lens s t a b      -> s -> (a -> m b) -> m t
forMOf :: Monad m => Traversal s t a b -> s -> (a -> m b) -> m t

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

Map each element of a structure targeted by a Lens to a monadic action, evaluate these actions from left to right, and collect the results.

>>> mapMOf both (\x -> [x, x + 1]) (1,3)
[(1,3),(1,4),(2,3),(2,4)]

mapM ≡ mapMOf traverse
imapMOf l ≡ forM l . Indexed

mapMOf :: Monad m => Iso s t a b       -> (a -> m b) -> s -> m t
mapMOf :: Monad m => Lens s t a b      -> (a -> m b) -> s -> m t
mapMOf :: Monad m => Traversal s t a b -> (a -> m b) -> s -> m t

sequenceAOf :: LensLike f s t (f b) b -> s -> f t #

Evaluate each action in the structure from left to right, and collect the results.

>>> sequenceAOf both ([1,2],[3,4])
[(1,3),(1,4),(2,3),(2,4)]

sequenceA ≡ sequenceAOf traverse ≡ traverse id
sequenceAOf l ≡ traverseOf l id ≡ l id

sequenceAOf :: Functor f => Iso s t (f b) b       -> s -> f t
sequenceAOf :: Functor f => Lens s t (f b) b      -> s -> f t
sequenceAOf :: Applicative f => Traversal s t (f b) b -> s -> f t

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

A version of traverseOf with the arguments flipped, such that:

>>> forOf each (1,2,3) print
1
2
3
((),(),())

This function is only provided for consistency, flip is strictly more general.

forOf ≡ flip
forOf ≡ flip . traverseOf

for ≡ forOf traverse
ifor l s ≡ for l s . Indexed

forOf :: Functor f => Iso s t a b -> s -> (a -> f b) -> f t
forOf :: Functor f => Lens s t a b -> s -> (a -> f b) -> f t
forOf :: Applicative f => Traversal s t a b -> s -> (a -> f b) -> f t

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

Map each element of a structure targeted by a Lens or Traversal, evaluate these actions from left to right, and collect the results.

This function is only provided for consistency, id is strictly more general.

>>> traverseOf each print (1,2,3)
1
2
3
((),(),())

traverseOf ≡ id
itraverseOf l ≡ traverseOf l . Indexed
itraverseOf itraversed ≡ itraverse

This yields the obvious law:

traverse ≡ traverseOf traverse

traverseOf :: Functor f     => Iso s t a b        -> (a -> f b) -> s -> f t
traverseOf :: Functor f     => Lens s t a b       -> (a -> f b) -> s -> f t
traverseOf :: Apply f       => Traversal1 s t a b -> (a -> f b) -> s -> f t
traverseOf :: Applicative f => Traversal s t a b  -> (a -> f b) -> s -> f t

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

When you see this as an argument to a function, it expects a Traversal.

type ATraversal' s a = ATraversal s s a a #

type ATraversal' = Simple ATraversal

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

When you see this as an argument to a function, it expects a Traversal1.

type ATraversal1' s a = ATraversal1 s s a a #

type ATraversal1' = Simple ATraversal1

type AnIndexedTraversal i s t a b = Over (Indexed i) (Bazaar (Indexed i) a b) s t a b #

When you see this as an argument to a function, it expects an IndexedTraversal.

type AnIndexedTraversal1 i s t a b = Over (Indexed i) (Bazaar1 (Indexed i) a b) s t a b #

When you see this as an argument to a function, it expects an IndexedTraversal1.

type AnIndexedTraversal' i s a = AnIndexedTraversal i s s a a #

type AnIndexedTraversal' = Simple (AnIndexedTraversal i)

type AnIndexedTraversal1' i s a = AnIndexedTraversal1 i s s a a #

type AnIndexedTraversal1' = Simple (AnIndexedTraversal1 i)

type Traversing (p :: Type -> Type -> Type) (f :: Type -> Type) s t a b = Over p (BazaarT p f a b) s t a b #

When you see this as an argument to a function, it expects

to be indexed if p is an instance of Indexed i,
to be unindexed if p is (->),
a Traversal if f is Applicative,
a Getter if f is only a Functor and Contravariant,
a Lens if f is only a Functor,
a Fold if f is Applicative and Contravariant.

type Traversing1 (p :: Type -> Type -> Type) (f :: Type -> Type) s t a b = Over p (BazaarT1 p f a b) s t a b #

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

type Traversing' f = Simple (Traversing f)

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

class Ord k => TraverseMin k (m :: Type -> Type) | m -> k where #

Allows IndexedTraversal the value at the smallest index.

Methods

traverseMin :: IndexedTraversal' k (m v) v #

IndexedTraversal of the element with the smallest index.

Instances

TraverseMin Int IntMap
Instance details Defined in Control.Lens.Traversal Methods traverseMin :: IndexedTraversal' Int (IntMap v) v #
Ord k => TraverseMin k (Map k)
Instance details Defined in Control.Lens.Traversal Methods traverseMin :: IndexedTraversal' k (Map k v) v #

class Ord k => TraverseMax k (m :: Type -> Type) | m -> k where #

Allows IndexedTraversal of the value at the largest index.

Methods

traverseMax :: IndexedTraversal' k (m v) v #

IndexedTraversal of the element at the largest index.

Instances

TraverseMax Int IntMap
Instance details Defined in Control.Lens.Traversal Methods traverseMax :: IndexedTraversal' Int (IntMap v) v #
Ord k => TraverseMax k (Map k)
Instance details Defined in Control.Lens.Traversal Methods traverseMax :: IndexedTraversal' k (Map k v) v #

foldMapByOf :: Fold s a -> (r -> r -> r) -> r -> (a -> r) -> s -> r #

Fold a value using a specified Fold and Monoid operations. This is like foldMapBy where the Foldable instance can be manually specified.

foldMapByOf folded ≡ foldMapBy

foldMapByOf :: Getter s a     -> (r -> r -> r) -> r -> (a -> r) -> s -> r
foldMapByOf :: Fold s a       -> (r -> r -> r) -> r -> (a -> r) -> s -> r
foldMapByOf :: Traversal' s a -> (r -> r -> r) -> r -> (a -> r) -> s -> r
foldMapByOf :: Lens' s a      -> (r -> r -> r) -> r -> (a -> r) -> s -> r
foldMapByOf :: Iso' s a       -> (r -> r -> r) -> r -> (a -> r) -> s -> r

>>> foldMapByOf both (+) 0 length ("hello","world")
10

foldByOf :: Fold s a -> (a -> a -> a) -> a -> s -> a #

Fold a value using a specified Fold and Monoid operations. This is like foldBy where the Foldable instance can be manually specified.

foldByOf folded ≡ foldBy

foldByOf :: Getter s a     -> (a -> a -> a) -> a -> s -> a
foldByOf :: Fold s a       -> (a -> a -> a) -> a -> s -> a
foldByOf :: Lens' s a      -> (a -> a -> a) -> a -> s -> a
foldByOf :: Traversal' s a -> (a -> a -> a) -> a -> s -> a
foldByOf :: Iso' s a       -> (a -> a -> a) -> a -> s -> a

>>> foldByOf both (++) [] ("hello","world")
"helloworld"

idroppingWhile :: (Indexable i p, Profunctor q, Applicative f) => (i -> a -> Bool) -> Optical (Indexed i) q (Compose (State Bool) f) s t a a -> Optical p q f s t a a #

Obtain an IndexedFold by dropping elements from another IndexedFold, IndexedLens, IndexedGetter or IndexedTraversal while a predicate holds.

idroppingWhile :: (i -> a -> Bool) -> IndexedFold i s a          -> IndexedFold i s a
idroppingWhile :: (i -> a -> Bool) -> IndexedTraversal' i s a    -> IndexedFold i s a -- see notes
idroppingWhile :: (i -> a -> Bool) -> IndexedLens' i s a         -> IndexedFold i s a -- see notes
idroppingWhile :: (i -> a -> Bool) -> IndexedGetter i s a        -> IndexedFold i s a

Note: As with droppingWhile applying idroppingWhile to an IndexedLens or IndexedTraversal will still allow you to use it as a pseudo-IndexedTraversal, but if you change the value of the first target to one where the predicate returns True, then you will break the Traversal laws and Traversal fusion will no longer be sound.

itakingWhile :: (Indexable i p, Profunctor q, Contravariant f, Applicative f) => (i -> a -> Bool) -> Optical' (Indexed i) q (Const (Endo (f s)) :: Type -> Type) s a -> Optical' p q f s a #

Obtain an IndexedFold by taking elements from another IndexedFold, IndexedLens, IndexedGetter or IndexedTraversal while a predicate holds.

itakingWhile :: (i -> a -> Bool) -> IndexedFold i s a          -> IndexedFold i s a
itakingWhile :: (i -> a -> Bool) -> IndexedTraversal' i s a    -> IndexedFold i s a
itakingWhile :: (i -> a -> Bool) -> IndexedLens' i s a         -> IndexedFold i s a
itakingWhile :: (i -> a -> Bool) -> IndexedGetter i s a        -> IndexedFold i s a

Note: Applying itakingWhile to an IndexedLens or IndexedTraversal will still allow you to use it as a pseudo-IndexedTraversal, but if you change the value of any target to one where the predicate returns False, then you will break the Traversal laws and Traversal fusion will no longer be sound.

ifiltered :: (Indexable i p, Applicative f) => (i -> a -> Bool) -> Optical' p (Indexed i) f a a #

Filter an IndexedFold or IndexedGetter, obtaining an IndexedFold.

>>> [0,0,0,5,5,5]^..traversed.ifiltered (\i a -> i <= a)
[0,5,5,5]

Compose with ifiltered to filter another IndexedLens, IndexedIso, IndexedGetter, IndexedFold (or IndexedTraversal) with access to both the value and the index.

Note: As with filtered, this is not a legal IndexedTraversal, unless you are very careful not to invalidate the predicate on the target!

findIndicesOf :: IndexedGetting i (Endo [i]) s a -> (a -> Bool) -> s -> [i] #

Retrieve the indices of the values targeted by a IndexedFold or IndexedTraversal which satisfy a predicate.

findIndices ≡ findIndicesOf folded

findIndicesOf :: IndexedFold i s a       -> (a -> Bool) -> s -> [i]
findIndicesOf :: IndexedTraversal' i s a -> (a -> Bool) -> s -> [i]

findIndexOf :: IndexedGetting i (First i) s a -> (a -> Bool) -> s -> Maybe i #

Retrieve the index of the first value targeted by a IndexedFold or IndexedTraversal which satisfies a predicate.

findIndex ≡ findIndexOf folded

findIndexOf :: IndexedFold i s a       -> (a -> Bool) -> s -> Maybe i
findIndexOf :: IndexedTraversal' i s a -> (a -> Bool) -> s -> Maybe i

elemIndicesOf :: Eq a => IndexedGetting i (Endo [i]) s a -> a -> s -> [i] #

Retrieve the indices of the values targeted by a IndexedFold or IndexedTraversal which are equal to a given value.

elemIndices ≡ elemIndicesOf folded

elemIndicesOf :: Eq a => IndexedFold i s a       -> a -> s -> [i]
elemIndicesOf :: Eq a => IndexedTraversal' i s a -> a -> s -> [i]

elemIndexOf :: Eq a => IndexedGetting i (First i) s a -> a -> s -> Maybe i #

Retrieve the index of the first value targeted by a IndexedFold or IndexedTraversal which is equal to a given value.

elemIndex ≡ elemIndexOf folded

elemIndexOf :: Eq a => IndexedFold i s a       -> a -> s -> Maybe i
elemIndexOf :: Eq a => IndexedTraversal' i s a -> a -> s -> Maybe i

(^@?!) :: HasCallStack => s -> IndexedGetting i (Endo (i, a)) s a -> (i, a) infixl 8 #

Perform an *UNSAFE* head (with index) of an IndexedFold or IndexedTraversal assuming that it is there.

(^@?!) :: s -> IndexedGetter i s a     -> (i, a)
(^@?!) :: s -> IndexedFold i s a       -> (i, a)
(^@?!) :: s -> IndexedLens' i s a      -> (i, a)
(^@?!) :: s -> IndexedTraversal' i s a -> (i, a)

(^@?) :: s -> IndexedGetting i (Endo (Maybe (i, a))) s a -> Maybe (i, a) infixl 8 #

Perform a safe head (with index) of an IndexedFold or IndexedTraversal or retrieve Just the index and result from an IndexedGetter or IndexedLens.

When using a IndexedTraversal as a partial IndexedLens, or an IndexedFold as a partial IndexedGetter this can be a convenient way to extract the optional value.

(^@?) :: s -> IndexedGetter i s a     -> Maybe (i, a)
(^@?) :: s -> IndexedFold i s a       -> Maybe (i, a)
(^@?) :: s -> IndexedLens' i s a      -> Maybe (i, a)
(^@?) :: s -> IndexedTraversal' i s a -> Maybe (i, a)

(^@..) :: s -> IndexedGetting i (Endo [(i, a)]) s a -> [(i, a)] infixl 8 #

An infix version of itoListOf.

itoListOf :: IndexedGetting i (Endo [(i, a)]) s a -> s -> [(i, a)] #

Extract the key-value pairs from a structure.

When you don't need access to the indices in the result, then toListOf is more flexible in what it accepts.

toListOf l ≡ map snd . itoListOf l

itoListOf :: IndexedGetter i s a     -> s -> [(i,a)]
itoListOf :: IndexedFold i s a       -> s -> [(i,a)]
itoListOf :: IndexedLens' i s a      -> s -> [(i,a)]
itoListOf :: IndexedTraversal' i s a -> s -> [(i,a)]

ifoldlMOf :: Monad m => IndexedGetting i (Endo (r -> m r)) s a -> (i -> r -> a -> m r) -> r -> s -> m r #

Monadic fold over the elements of a structure with an index, associating to the left.

When you don't need access to the index then foldlMOf is more flexible in what it accepts.

foldlMOf l ≡ ifoldlMOf l . const

ifoldlMOf :: Monad m => IndexedGetter i s a     -> (i -> r -> a -> m r) -> r -> s -> m r
ifoldlMOf :: Monad m => IndexedFold i s a       -> (i -> r -> a -> m r) -> r -> s -> m r
ifoldlMOf :: Monad m => IndexedLens' i s a      -> (i -> r -> a -> m r) -> r -> s -> m r
ifoldlMOf :: Monad m => IndexedTraversal' i s a -> (i -> r -> a -> m r) -> r -> s -> m r

ifoldrMOf :: Monad m => IndexedGetting i (Dual (Endo (r -> m r))) s a -> (i -> a -> r -> m r) -> r -> s -> m r #

Monadic fold right over the elements of a structure with an index.

When you don't need access to the index then foldrMOf is more flexible in what it accepts.

foldrMOf l ≡ ifoldrMOf l . const

ifoldrMOf :: Monad m => IndexedGetter i s a     -> (i -> a -> r -> m r) -> r -> s -> m r
ifoldrMOf :: Monad m => IndexedFold i s a       -> (i -> a -> r -> m r) -> r -> s -> m r
ifoldrMOf :: Monad m => IndexedLens' i s a      -> (i -> a -> r -> m r) -> r -> s -> m r
ifoldrMOf :: Monad m => IndexedTraversal' i s a -> (i -> a -> r -> m r) -> r -> s -> m r

ifoldlOf' :: IndexedGetting i (Endo (r -> r)) s a -> (i -> r -> a -> r) -> r -> s -> r #

Fold over the elements of a structure with an index, associating to the left, but strictly.

When you don't need access to the index then foldlOf' is more flexible in what it accepts.

foldlOf' l ≡ ifoldlOf' l . const

ifoldlOf' :: IndexedGetter i s a       -> (i -> r -> a -> r) -> r -> s -> r
ifoldlOf' :: IndexedFold i s a         -> (i -> r -> a -> r) -> r -> s -> r
ifoldlOf' :: IndexedLens' i s a        -> (i -> r -> a -> r) -> r -> s -> r
ifoldlOf' :: IndexedTraversal' i s a   -> (i -> r -> a -> r) -> r -> s -> r

ifoldrOf' :: IndexedGetting i (Dual (Endo (r -> r))) s a -> (i -> a -> r -> r) -> r -> s -> r #

Strictly fold right over the elements of a structure with an index.

When you don't need access to the index then foldrOf' is more flexible in what it accepts.

foldrOf' l ≡ ifoldrOf' l . const

ifoldrOf' :: IndexedGetter i s a     -> (i -> a -> r -> r) -> r -> s -> r
ifoldrOf' :: IndexedFold i s a       -> (i -> a -> r -> r) -> r -> s -> r
ifoldrOf' :: IndexedLens' i s a      -> (i -> a -> r -> r) -> r -> s -> r
ifoldrOf' :: IndexedTraversal' i s a -> (i -> a -> r -> r) -> r -> s -> r

ifindMOf :: Monad m => IndexedGetting i (Endo (m (Maybe a))) s a -> (i -> a -> m Bool) -> s -> m (Maybe a) #

The ifindMOf function takes an IndexedFold or IndexedTraversal, a monadic predicate that is also supplied the index, a structure and returns in the monad the left-most element of the structure matching the predicate, or Nothing if there is no such element.

When you don't need access to the index then findMOf is more flexible in what it accepts.

findMOf l ≡ ifindMOf l . const

ifindMOf :: Monad m => IndexedGetter i s a     -> (i -> a -> m Bool) -> s -> m (Maybe a)
ifindMOf :: Monad m => IndexedFold i s a       -> (i -> a -> m Bool) -> s -> m (Maybe a)
ifindMOf :: Monad m => IndexedLens' i s a      -> (i -> a -> m Bool) -> s -> m (Maybe a)
ifindMOf :: Monad m => IndexedTraversal' i s a -> (i -> a -> m Bool) -> s -> m (Maybe a)

ifindOf :: IndexedGetting i (Endo (Maybe a)) s a -> (i -> a -> Bool) -> s -> Maybe a #

The ifindOf function takes an IndexedFold or IndexedTraversal, a predicate that is also supplied the index, a structure and returns the left-most element of the structure matching the predicate, or Nothing if there is no such element.

When you don't need access to the index then findOf is more flexible in what it accepts.

findOf l ≡ ifindOf l . const

ifindOf :: IndexedGetter i s a     -> (i -> a -> Bool) -> s -> Maybe a
ifindOf :: IndexedFold i s a       -> (i -> a -> Bool) -> s -> Maybe a
ifindOf :: IndexedLens' i s a      -> (i -> a -> Bool) -> s -> Maybe a
ifindOf :: IndexedTraversal' i s a -> (i -> a -> Bool) -> s -> Maybe a

iconcatMapOf :: IndexedGetting i [r] s a -> (i -> a -> [r]) -> s -> [r] #

Concatenate the results of a function of the elements of an IndexedFold or IndexedTraversal with access to the index.

When you don't need access to the index then concatMapOf is more flexible in what it accepts.

concatMapOf l ≡ iconcatMapOf l . const
iconcatMapOf ≡ ifoldMapOf

iconcatMapOf :: IndexedGetter i s a     -> (i -> a -> [r]) -> s -> [r]
iconcatMapOf :: IndexedFold i s a       -> (i -> a -> [r]) -> s -> [r]
iconcatMapOf :: IndexedLens' i s a      -> (i -> a -> [r]) -> s -> [r]
iconcatMapOf :: IndexedTraversal' i s a -> (i -> a -> [r]) -> s -> [r]

iforMOf_ :: Monad m => IndexedGetting i (Sequenced r m) s a -> s -> (i -> a -> m r) -> m () #

Run monadic actions for each target of an IndexedFold or IndexedTraversal with access to the index, discarding the results (with the arguments flipped).

iforMOf_ ≡ flip . imapMOf_

When you don't need access to the index then forMOf_ is more flexible in what it accepts.

forMOf_ l a ≡ iforMOf l a . const

iforMOf_ :: Monad m => IndexedGetter i s a     -> s -> (i -> a -> m r) -> m ()
iforMOf_ :: Monad m => IndexedFold i s a       -> s -> (i -> a -> m r) -> m ()
iforMOf_ :: Monad m => IndexedLens' i s a      -> s -> (i -> a -> m r) -> m ()
iforMOf_ :: Monad m => IndexedTraversal' i s a -> s -> (i -> a -> m r) -> m ()

imapMOf_ :: Monad m => IndexedGetting i (Sequenced r m) s a -> (i -> a -> m r) -> s -> m () #

Run monadic actions for each target of an IndexedFold or IndexedTraversal with access to the index, discarding the results.

When you don't need access to the index then mapMOf_ is more flexible in what it accepts.

mapMOf_ l ≡ imapMOf l . const

imapMOf_ :: Monad m => IndexedGetter i s a     -> (i -> a -> m r) -> s -> m ()
imapMOf_ :: Monad m => IndexedFold i s a       -> (i -> a -> m r) -> s -> m ()
imapMOf_ :: Monad m => IndexedLens' i s a      -> (i -> a -> m r) -> s -> m ()
imapMOf_ :: Monad m => IndexedTraversal' i s a -> (i -> a -> m r) -> s -> m ()

iforOf_ :: Functor f => IndexedGetting i (Traversed r f) s a -> s -> (i -> a -> f r) -> f () #

Traverse the targets of an IndexedFold or IndexedTraversal with access to the index, discarding the results (with the arguments flipped).

iforOf_ ≡ flip . itraverseOf_

When you don't need access to the index then forOf_ is more flexible in what it accepts.

forOf_ l a ≡ iforOf_ l a . const

iforOf_ :: Functor f     => IndexedGetter i s a     -> s -> (i -> a -> f r) -> f ()
iforOf_ :: Applicative f => IndexedFold i s a       -> s -> (i -> a -> f r) -> f ()
iforOf_ :: Functor f     => IndexedLens' i s a      -> s -> (i -> a -> f r) -> f ()
iforOf_ :: Applicative f => IndexedTraversal' i s a -> s -> (i -> a -> f r) -> f ()

itraverseOf_ :: Functor f => IndexedGetting i (Traversed r f) s a -> (i -> a -> f r) -> s -> f () #

Traverse the targets of an IndexedFold or IndexedTraversal with access to the i, discarding the results.

When you don't need access to the index then traverseOf_ is more flexible in what it accepts.

traverseOf_ l ≡ itraverseOf l . const

itraverseOf_ :: Functor f     => IndexedGetter i s a     -> (i -> a -> f r) -> s -> f ()
itraverseOf_ :: Applicative f => IndexedFold i s a       -> (i -> a -> f r) -> s -> f ()
itraverseOf_ :: Functor f     => IndexedLens' i s a      -> (i -> a -> f r) -> s -> f ()
itraverseOf_ :: Applicative f => IndexedTraversal' i s a -> (i -> a -> f r) -> s -> f ()

inoneOf :: IndexedGetting i Any s a -> (i -> a -> Bool) -> s -> Bool #

Return whether or not none of the elements viewed through an IndexedFold or IndexedTraversal satisfy a predicate, with access to the i.

When you don't need access to the index then noneOf is more flexible in what it accepts.

noneOf l ≡ inoneOf l . const

inoneOf :: IndexedGetter i s a     -> (i -> a -> Bool) -> s -> Bool
inoneOf :: IndexedFold i s a       -> (i -> a -> Bool) -> s -> Bool
inoneOf :: IndexedLens' i s a      -> (i -> a -> Bool) -> s -> Bool
inoneOf :: IndexedTraversal' i s a -> (i -> a -> Bool) -> s -> Bool

iallOf :: IndexedGetting i All s a -> (i -> a -> Bool) -> s -> Bool #

Return whether or not all elements viewed through an IndexedFold or IndexedTraversal satisfy a predicate, with access to the i.

When you don't need access to the index then allOf is more flexible in what it accepts.

allOf l ≡ iallOf l . const

iallOf :: IndexedGetter i s a     -> (i -> a -> Bool) -> s -> Bool
iallOf :: IndexedFold i s a       -> (i -> a -> Bool) -> s -> Bool
iallOf :: IndexedLens' i s a      -> (i -> a -> Bool) -> s -> Bool
iallOf :: IndexedTraversal' i s a -> (i -> a -> Bool) -> s -> Bool

ianyOf :: IndexedGetting i Any s a -> (i -> a -> Bool) -> s -> Bool #

Return whether or not any element viewed through an IndexedFold or IndexedTraversal satisfy a predicate, with access to the i.

When you don't need access to the index then anyOf is more flexible in what it accepts.

anyOf l ≡ ianyOf l . const

ianyOf :: IndexedGetter i s a     -> (i -> a -> Bool) -> s -> Bool
ianyOf :: IndexedFold i s a       -> (i -> a -> Bool) -> s -> Bool
ianyOf :: IndexedLens' i s a      -> (i -> a -> Bool) -> s -> Bool
ianyOf :: IndexedTraversal' i s a -> (i -> a -> Bool) -> s -> Bool

ifoldlOf :: IndexedGetting i (Dual (Endo r)) s a -> (i -> r -> a -> r) -> r -> s -> r #

Left-associative fold of the parts of a structure that are viewed through an IndexedFold or IndexedTraversal with access to the i.

When you don't need access to the index then foldlOf is more flexible in what it accepts.

foldlOf l ≡ ifoldlOf l . const

ifoldlOf :: IndexedGetter i s a     -> (i -> r -> a -> r) -> r -> s -> r
ifoldlOf :: IndexedFold i s a       -> (i -> r -> a -> r) -> r -> s -> r
ifoldlOf :: IndexedLens' i s a      -> (i -> r -> a -> r) -> r -> s -> r
ifoldlOf :: IndexedTraversal' i s a -> (i -> r -> a -> r) -> r -> s -> r

ifoldrOf :: IndexedGetting i (Endo r) s a -> (i -> a -> r -> r) -> r -> s -> r #

Right-associative fold of parts of a structure that are viewed through an IndexedFold or IndexedTraversal with access to the i.

When you don't need access to the index then foldrOf is more flexible in what it accepts.

foldrOf l ≡ ifoldrOf l . const

ifoldrOf :: IndexedGetter i s a     -> (i -> a -> r -> r) -> r -> s -> r
ifoldrOf :: IndexedFold i s a       -> (i -> a -> r -> r) -> r -> s -> r
ifoldrOf :: IndexedLens' i s a      -> (i -> a -> r -> r) -> r -> s -> r
ifoldrOf :: IndexedTraversal' i s a -> (i -> a -> r -> r) -> r -> s -> r

ifoldMapOf :: IndexedGetting i m s a -> (i -> a -> m) -> s -> m #

Fold an IndexedFold or IndexedTraversal by mapping indices and values to an arbitrary Monoid with access to the i.

When you don't need access to the index then foldMapOf is more flexible in what it accepts.

foldMapOf l ≡ ifoldMapOf l . const

ifoldMapOf ::             IndexedGetter i s a     -> (i -> a -> m) -> s -> m
ifoldMapOf :: Monoid m => IndexedFold i s a       -> (i -> a -> m) -> s -> m
ifoldMapOf ::             IndexedLens' i s a      -> (i -> a -> m) -> s -> m
ifoldMapOf :: Monoid m => IndexedTraversal' i s a -> (i -> a -> m) -> s -> m

backwards :: (Profunctor p, Profunctor q) => Optical p q (Backwards f) s t a b -> Optical p q f s t a b #

This allows you to traverse the elements of a pretty much any LensLike construction in the opposite order.

This will preserve indexes on Indexed types and will give you the elements of a (finite) Fold or Traversal in the opposite order.

This has no practical impact on a Getter, Setter, Lens or Iso.

NB: To write back through an Iso, you want to use from. Similarly, to write back through an Prism, you want to use re.

ipreuses :: MonadState s m => IndexedGetting i (First r) s a -> (i -> a -> r) -> m (Maybe r) #

Retrieve a function of the first index and value targeted by an IndexedFold or IndexedTraversal (or a function of Just the index and result from an IndexedGetter or IndexedLens) into the current state.

ipreuses = uses . ipre

ipreuses :: MonadState s m => IndexedGetter i s a     -> (i -> a -> r) -> m (Maybe r)
ipreuses :: MonadState s m => IndexedFold i s a       -> (i -> a -> r) -> m (Maybe r)
ipreuses :: MonadState s m => IndexedLens' i s a      -> (i -> a -> r) -> m (Maybe r)
ipreuses :: MonadState s m => IndexedTraversal' i s a -> (i -> a -> r) -> m (Maybe r)

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

Retrieve a function of the first value targeted by a Fold or Traversal (or Just the result from a Getter or Lens) into the current state.

preuses = uses . pre

preuses :: MonadState s m => Getter s a     -> (a -> r) -> m (Maybe r)
preuses :: MonadState s m => Fold s a       -> (a -> r) -> m (Maybe r)
preuses :: MonadState s m => Lens' s a      -> (a -> r) -> m (Maybe r)
preuses :: MonadState s m => Iso' s a       -> (a -> r) -> m (Maybe r)
preuses :: MonadState s m => Traversal' s a -> (a -> r) -> m (Maybe r)

ipreuse :: MonadState s m => IndexedGetting i (First (i, a)) s a -> m (Maybe (i, a)) #

Retrieve the first index and value targeted by an IndexedFold or IndexedTraversal (or Just the index and result from an IndexedGetter or IndexedLens) into the current state.

ipreuse = use . ipre

ipreuse :: MonadState s m => IndexedGetter i s a     -> m (Maybe (i, a))
ipreuse :: MonadState s m => IndexedFold i s a       -> m (Maybe (i, a))
ipreuse :: MonadState s m => IndexedLens' i s a      -> m (Maybe (i, a))
ipreuse :: MonadState s m => IndexedTraversal' i s a -> m (Maybe (i, a))

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

Retrieve the first value targeted by a Fold or Traversal (or Just the result from a Getter or Lens) into the current state.

preuse = use . pre

preuse :: MonadState s m => Getter s a     -> m (Maybe a)
preuse :: MonadState s m => Fold s a       -> m (Maybe a)
preuse :: MonadState s m => Lens' s a      -> m (Maybe a)
preuse :: MonadState s m => Iso' s a       -> m (Maybe a)
preuse :: MonadState s m => Traversal' s a -> m (Maybe a)

ipreviews :: MonadReader s m => IndexedGetting i (First r) s a -> (i -> a -> r) -> m (Maybe r) #

Retrieve a function of the first index and value targeted by an IndexedFold or IndexedTraversal (or Just the result from an IndexedGetter or IndexedLens). See also (^@?).

ipreviews = views . ipre

This is usually applied in the Reader Monad (->) s.

ipreviews :: IndexedGetter i s a     -> (i -> a -> r) -> s -> Maybe r
ipreviews :: IndexedFold i s a       -> (i -> a -> r) -> s -> Maybe r
ipreviews :: IndexedLens' i s a      -> (i -> a -> r) -> s -> Maybe r
ipreviews :: IndexedTraversal' i s a -> (i -> a -> r) -> s -> Maybe r

However, it may be useful to think of its full generality when working with a Monad transformer stack:

ipreviews :: MonadReader s m => IndexedGetter i s a     -> (i -> a -> r) -> m (Maybe r)
ipreviews :: MonadReader s m => IndexedFold i s a       -> (i -> a -> r) -> m (Maybe r)
ipreviews :: MonadReader s m => IndexedLens' i s a      -> (i -> a -> r) -> m (Maybe r)
ipreviews :: MonadReader s m => IndexedTraversal' i s a -> (i -> a -> r) -> m (Maybe r)

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

Retrieve a function of the first value targeted by a Fold or Traversal (or Just the result from a Getter or Lens).

This is usually applied in the Reader Monad (->) s.

ipreview :: MonadReader s m => IndexedGetting i (First (i, a)) s a -> m (Maybe (i, a)) #

Retrieve the first index and value targeted by a Fold or Traversal (or Just the result from a Getter or Lens). See also (^@?).

ipreview = view . ipre

This is usually applied in the Reader Monad (->) s.

ipreview :: IndexedGetter i s a     -> s -> Maybe (i, a)
ipreview :: IndexedFold i s a       -> s -> Maybe (i, a)
ipreview :: IndexedLens' i s a      -> s -> Maybe (i, a)
ipreview :: IndexedTraversal' i s a -> s -> Maybe (i, a)

However, it may be useful to think of its full generality when working with a Monad transformer stack:

ipreview :: MonadReader s m => IndexedGetter s a     -> m (Maybe (i, a))
ipreview :: MonadReader s m => IndexedFold s a       -> m (Maybe (i, a))
ipreview :: MonadReader s m => IndexedLens' s a      -> m (Maybe (i, a))
ipreview :: MonadReader s m => IndexedTraversal' s a -> m (Maybe (i, a))

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

Retrieve the first value targeted by a Fold or Traversal (or Just the result from a Getter or Lens). See also firstOf and ^?, which are similar with some subtle differences (explained below).

listToMaybe . toList ≡ preview folded

preview = view . pre

Unlike ^?, this function uses a MonadReader to read the value to be focused in on. This allows one to pass the value as the last argument by using the MonadReader instance for (->) s However, it may also be used as part of some deeply nested transformer stack.

preview uses a monoidal value to obtain the result. This means that it generally has good performance, but can occasionally cause space leaks or even stack overflows on some data types. There is another function, firstOf, which avoids these issues at the cost of a slight constant performance cost and a little less flexibility.

It may be helpful to think of preview as having one of the following more specialized types:

preview :: Getter s a     -> s -> Maybe a
preview :: Fold s a       -> s -> Maybe a
preview :: Lens' s a      -> s -> Maybe a
preview :: Iso' s a       -> s -> Maybe a
preview :: Traversal' s a -> s -> Maybe a

preview :: MonadReader s m => Getter s a     -> m (Maybe a)
preview :: MonadReader s m => Fold s a       -> m (Maybe a)
preview :: MonadReader s m => Lens' s a      -> m (Maybe a)
preview :: MonadReader s m => Iso' s a       -> m (Maybe a)
preview :: MonadReader s m => Traversal' s a -> m (Maybe a)

ipre :: IndexedGetting i (First (i, a)) s a -> IndexPreservingGetter s (Maybe (i, a)) #

This converts an IndexedFold to an IndexPreservingGetter that returns the first index and element, if they exist, as a Maybe.

ipre :: IndexedGetter i s a     -> IndexPreservingGetter s (Maybe (i, a))
ipre :: IndexedFold i s a       -> IndexPreservingGetter s (Maybe (i, a))
ipre :: IndexedTraversal' i s a -> IndexPreservingGetter s (Maybe (i, a))
ipre :: IndexedLens' i s a      -> IndexPreservingGetter s (Maybe (i, a))

pre :: Getting (First a) s a -> IndexPreservingGetter s (Maybe a) #

This converts a Fold to a IndexPreservingGetter that returns the first element, if it exists, as a Maybe.

pre :: Getter s a     -> IndexPreservingGetter s (Maybe a)
pre :: Fold s a       -> IndexPreservingGetter s (Maybe a)
pre :: Traversal' s a -> IndexPreservingGetter s (Maybe a)
pre :: Lens' s a      -> IndexPreservingGetter s (Maybe a)
pre :: Iso' s a       -> IndexPreservingGetter s (Maybe a)
pre :: Prism' s a     -> IndexPreservingGetter s (Maybe a)

hasn't :: Getting All s a -> s -> Bool #

Check to see if this Fold or Traversal has no matches.

>>> hasn't _Left (Right 12)
True

>>> hasn't _Left (Left 12)
False

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

Check to see if this Fold or Traversal matches 1 or more entries.

>>> has (element 0) []
False

>>> has _Left (Left 12)
True

>>> has _Right (Left 12)
False

This will always return True for a Lens or Getter.

>>> has _1 ("hello","world")
True

has :: Getter s a     -> s -> Bool
has :: Fold s a       -> s -> Bool
has :: Iso' s a       -> s -> Bool
has :: Lens' s a      -> s -> Bool
has :: Traversal' s a -> s -> Bool

foldlMOf :: Monad m => Getting (Endo (r -> m r)) s a -> (r -> a -> m r) -> r -> s -> m r #

Monadic fold over the elements of a structure, associating to the left, i.e. from left to right.

foldlM ≡ foldlMOf folded

foldlMOf :: Monad m => Getter s a     -> (r -> a -> m r) -> r -> s -> m r
foldlMOf :: Monad m => Fold s a       -> (r -> a -> m r) -> r -> s -> m r
foldlMOf :: Monad m => Iso' s a       -> (r -> a -> m r) -> r -> s -> m r
foldlMOf :: Monad m => Lens' s a      -> (r -> a -> m r) -> r -> s -> m r
foldlMOf :: Monad m => Traversal' s a -> (r -> a -> m r) -> r -> s -> m r

foldrMOf :: Monad m => Getting (Dual (Endo (r -> m r))) s a -> (a -> r -> m r) -> r -> s -> m r #

Monadic fold over the elements of a structure, associating to the right, i.e. from right to left.

foldrM ≡ foldrMOf folded

foldrMOf :: Monad m => Getter s a     -> (a -> r -> m r) -> r -> s -> m r
foldrMOf :: Monad m => Fold s a       -> (a -> r -> m r) -> r -> s -> m r
foldrMOf :: Monad m => Iso' s a       -> (a -> r -> m r) -> r -> s -> m r
foldrMOf :: Monad m => Lens' s a      -> (a -> r -> m r) -> r -> s -> m r
foldrMOf :: Monad m => Traversal' s a -> (a -> r -> m r) -> r -> s -> m r

foldl1Of' :: HasCallStack => Getting (Endo (Endo (Maybe a))) s a -> (a -> a -> a) -> s -> a #

A variant of foldlOf' that has no base case and thus may only be applied to folds and structures such that the fold views at least one element of the structure.

foldl1Of' l f ≡ foldl1' f . toListOf l

foldl1Of' :: Getter s a     -> (a -> a -> a) -> s -> a
foldl1Of' :: Fold s a       -> (a -> a -> a) -> s -> a
foldl1Of' :: Iso' s a       -> (a -> a -> a) -> s -> a
foldl1Of' :: Lens' s a      -> (a -> a -> a) -> s -> a
foldl1Of' :: Traversal' s a -> (a -> a -> a) -> s -> a

foldr1Of' :: HasCallStack => Getting (Dual (Endo (Endo (Maybe a)))) s a -> (a -> a -> a) -> s -> a #

A variant of foldrOf' that has no base case and thus may only be applied to folds and structures such that the fold views at least one element of the structure.

foldr1Of l f ≡ foldr1 f . toListOf l

foldr1Of' :: Getter s a     -> (a -> a -> a) -> s -> a
foldr1Of' :: Fold s a       -> (a -> a -> a) -> s -> a
foldr1Of' :: Iso' s a       -> (a -> a -> a) -> s -> a
foldr1Of' :: Lens' s a      -> (a -> a -> a) -> s -> a
foldr1Of' :: Traversal' s a -> (a -> a -> a) -> s -> a

foldlOf' :: Getting (Endo (Endo r)) s a -> (r -> a -> r) -> r -> s -> r #

Fold over the elements of a structure, associating to the left, but strictly.

foldl' ≡ foldlOf' folded

foldlOf' :: Getter s a     -> (r -> a -> r) -> r -> s -> r
foldlOf' :: Fold s a       -> (r -> a -> r) -> r -> s -> r
foldlOf' :: Iso' s a       -> (r -> a -> r) -> r -> s -> r
foldlOf' :: Lens' s a      -> (r -> a -> r) -> r -> s -> r
foldlOf' :: Traversal' s a -> (r -> a -> r) -> r -> s -> r

foldrOf' :: Getting (Dual (Endo (Endo r))) s a -> (a -> r -> r) -> r -> s -> r #

Strictly fold right over the elements of a structure.

foldr' ≡ foldrOf' folded

foldrOf' :: Getter s a     -> (a -> r -> r) -> r -> s -> r
foldrOf' :: Fold s a       -> (a -> r -> r) -> r -> s -> r
foldrOf' :: Iso' s a       -> (a -> r -> r) -> r -> s -> r
foldrOf' :: Lens' s a      -> (a -> r -> r) -> r -> s -> r
foldrOf' :: Traversal' s a -> (a -> r -> r) -> r -> s -> r

foldl1Of :: HasCallStack => Getting (Dual (Endo (Maybe a))) s a -> (a -> a -> a) -> s -> a #

A variant of foldlOf that has no base case and thus may only be applied to lenses and structures such that the Lens views at least one element of the structure.

>>> foldl1Of each (+) (1,2,3,4)
10

foldl1Of l f ≡ foldl1 f . toListOf l
foldl1 ≡ foldl1Of folded

foldl1Of :: Getter s a     -> (a -> a -> a) -> s -> a
foldl1Of :: Fold s a       -> (a -> a -> a) -> s -> a
foldl1Of :: Iso' s a       -> (a -> a -> a) -> s -> a
foldl1Of :: Lens' s a      -> (a -> a -> a) -> s -> a
foldl1Of :: Traversal' s a -> (a -> a -> a) -> s -> a

foldr1Of :: HasCallStack => Getting (Endo (Maybe a)) s a -> (a -> a -> a) -> s -> a #

A variant of foldrOf that has no base case and thus may only be applied to lenses and structures such that the Lens views at least one element of the structure.

>>> foldr1Of each (+) (1,2,3,4)
10

foldr1Of l f ≡ foldr1 f . toListOf l
foldr1 ≡ foldr1Of folded

foldr1Of :: Getter s a     -> (a -> a -> a) -> s -> a
foldr1Of :: Fold s a       -> (a -> a -> a) -> s -> a
foldr1Of :: Iso' s a       -> (a -> a -> a) -> s -> a
foldr1Of :: Lens' s a      -> (a -> a -> a) -> s -> a
foldr1Of :: Traversal' s a -> (a -> a -> a) -> s -> a

lookupOf :: Eq k => Getting (Endo (Maybe v)) s (k, v) -> k -> s -> Maybe v #

The lookupOf function takes a Fold (or Getter, Traversal, Lens, Iso, etc.), a key, and a structure containing key/value pairs. It returns the first value corresponding to the given key. This function generalizes lookup to work on an arbitrary Fold instead of lists.

>>> lookupOf folded 4 [(2, 'a'), (4, 'b'), (4, 'c')]
Just 'b'

>>> lookupOf each 2 [(2, 'a'), (4, 'b'), (4, 'c')]
Just 'a'

lookupOf :: Eq k => Fold s (k,v) -> k -> s -> Maybe v

findMOf :: Monad m => Getting (Endo (m (Maybe a))) s a -> (a -> m Bool) -> s -> m (Maybe a) #

The findMOf function takes a Lens (or Getter, Iso, Fold, or Traversal), a monadic predicate and a structure and returns in the monad the leftmost element of the structure matching the predicate, or Nothing if there is no such element.

>>> findMOf each ( \x -> print ("Checking " ++ show x) >> return (even x)) (1,3,4,6)
"Checking 1"
"Checking 3"
"Checking 4"
Just 4

>>> findMOf each ( \x -> print ("Checking " ++ show x) >> return (even x)) (1,3,5,7)
"Checking 1"
"Checking 3"
"Checking 5"
"Checking 7"
Nothing

findMOf :: (Monad m, Getter s a)     -> (a -> m Bool) -> s -> m (Maybe a)
findMOf :: (Monad m, Fold s a)       -> (a -> m Bool) -> s -> m (Maybe a)
findMOf :: (Monad m, Iso' s a)       -> (a -> m Bool) -> s -> m (Maybe a)
findMOf :: (Monad m, Lens' s a)      -> (a -> m Bool) -> s -> m (Maybe a)
findMOf :: (Monad m, Traversal' s a) -> (a -> m Bool) -> s -> m (Maybe a)

findMOf folded :: (Monad m, Foldable f) => (a -> m Bool) -> f a -> m (Maybe a)
ifindMOf l ≡ findMOf l . Indexed

A simpler version that didn't permit indexing, would be:

findMOf :: Monad m => Getting (Endo (m (Maybe a))) s a -> (a -> m Bool) -> s -> m (Maybe a)
findMOf l p = foldrOf l (a y -> p a >>= x -> if x then return (Just a) else y) $ return Nothing

findOf :: Getting (Endo (Maybe a)) s a -> (a -> Bool) -> s -> Maybe a #

The findOf function takes a Lens (or Getter, Iso, Fold, or Traversal), a predicate and a structure and returns the leftmost element of the structure matching the predicate, or Nothing if there is no such element.

>>> findOf each even (1,3,4,6)
Just 4

>>> findOf folded even [1,3,5,7]
Nothing

findOf :: Getter s a     -> (a -> Bool) -> s -> Maybe a
findOf :: Fold s a       -> (a -> Bool) -> s -> Maybe a
findOf :: Iso' s a       -> (a -> Bool) -> s -> Maybe a
findOf :: Lens' s a      -> (a -> Bool) -> s -> Maybe a
findOf :: Traversal' s a -> (a -> Bool) -> s -> Maybe a

find ≡ findOf folded
ifindOf l ≡ findOf l . Indexed

A simpler version that didn't permit indexing, would be:

findOf :: Getting (Endo (Maybe a)) s a -> (a -> Bool) -> s -> Maybe a
findOf l p = foldrOf l (a y -> if p a then Just a else y) Nothing

minimumByOf :: Getting (Endo (Endo (Maybe a))) s a -> (a -> a -> Ordering) -> s -> Maybe a #

Obtain the minimum element (if any) targeted by a Fold, Traversal, Lens, Iso or Getter according to a user supplied Ordering.

In the interest of efficiency, This operation has semantics more strict than strictly necessary.

>>> minimumByOf traverse (compare `on` length) ["mustard","relish","ham"]
Just "ham"

minimumBy cmp ≡ fromMaybe (error "empty") . minimumByOf folded cmp

minimumByOf :: Getter s a     -> (a -> a -> Ordering) -> s -> Maybe a
minimumByOf :: Fold s a       -> (a -> a -> Ordering) -> s -> Maybe a
minimumByOf :: Iso' s a       -> (a -> a -> Ordering) -> s -> Maybe a
minimumByOf :: Lens' s a      -> (a -> a -> Ordering) -> s -> Maybe a
minimumByOf :: Traversal' s a -> (a -> a -> Ordering) -> s -> Maybe a

maximumByOf :: Getting (Endo (Endo (Maybe a))) s a -> (a -> a -> Ordering) -> s -> Maybe a #

Obtain the maximum element (if any) targeted by a Fold, Traversal, Lens, Iso, or Getter according to a user supplied Ordering.

>>> maximumByOf traverse (compare `on` length) ["mustard","relish","ham"]
Just "mustard"

In the interest of efficiency, This operation has semantics more strict than strictly necessary.

maximumBy cmp ≡ fromMaybe (error "empty") . maximumByOf folded cmp

maximumByOf :: Getter s a     -> (a -> a -> Ordering) -> s -> Maybe a
maximumByOf :: Fold s a       -> (a -> a -> Ordering) -> s -> Maybe a
maximumByOf :: Iso' s a       -> (a -> a -> Ordering) -> s -> Maybe a
maximumByOf :: Lens' s a      -> (a -> a -> Ordering) -> s -> Maybe a
maximumByOf :: Traversal' s a -> (a -> a -> Ordering) -> s -> Maybe a

minimum1Of :: Ord a => Getting (Min a) s a -> s -> a #

Obtain the minimum element targeted by a Fold1 or Traversal1.

>>> minimum1Of traverse1 (1 :| [2..10])
1

minimum1Of :: Ord a => Getter s a      -> s -> a
minimum1Of :: Ord a => Fold1 s a       -> s -> a
minimum1Of :: Ord a => Iso' s a        -> s -> a
minimum1Of :: Ord a => Lens' s a       -> s -> a
minimum1Of :: Ord a => Traversal1' s a -> s -> a

minimumOf :: Ord a => Getting (Endo (Endo (Maybe a))) s a -> s -> Maybe a #

Obtain the minimum element (if any) targeted by a Fold or Traversal safely.

Note: minimumOf on a valid Iso, Lens or Getter will always return Just a value.

>>> minimumOf traverse [1..10]
Just 1

>>> minimumOf traverse []
Nothing

>>> minimumOf (folded.filtered even) [1,4,3,6,7,9,2]
Just 2

minimum ≡ fromMaybe (error "empty") . minimumOf folded

In the interest of efficiency, This operation has semantics more strict than strictly necessary. rmap getMin (foldMapOf l Min) has lazier semantics but could leak memory.

minimumOf :: Ord a => Getter s a     -> s -> Maybe a
minimumOf :: Ord a => Fold s a       -> s -> Maybe a
minimumOf :: Ord a => Iso' s a       -> s -> Maybe a
minimumOf :: Ord a => Lens' s a      -> s -> Maybe a
minimumOf :: Ord a => Traversal' s a -> s -> Maybe a

maximum1Of :: Ord a => Getting (Max a) s a -> s -> a #

Obtain the maximum element targeted by a Fold1 or Traversal1.

>>> maximum1Of traverse1 (1 :| [2..10])
10

maximum1Of :: Ord a => Getter s a      -> s -> a
maximum1Of :: Ord a => Fold1 s a       -> s -> a
maximum1Of :: Ord a => Iso' s a        -> s -> a
maximum1Of :: Ord a => Lens' s a       -> s -> a
maximum1Of :: Ord a => Traversal1' s a -> s -> a

maximumOf :: Ord a => Getting (Endo (Endo (Maybe a))) s a -> s -> Maybe a #

Obtain the maximum element (if any) targeted by a Fold or Traversal safely.

Note: maximumOf on a valid Iso, Lens or Getter will always return Just a value.

>>> maximumOf traverse [1..10]
Just 10

>>> maximumOf traverse []
Nothing

>>> maximumOf (folded.filtered even) [1,4,3,6,7,9,2]
Just 6

maximum ≡ fromMaybe (error "empty") . maximumOf folded

In the interest of efficiency, This operation has semantics more strict than strictly necessary. rmap getMax (foldMapOf l Max) has lazier semantics but could leak memory.

maximumOf :: Ord a => Getter s a     -> s -> Maybe a
maximumOf :: Ord a => Fold s a       -> s -> Maybe a
maximumOf :: Ord a => Iso' s a       -> s -> Maybe a
maximumOf :: Ord a => Lens' s a      -> s -> Maybe a
maximumOf :: Ord a => Traversal' s a -> s -> Maybe a

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

Returns True if this Fold or Traversal has any targets in the given container.

A more "conversational" alias for this combinator is has.

Note: notNullOf on a valid Iso, Lens or Getter should always return True.

not . null ≡ notNullOf folded

This may be rather inefficient compared to the not . null check of many containers.

>>> notNullOf _1 (1,2)
True

>>> notNullOf traverse [1..10]
True

>>> notNullOf folded []
False

>>> notNullOf (element 20) [1..10]
False

notNullOf (folded . _1 . folded) :: (Foldable f, Foldable g) => f (g a, b) -> Bool

notNullOf :: Getter s a     -> s -> Bool
notNullOf :: Fold s a       -> s -> Bool
notNullOf :: Iso' s a       -> s -> Bool
notNullOf :: Lens' s a      -> s -> Bool
notNullOf :: Traversal' s a -> s -> Bool

nullOf :: Getting All s a -> s -> Bool #

Returns True if this Fold or Traversal has no targets in the given container.

Note: nullOf on a valid Iso, Lens or Getter should always return False.

null ≡ nullOf folded

This may be rather inefficient compared to the null check of many containers.

>>> nullOf _1 (1,2)
False

>>> nullOf ignored ()
True

>>> nullOf traverse []
True

>>> nullOf (element 20) [1..10]
True

nullOf (folded . _1 . folded) :: (Foldable f, Foldable g) => f (g a, b) -> Bool

nullOf :: Getter s a     -> s -> Bool
nullOf :: Fold s a       -> s -> Bool
nullOf :: Iso' s a       -> s -> Bool
nullOf :: Lens' s a      -> s -> Bool
nullOf :: Traversal' s a -> s -> Bool

last1Of :: Getting (Last a) s a -> s -> a #

Retrieve the Last entry of a Fold1 or Traversal1 or retrieve the result from a Getter or Lens.o

>>> last1Of traverse1 (1 :| [2..10])
10

>>> last1Of both1 (1,2)
2

last1Of :: Getter s a      -> s -> Maybe a
last1Of :: Fold1 s a       -> s -> Maybe a
last1Of :: Lens' s a       -> s -> Maybe a
last1Of :: Iso' s a        -> s -> Maybe a
last1Of :: Traversal1' s a -> s -> Maybe a

lastOf :: Getting (Rightmost a) s a -> s -> Maybe a #

Retrieve the Last entry of a Fold or Traversal or retrieve Just the result from a Getter or Lens.

The answer is computed in a manner that leaks space less than ala Last . foldMapOf and gives you back access to the outermost Just constructor more quickly, but may have worse constant factors.

>>> lastOf traverse [1..10]
Just 10

>>> lastOf both (1,2)
Just 2

>>> lastOf ignored ()
Nothing

lastOf :: Getter s a     -> s -> Maybe a
lastOf :: Fold s a       -> s -> Maybe a
lastOf :: Lens' s a      -> s -> Maybe a
lastOf :: Iso' s a       -> s -> Maybe a
lastOf :: Traversal' s a -> s -> Maybe a

first1Of :: Getting (First a) s a -> s -> a #

Retrieve the First entry of a Fold1 or Traversal1 or the result from a Getter or Lens.

>>> first1Of traverse1 (1 :| [2..10])
1

>>> first1Of both1 (1,2)
1

Note: this is different from ^..

>>> first1Of traverse1 ([1,2] :| [[3,4],[5,6]])
[1,2]

>>> ([1,2] :| [[3,4],[5,6]]) ^. traverse1
[1,2,3,4,5,6]

first1Of :: Getter s a      -> s -> a
first1Of :: Fold1 s a       -> s -> a
first1Of :: Lens' s a       -> s -> a
first1Of :: Iso' s a        -> s -> a
first1Of :: Traversal1' s a -> s -> a

firstOf :: Getting (Leftmost a) s a -> s -> Maybe a #

Retrieve the First entry of a Fold or Traversal or retrieve Just the result from a Getter or Lens.

The answer is computed in a manner that leaks space less than preview or ^?' and gives you back access to the outermost Just constructor more quickly, but does so in a way that builds an intermediate structure, and thus may have worse constant factors. This also means that it can not be used in any MonadReader, but must instead have s passed as its last argument, unlike preview.

Note: this could been named headOf.

>>> firstOf traverse [1..10]
Just 1

>>> firstOf both (1,2)
Just 1

>>> firstOf ignored ()
Nothing

firstOf :: Getter s a     -> s -> Maybe a
firstOf :: Fold s a       -> s -> Maybe a
firstOf :: Lens' s a      -> s -> Maybe a
firstOf :: Iso' s a       -> s -> Maybe a
firstOf :: Traversal' s a -> s -> Maybe a

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

Perform an *UNSAFE* head of a Fold or Traversal assuming that it is there.

>>> Left 4 ^?! _Left
4

>>> "world" ^?! ix 3
'l'

(^?!) :: s -> Getter s a     -> a
(^?!) :: s -> Fold s a       -> a
(^?!) :: s -> Lens' s a      -> a
(^?!) :: s -> Iso' s a       -> a
(^?!) :: s -> Traversal' s a -> a

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

Perform a safe head of a Fold or Traversal or retrieve Just the result from a Getter or Lens.

When using a Traversal as a partial Lens, or a Fold as a partial Getter this can be a convenient way to extract the optional value.

Note: if you get stack overflows due to this, you may want to use firstOf instead, which can deal more gracefully with heavily left-biased trees. This is because ^? works by using the First monoid, which can occasionally cause space leaks.

>>> Left 4 ^?_Left
Just 4

>>> Right 4 ^?_Left
Nothing

>>> "world" ^? ix 3
Just 'l'

>>> "world" ^? ix 20
Nothing

This operator works as an infix version of preview.

(^?) ≡ flip preview

It may be helpful to think of ^? as having one of the following more specialized types:

(^?) :: s -> Getter s a     -> Maybe a
(^?) :: s -> Fold s a       -> Maybe a
(^?) :: s -> Lens' s a      -> Maybe a
(^?) :: s -> Iso' s a       -> Maybe a
(^?) :: s -> Traversal' s a -> Maybe a

lengthOf :: Getting (Endo (Endo Int)) s a -> s -> Int #

Calculate the number of targets there are for a Fold in a given container.

Note: This can be rather inefficient for large containers and just like length, this will not terminate for infinite folds.

length ≡ lengthOf folded

>>> lengthOf _1 ("hello",())
1

>>> lengthOf traverse [1..10]
10

>>> lengthOf (traverse.traverse) [[1,2],[3,4],[5,6]]
6

lengthOf (folded . folded) :: (Foldable f, Foldable g) => f (g a) -> Int

lengthOf :: Getter s a     -> s -> Int
lengthOf :: Fold s a       -> s -> Int
lengthOf :: Lens' s a      -> s -> Int
lengthOf :: Iso' s a       -> s -> Int
lengthOf :: Traversal' s a -> s -> Int

concatOf :: Getting [r] s [r] -> s -> [r] #

Concatenate all of the lists targeted by a Fold into a longer list.

>>> concatOf both ("pan","ama")
"panama"

concat ≡ concatOf folded
concatOf ≡ view

concatOf :: Getter s [r]     -> s -> [r]
concatOf :: Fold s [r]       -> s -> [r]
concatOf :: Iso' s [r]       -> s -> [r]
concatOf :: Lens' s [r]      -> s -> [r]
concatOf :: Traversal' s [r] -> s -> [r]

concatMapOf :: Getting [r] s a -> (a -> [r]) -> s -> [r] #

Map a function over all the targets of a Fold of a container and concatenate the resulting lists.

>>> concatMapOf both (\x -> [x, x + 1]) (1,3)
[1,2,3,4]

concatMap ≡ concatMapOf folded

concatMapOf :: Getter s a     -> (a -> [r]) -> s -> [r]
concatMapOf :: Fold s a       -> (a -> [r]) -> s -> [r]
concatMapOf :: Lens' s a      -> (a -> [r]) -> s -> [r]
concatMapOf :: Iso' s a       -> (a -> [r]) -> s -> [r]
concatMapOf :: Traversal' s a -> (a -> [r]) -> s -> [r]

notElemOf :: Eq a => Getting All s a -> a -> s -> Bool #

Does the element not occur anywhere within a given Fold of the structure?

>>> notElemOf each 'd' ('a','b','c')
True

>>> notElemOf each 'a' ('a','b','c')
False

notElem ≡ notElemOf folded

notElemOf :: Eq a => Getter s a     -> a -> s -> Bool
notElemOf :: Eq a => Fold s a       -> a -> s -> Bool
notElemOf :: Eq a => Iso' s a       -> a -> s -> Bool
notElemOf :: Eq a => Lens' s a      -> a -> s -> Bool
notElemOf :: Eq a => Traversal' s a -> a -> s -> Bool
notElemOf :: Eq a => Prism' s a     -> a -> s -> Bool

elemOf :: Eq a => Getting Any s a -> a -> s -> Bool #

Does the element occur anywhere within a given Fold of the structure?

>>> elemOf both "hello" ("hello","world")
True

elem ≡ elemOf folded

elemOf :: Eq a => Getter s a     -> a -> s -> Bool
elemOf :: Eq a => Fold s a       -> a -> s -> Bool
elemOf :: Eq a => Lens' s a      -> a -> s -> Bool
elemOf :: Eq a => Iso' s a       -> a -> s -> Bool
elemOf :: Eq a => Traversal' s a -> a -> s -> Bool
elemOf :: Eq a => Prism' s a     -> a -> s -> Bool

msumOf :: MonadPlus m => Getting (Endo (m a)) s (m a) -> s -> m a #

The sum of a collection of actions, generalizing concatOf.

>>> msumOf both ("hello","world")
"helloworld"

>>> msumOf each (Nothing, Just "hello", Nothing)
Just "hello"

msum ≡ msumOf folded

msumOf :: MonadPlus m => Getter s (m a)     -> s -> m a
msumOf :: MonadPlus m => Fold s (m a)       -> s -> m a
msumOf :: MonadPlus m => Lens' s (m a)      -> s -> m a
msumOf :: MonadPlus m => Iso' s (m a)       -> s -> m a
msumOf :: MonadPlus m => Traversal' s (m a) -> s -> m a
msumOf :: MonadPlus m => Prism' s (m a)     -> s -> m a

asumOf :: Alternative f => Getting (Endo (f a)) s (f a) -> s -> f a #

The sum of a collection of actions, generalizing concatOf.

>>> asumOf both ("hello","world")
"helloworld"

>>> asumOf each (Nothing, Just "hello", Nothing)
Just "hello"

asum ≡ asumOf folded

asumOf :: Alternative f => Getter s (f a)     -> s -> f a
asumOf :: Alternative f => Fold s (f a)       -> s -> f a
asumOf :: Alternative f => Lens' s (f a)      -> s -> f a
asumOf :: Alternative f => Iso' s (f a)       -> s -> f a
asumOf :: Alternative f => Traversal' s (f a) -> s -> f a
asumOf :: Alternative f => Prism' s (f a)     -> s -> f a

sequenceOf_ :: Monad m => Getting (Sequenced a m) s (m a) -> s -> m () #

Evaluate each monadic action referenced by a Fold on the structure from left to right, and ignore the results.

>>> sequenceOf_ both (putStrLn "hello",putStrLn "world")
hello
world

sequence_ ≡ sequenceOf_ folded

sequenceOf_ :: Monad m => Getter s (m a)     -> s -> m ()
sequenceOf_ :: Monad m => Fold s (m a)       -> s -> m ()
sequenceOf_ :: Monad m => Lens' s (m a)      -> s -> m ()
sequenceOf_ :: Monad m => Iso' s (m a)       -> s -> m ()
sequenceOf_ :: Monad m => Traversal' s (m a) -> s -> m ()
sequenceOf_ :: Monad m => Prism' s (m a)     -> s -> m ()

forMOf_ :: Monad m => Getting (Sequenced r m) s a -> s -> (a -> m r) -> m () #

forMOf_ is mapMOf_ with two of its arguments flipped.

>>> forMOf_ both ("hello","world") putStrLn
hello
world

forM_ ≡ forMOf_ folded

forMOf_ :: Monad m => Getter s a     -> s -> (a -> m r) -> m ()
forMOf_ :: Monad m => Fold s a       -> s -> (a -> m r) -> m ()
forMOf_ :: Monad m => Lens' s a      -> s -> (a -> m r) -> m ()
forMOf_ :: Monad m => Iso' s a       -> s -> (a -> m r) -> m ()
forMOf_ :: Monad m => Traversal' s a -> s -> (a -> m r) -> m ()
forMOf_ :: Monad m => Prism' s a     -> s -> (a -> m r) -> m ()

mapMOf_ :: Monad m => Getting (Sequenced r m) s a -> (a -> m r) -> s -> m () #

Map each target of a Fold on a structure to a monadic action, evaluate these actions from left to right, and ignore the results.

>>> mapMOf_ both putStrLn ("hello","world")
hello
world

mapM_ ≡ mapMOf_ folded

mapMOf_ :: Monad m => Getter s a     -> (a -> m r) -> s -> m ()
mapMOf_ :: Monad m => Fold s a       -> (a -> m r) -> s -> m ()
mapMOf_ :: Monad m => Lens' s a      -> (a -> m r) -> s -> m ()
mapMOf_ :: Monad m => Iso' s a       -> (a -> m r) -> s -> m ()
mapMOf_ :: Monad m => Traversal' s a -> (a -> m r) -> s -> m ()
mapMOf_ :: Monad m => Prism' s a     -> (a -> m r) -> s -> m ()

sequence1Of_ :: Functor f => Getting (TraversedF a f) s (f a) -> s -> f () #

See sequenceAOf_ and traverse1Of_.

sequence1Of_ :: Apply f => Fold1 s (f a) -> s -> f ()

Since: lens-4.16

for1Of_ :: Functor f => Getting (TraversedF r f) s a -> s -> (a -> f r) -> f () #

See forOf_ and traverse1Of_.

>>> for1Of_ both1 ("abc", "bcd") (\ks -> Map.fromList [ (k, ()) | k <- ks ])
fromList [('b',()),('c',())]

for1Of_ :: Apply f => Fold1 s a -> s -> (a -> f r) -> f ()

Since: lens-4.16

traverse1Of_ :: Functor f => Getting (TraversedF r f) s a -> (a -> f r) -> s -> f () #

Traverse over all of the targets of a Fold1, computing an Apply based answer.

As long as you have Applicative or Functor effect you are better using traverseOf_. The traverse1Of_ is useful only when you have genuine Apply effect.

>>> traverse1Of_ both1 (\ks -> Map.fromList [ (k, ()) | k <- ks ]) ("abc", "bcd")
fromList [('b',()),('c',())]

traverse1Of_ :: Apply f => Fold1 s a -> (a -> f r) -> s -> f ()

Since: lens-4.16

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

Evaluate each action in observed by a Fold on a structure from left to right, ignoring the results.

sequenceA_ ≡ sequenceAOf_ folded

>>> sequenceAOf_ both (putStrLn "hello",putStrLn "world")
hello
world

sequenceAOf_ :: Functor f     => Getter s (f a)     -> s -> f ()
sequenceAOf_ :: Applicative f => Fold s (f a)       -> s -> f ()
sequenceAOf_ :: Functor f     => Lens' s (f a)      -> s -> f ()
sequenceAOf_ :: Functor f     => Iso' s (f a)       -> s -> f ()
sequenceAOf_ :: Applicative f => Traversal' s (f a) -> s -> f ()
sequenceAOf_ :: Applicative f => Prism' s (f a)     -> s -> f ()

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

Traverse over all of the targets of a Fold (or Getter), computing an Applicative (or Functor)-based answer, but unlike forOf do not construct a new structure. forOf_ generalizes for_ to work over any Fold.

When passed a Getter, forOf_ can work over any Functor, but when passed a Fold, forOf_ requires an Applicative.

for_ ≡ forOf_ folded

>>> forOf_ both ("hello","world") putStrLn
hello
world

The rather specific signature of forOf_ allows it to be used as if the signature was any of:

iforOf_ l s ≡ forOf_ l s . Indexed

forOf_ :: Functor f     => Getter s a     -> s -> (a -> f r) -> f ()
forOf_ :: Applicative f => Fold s a       -> s -> (a -> f r) -> f ()
forOf_ :: Functor f     => Lens' s a      -> s -> (a -> f r) -> f ()
forOf_ :: Functor f     => Iso' s a       -> s -> (a -> f r) -> f ()
forOf_ :: Applicative f => Traversal' s a -> s -> (a -> f r) -> f ()
forOf_ :: Applicative f => Prism' s a     -> s -> (a -> f r) -> f ()

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

Traverse over all of the targets of a Fold (or Getter), computing an Applicative (or Functor)-based answer, but unlike traverseOf do not construct a new structure. traverseOf_ generalizes traverse_ to work over any Fold.

When passed a Getter, traverseOf_ can work over any Functor, but when passed a Fold, traverseOf_ requires an Applicative.

>>> traverseOf_ both putStrLn ("hello","world")
hello
world

traverse_ ≡ traverseOf_ folded

traverseOf_ _2 :: Functor f => (c -> f r) -> (d, c) -> f ()
traverseOf_ _Left :: Applicative f => (a -> f b) -> Either a c -> f ()

itraverseOf_ l ≡ traverseOf_ l . Indexed

The rather specific signature of traverseOf_ allows it to be used as if the signature was any of:

traverseOf_ :: Functor f     => Getter s a     -> (a -> f r) -> s -> f ()
traverseOf_ :: Applicative f => Fold s a       -> (a -> f r) -> s -> f ()
traverseOf_ :: Functor f     => Lens' s a      -> (a -> f r) -> s -> f ()
traverseOf_ :: Functor f     => Iso' s a       -> (a -> f r) -> s -> f ()
traverseOf_ :: Applicative f => Traversal' s a -> (a -> f r) -> s -> f ()
traverseOf_ :: Applicative f => Prism' s a     -> (a -> f r) -> s -> f ()

sumOf :: Num a => Getting (Endo (Endo a)) s a -> s -> a #

Calculate the Sum of every number targeted by a Fold.

>>> sumOf both (5,6)
11
>>> sumOf folded [1,2,3,4]
10
>>> sumOf (folded.both) [(1,2),(3,4)]
10
>>> import Data.Data.Lens
>>> sumOf biplate [(1::Int,[]),(2,[(3::Int,4::Int)])] :: Int
10

sum ≡ sumOf folded

This operation may be more strict than you would expect. If you want a lazier version use ala Sum . foldMapOf

sumOf _1 :: Num a => (a, b) -> a
sumOf (folded . _1) :: (Foldable f, Num a) => f (a, b) -> a

sumOf :: Num a => Getter s a     -> s -> a
sumOf :: Num a => Fold s a       -> s -> a
sumOf :: Num a => Lens' s a      -> s -> a
sumOf :: Num a => Iso' s a       -> s -> a
sumOf :: Num a => Traversal' s a -> s -> a
sumOf :: Num a => Prism' s a     -> s -> a

productOf :: Num a => Getting (Endo (Endo a)) s a -> s -> a #

Calculate the Product of every number targeted by a Fold.

>>> productOf both (4,5)
20
>>> productOf folded [1,2,3,4,5]
120

product ≡ productOf folded

This operation may be more strict than you would expect. If you want a lazier version use ala Product . foldMapOf

productOf :: Num a => Getter s a     -> s -> a
productOf :: Num a => Fold s a       -> s -> a
productOf :: Num a => Lens' s a      -> s -> a
productOf :: Num a => Iso' s a       -> s -> a
productOf :: Num a => Traversal' s a -> s -> a
productOf :: Num a => Prism' s a     -> s -> a

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

Returns True only if no targets of a Fold satisfy a predicate.

>>> noneOf each (is _Nothing) (Just 3, Just 4, Just 5)
True
>>> noneOf (folded.folded) (<10) [[13,99,20],[3,71,42]]
False

inoneOf l = noneOf l . Indexed

noneOf :: Getter s a     -> (a -> Bool) -> s -> Bool
noneOf :: Fold s a       -> (a -> Bool) -> s -> Bool
noneOf :: Lens' s a      -> (a -> Bool) -> s -> Bool
noneOf :: Iso' s a       -> (a -> Bool) -> s -> Bool
noneOf :: Traversal' s a -> (a -> Bool) -> s -> Bool
noneOf :: Prism' s a     -> (a -> Bool) -> s -> Bool

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

Returns True if every target of a Fold satisfies a predicate.

>>> allOf both (>=3) (4,5)
True
>>> allOf folded (>=2) [1..10]
False

all ≡ allOf folded

iallOf l = allOf l . Indexed

allOf :: Getter s a     -> (a -> Bool) -> s -> Bool
allOf :: Fold s a       -> (a -> Bool) -> s -> Bool
allOf :: Lens' s a      -> (a -> Bool) -> s -> Bool
allOf :: Iso' s a       -> (a -> Bool) -> s -> Bool
allOf :: Traversal' s a -> (a -> Bool) -> s -> Bool
allOf :: Prism' s a     -> (a -> Bool) -> s -> Bool

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

Returns True if any target of a Fold satisfies a predicate.

>>> anyOf both (=='x') ('x','y')
True
>>> import Data.Data.Lens
>>> anyOf biplate (== "world") (((),2::Int),"hello",("world",11::Int))
True

any ≡ anyOf folded

ianyOf l ≡ anyOf l . Indexed

anyOf :: Getter s a     -> (a -> Bool) -> s -> Bool
anyOf :: Fold s a       -> (a -> Bool) -> s -> Bool
anyOf :: Lens' s a      -> (a -> Bool) -> s -> Bool
anyOf :: Iso' s a       -> (a -> Bool) -> s -> Bool
anyOf :: Traversal' s a -> (a -> Bool) -> s -> Bool
anyOf :: Prism' s a     -> (a -> Bool) -> s -> Bool

orOf :: Getting Any s Bool -> s -> Bool #

Returns True if any target of a Fold is True.

>>> orOf both (True,False)
True
>>> orOf both (False,False)
False

or ≡ orOf folded

orOf :: Getter s Bool     -> s -> Bool
orOf :: Fold s Bool       -> s -> Bool
orOf :: Lens' s Bool      -> s -> Bool
orOf :: Iso' s Bool       -> s -> Bool
orOf :: Traversal' s Bool -> s -> Bool
orOf :: Prism' s Bool     -> s -> Bool

andOf :: Getting All s Bool -> s -> Bool #

Returns True if every target of a Fold is True.

>>> andOf both (True,False)
False
>>> andOf both (True,True)
True

and ≡ andOf folded

andOf :: Getter s Bool     -> s -> Bool
andOf :: Fold s Bool       -> s -> Bool
andOf :: Lens' s Bool      -> s -> Bool
andOf :: Iso' s Bool       -> s -> Bool
andOf :: Traversal' s Bool -> s -> Bool
andOf :: Prism' s Bool     -> s -> Bool

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

A convenient infix (flipped) version of toListOf.

>>> [[1,2],[3]]^..id
[[[1,2],[3]]]
>>> [[1,2],[3]]^..traverse
[[1,2],[3]]
>>> [[1,2],[3]]^..traverse.traverse
[1,2,3]

>>> (1,2)^..both
[1,2]

toList xs ≡ xs ^.. folded
(^..) ≡ flip toListOf

(^..) :: s -> Getter s a     -> a :: s -> Fold s a       -> a :: s -> Lens' s a      -> a :: s -> Iso' s a       -> a :: s -> Traversal' s a -> a :: s -> Prism' s a     -> [a]

toNonEmptyOf :: Getting (NonEmptyDList a) s a -> s -> NonEmpty a #

Extract a NonEmpty of the targets of Fold1.

>>> toNonEmptyOf both1 ("hello", "world")
"hello" :| ["world"]

toNonEmptyOf :: Getter s a      -> s -> NonEmpty a
toNonEmptyOf :: Fold1 s a       -> s -> NonEmpty a
toNonEmptyOf :: Lens' s a       -> s -> NonEmpty a
toNonEmptyOf :: Iso' s a        -> s -> NonEmpty a
toNonEmptyOf :: Traversal1' s a -> s -> NonEmpty a
toNonEmptyOf :: Prism' s a      -> s -> NonEmpty a

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

Extract a list of the targets of a Fold. See also (^..).

toList ≡ toListOf folded
(^..) ≡ flip toListOf

foldlOf :: Getting (Dual (Endo r)) s a -> (r -> a -> r) -> r -> s -> r #

Left-associative fold of the parts of a structure that are viewed through a Lens, Getter, Fold or Traversal.

foldl ≡ foldlOf folded

foldlOf :: Getter s a     -> (r -> a -> r) -> r -> s -> r
foldlOf :: Fold s a       -> (r -> a -> r) -> r -> s -> r
foldlOf :: Lens' s a      -> (r -> a -> r) -> r -> s -> r
foldlOf :: Iso' s a       -> (r -> a -> r) -> r -> s -> r
foldlOf :: Traversal' s a -> (r -> a -> r) -> r -> s -> r
foldlOf :: Prism' s a     -> (r -> a -> r) -> r -> s -> r

foldrOf :: Getting (Endo r) s a -> (a -> r -> r) -> r -> s -> r #

Right-associative fold of parts of a structure that are viewed through a Lens, Getter, Fold or Traversal.

foldr ≡ foldrOf folded

foldrOf :: Getter s a     -> (a -> r -> r) -> r -> s -> r
foldrOf :: Fold s a       -> (a -> r -> r) -> r -> s -> r
foldrOf :: Lens' s a      -> (a -> r -> r) -> r -> s -> r
foldrOf :: Iso' s a       -> (a -> r -> r) -> r -> s -> r
foldrOf :: Traversal' s a -> (a -> r -> r) -> r -> s -> r
foldrOf :: Prism' s a     -> (a -> r -> r) -> r -> s -> r

ifoldrOf l ≡ foldrOf l . Indexed

foldrOf :: Getting (Endo r) s a -> (a -> r -> r) -> r -> s -> r

foldOf :: Getting a s a -> s -> a #

Combine the elements of a structure viewed through a Lens, Getter, Fold or Traversal using a monoid.

>>> foldOf (folded.folded) [[Sum 1,Sum 4],[Sum 8, Sum 8],[Sum 21]]
Sum {getSum = 42}

fold = foldOf folded

foldOf ≡ view

foldOf ::             Getter s m     -> s -> m
foldOf :: Monoid m => Fold s m       -> s -> m
foldOf ::             Lens' s m      -> s -> m
foldOf ::             Iso' s m       -> s -> m
foldOf :: Monoid m => Traversal' s m -> s -> m
foldOf :: Monoid m => Prism' s m     -> s -> m

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

Map each part of a structure viewed through a Lens, Getter, Fold or Traversal to a monoid and combine the results.

>>> foldMapOf (folded . both . _Just) Sum [(Just 21, Just 21)]
Sum {getSum = 42}

foldMap = foldMapOf folded

foldMapOf ≡ views
ifoldMapOf l = foldMapOf l . Indexed

foldMapOf ::                Getter s a      -> (a -> r) -> s -> r
foldMapOf :: Monoid r    => Fold s a        -> (a -> r) -> s -> r
foldMapOf :: Semigroup r => Fold1 s a       -> (a -> r) -> s -> r
foldMapOf ::                Lens' s a       -> (a -> r) -> s -> r
foldMapOf ::                Iso' s a        -> (a -> r) -> s -> r
foldMapOf :: Monoid r    => Traversal' s a  -> (a -> r) -> s -> r
foldMapOf :: Semigroup r => Traversal1' s a -> (a -> r) -> s -> r
foldMapOf :: Monoid r    => Prism' s a      -> (a -> r) -> s -> r

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

lined :: Applicative f => IndexedLensLike' Int f String String #

A Fold over the individual lines of a String.

lined :: Fold String String
lined :: Traversal' String String

lined :: IndexedFold Int String String
lined :: IndexedTraversal' Int String String

Note: This function type-checks as a Traversal but it doesn't satisfy the laws. It's only valid to use it when you don't insert any newline characters while traversing, and if your original String contains only isolated newline characters.

worded :: Applicative f => IndexedLensLike' Int f String String #

A Fold over the individual words of a String.

worded :: Fold String String
worded :: Traversal' String String

worded :: IndexedFold Int String String
worded :: IndexedTraversal' Int String String

Note: This function type-checks as a Traversal but it doesn't satisfy the laws. It's only valid to use it when you don't insert any whitespace characters while traversing, and if your original String contains only isolated space characters (and no other characters that count as space, such as non-breaking spaces).

droppingWhile :: (Conjoined p, Profunctor q, Applicative f) => (a -> Bool) -> Optical p q (Compose (State Bool) f) s t a a -> Optical p q f s t a a #

Obtain a Fold by dropping elements from another Fold, Lens, Iso, Getter or Traversal while a predicate holds.

dropWhile p ≡ toListOf (droppingWhile p folded)

>>> toListOf (droppingWhile (<=3) folded) [1..6]
[4,5,6]

>>> toListOf (droppingWhile (<=3) folded) [1,6,1]
[6,1]

droppingWhile :: (a -> Bool) -> Fold s a                         -> Fold s a
droppingWhile :: (a -> Bool) -> Getter s a                       -> Fold s a
droppingWhile :: (a -> Bool) -> Traversal' s a                   -> Fold s a                -- see notes
droppingWhile :: (a -> Bool) -> Lens' s a                        -> Fold s a                -- see notes
droppingWhile :: (a -> Bool) -> Prism' s a                       -> Fold s a                -- see notes
droppingWhile :: (a -> Bool) -> Iso' s a                         -> Fold s a                -- see notes

droppingWhile :: (a -> Bool) -> IndexPreservingTraversal' s a    -> IndexPreservingFold s a -- see notes
droppingWhile :: (a -> Bool) -> IndexPreservingLens' s a         -> IndexPreservingFold s a -- see notes
droppingWhile :: (a -> Bool) -> IndexPreservingGetter s a        -> IndexPreservingFold s a
droppingWhile :: (a -> Bool) -> IndexPreservingFold s a          -> IndexPreservingFold s a

droppingWhile :: (a -> Bool) -> IndexedTraversal' i s a          -> IndexedFold i s a       -- see notes
droppingWhile :: (a -> Bool) -> IndexedLens' i s a               -> IndexedFold i s a       -- see notes
droppingWhile :: (a -> Bool) -> IndexedGetter i s a              -> IndexedFold i s a
droppingWhile :: (a -> Bool) -> IndexedFold i s a                -> IndexedFold i s a

Note: Many uses of this combinator will yield something that meets the types, but not the laws of a valid Traversal or IndexedTraversal. The Traversal and IndexedTraversal laws are only satisfied if the new values you assign to the first target also does not pass the predicate! Otherwise subsequent traversals will visit fewer elements and Traversal fusion is not sound.

So for any traversal t and predicate p, droppingWhile p t may not be lawful, but (dropping 1 . droppingWhile p) t is. For example:

>>> let l  :: Traversal' [Int] Int; l  = droppingWhile (<= 1) traverse
>>> let l' :: Traversal' [Int] Int; l' = dropping 1 l

l is not a lawful setter because over l f . over l g ≢ over l (f . g):

>>> [1,2,3] & l .~ 0 & l .~ 4
[1,0,0]
>>> [1,2,3] & l .~ 4
[1,4,4]

l' on the other hand behaves lawfully:

>>> [1,2,3] & l' .~ 0 & l' .~ 4
[1,2,4]
>>> [1,2,3] & l' .~ 4
[1,2,4]

takingWhile :: (Conjoined p, Applicative f) => (a -> Bool) -> Over p (TakingWhile p f a a) s t a a -> Over p f s t a a #

Obtain a Fold by taking elements from another Fold, Lens, Iso, Getter or Traversal while a predicate holds.

takeWhile p ≡ toListOf (takingWhile p folded)

>>> timingOut $ toListOf (takingWhile (<=3) folded) [1..]
[1,2,3]

takingWhile :: (a -> Bool) -> Fold s a                         -> Fold s a
takingWhile :: (a -> Bool) -> Getter s a                       -> Fold s a
takingWhile :: (a -> Bool) -> Traversal' s a                   -> Fold s a -- * See note below
takingWhile :: (a -> Bool) -> Lens' s a                        -> Fold s a -- * See note below
takingWhile :: (a -> Bool) -> Prism' s a                       -> Fold s a -- * See note below
takingWhile :: (a -> Bool) -> Iso' s a                         -> Fold s a -- * See note below
takingWhile :: (a -> Bool) -> IndexedTraversal' i s a          -> IndexedFold i s a -- * See note below
takingWhile :: (a -> Bool) -> IndexedLens' i s a               -> IndexedFold i s a -- * See note below
takingWhile :: (a -> Bool) -> IndexedFold i s a                -> IndexedFold i s a
takingWhile :: (a -> Bool) -> IndexedGetter i s a              -> IndexedFold i s a

Note: When applied to a Traversal, takingWhile yields something that can be used as if it were a Traversal, but which is not a Traversal per the laws, unless you are careful to ensure that you do not invalidate the predicate when writing back through it.

filteredBy :: (Indexable i p, Applicative f) => Getting (First i) a i -> p a (f a) -> a -> f a #

Obtain a potentially empty IndexedTraversal by taking the first element from another, potentially empty Fold and using it as an index.

The resulting optic can be composed with to filter another Lens, Iso, Getter, Fold (or Traversal).

>>> [(Just 2, 3), (Nothing, 4)] & mapped . filteredBy (_1 . _Just) <. _2 %@~ (*) :: [(Maybe Int, Int)]
[(Just 2,6),(Nothing,4)]

filteredBy :: Fold a i -> IndexedTraversal' i a a

Note: As with filtered, this is not a legal IndexedTraversal, unless you are very careful not to invalidate the predicate on the target!

filtered :: (Choice p, Applicative f) => (a -> Bool) -> Optic' p f a a #

Obtain a Fold that can be composed with to filter another Lens, Iso, Getter, Fold (or Traversal).

Note: This is not a legal Traversal, unless you are very careful not to invalidate the predicate on the target.

Note: This is also not a legal Prism, unless you are very careful not to inject a value that fails the predicate.

As a counter example, consider that given evens = filtered even the second Traversal law is violated:

over evens succ . over evens succ /= over evens (succ . succ)

So, in order for this to qualify as a legal Traversal you can only use it for actions that preserve the result of the predicate!

>>> [1..10]^..folded.filtered even
[2,4,6,8,10]

This will preserve an index if it is present.

iterated :: Apply f => (a -> a) -> LensLike' f a a #

x ^. iterated f returns an infinite Fold1 of repeated applications of f to x.

toListOf (iterated f) a ≡ iterate f a

iterated :: (a -> a) -> Fold1 a a

unfolded :: (b -> Maybe (a, b)) -> Fold b a #

Build a Fold that unfolds its values from a seed.

unfoldr ≡ toListOf . unfolded

>>> 10^..unfolded (\b -> if b == 0 then Nothing else Just (b, b-1))
[10,9,8,7,6,5,4,3,2,1]

cycled :: Apply f => LensLike f s t a b -> LensLike f s t a b #

Transform a non-empty Fold into a Fold1 that loops over its elements over and over.

>>> timingOut $ [1,2,3]^..taking 7 (cycled traverse)
[1,2,3,1,2,3,1]

cycled :: Fold1 s a -> Fold1 s a

replicated :: Int -> Fold a a #

A Fold that replicates its input n times.

replicate n ≡ toListOf (replicated n)

>>> 5^..replicated 20
[5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5]

repeated :: Apply f => LensLike' f a a #

Form a Fold1 by repeating the input forever.

repeat ≡ toListOf repeated

>>> timingOut $ 5^..taking 20 repeated
[5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5]

repeated :: Fold1 a a

folded64 :: Foldable f => IndexedFold Int64 (f a) a #

Obtain a Fold from any Foldable indexed by ordinal position.

folded :: Foldable f => IndexedFold Int (f a) a #

Obtain a Fold from any Foldable indexed by ordinal position.

>>> Just 3^..folded
[3]

>>> Nothing^..folded
[]

>>> [(1,2),(3,4)]^..folded.both
[1,2,3,4]

ifoldring :: (Indexable i p, Contravariant f, Applicative f) => ((i -> a -> f a -> f a) -> f a -> s -> f a) -> Over p f s t a b #

Obtain FoldWithIndex by lifting ifoldr like function.

foldring :: (Contravariant f, Applicative f) => ((a -> f a -> f a) -> f a -> s -> f a) -> LensLike f s t a b #

Obtain a Fold by lifting foldr like function.

>>> [1,2,3,4]^..foldring foldr
[1,2,3,4]

ifolding :: (Foldable f, Indexable i p, Contravariant g, Applicative g) => (s -> f (i, a)) -> Over p g s t a b #

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

Obtain a Fold by lifting an operation that returns a Foldable result.

This can be useful to lift operations from Data.List and elsewhere into a Fold.

>>> [1,2,3,4]^..folding tail
[2,3,4]

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

This is an improper prism for text formatting based on Read and Show.

This Prism is "improper" in the sense that it normalizes the text formatting, but round tripping is idempotent given sane 'Read'/'Show' instances.

>>> _Show # 2
"2"

>>> "EQ" ^? _Show :: Maybe Ordering
Just EQ

_Show ≡ prism' show readMaybe

nearly :: a -> (a -> Bool) -> Prism' a () #

This Prism compares for approximate equality with a given value and a predicate for testing, an example where the value is the empty list and the predicate checks that a list is empty (same as _Empty with the AsEmpty list instance):

>>> nearly [] null # ()
[]
>>> [1,2,3,4] ^? nearly [] null
Nothing

nearly [] null :: Prism' [a] ()

To comply with the Prism laws the arguments you supply to nearly a p are somewhat constrained.

We assume p x holds iff x ≡ a. Under that assumption then this is a valid Prism.

This is useful when working with a type where you can test equality for only a subset of its values, and the prism selects such a value.

only :: Eq a => a -> Prism' a () #

This Prism compares for exact equality with a given value.

>>> only 4 # ()
4

>>> 5 ^? only 4
Nothing

_Void :: Prism s s a Void #

Void is a logically uninhabited data type.

This is a Prism that will always fail to match.

_Nothing :: Prism' (Maybe a) () #

This Prism provides the Traversal of a Nothing in a Maybe.

>>> Nothing ^? _Nothing
Just ()

>>> Just () ^? _Nothing
Nothing

But you can turn it around and use it to construct Nothing as well:

>>> _Nothing # ()
Nothing

_Just :: Prism (Maybe a) (Maybe b) a b #

This Prism provides a Traversal for tweaking the target of the value of Just in a Maybe.

>>> over _Just (+1) (Just 2)
Just 3

Unlike traverse this is a Prism, and so you can use it to inject as well:

>>> _Just # 5
Just 5

>>> 5^.re _Just
Just 5

Interestingly,

m ^? _Just ≡ m

>>> Just x ^? _Just
Just x

>>> Nothing ^? _Just
Nothing

_Right :: Prism (Either c a) (Either c b) a b #

This Prism provides a Traversal for tweaking the Right half of an Either:

>>> over _Right (+1) (Left 2)
Left 2

>>> over _Right (+1) (Right 2)
Right 3

>>> Right "hello" ^._Right
"hello"

>>> Left "hello" ^._Right :: [Double]
[]

It also can be turned around to obtain the embedding into the Right half of an Either:

>>> _Right # 5
Right 5

>>> 5^.re _Right
Right 5

_Left :: Prism (Either a c) (Either b c) a b #

This Prism provides a Traversal for tweaking the Left half of an Either:

>>> over _Left (+1) (Left 2)
Left 3

>>> over _Left (+1) (Right 2)
Right 2

>>> Right 42 ^._Left :: String
""

>>> Left "hello" ^._Left
"hello"

It also can be turned around to obtain the embedding into the Left half of an Either:

>>> _Left # 5
Left 5

>>> 5^.re _Left
Left 5

matching :: APrism s t a b -> s -> Either t a #

Retrieve the value targeted by a Prism or return the original value while allowing the type to change if it does not match.

>>> matching _Just (Just 12)
Right 12

>>> matching _Just (Nothing :: Maybe Int) :: Either (Maybe Bool) Int
Left Nothing

isn't :: APrism s t a b -> s -> Bool #

Check to see if this Prism doesn't match.

>>> isn't _Left (Right 12)
True

>>> isn't _Left (Left 12)
False

>>> isn't _Empty []
False

isn't = not . is
isn't = hasn't

below :: Traversable f => APrism' s a -> Prism' (f s) (f a) #

lift a Prism through a Traversable functor, giving a Prism that matches only if all the elements of the container match the Prism.

>>> [Left 1, Right "foo", Left 4, Right "woot"]^..below _Right
[]

>>> [Right "hail hydra!", Right "foo", Right "blah", Right "woot"]^..below _Right
[["hail hydra!","foo","blah","woot"]]

aside :: APrism s t a b -> Prism (e, s) (e, t) (e, a) (e, b) #

Use a Prism to work over part of a structure.

without :: APrism s t a b -> APrism u v c d -> Prism (Either s u) (Either t v) (Either a c) (Either b d) #

Given a pair of prisms, project sums.

Viewing a Prism as a co-Lens, this combinator can be seen to be dual to alongside.

outside :: Representable p => APrism s t a b -> Lens (p t r) (p s r) (p b r) (p a r) #

Use a Prism as a kind of first-class pattern.

outside :: Prism s t a b -> Lens (t -> r) (s -> r) (b -> r) (a -> r)

prism' :: (b -> s) -> (s -> Maybe a) -> Prism s s a b #

This is usually used to build a Prism', when you have to use an operation like cast which already returns a Maybe.

prism :: (b -> t) -> (s -> Either t a) -> Prism s t a b #

Build a Prism.

Either t a is used instead of Maybe a to permit the types of s and t to differ.

clonePrism :: APrism s t a b -> Prism s t a b #

Clone a Prism so that you can reuse the same monomorphically typed Prism for different purposes.

See cloneLens and cloneTraversal for examples of why you might want to do this.

withPrism :: APrism s t a b -> ((b -> t) -> (s -> Either t a) -> r) -> r #

Convert APrism to the pair of functions that characterize it.

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

If you see this in a signature for a function, the function is expecting a Prism.

type APrism' s a = APrism s s a a #

type APrism' = Simple APrism

reuses :: MonadState b m => AReview t b -> (t -> r) -> m r #

This can be used to turn an Iso or Prism around and use the current state through it the other way, applying a function.

reuses ≡ uses . re
reuses (unto f) g ≡ gets (g . f)

>>> evalState (reuses _Left isLeft) (5 :: Int)
True

reuses :: MonadState a m => Prism' s a -> (s -> r) -> m r
reuses :: MonadState a m => Iso' s a   -> (s -> r) -> m r

reuse :: MonadState b m => AReview t b -> m t #

This can be used to turn an Iso or Prism around and use a value (or the current environment) through it the other way.

reuse ≡ use . re
reuse . unto ≡ gets

>>> evalState (reuse _Left) 5
Left 5

>>> evalState (reuse (unto succ)) 5
6

reuse :: MonadState a m => Prism' s a -> m s
reuse :: MonadState a m => Iso' s a   -> m s

reviews :: MonadReader b m => AReview t b -> (t -> r) -> m r #

This can be used to turn an Iso or Prism around and view a value (or the current environment) through it the other way, applying a function.

reviews ≡ views . re
reviews (unto f) g ≡ g . f

>>> reviews _Left isRight "mustard"
False

>>> reviews (unto succ) (*2) 3
8

Usually this function is used in the (->) Monad with a Prism or Iso, in which case it may be useful to think of it as having one of these more restricted type signatures:

reviews :: Iso' s a   -> (s -> r) -> a -> r
reviews :: Prism' s a -> (s -> r) -> a -> r

However, when working with a Monad transformer stack, it is sometimes useful to be able to review the current environment, in which case it may be beneficial to think of it as having one of these slightly more liberal type signatures:

reviews :: MonadReader a m => Iso' s a   -> (s -> r) -> m r
reviews :: MonadReader a m => Prism' s a -> (s -> r) -> m r

(#) :: AReview t b -> b -> t infixr 8 #

An infix alias for review.

unto f # x ≡ f x
l # x ≡ x ^. re l

This is commonly used when using a Prism as a smart constructor.

>>> _Left # 4
Left 4

But it can be used for any Prism

>>> base 16 # 123
"7b"

(#) :: Iso'      s a -> a -> s
(#) :: Prism'    s a -> a -> s
(#) :: Review    s a -> a -> s
(#) :: Equality' s a -> a -> s

review :: MonadReader b m => AReview t b -> m t #

This can be used to turn an Iso or Prism around and view a value (or the current environment) through it the other way.

review ≡ view . re
review . unto ≡ id

>>> review _Left "mustard"
Left "mustard"

>>> review (unto succ) 5
6

Usually review is used in the (->) Monad with a Prism or Iso, in which case it may be useful to think of it as having one of these more restricted type signatures:

review :: Iso' s a   -> a -> s
review :: Prism' s a -> a -> s

However, when working with a Monad transformer stack, it is sometimes useful to be able to review the current environment, in which case it may be beneficial to think of it as having one of these slightly more liberal type signatures:

review :: MonadReader a m => Iso' s a   -> m s
review :: MonadReader a m => Prism' s a -> m s

re :: AReview t b -> Getter b t #

Turn a Prism or Iso around to build a Getter.

If you have an Iso, from is a more powerful version of this function that will return an Iso instead of a mere Getter.

>>> 5 ^.re _Left
Left 5

>>> 6 ^.re (_Left.unto succ)
Left 7

review  ≡ view  . re
reviews ≡ views . re
reuse   ≡ use   . re
reuses  ≡ uses  . re

re :: Prism s t a b -> Getter b t
re :: Iso s t a b   -> Getter b t

un :: (Profunctor p, Bifunctor p, Functor f) => Getting a s a -> Optic' p f a s #

Turn a Getter around to get a Review

un = unto . view
unto = un . to

>>> un (to length) # [1,2,3]
3

unto :: (Profunctor p, Bifunctor p, Functor f) => (b -> t) -> Optic p f s t a b #

An analogue of to for review.

unto :: (b -> t) -> Review' t b

unto = un . to

getting :: (Profunctor p, Profunctor q, Functor f, Contravariant f) => Optical p q f s t a b -> Optical' p q f s a #

Coerce a Getter-compatible Optical to an Optical'. This is useful when using a Traversal that is not simple as a Getter or a Fold.

getting :: Traversal s t a b          -> Fold s a
getting :: Lens s t a b               -> Getter s a
getting :: IndexedTraversal i s t a b -> IndexedFold i s a
getting :: IndexedLens i s t a b      -> IndexedGetter i s a

(^@.) :: s -> IndexedGetting i (i, a) s a -> (i, a) infixl 8 #

View the index and value of an IndexedGetter or IndexedLens.

This is the same operation as iview with the arguments flipped.

The fixity and semantics are such that subsequent field accesses can be performed with (.).

(^@.) :: s -> IndexedGetter i s a -> (i, a)
(^@.) :: s -> IndexedLens' i s a  -> (i, a)

The result probably doesn't have much meaning when applied to an IndexedFold.

iuses :: MonadState s m => IndexedGetting i r s a -> (i -> a -> r) -> m r #

Use a function of the index and value of an IndexedGetter into the current state.

When applied to an IndexedFold the result will be a monoidal summary instead of a single answer.

iuse :: MonadState s m => IndexedGetting i (i, a) s a -> m (i, a) #

Use the index and value of an IndexedGetter into the current state as a pair.

When applied to an IndexedFold the result will most likely be a nonsensical monoidal summary of the indices tupled with a monoidal summary of the values and probably not whatever it is you wanted.

iviews :: MonadReader s m => IndexedGetting i r s a -> (i -> a -> r) -> m r #

View a function of the index and value of an IndexedGetter into the current environment.

When applied to an IndexedFold the result will be a monoidal summary instead of a single answer.

iviews ≡ ifoldMapOf

iview :: MonadReader s m => IndexedGetting i (i, a) s a -> m (i, a) #

View the index and value of an IndexedGetter into the current environment as a pair.

When applied to an IndexedFold the result will most likely be a nonsensical monoidal summary of the indices tupled with a monoidal summary of the values and probably not whatever it is you wanted.

ilistenings :: MonadWriter w m => IndexedGetting i v w u -> (i -> u -> v) -> m a -> m (a, v) #

This is a generalized form of listen that only extracts the portion of the log that is focused on by a Getter. If given a Fold or a Traversal then a monoidal summary of the parts of the log that are visited will be returned.

ilistenings :: MonadWriter w m             => IndexedGetter w u     -> (i -> u -> v) -> m a -> m (a, v)
ilistenings :: MonadWriter w m             => IndexedLens' w u      -> (i -> u -> v) -> m a -> m (a, v)
ilistenings :: (MonadWriter w m, Monoid v) => IndexedFold w u       -> (i -> u -> v) -> m a -> m (a, v)
ilistenings :: (MonadWriter w m, Monoid v) => IndexedTraversal' w u -> (i -> u -> v) -> m a -> m (a, v)

listenings :: MonadWriter w m => Getting v w u -> (u -> v) -> m a -> m (a, v) #

This is a generalized form of listen that only extracts the portion of the log that is focused on by a Getter. If given a Fold or a Traversal then a monoidal summary of the parts of the log that are visited will be returned.

listenings :: MonadWriter w m             => Getter w u     -> (u -> v) -> m a -> m (a, v)
listenings :: MonadWriter w m             => Lens' w u      -> (u -> v) -> m a -> m (a, v)
listenings :: MonadWriter w m             => Iso' w u       -> (u -> v) -> m a -> m (a, v)
listenings :: (MonadWriter w m, Monoid v) => Fold w u       -> (u -> v) -> m a -> m (a, v)
listenings :: (MonadWriter w m, Monoid v) => Traversal' w u -> (u -> v) -> m a -> m (a, v)
listenings :: (MonadWriter w m, Monoid v) => Prism' w u     -> (u -> v) -> m a -> m (a, v)

ilistening :: MonadWriter w m => IndexedGetting i (i, u) w u -> m a -> m (a, (i, u)) #

This is a generalized form of listen that only extracts the portion of the log that is focused on by a Getter. If given a Fold or a Traversal then a monoidal summary of the parts of the log that are visited will be returned.

ilistening :: MonadWriter w m             => IndexedGetter i w u     -> m a -> m (a, (i, u))
ilistening :: MonadWriter w m             => IndexedLens' i w u      -> m a -> m (a, (i, u))
ilistening :: (MonadWriter w m, Monoid u) => IndexedFold i w u       -> m a -> m (a, (i, u))
ilistening :: (MonadWriter w m, Monoid u) => IndexedTraversal' i w u -> m a -> m (a, (i, u))

listening :: MonadWriter w m => Getting u w u -> m a -> m (a, u) #

This is a generalized form of listen that only extracts the portion of the log that is focused on by a Getter. If given a Fold or a Traversal then a monoidal summary of the parts of the log that are visited will be returned.

listening :: MonadWriter w m             => Getter w u     -> m a -> m (a, u)
listening :: MonadWriter w m             => Lens' w u      -> m a -> m (a, u)
listening :: MonadWriter w m             => Iso' w u       -> m a -> m (a, u)
listening :: (MonadWriter w m, Monoid u) => Fold w u       -> m a -> m (a, u)
listening :: (MonadWriter w m, Monoid u) => Traversal' w u -> m a -> m (a, u)
listening :: (MonadWriter w m, Monoid u) => Prism' w u     -> m a -> m (a, u)

uses :: MonadState s m => LensLike' (Const r :: Type -> Type) s a -> (a -> r) -> m r #

Use the target of a Lens, Iso or Getter in the current state, or use a summary of a Fold or Traversal that points to a monoidal value.

>>> evalState (uses _1 length) ("hello","world")
5

uses :: MonadState s m             => Getter s a     -> (a -> r) -> m r
uses :: (MonadState s m, Monoid r) => Fold s a       -> (a -> r) -> m r
uses :: MonadState s m             => Lens' s a      -> (a -> r) -> m r
uses :: MonadState s m             => Iso' s a       -> (a -> r) -> m r
uses :: (MonadState s m, Monoid r) => Traversal' s a -> (a -> r) -> m r

uses :: MonadState s m => Getting r s t a b -> (a -> r) -> m r

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

Use the target of a Lens, Iso, or Getter in the current state, or use a summary of a Fold or Traversal that points to a monoidal value.

>>> evalState (use _1) (a,b)
a

>>> evalState (use _1) ("hello","world")
"hello"

use :: MonadState s m             => Getter s a     -> m a
use :: (MonadState s m, Monoid r) => Fold s r       -> m r
use :: MonadState s m             => Iso' s a       -> m a
use :: MonadState s m             => Lens' s a      -> m a
use :: (MonadState s m, Monoid r) => Traversal' s r -> m r

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

View the value pointed to by a Getter or Lens or the result of folding over all the results of a Fold or Traversal that points at a monoidal values.

This is the same operation as view with the arguments flipped.

The fixity and semantics are such that subsequent field accesses can be performed with (.).

>>> (a,b)^._2
b

>>> ("hello","world")^._2
"world"

>>> import Data.Complex
>>> ((0, 1 :+ 2), 3)^._1._2.to magnitude
2.23606797749979

(^.) ::             s -> Getter s a     -> a
(^.) :: Monoid m => s -> Fold s m       -> m
(^.) ::             s -> Iso' s a       -> a
(^.) ::             s -> Lens' s a      -> a
(^.) :: Monoid m => s -> Traversal' s m -> m

views :: MonadReader s m => LensLike' (Const r :: Type -> Type) s a -> (a -> r) -> m r #

View a function of the value pointed to by a Getter or Lens or the result of folding over the result of mapping the targets of a Fold or Traversal.

views l f ≡ view (l . to f)

>>> views (to f) g a
g (f a)

>>> views _2 length (1,"hello")
5

As views is commonly used to access the target of a Getter or obtain a monoidal summary of the targets of a Fold, It may be useful to think of it as having one of these more restricted signatures:

views ::             Getter s a     -> (a -> r) -> s -> r
views :: Monoid m => Fold s a       -> (a -> m) -> s -> m
views ::             Iso' s a       -> (a -> r) -> s -> r
views ::             Lens' s a      -> (a -> r) -> s -> r
views :: Monoid m => Traversal' s a -> (a -> m) -> s -> m

In a more general setting, such as when working with a Monad transformer stack you can use:

views :: MonadReader s m             => Getter s a     -> (a -> r) -> m r
views :: (MonadReader s m, Monoid r) => Fold s a       -> (a -> r) -> m r
views :: MonadReader s m             => Iso' s a       -> (a -> r) -> m r
views :: MonadReader s m             => Lens' s a      -> (a -> r) -> m r
views :: (MonadReader s m, Monoid r) => Traversal' s a -> (a -> r) -> m r

views :: MonadReader s m => Getting r s a -> (a -> r) -> m r

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

View the value pointed to by a Getter, Iso or Lens or the result of folding over all the results of a Fold or Traversal that points at a monoidal value.

view . to ≡ id

>>> view (to f) a
f a

>>> view _2 (1,"hello")
"hello"

>>> view (to succ) 5
6

>>> view (_2._1) ("hello",("world","!!!"))
"world"

As view is commonly used to access the target of a Getter or obtain a monoidal summary of the targets of a Fold, It may be useful to think of it as having one of these more restricted signatures:

view ::             Getter s a     -> s -> a
view :: Monoid m => Fold s m       -> s -> m
view ::             Iso' s a       -> s -> a
view ::             Lens' s a      -> s -> a
view :: Monoid m => Traversal' s m -> s -> m

In a more general setting, such as when working with a Monad transformer stack you can use:

view :: MonadReader s m             => Getter s a     -> m a
view :: (MonadReader s m, Monoid a) => Fold s a       -> m a
view :: MonadReader s m             => Iso' s a       -> m a
view :: MonadReader s m             => Lens' s a      -> m a
view :: (MonadReader s m, Monoid a) => Traversal' s a -> m a

ilike :: (Indexable i p, Contravariant f, Functor f) => i -> a -> Over' p f s a #

ilike :: i -> a -> IndexedGetter i s a

like :: (Profunctor p, Contravariant f, Functor f) => a -> Optic' p f s a #

Build an constant-valued (index-preserving) Getter from an arbitrary Haskell value.

like a . like b ≡ like b
a ^. like b ≡ b
a ^. like b ≡ a ^. to (const b)

This can be useful as a second case failing a Fold e.g. foo failing like 0

like :: a -> IndexPreservingGetter s a

ito :: (Indexable i p, Contravariant f) => (s -> (i, a)) -> Over' p f s a #

ito :: (s -> (i, a)) -> IndexedGetter i s a

to :: (Profunctor p, Contravariant f) => (s -> a) -> Optic' p f s a #

Build an (index-preserving) Getter from an arbitrary Haskell function.

to f . to g ≡ to (g . f)

a ^. to f ≡ f a

>>> a ^.to f
f a

>>> ("hello","world")^.to snd
"world"

>>> 5^.to succ
6

>>> (0, -5)^._2.to abs
5

to :: (s -> a) -> IndexPreservingGetter s a

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

When you see this in a type signature it indicates that you can pass the function a Lens, Getter, Traversal, Fold, Prism, Iso, or one of the indexed variants, and it will just "do the right thing".

Most Getter combinators are able to be used with both a Getter or a Fold in limited situations, to do so, they need to be monomorphic in what we are going to extract with Const. To be compatible with Lens, Traversal and Iso we also restricted choices of the irrelevant t and b parameters.

If a function accepts a Getting r s a, then when r is a Monoid, then you can pass a Fold (or Traversal), otherwise you can only pass this a Getter or Lens.

type IndexedGetting i m s a = Indexed i a (Const m a) -> s -> Const m s #

Used to consume an IndexedFold.

type Accessing (p :: Type -> Type -> Type) m s a = p a (Const m a) -> s -> Const m s #

This is a convenient alias used when consuming (indexed) getters and (indexed) folds in a highly general fashion.

_19' :: Field19 s t a b => Lens s t a b #

Strict version of _19

_18' :: Field18 s t a b => Lens s t a b #

Strict version of _18

_17' :: Field17 s t a b => Lens s t a b #

Strict version of _17

_16' :: Field16 s t a b => Lens s t a b #

Strict version of _16

_15' :: Field15 s t a b => Lens s t a b #

Strict version of _15

_14' :: Field14 s t a b => Lens s t a b #

Strict version of _14

_13' :: Field13 s t a b => Lens s t a b #

Strict version of _13

_12' :: Field12 s t a b => Lens s t a b #

Strict version of _12

_11' :: Field11 s t a b => Lens s t a b #

Strict version of _11

_10' :: Field10 s t a b => Lens s t a b #

Strict version of _10

_9' :: Field9 s t a b => Lens s t a b #

Strict version of _9

_8' :: Field8 s t a b => Lens s t a b #

Strict version of _8

_7' :: Field7 s t a b => Lens s t a b #

Strict version of _7

_6' :: Field6 s t a b => Lens s t a b #

Strict version of _6

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

Strict version of _5

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

Strict version of _4

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

Strict version of _3

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

Strict version of _2

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

Strict version of _1

class Field1 s t a b | s -> a, t -> b, s b -> t, t a -> s where #

Provides access to 1st field of a tuple.

Minimal complete definition

Nothing

Methods

_1 :: Lens s t a b #

Access the 1st field of a tuple (and possibly change its type).

>>> (1,2)^._1
1

>>> _1 .~ "hello" $ (1,2)
("hello",2)

>>> (1,2) & _1 .~ "hello"
("hello",2)

>>> _1 putStrLn ("hello","world")
hello
((),"world")

This can also be used on larger tuples as well:

>>> (1,2,3,4,5) & _1 +~ 41
(42,2,3,4,5)

_1 :: Lens (a,b) (a',b) a a'
_1 :: Lens (a,b,c) (a',b,c) a a'
_1 :: Lens (a,b,c,d) (a',b,c,d) a a'
...
_1 :: Lens (a,b,c,d,e,f,g,h,i) (a',b,c,d,e,f,g,h,i) a a'

Instances

Field1 (Identity a) (Identity b) a b
Instance details Defined in Control.Lens.Tuple Methods _1 :: Lens (Identity a) (Identity b) a b #
Field1 (a, b) (a', b) a a'	`_1` k ~(a,b) = (\a' -> (a',b)) `<$>` k a
Instance details Defined in Control.Lens.Tuple Methods _1 :: Lens (a, b) (a', b) a a' #
Field1 (a, b, c) (a', b, c) a a'
Instance details Defined in Control.Lens.Tuple Methods _1 :: Lens (a, b, c) (a', b, c) a a' #
Field1 (a, b, c, d) (a', b, c, d) a a'
Instance details Defined in Control.Lens.Tuple Methods _1 :: Lens (a, b, c, d) (a', b, c, d) a a' #
Field1 ((f :: g) p) ((f' :: g) p) (f p) (f' p)
Instance details Defined in Control.Lens.Tuple Methods _1 :: Lens ((f :: g) p) ((f' :: g) p) (f p) (f' p) #
Field1 (Product f g a) (Product f' g a) (f a) (f' a)
Instance details Defined in Control.Lens.Tuple Methods _1 :: Lens (Product f g a) (Product f' g a) (f a) (f' a) #
Field1 (a, b, c, d, e) (a', b, c, d, e) a a'
Instance details Defined in Control.Lens.Tuple Methods _1 :: Lens (a, b, c, d, e) (a', b, c, d, e) a a' #
Field1 (a, b, c, d, e, f) (a', b, c, d, e, f) a a'
Instance details Defined in Control.Lens.Tuple Methods _1 :: Lens (a, b, c, d, e, f) (a', b, c, d, e, f) a a' #
Field1 (a, b, c, d, e, f, g) (a', b, c, d, e, f, g) a a'
Instance details Defined in Control.Lens.Tuple Methods _1 :: Lens (a, b, c, d, e, f, g) (a', b, c, d, e, f, g) a a' #
Field1 (a, b, c, d, e, f, g, h) (a', b, c, d, e, f, g, h) a a'
Instance details Defined in Control.Lens.Tuple Methods _1 :: Lens (a, b, c, d, e, f, g, h) (a', b, c, d, e, f, g, h) a a' #
Field1 (a, b, c, d, e, f, g, h, i) (a', b, c, d, e, f, g, h, i) a a'
Instance details Defined in Control.Lens.Tuple Methods _1 :: Lens (a, b, c, d, e, f, g, h, i) (a', b, c, d, e, f, g, h, i) a a' #
Field1 (a, b, c, d, e, f, g, h, i, j) (a', b, c, d, e, f, g, h, i, j) a a'
Instance details Defined in Control.Lens.Tuple Methods _1 :: Lens (a, b, c, d, e, f, g, h, i, j) (a', b, c, d, e, f, g, h, i, j) a a' #
Field1 (a, b, c, d, e, f, g, h, i, j, kk) (a', b, c, d, e, f, g, h, i, j, kk) a a'
Instance details Defined in Control.Lens.Tuple Methods _1 :: Lens (a, b, c, d, e, f, g, h, i, j, kk) (a', b, c, d, e, f, g, h, i, j, kk) a a' #
Field1 (a, b, c, d, e, f, g, h, i, j, kk, l) (a', b, c, d, e, f, g, h, i, j, kk, l) a a'
Instance details Defined in Control.Lens.Tuple Methods _1 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l) (a', b, c, d, e, f, g, h, i, j, kk, l) a a' #
Field1 (a, b, c, d, e, f, g, h, i, j, kk, l, m) (a', b, c, d, e, f, g, h, i, j, kk, l, m) a a'
Instance details Defined in Control.Lens.Tuple Methods _1 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m) (a', b, c, d, e, f, g, h, i, j, kk, l, m) a a' #
Field1 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n) (a', b, c, d, e, f, g, h, i, j, kk, l, m, n) a a'
Instance details Defined in Control.Lens.Tuple Methods _1 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n) (a', b, c, d, e, f, g, h, i, j, kk, l, m, n) a a' #
Field1 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o) (a', b, c, d, e, f, g, h, i, j, kk, l, m, n, o) a a'
Instance details Defined in Control.Lens.Tuple Methods _1 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o) (a', b, c, d, e, f, g, h, i, j, kk, l, m, n, o) a a' #
Field1 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p) (a', b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p) a a'
Instance details Defined in Control.Lens.Tuple Methods _1 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p) (a', b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p) a a' #
Field1 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q) (a', b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q) a a'
Instance details Defined in Control.Lens.Tuple Methods _1 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q) (a', b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q) a a' #
Field1 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r) (a', b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r) a a'
Instance details Defined in Control.Lens.Tuple Methods _1 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r) (a', b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r) a a' #
Field1 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s) (a', b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s) a a'
Instance details Defined in Control.Lens.Tuple Methods _1 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s) (a', b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s) a a' #

class Field2 s t a b | s -> a, t -> b, s b -> t, t a -> s where #

Provides access to the 2nd field of a tuple.

Minimal complete definition

Nothing

Methods

_2 :: Lens s t a b #

Access the 2nd field of a tuple.

>>> _2 .~ "hello" $ (1,(),3,4)
(1,"hello",3,4)

>>> (1,2,3,4) & _2 *~ 3
(1,6,3,4)

>>> _2 print (1,2)
2
(1,())

anyOf _2 :: (s -> Bool) -> (a, s) -> Bool
traverse . _2 :: (Applicative f, Traversable t) => (a -> f b) -> t (s, a) -> f (t (s, b))
foldMapOf (traverse . _2) :: (Traversable t, Monoid m) => (s -> m) -> t (b, s) -> m

Instances

Field2 (a, b) (a, b') b b'	`_2` k ~(a,b) = (\b' -> (a,b')) `<$>` k b
Instance details Defined in Control.Lens.Tuple Methods _2 :: Lens (a, b) (a, b') b b' #
Field2 (a, b, c) (a, b', c) b b'
Instance details Defined in Control.Lens.Tuple Methods _2 :: Lens (a, b, c) (a, b', c) b b' #
Field2 (a, b, c, d) (a, b', c, d) b b'
Instance details Defined in Control.Lens.Tuple Methods _2 :: Lens (a, b, c, d) (a, b', c, d) b b' #
Field2 ((f :: g) p) ((f :: g') p) (g p) (g' p)
Instance details Defined in Control.Lens.Tuple Methods _2 :: Lens ((f :: g) p) ((f :: g') p) (g p) (g' p) #
Field2 (Product f g a) (Product f g' a) (g a) (g' a)
Instance details Defined in Control.Lens.Tuple Methods _2 :: Lens (Product f g a) (Product f g' a) (g a) (g' a) #
Field2 (a, b, c, d, e) (a, b', c, d, e) b b'
Instance details Defined in Control.Lens.Tuple Methods _2 :: Lens (a, b, c, d, e) (a, b', c, d, e) b b' #
Field2 (a, b, c, d, e, f) (a, b', c, d, e, f) b b'
Instance details Defined in Control.Lens.Tuple Methods _2 :: Lens (a, b, c, d, e, f) (a, b', c, d, e, f) b b' #
Field2 (a, b, c, d, e, f, g) (a, b', c, d, e, f, g) b b'
Instance details Defined in Control.Lens.Tuple Methods _2 :: Lens (a, b, c, d, e, f, g) (a, b', c, d, e, f, g) b b' #
Field2 (a, b, c, d, e, f, g, h) (a, b', c, d, e, f, g, h) b b'
Instance details Defined in Control.Lens.Tuple Methods _2 :: Lens (a, b, c, d, e, f, g, h) (a, b', c, d, e, f, g, h) b b' #
Field2 (a, b, c, d, e, f, g, h, i) (a, b', c, d, e, f, g, h, i) b b'
Instance details Defined in Control.Lens.Tuple Methods _2 :: Lens (a, b, c, d, e, f, g, h, i) (a, b', c, d, e, f, g, h, i) b b' #
Field2 (a, b, c, d, e, f, g, h, i, j) (a, b', c, d, e, f, g, h, i, j) b b'
Instance details Defined in Control.Lens.Tuple Methods _2 :: Lens (a, b, c, d, e, f, g, h, i, j) (a, b', c, d, e, f, g, h, i, j) b b' #
Field2 (a, b, c, d, e, f, g, h, i, j, kk) (a, b', c, d, e, f, g, h, i, j, kk) b b'
Instance details Defined in Control.Lens.Tuple Methods _2 :: Lens (a, b, c, d, e, f, g, h, i, j, kk) (a, b', c, d, e, f, g, h, i, j, kk) b b' #
Field2 (a, b, c, d, e, f, g, h, i, j, kk, l) (a, b', c, d, e, f, g, h, i, j, kk, l) b b'
Instance details Defined in Control.Lens.Tuple Methods _2 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l) (a, b', c, d, e, f, g, h, i, j, kk, l) b b' #
Field2 (a, b, c, d, e, f, g, h, i, j, kk, l, m) (a, b', c, d, e, f, g, h, i, j, kk, l, m) b b'
Instance details Defined in Control.Lens.Tuple Methods _2 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m) (a, b', c, d, e, f, g, h, i, j, kk, l, m) b b' #
Field2 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n) (a, b', c, d, e, f, g, h, i, j, kk, l, m, n) b b'
Instance details Defined in Control.Lens.Tuple Methods _2 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n) (a, b', c, d, e, f, g, h, i, j, kk, l, m, n) b b' #
Field2 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o) (a, b', c, d, e, f, g, h, i, j, kk, l, m, n, o) b b'
Instance details Defined in Control.Lens.Tuple Methods _2 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o) (a, b', c, d, e, f, g, h, i, j, kk, l, m, n, o) b b' #
Field2 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p) (a, b', c, d, e, f, g, h, i, j, kk, l, m, n, o, p) b b'
Instance details Defined in Control.Lens.Tuple Methods _2 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p) (a, b', c, d, e, f, g, h, i, j, kk, l, m, n, o, p) b b' #
Field2 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q) (a, b', c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q) b b'
Instance details Defined in Control.Lens.Tuple Methods _2 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q) (a, b', c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q) b b' #
Field2 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r) (a, b', c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r) b b'
Instance details Defined in Control.Lens.Tuple Methods _2 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r) (a, b', c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r) b b' #
Field2 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s) (a, b', c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s) b b'
Instance details Defined in Control.Lens.Tuple Methods _2 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s) (a, b', c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s) b b' #

class Field3 s t a b | s -> a, t -> b, s b -> t, t a -> s where #

Provides access to the 3rd field of a tuple.

Minimal complete definition

Nothing

Methods

_3 :: Lens s t a b #

Access the 3rd field of a tuple.

Instances

Field3 (a, b, c) (a, b, c') c c'
Instance details Defined in Control.Lens.Tuple Methods _3 :: Lens (a, b, c) (a, b, c') c c' #
Field3 (a, b, c, d) (a, b, c', d) c c'
Instance details Defined in Control.Lens.Tuple Methods _3 :: Lens (a, b, c, d) (a, b, c', d) c c' #
Field3 (a, b, c, d, e) (a, b, c', d, e) c c'
Instance details Defined in Control.Lens.Tuple Methods _3 :: Lens (a, b, c, d, e) (a, b, c', d, e) c c' #
Field3 (a, b, c, d, e, f) (a, b, c', d, e, f) c c'
Instance details Defined in Control.Lens.Tuple Methods _3 :: Lens (a, b, c, d, e, f) (a, b, c', d, e, f) c c' #
Field3 (a, b, c, d, e, f, g) (a, b, c', d, e, f, g) c c'
Instance details Defined in Control.Lens.Tuple Methods _3 :: Lens (a, b, c, d, e, f, g) (a, b, c', d, e, f, g) c c' #
Field3 (a, b, c, d, e, f, g, h) (a, b, c', d, e, f, g, h) c c'
Instance details Defined in Control.Lens.Tuple Methods _3 :: Lens (a, b, c, d, e, f, g, h) (a, b, c', d, e, f, g, h) c c' #
Field3 (a, b, c, d, e, f, g, h, i) (a, b, c', d, e, f, g, h, i) c c'
Instance details Defined in Control.Lens.Tuple Methods _3 :: Lens (a, b, c, d, e, f, g, h, i) (a, b, c', d, e, f, g, h, i) c c' #
Field3 (a, b, c, d, e, f, g, h, i, j) (a, b, c', d, e, f, g, h, i, j) c c'
Instance details Defined in Control.Lens.Tuple Methods _3 :: Lens (a, b, c, d, e, f, g, h, i, j) (a, b, c', d, e, f, g, h, i, j) c c' #
Field3 (a, b, c, d, e, f, g, h, i, j, kk) (a, b, c', d, e, f, g, h, i, j, kk) c c'
Instance details Defined in Control.Lens.Tuple Methods _3 :: Lens (a, b, c, d, e, f, g, h, i, j, kk) (a, b, c', d, e, f, g, h, i, j, kk) c c' #
Field3 (a, b, c, d, e, f, g, h, i, j, kk, l) (a, b, c', d, e, f, g, h, i, j, kk, l) c c'
Instance details Defined in Control.Lens.Tuple Methods _3 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l) (a, b, c', d, e, f, g, h, i, j, kk, l) c c' #
Field3 (a, b, c, d, e, f, g, h, i, j, kk, l, m) (a, b, c', d, e, f, g, h, i, j, kk, l, m) c c'
Instance details Defined in Control.Lens.Tuple Methods _3 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m) (a, b, c', d, e, f, g, h, i, j, kk, l, m) c c' #
Field3 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n) (a, b, c', d, e, f, g, h, i, j, kk, l, m, n) c c'
Instance details Defined in Control.Lens.Tuple Methods _3 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n) (a, b, c', d, e, f, g, h, i, j, kk, l, m, n) c c' #
Field3 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o) (a, b, c', d, e, f, g, h, i, j, kk, l, m, n, o) c c'
Instance details Defined in Control.Lens.Tuple Methods _3 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o) (a, b, c', d, e, f, g, h, i, j, kk, l, m, n, o) c c' #
Field3 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p) (a, b, c', d, e, f, g, h, i, j, kk, l, m, n, o, p) c c'
Instance details Defined in Control.Lens.Tuple Methods _3 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p) (a, b, c', d, e, f, g, h, i, j, kk, l, m, n, o, p) c c' #
Field3 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q) (a, b, c', d, e, f, g, h, i, j, kk, l, m, n, o, p, q) c c'
Instance details Defined in Control.Lens.Tuple Methods _3 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q) (a, b, c', d, e, f, g, h, i, j, kk, l, m, n, o, p, q) c c' #
Field3 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r) (a, b, c', d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r) c c'
Instance details Defined in Control.Lens.Tuple Methods _3 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r) (a, b, c', d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r) c c' #
Field3 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s) (a, b, c', d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s) c c'
Instance details Defined in Control.Lens.Tuple Methods _3 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s) (a, b, c', d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s) c c' #

class Field4 s t a b | s -> a, t -> b, s b -> t, t a -> s where #

Provide access to the 4th field of a tuple.

Minimal complete definition

Nothing

Methods

_4 :: Lens s t a b #

Access the 4th field of a tuple.

Instances

Field4 (a, b, c, d) (a, b, c, d') d d'
Instance details Defined in Control.Lens.Tuple Methods _4 :: Lens (a, b, c, d) (a, b, c, d') d d' #
Field4 (a, b, c, d, e) (a, b, c, d', e) d d'
Instance details Defined in Control.Lens.Tuple Methods _4 :: Lens (a, b, c, d, e) (a, b, c, d', e) d d' #
Field4 (a, b, c, d, e, f) (a, b, c, d', e, f) d d'
Instance details Defined in Control.Lens.Tuple Methods _4 :: Lens (a, b, c, d, e, f) (a, b, c, d', e, f) d d' #
Field4 (a, b, c, d, e, f, g) (a, b, c, d', e, f, g) d d'
Instance details Defined in Control.Lens.Tuple Methods _4 :: Lens (a, b, c, d, e, f, g) (a, b, c, d', e, f, g) d d' #
Field4 (a, b, c, d, e, f, g, h) (a, b, c, d', e, f, g, h) d d'
Instance details Defined in Control.Lens.Tuple Methods _4 :: Lens (a, b, c, d, e, f, g, h) (a, b, c, d', e, f, g, h) d d' #
Field4 (a, b, c, d, e, f, g, h, i) (a, b, c, d', e, f, g, h, i) d d'
Instance details Defined in Control.Lens.Tuple Methods _4 :: Lens (a, b, c, d, e, f, g, h, i) (a, b, c, d', e, f, g, h, i) d d' #
Field4 (a, b, c, d, e, f, g, h, i, j) (a, b, c, d', e, f, g, h, i, j) d d'
Instance details Defined in Control.Lens.Tuple Methods _4 :: Lens (a, b, c, d, e, f, g, h, i, j) (a, b, c, d', e, f, g, h, i, j) d d' #
Field4 (a, b, c, d, e, f, g, h, i, j, kk) (a, b, c, d', e, f, g, h, i, j, kk) d d'
Instance details Defined in Control.Lens.Tuple Methods _4 :: Lens (a, b, c, d, e, f, g, h, i, j, kk) (a, b, c, d', e, f, g, h, i, j, kk) d d' #
Field4 (a, b, c, d, e, f, g, h, i, j, kk, l) (a, b, c, d', e, f, g, h, i, j, kk, l) d d'
Instance details Defined in Control.Lens.Tuple Methods _4 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l) (a, b, c, d', e, f, g, h, i, j, kk, l) d d' #
Field4 (a, b, c, d, e, f, g, h, i, j, kk, l, m) (a, b, c, d', e, f, g, h, i, j, kk, l, m) d d'
Instance details Defined in Control.Lens.Tuple Methods _4 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m) (a, b, c, d', e, f, g, h, i, j, kk, l, m) d d' #
Field4 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n) (a, b, c, d', e, f, g, h, i, j, kk, l, m, n) d d'
Instance details Defined in Control.Lens.Tuple Methods _4 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n) (a, b, c, d', e, f, g, h, i, j, kk, l, m, n) d d' #
Field4 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o) (a, b, c, d', e, f, g, h, i, j, kk, l, m, n, o) d d'
Instance details Defined in Control.Lens.Tuple Methods _4 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o) (a, b, c, d', e, f, g, h, i, j, kk, l, m, n, o) d d' #
Field4 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p) (a, b, c, d', e, f, g, h, i, j, kk, l, m, n, o, p) d d'
Instance details Defined in Control.Lens.Tuple Methods _4 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p) (a, b, c, d', e, f, g, h, i, j, kk, l, m, n, o, p) d d' #
Field4 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q) (a, b, c, d', e, f, g, h, i, j, kk, l, m, n, o, p, q) d d'
Instance details Defined in Control.Lens.Tuple Methods _4 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q) (a, b, c, d', e, f, g, h, i, j, kk, l, m, n, o, p, q) d d' #
Field4 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r) (a, b, c, d', e, f, g, h, i, j, kk, l, m, n, o, p, q, r) d d'
Instance details Defined in Control.Lens.Tuple Methods _4 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r) (a, b, c, d', e, f, g, h, i, j, kk, l, m, n, o, p, q, r) d d' #
Field4 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s) (a, b, c, d', e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s) d d'
Instance details Defined in Control.Lens.Tuple Methods _4 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s) (a, b, c, d', e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s) d d' #

class Field5 s t a b | s -> a, t -> b, s b -> t, t a -> s where #

Provides access to the 5th field of a tuple.

Minimal complete definition

Nothing

Methods

_5 :: Lens s t a b #

Access the 5th field of a tuple.

Instances

Field5 (a, b, c, d, e) (a, b, c, d, e') e e'
Instance details Defined in Control.Lens.Tuple Methods _5 :: Lens (a, b, c, d, e) (a, b, c, d, e') e e' #
Field5 (a, b, c, d, e, f) (a, b, c, d, e', f) e e'
Instance details Defined in Control.Lens.Tuple Methods _5 :: Lens (a, b, c, d, e, f) (a, b, c, d, e', f) e e' #
Field5 (a, b, c, d, e, f, g) (a, b, c, d, e', f, g) e e'
Instance details Defined in Control.Lens.Tuple Methods _5 :: Lens (a, b, c, d, e, f, g) (a, b, c, d, e', f, g) e e' #
Field5 (a, b, c, d, e, f, g, h) (a, b, c, d, e', f, g, h) e e'
Instance details Defined in Control.Lens.Tuple Methods _5 :: Lens (a, b, c, d, e, f, g, h) (a, b, c, d, e', f, g, h) e e' #
Field5 (a, b, c, d, e, f, g, h, i) (a, b, c, d, e', f, g, h, i) e e'
Instance details Defined in Control.Lens.Tuple Methods _5 :: Lens (a, b, c, d, e, f, g, h, i) (a, b, c, d, e', f, g, h, i) e e' #
Field5 (a, b, c, d, e, f, g, h, i, j) (a, b, c, d, e', f, g, h, i, j) e e'
Instance details Defined in Control.Lens.Tuple Methods _5 :: Lens (a, b, c, d, e, f, g, h, i, j) (a, b, c, d, e', f, g, h, i, j) e e' #
Field5 (a, b, c, d, e, f, g, h, i, j, kk) (a, b, c, d, e', f, g, h, i, j, kk) e e'
Instance details Defined in Control.Lens.Tuple Methods _5 :: Lens (a, b, c, d, e, f, g, h, i, j, kk) (a, b, c, d, e', f, g, h, i, j, kk) e e' #
Field5 (a, b, c, d, e, f, g, h, i, j, kk, l) (a, b, c, d, e', f, g, h, i, j, kk, l) e e'
Instance details Defined in Control.Lens.Tuple Methods _5 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l) (a, b, c, d, e', f, g, h, i, j, kk, l) e e' #
Field5 (a, b, c, d, e, f, g, h, i, j, kk, l, m) (a, b, c, d, e', f, g, h, i, j, kk, l, m) e e'
Instance details Defined in Control.Lens.Tuple Methods _5 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m) (a, b, c, d, e', f, g, h, i, j, kk, l, m) e e' #
Field5 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n) (a, b, c, d, e', f, g, h, i, j, kk, l, m, n) e e'
Instance details Defined in Control.Lens.Tuple Methods _5 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n) (a, b, c, d, e', f, g, h, i, j, kk, l, m, n) e e' #
Field5 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o) (a, b, c, d, e', f, g, h, i, j, kk, l, m, n, o) e e'
Instance details Defined in Control.Lens.Tuple Methods _5 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o) (a, b, c, d, e', f, g, h, i, j, kk, l, m, n, o) e e' #
Field5 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p) (a, b, c, d, e', f, g, h, i, j, kk, l, m, n, o, p) e e'
Instance details Defined in Control.Lens.Tuple Methods _5 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p) (a, b, c, d, e', f, g, h, i, j, kk, l, m, n, o, p) e e' #
Field5 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q) (a, b, c, d, e', f, g, h, i, j, kk, l, m, n, o, p, q) e e'
Instance details Defined in Control.Lens.Tuple Methods _5 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q) (a, b, c, d, e', f, g, h, i, j, kk, l, m, n, o, p, q) e e' #
Field5 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r) (a, b, c, d, e', f, g, h, i, j, kk, l, m, n, o, p, q, r) e e'
Instance details Defined in Control.Lens.Tuple Methods _5 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r) (a, b, c, d, e', f, g, h, i, j, kk, l, m, n, o, p, q, r) e e' #
Field5 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s) (a, b, c, d, e', f, g, h, i, j, kk, l, m, n, o, p, q, r, s) e e'
Instance details Defined in Control.Lens.Tuple Methods _5 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s) (a, b, c, d, e', f, g, h, i, j, kk, l, m, n, o, p, q, r, s) e e' #

class Field6 s t a b | s -> a, t -> b, s b -> t, t a -> s where #

Provides access to the 6th element of a tuple.

Minimal complete definition

Nothing

Methods

_6 :: Lens s t a b #

Access the 6th field of a tuple.

Instances

Field6 (a, b, c, d, e, f) (a, b, c, d, e, f') f f'
Instance details Defined in Control.Lens.Tuple Methods _6 :: Lens (a, b, c, d, e, f) (a, b, c, d, e, f') f f' #
Field6 (a, b, c, d, e, f, g) (a, b, c, d, e, f', g) f f'
Instance details Defined in Control.Lens.Tuple Methods _6 :: Lens (a, b, c, d, e, f, g) (a, b, c, d, e, f', g) f f' #
Field6 (a, b, c, d, e, f, g, h) (a, b, c, d, e, f', g, h) f f'
Instance details Defined in Control.Lens.Tuple Methods _6 :: Lens (a, b, c, d, e, f, g, h) (a, b, c, d, e, f', g, h) f f' #
Field6 (a, b, c, d, e, f, g, h, i) (a, b, c, d, e, f', g, h, i) f f'
Instance details Defined in Control.Lens.Tuple Methods _6 :: Lens (a, b, c, d, e, f, g, h, i) (a, b, c, d, e, f', g, h, i) f f' #
Field6 (a, b, c, d, e, f, g, h, i, j) (a, b, c, d, e, f', g, h, i, j) f f'
Instance details Defined in Control.Lens.Tuple Methods _6 :: Lens (a, b, c, d, e, f, g, h, i, j) (a, b, c, d, e, f', g, h, i, j) f f' #
Field6 (a, b, c, d, e, f, g, h, i, j, kk) (a, b, c, d, e, f', g, h, i, j, kk) f f'
Instance details Defined in Control.Lens.Tuple Methods _6 :: Lens (a, b, c, d, e, f, g, h, i, j, kk) (a, b, c, d, e, f', g, h, i, j, kk) f f' #
Field6 (a, b, c, d, e, f, g, h, i, j, kk, l) (a, b, c, d, e, f', g, h, i, j, kk, l) f f'
Instance details Defined in Control.Lens.Tuple Methods _6 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l) (a, b, c, d, e, f', g, h, i, j, kk, l) f f' #
Field6 (a, b, c, d, e, f, g, h, i, j, kk, l, m) (a, b, c, d, e, f', g, h, i, j, kk, l, m) f f'
Instance details Defined in Control.Lens.Tuple Methods _6 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m) (a, b, c, d, e, f', g, h, i, j, kk, l, m) f f' #
Field6 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n) (a, b, c, d, e, f', g, h, i, j, kk, l, m, n) f f'
Instance details Defined in Control.Lens.Tuple Methods _6 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n) (a, b, c, d, e, f', g, h, i, j, kk, l, m, n) f f' #
Field6 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o) (a, b, c, d, e, f', g, h, i, j, kk, l, m, n, o) f f'
Instance details Defined in Control.Lens.Tuple Methods _6 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o) (a, b, c, d, e, f', g, h, i, j, kk, l, m, n, o) f f' #
Field6 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p) (a, b, c, d, e, f', g, h, i, j, kk, l, m, n, o, p) f f'
Instance details Defined in Control.Lens.Tuple Methods _6 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p) (a, b, c, d, e, f', g, h, i, j, kk, l, m, n, o, p) f f' #
Field6 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q) (a, b, c, d, e, f', g, h, i, j, kk, l, m, n, o, p, q) f f'
Instance details Defined in Control.Lens.Tuple Methods _6 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q) (a, b, c, d, e, f', g, h, i, j, kk, l, m, n, o, p, q) f f' #
Field6 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r) (a, b, c, d, e, f', g, h, i, j, kk, l, m, n, o, p, q, r) f f'
Instance details Defined in Control.Lens.Tuple Methods _6 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r) (a, b, c, d, e, f', g, h, i, j, kk, l, m, n, o, p, q, r) f f' #
Field6 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s) (a, b, c, d, e, f', g, h, i, j, kk, l, m, n, o, p, q, r, s) f f'
Instance details Defined in Control.Lens.Tuple Methods _6 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s) (a, b, c, d, e, f', g, h, i, j, kk, l, m, n, o, p, q, r, s) f f' #

class Field7 s t a b | s -> a, t -> b, s b -> t, t a -> s where #

Provide access to the 7th field of a tuple.

Minimal complete definition

Nothing

Methods

_7 :: Lens s t a b #

Access the 7th field of a tuple.

Instances

Field7 (a, b, c, d, e, f, g) (a, b, c, d, e, f, g') g g'
Instance details Defined in Control.Lens.Tuple Methods _7 :: Lens (a, b, c, d, e, f, g) (a, b, c, d, e, f, g') g g' #
Field7 (a, b, c, d, e, f, g, h) (a, b, c, d, e, f, g', h) g g'
Instance details Defined in Control.Lens.Tuple Methods _7 :: Lens (a, b, c, d, e, f, g, h) (a, b, c, d, e, f, g', h) g g' #
Field7 (a, b, c, d, e, f, g, h, i) (a, b, c, d, e, f, g', h, i) g g'
Instance details Defined in Control.Lens.Tuple Methods _7 :: Lens (a, b, c, d, e, f, g, h, i) (a, b, c, d, e, f, g', h, i) g g' #
Field7 (a, b, c, d, e, f, g, h, i, j) (a, b, c, d, e, f, g', h, i, j) g g'
Instance details Defined in Control.Lens.Tuple Methods _7 :: Lens (a, b, c, d, e, f, g, h, i, j) (a, b, c, d, e, f, g', h, i, j) g g' #
Field7 (a, b, c, d, e, f, g, h, i, j, kk) (a, b, c, d, e, f, g', h, i, j, kk) g g'
Instance details Defined in Control.Lens.Tuple Methods _7 :: Lens (a, b, c, d, e, f, g, h, i, j, kk) (a, b, c, d, e, f, g', h, i, j, kk) g g' #
Field7 (a, b, c, d, e, f, g, h, i, j, kk, l) (a, b, c, d, e, f, g', h, i, j, kk, l) g g'
Instance details Defined in Control.Lens.Tuple Methods _7 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l) (a, b, c, d, e, f, g', h, i, j, kk, l) g g' #
Field7 (a, b, c, d, e, f, g, h, i, j, kk, l, m) (a, b, c, d, e, f, g', h, i, j, kk, l, m) g g'
Instance details Defined in Control.Lens.Tuple Methods _7 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m) (a, b, c, d, e, f, g', h, i, j, kk, l, m) g g' #
Field7 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n) (a, b, c, d, e, f, g', h, i, j, kk, l, m, n) g g'
Instance details Defined in Control.Lens.Tuple Methods _7 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n) (a, b, c, d, e, f, g', h, i, j, kk, l, m, n) g g' #
Field7 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o) (a, b, c, d, e, f, g', h, i, j, kk, l, m, n, o) g g'
Instance details Defined in Control.Lens.Tuple Methods _7 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o) (a, b, c, d, e, f, g', h, i, j, kk, l, m, n, o) g g' #
Field7 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p) (a, b, c, d, e, f, g', h, i, j, kk, l, m, n, o, p) g g'
Instance details Defined in Control.Lens.Tuple Methods _7 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p) (a, b, c, d, e, f, g', h, i, j, kk, l, m, n, o, p) g g' #
Field7 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q) (a, b, c, d, e, f, g', h, i, j, kk, l, m, n, o, p, q) g g'
Instance details Defined in Control.Lens.Tuple Methods _7 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q) (a, b, c, d, e, f, g', h, i, j, kk, l, m, n, o, p, q) g g' #
Field7 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r) (a, b, c, d, e, f, g', h, i, j, kk, l, m, n, o, p, q, r) g g'
Instance details Defined in Control.Lens.Tuple Methods _7 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r) (a, b, c, d, e, f, g', h, i, j, kk, l, m, n, o, p, q, r) g g' #
Field7 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s) (a, b, c, d, e, f, g', h, i, j, kk, l, m, n, o, p, q, r, s) g g'
Instance details Defined in Control.Lens.Tuple Methods _7 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s) (a, b, c, d, e, f, g', h, i, j, kk, l, m, n, o, p, q, r, s) g g' #

class Field8 s t a b | s -> a, t -> b, s b -> t, t a -> s where #

Provide access to the 8th field of a tuple.

Minimal complete definition

Nothing

Methods

_8 :: Lens s t a b #

Access the 8th field of a tuple.

Instances

Field8 (a, b, c, d, e, f, g, h) (a, b, c, d, e, f, g, h') h h'
Instance details Defined in Control.Lens.Tuple Methods _8 :: Lens (a, b, c, d, e, f, g, h) (a, b, c, d, e, f, g, h') h h' #
Field8 (a, b, c, d, e, f, g, h, i) (a, b, c, d, e, f, g, h', i) h h'
Instance details Defined in Control.Lens.Tuple Methods _8 :: Lens (a, b, c, d, e, f, g, h, i) (a, b, c, d, e, f, g, h', i) h h' #
Field8 (a, b, c, d, e, f, g, h, i, j) (a, b, c, d, e, f, g, h', i, j) h h'
Instance details Defined in Control.Lens.Tuple Methods _8 :: Lens (a, b, c, d, e, f, g, h, i, j) (a, b, c, d, e, f, g, h', i, j) h h' #
Field8 (a, b, c, d, e, f, g, h, i, j, kk) (a, b, c, d, e, f, g, h', i, j, kk) h h'
Instance details Defined in Control.Lens.Tuple Methods _8 :: Lens (a, b, c, d, e, f, g, h, i, j, kk) (a, b, c, d, e, f, g, h', i, j, kk) h h' #
Field8 (a, b, c, d, e, f, g, h, i, j, kk, l) (a, b, c, d, e, f, g, h', i, j, kk, l) h h'
Instance details Defined in Control.Lens.Tuple Methods _8 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l) (a, b, c, d, e, f, g, h', i, j, kk, l) h h' #
Field8 (a, b, c, d, e, f, g, h, i, j, kk, l, m) (a, b, c, d, e, f, g, h', i, j, kk, l, m) h h'
Instance details Defined in Control.Lens.Tuple Methods _8 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m) (a, b, c, d, e, f, g, h', i, j, kk, l, m) h h' #
Field8 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n) (a, b, c, d, e, f, g, h', i, j, kk, l, m, n) h h'
Instance details Defined in Control.Lens.Tuple Methods _8 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n) (a, b, c, d, e, f, g, h', i, j, kk, l, m, n) h h' #
Field8 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o) (a, b, c, d, e, f, g, h', i, j, kk, l, m, n, o) h h'
Instance details Defined in Control.Lens.Tuple Methods _8 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o) (a, b, c, d, e, f, g, h', i, j, kk, l, m, n, o) h h' #
Field8 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p) (a, b, c, d, e, f, g, h', i, j, kk, l, m, n, o, p) h h'
Instance details Defined in Control.Lens.Tuple Methods _8 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p) (a, b, c, d, e, f, g, h', i, j, kk, l, m, n, o, p) h h' #
Field8 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q) (a, b, c, d, e, f, g, h', i, j, kk, l, m, n, o, p, q) h h'
Instance details Defined in Control.Lens.Tuple Methods _8 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q) (a, b, c, d, e, f, g, h', i, j, kk, l, m, n, o, p, q) h h' #
Field8 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r) (a, b, c, d, e, f, g, h', i, j, kk, l, m, n, o, p, q, r) h h'
Instance details Defined in Control.Lens.Tuple Methods _8 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r) (a, b, c, d, e, f, g, h', i, j, kk, l, m, n, o, p, q, r) h h' #
Field8 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s) (a, b, c, d, e, f, g, h', i, j, kk, l, m, n, o, p, q, r, s) h h'
Instance details Defined in Control.Lens.Tuple Methods _8 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s) (a, b, c, d, e, f, g, h', i, j, kk, l, m, n, o, p, q, r, s) h h' #

class Field9 s t a b | s -> a, t -> b, s b -> t, t a -> s where #

Provides access to the 9th field of a tuple.

Minimal complete definition

Nothing

Methods

_9 :: Lens s t a b #

Access the 9th field of a tuple.

Instances

Field9 (a, b, c, d, e, f, g, h, i) (a, b, c, d, e, f, g, h, i') i i'
Instance details Defined in Control.Lens.Tuple Methods _9 :: Lens (a, b, c, d, e, f, g, h, i) (a, b, c, d, e, f, g, h, i') i i' #
Field9 (a, b, c, d, e, f, g, h, i, j) (a, b, c, d, e, f, g, h, i', j) i i'
Instance details Defined in Control.Lens.Tuple Methods _9 :: Lens (a, b, c, d, e, f, g, h, i, j) (a, b, c, d, e, f, g, h, i', j) i i' #
Field9 (a, b, c, d, e, f, g, h, i, j, kk) (a, b, c, d, e, f, g, h, i', j, kk) i i'
Instance details Defined in Control.Lens.Tuple Methods _9 :: Lens (a, b, c, d, e, f, g, h, i, j, kk) (a, b, c, d, e, f, g, h, i', j, kk) i i' #
Field9 (a, b, c, d, e, f, g, h, i, j, kk, l) (a, b, c, d, e, f, g, h, i', j, kk, l) i i'
Instance details Defined in Control.Lens.Tuple Methods _9 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l) (a, b, c, d, e, f, g, h, i', j, kk, l) i i' #
Field9 (a, b, c, d, e, f, g, h, i, j, kk, l, m) (a, b, c, d, e, f, g, h, i', j, kk, l, m) i i'
Instance details Defined in Control.Lens.Tuple Methods _9 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m) (a, b, c, d, e, f, g, h, i', j, kk, l, m) i i' #
Field9 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n) (a, b, c, d, e, f, g, h, i', j, kk, l, m, n) i i'
Instance details Defined in Control.Lens.Tuple Methods _9 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n) (a, b, c, d, e, f, g, h, i', j, kk, l, m, n) i i' #
Field9 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o) (a, b, c, d, e, f, g, h, i', j, kk, l, m, n, o) i i'
Instance details Defined in Control.Lens.Tuple Methods _9 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o) (a, b, c, d, e, f, g, h, i', j, kk, l, m, n, o) i i' #
Field9 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p) (a, b, c, d, e, f, g, h, i', j, kk, l, m, n, o, p) i i'
Instance details Defined in Control.Lens.Tuple Methods _9 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p) (a, b, c, d, e, f, g, h, i', j, kk, l, m, n, o, p) i i' #
Field9 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q) (a, b, c, d, e, f, g, h, i', j, kk, l, m, n, o, p, q) i i'
Instance details Defined in Control.Lens.Tuple Methods _9 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q) (a, b, c, d, e, f, g, h, i', j, kk, l, m, n, o, p, q) i i' #
Field9 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r) (a, b, c, d, e, f, g, h, i', j, kk, l, m, n, o, p, q, r) i i'
Instance details Defined in Control.Lens.Tuple Methods _9 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r) (a, b, c, d, e, f, g, h, i', j, kk, l, m, n, o, p, q, r) i i' #
Field9 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s) (a, b, c, d, e, f, g, h, i', j, kk, l, m, n, o, p, q, r, s) i i'
Instance details Defined in Control.Lens.Tuple Methods _9 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s) (a, b, c, d, e, f, g, h, i', j, kk, l, m, n, o, p, q, r, s) i i' #

class Field10 s t a b | s -> a, t -> b, s b -> t, t a -> s where #

Provides access to the 10th field of a tuple.

Minimal complete definition

Nothing

Methods

_10 :: Lens s t a b #

Access the 10th field of a tuple.

Instances

Field10 (a, b, c, d, e, f, g, h, i, j) (a, b, c, d, e, f, g, h, i, j') j j'
Instance details Defined in Control.Lens.Tuple Methods _10 :: Lens (a, b, c, d, e, f, g, h, i, j) (a, b, c, d, e, f, g, h, i, j') j j' #
Field10 (a, b, c, d, e, f, g, h, i, j, kk) (a, b, c, d, e, f, g, h, i, j', kk) j j'
Instance details Defined in Control.Lens.Tuple Methods _10 :: Lens (a, b, c, d, e, f, g, h, i, j, kk) (a, b, c, d, e, f, g, h, i, j', kk) j j' #
Field10 (a, b, c, d, e, f, g, h, i, j, kk, l) (a, b, c, d, e, f, g, h, i, j', kk, l) j j'
Instance details Defined in Control.Lens.Tuple Methods _10 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l) (a, b, c, d, e, f, g, h, i, j', kk, l) j j' #
Field10 (a, b, c, d, e, f, g, h, i, j, kk, l, m) (a, b, c, d, e, f, g, h, i, j', kk, l, m) j j'
Instance details Defined in Control.Lens.Tuple Methods _10 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m) (a, b, c, d, e, f, g, h, i, j', kk, l, m) j j' #
Field10 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n) (a, b, c, d, e, f, g, h, i, j', kk, l, m, n) j j'
Instance details Defined in Control.Lens.Tuple Methods _10 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n) (a, b, c, d, e, f, g, h, i, j', kk, l, m, n) j j' #
Field10 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o) (a, b, c, d, e, f, g, h, i, j', kk, l, m, n, o) j j'
Instance details Defined in Control.Lens.Tuple Methods _10 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o) (a, b, c, d, e, f, g, h, i, j', kk, l, m, n, o) j j' #
Field10 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p) (a, b, c, d, e, f, g, h, i, j', kk, l, m, n, o, p) j j'
Instance details Defined in Control.Lens.Tuple Methods _10 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p) (a, b, c, d, e, f, g, h, i, j', kk, l, m, n, o, p) j j' #
Field10 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q) (a, b, c, d, e, f, g, h, i, j', kk, l, m, n, o, p, q) j j'
Instance details Defined in Control.Lens.Tuple Methods _10 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q) (a, b, c, d, e, f, g, h, i, j', kk, l, m, n, o, p, q) j j' #
Field10 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r) (a, b, c, d, e, f, g, h, i, j', kk, l, m, n, o, p, q, r) j j'
Instance details Defined in Control.Lens.Tuple Methods _10 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r) (a, b, c, d, e, f, g, h, i, j', kk, l, m, n, o, p, q, r) j j' #
Field10 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s) (a, b, c, d, e, f, g, h, i, j', kk, l, m, n, o, p, q, r, s) j j'
Instance details Defined in Control.Lens.Tuple Methods _10 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s) (a, b, c, d, e, f, g, h, i, j', kk, l, m, n, o, p, q, r, s) j j' #

class Field11 s t a b | s -> a, t -> b, s b -> t, t a -> s where #

Provides access to the 11th field of a tuple.

Minimal complete definition

Nothing

Methods

_11 :: Lens s t a b #

Access the 11th field of a tuple.

Instances

Field11 (a, b, c, d, e, f, g, h, i, j, kk) (a, b, c, d, e, f, g, h, i, j, kk') kk kk'
Instance details Defined in Control.Lens.Tuple Methods _11 :: Lens (a, b, c, d, e, f, g, h, i, j, kk) (a, b, c, d, e, f, g, h, i, j, kk') kk kk' #
Field11 (a, b, c, d, e, f, g, h, i, j, kk, l) (a, b, c, d, e, f, g, h, i, j, kk', l) kk kk'
Instance details Defined in Control.Lens.Tuple Methods _11 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l) (a, b, c, d, e, f, g, h, i, j, kk', l) kk kk' #
Field11 (a, b, c, d, e, f, g, h, i, j, kk, l, m) (a, b, c, d, e, f, g, h, i, j, kk', l, m) kk kk'
Instance details Defined in Control.Lens.Tuple Methods _11 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m) (a, b, c, d, e, f, g, h, i, j, kk', l, m) kk kk' #
Field11 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n) (a, b, c, d, e, f, g, h, i, j, kk', l, m, n) kk kk'
Instance details Defined in Control.Lens.Tuple Methods _11 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n) (a, b, c, d, e, f, g, h, i, j, kk', l, m, n) kk kk' #
Field11 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o) (a, b, c, d, e, f, g, h, i, j, kk', l, m, n, o) kk kk'
Instance details Defined in Control.Lens.Tuple Methods _11 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o) (a, b, c, d, e, f, g, h, i, j, kk', l, m, n, o) kk kk' #
Field11 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p) (a, b, c, d, e, f, g, h, i, j, kk', l, m, n, o, p) kk kk'
Instance details Defined in Control.Lens.Tuple Methods _11 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p) (a, b, c, d, e, f, g, h, i, j, kk', l, m, n, o, p) kk kk' #
Field11 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q) (a, b, c, d, e, f, g, h, i, j, kk', l, m, n, o, p, q) kk kk'
Instance details Defined in Control.Lens.Tuple Methods _11 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q) (a, b, c, d, e, f, g, h, i, j, kk', l, m, n, o, p, q) kk kk' #
Field11 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r) (a, b, c, d, e, f, g, h, i, j, kk', l, m, n, o, p, q, r) kk kk'
Instance details Defined in Control.Lens.Tuple Methods _11 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r) (a, b, c, d, e, f, g, h, i, j, kk', l, m, n, o, p, q, r) kk kk' #
Field11 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s) (a, b, c, d, e, f, g, h, i, j, kk', l, m, n, o, p, q, r, s) kk kk'
Instance details Defined in Control.Lens.Tuple Methods _11 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s) (a, b, c, d, e, f, g, h, i, j, kk', l, m, n, o, p, q, r, s) kk kk' #

class Field12 s t a b | s -> a, t -> b, s b -> t, t a -> s where #

Provides access to the 12th field of a tuple.

Minimal complete definition

Nothing

Methods

_12 :: Lens s t a b #

Access the 12th field of a tuple.

Instances

Field12 (a, b, c, d, e, f, g, h, i, j, kk, l) (a, b, c, d, e, f, g, h, i, j, kk, l') l l'
Instance details Defined in Control.Lens.Tuple Methods _12 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l) (a, b, c, d, e, f, g, h, i, j, kk, l') l l' #
Field12 (a, b, c, d, e, f, g, h, i, j, kk, l, m) (a, b, c, d, e, f, g, h, i, j, kk, l', m) l l'
Instance details Defined in Control.Lens.Tuple Methods _12 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m) (a, b, c, d, e, f, g, h, i, j, kk, l', m) l l' #
Field12 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n) (a, b, c, d, e, f, g, h, i, j, kk, l', m, n) l l'
Instance details Defined in Control.Lens.Tuple Methods _12 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n) (a, b, c, d, e, f, g, h, i, j, kk, l', m, n) l l' #
Field12 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o) (a, b, c, d, e, f, g, h, i, j, kk, l', m, n, o) l l'
Instance details Defined in Control.Lens.Tuple Methods _12 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o) (a, b, c, d, e, f, g, h, i, j, kk, l', m, n, o) l l' #
Field12 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p) (a, b, c, d, e, f, g, h, i, j, kk, l', m, n, o, p) l l'
Instance details Defined in Control.Lens.Tuple Methods _12 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p) (a, b, c, d, e, f, g, h, i, j, kk, l', m, n, o, p) l l' #
Field12 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q) (a, b, c, d, e, f, g, h, i, j, kk, l', m, n, o, p, q) l l'
Instance details Defined in Control.Lens.Tuple Methods _12 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q) (a, b, c, d, e, f, g, h, i, j, kk, l', m, n, o, p, q) l l' #
Field12 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r) (a, b, c, d, e, f, g, h, i, j, kk, l', m, n, o, p, q, r) l l'
Instance details Defined in Control.Lens.Tuple Methods _12 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r) (a, b, c, d, e, f, g, h, i, j, kk, l', m, n, o, p, q, r) l l' #
Field12 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s) (a, b, c, d, e, f, g, h, i, j, kk, l', m, n, o, p, q, r, s) l l'
Instance details Defined in Control.Lens.Tuple Methods _12 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s) (a, b, c, d, e, f, g, h, i, j, kk, l', m, n, o, p, q, r, s) l l' #

class Field13 s t a b | s -> a, t -> b, s b -> t, t a -> s where #

Provides access to the 13th field of a tuple.

Minimal complete definition

Nothing

Methods

_13 :: Lens s t a b #

Access the 13th field of a tuple.

Instances

Field13 (a, b, c, d, e, f, g, h, i, j, kk, l, m) (a, b, c, d, e, f, g, h, i, j, kk, l, m') m m'
Instance details Defined in Control.Lens.Tuple Methods _13 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m) (a, b, c, d, e, f, g, h, i, j, kk, l, m') m m' #
Field13 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n) (a, b, c, d, e, f, g, h, i, j, kk, l, m', n) m m'
Instance details Defined in Control.Lens.Tuple Methods _13 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n) (a, b, c, d, e, f, g, h, i, j, kk, l, m', n) m m' #
Field13 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o) (a, b, c, d, e, f, g, h, i, j, kk, l, m', n, o) m m'
Instance details Defined in Control.Lens.Tuple Methods _13 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o) (a, b, c, d, e, f, g, h, i, j, kk, l, m', n, o) m m' #
Field13 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p) (a, b, c, d, e, f, g, h, i, j, kk, l, m', n, o, p) m m'
Instance details Defined in Control.Lens.Tuple Methods _13 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p) (a, b, c, d, e, f, g, h, i, j, kk, l, m', n, o, p) m m' #
Field13 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q) (a, b, c, d, e, f, g, h, i, j, kk, l, m', n, o, p, q) m m'
Instance details Defined in Control.Lens.Tuple Methods _13 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q) (a, b, c, d, e, f, g, h, i, j, kk, l, m', n, o, p, q) m m' #
Field13 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r) (a, b, c, d, e, f, g, h, i, j, kk, l, m', n, o, p, q, r) m m'
Instance details Defined in Control.Lens.Tuple Methods _13 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r) (a, b, c, d, e, f, g, h, i, j, kk, l, m', n, o, p, q, r) m m' #
Field13 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s) (a, b, c, d, e, f, g, h, i, j, kk, l, m', n, o, p, q, r, s) m m'
Instance details Defined in Control.Lens.Tuple Methods _13 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s) (a, b, c, d, e, f, g, h, i, j, kk, l, m', n, o, p, q, r, s) m m' #

class Field14 s t a b | s -> a, t -> b, s b -> t, t a -> s where #

Provides access to the 14th field of a tuple.

Minimal complete definition

Nothing

Methods

_14 :: Lens s t a b #

Access the 14th field of a tuple.

Instances

Field14 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n) (a, b, c, d, e, f, g, h, i, j, kk, l, m, n') n n'
Instance details Defined in Control.Lens.Tuple Methods _14 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n) (a, b, c, d, e, f, g, h, i, j, kk, l, m, n') n n' #
Field14 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o) (a, b, c, d, e, f, g, h, i, j, kk, l, m, n', o) n n'
Instance details Defined in Control.Lens.Tuple Methods _14 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o) (a, b, c, d, e, f, g, h, i, j, kk, l, m, n', o) n n' #
Field14 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p) (a, b, c, d, e, f, g, h, i, j, kk, l, m, n', o, p) n n'
Instance details Defined in Control.Lens.Tuple Methods _14 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p) (a, b, c, d, e, f, g, h, i, j, kk, l, m, n', o, p) n n' #
Field14 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q) (a, b, c, d, e, f, g, h, i, j, kk, l, m, n', o, p, q) n n'
Instance details Defined in Control.Lens.Tuple Methods _14 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q) (a, b, c, d, e, f, g, h, i, j, kk, l, m, n', o, p, q) n n' #
Field14 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r) (a, b, c, d, e, f, g, h, i, j, kk, l, m, n', o, p, q, r) n n'
Instance details Defined in Control.Lens.Tuple Methods _14 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r) (a, b, c, d, e, f, g, h, i, j, kk, l, m, n', o, p, q, r) n n' #
Field14 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s) (a, b, c, d, e, f, g, h, i, j, kk, l, m, n', o, p, q, r, s) n n'
Instance details Defined in Control.Lens.Tuple Methods _14 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s) (a, b, c, d, e, f, g, h, i, j, kk, l, m, n', o, p, q, r, s) n n' #

class Field15 s t a b | s -> a, t -> b, s b -> t, t a -> s where #

Provides access to the 15th field of a tuple.

Minimal complete definition

Nothing

Methods

_15 :: Lens s t a b #

Access the 15th field of a tuple.

Instances

Field15 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o) (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o') o o'
Instance details Defined in Control.Lens.Tuple Methods _15 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o) (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o') o o' #
Field15 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p) (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o', p) o o'
Instance details Defined in Control.Lens.Tuple Methods _15 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p) (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o', p) o o' #
Field15 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q) (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o', p, q) o o'
Instance details Defined in Control.Lens.Tuple Methods _15 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q) (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o', p, q) o o' #
Field15 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r) (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o', p, q, r) o o'
Instance details Defined in Control.Lens.Tuple Methods _15 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r) (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o', p, q, r) o o' #
Field15 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s) (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o', p, q, r, s) o o'
Instance details Defined in Control.Lens.Tuple Methods _15 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s) (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o', p, q, r, s) o o' #

class Field16 s t a b | s -> a, t -> b, s b -> t, t a -> s where #

Provides access to the 16th field of a tuple.

Minimal complete definition

Nothing

Methods

_16 :: Lens s t a b #

Access the 16th field of a tuple.

Instances

Field16 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p) (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p') p p'
Instance details Defined in Control.Lens.Tuple Methods _16 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p) (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p') p p' #
Field16 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q) (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p', q) p p'
Instance details Defined in Control.Lens.Tuple Methods _16 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q) (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p', q) p p' #
Field16 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r) (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p', q, r) p p'
Instance details Defined in Control.Lens.Tuple Methods _16 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r) (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p', q, r) p p' #
Field16 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s) (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p', q, r, s) p p'
Instance details Defined in Control.Lens.Tuple Methods _16 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s) (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p', q, r, s) p p' #

class Field17 s t a b | s -> a, t -> b, s b -> t, t a -> s where #

Provides access to the 17th field of a tuple.

Minimal complete definition

Nothing

Methods

_17 :: Lens s t a b #

Access the 17th field of a tuple.

Instances

Field17 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q) (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q') q q'
Instance details Defined in Control.Lens.Tuple Methods _17 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q) (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q') q q' #
Field17 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r) (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q', r) q q'
Instance details Defined in Control.Lens.Tuple Methods _17 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r) (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q', r) q q' #
Field17 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s) (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q', r, s) q q'
Instance details Defined in Control.Lens.Tuple Methods _17 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s) (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q', r, s) q q' #

class Field18 s t a b | s -> a, t -> b, s b -> t, t a -> s where #

Provides access to the 18th field of a tuple.

Minimal complete definition

Nothing

Methods

_18 :: Lens s t a b #

Access the 18th field of a tuple.

Instances

Field18 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r) (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r') r r'
Instance details Defined in Control.Lens.Tuple Methods _18 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r) (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r') r r' #
Field18 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s) (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r', s) r r'
Instance details Defined in Control.Lens.Tuple Methods _18 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s) (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r', s) r r' #

class Field19 s t a b | s -> a, t -> b, s b -> t, t a -> s where #

Provides access to the 19th field of a tuple.

Minimal complete definition

Nothing

Methods

_19 :: Lens s t a b #

Access the 19th field of a tuple.

Instances

Field19 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s) (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s') s s'
Instance details Defined in Control.Lens.Tuple Methods _19 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s) (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s') s s' #

fusing :: Functor f => LensLike (Yoneda f) s t a b -> LensLike f s t a b #

Fuse a composition of lenses using Yoneda to provide fmap fusion.

In general, given a pair of lenses foo and bar

fusing (foo.bar) = foo.bar

however, foo and bar are either going to fmap internally or they are trivial.

fusing exploits the Yoneda lemma to merge these separate uses into a single fmap.

This is particularly effective when the choice of functor f is unknown at compile time or when the Lens foo.bar in the above description is recursive or complex enough to prevent inlining.

fusing :: Lens s t a b -> Lens s t a b

last1 :: Traversable1 t => Lens' (t a) a #

A Lens focusing on the last element of a Traversable1 container.

>>> 2 :| [3, 4] & last1 +~ 10
2 :| [3,14]

>>> Node 'a' [Node 'b' [], Node 'c' []] ^. last1
'c'

head1 :: Traversable1 t => Lens' (t a) a #

A Lens focusing on the first element of a Traversable1 container.

>>> 2 :| [3, 4] & head1 +~ 10
12 :| [3,4]

>>> Identity True ^. head1
True

united :: Lens' a () #

We can always retrieve a () from any type.

>>> "hello"^.united
()

>>> "hello" & united .~ ()
"hello"

devoid :: Over p f Void Void a b #

There is a field for every type in the Void. Very zen.

>>> [] & mapped.devoid +~ 1
[]

>>> Nothing & mapped.devoid %~ abs
Nothing

devoid :: Lens' Void a

(<#=) :: MonadState s m => ALens s s a b -> b -> m b infix 4 #

A version of (<.=) that works on ALens.

(<#~) :: ALens s t a b -> b -> s -> (b, t) infixr 4 #

A version of (<.~) that works on ALens.

>>> ("hello","there") & _2 <#~ "world"
("world",("hello","world"))

(#%%=) :: MonadState s m => ALens s s a b -> (a -> (r, b)) -> m r infix 4 #

A version of (%%=) that works on ALens.

(<#%=) :: MonadState s m => ALens s s a b -> (a -> b) -> m b infix 4 #

A version of (<%=) that works on ALens.

(<#%~) :: ALens s t a b -> (a -> b) -> s -> (b, t) infixr 4 #

A version of (<%~) that works on ALens.

>>> ("hello","world") & _2 <#%~ length
(5,("hello",5))

(#%=) :: MonadState s m => ALens s s a b -> (a -> b) -> m () infix 4 #

A version of (%=) that works on ALens.

(#=) :: MonadState s m => ALens s s a b -> b -> m () infix 4 #

A version of (.=) that works on ALens.

(#%%~) :: Functor f => ALens s t a b -> (a -> f b) -> s -> f t infixr 4 #

A version of (%%~) that works on ALens.

>>> ("hello","world") & _2 #%%~ \x -> (length x, x ++ "!")
(5,("hello","world!"))

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

A version of (%~) that works on ALens.

>>> ("hello","world") & _2 #%~ length
("hello",5)

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

A version of (.~) that works on ALens.

>>> ("hello","there") & _2 #~ "world"
("hello","world")

storing :: ALens s t a b -> b -> s -> t #

A version of set that works on ALens.

>>> storing _2 "world" ("hello","there")
("hello","world")

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

A version of (^.) that works on ALens.

>>> ("hello","world")^#_2
"world"

(<<%@=) :: MonadState s m => Over (Indexed i) ((,) a) s s a b -> (i -> a -> b) -> m a infix 4 #

Adjust the target of an IndexedLens returning the old value, or adjust all of the targets of an IndexedTraversal within the current state, and return a monoidal summary of the old values.

(<<%@=) :: MonadState s m                 => IndexedLens i s s a b      -> (i -> a -> b) -> m a
(<<%@=) :: (MonadState s m, Monoid b) => IndexedTraversal i s s a b -> (i -> a -> b) -> m a

(<%@=) :: MonadState s m => Over (Indexed i) ((,) b) s s a b -> (i -> a -> b) -> m b infix 4 #

Adjust the target of an IndexedLens returning the intermediate result, or adjust all of the targets of an IndexedTraversal within the current state, and return a monoidal summary of the intermediate results.

(<%@=) :: MonadState s m                 => IndexedLens i s s a b      -> (i -> a -> b) -> m b
(<%@=) :: (MonadState s m, Monoid b) => IndexedTraversal i s s a b -> (i -> a -> b) -> m b

(%%@=) :: MonadState s m => Over (Indexed i) ((,) r) s s a b -> (i -> a -> (r, b)) -> m r infix 4 #

Adjust the target of an IndexedLens returning a supplementary result, or adjust all of the targets of an IndexedTraversal within the current state, and return a monoidal summary of the supplementary results.

l %%@= f ≡ state (l %%@~ f)

(%%@=) :: MonadState s m                 => IndexedLens i s s a b      -> (i -> a -> (r, b)) -> s -> m r
(%%@=) :: (MonadState s m, Monoid r) => IndexedTraversal i s s a b -> (i -> a -> (r, b)) -> s -> m r

(%%@~) :: Over (Indexed i) f s t a b -> (i -> a -> f b) -> s -> f t infixr 4 #

Adjust the target of an IndexedLens returning a supplementary result, or adjust all of the targets of an IndexedTraversal and return a monoidal summary of the supplementary results and the answer.

(%%@~) ≡ withIndex

(%%@~) :: Functor f => IndexedLens i s t a b      -> (i -> a -> f b) -> s -> f t
(%%@~) :: Applicative f => IndexedTraversal i s t a b -> (i -> a -> f b) -> s -> f t

In particular, it is often useful to think of this function as having one of these even more restricted type signatures:

(%%@~) ::             IndexedLens i s t a b      -> (i -> a -> (r, b)) -> s -> (r, t)
(%%@~) :: Monoid r => IndexedTraversal i s t a b -> (i -> a -> (r, b)) -> s -> (r, t)

(<<%@~) :: Over (Indexed i) ((,) a) s t a b -> (i -> a -> b) -> s -> (a, t) infixr 4 #

Adjust the target of an IndexedLens returning the old value, or adjust all of the targets of an IndexedTraversal and return a monoidal summary of the old values along with the answer.

(<<%@~) ::             IndexedLens i s t a b      -> (i -> a -> b) -> s -> (a, t)
(<<%@~) :: Monoid a => IndexedTraversal i s t a b -> (i -> a -> b) -> s -> (a, t)

(<%@~) :: Over (Indexed i) ((,) b) s t a b -> (i -> a -> b) -> s -> (b, t) infixr 4 #

Adjust the target of an IndexedLens returning the intermediate result, or adjust all of the targets of an IndexedTraversal and return a monoidal summary along with the answer.

l <%~ f ≡ l <%@~ const f

When you do not need access to the index then (<%~) is more liberal in what it can accept.

If you do not need the intermediate result, you can use (%@~) or even (%~).

(<%@~) ::             IndexedLens i s t a b      -> (i -> a -> b) -> s -> (b, t)
(<%@~) :: Monoid b => IndexedTraversal i s t a b -> (i -> a -> b) -> s -> (b, t)

overA :: Arrow ar => LensLike (Context a b) s t a b -> ar a b -> ar s t #

over for Arrows.

Unlike over, overA can't accept a simple Setter, but requires a full lens, or close enough.

>>> overA _1 ((+1) *** (+2)) ((1,2),6)
((2,4),6)

overA :: Arrow ar => Lens s t a b -> ar a b -> ar s t

(<<>=) :: (MonadState s m, Monoid r) => LensLike' ((,) r) s r -> r -> m r infix 4 #

mappend a monoidal value onto the end of the target of a Lens into your Monad's state and return the result.

When you do not need the result of the operation, (<>=) is more flexible.

(<<>~) :: Monoid m => LensLike ((,) m) s t m m -> m -> s -> (m, t) infixr 4 #

mappend a monoidal value onto the end of the target of a Lens and return the result.

When you do not need the result of the operation, (<>~) is more flexible.

(<<~) :: MonadState s m => ALens s s a b -> m b -> m b infixr 2 #

Run a monadic action, and set the target of Lens to its result.

(<<~) :: MonadState s m => Iso s s a b   -> m b -> m b
(<<~) :: MonadState s m => Lens s s a b  -> m b -> m b

NB: This is limited to taking an actual Lens than admitting a Traversal because there are potential loss of state issues otherwise.

(<<<>=) :: (MonadState s m, Monoid r) => LensLike' ((,) r) s r -> r -> m r infix 4 #

Modify the target of a Lens into your Monad's state by mappending a value and return the old value that was replaced.

When you do not need the result of the operation, (<>=) is more flexible.

(<<<>=) :: (MonadState s m, Monoid r) => Lens' s r -> r -> m r
(<<<>=) :: (MonadState s m, Monoid r) => Iso' s r -> r -> m r

(<<&&=) :: MonadState s m => LensLike' ((,) Bool) s Bool -> Bool -> m Bool infix 4 #

Modify the target of a Lens into your Monad's state by taking its logical && with a value and return the old value that was replaced.

When you do not need the result of the operation, (&&=) is more flexible.

(<<&&=) :: MonadState s m => Lens' s Bool -> Bool -> m Bool
(<<&&=) :: MonadState s m => Iso' s Bool -> Bool -> m Bool

(<<||=) :: MonadState s m => LensLike' ((,) Bool) s Bool -> Bool -> m Bool infix 4 #

Modify the target of a Lens into your Monad's state by taking its logical || with a value and return the old value that was replaced.

When you do not need the result of the operation, (||=) is more flexible.

(<<||=) :: MonadState s m => Lens' s Bool -> Bool -> m Bool
(<<||=) :: MonadState s m => Iso' s Bool -> Bool -> m Bool

(<<**=) :: (MonadState s m, Floating a) => LensLike' ((,) a) s a -> a -> m a infix 4 #

Modify the target of a Lens into your Monad's state by raising it by an arbitrary power and return the old value that was replaced.

When you do not need the result of the operation, (**=) is more flexible.

(<<**=) :: (MonadState s m, Floating a) => Lens' s a -> a -> m a
(<<**=) :: (MonadState s m, Floating a) => Iso' s a -> a -> m a

(<<^^=) :: (MonadState s m, Fractional a, Integral e) => LensLike' ((,) a) s a -> e -> m a infix 4 #

Modify the target of a Lens into your Monad's state by raising it by an integral power and return the old value that was replaced.

When you do not need the result of the operation, (^^=) is more flexible.

(<<^^=) :: (MonadState s m, Fractional a, Integral e) => Lens' s a -> e -> m a
(<<^^=) :: (MonadState s m, Fractional a, Integral e) => Iso' s a -> e -> m a

(<<^=) :: (MonadState s m, Num a, Integral e) => LensLike' ((,) a) s a -> e -> m a infix 4 #

Modify the target of a Lens into your Monad's state by raising it by a non-negative power and return the old value that was replaced.

When you do not need the result of the operation, (^=) is more flexible.

(<<^=) :: (MonadState s m, Num a, Integral e) => Lens' s a -> e -> m a
(<<^=) :: (MonadState s m, Num a, Integral e) => Iso' s a -> a -> m a

(<<//=) :: (MonadState s m, Fractional a) => LensLike' ((,) a) s a -> a -> m a infix 4 #

Modify the target of a Lens into your Monads state by dividing by a value and return the old value that was replaced.

When you do not need the result of the operation, (//=) is more flexible.

(<<//=) :: (MonadState s m, Fractional a) => Lens' s a -> a -> m a
(<<//=) :: (MonadState s m, Fractional a) => Iso' s a -> a -> m a

(<<*=) :: (MonadState s m, Num a) => LensLike' ((,) a) s a -> a -> m a infix 4 #

Modify the target of a Lens into your Monad's state by multipling a value and return the old value that was replaced.

When you do not need the result of the operation, (*=) is more flexible.

(<<*=) :: (MonadState s m, Num a) => Lens' s a -> a -> m a
(<<*=) :: (MonadState s m, Num a) => Iso' s a -> a -> m a

(<<-=) :: (MonadState s m, Num a) => LensLike' ((,) a) s a -> a -> m a infix 4 #

Modify the target of a Lens into your Monad's state by subtracting a value and return the old value that was replaced.

When you do not need the result of the operation, (-=) is more flexible.

(<<-=) :: (MonadState s m, Num a) => Lens' s a -> a -> m a
(<<-=) :: (MonadState s m, Num a) => Iso' s a -> a -> m a

(<<+=) :: (MonadState s m, Num a) => LensLike' ((,) a) s a -> a -> m a infix 4 #

Modify the target of a Lens into your Monad's state by adding a value and return the old value that was replaced.

When you do not need the result of the operation, (+=) is more flexible.

(<<+=) :: (MonadState s m, Num a) => Lens' s a -> a -> m a
(<<+=) :: (MonadState s m, Num a) => Iso' s a -> a -> m a

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

Replace the target of a Lens into your Monad's state with Just a user supplied value and return the old value that was replaced.

When applied to a Traversal, this will return a monoidal summary of all of the old values present.

When you do not need the result of the operation, (?=) is more flexible.

(<<?=) :: MonadState s m             => Lens s t a (Maybe b)      -> b -> m a
(<<?=) :: MonadState s m             => Iso s t a (Maybe b)       -> b -> m a
(<<?=) :: (MonadState s m, Monoid a) => Traversal s t a (Maybe b) -> b -> m a

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

Replace the target of a Lens into your Monad's state with a user supplied value and return the old value that was replaced.

When applied to a Traversal, this will return a monoidal summary of all of the old values present.

When you do not need the result of the operation, (.=) is more flexible.

(<<.=) :: MonadState s m             => Lens' s a      -> a -> m a
(<<.=) :: MonadState s m             => Iso' s a       -> a -> m a
(<<.=) :: (MonadState s m, Monoid a) => Traversal' s a -> a -> m a

(<<%=) :: (Strong p, MonadState s m) => Over p ((,) a) s s a b -> p a b -> m a infix 4 #

Modify the target of a Lens into your Monad's state by a user supplied function and return the old value that was replaced.

When applied to a Traversal, this will return a monoidal summary of all of the old values present.

When you do not need the result of the operation, (%=) is more flexible.

(<<%=) :: MonadState s m             => Lens' s a      -> (a -> a) -> m a
(<<%=) :: MonadState s m             => Iso' s a       -> (a -> a) -> m a
(<<%=) :: (MonadState s m, Monoid a) => Traversal' s a -> (a -> a) -> m a

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

(<&&=) :: MonadState s m => LensLike' ((,) Bool) s Bool -> Bool -> m Bool infix 4 #

Logically && a Boolean valued Lens into your Monad's state and return the result.

When you do not need the result of the operation, (&&=) is more flexible.

(<&&=) :: MonadState s m => Lens' s Bool -> Bool -> m Bool
(<&&=) :: MonadState s m => Iso' s Bool  -> Bool -> m Bool

(<||=) :: MonadState s m => LensLike' ((,) Bool) s Bool -> Bool -> m Bool infix 4 #

Logically || a Boolean valued Lens into your Monad's state and return the result.

When you do not need the result of the operation, (||=) is more flexible.

(<||=) :: MonadState s m => Lens' s Bool -> Bool -> m Bool
(<||=) :: MonadState s m => Iso' s Bool  -> Bool -> m Bool

(<**=) :: (MonadState s m, Floating a) => LensLike' ((,) a) s a -> a -> m a infix 4 #

Raise the target of a floating-point valued Lens into your Monad's state to an arbitrary power and return the result.

When you do not need the result of the operation, (**=) is more flexible.

(<**=) :: (MonadState s m, Floating a) => Lens' s a -> a -> m a
(<**=) :: (MonadState s m, Floating a) => Iso' s a -> a -> m a

(<^^=) :: (MonadState s m, Fractional a, Integral e) => LensLike' ((,) a) s a -> e -> m a infix 4 #

Raise the target of a fractionally valued Lens into your Monad's state to an Integral power and return the result.

When you do not need the result of the operation, (^^=) is more flexible.

(<^^=) :: (MonadState s m, Fractional b, Integral e) => Lens' s a -> e -> m a
(<^^=) :: (MonadState s m, Fractional b, Integral e) => Iso' s a  -> e -> m a

(<^=) :: (MonadState s m, Num a, Integral e) => LensLike' ((,) a) s a -> e -> m a infix 4 #

Raise the target of a numerically valued Lens into your Monad's state to a non-negative Integral power and return the result.

When you do not need the result of the operation, (^=) is more flexible.

(<^=) :: (MonadState s m, Num a, Integral e) => Lens' s a -> e -> m a
(<^=) :: (MonadState s m, Num a, Integral e) => Iso' s a -> e -> m a

(<//=) :: (MonadState s m, Fractional a) => LensLike' ((,) a) s a -> a -> m a infix 4 #

Divide the target of a fractionally valued Lens into your Monad's state and return the result.

When you do not need the result of the division, (//=) is more flexible.

(<//=) :: (MonadState s m, Fractional a) => Lens' s a -> a -> m a
(<//=) :: (MonadState s m, Fractional a) => Iso' s a -> a -> m a

(<*=) :: (MonadState s m, Num a) => LensLike' ((,) a) s a -> a -> m a infix 4 #

Multiply the target of a numerically valued Lens into your Monad's state and return the result.

When you do not need the result of the multiplication, (*=) is more flexible.

(<*=) :: (MonadState s m, Num a) => Lens' s a -> a -> m a
(<*=) :: (MonadState s m, Num a) => Iso' s a -> a -> m a

(<-=) :: (MonadState s m, Num a) => LensLike' ((,) a) s a -> a -> m a infix 4 #

Subtract from the target of a numerically valued Lens into your Monad's state and return the result.

When you do not need the result of the subtraction, (-=) is more flexible.

(<-=) :: (MonadState s m, Num a) => Lens' s a -> a -> m a
(<-=) :: (MonadState s m, Num a) => Iso' s a -> a -> m a

(<+=) :: (MonadState s m, Num a) => LensLike' ((,) a) s a -> a -> m a infix 4 #

Add to the target of a numerically valued Lens into your Monad's state and return the result.

When you do not need the result of the addition, (+=) is more flexible.

(<+=) :: (MonadState s m, Num a) => Lens' s a -> a -> m a
(<+=) :: (MonadState s m, Num a) => Iso' s a -> a -> m a

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

Modify the target of a Lens into your Monad's state by a user supplied function and return the result.

When applied to a Traversal, it this will return a monoidal summary of all of the intermediate results.

When you do not need the result of the operation, (%=) is more flexible.

(<%=) :: MonadState s m             => Lens' s a      -> (a -> a) -> m a
(<%=) :: MonadState s m             => Iso' s a       -> (a -> a) -> m a
(<%=) :: (MonadState s m, Monoid a) => Traversal' s a -> (a -> a) -> m a

(<<<>~) :: Monoid r => LensLike' ((,) r) s r -> r -> s -> (r, s) infixr 4 #

Modify the target of a monoidally valued Lens by mappending a new value and return the old value.

When you do not need the old value, (<>~) is more flexible.

>>> (Sum a,b) & _1 <<<>~ Sum c
(Sum {getSum = a},(Sum {getSum = a + c},b))

>>> _2 <<<>~ ", 007" $ ("James", "Bond")
("Bond",("James","Bond, 007"))

(<<<>~) :: Monoid r => Lens' s r -> r -> s -> (r, s)
(<<<>~) :: Monoid r => Iso' s r -> r -> s -> (r, s)

(<<&&~) :: LensLike' ((,) Bool) s Bool -> Bool -> s -> (Bool, s) infixr 4 #

Logically && the target of a Bool-valued Lens and return the old value.

When you do not need the old value, (&&~) is more flexible.

>>> (False,6) & _1 <<&&~ True
(False,(False,6))

>>> ("hello",True) & _2 <<&&~ False
(True,("hello",False))

(<<&&~) :: Lens' s Bool -> Bool -> s -> (Bool, s)
(<<&&~) :: Iso' s Bool -> Bool -> s -> (Bool, s)

(<<||~) :: LensLike' ((,) Bool) s Bool -> Bool -> s -> (Bool, s) infixr 4 #

Logically || the target of a Bool-valued Lens and return the old value.

When you do not need the old value, (||~) is more flexible.

>>> (False,6) & _1 <<||~ True
(False,(True,6))

>>> ("hello",True) & _2 <<||~ False
(True,("hello",True))

(<<||~) :: Lens' s Bool -> Bool -> s -> (Bool, s)
(<<||~) :: Iso' s Bool -> Bool -> s -> (Bool, s)

(<<**~) :: Floating a => LensLike' ((,) a) s a -> a -> s -> (a, s) infixr 4 #

Raise the target of a floating-point valued Lens to an arbitrary power and return the old value.

When you do not need the old value, (**~) is more flexible.

>>> (a,b) & _1 <<**~ c
(a,(a**c,b))

>>> (a,b) & _2 <<**~ c
(b,(a,b**c))

(<<**~) :: Floating a => Lens' s a -> a -> s -> (a, s)
(<<**~) :: Floating a => Iso' s a -> a -> s -> (a, s)

(<<^^~) :: (Fractional a, Integral e) => LensLike' ((,) a) s a -> e -> s -> (a, s) infixr 4 #

Raise the target of a fractionally valued Lens to an integral power and return the old value.

When you do not need the old value, (^^~) is more flexible.

(<<^^~) :: (Fractional a, Integral e) => Lens' s a -> e -> s -> (a, s)
(<<^^~) :: (Fractional a, Integral e) => Iso' s a -> e -> S -> (a, s)

(<<^~) :: (Num a, Integral e) => LensLike' ((,) a) s a -> e -> s -> (a, s) infixr 4 #

Raise the target of a numerically valued Lens to a non-negative power and return the old value.

When you do not need the old value, (^~) is more flexible.

(<<^~) :: (Num a, Integral e) => Lens' s a -> e -> s -> (a, s)
(<<^~) :: (Num a, Integral e) => Iso' s a -> e -> s -> (a, s)

(<<//~) :: Fractional a => LensLike' ((,) a) s a -> a -> s -> (a, s) infixr 4 #

Divide the target of a numerically valued Lens and return the old value.

When you do not need the old value, (//~) is more flexible.

>>> (a,b) & _1 <<//~ c
(a,(a / c,b))

>>> ("Hawaii",10) & _2 <<//~ 2
(10.0,("Hawaii",5.0))

(<<//~) :: Fractional a => Lens' s a -> a -> s -> (a, s)
(<<//~) :: Fractional a => Iso' s a -> a -> s -> (a, s)

(<<*~) :: Num a => LensLike' ((,) a) s a -> a -> s -> (a, s) infixr 4 #

Multiply the target of a numerically valued Lens and return the old value.

When you do not need the old value, (-~) is more flexible.

>>> (a,b) & _1 <<*~ c
(a,(a * c,b))

>>> (a,b) & _2 <<*~ c
(b,(a,b * c))

(<<*~) :: Num a => Lens' s a -> a -> s -> (a, s)
(<<*~) :: Num a => Iso' s a -> a -> s -> (a, s)

(<<-~) :: Num a => LensLike' ((,) a) s a -> a -> s -> (a, s) infixr 4 #

Decrement the target of a numerically valued Lens and return the old value.

When you do not need the old value, (-~) is more flexible.

>>> (a,b) & _1 <<-~ c
(a,(a - c,b))

>>> (a,b) & _2 <<-~ c
(b,(a,b - c))

(<<-~) :: Num a => Lens' s a -> a -> s -> (a, s)
(<<-~) :: Num a => Iso' s a -> a -> s -> (a, s)

(<<+~) :: Num a => LensLike' ((,) a) s a -> a -> s -> (a, s) infixr 4 #

Increment the target of a numerically valued Lens and return the old value.

When you do not need the old value, (+~) is more flexible.

>>> (a,b) & _1 <<+~ c
(a,(a + c,b))

>>> (a,b) & _2 <<+~ c
(b,(a,b + c))

(<<+~) :: Num a => Lens' s a -> a -> s -> (a, s)
(<<+~) :: Num a => Iso' s a -> a -> s -> (a, s)

(<<?~) :: LensLike ((,) a) s t a (Maybe b) -> b -> s -> (a, t) infixr 4 #

Replace the target of a Lens with a Just value, but return the old value.

If you do not need the old value (?~) is more flexible.

>>> import Data.Map as Map
>>> _2.at "hello" <<?~ "world" $ (42,Map.fromList [("goodnight","gracie")])
(Nothing,(42,fromList [("goodnight","gracie"),("hello","world")]))

(<<?~) :: Iso s t a (Maybe b)       -> b -> s -> (a, t)
(<<?~) :: Lens s t a (Maybe b)      -> b -> s -> (a, t)
(<<?~) :: Traversal s t a (Maybe b) -> b -> s -> (a, t)

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

Replace the target of a Lens, but return the old value.

When you do not need the old value, (.~) is more flexible.

(<<.~) ::             Lens s t a b      -> b -> s -> (a, t)
(<<.~) ::             Iso s t a b       -> b -> s -> (a, t)
(<<.~) :: Monoid a => Traversal s t a b -> b -> s -> (a, t)

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

Modify the target of a Lens, but return the old value.

When you do not need the old value, (%~) is more flexible.

(<<%~) ::             Lens s t a b      -> (a -> b) -> s -> (a, t)
(<<%~) ::             Iso s t a b       -> (a -> b) -> s -> (a, t)
(<<%~) :: Monoid a => Traversal s t a b -> (a -> b) -> s -> (a, t)

(<&&~) :: LensLike ((,) Bool) s t Bool Bool -> Bool -> s -> (Bool, t) infixr 4 #

Logically && a Boolean valued Lens and return the result.

When you do not need the result of the operation, (&&~) is more flexible.

(<&&~) :: Lens' s Bool -> Bool -> s -> (Bool, s)
(<&&~) :: Iso' s Bool  -> Bool -> s -> (Bool, s)

(<||~) :: LensLike ((,) Bool) s t Bool Bool -> Bool -> s -> (Bool, t) infixr 4 #

Logically || a Boolean valued Lens and return the result.

When you do not need the result of the operation, (||~) is more flexible.

(<||~) :: Lens' s Bool -> Bool -> s -> (Bool, s)
(<||~) :: Iso' s Bool  -> Bool -> s -> (Bool, s)

(<**~) :: Floating a => LensLike ((,) a) s t a a -> a -> s -> (a, t) infixr 4 #

Raise the target of a floating-point valued Lens to an arbitrary power and return the result.

When you do not need the result of the operation, (**~) is more flexible.

(<**~) :: Floating a => Lens' s a -> a -> s -> (a, s)
(<**~) :: Floating a => Iso' s a  -> a -> s -> (a, s)

(<^^~) :: (Fractional a, Integral e) => LensLike ((,) a) s t a a -> e -> s -> (a, t) infixr 4 #

Raise the target of a fractionally valued Lens to an Integral power and return the result.

When you do not need the result of the operation, (^^~) is more flexible.

(<^^~) :: (Fractional a, Integral e) => Lens' s a -> e -> s -> (a, s)
(<^^~) :: (Fractional a, Integral e) => Iso' s a -> e -> s -> (a, s)

(<^~) :: (Num a, Integral e) => LensLike ((,) a) s t a a -> e -> s -> (a, t) infixr 4 #

Raise the target of a numerically valued Lens to a non-negative Integral power and return the result.

When you do not need the result of the operation, (^~) is more flexible.

(<^~) :: (Num a, Integral e) => Lens' s a -> e -> s -> (a, s)
(<^~) :: (Num a, Integral e) => Iso' s a -> e -> s -> (a, s)

(<//~) :: Fractional a => LensLike ((,) a) s t a a -> a -> s -> (a, t) infixr 4 #

Divide the target of a fractionally valued Lens and return the result.

When you do not need the result of the division, (//~) is more flexible.

(<//~) :: Fractional a => Lens' s a -> a -> s -> (a, s)
(<//~) :: Fractional a => Iso'  s a -> a -> s -> (a, s)

(<*~) :: Num a => LensLike ((,) a) s t a a -> a -> s -> (a, t) infixr 4 #

Multiply the target of a numerically valued Lens and return the result.

When you do not need the result of the multiplication, (*~) is more flexible.

(<*~) :: Num a => Lens' s a -> a -> s -> (a, s)
(<*~) :: Num a => Iso'  s a -> a -> s -> (a, s)

(<-~) :: Num a => LensLike ((,) a) s t a a -> a -> s -> (a, t) infixr 4 #

Decrement the target of a numerically valued Lens and return the result.

When you do not need the result of the subtraction, (-~) is more flexible.

(<-~) :: Num a => Lens' s a -> a -> s -> (a, s)
(<-~) :: Num a => Iso' s a  -> a -> s -> (a, s)

(<+~) :: Num a => LensLike ((,) a) s t a a -> a -> s -> (a, t) infixr 4 #

Increment the target of a numerically valued Lens and return the result.

When you do not need the result of the addition, (+~) is more flexible.

(<+~) :: Num a => Lens' s a -> a -> s -> (a, s)
(<+~) :: Num a => Iso' s a  -> a -> s -> (a, s)

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

Modify the target of a Lens and return the result.

When you do not need the result of the operation, (%~) is more flexible.

(<%~) ::             Lens s t a b      -> (a -> b) -> s -> (b, t)
(<%~) ::             Iso s t a b       -> (a -> b) -> s -> (b, t)
(<%~) :: Monoid b => Traversal s t a b -> (a -> b) -> s -> (b, t)

cloneIndexedLens :: AnIndexedLens i s t a b -> IndexedLens i s t a b #

Clone an IndexedLens as an IndexedLens with the same index.

cloneIndexPreservingLens :: ALens s t a b -> IndexPreservingLens s t a b #

Clone a Lens as an IndexedPreservingLens that just passes through whatever index is on any IndexedLens, IndexedFold, IndexedGetter or IndexedTraversal it is composed with.

cloneLens :: ALens s t a b -> Lens s t a b #

Cloning a Lens is one way to make sure you aren't given something weaker, such as a Traversal and can be used as a way to pass around lenses that have to be monomorphic in f.

Note: This only accepts a proper Lens.

>>> let example l x = set (cloneLens l) (x^.cloneLens l + 1) x in example _2 ("hello",1,"you")
("hello",2,"you")

locus :: IndexedComonadStore p => Lens (p a c s) (p b c s) a b #

This Lens lets you view the current pos of any indexed store comonad and seek to a new position. This reduces the API for working these instances to a single Lens.

ipos w ≡ w ^. locus
iseek s w ≡ w & locus .~ s
iseeks f w ≡ w & locus %~ f

locus :: Lens' (Context' a s) a
locus :: Conjoined p => Lens' (Pretext' p a s) a
locus :: Conjoined p => Lens' (PretextT' p g a s) a

alongside :: LensLike (AlongsideLeft f b') s t a b -> LensLike (AlongsideRight f t) s' t' a' b' -> LensLike f (s, s') (t, t') (a, a') (b, b') #

alongside makes a Lens from two other lenses or a Getter from two other getters by executing them on their respective halves of a product.

>>> (Left a, Right b)^.alongside chosen chosen
(a,b)

>>> (Left a, Right b) & alongside chosen chosen .~ (c,d)
(Left c,Right d)

alongside :: Lens   s t a b -> Lens   s' t' a' b' -> Lens   (s,s') (t,t') (a,a') (b,b')
alongside :: Getter s   a   -> Getter s'    a'    -> Getter (s,s')        (a,a')

chosen :: IndexPreservingLens (Either a a) (Either b b) a b #

This is a Lens that updates either side of an Either, where both sides have the same type.

chosen ≡ choosing id id

>>> Left a^.chosen
a

>>> Right a^.chosen
a

>>> Right "hello"^.chosen
"hello"

>>> Right a & chosen *~ b
Right (a * b)

chosen :: Lens (Either a a) (Either b b) a b
chosen f (Left a)  = Left <$> f a
chosen f (Right a) = Right <$> f a

choosing :: Functor f => LensLike f s t a b -> LensLike f s' t' a b -> LensLike f (Either s s') (Either t t') a b #

Merge two lenses, getters, setters, folds or traversals.

chosen ≡ choosing id id

choosing :: Getter s a     -> Getter s' a     -> Getter (Either s s') a
choosing :: Fold s a       -> Fold s' a       -> Fold (Either s s') a
choosing :: Lens' s a      -> Lens' s' a      -> Lens' (Either s s') a
choosing :: Traversal' s a -> Traversal' s' a -> Traversal' (Either s s') a
choosing :: Setter' s a    -> Setter' s' a    -> Setter' (Either s s') a

inside :: Corepresentable p => ALens s t a b -> Lens (p e s) (p e t) (p e a) (p e b) #

Lift a Lens so it can run under a function (or other corepresentable profunctor).

inside :: Lens s t a b -> Lens (e -> s) (e -> t) (e -> a) (e -> b)

>>> (\x -> (x-1,x+1)) ^. inside _1 $ 5
4

>>> runState (modify (1:) >> modify (2:)) ^. (inside _2) $ []
[2,1]

(??) :: Functor f => f (a -> b) -> a -> f b infixl 1 #

This is convenient to flip argument order of composite functions defined as:

fab ?? a = fmap ($ a) fab

For the Functor instance f = ((->) r) you can reason about this function as if the definition was (??) ≡ flip:

>>> (h ?? x) a
h a x

>>> execState ?? [] $ modify (1:)
[1]

>>> over _2 ?? ("hello","world") $ length
("hello",5)

>>> over ?? length ?? ("hello","world") $ _2
("hello",5)

(%%=) :: MonadState s m => Over p ((,) r) s s a b -> p a (r, b) -> m r infix 4 #

Modify the target of a Lens in the current state returning some extra information of type r or modify all targets of a Traversal in the current state, extracting extra information of type r and return a monoidal summary of the changes.

>>> runState (_1 %%= \x -> (f x, g x)) (a,b)
(f a,(g a,b))

(%%=) ≡ (state .)

It may be useful to think of (%%=), instead, as having either of the following more restricted type signatures:

(%%=) :: MonadState s m             => Iso s s a b       -> (a -> (r, b)) -> m r
(%%=) :: MonadState s m             => Lens s s a b      -> (a -> (r, b)) -> m r
(%%=) :: (MonadState s m, Monoid r) => Traversal s s a b -> (a -> (r, b)) -> m r

(%%~) :: LensLike f s t a b -> (a -> f b) -> s -> f t infixr 4 #

(%%~) can be used in one of two scenarios:

When applied to a Lens, it can edit the target of the Lens in a structure, extracting a functorial result.

When applied to a Traversal, it can edit the targets of the traversals, extracting an applicative summary of its actions.

>>> [66,97,116,109,97,110] & each %%~ \a -> ("na", chr a)
("nananananana","Batman")

For all that the definition of this combinator is just:

(%%~) ≡ id

It may be beneficial to think about it as if it had these even more restricted types, however:

(%%~) :: Functor f =>     Iso s t a b       -> (a -> f b) -> s -> f t
(%%~) :: Functor f =>     Lens s t a b      -> (a -> f b) -> s -> f t
(%%~) :: Applicative f => Traversal s t a b -> (a -> f b) -> s -> f t

When applied to a Traversal, it can edit the targets of the traversals, extracting a supplemental monoidal summary of its actions, by choosing f = ((,) m)

(%%~) ::             Iso s t a b       -> (a -> (r, b)) -> s -> (r, t)
(%%~) ::             Lens s t a b      -> (a -> (r, b)) -> s -> (r, t)
(%%~) :: Monoid m => Traversal s t a b -> (a -> (m, b)) -> s -> (m, t)

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

This can be used to chain lens operations using op= syntax rather than op~ syntax for simple non-type-changing cases.

>>> (10,20) & _1 .~ 30 & _2 .~ 40
(30,40)

>>> (10,20) &~ do _1 .= 30; _2 .= 40
(30,40)

This does not support type-changing assignment, e.g.

>>> (10,20) & _1 .~ "hello"
("hello",20)

ilens :: (s -> (i, a)) -> (s -> b -> t) -> IndexedLens i s t a b #

Build an IndexedLens from a Getter and a Setter.

iplens :: (s -> a) -> (s -> b -> t) -> IndexPreservingLens s t a b #

Build an index-preserving Lens from a Getter and a Setter.

withLens :: ALens s t a b -> ((s -> a) -> (s -> b -> t) -> r) -> r #

Obtain a getter and a setter from a lens, reversing lens.

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

Build a Lens from a getter and a setter.

lens :: Functor f => (s -> a) -> (s -> b -> t) -> (a -> f b) -> s -> f t

>>> s ^. lens getter setter
getter s

>>> s & lens getter setter .~ b
setter s b

>>> s & lens getter setter %~ f
setter s (f (getter s))

lens :: (s -> a) -> (s -> a -> s) -> Lens' s a

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

When you see this as an argument to a function, it expects a Lens.

This type can also be used when you need to store a Lens in a container, since it is rank-1. You can turn them back into a Lens with cloneLens, or use it directly with combinators like storing and (^#).

type ALens' s a = ALens s s a a #

type ALens' = Simple ALens

type AnIndexedLens i s t a b = Optical (Indexed i) ((->) :: Type -> Type -> Type) (Pretext (Indexed i) a b) s t a b #

When you see this as an argument to a function, it expects an IndexedLens

type AnIndexedLens' i s a = AnIndexedLens i s s a a #

type AnIndexedLens' = Simple (AnIndexedLens i)

imapOf :: AnIndexedSetter i s t a b -> (i -> a -> b) -> s -> t #

Map with index. (Deprecated alias for iover).

When you do not need access to the index, then mapOf is more liberal in what it can accept.

mapOf l ≡ imapOf l . const

imapOf :: IndexedSetter i s t a b    -> (i -> a -> b) -> s -> t
imapOf :: IndexedLens i s t a b      -> (i -> a -> b) -> s -> t
imapOf :: IndexedTraversal i s t a b -> (i -> a -> b) -> s -> t

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

mapOf is a deprecated alias for over.

assignA :: Arrow p => ASetter s t a b -> p s b -> p s t #

Run an arrow command and use the output to set all the targets of a Lens, Setter or Traversal to the result.

assignA can be used very similarly to (<~), except that the type of the object being modified can change; for example:

runKleisli action ((), (), ()) where
  action =      assignA _1 (Kleisli (const getVal1))
           >>> assignA _2 (Kleisli (const getVal2))
           >>> assignA _3 (Kleisli (const getVal3))
  getVal1 :: Either String Int
  getVal1 = ...
  getVal2 :: Either String Bool
  getVal2 = ...
  getVal3 :: Either String Char
  getVal3 = ...

has the type Either String (Int, Bool, Char)

assignA :: Arrow p => Iso s t a b       -> p s b -> p s t
assignA :: Arrow p => Lens s t a b      -> p s b -> p s t
assignA :: Arrow p => Traversal s t a b -> p s b -> p s t
assignA :: Arrow p => Setter s t a b    -> p s b -> p s t

(.@=) :: MonadState s m => AnIndexedSetter i s s a b -> (i -> b) -> m () infix 4 #

Replace every target in the current state of an IndexedSetter, IndexedLens or IndexedTraversal with access to the index.

When you do not need access to the index then (.=) is more liberal in what it can accept.

l .= b ≡ l .@= const b

(.@=) :: MonadState s m => IndexedSetter i s s a b    -> (i -> b) -> m ()
(.@=) :: MonadState s m => IndexedLens i s s a b      -> (i -> b) -> m ()
(.@=) :: MonadState s m => IndexedTraversal i s t a b -> (i -> b) -> m ()

imodifying :: MonadState s m => AnIndexedSetter i s s a b -> (i -> a -> b) -> m () #

This is an alias for (%@=).

(%@=) :: MonadState s m => AnIndexedSetter i s s a b -> (i -> a -> b) -> m () infix 4 #

Adjust every target in the current state of an IndexedSetter, IndexedLens or IndexedTraversal with access to the index.

When you do not need access to the index then (%=) is more liberal in what it can accept.

l %= f ≡ l %@= const f

(%@=) :: MonadState s m => IndexedSetter i s s a b    -> (i -> a -> b) -> m ()
(%@=) :: MonadState s m => IndexedLens i s s a b      -> (i -> a -> b) -> m ()
(%@=) :: MonadState s m => IndexedTraversal i s t a b -> (i -> a -> b) -> m ()

(.@~) :: AnIndexedSetter i s t a b -> (i -> b) -> s -> t infixr 4 #

Replace every target of an IndexedSetter, IndexedLens or IndexedTraversal with access to the index.

(.@~) ≡ iset

When you do not need access to the index then (.~) is more liberal in what it can accept.

l .~ b ≡ l .@~ const b

(.@~) :: IndexedSetter i s t a b    -> (i -> b) -> s -> t
(.@~) :: IndexedLens i s t a b      -> (i -> b) -> s -> t
(.@~) :: IndexedTraversal i s t a b -> (i -> b) -> s -> t

(%@~) :: AnIndexedSetter i s t a b -> (i -> a -> b) -> s -> t infixr 4 #

Adjust every target of an IndexedSetter, IndexedLens or IndexedTraversal with access to the index.

(%@~) ≡ iover

When you do not need access to the index then (%~) is more liberal in what it can accept.

l %~ f ≡ l %@~ const f

(%@~) :: IndexedSetter i s t a b    -> (i -> a -> b) -> s -> t
(%@~) :: IndexedLens i s t a b      -> (i -> a -> b) -> s -> t
(%@~) :: IndexedTraversal i s t a b -> (i -> a -> b) -> s -> t

isets :: ((i -> a -> b) -> s -> t) -> IndexedSetter i s t a b #

Build an IndexedSetter from an imap-like function.

Your supplied function f is required to satisfy:

f id ≡ id
f g . f h ≡ f (g . h)

Equational reasoning:

isets . iover ≡ id
iover . isets ≡ id

Another way to view isets is that it takes a "semantic editor combinator" which has been modified to carry an index and transforms it into a IndexedSetter.

iset :: AnIndexedSetter i s t a b -> (i -> b) -> s -> t #

Set with index. Equivalent to iover with the current value ignored.

When you do not need access to the index, then set is more liberal in what it can accept.

set l ≡ iset l . const

iset :: IndexedSetter i s t a b    -> (i -> b) -> s -> t
iset :: IndexedLens i s t a b      -> (i -> b) -> s -> t
iset :: IndexedTraversal i s t a b -> (i -> b) -> s -> t

iover :: AnIndexedSetter i s t a b -> (i -> a -> b) -> s -> t #

Map with index. This is an alias for imapOf.

When you do not need access to the index, then over is more liberal in what it can accept.

over l ≡ iover l . const
iover l ≡ over l . Indexed

iover :: IndexedSetter i s t a b    -> (i -> a -> b) -> s -> t
iover :: IndexedLens i s t a b      -> (i -> a -> b) -> s -> t
iover :: IndexedTraversal i s t a b -> (i -> a -> b) -> s -> t

ilocally :: MonadReader s m => AnIndexedSetter i s s a b -> (i -> a -> b) -> m r -> m r #

This is a generalization of locally that allows one to make indexed local changes to a Reader environment associated with the target of a Setter, Lens, or Traversal.

locally l f ≡ ilocally l f . const
ilocally l f ≡ locally l f . Indexed

ilocally :: MonadReader s m => IndexedLens s s a b      -> (i -> a -> b) -> m r -> m r
ilocally :: MonadReader s m => IndexedTraversal s s a b -> (i -> a -> b) -> m r -> m r
ilocally :: MonadReader s m => IndexedSetter s s a b    -> (i -> a -> b) -> m r -> m r

locally :: MonadReader s m => ASetter s s a b -> (a -> b) -> m r -> m r #

Modify the value of the Reader environment associated with the target of a Setter, Lens, or Traversal.

locally l id a ≡ a
locally l f . locally l g ≡ locally l (f . g)

>>> (1,1) & locally _1 (+1) (uncurry (+))
3

>>> "," & locally ($) ("Hello" <>) (<> " world!")
"Hello, world!"

locally :: MonadReader s m => Iso s s a b       -> (a -> b) -> m r -> m r
locally :: MonadReader s m => Lens s s a b      -> (a -> b) -> m r -> m r
locally :: MonadReader s m => Traversal s s a b -> (a -> b) -> m r -> m r
locally :: MonadReader s m => Setter s s a b    -> (a -> b) -> m r -> m r

icensoring :: MonadWriter w m => IndexedSetter i w w u v -> (i -> u -> v) -> m a -> m a #

This is a generalization of censor that allows you to censor just a portion of the resulting MonadWriter, with access to the index of an IndexedSetter.

censoring :: MonadWriter w m => Setter w w u v -> (u -> v) -> m a -> m a #

This is a generalization of censor that allows you to censor just a portion of the resulting MonadWriter.

ipassing :: MonadWriter w m => IndexedSetter i w w u v -> m (a, i -> u -> v) -> m a #

This is a generalization of pass that allows you to modify just a portion of the resulting MonadWriter with access to the index of an IndexedSetter.

passing :: MonadWriter w m => Setter w w u v -> m (a, u -> v) -> m a #

This is a generalization of pass that allows you to modify just a portion of the resulting MonadWriter.

scribe :: (MonadWriter t m, Monoid s) => ASetter s t a b -> b -> m () #

Write to a fragment of a larger Writer format.

(<>=) :: (MonadState s m, Monoid a) => ASetter' s a -> a -> m () infix 4 #

Modify the target(s) of a Lens', Iso, Setter or Traversal by mappending a value.

>>> execState (do _1 <>= Sum c; _2 <>= Product d) (Sum a,Product b)
(Sum {getSum = a + c},Product {getProduct = b * d})

>>> execState (both <>= "!!!") ("hello","world")
("hello!!!","world!!!")

(<>=) :: (MonadState s m, Monoid a) => Setter' s a -> a -> m ()
(<>=) :: (MonadState s m, Monoid a) => Iso' s a -> a -> m ()
(<>=) :: (MonadState s m, Monoid a) => Lens' s a -> a -> m ()
(<>=) :: (MonadState s m, Monoid a) => Traversal' s a -> a -> m ()

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

Modify the target of a monoidally valued by mappending another value.

>>> (Sum a,b) & _1 <>~ Sum c
(Sum {getSum = a + c},b)

>>> (Sum a,Sum b) & both <>~ Sum c
(Sum {getSum = a + c},Sum {getSum = b + c})

>>> both <>~ "!!!" $ ("hello","world")
("hello!!!","world!!!")

(<>~) :: Monoid a => Setter s t a a    -> a -> s -> t
(<>~) :: Monoid a => Iso s t a a       -> a -> s -> t
(<>~) :: Monoid a => Lens s t a a      -> a -> s -> t
(<>~) :: Monoid a => Traversal s t a a -> a -> s -> t

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

Set Just a value with pass-through

This is useful for chaining assignment without round-tripping through your Monad stack.

do x <- at "foo" <?= ninety_nine_bottles_of_beer_on_the_wall

If you do not need a copy of the intermediate result, then using l ?= d will avoid unused binding warnings.

(<?=) :: MonadState s m => Setter s s a (Maybe b)    -> b -> m b
(<?=) :: MonadState s m => Iso s s a (Maybe b)       -> b -> m b
(<?=) :: MonadState s m => Lens s s a (Maybe b)      -> b -> m b
(<?=) :: MonadState s m => Traversal s s a (Maybe b) -> b -> m b

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

Set with pass-through

This is useful for chaining assignment without round-tripping through your Monad stack.

do x <- _2 <.= ninety_nine_bottles_of_beer_on_the_wall

If you do not need a copy of the intermediate result, then using l .= d will avoid unused binding warnings.

(<.=) :: MonadState s m => Setter s s a b    -> b -> m b
(<.=) :: MonadState s m => Iso s s a b       -> b -> m b
(<.=) :: MonadState s m => Lens s s a b      -> b -> m b
(<.=) :: MonadState s m => Traversal s s a b -> b -> m b

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

Run a monadic action, and set all of the targets of a Lens, Setter or Traversal to its result.

(<~) :: MonadState s m => Iso s s a b       -> m b -> m ()
(<~) :: MonadState s m => Lens s s a b      -> m b -> m ()
(<~) :: MonadState s m => Traversal s s a b -> m b -> m ()
(<~) :: MonadState s m => Setter s s a b    -> m b -> m ()

As a reasonable mnemonic, this lets you store the result of a monadic action in a Lens rather than in a local variable.

do foo <- bar
   ...

will store the result in a variable, while

do foo <~ bar
   ...

will store the result in a Lens, Setter, or Traversal.

(||=) :: MonadState s m => ASetter' s Bool -> Bool -> m () infix 4 #

Modify the target(s) of a Lens', 'Iso, Setter or Traversal by taking their logical || with a value.

>>> execState (do _1 ||= True; _2 ||= False; _3 ||= True; _4 ||= False) (True,True,False,False)
(True,True,True,False)

(||=) :: MonadState s m => Setter' s Bool    -> Bool -> m ()
(||=) :: MonadState s m => Iso' s Bool       -> Bool -> m ()
(||=) :: MonadState s m => Lens' s Bool      -> Bool -> m ()
(||=) :: MonadState s m => Traversal' s Bool -> Bool -> m ()

(&&=) :: MonadState s m => ASetter' s Bool -> Bool -> m () infix 4 #

Modify the target(s) of a Lens', Iso, Setter or Traversal by taking their logical && with a value.

>>> execState (do _1 &&= True; _2 &&= False; _3 &&= True; _4 &&= False) (True,True,False,False)
(True,False,False,False)

(&&=) :: MonadState s m => Setter' s Bool    -> Bool -> m ()
(&&=) :: MonadState s m => Iso' s Bool       -> Bool -> m ()
(&&=) :: MonadState s m => Lens' s Bool      -> Bool -> m ()
(&&=) :: MonadState s m => Traversal' s Bool -> Bool -> m ()

(**=) :: (MonadState s m, Floating a) => ASetter' s a -> a -> m () infix 4 #

Raise the target(s) of a numerically valued Lens, Setter or Traversal to an arbitrary power

>>> execState (do _1 **= c; _2 **= d) (a,b)
(a**c,b**d)

(**=) ::  (MonadState s m, Floating a) => Setter' s a    -> a -> m ()
(**=) ::  (MonadState s m, Floating a) => Iso' s a       -> a -> m ()
(**=) ::  (MonadState s m, Floating a) => Lens' s a      -> a -> m ()
(**=) ::  (MonadState s m, Floating a) => Traversal' s a -> a -> m ()

(^^=) :: (MonadState s m, Fractional a, Integral e) => ASetter' s a -> e -> m () infix 4 #

Raise the target(s) of a numerically valued Lens, Setter or Traversal to an integral power.

(^^=) ::  (MonadState s m, Fractional a, Integral e) => Setter' s a    -> e -> m ()
(^^=) ::  (MonadState s m, Fractional a, Integral e) => Iso' s a       -> e -> m ()
(^^=) ::  (MonadState s m, Fractional a, Integral e) => Lens' s a      -> e -> m ()
(^^=) ::  (MonadState s m, Fractional a, Integral e) => Traversal' s a -> e -> m ()

(^=) :: (MonadState s m, Num a, Integral e) => ASetter' s a -> e -> m () infix 4 #

Raise the target(s) of a numerically valued Lens, Setter or Traversal to a non-negative integral power.

(^=) ::  (MonadState s m, Num a, Integral e) => Setter' s a    -> e -> m ()
(^=) ::  (MonadState s m, Num a, Integral e) => Iso' s a       -> e -> m ()
(^=) ::  (MonadState s m, Num a, Integral e) => Lens' s a      -> e -> m ()
(^=) ::  (MonadState s m, Num a, Integral e) => Traversal' s a -> e -> m ()

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

Modify the target(s) of a Lens', Iso, Setter or Traversal by dividing by a value.

>>> execState (do _1 //= c; _2 //= d) (a,b)
(a / c,b / d)

(//=) :: (MonadState s m, Fractional a) => Setter' s a    -> a -> m ()
(//=) :: (MonadState s m, Fractional a) => Iso' s a       -> a -> m ()
(//=) :: (MonadState s m, Fractional a) => Lens' s a      -> a -> m ()
(//=) :: (MonadState s m, Fractional a) => Traversal' s a -> a -> m ()

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

Modify the target(s) of a Lens', Iso, Setter or Traversal by multiplying by value.

>>> execState (do _1 *= c; _2 *= d) (a,b)
(a * c,b * d)

(*=) :: (MonadState s m, Num a) => Setter' s a    -> a -> m ()
(*=) :: (MonadState s m, Num a) => Iso' s a       -> a -> m ()
(*=) :: (MonadState s m, Num a) => Lens' s a      -> a -> m ()
(*=) :: (MonadState s m, Num a) => Traversal' s a -> a -> m ()

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

Modify the target(s) of a Lens', Iso, Setter or Traversal by subtracting a value.

>>> execState (do _1 -= c; _2 -= d) (a,b)
(a - c,b - d)

(-=) :: (MonadState s m, Num a) => Setter' s a    -> a -> m ()
(-=) :: (MonadState s m, Num a) => Iso' s a       -> a -> m ()
(-=) :: (MonadState s m, Num a) => Lens' s a      -> a -> m ()
(-=) :: (MonadState s m, Num a) => Traversal' s a -> a -> m ()

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

Modify the target(s) of a Lens', Iso, Setter or Traversal by adding a value.

Example:

fresh :: MonadState Int m => m Int
fresh = do
  id += 1
  use id

>>> execState (do _1 += c; _2 += d) (a,b)
(a + c,b + d)

>>> execState (do _1.at 1.non 0 += 10) (Map.fromList [(2,100)],"hello")
(fromList [(1,10),(2,100)],"hello")

(+=) :: (MonadState s m, Num a) => Setter' s a    -> a -> m ()
(+=) :: (MonadState s m, Num a) => Iso' s a       -> a -> m ()
(+=) :: (MonadState s m, Num a) => Lens' s a      -> a -> m ()
(+=) :: (MonadState s m, Num a) => Traversal' s a -> a -> m ()

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

Replace the target of a Lens or all of the targets of a Setter or Traversal in our monadic state with Just a new value, irrespective of the old.

>>> execState (do at 1 ?= a; at 2 ?= b) Map.empty
fromList [(1,a),(2,b)]

>>> execState (do _1 ?= b; _2 ?= c) (Just a, Nothing)
(Just b,Just c)

(?=) :: MonadState s m => Iso' s (Maybe a)       -> a -> m ()
(?=) :: MonadState s m => Lens' s (Maybe a)      -> a -> m ()
(?=) :: MonadState s m => Traversal' s (Maybe a) -> a -> m ()
(?=) :: MonadState s m => Setter' s (Maybe a)    -> a -> m ()

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

This is an alias for (%=).

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

Map over the target of a Lens or all of the targets of a Setter or Traversal in our monadic state.

>>> execState (do _1 %= f;_2 %= g) (a,b)
(f a,g b)

>>> execState (do both %= f) (a,b)
(f a,f b)

(%=) :: MonadState s m => Iso' s a       -> (a -> a) -> m ()
(%=) :: MonadState s m => Lens' s a      -> (a -> a) -> m ()
(%=) :: MonadState s m => Traversal' s a -> (a -> a) -> m ()
(%=) :: MonadState s m => Setter' s a    -> (a -> a) -> m ()

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

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

Replace the target of a Lens or all of the targets of a Setter or Traversal in our monadic state with a new value, irrespective of the old.

This is an alias for (.=).

>>> execState (do assign _1 c; assign _2 d) (a,b)
(c,d)

>>> execState (both .= c) (a,b)
(c,c)

assign :: MonadState s m => Iso' s a       -> a -> m ()
assign :: MonadState s m => Lens' s a      -> a -> m ()
assign :: MonadState s m => Traversal' s a -> a -> m ()
assign :: MonadState s m => Setter' s a    -> a -> m ()

(&&~) :: ASetter s t Bool Bool -> Bool -> s -> t infixr 4 #

Logically && the target(s) of a Bool-valued Lens or Setter.

>>> both &&~ True $ (False, True)
(False,True)

>>> both &&~ False $ (False, True)
(False,False)

(&&~) :: Setter' s Bool    -> Bool -> s -> s
(&&~) :: Iso' s Bool       -> Bool -> s -> s
(&&~) :: Lens' s Bool      -> Bool -> s -> s
(&&~) :: Traversal' s Bool -> Bool -> s -> s

(||~) :: ASetter s t Bool Bool -> Bool -> s -> t infixr 4 #

Logically || the target(s) of a Bool-valued Lens or Setter.

>>> both ||~ True $ (False,True)
(True,True)

>>> both ||~ False $ (False,True)
(False,True)

(||~) :: Setter' s Bool    -> Bool -> s -> s
(||~) :: Iso' s Bool       -> Bool -> s -> s
(||~) :: Lens' s Bool      -> Bool -> s -> s
(||~) :: Traversal' s Bool -> Bool -> s -> s

(**~) :: Floating a => ASetter s t a a -> a -> s -> t infixr 4 #

Raise the target(s) of a floating-point valued Lens, Setter or Traversal to an arbitrary power.

>>> (a,b) & _1 **~ c
(a**c,b)

>>> (a,b) & both **~ c
(a**c,b**c)

>>> _2 **~ 10 $ (3,2)
(3,1024.0)

(**~) :: Floating a => Setter' s a    -> a -> s -> s
(**~) :: Floating a => Iso' s a       -> a -> s -> s
(**~) :: Floating a => Lens' s a      -> a -> s -> s
(**~) :: Floating a => Traversal' s a -> a -> s -> s

(^^~) :: (Fractional a, Integral e) => ASetter s t a a -> e -> s -> t infixr 4 #

Raise the target(s) of a fractionally valued Lens, Setter or Traversal to an integral power.

>>> (1,2) & _2 ^^~ (-1)
(1,0.5)

(^^~) :: (Fractional a, Integral e) => Setter' s a    -> e -> s -> s
(^^~) :: (Fractional a, Integral e) => Iso' s a       -> e -> s -> s
(^^~) :: (Fractional a, Integral e) => Lens' s a      -> e -> s -> s
(^^~) :: (Fractional a, Integral e) => Traversal' s a -> e -> s -> s

(^~) :: (Num a, Integral e) => ASetter s t a a -> e -> s -> t infixr 4 #

Raise the target(s) of a numerically valued Lens, Setter or Traversal to a non-negative integral power.

>>> (1,3) & _2 ^~ 2
(1,9)

(^~) :: (Num a, Integral e) => Setter' s a    -> e -> s -> s
(^~) :: (Num a, Integral e) => Iso' s a       -> e -> s -> s
(^~) :: (Num a, Integral e) => Lens' s a      -> e -> s -> s
(^~) :: (Num a, Integral e) => Traversal' s a -> e -> s -> s

(//~) :: Fractional a => ASetter s t a a -> a -> s -> t infixr 4 #

Divide the target(s) of a numerically valued Lens, Iso, Setter or Traversal.

>>> (a,b) & _1 //~ c
(a / c,b)

>>> (a,b) & both //~ c
(a / c,b / c)

>>> ("Hawaii",10) & _2 //~ 2
("Hawaii",5.0)

(//~) :: Fractional a => Setter' s a    -> a -> s -> s
(//~) :: Fractional a => Iso' s a       -> a -> s -> s
(//~) :: Fractional a => Lens' s a      -> a -> s -> s
(//~) :: Fractional a => Traversal' s a -> a -> s -> s

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

Decrement the target(s) of a numerically valued Lens, Iso, Setter or Traversal.

>>> (a,b) & _1 -~ c
(a - c,b)

>>> (a,b) & both -~ c
(a - c,b - c)

>>> _1 -~ 2 $ (1,2)
(-1,2)

>>> mapped.mapped -~ 1 $ [[4,5],[6,7]]
[[3,4],[5,6]]

(-~) :: Num a => Setter' s a    -> a -> s -> s
(-~) :: Num a => Iso' s a       -> a -> s -> s
(-~) :: Num a => Lens' s a      -> a -> s -> s
(-~) :: Num a => Traversal' s a -> a -> s -> s

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

Multiply the target(s) of a numerically valued Lens, Iso, Setter or Traversal.

>>> (a,b) & _1 *~ c
(a * c,b)

>>> (a,b) & both *~ c
(a * c,b * c)

>>> (1,2) & _2 *~ 4
(1,8)

>>> Just 24 & mapped *~ 2
Just 48

(*~) :: Num a => Setter' s a    -> a -> s -> s
(*~) :: Num a => Iso' s a       -> a -> s -> s
(*~) :: Num a => Lens' s a      -> a -> s -> s
(*~) :: Num a => Traversal' s a -> a -> s -> s

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

Increment the target(s) of a numerically valued Lens, Setter or Traversal.

>>> (a,b) & _1 +~ c
(a + c,b)

>>> (a,b) & both +~ c
(a + c,b + c)

>>> (1,2) & _2 +~ 1
(1,3)

>>> [(a,b),(c,d)] & traverse.both +~ e
[(a + e,b + e),(c + e,d + e)]

(+~) :: Num a => Setter' s a    -> a -> s -> s
(+~) :: Num a => Iso' s a       -> a -> s -> s
(+~) :: Num a => Lens' s a      -> a -> s -> s
(+~) :: Num a => Traversal' s a -> a -> s -> s

(<?~) :: ASetter s t a (Maybe b) -> b -> s -> (b, t) infixr 4 #

Set to Just a value with pass-through.

This is mostly present for consistency, but may be useful for for chaining assignments.

If you do not need a copy of the intermediate result, then using l ?~ d directly is a good idea.

>>> import Data.Map as Map
>>> _2.at "hello" <?~ "world" $ (42,Map.fromList [("goodnight","gracie")])
("world",(42,fromList [("goodnight","gracie"),("hello","world")]))

(<?~) :: Setter s t a (Maybe b)    -> b -> s -> (b, t)
(<?~) :: Iso s t a (Maybe b)       -> b -> s -> (b, t)
(<?~) :: Lens s t a (Maybe b)      -> b -> s -> (b, t)
(<?~) :: Traversal s t a (Maybe b) -> b -> s -> (b, t)

(<.~) :: ASetter s t a b -> b -> s -> (b, t) infixr 4 #

Set with pass-through.

This is mostly present for consistency, but may be useful for chaining assignments.

If you do not need a copy of the intermediate result, then using l .~ t directly is a good idea.

>>> (a,b) & _1 <.~ c
(c,(c,b))

>>> ("good","morning","vietnam") & _3 <.~ "world"
("world",("good","morning","world"))

>>> (42,Map.fromList [("goodnight","gracie")]) & _2.at "hello" <.~ Just "world"
(Just "world",(42,fromList [("goodnight","gracie"),("hello","world")]))

(<.~) :: Setter s t a b    -> b -> s -> (b, t)
(<.~) :: Iso s t a b       -> b -> s -> (b, t)
(<.~) :: Lens s t a b      -> b -> s -> (b, t)
(<.~) :: Traversal s t a b -> b -> s -> (b, t)

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

Set the target of a Lens, Traversal or Setter to Just a value.

l ?~ t ≡ set l (Just t)

>>> Nothing & id ?~ a
Just a

>>> Map.empty & at 3 ?~ x
fromList [(3,x)]

?~ can be used type-changily:

>>> ('a', ('b', 'c')) & _2.both ?~ 'x'
('a',(Just 'x',Just 'x'))

(?~) :: Setter s t a (Maybe b)    -> b -> s -> t
(?~) :: Iso s t a (Maybe b)       -> b -> s -> t
(?~) :: Lens s t a (Maybe b)      -> b -> s -> t
(?~) :: Traversal s t a (Maybe b) -> b -> s -> t

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

Replace the target of a Lens or all of the targets of a Setter or Traversal with a constant value.

This is an infix version of set, provided for consistency with (.=).

f <$ a ≡ mapped .~ f $ a

>>> (a,b,c,d) & _4 .~ e
(a,b,c,e)

>>> (42,"world") & _1 .~ "hello"
("hello","world")

>>> (a,b) & both .~ c
(c,c)

(.~) :: Setter s t a b    -> b -> s -> t
(.~) :: Iso s t a b       -> b -> s -> t
(.~) :: Lens s t a b      -> b -> s -> t
(.~) :: Traversal s t a b -> b -> s -> t

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

Modifies the target of a Lens or all of the targets of a Setter or Traversal with a user supplied function.

This is an infix version of over.

fmap f ≡ mapped %~ f
fmapDefault f ≡ traverse %~ f

>>> (a,b,c) & _3 %~ f
(a,b,f c)

>>> (a,b) & both %~ f
(f a,f b)

>>> _2 %~ length $ (1,"hello")
(1,5)

>>> traverse %~ f $ [a,b,c]
[f a,f b,f c]

>>> traverse %~ even $ [1,2,3]
[False,True,False]

>>> traverse.traverse %~ length $ [["hello","world"],["!!!"]]
[[5,5],[3]]

(%~) :: Setter s t a b    -> (a -> b) -> s -> t
(%~) :: Iso s t a b       -> (a -> b) -> s -> t
(%~) :: Lens s t a b      -> (a -> b) -> s -> t
(%~) :: Traversal s t a b -> (a -> b) -> s -> t

set' :: ASetter' s a -> a -> s -> s #

Replace the target of a Lens or all of the targets of a Setter' or Traversal with a constant value, without changing its type.

This is a type restricted version of set, which retains the type of the original.

>>> set' mapped x [a,b,c,d]
[x,x,x,x]

>>> set' _2 "hello" (1,"world")
(1,"hello")

>>> set' mapped 0 [1,2,3,4]
[0,0,0,0]

Note: Attempting to adjust set' a Fold or Getter will fail at compile time with an relatively nice error message.

set' :: Setter' s a    -> a -> s -> s
set' :: Iso' s a       -> a -> s -> s
set' :: Lens' s a      -> a -> s -> s
set' :: Traversal' s a -> a -> s -> s

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

Replace the target of a Lens or all of the targets of a Setter or Traversal with a constant value.

(<$) ≡ set mapped

>>> set _2 "hello" (1,())
(1,"hello")

>>> set mapped () [1,2,3,4]
[(),(),(),()]

Note: Attempting to set a Fold or Getter will fail at compile time with an relatively nice error message.

set :: Setter s t a b    -> b -> s -> t
set :: Iso s t a b       -> b -> s -> t
set :: Lens s t a b      -> b -> s -> t
set :: Traversal s t a b -> b -> s -> t

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

Modify the target of a Lens or all the targets of a Setter or Traversal with a function.

fmap ≡ over mapped
fmapDefault ≡ over traverse
sets . over ≡ id
over . sets ≡ id

Given any valid Setter l, you can also rely on the law:

over l f . over l g = over l (f . g)

e.g.

>>> over mapped f (over mapped g [a,b,c]) == over mapped (f . g) [a,b,c]
True

Another way to view over is to say that it transforms a Setter into a "semantic editor combinator".

>>> over mapped f (Just a)
Just (f a)

>>> over mapped (*10) [1,2,3]
[10,20,30]

>>> over _1 f (a,b)
(f a,b)

>>> over _1 show (10,20)
("10",20)

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

cloneIndexedSetter :: AnIndexedSetter i s t a b -> IndexedSetter i s t a b #

Clone an IndexedSetter.

cloneIndexPreservingSetter :: ASetter s t a b -> IndexPreservingSetter s t a b #

Build an IndexPreservingSetter from any Setter.

cloneSetter :: ASetter s t a b -> Setter s t a b #

Restore ASetter to a full Setter.

sets :: (Profunctor p, Profunctor q, Settable f) => (p a b -> q s t) -> Optical p q f s t a b #

Build a Setter, IndexedSetter or IndexPreservingSetter depending on your choice of Profunctor.

sets :: ((a -> b) -> s -> t) -> Setter s t a b

setting :: ((a -> b) -> s -> t) -> IndexPreservingSetter s t a b #

Build an index-preserving Setter from a map-like function.

Your supplied function f is required to satisfy:

f id ≡ id
f g . f h ≡ f (g . h)

Equational reasoning:

setting . over ≡ id
over . setting ≡ id

Another way to view sets is that it takes a "semantic editor combinator" and transforms it into a Setter.

setting :: ((a -> b) -> s -> t) -> Setter s t a b

argument :: Profunctor p => Setter (p b r) (p a r) a b #

This Setter can be used to map over the input of a Profunctor.

The most common Profunctor to use this with is (->).

>>> (argument %~ f) g x
g (f x)

>>> (argument %~ show) length [1,2,3]
7

>>> (argument %~ f) h x y
h (f x) y

Map over the argument of the result of a function -- i.e., its second argument:

>>> (mapped.argument %~ f) h x y
h x (f y)

argument :: Setter (b -> r) (a -> r) a b

contramapped :: Contravariant f => Setter (f b) (f a) a b #

This Setter can be used to map over all of the inputs to a Contravariant.

contramap ≡ over contramapped

>>> getPredicate (over contramapped (*2) (Predicate even)) 5
True

>>> getOp (over contramapped (*5) (Op show)) 100
"500"

>>> Prelude.map ($ 1) $ over (mapped . _Unwrapping' Op . contramapped) (*12) [(*2),(+1),(^3)]
[24,13,1728]

lifted :: Monad m => Setter (m a) (m b) a b #

This setter can be used to modify all of the values in a Monad.

You sometimes have to use this rather than mapped -- due to temporary insanity Functor was not a superclass of Monad until GHC 7.10.

liftM ≡ over lifted

>>> over lifted f [a,b,c]
[f a,f b,f c]

>>> set lifted b (Just a)
Just b

If you want an IndexPreservingSetter use setting liftM.

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

This Setter can be used to map over all of the values in a Functor.

fmap ≡ over mapped
fmapDefault ≡ over traverse
(<$) ≡ set mapped

>>> over mapped f [a,b,c]
[f a,f b,f c]

>>> over mapped (+1) [1,2,3]
[2,3,4]

>>> set mapped x [a,b,c]
[x,x,x]

>>> [[a,b],[c]] & mapped.mapped +~ x
[[a + x,b + x],[c + x]]

>>> over (mapped._2) length [("hello","world"),("leaders","!!!")]
[("hello",5),("leaders",3)]

mapped :: Functor f => Setter (f a) (f b) a b

If you want an IndexPreservingSetter use setting fmap.

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

Running a Setter instantiates it to a concrete type.

When consuming a setter directly to perform a mapping, you can use this type, but most user code will not need to use this type.

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

This is a useful alias for use when consuming a Setter'.

Most user code will never have to use this type.

type ASetter' = Simple ASetter

type AnIndexedSetter i s t a b = Indexed i a (Identity b) -> s -> Identity t #

Running an IndexedSetter instantiates it to a concrete type.

When consuming a setter directly to perform a mapping, you can use this type, but most user code will not need to use this type.

type AnIndexedSetter' i s a = AnIndexedSetter i s s a a #

type AnIndexedSetter' i = Simple (AnIndexedSetter i)

type Setting (p :: Type -> Type -> Type) s t a b = p a (Identity b) -> s -> Identity t #

This is a convenient alias when defining highly polymorphic code that takes both ASetter and AnIndexedSetter as appropriate. If a function takes this it is expecting one of those two things based on context.

type Setting' (p :: Type -> Type -> Type) s a = Setting p s s a a #

This is a convenient alias when defining highly polymorphic code that takes both ASetter' and AnIndexedSetter' as appropriate. If a function takes this it is expecting one of those two things based on context.

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

A Lens is actually a lens family as described in http://comonad.com/reader/2012/mirrored-lenses/.

With great power comes great responsibility and a Lens is subject to the three common sense Lens laws:

1) You get back what you put in:

view l (set l v s)  ≡ v

2) Putting back what you got doesn't change anything:

set l (view l s) s  ≡ s

3) Setting twice is the same as setting once:

set l v' (set l v s) ≡ set l v' s

These laws are strong enough that the 4 type parameters of a Lens cannot vary fully independently. For more on how they interact, read the "Why is it a Lens Family?" section of http://comonad.com/reader/2012/mirrored-lenses/.

There are some emergent properties of these laws:

1) set l s must be injective for every s This is a consequence of law #1

2) set l must be surjective, because of law #2, which indicates that it is possible to obtain any v from some s such that set s v = s

3) Given just the first two laws you can prove a weaker form of law #3 where the values v that you are setting match:

set l v (set l v s) ≡ set l v s

Every Lens can be used directly as a Setter or Traversal.

You can also use a Lens for Getting as if it were a Fold or Getter.

Since every Lens is a valid Traversal, the Traversal laws are required of any Lens you create:

l pure ≡ pure
fmap (l f) . l g ≡ getCompose . l (Compose . fmap f . g)

type Lens s t a b = forall f. Functor f => LensLike f s t a b

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

type Lens' = Simple Lens

type IndexedLens i s t a b = forall (f :: Type -> Type) (p :: Type -> Type -> Type). (Indexable i p, Functor f) => p a (f b) -> s -> f t #

Every IndexedLens is a valid Lens and a valid IndexedTraversal.

type IndexedLens' i s a = IndexedLens i s s a a #

type IndexedLens' i = Simple (IndexedLens i)

type IndexPreservingLens s t a b = forall (p :: Type -> Type -> Type) (f :: Type -> Type). (Conjoined p, Functor f) => p a (f b) -> p s (f t) #

An IndexPreservingLens leaves any index it is composed with alone.

type IndexPreservingLens' s a = IndexPreservingLens s s a a #

type IndexPreservingLens' = Simple IndexPreservingLens

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

A Traversal can be used directly as a Setter or a Fold (but not as a Lens) and provides the ability to both read and update multiple fields, subject to some relatively weak Traversal laws.

These have also been known as multilenses, but they have the signature and spirit of

traverse :: Traversable f => Traversal (f a) (f b) a b

and the more evocative name suggests their application.

Most of the time the Traversal you will want to use is just traverse, but you can also pass any Lens or Iso as a Traversal, and composition of a Traversal (or Lens or Iso) with a Traversal (or Lens or Iso) using (.) forms a valid Traversal.

The laws for a Traversal t follow from the laws for Traversable as stated in "The Essence of the Iterator Pattern".

t pure ≡ pure
fmap (t f) . t g ≡ getCompose . t (Compose . fmap f . g)

One consequence of this requirement is that a Traversal needs to leave the same number of elements as a candidate for subsequent Traversal that it started with. Another testament to the strength of these laws is that the caveat expressed in section 5.5 of the "Essence of the Iterator Pattern" about exotic Traversable instances that traverse the same entry multiple times was actually already ruled out by the second law in that same paper!

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

type Traversal' = Simple Traversal

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

type Traversal1' s a = Traversal1 s s a a #

type IndexedTraversal i s t a b = forall (p :: Type -> Type -> Type) (f :: Type -> Type). (Indexable i p, Applicative f) => p a (f b) -> s -> f t #

Every IndexedTraversal is a valid Traversal or IndexedFold.

The Indexed constraint is used to allow an IndexedTraversal to be used directly as a Traversal.

The Traversal laws are still required to hold.

In addition, the index i should satisfy the requirement that it stays unchanged even when modifying the value a, otherwise traversals like indices break the Traversal laws.

type IndexedTraversal' i s a = IndexedTraversal i s s a a #

type IndexedTraversal' i = Simple (IndexedTraversal i)

type IndexedTraversal1 i s t a b = forall (p :: Type -> Type -> Type) (f :: Type -> Type). (Indexable i p, Apply f) => p a (f b) -> s -> f t #

type IndexedTraversal1' i s a = IndexedTraversal1 i s s a a #

type IndexPreservingTraversal s t a b = forall (p :: Type -> Type -> Type) (f :: Type -> Type). (Conjoined p, Applicative f) => p a (f b) -> p s (f t) #

An IndexPreservingLens leaves any index it is composed with alone.

type IndexPreservingTraversal' s a = IndexPreservingTraversal s s a a #

type IndexPreservingTraversal' = Simple IndexPreservingTraversal

type IndexPreservingTraversal1 s t a b = forall (p :: Type -> Type -> Type) (f :: Type -> Type). (Conjoined p, Apply f) => p a (f b) -> p s (f t) #

type IndexPreservingTraversal1' s a = IndexPreservingTraversal1 s s a a #

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

The only LensLike law that can apply to a Setter l is that

set l y (set l x a) ≡ set l y a

You can't view a Setter in general, so the other two laws are irrelevant.

However, two Functor laws apply to a Setter:

over l id ≡ id
over l f . over l g ≡ over l (f . g)

These can be stated more directly:

l pure ≡ pure
l f . untainted . l g ≡ l (f . untainted . g)

You can compose a Setter with a Lens or a Traversal using (.) from the Prelude and the result is always only a Setter and nothing more.

>>> over traverse f [a,b,c,d]
[f a,f b,f c,f d]

>>> over _1 f (a,b)
(f a,b)

>>> over (traverse._1) f [(a,b),(c,d)]
[(f a,b),(f c,d)]

>>> over both f (a,b)
(f a,f b)

>>> over (traverse.both) f [(a,b),(c,d)]
[(f a,f b),(f c,f d)]

type Setter' s a = Setter s s a a #

A Setter' is just a Setter that doesn't change the types.

These are particularly common when talking about monomorphic containers. e.g.

sets Data.Text.map :: Setter' Text Char

type Setter' = Simple Setter

type IndexedSetter i s t a b = forall (f :: Type -> Type) (p :: Type -> Type -> Type). (Indexable i p, Settable f) => p a (f b) -> s -> f t #

Every IndexedSetter is a valid Setter.

The Setter laws are still required to hold.

type IndexedSetter' i s a = IndexedSetter i s s a a #

type IndexedSetter' i = Simple (IndexedSetter i)

type IndexPreservingSetter s t a b = forall (p :: Type -> Type -> Type) (f :: Type -> Type). (Conjoined p, Settable f) => p a (f b) -> p s (f t) #

An IndexPreservingSetter can be composed with a IndexedSetter, IndexedTraversal or IndexedLens and leaves the index intact, yielding an IndexedSetter.

type IndexPreservingSetter' s a = IndexPreservingSetter s s a a #

type IndexedPreservingSetter' i = Simple IndexedPreservingSetter

type Iso s t a b = forall (p :: Type -> Type -> Type) (f :: Type -> Type). (Profunctor p, Functor f) => p a (f b) -> p s (f t) #

Isomorphism families can be composed with another Lens using (.) and id.

Since every Iso is both a valid Lens and a valid Prism, the laws for those types imply the following laws for an Iso f:

f . from f ≡ id
from f . f ≡ id

Note: Composition with an Iso is index- and measure- preserving.

type Iso' s a = Iso s s a a #

type Iso' = Simple Iso

type Review t b = forall (p :: Type -> Type -> Type) (f :: Type -> Type). (Choice p, Bifunctor p, Settable f) => Optic' p f t b #

This is a limited form of a Prism that can only be used for re operations.

Like with a Getter, there are no laws to state for a Review.

You can generate a Review by using unto. You can also use any Prism or Iso directly as a Review.

type AReview t b = Optic' (Tagged :: Type -> Type -> Type) Identity t b #

If you see this in a signature for a function, the function is expecting a Review (in practice, this usually means a Prism).

type Prism s t a b = forall (p :: Type -> Type -> Type) (f :: Type -> Type). (Choice p, Applicative f) => p a (f b) -> p s (f t) #

A Prism l is a Traversal that can also be turned around with re to obtain a Getter in the opposite direction.

There are three laws that a Prism should satisfy:

First, if I re or review a value with a Prism and then preview or use (^?), I will get it back:

preview l (review l b) ≡ Just b

Second, if you can extract a value a using a Prism l from a value s, then the value s is completely described by l and a:

preview l s ≡ Just a ⟹ review l a ≡ s

Third, if you get non-match t, you can convert it result back to s:

matching l s ≡ Left t ⟹ matching l t ≡ Left s

The first two laws imply that the Traversal laws hold for every Prism and that we traverse at most 1 element:

lengthOf l x <= 1

It may help to think of this as an Iso that can be partial in one direction.

Every Prism is a valid Traversal.

Every Iso is a valid Prism.

For example, you might have a Prism' Integer Natural allows you to always go from a Natural to an Integer, and provide you with tools to check if an Integer is a Natural and/or to edit one if it is.

nat :: Prism' Integer Natural
nat = prism toInteger $ \ i ->
   if i < 0
   then Left i
   else Right (fromInteger i)

Now we can ask if an Integer is a Natural.

>>> 5^?nat
Just 5

>>> (-5)^?nat
Nothing

We can update the ones that are:

>>> (-3,4) & both.nat *~ 2
(-3,8)

And we can then convert from a Natural to an Integer.

>>> 5 ^. re nat -- :: Natural
5

Similarly we can use a Prism to traverse the Left half of an Either:

>>> Left "hello" & _Left %~ length
Left 5

or to construct an Either:

>>> 5^.re _Left
Left 5

such that if you query it with the Prism, you will get your original input back.

>>> 5^.re _Left ^? _Left
Just 5

Another interesting way to think of a Prism is as the categorical dual of a Lens -- a co-Lens, so to speak. This is what permits the construction of outside.

Note: Composition with a Prism is index-preserving.

type Prism' s a = Prism s s a a #

A Simple Prism.

type Equality (s :: k1) (t :: k2) (a :: k1) (b :: k2) = forall k3 (p :: k1 -> k3 -> Type) (f :: k2 -> k3). p a (f b) -> p s (f t) #

A witness that (a ~ s, b ~ t).

Note: Composition with an Equality is index-preserving.

type Equality' (s :: k2) (a :: k2) = Equality s s a a #

A Simple Equality.

type As (a :: k2) = Equality' a a #

Composable asTypeOf. Useful for constraining excess polymorphism, foo . (id :: As Int) . bar.

type Getter s a = forall (f :: Type -> Type). (Contravariant f, Functor f) => (a -> f a) -> s -> f s #

A Getter describes how to retrieve a single value in a way that can be composed with other LensLike constructions.

Unlike a Lens a Getter is read-only. Since a Getter cannot be used to write back there are no Lens laws that can be applied to it. In fact, it is isomorphic to an arbitrary function from (s -> a).

Moreover, a Getter can be used directly as a Fold, since it just ignores the Applicative.

type IndexedGetter i s a = forall (p :: Type -> Type -> Type) (f :: Type -> Type). (Indexable i p, Contravariant f, Functor f) => p a (f a) -> s -> f s #

Every IndexedGetter is a valid IndexedFold and can be used for Getting like a Getter.

type IndexPreservingGetter s a = forall (p :: Type -> Type -> Type) (f :: Type -> Type). (Conjoined p, Contravariant f, Functor f) => p a (f a) -> p s (f s) #

An IndexPreservingGetter can be used as a Getter, but when composed with an IndexedTraversal, IndexedFold, or IndexedLens yields an IndexedFold, IndexedFold or IndexedGetter respectively.

type Fold s a = forall (f :: Type -> Type). (Contravariant f, Applicative f) => (a -> f a) -> s -> f s #

A Fold describes how to retrieve multiple values in a way that can be composed with other LensLike constructions.

A Fold s a provides a structure with operations very similar to those of the Foldable typeclass, see foldMapOf and the other Fold combinators.

By convention, if there exists a foo method that expects a Foldable (f a), then there should be a fooOf method that takes a Fold s a and a value of type s.

A Getter is a legal Fold that just ignores the supplied Monoid.

Unlike a Traversal a Fold is read-only. Since a Fold cannot be used to write back there are no Lens laws that apply.

type IndexedFold i s a = forall (p :: Type -> Type -> Type) (f :: Type -> Type). (Indexable i p, Contravariant f, Applicative f) => p a (f a) -> s -> f s #

Every IndexedFold is a valid Fold and can be used for Getting.

type IndexPreservingFold s a = forall (p :: Type -> Type -> Type) (f :: Type -> Type). (Conjoined p, Contravariant f, Applicative f) => p a (f a) -> p s (f s) #

An IndexPreservingFold can be used as a Fold, but when composed with an IndexedTraversal, IndexedFold, or IndexedLens yields an IndexedFold respectively.

type Fold1 s a = forall (f :: Type -> Type). (Contravariant f, Apply f) => (a -> f a) -> s -> f s #

A relevant Fold (aka Fold1) has one or more targets.

type IndexedFold1 i s a = forall (p :: Type -> Type -> Type) (f :: Type -> Type). (Indexable i p, Contravariant f, Apply f) => p a (f a) -> s -> f s #

type IndexPreservingFold1 s a = forall (p :: Type -> Type -> Type) (f :: Type -> Type). (Conjoined p, Contravariant f, Apply f) => p a (f a) -> p s (f s) #

type Simple (f :: k -> k -> k1 -> k1 -> k2) (s :: k) (a :: k1) = f s s a a #

A Simple Lens, Simple Traversal, ... can be used instead of a Lens,Traversal, ... whenever the type variables don't change upon setting a value.

_imagPart :: Simple Lens (Complex a) a
traversed :: Simple (IndexedTraversal Int) [a] a

Note: To use this alias in your own code with LensLike f or Setter, you may have to turn on LiberalTypeSynonyms.

This is commonly abbreviated as a "prime" marker, e.g. Lens' = Simple Lens.

type Optic (p :: k1 -> k -> Type) (f :: k2 -> k) (s :: k1) (t :: k2) (a :: k1) (b :: k2) = p a (f b) -> p s (f t) #

A valid Optic l should satisfy the laws:

l pure ≡ pure
l (Procompose f g) = Procompose (l f) (l g)

This gives rise to the laws for Equality, Iso, Prism, Lens, Traversal, Traversal1, Setter, Fold, Fold1, and Getter as well along with their index-preserving variants.

type LensLike f s t a b = Optic (->) f s t a b

type Optic' (p :: k1 -> k -> Type) (f :: k1 -> k) (s :: k1) (a :: k1) = Optic p f s s a a #

type Optic' p f s a = Simple (Optic p f) s a

type Optical (p :: k2 -> k -> Type) (q :: k1 -> k -> Type) (f :: k3 -> k) (s :: k1) (t :: k3) (a :: k2) (b :: k3) = p a (f b) -> q s (f t) #

type LensLike f s t a b = Optical (->) (->) f s t a b

type Over p f s t a b = Optical p (->) f s t a b

type Optic p f s t a b = Optical p p f s t a b

type Optical' (p :: k1 -> k -> Type) (q :: k1 -> k -> Type) (f :: k1 -> k) (s :: k1) (a :: k1) = Optical p q f s s a a #

type Optical' p q f s a = Simple (Optical p q f) s a

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

Many combinators that accept a Lens can also accept a Traversal in limited situations.

They do so by specializing the type of Functor that they require of the caller.

If a function accepts a LensLike f s t a b for some Functor f, then they may be passed a Lens.

Further, if f is an Applicative, they may also be passed a Traversal.

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

type LensLike' f = Simple (LensLike f)

type IndexedLensLike i (f :: k -> Type) s (t :: k) a (b :: k) = forall (p :: Type -> Type -> Type). Indexable i p => p a (f b) -> s -> f t #

Convenient alias for constructing indexed lenses and their ilk.

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

Convenient alias for constructing simple indexed lenses and their ilk.

type Over (p :: k -> Type -> Type) (f :: k1 -> Type) s (t :: k1) (a :: k) (b :: k1) = p a (f b) -> s -> f t #

This is a convenient alias for use when you need to consume either indexed or non-indexed lens-likes based on context.

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

This is a convenient alias for use when you need to consume either indexed or non-indexed lens-likes based on context.

type Over' p f = Simple (Over p f)

class (Applicative f, Distributive f, Traversable f) => Settable (f :: Type -> Type) #

Anything Settable must be isomorphic to the Identity Functor.

Minimal complete definition

untainted

Instances

Settable Identity	So you can pass our `Setter` into combinators from other lens libraries.
Instance details Defined in Control.Lens.Internal.Setter Methods untainted :: Identity a -> a # untaintedDot :: Profunctor p => p a (Identity b) -> p a b # taintedDot :: Profunctor p => p a b -> p a (Identity b) #
Settable f => Settable (Backwards f)	`backwards`
Instance details Defined in Control.Lens.Internal.Setter Methods untainted :: Backwards f a -> a # untaintedDot :: Profunctor p => p a (Backwards f b) -> p a b # taintedDot :: Profunctor p => p a b -> p a (Backwards f b) #
(Settable f, Settable g) => Settable (Compose f g)
Instance details Defined in Control.Lens.Internal.Setter Methods untainted :: Compose f g a -> a # untaintedDot :: Profunctor p => p a (Compose f g b) -> p a b # taintedDot :: Profunctor p => p a b -> p a (Compose f g b) #

retagged :: (Profunctor p, Bifunctor p) => p a b -> p s b #

This is a profunctor used internally to implement Review

It plays a role similar to that of Accessor or Const do for Control.Lens.Getter

class (Profunctor p, Bifunctor p) => Reviewable (p :: Type -> Type -> Type) #

This class is provided mostly for backwards compatibility with lens 3.8, but it can also shorten type signatures.

Instances

(Profunctor p, Bifunctor p) => Reviewable p
Instance details Defined in Control.Lens.Internal.Review

data Magma i t b a #

This provides a way to peek at the internal structure of a Traversal or IndexedTraversal

Instances

FunctorWithIndex i (Magma i t b)
Instance details Defined in Control.Lens.Indexed Methods imap :: (i -> a -> b0) -> Magma i t b a -> Magma i t b b0 # imapped :: IndexedSetter i (Magma i t b a) (Magma i t b b0) a b0 #
FoldableWithIndex i (Magma i t b)
Instance details Defined in Control.Lens.Indexed Methods ifoldMap :: Monoid m => (i -> a -> m) -> Magma i t b a -> m # ifolded :: IndexedFold i (Magma i t b a) a # ifoldr :: (i -> a -> b0 -> b0) -> b0 -> Magma i t b a -> b0 # ifoldl :: (i -> b0 -> a -> b0) -> b0 -> Magma i t b a -> b0 # ifoldr' :: (i -> a -> b0 -> b0) -> b0 -> Magma i t b a -> b0 # ifoldl' :: (i -> b0 -> a -> b0) -> b0 -> Magma i t b a -> b0 #
TraversableWithIndex i (Magma i t b)
Instance details Defined in Control.Lens.Indexed Methods itraverse :: Applicative f => (i -> a -> f b0) -> Magma i t b a -> f (Magma i t b b0) # itraversed :: IndexedTraversal i (Magma i t b a) (Magma i t b b0) a b0 #
Functor (Magma i t b)
Instance details Defined in Control.Lens.Internal.Magma Methods fmap :: (a -> b0) -> Magma i t b a -> Magma i t b b0 # (<$) :: a -> Magma i t b b0 -> Magma i t b a #
Foldable (Magma i t b)
Instance details Defined in Control.Lens.Internal.Magma Methods fold :: Monoid m => Magma i t b m -> m # foldMap :: Monoid m => (a -> m) -> Magma i t b a -> m # foldr :: (a -> b0 -> b0) -> b0 -> Magma i t b a -> b0 # foldr' :: (a -> b0 -> b0) -> b0 -> Magma i t b a -> b0 # foldl :: (b0 -> a -> b0) -> b0 -> Magma i t b a -> b0 # foldl' :: (b0 -> a -> b0) -> b0 -> Magma i t b a -> b0 # foldr1 :: (a -> a -> a) -> Magma i t b a -> a # foldl1 :: (a -> a -> a) -> Magma i t b a -> a # toList :: Magma i t b a -> [a] # null :: Magma i t b a -> Bool # length :: Magma i t b a -> Int # elem :: Eq a => a -> Magma i t b a -> Bool # maximum :: Ord a => Magma i t b a -> a # minimum :: Ord a => Magma i t b a -> a # sum :: Num a => Magma i t b a -> a # product :: Num a => Magma i t b a -> a #
Traversable (Magma i t b)
Instance details Defined in Control.Lens.Internal.Magma Methods traverse :: Applicative f => (a -> f b0) -> Magma i t b a -> f (Magma i t b b0) # sequenceA :: Applicative f => Magma i t b (f a) -> f (Magma i t b a) # mapM :: Monad m => (a -> m b0) -> Magma i t b a -> m (Magma i t b b0) # sequence :: Monad m => Magma i t b (m a) -> m (Magma i t b a) #
(Show i, Show a) => Show (Magma i t b a)
Instance details Defined in Control.Lens.Internal.Magma Methods showsPrec :: Int -> Magma i t b a -> ShowS # show :: Magma i t b a -> String # showList :: [Magma i t b a] -> ShowS #

data Level i a #

This data type represents a path-compressed copy of one level of a source data structure. We can safely use path-compression because we know the depth of the tree.

Path compression is performed by viewing a Level as a PATRICIA trie of the paths into the structure to leaves at a given depth, similar in many ways to a IntMap, but unlike a regular PATRICIA trie we do not need to store the mask bits merely the depth of the fork.

One invariant of this structure is that underneath a Two node you will not find any Zero nodes, so Zero can only occur at the root.

Instances

FunctorWithIndex i (Level i)
Instance details Defined in Control.Lens.Indexed Methods imap :: (i -> a -> b) -> Level i a -> Level i b # imapped :: IndexedSetter i (Level i a) (Level i b) a b #
FoldableWithIndex i (Level i)
Instance details Defined in Control.Lens.Indexed Methods ifoldMap :: Monoid m => (i -> a -> m) -> Level i a -> m # ifolded :: IndexedFold i (Level i a) a # ifoldr :: (i -> a -> b -> b) -> b -> Level i a -> b # ifoldl :: (i -> b -> a -> b) -> b -> Level i a -> b # ifoldr' :: (i -> a -> b -> b) -> b -> Level i a -> b # ifoldl' :: (i -> b -> a -> b) -> b -> Level i a -> b #
TraversableWithIndex i (Level i)
Instance details Defined in Control.Lens.Indexed Methods itraverse :: Applicative f => (i -> a -> f b) -> Level i a -> f (Level i b) # itraversed :: IndexedTraversal i (Level i a) (Level i b) a b #
Functor (Level i)
Instance details Defined in Control.Lens.Internal.Level Methods fmap :: (a -> b) -> Level i a -> Level i b # (<$) :: a -> Level i b -> Level i a #
Foldable (Level i)
Instance details Defined in Control.Lens.Internal.Level Methods fold :: Monoid m => Level i m -> m # foldMap :: Monoid m => (a -> m) -> Level i a -> m # foldr :: (a -> b -> b) -> b -> Level i a -> b # foldr' :: (a -> b -> b) -> b -> Level i a -> b # foldl :: (b -> a -> b) -> b -> Level i a -> b # foldl' :: (b -> a -> b) -> b -> Level i a -> b # foldr1 :: (a -> a -> a) -> Level i a -> a # foldl1 :: (a -> a -> a) -> Level i a -> a # toList :: Level i a -> [a] # null :: Level i a -> Bool # length :: Level i a -> Int # elem :: Eq a => a -> Level i a -> Bool # maximum :: Ord a => Level i a -> a # minimum :: Ord a => Level i a -> a # sum :: Num a => Level i a -> a # product :: Num a => Level i a -> a #
Traversable (Level i)
Instance details Defined in Control.Lens.Internal.Level Methods traverse :: Applicative f => (a -> f b) -> Level i a -> f (Level i b) # sequenceA :: Applicative f => Level i (f a) -> f (Level i a) # mapM :: Monad m => (a -> m b) -> Level i a -> m (Level i b) # sequence :: Monad m => Level i (m a) -> m (Level i a) #
(Eq i, Eq a) => Eq (Level i a)
Instance details Defined in Control.Lens.Internal.Level Methods (==) :: Level i a -> Level i a -> Bool # (/=) :: Level i a -> Level i a -> Bool #
(Ord i, Ord a) => Ord (Level i a)
Instance details Defined in Control.Lens.Internal.Level Methods compare :: Level i a -> Level i a -> Ordering # (<) :: Level i a -> Level i a -> Bool # (<=) :: Level i a -> Level i a -> Bool # (>) :: Level i a -> Level i a -> Bool # (>=) :: Level i a -> Level i a -> Bool # max :: Level i a -> Level i a -> Level i a # min :: Level i a -> Level i a -> Level i a #
(Read i, Read a) => Read (Level i a)
Instance details Defined in Control.Lens.Internal.Level Methods readsPrec :: Int -> ReadS (Level i a) # readList :: ReadS [Level i a] # readPrec :: ReadPrec (Level i a) # readListPrec :: ReadPrec [Level i a] #
(Show i, Show a) => Show (Level i a)
Instance details Defined in Control.Lens.Internal.Level Methods showsPrec :: Int -> Level i a -> ShowS # show :: Level i a -> String # showList :: [Level i a] -> ShowS #

class Reversing t where #

This class provides a generalized notion of list reversal extended to other containers.

Methods

reversing :: t -> t #

Instances

Reversing ByteString
Instance details Defined in Control.Lens.Internal.Iso Methods reversing :: ByteString -> ByteString #
Reversing ByteString
Instance details Defined in Control.Lens.Internal.Iso Methods reversing :: ByteString -> ByteString #
Reversing Text
Instance details Defined in Control.Lens.Internal.Iso Methods reversing :: Text -> Text #
Reversing Text
Instance details Defined in Control.Lens.Internal.Iso Methods reversing :: Text -> Text #
Reversing [a]
Instance details Defined in Control.Lens.Internal.Iso Methods reversing :: [a] -> [a] #
Storable a => Reversing (Vector a)
Instance details Defined in Control.Lens.Internal.Iso Methods reversing :: Vector a -> Vector a #
Reversing (NonEmpty a)
Instance details Defined in Control.Lens.Internal.Iso Methods reversing :: NonEmpty a -> NonEmpty a #
Reversing (Seq a)
Instance details Defined in Control.Lens.Internal.Iso Methods reversing :: Seq a -> Seq a #
Prim a => Reversing (Vector a)
Instance details Defined in Control.Lens.Internal.Iso Methods reversing :: Vector a -> Vector a #
Unbox a => Reversing (Vector a)
Instance details Defined in Control.Lens.Internal.Iso Methods reversing :: Vector a -> Vector a #
Reversing (Vector a)
Instance details Defined in Control.Lens.Internal.Iso Methods reversing :: Vector a -> Vector a #

newtype Bazaar (p :: Type -> Type -> Type) a b t #

This is used to characterize a Traversal.

a.k.a. indexed Cartesian store comonad, indexed Kleene store comonad, or an indexed FunList.

http://twanvl.nl/blog/haskell/non-regular1

A Bazaar is like a Traversal that has already been applied to some structure.

Where a Context a b t holds an a and a function from b to t, a Bazaar a b t holds N as and a function from N bs to t, (where N might be infinite).

Mnemonically, a Bazaar holds many stores and you can easily add more.

This is a final encoding of Bazaar.

Constructors

Bazaar
Fields runBazaar :: forall (f :: Type -> Type). Applicative f => p a (f b) -> f t

Instances

Profunctor p => Bizarre p (Bazaar p)
Instance details Defined in Control.Lens.Internal.Bazaar Methods bazaar :: Applicative f => p a (f b) -> Bazaar p a b t -> f t #
Corepresentable p => Sellable p (Bazaar p)
Instance details Defined in Control.Lens.Internal.Bazaar Methods sell :: p a (Bazaar p a b b) #
IndexedFunctor (Bazaar p)
Instance details Defined in Control.Lens.Internal.Bazaar Methods ifmap :: (s -> t) -> Bazaar p a b s -> Bazaar p a b t #
Conjoined p => IndexedComonad (Bazaar p)
Instance details Defined in Control.Lens.Internal.Bazaar Methods iextract :: Bazaar p a a t -> t # iduplicate :: Bazaar p a c t -> Bazaar p a b (Bazaar p b c t) # iextend :: (Bazaar p b c t -> r) -> Bazaar p a c t -> Bazaar p a b r #
Functor (Bazaar p a b)
Instance details Defined in Control.Lens.Internal.Bazaar Methods fmap :: (a0 -> b0) -> Bazaar p a b a0 -> Bazaar p a b b0 # (<$) :: a0 -> Bazaar p a b b0 -> Bazaar p a b a0 #
Applicative (Bazaar p a b)
Instance details Defined in Control.Lens.Internal.Bazaar Methods pure :: a0 -> Bazaar p a b a0 # (<>) :: Bazaar p a b (a0 -> b0) -> Bazaar p a b a0 -> Bazaar p a b b0 # liftA2 :: (a0 -> b0 -> c) -> Bazaar p a b a0 -> Bazaar p a b b0 -> Bazaar p a b c # (>) :: Bazaar p a b a0 -> Bazaar p a b b0 -> Bazaar p a b b0 # (<*) :: Bazaar p a b a0 -> Bazaar p a b b0 -> Bazaar p a b a0 #
(a ~ b, Conjoined p) => Comonad (Bazaar p a b)
Instance details Defined in Control.Lens.Internal.Bazaar Methods extract :: Bazaar p a b a0 -> a0 # duplicate :: Bazaar p a b a0 -> Bazaar p a b (Bazaar p a b a0) # extend :: (Bazaar p a b a0 -> b0) -> Bazaar p a b a0 -> Bazaar p a b b0 #
(a ~ b, Conjoined p) => ComonadApply (Bazaar p a b)
Instance details Defined in Control.Lens.Internal.Bazaar Methods (<@>) :: Bazaar p a b (a0 -> b0) -> Bazaar p a b a0 -> Bazaar p a b b0 # (@>) :: Bazaar p a b a0 -> Bazaar p a b b0 -> Bazaar p a b b0 # (<@) :: Bazaar p a b a0 -> Bazaar p a b b0 -> Bazaar p a b a0 #
Apply (Bazaar p a b)
Instance details Defined in Control.Lens.Internal.Bazaar Methods (<.>) :: Bazaar p a b (a0 -> b0) -> Bazaar p a b a0 -> Bazaar p a b b0 # (.>) :: Bazaar p a b a0 -> Bazaar p a b b0 -> Bazaar p a b b0 # (<.) :: Bazaar p a b a0 -> Bazaar p a b b0 -> Bazaar p a b a0 # liftF2 :: (a0 -> b0 -> c) -> Bazaar p a b a0 -> Bazaar p a b b0 -> Bazaar p a b c #

type Bazaar' (p :: Type -> Type -> Type) a = Bazaar p a a #

This alias is helpful when it comes to reducing repetition in type signatures.

type Bazaar' p a t = Bazaar p a a t

newtype Bazaar1 (p :: Type -> Type -> Type) a b t #

This is used to characterize a Traversal.

a.k.a. indexed Cartesian store comonad, indexed Kleene store comonad, or an indexed FunList.

http://twanvl.nl/blog/haskell/non-regular1

A Bazaar1 is like a Traversal that has already been applied to some structure.

Where a Context a b t holds an a and a function from b to t, a Bazaar1 a b t holds N as and a function from N bs to t, (where N might be infinite).

Mnemonically, a Bazaar1 holds many stores and you can easily add more.

This is a final encoding of Bazaar1.

Constructors

Bazaar1
Fields runBazaar1 :: forall (f :: Type -> Type). Apply f => p a (f b) -> f t

Instances

Profunctor p => Bizarre1 p (Bazaar1 p)
Instance details Defined in Control.Lens.Internal.Bazaar Methods bazaar1 :: Apply f => p a (f b) -> Bazaar1 p a b t -> f t #
Corepresentable p => Sellable p (Bazaar1 p)
Instance details Defined in Control.Lens.Internal.Bazaar Methods sell :: p a (Bazaar1 p a b b) #
IndexedFunctor (Bazaar1 p)
Instance details Defined in Control.Lens.Internal.Bazaar Methods ifmap :: (s -> t) -> Bazaar1 p a b s -> Bazaar1 p a b t #
Conjoined p => IndexedComonad (Bazaar1 p)
Instance details Defined in Control.Lens.Internal.Bazaar Methods iextract :: Bazaar1 p a a t -> t # iduplicate :: Bazaar1 p a c t -> Bazaar1 p a b (Bazaar1 p b c t) # iextend :: (Bazaar1 p b c t -> r) -> Bazaar1 p a c t -> Bazaar1 p a b r #
Functor (Bazaar1 p a b)
Instance details Defined in Control.Lens.Internal.Bazaar Methods fmap :: (a0 -> b0) -> Bazaar1 p a b a0 -> Bazaar1 p a b b0 # (<$) :: a0 -> Bazaar1 p a b b0 -> Bazaar1 p a b a0 #
(a ~ b, Conjoined p) => Comonad (Bazaar1 p a b)
Instance details Defined in Control.Lens.Internal.Bazaar Methods extract :: Bazaar1 p a b a0 -> a0 # duplicate :: Bazaar1 p a b a0 -> Bazaar1 p a b (Bazaar1 p a b a0) # extend :: (Bazaar1 p a b a0 -> b0) -> Bazaar1 p a b a0 -> Bazaar1 p a b b0 #
(a ~ b, Conjoined p) => ComonadApply (Bazaar1 p a b)
Instance details Defined in Control.Lens.Internal.Bazaar Methods (<@>) :: Bazaar1 p a b (a0 -> b0) -> Bazaar1 p a b a0 -> Bazaar1 p a b b0 # (@>) :: Bazaar1 p a b a0 -> Bazaar1 p a b b0 -> Bazaar1 p a b b0 # (<@) :: Bazaar1 p a b a0 -> Bazaar1 p a b b0 -> Bazaar1 p a b a0 #
Apply (Bazaar1 p a b)
Instance details Defined in Control.Lens.Internal.Bazaar Methods (<.>) :: Bazaar1 p a b (a0 -> b0) -> Bazaar1 p a b a0 -> Bazaar1 p a b b0 # (.>) :: Bazaar1 p a b a0 -> Bazaar1 p a b b0 -> Bazaar1 p a b b0 # (<.) :: Bazaar1 p a b a0 -> Bazaar1 p a b b0 -> Bazaar1 p a b a0 # liftF2 :: (a0 -> b0 -> c) -> Bazaar1 p a b a0 -> Bazaar1 p a b b0 -> Bazaar1 p a b c #

type Bazaar1' (p :: Type -> Type -> Type) a = Bazaar1 p a a #

This alias is helpful when it comes to reducing repetition in type signatures.

type Bazaar1' p a t = Bazaar1 p a a t

data Context a b t #

The indexed store can be used to characterize a Lens and is used by cloneLens.

Context a b t is isomorphic to newtype Context a b t = Context { runContext :: forall f. Functor f => (a -> f b) -> f t }, and to exists s. (s, Lens s t a b).

A Context is like a Lens that has already been applied to a some structure.

Constructors

Context (b -> t) a

Instances

IndexedFunctor Context
Instance details Defined in Control.Lens.Internal.Context Methods ifmap :: (s -> t) -> Context a b s -> Context a b t #
IndexedComonad Context
Instance details Defined in Control.Lens.Internal.Context Methods iextract :: Context a a t -> t # iduplicate :: Context a c t -> Context a b (Context b c t) # iextend :: (Context b c t -> r) -> Context a c t -> Context a b r #
IndexedComonadStore Context
Instance details Defined in Control.Lens.Internal.Context Methods ipos :: Context a c t -> a # ipeek :: c -> Context a c t -> t # ipeeks :: (a -> c) -> Context a c t -> t # iseek :: b -> Context a c t -> Context b c t # iseeks :: (a -> b) -> Context a c t -> Context b c t # iexperiment :: Functor f => (b -> f c) -> Context b c t -> f t # context :: Context a b t -> Context a b t #
a ~ b => ComonadStore a (Context a b)
Instance details Defined in Control.Lens.Internal.Context Methods pos :: Context a b a0 -> a # peek :: a -> Context a b a0 -> a0 # peeks :: (a -> a) -> Context a b a0 -> a0 # seek :: a -> Context a b a0 -> Context a b a0 # seeks :: (a -> a) -> Context a b a0 -> Context a b a0 # experiment :: Functor f => (a -> f a) -> Context a b a0 -> f a0 #
Functor (Context a b)
Instance details Defined in Control.Lens.Internal.Context Methods fmap :: (a0 -> b0) -> Context a b a0 -> Context a b b0 # (<$) :: a0 -> Context a b b0 -> Context a b a0 #
a ~ b => Comonad (Context a b)
Instance details Defined in Control.Lens.Internal.Context Methods extract :: Context a b a0 -> a0 # duplicate :: Context a b a0 -> Context a b (Context a b a0) # extend :: (Context a b a0 -> b0) -> Context a b a0 -> Context a b b0 #
Sellable ((->) :: Type -> Type -> Type) Context
Instance details Defined in Control.Lens.Internal.Context Methods sell :: a -> Context a b b #

type Context' a = Context a a #

type Context' a s = Context a a s

asIndex :: (Indexable i p, Contravariant f, Functor f) => p i (f i) -> Indexed i s (f s) #

When composed with an IndexedFold or IndexedTraversal this yields an (Indexed) Fold of the indices.

withIndex :: (Indexable i p, Functor f) => p (i, s) (f (j, t)) -> Indexed i s (f t) #

Fold a container with indices returning both the indices and the values.

The result is only valid to compose in a Traversal, if you don't edit the index as edits to the index have no effect.

>>> [10, 20, 30] ^.. ifolded . withIndex
[(0,10),(1,20),(2,30)]

>>> [10, 20, 30] ^.. ifolded . withIndex . alongside negated (re _Show)
[(0,"10"),(-1,"20"),(-2,"30")]

indexing64 :: Indexable Int64 p => ((a -> Indexing64 f b) -> s -> Indexing64 f t) -> p a (f b) -> s -> f t #

Transform a Traversal into an IndexedTraversal or a Fold into an IndexedFold, etc.

This combinator is like indexing except that it handles large traversals and folds gracefully.

indexing64 :: Traversal s t a b -> IndexedTraversal Int64 s t a b
indexing64 :: Prism s t a b     -> IndexedTraversal Int64 s t a b
indexing64 :: Lens s t a b      -> IndexedLens Int64 s t a b
indexing64 :: Iso s t a b       -> IndexedLens Int64 s t a b
indexing64 :: Fold s a          -> IndexedFold Int64 s a
indexing64 :: Getter s a        -> IndexedGetter Int64 s a

indexing64 :: Indexable Int64 p => LensLike (Indexing64 f) s t a b -> Over p f s t a b

indexing :: Indexable Int p => ((a -> Indexing f b) -> s -> Indexing f t) -> p a (f b) -> s -> f t #

Transform a Traversal into an IndexedTraversal or a Fold into an IndexedFold, etc.

indexing :: Traversal s t a b -> IndexedTraversal Int s t a b
indexing :: Prism s t a b     -> IndexedTraversal Int s t a b
indexing :: Lens s t a b      -> IndexedLens Int  s t a b
indexing :: Iso s t a b       -> IndexedLens Int s t a b
indexing :: Fold s a          -> IndexedFold Int s a
indexing :: Getter s a        -> IndexedGetter Int s a

indexing :: Indexable Int p => LensLike (Indexing f) s t a b -> Over p f s t a b

class (Choice p, Corepresentable p, Comonad (Corep p), Traversable (Corep p), Strong p, Representable p, Monad (Rep p), MonadFix (Rep p), Distributive (Rep p), Costrong p, ArrowLoop p, ArrowApply p, ArrowChoice p, Closed p) => Conjoined (p :: Type -> Type -> Type) where #

This is a Profunctor that is both Corepresentable by f and Representable by g such that f is left adjoint to g. From this you can derive a lot of structure due to the preservation of limits and colimits.

Minimal complete definition

Nothing

Methods

distrib :: Functor f => p a b -> p (f a) (f b) #

Conjoined is strong enough to let us distribute every Conjoined Profunctor over every Haskell Functor. This is effectively a generalization of fmap.

conjoined :: ((p ~ ((->) :: Type -> Type -> Type)) -> q (a -> b) r) -> q (p a b) r -> q (p a b) r #

This permits us to make a decision at an outermost point about whether or not we use an index.

Ideally any use of this function should be done in such a way so that you compute the same answer, but this cannot be enforced at the type level.

Instances

Conjoined ReifiedGetter
Instance details Defined in Control.Lens.Reified Methods distrib :: Functor f => ReifiedGetter a b -> ReifiedGetter (f a) (f b) # conjoined :: ((ReifiedGetter ~ (->)) -> q (a -> b) r) -> q (ReifiedGetter a b) r -> q (ReifiedGetter a b) r #
Conjoined (Indexed i)
Instance details Defined in Control.Lens.Internal.Indexed Methods distrib :: Functor f => Indexed i a b -> Indexed i (f a) (f b) # conjoined :: ((Indexed i ~ (->)) -> q (a -> b) r) -> q (Indexed i a b) r -> q (Indexed i a b) r #
Conjoined ((->) :: Type -> Type -> Type)
Instance details Defined in Control.Lens.Internal.Indexed Methods distrib :: Functor f => (a -> b) -> f a -> f b # conjoined :: (((->) ~ (->)) -> q (a -> b) r) -> q (a -> b) r -> q (a -> b) r #

class Conjoined p => Indexable i (p :: Type -> Type -> Type) where #

This class permits overloading of function application for things that also admit a notion of a key or index.

Methods

indexed :: p a b -> i -> a -> b #

Build a function from an indexed function.

Instances

i ~ j => Indexable i (Indexed j)
Instance details Defined in Control.Lens.Internal.Indexed Methods indexed :: Indexed j a b -> i -> a -> b #
Indexable i ((->) :: Type -> Type -> Type)
Instance details Defined in Control.Lens.Internal.Indexed Methods indexed :: (a -> b) -> i -> a -> b #

newtype Indexed i a b #

A function with access to a index. This constructor may be useful when you need to store an Indexable in a container to avoid ImpredicativeTypes.

index :: Indexed i a b -> i -> a -> b

Constructors

Indexed
Fields runIndexed :: i -> a -> b

Instances

i ~ j => Indexable i (Indexed j)
Instance details Defined in Control.Lens.Internal.Indexed Methods indexed :: Indexed j a b -> i -> a -> b #
Arrow (Indexed i)
Instance details Defined in Control.Lens.Internal.Indexed Methods arr :: (b -> c) -> Indexed i b c # first :: Indexed i b c -> Indexed i (b, d) (c, d) # second :: Indexed i b c -> Indexed i (d, b) (d, c) # (***) :: Indexed i b c -> Indexed i b' c' -> Indexed i (b, b') (c, c') # (&&&) :: Indexed i b c -> Indexed i b c' -> Indexed i b (c, c') #
ArrowChoice (Indexed i)
Instance details Defined in Control.Lens.Internal.Indexed Methods left :: Indexed i b c -> Indexed i (Either b d) (Either c d) # right :: Indexed i b c -> Indexed i (Either d b) (Either d c) # (+++) :: Indexed i b c -> Indexed i b' c' -> Indexed i (Either b b') (Either c c') # (\|\|\|) :: Indexed i b d -> Indexed i c d -> Indexed i (Either b c) d #
ArrowApply (Indexed i)
Instance details Defined in Control.Lens.Internal.Indexed Methods app :: Indexed i (Indexed i b c, b) c #
ArrowLoop (Indexed i)
Instance details Defined in Control.Lens.Internal.Indexed Methods loop :: Indexed i (b, d) (c, d) -> Indexed i b c #
Profunctor (Indexed i)
Instance details Defined in Control.Lens.Internal.Indexed Methods dimap :: (a -> b) -> (c -> d) -> Indexed i b c -> Indexed i a d # lmap :: (a -> b) -> Indexed i b c -> Indexed i a c # rmap :: (b -> c) -> Indexed i a b -> Indexed i a c # (#.) :: Coercible c b => q b c -> Indexed i a b -> Indexed i a c # (.#) :: Coercible b a => Indexed i b c -> q a b -> Indexed i a c #
Representable (Indexed i)
Instance details Defined in Control.Lens.Internal.Indexed Associated Types type Rep (Indexed i) :: Type -> Type # Methods tabulate :: (d -> Rep (Indexed i) c) -> Indexed i d c #
Corepresentable (Indexed i)
Instance details Defined in Control.Lens.Internal.Indexed Associated Types type Corep (Indexed i) :: Type -> Type # Methods cotabulate :: (Corep (Indexed i) d -> c) -> Indexed i d c #
Conjoined (Indexed i)
Instance details Defined in Control.Lens.Internal.Indexed Methods distrib :: Functor f => Indexed i a b -> Indexed i (f a) (f b) # conjoined :: ((Indexed i ~ (->)) -> q (a -> b) r) -> q (Indexed i a b) r -> q (Indexed i a b) r #
Choice (Indexed i)
Instance details Defined in Control.Lens.Internal.Indexed Methods left' :: Indexed i a b -> Indexed i (Either a c) (Either b c) # right' :: Indexed i a b -> Indexed i (Either c a) (Either c b) #
Closed (Indexed i)
Instance details Defined in Control.Lens.Internal.Indexed Methods closed :: Indexed i a b -> Indexed i (x -> a) (x -> b) #
Strong (Indexed i)
Instance details Defined in Control.Lens.Internal.Indexed Methods first' :: Indexed i a b -> Indexed i (a, c) (b, c) # second' :: Indexed i a b -> Indexed i (c, a) (c, b) #
Costrong (Indexed i)
Instance details Defined in Control.Lens.Internal.Indexed Methods unfirst :: Indexed i (a, d) (b, d) -> Indexed i a b # unsecond :: Indexed i (d, a) (d, b) -> Indexed i a b #
Bizarre (Indexed Int) Mafic
Instance details Defined in Control.Lens.Internal.Magma Methods bazaar :: Applicative f => Indexed Int a (f b) -> Mafic a b t -> f t #
Category (Indexed i :: Type -> Type -> Type)
Instance details Defined in Control.Lens.Internal.Indexed Methods id :: Indexed i a a # (.) :: Indexed i b c -> Indexed i a b -> Indexed i a c #
Bizarre (Indexed i) (Molten i)
Instance details Defined in Control.Lens.Internal.Magma Methods bazaar :: Applicative f => Indexed i a (f b) -> Molten i a b t -> f t #
Sellable (Indexed i) (Molten i)
Instance details Defined in Control.Lens.Internal.Magma Methods sell :: Indexed i a (Molten i a b b) #
Cosieve (Indexed i) ((,) i)
Instance details Defined in Control.Lens.Internal.Indexed Methods cosieve :: Indexed i a b -> (i, a) -> b #
Sieve (Indexed i) ((->) i :: Type -> Type)
Instance details Defined in Control.Lens.Internal.Indexed Methods sieve :: Indexed i a b -> a -> i -> b #
Monad (Indexed i a)
Instance details Defined in Control.Lens.Internal.Indexed Methods (>>=) :: Indexed i a a0 -> (a0 -> Indexed i a b) -> Indexed i a b # (>>) :: Indexed i a a0 -> Indexed i a b -> Indexed i a b # return :: a0 -> Indexed i a a0 # fail :: String -> Indexed i a a0 #
Functor (Indexed i a)
Instance details Defined in Control.Lens.Internal.Indexed Methods fmap :: (a0 -> b) -> Indexed i a a0 -> Indexed i a b # (<$) :: a0 -> Indexed i a b -> Indexed i a a0 #
MonadFix (Indexed i a)
Instance details Defined in Control.Lens.Internal.Indexed Methods mfix :: (a0 -> Indexed i a a0) -> Indexed i a a0 #
Applicative (Indexed i a)
Instance details Defined in Control.Lens.Internal.Indexed Methods pure :: a0 -> Indexed i a a0 # (<>) :: Indexed i a (a0 -> b) -> Indexed i a a0 -> Indexed i a b # liftA2 :: (a0 -> b -> c) -> Indexed i a a0 -> Indexed i a b -> Indexed i a c # (>) :: Indexed i a a0 -> Indexed i a b -> Indexed i a b # (<*) :: Indexed i a a0 -> Indexed i a b -> Indexed i a a0 #
Apply (Indexed i a)
Instance details Defined in Control.Lens.Internal.Indexed Methods (<.>) :: Indexed i a (a0 -> b) -> Indexed i a a0 -> Indexed i a b # (.>) :: Indexed i a a0 -> Indexed i a b -> Indexed i a b # (<.) :: Indexed i a a0 -> Indexed i a b -> Indexed i a a0 # liftF2 :: (a0 -> b -> c) -> Indexed i a a0 -> Indexed i a b -> Indexed i a c #
Bind (Indexed i a)
Instance details Defined in Control.Lens.Internal.Indexed Methods (>>-) :: Indexed i a a0 -> (a0 -> Indexed i a b) -> Indexed i a b # join :: Indexed i a (Indexed i a a0) -> Indexed i a a0 #
type Rep (Indexed i)
Instance details Defined in Control.Lens.Internal.Indexed type Rep (Indexed i) = ((->) i :: Type -> Type)
type Corep (Indexed i)
Instance details Defined in Control.Lens.Internal.Indexed type Corep (Indexed i) = (,) i

data Traversed a (f :: Type -> Type) #

Used internally by traverseOf_ and the like.

The argument a of the result should not be used!

Instances

Applicative f => Semigroup (Traversed a f)
Instance details Defined in Control.Lens.Internal.Fold Methods (<>) :: Traversed a f -> Traversed a f -> Traversed a f # sconcat :: NonEmpty (Traversed a f) -> Traversed a f # stimes :: Integral b => b -> Traversed a f -> Traversed a f #
Applicative f => Monoid (Traversed a f)
Instance details Defined in Control.Lens.Internal.Fold Methods mempty :: Traversed a f # mappend :: Traversed a f -> Traversed a f -> Traversed a f # mconcat :: [Traversed a f] -> Traversed a f #

data Sequenced a (m :: Type -> Type) #

Used internally by mapM_ and the like.

The argument a of the result should not be used!

See 4.16 Changelog entry for the explanation of "why not Apply f =>"?

Instances

Monad m => Semigroup (Sequenced a m)
Instance details Defined in Control.Lens.Internal.Fold Methods (<>) :: Sequenced a m -> Sequenced a m -> Sequenced a m # sconcat :: NonEmpty (Sequenced a m) -> Sequenced a m # stimes :: Integral b => b -> Sequenced a m -> Sequenced a m #
Monad m => Monoid (Sequenced a m)
Instance details Defined in Control.Lens.Internal.Fold Methods mempty :: Sequenced a m # mappend :: Sequenced a m -> Sequenced a m -> Sequenced a m # mconcat :: [Sequenced a m] -> Sequenced a m #

data Leftmost a #

Used for firstOf.

Instances

Semigroup (Leftmost a)
Instance details Defined in Control.Lens.Internal.Fold Methods (<>) :: Leftmost a -> Leftmost a -> Leftmost a # sconcat :: NonEmpty (Leftmost a) -> Leftmost a # stimes :: Integral b => b -> Leftmost a -> Leftmost a #
Monoid (Leftmost a)
Instance details Defined in Control.Lens.Internal.Fold Methods mempty :: Leftmost a # mappend :: Leftmost a -> Leftmost a -> Leftmost a # mconcat :: [Leftmost a] -> Leftmost a #

data Rightmost a #

Used for lastOf.

Instances

Semigroup (Rightmost a)
Instance details Defined in Control.Lens.Internal.Fold Methods (<>) :: Rightmost a -> Rightmost a -> Rightmost a # sconcat :: NonEmpty (Rightmost a) -> Rightmost a # stimes :: Integral b => b -> Rightmost a -> Rightmost a #
Monoid (Rightmost a)
Instance details Defined in Control.Lens.Internal.Fold Methods mempty :: Rightmost a # mappend :: Rightmost a -> Rightmost a -> Rightmost a # mconcat :: [Rightmost a] -> Rightmost a #

class (Foldable1 t, Traversable t) => Traversable1 (t :: Type -> Type) where #

Minimal complete definition

traverse1 | sequence1

Methods

traverse1 :: Apply f => (a -> f b) -> t a -> f (t b) #

Instances

Traversable1 Par1
Instance details Defined in Data.Semigroup.Traversable.Class Methods traverse1 :: Apply f => (a -> f b) -> Par1 a -> f (Par1 b) # sequence1 :: Apply f => Par1 (f b) -> f (Par1 b) #
Traversable1 Identity
Instance details Defined in Data.Semigroup.Traversable.Class Methods traverse1 :: Apply f => (a -> f b) -> Identity a -> f (Identity b) # sequence1 :: Apply f => Identity (f b) -> f (Identity b) #
Traversable1 Complex
Instance details Defined in Data.Semigroup.Traversable.Class Methods traverse1 :: Apply f => (a -> f b) -> Complex a -> f (Complex b) # sequence1 :: Apply f => Complex (f b) -> f (Complex b) #
Traversable1 Min
Instance details Defined in Data.Semigroup.Traversable.Class Methods traverse1 :: Apply f => (a -> f b) -> Min a -> f (Min b) # sequence1 :: Apply f => Min (f b) -> f (Min b) #
Traversable1 Max
Instance details Defined in Data.Semigroup.Traversable.Class Methods traverse1 :: Apply f => (a -> f b) -> Max a -> f (Max b) # sequence1 :: Apply f => Max (f b) -> f (Max b) #
Traversable1 First
Instance details Defined in Data.Semigroup.Traversable.Class Methods traverse1 :: Apply f => (a -> f b) -> First a -> f (First b) # sequence1 :: Apply f => First (f b) -> f (First b) #
Traversable1 Last
Instance details Defined in Data.Semigroup.Traversable.Class Methods traverse1 :: Apply f => (a -> f b) -> Last a -> f (Last b) # sequence1 :: Apply f => Last (f b) -> f (Last b) #
Traversable1 Dual
Instance details Defined in Data.Semigroup.Traversable.Class Methods traverse1 :: Apply f => (a -> f b) -> Dual a -> f (Dual b) # sequence1 :: Apply f => Dual (f b) -> f (Dual b) #
Traversable1 Sum
Instance details Defined in Data.Semigroup.Traversable.Class Methods traverse1 :: Apply f => (a -> f b) -> Sum a -> f (Sum b) # sequence1 :: Apply f => Sum (f b) -> f (Sum b) #
Traversable1 Product
Instance details Defined in Data.Semigroup.Traversable.Class Methods traverse1 :: Apply f => (a -> f b) -> Product a -> f (Product b) # sequence1 :: Apply f => Product (f b) -> f (Product b) #
Traversable1 NonEmpty
Instance details Defined in Data.Semigroup.Traversable.Class Methods traverse1 :: Apply f => (a -> f b) -> NonEmpty a -> f (NonEmpty b) # sequence1 :: Apply f => NonEmpty (f b) -> f (NonEmpty b) #
Traversable1 Tree
Instance details Defined in Data.Semigroup.Traversable.Class Methods traverse1 :: Apply f => (a -> f b) -> Tree a -> f (Tree b) # sequence1 :: Apply f => Tree (f b) -> f (Tree b) #
Traversable1 (V1 :: Type -> Type)
Instance details Defined in Data.Semigroup.Traversable.Class Methods traverse1 :: Apply f => (a -> f b) -> V1 a -> f (V1 b) # sequence1 :: Apply f => V1 (f b) -> f (V1 b) #
Traversable1 ((,) a)
Instance details Defined in Data.Semigroup.Traversable.Class Methods traverse1 :: Apply f => (a0 -> f b) -> (a, a0) -> f (a, b) # sequence1 :: Apply f => (a, f b) -> f (a, b) #
Traversable1 f => Traversable1 (Cofree f)
Instance details Defined in Control.Comonad.Cofree Methods traverse1 :: Apply f0 => (a -> f0 b) -> Cofree f a -> f0 (Cofree f b) # sequence1 :: Apply f0 => Cofree f (f0 b) -> f0 (Cofree f b) #
Traversable1 f => Traversable1 (Free f)
Instance details Defined in Control.Monad.Free Methods traverse1 :: Apply f0 => (a -> f0 b) -> Free f a -> f0 (Free f b) # sequence1 :: Apply f0 => Free f (f0 b) -> f0 (Free f b) #
Traversable1 f => Traversable1 (Yoneda f)
Instance details Defined in Data.Functor.Yoneda Methods traverse1 :: Apply f0 => (a -> f0 b) -> Yoneda f a -> f0 (Yoneda f b) # sequence1 :: Apply f0 => Yoneda f (f0 b) -> f0 (Yoneda f b) #
Traversable1 f => Traversable1 (Lift f)
Instance details Defined in Data.Semigroup.Traversable.Class Methods traverse1 :: Apply f0 => (a -> f0 b) -> Lift f a -> f0 (Lift f b) # sequence1 :: Apply f0 => Lift f (f0 b) -> f0 (Lift f b) #
Traversable1 f => Traversable1 (Rec1 f)
Instance details Defined in Data.Semigroup.Traversable.Class Methods traverse1 :: Apply f0 => (a -> f0 b) -> Rec1 f a -> f0 (Rec1 f b) # sequence1 :: Apply f0 => Rec1 f (f0 b) -> f0 (Rec1 f b) #
Traversable1 f => Traversable1 (IdentityT f)
Instance details Defined in Data.Semigroup.Traversable.Class Methods traverse1 :: Apply f0 => (a -> f0 b) -> IdentityT f a -> f0 (IdentityT f b) # sequence1 :: Apply f0 => IdentityT f (f0 b) -> f0 (IdentityT f b) #
Traversable1 f => Traversable1 (Alt f)
Instance details Defined in Data.Semigroup.Traversable.Class Methods traverse1 :: Apply f0 => (a -> f0 b) -> Alt f a -> f0 (Alt f b) # sequence1 :: Apply f0 => Alt f (f0 b) -> f0 (Alt f b) #
Bitraversable1 p => Traversable1 (Join p)
Instance details Defined in Data.Semigroup.Traversable.Class Methods traverse1 :: Apply f => (a -> f b) -> Join p a -> f (Join p b) # sequence1 :: Apply f => Join p (f b) -> f (Join p b) #
Traversable1 f => Traversable1 (Backwards f)
Instance details Defined in Data.Semigroup.Traversable.Class Methods traverse1 :: Apply f0 => (a -> f0 b) -> Backwards f a -> f0 (Backwards f b) # sequence1 :: Apply f0 => Backwards f (f0 b) -> f0 (Backwards f b) #
Traversable1 f => Traversable1 (AlongsideLeft f b)
Instance details Defined in Control.Lens.Internal.Getter Methods traverse1 :: Apply f0 => (a -> f0 b0) -> AlongsideLeft f b a -> f0 (AlongsideLeft f b b0) # sequence1 :: Apply f0 => AlongsideLeft f b (f0 b0) -> f0 (AlongsideLeft f b b0) #
Traversable1 f => Traversable1 (AlongsideRight f a)
Instance details Defined in Control.Lens.Internal.Getter Methods traverse1 :: Apply f0 => (a0 -> f0 b) -> AlongsideRight f a a0 -> f0 (AlongsideRight f a b) # sequence1 :: Apply f0 => AlongsideRight f a (f0 b) -> f0 (AlongsideRight f a b) #
Traversable1 (Tagged a)
Instance details Defined in Data.Semigroup.Traversable.Class Methods traverse1 :: Apply f => (a0 -> f b) -> Tagged a a0 -> f (Tagged a b) # sequence1 :: Apply f => Tagged a (f b) -> f (Tagged a b) #
Traversable1 f => Traversable1 (Reverse f)
Instance details Defined in Data.Semigroup.Traversable.Class Methods traverse1 :: Apply f0 => (a -> f0 b) -> Reverse f a -> f0 (Reverse f b) # sequence1 :: Apply f0 => Reverse f (f0 b) -> f0 (Reverse f b) #
(Traversable1 f, Traversable1 g) => Traversable1 (f :+: g)
Instance details Defined in Data.Semigroup.Traversable.Class Methods traverse1 :: Apply f0 => (a -> f0 b) -> (f :+: g) a -> f0 ((f :+: g) b) # sequence1 :: Apply f0 => (f :+: g) (f0 b) -> f0 ((f :+: g) b) #
(Traversable1 f, Traversable1 g) => Traversable1 (f :*: g)
Instance details Defined in Data.Semigroup.Traversable.Class Methods traverse1 :: Apply f0 => (a -> f0 b) -> (f :: g) a -> f0 ((f :: g) b) # sequence1 :: Apply f0 => (f :: g) (f0 b) -> f0 ((f :: g) b) #
(Traversable1 f, Traversable1 g) => Traversable1 (Product f g)
Instance details Defined in Data.Semigroup.Traversable.Class Methods traverse1 :: Apply f0 => (a -> f0 b) -> Product f g a -> f0 (Product f g b) # sequence1 :: Apply f0 => Product f g (f0 b) -> f0 (Product f g b) #
(Traversable1 f, Traversable1 g) => Traversable1 (Sum f g)
Instance details Defined in Data.Semigroup.Traversable.Class Methods traverse1 :: Apply f0 => (a -> f0 b) -> Sum f g a -> f0 (Sum f g b) # sequence1 :: Apply f0 => Sum f g (f0 b) -> f0 (Sum f g b) #
Traversable1 f => Traversable1 (M1 i c f)
Instance details Defined in Data.Semigroup.Traversable.Class Methods traverse1 :: Apply f0 => (a -> f0 b) -> M1 i c f a -> f0 (M1 i c f b) # sequence1 :: Apply f0 => M1 i c f (f0 b) -> f0 (M1 i c f b) #
(Traversable1 f, Traversable1 g) => Traversable1 (f :.: g)
Instance details Defined in Data.Semigroup.Traversable.Class Methods traverse1 :: Apply f0 => (a -> f0 b) -> (f :.: g) a -> f0 ((f :.: g) b) # sequence1 :: Apply f0 => (f :.: g) (f0 b) -> f0 ((f :.: g) b) #
(Traversable1 f, Traversable1 g) => Traversable1 (Compose f g)
Instance details Defined in Data.Semigroup.Traversable.Class Methods traverse1 :: Apply f0 => (a -> f0 b) -> Compose f g a -> f0 (Compose f g b) # sequence1 :: Apply f0 => Compose f g (f0 b) -> f0 (Compose f g b) #
Traversable1 g => Traversable1 (Joker g a)
Instance details Defined in Data.Semigroup.Traversable.Class Methods traverse1 :: Apply f => (a0 -> f b) -> Joker g a a0 -> f (Joker g a b) # sequence1 :: Apply f => Joker g a (f b) -> f (Joker g a b) #

foldBy :: Foldable t => (a -> a -> a) -> a -> t a -> a #

Fold a value using its Foldable instance using explicitly provided Monoid operations. This is like fold where the Monoid instance can be manually specified.

foldBy mappend mempty ≡ fold

>>> foldBy (++) [] ["hello","world"]
"helloworld"

foldMapBy :: Foldable t => (r -> r -> r) -> r -> (a -> r) -> t a -> r #

Fold a value using its Foldable instance using explicitly provided Monoid operations. This is like foldMap where the Monoid instance can be manually specified.

foldMapBy mappend mempty ≡ foldMap

>>> foldMapBy (+) 0 length ["hello","world"]
10

traverseBy :: Traversable t => (forall x. x -> f x) -> (forall x y. f (x -> y) -> f x -> f y) -> (a -> f b) -> t a -> f (t b) #

Traverse a container using its Traversable instance using explicitly provided Applicative operations. This is like traverse where the Applicative instance can be manually specified.

sequenceBy :: Traversable t => (forall x. x -> f x) -> (forall x y. f (x -> y) -> f x -> f y) -> t (f a) -> f (t a) #

Sequence a container using its Traversable instance using explicitly provided Applicative operations. This is like sequence where the Applicative instance can be manually specified.

class Profunctor p => Choice (p :: Type -> Type -> Type) where #

The generalization of Costar of Functor that is strong with respect to Either.

Note: This is also a notion of strength, except with regards to another monoidal structure that we can choose to equip Hask with: the cocartesian coproduct.

Minimal complete definition

left' | right'

Methods

left' :: p a b -> p (Either a c) (Either b c) #

Laws:

left' ≡ dimap swapE swapE . right' where
  swapE :: Either a b -> Either b a
  swapE = either Right Left
rmap Left ≡ lmap Left . left'
lmap (right f) . left' ≡ rmap (right f) . left'
left' . left' ≡ dimap assocE unassocE . left' where
  assocE :: Either (Either a b) c -> Either a (Either b c)
  assocE (Left (Left a)) = Left a
  assocE (Left (Right b)) = Right (Left b)
  assocE (Right c) = Right (Right c)
  unassocE :: Either a (Either b c) -> Either (Either a b) c
  unassocE (Left a) = Left (Left a)
  unassocE (Right (Left b)) = Left (Right b)
  unassocE (Right (Right c)) = Right c

right' :: p a b -> p (Either c a) (Either c b) #

Laws:

right' ≡ dimap swapE swapE . left' where
  swapE :: Either a b -> Either b a
  swapE = either Right Left
rmap Right ≡ lmap Right . right'
lmap (left f) . right' ≡ rmap (left f) . right'
right' . right' ≡ dimap unassocE assocE . right' where
  assocE :: Either (Either a b) c -> Either a (Either b c)
  assocE (Left (Left a)) = Left a
  assocE (Left (Right b)) = Right (Left b)
  assocE (Right c) = Right (Right c)
  unassocE :: Either a (Either b c) -> Either (Either a b) c
  unassocE (Left a) = Left (Left a)
  unassocE (Right (Left b)) = Left (Right b)
  unassocE (Right (Right c)) = Right c

Instances

Choice ReifiedGetter
Instance details Defined in Control.Lens.Reified Methods left' :: ReifiedGetter a b -> ReifiedGetter (Either a c) (Either b c) # right' :: ReifiedGetter a b -> ReifiedGetter (Either c a) (Either c b) #
Choice ReifiedFold
Instance details Defined in Control.Lens.Reified Methods left' :: ReifiedFold a b -> ReifiedFold (Either a c) (Either b c) # right' :: ReifiedFold a b -> ReifiedFold (Either c a) (Either c b) #
Monad m => Choice (Kleisli m)
Instance details Defined in Data.Profunctor.Choice Methods left' :: Kleisli m a b -> Kleisli m (Either a c) (Either b c) # right' :: Kleisli m a b -> Kleisli m (Either c a) (Either c b) #
Choice (Indexed i)
Instance details Defined in Control.Lens.Internal.Indexed Methods left' :: Indexed i a b -> Indexed i (Either a c) (Either b c) # right' :: Indexed i a b -> Indexed i (Either c a) (Either c b) #
Profunctor p => Choice (TambaraSum p)
Instance details Defined in Data.Profunctor.Choice Methods left' :: TambaraSum p a b -> TambaraSum p (Either a c) (Either b c) # right' :: TambaraSum p a b -> TambaraSum p (Either c a) (Either c b) #
Choice (PastroSum p)
Instance details Defined in Data.Profunctor.Choice Methods left' :: PastroSum p a b -> PastroSum p (Either a c) (Either b c) # right' :: PastroSum p a b -> PastroSum p (Either c a) (Either c b) #
Choice p => Choice (Tambara p)
Instance details Defined in Data.Profunctor.Choice Methods left' :: Tambara p a b -> Tambara p (Either a c) (Either b c) # right' :: Tambara p a b -> Tambara p (Either c a) (Either c b) #
Applicative f => Choice (Star f)
Instance details Defined in Data.Profunctor.Choice Methods left' :: Star f a b -> Star f (Either a c) (Either b c) # right' :: Star f a b -> Star f (Either c a) (Either c b) #
ArrowChoice p => Choice (WrappedArrow p)
Instance details Defined in Data.Profunctor.Choice Methods left' :: WrappedArrow p a b -> WrappedArrow p (Either a c) (Either b c) # right' :: WrappedArrow p a b -> WrappedArrow p (Either c a) (Either c b) #
Monoid r => Choice (Forget r)
Instance details Defined in Data.Profunctor.Choice Methods left' :: Forget r a b -> Forget r (Either a c) (Either b c) # right' :: Forget r a b -> Forget r (Either c a) (Either c b) #
Choice (Tagged :: Type -> Type -> Type)
Instance details Defined in Data.Profunctor.Choice Methods left' :: Tagged a b -> Tagged (Either a c) (Either b c) # right' :: Tagged a b -> Tagged (Either c a) (Either c b) #
Choice ((->) :: Type -> Type -> Type)
Instance details Defined in Data.Profunctor.Choice Methods left' :: (a -> b) -> Either a c -> Either b c # right' :: (a -> b) -> Either c a -> Either c b #
Comonad w => Choice (Cokleisli w)	`extract` approximates `costrength`
Instance details Defined in Data.Profunctor.Choice Methods left' :: Cokleisli w a b -> Cokleisli w (Either a c) (Either b c) # right' :: Cokleisli w a b -> Cokleisli w (Either c a) (Either c b) #
(Choice p, Choice q) => Choice (Procompose p q)
Instance details Defined in Data.Profunctor.Composition Methods left' :: Procompose p q a b -> Procompose p q (Either a c) (Either b c) # right' :: Procompose p q a b -> Procompose p q (Either c a) (Either c b) #
Functor f => Choice (Joker f :: Type -> Type -> Type)
Instance details Defined in Data.Profunctor.Choice Methods left' :: Joker f a b -> Joker f (Either a c) (Either b c) # right' :: Joker f a b -> Joker f (Either c a) (Either c b) #
(Choice p, Choice q) => Choice (Product p q)
Instance details Defined in Data.Profunctor.Choice Methods left' :: Product p q a b -> Product p q (Either a c) (Either b c) # right' :: Product p q a b -> Product p q (Either c a) (Either c b) #
(Functor f, Choice p) => Choice (Tannen f p)
Instance details Defined in Data.Profunctor.Choice Methods left' :: Tannen f p a b -> Tannen f p (Either a c) (Either b c) # right' :: Tannen f p a b -> Tannen f p (Either c a) (Either c b) #

_JSON' :: (AsJSON t, FromJSON a, ToJSON a) => Prism' t a #

values :: AsValue t => IndexedTraversal' Int t Value #

An indexed Traversal into Array elements

>>> "[1,2,3]" ^.. values
[Number 1.0,Number 2.0,Number 3.0]

>>> "[1,2,3]" & values . _Number *~ 10
"[10,20,30]"

nth :: AsValue t => Int -> Traversal' t Value #

Like ix, but for Arrays with Int indexes

>>> "[1,2,3]" ^? nth 1
Just (Number 2.0)

>>> "{\"a\": 100, \"b\": 200}" ^? nth 1
Nothing

>>> "[1,2,3]" & nth 1 .~ Number 20
"[1,20,3]"

members :: AsValue t => IndexedTraversal' Text t Value #

An indexed Traversal into Object properties

>>> Data.List.sort ("{\"a\": 4, \"b\": 7}" ^@.. members . _Number)
[("a",4.0),("b",7.0)]

>>> "{\"a\": 4}" & members . _Number *~ 10
"{\"a\":40}"

key :: AsValue t => Text -> Traversal' t Value #

Like ix, but for Value with Text indices. This often has better inference than ix when used with OverloadedStrings.

>>> "{\"a\": 100, \"b\": 200}" ^? key "a"
Just (Number 100.0)

>>> "[1,2,3]" ^? key "a"
Nothing

nonNull :: Prism' Value Value #

Prism into non-Null values

>>> "{\"a\": \"xyz\", \"b\": null}" ^? key "a" . nonNull
Just (String "xyz")

>>> "{\"a\": {}, \"b\": null}" ^? key "a" . nonNull
Just (Object (fromList []))

>>> "{\"a\": \"xyz\", \"b\": null}" ^? key "b" . nonNull
Nothing

_Integral :: (AsNumber t, Integral a) => Prism' t a #

Access Integer Values as Integrals.

>>> "[10]" ^? nth 0 . _Integral
Just 10

>>> "[10.5]" ^? nth 0 . _Integral
Just 10

pattern JSON :: forall a t. (FromJSON a, ToJSON a, AsJSON t) => a -> t #

pattern Value_ :: forall a. (FromJSON a, ToJSON a) => a -> Value #

pattern Number_ :: forall t. AsNumber t => Scientific -> t #

pattern Double :: forall t. AsNumber t => Double -> t #

pattern Integer :: forall t. AsNumber t => Integer -> t #

pattern Integral :: forall t a. (AsNumber t, Integral a) => a -> t #

pattern Primitive :: forall t. AsPrimitive t => Primitive -> t #

pattern Bool_ :: forall t. AsPrimitive t => Bool -> t #

pattern String_ :: forall t. AsPrimitive t => Text -> t #

pattern Null_ :: forall t. AsPrimitive t => t #

class AsNumber t where #

Minimal complete definition

Nothing

Methods

_Number :: Prism' t Scientific #

>>> "[1, \"x\"]" ^? nth 0 . _Number
Just 1.0

>>> "[1, \"x\"]" ^? nth 1 . _Number
Nothing

_Double :: Prism' t Double #

Prism into an Double over a Value, Primitive or Scientific

>>> "[10.2]" ^? nth 0 . _Double
Just 10.2

_Integer :: Prism' t Integer #

Prism into an Integer over a Value, Primitive or Scientific

>>> "[10]" ^? nth 0 . _Integer
Just 10

>>> "[10.5]" ^? nth 0 . _Integer
Just 10

>>> "42" ^? _Integer
Just 42

Instances

AsNumber String
Instance details Defined in Data.Aeson.Lens Methods _Number :: Prism' String Scientific # _Double :: Prism' String Double # _Integer :: Prism' String Integer #
AsNumber ByteString
Instance details Defined in Data.Aeson.Lens Methods _Number :: Prism' ByteString Scientific # _Double :: Prism' ByteString Double # _Integer :: Prism' ByteString Integer #
AsNumber ByteString
Instance details Defined in Data.Aeson.Lens Methods _Number :: Prism' ByteString Scientific # _Double :: Prism' ByteString Double # _Integer :: Prism' ByteString Integer #
AsNumber Text
Instance details Defined in Data.Aeson.Lens Methods _Number :: Prism' Text Scientific # _Double :: Prism' Text Double # _Integer :: Prism' Text Integer #
AsNumber Scientific
Instance details Defined in Data.Aeson.Lens Methods _Number :: Prism' Scientific Scientific # _Double :: Prism' Scientific Double # _Integer :: Prism' Scientific Integer #
AsNumber Value
Instance details Defined in Data.Aeson.Lens Methods _Number :: Prism' Value Scientific # _Double :: Prism' Value Double # _Integer :: Prism' Value Integer #
AsNumber Text
Instance details Defined in Data.Aeson.Lens Methods _Number :: Prism' Text Scientific # _Double :: Prism' Text Double # _Integer :: Prism' Text Integer #
AsNumber Primitive
Instance details Defined in Data.Aeson.Lens Methods _Number :: Prism' Primitive Scientific # _Double :: Prism' Primitive Double # _Integer :: Prism' Primitive Integer #

data Primitive #

Primitives of Value

Constructors

StringPrim !Text
NumberPrim !Scientific
BoolPrim !Bool
NullPrim

Instances

Eq Primitive
Instance details Defined in Data.Aeson.Lens Methods (==) :: Primitive -> Primitive -> Bool # (/=) :: Primitive -> Primitive -> Bool #
Data Primitive
Instance details Defined in Data.Aeson.Lens Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Primitive -> c Primitive # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Primitive # toConstr :: Primitive -> Constr # dataTypeOf :: Primitive -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Primitive) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Primitive) # gmapT :: (forall b. Data b => b -> b) -> Primitive -> Primitive # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Primitive -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Primitive -> r # gmapQ :: (forall d. Data d => d -> u) -> Primitive -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Primitive -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Primitive -> m Primitive # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Primitive -> m Primitive # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Primitive -> m Primitive #
Ord Primitive
Instance details Defined in Data.Aeson.Lens Methods compare :: Primitive -> Primitive -> Ordering # (<) :: Primitive -> Primitive -> Bool # (<=) :: Primitive -> Primitive -> Bool # (>) :: Primitive -> Primitive -> Bool # (>=) :: Primitive -> Primitive -> Bool # max :: Primitive -> Primitive -> Primitive # min :: Primitive -> Primitive -> Primitive #
Show Primitive
Instance details Defined in Data.Aeson.Lens Methods showsPrec :: Int -> Primitive -> ShowS # show :: Primitive -> String # showList :: [Primitive] -> ShowS #
AsNumber Primitive
Instance details Defined in Data.Aeson.Lens Methods _Number :: Prism' Primitive Scientific # _Double :: Prism' Primitive Double # _Integer :: Prism' Primitive Integer #
AsPrimitive Primitive
Instance details Defined in Data.Aeson.Lens Methods _Primitive :: Prism' Primitive Primitive # _String :: Prism' Primitive Text # _Bool :: Prism' Primitive Bool # _Null :: Prism' Primitive () #

class AsNumber t => AsPrimitive t where #

Minimal complete definition

Nothing

Methods

_Primitive :: Prism' t Primitive #

>>> "[1, \"x\", null, true, false]" ^? nth 0 . _Primitive
Just (NumberPrim 1.0)

>>> "[1, \"x\", null, true, false]" ^? nth 1 . _Primitive
Just (StringPrim "x")

>>> "[1, \"x\", null, true, false]" ^? nth 2 . _Primitive
Just NullPrim

>>> "[1, \"x\", null, true, false]" ^? nth 3 . _Primitive
Just (BoolPrim True)

>>> "[1, \"x\", null, true, false]" ^? nth 4 . _Primitive
Just (BoolPrim False)

_String :: Prism' t Text #

>>> "{\"a\": \"xyz\", \"b\": true}" ^? key "a" . _String
Just "xyz"

>>> "{\"a\": \"xyz\", \"b\": true}" ^? key "b" . _String
Nothing

>>> _Object._Wrapped # [("key" :: Text, _String # "value")] :: String
"{\"key\":\"value\"}"

_Bool :: Prism' t Bool #

>>> "{\"a\": \"xyz\", \"b\": true}" ^? key "b" . _Bool
Just True

>>> "{\"a\": \"xyz\", \"b\": true}" ^? key "a" . _Bool
Nothing

>>> _Bool # True :: String
"true"

>>> _Bool # False :: String
"false"

_Null :: Prism' t () #

>>> "{\"a\": \"xyz\", \"b\": null}" ^? key "b" . _Null
Just ()

>>> "{\"a\": \"xyz\", \"b\": null}" ^? key "a" . _Null
Nothing

>>> _Null # () :: String
"null"

Instances

AsPrimitive String
Instance details Defined in Data.Aeson.Lens Methods _Primitive :: Prism' String Primitive # _String :: Prism' String Text # _Bool :: Prism' String Bool # _Null :: Prism' String () #
AsPrimitive ByteString
Instance details Defined in Data.Aeson.Lens Methods _Primitive :: Prism' ByteString Primitive # _String :: Prism' ByteString Text # _Bool :: Prism' ByteString Bool # _Null :: Prism' ByteString () #
AsPrimitive ByteString
Instance details Defined in Data.Aeson.Lens Methods _Primitive :: Prism' ByteString Primitive # _String :: Prism' ByteString Text # _Bool :: Prism' ByteString Bool # _Null :: Prism' ByteString () #
AsPrimitive Text
Instance details Defined in Data.Aeson.Lens Methods _Primitive :: Prism' Text Primitive # _String :: Prism' Text Text # _Bool :: Prism' Text Bool # _Null :: Prism' Text () #
AsPrimitive Value
Instance details Defined in Data.Aeson.Lens Methods _Primitive :: Prism' Value Primitive # _String :: Prism' Value Text # _Bool :: Prism' Value Bool # _Null :: Prism' Value () #
AsPrimitive Text
Instance details Defined in Data.Aeson.Lens Methods _Primitive :: Prism' Text Primitive # _String :: Prism' Text Text0 # _Bool :: Prism' Text Bool # _Null :: Prism' Text () #
AsPrimitive Primitive
Instance details Defined in Data.Aeson.Lens Methods _Primitive :: Prism' Primitive Primitive # _String :: Prism' Primitive Text # _Bool :: Prism' Primitive Bool # _Null :: Prism' Primitive () #

class AsPrimitive t => AsValue t where #

Minimal complete definition

_Value

Methods

_Value :: Prism' t Value #

>>> preview _Value "[1,2,3]" == Just (Array (Vector.fromList [Number 1.0,Number 2.0,Number 3.0]))
True

_Object :: Prism' t (HashMap Text Value) #

>>> "{\"a\": {}, \"b\": null}" ^? key "a" . _Object
Just (fromList [])

>>> "{\"a\": {}, \"b\": null}" ^? key "b" . _Object
Nothing

>>> _Object._Wrapped # [("key" :: Text, _String # "value")] :: String
"{\"key\":\"value\"}"

_Array :: Prism' t (Vector Value) #

>>> preview _Array "[1,2,3]" == Just (Vector.fromList [Number 1.0,Number 2.0,Number 3.0])
True

Instances

AsValue String
Instance details Defined in Data.Aeson.Lens Methods _Value :: Prism' String Value # _Object :: Prism' String (HashMap Text Value) # _Array :: Prism' String (Vector Value) #
AsValue ByteString
Instance details Defined in Data.Aeson.Lens Methods _Value :: Prism' ByteString Value # _Object :: Prism' ByteString (HashMap Text Value) # _Array :: Prism' ByteString (Vector Value) #
AsValue ByteString
Instance details Defined in Data.Aeson.Lens Methods _Value :: Prism' ByteString Value # _Object :: Prism' ByteString (HashMap Text Value) # _Array :: Prism' ByteString (Vector Value) #
AsValue Text
Instance details Defined in Data.Aeson.Lens Methods _Value :: Prism' Text Value # _Object :: Prism' Text (HashMap Text Value) # _Array :: Prism' Text (Vector Value) #
AsValue Value
Instance details Defined in Data.Aeson.Lens Methods _Value :: Prism' Value Value # _Object :: Prism' Value (HashMap Text Value) # _Array :: Prism' Value (Vector Value) #
AsValue Text
Instance details Defined in Data.Aeson.Lens Methods _Value :: Prism' Text Value # _Object :: Prism' Text (HashMap Text0 Value) # _Array :: Prism' Text (Vector Value) #

class AsJSON t where #

Methods

_JSON :: (FromJSON a, ToJSON b) => Prism t t a b #

_JSON is a Prism from something containing JSON to something encoded in that structure

Instances

AsJSON String
Instance details Defined in Data.Aeson.Lens Methods _JSON :: (FromJSON a, ToJSON b) => Prism String String a b #
AsJSON ByteString
Instance details Defined in Data.Aeson.Lens Methods _JSON :: (FromJSON a, ToJSON b) => Prism ByteString ByteString a b #
AsJSON ByteString
Instance details Defined in Data.Aeson.Lens Methods _JSON :: (FromJSON a, ToJSON b) => Prism ByteString ByteString a b #
AsJSON Text
Instance details Defined in Data.Aeson.Lens Methods _JSON :: (FromJSON a, ToJSON b) => Prism Text Text a b #
AsJSON Value
Instance details Defined in Data.Aeson.Lens Methods _JSON :: (FromJSON a, ToJSON b) => Prism Value Value a b #
AsJSON Text
Instance details Defined in Data.Aeson.Lens Methods _JSON :: (FromJSON a, ToJSON b) => Prism Text Text a b #

liftIO :: MonadIO m => IO a -> m a #

Lift a computation from the IO monad.

ToJSON1 []
Instance details Defined in Data.Aeson.Types.ToJSON Methods liftToJSON :: (a -> Value) -> ([a] -> Value) -> [a] -> Value # liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [[a]] -> Value # liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> [a] -> Encoding # liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [[a]] -> Encoding #
ToJSON1 Maybe
Instance details Defined in Data.Aeson.Types.ToJSON Methods liftToJSON :: (a -> Value) -> ([a] -> Value) -> Maybe a -> Value # liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [Maybe a] -> Value # liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> Maybe a -> Encoding # liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [Maybe a] -> Encoding #
ToJSON1 Set
Instance details Defined in Data.Aeson.Types.ToJSON Methods liftToJSON :: (a -> Value) -> ([a] -> Value) -> Set a -> Value # liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [Set a] -> Value # liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> Set a -> Encoding # liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [Set a] -> Encoding #
ToJSON1 Identity
Instance details Defined in Data.Aeson.Types.ToJSON Methods liftToJSON :: (a -> Value) -> ([a] -> Value) -> Identity a -> Value # liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [Identity a] -> Value # liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> Identity a -> Encoding # liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [Identity a] -> Encoding #
ToJSON1 Min
Instance details Defined in Data.Aeson.Types.ToJSON Methods liftToJSON :: (a -> Value) -> ([a] -> Value) -> Min a -> Value # liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [Min a] -> Value # liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> Min a -> Encoding # liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [Min a] -> Encoding #
ToJSON1 Max
Instance details Defined in Data.Aeson.Types.ToJSON Methods liftToJSON :: (a -> Value) -> ([a] -> Value) -> Max a -> Value # liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [Max a] -> Value # liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> Max a -> Encoding # liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [Max a] -> Encoding #
ToJSON1 First
Instance details Defined in Data.Aeson.Types.ToJSON Methods liftToJSON :: (a -> Value) -> ([a] -> Value) -> First a -> Value # liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [First a] -> Value # liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> First a -> Encoding # liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [First a] -> Encoding #
ToJSON1 Last
Instance details Defined in Data.Aeson.Types.ToJSON Methods liftToJSON :: (a -> Value) -> ([a] -> Value) -> Last a -> Value # liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [Last a] -> Value # liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> Last a -> Encoding # liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [Last a] -> Encoding #
ToJSON1 WrappedMonoid
Instance details Defined in Data.Aeson.Types.ToJSON Methods liftToJSON :: (a -> Value) -> ([a] -> Value) -> WrappedMonoid a -> Value # liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [WrappedMonoid a] -> Value # liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> WrappedMonoid a -> Encoding # liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [WrappedMonoid a] -> Encoding #
ToJSON1 Option
Instance details Defined in Data.Aeson.Types.ToJSON Methods liftToJSON :: (a -> Value) -> ([a] -> Value) -> Option a -> Value # liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [Option a] -> Value # liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> Option a -> Encoding # liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [Option a] -> Encoding #
ToJSON1 First
Instance details Defined in Data.Aeson.Types.ToJSON Methods liftToJSON :: (a -> Value) -> ([a] -> Value) -> First a -> Value # liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [First a] -> Value # liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> First a -> Encoding # liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [First a] -> Encoding #
ToJSON1 Last
Instance details Defined in Data.Aeson.Types.ToJSON Methods liftToJSON :: (a -> Value) -> ([a] -> Value) -> Last a -> Value # liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [Last a] -> Value # liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> Last a -> Encoding # liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [Last a] -> Encoding #
ToJSON1 Dual
Instance details Defined in Data.Aeson.Types.ToJSON Methods liftToJSON :: (a -> Value) -> ([a] -> Value) -> Dual a -> Value # liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [Dual a] -> Value # liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> Dual a -> Encoding # liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [Dual a] -> Encoding #
ToJSON1 NonEmpty
Instance details Defined in Data.Aeson.Types.ToJSON Methods liftToJSON :: (a -> Value) -> ([a] -> Value) -> NonEmpty a -> Value # liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [NonEmpty a] -> Value # liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> NonEmpty a -> Encoding # liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [NonEmpty a] -> Encoding #
ToJSON1 IntMap
Instance details Defined in Data.Aeson.Types.ToJSON Methods liftToJSON :: (a -> Value) -> ([a] -> Value) -> IntMap a -> Value # liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [IntMap a] -> Value # liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> IntMap a -> Encoding # liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [IntMap a] -> Encoding #
ToJSON1 Tree
Instance details Defined in Data.Aeson.Types.ToJSON Methods liftToJSON :: (a -> Value) -> ([a] -> Value) -> Tree a -> Value # liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [Tree a] -> Value # liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> Tree a -> Encoding # liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [Tree a] -> Encoding #
ToJSON1 Seq
Instance details Defined in Data.Aeson.Types.ToJSON Methods liftToJSON :: (a -> Value) -> ([a] -> Value) -> Seq a -> Value # liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [Seq a] -> Value # liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> Seq a -> Encoding # liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [Seq a] -> Encoding #
ToJSON1 DList
Instance details Defined in Data.Aeson.Types.ToJSON Methods liftToJSON :: (a -> Value) -> ([a] -> Value) -> DList a -> Value # liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [DList a] -> Value # liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> DList a -> Encoding # liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [DList a] -> Encoding #
ToJSON1 HashSet
Instance details Defined in Data.Aeson.Types.ToJSON Methods liftToJSON :: (a -> Value) -> ([a] -> Value) -> HashSet a -> Value # liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [HashSet a] -> Value # liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> HashSet a -> Encoding # liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [HashSet a] -> Encoding #
ToJSON1 Vector
Instance details Defined in Data.Aeson.Types.ToJSON Methods liftToJSON :: (a -> Value) -> ([a] -> Value) -> Vector a -> Value # liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [Vector a] -> Value # liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> Vector a -> Encoding # liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [Vector a] -> Encoding #
ToJSON a => ToJSON1 (Either a)
Instance details Defined in Data.Aeson.Types.ToJSON Methods liftToJSON :: (a0 -> Value) -> ([a0] -> Value) -> Either a a0 -> Value # liftToJSONList :: (a0 -> Value) -> ([a0] -> Value) -> [Either a a0] -> Value # liftToEncoding :: (a0 -> Encoding) -> ([a0] -> Encoding) -> Either a a0 -> Encoding # liftToEncodingList :: (a0 -> Encoding) -> ([a0] -> Encoding) -> [Either a a0] -> Encoding #
ToJSON a => ToJSON1 ((,) a)
Instance details Defined in Data.Aeson.Types.ToJSON Methods liftToJSON :: (a0 -> Value) -> ([a0] -> Value) -> (a, a0) -> Value # liftToJSONList :: (a0 -> Value) -> ([a0] -> Value) -> [(a, a0)] -> Value # liftToEncoding :: (a0 -> Encoding) -> ([a0] -> Encoding) -> (a, a0) -> Encoding # liftToEncodingList :: (a0 -> Encoding) -> ([a0] -> Encoding) -> [(a, a0)] -> Encoding #
ToJSONKey k => ToJSON1 (Map k)
Instance details Defined in Data.Aeson.Types.ToJSON Methods liftToJSON :: (a -> Value) -> ([a] -> Value) -> Map k a -> Value # liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [Map k a] -> Value # liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> Map k a -> Encoding # liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [Map k a] -> Encoding #
ToJSONKey k => ToJSON1 (HashMap k)
Instance details Defined in Data.Aeson.Types.ToJSON Methods liftToJSON :: (a -> Value) -> ([a] -> Value) -> HashMap k a -> Value # liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [HashMap k a] -> Value # liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> HashMap k a -> Encoding # liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [HashMap k a] -> Encoding #
ToJSON1 (Proxy :: Type -> Type)
Instance details Defined in Data.Aeson.Types.ToJSON Methods liftToJSON :: (a -> Value) -> ([a] -> Value) -> Proxy a -> Value # liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [Proxy a] -> Value # liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> Proxy a -> Encoding # liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [Proxy a] -> Encoding #
(ToJSON a, ToJSON b) => ToJSON1 ((,,) a b)
Instance details Defined in Data.Aeson.Types.ToJSON Methods liftToJSON :: (a0 -> Value) -> ([a0] -> Value) -> (a, b, a0) -> Value # liftToJSONList :: (a0 -> Value) -> ([a0] -> Value) -> [(a, b, a0)] -> Value # liftToEncoding :: (a0 -> Encoding) -> ([a0] -> Encoding) -> (a, b, a0) -> Encoding # liftToEncodingList :: (a0 -> Encoding) -> ([a0] -> Encoding) -> [(a, b, a0)] -> Encoding #
ToJSON a => ToJSON1 (Const a :: Type -> Type)
Instance details Defined in Data.Aeson.Types.ToJSON Methods liftToJSON :: (a0 -> Value) -> ([a0] -> Value) -> Const a a0 -> Value # liftToJSONList :: (a0 -> Value) -> ([a0] -> Value) -> [Const a a0] -> Value # liftToEncoding :: (a0 -> Encoding) -> ([a0] -> Encoding) -> Const a a0 -> Encoding # liftToEncodingList :: (a0 -> Encoding) -> ([a0] -> Encoding) -> [Const a a0] -> Encoding #
ToJSON1 (Tagged a)
Instance details Defined in Data.Aeson.Types.ToJSON Methods liftToJSON :: (a0 -> Value) -> ([a0] -> Value) -> Tagged a a0 -> Value # liftToJSONList :: (a0 -> Value) -> ([a0] -> Value) -> [Tagged a a0] -> Value # liftToEncoding :: (a0 -> Encoding) -> ([a0] -> Encoding) -> Tagged a a0 -> Encoding # liftToEncodingList :: (a0 -> Encoding) -> ([a0] -> Encoding) -> [Tagged a a0] -> Encoding #
(ToJSON a, ToJSON b, ToJSON c) => ToJSON1 ((,,,) a b c)
Instance details Defined in Data.Aeson.Types.ToJSON Methods liftToJSON :: (a0 -> Value) -> ([a0] -> Value) -> (a, b, c, a0) -> Value # liftToJSONList :: (a0 -> Value) -> ([a0] -> Value) -> [(a, b, c, a0)] -> Value # liftToEncoding :: (a0 -> Encoding) -> ([a0] -> Encoding) -> (a, b, c, a0) -> Encoding # liftToEncodingList :: (a0 -> Encoding) -> ([a0] -> Encoding) -> [(a, b, c, a0)] -> Encoding #
(ToJSON1 f, ToJSON1 g) => ToJSON1 (Product f g)
Instance details Defined in Data.Aeson.Types.ToJSON Methods liftToJSON :: (a -> Value) -> ([a] -> Value) -> Product f g a -> Value # liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [Product f g a] -> Value # liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> Product f g a -> Encoding # liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [Product f g a] -> Encoding #
(ToJSON1 f, ToJSON1 g) => ToJSON1 (Sum f g)
Instance details Defined in Data.Aeson.Types.ToJSON Methods liftToJSON :: (a -> Value) -> ([a] -> Value) -> Sum f g a -> Value # liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [Sum f g a] -> Value # liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> Sum f g a -> Encoding # liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [Sum f g a] -> Encoding #
(ToJSON a, ToJSON b, ToJSON c, ToJSON d) => ToJSON1 ((,,,,) a b c d)
Instance details Defined in Data.Aeson.Types.ToJSON Methods liftToJSON :: (a0 -> Value) -> ([a0] -> Value) -> (a, b, c, d, a0) -> Value # liftToJSONList :: (a0 -> Value) -> ([a0] -> Value) -> [(a, b, c, d, a0)] -> Value # liftToEncoding :: (a0 -> Encoding) -> ([a0] -> Encoding) -> (a, b, c, d, a0) -> Encoding # liftToEncodingList :: (a0 -> Encoding) -> ([a0] -> Encoding) -> [(a, b, c, d, a0)] -> Encoding #
(ToJSON1 f, ToJSON1 g) => ToJSON1 (Compose f g)
Instance details Defined in Data.Aeson.Types.ToJSON Methods liftToJSON :: (a -> Value) -> ([a] -> Value) -> Compose f g a -> Value # liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [Compose f g a] -> Value # liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> Compose f g a -> Encoding # liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [Compose f g a] -> Encoding #
(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e) => ToJSON1 ((,,,,,) a b c d e)
Instance details Defined in Data.Aeson.Types.ToJSON Methods liftToJSON :: (a0 -> Value) -> ([a0] -> Value) -> (a, b, c, d, e, a0) -> Value # liftToJSONList :: (a0 -> Value) -> ([a0] -> Value) -> [(a, b, c, d, e, a0)] -> Value # liftToEncoding :: (a0 -> Encoding) -> ([a0] -> Encoding) -> (a, b, c, d, e, a0) -> Encoding # liftToEncodingList :: (a0 -> Encoding) -> ([a0] -> Encoding) -> [(a, b, c, d, e, a0)] -> Encoding #
(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e, ToJSON f) => ToJSON1 ((,,,,,,) a b c d e f)
Instance details Defined in Data.Aeson.Types.ToJSON Methods liftToJSON :: (a0 -> Value) -> ([a0] -> Value) -> (a, b, c, d, e, f, a0) -> Value # liftToJSONList :: (a0 -> Value) -> ([a0] -> Value) -> [(a, b, c, d, e, f, a0)] -> Value # liftToEncoding :: (a0 -> Encoding) -> ([a0] -> Encoding) -> (a, b, c, d, e, f, a0) -> Encoding # liftToEncodingList :: (a0 -> Encoding) -> ([a0] -> Encoding) -> [(a, b, c, d, e, f, a0)] -> Encoding #
(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e, ToJSON f, ToJSON g) => ToJSON1 ((,,,,,,,) a b c d e f g)
Instance details Defined in Data.Aeson.Types.ToJSON Methods liftToJSON :: (a0 -> Value) -> ([a0] -> Value) -> (a, b, c, d, e, f, g, a0) -> Value # liftToJSONList :: (a0 -> Value) -> ([a0] -> Value) -> [(a, b, c, d, e, f, g, a0)] -> Value # liftToEncoding :: (a0 -> Encoding) -> ([a0] -> Encoding) -> (a, b, c, d, e, f, g, a0) -> Encoding # liftToEncodingList :: (a0 -> Encoding) -> ([a0] -> Encoding) -> [(a, b, c, d, e, f, g, a0)] -> Encoding #
(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e, ToJSON f, ToJSON g, ToJSON h) => ToJSON1 ((,,,,,,,,) a b c d e f g h)
Instance details Defined in Data.Aeson.Types.ToJSON Methods liftToJSON :: (a0 -> Value) -> ([a0] -> Value) -> (a, b, c, d, e, f, g, h, a0) -> Value # liftToJSONList :: (a0 -> Value) -> ([a0] -> Value) -> [(a, b, c, d, e, f, g, h, a0)] -> Value # liftToEncoding :: (a0 -> Encoding) -> ([a0] -> Encoding) -> (a, b, c, d, e, f, g, h, a0) -> Encoding # liftToEncodingList :: (a0 -> Encoding) -> ([a0] -> Encoding) -> [(a, b, c, d, e, f, g, h, a0)] -> Encoding #
(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e, ToJSON f, ToJSON g, ToJSON h, ToJSON i) => ToJSON1 ((,,,,,,,,,) a b c d e f g h i)
Instance details Defined in Data.Aeson.Types.ToJSON Methods liftToJSON :: (a0 -> Value) -> ([a0] -> Value) -> (a, b, c, d, e, f, g, h, i, a0) -> Value # liftToJSONList :: (a0 -> Value) -> ([a0] -> Value) -> [(a, b, c, d, e, f, g, h, i, a0)] -> Value # liftToEncoding :: (a0 -> Encoding) -> ([a0] -> Encoding) -> (a, b, c, d, e, f, g, h, i, a0) -> Encoding # liftToEncodingList :: (a0 -> Encoding) -> ([a0] -> Encoding) -> [(a, b, c, d, e, f, g, h, i, a0)] -> Encoding #
(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e, ToJSON f, ToJSON g, ToJSON h, ToJSON i, ToJSON j) => ToJSON1 ((,,,,,,,,,,) a b c d e f g h i j)
Instance details Defined in Data.Aeson.Types.ToJSON Methods liftToJSON :: (a0 -> Value) -> ([a0] -> Value) -> (a, b, c, d, e, f, g, h, i, j, a0) -> Value # liftToJSONList :: (a0 -> Value) -> ([a0] -> Value) -> [(a, b, c, d, e, f, g, h, i, j, a0)] -> Value # liftToEncoding :: (a0 -> Encoding) -> ([a0] -> Encoding) -> (a, b, c, d, e, f, g, h, i, j, a0) -> Encoding # liftToEncodingList :: (a0 -> Encoding) -> ([a0] -> Encoding) -> [(a, b, c, d, e, f, g, h, i, j, a0)] -> Encoding #
(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e, ToJSON f, ToJSON g, ToJSON h, ToJSON i, ToJSON j, ToJSON k) => ToJSON1 ((,,,,,,,,,,,) a b c d e f g h i j k)
Instance details Defined in Data.Aeson.Types.ToJSON Methods liftToJSON :: (a0 -> Value) -> ([a0] -> Value) -> (a, b, c, d, e, f, g, h, i, j, k, a0) -> Value # liftToJSONList :: (a0 -> Value) -> ([a0] -> Value) -> [(a, b, c, d, e, f, g, h, i, j, k, a0)] -> Value # liftToEncoding :: (a0 -> Encoding) -> ([a0] -> Encoding) -> (a, b, c, d, e, f, g, h, i, j, k, a0) -> Encoding # liftToEncodingList :: (a0 -> Encoding) -> ([a0] -> Encoding) -> [(a, b, c, d, e, f, g, h, i, j, k, a0)] -> Encoding #
(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e, ToJSON f, ToJSON g, ToJSON h, ToJSON i, ToJSON j, ToJSON k, ToJSON l) => ToJSON1 ((,,,,,,,,,,,,) a b c d e f g h i j k l)
Instance details Defined in Data.Aeson.Types.ToJSON Methods liftToJSON :: (a0 -> Value) -> ([a0] -> Value) -> (a, b, c, d, e, f, g, h, i, j, k, l, a0) -> Value # liftToJSONList :: (a0 -> Value) -> ([a0] -> Value) -> [(a, b, c, d, e, f, g, h, i, j, k, l, a0)] -> Value # liftToEncoding :: (a0 -> Encoding) -> ([a0] -> Encoding) -> (a, b, c, d, e, f, g, h, i, j, k, l, a0) -> Encoding # liftToEncodingList :: (a0 -> Encoding) -> ([a0] -> Encoding) -> [(a, b, c, d, e, f, g, h, i, j, k, l, a0)] -> Encoding #
(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e, ToJSON f, ToJSON g, ToJSON h, ToJSON i, ToJSON j, ToJSON k, ToJSON l, ToJSON m) => ToJSON1 ((,,,,,,,,,,,,,) a b c d e f g h i j k l m)
Instance details Defined in Data.Aeson.Types.ToJSON Methods liftToJSON :: (a0 -> Value) -> ([a0] -> Value) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, a0) -> Value # liftToJSONList :: (a0 -> Value) -> ([a0] -> Value) -> [(a, b, c, d, e, f, g, h, i, j, k, l, m, a0)] -> Value # liftToEncoding :: (a0 -> Encoding) -> ([a0] -> Encoding) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, a0) -> Encoding # liftToEncodingList :: (a0 -> Encoding) -> ([a0] -> Encoding) -> [(a, b, c, d, e, f, g, h, i, j, k, l, m, a0)] -> Encoding #
(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e, ToJSON f, ToJSON g, ToJSON h, ToJSON i, ToJSON j, ToJSON k, ToJSON l, ToJSON m, ToJSON n) => ToJSON1 ((,,,,,,,,,,,,,,) a b c d e f g h i j k l m n)
Instance details Defined in Data.Aeson.Types.ToJSON Methods liftToJSON :: (a0 -> Value) -> ([a0] -> Value) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, a0) -> Value # liftToJSONList :: (a0 -> Value) -> ([a0] -> Value) -> [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, a0)] -> Value # liftToEncoding :: (a0 -> Encoding) -> ([a0] -> Encoding) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, a0) -> Encoding # liftToEncodingList :: (a0 -> Encoding) -> ([a0] -> Encoding) -> [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, a0)] -> Encoding #

ToJSON2 Either
Instance details Defined in Data.Aeson.Types.ToJSON Methods liftToJSON2 :: (a -> Value) -> ([a] -> Value) -> (b -> Value) -> ([b] -> Value) -> Either a b -> Value # liftToJSONList2 :: (a -> Value) -> ([a] -> Value) -> (b -> Value) -> ([b] -> Value) -> [Either a b] -> Value # liftToEncoding2 :: (a -> Encoding) -> ([a] -> Encoding) -> (b -> Encoding) -> ([b] -> Encoding) -> Either a b -> Encoding # liftToEncodingList2 :: (a -> Encoding) -> ([a] -> Encoding) -> (b -> Encoding) -> ([b] -> Encoding) -> [Either a b] -> Encoding #
ToJSON2 (,)
Instance details Defined in Data.Aeson.Types.ToJSON Methods liftToJSON2 :: (a -> Value) -> ([a] -> Value) -> (b -> Value) -> ([b] -> Value) -> (a, b) -> Value # liftToJSONList2 :: (a -> Value) -> ([a] -> Value) -> (b -> Value) -> ([b] -> Value) -> [(a, b)] -> Value # liftToEncoding2 :: (a -> Encoding) -> ([a] -> Encoding) -> (b -> Encoding) -> ([b] -> Encoding) -> (a, b) -> Encoding # liftToEncodingList2 :: (a -> Encoding) -> ([a] -> Encoding) -> (b -> Encoding) -> ([b] -> Encoding) -> [(a, b)] -> Encoding #
ToJSON a => ToJSON2 ((,,) a)
Instance details Defined in Data.Aeson.Types.ToJSON Methods liftToJSON2 :: (a0 -> Value) -> ([a0] -> Value) -> (b -> Value) -> ([b] -> Value) -> (a, a0, b) -> Value # liftToJSONList2 :: (a0 -> Value) -> ([a0] -> Value) -> (b -> Value) -> ([b] -> Value) -> [(a, a0, b)] -> Value # liftToEncoding2 :: (a0 -> Encoding) -> ([a0] -> Encoding) -> (b -> Encoding) -> ([b] -> Encoding) -> (a, a0, b) -> Encoding # liftToEncodingList2 :: (a0 -> Encoding) -> ([a0] -> Encoding) -> (b -> Encoding) -> ([b] -> Encoding) -> [(a, a0, b)] -> Encoding #
ToJSON2 (Const :: Type -> Type -> Type)
Instance details Defined in Data.Aeson.Types.ToJSON Methods liftToJSON2 :: (a -> Value) -> ([a] -> Value) -> (b -> Value) -> ([b] -> Value) -> Const a b -> Value # liftToJSONList2 :: (a -> Value) -> ([a] -> Value) -> (b -> Value) -> ([b] -> Value) -> [Const a b] -> Value # liftToEncoding2 :: (a -> Encoding) -> ([a] -> Encoding) -> (b -> Encoding) -> ([b] -> Encoding) -> Const a b -> Encoding # liftToEncodingList2 :: (a -> Encoding) -> ([a] -> Encoding) -> (b -> Encoding) -> ([b] -> Encoding) -> [Const a b] -> Encoding #
ToJSON2 (Tagged :: Type -> Type -> Type)
Instance details Defined in Data.Aeson.Types.ToJSON Methods liftToJSON2 :: (a -> Value) -> ([a] -> Value) -> (b -> Value) -> ([b] -> Value) -> Tagged a b -> Value # liftToJSONList2 :: (a -> Value) -> ([a] -> Value) -> (b -> Value) -> ([b] -> Value) -> [Tagged a b] -> Value # liftToEncoding2 :: (a -> Encoding) -> ([a] -> Encoding) -> (b -> Encoding) -> ([b] -> Encoding) -> Tagged a b -> Encoding # liftToEncodingList2 :: (a -> Encoding) -> ([a] -> Encoding) -> (b -> Encoding) -> ([b] -> Encoding) -> [Tagged a b] -> Encoding #
(ToJSON a, ToJSON b) => ToJSON2 ((,,,) a b)
Instance details Defined in Data.Aeson.Types.ToJSON Methods liftToJSON2 :: (a0 -> Value) -> ([a0] -> Value) -> (b0 -> Value) -> ([b0] -> Value) -> (a, b, a0, b0) -> Value # liftToJSONList2 :: (a0 -> Value) -> ([a0] -> Value) -> (b0 -> Value) -> ([b0] -> Value) -> [(a, b, a0, b0)] -> Value # liftToEncoding2 :: (a0 -> Encoding) -> ([a0] -> Encoding) -> (b0 -> Encoding) -> ([b0] -> Encoding) -> (a, b, a0, b0) -> Encoding # liftToEncodingList2 :: (a0 -> Encoding) -> ([a0] -> Encoding) -> (b0 -> Encoding) -> ([b0] -> Encoding) -> [(a, b, a0, b0)] -> Encoding #
(ToJSON a, ToJSON b, ToJSON c) => ToJSON2 ((,,,,) a b c)
Instance details Defined in Data.Aeson.Types.ToJSON Methods liftToJSON2 :: (a0 -> Value) -> ([a0] -> Value) -> (b0 -> Value) -> ([b0] -> Value) -> (a, b, c, a0, b0) -> Value # liftToJSONList2 :: (a0 -> Value) -> ([a0] -> Value) -> (b0 -> Value) -> ([b0] -> Value) -> [(a, b, c, a0, b0)] -> Value # liftToEncoding2 :: (a0 -> Encoding) -> ([a0] -> Encoding) -> (b0 -> Encoding) -> ([b0] -> Encoding) -> (a, b, c, a0, b0) -> Encoding # liftToEncodingList2 :: (a0 -> Encoding) -> ([a0] -> Encoding) -> (b0 -> Encoding) -> ([b0] -> Encoding) -> [(a, b, c, a0, b0)] -> Encoding #
(ToJSON a, ToJSON b, ToJSON c, ToJSON d) => ToJSON2 ((,,,,,) a b c d)
Instance details Defined in Data.Aeson.Types.ToJSON Methods liftToJSON2 :: (a0 -> Value) -> ([a0] -> Value) -> (b0 -> Value) -> ([b0] -> Value) -> (a, b, c, d, a0, b0) -> Value # liftToJSONList2 :: (a0 -> Value) -> ([a0] -> Value) -> (b0 -> Value) -> ([b0] -> Value) -> [(a, b, c, d, a0, b0)] -> Value # liftToEncoding2 :: (a0 -> Encoding) -> ([a0] -> Encoding) -> (b0 -> Encoding) -> ([b0] -> Encoding) -> (a, b, c, d, a0, b0) -> Encoding # liftToEncodingList2 :: (a0 -> Encoding) -> ([a0] -> Encoding) -> (b0 -> Encoding) -> ([b0] -> Encoding) -> [(a, b, c, d, a0, b0)] -> Encoding #
(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e) => ToJSON2 ((,,,,,,) a b c d e)
Instance details Defined in Data.Aeson.Types.ToJSON Methods liftToJSON2 :: (a0 -> Value) -> ([a0] -> Value) -> (b0 -> Value) -> ([b0] -> Value) -> (a, b, c, d, e, a0, b0) -> Value # liftToJSONList2 :: (a0 -> Value) -> ([a0] -> Value) -> (b0 -> Value) -> ([b0] -> Value) -> [(a, b, c, d, e, a0, b0)] -> Value # liftToEncoding2 :: (a0 -> Encoding) -> ([a0] -> Encoding) -> (b0 -> Encoding) -> ([b0] -> Encoding) -> (a, b, c, d, e, a0, b0) -> Encoding # liftToEncodingList2 :: (a0 -> Encoding) -> ([a0] -> Encoding) -> (b0 -> Encoding) -> ([b0] -> Encoding) -> [(a, b, c, d, e, a0, b0)] -> Encoding #
(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e, ToJSON f) => ToJSON2 ((,,,,,,,) a b c d e f)
Instance details Defined in Data.Aeson.Types.ToJSON Methods liftToJSON2 :: (a0 -> Value) -> ([a0] -> Value) -> (b0 -> Value) -> ([b0] -> Value) -> (a, b, c, d, e, f, a0, b0) -> Value # liftToJSONList2 :: (a0 -> Value) -> ([a0] -> Value) -> (b0 -> Value) -> ([b0] -> Value) -> [(a, b, c, d, e, f, a0, b0)] -> Value # liftToEncoding2 :: (a0 -> Encoding) -> ([a0] -> Encoding) -> (b0 -> Encoding) -> ([b0] -> Encoding) -> (a, b, c, d, e, f, a0, b0) -> Encoding # liftToEncodingList2 :: (a0 -> Encoding) -> ([a0] -> Encoding) -> (b0 -> Encoding) -> ([b0] -> Encoding) -> [(a, b, c, d, e, f, a0, b0)] -> Encoding #
(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e, ToJSON f, ToJSON g) => ToJSON2 ((,,,,,,,,) a b c d e f g)
Instance details Defined in Data.Aeson.Types.ToJSON Methods liftToJSON2 :: (a0 -> Value) -> ([a0] -> Value) -> (b0 -> Value) -> ([b0] -> Value) -> (a, b, c, d, e, f, g, a0, b0) -> Value # liftToJSONList2 :: (a0 -> Value) -> ([a0] -> Value) -> (b0 -> Value) -> ([b0] -> Value) -> [(a, b, c, d, e, f, g, a0, b0)] -> Value # liftToEncoding2 :: (a0 -> Encoding) -> ([a0] -> Encoding) -> (b0 -> Encoding) -> ([b0] -> Encoding) -> (a, b, c, d, e, f, g, a0, b0) -> Encoding # liftToEncodingList2 :: (a0 -> Encoding) -> ([a0] -> Encoding) -> (b0 -> Encoding) -> ([b0] -> Encoding) -> [(a, b, c, d, e, f, g, a0, b0)] -> Encoding #
(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e, ToJSON f, ToJSON g, ToJSON h) => ToJSON2 ((,,,,,,,,,) a b c d e f g h)
Instance details Defined in Data.Aeson.Types.ToJSON Methods liftToJSON2 :: (a0 -> Value) -> ([a0] -> Value) -> (b0 -> Value) -> ([b0] -> Value) -> (a, b, c, d, e, f, g, h, a0, b0) -> Value # liftToJSONList2 :: (a0 -> Value) -> ([a0] -> Value) -> (b0 -> Value) -> ([b0] -> Value) -> [(a, b, c, d, e, f, g, h, a0, b0)] -> Value # liftToEncoding2 :: (a0 -> Encoding) -> ([a0] -> Encoding) -> (b0 -> Encoding) -> ([b0] -> Encoding) -> (a, b, c, d, e, f, g, h, a0, b0) -> Encoding # liftToEncodingList2 :: (a0 -> Encoding) -> ([a0] -> Encoding) -> (b0 -> Encoding) -> ([b0] -> Encoding) -> [(a, b, c, d, e, f, g, h, a0, b0)] -> Encoding #
(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e, ToJSON f, ToJSON g, ToJSON h, ToJSON i) => ToJSON2 ((,,,,,,,,,,) a b c d e f g h i)
Instance details Defined in Data.Aeson.Types.ToJSON Methods liftToJSON2 :: (a0 -> Value) -> ([a0] -> Value) -> (b0 -> Value) -> ([b0] -> Value) -> (a, b, c, d, e, f, g, h, i, a0, b0) -> Value # liftToJSONList2 :: (a0 -> Value) -> ([a0] -> Value) -> (b0 -> Value) -> ([b0] -> Value) -> [(a, b, c, d, e, f, g, h, i, a0, b0)] -> Value # liftToEncoding2 :: (a0 -> Encoding) -> ([a0] -> Encoding) -> (b0 -> Encoding) -> ([b0] -> Encoding) -> (a, b, c, d, e, f, g, h, i, a0, b0) -> Encoding # liftToEncodingList2 :: (a0 -> Encoding) -> ([a0] -> Encoding) -> (b0 -> Encoding) -> ([b0] -> Encoding) -> [(a, b, c, d, e, f, g, h, i, a0, b0)] -> Encoding #
(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e, ToJSON f, ToJSON g, ToJSON h, ToJSON i, ToJSON j) => ToJSON2 ((,,,,,,,,,,,) a b c d e f g h i j)
Instance details Defined in Data.Aeson.Types.ToJSON Methods liftToJSON2 :: (a0 -> Value) -> ([a0] -> Value) -> (b0 -> Value) -> ([b0] -> Value) -> (a, b, c, d, e, f, g, h, i, j, a0, b0) -> Value # liftToJSONList2 :: (a0 -> Value) -> ([a0] -> Value) -> (b0 -> Value) -> ([b0] -> Value) -> [(a, b, c, d, e, f, g, h, i, j, a0, b0)] -> Value # liftToEncoding2 :: (a0 -> Encoding) -> ([a0] -> Encoding) -> (b0 -> Encoding) -> ([b0] -> Encoding) -> (a, b, c, d, e, f, g, h, i, j, a0, b0) -> Encoding # liftToEncodingList2 :: (a0 -> Encoding) -> ([a0] -> Encoding) -> (b0 -> Encoding) -> ([b0] -> Encoding) -> [(a, b, c, d, e, f, g, h, i, j, a0, b0)] -> Encoding #
(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e, ToJSON f, ToJSON g, ToJSON h, ToJSON i, ToJSON j, ToJSON k) => ToJSON2 ((,,,,,,,,,,,,) a b c d e f g h i j k)
Instance details Defined in Data.Aeson.Types.ToJSON Methods liftToJSON2 :: (a0 -> Value) -> ([a0] -> Value) -> (b0 -> Value) -> ([b0] -> Value) -> (a, b, c, d, e, f, g, h, i, j, k, a0, b0) -> Value # liftToJSONList2 :: (a0 -> Value) -> ([a0] -> Value) -> (b0 -> Value) -> ([b0] -> Value) -> [(a, b, c, d, e, f, g, h, i, j, k, a0, b0)] -> Value # liftToEncoding2 :: (a0 -> Encoding) -> ([a0] -> Encoding) -> (b0 -> Encoding) -> ([b0] -> Encoding) -> (a, b, c, d, e, f, g, h, i, j, k, a0, b0) -> Encoding # liftToEncodingList2 :: (a0 -> Encoding) -> ([a0] -> Encoding) -> (b0 -> Encoding) -> ([b0] -> Encoding) -> [(a, b, c, d, e, f, g, h, i, j, k, a0, b0)] -> Encoding #
(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e, ToJSON f, ToJSON g, ToJSON h, ToJSON i, ToJSON j, ToJSON k, ToJSON l) => ToJSON2 ((,,,,,,,,,,,,,) a b c d e f g h i j k l)
Instance details Defined in Data.Aeson.Types.ToJSON Methods liftToJSON2 :: (a0 -> Value) -> ([a0] -> Value) -> (b0 -> Value) -> ([b0] -> Value) -> (a, b, c, d, e, f, g, h, i, j, k, l, a0, b0) -> Value # liftToJSONList2 :: (a0 -> Value) -> ([a0] -> Value) -> (b0 -> Value) -> ([b0] -> Value) -> [(a, b, c, d, e, f, g, h, i, j, k, l, a0, b0)] -> Value # liftToEncoding2 :: (a0 -> Encoding) -> ([a0] -> Encoding) -> (b0 -> Encoding) -> ([b0] -> Encoding) -> (a, b, c, d, e, f, g, h, i, j, k, l, a0, b0) -> Encoding # liftToEncodingList2 :: (a0 -> Encoding) -> ([a0] -> Encoding) -> (b0 -> Encoding) -> ([b0] -> Encoding) -> [(a, b, c, d, e, f, g, h, i, j, k, l, a0, b0)] -> Encoding #
(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e, ToJSON f, ToJSON g, ToJSON h, ToJSON i, ToJSON j, ToJSON k, ToJSON l, ToJSON m) => ToJSON2 ((,,,,,,,,,,,,,,) a b c d e f g h i j k l m)
Instance details Defined in Data.Aeson.Types.ToJSON Methods liftToJSON2 :: (a0 -> Value) -> ([a0] -> Value) -> (b0 -> Value) -> ([b0] -> Value) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, a0, b0) -> Value # liftToJSONList2 :: (a0 -> Value) -> ([a0] -> Value) -> (b0 -> Value) -> ([b0] -> Value) -> [(a, b, c, d, e, f, g, h, i, j, k, l, m, a0, b0)] -> Value # liftToEncoding2 :: (a0 -> Encoding) -> ([a0] -> Encoding) -> (b0 -> Encoding) -> ([b0] -> Encoding) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, a0, b0) -> Encoding # liftToEncodingList2 :: (a0 -> Encoding) -> ([a0] -> Encoding) -> (b0 -> Encoding) -> ([b0] -> Encoding) -> [(a, b, c, d, e, f, g, h, i, j, k, l, m, a0, b0)] -> Encoding #

Semigroup Series
Instance details Defined in Data.Aeson.Encoding.Internal Methods (<>) :: Series -> Series -> Series # sconcat :: NonEmpty Series -> Series # stimes :: Integral b => b -> Series -> Series #
Monoid Series
Instance details Defined in Data.Aeson.Encoding.Internal Methods mempty :: Series # mappend :: Series -> Series -> Series # mconcat :: [Series] -> Series #
KeyValue Series
Instance details Defined in Data.Aeson.Types.ToJSON Methods (.=) :: ToJSON v => Text -> v -> Series #
e ~ Encoding => KeyValuePair e Series
Instance details Defined in Data.Aeson.Types.ToJSON Methods pair :: String -> e -> Series
a ~ Value => FromPairs (Encoding' a) Series
Instance details Defined in Data.Aeson.Types.ToJSON Methods fromPairs :: Series -> Encoding' a