invariant 0.2.1 → 0.2.2

raw patch · 4 files changed

+41/−25 lines, 4 filesdep ~basedep ~transformersPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

Dependency ranges changed: base, transformers

API changes (from Hackage documentation)

Files

• CHANGELOG.md +5/−0
• invariant.cabal +2/−2
• src/Data/Functor/Invariant.hs +32/−20
• src/Data/Functor/Invariant/TH/Internal.hs +2/−3

@@ -1,3 +1,8 @@+# 0.2.2+* Add `genericInvmap` function (and make it the default implementation of+  `invmap` for `Invariant` instances) on GHC 7.2 or later+* Make `Tagged` instance poly-kinded+ # 0.2.1 * Add `Foldable` and `Traversable` instances for `WrappedFunctor` * Fixed build on GHC HEAD

@@ -1,5 +1,5 @@ name:                invariant-version:             0.2.1+version:             0.2.2 synopsis:            Haskell 98 invariant functors description:         Haskell 98 invariant functors category:            Control, Data@@ -9,7 +9,7 @@ bug-reports:         https://github.com/nfrisby/invariant-functors/issues author:              Nicolas Frisby <nicolas.frisby@gmail.com> maintainer:          Nicolas Frisby <nicolas.frisby@gmail.com>,-                     Ryan Scott <ryan.gl.scott@ku.edu>+                     Ryan Scott <ryan.gl.scott@gmail.com> build-type:          Simple cabal-version:       >= 1.9.2 extra-source-files:  CHANGELOG.md, README.md

@@ -3,6 +3,15 @@  #define GHC_GENERICS_OK __GLASGOW_HASKELL__ >= 702 +#if GHC_GENERICS_OK+{-# LANGUAGE DefaultSignatures #-}+{-# LANGUAGE FlexibleContexts #-}+#endif++#if __GLASGOW_HASKELL__ >= 706+{-# LANGUAGE PolyKinds #-}+#endif+ {-| Module:      Data.Functor.Invariant Copyright:   (C) 2012-2015 Nicolas Frisby, (C) 2015 Ryan Scott@@ -21,13 +30,14 @@   ( -- * @Invariant@     Invariant(..)   , invmapFunctor-  , WrappedFunctor(..)-  , invmapContravariant-  , WrappedContravariant(..) #if GHC_GENERICS_OK     -- ** @GHC.Generics@     -- $ghcgenerics+  , genericInvmap #endif+  , WrappedFunctor(..)+  , invmapContravariant+  , WrappedContravariant(..)     -- * @Invariant2@   , Invariant2(..)   , invmap2Bifunctor@@ -146,6 +156,10 @@ -- > invmap f2 f2' . invmap f1 f1' = invmap (f2 . f1) (f1' . f2') class Invariant f where   invmap :: (a -> b) -> (b -> a) -> f a -> f b+#if GHC_GENERICS_OK+  default invmap :: (Generic1 f, Invariant (Rep1 f)) => (a -> b) -> (b -> a) -> f a -> f b+  invmap = genericInvmap+#endif  -- | Every 'Functor' is also an 'Invariant' functor. invmapFunctor :: Functor f => (a -> b) -> (b -> a) -> f a -> f b@@ -739,30 +753,28 @@ instance (Invariant f, Invariant g) => Invariant ((:.:) f g) where   invmap f g (Comp1 fgp) = Comp1 $ invmap (invmap f g) (invmap g f) fgp - {- $ghcgenerics--Note: The restriction to Haskell98 prevents the full adoption of-"GHC.Generics", but we are permitted to at least provide @Invariant@-instances for the representation data types. Thus, while the \"ideal\"+With GHC 7.2 or later, 'Invariant' instances can be defined easily using GHC+generics like so:  @-  instance Invariant f => 'Invariant' (T f)-@+{-# LANGUAGE DeriveGeneric, FlexibleContexts #-} -doesn't work --- because Haskell98 precludes our use of-@-XDefaultSignatures@ in the class definition ---, the user only needs-to do slightly more work:+import Data.Functor.Invariant+import GHC.Generics -@-  import GHC.Generics (from1,to1)+data T f a = T (f a) deriving Generic1 -  instance Invariant f => 'Invariant' (T f) where-    invmap f g = 'to1' . 'invmap' f g . 'from1'+instance Invariant f => 'Invariant' (T f) @ -Note also that that instance is in fact Haskell98. Unfortunately, one-would require @-XFlexibleContexts@ in order to factor that right-hand-side out as reusable declaration polymorphic in the data type.+Be aware that generic 'Invariant' instances cannot be derived for data types+that have function arguments in which the last type parameter appears in a+position other than the result type (e.g., @data Fun a = Fun (a -> a)@). For+these, you can derive them using the "Data.Functor.Invariant.TH" module. -}++-- | A generic implementation of 'invmap'.+genericInvmap :: (Generic1 f, Invariant (Rep1 f)) => (a -> b) -> (b -> a) -> f a -> f b+genericInvmap f g = to1 . invmap f g . from1 #endif

@@ -13,9 +13,8 @@  import           Data.Function (on) import           Data.List-import qualified Data.Map as Map (fromList, lookup)+import qualified Data.Map as Map (fromList, findWithDefault) import           Data.Map (Map)-import           Data.Maybe import qualified Data.Set as Set import           Data.Set (Set) @@ -69,7 +68,7 @@  subst :: Subst -> Type -> Type subst subs (ForallT v c t) = ForallT v c $ subst subs t-subst subs t@(VarT n)      = fromMaybe t $ Map.lookup n subs+subst subs t@(VarT n)      = Map.findWithDefault t n subs subst subs (AppT t1 t2)    = AppT (subst subs t1) (subst subs t2) subst subs (SigT t k)      = SigT (subst subs t) k subst _ t                  = t