packages feed

base-compat 0.7.0 → 0.7.1

raw patch · 12 files changed

+88/−7 lines, 12 filesPVP ok

version bump matches the API change (PVP)

API changes (from Hackage documentation)

+ Control.Applicative.Compat: (*>) :: Applicative f => f a -> f b -> f b
+ Control.Applicative.Compat: (<*) :: Applicative f => f a -> f b -> f a
+ Control.Applicative.Compat: (<*>) :: Applicative f => f (a -> b) -> f a -> f b
+ Control.Applicative.Compat: (<|>) :: Alternative f => f a -> f a -> f a
+ Control.Applicative.Compat: WrapArrow :: a b c -> WrappedArrow b c
+ Control.Applicative.Compat: ZipList :: [a] -> ZipList a
+ Control.Applicative.Compat: class Applicative f => Alternative (f :: * -> *)
+ Control.Applicative.Compat: class Functor f => Applicative (f :: * -> *)
+ Control.Applicative.Compat: empty :: Alternative f => f a
+ Control.Applicative.Compat: getZipList :: ZipList a -> [a]
+ Control.Applicative.Compat: many :: Alternative f => f a -> f [a]
+ Control.Applicative.Compat: newtype WrappedArrow (a :: * -> * -> *) b c :: (* -> * -> *) -> * -> * -> *
+ Control.Applicative.Compat: newtype ZipList a :: * -> *
+ Control.Applicative.Compat: pure :: Applicative f => a -> f a
+ Control.Applicative.Compat: some :: Alternative f => f a -> f [a]
+ Control.Applicative.Compat: unwrapArrow :: WrappedArrow b c -> a b c
+ Control.Exception.Compat: ErrorCall :: String -> ErrorCall
+ Control.Exception.Compat: newtype ErrorCall :: *
+ Control.Monad.Compat: (>>) :: Monad m => m a -> m b -> m b
+ Control.Monad.Compat: (>>=) :: Monad m => m a -> (a -> m b) -> m b
+ Control.Monad.Compat: class Monad (m :: * -> *)
+ Control.Monad.Compat: class Monad m => MonadPlus (m :: * -> *)
+ Control.Monad.Compat: fail :: Monad m => String -> m a
+ Control.Monad.Compat: mplus :: MonadPlus m => m a -> m a -> m a
+ Control.Monad.Compat: mzero :: MonadPlus m => m a
+ Control.Monad.Compat: return :: Monad m => a -> m a
+ Data.Bits.Compat: (.&.) :: Bits a => a -> a -> a
+ Data.Bits.Compat: (.|.) :: Bits a => a -> a -> a
+ Data.Bits.Compat: bit :: Bits a => Int -> a
+ Data.Bits.Compat: bitSize :: Bits a => a -> Int
+ Data.Bits.Compat: bitSizeMaybe :: Bits a => a -> Maybe Int
+ Data.Bits.Compat: class Eq a => Bits a
+ Data.Bits.Compat: clearBit :: Bits a => a -> Int -> a
+ Data.Bits.Compat: complement :: Bits a => a -> a
+ Data.Bits.Compat: complementBit :: Bits a => a -> Int -> a
+ Data.Bits.Compat: isSigned :: Bits a => a -> Bool
+ Data.Bits.Compat: popCount :: Bits a => a -> Int
+ Data.Bits.Compat: rotate :: Bits a => a -> Int -> a
+ Data.Bits.Compat: rotateL :: Bits a => a -> Int -> a
+ Data.Bits.Compat: rotateR :: Bits a => a -> Int -> a
+ Data.Bits.Compat: setBit :: Bits a => a -> Int -> a
+ Data.Bits.Compat: shift :: Bits a => a -> Int -> a
+ Data.Bits.Compat: shiftL :: Bits a => a -> Int -> a
+ Data.Bits.Compat: shiftR :: Bits a => a -> Int -> a
+ Data.Bits.Compat: testBit :: Bits a => a -> Int -> Bool
+ Data.Bits.Compat: unsafeShiftL :: Bits a => a -> Int -> a
+ Data.Bits.Compat: unsafeShiftR :: Bits a => a -> Int -> a
+ Data.Bits.Compat: xor :: Bits a => a -> a -> a
+ Data.Bits.Compat: zeroBits :: Bits a => a
+ Data.Functor.Compat: (<$) :: Functor f => a -> f b -> f a
+ Data.Functor.Compat: class Functor (f :: * -> *)
+ Data.Functor.Compat: fmap :: Functor f => (a -> b) -> f a -> f b
+ Data.Monoid.Compat: Alt :: f a -> Alt f a
+ Data.Monoid.Compat: getAlt :: Alt f a -> f a
+ Data.Monoid.Compat: instance Alternative f => Alternative (Alt f)
+ Data.Monoid.Compat: instance Alternative f => Monoid (Alt f a)
+ Data.Monoid.Compat: instance Applicative f => Applicative (Alt f)
+ Data.Monoid.Compat: instance Constructor C1_0Alt
+ Data.Monoid.Compat: instance Datatype D1Alt
+ Data.Monoid.Compat: instance Enum (f a) => Enum (Alt f a)
+ Data.Monoid.Compat: instance Eq (f a) => Eq (Alt f a)
+ Data.Monoid.Compat: instance Functor f => Functor (Alt f)
+ Data.Monoid.Compat: instance Generic (Alt f a)
+ Data.Monoid.Compat: instance Generic1 (Alt f)
+ Data.Monoid.Compat: instance Monad m => Monad (Alt m)
+ Data.Monoid.Compat: instance MonadPlus m => MonadPlus (Alt m)
+ Data.Monoid.Compat: instance Num (f a) => Num (Alt f a)
+ Data.Monoid.Compat: instance Ord (f a) => Ord (Alt f a)
+ Data.Monoid.Compat: instance Read (f a) => Read (Alt f a)
+ Data.Monoid.Compat: instance Selector S1_0_0Alt
+ Data.Monoid.Compat: instance Show (f a) => Show (Alt f a)
+ Data.Monoid.Compat: newtype Alt f a
+ Data.Ord.Compat: (<) :: Ord a => a -> a -> Bool
+ Data.Ord.Compat: (<=) :: Ord a => a -> a -> Bool
+ Data.Ord.Compat: (>) :: Ord a => a -> a -> Bool
+ Data.Ord.Compat: (>=) :: Ord a => a -> a -> Bool
+ Data.Ord.Compat: Down :: a -> Down a
+ Data.Ord.Compat: class Eq a => Ord a
+ Data.Ord.Compat: compare :: Ord a => a -> a -> Ordering
+ Data.Ord.Compat: max :: Ord a => a -> a -> a
+ Data.Ord.Compat: min :: Ord a => a -> a -> a
+ Data.Ord.Compat: newtype Down a :: * -> *
+ Data.Version.Compat: Version :: [Int] -> [String] -> Version
+ Data.Version.Compat: data Version :: *
+ Data.Version.Compat: versionBranch :: Version -> [Int]
+ Data.Version.Compat: versionTags :: Version -> [String]
+ GHC.Generics.Compat: (:*:) :: f p -> g p -> (:*:) p
+ GHC.Generics.Compat: Comp1 :: f (g p) -> (:.:) p
+ GHC.Generics.Compat: K1 :: c -> K1 i c p
+ GHC.Generics.Compat: L1 :: f p -> (:+:) p
+ GHC.Generics.Compat: M1 :: f p -> M1 i c p
+ GHC.Generics.Compat: Par1 :: p -> Par1 p
+ GHC.Generics.Compat: R1 :: g p -> (:+:) p
+ GHC.Generics.Compat: Rec1 :: f p -> Rec1 p
+ GHC.Generics.Compat: U1 :: U1 p
+ GHC.Generics.Compat: class Generic a where type family Rep a :: * -> *
+ GHC.Generics.Compat: class Generic1 (f :: * -> *) where type family Rep1 (f :: * -> *) :: * -> *
+ GHC.Generics.Compat: data (:*:) (f :: * -> *) (g :: * -> *) p :: (* -> *) -> (* -> *) -> * -> *
+ GHC.Generics.Compat: data U1 p :: * -> *
+ GHC.Generics.Compat: from :: Generic a => a -> Rep a x
+ GHC.Generics.Compat: from1 :: Generic1 f => f a -> Rep1 f a
+ GHC.Generics.Compat: newtype (:.:) (f :: * -> *) (g :: * -> *) p :: (* -> *) -> (* -> *) -> * -> *
+ GHC.Generics.Compat: newtype K1 i c p :: * -> * -> * -> *
+ GHC.Generics.Compat: newtype M1 i c (f :: * -> *) p :: * -> * -> (* -> *) -> * -> *
+ GHC.Generics.Compat: newtype Par1 p :: * -> *
+ GHC.Generics.Compat: newtype Rec1 (f :: * -> *) p :: (* -> *) -> * -> *
+ GHC.Generics.Compat: to :: Generic a => Rep a x -> a
+ GHC.Generics.Compat: to1 :: Generic1 f => Rep1 f a -> f a
+ GHC.Generics.Compat: unComp1 :: (:.:) p -> f (g p)
+ GHC.Generics.Compat: unK1 :: K1 i c p -> c
+ GHC.Generics.Compat: unM1 :: M1 i c p -> f p
+ GHC.Generics.Compat: unPar1 :: Par1 p -> p
+ GHC.Generics.Compat: unRec1 :: Rec1 p -> f p
+ System.Console.GetOpt.Compat: NoArg :: a -> ArgDescr a
+ System.Console.GetOpt.Compat: OptArg :: (Maybe String -> a) -> String -> ArgDescr a
+ System.Console.GetOpt.Compat: Option :: [Char] -> [String] -> ArgDescr a -> String -> OptDescr a
+ System.Console.GetOpt.Compat: Permute :: ArgOrder a
+ System.Console.GetOpt.Compat: ReqArg :: (String -> a) -> String -> ArgDescr a
+ System.Console.GetOpt.Compat: RequireOrder :: ArgOrder a
+ System.Console.GetOpt.Compat: ReturnInOrder :: (String -> a) -> ArgOrder a
+ System.Console.GetOpt.Compat: data ArgDescr a :: * -> *
+ System.Console.GetOpt.Compat: data ArgOrder a :: * -> *
+ System.Console.GetOpt.Compat: data OptDescr a :: * -> *

