openSUSE Build Service

Overview Repositories Revisions Requests Users Attributes Meta

File lens.cabal of Package ghc-lens (Revision 5387194a77ef4b3a77d2148a107e094b)

Currently displaying revision 5387194a77ef4b3a77d2148a107e094b , Show latest

name:          lens
category:      Data, Lenses, Generics
version:       5.1
x-revision: 1
license:       BSD2
cabal-version: 1.18
license-file:  LICENSE
author:        Edward A. Kmett
maintainer:    Edward A. Kmett <ekmett@gmail.com>
stability:     provisional
homepage:      http://github.com/ekmett/lens/
bug-reports:   http://github.com/ekmett/lens/issues
copyright:     Copyright (C) 2012-2016 Edward A. Kmett
build-type:    Simple
-- build-tools:   cpphs
tested-with:   GHC == 8.0.2
             , GHC == 8.2.2
             , GHC == 8.4.4
             , GHC == 8.6.5
             , GHC == 8.8.4
             , GHC == 8.10.7
             , GHC == 9.0.1
             , GHC == 9.2.1
synopsis:      Lenses, Folds and Traversals
description:
  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 <https://github.com/ekmett/lens#lens-lenses-folds-and-traversals README>.
  .
  An introductory video on the style of code used in this library by Simon Peyton Jones is available from <http://skillsmatter.com/podcast/scala/lenses-compositional-data-access-and-manipulation Skills Matter>.
  .
  A video on how to use lenses and how they are constructed is available on <http://youtu.be/cefnmjtAolY?hd=1 youtube>.
  .
  Slides for that second talk can be obtained from <http://comonad.com/haskell/Lenses-Folds-and-Traversals-NYC.pdf comonad.com>.
  .
  More information on the care and feeding of lenses, including a brief tutorial and motivation
  for their types can be found on the <https://github.com/ekmett/lens/wiki lens wiki>.
  .
  A small game of @pong@ and other more complex examples that manage their state using lenses can be found in the <https://github.com/ekmett/lens/blob/master/examples/ example folder>.
  .
  /Lenses, Folds and Traversals/
  .
  With some signatures simplified, the core of the hierarchy of lens-like constructions looks like:
  .
  .
  <<http://i.imgur.com/ALlbPRa.png>>
  .
  <images/Hierarchy.png (Local Copy)>
  .
  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)
  .
  > -- quux :: 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).

