base-compat 0.10.5 → 0.11.0

raw patch · 7 files changed

+101/−6 lines, 7 filesPVP ok

version bump matches the API change (PVP)

API changes (from Hackage documentation)

- Control.Exception.Compat: AllocationLimitExceeded :: AllocationLimitExceeded

- Control.Exception.Compat: AssertionFailed :: String -> AssertionFailed

- Control.Exception.Compat: BlockedIndefinitelyOnMVar :: BlockedIndefinitelyOnMVar

- Control.Exception.Compat: BlockedIndefinitelyOnSTM :: BlockedIndefinitelyOnSTM

- Control.Exception.Compat: CompactionFailed :: String -> CompactionFailed

- Control.Exception.Compat: Deadlock :: Deadlock

- Control.Exception.Compat: Denormal :: ArithException

- Control.Exception.Compat: DivideByZero :: ArithException

- Control.Exception.Compat: ErrorCallWithLocation :: String -> String -> ErrorCall

- Control.Exception.Compat: HeapOverflow :: AsyncException

- Control.Exception.Compat: IndexOutOfBounds :: String -> ArrayException

- Control.Exception.Compat: LossOfPrecision :: ArithException

- Control.Exception.Compat: MaskedInterruptible :: MaskingState

- Control.Exception.Compat: MaskedUninterruptible :: MaskingState

- Control.Exception.Compat: NestedAtomically :: NestedAtomically

- Control.Exception.Compat: NoMethodError :: String -> NoMethodError

- Control.Exception.Compat: NonTermination :: NonTermination

- Control.Exception.Compat: Overflow :: ArithException

- Control.Exception.Compat: PatternMatchFail :: String -> PatternMatchFail

- Control.Exception.Compat: RatioZeroDenominator :: ArithException

- Control.Exception.Compat: RecConError :: String -> RecConError

- Control.Exception.Compat: RecSelError :: String -> RecSelError

- Control.Exception.Compat: RecUpdError :: String -> RecUpdError

- Control.Exception.Compat: StackOverflow :: AsyncException

- Control.Exception.Compat: ThreadKilled :: AsyncException

- Control.Exception.Compat: TypeError :: String -> TypeError

- Control.Exception.Compat: UndefinedElement :: String -> ArrayException

- Control.Exception.Compat: Underflow :: ArithException

- Control.Exception.Compat: Unmasked :: MaskingState

- Control.Exception.Compat: UserInterrupt :: AsyncException

- Control.Exception.Compat: [Handler] :: Handler a

- Control.Exception.Compat: [SomeAsyncException] :: SomeAsyncException

- Control.Exception.Compat: [SomeException] :: SomeException

- Control.Exception.Compat: allowInterrupt :: IO ()

- Control.Exception.Compat: assert :: () => Bool -> a -> a

- Control.Exception.Compat: asyncExceptionFromException :: Exception e => SomeException -> Maybe e

- Control.Exception.Compat: asyncExceptionToException :: Exception e => e -> SomeException

- Control.Exception.Compat: bracket :: () => IO a -> a -> IO b -> a -> IO c -> IO c

- Control.Exception.Compat: bracketOnError :: () => IO a -> a -> IO b -> a -> IO c -> IO c

- Control.Exception.Compat: bracket_ :: () => IO a -> IO b -> IO c -> IO c

- Control.Exception.Compat: catch :: Exception e => IO a -> e -> IO a -> IO a

- Control.Exception.Compat: catchJust :: Exception e => e -> Maybe b -> IO a -> b -> IO a -> IO a

- Control.Exception.Compat: catches :: () => IO a -> [Handler a] -> IO a

- Control.Exception.Compat: class (Typeable e, Show e) => Exception e

- Control.Exception.Compat: data AllocationLimitExceeded

- Control.Exception.Compat: data ArithException

- Control.Exception.Compat: data ArrayException

- Control.Exception.Compat: data AsyncException

- Control.Exception.Compat: data BlockedIndefinitelyOnMVar

- Control.Exception.Compat: data BlockedIndefinitelyOnSTM

- Control.Exception.Compat: data Deadlock

- Control.Exception.Compat: data ErrorCall

- Control.Exception.Compat: data Handler a

- Control.Exception.Compat: data IOException

- Control.Exception.Compat: data MaskingState

- Control.Exception.Compat: data NestedAtomically

- Control.Exception.Compat: data NonTermination

- Control.Exception.Compat: data SomeAsyncException

- Control.Exception.Compat: data SomeException

- Control.Exception.Compat: displayException :: Exception e => e -> String

- Control.Exception.Compat: evaluate :: () => a -> IO a

- Control.Exception.Compat: finally :: () => IO a -> IO b -> IO a

- Control.Exception.Compat: fromException :: Exception e => SomeException -> Maybe e

- Control.Exception.Compat: getMaskingState :: IO MaskingState

- Control.Exception.Compat: handle :: Exception e => e -> IO a -> IO a -> IO a

- Control.Exception.Compat: handleJust :: Exception e => e -> Maybe b -> b -> IO a -> IO a -> IO a

- Control.Exception.Compat: interruptible :: () => IO a -> IO a

- Control.Exception.Compat: ioError :: () => IOError -> IO a

- Control.Exception.Compat: mapException :: (Exception e1, Exception e2) => e1 -> e2 -> a -> a

