base-compat 0.10.1 → 0.10.2
raw patch · 8 files changed
+97/−5 lines, 8 filesdep ~basePVP: major bump suggested
API removals or changes: PVP suggests a major version bump
Dependency ranges changed: base
API changes (from Hackage documentation)
- Data.List.Compat: iterate' :: (a -> a) -> a -> [a]
+ 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: throw :: forall (r :: RuntimeRep). forall (a :: TYPE r). forall e. Exception e => e -> 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.List.NonEmpty.Compat: infixl 9 !!
+ Data.Monoid.Compat: All :: Bool -> All
+ Data.Monoid.Compat: Alt :: f a -> Alt
+ Data.Monoid.Compat: Any :: Bool -> Any
+ Data.Monoid.Compat: Dual :: a -> Dual a
+ Data.Monoid.Compat: Endo :: a -> a -> Endo a
+ Data.Monoid.Compat: First :: Maybe a -> First a
+ Data.Monoid.Compat: Last :: Maybe a -> Last a
+ Data.Monoid.Compat: Product :: a -> Product a
+ Data.Monoid.Compat: Sum :: a -> Sum a
+ Data.Monoid.Compat: [appEndo] :: Endo a -> a -> a
+ Data.Monoid.Compat: [getAll] :: All -> Bool
+ Data.Monoid.Compat: [getAlt] :: Alt -> f a
+ Data.Monoid.Compat: [getAny] :: Any -> Bool
+ Data.Monoid.Compat: [getDual] :: Dual a -> a
+ Data.Monoid.Compat: [getFirst] :: First a -> Maybe a
+ Data.Monoid.Compat: [getLast] :: Last a -> Maybe a
+ Data.Monoid.Compat: [getProduct] :: Product a -> a
+ Data.Monoid.Compat: [getSum] :: Sum a -> a
+ Data.Monoid.Compat: class Semigroup a => Monoid a
+ Data.Monoid.Compat: mappend :: Monoid a => a -> a -> a
+ Data.Monoid.Compat: mconcat :: Monoid a => [a] -> a
+ Data.Monoid.Compat: mempty :: Monoid a => a
+ Data.Monoid.Compat: newtype All
+ Data.Monoid.Compat: newtype Any
+ Data.Monoid.Compat: newtype Dual a
+ Data.Monoid.Compat: newtype Endo a
+ Data.Monoid.Compat: newtype First a
+ Data.Monoid.Compat: newtype Last a
+ Data.Monoid.Compat: newtype Product a
+ Data.Monoid.Compat: newtype Sum a
+ Data.Monoid.Compat: newtype Alt (f :: k -> *) (a :: k) :: forall k. () => k -> * -> k -> *
- 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.Monad.Compat: (>>=) :: Monad m => m a -> (a -> m b) -> m b
+ Control.Monad.Compat: (>>=) :: Monad m => m a -> a -> m b -> m b
- 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: fmap :: Functor f => (a -> b) -> f a -> f b
+ Data.Functor.Compat: fmap :: Functor f => a -> b -> f a -> f b
- Data.Functor.Const.Compat: Const :: a -> Const k a
+ Data.Functor.Const.Compat: Const :: a -> Const a
- Data.Functor.Const.Compat: [getConst] :: Const k a -> a
+ Data.Functor.Const.Compat: [getConst] :: Const a -> a
- Data.Functor.Const.Compat: newtype Const k a (b :: k) :: forall k. () => * -> k -> *
+ Data.Functor.Const.Compat: newtype Const a (b :: k) :: forall k. () => * -> k -> *
- 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: data NonEmpty a :: * -> *
+ Data.List.NonEmpty.Compat: data NonEmpty 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: 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: 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: 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: 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.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: data Arg a b :: * -> * -> *
+ Data.Semigroup.Compat: data Arg a b
- Data.Semigroup.Compat: newtype All :: *
+ Data.Semigroup.Compat: newtype All
- Data.Semigroup.Compat: newtype Any :: *
+ Data.Semigroup.Compat: newtype Any
- Data.Semigroup.Compat: newtype Dual a :: * -> *
+ Data.Semigroup.Compat: newtype Dual a
- Data.Semigroup.Compat: newtype Endo a :: * -> *
+ Data.Semigroup.Compat: newtype Endo a
- Data.Semigroup.Compat: newtype First a :: * -> *
+ Data.Semigroup.Compat: newtype First a
- Data.Semigroup.Compat: newtype Last a :: * -> *
+ Data.Semigroup.Compat: newtype Last a
- Data.Semigroup.Compat: newtype Max a :: * -> *
+ Data.Semigroup.Compat: newtype Max a
- Data.Semigroup.Compat: newtype Min a :: * -> *
+ Data.Semigroup.Compat: newtype Min a
- Data.Semigroup.Compat: newtype Option a :: * -> *
+ Data.Semigroup.Compat: newtype Option a
- Data.Semigroup.Compat: newtype Product a :: * -> *
+ Data.Semigroup.Compat: newtype Product a
- Data.Semigroup.Compat: newtype Sum a :: * -> *
+ Data.Semigroup.Compat: newtype Sum a
- Data.Semigroup.Compat: newtype WrappedMonoid m :: * -> *
+ Data.Semigroup.Compat: newtype WrappedMonoid m
- 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 k0 a b -> (Coercible k0 a b -> r) -> r
+ Data.Type.Coercion.Compat: gcoerceWith :: () => Coercion a b -> Coercible a b -> r -> r
- Foreign.ForeignPtr.Safe.Compat: data ForeignPtr a :: * -> *
+ Foreign.ForeignPtr.Safe.Compat: data ForeignPtr a
- Foreign.ForeignPtr.Safe.Compat: type FinalizerEnvPtr env a = FunPtr (Ptr env -> Ptr a -> IO ())
+ Foreign.ForeignPtr.Safe.Compat: type FinalizerEnvPtr env a = FunPtr Ptr env -> Ptr a -> IO ()
- Foreign.ForeignPtr.Safe.Compat: type FinalizerPtr a = FunPtr (Ptr a -> IO ())
+ Foreign.ForeignPtr.Safe.Compat: type FinalizerPtr a = FunPtr Ptr a -> IO ()
- 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
- Prelude.Compat: ($!) :: () => (a -> b) -> a -> b
+ 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: (.) :: () => (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 Monoid a
+ Prelude.Compat: class Semigroup a => Monoid a
- 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: data Bool :: *
+ Prelude.Compat: data Bool
- Prelude.Compat: data Char :: *
+ Prelude.Compat: data Char
- Prelude.Compat: data Double :: *
+ Prelude.Compat: data Double
- Prelude.Compat: data Either a b :: * -> * -> *
+ Prelude.Compat: data Either a b
- Prelude.Compat: data Float :: *
+ Prelude.Compat: data Float
- Prelude.Compat: data IO a :: * -> *
+ Prelude.Compat: data IO a
- Prelude.Compat: data Int :: *
+ Prelude.Compat: data Int
- Prelude.Compat: data Integer :: *
+ Prelude.Compat: data Integer
- Prelude.Compat: data Maybe a :: * -> *
+ Prelude.Compat: data Maybe a
- Prelude.Compat: data Ordering :: *
+ Prelude.Compat: data Ordering
- Prelude.Compat: data Word :: *
+ Prelude.Compat: data Word
- 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: 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: 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: 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.IO.Unsafe.Compat: unsafeFixIO :: () => (a -> IO a) -> IO a
+ System.IO.Unsafe.Compat: unsafeFixIO :: () => a -> IO a -> IO a
- Text.Read.Compat: data Lexeme :: *
+ Text.Read.Compat: data Lexeme
- Type.Reflection.Compat: withTypeable :: forall (a :: k) (r :: TYPE rep). () => TypeRep a -> (Typeable a => r) -> r
+ Type.Reflection.Compat: withTypeable :: () => TypeRep a -> Typeable a -> r -> r
Files
- CHANGES.markdown +13/−2
- README.markdown +8/−0
- base-compat.cabal +7/−2
- src/Control/Exception/Compat.hs +22/−0
- src/Control/Exception/Compat/Repl.hs +8/−0
- src/Data/Functor/Contravariant/Compat.hs +10/−0
- src/Data/Functor/Contravariant/Compat/Repl.hs +8/−0
- src/Prelude/Compat.hs +21/−1
CHANGES.markdown view
@@ -1,6 +1,17 @@+## Changes in 0.10.2 [2018.07.02]+ - Sync with `base-4.12`/GHC 8.6+ - Backport `RuntimeRep`-polymorphic versions of `($!)` and `throw` to+ `Prelude.Compat` and `Control.Exception.Compat`, respectively+ (if using `base-4.10`/GHC 8.2 or later).+ - Introduce the `Data.Functor.Contravariant.Compat` module, which reexports+ `Data.Functor.Contravariant` if using `base-4.12`/GHC 8.6 or later.++ See `Data.Functor.Contravariant.Compat` in the corresponding+ `base-compat-batteries` release for a version with a wider support window.+ ## Changes in 0.10.1 [2018.04.10]-- Add `Data.List.NonEmpty.Compat`.-- Reexport `(Data.Semigroup.<>)` from `Data.Monoid.Compat` back to `base-4.9`.+ - Add `Data.List.NonEmpty.Compat`.+ - Reexport `(Data.Semigroup.<>)` from `Data.Monoid.Compat` back to `base-4.9`. ## Changes in 0.10.0 [2018.04.05] - Sync with `base-4.11`/GHC 8.4
README.markdown view
@@ -148,6 +148,8 @@ * `showFFloatAlt` and `showGFloatAlt` to `Numeric.Compat` * `lookupEnv`, `setEnv` and `unsetEnv` to `System.Environment.Compat` * `unsafeFixIO` and `unsafeDupablePerformIO` to `System.IO.Unsafe.IO`+ * `RuntimeRep`-polymorphic `($!)` to `Prelude.Compat`+ * `RuntimeRep`-polymorphic `throw` to `Control.Exception.Compat` ## What is not covered @@ -258,6 +260,9 @@ * The [`Bifoldable`](http://hackage.haskell.org/package/base-4.10.0.0/docs/Data-Bifoldable.html#t:Bifoldable) and [`Bitraversable`](http://hackage.haskell.org/package/base-4.10.0.0/docs/Data-Bitraversable.html#t:Bitraversable) type classes, introduced in `base-4.10.0.0`+* [`contravariant`](http://hackage.haskell.org/package/contravariant)+ for the [`Contravariant`](http://hackage.haskell.org/package/base-4.12.0.0/docs/Data-Functor-Contravariant.html#t:Contravariant)+ type class, introduced in `base-4.12.0.0`. * [`fail`](http://hackage.haskell.org/package/fail) for the [`MonadFail`](http://hackage.haskell.org/package/base-4.9.0.0/docs/Control-Monad-Fail.html#t:MonadFail) type class, introduced in `base-4.9.0.0`@@ -297,6 +302,9 @@ ## Supported versions of GHC/`base` + * `ghc-8.6.1` / `base-4.12.0.0`+ * `ghc-8.4.3` / `base-4.11.1.0`+ * `ghc-8.4.2` / `base-4.11.1.0` * `ghc-8.4.1` / `base-4.11.0.0` * `ghc-8.2.2` / `base-4.10.1.0` * `ghc-8.2.1` / `base-4.10.0.0`
base-compat.cabal view
@@ -1,5 +1,5 @@ name: base-compat-version: 0.10.1+version: 0.10.2 license: MIT license-file: LICENSE copyright: (c) 2012-2018 Simon Hengel,@@ -51,7 +51,8 @@ , GHC == 7.10.1, GHC == 7.10.2, GHC == 7.10.3 , GHC == 8.0.1, GHC == 8.0.2 , GHC == 8.2.1, GHC == 8.2.2- , GHC == 8.4.1+ , GHC == 8.4.1, GHC == 8.4.2, GHC == 8.4.3+ , GHC == 8.6.1 extra-source-files: CHANGES.markdown, README.markdown source-repository head@@ -75,6 +76,7 @@ exposed-modules: Control.Concurrent.Compat Control.Concurrent.MVar.Compat+ Control.Exception.Compat Control.Monad.Compat Control.Monad.Fail.Compat Control.Monad.IO.Class.Compat@@ -92,6 +94,7 @@ Data.Functor.Compat Data.Functor.Compose.Compat Data.Functor.Const.Compat+ Data.Functor.Contravariant.Compat Data.Functor.Identity.Compat Data.Functor.Product.Compat Data.Functor.Sum.Compat@@ -130,6 +133,7 @@ Control.Concurrent.Compat.Repl Control.Concurrent.MVar.Compat.Repl+ Control.Exception.Compat.Repl Control.Monad.Compat.Repl Control.Monad.Fail.Compat.Repl Control.Monad.IO.Class.Compat.Repl@@ -147,6 +151,7 @@ Data.Functor.Compat.Repl Data.Functor.Compose.Compat.Repl Data.Functor.Const.Compat.Repl+ Data.Functor.Contravariant.Compat.Repl Data.Functor.Identity.Compat.Repl Data.Functor.Product.Compat.Repl Data.Functor.Sum.Compat.Repl
+ src/Control/Exception/Compat.hs view
@@ -0,0 +1,22 @@+{-# LANGUAGE CPP, NoImplicitPrelude #-}+#if MIN_VERSION_base(4,10,0)+{-# LANGUAGE MagicHash #-}+{-# LANGUAGE RankNTypes #-}+{-# LANGUAGE TypeInType #-}+#endif+module Control.Exception.Compat (+ module Base+, throw+) where++import Control.Exception as Base+#if MIN_VERSION_base(4,10,0) && !(MIN_VERSION_base(4,12,0))+ hiding (throw)+import GHC.Exts (RuntimeRep, TYPE, raise#)++-- | Throw an exception. Exceptions may be thrown from purely+-- functional code, but may only be caught within the 'IO' monad.+throw :: forall (r :: RuntimeRep). forall (a :: TYPE r). forall e.+ Exception e => e -> a+throw e = raise# (toException e)+#endif
+ src/Control/Exception/Compat/Repl.hs view
@@ -0,0 +1,8 @@+{-# LANGUAGE PackageImports #-}+{-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-}+-- | Reexports "Control.Exception.Compat"+-- from a globally unique namespace.+module Control.Exception.Compat.Repl (+ module Control.Exception.Compat+) where+import "this" Control.Exception.Compat
+ src/Data/Functor/Contravariant/Compat.hs view
@@ -0,0 +1,10 @@+{-# LANGUAGE CPP, NoImplicitPrelude #-}+module Data.Functor.Contravariant.Compat (+#if MIN_VERSION_base(4,12,0)+ module Base+#endif+) where++#if MIN_VERSION_base(4,12,0)+import Data.Functor.Contravariant as Base+#endif
+ src/Data/Functor/Contravariant/Compat/Repl.hs view
@@ -0,0 +1,8 @@+{-# LANGUAGE PackageImports #-}+{-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-}+-- | Reexports "Data.Functor.Contravariant.Compat"+-- from a globally unique namespace.+module Data.Functor.Contravariant.Compat.Repl (+ module Data.Functor.Contravariant.Compat+) where+import "this" Data.Functor.Contravariant.Compat
src/Prelude/Compat.hs view
@@ -1,6 +1,10 @@ {-# LANGUAGE CPP, NoImplicitPrelude #-}+#if MIN_VERSION_base(4,10,0) && !(MIN_VERSION_base(4,12,0))+{-# LANGUAGE RankNTypes #-}+{-# LANGUAGE TypeInType #-}+#endif module Prelude.Compat (-#if MIN_VERSION_base(4,11,0)+#if MIN_VERSION_base(4,12,0) module Base #else either@@ -267,6 +271,9 @@ #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 (($!))+# endif #else @@ -311,6 +318,10 @@ import Data.Semigroup as Base (Semigroup((<>))) #endif +#if MIN_VERSION_base(4,10,0) && !(MIN_VERSION_base(4,12,0))+import GHC.Exts (TYPE)+#endif+ #if !(MIN_VERSION_base(4,9,0)) -- | A variant of 'error' that does not produce a stack trace. --@@ -318,4 +329,13 @@ errorWithoutStackTrace :: [Char] -> a errorWithoutStackTrace s = error s {-# NOINLINE errorWithoutStackTrace #-}+#endif++#if MIN_VERSION_base(4,10,0) && !(MIN_VERSION_base(4,12,0))+-- | Strict (call-by-value) application operator. It takes a function and an+-- argument, evaluates the argument to weak head normal form (WHNF), then calls+-- the function with that value.++($!) :: forall r a (b :: TYPE r). (a -> b) -> a -> b+f $! x = let !vx = x in f vx -- see #2273 #endif