From 407525b571b48cfd65e1ad7a02d250a927c967c9 Mon Sep 17 00:00:00 2001 From: V3n3RiX Date: Fri, 1 Dec 2017 03:04:39 +0000 Subject: gentoo resync : 01.12.2017 --- dev-haskell/lens/metadata.xml | 77 ++++++++++++++++++++++--------------------- 1 file changed, 40 insertions(+), 37 deletions(-) (limited to 'dev-haskell/lens/metadata.xml') diff --git a/dev-haskell/lens/metadata.xml b/dev-haskell/lens/metadata.xml index 475ca4ea9656..ffb64447adda 100644 --- a/dev-haskell/lens/metadata.xml +++ b/dev-haskell/lens/metadata.xml @@ -9,84 +9,87 @@ This package comes \"Batteries Included\" with many useful lenses for the types commonly used from the Haskell Platform, and with tools for automatically generating lenses and isomorphisms for user-supplied data types. - + The combinators in @Control.Lens@ provide a highly generic toolbox for composing 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> - + A video on how to use lenses and how they are constructed is available from youtube: <http://youtu.be/cefnmjtAolY?hd=1> - + Slides can be obtained here: <http://comonad.com/haskell/Lenses-Folds-and-Traversals-NYC.pdf> - + 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> - + 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 the hierarchy of lens-like constructions looks like: - - + + <<http://i.imgur.com/4fHw3Fd.png>> - + Local copy (<Hierarchy.png>) - + 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). - + For instance: - + * You can use any 'Traversal' as a 'Fold' or as a 'Setter'. - + * The composition of a 'Traversal' and a 'Getter' yields a 'Fold'. - + /Minimizing Dependencies/ - + If you want to provide lenses and traversals for your own types in your own libraries, then you can do so without incurring a dependency on this (or any other) lens package at all. - + /e.g./ for a data type: - + > data Foo a = Foo Int Int a - + You can define lenses such as - + > -- 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) - + > -- baz :: Lens (Foo a) (Foo b) a b > quux :: Functor f => (a -> f b) -> Foo a -> f (Foo b) > quux f (Foo a b c) = fmap (Foo a b) (f c) - + without the need to use any type that isn't already defined in the @Prelude@. - + And you can define a traversal of multiple fields with 'Control.Applicative.Applicative': - + > -- 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 - + What is provided in this library is a number of stock lenses and traversals for common haskell types, a wide array of combinators for working them, and more exotic functionality, (/e.g./ getters, setters, indexed folds, isomorphisms). - Enable benchmarking against Neil Mitchell's - uniplate library for comparative performance analysis. Defaults to being - turned off to avoid the extra dependency. - Generate inline pragmas when using - template-haskell. This defaults to enabled, but you can - to shut it off to benchmark the relative performance impact, - or as last ditch effort to address compile errors resulting - from the myriad versions of template-haskell that all purport to be 2.8. - Some 7.6.1-rc1 users report their TH still - uses old style inline pragmas. This lets them turn on inlining. + + Enable benchmarking against Neil Mitchell's + uniplate library for comparative performance analysis. Defaults to being + turned off to avoid the extra dependency. + + + Generate inline pragmas when using + template-haskell. This defaults to enabled, but you can + to shut it off to benchmark the relative performance impact, + or as last ditch effort to address compile errors resulting + from the myriad versions of template-haskell that all purport to be 2.8. + + Some 7.6.1-rc1 users report their TH still uses old style inline pragmas. This lets them turn on inlining. Disallow unsafeCoerce Build and run the doctests test-suite. Attempt a parallel build with GHC 7.8. -- cgit v1.2.3