packages feed

lens 3.7.2 → 3.7.3

raw patch · 6 files changed

+36/−210 lines, 6 filesdep +natsdep +transformers-compatdep ~comonaddep ~comonad-transformersdep ~comonads-fdsetup-changed

Dependencies added: nats, transformers-compat

Dependency ranges changed: comonad, comonad-transformers, comonads-fd, semigroups, transformers

Files

CHANGELOG.markdown view
@@ -1,3 +1,9 @@+3.7.3 [maintenance release]+-----+* Removed my intra-package dependency upper bounds for my own packages. In particular this enables us to work with `semigroups` 0.9.+* Switched to `transformers-compat` to avoid having unbuilding modules at the top of the documentation, and to ease 3rd party compatibility.+* Updated `Setup.lhs` to be compatible with Cabal 1.17+ 3.7.2 [maintenance release] ----- * Bug fix for `Magnify`. It was missing functional dependencies to determine its `k` parameter from `m` or `n`.
Setup.lhs view
@@ -1,45 +1,44 @@ #!/usr/bin/runhaskell \begin{code}+{-# OPTIONS_GHC -Wall #-} module Main (main) where  import Data.List ( nub ) import Data.Version ( showVersion ) import Distribution.Package ( PackageName(PackageName), PackageId, InstalledPackageId, packageVersion, packageName )+import Distribution.PackageDescription ( PackageDescription(), TestSuite(..) ) import Distribution.Simple ( defaultMainWithHooks, UserHooks(..), simpleUserHooks ) import Distribution.Simple.Utils ( rewriteFile, createDirectoryIfMissingVerbose )-import Distribution.Verbosity ( Verbosity ) import Distribution.Simple.BuildPaths ( autogenModulesDir ) import Distribution.Simple.Setup ( BuildFlags(buildVerbosity), fromFlag )-import Distribution.Simple.LocalBuildInfo ( LocalBuildInfo(libraryConfig, testSuiteConfigs), ComponentLocalBuildInfo(componentPackageDeps) )+import Distribution.Simple.LocalBuildInfo ( withLibLBI, withTestLBI, LocalBuildInfo(), ComponentLocalBuildInfo(componentPackageDeps) )+import Distribution.Verbosity ( Verbosity ) import System.FilePath ( (</>) )  main :: IO () main = defaultMainWithHooks simpleUserHooks   { buildHook = \pkg lbi hooks flags -> do-     generateBuildModule "doctests" (fromFlag (buildVerbosity flags)) lbi+     generateBuildModule (fromFlag (buildVerbosity flags)) pkg lbi      buildHook simpleUserHooks pkg lbi hooks flags-  -- , haddockHook = \pkg lbi hooks flags -> do-  --   generateBuildModule (fromFlag (haddockVerbosity flags)) lbi-  --   haddockHook simpleUserHooks pkg lbi hooks flags   } -generateBuildModule :: String -> Verbosity -> LocalBuildInfo -> IO ()-generateBuildModule testSuite verbosity lbi = do+generateBuildModule :: Verbosity -> PackageDescription -> LocalBuildInfo -> IO ()+generateBuildModule verbosity pkg lbi = do   let dir = autogenModulesDir lbi   createDirectoryIfMissingVerbose verbosity True dir-  rewriteFile (dir </> "Build_" ++ testSuite ++ ".hs") $ unlines-    [ "module Build_" ++ testSuite ++ " where"-    , "deps :: [String]"-    , "deps = " ++ (show $ formatdeps (testDeps testSuite lbi))-    ]+  withLibLBI pkg lbi $ \_ libcfg -> do+    withTestLBI pkg lbi $ \suite suitecfg -> do+      rewriteFile (dir </> "Build_" ++ testName suite ++ ".hs") $ unlines+        [ "module Build_" ++ testName suite ++ " where"+        , "deps :: [String]"+        , "deps = " ++ (show $ formatdeps (testDeps libcfg suitecfg))+        ]   where     formatdeps = map (formatone . snd)     formatone p = case packageName p of       PackageName n -> n ++ "-" ++ showVersion (packageVersion p) -testDeps :: String -> LocalBuildInfo -> [(InstalledPackageId, PackageId)]-testDeps testSuite lbi = nub $-     maybe [] componentPackageDeps (lookup testSuite (testSuiteConfigs lbi))-  ++ maybe [] componentPackageDeps (libraryConfig lbi)+testDeps :: ComponentLocalBuildInfo -> ComponentLocalBuildInfo -> [(InstalledPackageId, PackageId)]+testDeps xs ys = nub $ componentPackageDeps xs ++ componentPackageDeps ys  \end{code}
− compat/Control/Applicative/Backwards.hs 
@@ -1,51 +0,0 @@--- |--- Module      :  Control.Applicative.Backwards--- Copyright   :  (c) Russell O'Connor 2009--- License     :  BSD-style (see the file LICENSE)------ Maintainer  :  libraries@haskell.org--- Stability   :  experimental--- Portability :  portable------ Making functors with an 'Applicative' instance that performs actions--- in the reverse order.------ NB: This module is only included in @lens@ for backwards compatibility with--- @transformers@ versions before 3.0.-module Control.Applicative.Backwards where--import Prelude hiding (foldr, foldr1, foldl, foldl1)-import Control.Applicative-import Data.Foldable-import Data.Traversable---- | The same functor, but with an 'Applicative' instance that performs--- actions in the reverse order.-newtype Backwards f a = Backwards { forwards :: f a }---- | Derived instance.-instance (Functor f) => Functor (Backwards f) where-    fmap f (Backwards a) = Backwards (fmap f a)---- | Apply @f@-actions in the reverse order.-instance (Applicative f) => Applicative (Backwards f) where-    pure a = Backwards (pure a)-    Backwards f <*> Backwards a = Backwards (a <**> f)---- | Try alternatives in the same order as @f@.-instance (Alternative f) => Alternative (Backwards f) where-    empty = Backwards empty-    Backwards x <|> Backwards y = Backwards (x <|> y)---- | Derived instance.-instance (Foldable f) => Foldable (Backwards f) where-    foldMap f (Backwards t) = foldMap f t-    foldr f z (Backwards t) = foldr f z t-    foldl f z (Backwards t) = foldl f z t-    foldr1 f (Backwards t) = foldl1 f t-    foldl1 f (Backwards t) = foldr1 f t---- | Derived instance.-instance (Traversable f) => Traversable (Backwards f) where-    traverse f (Backwards t) = fmap Backwards (traverse f t)-    sequenceA (Backwards t) = fmap Backwards (sequenceA t)
− compat/Control/Applicative/Lift.hs 
@@ -1,71 +0,0 @@--- |--- Module      :  Control.Applicative.Lift--- Copyright   :  (c) Ross Paterson 2010--- License     :  BSD-style (see the file LICENSE)------ Maintainer  :  ross@soi.city.ac.uk--- Stability   :  experimental--- Portability :  portable------ Adding a new kind of pure computation to an applicative functor.------ NB: This module is only included in @lens@ for backwards compatibility with--- @transformers@ versions before 3.0.--module Control.Applicative.Lift (-    Lift(..), unLift,-    -- * Collecting errors-    Errors, failure-  ) where--import Control.Applicative-import Data.Foldable (Foldable(foldMap))-import Data.Functor.Constant-import Data.Monoid-import Data.Traversable (Traversable(traverse))---- | Applicative functor formed by adding pure computations to a given--- applicative functor.-data Lift f a = Pure a | Other (f a)--instance (Functor f) => Functor (Lift f) where-    fmap f (Pure x) = Pure (f x)-    fmap f (Other y) = Other (fmap f y)--instance (Foldable f) => Foldable (Lift f) where-    foldMap f (Pure x) = f x-    foldMap f (Other y) = foldMap f y--instance (Traversable f) => Traversable (Lift f) where-    traverse f (Pure x) = Pure <$> f x-    traverse f (Other y) = Other <$> traverse f y---- | A combination is 'Pure' only if both parts are.-instance (Applicative f) => Applicative (Lift f) where-    pure = Pure-    Pure f <*> Pure x = Pure (f x)-    Pure f <*> Other y = Other (f <$> y)-    Other f <*> Pure x = Other (($ x) <$> f)-    Other f <*> Other y = Other (f <*> y)---- | A combination is 'Pure' only either part is.-instance Alternative f => Alternative (Lift f) where-    empty = Other empty-    Pure x <|> _ = Pure x-    Other _ <|> Pure y = Pure y-    Other x <|> Other y = Other (x <|> y)---- | Projection to the other functor.-unLift :: Applicative f => Lift f a -> f a-unLift (Pure x) = pure x-unLift (Other e) = e---- | An applicative functor that collects a monoid (e.g. lists) of errors.--- A sequence of computations fails if any of its components do, but--- unlike monads made with 'ErrorT' from "Control.Monad.Trans.Error",--- these computations continue after an error, collecting all the errors.-type Errors e = Lift (Constant e)---- | Report an error.-failure :: Monoid e => e -> Errors e a-failure e = Other (Constant e)
− compat/Data/Functor/Reverse.hs 
@@ -1,57 +0,0 @@--- |--- Module      :  Data.Functor.Reverse--- Copyright   :  (c) Russell O'Connor 2009--- License     :  BSD-style (see the file LICENSE)------ Maintainer  :  libraries@haskell.org--- Stability   :  experimental--- Portability :  portable------ Making functors whose elements are notionally in the reverse order--- from the original functor.------ /NB:/ Note this module is only included in @lens@ for backwards--- compatibility with older @containers@ versions.--module Data.Functor.Reverse where--import Control.Applicative.Backwards--import Prelude hiding (foldr, foldr1, foldl, foldl1)-import Control.Applicative-import Data.Foldable-import Data.Traversable-import Data.Monoid---- | The same functor, but with 'Foldable' and 'Traversable' instances--- that process the elements in the reverse order.-newtype Reverse f a = Reverse { getReverse :: f a }---- | Derived instance.-instance (Functor f) => Functor (Reverse f) where-    fmap f (Reverse a) = Reverse (fmap f a)---- | Derived instance.-instance (Applicative f) => Applicative (Reverse f) where-    pure a = Reverse (pure a)-    Reverse f <*> Reverse a = Reverse (f <*> a)---- | Derived instance.-instance (Alternative f) => Alternative (Reverse f) where-    empty = Reverse empty-    Reverse x <|> Reverse y = Reverse (x <|> y)---- | Fold from right to left.-instance (Foldable f) => Foldable (Reverse f) where-    foldMap f (Reverse t) = getDual (foldMap (Dual . f) t)-    foldr f z (Reverse t) = foldl (flip f) z t-    foldl f z (Reverse t) = foldr (flip f) z t-    foldr1 f (Reverse t) = foldl1 (flip f) t-    foldl1 f (Reverse t) = foldr1 (flip f) t---- | Traverse from right to left.-instance (Traversable f) => Traversable (Reverse f) where-    traverse f (Reverse t) =-        fmap Reverse . forwards $ traverse (Backwards . f) t-    sequenceA (Reverse t) =-        fmap Reverse . forwards $ sequenceA (fmap Backwards t)
lens.cabal view
@@ -1,6 +1,6 @@ name:          lens category:      Data, Lenses-version:       3.7.2+version:       3.7.3 license:       BSD3 cabal-version: >= 1.8 license-file:  LICENSE@@ -157,35 +157,35 @@   default: True   manual: True -flag transformers2+flag old-semigroups   default: False   manual: False + library   build-depends:     base                 >= 4.3      && < 5,     bytestring           >= 0.9.1.10 && < 0.11,-    comonad              == 3.0.*,-    comonad-transformers == 3.0.*,-    comonads-fd          == 3.0.*,+    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,-    semigroups           >= 0.8.4    && < 0.9,     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(transformers2)-    build-depends:  transformers >= 0.2 && < 0.3-    hs-source-dirs: compat-    exposed-modules:-      Control.Applicative.Backwards-      Control.Applicative.Lift-      Data.Functor.Reverse+  if flag(old-semigroups)+    build-depends:+      semigroups >= 0.8.4 && < 0.9   else-    build-depends: transformers >= 0.3 && < 0.4+    build-depends:+      nats >= 0.1,+      semigroups >= 0.9    exposed-modules:     Control.Exception.Lens