- Control.Exception.Compat: mask :: () => forall a. () => IO a -> IO a -> IO b -> IO b

- Control.Exception.Compat: mask_ :: () => IO a -> IO a

- Control.Exception.Compat: newtype AssertionFailed

- Control.Exception.Compat: newtype CompactionFailed

- Control.Exception.Compat: newtype NoMethodError

- Control.Exception.Compat: newtype PatternMatchFail

- Control.Exception.Compat: newtype RecConError

- Control.Exception.Compat: newtype RecSelError

- Control.Exception.Compat: newtype RecUpdError

- Control.Exception.Compat: newtype TypeError

- Control.Exception.Compat: onException :: () => IO a -> IO b -> IO a

- Control.Exception.Compat: throwIO :: Exception e => e -> IO a

- Control.Exception.Compat: throwTo :: Exception e => ThreadId -> e -> IO ()

- Control.Exception.Compat: toException :: Exception e => e -> SomeException

- Control.Exception.Compat: try :: Exception e => IO a -> IO Either e a

- Control.Exception.Compat: tryJust :: Exception e => e -> Maybe b -> IO a -> IO Either b a

- Control.Exception.Compat: uninterruptibleMask :: () => forall a. () => IO a -> IO a -> IO b -> IO b

- Control.Exception.Compat: uninterruptibleMask_ :: () => IO a -> IO a

- Data.Functor.Const.Compat: newtype Const a (b :: k) :: forall k. () => * -> k -> *

+ Control.Monad.Compat: (<$!>) :: Monad m => (a -> b) -> m a -> m b

+ Control.Monad.Compat: (<=<) :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c

+ Control.Monad.Compat: (=<<) :: Monad m => (a -> m b) -> m a -> m b

