-- Hoogle documentation, generated by Haddock -- See Hoogle, http://www.haskell.org/hoogle/ -- | Common functionality for Amazonka library test-suites. -- -- Common functionality depended upon by test suites of the various -- amazonka-* service libraries. -- -- The external interface of this library is stable with respect to the -- downstream Amazonka libraries, only, and as such is not suitable for -- use in non-Amazonka projects. @package amazonka-test @version 2.0 module Test.Amazonka.Diff -- | Display the difference between two Haskell values, with control over -- the diff parameters. diff :: (Show a, Show b) => a -> b -> IO String module Test.Amazonka.Orphans instance Data.Aeson.Types.FromJSON.FromJSON Data.ByteString.Internal.ByteString module Test.Amazonka.Assert assertDiff :: (Eq a, Show a) => String -> a -> Either String a -> Assertion module Test.Amazonka.TH mkTime :: Text -> Q Exp instance Language.Haskell.TH.Syntax.Lift (Amazonka.Data.Time.Time a) instance Language.Haskell.TH.Syntax.Lift Data.Time.Clock.Internal.UTCTime.UTCTime instance Language.Haskell.TH.Syntax.Lift Data.Time.Calendar.Days.Day instance Language.Haskell.TH.Syntax.Lift Data.Time.Clock.Internal.DiffTime.DiffTime module Test.Amazonka.Prelude -- | 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_. -- --

Examples

-- -- Basic usage: -- -- In the first two examples we show each evaluated action mapping to the -- output structure. -- --

--   >>> traverse Just [1,2,3,4]
--   Just [1,2,3,4]
--

-- --

--   >>> traverse id [Right 1, Right 2, Right 3, Right 4]
--   Right [1,2,3,4]
--

-- -- In the next examples, we show that Nothing and Left -- values short circuit the created structure. -- --

--   >>> traverse (const Nothing) [1,2,3,4]
--   Nothing
--

-- --

--   >>> traverse (\x -> if odd x then Just x else Nothing)  [1,2,3,4]
--   Nothing
--

-- --

--   >>> traverse id [Right 1, Right 2, Right 3, Right 4, Left 0]
--   Left 0
--

traverse :: (Traversable t, Applicative f) => (a -> f b) -> t a -> f (t b) -- | 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. class Profunctor p => Choice (p :: Type -> Type -> Type) -- |

--   type Optic' p f s a = Simple (Optic p f) s a
--

type Optic' (p :: k -> k1 -> Type) (f :: k -> k1) (s :: k) (a :: k) = Optic p f s s a a -- | 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 Fold s a = forall (f :: Type -> Type). (Contravariant f, Applicative 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 Getter s a = forall (f :: Type -> Type). (Contravariant f, Functor f) => a -> f a -> s -> f s -- | A Simple Prism. type Prism' s a = Prism s s a a -- | If you see this in a signature for a function, the function is -- expecting a Review (in practice, this usually means a -- Prism). type AReview t b = Optic' Tagged :: Type -> Type -> Type Identity t b -- |

--   type Iso' = Simple Iso
--

type Iso' s a = Iso 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 Setter' s a = Setter s s a a -- |

--   type IndexedTraversal' i = Simple (IndexedTraversal i)
--

type IndexedTraversal' i s a = IndexedTraversal i s s a a -- |

--   type Traversal' = Simple Traversal
--

type Traversal' s a = Traversal s s a a -- |

--   type Lens' = Simple Lens
--

type Lens' s a = Lens s s a a -- | 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 t a b = forall (f :: Type -> Type). Functor f => a -> f b -> s -> f t -- | Build a Setter, IndexedSetter or -- IndexPreservingSetter depending on your choice of -- Profunctor. -- --

--   sets :: ((a -> b) -> s -> t) -> 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 -- | 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
--