Files

LICENSE view
@@ -1,4 +1,4 @@-Copyright (c) 2012-2015 Simon Hengel <sol@typeful.net>+Copyright (c) 2012-2015 Simon Hengel <sol@typeful.net> and Ryan Scott <ryan.gl.scott@ku.edu>  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal
base-compat.cabal view
@@ -1,9 +1,10 @@ name:             base-compat-version:          0.7.0+version:          0.7.1 license:          MIT license-file:     LICENSE copyright:        (c) 2012-2015 Simon Hengel,-                  (c) 2014 João Cristóvão+                  (c) 2014 João Cristóvão,+                  (c) 2015 Ryan Scott author:           Simon Hengel <sol@typeful.net>, João Cristóvão <jmacristovao@gmail.com> maintainer:       Simon Hengel <sol@typeful.net>, João Cristóvão <jmacristovao@gmail.com> build-type:       Simple
src/Control/Applicative/Compat.hs view
@@ -2,8 +2,12 @@ {-# OPTIONS_GHC -fno-warn-orphans #-} module Control.Applicative.Compat (   module Base+, Applicative(..)+, Alternative(..) , Const(..) , WrappedMonad(..)+, WrappedArrow(..)+, ZipList(..) ) where import Control.Applicative as Base
src/Control/Exception/Compat.hs view
@@ -2,6 +2,7 @@ {-# OPTIONS_GHC -fno-warn-orphans #-} module Control.Exception.Compat (   module Base+, ErrorCall(..) ) where  import Control.Exception as Base
src/Control/Monad/Compat.hs view
@@ -1,5 +1,7 @@ module Control.Monad.Compat (   module Base+, Monad(..)+, MonadPlus(..) , void , (<$!>) ) where
src/Data/Bits/Compat.hs view
@@ -1,6 +1,7 @@ {-# OPTIONS_GHC -fno-warn-orphans #-} module Data.Bits.Compat (   module Base+, Bits(..) ) where import Data.Bits as Base
src/Data/Functor/Compat.hs view
@@ -1,5 +1,6 @@ module Data.Functor.Compat (   module Base+, Functor(..) , ($>) , void ) where
src/Data/Monoid/Compat.hs view
@@ -1,4 +1,13 @@ {-# LANGUAGE GeneralizedNewtypeDeriving, StandaloneDeriving #-}++#if __GLASGOW_HASKELL__ >= 702+{-# LANGUAGE DeriveGeneric #-}+#endif++#if __GLASGOW_HASKELL__ >= 706+{-# LANGUAGE PolyKinds #-}+#endif+ {-# OPTIONS_GHC -fno-warn-orphans #-} module Data.Monoid.Compat (         -- * Monoid typeclass@@ -15,14 +24,24 @@         -- * Maybe wrappers         -- $MaybeExamples         First(..),-        Last(..)+        Last(..),+        -- * Alternative wrapper+        Alt(..)   ) where  import Data.Monoid as Base -#if !MIN_VERSION_base(4,7,0)+-- To import orphan Generic instances for Sum and Product import GHC.Generics.Compat ()-import Prelude.Compat (Num)++#if !MIN_VERSION_base(4,8,0)+import Control.Applicative+import Control.Monad+import Prelude.Compat++# if __GLASGOW_HASKELL__ >= 702+import GHC.Generics+# endif #endif  #if !MIN_VERSION_base(4,5,0)@@ -39,4 +58,31 @@ #if !MIN_VERSION_base(4,7,0) deriving instance Num a => Num (Sum a) deriving instance Num a => Num (Product a)+#endif++#if !MIN_VERSION_base(4,8,0)+-- | Monoid under '<|>'.+--+-- /Since: 4.8.0.0/+newtype Alt f a = Alt {getAlt :: f a}+  deriving ( Read, Show, Eq, Ord, Num, Enum+# if __GLASGOW_HASKELL__ >= 702+           , Generic+# endif+# if __GLASGOW_HASKELL__ >= 708+           , Generic1+# endif+           )++-- To work around a GHC 7.6 bug, we'll use StandaloneDeriving for generalized+-- derivations that involve higher-kinded typeclasses.+deriving instance Functor f => Functor (Alt f)+deriving instance Applicative f => Applicative (Alt f)+deriving instance Monad m => Monad (Alt m)+deriving instance Alternative f => Alternative (Alt f)+deriving instance MonadPlus m => MonadPlus (Alt m)++instance Alternative f => Monoid (Alt f a) where+    mempty = Alt empty+    mappend (Alt x) (Alt y) = Alt (x <|> y) #endif
src/Data/Ord/Compat.hs view
@@ -2,12 +2,21 @@ {-# OPTIONS_GHC -fno-warn-orphans #-} module Data.Ord.Compat (   module Base+, Ord(..)+, Down(..) ) where import Data.Ord as Base -#if MIN_VERSION_base(4,6,0) && !MIN_VERSION_base(4,7,0)+#if !MIN_VERSION_base(4,7,0) import Prelude.Compat+#endif +#if MIN_VERSION_base(4,6,0) && !MIN_VERSION_base(4,7,0) deriving instance Read a => Read (Down a) deriving instance Show a => Show (Down a)+#elif !MIN_VERSION_base(4,6,0)+newtype Down a = Down a deriving (Eq, Show, Read)++instance Ord a => Ord (Down a) where+    compare (Down x) (Down y) = y `compare` x #endif
src/Data/Version/Compat.hs view
@@ -2,6 +2,7 @@ {-# OPTIONS_GHC -fno-warn-orphans #-} module Data.Version.Compat (   module Base+, Version(..) , makeVersion ) where import Data.Version as Base
src/GHC/Generics/Compat.hs view
@@ -11,6 +11,18 @@ ) where #else   module Base+  -- * Generic representation types+, U1(..)+, Par1(..)+, Rec1(..)+, K1(..)+, M1(..)+, (:+:)(..)+, (:*:)(..)+, (:.:)(..)+  -- * Generic type classes+, Generic(..)+, Generic1(..) ) where import           GHC.Generics as Base
src/System/Console/GetOpt/Compat.hs view
@@ -1,6 +1,9 @@ {-# OPTIONS_GHC -fno-warn-orphans #-} module System.Console.GetOpt.Compat (   module Base+, ArgOrder(..)+, OptDescr(..)+, ArgDescr(..) ) where import System.Console.GetOpt as Base