+ Control.Monad.Compat: (>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c

+ Control.Monad.Compat: ap :: Monad m => m (a -> b) -> m a -> m b

+ Control.Monad.Compat: class Functor (f :: Type -> Type)

+ Control.Monad.Compat: class Monad m => MonadFail (m :: Type -> Type)

+ Control.Monad.Compat: filterM :: Applicative m => (a -> m Bool) -> [a] -> m [a]

+ Control.Monad.Compat: fmap :: Functor f => (a -> b) -> f a -> f b

+ Control.Monad.Compat: foldM :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m b

+ Control.Monad.Compat: foldM_ :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m ()

+ Control.Monad.Compat: forM :: (Traversable t, Monad m) => t a -> (a -> m b) -> m (t b)

+ Control.Monad.Compat: forM_ :: (Foldable t, Monad m) => t a -> (a -> m b) -> m ()

+ Control.Monad.Compat: forever :: Applicative f => f a -> f b

+ Control.Monad.Compat: guard :: Alternative f => Bool -> f ()

+ Control.Monad.Compat: infixl 1 >>

+ Control.Monad.Compat: infixl 4 <$!>

+ Control.Monad.Compat: infixr 1 =<<

+ Control.Monad.Compat: join :: Monad m => m (m a) -> m a

+ Control.Monad.Compat: liftM :: Monad m => (a1 -> r) -> m a1 -> m r

+ Control.Monad.Compat: liftM2 :: Monad m => (a1 -> a2 -> r) -> m a1 -> m a2 -> m r

+ Control.Monad.Compat: liftM3 :: Monad m => (a1 -> a2 -> a3 -> r) -> m a1 -> m a2 -> m a3 -> m r

+ Control.Monad.Compat: liftM4 :: Monad m => (a1 -> a2 -> a3 -> a4 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m r

+ Control.Monad.Compat: liftM5 :: Monad m => (a1 -> a2 -> a3 -> a4 -> a5 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m a5 -> m r

+ Control.Monad.Compat: mapAndUnzipM :: Applicative m => (a -> m (b, c)) -> [a] -> m ([b], [c])

+ Control.Monad.Compat: mapM :: (Traversable t, Monad m) => (a -> m b) -> t a -> m (t b)

+ Control.Monad.Compat: mapM_ :: (Foldable t, Monad m) => (a -> m b) -> t a -> m ()

+ Control.Monad.Compat: mfilter :: MonadPlus m => (a -> Bool) -> m a -> m a

+ Control.Monad.Compat: msum :: (Foldable t, MonadPlus m) => t (m a) -> m a

+ Control.Monad.Compat: replicateM :: Applicative m => Int -> m a -> m [a]

+ Control.Monad.Compat: replicateM_ :: Applicative m => Int -> m a -> m ()

+ Control.Monad.Compat: sequence :: (Traversable t, Monad m) => t (m a) -> m (t a)

+ Control.Monad.Compat: sequence_ :: (Foldable t, Monad m) => t (m a) -> m ()

+ Control.Monad.Compat: unless :: Applicative f => Bool -> f () -> f ()

+ Control.Monad.Compat: void :: Functor f => f a -> f ()

+ Control.Monad.Compat: when :: Applicative f => Bool -> f () -> f ()

+ Control.Monad.Compat: zipWithM :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m [c]

+ Control.Monad.Compat: zipWithM_ :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m ()

+ Data.Functor.Const.Compat: newtype Const a (b :: k) :: forall k. () => Type -> k -> Type

+ Data.Monoid.Compat: Ap :: f a -> Ap

+ Data.Monoid.Compat: [getAp] :: Ap -> f a

+ Data.Semigroup.Compat: infixr 6 <>

+ Prelude.Compat: class Monad m => MonadFail (m :: Type -> Type)

- Control.Concurrent.Compat: forkFinally :: () => IO a -> Either SomeException a -> IO () -> IO ThreadId

+ Control.Concurrent.Compat: forkFinally :: () => IO a -> (Either SomeException a -> IO ()) -> IO ThreadId

- Control.Concurrent.Compat: forkOSWithUnmask :: forall a. () => IO a -> IO a -> IO () -> IO ThreadId

+ Control.Concurrent.Compat: forkOSWithUnmask :: ((forall a. () => IO a -> IO a) -> IO ()) -> IO ThreadId

- Control.Concurrent.MVar.Compat: withMVarMasked :: () => MVar a -> a -> IO b -> IO b

+ Control.Concurrent.MVar.Compat: withMVarMasked :: () => MVar a -> (a -> IO b) -> IO b

- Control.Exception.Compat: throw :: forall (r :: RuntimeRep). forall (a :: TYPE r). forall e. Exception e => e -> a

+ Control.Exception.Compat: throw :: Exception e => e -> a

- Control.Monad.Compat: (>>=) :: Monad m => m a -> a -> m b -> m b

+ Control.Monad.Compat: (>>=) :: Monad m => m a -> (a -> m b) -> m b

- Control.Monad.Compat: class Applicative m => Monad (m :: * -> *)

+ Control.Monad.Compat: class Applicative m => Monad (m :: Type -> Type)

- Control.Monad.Compat: class (Alternative m, Monad m) => MonadPlus (m :: * -> *)

+ Control.Monad.Compat: class (Alternative m, Monad m) => MonadPlus (m :: Type -> Type)

- Control.Monad.Compat: fail :: Monad m => String -> m a

+ Control.Monad.Compat: fail :: MonadFail m => String -> m a

- Data.Function.Compat: (&) :: () => a -> a -> b -> b

+ Data.Function.Compat: (&) :: () => a -> (a -> b) -> b

- Data.Functor.Compat: (<&>) :: Functor f => f a -> a -> b -> f b

+ Data.Functor.Compat: (<&>) :: Functor f => f a -> (a -> b) -> f b

- Data.Functor.Compat: class Functor (f :: * -> *)

+ Data.Functor.Compat: class Functor (f :: Type -> Type)

- Data.Functor.Compat: fmap :: Functor f => a -> b -> f a -> f b

+ Data.Functor.Compat: fmap :: Functor f => (a -> b) -> f a -> f b

- Data.IORef.Compat: atomicModifyIORef' :: () => IORef a -> a -> (a, b) -> IO b

+ Data.IORef.Compat: atomicModifyIORef' :: () => IORef a -> (a -> (a, b)) -> IO b

- Data.IORef.Compat: modifyIORef' :: () => IORef a -> a -> a -> IO ()

+ Data.IORef.Compat: modifyIORef' :: () => IORef a -> (a -> a) -> IO ()

- Data.List.NonEmpty.Compat: break :: () => a -> Bool -> NonEmpty a -> ([a], [a])

+ Data.List.NonEmpty.Compat: break :: () => (a -> Bool) -> NonEmpty a -> ([a], [a])

- Data.List.NonEmpty.Compat: dropWhile :: () => a -> Bool -> NonEmpty a -> [a]

+ Data.List.NonEmpty.Compat: dropWhile :: () => (a -> Bool) -> NonEmpty a -> [a]

- Data.List.NonEmpty.Compat: filter :: () => a -> Bool -> NonEmpty a -> [a]

+ Data.List.NonEmpty.Compat: filter :: () => (a -> Bool) -> NonEmpty a -> [a]

- Data.List.NonEmpty.Compat: group1 :: Eq a => NonEmpty a -> NonEmpty NonEmpty a

+ Data.List.NonEmpty.Compat: group1 :: Eq a => NonEmpty a -> NonEmpty (NonEmpty a)

- Data.List.NonEmpty.Compat: groupAllWith :: Ord b => a -> b -> [a] -> [NonEmpty a]

+ Data.List.NonEmpty.Compat: groupAllWith :: Ord b => (a -> b) -> [a] -> [NonEmpty a]

- Data.List.NonEmpty.Compat: groupAllWith1 :: Ord b => a -> b -> NonEmpty a -> NonEmpty NonEmpty a

+ Data.List.NonEmpty.Compat: groupAllWith1 :: Ord b => (a -> b) -> NonEmpty a -> NonEmpty (NonEmpty a)

- Data.List.NonEmpty.Compat: groupBy :: Foldable f => a -> a -> Bool -> f a -> [NonEmpty a]

+ Data.List.NonEmpty.Compat: groupBy :: Foldable f => (a -> a -> Bool) -> f a -> [NonEmpty a]

- Data.List.NonEmpty.Compat: groupBy1 :: () => a -> a -> Bool -> NonEmpty a -> NonEmpty NonEmpty a

+ Data.List.NonEmpty.Compat: groupBy1 :: () => (a -> a -> Bool) -> NonEmpty a -> NonEmpty (NonEmpty a)

- Data.List.NonEmpty.Compat: groupWith :: (Foldable f, Eq b) => a -> b -> f a -> [NonEmpty a]

+ Data.List.NonEmpty.Compat: groupWith :: (Foldable f, Eq b) => (a -> b) -> f a -> [NonEmpty a]

- Data.List.NonEmpty.Compat: groupWith1 :: Eq b => a -> b -> NonEmpty a -> NonEmpty NonEmpty a

+ Data.List.NonEmpty.Compat: groupWith1 :: Eq b => (a -> b) -> NonEmpty a -> NonEmpty (NonEmpty a)

- Data.List.NonEmpty.Compat: iterate :: () => a -> a -> a -> NonEmpty a

+ Data.List.NonEmpty.Compat: iterate :: () => (a -> a) -> a -> NonEmpty a

- Data.List.NonEmpty.Compat: map :: () => a -> b -> NonEmpty a -> NonEmpty b

+ Data.List.NonEmpty.Compat: map :: () => (a -> b) -> NonEmpty a -> NonEmpty b

- Data.List.NonEmpty.Compat: nonEmpty :: () => [a] -> Maybe NonEmpty a

+ Data.List.NonEmpty.Compat: nonEmpty :: () => [a] -> Maybe (NonEmpty a)

- Data.List.NonEmpty.Compat: nubBy :: () => a -> a -> Bool -> NonEmpty a -> NonEmpty a

+ Data.List.NonEmpty.Compat: nubBy :: () => (a -> a -> Bool) -> NonEmpty a -> NonEmpty a

- Data.List.NonEmpty.Compat: partition :: () => a -> Bool -> NonEmpty a -> ([a], [a])

+ Data.List.NonEmpty.Compat: partition :: () => (a -> Bool) -> NonEmpty a -> ([a], [a])

- Data.List.NonEmpty.Compat: scanl :: Foldable f => b -> a -> b -> b -> f a -> NonEmpty b

+ Data.List.NonEmpty.Compat: scanl :: Foldable f => (b -> a -> b) -> b -> f a -> NonEmpty b

- Data.List.NonEmpty.Compat: scanl1 :: () => a -> a -> a -> NonEmpty a -> NonEmpty a

+ Data.List.NonEmpty.Compat: scanl1 :: () => (a -> a -> a) -> NonEmpty a -> NonEmpty a

- Data.List.NonEmpty.Compat: scanr :: Foldable f => a -> b -> b -> b -> f a -> NonEmpty b

+ Data.List.NonEmpty.Compat: scanr :: Foldable f => (a -> b -> b) -> b -> f a -> NonEmpty b

- Data.List.NonEmpty.Compat: scanr1 :: () => a -> a -> a -> NonEmpty a -> NonEmpty a

+ Data.List.NonEmpty.Compat: scanr1 :: () => (a -> a -> a) -> NonEmpty a -> NonEmpty a

- Data.List.NonEmpty.Compat: some1 :: Alternative f => f a -> f NonEmpty a

+ Data.List.NonEmpty.Compat: some1 :: Alternative f => f a -> f (NonEmpty a)

- Data.List.NonEmpty.Compat: sortBy :: () => a -> a -> Ordering -> NonEmpty a -> NonEmpty a

+ Data.List.NonEmpty.Compat: sortBy :: () => (a -> a -> Ordering) -> NonEmpty a -> NonEmpty a

- Data.List.NonEmpty.Compat: sortWith :: Ord o => a -> o -> NonEmpty a -> NonEmpty a

+ Data.List.NonEmpty.Compat: sortWith :: Ord o => (a -> o) -> NonEmpty a -> NonEmpty a

- Data.List.NonEmpty.Compat: span :: () => a -> Bool -> NonEmpty a -> ([a], [a])

+ Data.List.NonEmpty.Compat: span :: () => (a -> Bool) -> NonEmpty a -> ([a], [a])

- Data.List.NonEmpty.Compat: takeWhile :: () => a -> Bool -> NonEmpty a -> [a]

+ Data.List.NonEmpty.Compat: takeWhile :: () => (a -> Bool) -> NonEmpty a -> [a]

- Data.List.NonEmpty.Compat: transpose :: () => NonEmpty NonEmpty a -> NonEmpty NonEmpty a

+ Data.List.NonEmpty.Compat: transpose :: () => NonEmpty (NonEmpty a) -> NonEmpty (NonEmpty a)

- Data.List.NonEmpty.Compat: uncons :: () => NonEmpty a -> (a, Maybe NonEmpty a)

+ Data.List.NonEmpty.Compat: uncons :: () => NonEmpty a -> (a, Maybe (NonEmpty a))

- Data.List.NonEmpty.Compat: unfold :: () => a -> (b, Maybe a) -> a -> NonEmpty b

+ Data.List.NonEmpty.Compat: unfold :: () => (a -> (b, Maybe a)) -> a -> NonEmpty b

- Data.List.NonEmpty.Compat: unfoldr :: () => a -> (b, Maybe a) -> a -> NonEmpty b

+ Data.List.NonEmpty.Compat: unfoldr :: () => (a -> (b, Maybe a)) -> a -> NonEmpty b

- Data.List.NonEmpty.Compat: zipWith :: () => a -> b -> c -> NonEmpty a -> NonEmpty b -> NonEmpty c

+ Data.List.NonEmpty.Compat: zipWith :: () => (a -> b -> c) -> NonEmpty a -> NonEmpty b -> NonEmpty c

- Data.Monoid.Compat: Endo :: a -> a -> Endo a

+ Data.Monoid.Compat: Endo :: (a -> a) -> Endo a

- Data.Monoid.Compat: newtype Alt (f :: k -> *) (a :: k) :: forall k. () => k -> * -> k -> *

+ Data.Monoid.Compat: newtype Alt (f :: k -> Type) (a :: k) :: forall k. () => k -> Type -> k -> Type

- Data.STRef.Compat: modifySTRef' :: () => STRef s a -> a -> a -> ST s ()

+ Data.STRef.Compat: modifySTRef' :: () => STRef s a -> (a -> a) -> ST s ()

- Data.Semigroup.Compat: Endo :: a -> a -> Endo a

+ Data.Semigroup.Compat: Endo :: (a -> a) -> Endo a

- Data.Semigroup.Compat: option :: () => b -> a -> b -> Option a -> b

+ Data.Semigroup.Compat: option :: () => b -> (a -> b) -> Option a -> b

- Data.Type.Coercion.Compat: gcoerceWith :: () => Coercion a b -> Coercible a b -> r -> r

+ Data.Type.Coercion.Compat: gcoerceWith :: () => Coercion a b -> (Coercible a b -> r) -> r

- Foreign.ForeignPtr.Safe.Compat: mallocForeignPtr :: Storable a => IO ForeignPtr a

+ Foreign.ForeignPtr.Safe.Compat: mallocForeignPtr :: Storable a => IO (ForeignPtr a)

- Foreign.ForeignPtr.Safe.Compat: mallocForeignPtrArray :: Storable a => Int -> IO ForeignPtr a

+ Foreign.ForeignPtr.Safe.Compat: mallocForeignPtrArray :: Storable a => Int -> IO (ForeignPtr a)

- Foreign.ForeignPtr.Safe.Compat: mallocForeignPtrArray0 :: Storable a => Int -> IO ForeignPtr a

+ Foreign.ForeignPtr.Safe.Compat: mallocForeignPtrArray0 :: Storable a => Int -> IO (ForeignPtr a)

- Foreign.ForeignPtr.Safe.Compat: mallocForeignPtrBytes :: () => Int -> IO ForeignPtr a

+ Foreign.ForeignPtr.Safe.Compat: mallocForeignPtrBytes :: () => Int -> IO (ForeignPtr a)

- Foreign.ForeignPtr.Safe.Compat: newForeignPtr :: () => FinalizerPtr a -> Ptr a -> IO ForeignPtr a

+ Foreign.ForeignPtr.Safe.Compat: newForeignPtr :: () => FinalizerPtr a -> Ptr a -> IO (ForeignPtr a)

- Foreign.ForeignPtr.Safe.Compat: newForeignPtrEnv :: () => FinalizerEnvPtr env a -> Ptr env -> Ptr a -> IO ForeignPtr a

+ Foreign.ForeignPtr.Safe.Compat: newForeignPtrEnv :: () => FinalizerEnvPtr env a -> Ptr env -> Ptr a -> IO (ForeignPtr a)

- Foreign.ForeignPtr.Safe.Compat: newForeignPtr_ :: () => Ptr a -> IO ForeignPtr a

+ Foreign.ForeignPtr.Safe.Compat: newForeignPtr_ :: () => Ptr a -> IO (ForeignPtr a)

- Foreign.ForeignPtr.Safe.Compat: withForeignPtr :: () => ForeignPtr a -> Ptr a -> IO b -> IO b

+ Foreign.ForeignPtr.Safe.Compat: withForeignPtr :: () => ForeignPtr a -> (Ptr a -> IO b) -> IO b

- Foreign.Marshal.Alloc.Compat: calloc :: Storable a => IO Ptr a

+ Foreign.Marshal.Alloc.Compat: calloc :: Storable a => IO (Ptr a)

- Foreign.Marshal.Alloc.Compat: callocBytes :: () => Int -> IO Ptr a

+ Foreign.Marshal.Alloc.Compat: callocBytes :: () => Int -> IO (Ptr a)

- Foreign.Marshal.Array.Compat: callocArray :: Storable a => Int -> IO Ptr a

+ Foreign.Marshal.Array.Compat: callocArray :: Storable a => Int -> IO (Ptr a)

- Foreign.Marshal.Array.Compat: callocArray0 :: Storable a => Int -> IO Ptr a

+ Foreign.Marshal.Array.Compat: callocArray0 :: Storable a => Int -> IO (Ptr a)

- Prelude.Compat: ($!) :: forall r a (b :: TYPE r). (a -> b) -> a -> b

+ Prelude.Compat: ($!) :: () => (a -> b) -> a -> b

- Prelude.Compat: ($) :: () => a -> b -> a -> b

+ Prelude.Compat: ($) :: () => (a -> b) -> a -> b

- Prelude.Compat: (.) :: () => b -> c -> a -> b -> a -> c

+ Prelude.Compat: (.) :: () => (b -> c) -> (a -> b) -> a -> c

- Prelude.Compat: (<$>) :: Functor f => a -> b -> f a -> f b

+ Prelude.Compat: (<$>) :: Functor f => (a -> b) -> f a -> f b

- Prelude.Compat: (<*>) :: Applicative f => f a -> b -> f a -> f b

+ Prelude.Compat: (<*>) :: Applicative f => f (a -> b) -> f a -> f b

- Prelude.Compat: (=<<) :: Monad m => a -> m b -> m a -> m b

+ Prelude.Compat: (=<<) :: Monad m => (a -> m b) -> m a -> m b

- Prelude.Compat: (>>=) :: Monad m => m a -> a -> m b -> m b

+ Prelude.Compat: (>>=) :: Monad m => m a -> (a -> m b) -> m b

- Prelude.Compat: all :: Foldable t => a -> Bool -> t a -> Bool

+ Prelude.Compat: all :: Foldable t => (a -> Bool) -> t a -> Bool

- Prelude.Compat: any :: Foldable t => a -> Bool -> t a -> Bool

+ Prelude.Compat: any :: Foldable t => (a -> Bool) -> t a -> Bool

- Prelude.Compat: break :: () => a -> Bool -> [a] -> ([a], [a])

+ Prelude.Compat: break :: () => (a -> Bool) -> [a] -> ([a], [a])

- Prelude.Compat: class Functor f => Applicative (f :: * -> *)

+ Prelude.Compat: class Functor f => Applicative (f :: Type -> Type)

- Prelude.Compat: class Foldable (t :: * -> *)

+ Prelude.Compat: class Foldable (t :: Type -> Type)

- Prelude.Compat: class Functor (f :: * -> *)

+ Prelude.Compat: class Functor (f :: Type -> Type)

- Prelude.Compat: class Applicative m => Monad (m :: * -> *)

+ Prelude.Compat: class Applicative m => Monad (m :: Type -> Type)

- Prelude.Compat: class (Functor t, Foldable t) => Traversable (t :: * -> *)

+ Prelude.Compat: class (Functor t, Foldable t) => Traversable (t :: Type -> Type)

- Prelude.Compat: concatMap :: Foldable t => a -> [b] -> t a -> [b]

+ Prelude.Compat: concatMap :: Foldable t => (a -> [b]) -> t a -> [b]

- Prelude.Compat: curry :: () => (a, b) -> c -> a -> b -> c

+ Prelude.Compat: curry :: () => ((a, b) -> c) -> a -> b -> c

- Prelude.Compat: dropWhile :: () => a -> Bool -> [a] -> [a]

+ Prelude.Compat: dropWhile :: () => (a -> Bool) -> [a] -> [a]

- Prelude.Compat: either :: () => a -> c -> b -> c -> Either a b -> c

+ Prelude.Compat: either :: () => (a -> c) -> (b -> c) -> Either a b -> c

- Prelude.Compat: fail :: Monad m => String -> m a

+ Prelude.Compat: fail :: MonadFail m => String -> m a

- Prelude.Compat: filter :: () => a -> Bool -> [a] -> [a]

+ Prelude.Compat: filter :: () => (a -> Bool) -> [a] -> [a]

- Prelude.Compat: flip :: () => a -> b -> c -> b -> a -> c

+ Prelude.Compat: flip :: () => (a -> b -> c) -> b -> a -> c

- Prelude.Compat: fmap :: Functor f => a -> b -> f a -> f b

+ Prelude.Compat: fmap :: Functor f => (a -> b) -> f a -> f b

- Prelude.Compat: foldMap :: (Foldable t, Monoid m) => a -> m -> t a -> m

+ Prelude.Compat: foldMap :: (Foldable t, Monoid m) => (a -> m) -> t a -> m

- Prelude.Compat: foldl :: Foldable t => b -> a -> b -> b -> t a -> b

+ Prelude.Compat: foldl :: Foldable t => (b -> a -> b) -> b -> t a -> b

- Prelude.Compat: foldl1 :: Foldable t => a -> a -> a -> t a -> a

+ Prelude.Compat: foldl1 :: Foldable t => (a -> a -> a) -> t a -> a

- Prelude.Compat: foldr :: Foldable t => a -> b -> b -> b -> t a -> b

+ Prelude.Compat: foldr :: Foldable t => (a -> b -> b) -> b -> t a -> b

- Prelude.Compat: foldr1 :: Foldable t => a -> a -> a -> t a -> a

+ Prelude.Compat: foldr1 :: Foldable t => (a -> a -> a) -> t a -> a

- Prelude.Compat: infix 4 >=

+ Prelude.Compat: infix 4 `notElem`

- Prelude.Compat: infixl 1 >>=

+ Prelude.Compat: infixl 1 >>

- Prelude.Compat: infixl 4 <$

+ Prelude.Compat: infixl 4 <$>

- Prelude.Compat: infixl 7 `rem`

+ Prelude.Compat: infixl 7 *

- Prelude.Compat: infixr 0 $

+ Prelude.Compat: infixr 0 $!

- Prelude.Compat: infixr 8 **

+ Prelude.Compat: infixr 8 ^

- Prelude.Compat: interact :: String -> String -> IO ()

+ Prelude.Compat: interact :: (String -> String) -> IO ()

- Prelude.Compat: iterate :: () => a -> a -> a -> [a]

+ Prelude.Compat: iterate :: () => (a -> a) -> a -> [a]

- Prelude.Compat: map :: () => a -> b -> [a] -> [b]

+ Prelude.Compat: map :: () => (a -> b) -> [a] -> [b]

- Prelude.Compat: mapM :: (Traversable t, Monad m) => a -> m b -> t a -> m t b

+ Prelude.Compat: mapM :: (Traversable t, Monad m) => (a -> m b) -> t a -> m (t b)

- Prelude.Compat: mapM_ :: (Foldable t, Monad m) => a -> m b -> t a -> m ()

+ Prelude.Compat: mapM_ :: (Foldable t, Monad m) => (a -> m b) -> t a -> m ()

- Prelude.Compat: maybe :: () => b -> a -> b -> Maybe a -> b

+ Prelude.Compat: maybe :: () => b -> (a -> b) -> Maybe a -> b

- Prelude.Compat: scanl :: () => b -> a -> b -> b -> [a] -> [b]

+ Prelude.Compat: scanl :: () => (b -> a -> b) -> b -> [a] -> [b]

- Prelude.Compat: scanl1 :: () => a -> a -> a -> [a] -> [a]

+ Prelude.Compat: scanl1 :: () => (a -> a -> a) -> [a] -> [a]

- Prelude.Compat: scanr :: () => a -> b -> b -> b -> [a] -> [b]

+ Prelude.Compat: scanr :: () => (a -> b -> b) -> b -> [a] -> [b]

- Prelude.Compat: scanr1 :: () => a -> a -> a -> [a] -> [a]

+ Prelude.Compat: scanr1 :: () => (a -> a -> a) -> [a] -> [a]

- Prelude.Compat: sequence :: (Traversable t, Monad m) => t m a -> m t a

+ Prelude.Compat: sequence :: (Traversable t, Monad m) => t (m a) -> m (t a)

- Prelude.Compat: sequenceA :: (Traversable t, Applicative f) => t f a -> f t a

+ Prelude.Compat: sequenceA :: (Traversable t, Applicative f) => t (f a) -> f (t a)

- Prelude.Compat: sequence_ :: (Foldable t, Monad m) => t m a -> m ()

+ Prelude.Compat: sequence_ :: (Foldable t, Monad m) => t (m a) -> m ()

- Prelude.Compat: span :: () => a -> Bool -> [a] -> ([a], [a])

+ Prelude.Compat: span :: () => (a -> Bool) -> [a] -> ([a], [a])

- Prelude.Compat: takeWhile :: () => a -> Bool -> [a] -> [a]

+ Prelude.Compat: takeWhile :: () => (a -> Bool) -> [a] -> [a]

- Prelude.Compat: traverse :: (Traversable t, Applicative f) => a -> f b -> t a -> f t b

+ Prelude.Compat: traverse :: (Traversable t, Applicative f) => (a -> f b) -> t a -> f (t b)

- Prelude.Compat: uncurry :: () => a -> b -> c -> (a, b) -> c

+ Prelude.Compat: uncurry :: () => (a -> b -> c) -> (a, b) -> c

- Prelude.Compat: until :: () => a -> Bool -> a -> a -> a -> a

+ Prelude.Compat: until :: () => (a -> Bool) -> (a -> a) -> a -> a

- Prelude.Compat: zipWith :: () => a -> b -> c -> [a] -> [b] -> [c]

+ Prelude.Compat: zipWith :: () => (a -> b -> c) -> [a] -> [b] -> [c]

- Prelude.Compat: zipWith3 :: () => a -> b -> c -> d -> [a] -> [b] -> [c] -> [d]

+ Prelude.Compat: zipWith3 :: () => (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]

- System.Environment.Compat: lookupEnv :: String -> IO Maybe String

+ System.Environment.Compat: lookupEnv :: String -> IO (Maybe String)

- System.IO.Unsafe.Compat: unsafeFixIO :: () => a -> IO a -> IO a

+ System.IO.Unsafe.Compat: unsafeFixIO :: () => (a -> IO a) -> IO a

- Type.Reflection.Compat: withTypeable :: () => TypeRep a -> Typeable a -> r -> r

+ Type.Reflection.Compat: withTypeable :: () => TypeRep a -> (Typeable a -> r) -> r

Files

CHANGES.markdown +49/−0
README.markdown +5/−0
base-compat.cabal +4/−1
src/Control/Monad/Compat.hs +7/−2
src/Data/Type/Equality/Compat.hs +14/−0
src/Data/Type/Equality/Compat/Repl.hs +8/−0
src/Prelude/Compat.hs +14/−3

CHANGES.markdown view

@@ -1,3 +1,52 @@+## Changes in 0.11.0 [2019.09.06]+ - Sync with `base-4.13`/GHC 8.8+ - Backport `MonadFail(fail)` to `Prelude.Compat` and `Control.Monad.Compat`.++   Because `Prelude.Compat.fail` now corresponds to the `fail` from `MonadFail`+   instead of `Monad`, some care is required to implement `Monad.fail` on+   pre-8.8 versions of GHC. The following template is recommended:++   ```haskell+   import Prelude.Compat+   import qualified Control.Monad      as Monad+   import qualified Control.Monad.Fail as Fail++   data Blah a = ...++   instance Functor Blah where ...+   instance Applicative Blah where ...++   instance Monad.Monad Blah where+     (>>=) = ...+   #if !(MIN_VERSION_base(4,13,0))+     fail = Fail.fail+   #endif++   instance Fail.MonadFail Blah where+     fail = ...+   ```++   This approach is also backwards-compatible with previous releases of+   `base-compat`.++   Note that the `MonadFail` class has only been in `base` since+   `base-4.9`/GHC 8.0, so accordingly, this can only be backported back+   to GHC 8.0. If you wish to have a version of+   `Prelude.Compat`/`Control.Monad.Compat` that backports+   `MonadFail` to older GHCs (by conditionally depending on the `fail`+   library), use the `Prelude.Compat`/`Control.Monad.Compat` modules from the+   `base-compat-batteries` package.++ - Introduce the `Data.Type.Equality.Compat` module, which re-exports+   `Data.Type.Equality` if using `base-4.7`/GHC-7.8 or later. If using an older+   version of `base`, this module is empty.++   If you wish to have a version of+   `Data.Type.Equality.Compat` with older GHCs+   (by conditionally depending on the `type-equality` library),+   use the `Data.Type.Equality.Compat` module from the+   `base-compat-batteries` package.+ ## Changes in 0.10.5 [2018.10.18]  - Enable `BangPatterns` in `Prelude.Compat`.

README.markdown view

@@ -302,6 +302,11 @@  ## Supported versions of GHC/`base` + * `ghc-8.8.1`  / `base-4.13.0.0`+ * `ghc-8.6.5`  / `base-4.12.0.0`+ * `ghc-8.6.4`  / `base-4.12.0.0`+ * `ghc-8.6.3`  / `base-4.12.0.0`+ * `ghc-8.6.2`  / `base-4.12.0.0`  * `ghc-8.6.1`  / `base-4.12.0.0`  * `ghc-8.4.4`  / `base-4.11.1.0`  * `ghc-8.4.3`  / `base-4.11.1.0`

base-compat.cabal view

@@ -1,5 +1,5 @@ name:             base-compat-version:          0.10.5+version:          0.11.0 license:          MIT license-file:     LICENSE copyright:        (c) 2012-2018 Simon Hengel,@@ -53,6 +53,7 @@                   , GHC == 8.2.*                   , GHC == 8.4.*                   , GHC == 8.6.*+                  , GHC == 8.8.* extra-source-files: CHANGES.markdown, README.markdown  source-repository head@@ -110,6 +111,7 @@       Data.STRef.Compat       Data.String.Compat       Data.Type.Coercion.Compat+      Data.Type.Equality.Compat       Data.Version.Compat       Data.Void.Compat       Data.Word.Compat@@ -167,6 +169,7 @@       Data.STRef.Compat.Repl       Data.String.Compat.Repl       Data.Type.Coercion.Compat.Repl+      Data.Type.Equality.Compat.Repl       Data.Version.Compat.Repl       Data.Void.Compat.Repl       Data.Word.Compat.Repl

src/Control/Monad/Compat.hs view

@@ -1,7 +1,11 @@ {-# LANGUAGE CPP, NoImplicitPrelude #-} module Control.Monad.Compat (   module Base-, Monad(..)+, Monad+#if MIN_VERSION_base(4,9,0)+, MonadFail+#endif+, fail , MonadPlus(..) #if !(MIN_VERSION_base(4,8,0)) , foldM@@ -31,7 +35,8 @@ ) where  #if MIN_VERSION_base(4,9,0)-import Control.Monad as Base+import Control.Monad as Base hiding (fail)+import Control.Monad.Fail as Base #else import Control.Monad as Base hiding (     forever

+ src/Data/Type/Equality/Compat.hs view

@@ -0,0 +1,14 @@+{-# LANGUAGE CPP, NoImplicitPrelude #-}+{-# LANGUAGE RankNTypes #-}+#if __GLASGOW_HASKELL__ >= 702+{-# LANGUAGE Trustworthy #-}+#endif+module Data.Type.Equality.Compat (+#if MIN_VERSION_base(4,7,0)+  module Base+#endif+) where++#if MIN_VERSION_base(4,7,0)+import Data.Type.Equality as Base+#endif

+ src/Data/Type/Equality/Compat/Repl.hs view

@@ -0,0 +1,8 @@+{-# LANGUAGE PackageImports #-}+{-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-}+-- | Reexports "Data.Type.Equality.Compat"+-- from a globally unique namespace.+module Data.Type.Equality.Compat.Repl (+  module Data.Type.Equality.Compat+) where+import "this" Data.Type.Equality.Compat

src/Prelude/Compat.hs view

@@ -235,6 +235,9 @@ , Functor , Integral , Monad+#if MIN_VERSION_base(4,9,0)+, MonadFail+#endif , Monoid , Num (fromInteger) , Ord@@ -274,10 +277,14 @@  #if MIN_VERSION_base(4,9,0) -import Prelude as Base-# if MIN_VERSION_base(4,10,0) && !(MIN_VERSION_base(4,12,0))-  hiding (($!))+import Prelude as Base hiding (+# if !(MIN_VERSION_base(4,13,0))+    fail+#  if MIN_VERSION_base(4,10,0) && !(MIN_VERSION_base(4,12,0))+  , ($!)+#  endif # endif+  )  #else @@ -320,6 +327,10 @@  #if MIN_VERSION_base(4,9,0) && !(MIN_VERSION_base(4,11,0)) import Data.Semigroup as Base (Semigroup((<>)))+#endif++#if MIN_VERSION_base(4,9,0) && !(MIN_VERSION_base(4,13,0))+import Control.Monad.Fail as Base (MonadFail(fail)) #endif  #if MIN_VERSION_base(4,10,0) && !(MIN_VERSION_base(4,12,0))