extra-source-files:
  .gitignore
  .hlint.yaml
  .vim.custom
  cabal.project
  examples/LICENSE
  examples/lens-examples.cabal
  examples/*.hs
  examples/*.lhs
  examples/.hlint.yaml
  include/*.h
  lens-properties/.hlint.yaml
  lens-properties/CHANGELOG.markdown
  lens-properties/LICENSE
  lens-properties/Setup.hs
  lens-properties/lens-properties.cabal
  AUTHORS.markdown
  CHANGELOG.markdown
  README.markdown
  SUPPORT.markdown
extra-doc-files:
  images/*.png

source-repository head
  type: git
  location: https://github.com/ekmett/lens.git

-- Enable benchmarking against Neil Mitchell's uniplate library for comparative performance analysis. Defaults to being turned off to avoid
-- the extra dependency.
--
-- > cabal configure --enable-benchmarks -fbenchmark-uniplate && cabal build && cabal bench
flag benchmark-uniplate
  default: False
  manual: True

-- Generate inline pragmas when using template-haskell. This defaults to enabled, but you can
--
-- > cabal install lens -f-inlining
--
-- 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.
flag inlining
  manual: True
  default: True

-- Make the test suites dump their template-haskell splices.
flag dump-splices
  default: False
  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

flag test-templates
  default: True
  manual: True

-- Assert that we are trustworthy when we can
flag trustworthy
  default: True
  manual: True

-- Attempt a parallel build with GHC 7.8
flag j
  default: False
  manual: True

library
  build-depends:
    array                         >= 0.5.0.0  && < 0.6,
    assoc                         >= 1.0.2    && < 1.1,
    base                          >= 4.9      && < 5,
    base-orphans                  >= 0.5.2    && < 1,
    bifunctors                    >= 5.5.7    && < 6,
    bytestring                    >= 0.10.4.0 && < 0.12,
    call-stack                    >= 0.1      && < 0.5,
    comonad                       >= 5.0.7    && < 6,
    containers                    >= 0.5.5.1  && < 0.7,
    contravariant                 >= 1.4      && < 2,
    distributive                  >= 0.5.1    && < 1,
    exceptions                    >= 0.8.2.1  && < 1,
    filepath                      >= 1.2.0.0  && < 1.5,
    free                          >= 5.1.5    && < 6,
    ghc-prim,
    hashable                      >= 1.2.7.0  && < 1.5,
    indexed-traversable           >= 0.1      && < 0.2,
    indexed-traversable-instances >= 0.1      && < 0.2,
    kan-extensions                >= 5        && < 6,
    mtl                           >= 2.2.1    && < 2.3,
    parallel                      >= 3.2.1.0  && < 3.3,
    profunctors                   >= 5.5.2    && < 6,
    reflection                    >= 2.1      && < 3,
    semigroupoids                 >= 5.0.1    && < 6,
    strict                        >= 0.4      && < 0.5,
    tagged                        >= 0.8.6    && < 1,
    template-haskell              >= 2.11.1.0 && < 2.19,
    text                          >= 1.2.3.0  && < 2.1,
    th-abstraction                >= 0.4.1    && < 0.5,
    these                         >= 1.1.1.1  && < 1.2,
    transformers                  >= 0.5.0.0  && < 0.6,
    transformers-compat           >= 0.5.0.4  && < 1,
    unordered-containers          >= 0.2.10   && < 0.3,
    vector                        >= 0.12.1.2 && < 0.13

-- Control.Lens as the first module, so cabal repl loads it.
  exposed-modules:
    Control.Lens

exposed-modules:
    Control.Exception.Lens
    Control.Lens.At
    Control.Lens.Combinators
    Control.Lens.Cons
    Control.Lens.Each
    Control.Lens.Empty
    Control.Lens.Equality
    Control.Lens.Extras
    Control.Lens.Fold
    Control.Lens.Getter
    Control.Lens.Indexed
    Control.Lens.Internal
    Control.Lens.Internal.Bazaar
    Control.Lens.Internal.ByteString
    Control.Lens.Internal.Context
    Control.Lens.Internal.CTypes
    Control.Lens.Internal.Deque
    Control.Lens.Internal.Exception
    Control.Lens.Internal.FieldTH
    Control.Lens.Internal.PrismTH
    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.List
    Control.Lens.Internal.Magma
    Control.Lens.Internal.Prism
    Control.Lens.Internal.Profunctor
    Control.Lens.Internal.Review
    Control.Lens.Internal.Setter
    Control.Lens.Internal.TH
    Control.Lens.Internal.Zoom
    Control.Lens.Iso
    Control.Lens.Lens
    Control.Lens.Level
    Control.Lens.Operators
    Control.Lens.Plated
    Control.Lens.Prism
    Control.Lens.Profunctor
    Control.Lens.Reified
    Control.Lens.Review
    Control.Lens.Setter
    Control.Lens.TH
    Control.Lens.Traversal
    Control.Lens.Tuple
    Control.Lens.Type
    Control.Lens.Unsound
    Control.Lens.Wrapped
    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
    Data.ByteString.Lazy.Lens
    Data.Complex.Lens
    Data.Data.Lens
    Data.Dynamic.Lens
    Data.HashSet.Lens
    Data.IntSet.Lens
    Data.List.Lens
    Data.Map.Lens
    Data.Sequence.Lens
    Data.Set.Lens
    Data.Text.Lens
    Data.Text.Strict.Lens
    Data.Text.Lazy.Lens
    Data.Tree.Lens
    Data.Typeable.Lens
    Data.Vector.Lens
    Data.Vector.Generic.Lens
    GHC.Generics.Lens
    System.Exit.Lens
    System.FilePath.Lens
    System.IO.Error.Lens
    Language.Haskell.TH.Lens
    Numeric.Lens
    Numeric.Natural.Lens

other-modules:
    Control.Lens.Internal.Prelude

if flag(trustworthy) && impl(ghc)
    other-extensions: Trustworthy
    cpp-options: -DTRUSTWORTHY=1

if flag(inlining)
    cpp-options: -DINLINING

if flag(j)
    ghc-options: -j4

ghc-options: -Wall -Wtabs -O2 -fdicts-cheap -funbox-strict-fields -fmax-simplifier-iterations=10
               -Wno-trustworthy-safe -Wmissing-pattern-synonym-signatures -Wno-redundant-constraints

hs-source-dirs: src

include-dirs: include

default-language: Haskell2010

-- future proof, whether the field will be comma separated or not.
  x-docspec-extra-packages: simple-reflect
  x-docspec-extra-packages: deepseq

-- Verify that Template Haskell expansion works
test-suite templates
  type: exitcode-stdio-1.0
  main-is: templates.hs
  other-modules:
    T799
    T917
    T972
  ghc-options: -Wall -threaded
  hs-source-dirs: tests
  default-language: Haskell2010

if flag(dump-splices)
    ghc-options: -ddump-splices

if !flag(test-templates)
    buildable: False
  else
    build-depends: base, lens

-- Verify the properties of lenses with QuickCheck
test-suite properties
  type: exitcode-stdio-1.0
  main-is: properties.hs
  other-modules:
    Control.Lens.Properties
  ghc-options: -Wall -threaded -rtsopts -with-rtsopts=-N
  hs-source-dirs:
    tests
    lens-properties/src
  include-dirs: include
  default-language: Haskell2010
  if !flag(test-properties)
    buildable: False
  else
    build-depends:
      base,
      lens,
      QuickCheck                 >= 2.4,
      test-framework             >= 0.6,
      test-framework-quickcheck2 >= 0.2,
      transformers

test-suite hunit
  type: exitcode-stdio-1.0
  main-is: hunit.hs
  ghc-options: -Wall -threaded -rtsopts -with-rtsopts=-N
  hs-source-dirs: tests
  default-language: Haskell2010

if !flag(test-hunit)
    buildable: False
  else
    build-depends:
      base,
      containers,
      HUnit >= 1.2,
      lens,
      mtl,
      test-framework       >= 0.6,
      test-framework-hunit >= 0.2

-- We need this dummy test-suite to add simple-reflect to the install plan
--
-- When cabal-install's extra-packages support becomes widely available
-- (i.e. after 3.4 release), we can remove this test-suite.
test-suite doctests
  type:              exitcode-stdio-1.0
  main-is:           doctests.hs
  hs-source-dirs:    tests
  default-language:  Haskell2010

build-depends: base, deepseq, simple-reflect >= 0.3.1

-- Basic benchmarks for the uniplate-style combinators
benchmark plated
  type:             exitcode-stdio-1.0
  main-is:          plated.hs
  ghc-options:      -Wall -O2 -threaded -fdicts-cheap -funbox-strict-fields
  hs-source-dirs:   benchmarks
  default-language: Haskell2010
  build-depends:
    base,
    base-compat >=0.11.0 && <0.13,
    comonad,
    criterion,
    deepseq,
    generic-deriving,
    lens,
    transformers

if flag(benchmark-uniplate)
    build-depends: uniplate >= 1.6.7 && < 1.7
    cpp-options: -DBENCHMARK_UNIPLATE

-- Benchmarking alongside variants
benchmark alongside
  type:             exitcode-stdio-1.0
  main-is:          alongside.hs
  ghc-options:      -Wall -O2 -threaded -fdicts-cheap -funbox-strict-fields
  hs-source-dirs:   benchmarks
  default-language: Haskell2010
  build-depends:
    base,
    comonad >= 4,
    criterion,
    deepseq,
    lens,
    transformers

-- Benchmarking folds
benchmark folds
  type:             exitcode-stdio-1.0
  main-is:          folds.hs
  ghc-options:      -Wall -O2 -threaded -fdicts-cheap -funbox-strict-fields
  hs-source-dirs:   benchmarks
  default-language: Haskell2010
  build-depends:
    base,
    criterion,
    containers,
    bytestring,
    unordered-containers,
    vector,
    lens

-- Benchmarking traversals
benchmark traversals
  type:             exitcode-stdio-1.0
  main-is:          traversals.hs
  ghc-options:      -Wall -O2 -threaded -fdicts-cheap -funbox-strict-fields
  hs-source-dirs:   benchmarks
  default-language: Haskell2010
  build-depends:
    base,
    criterion,
    containers,
    deepseq,
    bytestring,
    unordered-containers,
    vector,
    lens

-- Benchmarking unsafe implementation strategies
benchmark unsafe
  type:             exitcode-stdio-1.0
  main-is:          unsafe.hs
  ghc-options:      -Wall -O2 -threaded -fdicts-cheap -funbox-strict-fields
  hs-source-dirs:   benchmarks
  default-language: Haskell2010
  build-depends:
    base,
    comonad >= 4,
    criterion >= 1,
    deepseq,
    generic-deriving,
    lens,
    transformers

Places

File lens.cabal of Package ghc-lens (Revision 5387194a77ef4b3a77d2148a107e094b)

Places