(%~) :: ASetter s t a b -> (a -> 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 -> 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 (Maybe b) -> b -> s -> t infixr 4 ?~ -- | Modify the target of a Semigroup value by using -- (<>). -- --

--   >>> (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!!!")
--

-- --

--   (<>~) :: Semigroup a => Setter s t a a    -> a -> s -> t
--   (<>~) :: Semigroup a => Iso s t a a       -> a -> s -> t
--   (<>~) :: Semigroup a => Lens s t a a      -> a -> s -> t
--   (<>~) :: Semigroup a => Traversal s t a a -> a -> s -> t
--

(<>~) :: Semigroup a => ASetter s t a a -> a -> s -> t infixr 4 <>~ -- | 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
--

lens :: (s -> a) -> (s -> b -> t) -> Lens s t a b -- | 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 Getting r s a = a -> Const r a -> s -> Const r s -- | 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
--

to :: (Profunctor p, Contravariant f) => (s -> a) -> Optic' p f s 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
--

view :: MonadReader s m => Getting a s a -> m a -- | 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
--

(^.) :: s -> Getting a s a -> a infixl 8 ^. -- | Turn a Getter around to get a Review -- --

--   un = unto . view
--   unto = un . to
--

-- --

--   >>> un (to length) # [1,2,3]
--   3
--

un :: (Profunctor p, Bifunctor p, Functor f) => Getting a s a -> Optic' p f a s -- | 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
--

(#) :: AReview t b -> b -> t infixr 8 # -- | Build a Prism. -- -- Either t a is used instead of Maybe a -- to permit the types of s and t to differ. prism :: (b -> t) -> (s -> Either t a) -> Prism s t 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
--

_Just :: Prism (Maybe a) (Maybe b) a b -- | 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]
--

folding :: Foldable f => (s -> f a) -> Fold s 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. filtered :: (Choice p, Applicative f) => (a -> Bool) -> Optic' p f a a -- | 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]
--

(^..) :: s -> Getting (Endo [a]) s a -> [a] infixl 8 ^.. -- | 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
--

anyOf :: Getting Any 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
--

allOf :: Getting All s a -> (a -> Bool) -> s -> Bool -- | 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]
--

concatOf :: Getting [r] s [r] -> s -> [r] -- | 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
--

(^?) :: s -> Getting (First a) s a -> Maybe a infixl 8 ^? -- | 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
--

has :: Getting Any s a -> s -> Bool -- | Traverse any Traversable container. This is an -- IndexedTraversal that is indexed by ordinal position. traversed :: forall (f :: Type -> Type) a b. Traversable f => IndexedTraversal Int (f a) (f b) 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
--

iso :: (s -> a) -> (b -> t) -> Iso s t a b -- | This can be used to lift any Iso into an arbitrary -- Functor. mapping :: forall (f :: Type -> Type) (g :: Type -> Type) s t a b. (Functor f, Functor g) => AnIso s t a b -> Iso (f s) (g t) (f a) (g b) -- | 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: -- --

--   >>> Map.fromList [("hello",Map.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
--

non :: Eq a => a -> Iso' (Maybe a) a -- | Data types that are representationally equal are isomorphic. -- -- This is only available on GHC 7.8+ coerced :: forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b -- | 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
--

_last :: Snoc s s a a => Traversal' s a -- | Traverse the strongly typed Exception contained in -- SomeException where the type of your function matches the -- desired Exception. -- --

--   exception :: (Applicative f, Exception a)
--             => (a -> f a) -> SomeException -> f SomeException
--

exception :: Exception a => Prism' SomeException a -- | Catch exceptions that match a given ReifiedPrism (or any -- ReifiedFold, really). -- --

--   >>> catching _AssertionFailed (assert False (return "uncaught")) $ \ _ -> return "caught"
--   "caught"
--

-- --

--   catching :: MonadCatch m => Prism' SomeException a     -> m r -> (a -> m r) -> m r
--   catching :: MonadCatch m => Lens' SomeException a      -> m r -> (a -> m r) -> m r
--   catching :: MonadCatch m => Traversal' SomeException a -> m r -> (a -> m r) -> m r
--   catching :: MonadCatch m => Iso' SomeException a       -> m r -> (a -> m r) -> m r
--   catching :: MonadCatch m => ReifiedGetter SomeException a     -> m r -> (a -> m r) -> m r
--   catching :: MonadCatch m => ReifiedFold SomeException a       -> m r -> (a -> m r) -> m r
--

catching :: MonadCatch m => Getting (First a) SomeException a -> m r -> (a -> m r) -> m r -- | Catch exceptions that match a given ReifiedPrism (or any -- ReifiedGetter), discarding the information about the match. -- This is particularly useful when you have a Prism' e -- () where the result of the ReifiedPrism or -- ReifiedFold isn't particularly valuable, just the fact that it -- matches. -- --

--   >>> catching_ _AssertionFailed (assert False (return "uncaught")) $ return "caught"
--   "caught"
--

-- --

--   catching_ :: MonadCatch m => Prism' SomeException a     -> m r -> m r -> m r
--   catching_ :: MonadCatch m => Lens' SomeException a      -> m r -> m r -> m r
--   catching_ :: MonadCatch m => Traversal' SomeException a -> m r -> m r -> m r
--   catching_ :: MonadCatch m => Iso' SomeException a       -> m r -> m r -> m r
--   catching_ :: MonadCatch m => ReifiedGetter SomeException a     -> m r -> m r -> m r
--   catching_ :: MonadCatch m => ReifiedFold SomeException a       -> m r -> m r -> m r
--

catching_ :: MonadCatch m => Getting (First a) SomeException a -> m r -> m r -> m r -- | A variant of try that takes a ReifiedPrism (or any -- ReifiedFold) to select which exceptions are caught (c.f. -- tryJust, catchJust). If the Exception does not -- match the predicate, it is re-thrown. -- --

--   trying :: MonadCatch m => Prism'     SomeException a -> m r -> m (Either a r)
--   trying :: MonadCatch m => Lens'      SomeException a -> m r -> m (Either a r)
--   trying :: MonadCatch m => Traversal' SomeException a -> m r -> m (Either a r)
--   trying :: MonadCatch m => Iso'       SomeException a -> m r -> m (Either a r)
--   trying :: MonadCatch m => ReifiedGetter     SomeException a -> m r -> m (Either a r)
--   trying :: MonadCatch m => ReifiedFold       SomeException a -> m r -> m (Either a r)
--

trying :: MonadCatch m => Getting (First a) SomeException a -> m r -> m (Either a r) -- | A variant of throwing that can only be used within the -- IO Monad (or any other MonadCatch instance) to -- throw an Exception described by a ReifiedPrism. -- -- Although throwingM has a type that is a specialization of the -- type of throwing, the two functions are subtly different: -- --

--   throwing l e `seq` x  ≡ throwing e
--   throwingM l e `seq` x ≡ x
--

-- -- The first example will cause the Exception e to be -- raised, whereas the second one won't. In fact, throwingM will -- only cause an Exception to be raised when it is used within the -- MonadCatch instance. The throwingM variant should be -- used in preference to throwing to raise an Exception -- within the Monad because it guarantees ordering with respect to -- other monadic operations, whereas throwing does not. -- --

--   throwingM l ≡ reviews l throw
--

-- --

--   throwingM :: MonadThrow m => Prism' SomeException t -> t -> m r
--   throwingM :: MonadThrow m => Iso' SomeException t   -> t -> m r
--

throwingM :: MonadThrow m => AReview SomeException b -> b -> m r -- | Flipped version of <$>. -- --

--   (<&>) = flip fmap
--

-- --

Examples

-- -- 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
--

(<&>) :: Functor f => f a -> (a -> b) -> f b infixl 1 <&> -- | Unfortunately the name ioException is taken by base -- for throwing IOExceptions. -- --

--   _IOException :: Prism' IOException IOException
--   _IOException :: Prism' SomeException IOException
--

-- -- Many combinators for working with an IOException are available -- in System.IO.Error.Lens. _IOException :: AsIOException t => Prism' t IOException -- | 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'
--

_1 :: Field1 s t a b => 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
--

_2 :: Field2 s t a b => Lens s t a b -- | Create a named group of test cases or other groups testGroup :: TestName -> [TestTree] -> TestTree -- | The main data structure defining a test suite. -- -- It consists of individual test cases and properties, organized in -- named groups which form a tree-like hierarchy. -- -- There is no generic way to create a test case. Instead, every test -- provider (tasty-hunit, tasty-smallcheck etc.) provides a function to -- turn a test case into a TestTree. -- -- Groups can be created using testGroup. data TestTree -- | Turn an Assertion into a tasty test case testCase :: TestName -> Assertion -> TestTree assertDiff :: (Eq a, Show a) => String -> a -> Either String a -> Assertion mkTime :: Text -> Q Exp module Test.Amazonka.Fixture res :: (AWSRequest a, Eq (AWSResponse a), Show (AWSResponse a)) => TestName -> FilePath -> Service -> Proxy a -> AWSResponse a -> TestTree req :: forall a. (AWSRequest a, Eq a, Show a) => TestName -> FilePath -> a -> TestTree testResponse :: forall a. AWSRequest a => Service -> Proxy a -> ByteStringLazy -> IO (Either String (AWSResponse a)) auth :: AuthEnv time :: UTCTime data Req Req :: Method -> ByteString -> ByteString -> [Header] -> ByteString -> Req [_method] :: Req -> Method [_path] :: Req -> ByteString [_query] :: Req -> ByteString [_headers] :: Req -> [Header] [_body] :: Req -> ByteString mkReq :: Method -> ByteString -> ByteString -> [Header] -> ByteString -> Req sortKeys :: Ord a => [(a, b)] -> [(a, b)] instance GHC.Generics.Generic Test.Amazonka.Fixture.Req instance GHC.Show.Show Test.Amazonka.Fixture.Req instance GHC.Classes.Eq Test.Amazonka.Fixture.Req instance Data.Aeson.Types.FromJSON.FromJSON Test.Amazonka.Fixture.Req