base 4.12.0.0 → 4.13.0.0

raw patch · 139 files changed

+8991/−7925 lines, 139 filesPVP ok

version bump matches the API change (PVP)

API changes (from Hackage documentation)

Files

• Control/Applicative.hs +2/−2
• Control/Arrow.hs +2/−2
• Control/Category.hs +4/−5
• Control/Concurrent/Chan.hs +2/−2
• Control/Concurrent/MVar.hs +4/−4
• Control/Concurrent/QSem.hs +1/−2
• Control/Concurrent/QSemN.hs +1/−3
• Control/Exception.hs +11/−8
• Control/Monad.hs +6/−4
• Control/Monad/Fail.hs +2/−2
• Control/Monad/Fix.hs +5/−5
• Control/Monad/ST/Imp.hs +3/−3
• Control/Monad/ST/Lazy/Imp.hs +9/−12
• Control/Monad/ST/Lazy/Safe.hs +1/−1
• Control/Monad/ST/Lazy/Unsafe.hs +1/−1
• Control/Monad/Zip.hs +8/−9
• Data/Bifoldable.hs +7/−3
• Data/Bitraversable.hs +11/−25
• Data/Bits.hs +16/−60
• Data/Either.hs +3/−3
• Data/Fixed.hs +9/−8
• Data/Foldable.hs +130/−12
• Data/Function.hs +5/−3
• Data/Functor.hs +42/−16
• Data/Functor/Classes.hs +8/−7
• Data/Functor/Compose.hs +0/−2
• Data/Functor/Const.hs +2/−2
• Data/Functor/Contravariant.hs +8/−20
• Data/Functor/Product.hs +0/−3
• Data/Functor/Sum.hs +0/−2
• Data/Functor/Utils.hs +2/−2
• Data/IORef.hs +24/−29
• Data/List.hs +2/−2
• Data/List/NonEmpty.hs +1/−1
• Data/Maybe.hs +7/−6
• Data/Monoid.hs +44/−9
• Data/OldList.hs +169/−21
• Data/Proxy.hs +2/−2
• Data/STRef.hs +1/−1
• Data/Semigroup.hs +45/−11
• Data/Semigroup/Internal.hs-boot +1/−1
• Data/Traversable.hs +21/−35
• Data/Type/Equality.hs +2/−26
• Data/Typeable/Internal.hs +13/−3
• Debug/Trace.hs +3/−2
• Foreign/C/Error.hs +5/−1
• Foreign/C/Types.hs +6/−5
• Foreign/Concurrent.hs +12/−11
• Foreign/ForeignPtr/Imp.hs +1/−1
• Foreign/Marshal/Array.hs +18/−40
• Foreign/Marshal/Pool.hs +11/−22
• GHC/Arr.hs +5/−5
• GHC/Base.hs +39/−64
• GHC/Conc/IO.hs +2/−2
• GHC/Conc/Sync.hs +20/−7
• GHC/Conc/Windows.hs +6/−7
• GHC/Desugar.hs +1/−1
• GHC/Enum.hs +5/−29
• GHC/Environment.hs +4/−4
• GHC/Err.hs +4/−2
• GHC/Event/Control.hs +1/−1
• GHC/Event/Internal.hs +1/−1
• GHC/Event/KQueue.hsc +4/−4
• GHC/Event/PSQ.hs +0/−1
• GHC/Event/Thread.hs +4/−4
• GHC/Exception.hs +1/−1
• GHC/Exception/Type.hs +1/−1
• GHC/Exts.hs +28/−1
• GHC/Float.hs +19/−18
• GHC/Float/ConversionUtils.hs +1/−1
• GHC/Float/RealFracMethods.hs +1/−1
• GHC/Foreign.hs +6/−5
• GHC/ForeignPtr.hs +12/−10
• GHC/GHCi.hs +1/−1
• GHC/GHCi/Helpers.hs +36/−0
• GHC/Generics.hs +24/−28
• GHC/IO.hs +8/−8
• GHC/IO.hs-boot +1/−1
• GHC/IO/BufferedIO.hs +2/−2
• GHC/IO/Device.hs +3/−3
• GHC/IO/Encoding.hs +4/−3
• GHC/IO/Encoding/Failure.hs +2/−2
• GHC/IO/Encoding/Iconv.hs +1/−1
• GHC/IO/Encoding/Types.hs +2/−2
• GHC/IO/Exception.hs +3/−2
• GHC/IO/FD.hs +18/−5
• GHC/IO/Handle.hs +23/−21
• GHC/IO/Handle/FD.hs +8/−4
• GHC/IO/Handle/Internals.hs +1/−1
• GHC/IO/Handle/Lock.hsc +2/−0
• GHC/IO/Handle/Text.hs +12/−12
• GHC/IO/Handle/Types.hs +7/−7
• GHC/IO/IOMode.hs +1/−1
• GHC/IO/Unsafe.hs +3/−2
• GHC/IOArray.hs +1/−1
• GHC/IORef.hs +124/−7
• GHC/Int.hs +31/−11
• GHC/List.hs +86/−38
• GHC/MVar.hs +1/−1
• GHC/Maybe.hs +3/−2
• GHC/Natural.hs +58/−41
• GHC/Num.hs +10/−36
• GHC/Pack.hs +1/−1
• GHC/Ptr.hs +1/−1
• GHC/RTS/Flags.hsc +16/−16
• GHC/Read.hs +1/−8
• GHC/Real.hs +16/−46
• GHC/Records.hs +8/−1
• GHC/ResponseFile.hs +2/−2
• GHC/ST.hs +7/−7
• GHC/STRef.hs +1/−1
• GHC/Show.hs +1/−2
• GHC/Stable.hs +2/−2
• GHC/Stack/Types.hs +4/−4
• GHC/StaticPtr.hs +5/−7
• GHC/Storable.hs +1/−1
• GHC/TopHandler.hs +2/−2
• GHC/TypeLits.hs +4/−1
• GHC/TypeNats.hs +59/−0
• GHC/Unicode.hs +2/−2
• GHC/Weak.hs +1/−1
• GHC/Word.hs +31/−11
• Prelude.hs +2/−1
• System/Environment/ExecutablePath.hsc +48/−0
• System/Exit.hs +1/−1
• System/IO.hs +13/−12
• System/Posix/Internals.hs +1/−1
• Text/ParserCombinators/ReadP.hs +1/−4
• Text/ParserCombinators/ReadPrec.hs +0/−1
• Text/Printf.hs +6/−6
• Text/Show/Functions.hs +1/−1
• Type/Reflection.hs +3/−3
• Unsafe/Coerce.hs +7/−6
• base.cabal +5/−5
• cbits/WCsubst.c +5094/−4746
• cbits/fs.c +2/−4
• changelog.md +36/−5
• config.guess +480/−308
• config.sub +1792/−1830

@@ -118,8 +118,8 @@ -- See Data.Traversable for Traversable instance due to import loops  -- |--- > f '<$>' 'ZipList' xs1 '<*>' ... '<*>' 'ZipList' xsN--- >     = 'ZipList' (zipWithN f xs1 ... xsN)+-- > f <$> ZipList xs1 <*> ... <*> ZipList xsN+-- >     = ZipList (zipWithN f xs1 ... xsN) -- -- where @zipWithN@ refers to the @zipWith@ function of the appropriate arity -- (@zipWith@, @zipWith3@, @zipWith4@, ...). For example:

@@ -76,7 +76,7 @@ -- --  * @'first' f >>> 'arr' ('id' *** g) = 'arr' ('id' *** g) >>> 'first' f@ -----  * @'first' ('first' f) >>> 'arr' 'assoc' = 'arr' 'assoc' >>> 'first' f@+--  * @'first' ('first' f) >>> 'arr' assoc = 'arr' assoc >>> 'first' f@ -- -- where --@@ -209,7 +209,7 @@ -- --  * @'left' f >>> 'arr' ('id' +++ g) = 'arr' ('id' +++ g) >>> 'left' f@ -----  * @'left' ('left' f) >>> 'arr' 'assocsum' = 'arr' 'assocsum' >>> 'left' f@+--  * @'left' ('left' f) >>> 'arr' assocsum = 'arr' assocsum >>> 'left' f@ -- -- where --

@@ -30,11 +30,10 @@  -- | A class for categories. Instances should satisfy the laws ----- @--- f '.' 'id'  =  f  -- (right identity)--- 'id' '.' f  =  f  -- (left identity)--- f '.' (g '.' h)  =  (f '.' g) '.' h  -- (associativity)--- @+-- [Right identity] @f '.' 'id'  =  f@+-- [Left identity]  @'id' '.' f  =  f@+-- [Associativity]  @f '.' (g '.' h)  =  (f '.' g) '.' h@+-- class Category cat where     -- | the identity morphism     id :: cat a a

@@ -102,8 +102,8 @@ -- guarantees of 'MVar's (e.g. threads blocked in this operation are woken up in -- FIFO order). ----- Throws 'BlockedIndefinitelyOnMVar' when the channel is empty and no other--- thread holds a reference to the channel.+-- Throws 'Control.Exception.BlockedIndefinitelyOnMVar' when the channel is+-- empty and no other thread holds a reference to the channel. readChan :: Chan a -> IO a readChan (Chan readVar _) = do   modifyMVar readVar $ \read_end -> do

