Hello community, here is the log from the commit of package ghc-mono-traversable for openSUSE:Factory checked in at 2019-02-17 12:20:13 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/ghc-mono-traversable (Old) and /work/SRC/openSUSE:Factory/.ghc-mono-traversable.new.28833 (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Package is "ghc-mono-traversable" Sun Feb 17 12:20:13 2019 rev:17 rq:674301 version:1.0.11.0 Changes: -------- --- /work/SRC/openSUSE:Factory/ghc-mono-traversable/ghc-mono-traversable.changes 2018-12-28 12:35:25.767958970 +0100 +++ /work/SRC/openSUSE:Factory/.ghc-mono-traversable.new.28833/ghc-mono-traversable.changes 2019-02-17 12:20:13.604218942 +0100 @@ -1,0 +2,9 @@ +Sun Feb 3 03:02:41 UTC 2019 - psimons@suse.com + +- Update mono-traversable to version 1.0.11.0. + ## 1.0.11.0 + + * Adding monomorphic instances for GHC.Generics and Data.Proxy types + [#175](https://github.com/snoyberg/mono-traversable/issues/175) + +------------------------------------------------------------------- Old: ---- mono-traversable-1.0.10.0.tar.gz mono-traversable.cabal New: ---- mono-traversable-1.0.11.0.tar.gz ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ ghc-mono-traversable.spec ++++++ --- /var/tmp/diff_new_pack.j8PsR2/_old 2019-02-17 12:20:14.116218801 +0100 +++ /var/tmp/diff_new_pack.j8PsR2/_new 2019-02-17 12:20:14.120218800 +0100 @@ -1,7 +1,7 @@ # # spec file for package ghc-mono-traversable # -# Copyright (c) 2018 SUSE LINUX GmbH, Nuernberg, Germany. +# Copyright (c) 2019 SUSE LINUX GmbH, Nuernberg, Germany. # # All modifications and additions to the file contributed by third parties # remain the property of their copyright owners, unless otherwise agreed @@ -19,14 +19,13 @@ %global pkg_name mono-traversable %bcond_with tests Name: ghc-%{pkg_name} -Version: 1.0.10.0 +Version: 1.0.11.0 Release: 0 Summary: Type classes for mapping, folding, and traversing monomorphic containers License: MIT Group: Development/Libraries/Haskell URL: https://hackage.haskell.org/package/%{pkg_name} Source0: https://hackage.haskell.org/package/%{pkg_name}-%{version}/%{pkg_name}-%{version}.tar.gz -Source1: https://hackage.haskell.org/package/%{pkg_name}-%{version}/revision/1.cabal#/%{pkg_name}.cabal BuildRequires: ghc-Cabal-devel BuildRequires: ghc-bytestring-devel BuildRequires: ghc-containers-devel @@ -63,7 +62,6 @@ %prep %setup -q -n %{pkg_name}-%{version} -cp -p %{SOURCE1} %{pkg_name}.cabal %build %ghc_lib_build ++++++ mono-traversable-1.0.10.0.tar.gz -> mono-traversable-1.0.11.0.tar.gz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/mono-traversable-1.0.10.0/ChangeLog.md new/mono-traversable-1.0.11.0/ChangeLog.md --- old/mono-traversable-1.0.10.0/ChangeLog.md 2018-12-20 06:25:46.000000000 +0100 +++ new/mono-traversable-1.0.11.0/ChangeLog.md 2019-02-02 17:09:51.000000000 +0100 @@ -1,3 +1,8 @@ +## 1.0.11.0 + +* Adding monomorphic instances for GHC.Generics and Data.Proxy types + [#175](https://github.com/snoyberg/mono-traversable/issues/175) + ## 1.0.10.0 * Make index work on negative indices diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/mono-traversable-1.0.10.0/mono-traversable.cabal new/mono-traversable-1.0.11.0/mono-traversable.cabal --- old/mono-traversable-1.0.10.0/mono-traversable.cabal 2018-12-20 06:25:47.000000000 +0100 +++ new/mono-traversable-1.0.11.0/mono-traversable.cabal 2019-02-02 17:10:44.000000000 +0100 @@ -1,13 +1,13 @@ cabal-version: 1.12 --- This file has been generated from package.yaml by hpack version 0.30.0. +-- This file has been generated from package.yaml by hpack version 0.31.1. -- -- see: https://github.com/sol/hpack -- --- hash: dd6993a12a11dc33b47bd2f3d81ac5ab62e3168ad8a01582458b74b64f971031 +-- hash: d58c5bc6fce9bf509cf559fa04639076650c2e3c940a7a1d113ea8f647a49335 name: mono-traversable -version: 1.0.10.0 +version: 1.0.11.0 synopsis: Type classes for mapping, folding, and traversing monomorphic containers description: Please see the README at https://www.stackage.org/package/mono-traversable category: Data @@ -33,7 +33,7 @@ build-depends: base >=4.9 && <5 , bytestring >=0.9 - , containers >=0.4 + , containers >=0.5.8 , hashable , split >=0.2 , text >=0.11 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/mono-traversable-1.0.10.0/src/Data/MonoTraversable.hs new/mono-traversable-1.0.11.0/src/Data/MonoTraversable.hs --- old/mono-traversable-1.0.10.0/src/Data/MonoTraversable.hs 2018-10-04 15:18:41.000000000 +0200 +++ new/mono-traversable-1.0.11.0/src/Data/MonoTraversable.hs 2019-02-02 17:09:51.000000000 +0100 @@ -4,6 +4,7 @@ {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE TypeFamilies #-} +{-# LANGUAGE TypeOperators #-} {-# LANGUAGE UndecidableInstances #-} -- | Type classes mirroring standard typeclasses, but working with monomorphic containers. -- @@ -37,12 +38,14 @@ import Data.Functor import Data.Maybe (fromMaybe) import Data.Monoid (Monoid (..), Any (..), All (..)) +import Data.Proxy import qualified Data.Text as T import qualified Data.Text.Lazy as TL import Data.Traversable import Data.Word (Word8) import Data.Int (Int, Int64) import GHC.Exts (build) +import GHC.Generics ((:.:), (:*:), (:+:)(..), K1(..), M1(..), Par1(..), Rec1(..), U1(..), V1(..)) import Prelude (Bool (..), const, Char, flip, IO, Maybe (..), Either (..), (+), Integral, Ordering (..), compare, fromIntegral, Num, (>=), (==), seq, otherwise, Eq, Ord, (-), (*)) @@ -137,6 +140,16 @@ type instance Element (U.Vector a) = a type instance Element (VS.Vector a) = a type instance Element (Arg a b) = b +type instance Element ((f :.: g) a) = a +type instance Element ((f :*: g) a) = a +type instance Element ((f :+: g) a) = a +type instance Element (K1 i c a) = a +type instance Element (M1 i c f a) = a +type instance Element (Rec1 f a) = a +type instance Element (Par1 a) = a +type instance Element (U1 a) = a +type instance Element (V1 a) = a +type instance Element (Proxy a) = a -- | Monomorphic containers that can be mapped over. class MonoFunctor mono where @@ -194,6 +207,26 @@ instance Functor m => MonoFunctor (ContT r m a) instance (Functor f, Functor g) => MonoFunctor (Compose f g a) instance (Functor f, Functor g) => MonoFunctor (Product f g a) +-- | @since 1.0.11.0 +instance (Functor f, Functor g) => MonoFunctor ((f :.: g) a) +-- | @since 1.0.11.0 +instance (Functor f, Functor g) => MonoFunctor ((f :*: g) a) +-- | @since 1.0.11.0 +instance (Functor f, Functor g) => MonoFunctor ((f :+: g) a) +-- | @since 1.0.11.0 +instance MonoFunctor (K1 i c a) +-- | @since 1.0.11.0 +instance Functor f => MonoFunctor (M1 i c f a) +-- | @since 1.0.11.0 +instance Functor f => MonoFunctor (Rec1 f a) +-- | @since 1.0.11.0 +instance MonoFunctor (Par1 a) +-- | @since 1.0.11.0 +instance MonoFunctor (U1 a) +-- | @since 1.0.11.0 +instance MonoFunctor (V1 a) +-- | @since 1.0.11.0 +instance MonoFunctor (Proxy a) instance U.Unbox a => MonoFunctor (U.Vector a) where omap = U.map {-# INLINE omap #-} @@ -771,6 +804,26 @@ instance F.Foldable f => MonoFoldable (Strict.WriterT w f a) instance (F.Foldable f, F.Foldable g) => MonoFoldable (Compose f g a) instance (F.Foldable f, F.Foldable g) => MonoFoldable (Product f g a) +-- | @since 1.0.11.0 +instance (F.Foldable f, F.Foldable g) => MonoFoldable ((f :.: g) a) +-- | @since 1.0.11.0 +instance (F.Foldable f, F.Foldable g) => MonoFoldable ((f :*: g) a) +-- | @since 1.0.11.0 +instance (F.Foldable f, F.Foldable g) => MonoFoldable ((f :+: g) a) +-- | @since 1.0.11.0 +instance MonoFoldable (K1 i c a) +-- | @since 1.0.11.0 +instance F.Foldable f => MonoFoldable (M1 i c f a) +-- | @since 1.0.11.0 +instance F.Foldable f => MonoFoldable (Rec1 f a) +-- | @since 1.0.11.0 +instance MonoFoldable (Par1 a) +-- | @since 1.0.11.0 +instance MonoFoldable (U1 a) +-- | @since 1.0.11.0 +instance MonoFoldable (V1 a) +-- | @since 1.0.11.0 +instance MonoFoldable (Proxy a) -- | Safe version of 'headEx'. -- @@ -804,14 +857,14 @@ -- | Are __all__ of the elements 'True'? -- --- Since 0.6.0 +-- @since 0.6.0 oand :: (Element mono ~ Bool, MonoFoldable mono) => mono -> Bool oand = oall id {-# INLINE oand #-} -- | Are __any__ of the elements 'True'? -- --- Since 0.6.0 +-- @since 0.6.0 oor :: (Element mono ~ Bool, MonoFoldable mono) => mono -> Bool oor = oany id {-# INLINE oor #-} @@ -1049,6 +1102,26 @@ instance Traversable f => MonoTraversable (Strict.WriterT w f a) instance (Traversable f, Traversable g) => MonoTraversable (Compose f g a) instance (Traversable f, Traversable g) => MonoTraversable (Product f g a) +-- | @since 1.0.11.0 +instance (Traversable f, Traversable g) => MonoTraversable ((f :.: g) a) +-- | @since 1.0.11.0 +instance (Traversable f, Traversable g) => MonoTraversable ((f :*: g) a) +-- | @since 1.0.11.0 +instance (Traversable f, Traversable g) => MonoTraversable ((f :+: g) a) +-- | @since 1.0.11.0 +instance MonoTraversable (K1 i c a) +-- | @since 1.0.11.0 +instance Traversable f => MonoTraversable (M1 i c f a) +-- | @since 1.0.11.0 +instance Traversable f => MonoTraversable (Rec1 f a) +-- | @since 1.0.11.0 +instance MonoTraversable (Par1 a) +-- | @since 1.0.11.0 +instance MonoTraversable (U1 a) +-- | @since 1.0.11.0 +instance MonoTraversable (V1 a) +-- | @since 1.0.11.0 +instance MonoTraversable (Proxy a) -- | 'ofor' is 'otraverse' with its arguments flipped. ofor :: (MonoTraversable mono, Applicative f) => mono -> (Element mono -> f (Element mono)) -> f mono @@ -1070,7 +1143,7 @@ -- expected type. It is provided mainly for integration with the @foldl@ -- package, to be used in conjunction with @purely@. -- --- Since 0.3.1 +-- @since 0.3.1 ofoldlUnwrap :: MonoFoldable mono => (x -> Element mono -> x) -> x -> (x -> b) -> mono -> b ofoldlUnwrap f x unwrap mono = unwrap (ofoldl' f x mono) @@ -1080,7 +1153,7 @@ -- Similar to 'foldlUnwrap', but allows monadic actions. To be used with -- @impurely@ from @foldl@. -- --- Since 0.3.1 +-- @since 0.3.1 ofoldMUnwrap :: (Monad m, MonoFoldable mono) => (x -> Element mono -> m x) -> m x -> (x -> m b) -> mono -> m b ofoldMUnwrap f mx unwrap mono = do @@ -1142,6 +1215,20 @@ instance MonoPointed (ContT r m a) instance (Applicative f, Applicative g) => MonoPointed (Compose f g a) instance (Applicative f, Applicative g) => MonoPointed (Product f g a) +-- | @since 1.0.11.0 +instance (Applicative f, Applicative g) => MonoPointed ((f :.: g) a) +-- | @since 1.0.11.0 +instance (Applicative f, Applicative g) => MonoPointed ((f :*: g) a) +-- | @since 1.0.11.0 +instance Applicative f => MonoPointed (M1 i c f a) +-- | @since 1.0.11.0 +instance Applicative f => MonoPointed (Rec1 f a) +-- | @since 1.0.11.0 +instance MonoPointed (Par1 a) +-- | @since 1.0.11.0 +instance MonoPointed (U1 a) +-- | @since 1.0.11.0 +instance MonoPointed (Proxy a) -- Not Applicative instance MonoPointed (Seq a) where @@ -1189,6 +1276,10 @@ instance MonoPointed (Tree a) where opoint a = Node a [] {-# INLINE opoint #-} +-- | @since 1.0.11.0 +instance (Applicative f, Applicative g) => MonoPointed ((f :+: g) a) where + opoint = R1 . pure + {-# INLINE opoint #-} -- | Typeclass for monomorphic containers where it is always okay to