14.19.1 [2020.02.13] 2------------------- 3* Fix a bug introduced in 4.19 where using `_TupE` to `preview` a value would 4 always fail. 5 64.19 [2020.02.03] 7----------------- 8* Support building with GHC 8.10. 9* The types of `_TupE` and `_UnboxedTupE` are now `Prism' Exp [Maybe Exp]` 10 when built against `template-haskell-2.16` or later to reflect the new 11 types of `TupE` and `UnboxedTupE`. 12* Add `_ForallVisT` and `_BytesPrimL` prisms when building against 13 `template-haskell-2.16` or later. 14* Make `<>~` and `<>=` and their `<op` and `<<op` state variants require only 15 `Semigroup`, not `Monoid`. 16* Add `{Functor,Foldable,Traversable}WithIndex` instances for 17 `Control.Applicative.Const` and `Data.Functor.Constant.Constant`. 18 194.18.1 [2019.09.13] 20------------------- 21* Remove the use of `cpp-options: -traditional`. This should be unnecessary 22 on all versions of GHC that `lens` supports, as modern GHCs already use 23 `-traditional` internally during preprocessing. More critically, the use 24 of `cpp-options: -traditional` breaks profiling builds on GHC 8.8 25 (see https://gitlab.haskell.org/ghc/ghc/issues/17185). 26 274.18 [2019.09.06] 28----------------- 29* Support building with GHC 8.8. 30* Add `xplat` and `xplatf`. 31* Flip `auf` to take the `Iso` in the same direction as `au`. 32 Use the new `xplatf` or just call `coerce` for the old form. 33* Weaken `holeInOne`'s `Category p` constraint to `Comonad (Corep p)`. 34* Generalize the type of `GHC.Generics.Lens.generic1` from 35 `Iso' (f a) (Rep1 f a)` to `Iso (f a) (f b) (Rep1 f a) (Rep1 f b)`. 36* `makeClassyPrisms` now supports generating prisms for data types that share 37 a name with one of its constructors. In such a scenario, the name of the 38 classy prism for the data type will be prefixed with an extra `_` (for 39 prefix names) or `.` (for infix names) to disambiguate it from the prism 40 for the constructor. 41* Several type classes in `Control.Exception.Lens` now have additional 42 prisms corresponding to the data type that they focus on, in accordance 43 with the new convention established in the bullet point above. For example, 44 `AsNonTermination` now has an additional 45 `__NonTermination :: Prism' t NonTermination` method, and the existing 46 `_NonTermination :: Prism' t ()` method now has a default implementation in 47 terms of `__NonTermination`. 48 49 As a consequence of this change, you may need to update instances of these 50 classes to implement the new prisms. 51* Add additional bifunctor instances for `Swapped`. 52* New lenses `head1` and `last1`, to access the first/last elements of 53 a `Traversable1` container. 54* Add `filteredBy`. 55* Add `adjoin` to `Control.Lens.Unsound`. 56* Add `Each (Either a a) (Either b b) a b` instance. 57* Make `magnify` offer its getter argument the `Contravariant` and `Functor` 58 instances it will require. This allows `magnify` to be used without 59 knowing the concrete monad being magnified. 60* Add `equality`, `equality'`, `withEquality`, `underEquality`, `overEquality`, 61 `fromLeibniz`, `fromLeibniz'` and `cloneEquality` to `Control.Lens.Equality`. 62* Add `withLens` to `Control.Lens.Lens`. 63* Make `substEq` and `simply` in `Control.Lens.Equality` 64 and `withIso` in `Control.Lens.Iso` levity polymorphic. 65 664.17.1 [2019.04.26] 67------------------- 68* Support `th-abstraction-0.3.0.0` or later. 69* Only incur `semigroups` and `void` dependencies on old GHCs. 70* Add `holes1Of` 71* Add `locally` https://github.com/ekmett/lens/pull/829 72* Add `ilocally` https://github.com/ekmett/lens/pull/836 73* Add third `Prism` law. 74* Add `gplate1` 75* Add `Wrapped`/`Rewrapped` instances for `Data.Monoid.Ap`. 76 774.17 [2018.07.03] 78----------------- 79* Allow building with GHC 8.6. 80* Make the instances for `Product` and `(:*:)` in `Control.Lens.Tuple` 81 poly-kinded. 82* Make the definitions in `GHC.Generics.Lens` poly-kinded. 83* Make `(%%@~)`, `(%%@=)`, `(<%@=)`, and `(<<%@=)` consume an 84 `Over (Indexed i)` instead of an `IndexedLensLike i` to improve type 85 inference. 86* Add an `AsEmpty` instance for `ZipList`. 87 884.16.1 [2018.03.23] 89------------------- 90* Re-export `(<&>)` from `Data.Functor` on `base-4.11` and later. 91* Added `Cons` and `Snoc` instances for `Control.Applicative.ZipList` 92* Fix a bug in which `makeFields` would generate equality constraints for 93 field types involving data families, which are unnecessary. 94* Improve the performance of `holesOf`. 95 964.16 [2018.01.28] 97----------------- 98* The `Semigroup` instances for `Traversed` and `Sequenced` are now more 99 constrained (going from `Apply` to `Applicative` and `Monad`, respectively). 100 In GHC 8.4, `Semigroup` is a superclass of `Monoid`, therefore we'd need to 101 have `Apply` constraint in the `Monoid` instances. We opted to weaken our 102 ability to use `Apply` than to lose compatibility with third-party packages 103 that don't supply instances for `Apply`. 104 105 In practice this changes the (specialised) type signature of `traverseOf_` 106 ```diff+ 107 - traverseOf_ :: Apply f => Fold1 s a -> (a -> f r) -> s -> f () 108 + traverseOf_ :: Applicative f => Fold1 s a -> (a -> f r) -> s -> f () 109 ``` 110 and similarly for `forOf_` and `sequenceOf_`. 111 112 As part of this change, new combinators `traverse1Of_`, `for1Of_` and 113 `sequence1Of_` were added for `Apply`-only effects. 114 115 Similar instance context changes were made for `Folding` and `Effect`, 116 but these changes aren't publicly visible. 117 118* Add `Control.Lens.Unsound`, which exports unsound functionality for forming 119 products of lenses and sums of prisms. 120 121* Add `Numeric.Natural.Lens`, which export convenient isomorphisms for 122 natural numbers. 123 124* Add `Strict` instances for strict and lazy `ST`. 125 126* Adapt `Language.Haskell.TH.Lens` for `template-haskell-2.13` (bundled 127 with GHC 8.4). 128 129* Add `Semigroup` and `Monoid` instances for `Indexing`. 130 1314.15.4 132---- 133* `makeFields` and `declareFields` are now smarter with respect to type 134 families. Because GHC does not allow mentioning type families in instance 135 heads, the Template Haskell machinery works around this restriction by 136 instead generating instances of the form: 137 138 ```haskell 139 type family Fam a 140 data Rec a = Rec { _recFam :: Fam a } 141 makeFields ''Rec 142 143 ===> 144 145 instance (b ~ Fam a) => HasFam (Rec a) b where ... 146 ``` 147 148 This requires enabling the `UndecidableInstances` extension, so this trick is 149 only employed when a field's type contains a type family application. 150* `declareFields` now avoids creating duplicate field classes that are shared 151 among multiple datatypes within the same invocation. 152* The Template Haskell machinery will no longer generate optics for fields 153 whose types mention existentially quantified type variables. 154* Add `HasCallStack` constraints to partial operations 155* Reexport `(.@~)` and `(.@=)` from `Control.Lens.Operators` 156* Support `doctest-0.13` 157 1584.15.3 159---- 160* Generalized types of `transformMOf`, `transformOf`, `transformMOnOf`, 161 `transformOnOf`, `rewriteMOf`, `rewriteOf`, `rewriteMOnOf` and `rewriteOnOf`. 162* Depend on `th-abstraction` package for normalizing differences across 163 `template-haskell` versions 164 1654.15.2 166---- 167* Build with GHC 8.2 168* Expand tuple accessors to support up to 19-tuples 169* Add more `Rewrapped` and `Wrapped` instances for data types from the `base`, 170 `bifunctors`, `exceptions`, `free`, `profunctors`, and `semigroupoids` 171 libraries 172* Add a `Generic` default implementation for `Wrapped` 173* Add `Wrapped` instances for data types introduced in `Foreign.C.Types` and 174 `System.Posix.Types` in `base-4.10.0.0` 175* Add prisms for recently introduced data types in `Control.Exception` 176* Revamp `Setup.hs` to use `cabal-doctest`. This makes it build 177 with `Cabal-1.25`, and makes the `doctest`s work with `cabal new-build` and 178 sandboxes. 179* Add `makeFieldsNoPrefix`, a variant of `makeFields` which gives the desired 180 behavior in the presence of `DuplicateRecordFields`. Also add 181 `classUnderscoreNoPrefixFields` and `classUnderscoreNoPrefixNamer`, the 182 corresponding `LensRules` and `FieldNamer`, respectively. 183* Add `toNonEmptyOf`, `first1Of`, `last1Of`, `minimum1Of`, and `maximum1Of` 184 to `Control.Lens.Fold` 185* Add `both1` to `Control.Lens.Traversal` 186* Generalize the type of `levels` and `ilevels` in `Control.Lens.Level` to work 187 on `Fold`s 188* Generalize the type of `getting` in `Control.Lens.Getter` to work with any 189 `Optical` 190* Add `throwing_` to `Control.Monad.Error.Lens` and `Control.Exception.Lens` 191* Fix the meta-data in the .cabal file to properly indicate that this project 192 has a BSD2 license 193 1944.15.1 195---- 196* Restore the `generic` and `generic1` functions in `GHC.Generics.Lens` 197 1984.15 199---- 200* Remove `Generics.Deriving.Lens` module. 201* Incorporate `URec`, which was introduced in `GHC.Generics` in `base-4.9`. For compatibility with older versions of `base`, `lens` now conditionally depends on `generic-deriving` 202* Add `Rewrapped` instance for `ExceptT` 203* Add `FunctorWithIndex`, `FoldableWithIndex`, and `TraversableWithIndex` instances for `Sum`, `Proxy`, `Tagged` and data types in `GHC.Generics` 204* Remove unneeded context from `*WithIndex HashMap` instances 205* Add `Data.Map.Lens.toMapOf` 206* Add moral `Functor` constraint for `to` `ito` `ilike` `ilike` to allow the 207 "indented" type signature using Getter with redundant warnings turned on. 208 2094.14 210---- 211* Remove `Cons` and `Snoc` instances for `NonEmpty`. 212 2134.13.2.1 214------ 215* Fixed `itraverse_` and `imapM_` returning bottom 216 2174.13.2 218------ 219* Restore default signature for `Control.Lens.At.at` 220* Improve operations for `Data.Sequence.Seq` 221* Fix `declarePrisms` behavior on GHC 8 using GADT record syntax 222 2234.13.1 224------ 225* Modified to enable the `doctests` to build with `stack`. 226* Removed `.ghci`. 227* Added `lookupOf` 228* Support GHC 8 229* Support `transformers` 0.5 230* Support `kan-extensions` 5 231* Support `comonad` 5 232* Better support for `Closed` from `profunctors`. 233 2344.13 235---- 236* Pattern synonyms 237* Moved `foldMapBy` and `foldBy` into `reflection` 2.1 238* Added `traverseByOf`, `sequenceByOf`. 239* Reexported `traverseBy` and `sequenceBy` from `reflection` 2.1. 240* Modified the signatures of `alaf` and `auf` to work with a `Functor` rather than a `Profunctor` and rather drastically generalized them. 241* Removed `Control.Lens.Internal.Getter.coerce` in favor of the upstream `phantom` combinator in `contravariant` 1.3+ 242* Renamed `coerced` to `phantasm` to get it out of the way. 243* Added `Wrapped` instance for `Down` 244 2454.12.3 246------ 247* Move `Review` and `AReview` to `Control.Lens.Type` fixing a bug in `makePrisms` 248* Expose `HasTypes` class in `Language.Haskell.TH.Lens` 249* Make types of `foldByOf` and `foldMapByOf` more specific to hide implementation details 250* Add Prisms to `Language.Haskell.TH` for new constructors in `template-haskell-2.10` 251* Generalize type of `_FunDep` to an `Iso` 252 2534.12.2 254------ 255* Incorporated a bug fix for `foldByOf` and `foldMapByOf` to actually let them work on folds. 256* Added a `Plated` instance for `CofreeT` 257 2584.12.1 259------ 260* The `Simple` type alias is now poly-kinded. This lets you use `Simple Field1 s a` and the like in constraints. 261* Added `HasTypes` to `Language.Haskell.TH.Lens`. 262* Support for `vector-0.11.0` which changes `Stream` to `Bundle` 263 2644.12 265---- 266* `reflection 2` support. 267 2684.11.2 269------ 270* Give `cosmosOn` a more general type. 271 2724.11.1 273------ 274* Added `cosmos`, `cosmosOf`, `cosmosOn`, `cosmosOnOf` to `Control.Lens.Plated`. 275* Added `icontains`, `iat`, `iix`. 276* Made various documentation improvements. 277* Added a `test-templates` flag. 278 2794.11 280---- 281* Proper `profunctors` 5.1 support. This extended the superclass constraints for `Conjoined`, so it resulted in a major version bump. 282 2834.10 284---- 285* Added `elemIndexOf`, `elemIndicesOf`, `findIndexOf`, and `findIndicesOf`. 286* Fixed `Ixed` instance for `Tree`. It no longer drops nodes prior to the traversed node. 287* `bifunctors` 5, `profunctors` 5 and `semigroupoids` 5 support. 288 2894.9.1 290----- 291* Added `_Wrapped` support for `NonEmpty`. 292* Added `_Wrapped` support for `Alt`. 293* Fixed `Rewrapped` instance for `Last`. 294 2954.9 296------- 297* `filepath` 1.4 support 298* Removed `Control.Monad.Primitive.Lens` and shed the `primitive` dependency. 299* Add missing `_WithIndex` instances from `keys` package 300* Much more code is inferred `Safe` rather than `Trustworthy`. 301* Documented the difference between `unsafeSingular` and `singular`. 302* `folding` now produces an actual `Fold`. 303* Cleaned up builds for GHC 7.10 to get rid of redundant import warnings. 304 3054.8 306--- 307* When built with `profunctors` 4.4 on GHC 7.8+ we no longer need to use `unsafeCoerce` at all! 308 This drastically reduces the level of trust involved in the way we have optimized `lens`. 309* Added `fusing`. This optimizes long `Lens` chains, by enfocing a form of `fmap` fusion based on the Yoneda lemma. This is particularly effective at making faster lenses the definition is recursive or complex enough that it cannot be inlined. 310* Added `confusing`. This optimizes long `Traversal` chains. As with `fusing` it is best used when the definition for the `Traversal` chain in question is recursive or complex enough that it cannot be inlined, but the implementation is much more confusing. 311* Remove deprecated stuff: `Control.Lens.Loupe`, `headOf`, `makeFieldsWith`, 312 `strippingPrefix`, `strippingSuffix` 313* Added `Cons` and `Snoc` instances for `NonEmpty` 314* Removed `Data.List.Split.Lens` module 315* Reimplemented `bytestring` traversals to avoid internal modules 316* Added `gplate`, an implementation of `plate` for any type implementing `Generic` 317* Strictness revisited 318 * Add `generateLazyPatterns` configuration flag to `makeLenses` rules. 319 * Make the default `makeLenses` behavior to generate STRICT optics 320 * Add strict variants of `_1` .. `_9` named `_1'` .. `_9'` 321* Generalized some combinators in `Data.Vector.Generic.Lens` and added `converted` 322 3234.7 324--- 325* Migrated `Control.Lens.Action` to `lens-action`. 326* Added `Data.Vector.Generic.Lens.vectorIx` function for indexing vectors with only `Vector` constraint. 327* Added `Field1` and `Field2` instances for `Data.Functor.Product.Product`. 328* Removed the "typeclass synonym" `Gettable`. 329* Added new flag to `makeLenses`, `generateUpdateableOptics`, which allows 330 the generation of only `Getter`s and `Fold`s. This feature is intended 331 to be used when the constructors are hidden behind validating, "smart" 332 constructors. 333* Fixed Template Haskell name generation when using GHC 7.10 334* Fixed Template Haskell generation of classes methods where field types used 335 existential quantification 336 3374.6.0.1 [maintenance release] 338------- 339* Compatibility with `base` 4.8 [Edit: this turned out to not work for the final release of GHC 7.10] 340 3414.6 342--- 343* Reduced `Review` to two arguments, like `Getter`. 344* Added `abbreviatedFields` to permit `makeFieldsWith` to be invoked with an argument that lets it act like it did pre-4.5 and accept arbitrary common prefixes. 345 3464.5 347--- 348* Provide access to the typename in `lensRules` naming function. 349* `makeFields` camelcasing rules now properly support types with camelcasing. `MyType` with field `myTypeFieldA` generates `fieldA` now. Previously the prefix ignore capitalization and the field would need to be named `mytypeFieldA`. 350* `makeClassy` works on types even when none of the fields would generate optics. 351* Added `Monad`, `MonadReader`, `MonadPlus` and `Bind` instances for `ReifiedMonadicFold` 352* Added missing fixity declarations on many operators. 353* Migrated `Codec.Compression.Zlib.Lens` to `zlib-lens` package. 354 3554.4.0.2 356--- 357* `text` 1.2.0.0 support 358* Remove the use of the TemplateHaskell extension from the library to enable lens to be used on stage1 cross-compilers 359 3604.4.0.1 361---- 362* Restore previous default of `makeFields` using the camel case field namer. 363 3644.4 365---- 366* Internals of Template Haskell code generation rewritten. makeLenses, 367 makeClassy, and makeFields have been unified into the same generator. 368* TH generated single constructor Lens use irrefutable pattern matching to 369 enable construction starting with undefined. 370* TH generated traverals unify their field arguments (type synonyms not 371 currently expanded) enabling exotic traversals to be generated. 372* Added instances for `Text` to `Data.Aeson.Lens` 373* Reimplemented `makePrisms`, adding support for `makeClassyPrisms`, infix constructrs generate periods (.) prefixed prisms. 374* Added `Choice` to `Review` so that `Prism` is a proper subtype of `Review` 375* Migrated `Data.Aeson.Lens` to `lens-aeson` package. 376* Fixed `GHC.Generics.Lens.tinplate` behavior on single-field data types and empty data types. 377 3784.3.3 379----- 380* `semigroupoids` 4.2 support 381 3824.3.2 383----- 384* `contravariant` 1.0 support 385 3864.3.1 387----- 388* Added `bytewise` to `Data.Bits` 389 3904.3 391--- 392* Switched the "direction" of the `Iso` argument to `au` to match the order generated by `makePrisms` and `makeLenses`. 393* Removed `makeIsos` in favor of `makePrisms` and `makeLenses`. Each of these functions will construct `Iso`s when appropriate. 394* Removed `declareIsos` in favor of `declarePrisms` and `declareLenses`. Each of these functions will construct `Iso`s when appropriate. 395* Added `matching` for type-changing matches with `Prism`s. 396* Added `withPrism` for recovering the functions passed to `prism`. 397* Added `negated`, the isomorphism for the `negate` function. 398 3994.2 400--- 401* Added `_Text` isomorphisms to make the proper use with `(#)` more obvious and fit newer convention. 402* Added `Wrapped` instances for `Vector` types 403* Resolved issue #439. The various `Prism`s for string-like types in `Data.Aeson.Lens` are now law-abiding `Prism`s "up to quotient." 404* Added `selfIndex`. 405* Support `attoparsec` 0.12. 406 4074.1.2 408----- 409* When used with `exceptions` 0.4, `throwingM` will permit use with a mere `MonadThrow`. 410 4114.1.1 412---- 413* Generalized the types of `mapping`, `bimapping`, `contramapping`, `dimapping`, `lmapping`, `rmapping` to support changing the `Functor`, `Bifunctor`, `Contravariant`, and `Profunctor` respectively. 414* Compatibility with `free` 4.6 415 4164.1 417--- 418* Added `Plated` instances for various free monad variants. 419* Compatibility with GHC HEAD (7.9+) 420 4214.0.7 422----- 423* Removed dependency on `constraints`. It was used in a pre-release version of 4.0 but never made it into 4.0, but the dependency had remained around complicating builds for GHC 7.4. 424 4254.0.6 426----- 427* `makeLenses` attempt to make the accessors it can under existential quantification. 428* Added `(&~)`. 429* _Experimental_ support for parallel builds on GHC 7.8 with `cabal install lens -fj`. Due to at last one known issue with GHC, it isn't recommended to use this option when rebuilding lens, as a race condition on at least one platform has been seen in the wild. 430* Added `RoleAnnotations` for GHC 7.8.1. These rule out a few user-accessible bottoms that could be caused by creative abuse of the new `Coercible` machinery. However, there was no `unsafeCoerce` exposed. 431* Removed some impossible cases that required unwritable instances from the example doctypes. 432 4334.0.5 434----- 435* Added `bimapping` to `Control.Lens.Iso` 436* Restored correct behavior of `makePrism` on types with a single constructor. 437* `makeLenses` now generates `Getter`s and `Fold`s on universally quantified fields. 438 4394.0.4 440----- 441* Made `declareFields` work again. 442 4434.0.3 444----- 445* Fixed random segfaulting when using `foldMapBy`. 446 4474.0.2 448----- 449* Properly bundled the modules needed for the properties test suite into the tarball for hackage. 450 4514.0.1 452----- 453* Typo fixes 454* Exporting `Rewrapping` from `Control.Lens.Wrapped`. 455* Removed the dependency on `cpphs`. 456 4574.0 458---- 459* Added `nearly` to `Control.Lens.Prism`. 460* Added `Control.Lens.Empty`, exporting `_Empty`. 461* We now require `DefaultSignatures`. 462* Added `failing` and `ifailing` to `Control.Lens.Traversal`. 463* Changed the signature of `Data.List.Split.Lens.condensing` due to the addition of `DropBlankFields` to `Data.List.Split.CondensePolicy` in `split`. 464* Simplified `Each`, `Ixed`, and `Contains`. They are no longer indexed. The previous design was actively getting in the way of user-defined instances. 465* Replaced more of our home-grown types with standard ones. They had previously been defined to help make more intelligible error messages, but when we switched to using `(Contravariant f, Functor f)` instead of `(Gettable f)`, these ceased to really help. Now you can define even more `lens`-compatible types (e.g. `Getter` and `Fold`) without depending on `lens`. 466 * Replaced the use of `Accessor` with `Const`. 467 * Replaced the use of `Mutator` with `Identity`. 468 * Replaced the use of `Reviewed` with `Tagged`. 469* Removed the deprecated `Control.Lens.Simple` module. 470* Repurposed `Control.Lens.Combinators` to re-export `Control.Lens` sans any operators; previous residents rehomed to `Control.Lens.Lens`. 471* Added `Control.Lens.Operators` to export just the operators. Varying your import styles between these supports many qualified usage scenarios. 472* Simplified `Cons` and `Snoc`. Now they must be a `Prism`. 473* Simplified `Contains`. This necessitated losing many instancs of `Contains`, but makes it much easier and more consistent to use and instantiate. 474* Simplified the various `AsFoo` types in `Control.Exception.Lens` 475* Simplified the types in `System.IO.Error.Lens`. 476* Merged `lens-aeson` into `lens`. 477* We're exiling `Control.Lens.Zipper` to a separate package. This will let the design for it iterate faster and let us explore the trade-offs between the 3.8 style and the 3.9 style of zippers. 478* Generalized `alongside`, `inside`, `both`. 479* Switched to a new `Typeable` version of `reflection` for the harder combinators in `Control.Exception.Lens`. This enables us to comply with GHC 7.7's ban on hand-written `Typeable` instances. 480* Added a `_Show` `Prism`. 481* Added `Control.Lens.Extras` for the combinator names we don't have the gall to claim outright, but which are consistent with the rest. 482* Renamed the constructors for `ReifiedLens`, etc. to just be the name of their base type. 483* Added many many missing instances for `ReifiedFold` and `ReifiedGetter`. This permits things like `runFold ((,) <$> Fold (traverse._1) <*> Fold (traverse._2))` to be a `Fold` 484 and `ReifiedFold` can be used as a `Monad`, `Profunctor`, etc. 485* Many performance optimizations. 486* Switched to `exceptions` from `MonadCatchIO-transformers` 487* Added types for working with `RelevantFold` and `RelevantTraversal`. These are a `Fold` or `Traversal` that always has at least one target. Since `Apply` isn't a superclass of `Applicative`, you occasionally need to convert between them, but it lets you more readily work with less unsafety. 488* Changed `unwrapping` and `wrapping` to have the same constructor-oriented order as a `Prism` and renamed them t `_Wrapping` and `_Unwrapping` respectively. 489* Drastically changed the way `_Wrapping` and `_Unwrapping` are built to get much better inference. 490* There are about 15,000 lines of patches over the last year, so I'm sure we missed a few big changes. 491 4923.10.1 [maintenance release] 493------ 494* Compatibility with `base` 4.7 495 4963.10.0.1 [maintenance release] 497-------- 498* Compatibility with `text` 1.0 499 5003.10 501---- 502* Switched to `bifunctors`, `comonad`, `profunctors`, and `semigroupoids` 4.0. 503 5043.9.2 505----- 506* Generalized signatures for `throwing` and `throwingM`. 507 5083.9.1 509----- 510* 'condensingPolicy' was updated to work with 'split' 0.2.2 511 5123.9.0.3 513------- 514* Bumped dependency on `generic-deriving` again. 515 5163.9.0.2 517------- 518* Bumped dependency on `generic-deriving` to enable building on GHC HEAD. 519 5203.9.0.1 521------- 522* Updated the field guide image to link to imgur. Sadly the overview haddock and the haddocks are not generated in the same directory, so the haddock hook for copying the image only works locally. 523 5243.9 525----- 526* Changed `Getting` to take 3 arguments instead of 5. If you need the old behavior for portability you can use 527 `Overloaded (Accessor r) s t a b` instead of `Getting r s t a b` and it'll work consistently back through the last few releases. 528* Added `involuted` to `Control.Lens.Iso`. 529* Factored out a common `reversed` definition from all the various forms of it around the library and placed it in `Control.Lens.Iso`. 530* Added `binary`, `octal`, `decimal` and `hex` to `Numeric.Lens`. 531* Added `sans` to `Control.Lens.At`. 532* Improved interoperability: 533 * Reimplemented `Gettable` as an alias for `Contravariant` and `Functor` together to derive `Getter` and `Fold`. This means you can now 534 implement a `Getter` or `Fold` with only a Haskell 98 dependency (`contravariant`). 535 * Removed `Reviewable`. We now use `Bifunctor` and `Profunctor` together to derive `Review`. This means you can now implement a `Review` 536 with Haskell 98 dependencies (`profunctors` and `bifunctors`). 537 * These changes enables more types to be defined without incurring a dependency on the `lens` package. 538 5393.8.7.0-3.8.7.3 [maintenance releases] 540----- 541* Fixes to dependencies and pragmas. 542 5433.8.6 [maintenance release] 544----- 545* Fixed an issue with `DefaultSignatures` being used outside of the appropriate `#ifdef` that caused compilation issues on GHC 7.0.2. 546* Generalized the signature of `prism'` 547* Added `\_Void` and `only` to `Control.Lens.Prism` and `devoid` to `Control.Lens.Lens`. 548* Added `\_Nothing` to `Control.Lens.Prism`. 549* Added `devoid` and `united` to `Control.Lens.Lens`. 550 5513.8.5 552----- 553* Fixed more sporadic issues in doctests, caused by carrying flags from `$setup` between modules. 554 5553.8.4 556----- 557* Renamed `strippingPrefix` to `prefixed`, `strippingSuffix` to `suffixed`. Left the old names as deprecated aliases. 558* Fixed issues with the test suite caused by `doctests` carrying flags from the `$setup` block between modules. 559* Benchmarks now use `generic-deriving` rather than `ghc-prim` directly, like the rest of the package. 560* Added `Generics.Deriving.Lens`, which is now simply re-exported from `GHC.Generics.Lens`. 561 5623.8.3 563----- 564* Added `strippingSuffix` and `stripSuffix` to `Data.Data.Lens` 565* Added `unpackedBytes` and `unpackedChars` to `Data.ByteString.*.Lens` 566* Added `unpacked` to `Data.Text.*.Lens` 567* Added `(#)` as an infix form of `review` to ease using a `Prism` like a smart constructor in `Control.Lens.Review`. 568 5693.8.2 570----- 571* Added a notion of `Handleable(handler, handler_)` to `Control.Exception.Lens` to facilitate constructing a `Handler` from an arbitrary `Fold` or `Prism`. 572* Added a notion of `Handler` and `catches` to and `Control.Monad.Error.Lens` to mirror the `Control.Exception` and `Control.Monad.CatchIO` constructions. 573* Added additional doctests and documentation. 574* Improved error messages and support for types with arguments in `makeFields`. 575 5763.8.1 577----- 578* Fixed a bug in `makeFields` in hierarchical modules. 579 5803.8.0.2 581------- 582* Fixed an issue with running the `doctests` test suite when an older version of `semigroups` is installed. 583 5843.8 585--- 586* Overall: 587 * 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. 588 * 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`. 589 * 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. 590* `Control.Exception.Lens` 591 * 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`. 592* `Control.Lens.At` 593 * Moved `At(at)` and `Contains(contains)` and factored out `Ixed(ix)`. 594 * Deprecated `_at` and `resultAt`. 595 * Removed various `ordinal` and `ix` combinators, which are subsumed by `Ixed(ix)`. 596* `Control.Lens.Cons` 597 * 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. 598* `Control.Lens.Each` 599 * Generalized the signature of `Each` to permit it to provide an `IndexedSetter` for `((->) e)`. 600 * `Each` now uses an `Index` type family that is shared with `At`, `Ixed` and `Contains` to indicate these operations are related. 601* `Control.Lens.Equality` 602 * Added as a stronger form of `Iso` that can be used to safely cast. 603 * 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`. 604* `Control.Lens.Fold` 605 * Added `foldr1Of'` and `foldl1Of'`. 606 * Added `has` and `hasn't`. 607* `Control.Lens.Indexed` 608 * The various indexed combinators for each type were distributed to their respective modules. This module grew to encompass the remaining index-specifics. 609 * Added `index` and `indices`, and removed `iwhere` and `iwhereOf`. Use `itraversed.indices even` and `bar.indices (>3)` instead. 610* `Control.Lens.Internal` 611 * This module was exploded into more manageable component modules. 612* `Control.Lens.Iso` 613 * `Strict(strict)` is now a `Simple Iso`. 614 * Added `magma` and `imagma` which can be used to provide a 'debugging view' of a `Traversal`. 615* `Control.Lens.Lens` 616 * Restructuring split this module out from `Control.Lens.Type` and merged the contents `Control.Lens.IndexedLens`. 617* `Control.Lens.Level` 618 * 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. 619* `Control.Lens.Loupe` 620 * In the interest of consistency, the `Loupe` alias has been deprecated in favor of `ALens`. 621 * `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`. 622* `Control.Lens.Operators` 623 * 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. 624* `Control.Lens.Prism` 625 * Added `prism'` to construct `SimplePrism`s. 626* `Control.Lens.Reified` 627 * Consolidated the various `ReifiedFoo` definitions into one module. 628* `Control.Lens.Representable` 629 * 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. 630* `Control.Lens.Review` 631 * This module now factors the `review` functionality out of `Prism` and exposes `unto`, which is to `review` what `to` is to `view`. 632* `Control.Lens.Setter` 633 * Added `contramapped` and `argument` for mapping over inputs. 634* `Control.Lens.Simple` 635 * Removed the infix lens aliases and repurposed the module to house the now deprecated `SimpleFoo` type aliases, which were replaced universally with `Foo'`. 636* `Control.Lens.TH` 637 * `makeLenses` now generates `Lens'` and `Traversal'` where appropriate 638 * 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. 639 * Added `makeFields`, which generates classes for each individual field in a data type. 640 * Added `makeWrapped`, which automatically generates a `Wrapped` instance for a newtype. 641* `Control.Lens.Type` 642 * 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 643* `Control.Lens.Wrapped` 644 * Added `wrapped'` and `unwrapped'` for scenarios where you need the help with type inference. 645* `Control.Lens.Zipper` 646 * 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. 647* `Data.Bits.Lens` 648 * Added `byteAt`. 649* `Data.ByteString.Lens` 650 * `Data.ByteString.Lazy.Lens` now uses `Int64`-based indexing. 651 * 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. 652* `Numeric.Lens` 653 * Created. `base` shows and reads integers at base-2 through base-36. `integral` can be used as a safe `fromInteger`/`toInteger`. 654 6553.7.6 [maintenance release] 656----- 657* Fixed an issue with the `Complex` `Each` instance. 658 6593.7.5 [maintenance release] 660----- 661* Fixed an errant `LANGUAGE` pragma 662 6633.7.4 [maintenance release] 664----- 665* Backported the API for `ALens` and `ALens'` to support `snap` builds on old platforms. 666 6673.7.3 [maintenance release] 668----- 669* Removed my intra-package dependency upper bounds for my own packages. In particular this enables us to work with `semigroups` 0.9. 670* Switched to `transformers-compat` to avoid having unbuilding modules at the top of the documentation, and to ease 3rd party compatibility. 671* Updated `Setup.lhs` to be compatible with Cabal 1.17 672 6733.7.2 [maintenance release] 674----- 675* Bug fix for `Magnify`. It was missing functional dependencies to determine its `k` parameter from `m` or `n`. 676 6773.7.1.2 [maintenance release] 678------- 679* Made the doctest test suite hide all but the exact versions of packages used to build this package to avoid problems with complicated user environments. 680* Removed doctests based on `:t` as they are fragile and break across GHC versions. 681* Fixed GHC 7.0.4 compatibility by guarding `DefaultSignatures` in `Control.Lens.Each`. 682 6833.7.1.1 [maintenance release] 684------- 685* Removed tests that will (likely) fail in the presence of `hashable` 1.2 686 6873.7.1 688----- 689* Added `preuse`, `preuses` to `Control.Lens.Fold` 690* Added `Each(each)` to `Control.Lens.Each` for indexed traversal of potentially monomorphic containers. 691* Added `indexing64` and `traversed64` for help with large containers. 692* Generalized the type signature of `choosing`. 693* Exported `unwrapped` from `Control.Lens.Wrapped`. 694* Support for `hashable` 1.2 695* Added `(??)` to `Control.Lens.Combinators`. 696 6973.7.0.2 698------- 699* Fixed flagging for Safe Haskell. 700* Fixed examples. 701* Cleaned up the statement of the Prism laws. 702 7033.7.0.1 704------- 705* Corrected bounds for hashable. 706* Fixed compatibility with Haskell Platform 2011.4.0.0 -- you may have to install with --constraint="transformers = 0.2.2.0" to avoid getting new mtl and transformer versions installed. 707 708[3.7](https://github.com/ekmett/lens/issues?milestone=11&page=1&state=closed) 709----- 710* Renamed `Projection` to `Prism`. 711* Implemented a complete redesign of the way `Iso` and `Prism` are handled internally. Any `Iso` can now be used as a `Prism`. 712* The `isos` combinator is no longer required. `iso` can now be used to construct an `Iso`. 713* Changes to the signature of `from` and `under` were necessitated by the new design. 714* Added `Control.Lens.Wrapped` providing a canonical isomorphism for newtypes. 715* Repurposed `ala` to be closer to the original design in `newtype`, but added `au` and `alaf`. 716* Added `_magnitude`, `_phase` and `_conjugate` to `Data.Complex.Lens`. Renamed other lenses for consistency: `_realPart`, `_imagPart`, `_polar`. 717* Promoted `_left` and `_right` to prisms and moved them to `Control.Lens.Prism`. 718* Generalized `view` and `views` to subsume the old functionality of `peruse` and `peruses`. 719* Generalized `review` and `reviews` to both return a `MonadReader` and to work on a `Projection`. 720* Added `view'`/`views'` and `use'`/`uses'` for `Simple` access to the environment/state. 721* Added `set'`, a `Simple` version of `set`. 722* Added `reuse` : `use` :: `review` : `view` and `reuses` : `uses` :: `reviews` : `views` for working a `Projection` from the current `MonadState`. 723* Removed many isomorphisms for various newtypes. `_const`, `identity`, `_sum`, etc. Use `wrapping Const`, `wrapping Identity`, etc. 724* Removed `Data.Monoid.Lens` now that its newtypes are instances of `Wrapped`, exporting the (`<>=`)-variants from `Control.Lens.*`. 725* Renamed `via` to `cloneIso` for consistency. 726* Moved `Indexed(..)` to `Control.Lens.Classes`. 727* Renamed `index` to `indexed` to reduce conflicts with third-party libraries. 728* Added `curried` and `uncurried` to `Control.Lens.Iso`. 729* Added `Strict(strict)` for ad hoc overloading of conversions between strict and lazy variants of `ByteString` and `Text`. 730* Bug fixes for `tugTo` and `jerkTo`. 731* These no longer traverse in the wrong direction: `scanl1Of`, `scanr1Of`, `mapAccumLOf`, and `mapAccumROf`. 732* Added `anon` to `Control.Lens.Iso`. 733* Generalized the types of the `Control.Lens.Zipper` combinators to work with other MonadPlus instances. 734* Added `withins` to `Control.Lens.Zipper` now that they can work better with []. 735* Added `singular` and `unsafeSingular` to `Control.Lens.Traversal` to assert a `Traversal` is a `Lens`, a `Fold` is a `Getter` or a `MonadicFold` is an `Action`. 736* Generalized `sequenceAOf_`'s type to match `sequenceA_`. 737* Renamed `up`/`down`/`left`/`right` to `upward`/`downward`/`leftward`/`rightward` to reduce conflicts -- in particular with `Control.Arrow`. 738* Readded `leftmost` and `rightmost` due to the verbosity of `farthest leftward`/`farthest rightward`. 739* Added `preview`/`previews`/`firstOf` and deprecated `headOf`. 740* Added `iview`/`iviews`/`iuse`/`iuses` to `Control.Lens.IndexedGetter`. 741* We've generalized the type of Bazaar and provided generalized variants of `partsOf`, etc. that used it. 742 7433.6.0.4 [maintenance release] 744------- 745* Added support for `test-framework` 0.8 746 7473.6.0.3 [maintenance release] 748------- 749* Added support for `test-framework` 0.7 750 7513.6.0.2 [maintenance release] 752------- 753* Added more explicit dependencies to the doctest suite. 754* Disabled the 'expected failure' quickcheck tests that occasionally would fail with internal QuickCheck errors. 755 7563.6.0.1 [maintenance release] 757------- 758* Added explicit dependency on containers and unordered-containers to the doctest suite 759 760[3.6](https://github.com/ekmett/lens/issues?milestone=9&state=closed) 761--- 762* Added `upon` (along with variants of it) to `Data.Data.Lens`, which can be used to generate a `Traversal` from a field accessor or any function that returns, unmodified, 763 a single field that would be visited by `template`. 764* Added some missing `examples/` files to the distribution. 765* Renamed `Data.Bits.Lens.traverseBits` to `bits`. 766* Removed `(^!?)`, which was an alias for `(^?!)`. 767* Removed the need for `Trustworthy` by changing the implementation of `coerce` for `BazaarT`. 768* Moved BazaarT to `Control.Lens.Internal`. 769* Added `(<&>)` to `Control.Lens.Combinators`. 770* `element` and `elementOf` are now indexed traversals rather than lenses and have moved to `Control.Lens.IndexedTraversal`. This both fixes their former partiality and lets you use chain indexed combinators with them. 771* Added `elements` and `elementsOf` as indexed traversals for ordinal indexing into regular traversals that generalize `element` and `elementOf`. 772* Renamed `Data.Complex.Lens.traverseComplex` to `complex`. 773* Changed `Data.Complex.Lens.polarize` to a `Simple Iso`, due to the `RealFloat` constraint causing inference problems. 774* Renamed `traverseLeft` and `traverseRight` to `_left` and `_right` respectively. 775* Renamed `traverseSlice`, `traverseFrom`, and `traverseTo` in `Data.Sequence.Lens` to `sliced`, `slicedFrom`, and `slicedTo` respectively. 776* Renamed `traverseAt` to `_at` in `Control.Lens.IndexedTraversal`. 777* Renamed `traverseArray` to `_array` in `Data.Array.Lens`. 778* Renamed and made the combinators in `Control.Lens.Zipper` more compositional to reduce third-party naming conflicts down to just `left` and `right`. 779* Renamed `&=` and `|=` to `.&.=` and `.|.=` for consistency, mutatis mutandis their related operations. 780* Added a `Plated` instances for `Language.Haskell.TH` types. 781* Renamed `atIndex` and `atIndices` in `Data.Vector.Lens` and `Data.Vector.Generic.Lens` to `ordinal` and `ordinals` to match `Data.Sequence.Lens` 782 7833.5.1 784----- 785* Improved SafeHaskell inference. 786 787[3.5](https://github.com/ekmett/lens/issues?milestone=8&state=closed) 788--- 789* Fixed a potential SafeHaskell issue where a user could use `undefined` to derive `unsafeCoerce`. You now have to import an explicitly 790 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. :) 791* Renamed `EvilBazaar` to `BazaarT`. 792* Moved a lot of internals around. Most notably, `Gettable`, `Settable` and `Effective` have moved to `Control.Lens.Classes`. 793* Exposed `partsOf'` and `unsafePartsOf'` in `Control.Lens.Traversal` to reduce reliance on `BazaarT` in `Control.Lens.Zipper` 794 795[3.4](https://github.com/ekmett/lens/issues?milestone=7&state=closed) 796--- 797* Renamed `(%)` to `(&)` and `(^%)` to `(^&)`. This avoids the conflict with `Data.Ratio`, which was our highest priority conflict with a third party library. 798* Switched to a more liberal type for `ignored` 799* Removed some "`isplitting`" bad combinators from `Control.Lens.IndexedFold`. 800* Made `indexed`, `taking`, and `dropping` and `elementOf` lazier and capable of dealing with infinite traversals and infinite folds. 801* Improved `Indexing` to support infinite traversals and folds. 802* Removed some of the more redundant combinators from `Control.Lens.Plated`, which already had existing aliases in the rest of the traversal API. 803* Moved `partsOf`, `holesOf`, and `elementOf` into `Control.Lens.Traversal`. 804* Renamed `query` to `peruse` and `queries` to `peruses`. These are much less contentious names, 805 both contain `use` in their name for analogy to `use` and `uses` and the word is about reading. 806* Simpler `simple`. 807* Added `enum` and `non` to `Control.Lens.Iso`. 808* Added `(^?!)` to `Control.Lens.Fold` for unsafe access to the head of a `Fold`. 809* Changed `_head`, `_tail`, `_init` and `_last` to traversals in `Data.List.Lens` and `Data.Sequence.Lens`. 810* Eliminated `traverseHead`, `traverseTail`, `traverseInit` and `traverseLast`. 811* `partsOf` and `unsafePartsOf` can now also be applied to a `Fold` yielding a `Getter` or to a `MonadicFold` yielding an `Action`. 812 8133.3 814--- 815* Redefined `simple` and moved it to `Control.Lens.Iso`. Instead of using `simple l` you can now compose `l.simple` or `simple.l` providing more nuanced control and a more compositional API. 816* Moved the various `foo#` combinators used to emit cleaner core into an unexported module, `Control.Lens.Unsafe`. This removes `MagicHash` from the public API. 817* Removed the `bazaar#` and `runBazaar#` coercions that caused issues on GHC HEAD. 818* Changed the default definition of `plate` to `uniplate` from `ignored`. 819* Added `Data.Vector.Lens` and instances for `Data.Vector`. 820* Added support for the `split` package, which is now part of the Haskell platform. 821* Removed redundant `Data.List.traverseList`. Use `itraversed` or `traverse` instead. 822* Moved `(:<->)` to `Control.Lens.Simple`. 823* Fixed a bug in `Control.Lens.TH` that was causing `makeIso` not to work. 824* Added `lifted` to `Control.Lens.Setter` for mapping over monads. 825* Added `beside` to `Control.Lens.Traversal`. 826* Removed the operators from `Data.List.Lens`, they broke the overall pattern of the rest of the API, and were terrible clutter. 827* Fixed a bug that caused `resultAt` to give wrong answers most of the time. 828* Changed `resultAt` to an `IndexedLens` and moved it to `Control.Lens.IndexedLens` 829* Changed `ignored` to an `IndexedTraversal` and moved it to `Control.Lens.IndexedTraversal` 830* We've relinquished the name `value`. 831 8323.2 833--- 834* Made `elementOf` lazier and moved it from `Control.Lens.Traversal` to `Control.Lens.Plated`. 835* Made `holesOf` and `partsOf` lazier to deal with infinite structures. 836* Resolved issue #75. We now generate nicer core for most `Setter` and `Fold` operations, and some others. 837* Made lenses for field access like `_1`, `_2`, etc. lazier. 838* Added `Control.Lens.Loupe`, which provides a limited form of `Lens` that can be read from and written to and which can compose 839 with other lenses, but can also be returned in a list or as a monadic result, but cannot be used directly for most combinators 840 without cloning it first. It is easier to compose than a `ReifiedLens`, but slightly slower. 841* Moved (`:=>`) and (`:->`) into `Control.Lens.Simple`, which is not exported by `Control.Lens` by default to reduce name conflicts with third party libraries. 842 8433.1 844--- 845* Simplified the type of `filtered`, so that it can be composed with other folds rather than be parameterized on one. Included the caveat that the new `filtered` is still not a legal `Traversal`, despite seeming to compose like one. 846* Renamed `ifiltered` to `ifiltering`, and while it still must take an indexed lens-like as an argument, I included a similar caveat about the result not being a legal `IndexedLens` when given an `IndexedLens`. The function was renamed because its signature no longer lined up with the new `filtered` and the gerundive '-ing' suffix has come to indicate an operator that transformers another lens/traversal/etc. into a new one. 847* Added `taking` and `dropping` to `Control.Lens.Traversal`. 848 8493.0.6 850----- 851* Alpha-renamed all combinators to a new scheme. Instead of `Foo a b c d`, they now follow `Foo s t a b`. This means that you don't need to alpha rename everything in your head to work through the examples, simplifies exposition, and uses s and t for common state monad parameters. Thanks go to Shachaf Ben-Kiki for the grunt work of slogging through hundreds of definitions by hand and with regular expressions! 852* Restored lenses to `Trustworthy` status so they can be used with Safe Haskell once more. 853 8543.0.5 855----- 856* Fixed a bug in `rights1` and `lefts1` in `Control.Lens.Zipper` which would cause them to loop forever when given a 0 offset. 857 8583.0.4 859----- 860* Added `?~`, `<?~`, `?=` and `<?=` to `Control.Lens.Setter` for setting the target(s) of a Lens to `Just` a value. They are particularly useful when combined with `at`. 861 8623.0.3 863----- 864* Refined the behavior of `substType` in `Control.Lens.TH` to match the behavior of `typeVarsEx` when moving under binders. 865 866 8673.0.2 868----- 869* Added `generateSignatures` option to `Control.Lens.TH` to allow the end user to disable the generation of type signatures for the 870 template-haskell generated lenses. This lets the user supply hand-written haddocks and more restricted signatures. 871 8723.0.1 873----- 874* Added `Control.Lens.Type.simple`. 875 876[3.0](https://github.com/ekmett/lens/issues?milestone=6&state=closed) 877--- 878* Added `Control.Lens.Zipper`. 879* Added `<<~`, a version of `<~` that supports chaining assignment. 880* Added `:->`, `:=>`, and `:<->` as type operator aliases for `Simple Lens`, `Simple Traversal`, and `Simple Iso` respectively. 881 882[2.9](https://github.com/ekmett/lens/issues?milestone=5&state=closed) 883--- 884* Added `<<%~`, `<<.~`, `<<%=` and `<<.=` for accessing the old values targeted by a `Lens` (or a summary of those targeted by a `Traversal`) 885* Renamed `|>` to `%`, as `%~` is the lensed version of `%`, and moved it to `Control.Lens.Getter` along with a version `^%` with tighter 886 precedence that can be interleaved with `^.` 887* Upgraded to `doctest` 0.9, which lets us factor out common `$setup` for our doctests 888* Renamed `merged` to `choosing`. Added a simpler `chosen` operation to mirror `both`. 889* Added `Control.Lens.Projection` 890* Renamed `traverseException` to `exception` and `traverseDynamic` to `dynamic`, upgrading them to use `Projection`. 891* `makeClassy` now places each generated `Lens` or `Traversal` inside the class it constructs when possible. 892 This makes it possible for users to just export `HasFoo(..)`, rather than have to enumerate each lens in 893 the export list. It can only do that if it creates the class. If the `createClass` flag is disabled, then 894 it will default to the old behavior. 895* Added `performs` to `Control.Lens.Action` to mirror `views` in `Control.Lens.Getter`. 896 897[2.8](https://github.com/ekmett/lens/issues?milestone=4&state=closed) 898--- 899* Restored compatibility with GHC 7.2. This required a major version bump due to making some MPTC-based default signatures conditional. 900 9012.7.0.1 902------- 903* Added the missing `Control.Lens.Combinators` to exported-modules! Its absence was causing it not to be included on hackage. 904 905[2.7](https://github.com/ekmett/lens/issues?milestone=3&state=closed) 906--- 907* Generalized the signature of `Getting`, `Acting` and `IndexedGetting` to help out with the common user code scenario of needing to read 908 and then write to change types. 909* Documentation cleanup and additional examples. 910* Renamed `au` to `ala`, introducing further incompatibility with the `newtype` package, but reducing confusion. 911* Removed need for `Data.Map.Lens` and `Data.IntMap.Lens` by adding `TraverseMin` and `TraverseMax` to `Control.Lens.IndexedTraversal`. 912* Flipped fixity of `~:` and `<~:` 913* Added `++~`, `++=`, `<++~` and `<++=` to Data.List.Lens in response to popular demand. 914* Added `|>`, `<$!>` and `<$!` to `Control.Lens.Combinators`, which exports combinators that are often useful in lens-based code, but that 915 don't strictly involve lenses. 916* Added an HUnit-based test suite by @orenbenkiki 917 9182.6.1 919----- 920* Fixed bugs in `Traversal` code-generation. 921 922[2.6](https://github.com/ekmett/lens/issues?milestone=2&state=closed) 923--- 924* Added build option `-f-inlining` to facilitate building with the various TH 2.8 versions used by GHC 7.6 and HEAD. 925* Added build option `-f-template-haskell` for testing without template haskell. (Users should be able to assume TH is enabled; use this only for testing!) 926* Added support for generating a `Traversal` rather than a `Lens` when multiple fields map to the same name or some constructors are missing a field. 927* Removed `_` from the lens names in `System.FilePath.Lens`. 928* Added `iwhere`, `withIndices`, `withIndicesOf`, `indices` and `indicesOf` to ease work with indexed traversals 929* Added `assign` as an alias for `(.=)` in `Control.Lens.Setter`. 930* Added `~:`, `=:`, `<~:` and `<=:` to `Data.List.Lens` 931 932[2.5](https://github.com/ekmett/lens/issues?milestone=1&state=closed) 933--- 934* Added `Control.Lens.Plated`, a port of Neil Mitchell's `uniplate` that can be used on any `Traversal`. 935* Added `Data.Data.Lens` with smart traversals that know how to avoid traversing parts of a structure that can't contain a given type. 936* Added `Data.Typeable.Lens` with `_cast` and `_gcast` like `traverseData` 937* Renamed `IndexedStore` to `Context` now that it is used in user-visible locations, and since I also use it as `uniplate`'s notion of a context. 938* Renamed `Kleene` to `Bazaar` -- "a bazaar contains a bunch of stores." 939* Added `Comonad` instances for `Context` and `Bazaar`, so we can use stores directly as the notion of an editable context in uniplate 940* Compatibility with both sets of template haskell quirks for GHC 7.6.1-rc1 and the GHC 7.6.1 development head. 941* Renamed `children` to `branches` in `Data.Tree.Lens`. 942* Added `At` and `Contains` to `Control.Lens.IndexedLens`. 943* Added `FunctorWithIndex`, `FoldableWithIndex`, and `TraversableWithIndex` under `Control.Lens.WithIndex` 944* Added support for `unordered-containers`. 945 9462.4.0.2 947------- 948* GHC 7.6.1 development HEAD compatibility (but broke 7.6.1-rc1) 949 9502.4.0.1 951------- 952* Haddock cleanup 953 9542.4 955----- 956* Added the indexed `Kleene` store to `Control.Lens.Internal` 957* Moved `Gettable`, `Accessor`, `Settable` and `Mutator` to `Control.Lens.Internal` 958* Added `cloneTraversal` to `Control.Lens.Traversal` 959* Renamed `clone` to `cloneLens` in `Control.Lens.Type` 960* Generalized the type of `zoom` to subsume `focus`. 961* Removed `Focus(..)` from `Control.Lens.Type`. 962* Factored out `Control.Lens.Isomorphic`. 963* Moved many private types to `Control.Lens.Internal` 964* Added `conFields` to `Language.Haskell.TH.Lens`. 965* Added `System.FilePath.Lens`. 966 9672.3 968--- 969* Added missing `{-# INLINE #-}` pragmas 970* Renamed `meanwhile` to `throughout` in `Control.Parallel.Strategies.Lens` 971* Added `Magnify` to `Control.Lens.Getter`. 972* Added `Zoom` to `Control.Lens.Type`. 973 9742.2 975--- 976* Added `<&=`, `<&~`, `<|=`, and `<|~` 977* Moved `<>~`, `<<>~`, `<>=`, and `<<>=` to `Data.Monoid.Lens` 978* Template Haskell now uses eager binding to avoid adding dependencies. 979 9802.1 981--- 982* Renamed `adjust` to `over` 983* Added `au`, `auf` and `under` 984* Added `Data.Monoid.Lens` 985* Increased lower dependency bound on `mtl` for cleaner installation. 986