@@ -33,12 +33,12 @@ -- -- === Applicability ----- 'MVar's offer more flexibility than 'IORef's, but less flexibility--- than 'STM'.  They are appropriate for building synchronization+-- 'MVar's offer more flexibility than 'Data.IORef.IORef's, but less flexibility+-- than 'GHC.Conc.STM'.  They are appropriate for building synchronization -- primitives and performing simple interthread communication; however -- they are very simple and susceptible to race conditions, deadlocks or -- uncaught exceptions.  Do not use them if you need perform larger--- atomic operations such as reading from multiple variables: use 'STM'+-- atomic operations such as reading from multiple variables: use 'GHC.Conc.STM' -- instead. -- -- In particular, the "bigger" functions in this module ('swapMVar',@@ -70,7 +70,7 @@ -- -- 'MVar' operations are always observed to take place in the order -- they are written in the program, regardless of the memory model of--- the underlying machine.  This is in contrast to 'IORef' operations+-- the underlying machine.  This is in contrast to 'Data.IORef.IORef' operations -- which may appear out-of-order to another thread in some cases. -- -- === Example

@@ -1,6 +1,5 @@ {-# LANGUAGE Safe #-} {-# LANGUAGE BangPatterns #-}-{-# OPTIONS_GHC -funbox-strict-fields #-}  ----------------------------------------------------------------------------- -- |@@ -39,7 +38,7 @@ -- -- is safe; it never loses a unit of the resource. ---data QSem = QSem !(MVar (Int, [MVar ()], [MVar ()]))+newtype QSem = QSem (MVar (Int, [MVar ()], [MVar ()]))  -- The semaphore state (i, xs, ys): --

@@ -1,6 +1,4 @@ {-# LANGUAGE Safe #-}-{-# LANGUAGE BangPatterns #-}-{-# OPTIONS_GHC -funbox-strict-fields #-}  ----------------------------------------------------------------------------- -- |@@ -41,7 +39,7 @@ -- -- is safe; it never loses any of the resource. ---data QSemN = QSemN !(MVar (Int, [(Int, MVar ())], [(Int, MVar ())]))+newtype QSemN = QSemN (MVar (Int, [(Int, MVar ())], [(Int, MVar ())]))  -- The semaphore state (i, xs, ys): --

@@ -264,7 +264,7 @@ >                 (\e -> handler)  If you need to unmask asynchronous exceptions again in the exception-handler, 'restore' can be used there too.+handler, @restore@ can be used there too.  Note that 'try' and friends /do not/ have a similar default, because there is no exception handler in this case.  Don't use 'try' for@@ -332,21 +332,24 @@  The following operations are guaranteed not to be interruptible: - * operations on 'IORef' from "Data.IORef"+ * operations on 'Data.IORef.IORef' from "Data.IORef" - * STM transactions that do not use 'retry'+ * STM transactions that do not use 'GHC.Conc.retry'   * everything from the @Foreign@ modules - * everything from @Control.Exception@ except for 'throwTo'+ * everything from "Control.Exception" except for 'throwTo' - * @tryTakeMVar@, @tryPutMVar@, @isEmptyMVar@+ * 'Control.Concurrent.MVar.tryTakeMVar', 'Control.Concurrent.MVar.tryPutMVar',+   'Control.Concurrent.MVar.isEmptyMVar' - * @takeMVar@ if the @MVar@ is definitely full, and conversely @putMVar@ if the @MVar@ is definitely empty+ * 'Control.Concurrent.MVar.takeMVar' if the 'Control.Concurrent.MVar.MVar' is+   definitely full, and conversely 'Control.Concurrent.MVar.putMVar' if the+   'Control.Concurrent.MVar.MVar' is definitely empty - * @newEmptyMVar@, @newMVar@+ * 'Control.Concurrent.MVar.newEmptyMVar', 'Control.Concurrent.MVar.newMVar' - * @forkIO@, @forkIOUnmasked@, @myThreadId@+ * 'Control.Concurrent.forkIO', 'Control.Concurrent.myThreadId'  -} 

@@ -19,7 +19,8 @@     -- * Functor and monad classes        Functor(fmap)-    , Monad((>>=), (>>), return, fail)+    , Monad((>>=), (>>), return)+    , MonadFail(fail)     , MonadPlus(mzero, mplus)     -- * Functions @@ -75,6 +76,7 @@     , (<$!>)     ) where +import Control.Monad.Fail ( MonadFail(fail) ) import Data.Foldable ( Foldable, sequence_, sequenceA_, msum, mapM_, foldlM, forM_ ) import Data.Functor ( void, (<$>) ) import Data.Traversable ( forM, mapM, traverse, sequence, sequenceA )@@ -131,7 +133,7 @@ guard True      =  pure () guard False     =  empty --- | This generalizes the list-based 'filter' function.+-- | This generalizes the list-based 'Data.List.filter' function.  {-# INLINE filterM #-} filterM          :: (Applicative m) => (a -> m Bool) -> [a] -> m [a]@@ -188,7 +190,7 @@  -- | The 'mapAndUnzipM' function maps its first argument over a list, returning -- the result as a pair of lists. This function is mainly used with complicated--- data structures or a state-transforming monad.+-- data structures or a state monad. mapAndUnzipM      :: (Applicative m) => (a -> m (b,c)) -> [a] -> m ([b], [c]) {-# INLINE mapAndUnzipM #-} mapAndUnzipM f xs =  unzip <$> traverse f xs@@ -203,7 +205,7 @@ {-# INLINE zipWithM_ #-} zipWithM_ f xs ys =  sequenceA_ (zipWith f xs ys) -{- | The 'foldM' function is analogous to 'foldl', except that its result is+{- | The 'foldM' function is analogous to 'Data.Foldable.foldl', except that its result is encapsulated in a monad. Note that 'foldM' works from left-to-right over the list arguments. This could be an issue where @('>>')@ and the `folded function' are not commutative.

@@ -50,13 +50,13 @@ -- only a single data constructor, and irrefutable patterns (@~pat@). -- -- Instances of 'MonadFail' should satisfy the following law: @fail s@ should--- be a left zero for '>>=',+-- be a left zero for 'Control.Monad.>>=', -- -- @ -- fail s >>= f  =  fail s -- @ ----- If your 'Monad' is also 'MonadPlus', a popular definition is+-- If your 'Monad' is also 'Control.Monad.MonadPlus', a popular definition is -- -- @ -- fail _ = mzero

@@ -39,17 +39,17 @@ -- | Monads having fixed points with a \'knot-tying\' semantics. -- Instances of 'MonadFix' should satisfy the following laws: ----- [/purity/]---      @'mfix' ('return' . h)  =  'return' ('fix' h)@+-- [Purity]+--      @'mfix' ('Control.Monad.return' . h)  =  'Control.Monad.return' ('fix' h)@ ----- [/left shrinking/ (or /tightening/)]+-- [Left shrinking (or Tightening)] --      @'mfix' (\\x -> a >>= \\y -> f x y)  =  a >>= \\y -> 'mfix' (\\x -> f x y)@ ----- [/sliding/]+-- [Sliding] --      @'mfix' ('Control.Monad.liftM' h . f)  =  'Control.Monad.liftM' h ('mfix' (f . h))@, --      for strict @h@. ----- [/nesting/]+-- [Nesting] --      @'mfix' (\\x -> 'mfix' (\\y -> f x y))  =  'mfix' (\\x -> f x x)@ -- -- This class is used in the translation of the recursive @do@ notation

@@ -1,6 +1,6 @@ {-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE Unsafe #-}-{-# OPTIONS_HADDOCK hide #-}+{-# OPTIONS_HADDOCK not-home #-}  ----------------------------------------------------------------------------- -- |@@ -24,7 +24,7 @@         runST,         fixST, -        -- * Converting 'ST' to 'IO'+        -- * Converting 'ST' to 'Prelude.IO'         RealWorld,              -- abstract         stToIO, @@ -45,7 +45,7 @@                         ( catch, throwIO, NonTermination (..)                         , BlockedIndefinitelyOnMVar (..) ) --- | Allow the result of a state transformer computation to be used (lazily)+-- | Allow the result of an 'ST' computation to be used (lazily) -- inside the computation. -- -- Note that if @f@ is strict, @'fixST' f = _|_@.

@@ -1,7 +1,7 @@ {-# LANGUAGE Unsafe #-} {-# LANGUAGE BangPatterns #-} {-# LANGUAGE MagicHash, UnboxedTuples, RankNTypes #-}-{-# OPTIONS_HADDOCK hide #-}+{-# OPTIONS_HADDOCK not-home #-}  ----------------------------------------------------------------------------- -- |@@ -14,7 +14,7 @@ -- Portability :  non-portable (requires universal quantification for runST) -- -- This module presents an identical interface to "Control.Monad.ST",--- except that the monad delays evaluation of state operations until+-- except that the monad delays evaluation of 'ST' operations until -- a value depending on them is required. -- -----------------------------------------------------------------------------@@ -46,10 +46,10 @@ import GHC.Base import qualified Control.Monad.Fail as Fail --- | The lazy state-transformer monad.--- A computation of type @'ST' s a@ transforms an internal state indexed--- by @s@, and returns a value of type @a@.--- The @s@ parameter is either+-- | The lazy @'ST' monad.+-- The ST monad allows for destructive updates, but is escapable (unlike IO).+-- A computation of type @'ST' s a@ returns a value of type @a@, and+-- execute in "thread" @s@. The @s@ parameter is either -- -- * an uninstantiated type variable (inside invocations of 'runST'), or --@@ -180,9 +180,6 @@  -- | @since 2.01 instance Monad (ST s) where--    fail s   = errorWithoutStackTrace s-     (>>) = (*>)      m >>= k = ST $ \ s ->@@ -198,13 +195,13 @@ instance Fail.MonadFail (ST s) where     fail s = errorWithoutStackTrace s --- | Return the value computed by a state transformer computation.+-- | Return the value computed by an 'ST' computation. -- The @forall@ ensures that the internal state used by the 'ST' -- computation is inaccessible to the rest of the program. runST :: (forall s. ST s a) -> a runST (ST st) = runRW# (\s -> case st (S# s) of (r, _) -> r) --- | Allow the result of a state transformer computation to be used (lazily)+-- | Allow the result of an 'ST' computation to be used (lazily) -- inside the computation. -- Note that if @f@ is strict, @'fixST' f = _|_@. fixST :: (a -> ST s a) -> ST s a@@ -243,7 +240,7 @@ lazyToStrictST (ST m) = GHC.ST.ST $ \s ->         case (m (S# s)) of (a, S# s') -> (# s', a #) --- | A monad transformer embedding lazy state transformers in the 'IO'+-- | A monad transformer embedding lazy 'ST' in the 'IO' -- monad.  The 'RealWorld' parameter indicates that the internal state -- used by the 'ST' computation is a special one supplied by the 'IO' -- monad, and thus distinct from those used by invocations of 'runST'.

@@ -11,7 +11,7 @@ -- Portability :  non-portable (requires universal quantification for runST) -- -- This module presents an identical interface to "Control.Monad.ST",--- except that the monad delays evaluation of state operations until+-- except that the monad delays evaluation of 'ST' operations until -- a value depending on them is required. -- -- Safe API only.

@@ -11,7 +11,7 @@ -- Portability :  non-portable (requires universal quantification for runST) -- -- This module presents an identical interface to "Control.Monad.ST",--- except that the monad delays evaluation of state operations until+-- except that the monad delays evaluation of 'ST' operations until -- a value depending on them is required. -- -- Unsafe API.

@@ -26,19 +26,18 @@ import qualified Data.List.NonEmpty as NE import GHC.Generics --- | `MonadZip` type class. Minimal definition: `mzip` or `mzipWith`------ Instances should satisfy the laws:+-- | Instances should satisfy the laws: ----- * Naturality :+-- [Naturality] -----   > liftM (f *** g) (mzip ma mb) = mzip (liftM f ma) (liftM g mb)+--     @'liftM' (f 'Control.Arrow.***' g) ('mzip' ma mb)+--         = 'mzip' ('liftM' f ma) ('liftM' g mb)@ ----- * Information Preservation:+-- [Information Preservation] -----   > liftM (const ()) ma = liftM (const ()) mb---   > ==>---   > munzip (mzip ma mb) = (ma, mb)+--     @'liftM' ('Prelude.const' ()) ma = 'liftM' ('Prelude.const' ()) mb@+--         implies+--     @'munzip' ('mzip' ma mb) = (ma, mb)@ -- class Monad m => MonadZip m where     {-# MINIMAL mzip | mzipWith #-}

@@ -76,13 +76,17 @@ -- 'bifoldr' f g z t ≡ 'appEndo' ('bifoldMap' (Endo . f) (Endo . g) t) z -- @ ----- If the type is also a 'Bifunctor' instance, it should satisfy:+-- If the type is also a 'Data.Bifunctor.Bifunctor' instance, it should satisfy: ----- > 'bifoldMap' f g ≡ 'bifold' . 'bimap' f g+-- @+-- 'bifoldMap' f g ≡ 'bifold' . 'Data.Bifunctor.bimap' f g+-- @ -- -- which implies that ----- > 'bifoldMap' f g . 'bimap' h i ≡ 'bifoldMap' (f . h) (g . i)+-- @+-- 'bifoldMap' f g . 'Data.Bifunctor.bimap' h i ≡ 'bifoldMap' (f . h) (g . i)+-- @ -- -- @since 4.10.0.0 class Bifoldable p where

@@ -44,16 +44,19 @@ -- -- A definition of 'bitraverse' must satisfy the following laws: ----- [/naturality/]+-- [Naturality] --   @'bitraverse' (t . f) (t . g) ≡ t . 'bitraverse' f g@ --   for every applicative transformation @t@ ----- [/identity/]+-- [Identity] --   @'bitraverse' 'Identity' 'Identity' ≡ 'Identity'@ ----- [/composition/]---   @'Compose' . 'fmap' ('bitraverse' g1 g2) . 'bitraverse' f1 f2---     ≡ 'traverse' ('Compose' . 'fmap' g1 . f1) ('Compose' . 'fmap' g2 . f2)@+-- [Composition]+--   @'Data.Functor.Compose.Compose' .+--    'fmap' ('bitraverse' g1 g2) .+--    'bitraverse' f1 f2+--     ≡ 'bitraverse' ('Data.Functor.Compose.Compose' . 'fmap' g1 . f1)+--                  ('Data.Functor.Compose.Compose' . 'fmap' g2 . f2)@ -- -- where an /applicative transformation/ is a function --@@ -66,26 +69,9 @@ -- t (f '<*>' x) = t f '<*>' t x -- @ ----- and the identity functor 'Identity' and composition functors 'Compose' are--- defined as------ > newtype Identity a = Identity { runIdentity :: a }--- >--- > instance Functor Identity where--- >   fmap f (Identity x) = Identity (f x)--- >--- > instance Applicative Identity where--- >   pure = Identity--- >   Identity f <*> Identity x = Identity (f x)--- >--- > newtype Compose f g a = Compose (f (g a))--- >--- > instance (Functor f, Functor g) => Functor (Compose f g) where--- >   fmap f (Compose x) = Compose (fmap (fmap f) x)--- >--- > instance (Applicative f, Applicative g) => Applicative (Compose f g) where--- >   pure = Compose . pure . pure--- >   Compose f <*> Compose x = Compose ((<*>) <$> f <*> x)+-- and the identity functor 'Identity' and composition functors+-- 'Data.Functor.Compose.Compose' are from "Data.Functor.Identity" and+-- "Data.Functor.Compose". -- -- Some simple examples are 'Either' and '(,)': --

@@ -63,10 +63,6 @@ import GHC.Base import GHC.Real -#if defined(MIN_VERSION_integer_gmp)-import GHC.Integer.GMP.Internals (bitInteger, popCountInteger)-#endif- infixl 8 `shift`, `rotate`, `shiftL`, `shiftR`, `rotateL`, `rotateR` infixl 7 .&. infixl 6 `xor`@@ -209,7 +205,8 @@     x `complementBit` i = x `xor` bit i      {-| Shift the argument left by the specified number of bits-        (which must be non-negative).+        (which must be non-negative). Some instances may throw an+        'Control.Exception.Overflow' exception if given a negative input.          An instance can define either this and 'shiftR' or the unified         'shift', depending on which is more convenient for the type in@@ -231,7 +228,8 @@      {-| Shift the first argument right by the specified number of bits. The         result is undefined for negative shift amounts and shift amounts-        greater or equal to the 'bitSize'.+        greater or equal to the 'bitSize'. Some instances may throw an+        'Control.Exception.Overflow' exception if given a negative input.          Right shifts perform sign extension on signed number types;         i.e. they fill the top bits with 1 if the @x@ is negative@@ -454,9 +452,13 @@     (I# x#) `shift` (I# i#)         | isTrue# (i# >=# 0#)      = I# (x# `iShiftL#` i#)         | otherwise                = I# (x# `iShiftRA#` negateInt# i#)-    (I# x#) `shiftL` (I# i#)       = I# (x# `iShiftL#` i#)+    (I# x#) `shiftL` (I# i#)+        | isTrue# (i# >=# 0#)      = I# (x# `iShiftL#` i#)+        | otherwise                = overflowError     (I# x#) `unsafeShiftL` (I# i#) = I# (x# `uncheckedIShiftL#` i#)-    (I# x#) `shiftR` (I# i#)       = I# (x# `iShiftRA#` i#)+    (I# x#) `shiftR` (I# i#)+        | isTrue# (i# >=# 0#)      = I# (x# `iShiftRA#` i#)+        | otherwise                = overflowError     (I# x#) `unsafeShiftR` (I# i#) = I# (x# `uncheckedIShiftRA#` i#)      {-# INLINE rotate #-}       -- See Note [Constant folding for rotate]@@ -492,9 +494,13 @@     (W# x#) `shift` (I# i#)         | isTrue# (i# >=# 0#)      = W# (x# `shiftL#` i#)         | otherwise                = W# (x# `shiftRL#` negateInt# i#)-    (W# x#) `shiftL` (I# i#)       = W# (x# `shiftL#` i#)+    (W# x#) `shiftL` (I# i#)+        | isTrue# (i# >=# 0#)      = W# (x# `shiftL#` i#)+        | otherwise                = overflowError     (W# x#) `unsafeShiftL` (I# i#) = W# (x# `uncheckedShiftL#` i#)-    (W# x#) `shiftR` (I# i#)       = W# (x# `shiftRL#` i#)+    (W# x#) `shiftR` (I# i#)+        | isTrue# (i# >=# 0#)      = W# (x# `shiftRL#` i#)+        | otherwise                = overflowError     (W# x#) `unsafeShiftR` (I# i#) = W# (x# `uncheckedShiftRL#` i#)     (W# x#) `rotate` (I# i#)         | isTrue# (i'# ==# 0#) = W# x#@@ -526,13 +532,8 @@    testBit x (I# i) = testBitInteger x i    zeroBits   = 0 -#if defined(MIN_VERSION_integer_gmp)    bit (I# i#) = bitInteger i#    popCount x  = I# (popCountInteger x)-#else-   bit        = bitDefault-   popCount   = popCountDefault-#endif     rotate x i = shift x i   -- since an Integer never wraps around @@ -540,7 +541,6 @@    bitSize _  = errorWithoutStackTrace "Data.Bits.bitSize(Integer)"    isSigned _ = True -#if defined(MIN_VERSION_integer_gmp) -- | @since 4.8.0 instance Bits Natural where    (.&.) = andNatural@@ -563,50 +563,6 @@    bitSizeMaybe _ = Nothing    bitSize _  = errorWithoutStackTrace "Data.Bits.bitSize(Natural)"    isSigned _ = False-#else--- | @since 4.8.0.0-instance Bits Natural where-  Natural n .&. Natural m = Natural (n .&. m)-  {-# INLINE (.&.) #-}-  Natural n .|. Natural m = Natural (n .|. m)-  {-# INLINE (.|.) #-}-  xor (Natural n) (Natural m) = Natural (xor n m)-  {-# INLINE xor #-}-  complement _ = errorWithoutStackTrace "Bits.complement: Natural complement undefined"-  {-# INLINE complement #-}-  shift (Natural n) = Natural . shift n-  {-# INLINE shift #-}-  rotate (Natural n) = Natural . rotate n-  {-# INLINE rotate #-}-  bit = Natural . bit-  {-# INLINE bit #-}-  setBit (Natural n) = Natural . setBit n-  {-# INLINE setBit #-}-  clearBit (Natural n) = Natural . clearBit n-  {-# INLINE clearBit #-}-  complementBit (Natural n) = Natural . complementBit n-  {-# INLINE complementBit #-}-  testBit (Natural n) = testBit n-  {-# INLINE testBit #-}-  bitSizeMaybe _ = Nothing-  {-# INLINE bitSizeMaybe #-}-  bitSize = errorWithoutStackTrace "Natural: bitSize"-  {-# INLINE bitSize #-}-  isSigned _ = False-  {-# INLINE isSigned #-}-  shiftL (Natural n) = Natural . shiftL n-  {-# INLINE shiftL #-}-  shiftR (Natural n) = Natural . shiftR n-  {-# INLINE shiftR #-}-  rotateL (Natural n) = Natural . rotateL n-  {-# INLINE rotateL #-}-  rotateR (Natural n) = Natural . rotateR n-  {-# INLINE rotateR #-}-  popCount (Natural n) = popCount n-  {-# INLINE popCount #-}-  zeroBits = Natural 0--#endif  ----------------------------------------------------------------------------- 

@@ -164,7 +164,7 @@ -- -- We create two values of type @'Either' 'String' 'Int'@, one using the -- 'Left' constructor and another using the 'Right' constructor. Then--- we apply \"either\" the 'length' function (if we have a 'String')+-- we apply \"either\" the 'Prelude.length' function (if we have a 'String') -- or the \"times-two\" function (if we have an 'Int'): -- -- >>> let s = Left "foo" :: Either String Int@@ -192,7 +192,7 @@ -- lefts   :: [Either a b] -> [a] lefts x = [a | Left a <- x]-{-# INLINEABLE lefts #-} -- otherwise doesnt get an unfolding, see #13689+{-# INLINEABLE lefts #-} -- otherwise doesn't get an unfolding, see #13689  -- | Extracts from a list of 'Either' all the 'Right' elements. -- All the 'Right' elements are extracted in order.@@ -207,7 +207,7 @@ -- rights   :: [Either a b] -> [b] rights x = [a | Right a <- x]-{-# INLINEABLE rights #-} -- otherwise doesnt get an unfolding, see #13689+{-# INLINEABLE rights #-} -- otherwise doesn't get an unfolding, see #13689  -- | Partitions a list of 'Either' into two lists. -- All the 'Left' elements are extracted, in order, to the first

@@ -12,11 +12,12 @@ -- Portability :  portable -- -- This module defines a \"Fixed\" type for fixed-precision arithmetic.--- The parameter to Fixed is any type that's an instance of HasResolution.--- HasResolution has a single method that gives the resolution of the Fixed type.+-- The parameter to 'Fixed' is any type that's an instance of 'HasResolution'.+-- 'HasResolution' has a single method that gives the resolution of the 'Fixed'+-- type. ----- This module also contains generalisations of div, mod, and divmod to work--- with any Real instance.+-- This module also contains generalisations of 'div', 'mod', and 'divMod' to+-- work with any 'Real' instance. -- ----------------------------------------------------------------------------- @@ -42,16 +43,16 @@  default () -- avoid any defaulting shenanigans --- | generalisation of 'div' to any instance of Real+-- | generalisation of 'div' to any instance of 'Real' div' :: (Real a,Integral b) => a -> a -> b div' n d = floor ((toRational n) / (toRational d)) --- | generalisation of 'divMod' to any instance of Real+-- | generalisation of 'divMod' to any instance of 'Real' divMod' :: (Real a,Integral b) => a -> a -> (b,a) divMod' n d = (f,n - (fromIntegral f) * d) where     f = div' n d --- | generalisation of 'mod' to any instance of Real+-- | generalisation of 'mod' to any instance of 'Real' mod' :: (Real a) => a -> a -> a mod' n d = n - (fromInteger f) * d where     f = div' n d@@ -157,7 +158,7 @@  -- | @since 2.01 instance (HasResolution a) => Show (Fixed a) where-    show = showFixed False+    showsPrec p n = showParen (p > 6 && n < 0) $ showString $ showFixed False n  -- | @since 4.3.0.0 instance (HasResolution a) => Read (Fixed a) where

@@ -130,6 +130,12 @@     -- This INLINE allows more list functions to fuse. See Trac #9848.     foldMap f = foldr (mappend . f) mempty +    -- | A variant of 'foldMap' that is strict in the accumulator.+    --+    -- @since 4.13.0.0+    foldMap' :: Monoid m => (a -> m) -> t a -> m+    foldMap' f = foldl' (\ acc a -> acc <> f a) mempty+     -- | Right-associative fold of a structure.     --     -- In the case of lists, 'foldr', when applied to a binary operator, a@@ -153,6 +159,7 @@     -- | Right-associative fold of a structure, but with strict application of     -- the operator.     --+    -- @since 4.6.0.0     foldr' :: (a -> b -> b) -> b -> t a -> b     foldr' f z0 xs = foldl f' id xs z0       where f' k x z = k $! f x z@@ -172,8 +179,8 @@     --     -- Also note that if you want an efficient left-fold, you probably want to     -- use 'foldl'' instead of 'foldl'. The reason for this is that latter does-    -- not force the "inner" results (e.g. @z `f` x1@ in the above example)-    -- before applying them to the operator (e.g. to @(`f` x2)@). This results+    -- not force the "inner" results (e.g. @z \`f\` x1@ in the above example)+    -- before applying them to the operator (e.g. to @(\`f\` x2)@). This results     -- in a thunk chain @O(n)@ elements long, which then must be evaluated from     -- the outside-in.     --@@ -198,8 +205,9 @@     -- For a general 'Foldable' structure this should be semantically identical     -- to,     ---    -- @foldl f z = 'List.foldl'' f z . 'toList'@+    -- @foldl' f z = 'List.foldl'' f z . 'toList'@     --+    -- @since 4.6.0.0     foldl' :: (b -> a -> b) -> b -> t a -> b     foldl' f z0 xs = foldr f' id xs z0       where f' x k z = k $! f z x@@ -229,6 +237,8 @@                          Just x  -> f x y)      -- | List of elements of a structure, from left to right.+    --+    -- @since 4.8.0.0     toList :: t a -> [a]     {-# INLINE toList #-}     toList t = build (\ c n -> foldr c n t)@@ -236,35 +246,49 @@     -- | Test whether the structure is empty. The default implementation is     -- optimized for structures that are similar to cons-lists, because there     -- is no general way to do better.+    --+    -- @since 4.8.0.0     null :: t a -> Bool     null = foldr (\_ _ -> False) True      -- | Returns the size/length of a finite structure as an 'Int'.  The     -- default implementation is optimized for structures that are similar to     -- cons-lists, because there is no general way to do better.+    --+    -- @since 4.8.0.0     length :: t a -> Int     length = foldl' (\c _ -> c+1) 0      -- | Does the element occur in the structure?+    --+    -- @since 4.8.0.0     elem :: Eq a => a -> t a -> Bool     elem = any . (==)      -- | The largest element of a non-empty structure.+    --+    -- @since 4.8.0.0     maximum :: forall a . Ord a => t a -> a     maximum = fromMaybe (errorWithoutStackTrace "maximum: empty structure") .        getMax . foldMap (Max #. (Just :: a -> Maybe a))      -- | The least element of a non-empty structure.+    --+    -- @since 4.8.0.0     minimum :: forall a . Ord a => t a -> a     minimum = fromMaybe (errorWithoutStackTrace "minimum: empty structure") .        getMin . foldMap (Min #. (Just :: a -> Maybe a))      -- | The 'sum' function computes the sum of the numbers of a structure.+    --+    -- @since 4.8.0.0     sum :: Num a => t a -> a     sum = getSum #. foldMap Sum      -- | The 'product' function computes the product of the numbers of a     -- structure.+    --+    -- @since 4.8.0.0     product :: Num a => t a -> a     product = getProduct #. foldMap Product @@ -512,20 +536,27 @@ -- | Monadic fold over the elements of a structure, -- associating to the right, i.e. from right to left. foldrM :: (Foldable t, Monad m) => (a -> b -> m b) -> b -> t a -> m b-foldrM f z0 xs = foldl f' return xs z0-  where f' k x z = f x z >>= k+foldrM f z0 xs = foldl c return xs z0+  -- See Note [List fusion and continuations in 'c']+  where c k x z = f x z >>= k+        {-# INLINE c #-}  -- | Monadic fold over the elements of a structure, -- associating to the left, i.e. from left to right. foldlM :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m b-foldlM f z0 xs = foldr f' return xs z0-  where f' x k z = f z x >>= k+foldlM f z0 xs = foldr c return xs z0+  -- See Note [List fusion and continuations in 'c']+  where c x k z = f z x >>= k+        {-# INLINE c #-}  -- | Map each element of a structure to an action, evaluate these -- actions from left to right, and ignore the results. For a version -- that doesn't ignore the results see 'Data.Traversable.traverse'. traverse_ :: (Foldable t, Applicative f) => (a -> f b) -> t a -> f ()-traverse_ f = foldr ((*>) . f) (pure ())+traverse_ f = foldr c (pure ())+  -- See Note [List fusion and continuations in 'c']+  where c x k = f x *> k+        {-# INLINE c #-}  -- | 'for_' is 'traverse_' with its arguments flipped. For a version -- that doesn't ignore the results see 'Data.Traversable.for'.@@ -547,7 +578,10 @@ -- As of base 4.8.0.0, 'mapM_' is just 'traverse_', specialized to -- 'Monad'. mapM_ :: (Foldable t, Monad m) => (a -> m b) -> t a -> m ()-mapM_ f= foldr ((>>) . f) (return ())+mapM_ f = foldr c (return ())+  -- See Note [List fusion and continuations in 'c']+  where c x k = f x >> k+        {-# INLINE c #-}  -- | 'forM_' is 'mapM_' with its arguments flipped. For a version that -- doesn't ignore the results see 'Data.Traversable.forM'.@@ -561,7 +595,10 @@ -- ignore the results. For a version that doesn't ignore the results -- see 'Data.Traversable.sequenceA'. sequenceA_ :: (Foldable t, Applicative f) => t (f a) -> f ()-sequenceA_ = foldr (*>) (pure ())+sequenceA_ = foldr c (pure ())+  -- See Note [List fusion and continuations in 'c']+  where c m k = m *> k+        {-# INLINE c #-}  -- | Evaluate each monadic action in the structure from left to right, -- and ignore the results. For a version that doesn't ignore the@@ -570,11 +607,14 @@ -- As of base 4.8.0.0, 'sequence_' is just 'sequenceA_', specialized -- to 'Monad'. sequence_ :: (Foldable t, Monad m) => t (m a) -> m ()-sequence_ = foldr (>>) (return ())+sequence_ = foldr c (return ())+  -- See Note [List fusion and continuations in 'c']+  where c m k = m >> k+        {-# INLINE c #-}  -- | The sum of a collection of actions, generalizing 'concat'. ----- asum [Just "Hello", Nothing, Just "World"]+-- >>> asum [Just "Hello", Nothing, Just "World"] -- Just "Hello" asum :: (Foldable t, Alternative f) => t (f a) -> f a {-# INLINE asum #-}@@ -648,6 +688,84 @@ -- 'Nothing' if there is no such element. find :: Foldable t => (a -> Bool) -> t a -> Maybe a find p = getFirst . foldMap (\ x -> First (if p x then Just x else Nothing))++{-+Note [List fusion and continuations in 'c']+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Suppose we define+  mapM_ f = foldr ((>>) . f) (return ())+(this is the way it used to be).++Now suppose we want to optimise the call++  mapM_ <big> (build g)+    where+  g c n = ...(c x1 y1)...(c x2 y2)....n...++GHC used to proceed like this:++  mapM_ <big> (build g)++  = { Definition of mapM_ }+    foldr ((>>) . <big>) (return ()) (build g)++  = { foldr/build rule }+    g ((>>) . <big>) (return ())++  = { Inline g }+    let c = (>>) . <big>+        n = return ()+    in ...(c x1 y1)...(c x2 y2)....n...++The trouble is that `c`, being big, will not be inlined.  And that can+be absolutely terrible for performance, as we saw in Trac #8763.++It's much better to define++  mapM_ f = foldr c (return ())+    where+      c x k = f x >> k+      {-# INLINE c #-}++Now we get+  mapM_ <big> (build g)++  = { inline mapM_ }+    foldr c (return ()) (build g)+      where c x k = f x >> k+            {-# INLINE c #-}+            f = <big>++Notice that `f` does not inline into the RHS of `c`,+because the INLINE pragma stops it; see+Note [Simplifying inside stable unfoldings] in SimplUtils.+Continuing:++  = { foldr/build rule }+    g c (return ())+      where ...+         c x k = f x >> k+         {-# INLINE c #-}+            f = <big>++  = { inline g }+    ...(c x1 y1)...(c x2 y2)....n...+      where c x k = f x >> k+            {-# INLINE c #-}+            f = <big>+            n = return ()++      Now, crucially, `c` does inline++  = { inline c }+    ...(f x1 >> y1)...(f x2 >> y2)....n...+      where f = <big>+            n = return ()++And all is well!  The key thing is that the fragment+`(f x1 >> y1)` is inlined into the body of the builder+`g`.+-}  {- Note [maximumBy/minimumBy space usage]

@@ -45,16 +45,18 @@ -- 120 -- -- Instead of making a recursive call, we introduce a dummy parameter @rec@;--- when used within 'fix', this parameter then refers to 'fix'' argument, hence+-- when used within 'fix', this parameter then refers to 'fix' argument, hence -- the recursion is reintroduced. fix :: (a -> a) -> a fix f = let x = f x in x --- | @'on' b u x y@ runs the binary function `b` /on/ the results of applying unary function `u` to two arguments `x` and `y`. From the opposite perspective, it transforms two inputs and combines the outputs.+-- | @'on' b u x y@ runs the binary function @b@ /on/ the results of applying+-- unary function @u@ to two arguments @x@ and @y@. From the opposite+-- perspective, it transforms two inputs and combines the outputs. -- -- @((+) \``on`\` f) x y = f x + f y@ ----- Typical usage: @'Data.List.sortBy' ('compare' \`on\` 'fst')@.+-- Typical usage: @'Data.List.sortBy' ('Prelude.compare' \`on\` 'Prelude.fst')@. -- -- Algebraic properties: --

@@ -11,8 +11,31 @@ -- Stability   :  provisional -- Portability :  portable ----- Functors: uniform action over a parameterized type, generalizing the--- 'Data.List.map' function on lists.+--+-- A type @f@ is a Functor if it provides a function @fmap@ which, given any types @a@ and @b@,+-- lets you apply any function of type @(a -> b)@ to turn an @f a@ into an @f b@, preserving the+-- structure of @f@.+--+-- ==== __Examples__+--+--  >>> fmap show (Just 1)  --  (a   -> b)      -> f a       -> f b+--  Just "1"                --  (Int -> String) -> Maybe Int -> Maybe String+--+--  >>> fmap show Nothing   --  (a   -> b)      -> f a       -> f b+--  Nothing                 --  (Int -> String) -> Maybe Int -> Maybe String+--+--  >>> fmap show [1,2,3]   --  (a   -> b)      -> f a       -> f b+--  ["1", "2", "3"]         --  (Int -> String) -> [Int]     -> [String]+--+--  >>> fmap show []        --  (a   -> b)      -> f a       -> f b+--  []                      --  (Int -> String) -> [Int]     -> [String]+--+-- The 'fmap' function is also available as the infix operator '<$>':+--+--  >>> fmap show (Just 1) --  (Int -> String) -> Maybe Int -> Maybe String+--  Just "1"+--  >>> show <$> (Just 1)  --  (Int -> String) -> Maybe Int -> Maybe String+--  Just "1"  module Data.Functor     (@@ -34,26 +57,27 @@  -- | An infix synonym for 'fmap'. ----- The name of this operator is an allusion to '$'.+-- The name of this operator is an allusion to 'Prelude.$'. -- Note the similarities between their types: -- -- >  ($)  ::              (a -> b) ->   a ->   b -- > (<$>) :: Functor f => (a -> b) -> f a -> f b ----- Whereas '$' is function application, '<$>' is function+-- Whereas 'Prelude.$' is function application, '<$>' is function -- application lifted over a 'Functor'. -- -- ==== __Examples__ ----- Convert from a @'Maybe' 'Int'@ to a @'Maybe' 'String'@ using 'show':+-- Convert from a @'Data.Maybe.Maybe' 'Data.Int.Int'@ to a @'Data.Maybe.Maybe'+-- 'Data.String.String'@ using 'Prelude.show': -- -- >>> show <$> Nothing -- Nothing -- >>> show <$> Just 3 -- Just "3" ----- Convert from an @'Either' 'Int' 'Int'@ to an @'Either' 'Int'@--- 'String' using 'show':+-- Convert from an @'Data.Either.Either' 'Data.Int.Int' 'Data.Int.Int'@ to an+-- @'Data.Either.Either' 'Data.Int.Int'@ 'Data.String.String' using 'Prelude.show': -- -- >>> show <$> Left 17 -- Left 17@@ -65,7 +89,7 @@ -- >>> (*2) <$> [1,2,3] -- [2,4,6] ----- Apply 'even' to the second element of a pair:+-- Apply 'Prelude.even' to the second element of a pair: -- -- >>> even <$> (2,2) -- (2,True)@@ -106,27 +130,29 @@ -- -- ==== __Examples__ ----- Replace the contents of a @'Maybe' 'Int'@ with a constant 'String':+-- Replace the contents of a @'Data.Maybe.Maybe' 'Data.Int.Int'@ with a constant+-- 'Data.String.String': -- -- >>> Nothing $> "foo" -- Nothing -- >>> Just 90210 $> "foo" -- Just "foo" ----- Replace the contents of an @'Either' 'Int' 'Int'@ with a constant--- 'String', resulting in an @'Either' 'Int' 'String'@:+-- Replace the contents of an @'Data.Either.Either' 'Data.Int.Int' 'Data.Int.Int'@+-- with a constant 'Data.String.String', resulting in an @'Data.Either.Either'+-- 'Data.Int.Int' 'Data.String.String'@: -- -- >>> Left 8675309 $> "foo" -- Left 8675309 -- >>> Right 8675309 $> "foo" -- Right "foo" ----- Replace each element of a list with a constant 'String':+-- Replace each element of a list with a constant 'Data.String.String': -- -- >>> [1,2,3] $> "foo" -- ["foo","foo","foo"] ----- Replace the second element of a pair with a constant 'String':+-- Replace the second element of a pair with a constant 'Data.String.String': -- -- >>> (1,2) $> "foo" -- (1,"foo")@@ -139,15 +165,15 @@ -- -- ==== __Examples__ ----- Replace the contents of a @'Maybe' 'Int'@ with unit:+-- Replace the contents of a @'Data.Maybe.Maybe' 'Data.Int.Int'@ with unit: -- -- >>> void Nothing -- Nothing -- >>> void (Just 3) -- Just () ----- Replace the contents of an @'Either' 'Int' 'Int'@ with unit,--- resulting in an @'Either' 'Int' '()'@:+-- Replace the contents of an @'Data.Either.Either' 'Data.Int.Int' 'Data.Int.Int'@+-- with unit, resulting in an @'Data.Either.Either' 'Data.Int.Int' '()'@: -- -- >>> void (Left 8675309) -- Left 8675309

@@ -69,7 +69,6 @@ import Data.Functor.Identity (Identity(Identity)) import Data.Proxy (Proxy(Proxy)) import Data.List.NonEmpty (NonEmpty(..))-import Data.Monoid (mappend) import Data.Ord (Down(Down))  import GHC.Read (expectP, list, paren)@@ -752,7 +751,7 @@ -- and then parses its argument using 'readsPrec'. -- -- @since 4.9.0.0-{-# DEPRECATED readsUnary "Use readsUnaryWith to define liftReadsPrec" #-}+{-# DEPRECATED readsUnary "Use 'readsUnaryWith' to define 'liftReadsPrec'" #-} readsUnary :: (Read a) => String -> (a -> t) -> String -> ReadS t readsUnary name cons kw s =     [(cons x,t) | kw == name, (x,t) <- readsPrec 11 s]@@ -761,7 +760,7 @@ -- and then parses its argument using 'readsPrec1'. -- -- @since 4.9.0.0-{-# DEPRECATED readsUnary1 "Use readsUnaryWith to define liftReadsPrec" #-}+{-# DEPRECATED readsUnary1 "Use 'readsUnaryWith' to define 'liftReadsPrec'" #-} readsUnary1 :: (Read1 f, Read a) => String -> (f a -> t) -> String -> ReadS t readsUnary1 name cons kw s =     [(cons x,t) | kw == name, (x,t) <- readsPrec1 11 s]@@ -770,7 +769,8 @@ -- and then parses its arguments using 'readsPrec1'. -- -- @since 4.9.0.0-{-# DEPRECATED readsBinary1 "Use readsBinaryWith to define liftReadsPrec" #-}+{-# DEPRECATED readsBinary1+      "Use 'readsBinaryWith' to define 'liftReadsPrec'" #-} readsBinary1 :: (Read1 f, Read1 g, Read a) =>     String -> (f a -> g a -> t) -> String -> ReadS t readsBinary1 name cons kw s =@@ -781,7 +781,7 @@ -- constructor with name @n@ and argument @x@, in precedence context @d@. -- -- @since 4.9.0.0-{-# DEPRECATED showsUnary "Use showsUnaryWith to define liftShowsPrec" #-}+{-# DEPRECATED showsUnary "Use 'showsUnaryWith' to define 'liftShowsPrec'" #-} showsUnary :: (Show a) => String -> Int -> a -> ShowS showsUnary name d x = showParen (d > 10) $     showString name . showChar ' ' . showsPrec 11 x@@ -790,7 +790,7 @@ -- constructor with name @n@ and argument @x@, in precedence context @d@. -- -- @since 4.9.0.0-{-# DEPRECATED showsUnary1 "Use showsUnaryWith to define liftShowsPrec" #-}+{-# DEPRECATED showsUnary1 "Use 'showsUnaryWith' to define 'liftShowsPrec'" #-} showsUnary1 :: (Show1 f, Show a) => String -> Int -> f a -> ShowS showsUnary1 name d x = showParen (d > 10) $     showString name . showChar ' ' . showsPrec1 11 x@@ -800,7 +800,8 @@ -- context @d@. -- -- @since 4.9.0.0-{-# DEPRECATED showsBinary1 "Use showsBinaryWith to define liftShowsPrec" #-}+{-# DEPRECATED showsBinary1+      "Use 'showsBinaryWith' to define 'liftShowsPrec'" #-} showsBinary1 :: (Show1 f, Show1 g, Show a) =>     String -> Int -> f a -> g a -> ShowS showsBinary1 name d x y = showParen (d > 10) $

@@ -27,8 +27,6 @@ import Control.Applicative import Data.Coerce (coerce) import Data.Data (Data)-import Data.Foldable (Foldable(foldMap))-import Data.Traversable (Traversable(traverse)) import GHC.Generics (Generic, Generic1) import Text.Read (Read(..), readListDefault, readListPrecDefault) 

@@ -59,7 +59,7 @@              )  -- | This instance would be equivalent to the derived instances of the--- 'Const' newtype if the 'runConst' field were removed+-- 'Const' newtype if the 'getConst' field were removed -- -- @since 4.8.0.0 instance Read a => Read (Const a b) where@@ -67,7 +67,7 @@         $ \r -> [(Const x,t) | ("Const", s) <- lex r, (x, t) <- readsPrec 11 s]  -- | This instance would be equivalent to the derived instances of the--- 'Const' newtype if the 'runConst' field were removed+-- 'Const' newtype if the 'getConst' field were removed -- -- @since 4.8.0.0 instance Show a => Show (Const a b) where

@@ -54,7 +54,6 @@ import Data.Functor.Compose  import Data.Monoid (Alt(..))-import Data.Semigroup (Semigroup(..)) import Data.Proxy import GHC.Generics @@ -87,8 +86,8 @@ -- -- Any instance should be subject to the following laws: ----- > contramap id = id--- > contramap f . contramap g = contramap (g . f)+-- [Identity]    @'contramap' 'id' = 'id'@+-- [Composition] @'contramap' (g . f) = 'contramap' f . 'contramap' g@ -- -- Note, that the second law follows from the free theorem of the type of -- 'contramap' and the first law, so you need only check that the former@@ -103,7 +102,7 @@   (>$) :: b -> f b -> f a   (>$) = contramap . const --- | If 'f' is both 'Functor' and 'Contravariant' then by the time you factor+-- | If @f@ is both 'Functor' and 'Contravariant' then by the time you factor -- in the laws of each of those classes, it can't actually use its argument in -- any meaningful capacity. --@@ -206,22 +205,11 @@ -- -- Equivalence relations are expected to satisfy three laws: ----- __Reflexivity__:------ @--- 'getEquivalence' f a a = True--- @------ __Symmetry__:------ @--- 'getEquivalence' f a b = 'getEquivalence' f b a--- @------ __Transitivity__:------ If @'getEquivalence' f a b@ and @'getEquivalence' f b c@ are both 'True'--- then so is @'getEquivalence' f a c@.+-- [Reflexivity]:  @'getEquivalence' f a a = True@+-- [Symmetry]:     @'getEquivalence' f a b = 'getEquivalence' f b a@+-- [Transitivity]:+--    If @'getEquivalence' f a b@ and @'getEquivalence' f b c@ are both 'True'+--    then so is @'getEquivalence' f a c@. -- -- The types alone do not enforce these laws, so you'll have to check them -- yourself.

@@ -26,10 +26,7 @@ import Control.Monad.Fix (MonadFix(..)) import Control.Monad.Zip (MonadZip(mzipWith)) import Data.Data (Data)-import Data.Foldable (Foldable(foldMap)) import Data.Functor.Classes-import Data.Monoid (mappend)-import Data.Traversable (Traversable(traverse)) import GHC.Generics (Generic, Generic1) import Text.Read (Read(..), readListDefault, readListPrecDefault) 

@@ -23,9 +23,7 @@  import Control.Applicative ((<|>)) import Data.Data (Data)-import Data.Foldable (Foldable(foldMap)) import Data.Functor.Classes-import Data.Traversable (Traversable(traverse)) import GHC.Generics (Generic, Generic1) import Text.Read (Read(..), readListDefault, readListPrecDefault) 

@@ -48,7 +48,7 @@ instance Ord a => Monoid (Min a) where     mempty = Min Nothing --- left-to-right state transformer+-- left-to-right state-transforming monad newtype StateL s a = StateL { runStateL :: s -> (s, a) }  -- | @since 4.0@@ -67,7 +67,7 @@             (s'', y) = ky s'         in (s'', f x y) --- right-to-left state transformer+-- right-to-left state-transforming monad newtype StateR s a = StateR { runStateR :: s -> (s, a) }  -- | @since 4.0

@@ -1,5 +1,6 @@ {-# LANGUAGE Trustworthy #-} {-# LANGUAGE NoImplicitPrelude, MagicHash, UnboxedTuples #-}+{-# LANGUAGE BangPatterns #-}  ----------------------------------------------------------------------------- -- |@@ -36,8 +37,7 @@  import GHC.Base import GHC.STRef-import GHC.IORef hiding (atomicModifyIORef)-import qualified GHC.IORef+import GHC.IORef import GHC.Weak  -- |Make a 'Weak' pointer to an 'IORef', using the second argument as a finalizer@@ -91,18 +91,9 @@ -- Use 'atomicModifyIORef'' or 'atomicWriteIORef' to avoid this problem. -- atomicModifyIORef :: IORef a -> (a -> (a,b)) -> IO b-atomicModifyIORef = GHC.IORef.atomicModifyIORef---- | Strict version of 'atomicModifyIORef'.  This forces both the value stored--- in the 'IORef' as well as the value returned.------ @since 4.6.0.0-atomicModifyIORef' :: IORef a -> (a -> (a,b)) -> IO b-atomicModifyIORef' ref f = do-    b <- atomicModifyIORef ref $ \a ->-            case f a of-                v@(a',_) -> a' `seq` v-    b `seq` return b+atomicModifyIORef ref f = do+  (_old, ~(_new, res)) <- atomicModifyIORef2 ref f+  pure res  -- | Variant of 'writeIORef' with the \"barrier to reordering\" property that -- 'atomicModifyIORef' has.@@ -110,8 +101,8 @@ -- @since 4.6.0.0 atomicWriteIORef :: IORef a -> a -> IO () atomicWriteIORef ref a = do-    x <- atomicModifyIORef ref (\_ -> (a, ()))-    x `seq` return ()+  _ <- atomicSwapIORef ref a+  pure ()  {- $memmodel @@ -120,19 +111,23 @@   processor architecture.  For example, on x86, loads can move ahead   of stores, so in the following example: ->  maybePrint :: IORef Bool -> IORef Bool -> IO ()->  maybePrint myRef yourRef = do->    writeIORef myRef True->    yourVal <- readIORef yourRef->    unless yourVal $ putStrLn "critical section"->->  main :: IO ()->  main = do->    r1 <- newIORef False->    r2 <- newIORef False->    forkIO $ maybePrint r1 r2->    forkIO $ maybePrint r2 r1->    threadDelay 1000000+  > import Data.IORef+  > import Control.Monad (unless)+  > import Control.Concurrent (forkIO, threadDelay)+  >+  > maybePrint :: IORef Bool -> IORef Bool -> IO ()+  > maybePrint myRef yourRef = do+  >   writeIORef myRef True+  >   yourVal <- readIORef yourRef+  >   unless yourVal $ putStrLn "critical section"+  >+  > main :: IO ()+  > main = do+  >   r1 <- newIORef False+  >   r2 <- newIORef False+  >   forkIO $ maybePrint r1 r2+  >   forkIO $ maybePrint r2 r1+  >   threadDelay 1000000    it is possible that the string @"critical section"@ is printed   twice, even though there is no interleaving of the operations of the

@@ -178,8 +178,8 @@    -- counterpart whose name is suffixed with \`@By@\'.    --    -- It is often convenient to use these functions together with-   -- 'Data.Function.on', for instance @'sortBy' ('compare'-   -- \`on\` 'fst')@.+   -- 'Data.Function.on', for instance @'sortBy' ('Prelude.compare'+   -- ``Data.Function.on`` 'Prelude.fst')@.     -- *** User-supplied equality (replacing an @Eq@ context)    -- | The predicate is assumed to define an equivalence.

@@ -380,7 +380,7 @@ groupAllWith1 :: (Ord b) => (a -> b) -> NonEmpty a -> NonEmpty (NonEmpty a) groupAllWith1 f = groupWith1 f . sortWith f --- | The 'isPrefix' function returns @True@ if the first argument is+-- | The 'isPrefixOf' function returns 'True' if the first argument is -- a prefix of the second. isPrefixOf :: Eq a => [a] -> NonEmpty a -> Bool isPrefixOf [] _ = True

@@ -32,6 +32,7 @@    ) where  import GHC.Base+import GHC.Stack.Types ( HasCallStack )  -- $setup -- Allow the use of some Prelude functions in doctests.@@ -55,7 +56,7 @@ -- >>> maybe False odd Nothing -- False ----- Read an integer from a string using 'readMaybe'. If we succeed,+-- Read an integer from a string using 'Text.Read.readMaybe'. If we succeed, -- return twice the integer; that is, apply @(*2)@ to it. If instead -- we fail to parse an integer, return @0@ by default: --@@ -65,7 +66,7 @@ -- >>> maybe 0 (*2) (readMaybe "") -- 0 ----- Apply 'show' to a @Maybe Int@. If we have @Just n@, we want to show+-- Apply 'Prelude.show' to a @Maybe Int@. If we have @Just n@, we want to show -- the underlying 'Int' @n@. But if we have 'Nothing', we return the -- empty string instead of (for example) \"Nothing\": --@@ -143,8 +144,8 @@ -- >>> 2 * (fromJust Nothing) -- *** Exception: Maybe.fromJust: Nothing ---fromJust          :: Maybe a -> a-fromJust Nothing  = errorWithoutStackTrace "Maybe.fromJust: Nothing" -- yuck+fromJust          :: HasCallStack => Maybe a -> a+fromJust Nothing  = error "Maybe.fromJust: Nothing" -- yuck fromJust (Just x) = x  -- | The 'fromMaybe' function takes a default value and and 'Maybe'@@ -161,7 +162,7 @@ -- >>> fromMaybe "" Nothing -- "" ----- Read an integer from a string using 'readMaybe'. If we fail to+-- Read an integer from a string using 'Text.Read.readMaybe'. If we fail to -- parse an integer, we want to return @0@ by default: -- -- >>> import Text.Read ( readMaybe )@@ -174,7 +175,7 @@ fromMaybe d x = case x of {Nothing -> d;Just v  -> v}  -- | The 'maybeToList' function returns an empty list when given--- 'Nothing' or a singleton list when not given 'Nothing'.+-- 'Nothing' or a singleton list when given 'Just'. -- -- ==== __Examples__ --

@@ -16,9 +16,44 @@ -- Stability   :  experimental -- Portability :  portable ----- A class for monoids (types with an associative binary operation that--- has an identity) with various general-purpose instances.+-- A type @a@ is a 'Monoid' if it provides an associative function ('<>')+-- that lets you combine any two values of type @a@ into one, and a neutral+-- element (`mempty`) such that --+-- > a <> mempty == mempty <> a == a+--+-- A 'Monoid' is a 'Semigroup' with the added requirement of a neutral element.+-- Thus any 'Monoid' is a 'Semigroup', but not the other way around.+--+-- ==== __Examples__+--+-- The 'Sum' monoid is defined by the numerical addition operator and `0` as neutral element:+--+-- >>> mempty :: Sum Int+-- Sum 0+-- >>> Sum 1 <> Sum 2 <> Sum 3 <> Sum 4 :: Sum Int+-- Sum {getSum = 10}+--+-- We can combine multiple values in a list into a single value using the `mconcat` function.+-- Note that we have to specify the type here since 'Int' is a monoid under several different+-- operations:+--+-- >>> mconcat [1,2,3,4] :: Sum Int+-- Sum {getSum = 10}+-- >>> mconcat [] :: Sum Int+-- Sum {getSum = 0}+--+-- Another valid monoid instance of 'Int' is 'Product' It is defined by multiplication+-- and `1` as neutral element:+--+-- >>> Product 1 <> Product 2 <> Product 3 <> Product 4 :: Product Int+-- Product {getProduct = 24}+-- >>> mconcat [1,2,3,4] :: Product Int+-- Product {getProduct = 24}+-- >>> mconcat [] :: Product Int+-- Product {getProduct = 1}+--+-- -----------------------------------------------------------------------------  module Data.Monoid (@@ -56,7 +91,7 @@ import Data.Semigroup.Internal  -- $MaybeExamples--- To implement @find@ or @findLast@ on any 'Foldable':+-- To implement @find@ or @findLast@ on any 'Data.Foldable.Foldable': -- -- @ -- findLast :: Foldable t => (a -> Bool) -> t a -> Maybe a@@ -65,20 +100,20 @@ --                                            else Last Nothing) -- @ ----- Much of Data.Map's interface can be implemented with--- Data.Map.alter. Some of the rest can be implemented with a new--- @alterA@ function and either 'First' or 'Last':+-- Much of 'Data.Map.Lazy.Map's interface can be implemented with+-- 'Data.Map.Lazy.alter'. Some of the rest can be implemented with a new+-- 'Data.Map.Lazy.alterF' function and either 'First' or 'Last': ----- > alterA :: (Applicative f, Ord k) =>+-- > alterF :: (Functor f, Ord k) => -- >           (Maybe a -> f (Maybe a)) -> k -> Map k a -> f (Map k a) -- >--- > instance Monoid a => Applicative ((,) a)  -- from Control.Applicative+-- > instance Monoid a => Functor ((,) a)  -- from Data.Functor -- -- @ -- insertLookupWithKey :: Ord k => (k -> v -> v -> v) -> k -> v --                     -> Map k v -> (Maybe v, Map k v) -- insertLookupWithKey combine key value =---   Arrow.first getFirst . alterA doChange key+--   Arrow.first getFirst . 'Data.Map.Lazy.alterF' doChange key --   where --   doChange Nothing = (First Nothing, Just value) --   doChange (Just oldValue) =

@@ -221,7 +221,7 @@ import GHC.List import GHC.Base -infix 5 \\ -- comment to fool cpp: https://www.haskell.org/ghc/docs/latest/html/users_guide/options-phases.html#cpp-string-gaps+infix 5 \\ -- comment to fool cpp: https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/phases.html#cpp-and-string-gaps  -- ----------------------------------------------------------------------------- -- List functions@@ -241,9 +241,9 @@ dropWhileEnd :: (a -> Bool) -> [a] -> [a] dropWhileEnd p = foldr (\x xs -> if p x && null xs then [] else x : xs) [] --- | The 'stripPrefix' function drops the given prefix from a list.--- It returns 'Nothing' if the list did not start with the prefix--- given, or 'Just' the list after the prefix, if it does.+-- | /O(min(m,n))/. The 'stripPrefix' function drops the given prefix from a+-- list. It returns 'Nothing' if the list did not start with the prefix given,+-- or 'Just' the list after the prefix, if it does. -- -- >>> stripPrefix "foo" "foobar" -- Just "bar"@@ -310,14 +310,16 @@ findIndices p xs = [ i | (x,i) <- zip xs [0..], p x] #else -- Efficient definition, adapted from Data.Sequence-{-# INLINE findIndices #-}+-- (Note that making this INLINABLE instead of INLINE allows+-- 'findIndex' to fuse, fixing #15426.)+{-# INLINABLE findIndices #-} findIndices p ls = build $ \c n ->   let go x r k | p x       = I# k `c` r (k +# 1#)                | otherwise = r (k +# 1#)   in foldr go (\_ -> n) ls 0# #endif  /* USE_REPORT_PRELUDE */ --- | The 'isPrefixOf' function takes two lists and returns 'True'+-- | /O(min(m,n))/. The 'isPrefixOf' function takes two lists and returns 'True' -- iff the first list is a prefix of the second. -- -- >>> "Hello" `isPrefixOf` "Hello World!"@@ -429,8 +431,8 @@ #endif  --- | 'delete' @x@ removes the first occurrence of @x@ from its list argument.--- For example,+-- | /O(n)/. 'delete' @x@ removes the first occurrence of @x@ from its list+-- argument. For example, -- -- >>> delete 'a' "banana" -- "bnana"@@ -440,7 +442,7 @@ delete                  :: (Eq a) => a -> [a] -> [a] delete                  =  deleteBy (==) --- | The 'deleteBy' function behaves like 'delete', but takes a+-- | /O(n)/. The 'deleteBy' function behaves like 'delete', but takes a -- user-supplied equality predicate. -- -- >>> deleteBy (<=) 4 [1..10]@@ -507,7 +509,7 @@ intersectBy _  _  []    =  [] intersectBy eq xs ys    =  [x | x <- xs, any (eq x) ys] --- | The 'intersperse' function takes an element and a list and+-- | /O(n)/. The 'intersperse' function takes an element and a list and -- \`intersperses\' that element between the elements of the list. -- For example, --@@ -616,19 +618,18 @@                            where (s'',y ) = f s' x                                  (s', ys) = mapAccumR f s xs --- | The 'insert' function takes an element and a list and inserts the--- element into the list at the first position where it is less--- than or equal to the next element.  In particular, if the list--- is sorted before the call, the result will also be sorted.--- It is a special case of 'insertBy', which allows the programmer to--- supply their own comparison function.+-- | /O(n)/. The 'insert' function takes an element and a list and inserts the+-- element into the list at the first position where it is less than or equal to+-- the next element. In particular, if the list is sorted before the call, the+-- result will also be sorted. It is a special case of 'insertBy', which allows+-- the programmer to supply their own comparison function. -- -- >>> insert 4 [1,2,3,5,6,7] -- [1,2,3,4,5,6,7] insert :: Ord a => a -> [a] -> [a] insert e ls = insertBy (compare) e ls --- | The non-overloaded version of 'insert'.+-- | /O(n)/. The non-overloaded version of 'insert'. insertBy :: (a -> a -> Ordering) -> a -> [a] -> [a] insertBy _   x [] = [x] insertBy cmp x ys@(y:ys')@@ -668,9 +669,14 @@                                        GT -> y                                        _  -> x --- | The 'genericLength' function is an overloaded version of 'length'.  In--- particular, instead of returning an 'Int', it returns any type which is--- an instance of 'Num'.  It is, however, less efficient than 'length'.+-- | /O(n)/. The 'genericLength' function is an overloaded version of 'length'.+-- In particular, instead of returning an 'Int', it returns any type which is an+-- instance of 'Num'. It is, however, less efficient than 'length'.+--+-- >>> genericLength [1, 2, 3] :: Int+-- 3+-- >>> genericLength [1, 2, 3] :: Float+-- 3.0 genericLength           :: (Num i) => [a] -> i {-# NOINLINE [1] genericLength #-} genericLength []        =  0@@ -726,22 +732,34 @@  -- | The 'zip4' function takes four lists and returns a list of -- quadruples, analogous to 'zip'.+-- It is capable of list fusion, but it is restricted to its+-- first list argument and its resulting list.+{-# INLINE zip4 #-} zip4                    :: [a] -> [b] -> [c] -> [d] -> [(a,b,c,d)] zip4                    =  zipWith4 (,,,)  -- | The 'zip5' function takes five lists and returns a list of -- five-tuples, analogous to 'zip'.+-- It is capable of list fusion, but it is restricted to its+-- first list argument and its resulting list.+{-# INLINE zip5 #-} zip5                    :: [a] -> [b] -> [c] -> [d] -> [e] -> [(a,b,c,d,e)] zip5                    =  zipWith5 (,,,,)  -- | The 'zip6' function takes six lists and returns a list of six-tuples, -- analogous to 'zip'.+-- It is capable of list fusion, but it is restricted to its+-- first list argument and its resulting list.+{-# INLINE zip6 #-} zip6                    :: [a] -> [b] -> [c] -> [d] -> [e] -> [f] ->                               [(a,b,c,d,e,f)] zip6                    =  zipWith6 (,,,,,)  -- | The 'zip7' function takes seven lists and returns a list of -- seven-tuples, analogous to 'zip'.+-- It is capable of list fusion, but it is restricted to its+-- first list argument and its resulting list.+{-# INLINE zip7 #-} zip7                    :: [a] -> [b] -> [c] -> [d] -> [e] -> [f] ->                               [g] -> [(a,b,c,d,e,f,g)] zip7                    =  zipWith7 (,,,,,,)@@ -749,6 +767,9 @@ -- | The 'zipWith4' function takes a function which combines four -- elements, as well as four lists and returns a list of their point-wise -- combination, analogous to 'zipWith'.+-- It is capable of list fusion, but it is restricted to its+-- first list argument and its resulting list.+{-# NOINLINE [1] zipWith4 #-} zipWith4                :: (a->b->c->d->e) -> [a]->[b]->[c]->[d]->[e] zipWith4 z (a:as) (b:bs) (c:cs) (d:ds)                         =  z a b c d : zipWith4 z as bs cs ds@@ -757,6 +778,9 @@ -- | The 'zipWith5' function takes a function which combines five -- elements, as well as five lists and returns a list of their point-wise -- combination, analogous to 'zipWith'.+-- It is capable of list fusion, but it is restricted to its+-- first list argument and its resulting list.+{-# NOINLINE [1] zipWith5 #-} zipWith5                :: (a->b->c->d->e->f) ->                            [a]->[b]->[c]->[d]->[e]->[f] zipWith5 z (a:as) (b:bs) (c:cs) (d:ds) (e:es)@@ -766,6 +790,9 @@ -- | The 'zipWith6' function takes a function which combines six -- elements, as well as six lists and returns a list of their point-wise -- combination, analogous to 'zipWith'.+-- It is capable of list fusion, but it is restricted to its+-- first list argument and its resulting list.+{-# NOINLINE [1] zipWith6 #-} zipWith6                :: (a->b->c->d->e->f->g) ->                            [a]->[b]->[c]->[d]->[e]->[f]->[g] zipWith6 z (a:as) (b:bs) (c:cs) (d:ds) (e:es) (f:fs)@@ -775,12 +802,133 @@ -- | The 'zipWith7' function takes a function which combines seven -- elements, as well as seven lists and returns a list of their point-wise -- combination, analogous to 'zipWith'.+-- It is capable of list fusion, but it is restricted to its+-- first list argument and its resulting list.+{-# NOINLINE [1] zipWith7 #-} zipWith7                :: (a->b->c->d->e->f->g->h) ->                            [a]->[b]->[c]->[d]->[e]->[f]->[g]->[h] zipWith7 z (a:as) (b:bs) (c:cs) (d:ds) (e:es) (f:fs) (g:gs)                    =  z a b c d e f g : zipWith7 z as bs cs ds es fs gs zipWith7 _ _ _ _ _ _ _ _ = [] +{-+Functions and rules for fusion of zipWith4, zipWith5, zipWith6 and zipWith7.+The principle is the same as for zip and zipWith in GHC.List:+Turn zipWithX into a version in which the first argument and the result+can be fused. Turn it back into the original function if no fusion happens.+-}++{-# INLINE [0] zipWith4FB #-} -- See Note [Inline FB functions]+zipWith4FB :: (e->xs->xs') -> (a->b->c->d->e) ->+              a->b->c->d->xs->xs'+zipWith4FB cons func = \a b c d r -> (func a b c d) `cons` r++{-# INLINE [0] zipWith5FB #-} -- See Note [Inline FB functions]+zipWith5FB :: (f->xs->xs') -> (a->b->c->d->e->f) ->+              a->b->c->d->e->xs->xs'+zipWith5FB cons func = \a b c d e r -> (func a b c d e) `cons` r++{-# INLINE [0] zipWith6FB #-} -- See Note [Inline FB functions]+zipWith6FB :: (g->xs->xs') -> (a->b->c->d->e->f->g) ->+              a->b->c->d->e->f->xs->xs'+zipWith6FB cons func = \a b c d e f r -> (func a b c d e f) `cons` r++{-# INLINE [0] zipWith7FB #-} -- See Note [Inline FB functions]+zipWith7FB :: (h->xs->xs') -> (a->b->c->d->e->f->g->h) ->+              a->b->c->d->e->f->g->xs->xs'+zipWith7FB cons func = \a b c d e f g r -> (func a b c d e f g) `cons` r++{-# INLINE [0] foldr4 #-}+foldr4 :: (a->b->c->d->e->e) ->+          e->[a]->[b]->[c]->[d]->e+foldr4 k z = go+  where+    go (a:as) (b:bs) (c:cs) (d:ds) = k a b c d (go as bs cs ds)+    go _      _      _      _      = z++{-# INLINE [0] foldr5 #-}+foldr5 :: (a->b->c->d->e->f->f) ->+          f->[a]->[b]->[c]->[d]->[e]->f+foldr5 k z = go+  where+    go (a:as) (b:bs) (c:cs) (d:ds) (e:es) = k a b c d e (go as bs cs ds es)+    go _      _      _      _      _      = z++{-# INLINE [0] foldr6 #-}+foldr6 :: (a->b->c->d->e->f->g->g) ->+          g->[a]->[b]->[c]->[d]->[e]->[f]->g+foldr6 k z = go+  where+    go (a:as) (b:bs) (c:cs) (d:ds) (e:es) (f:fs) = k a b c d e f (+        go as bs cs ds es fs)+    go _      _      _      _      _      _      = z++{-# INLINE [0] foldr7 #-}+foldr7 :: (a->b->c->d->e->f->g->h->h) ->+          h->[a]->[b]->[c]->[d]->[e]->[f]->[g]->h+foldr7 k z = go+  where+    go (a:as) (b:bs) (c:cs) (d:ds) (e:es) (f:fs) (g:gs) = k a b c d e f g (+        go as bs cs ds es fs gs)+    go _      _      _      _      _      _      _      = z++foldr4_left :: (a->b->c->d->e->f)->+               f->a->([b]->[c]->[d]->e)->+               [b]->[c]->[d]->f+foldr4_left k _z a r (b:bs) (c:cs) (d:ds) = k a b c d (r bs cs ds)+foldr4_left _  z _ _ _      _      _      = z++foldr5_left :: (a->b->c->d->e->f->g)->+               g->a->([b]->[c]->[d]->[e]->f)->+               [b]->[c]->[d]->[e]->g+foldr5_left k _z a r (b:bs) (c:cs) (d:ds) (e:es) = k a b c d e (r bs cs ds es)+foldr5_left _  z _ _ _      _      _      _      = z++foldr6_left :: (a->b->c->d->e->f->g->h)->+               h->a->([b]->[c]->[d]->[e]->[f]->g)->+               [b]->[c]->[d]->[e]->[f]->h+foldr6_left k _z a r (b:bs) (c:cs) (d:ds) (e:es) (f:fs) =+    k a b c d e f (r bs cs ds es fs)+foldr6_left _  z _ _ _      _      _      _      _      = z++foldr7_left :: (a->b->c->d->e->f->g->h->i)->+               i->a->([b]->[c]->[d]->[e]->[f]->[g]->h)->+               [b]->[c]->[d]->[e]->[f]->[g]->i+foldr7_left k _z a r (b:bs) (c:cs) (d:ds) (e:es) (f:fs) (g:gs) =+    k a b c d e f g (r bs cs ds es fs gs)+foldr7_left _  z _ _ _      _      _      _      _      _      = z++{-# RULES++"foldr4/left"   forall k z (g::forall b.(a->b->b)->b->b).+                  foldr4 k z (build g) = g (foldr4_left k z) (\_ _ _ -> z)+"foldr5/left"   forall k z (g::forall b.(a->b->b)->b->b).+                  foldr5 k z (build g) = g (foldr5_left k z) (\_ _ _ _ -> z)+"foldr6/left"   forall k z (g::forall b.(a->b->b)->b->b).+                  foldr6 k z (build g) = g (foldr6_left k z) (\_ _ _ _ _ -> z)+"foldr7/left"   forall k z (g::forall b.(a->b->b)->b->b).+                  foldr7 k z (build g) = g (foldr7_left k z) (\_ _ _ _ _ _ -> z)++"zipWith4" [~1] forall f as bs cs ds.+                  zipWith4 f as bs cs ds = build (\c n ->+                        foldr4 (zipWith4FB c f) n as bs cs ds)+"zipWith5" [~1] forall f as bs cs ds es.+                  zipWith5 f as bs cs ds es = build (\c n ->+                        foldr5 (zipWith5FB c f) n as bs cs ds es)+"zipWith6" [~1] forall f as bs cs ds es fs.+                  zipWith6 f as bs cs ds es fs = build (\c n ->+                        foldr6 (zipWith6FB c f) n as bs cs ds es fs)+"zipWith7" [~1] forall f as bs cs ds es fs gs.+                  zipWith7 f as bs cs ds es fs gs = build (\c n ->+                        foldr7 (zipWith7FB c f) n as bs cs ds es fs gs)++"zipWith4List"  [1]  forall f.   foldr4 (zipWith4FB (:) f) [] = zipWith4 f+"zipWith5List"  [1]  forall f.   foldr5 (zipWith5FB (:) f) [] = zipWith5 f+"zipWith6List"  [1]  forall f.   foldr6 (zipWith6FB (:) f) [] = zipWith6 f+"zipWith7List"  [1]  forall f.   foldr7 (zipWith7FB (:) f) [] = zipWith7 f++ #-}+ -- | The 'unzip4' function takes a list of quadruples and returns four -- lists, analogous to 'unzip'. unzip4                  :: [(a,b,c,d)] -> ([a],[b],[c],[d])@@ -853,7 +1001,7 @@ -- if it fuses with a consumer, and it would generally lead to serious -- loss of sharing if allowed to fuse with a producer. --- | The 'tails' function returns all final segments of the argument,+-- | /O(n)/. The 'tails' function returns all final segments of the argument, -- longest first.  For example, -- -- >>> tails "abc"

@@ -38,7 +38,7 @@ -- create one). -- -- Historically, @'Proxy' :: 'Proxy' a@ is a safer alternative to the--- @'undefined :: a'@ idiom.+-- @'undefined' :: a@ idiom. -- -- >>> Proxy :: Proxy (Void, Int -> Int) -- Proxy@@ -57,7 +57,7 @@                               , Read    -- ^ @since 4.7.0.0                               ) --- | A concrete, promotable proxy type, for use at the kind level+-- | A concrete, promotable proxy type, for use at the kind level. -- There are no instances for this because it is intended at the kind level only data KProxy (t :: Type) = KProxy 

@@ -42,7 +42,7 @@ -- Be warned that 'modifySTRef' does not apply the function strictly.  This -- means if the program calls 'modifySTRef' many times, but seldomly uses the -- value, thunks will pile up in memory resulting in a space leak.  This is a--- common mistake made when using an STRef as a counter.  For example, the+-- common mistake made when using an 'STRef' as a counter.  For example, the -- following will leak memory and may produce a stack overflow: -- -- >>> import Control.Monad (replicateM_)

@@ -19,15 +19,52 @@ -- Stability   :  provisional -- Portability :  portable ----- In mathematics, a semigroup is an algebraic structure consisting of a--- set together with an associative binary operation. A semigroup--- generalizes a monoid in that there might not exist an identity--- element. It also (originally) generalized a group (a monoid with all--- inverses) to a type where every element did not have to have an inverse,--- thus the name semigroup.+-- A type @a@ is a 'Semigroup' if it provides an associative function ('<>')+-- that lets you combine any two values of type @a@ into one. Where being+-- associative means that the following must always hold: ----- The use of @(\<\>)@ in this module conflicts with an operator with the same--- name that is being exported by Data.Monoid. However, this package+-- >>> (a <> b) <> c == a <> (b <> c)+--+-- ==== __Examples__+--+-- The 'Min' 'Semigroup' instance for 'Int' is defined to always pick the smaller+-- number:+-- >>> Min 1 <> Min 2 <> Min 3 <> Min 4 :: Min Int+-- Min {getMin = 1}+--+-- If we need to combine multiple values we can use the 'sconcat' function+-- to do so. We need to ensure however that we have at least one value to+-- operate on, since otherwise our result would be undefined. It is for this+-- reason that 'sconcat' uses "Data.List.NonEmpty.NonEmpty" - a list that+-- can never be empty:+--+-- >>> (1 :| [])+-- 1 :| []               -- equivalent to [1] but guaranteed to be non-empty+-- >>> (1 :| [2, 3, 4])+-- 1 :| [2,3,4]          -- equivalent to [1,2,3,4] but guaranteed to be non-empty+--+-- Equipped with this guaranteed to be non-empty data structure, we can combine+-- values using 'sconcat' and a 'Semigroup' of our choosing. We can try the 'Min'+-- and 'Max' instances of 'Int' which pick the smallest, or largest number+-- respectively:+--+-- >>> sconcat (1 :| [2, 3, 4]) :: Min Int+-- Min {getMin = 1}+-- >>> sconcat (1 :| [2, 3, 4]) :: Max Int+-- Max {getMax = 4}+--+-- String concatenation is another example of a 'Semigroup' instance:+--+-- >>> "foo" <> "bar"+-- "foobar"+--+-- A 'Semigroup' is a generalization of a 'Monoid'. Yet unlike the 'Semigroup', the 'Monoid'+-- requires the presence of a neutral element ('mempty') in addition to the associative+-- operator. The requirement for a neutral element prevents many types from being a full Monoid,+-- like "Data.List.NonEmpty.NonEmpty".+--+-- Note that the use of @(\<\>)@ in this module conflicts with an operator with the same+-- name that is being exported by "Data.Monoid". However, this package -- re-exports (most of) the contents of Data.Monoid, so to use semigroups -- and monoids in the same package just --@@ -80,9 +117,6 @@ import           Data.Bitraversable import           Data.Coerce import           Data.Data-import           Data.Monoid         (All (..), Any (..), Dual (..), Endo (..),-                                      Product (..), Sum (..))--- import qualified Data.Monoid         as Monoid import           GHC.Generics  -- | A generalization of 'Data.List.cycle' to an arbitrary 'Semigroup'.

@@ -4,7 +4,7 @@  import {-# SOURCE #-} GHC.Real (Integral) import {-# SOURCE #-} GHC.Base (Semigroup,Monoid,Maybe)-import GHC.Integer ()   -- Note [Depend on GHC.Integer]+import GHC.Integer () -- See Note [Depend on GHC.Integer] in GHC.Base  stimesIdempotentMonoid :: (Integral b, Monoid a) => b -> a -> a 

@@ -76,27 +76,29 @@ -- -- A definition of 'traverse' must satisfy the following laws: ----- [/naturality/]+-- [Naturality] --   @t . 'traverse' f = 'traverse' (t . f)@ --   for every applicative transformation @t@ ----- [/identity/]---   @'traverse' Identity = Identity@+-- [Identity]+--   @'traverse' 'Identity' = 'Identity'@ ----- [/composition/]---   @'traverse' (Compose . 'fmap' g . f) = Compose . 'fmap' ('traverse' g) . 'traverse' f@+-- [Composition]+--   @'traverse' ('Data.Functor.Compose.Compose' . 'fmap' g . f)+--     = 'Data.Functor.Compose.Compose' . 'fmap' ('traverse' g) . 'traverse' f@ -- -- A definition of 'sequenceA' must satisfy the following laws: ----- [/naturality/]+-- [Naturality] --   @t . 'sequenceA' = 'sequenceA' . 'fmap' t@ --   for every applicative transformation @t@ ----- [/identity/]---   @'sequenceA' . 'fmap' Identity = Identity@+-- [Identity]+--   @'sequenceA' . 'fmap' 'Identity' = 'Identity'@ ----- [/composition/]---   @'sequenceA' . 'fmap' Compose = Compose . 'fmap' 'sequenceA' . 'sequenceA'@+-- [Composition]+--   @'sequenceA' . 'fmap' 'Data.Functor.Compose.Compose'+--     = 'Data.Functor.Compose.Compose' . 'fmap' 'sequenceA' . 'sequenceA'@ -- -- where an /applicative transformation/ is a function --@@ -104,30 +106,14 @@ -- -- preserving the 'Applicative' operations, i.e. -----  * @t ('pure' x) = 'pure' x@------  * @t (x '<*>' y) = t x '<*>' t y@------ and the identity functor @Identity@ and composition of functors @Compose@--- are defined as+-- @+-- t ('pure' x) = 'pure' x+-- t (f '<*>' x) = t f '<*>' t x+-- @ ----- >   newtype Identity a = Identity a--- >--- >   instance Functor Identity where--- >     fmap f (Identity x) = Identity (f x)--- >--- >   instance Applicative Identity where--- >     pure x = Identity x--- >     Identity f <*> Identity x = Identity (f x)--- >--- >   newtype Compose f g a = Compose (f (g a))--- >--- >   instance (Functor f, Functor g) => Functor (Compose f g) where--- >     fmap f (Compose x) = Compose (fmap (fmap f) x)--- >--- >   instance (Applicative f, Applicative g) => Applicative (Compose f g) where--- >     pure x = Compose (pure (pure x))--- >     Compose f <*> Compose x = Compose ((<*>) <$> f <*> x)+-- and the identity functor 'Identity' and composition functors+-- 'Data.Functor.Compose.Compose' are from "Data.Functor.Identity" and+-- "Data.Functor.Compose". -- -- (The naturality law is implied by parametricity.) --@@ -380,14 +366,14 @@ forM = flip mapM  -- |The 'mapAccumL' function behaves like a combination of 'fmap'--- and 'foldl'; it applies a function to each element of a structure,+-- and 'Data.Foldable.foldl'; it applies a function to each element of a structure, -- passing an accumulating parameter from left to right, and returning -- a final value of this accumulator together with the new structure. mapAccumL :: Traversable t => (a -> b -> (a, c)) -> a -> t b -> (a, t c) mapAccumL f s t = runStateL (traverse (StateL . flip f) t) s  -- |The 'mapAccumR' function behaves like a combination of 'fmap'--- and 'foldr'; it applies a function to each element of a structure,+-- and 'Data.Foldable.foldr'; it applies a function to each element of a structure, -- passing an accumulating parameter from right to left, and returning -- a final value of this accumulator together with the new structure. mapAccumR :: Traversable t => (a -> b -> (a, c)) -> a -> t b -> (a, t c)

@@ -23,8 +23,8 @@ -- Stability   :  experimental -- Portability :  not portable ----- Definition of propositional equality @(:~:)@. Pattern-matching on a variable--- of type @(a :~: b)@ produces a proof that @a ~ b@.+-- Definition of propositional equality @(':~:')@. Pattern-matching on a variable+-- of type @(a ':~:' b)@ produces a proof that @a '~' b@. -- -- @since 4.7.0.0 -----------------------------------------------------------------------------@@ -52,30 +52,6 @@ import GHC.Read import GHC.Base import Data.Type.Bool---- | Lifted, homogeneous equality. By lifted, we mean that it can be--- bogus (deferred type error). By homogeneous, the two types @a@--- and @b@ must have the same kind.-class a ~~ b => (a :: k) ~ (b :: k)-  -- See Note [The equality types story] in TysPrim-  -- NB: All this class does is to wrap its superclass, which is-  --     the "real", inhomogeneous equality; this is needed when-  --     we have a Given (a~b), and we want to prove things from it-  -- NB: Not exported, as (~) is magical syntax. That's also why there's-  -- no fixity.--  -- It's tempting to put functional dependencies on (~), but it's not-  -- necessary because the functional-dependency coverage check looks-  -- through superclasses, and (~#) is handled in that check.---- | @since 4.9.0.0-instance {-# INCOHERENT #-} a ~~ b => a ~ b-  -- See Note [The equality types story] in TysPrim-  -- If we have a Wanted (t1 ~ t2), we want to immediately-  -- simplify it to (t1 ~~ t2) and solve that instead-  ---  -- INCOHERENT because we want to use this instance eagerly, even when-  -- the tyvars are partially unknown.  infix 4 :~:, :~~: 

@@ -569,7 +569,9 @@ -- in the usual case that it is scrutinized immediately. We -- split eqTypeRep into a worker and wrapper because otherwise -- it's much larger than anything we'd want to inline.-{-# INLINABLE eqTypeRep #-}+--+-- However, due to #16893 it is currently unsafe to do so, hence the NOINLINE.+{-# NOINLINE eqTypeRep #-}  sameTypeRep :: forall k1 k2 (a :: k1) (b :: k2).                TypeRep a -> TypeRep b -> Bool@@ -664,8 +666,12 @@       SumRep rs   -> kindedTypeRep @_ @'SumRep                      `kApp` buildList (map runtimeRepTypeRep rs)       IntRep      -> rep @'IntRep-      WordRep     -> rep @'WordRep+      Int8Rep     -> rep @'Int8Rep+      Int16Rep    -> rep @'Int16Rep       Int64Rep    -> rep @'Int64Rep+      WordRep     -> rep @'WordRep+      Word8Rep    -> rep @'Word8Rep+      Word16Rep   -> rep @'Word16Rep       Word64Rep   -> rep @'Word64Rep       AddrRep     -> rep @'AddrRep       FloatRep    -> rep @'FloatRep@@ -773,7 +779,11 @@ showTypeable _ rep   | isListTyCon tc, [ty] <- tys =     showChar '[' . shows ty . showChar ']'-  | isTupleTyCon tc =++    -- Take care only to render saturated tuple tycon applications+    -- with tuple notation (#14341).+  | isTupleTyCon tc,+    Just _ <- TrType `eqTypeRep` typeRepKind rep =     showChar '(' . showArgs (showChar ',') tys . showChar ')'   where (tc, tys) = splitApps rep showTypeable _ (TrTyCon {trTyCon = tycon, trKindVars = []})

@@ -169,8 +169,9 @@ context, as 'traceIO' is in the 'IO' type. While the fresh bindings in the following example will force the 'traceM' expressions to be reduced every time the @do@-block is executed, @traceM "not crashed"@ would only be reduced once,-and the message would only be printed once.  If your monad is in 'MonadIO',-@liftIO . traceIO@ may be a better option.+and the message would only be printed once.  If your monad is in+'Control.Monad.IO.Class.MonadIO', @'Control.Monad.IO.Class.liftIO' . 'traceIO'@+may be a better option.  >>> :{ do

@@ -255,11 +255,15 @@  -- | Get the current value of @errno@ in the current thread. --+-- On GHC, the runtime will ensure that any Haskell thread will only see "its own"+-- @errno@, by saving and restoring the value when Haskell threads are scheduled+-- across OS threads. getErrno :: IO Errno  -- We must call a C function to get the value of errno in general.  On -- threaded systems, errno is hidden behind a C macro so that each OS--- thread gets its own copy.+-- thread gets its own copy (`saved_errno`, which `rts/Schedule.c` restores+-- back into the thread-local `errno` when a Haskell thread is rescheduled). getErrno = do e <- get_errno; return (Errno e) foreign import ccall unsafe "HsBase.h __hscore_get_errno" get_errno :: IO CInt 

@@ -37,9 +37,9 @@           -- | These types are represented as @newtype@s of           -- types in "Data.Int" and "Data.Word", and are instances of           -- 'Prelude.Eq', 'Prelude.Ord', 'Prelude.Num', 'Prelude.Read',-          -- 'Prelude.Show', 'Prelude.Enum', 'Typeable', 'Storable',-          -- 'Prelude.Bounded', 'Prelude.Real', 'Prelude.Integral' and-          -- 'Bits'.+          -- 'Prelude.Show', 'Prelude.Enum', 'Data.Typeable.Typeable',+          -- 'Storable', 'Prelude.Bounded', 'Prelude.Real', 'Prelude.Integral'+          -- and 'Bits'.           CChar(..),    CSChar(..),   CUChar(..)         , CShort(..),   CUShort(..),  CInt(..),      CUInt(..)         , CLong(..),    CULong(..)@@ -51,7 +51,8 @@           -- | These types are represented as @newtype@s of basic           -- foreign types, and are instances of           -- 'Prelude.Eq', 'Prelude.Ord', 'Prelude.Num', 'Prelude.Read',-          -- 'Prelude.Show', 'Prelude.Enum', 'Typeable' and 'Storable'.+          -- 'Prelude.Show', 'Prelude.Enum', 'Data.Typeable.Typeable' and+          -- 'Storable'.         , CClock(..),   CTime(..),    CUSeconds(..), CSUSeconds(..)          -- extracted from CTime, because we don't want this comment in@@ -66,7 +67,7 @@           -- | These types are represented as @newtype@s of           -- 'Prelude.Float' and 'Prelude.Double', and are instances of           -- 'Prelude.Eq', 'Prelude.Ord', 'Prelude.Num', 'Prelude.Read',-          -- 'Prelude.Show', 'Prelude.Enum', 'Typeable', 'Storable',+          -- 'Prelude.Show', 'Prelude.Enum', 'Data.Typeable.Typeable', 'Storable',           -- 'Prelude.Real', 'Prelude.Fractional', 'Prelude.Floating',           -- 'Prelude.RealFrac' and 'Prelude.RealFloat'. That does mean           -- that `CFloat`'s (respectively `CDouble`'s) instances of

@@ -40,33 +40,34 @@ -- associating a finalizer - given by the monadic operation - with the -- reference.  The storage manager will start the finalizer, in a -- separate thread, some time after the last reference to the--- @ForeignPtr@ is dropped.  There is no guarantee of promptness, and+-- 'ForeignPtr' is dropped.  There is no guarantee of promptness, and -- in fact there is no guarantee that the finalizer will eventually -- run at all. -- -- Note that references from a finalizer do not necessarily prevent -- another object from being finalized.  If A's finalizer refers to B--- (perhaps using 'touchForeignPtr', then the only guarantee is that--- B's finalizer will never be started before A's.  If both A and B--- are unreachable, then both finalizers will start together.  See--- 'touchForeignPtr' for more on finalizer ordering.+-- (perhaps using 'Foreign.ForeignPtr.touchForeignPtr', then the only+-- guarantee is that B's finalizer will never be started before A's.  If both+-- A and B are unreachable, then both finalizers will start together.  See+-- 'Foreign.ForeignPtr.touchForeignPtr' for more on finalizer ordering. -- newForeignPtr = GHC.ForeignPtr.newConcForeignPtr  addForeignPtrFinalizer :: ForeignPtr a -> IO () -> IO ()--- ^This function adds a finalizer to the given @ForeignPtr@.  The+-- ^This function adds a finalizer to the given 'ForeignPtr'.  The -- finalizer will run /before/ all other finalizers for the same -- object which have already been registered. ----- This is a variant of @Foreign.ForeignPtr.addForeignPtrFinalizer@,--- where the finalizer is an arbitrary @IO@ action.  When it is+-- This is a variant of 'Foreign.ForeignPtr.addForeignPtrFinalizer',+-- where the finalizer is an arbitrary 'IO' action.  When it is -- invoked, the finalizer will run in a new thread. -- -- NB. Be very careful with these finalizers.  One common trap is that -- if a finalizer references another finalized value, it does not--- prevent that value from being finalized.  In particular, 'Handle's--- are finalized objects, so a finalizer should not refer to a 'Handle'--- (including @stdout@, @stdin@ or @stderr@).+-- prevent that value from being finalized.  In particular, 'System.IO.Handle's+-- are finalized objects, so a finalizer should not refer to a+-- 'System.IO.Handle' (including 'System.IO.stdout', 'System.IO.stdin', or+-- 'System.IO.stderr'). -- addForeignPtrFinalizer = GHC.ForeignPtr.addForeignPtrConcFinalizer 

@@ -1,6 +1,6 @@ {-# LANGUAGE Unsafe #-} {-# LANGUAGE NoImplicitPrelude #-}-{-# OPTIONS_HADDOCK hide #-}+{-# OPTIONS_HADDOCK not-home #-}  ----------------------------------------------------------------------------- -- |

@@ -1,12 +1,12 @@ {-# LANGUAGE Trustworthy #-}-{-# LANGUAGE NoImplicitPrelude, MagicHash #-}+{-# LANGUAGE NoImplicitPrelude, MagicHash, ScopedTypeVariables #-}  ----------------------------------------------------------------------------- -- | -- Module      :  Foreign.Marshal.Array -- Copyright   :  (c) The FFI task force 2001 -- License     :  BSD-style (see the file libraries/base/LICENSE)--- +-- -- Maintainer  :  ffi@haskell.org -- Stability   :  provisional -- Portability :  portable@@ -82,11 +82,8 @@ -- |Allocate storage for the given number of elements of a storable type -- (like 'Foreign.Marshal.Alloc.malloc', but for multiple elements). ---mallocArray :: Storable a => Int -> IO (Ptr a)-mallocArray  = doMalloc undefined-  where-    doMalloc            :: Storable a' => a' -> Int -> IO (Ptr a')-    doMalloc dummy size  = mallocBytes (size * sizeOf dummy)+mallocArray :: forall a . Storable a => Int -> IO (Ptr a)+mallocArray  size = mallocBytes (size * sizeOf (undefined :: a))  -- |Like 'mallocArray', but add an extra position to hold a special -- termination element.@@ -96,11 +93,8 @@  -- |Like 'mallocArray', but allocated memory is filled with bytes of value zero. ---callocArray :: Storable a => Int -> IO (Ptr a)-callocArray  = doCalloc undefined-  where-    doCalloc :: Storable a' => a' -> Int -> IO (Ptr a')-    doCalloc dummy size  = callocBytes (size * sizeOf dummy)+callocArray :: forall a . Storable a => Int -> IO (Ptr a)+callocArray size = callocBytes (size * sizeOf (undefined :: a))  -- |Like 'callocArray0', but allocated memory is filled with bytes of value -- zero.@@ -111,12 +105,9 @@ -- |Temporarily allocate space for the given number of elements -- (like 'Foreign.Marshal.Alloc.alloca', but for multiple elements). ---allocaArray :: Storable a => Int -> (Ptr a -> IO b) -> IO b-allocaArray  = doAlloca undefined-  where-    doAlloca            :: Storable a' => a' -> Int -> (Ptr a' -> IO b') -> IO b'-    doAlloca dummy size  = allocaBytesAligned (size * sizeOf dummy)-                                              (alignment dummy)+allocaArray :: forall a b . Storable a => Int -> (Ptr a -> IO b) -> IO b+allocaArray size = allocaBytesAligned (size * sizeOf (undefined :: a))+                                      (alignment (undefined :: a))  -- |Like 'allocaArray', but add an extra position to hold a special -- termination element.@@ -129,11 +120,8 @@  -- |Adjust the size of an array ---reallocArray :: Storable a => Ptr a -> Int -> IO (Ptr a)-reallocArray  = doRealloc undefined-  where-    doRealloc                :: Storable a' => a' -> Ptr a' -> Int -> IO (Ptr a')-    doRealloc dummy ptr size  = reallocBytes ptr (size * sizeOf dummy)+reallocArray :: forall a . Storable a => Ptr a -> Int -> IO (Ptr a)+reallocArray ptr size = reallocBytes ptr (size * sizeOf (undefined :: a))  -- |Adjust the size of an array including an extra position for the end marker. --@@ -153,7 +141,7 @@   where     f 0 acc = do e <- peekElemOff ptr 0; return (e:acc)     f n acc = do e <- peekElemOff ptr n; f (n-1) (e:acc)-  + -- |Convert an array terminated by the given end marker into a Haskell list -- peekArray0            :: (Storable a, Eq a) => a -> Ptr a -> IO [a]@@ -238,20 +226,14 @@ -- |Copy the given number of elements from the second array (source) into the -- first array (destination); the copied areas may /not/ overlap ---copyArray :: Storable a => Ptr a -> Ptr a -> Int -> IO ()-copyArray  = doCopy undefined-  where-    doCopy                     :: Storable a' => a' -> Ptr a' -> Ptr a' -> Int -> IO ()-    doCopy dummy dest src size  = copyBytes dest src (size * sizeOf dummy)+copyArray :: forall a . Storable a => Ptr a -> Ptr a -> Int -> IO ()+copyArray dest src size = copyBytes dest src (size * sizeOf (undefined :: a))  -- |Copy the given number of elements from the second array (source) into the -- first array (destination); the copied areas /may/ overlap ---moveArray :: Storable a => Ptr a -> Ptr a -> Int -> IO ()-moveArray  = doMove undefined-  where-    doMove                     :: Storable a' => a' -> Ptr a' -> Ptr a' -> Int -> IO ()-    doMove dummy dest src size  = moveBytes dest src (size * sizeOf dummy)+moveArray :: forall a . Storable a => Ptr a -> Ptr a -> Int -> IO ()+moveArray  dest src size = moveBytes dest src (size * sizeOf (undefined :: a))   -- finding the length@@ -272,9 +254,5 @@  -- |Advance a pointer into an array by the given number of elements ---advancePtr :: Storable a => Ptr a -> Int -> Ptr a-advancePtr  = doAdvance undefined-  where-    doAdvance             :: Storable a' => a' -> Ptr a' -> Int -> Ptr a'-    doAdvance dummy ptr i  = ptr `plusPtr` (i * sizeOf dummy)-+advancePtr :: forall a . Storable a => Ptr a -> Int -> Ptr a+advancePtr ptr i = ptr `plusPtr` (i * sizeOf (undefined :: a))

@@ -1,5 +1,5 @@ {-# LANGUAGE Trustworthy #-}-{-# LANGUAGE NoImplicitPrelude #-}+{-# LANGUAGE NoImplicitPrelude, ScopedTypeVariables #-}  -------------------------------------------------------------------------------- -- |@@ -102,11 +102,8 @@ -- allocated is determined by the 'sizeOf' method from the instance of -- 'Storable' for the appropriate type. -pooledMalloc :: Storable a => Pool -> IO (Ptr a)-pooledMalloc = pm undefined-  where-    pm           :: Storable a' => a' -> Pool -> IO (Ptr a')-    pm dummy pool = pooledMallocBytes pool (sizeOf dummy)+pooledMalloc :: forall a . Storable a => Pool -> IO (Ptr a)+pooledMalloc pool = pooledMallocBytes pool (sizeOf (undefined :: a))  -- | Allocate the given number of bytes of storage in the pool. @@ -120,11 +117,8 @@ -- | Adjust the storage area for an element in the pool to the given size of -- the required type. -pooledRealloc :: Storable a => Pool -> Ptr a -> IO (Ptr a)-pooledRealloc = pr undefined-  where-    pr               :: Storable a' => a' -> Pool -> Ptr a' -> IO (Ptr a')-    pr dummy pool ptr = pooledReallocBytes pool ptr (sizeOf dummy)+pooledRealloc :: forall a . Storable a => Pool -> Ptr a -> IO (Ptr a)+pooledRealloc pool ptr = pooledReallocBytes pool ptr (sizeOf (undefined :: a))  -- | Adjust the storage area for an element in the pool to the given size. @@ -140,11 +134,9 @@ -- | Allocate storage for the given number of elements of a storable type in the -- pool. -pooledMallocArray :: Storable a => Pool -> Int -> IO (Ptr a)-pooledMallocArray = pma undefined-  where-    pma                :: Storable a' => a' -> Pool -> Int -> IO (Ptr a')-    pma dummy pool size = pooledMallocBytes pool (size * sizeOf dummy)+pooledMallocArray :: forall a . Storable a => Pool -> Int -> IO (Ptr a)+pooledMallocArray pool size =+    pooledMallocBytes pool (size * sizeOf (undefined :: a))  -- | Allocate storage for the given number of elements of a storable type in the -- pool, but leave room for an extra element to signal the end of the array.@@ -155,11 +147,9 @@  -- | Adjust the size of an array in the given pool. -pooledReallocArray :: Storable a => Pool -> Ptr a -> Int -> IO (Ptr a)-pooledReallocArray = pra undefined-  where-    pra                ::  Storable a' => a' -> Pool -> Ptr a' -> Int -> IO (Ptr a')-    pra dummy pool ptr size  = pooledReallocBytes pool ptr (size * sizeOf dummy)+pooledReallocArray :: forall a . Storable a => Pool -> Ptr a -> Int -> IO (Ptr a)+pooledReallocArray pool ptr size =+    pooledReallocBytes pool ptr (size * sizeOf (undefined :: a))  -- | Adjust the size of an array with an end marker in the given pool. @@ -195,4 +185,3 @@    ptr <- pooledMallocArray0 pool (length vals)    pokeArray0 marker ptr vals    return ptr-

@@ -1,7 +1,7 @@ {-# LANGUAGE Unsafe #-} {-# LANGUAGE NoImplicitPrelude, MagicHash, UnboxedTuples, RoleAnnotations #-} {-# LANGUAGE BangPatterns #-}-{-# OPTIONS_HADDOCK hide #-}+{-# OPTIONS_HADDOCK not-home #-}  ----------------------------------------------------------------------------- -- |@@ -453,13 +453,13 @@                         -- of the array.  These bounds are the lowest and                         -- highest indices in the array, in that order.                         -- For example, a one-origin vector of length-                        -- '10' has bounds '(1,10)', and a one-origin '10'-                        -- by '10' matrix has bounds '((1,1),(10,10))'.+                        -- @10@ has bounds @(1,10)@, and a one-origin @10@+                        -- by @10@ matrix has bounds @((1,1),(10,10))@.         -> [(i, e)]     -- ^ a list of /associations/ of the form                         -- (/index/, /value/).  Typically, this list will                         -- be expressed as a comprehension.  An-                        -- association '(i, x)' defines the value of-                        -- the array at index 'i' to be 'x'.+                        -- association @(i, x)@ defines the value of+                        -- the array at index @i@ to be @x@.         -> Array i e array (l,u) ies     = let n = safeRangeSize (l,u)

@@ -90,7 +90,7 @@ -- -Wno-orphans is needed for things like: -- Orphan rule: "x# -# x#" ALWAYS forall x# :: Int# -# x# x# = 0 {-# OPTIONS_GHC -Wno-orphans #-}-{-# OPTIONS_HADDOCK hide #-}+{-# OPTIONS_HADDOCK not-home #-}  ----------------------------------------------------------------------------- -- |@@ -213,16 +213,16 @@  -- | The class of semigroups (types with an associative binary operation). ----- Instances should satisfy the associativity law:+-- Instances should satisfy the following: -----  * @x '<>' (y '<>' z) = (x '<>' y) '<>' z@+-- [Associativity] @x '<>' (y '<>' z) = (x '<>' y) '<>' z@ -- -- @since 4.9.0.0 class Semigroup a where         -- | An associative operation.         (<>) :: a -> a -> a -        -- | Reduce a non-empty list with @\<\>@+        -- | Reduce a non-empty list with '<>'         --         -- The default definition should be sufficient, but this can be         -- overridden for efficiency.@@ -240,22 +240,19 @@         --         -- By making this a member of the class, idempotent semigroups         -- and monoids can upgrade this to execute in /O(1)/ by-        -- picking @stimes = 'stimesIdempotent'@ or @stimes =+        -- picking @stimes = 'Data.Semigroup.stimesIdempotent'@ or @stimes =         -- 'stimesIdempotentMonoid'@ respectively.         stimes :: Integral b => b -> a -> a         stimes = stimesDefault   -- | The class of monoids (types with an associative binary operation that--- has an identity).  Instances should satisfy the following laws:------  * @x '<>' 'mempty' = x@------  * @'mempty' '<>' x = x@------  * @x '<>' (y '<>' z) = (x '<>' y) '<>' z@ ('Semigroup' law)+-- has an identity).  Instances should satisfy the following: -----  * @'mconcat' = 'foldr' '(<>)' 'mempty'@+-- [Right identity] @x '<>' 'mempty' = x@+-- [Left identity]  @'mempty' '<>' x = x@+-- [Associativity]  @x '<>' (y '<>' z) = (x '<>' y) '<>' z@ ('Semigroup' law)+-- [Concatenation]  @'mconcat' = 'foldr' ('<>') 'mempty'@ -- -- The method names refer to the monoid of lists under concatenation, -- but there are many other instances.@@ -263,7 +260,7 @@ -- Some types can be viewed as a monoid in more than one way, -- e.g. both addition and multiplication on numbers. -- In such cases we often define @newtype@s and make those instances--- of 'Monoid', e.g. 'Sum' and 'Product'.+-- of 'Monoid', e.g. 'Data.Semigroup.Sum' and 'Data.Semigroup.Product'. -- -- __NOTE__: 'Semigroup' is a superclass of 'Monoid' since /base-4.11.0.0/. class Semigroup a => Monoid a where@@ -273,7 +270,7 @@         -- | An associative operation         --         -- __NOTE__: This method is redundant and has the default-        -- implementation @'mappend' = '(<>)'@ since /base-4.11.0.0/.+        -- implementation @'mappend' = ('<>')@ since /base-4.11.0.0/.         mappend :: a -> a -> a         mappend = (<>)         {-# INLINE mappend #-}@@ -444,14 +441,15 @@ instance Monoid a => Monoid (IO a) where     mempty = pure mempty -{- | The 'Functor' class is used for types that can be mapped over.-Instances of 'Functor' should satisfy the following laws:+{- | A type @f@ is a Functor if it provides a function @fmap@ which, given any types @a@ and @b@+lets you apply any function from @(a -> b)@ to turn an @f a@ into an @f b@, preserving the+structure of @f@. Furthermore @f@ needs to adhere to the following: -> fmap id  ==  id-> fmap (f . g)  ==  fmap f . fmap g+[Identity]    @'fmap' 'id' == 'id'@+[Composition] @'fmap' (f . g) == 'fmap' f . 'fmap' g@ -The instances of 'Functor' for lists, 'Data.Maybe.Maybe' and 'System.IO.IO'-satisfy these laws.+Note, that the second law follows from the free theorem of the type 'fmap' and+the first law, so you need only check that the former condition holds. -}  class  Functor f  where@@ -475,23 +473,23 @@ -- --      @('<*>') = 'liftA2' 'id'@ -----      @'liftA2' f x y = f '<$>' x '<*>' y@+--      @'liftA2' f x y = f 'Prelude.<$>' x '<*>' y@ -- -- Further, any definition must satisfy the following: ----- [/identity/]+-- [Identity] -- --      @'pure' 'id' '<*>' v = v@ ----- [/composition/]+-- [Composition] -- --      @'pure' (.) '<*>' u '<*>' v '<*>' w = u '<*>' (v '<*>' w)@ ----- [/homomorphism/]+-- [Homomorphism] -- --      @'pure' f '<*>' 'pure' x = 'pure' (f x)@ ----- [/interchange/]+-- [Interchange] -- --      @u '<*>' 'pure' y = 'pure' ('$' y) '<*>' u@ --@@ -629,11 +627,11 @@ Haskell's @do@ expressions provide a convenient syntax for writing monadic expressions. -Instances of 'Monad' should satisfy the following laws:+Instances of 'Monad' should satisfy the following: -* @'return' a '>>=' k  =  k a@-* @m '>>=' 'return'  =  m@-* @m '>>=' (\\x -> k x '>>=' h)  =  (m '>>=' k) '>>=' h@+[Left identity]  @'return' a '>>=' k  =  k a@+[Right identity] @m '>>=' 'return'  =  m@+[Associativity]  @m '>>=' (\\x -> k x '>>=' h)  =  (m '>>=' k) '>>=' h@  Furthermore, the 'Monad' and 'Applicative' operations should relate as follows: @@ -666,17 +664,6 @@     return      :: a -> m a     return      = pure -    -- | Fail with a message.  This operation is not part of the-    -- mathematical definition of a monad, but is invoked on pattern-match-    -- failure in a @do@ expression.-    ---    -- As part of the MonadFail proposal (MFP), this function is moved-    -- to its own class 'MonadFail' (see "Control.Monad.Fail" for more-    -- details). The definition here will be removed in a future-    -- release.-    fail        :: String -> m a-    fail s      = errorWithoutStackTrace s- {- Note [Recursive bindings for Applicative/Monad] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ @@ -857,8 +844,6 @@      (>>) = (*>) -    fail _              = Nothing- -- ----------------------------------------------------------------------------- -- The Alternative class definition @@ -869,7 +854,7 @@ -- If defined, 'some' and 'many' should be the least solutions -- of the equations: ----- * @'some' v = (:) '<$>' v '<*>' 'many' v@+-- * @'some' v = (:) 'Prelude.<$>' v '<*>' 'many' v@ -- -- * @'many' v = 'some' v '<|>' 'pure' []@ class Applicative f => Alternative f where@@ -986,8 +971,6 @@     xs >>= f             = [y | x <- xs, y <- f x]     {-# INLINE (>>) #-}     (>>) = (*>)-    {-# INLINE fail #-}-    fail _              = []  -- | @since 2.01 instance Alternative [] where@@ -1097,11 +1080,14 @@ --              map ---------------------------------------------- --- | 'map' @f xs@ is the list obtained by applying @f@ to each element+-- | /O(n)/. 'map' @f xs@ is the list obtained by applying @f@ to each element -- of @xs@, i.e., -- -- > map f [x1, x2, ..., xn] == [f x1, f x2, ..., f xn] -- > map f [x1, x2, ...] == [f x1, f x2, ...]+--+-- >>> map (+1) [1, 2, 3]+--- [2,3,4]  map :: (a -> b) -> [a] -> [b] {-# NOINLINE [0] map #-}@@ -1256,8 +1242,8 @@ -- The compiler may rewrite it to @('assertError' line)@.  -- | If the first argument evaluates to 'True', then the result is the--- second argument.  Otherwise an 'AssertionFailed' exception is raised,--- containing a 'String' with the source file and line number of the+-- second argument.  Otherwise an 'Control.Exception.AssertionFailed' exception+-- is raised, containing a 'String' with the source file and line number of the -- call to 'assert'. -- -- Assertions can normally be turned on or off with a compiler flag@@ -1314,9 +1300,8 @@ -- It is also useful in higher-order situations, such as @'map' ('$' 0) xs@, -- or @'Data.List.zipWith' ('$') fs xs@. ----- Note that @($)@ is levity-polymorphic in its result type, so that---     foo $ True    where  foo :: Bool -> Int#--- is well-typed+-- Note that @('$')@ is levity-polymorphic in its result type, so that+-- @foo '$' True@ where @foo :: Bool -> Int#@ is well-typed. {-# INLINE ($) #-} ($) :: forall r a (b :: TYPE r). (a -> b) -> a -> b f $ x =  f x@@ -1365,7 +1350,6 @@     {-# INLINE (>>=)  #-}     (>>)      = (*>)     (>>=)     = bindIO-    fail s    = failIO s  -- | @since 4.9.0.0 instance Alternative IO where@@ -1388,21 +1372,12 @@ unIO (IO a) = a  {- |-Returns the 'tag' of a constructor application; this function is used+Returns the tag of a constructor application; this function is used by the deriving code for Eq, Ord and Enum.--The primitive dataToTag# requires an evaluated constructor application-as its argument, so we provide getTag as a wrapper that performs the-evaluation before calling dataToTag#.  We could have dataToTag#-evaluate its argument, but we prefer to do it this way because (a)-dataToTag# can be an inline primop if it doesn't need to do any-evaluation, and (b) we want to expose the evaluation to the-simplifier, because it might be possible to eliminate the evaluation-in the case when the argument is already known to be evaluated. -} {-# INLINE getTag #-} getTag :: a -> Int#-getTag !x = dataToTag# x+getTag x = dataToTag# x  ---------------------------------------------- -- Numeric primops

@@ -85,7 +85,7 @@ -- | Block the current thread until data is available to read on the -- given file descriptor (GHC only). ----- This will throw an 'IOError' if the file descriptor was closed+-- This will throw an 'Prelude.IOError' if the file descriptor was closed -- while this thread was blocked.  To safely close a file descriptor -- that has been used with 'threadWaitRead', use 'closeFdWith'. threadWaitRead :: Fd -> IO ()@@ -101,7 +101,7 @@ -- | Block the current thread until data can be written to the -- given file descriptor (GHC only). ----- This will throw an 'IOError' if the file descriptor was closed+-- This will throw an 'Prelude.IOError' if the file descriptor was closed -- while this thread was blocked.  To safely close a file descriptor -- that has been used with 'threadWaitWrite', use 'closeFdWith'. threadWaitWrite :: Fd -> IO ()

@@ -367,7 +367,7 @@ -} setNumCapabilities :: Int -> IO () setNumCapabilities i-  | i <= 0    = fail $ "setNumCapabilities: Capability count ("++show i++") must be positive"+  | i <= 0    = failIO $ "setNumCapabilities: Capability count ("++show i++") must be positive"   | otherwise = c_setNumCapabilities (fromIntegral i)  foreign import ccall safe "setNumCapabilities"@@ -543,8 +543,8 @@         -- ^currently in a foreign call   | BlockedOnOther         -- ^blocked on some other resource.  Without @-threaded@,-        -- I\/O and 'threadDelay' show up as 'BlockedOnOther', with @-threaded@-        -- they show up as 'BlockedOnMVar'.+        -- I\/O and 'Control.Concurrent.threadDelay' show up as+        -- 'BlockedOnOther', with @-threaded@ they show up as 'BlockedOnMVar'.   deriving ( Eq   -- ^ @since 4.3.0.0            , Ord  -- ^ @since 4.3.0.0            , Show -- ^ @since 4.3.0.0@@ -720,8 +720,11 @@ -- -- However, there are functions for creating transactional variables that -- can always be safely called in 'unsafePerformIO'. See: 'newTVarIO',--- 'newTChanIO', 'newBroadcastTChanIO', 'newTQueueIO', 'newTBQueueIO',--- and 'newTMVarIO'.+-- 'Control.Concurrent.STM.TChan.newTChanIO',+-- 'Control.Concurrent.STM.TChan.newBroadcastTChanIO',+-- 'Control.Concurrent.STM.TQueue.newTQueueIO',+-- 'Control.Concurrent.STM.TBQueue.newTBQueueIO', and+-- 'Control.Concurrent.STM.TMVar.newTMVarIO'. -- -- Using 'unsafePerformIO' inside of 'atomically' is also dangerous but for -- different reasons. See 'unsafeIOToSTM' for more on this.@@ -749,8 +752,13 @@ -- | A variant of 'throw' that can only be used within the 'STM' monad. -- -- Throwing an exception in @STM@ aborts the transaction and propagates the--- exception.+-- exception. If the exception is caught via 'catchSTM', only the changes+-- enclosed by the catch are rolled back; changes made outside of 'catchSTM'+-- persist. --+-- If the exception is not caught inside of the 'STM', it is re-thrown by+-- 'atomically', and the entire 'STM' is rolled back.+-- -- Although 'throwSTM' has a type that is an instance of the type of 'throw', the -- two functions are subtly different: --@@ -767,7 +775,12 @@ throwSTM :: Exception e => e -> STM a throwSTM e = STM $ raiseIO# (toException e) --- |Exception handling within STM actions.+-- | Exception handling within STM actions.+--+-- @'catchSTM' m f@ catches any exception thrown by @m@ using 'throwSTM',+-- using the function @f@ to handle the exception. If an exception is+-- thrown, any changes made by @m@ are rolled back, but changes prior to+-- @m@ persist. catchSTM :: Exception e => STM a -> (e -> STM a) -> STM a catchSTM (STM m) handler = STM $ catchSTM# m handler'     where

@@ -131,7 +131,7 @@ waitForDelayEvent usecs = do   m <- newEmptyMVar   target <- calculateTarget usecs-  atomicModifyIORef pendingDelays (\xs -> (Delay target m : xs, ()))+  _ <- atomicModifyIORef'_ pendingDelays (\xs -> Delay target m : xs)   prodServiceThread   takeMVar m @@ -140,7 +140,7 @@ waitForDelayEventSTM usecs = do    t <- atomically $ newTVar False    target <- calculateTarget usecs-   atomicModifyIORef pendingDelays (\xs -> (DelaySTM target t : xs, ()))+   _ <- atomicModifyIORef'_ pendingDelays (\xs -> DelaySTM target t : xs)    prodServiceThread    return t @@ -219,10 +219,10 @@  prodServiceThread :: IO () prodServiceThread = do-  -- NB. use atomicModifyIORef here, otherwise there are race+  -- NB. use atomicSwapIORef here, otherwise there are race   -- conditions in which prodding is left at True but the server is   -- blocked in select().-  was_set <- atomicModifyIORef prodding $ \b -> (True,b)+  was_set <- atomicSwapIORef prodding True   when (not was_set) wakeupIOManager  -- ----------------------------------------------------------------------------@@ -239,7 +239,7 @@  service_loop wakeup old_delays = do   -- pick up new delay requests-  new_delays <- atomicModifyIORef pendingDelays (\a -> ([],a))+  new_delays <- atomicSwapIORef pendingDelays []   let  delays = foldr insertDelay old_delays new_delays    now <- getMonotonicUSec@@ -262,8 +262,7 @@  service_cont :: HANDLE -> [DelayReq] -> IO () service_cont wakeup delays = do-  r <- atomicModifyIORef prodding (\_ -> (False,False))-  r `seq` return () -- avoid space leak+  _ <- atomicSwapIORef prodding False   service_loop wakeup delays  -- must agree with rts/win32/ThrIOManager.c

@@ -3,7 +3,7 @@            , RankNTypes            , ExistentialQuantification   #-}-{-# OPTIONS_HADDOCK hide #-}+{-# OPTIONS_HADDOCK not-home #-}  ----------------------------------------------------------------------------- -- |

@@ -4,7 +4,7 @@ {-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE StandaloneDeriving #-} {-# LANGUAGE Trustworthy #-}-{-# OPTIONS_HADDOCK hide #-}+{-# OPTIONS_HADDOCK not-home #-}  ----------------------------------------------------------------------------- -- |@@ -632,9 +632,9 @@     -- use unboxed literals for maxBound, because GHC doesn't optimise     -- (fromInteger 0xffffffff :: Word). #if WORD_SIZE_IN_BITS == 32-    maxBound = W# (int2Word# 0xFFFFFFFF#)+    maxBound = W# 0xFFFFFFFF## #elif WORD_SIZE_IN_BITS == 64-    maxBound = W# (int2Word# 0xFFFFFFFFFFFFFFFF#)+    maxBound = W# 0xFFFFFFFFFFFFFFFF## #else #error Unhandled value for WORD_SIZE_IN_BITS #endif@@ -919,7 +919,6 @@ -- Natural ------------------------------------------------------------------------ -#if defined(MIN_VERSION_integer_gmp) -- | @since 4.8.0.0 instance Enum Natural where     succ n = n `plusNatural`  wordToNaturalBase 1##@@ -927,11 +926,13 @@      toEnum = intToNatural +#if defined(MIN_VERSION_integer_gmp)     fromEnum (NatS# w)       | i >= 0    = i       | otherwise = errorWithoutStackTrace "fromEnum: out of Int range"       where         i = I# (word2Int# w)+#endif     fromEnum n = fromEnum (naturalToInteger n)      enumFrom x        = enumDeltaNatural      x (wordToNaturalBase 1##)@@ -962,31 +963,6 @@          | x >= ndelta = x : go (x-ndelta)          | otherwise   = [x] -#else---- | @since 4.8.0.0-instance Enum Natural where-  pred (Natural 0) = errorWithoutStackTrace "Natural.pred: 0"-  pred (Natural n) = Natural (pred n)-  {-# INLINE pred #-}-  succ (Natural n) = Natural (succ n)-  {-# INLINE succ #-}-  fromEnum (Natural n) = fromEnum n-  {-# INLINE fromEnum #-}-  toEnum n | n < 0     = errorWithoutStackTrace "Natural.toEnum: negative"-           | otherwise = Natural (toEnum n)-  {-# INLINE toEnum #-}--  enumFrom     = coerce (enumFrom     :: Integer -> [Integer])-  enumFromThen x y-    | x <= y    = coerce (enumFromThen :: Integer -> Integer -> [Integer]) x y-    | otherwise = enumFromThenTo x y (wordToNaturalBase 0##)--  enumFromTo   = coerce (enumFromTo   :: Integer -> Integer -> [Integer])-  enumFromThenTo-    = coerce (enumFromThenTo :: Integer -> Integer -> Integer -> [Integer])--#endif  -- Instances from GHC.Types 

@@ -21,10 +21,10 @@ # endif #endif --- | Computation 'getFullArgs' is the "raw" version of 'getArgs', similar--- to @argv@ in other languages. It returns a list of the program's--- command line arguments, starting with the program name, and--- including those normally eaten by the RTS (+RTS ... -RTS).+-- | Computation 'getFullArgs' is the "raw" version of+-- 'System.Environment.getArgs', similar to @argv@ in other languages. It+-- returns a list of the program's command line arguments, starting with the+-- program name, and including those normally eaten by the RTS (+RTS ... -RTS). getFullArgs :: IO [String] getFullArgs = do   alloca $ \ p_argc -> do

@@ -1,7 +1,7 @@ {-# LANGUAGE Trustworthy #-} {-# LANGUAGE NoImplicitPrelude, MagicHash, ImplicitParams #-} {-# LANGUAGE RankNTypes, PolyKinds, DataKinds #-}-{-# OPTIONS_HADDOCK hide #-}+{-# OPTIONS_HADDOCK not-home #-}  ----------------------------------------------------------------------------- -- |@@ -29,7 +29,9 @@ import GHC.Prim import GHC.Integer ()   -- Make sure Integer and Natural are compiled first import GHC.Natural ()   -- because GHC depends on it in a wired-in way-                        -- so the build system doesn't see the dependency+                        -- so the build system doesn't see the dependency.+                        -- See Note [Depend on GHC.Integer] and+                        -- Note [Depend on GHC.Natural] in GHC.Base. import {-# SOURCE #-} GHC.Exception   ( errorCallWithCallStackException   , errorCallException )

@@ -126,7 +126,7 @@ -- file after it has been closed. closeControl :: Control -> IO () closeControl w = do-  atomicModifyIORef (controlIsDead w) (\_ -> (True, ()))+  _ <- atomicSwapIORef (controlIsDead w) True   _ <- c_close . fromIntegral . controlReadFd $ w   _ <- c_close . fromIntegral . controlWriteFd $ w   when (didRegisterWakeupFd w) $ c_setIOManagerWakeupFd (-1)

@@ -216,7 +216,7 @@ delete (Backend bState _ _ _ bDelete) = bDelete bState {-# INLINE delete #-} --- | Throw an 'IOError' corresponding to the current value of+-- | Throw an 'Prelude.IOError' corresponding to the current value of -- 'getErrno' if the result value of the 'IO' action is -1 and -- 'getErrno' is not 'eINTR'.  If the result value is -1 and -- 'getErrno' returns 'eINTR' 0 is returned.  Otherwise the result

@@ -87,11 +87,11 @@   return ()  modifyFd :: KQueue -> Fd -> E.Event -> E.Event -> IO Bool-modifyFd kq fd oevt nevt = kqueueControl (kqueueFd kq) evs+modifyFd kq fd oevt nevt = do+  kqueueControl (kqueueFd kq) evs   where-    evs-      | nevt == mempty = toEvents fd (toFilter oevt) flagDelete noteEOF-      | otherwise      = toEvents fd (toFilter nevt) flagAdd noteEOF+    evs = toEvents fd (toFilter oevt) flagDelete noteEOF+       <> toEvents fd (toFilter nevt) flagAdd noteEOF  toFilter :: E.Event -> [Filter] toFilter e = catMaybes [ check E.evtRead filterRead, check E.evtWrite filterWrite ]

@@ -49,7 +49,6 @@ import GHC.Word (Word64) import GHC.Num (Num(..)) import GHC.Real (fromIntegral)-import GHC.Types (Int)  #include "MachDeps.h" 

@@ -72,7 +72,7 @@ -- | Block the current thread until data is available to read from the -- given file descriptor. ----- This will throw an 'IOError' if the file descriptor was closed+-- This will throw an 'Prelude.IOError' if the file descriptor was closed -- while this thread was blocked.  To safely close a file descriptor -- that has been used with 'threadWaitRead', use 'closeFdWith'. threadWaitRead :: Fd -> IO ()@@ -82,7 +82,7 @@ -- | Block the current thread until the given file descriptor can -- accept data to write. ----- This will throw an 'IOError' if the file descriptor was closed+-- This will throw an 'Prelude.IOError' if the file descriptor was closed -- while this thread was blocked.  To safely close a file descriptor -- that has been used with 'threadWaitWrite', use 'closeFdWith'. threadWaitWrite :: Fd -> IO ()@@ -145,7 +145,7 @@ -- The second element of the return value pair is an IO action that can be used -- to deregister interest in the file descriptor. ----- The STM action will throw an 'IOError' if the file descriptor was closed+-- The STM action will throw an 'Prelude.IOError' if the file descriptor was closed -- while the STM action is being executed.  To safely close a file descriptor -- that has been used with 'threadWaitReadSTM', use 'closeFdWith'. threadWaitReadSTM :: Fd -> IO (STM (), IO ())@@ -157,7 +157,7 @@ -- The second element of the return value pair is an IO action that can be used to deregister -- interest in the file descriptor. ----- The STM action will throw an 'IOError' if the file descriptor was closed+-- The STM action will throw an 'Prelude.IOError' if the file descriptor was closed -- while the STM action is being executed.  To safely close a file descriptor -- that has been used with 'threadWaitWriteSTM', use 'closeFdWith'. threadWaitWriteSTM :: Fd -> IO (STM (), IO ())

@@ -6,7 +6,7 @@            , PatternSynonyms   #-} {-# LANGUAGE TypeInType #-}-{-# OPTIONS_HADDOCK hide #-}+{-# OPTIONS_HADDOCK not-home #-}  ----------------------------------------------------------------------------- -- |

@@ -5,7 +5,7 @@            , RecordWildCards            , PatternSynonyms   #-}-{-# OPTIONS_HADDOCK hide #-}+{-# OPTIONS_HADDOCK not-home #-}  ----------------------------------------------------------------------------- -- |

@@ -34,6 +34,9 @@         uncheckedIShiftL64#, uncheckedIShiftRA64#,         isTrue#, +        -- * Compat wrapper+        atomicModifyMutVar#,+         -- * Fusion         build, augment, @@ -46,7 +49,7 @@         -- * Ids with special behaviour         lazy, inline, oneShot, -        -- * Running 'RealWorld' state transformers+        -- * Running 'RealWorld' state thread         runRW#,          -- * Safe coercions@@ -219,3 +222,27 @@   type (Item CallStack) = (String, SrcLoc)   fromList = fromCallSiteList   toList   = getCallStack++-- | An implementation of the old @atomicModifyMutVar#@ primop in+-- terms of the new 'atomicModifyMutVar2#' primop, for backwards+-- compatibility. The type of this function is a bit bogus. It's+-- best to think of it as having type+--+-- @+-- atomicModifyMutVar#+--   :: MutVar# s a+--   -> (a -> (a, b))+--   -> State# s+--   -> (# State# s, b #)+-- @+--+-- but there may be code that uses this with other two-field record+-- types.+atomicModifyMutVar#+  :: MutVar# s a+  -> (a -> b)+  -> State# s+  -> (# State# s, c #)+atomicModifyMutVar# mv f s =+  case unsafeCoerce# (atomicModifyMutVar2# mv f s) of+    (# s', _, ~(_, res) #) -> (# s', res #)

@@ -10,7 +10,7 @@ -- We believe we could deorphan this module, by moving lots of things -- around, but we haven't got there yet: {-# OPTIONS_GHC -Wno-orphans #-}-{-# OPTIONS_HADDOCK hide #-}+{-# OPTIONS_HADDOCK not-home #-}  ----------------------------------------------------------------------------- -- |@@ -65,12 +65,13 @@  -- | Trigonometric and hyperbolic functions and related functions. ----- The Haskell Report defines no laws for 'Floating'. However, '(+)', '(*)'+-- The Haskell Report defines no laws for 'Floating'. However, @('+')@, @('*')@ -- and 'exp' are customarily expected to define an exponential field and have -- the following properties: ----- * @exp (a + b)@ = @exp a * exp b+-- * @exp (a + b)@ = @exp a * exp b@ -- * @exp (fromInteger 0)@ = @fromInteger 1@+-- class  (Fractional a) => Floating a  where     pi                  :: a     exp, log, sqrt      :: a -> a@@ -166,7 +167,7 @@     decodeFloat         :: a -> (Integer,Int)     -- | 'encodeFloat' performs the inverse of 'decodeFloat' in the     -- sense that for finite @x@ with the exception of @-0.0@,-    -- @'uncurry' 'encodeFloat' ('decodeFloat' x) = x@.+    -- @'Prelude.uncurry' 'encodeFloat' ('decodeFloat' x) = x@.     -- @'encodeFloat' m n@ is one of the two closest representable     -- floating-point numbers to @m*b^^n@ (or @&#177;Infinity@ if overflow     -- occurs); usually the closer, but if @m@ contains too many bits,@@ -390,13 +391,9 @@     (**) x y            =  powerFloat x y     logBase x y         =  log y / log x -    asinh x-      | x > huge   = log 2 + log x-      | x < 0      = -asinh (-x)-      | otherwise  = log (x + sqrt (1 + x*x))-     where huge = 1e10-    acosh x = log (x + (x+1.0) * sqrt ((x-1.0)/(x+1.0)))-    atanh x = 0.5 * log ((1.0+x) / (1.0-x))+    asinh x             =  asinhFloat x+    acosh x             =  acoshFloat x+    atanh x             =  atanhFloat x      log1p = log1pFloat     expm1 = expm1Float@@ -535,13 +532,9 @@     (**) x y            =  powerDouble x y     logBase x y         =  log y / log x -    asinh x-      | x > huge   = log 2 + log x-      | x < 0      = -asinh (-x)-      | otherwise  = log (x + sqrt (1 + x*x))-     where huge = 1e20-    acosh x = log (x + (x+1.0) * sqrt ((x-1.0)/(x+1.0)))-    atanh x = 0.5 * log ((1.0+x) / (1.0-x))+    asinh x             =  asinhDouble x+    acosh x             =  acoshDouble x+    atanh x             =  atanhDouble x      log1p = log1pDouble     expm1 = expm1Double@@ -1151,6 +1144,7 @@ sinFloat, cosFloat, tanFloat  :: Float -> Float asinFloat, acosFloat, atanFloat  :: Float -> Float sinhFloat, coshFloat, tanhFloat  :: Float -> Float+asinhFloat, acoshFloat, atanhFloat  :: Float -> Float expFloat    (F# x) = F# (expFloat# x) logFloat    (F# x) = F# (logFloat# x) sqrtFloat   (F# x) = F# (sqrtFloat# x)@@ -1164,6 +1158,9 @@ sinhFloat   (F# x) = F# (sinhFloat# x) coshFloat   (F# x) = F# (coshFloat# x) tanhFloat   (F# x) = F# (tanhFloat# x)+asinhFloat  (F# x) = F# (asinhFloat# x)+acoshFloat  (F# x) = F# (acoshFloat# x)+atanhFloat  (F# x) = F# (atanhFloat# x)  powerFloat :: Float -> Float -> Float powerFloat  (F# x) (F# y) = F# (powerFloat# x y)@@ -1196,6 +1193,7 @@ sinDouble, cosDouble, tanDouble  :: Double -> Double asinDouble, acosDouble, atanDouble  :: Double -> Double sinhDouble, coshDouble, tanhDouble  :: Double -> Double+asinhDouble, acoshDouble, atanhDouble  :: Double -> Double expDouble    (D# x) = D# (expDouble# x) logDouble    (D# x) = D# (logDouble# x) sqrtDouble   (D# x) = D# (sqrtDouble# x)@@ -1209,6 +1207,9 @@ sinhDouble   (D# x) = D# (sinhDouble# x) coshDouble   (D# x) = D# (coshDouble# x) tanhDouble   (D# x) = D# (tanhDouble# x)+asinhDouble  (D# x) = D# (asinhDouble# x)+acoshDouble  (D# x) = D# (acoshDouble# x)+atanhDouble  (D# x) = D# (atanhDouble# x)  powerDouble :: Double -> Double -> Double powerDouble  (D# x) (D# y) = D# (x **## y)

@@ -1,7 +1,7 @@ {-# LANGUAGE Trustworthy #-} {-# LANGUAGE CPP, MagicHash, UnboxedTuples, NoImplicitPrelude #-} {-# OPTIONS_GHC -O2 #-}-{-# OPTIONS_HADDOCK hide #-}+{-# OPTIONS_HADDOCK not-home #-}  ----------------------------------------------------------------------------- -- |

@@ -1,6 +1,6 @@ {-# LANGUAGE Trustworthy #-} {-# LANGUAGE CPP, MagicHash, UnboxedTuples, NoImplicitPrelude #-}-{-# OPTIONS_HADDOCK hide #-}+{-# OPTIONS_HADDOCK not-home #-}  ----------------------------------------------------------------------------- -- |

@@ -154,7 +154,8 @@   go cs (s:ss) = withCString enc s $ \c -> go (c:cs) ss   go cs [] = withArrayLen (reverse cs) f --- | Determines whether a character can be accurately encoded in a 'CString'.+-- | Determines whether a character can be accurately encoded in a+-- 'Foreign.C.String.CString'. -- -- Pretty much anyone who uses this function is in a state of sin because -- whether or not a character is encodable will, in general, depend on the@@ -200,7 +201,7 @@       from0 <- fmap (\fp -> bufferAdd sz_bytes (emptyBuffer fp sz_bytes ReadBuffer)) $ newForeignPtr_ (castPtr p)       to <- newCharBuffer chunk_size WriteBuffer -      let go iteration from = do+      let go !iteration from = do             (why, from', to') <- encode decoder from to             if isEmptyBuffer from'              then@@ -229,7 +230,7 @@   = bracket mk_encoder close $ \encoder -> withArrayLen s $ \sz p -> do       from <- fmap (\fp -> bufferAdd sz (emptyBuffer fp sz ReadBuffer)) $ newForeignPtr_ p -      let go iteration to_sz_bytes = do+      let go !iteration to_sz_bytes = do            putDebugMsg ("withEncodedCString: " ++ show iteration)            allocaBytes to_sz_bytes $ \to_p -> do             mb_res <- tryFillBufferAndCall encoder null_terminate from to_p to_sz_bytes act@@ -249,7 +250,7 @@   = bracket mk_encoder close $ \encoder -> withArrayLen s $ \sz p -> do       from <- fmap (\fp -> bufferAdd sz (emptyBuffer fp sz ReadBuffer)) $ newForeignPtr_ p -      let go iteration to_p to_sz_bytes = do+      let go !iteration to_p to_sz_bytes = do            putDebugMsg ("newEncodedCString: " ++ show iteration)            mb_res <- tryFillBufferAndCall encoder null_terminate from to_p to_sz_bytes return            case mb_res of@@ -271,7 +272,7 @@     to_fp <- newForeignPtr_ to_p     go (0 :: Int) (from0, emptyBuffer to_fp to_sz_bytes WriteBuffer)   where-    go iteration (from, to) = do+    go !iteration (from, to) = do       (why, from', to') <- encode encoder from to       putDebugMsg ("tryFillBufferAndCall: " ++ show iteration ++ " " ++ show why ++ " " ++ summaryBuffer from ++ " " ++ summaryBuffer from')       if isEmptyBuffer from'

@@ -4,7 +4,7 @@            , MagicHash            , UnboxedTuples   #-}-{-# OPTIONS_HADDOCK hide #-}+{-# OPTIONS_HADDOCK not-home #-} {-# LANGUAGE StandaloneDeriving #-}  -----------------------------------------------------------------------------@@ -153,8 +153,8 @@ -- implementation in GHC.  It uses pinned memory in the garbage -- collected heap, so the 'ForeignPtr' does not require a finalizer to -- free the memory.  Use of 'mallocForeignPtr' and associated--- functions is strongly recommended in preference to 'newForeignPtr'--- with a finalizer.+-- functions is strongly recommended in preference to+-- 'Foreign.ForeignPtr.newForeignPtr' with a finalizer. -- mallocForeignPtr = doMalloc undefined   where doMalloc :: Storable b => b -> IO (ForeignPtr b)@@ -289,9 +289,10 @@ -- -- NB. Be very careful with these finalizers.  One common trap is that -- if a finalizer references another finalized value, it does not--- prevent that value from being finalized.  In particular, 'Handle's--- are finalized objects, so a finalizer should not refer to a 'Handle'--- (including @stdout@, @stdin@ or @stderr@).+-- prevent that value from being finalized.  In particular, 'System.IO.Handle's+-- are finalized objects, so a finalizer should not refer to a+-- 'System.IO.Handle' (including 'System.IO.stdout', 'System.IO.stdin', or+-- 'System.IO.stderr'). -- addForeignPtrConcFinalizer (ForeignPtr _ c) finalizer =   addForeignPtrConcFinalizer_ c finalizer@@ -321,7 +322,7 @@  insertHaskellFinalizer :: IORef Finalizers -> IO () -> IO Bool insertHaskellFinalizer r f = do-  !wasEmpty <- atomicModifyIORef r $ \finalizers -> case finalizers of+  !wasEmpty <- atomicModifyIORefP r $ \finalizers -> case finalizers of       NoFinalizers -> (HaskellFinalizers [f], True)       HaskellFinalizers fs -> (HaskellFinalizers (f:fs), False)       _ -> noMixingError@@ -352,8 +353,8 @@       NoFinalizers -> IO $ \s ->           case mkWeakNoFinalizer# r# (unsafeCoerce# value) s of { (# s1, w #) ->              -- See Note [MallocPtr finalizers] (#10904)-          case atomicModifyMutVar# r# (update w) s1 of-              { (# s2, (weak, needKill ) #) ->+          case atomicModifyMutVar2# r# (update w) s1 of+              { (# s2, _, (_, (weak, needKill )) #) ->           if needKill             then case finalizeWeak# w s2 of { (# s3, _, _ #) ->               (# s3, weak #) }@@ -370,7 +371,8 @@  foreignPtrFinalizer :: IORef Finalizers -> IO () foreignPtrFinalizer r = do-  fs <- atomicModifyIORef r $ \fs -> (NoFinalizers, fs) -- atomic, see #7170+  fs <- atomicSwapIORef r NoFinalizers+             -- atomic, see #7170   case fs of     NoFinalizers -> return ()     CFinalizers w -> IO $ \s -> case finalizeWeak# w s of

@@ -1,5 +1,5 @@ {-# LANGUAGE NoImplicitPrelude #-}-{-# OPTIONS_HADDOCK hide #-}+{-# OPTIONS_HADDOCK not-home #-}  ----------------------------------------------------------------------------- -- |

@@ -0,0 +1,36 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  GHC.GHCi.Helpers+-- Copyright   :  (c) The GHC Developers+-- License     :  see libraries/base/LICENSE+--+-- Maintainer  :  cvs-ghc@haskell.org+-- Stability   :  internal+-- Portability :  non-portable (GHC Extensions)+--+-- Various helpers used by the GHCi shell.+--+-----------------------------------------------------------------------------++module GHC.GHCi.Helpers+  ( disableBuffering, flushAll+  , evalWrapper+  ) where++import System.IO+import System.Environment++disableBuffering :: IO ()+disableBuffering = do+  hSetBuffering stdin NoBuffering+  hSetBuffering stdout NoBuffering+  hSetBuffering stderr NoBuffering++flushAll :: IO ()+flushAll = do+  hFlush stdout+  hFlush stderr++evalWrapper :: String -> [String] -> IO a -> IO a+evalWrapper progName args m =+  withProgName progName (withArgs args m)

@@ -105,7 +105,7 @@ -- This is a lot of information! However, most of it is actually merely meta-information -- that makes names of datatypes and constructors and more available on the type level. ----- Here is a reduced representation for 'Tree' with nearly all meta-information removed,+-- Here is a reduced representation for @Tree@ with nearly all meta-information removed, -- for now keeping only the most essential aspects: -- -- @@@ -189,7 +189,7 @@ -- -- Here, 'R' is a type-level proxy that does not have any associated values. ----- There used to be another variant of 'K1' (namely 'Par0'), but it has since+-- There used to be another variant of 'K1' (namely @Par0@), but it has since -- been deprecated.  -- *** Meta information: 'M1'@@ -273,7 +273,7 @@ --       between the original value and its `Rep`-based representation and then invokes the --       generic instances. ----- As an example, let us look at a function 'encode' that produces a naive, but lossless+-- As an example, let us look at a function @encode@ that produces a naive, but lossless -- bit encoding of values of various datatypes. So we are aiming to define a function -- -- @@@ -367,18 +367,15 @@ -- @ -- -- The case for 'K1' is rather interesting. Here, we call the final function--- 'encode' that we yet have to define, recursively. We will use another type--- class 'Encode' for that function:+-- @encode@ that we yet have to define, recursively. We will use another type+-- class @Encode@ for that function: -- -- @ -- instance (Encode c) => Encode' ('K1' i c) where --   encode' ('K1' x) = encode x -- @ ----- Note how 'Par0' and 'Rec0' both being mapped to 'K1' allows us to define--- a uniform instance here.------ Similarly, we can define a uniform instance for 'M1', because we completely+-- Note how we can define a uniform instance for 'M1', because we completely -- disregard all meta-information: -- -- @@@ -386,13 +383,13 @@ --   encode' ('M1' x) = encode' x -- @ ----- Unlike in 'K1', the instance for 'M1' refers to 'encode'', not 'encode'.+-- Unlike in 'K1', the instance for 'M1' refers to @encode'@, not @encode@.  -- *** The wrapper and generic default -- -- | ----- We now define class 'Encode' for the actual 'encode' function:+-- We now define class @Encode@ for the actual @encode@ function: -- -- @ -- class Encode a where@@ -401,9 +398,9 @@ --   encode x = encode' ('from' x) -- @ ----- The incoming 'x' is converted using 'from', then we dispatch to the--- generic instances using 'encode''. We use this as a default definition--- for 'encode'. We need the 'default encode' signature because ordinary+-- The incoming @x@ is converted using 'from', then we dispatch to the+-- generic instances using @encode'@. We use this as a default definition+-- for @encode@. We need the @default encode@ signature because ordinary -- Haskell default methods must not introduce additional class constraints, -- but our generic default does. --@@ -421,10 +418,10 @@ -- possible to use @deriving Encode@ as well, but GHC does not yet support -- that syntax for this situation. ----- Having 'Encode' as a class has the advantage that we can define+-- Having @Encode@ as a class has the advantage that we can define -- non-generic special cases, which is particularly useful for abstract -- datatypes that have no structural representation. For example, given--- a suitable integer encoding function 'encodeInt', we can define+-- a suitable integer encoding function @encodeInt@, we can define -- -- @ -- instance Encode Int where@@ -457,7 +454,7 @@ --      any datatype where each constructor has at least one field. -- -- An 'M1' instance is always required (but it can just ignore the--- meta-information, as is the case for 'encode' above).+-- meta-information, as is the case for @encode@ above). #if 0 -- *** Using meta-information --@@ -470,14 +467,15 @@ -- | -- -- Datatype-generic functions as defined above work for a large class--- of datatypes, including parameterized datatypes. (We have used 'Tree'+-- of datatypes, including parameterized datatypes. (We have used @Tree@ -- as our example above, which is of kind @* -> *@.) However, the -- 'Generic' class ranges over types of kind @*@, and therefore, the--- resulting generic functions (such as 'encode') must be parameterized+-- resulting generic functions (such as @encode@) must be parameterized -- by a generic type argument of kind @*@. -- -- What if we want to define generic classes that range over type--- constructors (such as 'Functor', 'Traversable', or 'Foldable')?+-- constructors (such as 'Data.Functor.Functor',+-- 'Data.Traversable.Traversable', or 'Data.Foldable.Foldable')?  -- *** The 'Generic1' class --@@ -491,7 +489,7 @@ -- The 'Generic1' class is also derivable. -- -- The representation 'Rep1' is ever so slightly different from 'Rep'.--- Let us look at 'Tree' as an example again:+-- Let us look at @Tree@ as an example again: -- -- @ -- data Tree a = Leaf a | Node (Tree a) (Tree a)@@ -749,7 +747,7 @@  -- Needed for metadata import Data.Proxy   ( Proxy(..) )-import GHC.TypeLits ( Nat, Symbol, KnownSymbol, KnownNat, symbolVal, natVal )+import GHC.TypeLits ( KnownSymbol, KnownNat, symbolVal, natVal )  -------------------------------------------------------------------------------- -- Representation types@@ -1335,8 +1333,8 @@ -- A 'Generic' instance must satisfy the following laws: -- -- @--- 'from' . 'to' ≡ 'id'--- 'to' . 'from' ≡ 'id'+-- 'from' . 'to' ≡ 'Prelude.id'+-- 'to' . 'from' ≡ 'Prelude.id' -- @ class Generic a where   -- | Generic representation type@@ -1354,8 +1352,8 @@ -- A 'Generic1' instance must satisfy the following laws: -- -- @--- 'from1' . 'to1' ≡ 'id'--- 'to1' . 'from1' ≡ 'id'+-- 'from1' . 'to1' ≡ 'Prelude.id'+-- 'to1' . 'from1' ≡ 'Prelude.id' -- @ class Generic1 (f :: k -> Type) where   -- | Generic representation type@@ -1484,8 +1482,6 @@ data family Sing (a :: k)  -- | A 'SingI' constraint is essentially an implicitly-passed singleton.--- If you need to satisfy this constraint with an explicit singleton, please--- see 'withSingI'. class SingI (a :: k) where   -- | Produce the singleton explicitly. You will likely need the @ScopedTypeVariables@   -- extension to use this method the way you want.

@@ -7,7 +7,7 @@            , UnboxedTuples   #-} {-# OPTIONS_GHC -funbox-strict-fields #-}-{-# OPTIONS_HADDOCK hide #-}+{-# OPTIONS_HADDOCK not-home #-}  ----------------------------------------------------------------------------- -- |@@ -53,8 +53,8 @@ -- The IO Monad  {--The IO Monad is just an instance of the ST monad, where the state is-the real world.  We use the exception mechanism (in GHC.Exception) to+The IO Monad is just an instance of the ST monad, where the state thread+is the real world.  We use the exception mechanism (in GHC.Exception) to implement IO exceptions.  NOTE: The IO representation is deeply wired in to various parts of the@@ -84,7 +84,7 @@ -- --------------------------------------------------------------------------- -- Coercions between IO and ST --- | Embed a strict state transformer in an 'IO'+-- | Embed a strict state thread in an 'IO' -- action.  The 'RealWorld' parameter indicates that the internal state -- used by the 'ST' computation is a special one supplied by the 'IO' -- monad, and thus distinct from those used by invocations of 'runST'.@@ -92,20 +92,20 @@ stToIO (ST m) = IO m  -- | Convert an 'IO' action into an 'ST' action. The type of the result--- is constrained to use a 'RealWorld' state, and therefore the result cannot--- be passed to 'runST'.+-- is constrained to use a 'RealWorld' state thread, and therefore the+-- result cannot be passed to 'runST'. ioToST        :: IO a -> ST RealWorld a ioToST (IO m) = (ST m)  -- | Convert an 'IO' action to an 'ST' action. -- This relies on 'IO' and 'ST' having the same representation modulo the--- constraint on the type of the state.+-- constraint on the state thread type parameter. unsafeIOToST        :: IO a -> ST s a unsafeIOToST (IO io) = ST $ \ s -> (unsafeCoerce# io) s  -- | Convert an 'ST' action to an 'IO' action. -- This relies on 'IO' and 'ST' having the same representation modulo the--- constraint on the type of the state.+-- constraint on the state thread type parameter. -- -- For an example demonstrating why this is unsafe, see -- https://mail.haskell.org/pipermail/haskell-cafe/2009-April/060719.html

@@ -4,7 +4,7 @@ module GHC.IO where  import GHC.Types-import GHC.Integer () -- see Note [Depend upon GHC.Integer] in libraries/base/GHC/Base.hs+import GHC.Integer () -- See Note [Depend on GHC.Integer] in GHC.Base  failIO :: [Char] -> IO a mplusIO :: IO a -> IO a -> IO a

@@ -32,8 +32,8 @@ -- | The purpose of 'BufferedIO' is to provide a common interface for I/O -- devices that can read and write data through a buffer.  Devices that -- implement 'BufferedIO' include ordinary files, memory-mapped files,--- and bytestrings.  The underlying device implementing a 'Handle' must--- provide 'BufferedIO'.+-- and bytestrings.  The underlying device implementing a 'System.IO.Handle'+-- must provide 'BufferedIO'. -- class BufferedIO dev where   -- | allocate a new buffer.  The size of the buffer is at the

@@ -56,7 +56,7 @@   writeNonBlocking    :: a -> Ptr Word8 -> Int -> IO Int  --- | I/O operations required for implementing a 'Handle'.+-- | I/O operations required for implementing a 'System.IO.Handle'. class IODevice a where   -- | @ready dev write msecs@ returns 'True' if the device has data   -- to read (if @write@ is 'False') or space to write new data (if@@ -139,7 +139,7 @@   = Directory -- ^ The standard libraries do not have direct support               -- for this device type, but a user implementation is               -- expected to provide a list of file names in-              -- the directory, in any order, separated by @'\0'@+              -- the directory, in any order, separated by @\'\\0\'@               -- characters, excluding the @"."@ and @".."@ names. See               -- also 'System.Directory.getDirectoryContents'.  Seek               -- operations are not supported on directories (other@@ -160,7 +160,7 @@ -- ----------------------------------------------------------------------------- -- SeekMode type --- | A mode that determines the effect of 'hSeek' @hdl mode i@.+-- | A mode that determines the effect of 'System.IO.hSeek' @hdl mode i@. data SeekMode   = AbsoluteSeek        -- ^ the position of @hdl@ is set to @i@.   | RelativeSeek        -- ^ the position of @hdl@ is set to offset @i@

@@ -57,7 +57,8 @@ -- | The Latin1 (ISO8859-1) encoding.  This encoding maps bytes -- directly to the first 256 Unicode code points, and is thus not a -- complete Unicode encoding.  An attempt to write a character greater than--- '\255' to a 'Handle' using the 'latin1' encoding will result in an error.+-- @\'\\255\'@ to a 'System.IO.Handle' using the 'latin1' encoding will result in an+-- error. latin1  :: TextEncoding latin1 = Latin1.latin1_checked @@ -122,7 +123,7 @@  -- | The Unicode encoding of the current locale, but where undecodable -- bytes are replaced with their closest visual match. Used for--- the 'CString' marshalling functions in "Foreign.C.String"+-- the 'Foreign.C.String.CString' marshalling functions in "Foreign.C.String" -- -- @since 4.5.0.0 getForeignEncoding :: IO TextEncoding@@ -187,7 +188,7 @@  -- | Look up the named Unicode encoding.  May fail with -----  * 'isDoesNotExistError' if the encoding is unknown+--  * 'System.IO.Error.isDoesNotExistError' if the encoding is unknown -- -- The set of known encodings is system-dependent, but includes at least: --

@@ -34,8 +34,8 @@  --import System.Posix.Internals --- | The 'CodingFailureMode' is used to construct 'TextEncoding's, and--- specifies how they handle illegal sequences.+-- | The 'CodingFailureMode' is used to construct 'System.IO.TextEncoding's,+-- and specifies how they handle illegal sequences. data CodingFailureMode   = ErrorOnCodingFailure        -- ^ Throw an error when an illegal sequence is encountered

@@ -3,7 +3,7 @@            , NoImplicitPrelude            , NondecreasingIndentation   #-}-{-# OPTIONS_HADDOCK hide #-}+{-# OPTIONS_HADDOCK not-home #-}  ----------------------------------------------------------------------------- -- |

@@ -103,11 +103,11 @@ -- between sequences of bytes and sequences of Unicode characters. -- -- For example, UTF-8 is an encoding of Unicode characters into a sequence--- of bytes.  The 'TextEncoding' for UTF-8 is 'utf8'.+-- of bytes.  The 'TextEncoding' for UTF-8 is 'System.IO.utf8'. data TextEncoding   = forall dstate estate . TextEncoding  {         textEncodingName :: String,-                   -- ^ a string that can be passed to 'mkTextEncoding' to+                   -- ^ a string that can be passed to 'System.IO.mkTextEncoding' to                    -- create an equivalent 'TextEncoding'.         mkTextDecoder :: IO (TextDecoder dstate),                    -- ^ Creates a means of decoding bytes into characters: the result must not

@@ -2,7 +2,7 @@ {-# LANGUAGE DeriveGeneric, NoImplicitPrelude, MagicHash,              ExistentialQuantification, ImplicitParams #-} {-# OPTIONS_GHC -funbox-strict-fields #-}-{-# OPTIONS_HADDOCK hide #-}+{-# OPTIONS_HADDOCK not-home #-}  ----------------------------------------------------------------------------- -- |@@ -273,7 +273,8 @@         . (if not (null s) then showString ": " . showString s                            else id) --- | The exception thrown when an infinite cycle is detected in 'fixIO'.+-- | The exception thrown when an infinite cycle is detected in+-- 'System.IO.fixIO'. -- -- @since 4.11.0.0 data FixIOException = FixIOException

@@ -5,7 +5,7 @@   #-} {-# OPTIONS_GHC -Wno-identities #-} -- Whether there are identities depends on the platform-{-# OPTIONS_HADDOCK hide #-}+{-# OPTIONS_HADDOCK not-home #-}  ----------------------------------------------------------------------------- -- |@@ -67,6 +67,17 @@ c_DEBUG_DUMP :: Bool c_DEBUG_DUMP = False +-- Darwin limits the length of writes to 2GB. See+-- #17414.+clampWriteSize, clampReadSize :: Int -> Int+#if defined(darwin_HOST_OS)+clampWriteSize = min 0x7fffffff+clampReadSize  = min 0x7fffffff+#else+clampWriteSize = id+clampReadSize  = id+#endif+ -- ----------------------------------------------------------------------------- -- The file-descriptor IO device @@ -430,13 +441,14 @@  fdRead :: FD -> Ptr Word8 -> Int -> IO Int fdRead fd ptr bytes-  = do { r <- readRawBufferPtr "GHC.IO.FD.fdRead" fd ptr 0 (fromIntegral bytes)+  = do { r <- readRawBufferPtr "GHC.IO.FD.fdRead" fd ptr 0+                (fromIntegral $ clampReadSize bytes)        ; return (fromIntegral r) }  fdReadNonBlocking :: FD -> Ptr Word8 -> Int -> IO (Maybe Int) fdReadNonBlocking fd ptr bytes = do   r <- readRawBufferPtrNoBlock "GHC.IO.FD.fdReadNonBlocking" fd ptr-           0 (fromIntegral bytes)+           0 (fromIntegral $ clampReadSize bytes)   case fromIntegral r of     (-1) -> return (Nothing)     n    -> return (Just n)@@ -444,7 +456,8 @@  fdWrite :: FD -> Ptr Word8 -> Int -> IO () fdWrite fd ptr bytes = do-  res <- writeRawBufferPtr "GHC.IO.FD.fdWrite" fd ptr 0 (fromIntegral bytes)+  res <- writeRawBufferPtr "GHC.IO.FD.fdWrite" fd ptr 0+          (fromIntegral $ clampWriteSize bytes)   let res' = fromIntegral res   if res' < bytes      then fdWrite fd (ptr `plusPtr` res') (bytes - res')@@ -454,7 +467,7 @@ fdWriteNonBlocking :: FD -> Ptr Word8 -> Int -> IO Int fdWriteNonBlocking fd ptr bytes = do   res <- writeRawBufferPtrNoBlock "GHC.IO.FD.fdWriteNonBlocking" fd ptr 0-            (fromIntegral bytes)+            (fromIntegral $ clampWriteSize bytes)   return (fromIntegral res)  -- -----------------------------------------------------------------------------

@@ -183,7 +183,7 @@ -- -- This operation may fail with: -----  * 'isEOFError' if the end of file has been reached.+--  * 'System.IO.Error.isEOFError' if the end of file has been reached.  hLookAhead :: Handle -> IO Char hLookAhead handle =@@ -208,9 +208,9 @@ -- -- This operation may fail with: -----  * 'isPermissionError' if the handle has already been used for reading---    or writing and the implementation does not allow the buffering mode---    to be changed.+--  * 'System.IO.Error.isPermissionError' if the handle has already been used+--    for reading or writing and the implementation does not allow the+--    buffering mode to be changed.  hSetBuffering :: Handle -> BufferMode -> IO () hSetBuffering handle mode =@@ -251,8 +251,8 @@  -- | The action 'hSetEncoding' @hdl@ @encoding@ changes the text encoding -- for the handle @hdl@ to @encoding@.  The default encoding when a 'Handle' is--- created is 'localeEncoding', namely the default encoding for the current--- locale.+-- created is 'System.IO.localeEncoding', namely the default encoding for the+-- current locale. -- -- To create a 'Handle' with no encoding at all, use 'openBinaryFile'.  To -- stop further encoding or decoding on an existing 'Handle', use@@ -295,11 +295,11 @@ -- -- This operation may fail with: -----  * 'isFullError' if the device is full;+--  * 'System.IO.Error.isFullError' if the device is full; -----  * 'isPermissionError' if a system resource limit would be exceeded.---    It is unspecified whether the characters in the buffer are discarded---    or retained under these circumstances.+--  * 'System.IO.Error.isPermissionError' if a system resource limit would be+--    exceeded. It is unspecified whether the characters in the buffer are+--    discarded or retained under these circumstances.  hFlush :: Handle -> IO () hFlush handle = wantWritableHandle "hFlush" handle flushWriteBuffer@@ -312,14 +312,14 @@ -- -- This operation may fail with: -----  * 'isFullError' if the device is full;+--  * 'System.IO.Error.isFullError' if the device is full; -----  * 'isPermissionError' if a system resource limit would be exceeded.---    It is unspecified whether the characters in the buffer are discarded---    or retained under these circumstances;+--  * 'System.IO.Error.isPermissionError' if a system resource limit would be+--    exceeded. It is unspecified whether the characters in the buffer are+--    discarded or retained under these circumstances; -----  * 'isIllegalOperation' if @hdl@ has buffered read data, and is not---    seekable.+--  * 'System.IO.Error.isIllegalOperation' if @hdl@ has buffered read data, and+--    is not seekable.  hFlushAll :: Handle -> IO () hFlushAll handle = withHandle_ "hFlushAll" handle flushBuffer@@ -358,7 +358,8 @@ -- -- This operation may fail with: -----  * 'isPermissionError' if a system resource limit would be exceeded.+--  * 'System.IO.Error.isPermissionError' if a system resource limit would be+--    exceeded.  hSetPosn :: HandlePosn -> IO () hSetPosn (HandlePosn h i) = hSeek h AbsoluteSeek i@@ -391,10 +392,11 @@ -- -- This operation may fail with: -----  * 'isIllegalOperationError' if the Handle is not seekable, or does---     not support the requested seek mode.+--  * 'System.IO.Error.isIllegalOperationError' if the Handle is not seekable,+--    or does not support the requested seek mode. -----  * 'isPermissionError' if a system resource limit would be exceeded.+--  * 'System.IO.Error.isPermissionError' if a system resource limit would be+--    exceeded.  hSeek :: Handle -> SeekMode -> Integer -> IO () hSeek handle mode offset =@@ -425,7 +427,7 @@ -- -- This operation may fail with: -----  * 'isIllegalOperationError' if the Handle is not seekable.+--  * 'System.IO.Error.isIllegalOperationError' if the Handle is not seekable. -- hTell :: Handle -> IO Integer hTell handle =