lens 3.7.6 → 3.8

raw patch · 112 files changed

+14454/−8010 lines, 112 filesdep +MonadCatchIO-transformersdep +base-orphansdep +bifunctorsdep ~basedep ~comonaddep ~comonads-fdPVP ok

version bump matches the API change (PVP)

Dependencies added: MonadCatchIO-transformers, base-orphans, bifunctors, contravariant, distributive, profunctor-extras, profunctors, semigroupoids, tagged

Dependency ranges changed: base, comonad, comonads-fd, containers, generic-deriving, nats, semigroups, template-haskell, transformers, transformers-compat

API changes (from Hackage documentation)

Files

• .gitignore +4/−0
• .travis.yml +6/−4
• AUTHORS.markdown +45/−0
• CHANGELOG.markdown +73/−12
• LICENSE +1/−1
• README.markdown +32/−30
• benchmarks/plated.hs +0/−1
• benchmarks/unsafe.hs +4/−4
• benchmarks/zipper.hs +45/−0
• config +0/−16
• examples/Aeson.hs +6/−6
• examples/Brainfuck.hs +50/−44
• examples/BrainfuckFinal.hs +129/−0
• examples/Plates.hs +1/−1
• examples/Pong.hs +2/−2
• examples/Turtle.hs +6/−6
• examples/bf-examples/triangle.bf +33/−33
• examples/lens-examples.cabal +17/−4
• lens.cabal +129/−98
• src/Control/Exception/Lens.hs +828/−8
• src/Control/Lens.hs +23/−23
• src/Control/Lens/Action.hs +111/−33
• src/Control/Lens/At.hs +552/−0
• src/Control/Lens/Classes.hs +0/−192
• src/Control/Lens/Combinators.hs +38/−25
• src/Control/Lens/Cons.hs +444/−0
• src/Control/Lens/Each.hs +175/−73
• src/Control/Lens/Equality.hs +76/−0
• src/Control/Lens/Fold.hs +2112/−1187
• src/Control/Lens/Getter.hs +298/−231
• src/Control/Lens/Indexed.hs +635/−53
• src/Control/Lens/IndexedFold.hs +0/−464
• src/Control/Lens/IndexedGetter.hs +0/−75
• src/Control/Lens/IndexedLens.hs +0/−182
• src/Control/Lens/IndexedSetter.hs +0/−152
• src/Control/Lens/IndexedTraversal.hs +0/−408
• src/Control/Lens/Internal.hs +33/−557
• src/Control/Lens/Internal/Action.hs +99/−0
• src/Control/Lens/Internal/Bazaar.hs +182/−0
• src/Control/Lens/Internal/ByteString.hs +216/−0
• src/Control/Lens/Internal/Combinators.hs +0/−231
• src/Control/Lens/Internal/Context.hs +353/−0
• src/Control/Lens/Internal/Deque.hs +200/−0
• src/Control/Lens/Internal/Fold.hs +203/−0
• src/Control/Lens/Internal/Getter.hs +97/−0
• src/Control/Lens/Internal/Indexed.hs +319/−0
• src/Control/Lens/Internal/Instances.hs +51/−0
• src/Control/Lens/Internal/Iso.hs +47/−0
• src/Control/Lens/Internal/Level.hs +167/−0
• src/Control/Lens/Internal/Magma.hs +247/−0
• src/Control/Lens/Internal/Prism.hs +65/−0
• src/Control/Lens/Internal/Review.hs +176/−0
• src/Control/Lens/Internal/Setter.hs +132/−0
• src/Control/Lens/Internal/Zipper.hs +524/−166
• src/Control/Lens/Internal/Zoom.hs +292/−0
• src/Control/Lens/Iso.hs +150/−64
• src/Control/Lens/Lens.hs +930/−0
• src/Control/Lens/Level.hs +113/−0
• src/Control/Lens/Loupe.hs +24/−161
• src/Control/Lens/Operators.hs +106/−0
• src/Control/Lens/Plated.hs +146/−94
• src/Control/Lens/Prism.hs +99/−255
• src/Control/Lens/Reified.hs +92/−0
• src/Control/Lens/Representable.hs +0/−320
• src/Control/Lens/Review.hs +185/−0
• src/Control/Lens/Setter.hs +561/−327
• src/Control/Lens/Simple.hs +56/−23
• src/Control/Lens/TH.hs +316/−135
• src/Control/Lens/Traversal.hs +626/−223
• src/Control/Lens/Tuple.hs +91/−80
• src/Control/Lens/Type.hs +368/−583
• src/Control/Lens/WithIndex.hs +0/−497
• src/Control/Lens/Wrapped.hs +84/−23
• src/Control/Lens/Zipper.hs +25/−15
• src/Control/Lens/Zoom.hs +64/−62
• src/Control/Monad/Error/Lens.hs +144/−0
• src/Control/Parallel/Strategies/Lens.hs +7/−7
• src/Control/Seq/Lens.hs +2/−2
• src/Data/Array/Lens.hs +7/−37
• src/Data/Bits/Lens.hs +76/−54
• src/Data/ByteString/Lazy/Lens.hs +17/−16
• src/Data/ByteString/Lens.hs +13/−14
• src/Data/ByteString/Strict/Lens.hs +20/−15
• src/Data/Complex/Lens.hs +23/−38
• src/Data/Data/Lens.hs +40/−38
• src/Data/Dynamic/Lens.hs +28/−11
• src/Data/HashSet/Lens.hs +14/−14
• src/Data/IntSet/Lens.hs +11/−8
• src/Data/List/Lens.hs +6/−149
• src/Data/List/Split/Lens.hs +23/−21
• src/Data/Sequence/Lens.hs +15/−101
• src/Data/Set/Lens.hs +15/−11
• src/Data/Text/Lazy/Lens.hs +16/−5
• src/Data/Text/Lens.hs +17/−5
• src/Data/Text/Strict/Lens.hs +20/−7
• src/Data/Tree/Lens.hs +3/−3
• src/Data/Typeable/Lens.hs +5/−5
• src/Data/Vector/Generic/Lens.hs +52/−80
• src/Data/Vector/Lens.hs +41/−67
• src/GHC/Generics/Lens.hs +16/−8
• src/Language/Haskell/TH/Lens.hs +9/−10
• src/Numeric/Lens.hs +86/−0
• src/System/Exit/Lens.hs +65/−0
• src/System/FilePath/Lens.hs +19/−19
• src/System/IO/Error/Lens.hs +93/−0
• tests/doctests.hs +0/−30
• tests/doctests.hsc +71/−0
• tests/hunit.hs +21/−9
• tests/properties.hs +99/−40
• tests/templates.hs +14/−2
• travis/cabal-apt-install +16/−0
• travis/config +16/−0

@@ -7,3 +7,7 @@ .DS_Store .*.swp .*.swo+*.o+*.hi+*~+*#

@@ -1,17 +1,19 @@ language: haskell before_install:   # Uncomment whenever hackage is down.-  # - mkdir -p ~/.cabal && cp config ~/.cabal/config && cabal update+  # - mkdir -p ~/.cabal && cp travis/config ~/.cabal/config && cabal update    # Try installing some of the build-deps with apt-get for speed.-  - ./travis-cabal-apt-install --only-dependencies --force-reinstall $mode+  - travis/cabal-apt-install --only-dependencies --force-reinstall $mode +  - sudo apt-get -q -y install hlint || cabal install hlint+ install:-  - cabal configure $mode+  - cabal configure -flib-Werror $mode   - cabal build  script:-  - $script+  - $script && hlint src --cpp-define HLINT  notifications:   irc:

@@ -0,0 +1,45 @@+Lens started as a one man project by++* [Edward Kmett](mailto:ekmett@gmail.com) [@ekmett](https://github.com/ekmett)++But it has been greatly enriched by opening it up to community development.++Many people have contributed patches, documentation, wiki pages, bug reports, test cases and massive quantities of code to `lens` including (among others):++* [Shachaf Ben-Kiki](mailto:shachaf@gmail.com) [@shachaf](https://github.com/shachaf)+* Elliott Hird [@ehird](https://github.com/ehird)+* [Johan Kiviniemi](mailto:lens@johan.kiviniemi.name) [@ion1](https://github.com/ion1)+* [Bas Dirks](mailto:ik@basdirks.eu) [@basdirks](https://github.com/basdirks)+* [Eric Mertens](mailto:emertens@gmail.com) [@glguy](https://github.com/glguy)+* [Michael Sloan](mailto:mgsloan@gmail.com) [@mgsloan](https://github.com/mgsloan)+* [Alexander Altman](mailto:alexanderaltman@me.com) [@phtariensflame](https://github.com/phtariensflame)+* [Austin Seipp](mailto:mad.one@gmail.com) [@thoughtpolice](https://github.com/thoughtpolice)+* [Dag Odenhall](mailto:dag.odenhall@gmail.com) [@dag](https://github.com/dag)+* [Aristid Breitkreuz](mailto:aristidb+lens@gmail.com) [@aristidb](https://github.com/aristidb)+* [Simon Hengel](mailto:sol@typeful.net) [@sol](https://github.com/sol)+* [@startling](https://github.com/startling)+* [Mike Ledger](mailto:eleventynine@gmail.com) [@mikeplus64](https://github.com/mikeplus64)+* `nand` [@nandykins](https://github.com/nandykins)+* [Adrian Keet](mailto:arkeet@gmail.com) [@arkeet](https://github.com/arkeet)+* [Matvey B. Aksenov](mailto:matvey.aksenov@gmail.com) [@supki](https://github.com/supki)+* [Eyal Lotem](mailto:eyal.lotem+github@gmail.com) [@Peaker](https://github.com/Peaker)+* [Oliver Charles](mailto:ollie@ocharles.org.uk) [@ocharles](https://github.com/ocharles)+* Liyang HU [@liyang](https://github.com/liyang)+* [Carter Schonwald](mailto:carter.schonwald@gmail.com) [@cartazio](https://github.com/cartazio)+* [Mark Wright](mailto:gienah@gentoo.org) [@markwright](https://github.com/markwright)+* [Nathan van Doorn](mailto:nvd1234@gmail.com) [@Taneb](https://github.com/Taneb)+* Ville Tirronen [@aleator](https://github.com/aleator)+* [Mikhail Vorozhtsov](mailto:mikhail.vorozhtsov@gmail.com) [@mvv](https://github.com/mvv)+* [Brent Yorgey](mailto:byorgey@gmail.com) [@byorgey](https://github.com/byorgey)+* [Dan Rosén](mailto:danr@fripost.org) [@danr](https://github.com/danr)+* Yair Chuchem [@yairchu](https://github.com/yairchu)+* [Michael Thompson](mailto:what_is_it_to_do_anything@yahoo.com) [@michaelt](https://github.com/michaelt)+* [John Wiegley](mailto:johnw@newartisans.com) [@jwiegley](https://github.com/jwiegley)++You can watch them carry on the quest for bragging rights in the [contributors graph](https://github.com/ekmett/lens/graphs/contributors).++Omission from this list is by no means an attempt to discount your contributions!++Thank you for all of your help!++-Edward Kmett

@@ -1,14 +1,73 @@-3.7.6 [maintenance release]-------* Fixed an issue with the `Complex` `Each` instance.--3.7.5 [maintenance release]-------* Fixed an errant `LANGUAGE` pragma--3.7.4 [maintenance release]-------* Backported the API for `ALens` and `ALens'` to support `snap` builds on old platforms.+3.8+---+* Overall:+  * Replaced each of the different `SimpleFoo` type aliases with `Foo'` throughout. The various `Simple` aliases can still be found in `Control.Lens.Simple` but are now deprecated.+  * Made sweeping changes to `Iso` and `Prism` and `Indexed` lenses internally. They are now based on `profunctors`. This affects how you use `indexed` in the resulting code and dramatically changed the meaning of `Overloaded`.+  * Generalized combinators to pass through indices unmodified wherever possible and added indexed variants to existing combinators. There are hundreds of these changes and they would swamp this list.+* `Control.Exception.Lens`+  * This module was created to add combinators and prisms that make it possible to work with GHC's extensible exceptions and monad transformer stacks more easily. There are knock-on changes in `Data.Dynamic.Lens`, `System.Exit.Lens`, and `System.IO.Error.Lens`.+* `Control.Lens.At`+  * Moved `At(at)` and `Contains(contains)` and factored out `Ixed(ix)`.+  * Deprecated `_at` and `resultAt`.+  * Removed various `ordinal` and `ix` combinators, which are subsumed by `Ixed(ix)`.+* `Control.Lens.Cons`+  * Consoldiated the various `_head`, `_tail`, `_init` and `_last` traversals that were scattered around the place into a pair of `Cons` and `Snoc` classes that provide `_Cons` and `_Snoc` prisms respectively, and combinators that build on top.+* `Control.Lens.Each`+  * Generalized the signature of `Each` to permit it to provide an `IndexedSetter` for `((->) e)`.+  * `Each` now uses an `Index` type family that is shared with `At`, `Ixed` and `Contains` to indicate these operations are related.+* `Control.Lens.Equality`+  * Added as a stronger form of `Iso` that can be used to safely cast.+  * Added the adverb `simply`, which can be used to simplify the types of most combinators in the library so they only take a simple lens, simple traversal, etc as their first argument instead. e.g. `simply view` forces `a ~ b`, `s ~ t` in the argument to `view`.+* `Control.Lens.Fold`+  * Added `foldr1Of'` and `foldl1Of'`.+  * Added `has` and `hasn't`.+* `Control.Lens.Indexed`+  * The various indexed combinators for each type were distributed to their respective modules. This module grew to encompass the remaining index-specifics.+  * Added `index` and `indices`, and removed `iwhere` and `iwhereOf`. Use `itraversed.indices even` and `bar.indices (>3)` instead.+* `Control.Lens.Internal`+  * This module was exploded into more manageable component modules.+* `Control.Lens.Iso`+  * `Strict(strict)` is now a `Simple Iso`.+  * Added `magma` and `imagma` which can be used to provide a 'debugging view' of a `Traversal`.+* `Control.Lens.Lens`+  * Restructuring split this module out from `Control.Lens.Type` and merged the contents `Control.Lens.IndexedLens`.+* `Control.Lens.Level`+  * This module was created to provide the breadth-first-search Traversals `levels` and `ilevels` which can be used to do (optionally depth-limited) breadth-first searches through arbitrary traversals reaching all leaves at finite depth in finite time. To use these in full accordance with the laws you should restrict yourself to commutative operations and finite containers, but they are useful even in the absence of these properties.+* `Control.Lens.Loupe`+  * In the interest of consistency, the `Loupe` alias has been deprecated in favor of `ALens`.+  * `Loupe` (and `ALens`) are now defined in terms of `Pretext` rather than `Context`. This permits them to be cloned at a reduced cost reducing the call for `ReifiedLens`.+* `Control.Lens.Operators`+  * Added this module for users who insist on qualified use, but want access to the operators. They can `import qualified Control.Lens as Lens` and `import Control.Lens.Operators` unqualified.+* `Control.Lens.Prism`+  * Added `prism'` to construct `SimplePrism`s.+* `Control.Lens.Reified`+  * Consolidated the various `ReifiedFoo` definitions into one module.+* `Control.Lens.Representable`+  * This module was removed. Its functionality may be split out into a separate package, but currently the `linear` package exports is own `Linear.Core` module to provide this functionality. It was taking lots of useful names for little functionality and didn't feel like the rest of the API.+* `Control.Lens.Review`+  * This module now factors the `review` functionality out of `Prism` and exposes `unto`, which is to `review` what `to` is to `view`.+* `Control.Lens.Setter`+  * Added `contramapped` and `argument` for mapping over inputs.+* `Control.Lens.Simple`+  * Removed the infix lens aliases and repurposed the module to house the now deprecated `SimpleFoo` type aliases, which were replaced universally with `Foo'`.+* `Control.Lens.TH`+  * `makeLenses` now generates `Lens'` and `Traversal'` where appropriate+  * Added `makePrisms` as a generalized `makeIso` that automatically generates a `Prism` for each constructor. `makePrisms` generates names with an `_Foo` convention. This was consolidated upon throughout the library to reduce namespace conflicts between prisms and lenses.+  * Added `makeFields`, which generates classes for each individual field in a data type.+  * Added `makeWrapped`, which automatically generates a `Wrapped` instance for a newtype.+* `Control.Lens.Type`+  * This module was repurposed to provide a single home for all the standard lens-like type aliases used when producing lenses. You still need to go to their respective modules to find the types for consuming lens-likes if you want to generate your own lens combinators+* `Control.Lens.Wrapped`+  * Added `wrapped'` and `unwrapped'` for scenarios where you need the help with type inference.+* `Control.Lens.Zipper`+  * Converted `Zipper` to walk a magma based on the original structure and to use indices from indexed traversals when restoring from tape. This also means that when zipping around within a balanced structure with ascending keys `moveTo` can operate in logarithmic time, but required changing the `Zipper` type to add the index type.+* `Data.Bits.Lens`+  * Added `byteAt`.+* `Data.ByteString.Lens`+  * `Data.ByteString.Lazy.Lens` now uses `Int64`-based indexing.+  * The `Traversal` for strict `ByteStrings` now construct a balanced tree up to a given grain size. This permits zipper based seeking to operate in logarithmic time and speeds up many traversals.+* `Numeric.Lens`+  * Created. `base` shows and reads integers at base-2 through base-36. `integral` can be used as a safe `fromInteger`/`toInteger`.  3.7.3 [maintenance release] -----@@ -84,6 +143,7 @@ * Readded `leftmost` and `rightmost` due to the verbosity of `farthest leftward`/`farthest rightward`. * Added `preview`/`previews`/`firstOf` and deprecated `headOf`. * Added `iview`/`iviews`/`iuse`/`iuses` to `Control.Lens.IndexedGetter`.+* We've generalized the type of Bazaar and provided generalized variants of `partsOf`, etc. that used it.  3.6.0.4 [maintenance release] -------@@ -132,7 +192,7 @@ [3.5](https://github.com/ekmett/lens/issues?milestone=8&state=closed) --- * Fixed a potential SafeHaskell issue where a user could use `undefined` to derive `unsafeCoerce`. You now have to import an explicitly-  Unsafe module and create an instance of `Trustworthy` for your type to cause this behavior, so if you do, its on your head, not mine. :)+  Unsafe module and create an instance of `Trustworthy` for your type to cause this behavior, so if you do, it's on your head, not mine. :) * Renamed `EvilBazaar` to `BazaarT`. * Moved a lot of internals around. Most notably, `Gettable`, `Settable` and `Effective` have moved to `Control.Lens.Classes`. * Exposed `partsOf'` and `unsafePartsOf'` in `Control.Lens.Traversal` to reduce reliance on `BazaarT` in `Control.Lens.Zipper`@@ -172,6 +232,7 @@ * Fixed a bug that caused `resultAt` to give wrong answers most of the time. * Changed `resultAt` to an `IndexedLens` and moved it to `Control.Lens.IndexedLens` * Changed `ignored` to an `IndexedTraversal` and moved it to `Control.Lens.IndexedTraversal`+* We've relinquished the name `value`.  3.2 ---

@@ -1,4 +1,4 @@-Copyright 2012 Edward Kmett+Copyright 2012-2013 Edward Kmett  All rights reserved. 

@@ -1,10 +1,12 @@ Lens: Lenses, Folds, and Traversals ================================== -[![Build Status](https://secure.travis-ci.org/ekmett/lens.png?branch=master)](http://travis-ci.org/ekmett/lens)+[![Build Status](https://secure.travis-ci.org/ekmett/lens.png)](http://travis-ci.org/ekmett/lens)  This package provides families of [lenses](https://github.com/ekmett/lens/blob/master/src/Control/Lens/Type.hs), [isomorphisms](https://github.com/ekmett/lens/blob/master/src/Control/Lens/Iso.hs), [folds](https://github.com/ekmett/lens/blob/master/src/Control/Lens/Fold.hs), [traversals](https://github.com/ekmett/lens/blob/master/src/Control/Lens/Traversal.hs), [getters](https://github.com/ekmett/lens/blob/master/src/Control/Lens/Getter.hs) and [setters](https://github.com/ekmett/lens/blob/master/src/Control/Lens/Setter.hs). +If you are looking for where to get started, [a crash course video](http://youtu.be/cefnmjtAolY?hd=1) on how `lens` was constructed and how to use the basics is available on youtube. It is best watched in high definition to see the slides, but the [slides](http://comonad.com/haskell/Lenses-Folds-and-Traversals-NYC.pdf) are also available if you want to use them to follow along.+ The [FAQ](https://github.com/ekmett/lens/wiki/FAQ), which provides links to a large number of different resources for learning about lenses and an overview of the [derivation](https://github.com/ekmett/lens/wiki/Derivation) of these types can be found on the [Lens Wiki](https://github.com/ekmett/lens/wiki) along with a brief [overview](https://github.com/ekmett/lens/wiki/Overview) and some [examples](https://github.com/ekmett/lens/wiki/Examples).  Documentation is available through [github](http://ekmett.github.com/lens/frames.html) (for HEAD) or [hackage](http://hackage.haskell.org/package/lens) for the current and preceding releases.@@ -51,7 +53,7 @@ ("hello",(42,"!!!")) ``` -You can make a `Getter` out of a pure functions with `to`.+You can make a `Getter` out of a pure function with `to`.  ```haskell ghci> "hello"^.to length@@ -246,94 +248,94 @@   <td><a href="http://ekmett.github.com/lens/Control-Lens-Setter.html#v:-60-.-126-"><code>&lt;.~</code></a></td>   <td><a href="http://ekmett.github.com/lens/Control-Lens-Setter.html#v:.-61-"><code>.=</code></a></td>   <td><a href="http://ekmett.github.com/lens/Control-Lens-Setter.html#v:assign"><code>assign</code></a>,<a href="http://ekmett.github.com/lens/Control-Lens-Setter.html#v:-60-.-61-"><code>&lt;.=</code></a></td>-  <td>Replace target(s). <a href="http://ekmett.github.com/lens/Control-Lens-Type.html#v:-60--60-.-126-"><code>&lt;&lt;.~</code> and-      <a href="http://ekmett.github.com/lens/Control-Lens-Type.html#v:-60--60-.-61-"><code>&lt;&lt;.=</code></a>+  <td>Replace target(s). <a href="http://ekmett.github.com/lens/Control-Lens-Lens.html#v:-60--60-.-126-"><code>&lt;&lt;.~</code></a> and+      <a href="http://ekmett.github.com/lens/Control-Lens-Lens.html#v:-60--60-.-61-"><code>&lt;&lt;.=</code></a>       return the old value</td> </tr> <tr>   <td><a href="http://ekmett.github.com/lens/Control-Lens-Setter.html#v:over"><code>over</code></a>,<a href="http://ekmett.github.com/lens/Control-Lens-Setter.html#v:mapOf"><code>mapOf</code></a>,<a href="http://ekmett.github.com/lens/Control-Lens-Setter.html#v:-37--126-"><code>%~</code></a></td>-  <td><a href="http://ekmett.github.com/lens/Control-Lens-Type.html#v:-60--37--126-"><code>&lt;%~</code></td>+  <td><a href="http://ekmett.github.com/lens/Control-Lens-Lens.html#v:-60--37--126-"><code>&lt;%~</code></td>   <td><a href="http://ekmett.github.com/lens/Control-Lens-Setter.html#v:-37--61-"><code>%=</code></a></td>-  <td><a href="http://ekmett.github.com/lens/Control-Lens-Type.html#v:-60--37--61-"><code>&lt;%=</code></td>-  <td>Update target(s). <a href="http://ekmett.github.com/lens/Control-Lens-Type.html#v:-60--60--37--126-"><code>&lt;&lt;%~</code> and-      <a href="http://ekmett.github.com/lens/Control-Lens-Type.html#v:-60--60--37--61-"><code>&lt;&lt;%=</code></a>+  <td><a href="http://ekmett.github.com/lens/Control-Lens-Lens.html#v:-60--37--61-"><code>&lt;%=</code></td>+  <td>Update target(s). <a href="http://ekmett.github.com/lens/Control-Lens-Lens.html#v:-60--60--37--126-"><code>&lt;&lt;%~</code></a> and+      <a href="http://ekmett.github.com/lens/Control-Lens-Lens.html#v:-60--60--37--61-"><code>&lt;&lt;%=</code></a>       return the old value</td> </tr> <tr>-  <td><code>id</code>,<a href="http://ekmett.github.com/lens/Control-Lens-Traversal.html#v:traverseOf"><code>traverseOf</code></a>,<a href="http://ekmett.github.com/lens/Control-Lens-Type.html#v:-37--37--126-"><code>%%~</code></a></td>+  <td><code>id</code>,<a href="http://ekmett.github.com/lens/Control-Lens-Traversal.html#v:traverseOf"><code>traverseOf</code></a>,<a href="http://ekmett.github.com/lens/Control-Lens-Lens.html#v:-37--37--126-"><code>%%~</code></a></td>   <td/>-  <td><a href="http://ekmett.github.com/lens/Control-Lens-Type.html#v:-37--37--61-"><code>%%=</code></a></td>+  <td><a href="http://ekmett.github.com/lens/Control-Lens-Lens.html#v:-37--37--61-"><code>%%=</code></a></td>   <td/>   <td>Update target(s) with an <code>Applicative</code> or auxiliary result</td> </tr> <tr>   <td><a href="http://ekmett.github.com/lens/Control-Lens-Setter.html#v:-43--126-"><code>+~</code></a></td>-  <td><a href="http://ekmett.github.com/lens/Control-Lens-Type.html#v:-60--43--126-"><code>&lt;+~</code></td>+  <td><a href="http://ekmett.github.com/lens/Control-Lens-Lens.html#v:-60--43--126-"><code>&lt;+~</code></td>   <td><a href="http://ekmett.github.com/lens/Control-Lens-Setter.html#v:-43--61-"><code>+=</code></a></td>-  <td><a href="http://ekmett.github.com/lens/Control-Lens-Type.html#v:-60--43--61-"><code>&lt;+=</code></td>+  <td><a href="http://ekmett.github.com/lens/Control-Lens-Lens.html#v:-60--43--61-"><code>&lt;+=</code></td>   <td>Add to target(s)</td> </tr> <tr>   <td><a href="http://ekmett.github.com/lens/Control-Lens-Setter.html#v:-45--126-"><code>-~</code></a></td>-  <td><a href="http://ekmett.github.com/lens/Control-Lens-Type.html#v:-60--45--126-"><code>&lt;-~</code></td>+  <td><a href="http://ekmett.github.com/lens/Control-Lens-Lens.html#v:-60--45--126-"><code>&lt;-~</code></td>   <td><a href="http://ekmett.github.com/lens/Control-Lens-Setter.html#v:-45--61-"><code>-=</code></a></td>-  <td><a href="http://ekmett.github.com/lens/Control-Lens-Type.html#v:-60--45--61-"><code>&lt;-=</code></td>+  <td><a href="http://ekmett.github.com/lens/Control-Lens-Lens.html#v:-60--45--61-"><code>&lt;-=</code></td>   <td>Subtract from target(s)</td> </tr> <tr>   <td><a href="http://ekmett.github.com/lens/Control-Lens-Setter.html#v:-42--126-"><code>*~</code></a></td>-  <td><a href="http://ekmett.github.com/lens/Control-Lens-Type.html#v:-60--42--126-"><code>&lt;*~</code></td>+  <td><a href="http://ekmett.github.com/lens/Control-Lens-Lens.html#v:-60--42--126-"><code>&lt;*~</code></td>   <td><a href="http://ekmett.github.com/lens/Control-Lens-Setter.html#v:-42--61-"><code>*=</code></a></td>-  <td><a href="http://ekmett.github.com/lens/Control-Lens-Type.html#v:-60--42--61-"><code>&lt;*=</code></td>+  <td><a href="http://ekmett.github.com/lens/Control-Lens-Lens.html#v:-60--42--61-"><code>&lt;*=</code></td>   <td>Multiply target(s)</td> </tr> <tr>   <td><a href="http://ekmett.github.com/lens/Control-Lens-Setter.html#v:-47--47--126-"><code>//~</code></a></td>-  <td><a href="http://ekmett.github.com/lens/Control-Lens-Type.html#v:-60--47--47--126-"><code>&lt;//~</code></td>+  <td><a href="http://ekmett.github.com/lens/Control-Lens-Lens.html#v:-60--47--47--126-"><code>&lt;//~</code></td>   <td><a href="http://ekmett.github.com/lens/Control-Lens-Setter.html#v:-47--47--61-"><code>//=</code></a></td>-  <td><a href="http://ekmett.github.com/lens/Control-Lens-Type.html#v:-60--47--47--61-"><code>&lt;//=</code></td>+  <td><a href="http://ekmett.github.com/lens/Control-Lens-Lens.html#v:-60--47--47--61-"><code>&lt;//=</code></td>   <td>Divide target(s)</td> </tr> <tr>   <td><a href="http://ekmett.github.com/lens/Control-Lens-Setter.html#v:-94--126-"><code>^~</code></a></td>-  <td><a href="http://ekmett.github.com/lens/Control-Lens-Type.html#v:-60--94--126-"><code>&lt;^~</code></td>+  <td><a href="http://ekmett.github.com/lens/Control-Lens-Lens.html#v:-60--94--126-"><code>&lt;^~</code></td>   <td><a href="http://ekmett.github.com/lens/Control-Lens-Setter.html#v:-94--61-"><code>^=</code></a></td>-  <td><a href="http://ekmett.github.com/lens/Control-Lens-Type.html#v:-60--94--61-"><code>&lt;^=</code></td>+  <td><a href="http://ekmett.github.com/lens/Control-Lens-Lens.html#v:-60--94--61-"><code>&lt;^=</code></td>   <td>Raise target(s) to a non-negative <code>Integral</code> power</td> </tr> <tr>   <td><a href="http://ekmett.github.com/lens/Control-Lens-Setter.html#v:-94--94--126-"><code>^^~</code></a></td>-  <td><a href="http://ekmett.github.com/lens/Control-Lens-Type.html#v:-60--94--94--126-"><code>&lt;^^~</code></td>+  <td><a href="http://ekmett.github.com/lens/Control-Lens-Lens.html#v:-60--94--94--126-"><code>&lt;^^~</code></td>   <td><a href="http://ekmett.github.com/lens/Control-Lens-Setter.html#v:-94--94--61-"><code>^^=</code></a></td>-  <td><a href="http://ekmett.github.com/lens/Control-Lens-Type.html#v:-60--94--94--61-"><code>&lt;^^=</code></td>+  <td><a href="http://ekmett.github.com/lens/Control-Lens-Lens.html#v:-60--94--94--61-"><code>&lt;^^=</code></td>   <td>Raise target(s) to an <code>Integral</code> power</td> </tr> <tr>   <td><a href="http://ekmett.github.com/lens/Control-Lens-Setter.html#v:-42--42--126-"><code>**~</code></a></td>-  <td><a href="http://ekmett.github.com/lens/Control-Lens-Type.html#v:-60--42--42--126-"><code>&lt;**~</code></td>+  <td><a href="http://ekmett.github.com/lens/Control-Lens-Lens.html#v:-60--42--42--126-"><code>&lt;**~</code></td>   <td><a href="http://ekmett.github.com/lens/Control-Lens-Setter.html#v:-42--42--61-"><code>**=</code></a></td>-  <td><a href="http://ekmett.github.com/lens/Control-Lens-Type.html#v:-60--42--42--61-"><code>&lt;**=</code></td>+  <td><a href="http://ekmett.github.com/lens/Control-Lens-Lens.html#v:-60--42--42--61-"><code>&lt;**=</code></td>   <td>Raise target(s) to an arbitrary power</td> </tr> <tr>   <td><a href="http://ekmett.github.com/lens/Control-Lens-Setter.html#v:-124--124--126-"><code>||~</code></a></td>-  <td><a href="http://ekmett.github.com/lens/Control-Lens-Type.html#v:-60--124--124--126-"><code>&lt;||~</code></td>+  <td><a href="http://ekmett.github.com/lens/Control-Lens-Lens.html#v:-60--124--124--126-"><code>&lt;||~</code></td>   <td><a href="http://ekmett.github.com/lens/Control-Lens-Setter.html#v:-124--124--61-"><code>||=</code></a></td>-  <td><a href="http://ekmett.github.com/lens/Control-Lens-Type.html#v:-60--124--124--61-"><code>&lt;||=</code></td>+  <td><a href="http://ekmett.github.com/lens/Control-Lens-Lens.html#v:-60--124--124--61-"><code>&lt;||=</code></td>   <td>Logically or target(s)</td> </tr> <tr>   <td><a href="http://ekmett.github.com/lens/Control-Lens-Setter.html#v:-38--38--126-"><code>&amp;&amp;~</code></a></td>-  <td><a href="http://ekmett.github.com/lens/Control-Lens-Type.html#v:-60--38--38--126-"><code>&lt;&amp;&amp;~</code></td>+  <td><a href="http://ekmett.github.com/lens/Control-Lens-Lens.html#v:-60--38--38--126-"><code>&lt;&amp;&amp;~</code></td>   <td><a href="http://ekmett.github.com/lens/Control-Lens-Setter.html#v:-38--38--61-"><code>&amp;&amp;=</code></a></td>-  <td><a href="http://ekmett.github.com/lens/Control-Lens-Type.html#v:-60--38--38--61-"><code>&lt;&amp;&amp;=</code></td>+  <td><a href="http://ekmett.github.com/lens/Control-Lens-Lens.html#v:-60--38--38--61-"><code>&lt;&amp;&amp;=</code></td>   <td>Logically and target(s)</td> </tr> <tr>   <td><a href="http://ekmett.github.com/lens/Control-Lens-Setter.html#v:-60--62--126-"><code>&lt;&gt;~</code></a></td>-  <td><a href="http://ekmett.github.com/lens/Control-Lens-Type.html#v:-60--60--62--126-"><code>&lt;&lt;&gt;~</code></td>+  <td><a href="http://ekmett.github.com/lens/Control-Lens-Lens.html#v:-60--60--62--126-"><code>&lt;&lt;&gt;~</code></td>   <td><a href="http://ekmett.github.com/lens/Control-Lens-Setter.html#v:-60--62--61-"><code>&lt;&gt;=</code></a></td>-  <td><a href="http://ekmett.github.com/lens/Control-Lens-Type.html#v:-60--60--62--61-"><code>&lt;&lt;&gt;=</code></td>+  <td><a href="http://ekmett.github.com/lens/Control-Lens-Lens.html#v:-60--60--62--61-"><code>&lt;&lt;&gt;=</code></td>   <td><code>mappend</code> to the target monoidal value(s)</td> </tr> <tr>

@@ -1,6 +1,5 @@ {-# LANGUAGE CPP #-} {-# LANGUAGE Rank2Types #-}-{-# LANGUAGE TypeFamilies #-} {-# LANGUAGE DeriveDataTypeable, DeriveGeneric #-} {-# OPTIONS_GHC -funbox-strict-fields #-} import           Control.Applicative

@@ -10,19 +10,19 @@  import GHC.Exts -overS :: Setting s t a b -> (a -> b) -> s -> t+overS :: ASetter s t a b -> (a -> b) -> s -> t overS l f = runMutator . l (Mutator . f) {-# INLINE overS #-} -mappedS :: Setting [a] [b] a b+mappedS :: ASetter [a] [b] a b mappedS f = Mutator . map (runMutator . f) {-# INLINE mappedS #-} -overU :: Setting s t a b -> (a -> b) -> s -> t+overU :: ASetter s t a b -> (a -> b) -> s -> t overU = over {-# INLINE overU #-} -mappedU :: Setting [a] [b] a b+mappedU :: ASetter [a] [b] a b mappedU = mapped {-# INLINE mappedU #-} 

@@ -0,0 +1,45 @@+module Main+       ( main -- :: IO ()+       ) where++import Control.Lens+import Criterion.Main++main :: IO ()+main = defaultMain+  [ bgroup "rezip"+      [ bench "rezip"             $ nf tugAndRezip1 ['a'..'z']+      , bench "farthest leftward" $ nf tugAndRezip2 ['a'..'z']+      , bench "leftmost"          $ nf tugAndRezip3 ['a'..'z']+      , bench "tugTo"             $ nf tugAndRezip4 ['a'..'z']+      ]+  , bgroup "zipper creation"+      [ bench "over traverse id"  $ nf (over traverse id) ['a'..'z']+      , bench "zipper"            $ nf zipTraverseRezip   ['a'..'z']+      ]+  , bgroup "downward"+      [ bench "downward _1"       $ nf downwardAndRezip1 (['a'..'z'],['z'..'a'])+      , bench "fromWithin"        $ nf downwardAndRezip2 (['a'..'z'],['z'..'a'])+      ]+  ]++-- What's the fastest rezip of all?+tugAndRezip1, tugAndRezip2, tugAndRezip3 :: String -> String+tugAndRezip1 xs = zipntugs 25 xs & focus .~ 'a' & rezip+tugAndRezip2 xs = zipntugs 25 xs & focus .~ 'b' & farthest leftward & rezip+tugAndRezip3 xs = zipntugs 25 xs & focus .~ 'c' & leftmost & rezip+tugAndRezip4 xs = zipntugs 25 xs & focus .~ 'd' & tugTo 0 & rezip++zipntugs i x = zipper x & fromWithin traverse & tugs rightward i++-- How fast is creating and destroying a zipper compared to+-- a regular traversal?+zipTraverseRezip x = zipper x & fromWithin traverse & rezip++-- is 'downward' any faster than the composition of traverse?+downwardAndRezip1 :: (String, String) -> (String, String)+downwardAndRezip1 xs =+  zipper xs & downward _1 & fromWithin traverse & focus .~ 'h' & rezip+downwardAndRezip2 :: (String, String) -> (String, String)+downwardAndRezip2 xs =+  zipper xs & fromWithin (_1.traverse) & focus .~ 'g' & rezip

@@ -1,16 +0,0 @@--- This provides a custom ~/.cabal/config file for use when hackage is down that should work on unix------ This is particularly useful for travis-ci to get it to stop complaining--- about a broken build when everything is still correct on our end.------ This uses Luite Stegeman's mirror of hackage provided by his 'hdiff' site instead------ To enable this, uncomment the before_script in .travis.yml--remote-repo: hdiff.luite.com:http://hdiff.luite.com/packages/archive-remote-repo-cache: ~/.cabal/packages-world-file: ~/.cabal/world-build-summary: ~/.cabal/logs/build.log-remote-build-reporting: anonymous-install-dirs user-install-dirs global

@@ -14,12 +14,12 @@ import Data.ByteString.Lazy  -- |--- >>> 5^.by aeson+-- >>> review aeson 5 -- "5"--- >>> [1,2,3]^.by aeson+-- >>> [1,2,3]^.re aeson -- "[1,2,3]"--- >>> aeson.both +~ 2 $ (2,3)^.by aeson+-- >>> aeson.both +~ 2 $ (2,3)^.re aeson -- "[4,5]"-aeson, aeson' :: (FromJSON c, ToJSON d) => Projection ByteString ByteString c d-aeson  = projection encode decode-aeson' = projection encode decode'+aeson, aeson' :: (FromJSON a, ToJSON a) => Prism' ByteString a+aeson  = prism' encode decode+aeson' = prism' encode decode'

@@ -1,4 +1,6 @@ {-# LANGUAGE TypeOperators #-}+{-# LANGUAGE TemplateHaskell #-}+{-# LANGUAGE DeriveFunctor #-} ----------------------------------------------------------------------------- -- | -- Module      :  Brainfuck@@ -17,17 +19,19 @@  import Control.Lens import Control.Applicative-import Control.Monad.Free-import Control.Monad.RWS+import Control.Monad.State+import Control.Monad.Writer  import qualified Data.ByteString.Lazy as BS-import Data.Maybe (fromMaybe)-import qualified Data.Stream.Infinite as S+import Data.Maybe (fromMaybe, mapMaybe) import Data.Word (Word8)  import System.Environment (getArgs) import System.IO +-- | Brainfuck is defined to have a memory of 30000 cells.+memoryCellNum :: Int+memoryCellNum = 30000  -- Low level syntax form @@ -35,84 +39,86 @@ type Code = [Instr]  parse :: String -> Code-parse = concatMap (maybe [] return . (`lookup` symbols))+parse = mapMaybe (`lookup` symbols)   where symbols = [ ('+', Plus ), ('-', Minus), ('<', Left), ('>', Right)                   , (',', Comma), ('.', Dot  ), ('[', Open), (']', Close) ]  -- Higher level semantic graph -data Brainfuck n-  = Succ n | Pred n  -- Increment or decrement the current value-  | Next n | Prev n  -- Shift memory left or right-  | Read n | Write n -- Input or output the current value+data Program+  = Succ Program | Pred Program  -- Increment or decrement the current value+  | Next Program | Prev Program  -- Shift memory left or right+  | Read Program | Write Program -- Input or output the current value+  | Halt                         -- End execution    -- Branching semantic, used for both sides of loops-  | Branch { zero :: n, nonzero :: n }--type Program = Free Brainfuck ()+  | Branch { zero :: Program, nonzero :: Program }  compile :: Code -> Program compile = fst . bracket []  bracket :: [Program] -> Code -> (Program, [Program])-bracket [] []        = (Pure (), [])+bracket [] []        = (Halt, []) bracket _  []        = error "Mismatched opening bracket" bracket [] (Close:_) = error "Mismatched closing bracket"  -- Match a closing bracket: Pop a forward continuation, push backwards-bracket (c:cs) (Close : xs) = (Free (Branch n c), n:bs)+bracket (c:cs) (Close : xs) = (Branch n c, n:bs)   where (n, bs) = bracket cs xs  -- Match an opening bracket: Pop a backwards continuation, push forwards-bracket cs (Open : xs) = (Free (Branch b n), bs)+bracket cs (Open : xs) = (Branch b n, bs)   where (n, b:bs) = bracket (n:cs) xs  -- Match any other symbol in the trivial way-bracket cs (x:xs) = over _1 (Free . f x) (bracket cs xs)+bracket cs (x:xs) = over _1 (f x) (bracket cs xs)   where     f Plus  = Succ; f Minus = Pred     f Right = Next; f Left  = Prev     f Comma = Read; f Dot   = Write --- * RWS-based interpreter+-- * State/Writer-based interpreter  type Cell   = Word8-type Input  = S.Stream Cell+type Input  = [Cell] type Output = [Cell]-type Memory = Top :> [Cell] :> Cell -- list zipper+type Memory = Top :>> [Cell] :>> Cell -- list zipper -type Interpreter = RWS Input Output Memory ()+data MachineState = MachineState+  { _input  :: [Cell]+  , _memory :: Memory }+makeLenses ''MachineState +type Interpreter = StateT MachineState (Writer Output) ()+ -- | Initial memory configuration-initial :: Memory-initial = zipper (replicate 30000 0) & fromWithin traverse+initial :: Input -> MachineState+initial i = MachineState i (zipper (replicate memoryCellNum 0) & fromWithin traverse)  interpret :: Input -> Program -> Output-interpret i p = snd $ execRWS (run p) i initial+interpret i = execWriter . flip execStateT (initial i) . run  -- | Evaluation function run :: Program -> Interpreter-run (Pure _) = return ()-run (Free f) = case f of-  Succ n -> focus += 1       >> run n-  Pred n -> focus -= 1       >> run n-  Next n -> modify wrapRight >> run n-  Prev n -> modify wrapLeft  >> run n--  Read n -> do-    focus <~ asks S.head-    local S.tail $ run n--  Write n -> do-    tell . return =<< use focus-    run n--  Branch z n -> do-    c <- use focus-    run $ case c of 0 -> z; _ -> n+run Halt     = return ()+run (Succ n) = memory.focus += 1   >> run n+run (Pred n) = memory.focus -= 1   >> run n+run (Next n) = memory %= wrapRight >> run n+run (Prev n) = memory %= wrapLeft  >> run n+run (Read n) = do+  memory.focus <~ uses input head+  input %= tail+  run n+run (Write n) = do+  x <- use (memory.focus)+  tell [x]+  run n+run (Branch z n) = do+  c <- use (memory.focus)+  run $ if c == 0 then z else n  -- | Zipper helpers-wrapRight, wrapLeft :: (a :> b) -> (a :> b)+wrapRight, wrapLeft :: (a :>> b) -> (a :>> b) wrapRight = liftM2 fromMaybe leftmost rightward wrapLeft  = liftM2 fromMaybe rightmost leftward @@ -141,7 +147,7 @@ -- | EOF is represented as 0 getInput :: IO Input getInput = f <$> BS.getContents-  where f s = S.fromList (BS.unpack s ++ repeat 0)+  where f s = BS.unpack s ++ repeat 0  noInput :: Input-noInput = S.repeat 0+noInput = repeat 0

@@ -0,0 +1,129 @@+{-# LANGUAGE TypeOperators #-}+{-# LANGUAGE TemplateHaskell #-}+{-# LANGUAGE DeriveFunctor #-}+-----------------------------------------------------------------------------+-- |+-- Module      :  BrainfuckFinal+-- Copyright   :  (C) 2012 Edward Kmett, nand`+-- License     :  BSD-style (see the file LICENSE)+-- Maintainer  :  Edward Kmett <ekmett@gmail.com>+-- Stability   :  provisional+-- Portability :  TH, Rank2, NoMonomorphismRestriction+--+-- A simple interpreter for the esoteric programming language "Brainfuck"+-- written using lenses and zippers.+--+-- This version of the interpreter is 'finally encoded' without going through+-- an AST.+-----------------------------------------------------------------------------+module Main where++import Prelude hiding (Either(..))++import Control.Lens+import Control.Applicative+import Control.Monad.State+import Control.Monad.Writer++import qualified Data.ByteString.Lazy as BS+import Data.Maybe (fromMaybe, mapMaybe)+import Data.Word (Word8)++import System.Environment (getArgs)+import System.IO++-- | Brainfuck is defined to have a memory of 30000 cells.+memoryCellNum :: Int+memoryCellNum = 30000++-- * State/Writer-based interpreter++type Cell   = Word8+type Input  = [Cell]+type Output = [Cell]+type Memory = Top :>> [Cell] :>> Cell -- list zipper++data MachineState = MachineState+  { _input  :: [Cell]+  , _memory :: Memory }++makeLenses ''MachineState++type Program = StateT MachineState (Writer Output) ()++compile :: String -> Program+compile = fst . bracket []++branch :: Program -> Program -> Program+branch z n = do+  c <- use (memory.focus)+  if c == 0 then z else n++bracket :: [Program] -> String -> (Program, [Program])+bracket [] ""      = (return () , [])+bracket _  ""      = error "Mismatched opening bracket"+bracket [] (']':_) = error "Mismatched closing bracket"++-- Match a closing bracket: Pop a forward continuation, push backwards+bracket (c:cs) (']': xs) = (branch n c, n:bs) where+  (n, bs) = bracket cs xs++-- Match an opening bracket: Pop a backwards continuation, push forwards+bracket cs ('[': xs) = (branch b n, bs) where+  (n, b:bs) = bracket (n:cs) xs++-- Match any other symbol in the trivial way+bracket cs (x:xs) = over _1 (f x >>) (bracket cs xs) where+  f '+' = memory.focus += 1+  f '-' = memory.focus -= 1+  f '>' = memory %= wrapRight+  f '<' = memory %= wrapLeft+  f ',' = do+    memory.focus <~ uses input head+    input %= tail+  f '.' = do+    x <- use (memory.focus)+    tell [x]+  f _   = return ()++-- | Initial memory configuration+initial :: Input -> MachineState+initial i = MachineState i (zipper (replicate memoryCellNum 0) & fromWithin traverse)++interpret :: Input -> Program -> Output+interpret i = execWriter . flip execStateT (initial i)++-- | Zipper helpers+wrapRight, wrapLeft :: (a :>> b) -> (a :>> b)+wrapRight = liftM2 fromMaybe leftmost rightward+wrapLeft  = liftM2 fromMaybe rightmost leftward++-- Main program action to actually run this stuff++main :: IO ()+main = do+  as <- getArgs+  case as of+    -- STDIN is program+    [ ] -> do+      hSetBuffering stdin  NoBuffering+      hSetBuffering stdout NoBuffering+      getContents >>= eval noInput++    -- STDIN is input+    [f] -> join $ eval <$> getInput <*> readFile f++    -- Malformed command line+    _ -> putStrLn "Usage: brainfuck [program]"++eval :: Input -> String -> IO ()+eval i = mapM_ putByte . interpret i . compile+  where putByte = BS.putStr . BS.pack . return++-- | EOF is represented as 0+getInput :: IO Input+getInput = f <$> BS.getContents+  where f s = BS.unpack s ++ repeat 0++noInput :: Input+noInput = repeat 0

@@ -19,7 +19,7 @@   plate f (Sel xs) = pure (Sel xs)   plate f (Let x y) = pure (Let x y) -exprs :: Simple Traversal Stmt Expr+exprs :: Traversal' Stmt Expr exprs f (Seq xs)  = Seq <$> traverse (exprs f) xs exprs f (Sel xs)  = Sel <$> traverse f xs exprs f (Let x y) = Let x <$> f y

@@ -111,7 +111,7 @@   p <- get    let paddleMovement = time * paddleSpeed-      keyPressed key = p^.keys.contains (SpecialKey key)+      keyPressed key = p^.keys.ix (SpecialKey key)    -- Update the player's paddle based on keys   when (keyPressed KeyUp)   $ paddle1 += paddleMovement@@ -205,7 +205,7 @@ -- Handle input by simply updating the keys set  handle :: Event -> Pong -> Pong-handle (EventKey k s _ _) = keys.contains k .~ (s == Down)+handle (EventKey k s _ _) = keys.ix k .~ (s == Down) handle _ = id  -- The main program action

@@ -2,7 +2,7 @@ {-# LANGUAGE DeriveDataTypeable #-} -- | A simple Turtle-graphics demonstration for modeling the location of a turtle. ----- This is based on the code presented by Seth Tisue at the Boston Area Scala +-- This is based on the code presented by Seth Tisue at the Boston Area Scala -- Enthusiasts meeting during his lens talk. -- -- Usage:@@ -10,11 +10,11 @@ -- > def & forward 10 & down & color .~ red % turn (pi/2) & forward 5 module Turtle where -import Control.Lens hiding (up, down)+import Control.Lens import Data.Default  data Point = Point-  { _x, _y :: Double+  { __x, __y :: Double   } deriving (Eq,Show)  makeClassy ''Point@@ -23,7 +23,7 @@   def = Point def def  data Color = Color-  { _r, _g, _b :: Int+  { __r, __g, __b :: Int   } deriving (Eq,Show)  makeClassy ''Color@@ -54,8 +54,8 @@  forward :: Double -> Turtle -> Turtle forward d t =-  t & y +~ d * cos (t^.heading)-    & x +~ d * sin (t^.heading)+  t & _y +~ d * cos (t^.heading)+    & _x +~ d * sin (t^.heading)  turn :: Double -> Turtle -> Turtle turn d = heading +~ d

@@ -1,33 +1,33 @@-[ This program prints Sierpinski triangle on 80-column display. ]
-                                >    
-                               + +    
-                              +   +    
-                             [ < + +    
-                            +       +    
-                           + +     + +    
-                          >   -   ]   >    
-                         + + + + + + + +    
-                        [               >    
-                       + +             + +    
-                      <   -           ]   >    
-                     > + + >         > > + >    
-                    >       >       +       <    
-                   < <     < <     < <     < <    
-                  <   [   -   [   -   >   +   <    
-                 ] > [ - < + > > > . < < ] > > >    
-                [                               [    
-               - >                             + +    
-              +   +                           +   +    
-             + + [ >                         + + + +    
-            <       -                       ]       >    
-           . <     < [                     - >     + <    
-          ]   +   >   [                   -   >   +   +    
-         + + + + + + + +                 < < + > ] > . [    
-        -               ]               >               ]    
-       ] +             < <             < [             - [    
-      -   >           +   <           ]   +           >   [    
-     - < + >         > > - [         - > + <         ] + + >    
-    [       -       <       -       >       ]       <       <    
-   < ]     < <     < <     ] +     + +     + +     + +     + +    
-  +   .   +   +   +   .   [   -   ]   <   ]   +   +   +   +   +    
- * * * * * M a d e * B y : * N Y Y R I K K I * 2 0 0 2 * * * * *    
+[ This program prints Sierpinski triangle on 80-column display. ]+                                >+                               + ++                              +   ++                             [ < + ++                            +       ++                           + +     + ++                          >   -   ]   >+                         + + + + + + + ++                        [               >+                       + +             + ++                      <   -           ]   >+                     > + + >         > > + >+                    >       >       +       <+                   < <     < <     < <     < <+                  <   [   -   [   -   >   +   <+                 ] > [ - < + > > > . < < ] > > >+                [                               [+               - >                             + ++              +   +                           +   ++             + + [ >                         + + + ++            <       -                       ]       >+           . <     < [                     - >     + <+          ]   +   >   [                   -   >   +   ++         + + + + + + + +                 < < + > ] > . [+        -               ]               >               ]+       ] +             < <             < [             - [+      -   >           +   <           ]   +           >   [+     - < + >         > > - [         - > + <         ] + + >+    [       -       <       -       >       ]       <       <+   < ]     < <     < <     ] +     + +     + +     + +     + ++  +   .   +   +   +   .   [   -   ]   <   ]   +   +   +   +   ++ * * * * * M a d e * B y : * N Y Y R I K K I * 2 0 0 2 * * * * *

@@ -26,7 +26,7 @@ flag brainfuck   default: True -executable pong+executable lens-pong   if !flag(pong)     buildable: False @@ -39,15 +39,28 @@     random     == 1.0.*   main-is: Pong.hs -executable brainfuck+executable lens-brainfuck   if !flag(brainfuck)     buildable: False    build-depends:     base,     lens,-    free       >= 3.0 && < 3.3,+    free       >= 3.0,     bytestring,     mtl        >= 2.0.1 && < 2.2,-    streams    == 3.0.*+    streams    >= 3.0   main-is: Brainfuck.hs++executable lens-brainfuck-final+  if !flag(brainfuck)+    buildable: False++  build-depends:+    base,+    lens,+    free       >= 3.0,+    bytestring,+    mtl        >= 2.0.1 && < 2.2,+    streams    >= 3.0+  main-is: BrainfuckFinal.hs

@@ -1,6 +1,6 @@ name:          lens category:      Data, Lenses-version:       3.7.6+version:       3.8 license:       BSD3 cabal-version: >= 1.8 license-file:  LICENSE@@ -9,7 +9,9 @@ stability:     provisional homepage:      http://github.com/ekmett/lens/ bug-reports:   http://github.com/ekmett/lens/issues-copyright:     Copyright (C) 2012 Edward A. Kmett+copyright:     Copyright (C) 2012-2013 Edward A. Kmett+build-type:    Custom+tested-with:   GHC == 7.0.4, GHC == 7.4.1, GHC == 7.4.2, GHC == 7.6.1, GHC == 7.7.20121213, GHC == 7.7.20130117 synopsis:      Lenses, Folds and Traversals description:   This package comes \"Batteries Included\" with many useful lenses for the types@@ -20,26 +22,24 @@   families of getters, folds, isomorphisms, traversals, setters and lenses and their   indexed variants.   .-  An overview, with a large number of examples can be found in the README.-  .-  <https://github.com/ekmett/lens#lens-lenses-folds-and-traversals>+  An overview, with a large number of examples can be found in the @README@: <https://github.com/ekmett/lens#lens-lenses-folds-and-traversals>   .-  More information on the care and feeding of lenses, including a brief tutorial and motivation-  for their types can be found on the lens wiki.+  A video on how to use lenses and how they are constructed is available from youtube: <http://youtu.be/cefnmjtAolY?hd=1>   .-  <https://github.com/ekmett/lens/wiki>+  Slides can be obtained here: <http://comonad.com/haskell/Lenses-Folds-and-Traversals-NYC.pdf>   .-  A small game that manages its state using lenses can be found in the example folder.+  More information on the care and feeding of lenses, including a brief tutorial and motivation+  for their types can be found on the lens wiki: <https://github.com/ekmett/lens/wiki>   .-  <https://github.com/ekmett/lens/blob/master/examples/Pong.hs>+  A small game of @pong@ and other more complex examples that manage their state using lenses can be found in the example folder: <https://github.com/ekmett/lens/blob/master/examples/>   .   /Lenses, Folds and Traversals/   .-  The core of this hierarchy looks like:+  The core of the hierarchy of lens-like constructions looks like:   .-  <<http://i.imgur.com/FgfVW.png>>+  <<http://i.imgur.com/RFi75.png>>   .-  You can compose any two elements of the hierarchy above using (.) from the Prelude, and you can+  You can compose any two elements of the hierarchy above using @(.)@ from the @Prelude@, and you can   use any element of the hierarchy as any type it linked to above it.   .   The result is their lowest upper bound in the hierarchy (or an error if that bound doesn't exist).@@ -61,7 +61,7 @@   .   You can define lenses such as   .-  > -- bar :: Simple Lens (Foo a) Int+  > -- bar :: Lens' (Foo a) Int   > bar :: Functor f => (Int -> f Int) -> Foo a -> f (Foo a)   > bar f (Foo a b c) = fmap (\a' -> Foo a' b c) (f a)   .@@ -73,7 +73,7 @@   .   And you can define a traversal of multiple fields with 'Control.Applicative.Applicative':   .-  > -- traverseBarAndBaz :: Simple Traversal (Foo a) Int+  > -- traverseBarAndBaz :: Traversal' (Foo a) Int   > traverseBarAndBaz :: Applicative f => (Int -> f Int) -> Foo a -> f (Foo a)   > traverseBarAndBaz f (Foo a b c) = Foo <$> f a <*> f b <*> pure c   .@@ -81,19 +81,19 @@   common haskell types, a wide array of combinators for working them, and more   exotic functionality, (/e.g./ getters, setters, indexed folds, isomorphisms). -build-type:    Custom-tested-with:   GHC == 7.0.4, GHC == 7.4.1, GHC == 7.6.1 extra-source-files:   .travis.yml   .ghci   .gitignore   .vim.custom-  config   examples/LICENSE   examples/lens-examples.cabal   examples/*.hs   examples/*.lhs   examples/bf-examples/*.bf+  travis/cabal-apt-install+  travis/config+  AUTHORS.markdown   README.markdown   CHANGELOG.markdown @@ -109,15 +109,6 @@   default: False   manual: True --- Enable template haskell. Disable this at your own risk and for testing only.------ cabal configure -f-template-haskell is an /unsupported/ configuration.------ Clients of this library can and should expect this to be turned on.-flag template-haskell-  default: True-  manual: True- -- Generate inline pragmas when using template-haskell. This defaults to enabled, but you can -- -- > cabal install lens -f-inlining@@ -138,11 +129,17 @@   default: False   manual: True +-- You can disable the doctests test suite with -f-test-doctests+flag test-doctests+  default: True+  manual: True+ -- You can disable the hunit test suite with -f-test-hunit flag test-hunit   default: True   manual: True +-- Build the properties test if we're building tests flag test-properties   default: True   manual: True@@ -157,67 +154,94 @@   default: True   manual: True -flag old-semigroups+flag lib-Werror   default: False-  manual: False-+  manual: True  library   build-depends:-    base                 >= 4.3      && < 5,-    bytestring           >= 0.9.1.10 && < 0.11,-    comonad              >= 3,-    comonad-transformers >= 3,-    comonads-fd          >= 3,-    containers           >= 0.4.0    && < 0.6,-    hashable             >= 1.1.2.3  && < 1.3,-    mtl                  >= 2.0.1    && < 2.2,-    split                == 0.2.*,-    text                 >= 0.11     && < 0.12,-    transformers         >= 0.2      && < 0.4,-    transformers-compat  >= 0.1,-    unordered-containers >= 0.2      && < 0.3,-    vector               >= 0.9      && < 0.11--  if flag(old-semigroups)-    build-depends:-      semigroups >= 0.8.4 && < 0.9-  else-    build-depends:-      nats >= 0.1,-      semigroups >= 0.9+    array                     >= 0.3.0.2  && < 0.5,+    base                      >= 4.3      && < 5,+    bifunctors                >= 3        && < 4,+    bytestring                >= 0.9.1.10 && < 0.11,+    comonad                   >= 3        && < 4,+    comonad-transformers      >= 3        && < 4,+    comonads-fd               >= 3        && < 4,+    contravariant             >= 0.2.0.2,+    containers                >= 0.4.0    && < 0.6,+    distributive              >= 0.3,+    filepath                  >= 1.2.0.0  && < 1.4,+    generic-deriving          == 1.4.*,+    ghc-prim,+    hashable                  >= 1.1.2.3  && < 1.3,+    MonadCatchIO-transformers >= 0.3      && < 0.4,+    mtl                       >= 2.0.1    && < 2.2,+    parallel                  >= 3.1.0.1  && < 3.3,+    profunctors               >= 3.2      && < 4,+    profunctor-extras         >= 3.3      && < 4,+    semigroupoids             >= 3        && < 4,+    semigroups                >= 0.8.4    && < 1,+    split                     == 0.2.*,+    tagged                    >= 0.4.4    && < 1,+    template-haskell          >= 2.4      && < 2.10,+    text                      >= 0.11     && < 0.12,+    transformers              >= 0.2      && < 0.4,+    transformers-compat       >= 0.1      && < 1,+    unordered-containers      >= 0.2      && < 0.3,+    vector                    >= 0.9      && < 0.11    exposed-modules:     Control.Exception.Lens     Control.Lens     Control.Lens.Action-    Control.Lens.Classes+    Control.Lens.At     Control.Lens.Combinators+    Control.Lens.Cons     Control.Lens.Each+    Control.Lens.Equality     Control.Lens.Fold     Control.Lens.Getter     Control.Lens.Indexed-    Control.Lens.IndexedGetter-    Control.Lens.IndexedFold-    Control.Lens.IndexedLens-    Control.Lens.IndexedSetter-    Control.Lens.IndexedTraversal     Control.Lens.Internal+    Control.Lens.Internal.Action+    Control.Lens.Internal.Bazaar+    Control.Lens.Internal.ByteString+    Control.Lens.Internal.Context+    Control.Lens.Internal.Deque+    Control.Lens.Internal.Fold+    Control.Lens.Internal.Getter+    Control.Lens.Internal.Indexed+    Control.Lens.Internal.Instances+    Control.Lens.Internal.Iso+    Control.Lens.Internal.Level+    Control.Lens.Internal.Magma+    Control.Lens.Internal.Prism+    Control.Lens.Internal.Review+    Control.Lens.Internal.Setter     Control.Lens.Internal.Zipper+    Control.Lens.Internal.Zoom     Control.Lens.Iso+    Control.Lens.Lens+    Control.Lens.Level     Control.Lens.Loupe+    Control.Lens.Operators     Control.Lens.Plated     Control.Lens.Prism-    Control.Lens.Representable+    Control.Lens.Reified+    Control.Lens.Review     Control.Lens.Setter     Control.Lens.Simple+    Control.Lens.TH     Control.Lens.Traversal     Control.Lens.Tuple     Control.Lens.Type-    Control.Lens.WithIndex     Control.Lens.Wrapped     Control.Lens.Zipper     Control.Lens.Zoom+    Control.Monad.Error.Lens+    Control.Parallel.Strategies.Lens+    Control.Seq.Lens+    Data.Array.Lens     Data.Bits.Lens     Data.ByteString.Lens     Data.ByteString.Strict.Lens@@ -239,15 +263,11 @@     Data.Vector.Lens     Data.Vector.Generic.Lens     GHC.Generics.Lens--  other-modules:-    Control.Lens.Internal.Combinators--  if flag(template-haskell)-    build-depends: template-haskell >= 2.4 && < 2.9-    exposed-modules: Control.Lens.TH Language.Haskell.TH.Lens-  else-    cpp-options: -DDISABLE_TEMPLATE_HASKELL=1+    System.Exit.Lens+    System.FilePath.Lens+    System.IO.Error.Lens+    Language.Haskell.TH.Lens+    Numeric.Lens    if flag(safe)     cpp-options: -DSAFE=1@@ -258,30 +278,20 @@   if impl(ghc<7.4)     ghc-options: -fno-spec-constr-count -  -- platform-  build-depends:   array >= 0.3.0.2 && < 0.5-  exposed-modules: Data.Array.Lens--  build-depends:   filepath >= 1.2.0.0 && < 1.4-  exposed-modules: System.FilePath.Lens--  build-depends:   parallel >= 3.1.0.1 && < 3.3-  exposed-modules: Control.Parallel.Strategies.Lens Control.Seq.Lens-   if impl(ghc>=7.6.0.20120810)     if flag(old-inline-pragmas)       cpp-options: -DOLD_INLINE_PRAGMAS=1 -  if !flag(inlining)-    cpp-options: -DOMIT_INLINING=1+  if flag(inlining)+    cpp-options: -DINLINING    if impl(ghc>=7.2)     other-extensions: Trustworthy-    build-depends: ghc-prim     cpp-options: -DDEFAULT_SIGNATURES=1-  else-    build-depends: generic-deriving +  if flag(lib-Werror)+    ghc-options: -Werror+   ghc-options: -Wall -fwarn-tabs -O2 -fdicts-cheap -funbox-strict-fields   hs-source-dirs: src @@ -339,20 +349,25 @@ test-suite doctests   type:    exitcode-stdio-1.0   main-is: doctests.hs-  build-depends:-    base,-    bytestring,-    containers,-    directory >= 1.0,-    doctest >= 0.9.1,-    filepath,-    mtl,-    parallel,-    simple-reflect >= 0.3.1,-    split,-    text,-    unordered-containers,-    vector+  if !flag(test-doctests)+    buildable: False+  else+    build-depends:+      base,+      bytestring,+      containers,+      directory >= 1.0,+      deepseq,+      doctest >= 0.9.1,+      filepath,+      mtl,+      nats,+      parallel,+      simple-reflect >= 0.3.1,+      split,+      text,+      unordered-containers,+      vector   ghc-options: -Wall -threaded   if impl(ghc<7.6.1)     ghc-options: -Werror@@ -398,6 +413,22 @@ benchmark unsafe   type: exitcode-stdio-1.0   main-is: unsafe.hs+  build-depends:+    base,+    comonad,+    comonads-fd,+    criterion,+    deepseq,+    ghc-prim,+    lens,+    transformers+  ghc-options: -w -O2 -threaded -fdicts-cheap -funbox-strict-fields+  hs-source-dirs: benchmarks++-- Benchmarking zipper usage+benchmark zipper+  type: exitcode-stdio-1.0+  main-is: zipper.hs   build-depends:     base,     comonad,

@@ -1,36 +1,856 @@ {-# LANGUAGE CPP #-}-{-# LANGUAGE TypeFamilies #-}-{-# LANGUAGE FlexibleContexts #-}+{-# LANGUAGE Rank2Types #-}+{-# LANGUAGE PatternGuards #-}+{-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE ScopedTypeVariables #-}+{-# LANGUAGE MultiParamTypeClasses #-}+{-# LANGUAGE NoMonomorphismRestriction #-} #ifdef TRUSTWORTHY {-# LANGUAGE Trustworthy #-} #endif +#ifndef MIN_VERSION_base+#define MIN_VERSION_base(x,y,z) 1+#endif+ ----------------------------------------------------------------------------- -- | -- Module      :  Control.Exception.Lens--- Copyright   :  (C) 2012 Edward Kmett+-- Copyright   :  (C) 2012-13 Edward Kmett -- License     :  BSD-style (see the file LICENSE) -- Maintainer  :  Edward Kmett <ekmett@gmail.com> -- Stability   :  provisional -- Portability :  Control.Exception --+-- @Control.Exception@ provides an example of a large open hierarchy+-- that we can model with prisms and isomorphisms.+--+-- Additional combinators for working with 'IOException' results can+-- be found in "System.IO.Error.Lens".+--+-- The combinators in this module have been generalized to work with+-- 'MonadCatchIO' instead of just 'IO'. This enables them to be used+-- more easily in 'Monad' transformer stacks. ---------------------------------------------------------------------------- module Control.Exception.Lens-  ( exception+  (+  -- * Handling+    catching, catching_+  , handling, handling_+  -- * Trying+  , trying+  -- * Throwing+  , throwing+  , throwingM+  , throwingTo+  -- * Exceptions+  , exception+  -- ** IOExceptions+  , AsIOException(..)+  -- ** Arithmetic Exceptions+  , AsArithException(..)+  , _Overflow+  , _Underflow+  , _LossOfPrecision+  , _DivideByZero+  , _Denormal+#if MIN_VERSION_base(4,6,0)+  , _RatioZeroDenominator+#endif+  -- ** Array Exceptions+  , AsArrayException(..)+  , _IndexOutOfBounds+  , _UndefinedElement+  -- ** Assertion Failed+  , AsAssertionFailed(..)+  -- ** Async Exceptions+  , AsAsyncException(..)+  , _StackOverflow+  , _HeapOverflow+  , _ThreadKilled+  , _UserInterrupt+  -- ** Non-Termination+  , AsNonTermination(..)+  -- ** Nested Atomically+  , AsNestedAtomically(..)+  -- ** Blocked Indefinitely+  -- *** on MVar+  , AsBlockedIndefinitelyOnMVar(..)+  -- *** on STM+  , AsBlockedIndefinitelyOnSTM(..)+  -- ** Deadlock+  , AsDeadlock(..)+  -- ** No Such Method+  , AsNoMethodError(..)+  -- ** Pattern Match Failure+  , AsPatternMatchFail(..)+  -- ** Record+  , AsRecConError(..)+  , AsRecSelError(..)+  , AsRecUpdError(..)+  -- ** Error Call+  , AsErrorCall(..)   ) where -import Control.Exception+import Control.Applicative+import Control.Monad+import Control.Monad.IO.Class+import Control.Monad.CatchIO as CatchIO hiding (try, tryJust)+import Control.Exception as Exception hiding (try, tryJust, catchJust) import Control.Lens+import Data.Monoid+import GHC.Conc (ThreadId)+import Prelude+  ( asTypeOf, const, either, flip, id, maybe, undefined+  , ($), (.)+  ,  Maybe(..), Either(..), Functor(..), String+  ) --- |--- Traverse the strongly typed 'Exception' contained in 'SomeException' where the type of your function matches+{-# ANN module "HLint: ignore Use Control.Exception.catch" #-}++-- $setup+-- >>> :m + Control.Exception Control.Monad Data.List Prelude++------------------------------------------------------------------------------+-- Exceptions as Prisms+------------------------------------------------------------------------------++-- | Traverse the strongly typed 'Exception' contained in 'SomeException' where the type of your function matches -- the desired 'Exception'. -- -- @ -- exception :: ('Applicative' f, 'Exception' a, 'Exception' b) --           => (a -> f b) -> 'SomeException' -> f 'SomeException' -- @-exception :: Exception a => Simple Prism SomeException a+exception :: Exception a => Prism' SomeException a exception = prism toException $ \ e -> maybe (Left e) Right $ fromException e {-# INLINE exception #-}++------------------------------------------------------------------------------+-- Catching+------------------------------------------------------------------------------++-- | Catch exceptions that match a given 'Prism' (or any 'Getter', really).+--+-- >>> catching _AssertionFailed (assert False (return "uncaught")) $ \ _ -> return "caught"+-- "caught"+--+-- @+-- 'catching' :: 'MonadCatchIO' m => 'Prism'' 'SomeException' a     -> m r -> (a -> m r) -> m r+-- 'catching' :: 'MonadCatchIO' m => 'Lens'' 'SomeException' a      -> m r -> (a -> m r) -> m r+-- 'catching' :: 'MonadCatchIO' m => 'Traversal'' 'SomeException' a -> m r -> (a -> m r) -> m r+-- 'catching' :: 'MonadCatchIO' m => 'Iso'' 'SomeException' a       -> m r -> (a -> m r) -> m r+-- 'catching' :: 'MonadCatchIO' m => 'Getter' 'SomeException' a     -> m r -> (a -> m r) -> m r+-- 'catching' :: 'MonadCatchIO' m => 'Fold' 'SomeException' a       -> m r -> (a -> m r) -> m r+-- @+catching :: MonadCatchIO m => Getting (First a) SomeException t a b -> m r -> (a -> m r) -> m r+catching l = catchJust (preview l)+{-# INLINE catching #-}++-- | Catch exceptions that match a given 'Prism' (or any 'Getter'), discarding+-- the information about the match. This is particuarly useful when you have+-- a @'Prism'' e ()@ where the result of the 'Prism' or 'Fold' isn't+-- particularly valuable, just the fact that it matches.+--+-- >>> catching_ _AssertionFailed (assert False (return "uncaught")) $ return "caught"+-- "caught"+--+-- @+-- 'catching_' :: 'MonadCatchIO' m => 'Prism'' 'SomeException' a     -> m r -> m r -> m r+-- 'catching_' :: 'MonadCatchIO' m => 'Lens'' 'SomeException' a      -> m r -> m r -> m r+-- 'catching_' :: 'MonadCatchIO' m => 'Traversal'' 'SomeException' a -> m r -> m r -> m r+-- 'catching_' :: 'MonadCatchIO' m => 'Iso'' 'SomeException' a       -> m r -> m r -> m r+-- 'catching_' :: 'MonadCatchIO' m => 'Getter' 'SomeException' a     -> m r -> m r -> m r+-- 'catching_' :: 'MonadCatchIO' m => 'Fold' 'SomeException' a       -> m r -> m r -> m r+-- @+catching_ :: MonadCatchIO m => Getting (First a) SomeException t a b -> m r -> m r -> m r+catching_ l a b = catchJust (preview l) a (const b)+{-# INLINE catching_ #-}++-- | A helper function to provide conditional catch behavior.+catchJust :: (MonadCatchIO m, Exception e) => (e -> Maybe t) -> m a -> (t -> m a) -> m a+catchJust f m k = CatchIO.catch m $ \ e -> case f e of+  Nothing -> liftIO (throwIO e)+  Just x  -> k x+{-# INLINE catchJust #-}++------------------------------------------------------------------------------+-- Handling+------------------------------------------------------------------------------++-- | A version of 'catching' with the arguments swapped around; useful in+-- situations where the code for the handler is shorter.+--+-- >>> handling _NonTermination (\_ -> return "caught") $ throwIO NonTermination+-- "caught"+--+-- @+-- 'handling' :: 'MonadCatchIO' m => 'Prism'' 'SomeException' a     -> (a -> m r) -> m r -> m r+-- 'handling' :: 'MonadCatchIO' m => 'Lens'' 'SomeException' a      -> (a -> m r) -> m r -> m r+-- 'handling' :: 'MonadCatchIO' m => 'Traversal'' 'SomeException' a -> (a -> m r) -> m r -> m r+-- 'handling' :: 'MonadCatchIO' m => 'Iso'' 'SomeException' a       -> (a -> m r) -> m r -> m r+-- 'handling' :: 'MonadCatchIO' m => 'Fold' 'SomeException' a       -> (a -> m r) -> m r -> m r+-- 'handling' :: 'MonadCatchIO' m => 'Getter' 'SomeException' a     -> (a -> m r) -> m r -> m r+-- @+handling :: MonadCatchIO m => Getting (First a) SomeException t a b -> (a -> m r) -> m r -> m r+handling l = flip (catching l)+{-# INLINE handling #-}++-- | A version of 'catching_' with the arguments swapped around; useful in+-- situations where the code for the handler is shorter.+--+-- >>> handling_ _NonTermination (return "caught") $ throwIO NonTermination+-- "caught"+--+-- @+-- 'handling_' :: 'MonadCatchIO' m => 'Prism'' 'SomeException' a     -> m r -> m r -> m r+-- 'handling_' :: 'MonadCatchIO' m => 'Lens'' 'SomeException' a      -> m r -> m r -> m r+-- 'handling_' :: 'MonadCatchIO' m => 'Traversal'' 'SomeException' a -> m r -> m r -> m r+-- 'handling_' :: 'MonadCatchIO' m => 'Iso'' 'SomeException' a       -> m r -> m r -> m r+-- 'handling_' :: 'MonadCatchIO' m => 'Getter' 'SomeException' a     -> m r -> m r -> m r+-- 'handling_' :: 'MonadCatchIO' m => 'Fold' 'SomeException' a       -> m r -> m r -> m r+-- @+handling_ :: MonadCatchIO m => Getting (First a) SomeException t a b -> m r -> m r -> m r+handling_ l = flip (catching_ l)+{-# INLINE handling_ #-}++------------------------------------------------------------------------------+-- Trying+------------------------------------------------------------------------------++-- | A variant of 'CatchIO.try' that takes an 'Prism' (or any 'Getter') to select which+-- exceptions are caught (c.f. 'tryJust', 'catchJust'). If the 'Exception' does+-- not match the predicate, it is re-thrown.+--+-- @+-- 'trying' :: 'MonadCatchIO' m => 'Prism''     'SomeException' a -> m r -> m ('Either' a r)+-- 'trying' :: 'MonadCatchIO' m => 'Lens''      'SomeException' a -> m r -> m ('Either' a r)+-- 'trying' :: 'MonadCatchIO' m => 'Traversal'' 'SomeException' a -> m r -> m ('Either' a r)+-- 'trying' :: 'MonadCatchIO' m => 'Iso''       'SomeException' a -> m r -> m ('Either' a r)+-- 'trying' :: 'MonadCatchIO' m => 'Getter'     'SomeException' a -> m r -> m ('Either' a r)+-- 'trying' :: 'MonadCatchIO' m => 'Fold'       'SomeException' a -> m r -> m ('Either' a r)+-- @+trying :: MonadCatchIO m => Getting (First a) SomeException t a b -> m r -> m (Either a r)+trying l = tryJust (preview l)++-- | A helper version of 'CatchIO.try' that doesn't needlessly require 'Functor'.+try :: (MonadCatchIO m, Exception e) => m a -> m (Either e a)+try a = CatchIO.catch (liftM Right a) (return . Left)++-- | A helper version of 'CatchIO.tryJust' that doesn't needlessly require 'Functor'.+tryJust :: (MonadCatchIO m, Exception e) => (e -> Maybe b) -> m a -> m (Either b a)+tryJust p a = do+  r <- try a+  case r of+    Right v -> return (Right v)+    Left  e -> case p e of+      Nothing -> CatchIO.throw e `asTypeOf` return (Left undefined)+      Just b  -> return (Left b)++------------------------------------------------------------------------------+-- Throwing+------------------------------------------------------------------------------++-- | Throw an 'Exception' described by a 'Prism'. Exceptions may be thrown from+-- purely functional code, but may only be caught within the 'IO' 'Monad'.+--+-- @'throwing' l ≡ 'reviews' l 'throw'@+--+-- @+-- 'throwing' :: 'Prism'' 'SomeException' t -> t -> a+-- 'throwing' :: 'Iso'' 'SomeException' t   -> t -> a+-- @+throwing :: AReview s SomeException a b -> b -> a+throwing l = reviews l Exception.throw+{-# INLINE throwing #-}++-- | A variant of 'throwing' that can only be used within the 'IO' 'Monad'+-- (or any other 'MonadCatchIO' instance) to throw an 'Exception' described +-- by a 'Prism'.+--+-- 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 'MonadCatchIO' 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 'CatchIO.throw'@+--+-- @+-- 'throwingM' :: 'MonadCatchIO' m => 'Prism'' 'SomeException' t -> t -> m a+-- 'throwingM' :: 'MonadCatchIO' m => 'Iso'' 'SomeException' t   -> t -> m a+-- @+throwingM :: MonadCatchIO m => AReview s SomeException a b -> b -> m a+throwingM l = reviews l (liftIO . throwIO)+{-# INLINE throwingM #-}++-- | 'throwingTo' raises an 'Exception' specified by a 'Prism' in the target thread.+--+-- @'throwingTo' thread l ≡ 'reviews' l ('throwTo' thread)@+--+--+-- @+-- 'throwingTo' :: 'ThreadId' -> 'Prism'' 'SomeException' t -> t -> m a+-- 'throwingTo' :: 'ThreadId' -> 'Iso'' 'SomeException' t   -> t -> m a+-- @+throwingTo :: MonadIO m => ThreadId -> AReview s SomeException a b -> b -> m ()+throwingTo tid l = reviews l (liftIO . throwTo tid)+{-# INLINE throwingTo #-}++----------------------------------------------------------------------------+-- IOException+----------------------------------------------------------------------------++-- | Exceptions that occur in the 'IO' 'Monad'. An 'IOException' records a+-- more specific error type, a descriptive string and maybe the handle that was+-- used when the error was flagged.+--+-- Due to their richer structure relative to other exceptions, these have+-- a more carefully overloaded signature.+class AsIOException p f t where+  -- | Unfortunately the name 'ioException' is taken by @base@ for+  -- throwing IOExceptions.+  --+  -- @+  -- '_IOException' :: 'Equality'' 'IOException' 'IOException'+  -- '_IOException' :: 'Prism'' 'SomeException' 'IOException'+  -- @+  --+  -- Many combinators for working with an 'IOException' are available+  -- in "System.IO.Error.Lens".+  _IOException :: Overloaded' p f t IOException++instance AsIOException p f IOException where+  _IOException = id+  {-# INLINE _IOException #-}++instance (Choice p, Applicative f) => AsIOException p f SomeException where+  _IOException = exception+  {-# INLINE _IOException #-}++----------------------------------------------------------------------------+-- ArithException+----------------------------------------------------------------------------++-- | Arithmetic exceptions.+class AsArithException p f t where+  -- '_ArithException' :: 'Equality'' 'ArithException' 'ArithException'+  -- '_ArithException' :: 'Prism''    'SomeException'  'ArithException'+  _ArithException :: Overloaded' p f t ArithException++instance AsArithException p f ArithException where+  _ArithException = id+  {-# INLINE _ArithException #-}++instance (Choice p, Applicative f) => AsArithException p f SomeException where+  _ArithException = exception+  {-# INLINE _ArithException #-}++-- | Handle arithmetic '_Overflow'.+--+-- @'_Overflow' ≡ '_ArithException' '.' '_Overflow'@+--+-- @+-- '_Overflow' :: 'Prism'' 'ArithException' 'ArithException'+-- '_Overflow' :: 'Prism'' 'SomeException'  'ArithException'+-- @+_Overflow :: (AsArithException p f t, Choice p, Applicative f) => Overloaded' p f t ()+_Overflow = _ArithException . dimap seta (either id id) . right' . rmap (Overflow <$) where+  seta Overflow = Right ()+  seta t        = Left  (pure t)+{-# INLINE _Overflow #-}++-- | Handle arithmetic '_Underflow'.+--+-- @'_Underflow' ≡ '_ArithException' '.' '_Underflow'@+--+-- @+-- '_Underflow' :: 'Prism'' 'ArithException' 'ArithException'+-- '_Underflow' :: 'Prism'' 'SomeException'  'ArithException'+-- @+_Underflow :: (AsArithException p f t, Choice p, Applicative f) => Overloaded' p f t ()+_Underflow = _ArithException . dimap seta (either id id) . right' . rmap (Underflow <$) where+  seta Underflow = Right ()+  seta t        = Left  (pure t)+{-# INLINE _Underflow #-}++-- | Handle arithmetic loss of precision.+--+-- @'_LossOfPrecision' ≡ '_ArithException' '.' '_LossOfPrecision'@+--+-- @+-- '_LossOfPrecision' :: 'Prism'' 'ArithException' 'ArithException'+-- '_LossOfPrecision' :: 'Prism'' 'SomeException'  'ArithException'+-- @+_LossOfPrecision :: (AsArithException p f t, Choice p, Applicative f) => Overloaded' p f t ()+_LossOfPrecision = _ArithException . dimap seta (either id id) . right' . rmap (LossOfPrecision <$) where+  seta LossOfPrecision = Right ()+  seta t        = Left  (pure t)+{-# INLINE _LossOfPrecision #-}++-- | Handle division by zero.+--+-- @'_DivideByZero' ≡ '_ArithException' '.' '_DivideByZero'@+--+-- @+-- '_DivideByZero' :: 'Prism'' 'ArithException' 'ArithException'+-- '_DivideByZero' :: 'Prism'' 'SomeException'  'ArithException'+-- @+_DivideByZero :: (AsArithException p f t, Choice p, Applicative f) => Overloaded' p f t ()+_DivideByZero = _ArithException . dimap seta (either id id) . right' . rmap (DivideByZero <$) where+  seta DivideByZero = Right ()+  seta t        = Left  (pure t)+{-# INLINE _DivideByZero #-}++-- | Handle exceptional _Denormalized floating point.+--+-- @'_Denormal' ≡ '_ArithException' '.' '_Denormal'@+--+-- @+-- '_Denormal' :: 'Prism'' 'ArithException' 'ArithException'+-- '_Denormal' :: 'Prism'' 'SomeException'  'ArithException'+-- @+_Denormal :: (AsArithException p f t, Choice p, Applicative f) => Overloaded' p f t ()+_Denormal = _ArithException . dimap seta (either id id) . right' . rmap (Denormal <$) where+  seta Denormal = Right ()+  seta t        = Left  (pure t)+{-# INLINE _Denormal #-}++#if MIN_VERSION_base(4,6,0)+-- | Added in @base@ 4.6 in response to this libraries discussion:+--+-- <http://haskell.1045720.n5.nabble.com/Data-Ratio-and-exceptions-td5711246.html>+--+-- @'_RatioZeroDenominator' ≡ '_ArithException' '.' '_RatioZeroDenominator'@+--+-- @+-- '_RatioZeroDenominator' :: 'Prism'' 'ArithException' 'ArithException'+-- '_RatioZeroDenominator' :: 'Prism'' 'SomeException'  'ArithException'+-- @+_RatioZeroDenominator :: (AsArithException p f t, Choice p, Applicative f) => Overloaded' p f t ()+_RatioZeroDenominator = _ArithException . dimap seta (either id id) . right' . rmap (RatioZeroDenominator <$) where+  seta RatioZeroDenominator = Right ()+  seta t        = Left  (pure t)+{-# INLINE _RatioZeroDenominator #-}++#endif++----------------------------------------------------------------------------+-- ArrayException+----------------------------------------------------------------------------++-- | Exceptions generated by array operations.+class AsArrayException p f t where+  -- | Extract information about an 'ArrayException'.+  --+  -- @+  -- '_ArrayException' :: 'Equality'' 'ArrayException' 'ArrayException'+  -- '_ArrayException' :: 'Prism''    'SomeException'  'ArrayException'+  -- @+  _ArrayException :: Overloaded' p f t ArrayException++instance AsArrayException p f ArrayException where+  _ArrayException = id+  {-# INLINE _ArrayException #-}++instance (Choice p, Applicative f) => AsArrayException p f SomeException where+  _ArrayException = exception+  {-# INLINE _ArrayException #-}++-- | An attempt was made to index an array outside its declared bounds.+--+-- @'_IndexOutOfBounds' ≡ '_ArrayException' '.' '_IndexOutOfBounds'@+--+-- @+-- '_IndexOutOfBounds' :: 'Prism'' 'ArrayException' 'String'+-- '_IndexOutOfBounds' :: 'Prism'' 'SomeException'  'String'+-- @+_IndexOutOfBounds :: (AsArrayException p f t, Choice p, Applicative f) => Overloaded' p f t String+_IndexOutOfBounds = _ArrayException . dimap seta (either id id) . right' . rmap (fmap IndexOutOfBounds) where+  seta (IndexOutOfBounds r) = Right r+  seta t                    = Left  (pure t)+{-# INLINE _IndexOutOfBounds #-}++-- | An attempt was made to evaluate an element of an array that had not been initialized.+--+-- @'_UndefinedElement' ≡ '_ArrayException' '.' '_UndefinedElement'@+--+-- @+-- '_UndefinedElement' :: 'Prism'' 'ArrayException' 'String'+-- '_UndefinedElement' :: 'Prism'' 'SomeException'  'String'+-- @+_UndefinedElement :: (AsArrayException p f t, Choice p, Applicative f) => Overloaded' p f t String+_UndefinedElement = _ArrayException . dimap seta (either id id) . right' . rmap (fmap UndefinedElement) where+  seta (UndefinedElement r) = Right r+  seta t                    = Left  (pure t)+{-# INLINE _UndefinedElement #-}++----------------------------------------------------------------------------+-- AssertionFailed+----------------------------------------------------------------------------++-- | 'assert' was applied to 'Prelude.False'.+class AsAssertionFailed p f t where+  -- | This exception contains provides information about what assertion failed in the string.+  --+  -- >>> handling _AssertionFailed (\ xs -> "caught" <$ guard ("<interactive>" `isInfixOf` xs) ) $ assert False (return "uncaught")+  -- "caught"+  --+  -- @+  -- '_AssertionFailed' :: 'Iso''   'AssertionFailed' 'String'+  -- '_AssertionFailed' :: 'Prism'' 'SomeException'   'String'+  -- @+  _AssertionFailed :: Overloaded' p f t String++instance (Profunctor p, Functor f) => AsAssertionFailed p f AssertionFailed where+  _AssertionFailed = unwrapping AssertionFailed+  {-# INLINE _AssertionFailed #-}++instance (Choice p, Applicative f) => AsAssertionFailed p f SomeException where+  _AssertionFailed = exception.unwrapping AssertionFailed+  {-# INLINE _AssertionFailed #-}++----------------------------------------------------------------------------+-- AsyncException+----------------------------------------------------------------------------++-- | Asynchronous exceptions.+class AsAsyncException p f t where+  -- | There are several types of 'AsyncException'.+  --+  -- @+  -- '_AsyncException' :: 'Equality'' 'AsyncException' 'AsyncException'+  -- '_AsyncException' :: 'Prism''    'SomeException'  'AsyncException'+  -- @+  _AsyncException :: Overloaded' p f t AsyncException++instance AsAsyncException p f AsyncException where+  _AsyncException = id+  {-# INLINE _AsyncException #-}++instance (Choice p, Applicative f) => AsAsyncException p f SomeException where+  _AsyncException = exception+  {-# INLINE _AsyncException #-}++-- | The current thread's stack exceeded its limit. Since an 'Exception' has+-- been raised, the thread's stack will certainly be below its limit again,+-- but the programmer should take remedial action immediately.+--+-- @+-- '_StackOverflow' :: 'Prism'' 'AsyncException' ()+-- '_StackOverflow' :: 'Prism'' 'SomeException'  ()+-- @+_StackOverflow :: (AsAsyncException p f t, Choice p, Applicative f) => Overloaded' p f t ()+_StackOverflow = _AsyncException . dimap seta (either id id) . right' . rmap (StackOverflow <$) where+  seta StackOverflow = Right ()+  seta t             = Left  (pure t)+{-# INLINE _StackOverflow #-}++-- | The program's heap is reaching its limit, and the program should take action+-- to reduce the amount of live data it has.+--+-- Notes:+--+-- * It is undefined which thread receives this 'Exception'.+--+-- * GHC currently does not throw 'HeapOverflow' exceptions.+--+-- @+-- '_HeapOverflow' :: 'Prism'' 'AsyncException' ()+-- '_HeapOverflow' :: 'Prism'' 'SomeException'  ()+-- @+_HeapOverflow :: (AsAsyncException p f t, Choice p, Applicative f) => Overloaded' p f t ()+_HeapOverflow = _AsyncException . dimap seta (either id id) . right' . rmap (HeapOverflow <$) where+  seta HeapOverflow = Right ()+  seta t             = Left  (pure t)+{-# INLINE _HeapOverflow #-}++-- | This 'Exception' is raised by another thread calling+-- 'Control.Concurrent.killThread', or by the system if it needs to terminate+-- the thread for some reason.+--+-- @+-- '_ThreadKilled' :: 'Prism'' 'AsyncException' ()+-- '_ThreadKilled' :: 'Prism'' 'SomeException'  ()+-- @+_ThreadKilled :: (AsAsyncException p f t, Choice p, Applicative f) => Overloaded' p f t ()+_ThreadKilled = _AsyncException . dimap seta (either id id) . right' . rmap (ThreadKilled <$) where+  seta ThreadKilled = Right ()+  seta t             = Left  (pure t)+{-# INLINE _ThreadKilled #-}++-- | This 'Exception' is raised by default in the main thread of the program when+-- the user requests to terminate the program via the usual mechanism(s)+-- (/e.g./ Control-C in the console).+--+-- @+-- '_UserInterrupt' :: 'Prism'' 'AsyncException' ()+-- '_UserInterrupt' :: 'Prism'' 'SomeException'  ()+-- @+_UserInterrupt :: (AsAsyncException p f t, Choice p, Applicative f) => Overloaded' p f t ()+_UserInterrupt = _AsyncException . dimap seta (either id id) . right' . rmap (UserInterrupt <$) where+  seta UserInterrupt = Right ()+  seta t             = Left  (pure t)+{-# INLINE _UserInterrupt #-}++----------------------------------------------------------------------------+-- AsyncException+----------------------------------------------------------------------------++-- | Thrown when the runtime system detects that the computation is guaranteed+-- not to terminate. Note that there is no guarantee that the runtime system+-- will notice whether any given computation is guaranteed to terminate or not.+class (Profunctor p, Functor f) => AsNonTermination p f t where+  -- | There is no additional information carried in a 'NonTermination' exception.+  --+  -- @+  -- '_NonTermination' :: 'Iso''   'NonTermination' ()+  -- '_NonTermination' :: 'Prism'' 'SomeException'  ()+  -- @+  _NonTermination :: Overloaded' p f t ()++instance (Profunctor p, Functor f) => AsNonTermination p f NonTermination where+  _NonTermination = trivial NonTermination+  {-# INLINE _NonTermination #-}++instance (Choice p, Applicative f) => AsNonTermination p f SomeException where+  _NonTermination = exception.trivial NonTermination+  {-# INLINE _NonTermination #-}++----------------------------------------------------------------------------+-- NestedAtomically+----------------------------------------------------------------------------++-- | Thrown when the program attempts to call atomically, from the+-- 'Control.Monad.STM' package, inside another call to atomically.+class (Profunctor p, Functor f) => AsNestedAtomically p f t where+  -- | There is no additional information carried in a 'NestedAtomically' exception.+  --+  -- @+  -- '_NestedAtomically' :: 'Iso''   'NestedAtomically' ()+  -- '_NestedAtomically' :: 'Prism'' 'SomeException'    ()+  -- @+  _NestedAtomically :: Overloaded' p f t ()++instance (Profunctor p, Functor f) => AsNestedAtomically p f NestedAtomically where+  _NestedAtomically = trivial NestedAtomically+  {-# INLINE _NestedAtomically #-}++instance (Choice p, Applicative f) => AsNestedAtomically p f SomeException where+  _NestedAtomically = exception.trivial NestedAtomically+  {-# INLINE _NestedAtomically #-}++----------------------------------------------------------------------------+-- BlockedIndefinitelyOnMVar+----------------------------------------------------------------------------++-- | The thread is blocked on an 'Control.Concurrent.MVar.MVar', but there+-- are no other references to the 'Control.Concurrent.MVar.MVar' so it can't+-- ever continue.+class (Profunctor p, Functor f) => AsBlockedIndefinitelyOnMVar p f t where+  -- | There is no additional information carried in a 'BlockedIndefinitelyOnMVar' exception.+  --+  -- @+  -- '_BlockedIndefinitelyOnMVar' :: 'Iso''   'BlockedIndefinitelyOnMVar' ()+  -- '_BlockedIndefinitelyOnMVar' :: 'Prism'' 'SomeException'             ()+  -- @+  _BlockedIndefinitelyOnMVar :: Overloaded' p f t ()++instance (Profunctor p, Functor f) => AsBlockedIndefinitelyOnMVar p f BlockedIndefinitelyOnMVar where+  _BlockedIndefinitelyOnMVar = trivial BlockedIndefinitelyOnMVar+  {-# INLINE _BlockedIndefinitelyOnMVar #-}++instance (Choice p, Applicative f) => AsBlockedIndefinitelyOnMVar p f SomeException where+  _BlockedIndefinitelyOnMVar = exception.trivial BlockedIndefinitelyOnMVar+  {-# INLINE _BlockedIndefinitelyOnMVar #-}++----------------------------------------------------------------------------+-- BlockedIndefinitelyOnSTM+----------------------------------------------------------------------------++-- | The thread is waiting to retry an 'Control.Monad.STM.STM' transaction,+-- but there are no other references to any TVars involved, so it can't ever+-- continue.+class (Profunctor p, Functor f) => AsBlockedIndefinitelyOnSTM p f t where+  -- | There is no additional information carried in a 'BlockedIndefinitelyOnSTM' exception.+  --+  -- @+  -- '_BlockedIndefinitelyOnSTM' :: 'Iso''   'BlockedIndefinitelyOnSTM' ()+  -- '_BlockedIndefinitelyOnSTM' :: 'Prism'' 'SomeException'            ()+  -- @+  _BlockedIndefinitelyOnSTM :: Overloaded' p f t ()++instance (Profunctor p, Functor f) => AsBlockedIndefinitelyOnSTM p f BlockedIndefinitelyOnSTM where+  _BlockedIndefinitelyOnSTM = trivial BlockedIndefinitelyOnSTM+  {-# INLINE _BlockedIndefinitelyOnSTM #-}++instance (Choice p, Applicative f) => AsBlockedIndefinitelyOnSTM p f SomeException where+  _BlockedIndefinitelyOnSTM = exception.trivial BlockedIndefinitelyOnSTM+  {-# INLINE _BlockedIndefinitelyOnSTM #-}++----------------------------------------------------------------------------+-- Deadlock+----------------------------------------------------------------------------++-- | There are no runnable threads, so the program is deadlocked. The+-- 'Deadlock' 'Exception' is raised in the main thread only.+class (Profunctor p, Functor f) => AsDeadlock p f t where+  -- | There is no information carried in a 'Deadlock' exception.+  --+  -- @+  -- '_Deadlock' :: 'Iso''   'Deadlock'      ()+  -- '_Deadlock' :: 'Prism'' 'SomeException' ()+  -- @+  _Deadlock :: Overloaded' p f t ()++instance (Profunctor p, Functor f) => AsDeadlock p f Deadlock where+  _Deadlock = trivial Deadlock+  {-# INLINE _Deadlock #-}++instance (Choice p, Applicative f) => AsDeadlock p f SomeException where+  _Deadlock = exception.trivial Deadlock+  {-# INLINE _Deadlock #-}++----------------------------------------------------------------------------+-- NoMethodError+----------------------------------------------------------------------------++-- | A class method without a definition (neither a default definition,+-- nor a definition in the appropriate instance) was called.+class (Profunctor p, Functor f) => AsNoMethodError p f t where+  -- | Extract a description of the missing method.+  --+  -- @+  -- '_NoMethodError' :: 'Iso''   'NoMethodError' 'String'+  -- '_NoMethodError' :: 'Prism'' 'SomeException' 'String'+  -- @+  _NoMethodError :: Overloaded' p f t String++instance (Profunctor p, Functor f) => AsNoMethodError p f NoMethodError where+  _NoMethodError = unwrapping NoMethodError+  {-# INLINE _NoMethodError #-}++instance (Choice p, Applicative f) => AsNoMethodError p f SomeException where+  _NoMethodError = exception.unwrapping NoMethodError+  {-# INLINE _NoMethodError #-}++----------------------------------------------------------------------------+-- PatternMatchFail+----------------------------------------------------------------------------++-- | A pattern match failed.+class (Profunctor p, Functor f) => AsPatternMatchFail p f t where+  -- | Information about the source location of the pattern.+  --+  -- @+  -- '_PatternMatchFail' :: 'Iso''   'PatternMatchFail' 'String'+  -- '_PatternMatchFail' :: 'Prism'' 'SomeException'    'String'+  -- @+  _PatternMatchFail :: Overloaded' p f t String++instance (Profunctor p, Functor f) => AsPatternMatchFail p f PatternMatchFail where+  _PatternMatchFail = unwrapping PatternMatchFail+  {-# INLINE _PatternMatchFail #-}++instance (Choice p, Applicative f) => AsPatternMatchFail p f SomeException where+  _PatternMatchFail = exception.unwrapping PatternMatchFail+  {-# INLINE _PatternMatchFail #-}++----------------------------------------------------------------------------+-- RecConError+----------------------------------------------------------------------------++-- | An uninitialised record field was used.+class (Profunctor p, Functor f) => AsRecConError p f t where+  -- | Information about the source location where the record was+  -- constructed.+  --+  -- @+  -- '_RecConError' :: 'Iso''   'RecConError'   'String'+  -- '_RecConError' :: 'Prism'' 'SomeException' 'String'+  -- @+  _RecConError :: Overloaded' p f t String++instance (Profunctor p, Functor f) => AsRecConError p f RecConError where+  _RecConError = unwrapping RecConError+  {-# INLINE _RecConError #-}++instance (Choice p, Applicative f) => AsRecConError p f SomeException where+  _RecConError = exception.unwrapping RecConError+  {-# INLINE _RecConError #-}++----------------------------------------------------------------------------+-- RecSelError+----------------------------------------------------------------------------++-- | A record selector was applied to a constructor without the appropriate+-- field. This can only happen with a datatype with multiple constructors,+-- where some fields are in one constructor but not another.+class (Profunctor p, Functor f) => AsRecSelError p f t where+  -- | Information about the source location where the record selection occurred.+  _RecSelError :: Overloaded' p f t String++instance (Profunctor p, Functor f) => AsRecSelError p f RecSelError where+  _RecSelError = unwrapping RecSelError+  {-# INLINE _RecSelError #-}++instance (Choice p, Applicative f) => AsRecSelError p f SomeException where+  _RecSelError = exception.unwrapping RecSelError+  {-# INLINE _RecSelError #-}++----------------------------------------------------------------------------+-- RecUpdError+----------------------------------------------------------------------------++-- | A record update was performed on a constructor without the+-- appropriate field. This can only happen with a datatype with multiple+-- constructors, where some fields are in one constructor but not another.+class (Profunctor p, Functor f) => AsRecUpdError p f t where+  -- | Information about the source location where the record was updated.+  _RecUpdError :: Overloaded' p f t String++instance (Profunctor p, Functor f) => AsRecUpdError p f RecUpdError where+  _RecUpdError = unwrapping RecUpdError+  {-# INLINE _RecUpdError #-}++instance (Choice p, Applicative f) => AsRecUpdError p f SomeException where+  _RecUpdError = exception.unwrapping RecUpdError+  {-# INLINE _RecUpdError #-}++----------------------------------------------------------------------------+-- ErrorCall+----------------------------------------------------------------------------++-- | This is thrown when the user calls 'Prelude.error'.+class (Profunctor p, Functor f) => AsErrorCall p f t where+  -- | Retrieve the argument given to 'Prelude.error'.+  --+  -- 'ErrorCall' is isomorphic to a 'String'.+  --+  -- >>> catching _ErrorCall (error "touch down!") return+  -- "touch down!"+  _ErrorCall :: Overloaded' p f t String++instance (Profunctor p, Functor f) => AsErrorCall p f ErrorCall where+  _ErrorCall = unwrapping ErrorCall+  {-# INLINE _ErrorCall #-}++instance (Choice p, Applicative f) => AsErrorCall p f SomeException where+  _ErrorCall = exception.unwrapping ErrorCall+  {-# INLINE _ErrorCall #-}++------------------------------------------------------------------------------+-- Helper Functions+------------------------------------------------------------------------------++trivial :: t -> Iso' t ()+trivial t = const () `iso` const t

@@ -1,16 +1,12 @@ {-# LANGUAGE CPP #-}-{-# LANGUAGE MultiParamTypeClasses #-}-{-# LANGUAGE Rank2Types #-}-{-# LANGUAGE LiberalTypeSynonyms #-}-{-# LANGUAGE FlexibleContexts #-} ----------------------------------------------------------------------------- -- | -- Module      :  Control.Lens--- Copyright   :  (C) 2012 Edward Kmett+-- Copyright   :  (C) 2012-13 Edward Kmett -- License     :  BSD-style (see the file LICENSE) -- Maintainer  :  Edward Kmett <ekmett@gmail.com>--- Stability   :  provisional--- Portability :  Rank2Types+-- Stability   :  experimental+-- Portability :  non-portable -- -- Usage: --@@ -25,7 +21,7 @@ -- This defines the following lenses: -- -- @--- fooArgs :: 'Simple' 'Lens' (Foo a) ['String']+-- fooArgs :: 'Lens'' (Foo a) ['String'] -- fooValue :: 'Lens' (Foo a) (Foo b) a b -- @ --@@ -41,62 +37,66 @@ -- -- <http://github.com/ekmett/lens/wiki> ----- <<http://github.com/ekmett/lens/wiki/images/Hierarchy-3.7.png>>+-- <<http://github.com/ekmett/lens/wiki/images/Hierarchy-3.8.png>> ---------------------------------------------------------------------------- module Control.Lens   ( module Control.Lens.Action+  , module Control.Lens.At   , module Control.Lens.Combinators+  , module Control.Lens.Cons   , module Control.Lens.Each+  , module Control.Lens.Equality   , module Control.Lens.Fold   , module Control.Lens.Getter   , module Control.Lens.Indexed-  , module Control.Lens.IndexedFold-  , module Control.Lens.IndexedGetter-  , module Control.Lens.IndexedLens-  , module Control.Lens.IndexedSetter-  , module Control.Lens.IndexedTraversal   , module Control.Lens.Iso+  , module Control.Lens.Lens+  , module Control.Lens.Level   , module Control.Lens.Loupe   , module Control.Lens.Plated   , module Control.Lens.Prism-  , module Control.Lens.Representable+  , module Control.Lens.Reified+  , module Control.Lens.Review   , module Control.Lens.Setter+  , module Control.Lens.Simple #ifndef DISABLE_TEMPLATE_HASKELL   , module Control.Lens.TH #endif   , module Control.Lens.Traversal   , module Control.Lens.Tuple   , module Control.Lens.Type-  , module Control.Lens.WithIndex   , module Control.Lens.Wrapped   , module Control.Lens.Zipper   , module Control.Lens.Zoom   ) where  import Control.Lens.Action+import Control.Lens.At import Control.Lens.Combinators+import Control.Lens.Cons import Control.Lens.Each+import Control.Lens.Equality import Control.Lens.Fold import Control.Lens.Getter import Control.Lens.Indexed-import Control.Lens.IndexedFold-import Control.Lens.IndexedGetter-import Control.Lens.IndexedLens-import Control.Lens.IndexedSetter-import Control.Lens.IndexedTraversal import Control.Lens.Iso+import Control.Lens.Lens+import Control.Lens.Level import Control.Lens.Loupe import Control.Lens.Plated import Control.Lens.Prism-import Control.Lens.Representable+import Control.Lens.Reified+import Control.Lens.Review import Control.Lens.Setter+import Control.Lens.Simple #ifndef DISABLE_TEMPLATE_HASKELL import Control.Lens.TH #endif import Control.Lens.Traversal import Control.Lens.Tuple import Control.Lens.Type-import Control.Lens.WithIndex import Control.Lens.Wrapped import Control.Lens.Zipper import Control.Lens.Zoom++{-# ANN module "HLint: ignore Use import/export shortcut" #-}

@@ -1,14 +1,14 @@-{-# LANGUAGE MagicHash #-} {-# LANGUAGE Rank2Types #-}+{-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE MultiParamTypeClasses #-} ----------------------------------------------------------------------------- -- | -- Module      :  Control.Lens.Action--- Copyright   :  (C) 2012 Edward Kmett+-- Copyright   :  (C) 2012-13 Edward Kmett -- License     :  BSD-style (see the file LICENSE) -- Maintainer  :  Edward Kmett <ekmett@gmail.com> -- Stability   :  experimental--- Portability :  MTPCs, FDs, Rank2+-- Portability :  non-portable -- ---------------------------------------------------------------------------- module Control.Lens.Action@@ -21,73 +21,106 @@   , performs   , liftAct   , (^!)+  , (^!!)+  , (^!?) +  -- * Indexed Actions+  , IndexedAction+  , iact+  , iperform+  , iperforms+  , (^@!)+  , (^@!!)+  , (^@!?)+   -- * Folds with Effects   , MonadicFold+  , IndexedMonadicFold    -- * Implementation Details   , Acting+  , IndexedActing+  , Effective   ) where -import Control.Applicative-import Control.Lens.Classes-import Control.Lens.Internal-import Control.Lens.Internal.Combinators+import Control.Comonad+import Control.Lens.Internal.Action+import Control.Lens.Internal.Fold+import Control.Lens.Internal.Indexed+import Control.Lens.Type+import Control.Monad (liftM) import Control.Monad.Trans.Class+import Data.Profunctor+import Data.Profunctor.Rep+import Data.Profunctor.Unsafe  -- $setup -- >>> :m + Control.Lens -infixr 8 ^!---- | An 'Action' is a 'Getter' enriched with access to a 'Monad' for side-effects.------ Every 'Getter' can be used as an 'Action'------ You can compose an 'Action' with another 'Action' using ('Prelude..') from the @Prelude@.-type Action m s a = forall f r. Effective m r f => (a -> f a) -> s -> f s---- | A 'MonadicFold' is a 'Fold' enriched with access to a 'Monad' for side-effects.------ Every 'Fold' can be used as a 'MonadicFold', that simply ignores the access to the 'Monad'.------ You can compose a 'MonadicFold' with another 'MonadicFold' using ('Prelude..') from the @Prelude@.-type MonadicFold m s a = forall f r. (Effective m r f, Applicative f) => (a -> f a) -> s -> f s+infixr 8 ^!, ^!!, ^@!, ^@!!, ^!?, ^@!?  -- | Used to evaluate an 'Action'.-type Acting m r s t a b = (a -> Effect m r b) -> s -> Effect m r t+type Acting m r s t a b = LensLike (Effect m r) s t a b  -- | Perform an 'Action'. ----- @'perform' ≡ 'flip' ('^!')@+-- @+-- 'perform' ≡ 'flip' ('^!')+-- @ perform :: Monad m => Acting m a s t a b -> s -> m a-perform l = getEffect# (l (effect# return))+perform l = getEffect #. l (Effect #. return) {-# INLINE perform #-}  -- | Perform an 'Action' and modify the result.-performs :: Monad m => Acting m e s t a b -> (a -> e) -> s -> m e-performs l f = getEffect# (l (effect# (return . f)))+--+-- @+-- 'performs' :: 'Monad' m => 'Acting' m e s t a b -> (a -> e) -> s -> m e+-- @+performs :: (Profunctor p, Monad m) => Over p (Effect m e) s t a b -> p a e -> s -> m e+performs l f = getEffect #. l (rmap (Effect #. return) f)+{-# INLINE performs #-} --- | Perform an 'Action'+-- | Perform an 'Action'. -- -- >>> ["hello","world"]^!folded.act putStrLn -- hello -- world (^!) :: Monad m => s -> Acting m a s t a b -> m a-a ^! l = getEffect (l (effect# return) a)+a ^! l = getEffect (l (Effect #. return) a) {-# INLINE (^!) #-} --- | Construct an 'Action' from a monadic side-effect+-- | Perform a 'MonadicFold' and collect all of the results in a list.+(^!!) :: Monad m => s -> Acting m [a] s t a b -> m [a]+a ^!! l = getEffect (l (Effect #. return . return) a)+{-# INLINE (^!!) #-}++-- | Perform a 'MonadicFold' and collect the leftmost result. --+-- /Note:/ this still causes all effects for all elements.+(^!?) :: Monad m => s -> Acting m (Leftmost a) s t a b -> m (Maybe a)+a ^!?  l = liftM getLeftmost .# getEffect $ l (Effect #. return . LLeaf) a+{-# INLINE (^!?) #-}++-- | Construct an 'Action' from a monadic side-effect.+-- -- >>> ["hello","world"]^!folded.act (\x -> [x,x ++ "!"]) -- ["helloworld","helloworld!","hello!world","hello!world!"]-act :: Monad m => (s -> m a) -> Action m s a-act sma afb a = effective (sma a >>= ineffective . afb)+--+-- @+-- 'act' :: 'Monad' m => (s -> m a) -> 'Action' m s a+-- 'act' sma afb a = 'effective' (sma a '>>=' 'ineffective' '.' afb)+-- @+act :: Monad m => (s -> m a) -> IndexPreservingAction m s a+act sma pafb = cotabulate $ \ws -> effective $ do+   a <- sma (extract ws)+   ineffective (corep pafb (a <$ ws)) {-# INLINE act #-}  -- | A self-running 'Action', analogous to 'Control.Monad.join'. ----- @'acts' ≡ 'act' 'id'@+-- @+-- 'acts' ≡ 'act' 'id'+-- @ -- -- >>> (1,"hello")^!_2.acts.to succ -- "ifmmp"@@ -99,3 +132,48 @@ liftAct :: (MonadTrans trans, Monad m) => Acting m a s t a b -> Action (trans m) s a liftAct l = act (lift . perform l) {-# INLINE liftAct #-}++-----------------------------------------------------------------------------+-- Indexed Actions+----------------------------------------------------------------------------++-- | Used to evaluate an 'IndexedAction'.+type IndexedActing i m r s t a b = Over (Indexed i) (Effect m r) s t a b++-- | Perform an 'IndexedAction'.+--+-- @+-- 'iperform' ≡ 'flip' ('^@!')+-- @+iperform :: Monad m => IndexedActing i m (i, a) s t a b -> s -> m (i, a)+iperform l = getEffect #. l (Indexed $ \i a -> Effect (return (i, a)))+{-# INLINE iperform #-}++-- | Perform an 'IndexedAction' and modify the result.+iperforms :: Monad m => IndexedActing i m e s t a b -> (i -> a -> e) -> s -> m e+iperforms l = performs l .# Indexed+{-# INLINE iperforms #-}++-- | Perform an 'IndexedAction'.+(^@!) :: Monad m => s -> IndexedActing i m (i, a) s t a b -> m (i, a)+s ^@! l = getEffect (l (Indexed $ \i a -> Effect (return (i, a))) s)+{-# INLINE (^@!) #-}++-- | Obtain a list of all of the results of an 'IndexedMonadicFold'.+(^@!!) :: Monad m => s -> IndexedActing i m [(i, a)] s t a b -> m [(i, a)]+s ^@!! l = getEffect (l (Indexed $ \i a -> Effect (return [(i, a)])) s)+{-# INLINE (^@!!) #-}++-- | Perform an 'IndexedMonadicFold' and collect the 'Leftmost' result.+--+-- /Note:/ this still causes all effects for all elements.+(^@!?) :: Monad m => s -> IndexedActing i m (Leftmost (i, a)) s t a b -> m (Maybe (i, a))+a ^@!?  l = liftM getLeftmost .# getEffect $ l (Indexed $ \i -> Effect #. return . LLeaf . (,) i) a+{-# INLINE (^@!?) #-}++-- | Construct an 'IndexedAction' from a monadic side-effect.+iact :: Monad m => (s -> m (i, a)) -> IndexedAction i m s a+iact smia iafb s = effective $ do+  (i, a) <- smia s+  ineffective (indexed iafb i a)+{-# INLINE iact #-}

@@ -0,0 +1,552 @@+{-# LANGUAGE CPP #-}+{-# LANGUAGE GADTs #-}+{-# LANGUAGE Rank2Types #-}+{-# LANGUAGE TypeFamilies #-}+{-# LANGUAGE FlexibleContexts #-}+{-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE ScopedTypeVariables #-}+{-# LANGUAGE MultiParamTypeClasses #-}++#ifdef DEFAULT_SIGNATURES+{-# LANGUAGE DefaultSignatures #-}+#endif++#ifdef TRUSTWORTHY+{-# LANGUAGE Trustworthy #-}+#endif++#ifndef MIN_VERSION_base+#define MIN_VERSION_base(x,y,z) 1+#endif+-----------------------------------------------------------------------------+-- |+-- Module      :  Control.Lens.At+-- Copyright   :  (C) 2012-13 Edward Kmett+-- License     :  BSD-style (see the file LICENSE)+-- Maintainer  :  Edward Kmett <ekmett@gmail.com>+-- Stability   :  experimental+-- Portability :  non-portable+--+----------------------------------------------------------------------------+module Control.Lens.At+  (+  -- * At+    At(at)+  -- * Ixed+  , IxValue+  , Ixed(ix)+  , ixAt, ixEach+  -- * Contains+  , Contains(..)+  , containsIx, containsAt, containsLength, containsN, containsTest, containsLookup+  -- * Deprecated+  , _at+  , resultAt+  ) where++import Control.Applicative+import Control.Lens.Combinators+import Control.Lens.Each+import Control.Lens.Fold+import Control.Lens.Getter+import Control.Lens.Indexed as Lens+import Control.Lens.Type+import Control.Lens.Traversal+import Data.Array.IArray as Array+import Data.Array.Unboxed+import Data.ByteString as StrictB+import Data.ByteString.Lazy as LazyB+import Data.Complex+import Data.Functor.Identity+import Data.Hashable+import Data.HashMap.Lazy as HashMap+import Data.HashSet as HashSet+import Data.IntMap as IntMap+import Data.IntSet as IntSet+import Data.Map as Map+import Data.Maybe+import Data.Monoid+import Data.Set as Set+import Data.Sequence as Seq+import Data.Text as StrictT+import Data.Text.Lazy as LazyT+import Data.Tree+import Data.Vector as Vector hiding (indexed)+import Data.Vector.Primitive as Prim+import Data.Vector.Storable as Storable+import Data.Vector.Unboxed as Unboxed+import Data.Word++-- $setup+-- >>> import Control.Lens+-- >>> import Debug.SimpleReflect.Expr+-- >>> import Debug.SimpleReflect.Vars as Vars hiding (f,g)+-- >>> let f :: Expr -> Expr; f = Debug.SimpleReflect.Vars.f+-- >>> let g :: Expr -> Expr; g = Debug.SimpleReflect.Vars.g++-- | Deprecated aliases for 'ix'.+_at, resultAt :: Ixed f m => Index m -> IndexedLensLike' (Index m) f m (IxValue m)+_at      = ix+resultAt = ix+{-# DEPRECATED _at, resultAt "use 'ix'. This function will be removed in version 3.9" #-}++-- |+-- This class provides a simple 'IndexedFold' (or 'IndexedTraversal') that lets you view (and modify)+-- information about whether or not a container contains a given 'Index'.+class Functor f => Contains f m where+  -- |+  -- >>> 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]+  contains :: Index m -> IndexedLensLike' (Index m) f m Bool+#ifdef DEFAULT_SIGNATURES+  default contains :: (Gettable f, At m) => Index m -> IndexedLensLike' (Index m) f m Bool+  contains = containsAt+#endif++-- | A definition of 'contains' for types with an 'Ix' instance.+containsIx :: (Gettable f, Ixed (Accessor Any) m) => Index m -> IndexedLensLike' (Index m) f m Bool+containsIx i f = coerce . Lens.indexed f i . has (ix i)+{-# INLINE containsIx #-}++-- | A definition of 'ix' for types with an 'At' instance. This is the default+-- if you don't specify a definition for 'contains' and you are on GHC >= 7.0.2+containsAt :: (Gettable f, At m) => Index m -> IndexedLensLike' (Index m) f m Bool+containsAt i f = coerce . Lens.indexed f i . views (at i) isJust+{-# INLINE containsAt #-}++-- | Construct a 'contains' check based on some notion of 'Prelude.length' for the container.+containsLength :: forall i s. (Ord i, Num i) => (s -> i) -> i -> IndexedGetter i s Bool+containsLength sn = \ i pafb s -> coerce $ Lens.indexed pafb (i :: i) (0 <= i && i < sn s)+{-# INLINE containsLength #-}++-- | Construct a 'contains' check for a fixed number of elements.+containsN :: Int -> Int -> IndexedGetter Int s Bool+containsN n = \ i pafb _ -> coerce $ Lens.indexed pafb (i :: Int) (0 <= i && i < n)+{-# INLINE containsN #-}++-- | Construct a 'contains' check that uses an arbitrary test.+containsTest :: forall i s. (i -> s -> Bool) -> i -> IndexedGetter i s Bool+containsTest isb = \i pafb s -> coerce $ Lens.indexed pafb (i :: i) (isb i s)+{-# INLINE containsTest #-}++-- | Construct a 'contains' check that uses an arbitrary 'Map.lookup' function.+containsLookup :: forall i s a. (i -> s -> Maybe a) -> i -> IndexedGetter i s Bool+containsLookup isb = \i pafb s -> coerce $ Lens.indexed pafb (i :: i) (isJust (isb i s))+{-# INLINE containsLookup #-}++instance Gettable f => Contains f (e -> a) where+  contains i f _ = coerce (Lens.indexed f i True)+  {-# INLINE contains #-}++instance Functor f => Contains f IntSet where+  contains k f s = Lens.indexed f k (IntSet.member k s) <&> \b ->+    if b then IntSet.insert k s else IntSet.delete k s+  {-# INLINE contains #-}++instance (Functor f, Ord a) => Contains f (Set a) where+  contains k f s = Lens.indexed f k (Set.member k s) <&> \b ->+    if b then Set.insert k s else Set.delete k s+  {-# INLINE contains #-}++instance (Functor f, Eq a, Hashable a) => Contains f (HashSet a) where+  contains k f s = Lens.indexed f k (HashSet.member k s) <&> \b ->+    if b then HashSet.insert k s else HashSet.delete k s+  {-# INLINE contains #-}++instance Gettable f => Contains f [a] where+  contains = containsLength Prelude.length+  {-# INLINE contains #-}++instance Gettable f => Contains f (Seq a) where+  contains = containsLength Seq.length+  {-# INLINE contains #-}++#if MIN_VERSION_base(4,4,0)+instance Gettable f => Contains f (Complex a) where+  contains = containsN 2+  {-# INLINE contains #-}+#else+instance (Gettable f, RealFloat a) => Contains f (Complex a) where+  contains = containsN 2+  {-# INLINE contains #-}+#endif++instance Gettable f => Contains f (Tree a) where+  contains xs0 pafb = coerce . Lens.indexed pafb xs0 . go xs0 where+    go [] (Node _ _) = True+    go (i:is) (Node _ as) = goto i is as+    goto 0 is (a:_) = go is a+    goto _ _  []     = False+    goto n is (_:as) = (goto $! n - 1) is as+  {-# INLINE contains #-}++instance Gettable k => Contains k (Identity a) where+  contains () f _ = coerce (Lens.indexed f () True)+  {-# INLINE contains #-}++instance Gettable k => Contains k (a,b) where+  contains = containsN 2+  {-# INLINE contains #-}++instance Gettable k => Contains k (a,b,c) where+  contains = containsN 3+  {-# INLINE contains #-}++instance Gettable k => Contains k (a,b,c,d) where+  contains = containsN 4+  {-# INLINE contains #-}++instance Gettable k => Contains k (a,b,c,d,e) where+  contains = containsN 5+  {-# INLINE contains #-}++instance Gettable k => Contains k (a,b,c,d,e,f) where+  contains = containsN 6+  {-# INLINE contains #-}++instance Gettable k => Contains k (a,b,c,d,e,f,g) where+  contains = containsN 7+  {-# INLINE contains #-}++instance Gettable k => Contains k (a,b,c,d,e,f,g,h) where+  contains = containsN 8+  {-# INLINE contains #-}++instance Gettable k => Contains k (a,b,c,d,e,f,g,h,i) where+  contains = containsN 9+  {-# INLINE contains #-}++instance Gettable k => Contains k (IntMap a) where+  contains = containsLookup IntMap.lookup+  {-# INLINE contains #-}++instance (Gettable f, Ord k) => Contains f (Map k a) where+  contains = containsLookup Map.lookup+  {-# INLINE contains #-}++instance (Gettable f, Eq k, Hashable k) => Contains f (HashMap k a) where+  contains = containsLookup HashMap.lookup+  {-# INLINE contains #-}++instance (Gettable f, Ix i) => Contains f (Array i e) where+  contains = containsTest $ \i s -> inRange (bounds s) i+  {-# INLINE contains #-}++instance (Gettable f, IArray UArray e, Ix i) => Contains f (UArray i e) where+  contains = containsTest $ \i s -> inRange (bounds s) i+  {-# INLINE contains #-}++instance Gettable f => Contains f (Vector.Vector a) where+  contains = containsLength Vector.length+  {-# INLINE contains #-}++instance (Gettable f, Prim a) => Contains f (Prim.Vector a) where+  contains = containsLength Prim.length+  {-# INLINE contains #-}++instance (Gettable f, Storable a) => Contains f (Storable.Vector a) where+  contains = containsLength Storable.length+  {-# INLINE contains #-}++instance (Gettable f, Unbox a) => Contains f (Unboxed.Vector a) where+  contains = containsLength Unboxed.length+  {-# INLINE contains #-}++instance Gettable f => Contains f StrictT.Text where+  contains = containsTest $ \i s -> StrictT.compareLength s i == GT+  {-# INLINE contains #-}++instance Gettable f => Contains f LazyT.Text where+  contains = containsTest $ \i s -> LazyT.compareLength s i == GT+  {-# INLINE contains #-}++instance Gettable f => Contains f StrictB.ByteString where+  contains = containsLength StrictB.length+  {-# INLINE contains #-}++instance Gettable f => Contains f LazyB.ByteString where+  contains = containsTest $ \i s -> not (LazyB.null (LazyB.drop i s))+  {-# INLINE contains #-}++-- | This provides a common notion of a value at an index that is shared by both 'Ixed' and 'At'.+type family IxValue (m :: *) :: *++-- | This simple 'IndexedTraversal' lets you 'traverse' the value at a given+-- key in a 'Map' or element at an ordinal position in a list or 'Seq'.+class (Functor f, Contains (Accessor (IxValue m)) m) => Ixed f m where+  -- | This simple 'IndexedTraversal' lets you 'traverse' the value at a given+  -- key in a 'Map' or element at an ordinal position in a list or 'Seq'.+  --+  -- /NB:/ Setting the value of this 'Traversal' will only set the value in the+  -- 'Lens' 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+  ix :: Index m -> IndexedLensLike' (Index m) f m (IxValue m)+#ifdef DEFAULT_SIGNATURES+  default ix :: (Applicative f, At m) => Index m -> IndexedLensLike' (Index m) f m (IxValue m)+  ix = ixAt+  {-# INLINE ix #-}+#endif++-- | A definition of 'ix' for types with an 'At' instance. This is the default+-- if you don't specify a definition for 'ix'.+ixAt :: (Applicative f, At m) => Index m -> IndexedLensLike' (Index m) f m (IxValue m)+ixAt i = at i <. traverse+{-# INLINE ixAt #-}++-- | A definition of 'ix' for types with an 'Each' instance.+ixEach :: (Applicative f, Eq (Index m), Each f m m (IxValue m) (IxValue m)) => Index m -> IndexedLensLike' (Index m) f m (IxValue m)+ixEach i = each . Lens.index i+{-# INLINE ixEach #-}++type instance IxValue [a] = a+instance Applicative f => Ixed f [a] where+  ix k f xs0 = go xs0 k where+    go [] _ = pure []+    go (a:as) 0 = Lens.indexed f k a <&> (:as)+    go (a:as) i = (a:) <$> (go as $! i - 1)+  {-# INLINE ix #-}++type instance IxValue (Identity a) = a+instance Functor f => Ixed f (Identity a) where+  ix () f (Identity a) = Identity <$> Lens.indexed f () a+  {-# INLINE ix #-}++type instance IxValue (Tree a) = a+instance Applicative f => Ixed f (Tree a) where+  ix xs0 f = go xs0 where+    go [] (Node a as) = Lens.indexed f xs0 a <&> \a' -> Node a' as+    go (i:is) (Node a as) = Node a <$> goto is as i+    goto is (a:as) 0 = go is a <&> (:as)+    goto is (_:as) n = goto is as $! n - 1+    goto _  []     _ = pure []+  {-# INLINE ix #-}++type instance IxValue (Seq a) = a+instance Applicative f => Ixed f (Seq a) where+  ix i f m+    | 0 <= i && i < Seq.length m = Lens.indexed f i (Seq.index m i) <&> \a -> Seq.update i a m+    | otherwise                  = pure m+  {-# INLINE ix #-}++type instance IxValue (IntMap a) = a+instance Applicative f => Ixed f (IntMap a) where+  ix k f m = case IntMap.lookup k m of+     Just v -> Lens.indexed f k v <&> \v' -> IntMap.insert k v' m+     Nothing -> pure m+  {-# INLINE ix #-}++type instance IxValue (Map k a) = a+instance (Applicative f, Ord k) => Ixed f (Map k a) where+  ix k f m = case Map.lookup k m of+     Just v  -> Lens.indexed f k v <&> \v' -> Map.insert k v' m+     Nothing -> pure m+  {-# INLINE ix #-}++type instance IxValue (HashMap k a) = a+instance (Applicative f, Eq k, Hashable k) => Ixed f (HashMap k a) where+  ix k f m = case HashMap.lookup k m of+     Just v  -> Lens.indexed f k v <&> \v' -> HashMap.insert k v' m+     Nothing -> pure m+  {-# INLINE ix #-}++type instance IxValue (Array i e) = e+-- |+-- @+-- arr '!' i ≡ arr 'Control.Lens.Getter.^.' 'ix' i+-- arr '//' [(i,e)] ≡ 'ix' i 'Control.Lens.Setter..~' e '$' arr+-- @+instance (Applicative f, Ix i) => Ixed f (Array i e) where+  ix i f arr+    | inRange (bounds arr) i = Lens.indexed f i (arr Array.! i) <&> \e -> arr Array.// [(i,e)]+    | otherwise              = pure arr+  {-# INLINE ix #-}++type instance IxValue (UArray i e) = e+-- |+-- @+-- arr '!' i ≡ arr 'Control.Lens.Getter.^.' 'ix' i+-- arr '//' [(i,e)] ≡ 'ix' i 'Control.Lens.Setter..~' e '$' arr+-- @+instance (Applicative f, IArray UArray e, Ix i) => Ixed f (UArray i e) where+  ix i f arr+    | inRange (bounds arr) i = Lens.indexed f i (arr Array.! i) <&> \e -> arr Array.// [(i,e)]+    | otherwise              = pure arr+  {-# INLINE ix #-}++type instance IxValue (Vector.Vector a) = a+instance Applicative f => Ixed f (Vector.Vector a) where+  ix i f v+    | 0 <= i && i < Vector.length v = Lens.indexed f i (v Vector.! i) <&> \a -> v Vector.// [(i, a)]+    | otherwise                     = pure v+  {-# INLINE ix #-}++type instance IxValue (Prim.Vector a) = a+instance (Applicative f, Prim a) => Ixed f (Prim.Vector a) where+  ix i f v+    | 0 <= i && i < Prim.length v = Lens.indexed f i (v Prim.! i) <&> \a -> v Prim.// [(i, a)]+    | otherwise                   = pure v+  {-# INLINE ix #-}++type instance IxValue (Storable.Vector a) = a+instance (Applicative f, Storable a) => Ixed f (Storable.Vector a) where+  ix i f v+    | 0 <= i && i < Storable.length v = Lens.indexed f i (v Storable.! i) <&> \a -> v Storable.// [(i, a)]+    | otherwise                       = pure v+  {-# INLINE ix #-}++type instance IxValue (Unboxed.Vector a) = a+instance (Applicative f, Unbox a) => Ixed f (Unboxed.Vector a) where+  ix i f v+    | 0 <= i && i < Unboxed.length v = Lens.indexed f i (v Unboxed.! i) <&> \a -> v Unboxed.// [(i, a)]+    | otherwise                      = pure v+  {-# INLINE ix #-}++type instance IxValue StrictT.Text = Char+instance Applicative f => Ixed f StrictT.Text where+  ix e f s = case StrictT.splitAt e s of+     (l, mr) -> case StrictT.uncons mr of+       Nothing      -> pure s+       Just (c, xs) -> Lens.indexed f e c <&> \d -> StrictT.concat [l, StrictT.singleton d, xs]+  {-# INLINE ix #-}++type instance IxValue LazyT.Text = Char+instance Applicative f => Ixed f LazyT.Text where+  ix e f s = case LazyT.splitAt e s of+     (l, mr) -> case LazyT.uncons mr of+       Nothing      -> pure s+       Just (c, xs) -> Lens.indexed f e c <&> \d -> LazyT.append l (LazyT.cons d xs)+  {-# INLINE ix #-}++type instance IxValue StrictB.ByteString = Word8+instance Applicative f => Ixed f StrictB.ByteString where+  ix e f s = case StrictB.splitAt e s of+     (l, mr) -> case StrictB.uncons mr of+       Nothing      -> pure s+       Just (c, xs) -> Lens.indexed f e c <&> \d -> StrictB.concat [l, StrictB.singleton d, xs]+  {-# INLINE ix #-}++type instance IxValue LazyB.ByteString = Word8+instance Applicative f => Ixed f LazyB.ByteString where+  -- TODO: we could be lazier, returning each chunk as it is passed+  ix e f s = case LazyB.splitAt e s of+     (l, mr) -> case LazyB.uncons mr of+       Nothing      -> pure s+       Just (c, xs) -> Lens.indexed f e c <&> \d -> LazyB.append l (LazyB.cons d xs)+  {-# INLINE ix #-}++type instance IxValue (k -> a) = a+instance (Functor f, Eq k) => Ixed f (k -> a) where+  ix e g f = Lens.indexed g e (f e) <&> \a' e' -> if e == e' then a' else f e'+  {-# INLINE ix #-}++#if MIN_VERSION_base(4,4,0)+type instance IxValue (Complex a) = a+instance Applicative f => Ixed f (Complex a) where+  ix = ixEach+  {-# INLINE ix #-}+#else+instance (Applicative f, RealFloat a) => Ixed f (Complex a) where+  ix = ixEach+  {-# INLINE ix #-}+#endif++type instance IxValue (a,a) = a+instance (Applicative f, a ~ b) => Ixed f (a,b) where+  ix = ixEach+  {-# INLINE ix #-}++type instance IxValue (a,a,a) = a+instance (Applicative f, a ~ b, b ~ c) => Ixed f (a,b,c) where+  ix = ixEach+  {-# INLINE ix #-}++type instance IxValue (a,a,a,a) = a+instance (Applicative f, a ~ b, b ~ c, c ~ d) => Ixed f (a,b,c,d) where+  ix = ixEach+  {-# INLINE ix #-}++type instance IxValue (a,a,a,a,a) = a+instance (Applicative f, a ~ b, b ~ c, c ~ d, d ~ e) => Ixed f (a,b,c,d,e) where+  ix = ixEach+  {-# INLINE ix #-}++type instance IxValue (a,a,a,a,a,a) = a+instance (Applicative f, a ~ b, b ~ c, c ~ d, d ~ e, e ~ f') => Ixed f (a,b,c,d,e,f') where+  ix = ixEach+  {-# INLINE ix #-}++type instance IxValue (a,a,a,a,a,a,a) = a+instance (Applicative f, a ~ b, b ~ c, c ~ d, d ~ e, e ~ f', f' ~ g) => Ixed f (a,b,c,d,e,f',g) where+  ix = ixEach+  {-# INLINE ix #-}++type instance IxValue (a,a,a,a,a,a,a,a) = a+instance (Applicative f, a ~ b, b ~ c, c ~ d, d ~ e, e ~ f', f' ~ g, g ~ h) => Ixed f (a,b,c,d,e,f',g,h) where+  ix = ixEach+  {-# INLINE ix #-}++type instance IxValue (a,a,a,a,a,a,a,a,a) = a+instance (Applicative f, a ~ b, b ~ c, c ~ d, d ~ e, e ~ f', f' ~ g, g ~ h, h ~ i) => Ixed f (a,b,c,d,e,f',g,h,i) where+  ix = ixEach+  {-# INLINE ix #-}++-- | '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'+-- @+class At m where+  -- |+  -- >>> 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.+  at :: Index m -> IndexedLens' (Index m) m (Maybe (IxValue m))++instance At (IntMap a) where+  at k f m = Lens.indexed f k mv <&> \r -> case r of+    Nothing -> maybe m (const (IntMap.delete k m)) mv+    Just v' -> IntMap.insert k v' m+    where mv = IntMap.lookup k m+  {-# INLINE at #-}++instance Ord k => At (Map k a) where+  at k f m = Lens.indexed f k mv <&> \r -> case r of+    Nothing -> maybe m (const (Map.delete k m)) mv+    Just v' -> Map.insert k v' m+    where mv = Map.lookup k m+  {-# INLINE at #-}++instance (Eq k, Hashable k) => At (HashMap k a) where+  at k f m = Lens.indexed f k mv <&> \r -> case r of+    Nothing -> maybe m (const (HashMap.delete k m)) mv+    Just v' -> HashMap.insert k v' m+    where mv = HashMap.lookup k m+  {-# INLINE at #-}

@@ -1,192 +0,0 @@-{-# LANGUAGE CPP #-}-{-# LANGUAGE MagicHash #-}-{-# LANGUAGE TypeFamilies #-}-{-# LANGUAGE FlexibleContexts #-}-{-# LANGUAGE FlexibleInstances #-}-{-# LANGUAGE MultiParamTypeClasses #-}-{-# LANGUAGE FunctionalDependencies #-}-{-# LANGUAGE UndecidableInstances #-}-#if defined(TRUSTWORTHY) && !defined(SAFE)-{-# LANGUAGE Trustworthy #-}-#endif--------------------------------------------------------------------------------- |--- Module      :  Control.Lens.Classes--- Copyright   :  (C) 2012 Edward Kmett--- License     :  BSD-style (see the file LICENSE)--- Maintainer  :  Edward Kmett <ekmett@gmail.com>--- Stability   :  provisional--- Portability :  Rank2Types---------------------------------------------------------------------------------module Control.Lens.Classes-  (-  -- * Getters-    Gettable(..)-  , noEffect-  -- * Actions-  , Effective(..)-  -- * Setters-  , Settable(..)-  -- * Isomorphisms-  , Isomorphic(..)-  -- * Prisms-  , Prismatic(..)-  -- * Indexable-  , Indexable(..)-  ) where--import Control.Applicative-import Control.Applicative.Backwards (Backwards(..))-import Control.Category-import Control.Monad (liftM)-import Data.Functor.Compose (Compose(..))-import Data.Functor.Identity (Identity(..))-import Data.Monoid (Dual(..))-import Prelude hiding ((.),id)-#ifndef SAFE-import Unsafe.Coerce (unsafeCoerce)-#endif--#ifndef SAFE-#define UNSAFELY(x) unsafeCoerce-#else-#define UNSAFELY(f) (\g -> g `seq` \x -> (f) (g x))-#endif------------------------------------------------------------------------------------- Gettables & Accessors------------------------------------------------------------------------------------ | Generalizing 'Const' so we can apply simple 'Applicative'--- transformations to it and so we can get nicer error messages------ A 'Gettable' 'Functor' ignores its argument, which it carries solely as a--- phantom type parameter.------ To ensure this, an instance of 'Gettable' is required to satisfy:------ @'id' = 'fmap' f = 'coerce'@------ Which is equivalent to making a @'Gettable' f@ an \"anyvariant\" functor.-----class Functor f => Gettable f where-  -- | Replace the phantom type argument.-  coerce :: f a -> f b--instance Gettable (Const r) where-  coerce (Const m) = Const m--instance Gettable f => Gettable (Backwards f) where-  coerce = Backwards . coerce . forwards--instance (Functor f, Gettable g) => Gettable (Compose f g) where-  coerce = Compose . fmap coerce . getCompose---- | The 'mempty' equivalent for a 'Gettable' 'Applicative' 'Functor'.-noEffect :: (Applicative f, Gettable f) => f a-noEffect = coerce $ pure ()-{-# INLINE noEffect #-}------------------------------------------------------------------------------------ Programming with Effects------------------------------------------------------------------------------------ | An 'Effective' 'Functor' ignores its argument and is isomorphic to a 'Monad' wrapped around a value.------ That said, the 'Monad' is possibly rather unrelated to any 'Applicative' structure.-class (Monad m, Gettable f) => Effective m r f | f -> m r where-  effective :: m r -> f a-  ineffective :: f a -> m r--instance Effective m r f => Effective m (Dual r) (Backwards f) where-  effective = Backwards . effective . liftM getDual-  ineffective = liftM Dual . ineffective . forwards---------------------------------------------------------------------------------- Settable---------------------------------------------------------------------------------- | Anything 'Settable' must be isomorphic to the 'Identity' 'Functor'.-class Applicative f => Settable f where-  untainted :: f a -> a--  untainted# :: (a -> f b) -> a -> b-  untainted# g = g `seq` \x -> untainted (g x)--  tainted# :: (a -> b) -> a -> f b-  tainted# g = g `seq` \x -> pure (g x)---- | so you can pass our a 'Control.Lens.Setter.Setter' into combinators from other lens libraries-instance Settable Identity where-  untainted = runIdentity-  untainted# = UNSAFELY(runIdentity)-  {-# INLINE untainted #-}-  tainted# = UNSAFELY(Identity)-  {-# INLINE tainted# #-}---- | 'Control.Lens.Fold.backwards'-instance Settable f => Settable (Backwards f) where-  untainted = untainted . forwards-  {-# INLINE untainted #-}--instance (Settable f, Settable g) => Settable (Compose f g) where-  untainted = untainted . untainted . getCompose-  {-# INLINE untainted #-}---------------------------------------------------------------------------------- Isomorphisms---------------------------------------------------------------------------------- | Used to provide overloading of isomorphism application------ An instance of 'Isomorphic' is a 'Category' with a canonical mapping to it from the--- category of isomorphisms over Haskell types.-class Category k => Isomorphic k where-  -- | Build a simple isomorphism from a pair of inverse functions-  ---  -- @-  -- 'Control.Lens.Getter.view' ('iso' f g) ≡ f-  -- 'Control.Lens.Getter.view' ('Control.Lens.Iso.from' ('iso' f g)) ≡ g-  -- 'Control.Lens.Setter.set' ('iso' f g) h ≡ g '.' h '.' f-  -- 'Control.Lens.Setter.set' ('Control.Lens.Iso.from' ('iso' f g)) h ≡ f '.' h '.' g-  -- @-  iso :: Functor f => (s -> a) -> (b -> t) -> k (a -> f b) (s -> f t)--instance Isomorphic (->) where-  iso sa bt afb s = bt <$> afb (sa s)-  {-# INLINE iso #-}---------------------------------------------------------------------------------- Prisms---------------------------------------------------------------------------------- | Used to provide overloading of prisms.------ An instance of 'Prismatic' is a 'Category' with a canonical mapping to it from the category--- of embedding-projection pairs over Haskell types.-class Isomorphic k => Prismatic k where-  -- | Build a 'Control.Lens.Prism.Prism'.-  ---  -- @'Either' t a@ is used instead of @'Maybe' a@ to permit the types of @s@ and @t@ to differ.-  prism :: Applicative f => (b -> t) -> (s -> Either t a) -> k (a -> f b) (s -> f t)--instance Prismatic (->) where-  prism bt seta afb = either pure (fmap bt . afb) . seta-  {-# INLINE prism #-}--------------------------------------------------------------------------------- Indexed Internals---------------------------------------------------------------------------------- | This class permits overloading of function application for things that--- also admit a notion of a key or index.-class Indexable i k where-  -- | Build a function from an 'Indexed' function-  indexed :: ((i -> a) -> b) -> k a b--instance Indexable i (->) where-  indexed f = f . const-  {-# INLINE indexed #-}

@@ -1,53 +1,66 @@--------------------------------------------------------------------------------+-------------------------------------------------------------------------------- -- | -- Module      :  Control.Lens.Combinators--- Copyright   :  (C) 2012 Edward Kmett+-- Copyright   :  (C) 2012-13 Edward Kmett -- License     :  BSD-style (see the file LICENSE) -- Maintainer  :  Edward Kmett <ekmett@gmail.com> -- Stability   :  provisional -- Portability :  portable --+-- These are general purpose combinators that provide utility for non-lens code ------------------------------------------------------------------------------- module Control.Lens.Combinators-  ( (<$!>), (<$!), (<&>), (??)+  ( (&)+  , (<&>)+  , (??)   ) where  import Data.Functor ((<$>))  -- $setup -- >>> import Control.Lens+-- >>> import Control.Monad.State+-- >>> import Debug.SimpleReflect.Expr+-- >>> import Debug.SimpleReflect.Vars as Vars hiding (f)+-- >>> let f :: Expr -> Expr; f = Debug.SimpleReflect.Vars.f -infixl 4 <$!>, <$!-infixl 1 <&>, ??+infixl 1 &, <&>, ?? --- | A strict version of ('Data.Functor.<$>') for monads.+-- | Passes the result of the left side to the function on the right side (forward pipe operator). ----- >>> (+1) <$!> [1,2,3,4]--- [2,3,4,5]-(<$!>) :: Monad m => (a -> b) -> m a -> m b-f <$!> m = do-  a <- m-  return $! f a-{-# INLINE (<$!>) #-}---- | A strict version of ('Data.Functor.<$') for monads.+-- This is the flipped version of ('$'), which is more common in languages like F# as (@|>@) where it is needed+-- for inference. Here it is supplied for notational convenience and given a precedence that allows it+-- to be nested inside uses of ('$'). ----- >>> () <$! [1,2,3,4]--- [(),(),(),()]-(<$!) :: Monad m => b -> m a -> m b-b <$! m = do-  _ <- m-  return $! b-{-# INLINE (<$!) #-}+-- >>> a & f+-- f a+--+-- >>> "hello" & length & succ+-- 6+--+-- This combinator is commonly used when applying multiple 'Control.Lens.Lens.Lens' operations in sequence.+--+-- >>> ("hello","world") & _1.element 0 .~ 'j' & _1.element 4 .~ 'y'+-- ("jelly","world")+--+-- This reads somewhat similar to:+--+-- >>> flip execState ("hello","world") $ do _1.element 0 .= 'j'; _1.element 4 .= 'y'+-- ("jelly","world")+(&) :: a -> (a -> b) -> b+a & f = f a+{-# INLINE (&) #-} --- | Infix flipped fmap.+-- | Infix flipped 'fmap'. ----- @('<&>') = 'flip' 'fmap'@+-- @+-- ('<&>') = 'flip' 'fmap'+-- @ (<&>) :: Functor f => f a -> (a -> b) -> f b as <&> f = f <$> as {-# INLINE (<&>) #-} --- | This is convenient to 'flip' argument order of composite functions+-- | This is convenient to 'flip' argument order of composite functions. -- -- >>> over _2 ?? ("hello","world") $ length -- ("hello",5)

@@ -0,0 +1,444 @@+{-# LANGUAGE CPP #-}+{-# LANGUAGE FlexibleContexts #-}+{-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE MultiParamTypeClasses #-}+{-# LANGUAGE FunctionalDependencies #-}+#ifdef TRUSTWORTHY+{-# LANGUAGE Trustworthy #-}+#endif+-----------------------------------------------------------------------------+-- |+-- Module      :  Control.Lens.Cons+-- Copyright   :  (C) 2012-13 Edward Kmett+-- License     :  BSD-style (see the file LICENSE)+-- Maintainer  :  Edward Kmett <ekmett@gmail.com>+-- Stability   :  experimental+-- Portability :  non-portable+--+-----------------------------------------------------------------------------+module Control.Lens.Cons+  (+  -- * Cons+    Cons(..)+  , (<|)+  , cons+  , uncons+  , _head, _tail+  -- * Snoc+  , Snoc(..)+  , (|>)+  , snoc+  , unsnoc+  , _init, _last+  ) where++import Control.Applicative+import Control.Lens.Equality (simply)+import Control.Lens.Fold+import Control.Lens.Internal.Getter+import Control.Lens.Internal.Review+import Control.Lens.Prism+import Control.Lens.Review+import Control.Lens.Tuple+import Control.Lens.Type+import qualified Data.ByteString      as StrictB+import qualified Data.ByteString.Lazy as LazyB+import           Data.Functor.Identity+import           Data.Monoid+import           Data.Profunctor+import qualified Data.Sequence as Seq+import           Data.Sequence hiding ((<|), (|>))+import qualified Data.Text      as StrictT+import qualified Data.Text.Lazy as LazyT+import           Data.Vector (Vector)+import qualified Data.Vector as Vector+import           Data.Vector.Storable (Storable)+import qualified Data.Vector.Storable as Storable+import           Data.Vector.Primitive (Prim)+import qualified Data.Vector.Primitive as Prim+import           Data.Vector.Unboxed (Unbox)+import qualified Data.Vector.Unboxed as Unbox+import           Data.Word++-- $setup+-- >>> import Control.Lens+-- >>> import Debug.SimpleReflect.Expr+-- >>> import Debug.SimpleReflect.Vars as Vars hiding (f,g)+-- >>> let f :: Expr -> Expr; f = Debug.SimpleReflect.Vars.f+-- >>> let g :: Expr -> Expr; g = Debug.SimpleReflect.Vars.g++infixr 5 <|, `cons`+infixl 5 |>, `snoc`++------------------------------------------------------------------------------+-- Cons+------------------------------------------------------------------------------++-- | This class provides a way to attach or detach elements on the left+-- side of a structure in a flexible manner.+class (Profunctor p, Functor f) => Cons p f s t a b | s -> a, t -> b, s b -> t, t a -> s where+  -- | Most of the time this is a 'Prism'.+  --+  -- @+  -- '_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'' 'StrictT.Text' ('Char', 'StrictT.Text')+  -- '_Cons' :: 'Prism'' 'StrictB.ByteString' ('Word8', 'StrictB.ByteString')+  -- @+  --+  -- However, by including @p@ and @f@ in the class you can write instances that only permit 'uncons'+  -- or which only permit 'cons', or where '_head' and '_tail' are lenses and not traversals.+  _Cons :: Overloaded p f s t (a,s) (b,t)++instance (Choice p, Applicative f) => Cons p f [a] [b] a b where+  _Cons = prism (uncurry (:)) $ \ aas -> case aas of+    (a:as) -> Right (a, as)+    []     -> Left  []+  {-# INLINE _Cons #-}++instance (Choice p, Applicative f) => Cons p f (Seq a) (Seq b) a b where+  _Cons = prism (uncurry (Seq.<|)) $ \aas -> case viewl aas of+    a :< as -> Right (a, as)+    EmptyL  -> Left mempty+  {-# INLINE _Cons #-}++instance (Choice p, Applicative f) => Cons p f StrictB.ByteString StrictB.ByteString Word8 Word8 where+  _Cons = prism' (uncurry StrictB.cons) StrictB.uncons++instance (Choice p, Applicative f) => Cons p f LazyB.ByteString LazyB.ByteString Word8 Word8 where+  _Cons = prism' (uncurry LazyB.cons) LazyB.uncons++instance (Choice p, Applicative f) => Cons p f StrictT.Text StrictT.Text Char Char where+  _Cons = prism' (uncurry StrictT.cons) StrictT.uncons++instance (Choice p, Applicative f) => Cons p f LazyT.Text LazyT.Text Char Char where+  _Cons = prism' (uncurry LazyT.cons) LazyT.uncons++instance (Choice p, Applicative f) => Cons p f (Vector a) (Vector b) a b where+  _Cons = prism (uncurry Vector.cons) $ \v ->+    if Vector.null v+    then Left Vector.empty+    else Right (Vector.unsafeHead v, Vector.unsafeTail v)+  {-# INLINE _Cons #-}++instance (Choice p, Applicative f, Prim a, Prim b) => Cons p f (Prim.Vector a) (Prim.Vector b) a b where+  _Cons = prism (uncurry Prim.cons) $ \v ->+    if Prim.null v+    then Left Prim.empty+    else Right (Prim.unsafeHead v, Prim.unsafeTail v)+  {-# INLINE _Cons #-}++instance (Choice p, Applicative f, Storable a, Storable b) => Cons p f (Storable.Vector a) (Storable.Vector b) a b where+  _Cons = prism (uncurry Storable.cons) $ \v ->+    if Storable.null v+    then Left Storable.empty+    else Right (Storable.unsafeHead v, Storable.unsafeTail v)+  {-# INLINE _Cons #-}++instance (Choice p, Applicative f, Unbox a, Unbox b) => Cons p f (Unbox.Vector a) (Unbox.Vector b) a b where+  _Cons = prism (uncurry Unbox.cons) $ \v ->+    if Unbox.null v+    then Left Unbox.empty+    else Right (Unbox.unsafeHead v, Unbox.unsafeTail v)+  {-# INLINE _Cons #-}++-- | 'cons' an element onto a container.+--+-- This is an infix alias for 'cons'.+(<|) :: Cons Reviewed Identity s s a a => a -> s -> s+(<|) = curry (simply review _Cons)+{-# INLINE (<|) #-}++-- | 'cons' an element onto a container.+cons :: Cons Reviewed Identity s s a a => a -> s -> s+cons = curry (simply review _Cons)++-- | Attempt to extract the left-most element from a container, and a version of the container without that element.+uncons :: Cons (->) (Accessor (First (a, s))) s s a a => s -> Maybe (a, s)+uncons = simply preview _Cons+{-# INLINE uncons #-}++-- | 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 'Data.Traversable.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+-- @+_head :: Cons (->) f s s a a => LensLike' f s a+_head = _Cons._1+{-# INLINE _head #-}++-- | 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 'Control.Traversable.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)+-- @+_tail :: Cons (->) f s s a a => LensLike' f s s+_tail = _Cons._2+{-# INLINE _tail #-}++------------------------------------------------------------------------------+-- Snoc+------------------------------------------------------------------------------++-- | This class provides a way to attach or detach elements on the right+-- side of a structure in a flexible manner.+class (Profunctor p, Functor f) => Snoc p f s t a b | s -> a, t -> b, s b -> t, t a -> s where+  -- | Most of the time this is a 'Prism'.+  --+  -- @+  -- '_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'' 'StrictT.Text' ('StrictT.Text', 'Char')+  -- '_Snoc' :: 'Prism'' 'StrictB.ByteString' ('StrictB.ByteString', 'Word8')+  -- @+  --+  -- However, by including @p@ and @f@ in the class you can write instances that only permit 'unsnoc'+  -- or which only permit 'snoc' or where '_init' and '_last' are lenses and not traversals.+  _Snoc :: Overloaded p f s t (s,a) (t,b)++instance (Choice p, Applicative f) => Snoc p f [a] [b] a b where+  _Snoc = prism (\(as,a) -> as Prelude.++ [a]) $ \aas -> if Prelude.null aas+    then Left []+    else Right (Prelude.init aas, Prelude.last aas)+  {-# INLINE _Snoc #-}++instance (Choice p, Applicative f) => Snoc p f (Seq a) (Seq b) a b where+  _Snoc = prism (uncurry (Seq.|>)) $ \aas -> case viewr aas of+    as :> a -> Right (as, a)+    EmptyR  -> Left mempty+  {-# INLINE _Snoc #-}++instance (Choice p, Applicative f) => Snoc p f (Vector a) (Vector b) a b where+  _Snoc = prism (uncurry Vector.snoc) $ \v -> if Vector.null v+    then Left Vector.empty+    else Right (Vector.unsafeInit v, Vector.unsafeLast v)+  {-# INLINE _Snoc #-}++instance (Choice p, Applicative f, Prim a, Prim b) => Snoc p f (Prim.Vector a) (Prim.Vector b) a b where+  _Snoc = prism (uncurry Prim.snoc) $ \v -> if Prim.null v+    then Left Prim.empty+    else Right (Prim.unsafeInit v, Prim.unsafeLast v)+  {-# INLINE _Snoc #-}++instance (Choice p, Applicative f, Storable a, Storable b) => Snoc p f (Storable.Vector a) (Storable.Vector b) a b where+  _Snoc = prism (uncurry Storable.snoc) $ \v -> if Storable.null v+    then Left Storable.empty+    else Right (Storable.unsafeInit v, Storable.unsafeLast v)+  {-# INLINE _Snoc #-}++instance (Choice p, Applicative f, Unbox a, Unbox b) => Snoc p f (Unbox.Vector a) (Unbox.Vector b) a b where+  _Snoc = prism (uncurry Unbox.snoc) $ \v -> if Unbox.null v+    then Left Unbox.empty+    else Right (Unbox.unsafeInit v, Unbox.unsafeLast v)+  {-# INLINE _Snoc #-}++instance (Choice p, Applicative f) => Snoc p f StrictB.ByteString StrictB.ByteString Word8 Word8 where+  _Snoc = prism (uncurry StrictB.snoc) $ \v -> if StrictB.null v+    then Left StrictB.empty+    else Right (StrictB.init v, StrictB.last v)+  {-# INLINE _Snoc #-}++instance (Choice p, Applicative f) => Snoc p f LazyB.ByteString LazyB.ByteString Word8 Word8 where+  _Snoc = prism (uncurry LazyB.snoc) $ \v -> if LazyB.null v+    then Left LazyB.empty+    else Right (LazyB.init v, LazyB.last v)+  {-# INLINE _Snoc #-}++instance (Choice p, Applicative f) => Snoc p f StrictT.Text StrictT.Text Char Char where+  _Snoc = prism (uncurry StrictT.snoc) $ \v -> if StrictT.null v+    then Left StrictT.empty+    else Right (StrictT.init v, StrictT.last v)+  {-# INLINE _Snoc #-}++instance (Choice p, Applicative f) => Snoc p f LazyT.Text LazyT.Text Char Char where+  _Snoc = prism (uncurry LazyT.snoc) $ \v -> if LazyT.null v+    then Left LazyT.empty+    else Right (LazyT.init v, LazyT.last v)+  {-# INLINE _Snoc #-}++-- | 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) a+-- '_init' :: 'Traversal'' ('Vector' a) a+-- @+_init :: Snoc (->) f s s a a => LensLike' f s s+_init = _Snoc._1+{-# INLINE _init #-}++-- | 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'+-- fromList "abcdQ"+--+-- @+-- '_last' :: 'Traversal'' [a] [a]+-- '_last' :: 'Traversal'' ('Seq' a) ('Seq' a)+-- '_last' :: 'Traversal'' ('Vector' a) ('Vector' a)+-- @+_last :: Snoc (->) f s s a a => LensLike' f s a+_last = _Snoc._2+{-# INLINE _last #-}++-- | 'snoc' an element onto the end of a container.+--+-- This is an infix alias for 'snoc'.+(|>) :: Snoc Reviewed Identity s s a a => s -> a -> s+(|>) = curry (simply review _Snoc)+{-# INLINE (|>) #-}++-- | 'snoc' an element onto the end of a container.+snoc  :: Snoc Reviewed Identity s s a a => s -> a -> s+snoc = curry (simply review _Snoc)+{-# INLINE snoc #-}++-- | Attempt to extract the right-most element from a container, and a version of the container without that element.+unsnoc :: Snoc (->) (Accessor (First (s, a))) s s a a => s -> Maybe (s, a)+unsnoc s = simply preview _Snoc s+{-# INLINE unsnoc #-}

@@ -1,6 +1,8 @@ {-# LANGUAGE CPP #-}+{-# LANGUAGE GADTs #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE FlexibleContexts #-}+{-# LANGUAGE DefaultSignatures #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE UndecidableInstances #-}@@ -16,7 +18,7 @@ ----------------------------------------------------------------------------- -- | -- Module      :  Control.Lens.Each--- Copyright   :  (C) 2012 Edward Kmett+-- Copyright   :  (C) 2012-13 Edward Kmett -- License     :  BSD-style (see the file LICENSE) -- Maintainer  :  Edward Kmett <ekmett@gmail.com> -- Stability   :  experimental@@ -24,35 +26,83 @@ -- ----------------------------------------------------------------------------- module Control.Lens.Each-  ( Each(..)+  (+  -- * Indices+    Index+  -- * Each+  , Each(..)   ) where  import Control.Applicative+import Control.Lens.Cons as Lens+import Control.Lens.Internal.Deque+import Control.Lens.Internal.Setter import Control.Lens.Indexed as Lens-import Control.Lens.IndexedTraversal-import Control.Lens.Traversal import Control.Lens.Iso+import Control.Lens.Type+import Control.Lens.Traversal+import Data.Array.Unboxed as Unboxed+import Data.Array.IArray as IArray import Data.ByteString as StrictB import Data.ByteString.Lazy as LazyB import Data.Complex+import Data.Foldable as Foldable import Data.Functor.Identity+import Data.HashMap.Lazy as HashMap+import Data.HashSet import Data.Int+import Data.IntMap as IntMap+import Data.IntSet+import Data.Map as Map+import Data.Set import Data.Sequence as Seq import Data.Text as StrictT import Data.Text.Lazy as LazyT import Data.Traversable import Data.Tree as Tree+import qualified Data.Vector as Vector+import qualified Data.Vector.Primitive as Prim+import Data.Vector.Primitive (Prim)+import qualified Data.Vector.Storable as Storable+import Data.Vector.Storable (Storable)+import qualified Data.Vector.Unboxed as Unboxed+import Data.Vector.Unboxed (Unbox) import Data.Word-import Data.Map as Map-import Data.IntMap as IntMap-import Data.HashMap.Lazy as HashMap-import Data.Vector as Vector-import Data.Vector.Primitive as Prim-import Data.Vector.Storable as Storable-import Data.Vector.Unboxed as Unboxed-import Data.Array.Unboxed as Unboxed-import Data.Array.IArray as IArray +-- | This is a common 'Index' type shared by 'Each', 'Control.Lens.At.At', 'Control.Lens.At.Contains' and 'Control.Lens.At.Ixed'.+type family Index (s :: *) :: *+type instance Index (e -> a) = e+type instance Index IntSet = Int+type instance Index (Set a) = a+type instance Index (HashSet a) = a+type instance Index [a] = Int+type instance Index (Seq a) = Int+type instance Index (a,b) = Int+type instance Index (a,b,c) = Int+type instance Index (a,b,c,d) = Int+type instance Index (a,b,c,d,e) = Int+type instance Index (a,b,c,d,e,f) = Int+type instance Index (a,b,c,d,e,f,g) = Int+type instance Index (a,b,c,d,e,f,g,h) = Int+type instance Index (a,b,c,d,e,f,g,h,i) = Int+type instance Index (IntMap a) = Int+type instance Index (Map k a) = k+type instance Index (HashMap k a) = k+type instance Index (Array i e) = i+type instance Index (UArray i e) = i+type instance Index (Vector.Vector a) = Int+type instance Index (Prim.Vector a) = Int+type instance Index (Storable.Vector a) = Int+type instance Index (Unboxed.Vector a) = Int+type instance Index (Complex a) = Int+type instance Index (Identity a) = ()+type instance Index (Maybe a) = ()+type instance Index (Tree a) = [Int]+type instance Index StrictT.Text = Int+type instance Index LazyT.Text = Int64+type instance Index StrictB.ByteString = Int+type instance Index LazyB.ByteString = Int64+ -- $setup -- >>> import Control.Lens -- >>> import Data.Text.Strict.Lens as Text@@ -65,134 +115,186 @@ -- >>> (1,2,3) & each *~ 10 -- (10,20,30) ----- It can also be used on monomorphic containers like 'StrictT.Text' or 'StrictB.ByteString'+-- It can also be used on monomorphic containers like 'StrictT.Text' or 'StrictB.ByteString'. -- -- >>> over each Char.toUpper ("hello"^.Text.packed) -- "HELLO" ----- 'each' is an indexed traversal, so it can be used to access keys in many containers:+-- 'each' is an 'IndexedTraversal', so it can be used to access keys in many containers: -- -- >>> itoListOf each $ Map.fromList [("hello",2),("world",4)] -- [("hello",2),("world",4)] -- -- >>> ("hello","world") & each.each %~ Char.toUpper -- ("HELLO","WORLD")-class Each i s t a b | s -> i a, t -> i b, s b -> t, t a -> s where-  each :: IndexedTraversal i s t a b-+class (Functor f, Index s ~ Index t) => Each f s t a b | s -> a, t -> b, s b -> t, t a -> s where+  each :: IndexedLensLike (Index s) f s t a b #ifdef DEFAULT_SIGNATURES-  default each :: (Traversable f, s ~ f a, t ~ f b) => IndexedTraversal Int s t a b+  default each :: (Applicative f, Traversable g, s ~ g a, t ~ g b, Index s ~ Int, Index t ~ Int) => IndexedLensLike Int f s t a b   each = traversed   {-# INLINE each #-} #endif -instance (a ~ a', b ~ b') => Each Int (a,a') (b,b') a b where-  each = Lens.indexed $ \ f ~(a,b) -> (,) <$> f (0 :: Int) a <*> f 1 b+-- | @'each' :: 'IndexedTraversal' 'Int' (a,a) (b,b) a b@+instance (Applicative f, a~a', b~b') => Each f (a,a') (b,b') a b where+  each f ~(a,b) = (,) <$> f' (0 :: Int) a <*> f' 1 b+    where f' = Lens.indexed f   {-# INLINE each #-} -instance (a ~ a2, a ~ a3, b ~ b2, b ~ b3) => Each Int (a,a2,a3) (b,b2,b3) a b where-  each = Lens.indexed $ \ f ~(a,b,c) -> (,,) <$> f (0 :: Int) a <*> f 1 b <*> f 2 c+-- | @'each' :: 'IndexedTraversal' 'Int' (a,a,a) (b,b,b) a b@+instance (Applicative f, a~a2, a~a3, b~b2, b~b3) => Each f (a,a2,a3) (b,b2,b3) a b where+  each f ~(a,b,c) = (,,) <$> f' (0 :: Int) a <*> f' 1 b <*> f' 2 c+    where f' = Lens.indexed f   {-# INLINE each #-} -instance (a ~ a2, a ~ a3, a ~ a4, b ~ b2, b ~ b3, b ~ b4) => Each Int (a,a2,a3,a4) (b,b2,b3,b4) a b where-  each = Lens.indexed $ \ f ~(a,b,c,d) -> (,,,) <$> f (0 :: Int) a <*> f 1 b <*> f 2 c <*> f 3 d+-- | @'each' :: 'IndexedTraversal' 'Int' (a,a,a,a) (b,b,b,b) a b@+instance (Applicative f, a~a2, a~a3, a~a4, b~b2, b~b3, b~b4) => Each f (a,a2,a3,a4) (b,b2,b3,b4) a b where+  each f ~(a,b,c,d) = (,,,) <$> f' (0 :: Int) a <*> f' 1 b <*> f' 2 c <*> f' 3 d+    where f' = Lens.indexed f   {-# INLINE each #-} -instance (a ~ a2, a ~ a3, a ~ a4, a ~ a5, b ~ b2, b ~ b3, b ~ b4, b ~ b5) => Each Int (a,a2,a3,a4,a5) (b,b2,b3,b4,b5) a b where-  each = Lens.indexed $ \ f ~(a,b,c,d,e) -> (,,,,) <$> f (0 :: Int) a <*> f 1 b <*> f 2 c <*> f 3 d <*> f 4 e+-- | @'each' :: 'IndexedTraversal' 'Int' (a,a,a,a,a) (b,b,b,b,b) a b@+instance (Applicative f, a~a2, a~a3, a~a4, a~a5, b~b2, b~b3, b~b4, b~b5) => Each f (a,a2,a3,a4,a5) (b,b2,b3,b4,b5) a b where+  each f ~(a,b,c,d,e) = (,,,,) <$> f' (0 :: Int) a <*> f' 1 b <*> f' 2 c <*> f' 3 d <*> f' 4 e+    where f' = Lens.indexed f   {-# INLINE each #-} -instance (a ~ a2, a ~ a3, a ~ a4, a ~ a5, a ~ a6, b ~ b2, b ~ b3, b ~ b4, b ~ b5, b ~ b6) => Each Int (a,a2,a3,a4,a5,a6) (b,b2,b3,b4,b5,b6) a b where-  each = Lens.indexed $ \ f ~(a,b,c,d,e,g) -> (,,,,,) <$> f (0 :: Int) a <*> f 1 b <*> f 2 c <*> f 3 d <*> f 4 e <*> f 5 g+-- | @'each' :: 'IndexedTraversal' 'Int' (a,a,a,a,a,a) (b,b,b,b,b,b) a b@+instance (Applicative f, a~a2, a~a3, a~a4, a~a5, a~a6, b~b2, b~b3, b~b4, b~b5, b~b6) => Each f (a,a2,a3,a4,a5,a6) (b,b2,b3,b4,b5,b6) a b where+  each f ~(a,b,c,d,e,g) = (,,,,,) <$> f' (0 :: Int) a <*> f' 1 b <*> f' 2 c <*> f' 3 d <*> f' 4 e <*> f' 5 g+    where f' = Lens.indexed f   {-# INLINE each #-} -instance (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 Int (a,a2,a3,a4,a5,a6,a7) (b,b2,b3,b4,b5,b6,b7) a b where-  each = Lens.indexed $ \ f ~(a,b,c,d,e,g,h) -> (,,,,,,) <$> f (0 :: Int) a <*> f 1 b <*> f 2 c <*> f 3 d <*> f 4 e <*> f 5 g <*> f 6 h+-- | @'each' :: 'IndexedTraversal' 'Int' (a,a,a,a,a,a,a) (b,b,b,b,b,b,b) a b@+instance (Applicative f, 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 f (a,a2,a3,a4,a5,a6,a7) (b,b2,b3,b4,b5,b6,b7) a b where+  each f ~(a,b,c,d,e,g,h) = (,,,,,,) <$> f' (0 :: Int) a <*> f' 1 b <*> f' 2 c <*> f' 3 d <*> f' 4 e <*> f' 5 g <*> f' 6 h+    where f' = Lens.indexed f   {-# INLINE each #-} -instance (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 Int (a,a2,a3,a4,a5,a6,a7,a8) (b,b2,b3,b4,b5,b6,b7,b8) a b where-  each = Lens.indexed $ \ f ~(a,b,c,d,e,g,h,i) -> (,,,,,,,) <$> f (0 :: Int) a <*> f 1 b <*> f 2 c <*> f 3 d <*> f 4 e <*> f 5 g <*> f 6 h <*> f 7 i+-- | @'each' :: 'IndexedTraversal' 'Int' (a,a,a,a,a,a,a,a) (b,b,b,b,b,b,b,b) a b@+instance (Applicative f, 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 f (a,a2,a3,a4,a5,a6,a7,a8) (b,b2,b3,b4,b5,b6,b7,b8) a b where+  each f ~(a,b,c,d,e,g,h,i) = (,,,,,,,) <$> f' (0 :: Int) a <*> f' 1 b <*> f' 2 c <*> f' 3 d <*> f' 4 e <*> f' 5 g <*> f' 6 h <*> f' 7 i+    where f' = Lens.indexed f   {-# INLINE each #-} -instance (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 Int (a,a2,a3,a4,a5,a6,a7,a8,a9) (b,b2,b3,b4,b5,b6,b7,b8,b9) a b where-  each = Lens.indexed $ \ f ~(a,b,c,d,e,g,h,i,j) -> (,,,,,,,,) <$> f (0 :: Int) a <*> f 1 b <*> f 2 c <*> f 3 d <*> f 4 e <*> f 5 g <*> f 6 h <*> f 7 i <*> f 8 j+-- | @'each' :: 'IndexedTraversal' 'Int' (a,a,a,a,a,a,a,a,a) (b,b,b,b,b,b,b,b,b) a b@+instance (Applicative f, 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 f (a,a2,a3,a4,a5,a6,a7,a8,a9) (b,b2,b3,b4,b5,b6,b7,b8,b9) a b where+  each f ~(a,b,c,d,e,g,h,i,j) = (,,,,,,,,) <$> f' (0 :: Int) a <*> f' 1 b <*> f' 2 c <*> f' 3 d <*> f' 4 e <*> f' 5 g <*> f' 6 h <*> f' 7 i <*> f' 8 j+    where f' = Lens.indexed f   {-# INLINE each #-} -#if !(MIN_VERSION_base(4,4,0))-instance (RealFloat a, RealFloat b) => Each Int (Complex a) (Complex b) a b where-  each = Lens.indexed $ \ f (a :+ b) -> (:+) <$> f (0 :: Int) a <*> f 1 b+#if MIN_VERSION_base(4,4,0)+-- | @'each' :: ('RealFloat' a, 'RealFloat' b) => 'IndexedTraversal' 'Int' ('Complex' a) ('Complex' b) a b@+instance Applicative f => Each f (Complex a) (Complex b) a b where+  each f (a :+ b) = (:+) <$> f' (0 :: Int) a <*> f' (1 :: Int) b+    where f' = Lens.indexed f   {-# INLINE each #-} #else-instance Each Int (Complex a) (Complex b) a b where-  each = Lens.indexed $ \ f (a :+ b) -> (:+) <$> f (0 :: Int) a <*> f 1 b+-- | @'each' :: 'IndexedTraversal' 'Int' ('Complex' a) ('Complex' b) a b@+instance (Applicative f, RealFloat a, RealFloat b) => Each f (Complex a) (Complex b) a b where+  each f (a :+ b) = (:+) <$> f' (0 :: Int) a <*> f' 1 b+    where f' = Lens.indexed f   {-# INLINE each #-} #endif -instance Each k (Map k a) (Map k b) a b where-  each = Lens.indexed $ \f m -> sequenceA $ Map.mapWithKey f m+-- | @'each' :: 'IndexedTraversal' c ('Map' c a) ('Map' c b) a b@+instance Applicative f => Each f (Map c a) (Map c b) a b where+  each f m = sequenceA $ Map.mapWithKey f' m+    where f' = Lens.indexed f   {-# INLINE each #-} -instance Each Int (IntMap a) (IntMap b) a b where-  each = Lens.indexed $ \f m -> sequenceA $ IntMap.mapWithKey f m+-- | @'each' :: 'IndexedTraversal' 'Int' ('Map' c a) ('Map' c b) a b@+instance Applicative f => Each f (IntMap a) (IntMap b) a b where+  each f m = sequenceA $ IntMap.mapWithKey f' m+    where f' = Lens.indexed f   {-# INLINE each #-} -instance Each k (HashMap k a) (HashMap k b) a b where-  each = Lens.indexed HashMap.traverseWithKey+-- | @'each' :: 'IndexedTraversal' c ('HashMap' c a) ('HashMap' c b) a b@+instance Applicative f => Each f (HashMap c a) (HashMap c b) a b where+  each = HashMap.traverseWithKey . Lens.indexed   {-# INLINE each #-} -instance Each Int [a] [b] a b where+-- | @'each' :: 'IndexedTraversal' 'Int' [a] [b] a b@+instance Applicative f => Each f [a] [b] a b where   each = traversed   {-# INLINE each #-} -instance Each Int (Identity a) (Identity b) a b where-  each = traversed+-- | @'each' :: 'IndexedTraversal' 'Int' ('Identity' a) ('Identity' b) a b@+instance Functor f => Each f (Identity a) (Identity b) a b where+  each f (Identity a) = Identity <$> Lens.indexed f () a   {-# INLINE each #-} -instance Each Int (Maybe a) (Maybe b) a b where-  each = traversed+-- | @'each' :: 'IndexedTraversal' 'Int' ('Maybe' a) ('Maybe' b) a b@+instance Applicative f => Each f (Maybe a) (Maybe b) a b where+  each f (Just a) = Just <$> Lens.indexed f () a+  each _ Nothing  = pure Nothing   {-# INLINE each #-} -instance Each Int (Seq a) (Seq b) a b where+-- | @'each' :: 'IndexedTraversal' 'Int' ('Seq' a) ('Seq' b) a b@+instance Applicative f => Each f (Seq a) (Seq b) a b where   each = traversed   {-# INLINE each #-} -instance Each Int (Tree a) (Tree b) a b where-  each = traversed+-- | @'each' :: 'IndexedTraversal' ['Int'] ('Tree' a) ('Tree' b) a b@+instance Applicative f => Each f (Tree a) (Tree b) a b where+  each pafb = go (BD 0 [] 0 []) where+    go dq (Node a as) = Node <$> Lens.indexed pafb (Foldable.toList dq) a <*> itraverse (\i n -> go (Lens.snoc dq i) n) as   {-# INLINE each #-} -instance Each Int (Vector.Vector a) (Vector.Vector b) a b where+-- | @'each' :: 'IndexedTraversal' 'Int' ('Vector.Vector' a) ('Vector.Vector' b) a b@+instance Applicative f => Each f (Vector.Vector a) (Vector.Vector b) a b where   each = traversed   {-# INLINE each #-} -instance (Prim a, Prim b) => Each Int (Prim.Vector a) (Prim.Vector b) a b where-  each = Lens.indexed $ \f v -> Prim.fromListN (Prim.length v) <$> withIndex traversed f (Prim.toList v)+-- | @'each' :: ('Prim' a, 'Prim' b) => 'IndexedTraversal' 'Int' ('Prim.Vector' a) ('Prim.Vector' b) a b@+instance (Applicative f, Prim a, Prim b) => Each f (Prim.Vector a) (Prim.Vector b) a b where+  each f v = Prim.fromListN (Prim.length v) <$> traversed (Indexed f') (Prim.toList v)+    where f' = Lens.indexed f+  {-# INLINE each #-} -instance (Storable a, Storable b) => Each Int (Storable.Vector a) (Storable.Vector b) a b where-  each = Lens.indexed $ \f v -> Storable.fromListN (Storable.length v) <$> withIndex traversed f (Storable.toList v)+-- | @'each' :: ('Storable' a, 'Storable' b) => 'IndexedTraversal' 'Int' ('Storable.Vector' a) ('Storable.Vector' b) a b@+instance (Applicative f, Storable a, Storable b) => Each f (Storable.Vector a) (Storable.Vector b) a b where+  each f v = Storable.fromListN (Storable.length v) <$> traversed (Indexed f') (Storable.toList v)+    where f' = Lens.indexed f+  {-# INLINE each #-} -instance (Unbox a, Unbox b) => Each Int (Unboxed.Vector a) (Unboxed.Vector b) a b where-  each = Lens.indexed $ \f v -> Unboxed.fromListN (Unboxed.length v) <$> withIndex traversed f (Unboxed.toList v)+-- | @'each' :: ('Unbox' a, 'Unbox' b) => 'IndexedTraversal' 'Int' ('Unboxed.Vector' a) ('Unboxed.Vector' b) a b@+instance (Applicative f, Unbox a, Unbox b) => Each f (Unboxed.Vector a) (Unboxed.Vector b) a b where+  each f v = Unboxed.fromListN (Unboxed.length v) <$> traversed (Indexed f') (Unboxed.toList v)+    where f' = Lens.indexed f+  {-# INLINE each #-} -instance Each Int StrictT.Text StrictT.Text Char Char where-  each = iso StrictT.unpack StrictT.pack .> traversed+-- | @'each' :: 'IndexedTraversal' 'Int' 'StrictT.Text' 'StrictT.Text' 'Char' 'Char'@+instance Applicative f =>  Each f StrictT.Text StrictT.Text Char Char where+  each = iso StrictT.unpack StrictT.pack . traversed   {-# INLINE each #-} -instance Each Int64 LazyT.Text LazyT.Text Char Char where-  each = iso LazyT.unpack LazyT.pack .> traversed64+-- | @'each' :: 'IndexedTraversal' 'Int64' 'LazyT.Text' 'LazyT.Text' 'Char' 'Char'@+instance Applicative f => Each f LazyT.Text LazyT.Text Char Char where+  each = iso LazyT.unpack LazyT.pack . traversed64   {-# INLINE each #-} -instance Each Int StrictB.ByteString StrictB.ByteString Word8 Word8 where-  each = iso StrictB.unpack StrictB.pack .> traversed+-- | @'each' :: 'IndexedTraversal' 'Int' 'StrictB.ByteString' 'StrictB.ByteString' 'Char' 'Char'@+instance Applicative f => Each f StrictB.ByteString StrictB.ByteString Word8 Word8 where+  each = iso StrictB.unpack StrictB.pack . traversed   {-# INLINE each #-} -instance Each Int64 LazyB.ByteString LazyB.ByteString Word8 Word8 where-  each = iso LazyB.unpack LazyB.pack .> traversed64+-- | @'each' :: 'IndexedTraversal' 'Int64' 'LazyB.ByteString' 'LazyB.ByteString' 'Char' 'Char'@+instance Applicative f => Each f LazyB.ByteString LazyB.ByteString Word8 Word8 where+  each = iso LazyB.unpack LazyB.pack . traversed64   {-# INLINE each #-} -instance (Ix i, IArray UArray a, IArray UArray b) => Each i (Array i a) (Array i b) a b where-  each = Lens.indexed $ \f arr -> array (bounds arr) <$> traverse (\(i,a) -> (,) i <$> f i a) (IArray.assocs arr)+-- | @'each' :: 'Ix' i => 'IndexedTraversal' i ('Array' i a) ('Array' i b) a b@+instance (Applicative f, Ix i) => Each f (Array i a) (Array i b) a b where+  each f arr = array (bounds arr) <$> traverse (\(i,a) -> (,) i <$> Lens.indexed f i a) (IArray.assocs arr)   {-# INLINE each #-} -instance (Ix i, IArray UArray a, IArray UArray b) => Each i (UArray i a) (UArray i b) a b where-  each = Lens.indexed $ \f arr -> array (bounds arr) <$> traverse (\(i,a) -> (,) i <$> f i a) (IArray.assocs arr)+-- | @'each' :: ('Ix' i, 'IArray' 'UArray' a, 'IArray' 'UArray' b) => 'IndexedTraversal' i ('Array' i a) ('Array' i b) a b@+instance (Applicative f, Ix i, IArray UArray a, IArray UArray b) => Each f (UArray i a) (UArray i b) a b where+  each f arr = array (bounds arr) <$> traverse (\(i,a) -> (,) i <$> Lens.indexed f i a) (IArray.assocs arr)+  {-# INLINE each #-}++-- | @'each' :: 'Control.Lens.IndexedSetter.IndexedSetter' i (i -> a) (i -> b) a b@+instance Settable f => Each f (i -> a) (i -> b) a b where+  each f g = pure (\i -> untaintedDot (Lens.indexed f i) (g i))   {-# INLINE each #-}

@@ -0,0 +1,76 @@+{-# LANGUAGE GADTs #-}+{-# LANGUAGE Rank2Types #-}+{-# LANGUAGE TypeFamilies #-}+-----------------------------------------------------------------------------+-- |+-- Module      :  Control.Lens.Equality+-- Copyright   :  (C) 2012-13 Edward Kmett+-- License     :  BSD-style (see the file LICENSE)+-- Maintainer  :  Edward Kmett <ekmett@gmail.com>+-- Stability   :  provisional+-- Portability :  Rank2Types+--+----------------------------------------------------------------------------+module Control.Lens.Equality+  (+  -- * Type Equality+    Equality, Equality'+  , AnEquality, AnEquality'+  , runEq+  , substEq+  , mapEq+  , fromEq+  , simply+  -- * Implementation Details+  , Identical(..)+  ) where++import Control.Lens.Internal.Setter+import Control.Lens.Type++{-# ANN module "HLint: ignore Use id" #-}+{-# ANN module "HLint: ignore Eta reduce" #-}++-- $setup+-- >>> import Control.Lens++-----------------------------------------------------------------------------+-- Equality+-----------------------------------------------------------------------------++-- | Provides witness that @(s ~ a, b ~ t)@ holds.+data Identical a b s t where+  Identical :: Identical a b a b++-- | When you see this as an argument to a function, it expects an 'Equality'.+type AnEquality s t a b = Identical a (Mutator b) a (Mutator b) -> Identical a (Mutator b) s (Mutator t)++-- | A 'Simple' 'AnEquality'.+type AnEquality' s a = AnEquality s s a a++-- | Extract a witness of type 'Equality'.+runEq :: AnEquality s t a b -> Identical s t a b+runEq l = case l Identical of Identical -> Identical+{-# INLINE runEq #-}++-- | Substituting types with 'Equality'.+substEq :: AnEquality s t a b -> ((s ~ a, t ~ b) => r) -> r+substEq l = case runEq l of+  Identical -> \r -> r+{-# INLINE substEq #-}++-- | We can use 'Equality' to do substitution into anything.+mapEq :: AnEquality s t a b -> f s -> f a+mapEq l r = substEq l r+{-# INLINE mapEq #-}++-- | 'Equality' is symmetric.+fromEq :: AnEquality s t a b -> Equality b a t s+fromEq l = substEq l id+{-# INLINE fromEq #-}++-- | 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.+simply :: (Overloaded' p f s a -> r) -> Overloaded' p f s a -> r+simply = id+{-# INLINE simply #-}

@@ -1,1188 +1,2113 @@ {-# LANGUAGE CPP #-}-{-# LANGUAGE MagicHash #-}-{-# LANGUAGE Rank2Types #-}-{-# LANGUAGE FlexibleInstances #-}-{-# LANGUAGE LiberalTypeSynonyms #-}-{-# LANGUAGE UndecidableInstances #-}-{-# LANGUAGE MultiParamTypeClasses #-}-#ifdef TRUSTWORTHY-{-# LANGUAGE Trustworthy #-}-#endif-------------------------------------------------------------------------------- |--- Module      :  Control.Lens.Fold--- Copyright   :  (C) 2012 Edward Kmett--- License     :  BSD-style (see the file LICENSE)--- Maintainer  :  Edward Kmett <ekmett@gmail.com>--- Stability   :  provisional--- Portability :  Rank2Types------ A @'Fold' s a@ is a generalization of something 'Foldable'. It allows--- you to extract multiple results from a container. A 'Foldable' container--- can be characterized by the behavior of--- @foldMap :: ('Foldable' t, 'Monoid' m) => (a -> m) -> t a -> m@.--- Since we want to be able to work with monomorphic containers, we could--- generalize this signature to @forall m. 'Monoid' m => (a -> m) -> s -> m@,--- and then decorate it with 'Accessor' to obtain------ @type 'Fold' s a = forall m. 'Monoid' m => 'Getting' m s s a a@------ Every 'Getter' is a valid 'Fold' that simply doesn't use the 'Monoid'--- it is passed.------ In practice the type we use is slightly more complicated to allow for--- better error messages and for it to be transformed by certain--- 'Applicative' transformers.------ Everything you can do with a 'Foldable' container, you can with with a 'Fold' and there are--- combinators that generalize the usual 'Foldable' operations here.------------------------------------------------------------------------------module Control.Lens.Fold-  (-  -- * Folds-    Fold-  , (^..)-  , (^?)-  , (^?!)-  , preview-  , previews-  , preuse-  , preuses-  -- ** Building Folds-  --, folds-  , folding-  , folded-  , unfolded-  , iterated-  , filtered-  , backwards-  , repeated-  , replicated-  , cycled-  , takingWhile-  , droppingWhile-  -- ** Folding-  , foldMapOf, foldOf-  , foldrOf, foldlOf-  , toListOf-  , anyOf, allOf-  , andOf, orOf-  , productOf, sumOf-  , traverseOf_, forOf_, sequenceAOf_-  , mapMOf_, forMOf_, sequenceOf_-  , asumOf, msumOf-  , concatMapOf, concatOf-  , elemOf, notElemOf-  , lengthOf-  , nullOf, notNullOf-  , firstOf, lastOf-  , maximumOf, minimumOf-  , maximumByOf, minimumByOf-  , findOf-  , foldrOf', foldlOf'-  , foldr1Of, foldl1Of-  , foldrMOf, foldlMOf-  -- * Storing Folds-  , ReifiedFold(..)-  -- * Deprecated-  , headOf-  ) where--import Control.Applicative as Applicative-import Control.Applicative.Backwards-import Control.Lens.Classes-import Control.Lens.Getter-import Control.Lens.Internal-import Control.Lens.Internal.Combinators-import Control.Lens.Type-import Control.Monad-import Control.Monad.Reader-import Control.Monad.State-import Data.Foldable as Foldable-import Data.Maybe-import Data.Monoid---- $setup--- >>> import Control.Lens--infixl 8 ^.., ^?, ^?!------------------------------- Folds------------------------------- | A 'Fold' describes how to retrieve multiple values in a way that can be composed--- with other lens-like 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 'Control.Lens.Traversal.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. (Gettable f, Applicative f) => (a -> f a) -> s -> f s----- | 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, Applicative g, Gettable g) => (s -> f a) -> LensLike g s t a b-folding sfa agb = coerce . traverse_ agb . sfa-{-# INLINE folding #-}---- | Obtain a 'Fold' from any 'Foldable'.------ >>> Just 3^..folded--- [3]------ >>> Nothing^..folded--- []------ >>> [(1,2),(3,4)]^..folded.both--- [1,2,3,4]-folded :: Foldable f => Fold (f a) a-folded f = coerce . getFolding . foldMap (folding# f)-{-# INLINE folded #-}---- | Fold by repeating the input forever.------ @'repeat' ≡ 'toListOf' 'repeated'@------ >>> 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 :: Fold a a-repeated f a = as where as = f a *> as-{-# INLINE repeated #-}---- | 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]-replicated :: Int -> Fold a a-replicated n0 f a = go n0 where-  m = f a-  go 0 = noEffect-  go n = m *> go (n - 1)-{-# INLINE replicated #-}---- | Transform a fold into a fold that loops over its elements over and over.------ >>> [1,2,3]^..taking 7 (cycled traverse)--- [1,2,3,1,2,3,1]-cycled :: (Applicative f, Gettable f) => LensLike f s t a b -> LensLike f s t a b-cycled l f a = as where as = l f a *> as-{-# INLINE cycled #-}---- | Build a fold that unfolds its values from a seed.------ @'Prelude.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]-unfolded :: (b -> Maybe (a, b)) -> Fold b a-unfolded f g b0 = go b0 where-  go b = case f b of-    Just (a, b') -> g a *> go b'-    Nothing      -> noEffect-{-# INLINE unfolded #-}---- | @x ^. 'iterated' f@ Return an infinite fold of repeated applications of @f@ to @x@.------ @'toListOf' ('iterated' f) a ≡ 'iterate' f a@-iterated :: (a -> a) -> Fold a a-iterated f g a0 = go a0 where-  go a = g a *> go (f a)-{-# INLINE iterated #-}---- | Obtain a 'Fold' that can be composed with to filter another 'Lens', 'Control.Lens.Iso.Iso', 'Getter', 'Fold' (or 'Control.Lens.Traversal.Traversal')------ Note: This is /not/ a legal 'Control.Lens.Traversal.Traversal', unless you are very careful not to invalidate the predicate on the target.------ As a counter example, consider that given @evens = 'filtered' 'even'@ the second 'Control.Lens.Traversal.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!------ @'filtered' :: (a -> 'Bool') -> 'Fold' a a@-filtered :: Applicative f => (a -> Bool) -> SimpleLensLike f a a-filtered p f a-  | p a       = f a-  | otherwise = pure a-{-# INLINE filtered #-}---- | This allows you to traverse the elements of a 'Control.Lens.Traversal.Traversal' or 'Fold' in the opposite order.--- This will demote an 'Control.Lens.IndexedTraversal.IndexedTraversal' or 'Control.Lens.IndexedFold.IndexedFold' to a regular 'Control.Lens.Traversal.Traversal' or 'Fold',--- respectively; to preserve the indices, use 'Control.Lens.IndexedFold.ibackwards' instead.------ Note: 'backwards' should have no impact on a 'Getter', 'Control.Lens.Setter.Setter', 'Lens' or 'Control.Lens.Iso.Iso'.------ To change the direction of an 'Control.Lens.Iso.Iso', use 'Control.Lens.Isomorphic.from'.-backwards :: LensLike (Backwards f) s t a b -> LensLike f s t a b-backwards l f = forwards# $ l (backwards# f)-{-# INLINE backwards #-}---- | Obtain a 'Fold' by taking elements from another 'Fold', 'Lens', 'Control.Lens.Iso.Iso', 'Getter' or 'Control.Lens.Traversal.Traversal' while a predicate holds.------ @'takeWhile' p ≡ 'toListOf' ('takingWhile' p 'folded')@------ >>> toListOf (takingWhile (<=3) folded) [1..]--- [1,2,3]-takingWhile :: (Gettable f, Applicative f)-            => (a -> Bool)-            -> Getting (Endo (f s)) s s a a-            -> LensLike f s s a a-takingWhile p l f = foldrOf l (\a r -> if p a then f a *> r else noEffect) noEffect-{-# INLINE takingWhile #-}----- | Obtain a 'Fold' by dropping elements from another 'Fold', 'Lens', 'Control.Lens.Iso.Iso', 'Getter' or 'Control.Lens.Traversal.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 :: (Gettable f, Applicative f)-              => (a -> Bool)-              -> Getting (Endo (f s, f s)) s s a a-              -> LensLike f s s a a-droppingWhile p l f = fst . foldrOf l (\a r -> let s = f a *> snd r in (if p a then fst r else s, s)) (noEffect, noEffect)-{-# INLINE droppingWhile #-}------------------------------- Fold/Getter combinators------------------------------- |--- @'Data.Foldable.foldMap' = 'foldMapOf' 'folded'@------ @'foldMapOf' ≡ 'views'@------ @--- 'foldMapOf' ::             'Getter' s a           -> (a -> r) -> s -> r--- 'foldMapOf' :: 'Monoid' r => 'Fold' s a             -> (a -> r) -> s -> r--- 'foldMapOf' ::             'Simple' 'Lens' s a      -> (a -> r) -> s -> r--- 'foldMapOf' ::             'Simple' 'Control.Lens.Iso.Iso' s a       -> (a -> r) -> s -> r--- 'foldMapOf' :: 'Monoid' r => 'Simple' 'Control.Lens.Traversal.Traversal' s a -> (a -> r) -> s -> r--- 'foldMapOf' :: 'Monoid' r => 'Simple' 'Control.Lens.Prism.Prism' s a     -> (a -> r) -> s -> r--- @-foldMapOf :: Getting r s t a b -> (a -> r) -> s -> r-foldMapOf l f = runAccessor# (l (accessor# f))-{-# INLINE foldMapOf #-}---- |--- @'Data.Foldable.fold' = 'foldOf' 'folded'@------ @'foldOf' ≡ 'view'@------ @--- 'foldOf' ::             'Getter' s m           -> s -> m--- 'foldOf' :: 'Monoid' m => 'Fold' s m             -> s -> m--- 'foldOf' ::             'Simple' 'Lens' s m      -> s -> m--- 'foldOf' ::             'Simple' 'Control.Lens.Iso.Iso' s m       -> s -> m--- 'foldOf' :: 'Monoid' m => 'Simple' 'Control.Lens.Traversal.Traversal' s m -> s -> m--- 'foldOf' :: 'Monoid' m => 'Simple' 'Control.Lens.Prism.Prism' s m     -> s -> m--- @-foldOf :: Getting a s t a b -> s -> a-foldOf l = runAccessor# (l Accessor)-{-# INLINE foldOf #-}---- |--- Right-associative fold of parts of a structure that are viewed through a 'Lens', 'Getter', 'Fold' or 'Control.Lens.Traversal.Traversal'.------ @'Data.Foldable.foldr' ≡ 'foldrOf' 'folded'@------ @--- 'foldrOf' :: 'Getter' s a           -> (a -> r -> r) -> r -> s -> r--- 'foldrOf' :: 'Fold' s a             -> (a -> r -> r) -> r -> s -> r--- 'foldrOf' :: 'Simple' 'Lens' s a      -> (a -> r -> r) -> r -> s -> r--- 'foldrOf' :: 'Simple' 'Control.Lens.Iso.Iso' s a       -> (a -> r -> r) -> r -> s -> r--- 'foldrOf' :: 'Simple' 'Control.Lens.Traversal.Traversal' s a -> (a -> r -> r) -> r -> s -> r--- 'foldrOf' :: 'Simple' 'Control.Lens.Prism.Prism' s a     -> (a -> r -> r) -> r -> s -> r--- @-foldrOf :: Getting (Endo r) s t a b -> (a -> r -> r) -> r -> s -> r-foldrOf l f z t = appEndo (foldMapOf l (endo# f) t) z-{-# INLINE foldrOf #-}---- |--- Left-associative fold of the parts of a structure that are viewed through a 'Lens', 'Getter', 'Fold' or 'Control.Lens.Traversal.Traversal'.------ @'Data.Foldable.foldl' ≡ 'foldlOf' 'folded'@------ @--- 'foldlOf' :: 'Getter' s a           -> (r -> a -> r) -> r -> s -> r--- 'foldlOf' :: 'Fold' s a             -> (r -> a -> r) -> r -> s -> r--- 'foldlOf' :: 'Simple' 'Lens' s a      -> (r -> a -> r) -> r -> s -> r--- 'foldlOf' :: 'Simple' 'Control.Lens.Iso.Iso' s a       -> (r -> a -> r) -> r -> s -> r--- 'foldlOf' :: 'Simple' 'Control.Lens.Traversal.Traversal' s a -> (r -> a -> r) -> r -> s -> r--- 'foldlOf' :: 'Simple' 'Control.Lens.Prism.Prism' s a     -> (r -> a -> r) -> r -> s -> r--- @-foldlOf :: Getting (Dual (Endo r)) s t a b -> (r -> a -> r) -> r -> s -> r-foldlOf l f z t = appEndo (getDual (foldMapOf l (dual# (endo# (flip f))) t)) z-{-# INLINE foldlOf #-}---- | Extract a list of the targets of a 'Fold'. See also ('^..').------ @--- 'Data.Foldable.toList' ≡ 'toListOf' 'folded'--- ('^..') ≡ 'flip' 'toListOf'--- @---- >>> toListOf both ("hello","world")--- ["hello","world"]------ @--- 'toListOf' :: 'Getter' s a           -> s -> [a]--- 'toListOf' :: 'Fold' s a             -> s -> [a]--- 'toListOf' :: 'Simple' 'Lens' s a      -> s -> [a]--- 'toListOf' :: 'Simple' 'Control.Lens.Iso.Iso' s a       -> s -> [a]--- 'toListOf' :: 'Simple' 'Control.Lens.Traversal.Traversal' s a -> s -> [a]--- 'toListOf' :: 'Simple' 'Control.Lens.Prism.Prism' s a     -> s -> [a]--- @-toListOf :: Getting (Endo [a]) s t a b -> s -> [a]-toListOf l = foldrOf l (:) []--- toListOf l = foldMapOf l return-{-# INLINE toListOf #-}---- |------ A convenient infix (flipped) version of 'toListOf'.------ >>> [[1,2],[3]]^..traverse.traverse--- [1,2,3]------ >>> (1,2)^..both--- [1,2]------ @--- 'Data.Foldable.toList' xs ≡ xs '^..' 'folded'--- ('^..') ≡ 'flip' 'toListOf'--- @------ @--- ('^..') :: s -> 'Getter' s a           -> [a]--- ('^..') :: s -> 'Fold' s a             -> [a]--- ('^..') :: s -> 'Simple' 'Lens' s a      -> [a]--- ('^..') :: s -> 'Simple' 'Control.Lens.Iso.Iso' s a       -> [a]--- ('^..') :: s -> 'Simple' 'Control.Lens.Traversal.Traversal' s a -> [a]--- ('^..') :: s -> 'Simple' 'Control.Lens.Prism.Prism' s a     -> [a]--- @-(^..) :: s -> Getting (Endo [a]) s t a b -> [a]-s ^.. l = toListOf l s-{-# INLINE (^..) #-}---- | Returns 'True' if every target of a 'Fold' is 'True'.------ >>> andOf both (True,False)--- False--- >>> andOf both (True,True)--- True------ @'Data.Foldable.and' ≡ 'andOf' 'folded'@------ @--- 'andOf' :: 'Getter' s 'Bool'           -> s -> 'Bool'--- 'andOf' :: 'Fold' s 'Bool'             -> s -> 'Bool'--- 'andOf' :: 'Simple' 'Lens' s 'Bool'      -> s -> 'Bool'--- 'andOf' :: 'Simple' 'Control.Lens.Iso.Iso' s 'Bool'       -> s -> 'Bool'--- 'andOf' :: 'Simple' 'Control.Lens.Traversal.Traversal' s 'Bool' -> s -> 'Bool'--- 'andOf' :: 'Simple' 'Control.Lens.Prism.Prism' s 'Bool'     -> s -> 'Bool'--- @-andOf :: Getting All s t Bool b -> s -> Bool-andOf l = getAll# (foldMapOf l All)-{-# INLINE andOf #-}---- | Returns 'True' if any target of a 'Fold' is 'True'.------ >>> orOf both (True,False)--- True--- >>> orOf both (False,False)--- False------ @'Data.Foldable.or' ≡ 'orOf' 'folded'@------ @--- 'orOf' :: 'Getter' s 'Bool'           -> s -> 'Bool'--- 'orOf' :: 'Fold' s 'Bool'             -> s -> 'Bool'--- 'orOf' :: 'Simple' 'Lens' s 'Bool'      -> s -> 'Bool'--- 'orOf' :: 'Simple' 'Control.Lens.Iso.Iso' s 'Bool'       -> s -> 'Bool'--- 'orOf' :: 'Simple' 'Control.Lens.Traversal.Traversal' s 'Bool' -> s -> 'Bool'--- 'orOf' :: 'Simple' 'Control.Lens.Prism.Prism' s 'Bool'     -> s -> 'Bool'--- @-orOf :: Getting Any s t Bool b -> s -> Bool-orOf l = getAny# (foldMapOf l Any)-{-# INLINE orOf #-}---- | 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))--- True------ @'Data.Foldable.any' ≡ 'anyOf' 'folded'@------ @--- 'anyOf' :: 'Getter' s a               -> (a -> 'Bool') -> s -> 'Bool'--- 'anyOf' :: 'Fold' s a                 -> (a -> 'Bool') -> s -> 'Bool'--- 'anyOf' :: 'Simple' 'Lens' s a      -> (a -> 'Bool') -> s -> 'Bool'--- 'anyOf' :: 'Simple' 'Control.Lens.Iso.Iso' s a       -> (a -> 'Bool') -> s -> 'Bool'--- 'anyOf' :: 'Simple' 'Control.Lens.Traversal.Traversal' s a -> (a -> 'Bool') -> s -> 'Bool'--- 'anyOf' :: 'Simple' 'Control.Lens.Prism.Prism' s a     -> (a -> 'Bool') -> s -> 'Bool'--- @-anyOf :: Getting Any s t a b -> (a -> Bool) -> s -> Bool-anyOf l f = getAny# $ foldMapOf l (any# f)-{-# INLINE anyOf #-}---- | Returns 'True' if every target of a 'Fold' satisfies a predicate.------ >>> allOf both (>=3) (4,5)--- True--- >>> allOf folded (>=2) [1..10]--- False------ @'Data.Foldable.all' ≡ 'allOf' 'folded'@------ @--- 'allOf' :: 'Getter' s a           -> (a -> 'Bool') -> s -> 'Bool'--- 'allOf' :: 'Fold' s a             -> (a -> 'Bool') -> s -> 'Bool'--- 'allOf' :: 'Simple' 'Lens' s a      -> (a -> 'Bool') -> s -> 'Bool'--- 'allOf' :: 'Simple' 'Control.Lens.Iso.Iso' s a       -> (a -> 'Bool') -> s -> 'Bool'--- 'allOf' :: 'Simple' 'Control.Lens.Traversal.Traversal' s a -> (a -> 'Bool') -> s -> 'Bool'--- 'allOf' :: 'Simple' 'Control.Lens.Prism.Prism' s a     -> (a -> 'Bool') -> s -> 'Bool'--- @-allOf :: Getting All s t a b -> (a -> Bool) -> s -> Bool-allOf l f = getAll# $ foldMapOf l (all# f)-{-# INLINE allOf #-}---- | Calculate the product of every number targeted by a 'Fold'------ >>> productOf both (4,5)--- 20--- >>> productOf folded [1,2,3,4,5]--- 120------ @'Data.Foldable.product' ≡ 'productOf' 'folded'@------ @--- 'productOf' ::          'Getter' s a           -> s -> a--- 'productOf' :: 'Num' a => 'Fold' s a             -> s -> a--- 'productOf' ::          'Simple' 'Lens' s a      -> s -> a--- 'productOf' ::          'Simple' 'Control.Lens.Iso.Iso' s a       -> s -> a--- 'productOf' :: 'Num' a => 'Simple' 'Control.Lens.Traversal.Traversal' s a -> s -> a--- 'productOf' :: 'Num' a => 'Simple' 'Control.Lens.Prism.Prism' s a     -> s -> a--- @-productOf :: Getting (Product a) s t a b -> s -> a-productOf l = getProduct# $ foldMapOf l Product-{-# INLINE productOf #-}---- | 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------ @'Data.Foldable.sum' ≡ 'sumOf' 'folded'@------ @--- 'sumOf' '_1' :: (a, b) -> a--- 'sumOf' ('folded' . '_1') :: ('Foldable' f, 'Num' a) => f (a, b) -> a--- @------ @--- 'sumOf' ::          'Getter' s a           -> s -> a--- 'sumOf' :: 'Num' a => 'Fold' s a             -> s -> a--- 'sumOf' ::          'Simple' 'Lens' s a      -> s -> a--- 'sumOf' ::          'Simple' 'Control.Lens.Iso.Iso' s a       -> s -> a--- 'sumOf' :: 'Num' a => 'Simple' 'Control.Lens.Traversal.Traversal' s a -> s -> a--- 'sumOf' :: 'Num' a => 'Simple' 'Control.Lens.Prism.Prism' s a     -> s -> a--- @-sumOf :: Getting (Sum a) s t a b -> s -> a-sumOf l = getSum# $ foldMapOf l Sum-{-# INLINE sumOf #-}---- | Traverse over all of the targets of a 'Fold' (or 'Getter'), computing an 'Applicative' (or 'Functor') -based answer,--- but unlike 'Control.Lens.Traversal.traverseOf' do not construct a new structure. 'traverseOf_' generalizes--- 'Data.Foldable.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------ @'Data.Foldable.traverse_' ≡ 'traverseOf_' 'folded'@------ @--- 'traverseOf_' '_2' :: 'Functor' f => (c -> f r) -> (d, c) -> f ()--- 'traverseOf_' 'Data.Either.Lens.traverseLeft' :: 'Applicative' f => (a -> f b) -> 'Either' a c -> f ()--- @------ 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     => 'Simple' 'Lens' s a      -> (a -> f r) -> s -> f ()--- 'traverseOf_' :: 'Functor' f     => 'Simple' 'Control.Lens.Iso.Iso' s a       -> (a -> f r) -> s -> f ()--- 'traverseOf_' :: 'Applicative' f => 'Simple' 'Control.Lens.Traversal.Traversal' s a -> (a -> f r) -> s -> f ()--- 'traverseOf_' :: 'Applicative' f => 'Simple' 'Control.Lens.Prism.Prism' s a     -> (a -> f r) -> s -> f ()--- @-traverseOf_ :: Functor f => Getting (Traversed f) s t a b -> (a -> f r) -> s -> f ()-traverseOf_ l f = getTraversed# (foldMapOf l (traversed# (void . f)))-{-# INLINE traverseOf_ #-}---- | Traverse over all of the targets of a 'Fold' (or 'Getter'), computing an 'Applicative' (or 'Functor') -based answer,--- but unlike 'Control.Lens.Traversal.forOf' do not construct a new structure. 'forOf_' generalizes--- 'Data.Foldable.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'@------ The rather specific signature of 'forOf_' allows it to be used as if the signature was any of:------ @--- '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     => 'Simple' 'Lens' s a      -> s -> (a -> f r) -> f ()--- 'forOf_' :: 'Functor' f     => 'Simple' 'Control.Lens.Iso.Iso' s a       -> s -> (a -> f r) -> f ()--- 'forOf_' :: 'Applicative' f => 'Simple' 'Control.Lens.Traversal.Traversal' s a -> s -> (a -> f r) -> f ()--- 'forOf_' :: 'Applicative' f => 'Simple' 'Control.Lens.Prism.Prism' s a     -> s -> (a -> f r) -> f ()--- @-forOf_ :: Functor f => Getting (Traversed f) s t a b -> s -> (a -> f r) -> f ()-forOf_ = flip . traverseOf_-{-# INLINE forOf_ #-}---- | Evaluate each action in observed by a 'Fold' on a structure from left to right, ignoring the results.------ @'sequenceA_' ≡ 'sequenceAOf_' 'folded'@------ @--- 'sequenceAOf_' :: 'Functor' f     => 'Getter' s (f a)           -> s -> f ()--- 'sequenceAOf_' :: 'Applicative' f => 'Fold' s (f a)             -> s -> f ()--- 'sequenceAOf_' :: 'Functor' f     => 'Simple' 'Lens' s (f a)      -> s -> f ()--- 'sequenceAOf_' :: 'Functor' f     => 'Simple' 'Iso' s (f a)       -> s -> f ()--- 'sequenceAOf_' :: 'Applicative' f => 'Simple' 'Control.Lens.Traversal.Traversal' s (f a) -> s -> f ()--- 'sequenceAOf_' :: 'Applicative' f => 'Simple' 'Control.Lens.Prism.Prism' s (f a)     -> s -> f ()--- @-sequenceAOf_ :: Functor f => Getting (Traversed f) s t (f a) b -> s -> f ()-sequenceAOf_ l = getTraversed# (foldMapOf l (traversed# void))-{-# INLINE sequenceAOf_ #-}---- | Map each target of a 'Fold' on a structure to a monadic action, evaluate these actions from left to right, and ignore the results.------ @'Data.Foldable.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 => 'Simple' 'Lens' s a      -> (a -> m r) -> s -> m ()--- 'mapMOf_' :: 'Monad' m => 'Simple' 'Control.Lens.Iso.Iso' s a       -> (a -> m r) -> s -> m ()--- 'mapMOf_' :: 'Monad' m => 'Simple' 'Control.Lens.Traversal.Traversal' s a -> (a -> m r) -> s -> m ()--- 'mapMOf_' :: 'Monad' m => 'Simple' 'Control.Lens.Prism.Prism' s a     -> (a -> m r) -> s -> m ()--- @-mapMOf_ :: Monad m => Getting (Sequenced m) s t a b -> (a -> m r) -> s -> m ()-mapMOf_ l f = getSequenced# (foldMapOf l (sequenced# (liftM skip . f)))-{-# INLINE mapMOf_ #-}--skip :: a -> ()-skip _ = ()-{-# INLINE skip #-}---- | 'forMOf_' is 'mapMOf_' with two of its arguments flipped.------ @'Data.Foldable.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 => 'Simple' 'Lens' s a      -> s -> (a -> m r) -> m ()--- 'forMOf_' :: 'Monad' m => 'Simple' 'Control.Lens.Iso.Iso' s a       -> s -> (a -> m r) -> m ()--- 'forMOf_' :: 'Monad' m => 'Simple' 'Control.Lens.Traversal.Traversal' s a -> s -> (a -> m r) -> m ()--- 'forMOf_' :: 'Monad' m => 'Simple' 'Control.Lens.Prism.Prism' s a     -> s -> (a -> m r) -> m ()--- @-forMOf_ :: Monad m => Getting (Sequenced m) s t a b -> s -> (a -> m r) -> m ()-forMOf_ = flip . mapMOf_-{-# INLINE forMOf_ #-}---- | Evaluate each monadic action referenced by a 'Fold' on the structure from left to right, and ignore the results.------ @'Data.Foldable.sequence_' ≡ 'sequenceOf_' 'folded'@------ @--- 'sequenceOf_' :: 'Monad' m => 'Getter' s (m a)           -> s -> m ()--- 'sequenceOf_' :: 'Monad' m => 'Fold' s (m a)             -> s -> m ()--- 'sequenceOf_' :: 'Monad' m => 'Simple' 'Lens' s (m a)      -> s -> m ()--- 'sequenceOf_' :: 'Monad' m => 'Simple' 'Control.Lens.Iso.Iso' s (m a)       -> s -> m ()--- 'sequenceOf_' :: 'Monad' m => 'Simple' 'Control.Lens.Traversal.Traversal' s (m a) -> s -> m ()--- 'sequenceOf_' :: 'Monad' m => 'Simple' 'Control.Lens.Prism.Prism' s (m a)     -> s -> m ()--- @-sequenceOf_ :: Monad m => Getting (Sequenced m) s t (m a) b -> s -> m ()-sequenceOf_ l = getSequenced# (foldMapOf l (sequenced# (liftM skip)))-{-# INLINE sequenceOf_ #-}---- | The sum of a collection of actions, generalizing 'concatOf'.------ @'asum' ≡ 'asumOf' 'folded'@------ @--- 'asumOf' :: 'Alternative' f => 'Getter' s a           -> s -> f a--- 'asumOf' :: 'Alternative' f => 'Fold' s a             -> s -> f a--- 'asumOf' :: 'Alternative' f => 'Simple' 'Lens' s a      -> s -> f a--- 'asumOf' :: 'Alternative' f => 'Simple' 'Control.Lens.Iso.Iso' s a       -> s -> f a--- 'asumOf' :: 'Alternative' f => 'Simple' 'Control.Lens.Traversal.Traversal' s a -> s -> f a--- 'asumOf' :: 'Alternative' f => 'Simple' 'Control.Lens.Prism.Prism' s a     -> s -> f a--- @-asumOf :: Alternative f => Getting (Endo (f a)) s t (f a) b -> s -> f a-asumOf l = foldrOf l (<|>) Applicative.empty-{-# INLINE asumOf #-}---- | The sum of a collection of actions, generalizing 'concatOf'.------ @'msum' ≡ 'msumOf' 'folded'@------ @--- 'msumOf' :: 'MonadPlus' m => 'Getter' s a           -> s -> m a--- 'msumOf' :: 'MonadPlus' m => 'Fold' s a             -> s -> m a--- 'msumOf' :: 'MonadPlus' m => 'Simple' 'Lens' s a      -> s -> m a--- 'msumOf' :: 'MonadPlus' m => 'Simple' 'Control.Lens.Iso.Iso' s a       -> s -> m a--- 'msumOf' :: 'MonadPlus' m => 'Simple' 'Control.Lens.Traversal.Traversal' s a -> s -> m a--- 'msumOf' :: 'MonadPlus' m => 'Simple' 'Control.Lens.Prism.Prism' s a     -> s -> m a--- @-msumOf :: MonadPlus m => Getting (Endo (m a)) s t (m a) b -> s -> m a-msumOf l = foldrOf l mplus mzero-{-# INLINE msumOf #-}---- | 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 => 'Simple' 'Lens' s a      -> a -> s -> 'Bool'--- 'elemOf' :: 'Eq' a => 'Simple' 'Control.Lens.Iso.Iso' s a       -> a -> s -> 'Bool'--- 'elemOf' :: 'Eq' a => 'Simple' 'Control.Lens.Traversal.Traversal' s a -> a -> s -> 'Bool'--- 'elemOf' :: 'Eq' a => 'Simple' 'Control.Lens.Prism.Prism' s a     -> a -> s -> 'Bool'--- @-elemOf :: Eq a => Getting Any s t a b -> a -> s -> Bool-elemOf l = anyOf l . (==)-{-# INLINE elemOf #-}---- | Does the element not occur anywhere within a given 'Fold' of the structure?------ @'notElem' ≡ 'notElemOf' 'folded'@------ @--- 'notElemOf' :: 'Eq' a => 'Getter' s a           -> a -> s -> 'Bool'--- 'notElemOf' :: 'Eq' a => 'Fold' s a             -> a -> s -> 'Bool'--- 'notElemOf' :: 'Eq' a => 'Simple' 'Control.Lens.Iso.Iso' s a       -> a -> s -> 'Bool'--- 'notElemOf' :: 'Eq' a => 'Simple' 'Lens' s a      -> a -> s -> 'Bool'--- 'notElemOf' :: 'Eq' a => 'Simple' 'Control.Lens.Traversal.Traversal' s a -> a -> s -> 'Bool'--- 'notElemOf' :: 'Eq' a => 'Simple' 'Control.Lens.Prism.Prism' s a     -> a -> s -> 'Bool'--- @-notElemOf :: Eq a => Getting All s t a b -> a -> s -> Bool-notElemOf l = allOf l . (/=)-{-# INLINE notElemOf #-}---- | Map a function over all the targets of a 'Fold' of a container and concatenate the resulting lists.------ @'concatMap' ≡ 'concatMapOf' 'folded'@------ @--- 'concatMapOf' :: 'Getter' s a           -> (a -> [r]) -> s -> [r]--- 'concatMapOf' :: 'Fold' s a             -> (a -> [r]) -> s -> [r]--- 'concatMapOf' :: 'Simple' 'Lens' s a      -> (a -> [r]) -> s -> [r]--- 'concatMapOf' :: 'Simple' 'Control.Lens.Iso.Iso' s a       -> (a -> [r]) -> s -> [r]--- 'concatMapOf' :: 'Simple' 'Control.Lens.Traversal.Traversal' s a -> (a -> [r]) -> s -> [r]--- @-concatMapOf :: Getting [r] s t a b -> (a -> [r]) -> s -> [r]-concatMapOf l ces = runAccessor# (l (accessor# ces))-{-# INLINE concatMapOf #-}---- | 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' :: 'Simple' 'Control.Lens.Iso.Iso' s [r]       -> s -> [r]--- 'concatOf' :: 'Simple' 'Lens' s [r]      -> s -> [r]--- 'concatOf' :: 'Simple' 'Control.Lens.Traversal.Traversal' s [r] -> s -> [r]--- @-concatOf :: Getting [r] s t [r] b -> s -> [r]-concatOf = view-{-# INLINE concatOf #-}---- |--- Note: this can be rather inefficient for large containers.------ @'length' ≡ 'lengthOf' 'folded'@------ >>> lengthOf _1 ("hello",())--- 1------ @'lengthOf' ('folded' . 'folded') :: 'Foldable' f => f (g a) -> 'Int'@------ @--- 'lengthOf' :: 'Getter' s a           -> s -> 'Int'--- 'lengthOf' :: 'Fold' s a             -> s -> 'Int'--- 'lengthOf' :: 'Simple' 'Lens' s a      -> s -> 'Int'--- 'lengthOf' :: 'Simple' 'Control.Lens.Iso.Iso' s a       -> s -> 'Int'--- 'lengthOf' :: 'Simple' 'Control.Lens.Traversal.Traversal' s a -> s -> 'Int'--- @-lengthOf :: Getting (Sum Int) s t a b -> s -> Int-lengthOf l = getSum# (foldMapOf l (\_ -> Sum 1))-{-# INLINE lengthOf #-}---- | A deprecated alias for 'firstOf'-headOf :: Getting (First a) s t a b -> s -> Maybe a-headOf l = getFirst# (foldMapOf l (first# Just))-{-# INLINE headOf #-}-{-# DEPRECATED headOf "`headOf' will be removed in 3.8. (Use `preview' or `firstOf')" #-}---- | Perform a safe 'head' of a 'Fold' or 'Control.Lens.Traversal.Traversal' or retrieve 'Just' the result--- from a 'Getter' or 'Lens'.------ When using a 'Control.Lens.Traversal.Traversal' as a partial 'Control.Lens.Type.Lens', or a 'Fold' as a partial 'Getter' this can be a convenient--- way to extract the optional value.------ @('^?') ≡ 'flip' 'preview'@------ @--- ('^?') :: s -> 'Getter' s a           -> 'Maybe' a--- ('^?') :: s -> 'Fold' s a             -> 'Maybe' a--- ('^?') :: s -> 'Simple' 'Lens' s a      -> 'Maybe' a--- ('^?') :: s -> 'Simple' 'Control.Lens.Iso.Iso' s a       -> 'Maybe' a--- ('^?') :: s -> 'Simple' 'Control.Lens.Traversal.Traversal' s a -> 'Maybe' a--- @-(^?) :: s -> Getting (First a) s t a b -> Maybe a-a ^? l = getFirst (foldMapOf l (first# Just) a)-{-# INLINE (^?) #-}---- | Perform an *UNSAFE* 'head' of a 'Fold' or 'Control.Lens.Traversal.Traversal' assuming that it is there.------ @--- ('^?!') :: s -> 'Getter' s a           -> a--- ('^?!') :: s -> 'Fold' s a             -> a--- ('^?!') :: s -> 'Simple' 'Lens' s a      -> a--- ('^?!') :: s -> 'Simple' 'Control.Lens.Iso.Iso' s a       -> a--- ('^?!') :: s -> 'Simple' 'Control.Lens.Traversal.Traversal' s a -> a--- @-(^?!) :: s -> Getting (First a) s t a b -> a-a ^?! l = fromMaybe (error "(^?!): empty Fold") $ getFirst (foldMapOf l (first# Just) a)-{-# INLINE (^?!) #-}---- | Retrieve the 'First' entry of a 'Fold' or 'Control.Lens.Traversal.Traversal' or retrieve 'Just' the result--- from a 'Getter' or 'Lens'.------ @--- 'firstOf' :: 'Getter' s a           -> s -> 'Maybe' a--- 'firstOf' :: 'Fold' s a             -> s -> 'Maybe' a--- 'firstOf' :: 'Simple' 'Lens' s a      -> s -> 'Maybe' a--- 'firstOf' :: 'Simple' 'Control.Lens.Iso.Iso' s a       -> s -> 'Maybe' a--- 'firstOf' :: 'Simple' 'Control.Lens.Traversal.Traversal' s a -> s -> 'Maybe' a--- @-firstOf :: Getting (First a) s t a b -> s -> Maybe a-firstOf l = getFirst# (foldMapOf l (first# Just))-{-# INLINE firstOf #-}---- | Retrieve the 'Last' entry of a 'Fold' or 'Control.Lens.Traversal.Traversal' or retrieve 'Just' the result--- from a 'Getter' or 'Lens'.------ @--- 'lastOf' :: 'Getter' s a           -> s -> 'Maybe' a--- 'lastOf' :: 'Fold' s a             -> s -> 'Maybe' a--- 'lastOf' :: 'Simple' 'Lens' s a      -> s -> 'Maybe' a--- 'lastOf' :: 'Simple' 'Control.Lens.Iso.Iso' s a       -> s -> 'Maybe' a--- 'lastOf' :: 'Simple' 'Control.Lens.Traversal.Traversal' s a -> s -> 'Maybe' a--- @-lastOf :: Getting (Last a) s t a b -> s -> Maybe a-lastOf l = getLast# (foldMapOf l (last# Just))-{-# INLINE lastOf #-}---- |--- Returns 'True' if this 'Fold' or 'Control.Lens.Traversal.Traversal' has no targets in the given container.------ Note: 'nullOf' on a valid 'Control.Lens.Iso.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' ('folded' '.' '_1' '.' 'folded') :: 'Foldable' f => f (g a, b) -> 'Bool'@------ @--- 'nullOf' :: 'Getter' s a           -> s -> 'Bool'--- 'nullOf' :: 'Fold' s a             -> s -> 'Bool'--- 'nullOf' :: 'Simple' 'Control.Lens.Iso.Iso' s a       -> s -> 'Bool'--- 'nullOf' :: 'Simple' 'Lens' s a      -> s -> 'Bool'--- 'nullOf' :: 'Simple' 'Control.Lens.Traversal.Traversal' s a -> s -> 'Bool'--- @-nullOf :: Getting All s t a b -> s -> Bool-nullOf l = getAll# (foldMapOf l (\_ -> All False))-{-# INLINE nullOf #-}----- |--- Returns 'True' if this 'Fold' or 'Control.Lens.Traversal.Traversal' has any targets in the given container.------ Note: 'notNullOf' on a valid 'Control.Lens.Iso.Iso', 'Lens' or 'Getter' should always return 'True'------ @'null' ≡ 'notNullOf' 'folded'@------ This may be rather inefficient compared to the @'not' . 'null'@ check of many containers.------ >>> notNullOf _1 (1,2)--- True------ @'notNullOf' ('folded' '.' '_1' '.' 'folded') :: 'Foldable' f => f (g a, b) -> 'Bool'@------ @--- 'notNullOf' :: 'Getter' s a           -> s -> 'Bool'--- 'notNullOf' :: 'Fold' s a             -> s -> 'Bool'--- 'notNullOf' :: 'Simple' 'Control.Lens.Iso.Iso' s a       -> s -> 'Bool'--- 'notNullOf' :: 'Simple' 'Lens' s a      -> s -> 'Bool'--- 'notNullOf' :: 'Simple' 'Control.Lens.Traversal.Traversal' s a -> s -> 'Bool'--- @-notNullOf :: Getting Any s t a b -> s -> Bool-notNullOf l = getAny# (foldMapOf l (\_ -> Any True))-{-# INLINE notNullOf #-}---- |--- Obtain the maximum element (if any) targeted by a 'Fold' or 'Control.Lens.Traversal.Traversal'------ Note: maximumOf on a valid 'Control.Lens.Iso.Iso', 'Lens' or 'Getter' will always return 'Just' a value.------ @'maximum' ≡ 'fromMaybe' ('error' \"empty\") '.' 'maximumOf' 'folded'@------ @--- 'maximumOf' ::          'Getter' s a           -> s -> 'Maybe' a--- 'maximumOf' :: 'Ord' a => 'Fold' s a             -> s -> 'Maybe' a--- 'maximumOf' ::          'Simple' 'Control.Lens.Iso.Iso' s a       -> s -> 'Maybe' a--- 'maximumOf' ::          'Simple' 'Lens' s a      -> s -> 'Maybe' a--- 'maximumOf' :: 'Ord' a => 'Simple' 'Control.Lens.Traversal.Traversal' s a -> s -> 'Maybe' a--- @-maximumOf :: Getting (Max a) s t a b -> s -> Maybe a-maximumOf l = getMax . foldMapOf l Max-{-# INLINE maximumOf #-}---- |--- Obtain the minimum element (if any) targeted by a 'Fold' or 'Control.Lens.Traversal.Traversal'------ Note: minimumOf on a valid 'Control.Lens.Iso.Iso', 'Lens' or 'Getter' will always return 'Just' a value.------ @'minimum' ≡ 'Data.Maybe.fromMaybe' ('error' \"empty\") '.' 'minimumOf' 'folded'@------ @--- 'minimumOf' ::          'Getter' s a           -> s -> 'Maybe' a--- 'minimumOf' :: 'Ord' a => 'Fold' s a             -> s -> 'Maybe' a--- 'minimumOf' ::          'Simple' 'Control.Lens.Iso.Iso' s a       -> s -> 'Maybe' a--- 'minimumOf' ::          'Simple' 'Lens' s a      -> s -> 'Maybe' a--- 'minimumOf' :: 'Ord' a => 'Simple' 'Control.Lens.Traversal.Traversal' s a -> s -> 'Maybe' a--- @-minimumOf :: Getting (Min a) s t a b -> s -> Maybe a-minimumOf l = getMin . foldMapOf l Min-{-# INLINE minimumOf #-}---- |--- Obtain the maximum element (if any) targeted by a 'Fold', 'Control.Lens.Traversal.Traversal', 'Lens', 'Control.Lens.Iso.Iso',--- or 'Getter' according to a user supplied ordering.------ @'Data.Foldable.maximumBy' cmp ≡ 'Data.Maybe.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' :: 'Simple' 'Control.Lens.Iso.Iso' s a       -> (a -> a -> 'Ordering') -> s -> 'Maybe' a--- 'maximumByOf' :: 'Simple' 'Lens' s a      -> (a -> a -> 'Ordering') -> s -> 'Maybe' a--- 'maximumByOf' :: 'Simple' 'Control.Lens.Traversal.Traversal' s a -> (a -> a -> 'Ordering') -> s -> 'Maybe' a--- @-maximumByOf :: Getting (Endo (Maybe a)) s t a b -> (a -> a -> Ordering) -> s -> Maybe a-maximumByOf l cmp = foldrOf l step Nothing where-  step a Nothing  = Just a-  step a (Just b) = Just (if cmp a b == GT then a else b)-{-# INLINE maximumByOf #-}---- |--- Obtain the minimum element (if any) targeted by a 'Fold', 'Control.Lens.Traversal.Traversal', 'Lens', 'Control.Lens.Iso.Iso'--- or 'Getter' according to a user supplied ordering.------ @'minimumBy' cmp ≡ 'Data.Maybe.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' :: 'Simple' 'Control.Lens.Iso.Iso' s a       -> (a -> a -> 'Ordering') -> s -> 'Maybe' a--- 'minimumByOf' :: 'Simple' 'Lens' s a      -> (a -> a -> 'Ordering') -> s -> 'Maybe' a--- 'minimumByOf' :: 'Simple' 'Control.Lens.Traversal.Traversal' s a -> (a -> a -> 'Ordering') -> s -> 'Maybe' a--- @-minimumByOf :: Getting (Endo (Maybe a)) s t a b -> (a -> a -> Ordering) -> s -> Maybe a-minimumByOf l cmp = foldrOf l step Nothing where-  step a Nothing  = Just a-  step a (Just b) = Just (if cmp a b == GT then b else a)-{-# INLINE minimumByOf #-}---- | The 'findOf' function takes a 'Lens' (or 'Control.Lens.Getter.Getter', 'Control.Lens.Iso.Iso', 'Control.Lens.Fold.Fold', or 'Control.Lens.Traversal.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' :: 'Getter' s a           -> (a -> 'Bool') -> s -> 'Maybe' a--- 'findOf' :: 'Fold' s a             -> (a -> 'Bool') -> s -> 'Maybe' a--- 'findOf' :: 'Simple' 'Control.Lens.Iso.Iso' s a       -> (a -> 'Bool') -> s -> 'Maybe' a--- 'findOf' :: 'Simple' 'Lens' s a      -> (a -> 'Bool') -> s -> 'Maybe' a--- 'findOf' :: 'Simple' 'Control.Lens.Traversal.Traversal' s a -> (a -> 'Bool') -> s -> 'Maybe' a--- @-findOf :: Getting (First a) s t a b -> (a -> Bool) -> s -> Maybe a-findOf l p = getFirst# (foldMapOf l step) where-  step a-    | p a       = First (Just a)-    | otherwise = First Nothing-{-# INLINE findOf #-}---- |--- 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' l f ≡ 'Prelude.foldr1' f '.' 'toListOf' l--- 'Data.Foldable.foldr1' ≡ 'foldr1Of' 'folded'--- @------ @--- 'foldr1Of' :: 'Getter' s a           -> (a -> a -> a) -> s -> a--- 'foldr1Of' :: 'Fold' s a             -> (a -> a -> a) -> s -> a--- 'foldr1Of' :: 'Simple' 'Control.Lens.Iso.Iso' s a       -> (a -> a -> a) -> s -> a--- 'foldr1Of' :: 'Simple' 'Lens' s a      -> (a -> a -> a) -> s -> a--- 'foldr1Of' :: 'Simple' 'Control.Lens.Traversal.Traversal' s a -> (a -> a -> a) -> s -> a--- @-foldr1Of :: Getting (Endo (Maybe a)) s t a b -> (a -> a -> a) -> s -> a-foldr1Of l f xs = fromMaybe (error "foldr1Of: empty structure")-                            (foldrOf l mf Nothing xs) where-  mf x Nothing = Just x-  mf x (Just y) = Just (f x y)-{-# INLINE foldr1Of #-}---- | 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' l f ≡ 'Prelude.foldl1Of' l f . 'toList'--- 'Data.Foldable.foldl1' ≡ 'foldl1Of' 'folded'--- @------ @--- 'foldl1Of' :: 'Getter' s a           -> (a -> a -> a) -> s -> a--- 'foldl1Of' :: 'Fold' s a             -> (a -> a -> a) -> s -> a--- 'foldl1Of' :: 'Simple' 'Control.Lens.Iso.Iso' s a       -> (a -> a -> a) -> s -> a--- 'foldl1Of' :: 'Simple' 'Lens' s a      -> (a -> a -> a) -> s -> a--- 'foldl1Of' :: 'Simple' 'Control.Lens.Traversal.Traversal' s a -> (a -> a -> a) -> s -> a--- @-foldl1Of :: Getting (Dual (Endo (Maybe a))) s t a b -> (a -> a -> a) -> s -> a-foldl1Of l f xs = fromMaybe (error "foldl1Of: empty structure") (foldlOf l mf Nothing xs) where-  mf Nothing y = Just y-  mf (Just x) y = Just (f x y)-{-# INLINE foldl1Of #-}---- | Strictly fold right over the elements of a structure.------ @'Data.Foldable.foldr'' ≡ 'foldrOf'' 'folded'@------ @--- 'foldrOf'' :: 'Getter' s a           -> (a -> r -> r) -> r -> s -> r--- 'foldrOf'' :: 'Fold' s a             -> (a -> r -> r) -> r -> s -> r--- 'foldrOf'' :: 'Simple' 'Control.Lens.Iso.Iso' s a       -> (a -> r -> r) -> r -> s -> r--- 'foldrOf'' :: 'Simple' 'Lens' s a      -> (a -> r -> r) -> r -> s -> r--- 'foldrOf'' :: 'Simple' 'Control.Lens.Traversal.Traversal' s a -> (a -> r -> r) -> r -> s -> r--- @-foldrOf' :: Getting (Dual (Endo (r -> r))) s t a b -> (a -> r -> r) -> r -> s -> r-foldrOf' l f z0 xs = foldlOf l f' id xs z0-  where f' k x z = k $! f x z-{-# INLINE foldrOf' #-}---- | Fold over the elements of a structure, associating to the left, but strictly.------ @'Data.Foldable.foldl'' ≡ 'foldlOf'' 'folded'@------ @--- 'foldlOf'' :: 'Getter' s a           -> (r -> a -> r) -> r -> s -> r--- 'foldlOf'' :: 'Fold' s a             -> (r -> a -> r) -> r -> s -> r--- 'foldlOf'' :: 'Simple' 'Control.Lens.Iso.Iso' s a       -> (r -> a -> r) -> r -> s -> r--- 'foldlOf'' :: 'Simple' 'Lens' s a      -> (r -> a -> r) -> r -> s -> r--- 'foldlOf'' :: 'Simple' 'Control.Lens.Traversal.Traversal' s a -> (r -> a -> r) -> r -> s -> r--- @-foldlOf' :: Getting (Endo (r -> r)) s t a b -> (r -> a -> r) -> r -> s -> r-foldlOf' l f z0 xs = foldrOf l f' id xs z0-  where f' x k z = k $! f z x-{-# INLINE foldlOf' #-}---- | Monadic fold over the elements of a structure, associating to the right,--- i.e. from right to left.------ @'Data.Foldable.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 => 'Simple' 'Control.Lens.Iso.Iso' s a       -> (a -> r -> m r) -> r -> s -> m r--- 'foldrMOf' :: 'Monad' m => 'Simple' 'Lens' s a      -> (a -> r -> m r) -> r -> s -> m r--- 'foldrMOf' :: 'Monad' m => 'Simple' 'Control.Lens.Traversal.Traversal' s a -> (a -> r -> m r) -> r -> s -> m r--- @-foldrMOf :: Monad m-         => Getting (Dual (Endo (r -> m r))) s t a b-         -> (a -> r -> m r) -> r -> s -> m r-foldrMOf l f z0 xs = foldlOf l f' return xs z0-  where f' k x z = f x z >>= k-{-# INLINE foldrMOf #-}---- | Monadic fold over the elements of a structure, associating to the left,--- i.e. from left to right.------ @'Data.Foldable.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 => 'Simple' 'Control.Lens.Iso.Iso' s a       -> (r -> a -> m r) -> r -> s -> m r--- 'foldlMOf' :: 'Monad' m => 'Simple' 'Lens' s a      -> (r -> a -> m r) -> r -> s -> m r--- 'foldlMOf' :: 'Monad' m => 'Simple' 'Control.Lens.Traversal.Traversal' s a -> (r -> a -> m r) -> r -> s -> m r--- @-foldlMOf :: Monad m-         => Getting (Endo (r -> m r)) s t a b-         -> (r -> a -> m r) -> r -> s -> m r-foldlMOf l f z0 xs = foldrOf l f' return xs z0-  where f' x k z = f z x >>= k-{-# INLINE foldlMOf #-}---- | Useful for storing folds in containers.-newtype ReifiedFold s a = ReifyFold { reflectFold :: Fold s a }----------------------------------------------------------------------------------- Preview----------------------------------------------------------------------------------- | Retrieve the first value targeted by a 'Fold' or 'Control.Lens.Traversal.Traversal' (or 'Just' the result--- from a 'Getter' or 'Lens'). See also ('^?').------ @'Data.Maybe.listToMaybe' '.' 'toList' ≡ 'preview' 'folded'@------ This is usually applied in the reader monad @(->) s@.------ @--- 'preview' :: 'Getter' s a           -> s -> 'Maybe' a--- 'preview' :: 'Fold' s a             -> s -> 'Maybe' a--- 'preview' :: 'Simple' 'Lens' s a      -> s -> 'Maybe' a--- 'preview' :: 'Simple' 'Control.Lens.Iso.Iso' s a       -> s -> 'Maybe' a--- 'preview' :: 'Simple' 'Control.Lens.Traversal.Traversal' s a -> s -> 'Maybe' a--- @------ However, it may be useful to think of its full generality when working with--- a monad transformer stack:------ @--- 'preview' :: MonadReader s m => 'Getter' s a           -> m ('Maybe' a)--- 'preview' :: MonadReader s m => 'Fold' s a             -> m ('Maybe' a)--- 'preview' :: MonadReader s m => 'Simple' 'Lens' s a      -> m ('Maybe' a)--- 'preview' :: MonadReader s m => 'Simple' 'Control.Lens.Iso.Iso' s a       -> m ('Maybe' a)--- 'preview' :: MonadReader s m => 'Simple' 'Control.Lens.Traversal.Traversal' s a -> m ('Maybe' a)--- @-preview :: MonadReader s m => Getting (First a) s t a b -> m (Maybe a)-preview l = asks (getFirst# (foldMapOf l (first# Just)))-{-# INLINE preview #-}---- | Retrieve a function of the first value targeted by a 'Fold' or--- 'Control.Lens.Traversal.Traversal' (or 'Just' the result from a 'Getter' or 'Lens').------ This is usually applied in the reader monad @(->) s@.------ @--- 'previews' :: 'Getter' s a           -> (a -> r) -> s -> 'Maybe' a--- 'previews' :: 'Fold' s a             -> (a -> r) -> s -> 'Maybe' a--- 'previews' :: 'Simple' 'Lens' s a      -> (a -> r) -> s -> 'Maybe' a--- 'previews' :: 'Simple' 'Control.Lens.Iso.Iso' s a       -> (a -> r) -> s -> 'Maybe' a--- 'previews' :: 'Simple' 'Control.Lens.Traversal.Traversal' s a -> (a -> r) -> s -> 'Maybe' a--- @------ However, it may be useful to think of its full generality when working with--- a monad transformer stack:------ @--- 'previews' :: MonadReader s m => 'Getter' s a           -> (a -> r) -> m ('Maybe' r)--- 'previews' :: MonadReader s m => 'Fold' s a             -> (a -> r) -> m ('Maybe' r)--- 'previews' :: MonadReader s m => 'Simple' 'Lens' s a      -> (a -> r) -> m ('Maybe' r)--- 'previews' :: MonadReader s m => 'Simple' 'Control.Lens.Iso.Iso' s a       -> (a -> r) -> m ('Maybe' r)--- 'previews' :: MonadReader s m => 'Simple' 'Control.Lens.Traversal.Traversal' s a -> (a -> r) -> m ('Maybe' r)--- @-previews :: MonadReader s m => Getting (First r) s t a b -> (a -> r) -> m (Maybe r)-previews l f = asks (getFirst# (foldMapOf l (first# (Just . f))))-{-# INLINE previews #-}------------------------------------------------------------------------------------ Preuse----------------------------------------------------------------------------------- | Retrieve the first value targeted by a 'Fold' or 'Control.Lens.Traversal.Traversal' (or 'Just' the result--- from a 'Getter' or 'Lens') into the current state.------ @--- 'preuse' :: MonadState s m => 'Getter' s a           -> m ('Maybe' a)--- 'preuse' :: MonadState s m => 'Fold' s a             -> m ('Maybe' a)--- 'preuse' :: MonadState s m => 'Simple' 'Lens' s a      -> m ('Maybe' a)--- 'preuse' :: MonadState s m => 'Simple' 'Control.Lens.Iso.Iso' s a       -> m ('Maybe' a)--- 'preuse' :: MonadState s m => 'Simple' 'Control.Lens.Traversal.Traversal' s a -> m ('Maybe' a)--- @-preuse :: MonadState s m => Getting (First a) s t a b -> m (Maybe a)-preuse l = gets (getFirst# (foldMapOf l (first# Just)))-{-# INLINE preuse #-}---- | Retrieve a function of the first value targeted by a 'Fold' or--- 'Control.Lens.Traversal.Traversal' (or 'Just' the result from a 'Getter' or 'Lens') into the current state.------ @--- '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 => 'Simple' 'Lens' s a      -> (a -> r) -> m ('Maybe' r)--- 'preuses' :: MonadState s m => 'Simple' 'Control.Lens.Iso.Iso' s a       -> (a -> r) -> m ('Maybe' r)--- 'preuses' :: MonadState s m => 'Simple' 'Control.Lens.Traversal.Traversal' s a -> (a -> r) -> m ('Maybe' r)--- @-preuses :: MonadState s m => Getting (First r) s t a b -> (a -> r) -> m (Maybe r)-preuses l f = gets (getFirst# (foldMapOf l (first# (Just . f))))-{-# INLINE preuses #-}+{-# LANGUAGE Rank2Types #-}+{-# LANGUAGE FlexibleContexts #-}+{-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE MultiParamTypeClasses #-}+#ifdef TRUSTWORTHY+{-# LANGUAGE Trustworthy #-}+#endif+----------------------------------------------------------------------------+-- |+-- Module      :  Control.Lens.Fold+-- Copyright   :  (C) 2012-13 Edward Kmett+-- License     :  BSD-style (see the file LICENSE)+-- Maintainer  :  Edward Kmett <ekmett@gmail.com>+-- Stability   :  provisional+-- Portability :  Rank2Types+--+-- A @'Fold' s a@ is a generalization of something 'Foldable'. It allows+-- you to extract multiple results from a container. A 'Foldable' container+-- can be characterized by the behavior of+-- @'Data.Foldable.foldMap' :: ('Foldable' t, 'Monoid' m) => (a -> m) -> t a -> m@.+-- Since we want to be able to work with monomorphic containers, we could+-- generalize this signature to @forall m. 'Monoid' m => (a -> m) -> s -> m@,+-- and then decorate it with 'Accessor' to obtain+--+-- @type 'Fold' s a = forall m. 'Monoid' m => 'Getting' m s s a a@+--+-- Every 'Getter' is a valid 'Fold' that simply doesn't use the 'Monoid'+-- it is passed.+--+-- In practice the type we use is slightly more complicated to allow for+-- better error messages and for it to be transformed by certain+-- 'Applicative' transformers.+--+-- Everything you can do with a 'Foldable' container, you can with with a 'Fold' and there are+-- combinators that generalize the usual 'Foldable' operations here.+----------------------------------------------------------------------------+module Control.Lens.Fold+  (+  -- * Folds+    Fold+  , IndexedFold++  -- * Getting Started+  , (^..)+  , (^?)+  , (^?!)+  , pre, ipre+  , preview, previews, ipreview, ipreviews+  , preuse, preuses, ipreuse, ipreuses++  , has, hasn't++  -- ** Building Folds+  , folding+  , folded+  , unfolded+  , iterated+  , filtered+  , backwards+  , repeated+  , replicated+  , cycled+  , takingWhile+  , droppingWhile++  -- ** Folding+  , foldMapOf, foldOf+  , foldrOf, foldlOf+  , toListOf+  , anyOf, allOf+  , andOf, orOf+  , productOf, sumOf+  , traverseOf_, forOf_, sequenceAOf_+  , mapMOf_, forMOf_, sequenceOf_+  , asumOf, msumOf+  , concatMapOf, concatOf+  , elemOf, notElemOf+  , lengthOf+  , nullOf, notNullOf+  , firstOf, lastOf+  , maximumOf, minimumOf+  , maximumByOf, minimumByOf+  , findOf+  , foldrOf', foldlOf'+  , foldr1Of, foldl1Of+  , foldr1Of', foldl1Of'+  , foldrMOf, foldlMOf++  -- * Indexed Folds+  , (^@..)+  , (^@?)+  , (^@?!)++  -- ** Indexed Folding+  , ifoldMapOf+  , ifoldrOf+  , ifoldlOf+  , ianyOf+  , iallOf+  , itraverseOf_+  , iforOf_+  , imapMOf_+  , iforMOf_+  , iconcatMapOf+  , ifindOf+  , ifoldrOf'+  , ifoldlOf'+  , ifoldrMOf+  , ifoldlMOf+  , itoListOf++  -- ** Building Indexed Folds+  , ifiltered+  , itakingWhile+  , idroppingWhile++  -- * Deprecated+  , headOf++  -- * Internal types+  , Leftmost+  , Rightmost+  , Traversed+  , Sequenced+  ) where++import Control.Applicative as Applicative+import Control.Applicative.Backwards+import Control.Comonad+import Control.Lens.Getter+import Control.Lens.Internal.Fold+import Control.Lens.Internal.Getter+import Control.Lens.Internal.Indexed+import Control.Lens.Internal.Magma+import Control.Lens.Type+import Control.Monad+import Control.Monad.Reader+import Control.Monad.State+import Data.Foldable as Foldable+import Data.Functor.Compose+import Data.Maybe+import Data.Monoid+import Data.Profunctor+import Data.Profunctor.Rep+import Data.Profunctor.Unsafe+import Data.Traversable++-- $setup+-- >>> import Control.Lens+-- >>> import Data.List.Lens+-- >>> import Debug.SimpleReflect.Expr+-- >>> import Debug.SimpleReflect.Vars as Vars hiding (f,g)+-- >>> let f :: Expr -> Expr; f = Debug.SimpleReflect.Vars.f+-- >>> let g :: Expr -> Expr; g = Debug.SimpleReflect.Vars.g+-- >>> import Control.DeepSeq (NFData (..), force)+-- >>> import Control.Exception (evaluate)+-- >>> import Data.Maybe (fromMaybe)+-- >>> import System.Timeout (timeout)+-- >>> let timingOut :: NFData a => a -> IO a; timingOut = fmap (fromMaybe (error "timeout")) . timeout (5*10^6) . evaluate . force++{-# ANN module "HLint: ignore Eta reduce" #-}+{-# ANN module "HLint: ignore Use camelCase" #-}+{-# ANN module "HLint: ignore Use curry" #-}++infixl 8 ^.., ^?, ^?!, ^@.., ^@?, ^@?!++--------------------------+-- Folds+--------------------------++-- | 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, Applicative g, Gettable g) => (s -> f a) -> LensLike g s t a b+folding sfa agb = coerce . traverse_ agb . sfa+{-# INLINE folding #-}++-- | Obtain a 'Fold' from any 'Foldable'.+--+-- >>> Just 3^..folded+-- [3]+--+-- >>> Nothing^..folded+-- []+--+-- >>> [(1,2),(3,4)]^..folded.both+-- [1,2,3,4]+folded :: Foldable f => Fold (f a) a+folded f = coerce . getFolding . foldMap (Folding #. f)+{-# INLINE folded #-}++-- | 'Fold' 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 :: Fold a a+repeated f a = as where as = f a *> as+{-# INLINE repeated #-}++-- | 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]+replicated :: Int -> Fold a a+replicated n0 f a = go n0 where+  m = f a+  go 0 = noEffect+  go n = m *> go (n - 1)+{-# INLINE replicated #-}++-- | Transform a 'Fold' into a 'Fold' that loops over its elements over and over.+--+-- >>> timingOut $ [1,2,3]^..taking 7 (cycled traverse)+-- [1,2,3,1,2,3,1]+cycled :: (Applicative f, Gettable f) => LensLike f s t a b -> LensLike f s t a b+cycled l f a = as where as = l f a *> as+{-# INLINE cycled #-}++-- | Build a 'Fold' that unfolds its values from a seed.+--+-- @+-- 'Prelude.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]+unfolded :: (b -> Maybe (a, b)) -> Fold b a+unfolded f g b0 = go b0 where+  go b = case f b of+    Just (a, b') -> g a *> go b'+    Nothing      -> noEffect+{-# INLINE unfolded #-}++-- | @x '^.' 'iterated' f@ returns an infinite 'Fold' of repeated applications of @f@ to @x@.+--+-- @+-- 'toListOf' ('iterated' f) a ≡ 'iterate' f a+-- @+iterated :: (a -> a) -> Fold a a+iterated f g a0 = go a0 where+  go a = g a *> go (f a)+{-# INLINE iterated #-}++-- | 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 matches the predicate.+--+-- As a counter example, consider that given @evens = 'filtered' 'even'@ the second 'Traversal' law is violated:+--+-- @+-- 'Control.Lens.Setter.over' evens 'succ' '.' 'Control.Lens.Setter.over' evens 'succ' '/=' 'Control.Lens.Setter.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) -> Overloaded' p f a a+filtered p = dimap (\x -> if p x then Right x else Left x) (either pure id) . right'+{-# INLINE filtered #-}++-- | 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') -> 'Action' m s a                     -> 'MonadicFold' m s a+-- 'takingWhile' :: (a -> 'Bool') -> 'MonadicFold' m s a                -> 'MonadicFold' m s a+-- '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+-- 'takingWhile' :: (a -> 'Bool') -> 'IndexedAction' i m s a            -> 'IndexedMonadicFold' i m s a+-- 'takingWhile' :: (a -> 'Bool') -> 'IndexedMonadicFold' i m s a       -> 'IndexedMonadicFold' i m 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.+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+takingWhile p l pafb = fmap runMagma . traverse (corep pafb) . runTakingWhile . l flag where+  flag = cotabulate $ \wa -> let a = extract wa; r = p a in TakingWhile r a $ \pr ->+    if pr && r then Magma () wa else MagmaPure a+{-# INLINE takingWhile #-}++-- | 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') -> 'IndexPreservingAction' m s a      -> 'IndexPreservingFold' m s a+-- @+--+-- @+-- 'droppingWhile' :: (a -> 'Bool') -> 'IndexPreservingMonadicFold' m s a -> 'IndexPreservingMonadicFold' m 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+-- 'droppingWhile' :: (a -> 'Bool') -> 'IndexedAction' i m s a            -> 'IndexedFold' i m s a+-- @+--+-- @+-- 'droppingWhile' :: (a -> 'Bool') -> 'IndexedMonadicFold' i m s a       -> 'IndexedMonadicFold' i m 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 also pass the predicate! Otherwise subsequent traversals will visit fewer elements+-- and 'Traversal' fusion is not sound.+droppingWhile :: (Conjoined p, Profunctor q, Applicative f)+              => (a -> Bool)+              -> Overloading p q (Compose (State Bool) f) s t a a+              -> Overloading p q f s t a a+droppingWhile p l f = (flip evalState True .# getCompose) `rmap` l g where+  g = cotabulate $ \wa -> Compose $ state $ \b -> let+      a = extract wa+      b' = b && p a+    in (if b' then pure a else corep f wa, b')+{-# INLINE droppingWhile #-}++--------------------------+-- Fold/Getter combinators+--------------------------++-- | @+-- 'Data.Foldable.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' ::             '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' :: 'Monoid' r => 'Prism'' s a     -> (a -> r) -> s -> r+-- @+--+-- @+-- 'foldMapOf' :: 'Getting' r s t a b -> (a -> r) -> s -> r+-- @+foldMapOf :: Profunctor p => Accessing p r s t a b -> p a r -> s -> r+foldMapOf l f = runAccessor #. l (Accessor #. f)+{-# INLINE foldMapOf #-}++-- | @+-- 'Data.Foldable.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+-- @+foldOf :: Getting a s t a b -> s -> a+foldOf l = runAccessor #. l Accessor+{-# INLINE foldOf #-}++-- | Right-associative fold of parts of a structure that are viewed through a 'Lens', 'Getter', 'Fold' or 'Traversal'.+--+-- @+-- 'Data.Foldable.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 t a b -> (a -> r -> r) -> r -> s -> r+-- @+foldrOf :: Profunctor p => Accessing p (Endo r) s t a b -> p a (r -> r) -> r -> s -> r+foldrOf l f z = flip appEndo z `rmap` foldMapOf l (Endo #. f)+{-# INLINE foldrOf #-}++-- | Left-associative fold of the parts of a structure that are viewed through a 'Lens', 'Getter', 'Fold' or 'Traversal'.+--+-- @+-- 'Data.Foldable.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+-- @+foldlOf :: Getting (Dual (Endo r)) s t a b -> (r -> a -> r) -> r -> s -> r+foldlOf l f z = (flip appEndo z .# getDual) `rmap` foldMapOf l (Dual #. Endo #. flip f)+{-# INLINE foldlOf #-}++-- | Extract a list of the targets of a 'Fold'. See also ('^..').+--+-- @+-- 'Data.Foldable.toList' ≡ 'toListOf' 'folded'+-- ('^..') ≡ 'flip' 'toListOf'+-- @++-- >>> toListOf both ("hello","world")+-- ["hello","world"]+--+-- @+-- 'toListOf' :: 'Getter' s a     -> s -> [a]+-- 'toListOf' :: 'Fold' s a       -> s -> [a]+-- 'toListOf' :: 'Lens'' s a      -> s -> [a]+-- 'toListOf' :: 'Iso'' s a       -> s -> [a]+-- 'toListOf' :: 'Traversal'' s a -> s -> [a]+-- 'toListOf' :: 'Prism'' s a     -> s -> [a]+-- @+toListOf :: Getting (Endo [a]) s t a b -> s -> [a]+toListOf l = foldrOf l (:) []+{-# INLINE toListOf #-}++-- | A convenient infix (flipped) version of 'toListOf'.+--+-- >>> [[1,2],[3]]^..traverse.traverse+-- [1,2,3]+--+-- >>> (1,2)^..both+-- [1,2]+--+-- @+-- 'Data.Foldable.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 t a b -> [a]+s ^.. l = toListOf l s+{-# INLINE (^..) #-}++-- | Returns 'True' if every target of a 'Fold' is 'True'.+--+-- >>> andOf both (True,False)+-- False+-- >>> andOf both (True,True)+-- True+--+-- @+-- 'Data.Foldable.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'+-- @+andOf :: Getting All s t Bool b -> s -> Bool+andOf l = getAll #. foldMapOf l All+{-# INLINE andOf #-}++-- | Returns 'True' if any target of a 'Fold' is 'True'.+--+-- >>> orOf both (True,False)+-- True+-- >>> orOf both (False,False)+-- False+--+-- @+-- 'Data.Foldable.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'+-- @+orOf :: Getting Any s t Bool b -> s -> Bool+orOf l = getAny #. foldMapOf l Any+{-# INLINE orOf #-}++-- | 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))+-- True+--+-- @+-- 'Data.Foldable.any' ≡ 'anyOf' 'folded'+-- @+--+-- @+-- 'ianyOf' l ≡ 'allOf' 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 :: Profunctor p => Accessing p Any s t a b -> p a Bool -> s -> Bool+anyOf l f = getAny #. foldMapOf l (Any #. f)+{-# INLINE anyOf #-}++-- | Returns 'True' if every target of a 'Fold' satisfies a predicate.+--+-- >>> allOf both (>=3) (4,5)+-- True+-- >>> allOf folded (>=2) [1..10]+-- False+--+-- @+-- 'Data.Foldable.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 :: Profunctor p => Accessing p All s t a b -> p a Bool -> s -> Bool+allOf l f = getAll #. foldMapOf l (All #. f)+{-# INLINE allOf #-}++-- | Calculate the 'Product' of every number targeted by a 'Fold'.+--+-- >>> productOf both (4,5)+-- 20+-- >>> productOf folded [1,2,3,4,5]+-- 120+--+-- @+-- 'Data.Foldable.product' ≡ 'productOf' 'folded'+-- @++-- This operation may be more strict than you would expect. If you+-- want a lazier version use @'ala' 'Sum' '.' '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+-- @+productOf :: Num a => Getting (Endo (Endo a)) s t a b -> s -> a+productOf l = foldlOf' l (*) 1+{-# INLINE productOf #-}++-- | 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+--+-- @+-- 'Data.Foldable.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' :: (a, b) -> a+-- 'sumOf' ('folded' '.' 'Control.Lens.Tuple._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+-- @+sumOf :: Num a => Getting (Endo (Endo a)) s t a b -> s -> a+sumOf l = foldlOf' l (+) 0+{-# INLINE sumOf #-}++-- | Traverse over all of the targets of a 'Fold' (or 'Getter'), computing an 'Applicative' (or 'Functor')-based answer,+-- but unlike 'Control.Lens.Traversal.traverseOf' do not construct a new structure. 'traverseOf_' generalizes+-- 'Data.Foldable.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+--+-- @+-- 'Data.Foldable.traverse_' ≡ 'traverseOf_' 'folded'+-- @+--+-- @+-- 'traverseOf_' '_2' :: 'Functor' f => (c -> f r) -> (d, c) -> f ()+-- 'traverseOf_' 'Data.Either.Lens.traverseLeft' :: '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 ()+-- @+traverseOf_ :: (Profunctor p, Functor f) => Accessing p (Traversed r f) s t a b -> p a (f r) -> s -> f ()+traverseOf_ l f = void . getTraversed #. foldMapOf l (Traversed #. f)+{-# INLINE traverseOf_ #-}++-- | Traverse over all of the targets of a 'Fold' (or 'Getter'), computing an 'Applicative' (or 'Functor')-based answer,+-- but unlike 'Control.Lens.Traversal.forOf' do not construct a new structure. 'forOf_' generalizes+-- 'Data.Foldable.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'+-- @+--+-- 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 ()+-- @+forOf_ :: (Profunctor p, Functor f) => Accessing p (Traversed r f) s t a b -> s -> p a (f r) -> f ()+forOf_ = flip . traverseOf_+{-# INLINE forOf_ #-}++-- | Evaluate each action in observed by a 'Fold' on a structure from left to right, ignoring the results.+--+-- @+-- 'sequenceA_' ≡ 'sequenceAOf_' 'folded'+-- @+--+-- @+-- '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 ()+-- @+sequenceAOf_ :: Functor f => Getting (Traversed a f) s t (f a) b -> s -> f ()+sequenceAOf_ l = void . getTraversed #. foldMapOf l Traversed+{-# INLINE sequenceAOf_ #-}++-- | Map each target of a 'Fold' on a structure to a monadic action, evaluate these actions from left to right, and ignore the results.+--+-- @+-- 'Data.Foldable.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 ()+-- @+mapMOf_ :: (Profunctor p, Monad m) => Accessing p (Sequenced r m) s t a b -> p a (m r) -> s -> m ()+mapMOf_ l f = liftM skip . getSequenced #. foldMapOf l (Sequenced #. f)+{-# INLINE mapMOf_ #-}++-- | 'forMOf_' is 'mapMOf_' with two of its arguments flipped.+--+-- @+-- 'Data.Foldable.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 ()+-- @+forMOf_ :: (Profunctor p, Monad m) => Accessing p (Sequenced r m) s t a b -> s -> p a (m r) -> m ()+forMOf_ = flip . mapMOf_+{-# INLINE forMOf_ #-}++-- | Evaluate each monadic action referenced by a 'Fold' on the structure from left to right, and ignore the results.+--+-- @+-- 'Data.Foldable.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 ()+-- @+sequenceOf_ :: Monad m => Getting (Sequenced a m) s t (m a) b -> s -> m ()+sequenceOf_ l = liftM skip . getSequenced #. foldMapOf l Sequenced+{-# INLINE sequenceOf_ #-}++-- | The sum of a collection of actions, generalizing 'concatOf'.+--+-- @+-- 'asum' ≡ 'asumOf' 'folded'+-- @+--+-- @+-- 'asumOf' :: 'Alternative' f => 'Getter' s a     -> s -> f a+-- 'asumOf' :: 'Alternative' f => 'Fold' s a       -> s -> f a+-- 'asumOf' :: 'Alternative' f => 'Lens'' s a      -> s -> f a+-- 'asumOf' :: 'Alternative' f => 'Iso'' s a       -> s -> f a+-- 'asumOf' :: 'Alternative' f => 'Traversal'' s a -> s -> f a+-- 'asumOf' :: 'Alternative' f => 'Prism'' s a     -> s -> f a+-- @+asumOf :: Alternative f => Getting (Endo (f a)) s t (f a) b -> s -> f a+asumOf l = foldrOf l (<|>) Applicative.empty+{-# INLINE asumOf #-}++-- | The sum of a collection of actions, generalizing 'concatOf'.+--+-- @+-- 'msum' ≡ 'msumOf' 'folded'+-- @+--+-- @+-- 'msumOf' :: 'MonadPlus' m => 'Getter' s a     -> s -> m a+-- 'msumOf' :: 'MonadPlus' m => 'Fold' s a       -> s -> m a+-- 'msumOf' :: 'MonadPlus' m => 'Lens'' s a      -> s -> m a+-- 'msumOf' :: 'MonadPlus' m => 'Iso'' s a       -> s -> m a+-- 'msumOf' :: 'MonadPlus' m => 'Traversal'' s a -> s -> m a+-- 'msumOf' :: 'MonadPlus' m => 'Prism'' s a     -> s -> m a+-- @+msumOf :: MonadPlus m => Getting (Endo (m a)) s t (m a) b -> s -> m a+msumOf l = foldrOf l mplus mzero+{-# INLINE msumOf #-}++-- | 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'+-- @+elemOf :: Eq a => Getting Any s t a b -> a -> s -> Bool+elemOf l = anyOf l . (==)+{-# INLINE elemOf #-}++-- | Does the element not occur anywhere within a given 'Fold' of the structure?+--+-- @+-- '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'+-- @+notElemOf :: Eq a => Getting All s t a b -> a -> s -> Bool+notElemOf l = allOf l . (/=)+{-# INLINE notElemOf #-}++-- | Map a function over all the targets of a 'Fold' of a container and concatenate the resulting lists.+--+-- @+-- '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]+-- @+concatMapOf :: Profunctor p => Accessing p [r] s t a b -> p a [r] -> s -> [r]+concatMapOf l ces = runAccessor #. l (Accessor #. ces)+{-# INLINE concatMapOf #-}++-- | 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 t [r] b -> s -> [r]+concatOf l = runAccessor #. l Accessor+{-# INLINE concatOf #-}++-- | 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' ('folded' '.' 'folded') :: 'Foldable' f => 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'+-- @+lengthOf :: Getting (Endo (Endo Int)) s t a b -> s -> Int+lengthOf l = foldlOf' l (\a _ -> a + 1) 0+{-# INLINE lengthOf #-}++-- | 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.+--+-- @+-- ('^?') ≡ 'flip' 'preview'+-- @+--+-- @+-- ('^?') :: 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 t a b -> Maybe a+s ^? l = getFirst (foldMapOf l (First #. Just) s)+{-# INLINE (^?) #-}++-- | Perform an *UNSAFE* 'head' of a 'Fold' or 'Traversal' assuming that it is there.+--+-- @+-- ('^?!') :: 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 (Endo a) s t a b -> a+s ^?! l = foldrOf l const (error "(^?!): empty Fold") s+{-# INLINE (^?!) #-}++-- | 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 @'ala' 'First' '.' 'foldMapOf'@+-- and gives you back access to the outermost 'Just' constructor more quickly, but may have worse+-- constant factors.+--+-- @+-- '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+-- @+firstOf :: Getting (Leftmost a) s t a b -> s -> Maybe a+firstOf l = getLeftmost . foldMapOf l LLeaf+{-# INLINE firstOf #-}++-- | 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' :: '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+-- @+lastOf :: Getting (Rightmost a) s t a b -> s -> Maybe a+lastOf l = getRightmost . foldMapOf l RLeaf+{-# INLINE lastOf #-}++-- | 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' ('folded' '.' '_1' '.' 'folded') :: 'Foldable' f => 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'+-- @+nullOf :: Getting All s t a b -> s -> Bool+nullOf l = getAll #. foldMapOf l (\_ -> All False)+{-# INLINE nullOf #-}+++-- | Returns 'True' if this 'Fold' or 'Traversal' has any targets in the given container.+--+-- Note: 'notNullOf' on a valid 'Iso', 'Lens' or 'Getter' should always return 'True'.+--+-- @+-- 'null' ≡ 'notNullOf' 'folded'+-- @+--+-- This may be rather inefficient compared to the @'not' '.' 'null'@ check of many containers.+--+-- >>> notNullOf _1 (1,2)+-- True+--+-- @+-- 'notNullOf' ('folded' '.' '_1' '.' 'folded') :: 'Foldable' f => 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'+-- @+notNullOf :: Getting Any s t a b -> s -> Bool+notNullOf l = getAny #. foldMapOf l (\_ -> Any True)+{-# INLINE notNullOf #-}++-- | 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.+--+-- @+-- '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+-- @+maximumOf :: Ord a => Getting (Endo (Endo (Maybe a))) s t a b -> s -> Maybe a+maximumOf l = foldlOf' l mf Nothing where+  mf Nothing y = Just $! y+  mf (Just x) y = Just $! max x y++{-# INLINE maximumOf #-}++-- | 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.+--+-- @+-- 'minimum' ≡ 'Data.Maybe.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+-- @++minimumOf :: Ord a => Getting (Endo (Endo (Maybe a))) s t a b -> s -> Maybe a+minimumOf l = foldlOf' l mf Nothing where+  mf Nothing y = Just $! y+  mf (Just x) y = Just $! min x y++-- minimumOf :: Getting (Min a) s t a b -> s -> Maybe a+-- minimumOf l = getMin `rmap` foldMapOf l Min+{-# INLINE minimumOf #-}++-- | Obtain the maximum 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.+--+-- @+-- 'Data.Foldable.maximumBy' cmp ≡ 'Data.Maybe.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+-- @+maximumByOf :: Getting (Endo (Endo (Maybe a))) s t a b -> (a -> a -> Ordering) -> s -> Maybe a+maximumByOf l cmp = foldlOf' l mf Nothing where+  mf Nothing y = Just $! y+  mf (Just x) y = Just $! if cmp x y == GT then x else y++-- maximumByOf :: Getting (Endo (Maybe a)) s t a b -> (a -> a -> Ordering) -> s -> Maybe a+-- maximumByOf l cmp = foldrOf l step Nothing where+--   step a Nothing  = Just a+--   step a (Just b) = Just (if cmp a b == GT then a else b)+{-# INLINE maximumByOf #-}++-- | 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.+--+-- @+-- 'minimumBy' cmp ≡ 'Data.Maybe.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+-- @+minimumByOf :: Getting (Endo (Endo (Maybe a))) s t a b -> (a -> a -> Ordering) -> s -> Maybe a+minimumByOf l cmp = foldlOf' l mf Nothing where+  mf Nothing y = Just $! y+  mf (Just x) y = Just $! if cmp x y == GT then y else x++-- minimumByOf :: Getting (Endo (Maybe a)) s t a b -> (a -> a -> Ordering) -> s -> Maybe a+-- minimumByOf l cmp = foldrOf l step Nothing where+--   step a Nothing  = Just a+--   step a (Just b) = Just (if cmp a b == GT then b else a)+{-# INLINE minimumByOf #-}++-- | 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' :: '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+-- @+--+-- @+-- 'ifindOf' l = 'findOf' l '.' 'Indexed'+-- @+--+-- A simpler version that didn't permit indexing, would be:+--+-- @+-- 'findOf' :: 'Getting' ('Endo' ('Maybe' a)) s t a b -> (a -> 'Bool') -> s -> 'Maybe' a+-- 'findOf' l p = 'foldrOf' l (\a y -> if p a then 'Just' a else y) 'Nothing'+-- @+findOf :: Conjoined p => Accessing p (Endo (Maybe a)) s t a b -> p a Bool -> s -> Maybe a+findOf l p = foldrOf l (cotabulate $ \wa y -> if corep p wa then Just (extract wa) else y) Nothing+{-# INLINE findOf #-}++-- | 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' l f ≡ 'Prelude.foldr1' f '.' 'toListOf' l+-- 'Data.Foldable.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+-- @+foldr1Of :: Getting (Endo (Maybe a)) s t a b -> (a -> a -> a) -> s -> a+foldr1Of l f xs = fromMaybe (error "foldr1Of: empty structure")+                            (foldrOf l mf Nothing xs) where+  mf x my = Just $ case my of+    Nothing -> x+    Just y -> f x y+{-# INLINE foldr1Of #-}++-- | 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' l f ≡ 'Prelude.foldl1' f '.' 'toListOf' l+-- 'Data.Foldable.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+-- @+foldl1Of :: Getting (Dual (Endo (Maybe a))) s t a b -> (a -> a -> a) -> s -> a+foldl1Of l f xs = fromMaybe (error "foldl1Of: empty structure") (foldlOf l mf Nothing xs) where+  mf mx y = Just $ case mx of+    Nothing -> y+    Just x  -> f x y+{-# INLINE foldl1Of #-}++-- | Strictly fold right over the elements of a structure.+--+-- @+-- 'Data.Foldable.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+-- @+foldrOf' :: Getting (Dual (Endo (Endo r))) s t a b -> (a -> r -> r) -> r -> s -> r+foldrOf' l f z0 xs = foldlOf l f' (Endo id) xs `appEndo` z0+  where f' (Endo k) x = Endo $ \ z -> k $! f x z+{-# INLINE foldrOf' #-}++-- | Fold over the elements of a structure, associating to the left, but strictly.+--+-- @+-- 'Data.Foldable.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+-- @+foldlOf' :: Getting (Endo (Endo r)) s t a b -> (r -> a -> r) -> r -> s -> r+foldlOf' l f z0 xs = foldrOf l f' (Endo id) xs `appEndo` z0+  where f' x (Endo k) = Endo $ \z -> k $! f z x+{-# INLINE foldlOf' #-}++-- | 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 ≡ 'Prelude.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+-- @+foldr1Of' :: Getting (Dual (Endo (Endo (Maybe a)))) s t a b -> (a -> a -> a) -> s -> a+foldr1Of' l f xs = fromMaybe (error "foldr1Of': empty structure") (foldrOf' l mf Nothing xs) where+  mf x Nothing = Just $! x+  mf x (Just y) = Just $! f x y+{-# INLINE foldr1Of' #-}++-- | 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 ≡ 'Data.List.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+-- @+foldl1Of' :: Getting (Endo (Endo (Maybe a))) s t a b -> (a -> a -> a) -> s -> a+foldl1Of' l f xs = fromMaybe (error "foldl1Of': empty structure") (foldlOf' l mf Nothing xs) where+  mf Nothing y = Just $! y+  mf (Just x) y = Just $! f x y+{-# INLINE foldl1Of' #-}++-- | Monadic fold over the elements of a structure, associating to the right,+-- i.e. from right to left.+--+-- @+-- 'Data.Foldable.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+-- @+foldrMOf :: Monad m+         => Getting (Dual (Endo (r -> m r))) s t a b+         -> (a -> r -> m r) -> r -> s -> m r+foldrMOf l f z0 xs = foldlOf l f' return xs z0+  where f' k x z = f x z >>= k+{-# INLINE foldrMOf #-}++-- | Monadic fold over the elements of a structure, associating to the left,+-- i.e. from left to right.+--+-- @+-- 'Data.Foldable.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+-- @+foldlMOf :: Monad m+         => Getting (Endo (r -> m r)) s t a b+         -> (r -> a -> m r) -> r -> s -> m r+foldlMOf l f z0 xs = foldrOf l f' return xs z0+  where f' x k z = f z x >>= k+{-# INLINE foldlMOf #-}++-- | 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 t a b -> s -> Bool+has l = getAny #. foldMapOf l (\_ -> Any True)+{-# INLINE has #-}++-- | Check to see if this 'Fold' or 'Traversal' has no matches.+--+-- >>> hasn't _Left (Right 12)+-- True+--+-- >>> hasn't _Left (Left 12)+-- False+hasn't :: Getting All s t a b -> s -> Bool+hasn't l = getAll #. foldMapOf l (\_ -> All False)+{-# INLINE hasn't #-}++------------------------------------------------------------------------------+-- Pre+------------------------------------------------------------------------------++-- | 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 t a b -> 'IndexPreservingGetter' s ('Maybe' a)+-- 'pre' :: 'Lens' s t a b      -> 'IndexPreservingGetter' s ('Maybe' a)+-- 'pre' :: 'Iso' s t a b       -> 'IndexPreservingGetter' s ('Maybe' a)+-- 'pre' :: 'Prism' s t a b     -> 'IndexPreservingGetter' s ('Maybe' a)+-- @+pre :: Getting (First a) s t a b -> IndexPreservingGetter s (Maybe a)+pre l = dimap (getFirst . runAccessor #. l (Accessor #. First #. Just)) coerce+++-- | This converts an 'IndexedFold' to an 'IndexPreservingGetter' that returns the first index+-- and element if it exists 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 t a b -> 'IndexPreservingGetter' s ('Maybe' (i, a))+-- 'ipre' :: 'IndexedLens' i s t a b      -> 'IndexPreservingGetter' s ('Maybe' (i, a))+-- @+ipre :: IndexedGetting i (First (i, a)) s t a b -> IndexPreservingGetter s (Maybe (i, a))+ipre l = dimap (getFirst . runAccessor #. l (Indexed $ \i a -> Accessor (First (Just (i, a))))) coerce++------------------------------------------------------------------------------+-- Preview+------------------------------------------------------------------------------++-- | Retrieve the first value targeted by a 'Fold' or 'Traversal' (or 'Just' the result+-- from a 'Getter' or 'Lens'). See also ('^?').+--+-- @+-- 'Data.Maybe.listToMaybe' '.' 'toList' ≡ 'preview' 'folded'+-- @+--+-- This is usually applied in the 'Control.Monad.Reader.Reader'+-- 'Control.Monad.Monad' @(->) s@.+--+-- @+-- 'preview' = 'view' '.' 'pre'+-- @+--+-- @+-- '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+-- @+--+-- However, it may be useful to think of its full generality when working with+-- a 'Control.Monad.Monad' transformer stack:+--+-- @+-- '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)+-- @+preview :: MonadReader s m => Getting (First a) s t a b -> m (Maybe a)+preview l = asks (getFirst #. foldMapOf l (First #. Just))+{-# INLINE preview #-}++-- | 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 'Control.Monad.Reader.Reader'+-- 'Control.Monad.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 'Control.Monad.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))+-- @+ipreview :: MonadReader s m => IndexedGetting i (First (i, a)) s t a b -> m (Maybe (i, a))+ipreview l = asks (getFirst #. ifoldMapOf l (\i a -> First (Just (i, a))))+{-# INLINE ipreview #-}++-- | 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 'Control.Monad.Reader.Reader'+-- 'Control.Monad.Monad' @(->) s@.++-- @+-- 'previews' = 'views' '.' 'pre'+-- @+--+-- @+-- 'previews' :: 'Getter' s a     -> (a -> r) -> s -> 'Maybe' r+-- 'previews' :: 'Fold' s a       -> (a -> r) -> s -> 'Maybe' r+-- 'previews' :: 'Lens'' s a      -> (a -> r) -> s -> 'Maybe' r+-- 'previews' :: 'Iso'' s a       -> (a -> r) -> s -> 'Maybe' r+-- 'previews' :: 'Traversal'' s a -> (a -> r) -> s -> 'Maybe' r+-- @+--+-- However, it may be useful to think of its full generality when working with+-- a 'Monad' transformer stack:+--+-- @+-- 'previews' :: 'MonadReader' s m => 'Getter' s a     -> (a -> r) -> m ('Maybe' r)+-- 'previews' :: 'MonadReader' s m => 'Fold' s a       -> (a -> r) -> m ('Maybe' r)+-- 'previews' :: 'MonadReader' s m => 'Lens'' s a      -> (a -> r) -> m ('Maybe' r)+-- 'previews' :: 'MonadReader' s m => 'Iso'' s a       -> (a -> r) -> m ('Maybe' r)+-- 'previews' :: 'MonadReader' s m => 'Traversal'' s a -> (a -> r) -> m ('Maybe' r)+-- @+previews :: MonadReader s m => Getting (First r) s t a b -> (a -> r) -> m (Maybe r)+previews l f = asks (getFirst . foldMapOf l (First #. Just . f))+{-# INLINE previews #-}++-- | 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 'Control.Monad.Reader.Reader'+-- 'Control.Monad.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 'Control.Monad.Monad' transformer stack:+--+-- @+-- 'ipreviews' :: 'MonadReader' s m => 'IndexedGetter' s a     -> (i -> a -> r) -> m ('Maybe' r)+-- 'ipreviews' :: 'MonadReader' s m => 'IndexedFold' s a       -> (i -> a -> r) -> m ('Maybe' r)+-- 'ipreviews' :: 'MonadReader' s m => 'IndexedLens'' s a      -> (i -> a -> r) -> m ('Maybe' r)+-- 'ipreviews' :: 'MonadReader' s m => 'IndexedTraversal'' s a -> (i -> a -> r) -> m ('Maybe' r)+-- @+ipreviews :: MonadReader s m => IndexedGetting i (First r) s t a b -> (i -> a -> r) -> m (Maybe r)+ipreviews l f = asks (getFirst . ifoldMapOf l (\i -> First #. Just . f i))+{-# INLINE ipreviews #-}++------------------------------------------------------------------------------+-- Preuse+------------------------------------------------------------------------------++-- | 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)+-- @+preuse :: MonadState s m => Getting (First a) s t a b -> m (Maybe a)+preuse l = gets (preview l)+{-# INLINE preuse #-}++-- | 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))+-- @+ipreuse :: MonadState s m => IndexedGetting i (First (i, a)) s t a b -> m (Maybe (i, a))+ipreuse l = gets (ipreview l)+{-# INLINE ipreuse #-}++-- | 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)+-- @+preuses :: MonadState s m => Getting (First r) s t a b -> (a -> r) -> m (Maybe r)+preuses l f = gets (previews l f)+{-# INLINE preuses #-}++-- | 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)+-- @+ipreuses :: MonadState s m => IndexedGetting i (First r) s t a b -> (i -> a -> r) -> m (Maybe r)+ipreuses l f = gets (ipreviews l f)+{-# INLINE ipreuses #-}++------------------------------------------------------------------------------+-- Profunctors+------------------------------------------------------------------------------+++-- | This allows you to 'Control.Traversable.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 'Control.Lens.Isomorphic.from'.+-- Similarly, to write back through an 'Prism', you want to use 'Control.Lens.Review.re'.+backwards :: (Profunctor p, Profunctor q) => Overloading p q (Backwards f) s t a b -> Overloading p q f s t a b+backwards l f = forwards #. l (Backwards #. f)+{-# INLINE backwards #-}++------------------------------------------------------------------------------+-- Indexed Folds+------------------------------------------------------------------------------++-- | 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+-- @+--+ifoldMapOf :: IndexedGetting i m s t a b -> (i -> a -> m) -> s -> m+ifoldMapOf l = foldMapOf l .# Indexed+{-# INLINE ifoldMapOf #-}++-- | 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+-- @+ifoldrOf :: IndexedGetting i (Endo r) s t a b -> (i -> a -> r -> r) -> r -> s -> r+ifoldrOf l = foldrOf l .# Indexed+{-# INLINE ifoldrOf #-}++-- | 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+-- @+ifoldlOf :: IndexedGetting i (Dual (Endo r)) s t a b -> (i -> r -> a -> r) -> r -> s -> r+ifoldlOf l f z = (flip appEndo z .# getDual) `rmap` ifoldMapOf l (\i -> Dual #. Endo #. flip (f i))+{-# INLINE ifoldlOf #-}++-- | 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'+-- @+ianyOf :: IndexedGetting i Any s t a b -> (i -> a -> Bool) -> s -> Bool+ianyOf l = anyOf l .# Indexed+{-# INLINE ianyOf #-}++-- | 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'+-- @+iallOf :: IndexedGetting i All s t a b -> (i -> a -> Bool) -> s -> Bool+iallOf l = allOf l .# Indexed+{-# INLINE iallOf #-}++-- | 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 ≡ 'Control.Lens.Traversal.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 ()+-- @+itraverseOf_ :: Functor f => IndexedGetting i (Traversed r f) s t a b -> (i -> a -> f r) -> s -> f ()+itraverseOf_ l = traverseOf_ l .# Indexed+{-# INLINE itraverseOf_ #-}++-- | 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 ()+-- @+iforOf_ :: Functor f => IndexedGetting i (Traversed r f) s t a b -> s -> (i -> a -> f r) -> f ()+iforOf_ = flip . itraverseOf_+{-# INLINE iforOf_ #-}++-- | 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 ≡ 'Control.Lens.Setter.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 ()+-- @+imapMOf_ :: Monad m => IndexedGetting i (Sequenced r m) s t a b -> (i -> a -> m r) -> s -> m ()+imapMOf_ l = mapMOf_ l .# Indexed+{-# INLINE imapMOf_ #-}++-- | 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 ≡ 'Control.Lens.Traversal.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 ()+-- @+iforMOf_ :: Monad m => IndexedGetting i (Sequenced r m) s t a b -> s -> (i -> a -> m r) -> m ()+iforMOf_ = flip . imapMOf_+{-# INLINE iforMOf_ #-}++-- | 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]+-- @+iconcatMapOf :: IndexedGetting i [r] s t a b -> (i -> a -> [r]) -> s -> [r]+iconcatMapOf = ifoldMapOf+{-# INLINE iconcatMapOf #-}++-- | The 'findOf' 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' s a     -> (i -> a -> 'Bool') -> s -> 'Maybe' a+-- 'ifindOf' :: 'IndexedFold' s a       -> (i -> a -> 'Bool') -> s -> 'Maybe' a+-- 'ifindOf' :: 'IndexedLens'' s a      -> (i -> a -> 'Bool') -> s -> 'Maybe' a+-- 'ifindOf' :: 'IndexedTraversal'' s a -> (i -> a -> 'Bool') -> s -> 'Maybe' a+-- @+ifindOf :: IndexedGetting i (Endo (Maybe a)) s t a b -> (i -> a -> Bool) -> s -> Maybe a+ifindOf l = findOf l .# Indexed+{-# INLINE ifindOf #-}++-- | /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+-- @+ifoldrOf' :: IndexedGetting i (Dual (Endo (r -> r))) s t a b -> (i -> a -> r -> r) -> r -> s -> r+ifoldrOf' l f z0 xs = ifoldlOf l f' id xs z0+  where f' i k x z = k $! f i x z+{-# INLINE ifoldrOf' #-}++-- | 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+-- @+ifoldlOf' :: IndexedGetting i (Endo (r -> r)) s t a b -> (i -> r -> a -> r) -> r -> s -> r+ifoldlOf' l f z0 xs = ifoldrOf l f' id xs z0+  where f' i x k z = k $! f i z x+{-# INLINE ifoldlOf' #-}++-- | 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 -> r+-- 'ifoldrMOf' :: 'Monad' m => 'IndexedFold' i s a       -> (i -> a -> r -> m r) -> r -> s -> r+-- 'ifoldrMOf' :: 'Monad' m => 'IndexedLens'' i s a      -> (i -> a -> r -> m r) -> r -> s -> r+-- 'ifoldrMOf' :: 'Monad' m => 'IndexedTraversal'' i s a -> (i -> a -> r -> m r) -> r -> s -> r+-- @+ifoldrMOf :: Monad m => IndexedGetting i (Dual (Endo (r -> m r))) s t a b -> (i -> a -> r -> m r) -> r -> s -> m r+ifoldrMOf l f z0 xs = ifoldlOf l f' return xs z0+  where f' i k x z = f i x z >>= k+{-# INLINE ifoldrMOf #-}++-- | 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'+-- @+--+-- @+-- 'ifoldlOf'' :: 'Monad' m => 'IndexedGetter' i s a     -> (i -> r -> a -> m r) -> r -> s -> r+-- 'ifoldlOf'' :: 'Monad' m => 'IndexedFold' i s a       -> (i -> r -> a -> m r) -> r -> s -> r+-- 'ifoldlOf'' :: 'Monad' m => 'IndexedLens'' i s a      -> (i -> r -> a -> m r) -> r -> s -> r+-- 'ifoldlOf'' :: 'Monad' m => 'IndexedTraversal'' i s a -> (i -> r -> a -> m r) -> r -> s -> r+-- @+ifoldlMOf :: Monad m => IndexedGetting i (Endo (r -> m r)) s t a b -> (i -> r -> a -> m r) -> r -> s -> m r+ifoldlMOf l f z0 xs = ifoldrOf l f' return xs z0+  where f' i x k z = f i z x >>= k+{-# INLINE ifoldlMOf #-}++-- | 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' 'fst' '.' '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)]+-- @+itoListOf :: IndexedGetting i (Endo [(i,a)]) s t a b -> s -> [(i,a)]+itoListOf l = ifoldrOf l (\i a -> ((i,a):)) []+{-# INLINE itoListOf #-}++-- | An infix version of 'itoListOf'.++-- @+-- ('^@..') :: 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 [(i,a)]) s t a b -> [(i,a)]+s ^@.. l = ifoldrOf l (\i a -> ((i,a):)) [] s++-- | 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 -> 'Iso'' i s a          -> 'Maybe' (i, a)+-- ('^@?') :: s -> 'Traversal'' i s a    -> 'Maybe' (i, a)+-- @+(^@?) :: s -> IndexedGetting i (Endo (Maybe (i, a))) s t a b -> Maybe (i, a)+s ^@? l = ifoldrOf l (\i x _ -> Just (i,x)) Nothing s+{-# INLINE (^@?) #-}++-- | 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 -> 'Lens'' i s a         -> (i, a)+-- ('^@?!') :: s -> 'Iso'' i s a          -> (i, a)+-- ('^@?!') :: s -> 'Traversal'' i s a    -> (i, a)+-- @+(^@?!) :: s -> IndexedGetting i (Endo (i, a)) s t a b -> (i, a)+s ^@?! l = ifoldrOf l (\i x _ -> (i,x)) (error "(^@?!): empty Fold") s+{-# INLINE (^@?!) #-}++-------------------------------------------------------------------------------+-- Converting to Folds+-------------------------------------------------------------------------------++-- | 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 'filtered' 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!+ifiltered :: (Indexable i p, Applicative f) => (i -> a -> Bool) -> Overloading' p (Indexed i) f a a+ifiltered p f = Indexed $ \i a -> if p i a then indexed f i a else pure a+{-# INLINE ifiltered #-}++-- | 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+-- 'itakingWhile' :: (i -> a -> 'Bool') -> 'IndexedMonadicFold' i m s a -> 'IndexedMonadicFold' i m s a+-- 'itakingWhile' :: (i -> a -> 'Bool') -> 'IndexedAction' i m s a      -> 'IndexedMonadicFold' i m s a+-- @+itakingWhile :: (Indexable i p, Profunctor q, Applicative f, Gettable f)+         => (i -> a -> Bool)+         -> Overloading (Indexed i) q (Accessor (Endo (f s))) s s a a+         -> Overloading p q f s s a a+itakingWhile p l f = (flip appEndo noEffect .# runAccessor) `rmap` l g where+  g = Indexed $ \i a -> Accessor . Endo $ if p i a then (indexed f i a *>) else const noEffect+{-# INLINE itakingWhile #-}++-- | 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+-- 'idroppingWhile' :: (i -> a -> 'Bool') -> 'IndexedMonadicFold' i m s a -> 'IndexedMonadicFold' i m s a+-- 'idroppingWhile' :: (i -> a -> 'Bool') -> 'IndexedAction' i m s a      -> 'IndexedMonadicFold' i m s a+-- @+--+-- 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 targets to ones where the predicate returns+-- 'True', then you will break the 'Traversal' laws and 'Traversal' fusion will no longer be sound.+idroppingWhile :: (Indexable i p, Profunctor q, Applicative f)+              => (i -> a -> Bool)+              -> Overloading (Indexed i) q (Compose (State Bool) f) s t a a+              -> Overloading p q f s t a a+idroppingWhile p l f = (flip evalState True .# getCompose) `rmap` l g where+  g = Indexed $ \ i a -> Compose $ state $ \b -> let+      b' = b && p i a+    in (if b' then pure a else indexed f i a, b')+{-# INLINE idroppingWhile #-}++------------------------------------------------------------------------------+-- Deprecated+------------------------------------------------------------------------------++-- | A deprecated alias for 'firstOf'.+headOf :: Getting (First a) s t a b -> s -> Maybe a+headOf l = getFirst #. foldMapOf l (First #. Just)+{-# INLINE headOf #-}+{-# DEPRECATED headOf "`headOf' will be removed in 3.9. (Use `preview' or `firstOf')" #-}++------------------------------------------------------------------------------+-- Misc.+------------------------------------------------------------------------------++skip :: a -> ()+skip _ = ()+{-# INLINE skip #-}