base-orphans 0.8 → 0.9.4
raw patch · 10 files changed
Files
- CHANGES.markdown +100/−0
- README.markdown +43/−32
- base-orphans.cabal +23/−10
- src/Data/Orphans.hs +1520/−1707
- src/Data/Orphans/Prelude.hs +62/−59
- test/Control/Applicative/OrphansSpec.hs +3/−0
- test/Data/Bits/OrphansSpec.hs +0/−7
- test/Data/Version/OrphansSpec.hs +9/−5
- test/GHC/Fingerprint/OrphansSpec.hs +1/−8
- test/System/Posix/Types/OrphansSpec.hs +20/−15
CHANGES.markdown view
@@ -1,3 +1,103 @@+## Changes in 0.9.4 [2026.01.10]+ - Allow building with MicroHs.++## Changes in 0.9.3 [2024.12.06]+ - Backport new instances from GHC 9.12/`base-4.21`:+ * `MonadFix` instance for `(,) a`+ * `Eq1`, `Ord1`, `Read1`, and `Show1` instances for basic `GHC.Generics`+ representation types+ * `Show` instance for `UAddr`+ - Drop support for pre-8.0 versions of GHC.++## Changes in 0.9.2 [2024.04.30]+ - Backport new instances from GHC 9.10/`base-4.20`:+ * `Fractional`, `RealFrac`, `Floating`, and `RealFloat` instances for `Compose`++## Changes in 0.9.1 [2023.10.11]+ - Backport new instances from GHC 9.8/`base-4.19`:+ * `Eq` and `Ord` instances for `SChar`, `SNat`, and `SSymbol`+ * `Enum`, `Bounded`, `Num`, `Real`, and `Integral` instances for `Compose`++## Changes in 0.9.0 [2023.03.05]+ - Adapt to recent changes to `Down` instances:+ * The `Bounded` instance for `Down` was changed in `base-4.15.0.0` to swap+ the values of `minBound` and `maxBound` for the underlying type. This+ change has now been propagated to `base-orphans`.+ * The `Enum` instance for `Down` was removed in `base-4.15.0.0`, but a+ different version of the instance was added back in `base-4.18.0.0`, where+ `succ` and `pred` are swapped. We have changed the backported version of+ this instance in `base-orphans` to match the behavior of the instance+ added in `base-4.18.0.0`.+ * The `Integral` instance for `Down` was removed from `base` entirely in+ `base-4.15.0.0`. We have finally removed it from `base-orphans` in this+ release, as it actively makes it more difficult to define the+ aforementioned `Enum` instance.++## Changes in 0.8.8.1 [2023.03.05]+ - Fix GHC 9.4 build error that was accidentally introduced in+ `base-orphans-0.8.8`.++## Changes in 0.8.8 [2023.03.05]+ - Backport new instances from GHC 9.6.1/`base-4.18.0.0`:+ * `Functor` instances for the `(,,,,) a b c d`, `(,,,,,) a b c d e`, and+ `(,,,,,) a b c d e f` tuple types.+ * `Eq` and `Ord` instances for `Generically1`++## Changes in 0.8.7 [2022.08.11]+ - Backport new instances from GHC 9.2.2/`base-4.16.1.0`:+ * `Ix` instances for various integral types in `Foreign.C.Types`,+ `Foreign.Ptr`, and `System.Posix.Types`. For a complete list of such types,+ see https://gitlab.haskell.org/ghc/ghc/-/merge_requests/7385.+ - Backport a bugfix for the `Ord1 Down` instance from GHC 9.4/`base-4.17` such+ that it now uses reverse sort order.++## Changes in 0.8.6 [2021.10.29]+ - Backport `Eq`, `Ord`, `Bounded`, `Enum`, and `Ix` instances for `Solo`,+ introduced in GHC 9.2/`base-4.16`+ - Remove the backported `Eq1` and `Ord1` instances for `Fixed` that were+ introduced in `base-orphans-0.8.5`. While these briefly appeared in a+ release candidate version of GHC 9.2.1, they were ultimately removed from+ the final 9.2.1 release. This release of `base-orphans` synchronizes with+ that change.++## Changes in 0.8.5 [2021.08.29]+ - Backport new instances from GHC 9.2/`base-4.16`+ * `Eq1`, `Read1`, and `Show1` instances for `Complex`+ * `Eq1` and `Ord1` instances for `Fixed`+ * `Eq{1,2}`, `Ord{1,2}`, `Show{1,2}`, and `Read{1,2}` instances for `(,,)`+ and `(,,,)`+ * `Semigroup` and `Monoid` instances for `Data.Functor.Product` and+ `Data.Functor.Compose`++## Changes in 0.8.4 [2020.12.09]+ - Backport the `Ord` instances for `TyCon` and `TypeRep` to be available on+ GHC 7.0.++## Changes in 0.8.3 [2020.09.30]+ - Backport new instances from GHC 9.0/`base-4.15`+ * `MonadFix` and `MonadZip` instances for `Complex`+ * `Ix` instances for tuples of size 6 through 15++## Changes in 0.8.2 [2020.01.27]+ - Backport new instances from GHC 8.10/`base-4.14`+ * `Bits`, `Bounded`, `Enum`, `FiniteBits`, `Floating`, `Fractional`,+ `Integral`, `Ix`, `Real`, `RealFrac`, `RealFloat` and `Storable` instances+ for `Data.Ord.Down`+ * `Functor`, `Applicative`, `Monad`, `Alternative`, and `MonadPlus` instances+ for `Kleisli`+ * `Functor`, `Applicative`, and `Monad` instances for+ `(,,) a b` and `(,,,) a b c`+ * `Data` instances for `WrappedArrow` and `WrappedMonad`+ * `Data` and `IsList` instances for `ZipList`+ * `TestEquality` instance for `Compose`+ - Backport the `Typeable (() :: Constraint)` instance to be available on+ GHC 7.8.++## Changes in 0.8.1 [2019.03.25]+ - Ensure that the test suite passes non-negative numbers to `Bits` methods+ that require them, such as `bit`, `setBit`, `clearBit`, `complementBit`,+ and `testBit`.+ ## Changes in 0.8 [2018.07.02] - Backported new instance from GHC 8.6/`base-4.12` * Data types in `GHC.Generics`:
README.markdown view
@@ -3,7 +3,7 @@ [](http://packdeps.haskellers.com/reverse/base-orphans) [][Haskell.org] [][tl;dr Legal: MIT]-[](https://travis-ci.org/haskell-compat/base-orphans)+[](https://github.com/haskell-compat/base-orphans/actions?query=workflow%3AHaskell-CI) [Hackage: base-orphans]: http://hackage.haskell.org/package/base-orphans@@ -35,9 +35,11 @@ * `Alternative`, `Applicative`, `Bounded`, `Data`, `Enum`, `Foldable`, `Functor`, `Ix`, `Monad`, `MonadFix`, `MonadPlus`, `MonadZip`, and `Traversable` instances for data types in `GHC.Generics` * `Alternative`, `Eq`, `Ord`, `Read`, `Show`, `Foldable`, and `Traversable` instances for `ZipList` * `Applicative` instance for `K1` from `GHC.Generics`- * `Applicative`, `Data`, `Eq1`, `Foldable`, `Functor`, `Ord1`, `Monad`,- `MonadFix`, `MonadZip`, `Monoid`, `Num`, `Read`, `Read1`, `Semigroup`,- `Show`, `Show1`, and `Traversable` instances for `Down`+ * `Applicative`, `Bits`, `Bounded`, `Data`, `Enum`, `Eq1`, `FiniteBits`,+ `Floating`, `Foldable`, `Fractional`, `Functor`, `Ix`, `Ord1`,+ `Monad`, `MonadFix`, `MonadZip`, `Monoid`, `Num`, `Read`, `Read1`, `Real`,+ `RealFloat`, `RealFrac`, `Semigroup`, `Show`, `Show1`, `Storable`, and+ `Traversable` instances for `Down` * `Applicative` and `Alternative` instances for `ReadP` and `ReadPrec` * `Applicative` instance for strict and lazy `ST` * `Applicative`, `Foldable`, `Functor`, `Monad`, and `Traversable` instances for `Complex`,@@ -45,20 +47,38 @@ * `Bits` instance for `Bool` * `Bits`, `Bounded`, and `Integral` instances for `CDev` * `Bits`, `Bounded`, `Enum`, `FiniteBits`, `Floating`, `Fractional`, `Integral`, `IsString`, `Ix`, `Num`, `Real`, `RealFloat`, `RealFrac`, and `Storable` instances for `Const` and `Identity`- * `Data` instances for `All`, `Any`, and `Const`, `IntPtr`, and `WordPtr`+ * `Data` instances for `All`, `Any`, and `Const`, `IntPtr`, `WordPtr`,+ `WrappedArrow` and `WrappedMonad` * `Data`, `MonadFix` and `MonadZip` instances for `Alt`, `Dual`, `First`, `Last`, `Product`, and `Sum`- * `Data` and `IsList` instances for `Version`+ * `Data` and `IsList` instances for `Version` and `ZipList`+ * `Eq{1,2}`, `Ord{1,2}`, `Show{1,2}`, and `Read{1,2}` instances for `(,,)` and `(,,,)` * `Eq` and `Ord` instances for `Control.Exception.ErrorCall` * `Eq`, `Ord`, `Read`, and `Show` instances for data types in `GHC.Generics`+ * `Eq`, `Ord`, `Bounded`, `Enum`, and `Ix` instances for `Solo`+ * `Eq` and `Ord` instances for `Generically1`+ * `Eq` and `Ord` instances for `SChar`, `SNat`, and `SSymbol`+ * `Eq1`, `Read1`, and `Show1` instances for `Complex` * `Eq1`, `Ord1`, `Read1`, and `Show1` instances for `NonEmpty`+ * `Eq1`, `Ord1`, `Read1`, and `Show1` instances for basic `GHC.Generics` representation types+ * `Enum`, `Bounded`, `Num`, `Real`, `Integral`, `Fractional`, `RealFrac`, `Floating`, and `RealFloat` instances for `Compose` * `Foldable` instance for `Either`, `(,)` and `Const` * `Foldable` and `Traversable` instances for `Alt` from `Data.Monoid`+ * `Functor`, `Applicative`, and `Monad` instances for+ `(,,) a b` and `(,,,) a b c`+ * `Functor` instances for `(,,,,) a b c d`, `(,,,,,) a b c d e`, and+ `(,,,,,) a b c d e f` * `Functor` instance for `Handler`, `ArgOrder`, `OptDescr`, and `ArgDescr` * `Functor`, `Applicative`, `Alternative`, and `MonadPlus` instances for `ArrowMonad`+ * `Functor`, `Applicative`, `Monad`, `Alternative`, and `MonadPlus` instances+ for `Kleisli`+ * `Ix` instances for tuples of size 6 through 15+ * `Ix` instances for integral types in `Foreign.C.Types`, `Foreign.Ptr`, and `System.Posix.Types` * `Monad` instance for `(,)` * `Monad` instance for `WrappedMonad` * `MonadFail`, `Monoid`, and `Semigroup` instances for strict `ST`+ * `MonadFix` instance for `(,) a`+ * `MonadFix` and `MonadZip` instances for `Complex` * `MonadZip` instance for `Maybe` * `Monoid`, `Eq`, `Ord`, `Read`, and `Show` instances for `Const` * `Monoid` instances for `Identity` and `IO`@@ -67,9 +87,13 @@ * `Semigroup` instances for `IO`, `Event` and `Lifetime` * `Semigroup` instances for `V1`, `U1`, `Par1`, `Rec1`, `K1`, `M1`, `(:*:)`, and `(:.:)` from `GHC.Generics`. `Monoid` instances for the same types (except `V1`).+ * `Semigroup` and `Monoid` instances for `Data.Functor.Product` and `Data.Functor.Compose` * `Show` instance for `Fingerprint`+ * `Show` instance for `UAddr` * `Storable` instance for `()`, `Complex`, and `Ratio`+ * `TestEquality` instance for `Compose` * `Traversable` instance for `Either`, `(,)` and `Const`+ * `Ord` instance for `TyCon` and `TypeRep`. * `Typeable` instance for most data types, typeclasses, and promoted data constructors (when possible) ## What is not covered@@ -85,32 +109,19 @@ ## Supported versions of GHC/`base` - * `ghc-8.6.1` / `base-4.12.0.0`- * `ghc-8.4.3` / `base-4.11.1.0`- * `ghc-8.4.2` / `base-4.11.1.0`- * `ghc-8.4.1` / `base-4.11.0.0`- * `ghc-8.2.2` / `base-4.10.1.0`- * `ghc-8.2.1` / `base-4.10.0.0`- * `ghc-8.0.2` / `base-4.9.1.0`- * `ghc-8.0.1` / `base-4.9.0.0`- * `ghc-7.10.3` / `base-4.8.2.0`- * `ghc-7.10.2` / `base-4.8.1.0`- * `ghc-7.10.1` / `base-4.8.0.0`- * `ghc-7.8.4` / `base-4.7.0.2`- * `ghc-7.8.3` / `base-4.7.0.1`- * `ghc-7.8.2` / `base-4.7.0.0`- * `ghc-7.8.1` / `base-4.7.0.0`- * `ghc-7.6.3` / `base-4.6.0.1`- * `ghc-7.6.2` / `base-4.6.0.1`- * `ghc-7.6.1` / `base-4.6.0.0`- * `ghc-7.4.2` / `base-4.5.1.0`- * `ghc-7.4.1` / `base-4.5.0.0`- * `ghc-7.2.2` / `base-4.4.1.0`- * `ghc-7.2.1` / `base-4.4.0.0`- * `ghc-7.0.4` / `base-4.3.1.0`- * `ghc-7.0.3` / `base-4.3.1.0`- * `ghc-7.0.2` / `base-4.3.1.0`- * `ghc-7.0.1` / `base-4.3.0.0`+ * `ghc-9.12.*` / `base-4.21.*`+ * `ghc-9.10.*` / `base-4.20.*`+ * `ghc-9.8.*` / `base-4.19.*`+ * `ghc-9.6.*` / `base-4.18.*`+ * `ghc-9.4.*` / `base-4.17.*`+ * `ghc-9.2.*` / `base-4.16.*`+ * `ghc-9.0.*` / `base-4.15.*`+ * `ghc-8.10.*` / `base-4.14.*`+ * `ghc-8.8.*` / `base-4.13.*`+ * `ghc-8.6.*` / `base-4.12.*`+ * `ghc-8.4.*` / `base-4.11.*`+ * `ghc-8.2.*` / `base-4.10.*`+ * `ghc-8.0.*` / `base-4.9.*` We also make an attempt to keep `base-orphans` building with GHC HEAD, but due to its volatility, it may not work at any given point in time. If it doesn't,
base-orphans.cabal view
@@ -1,14 +1,25 @@--- This file has been generated from package.yaml by hpack version 0.28.2.+cabal-version: 1.12++-- This file has been generated from package.yaml by hpack version 0.39.1. -- -- see: https://github.com/sol/hpack ----- hash: f7b54386bbe16442a11779267f4a728967659e625e63acc7a4a4a9d07cfd302f+-- hash: 459819c97f970a9f10f930c19a33ad7c14c34c1056852f4b0c57fa8e8487e8ca name: base-orphans-version: 0.8+version: 0.9.4 synopsis: Backwards-compatible orphan instances for base-description: @base-orphans@ defines orphan instances that mimic instances available in later versions of @base@ to a wider (older) range of compilers. @base-orphans@ does not export anything except the orphan instances themselves and complements @<http://hackage.haskell.org/package/base-compat base-compat>@.- See the README for what instances are covered: <https://github.com/haskell-compat/base-orphans#readme>. See also the <https://github.com/haskell-compat/base-orphans#what-is-not-covered what is not covered> section.+description: @base-orphans@ defines orphan instances that mimic instances available in+ later versions of @base@ to a wider (older) range of compilers.+ @base-orphans@ does not export anything except the orphan instances+ themselves and complements @<http://hackage.haskell.org/package/base-compat+ base-compat>@.+ .+ See the README for what instances are covered:+ <https://github.com/haskell-compat/base-orphans#readme>.+ See also the+ <https://github.com/haskell-compat/base-orphans#what-is-not-covered what is not covered>+ section. category: Compatibility homepage: https://github.com/haskell-compat/base-orphans#readme bug-reports: https://github.com/haskell-compat/base-orphans/issues@@ -24,8 +35,8 @@ license: MIT license-file: LICENSE build-type: Simple-cabal-version: >= 1.10-tested-with: GHC == 7.0.1, GHC == 7.0.2, GHC == 7.0.3, GHC == 7.0.4 , GHC == 7.2.1, GHC == 7.2.2 , GHC == 7.4.1, GHC == 7.4.2 , GHC == 7.6.1, GHC == 7.6.2, GHC == 7.6.3 , GHC == 7.8.1, GHC == 7.8.2, GHC == 7.8.3, GHC == 7.8.4 , GHC == 7.10.1, GHC == 7.10.2, GHC == 7.10.3 , GHC == 8.0.1, GHC == 8.0.2 , GHC == 8.2.1, GHC == 8.2.2 , GHC == 8.4.1, GHC == 8.4.2, GHC == 8.4.3 , GHC == 8.6.1+tested-with:+ GHC == 8.0.2 , GHC == 8.2.2 , GHC == 8.4.4 , GHC == 8.6.5 , GHC == 8.8.4 , GHC == 8.10.7 , GHC == 9.0.2 , GHC == 9.2.8 , GHC == 9.4.8 , GHC == 9.6.7 , GHC == 9.8.4 , GHC == 9.10.3 , GHC == 9.12.2 , GHC == 9.14.1 extra-source-files: CHANGES.markdown README.markdown@@ -39,13 +50,15 @@ src ghc-options: -Wall build-depends:- base >=4.3 && <5- , ghc-prim+ base >=4.9 && <5 exposed-modules: Data.Orphans other-modules: Data.Orphans.Prelude default-language: Haskell2010+ if impl(ghc >= 9.0) && !impl(ghc >= 9.2)+ build-depends:+ ghc-prim test-suite spec type: exitcode-stdio-1.0@@ -55,7 +68,7 @@ ghc-options: -Wall build-depends: QuickCheck- , base >=4.3 && <5+ , base >=4.9 && <5 , base-orphans , hspec ==2.* build-tool-depends: hspec-discover:hspec-discover == 2.*
src/Data/Orphans.hs view
@@ -1,1710 +1,1523 @@ {-# LANGUAGE BangPatterns #-} {-# LANGUAGE CPP #-}-{-# LANGUAGE DeriveDataTypeable #-}-{-# LANGUAGE DeriveFoldable #-}-{-# LANGUAGE DeriveFunctor #-}-{-# LANGUAGE DeriveTraversable #-}-{-# LANGUAGE FlexibleContexts #-}-{-# LANGUAGE GeneralizedNewtypeDeriving #-}-{-# LANGUAGE KindSignatures #-}-{-# LANGUAGE ScopedTypeVariables #-}-{-# LANGUAGE StandaloneDeriving #-}-{-# LANGUAGE TypeFamilies #-}-{-# LANGUAGE TypeOperators #-}--#if __GLASGOW_HASKELL__ >= 702-{-# LANGUAGE Trustworthy #-}-#endif--#if __GLASGOW_HASKELL__ >= 706-{-# LANGUAGE PolyKinds #-}-#endif--#if __GLASGOW_HASKELL__ >= 708 && __GLASGOW_HASKELL__ < 710-{-# LANGUAGE DataKinds #-}-{-# LANGUAGE NullaryTypeClasses #-}-#endif--#if __GLASGOW_HASKELL__ >= 800-{-# LANGUAGE TypeInType #-}-#endif--{-# OPTIONS_GHC -fno-warn-deprecations #-}-{-# OPTIONS_GHC -fno-warn-orphans #-}-{-|-Exports orphan instances that mimic instances available in later versions of @base@.-To use them, simply @import Data.Orphans ()@.--}-module Data.Orphans () where--#if __GLASGOW_HASKELL__ >= 701 && !(MIN_VERSION_base(4,12,0))-import GHC.Generics as Generics-#endif--#if !(MIN_VERSION_base(4,6,0))-import Control.Monad.Instances ()-#endif--#if !(MIN_VERSION_base(4,9,0))-import qualified Data.Monoid as Monoid-import Text.ParserCombinators.ReadPrec as ReadPrec-import Text.Read as Read-#endif--#if MIN_VERSION_base(4,9,0) && !(MIN_VERSION_base(4,11,0))-import qualified Control.Monad.Fail as Fail (MonadFail(..))-#endif--#if !(MIN_VERSION_base(4,10,0))-import Data.Data as Data-#endif--#if !(MIN_VERSION_base(4,11,0))-import Control.Monad.ST as Strict-#endif--#if !(MIN_VERSION_base(4,12,0))-import qualified Data.Foldable as F (Foldable(..))-import qualified Data.Traversable as T (Traversable(..))-#endif--#if __GLASGOW_HASKELL__ < 710-import Control.Exception as Exception-import Control.Monad.ST.Lazy as Lazy-import GHC.Exts as Exts-import GHC.IO.Exception as Exception-import Text.ParserCombinators.ReadP as ReadP--# if defined(mingw32_HOST_OS)-import GHC.ConsoleHandler as Console-# endif-#endif--#if !(MIN_VERSION_base(4,12,0))-import Data.Orphans.Prelude-#endif--#include "HsBaseConfig.h"-----------------------------------------------------------------------------------#if MIN_VERSION_base(4,4,0) && !(MIN_VERSION_base(4,7,0))-instance Show Fingerprint where- show (Fingerprint w1 w2) = hex16 w1 ++ hex16 w2- where- -- Formats a 64 bit number as 16 digits hex.- hex16 :: Word64 -> String- hex16 i = let hex = showHex i ""- in replicate (16 - length hex) '0' ++ hex-#endif--#if !(MIN_VERSION_base(4,4,0))-instance HasResolution a => Read (Fixed a) where- readsPrec _ = readsFixed--readsFixed :: (HasResolution a) => ReadS (Fixed a)-readsFixed = readsSigned- where readsSigned ('-' : xs) = [ (negate x, rest)- | (x, rest) <- readsUnsigned xs ]- readsSigned xs = readsUnsigned xs- readsUnsigned xs = case span isDigit xs of- ([], _) -> []- (is, xs') ->- let i = fromInteger (read is)- in case xs' of- '.' : xs'' ->- case span isDigit xs'' of- ([], _) -> []- (js, xs''') ->- let j = fromInteger (read js)- l = genericLength js :: Integer- in [(i + (j / (10 ^ l)), xs''')]- _ -> [(i, xs')]--deriving instance Typeable1 SampleVar--instance Applicative (Strict.ST s) where- pure = return- (<*>) = ap--instance Applicative (Lazy.ST s) where- pure = return- (<*>) = ap-#endif---- These instances are only valid if Bits isn't a subclass of Num (as Bool is--- not a Num instance), which is only true as of base-4.6.0.0 and later.-#if MIN_VERSION_base(4,6,0) && !(MIN_VERSION_base(4,7,0))-instance Bits Bool where- (.&.) = (&&)-- (.|.) = (||)-- xor = (/=)-- complement = not-- shift x 0 = x- shift _ _ = False-- rotate x _ = x-- bit 0 = True- bit _ = False-- testBit x 0 = x- testBit _ _ = False-- bitSize _ = 1-- isSigned _ = False-- popCount False = 0- popCount True = 1-#endif--#if !(MIN_VERSION_base(4,6,0))-# if defined(HTYPE_DEV_T)-# if MIN_VERSION_base(4,5,0)-deriving instance Bits CDev-deriving instance Bounded CDev-deriving instance Integral CDev-# else-type HDev = HTYPE_DEV_T--instance Bits CDev where- (.&.) = unsafeCoerce ((.&.) :: HDev -> HDev -> HDev)- (.|.) = unsafeCoerce ((.|.) :: HDev -> HDev -> HDev)- xor = unsafeCoerce (xor :: HDev -> HDev -> HDev)- shift = unsafeCoerce (shift :: HDev -> Int -> HDev)- rotate = unsafeCoerce (rotate :: HDev -> Int -> HDev)- setBit = unsafeCoerce (setBit :: HDev -> Int -> HDev)- clearBit = unsafeCoerce (clearBit :: HDev -> Int -> HDev)- complementBit = unsafeCoerce (complementBit :: HDev -> Int -> HDev)- testBit = unsafeCoerce (testBit :: HDev -> Int -> Bool)- complement = unsafeCoerce (complement :: HDev -> HDev)- bit = unsafeCoerce (bit :: Int -> HDev)- bitSize = unsafeCoerce (bitSize :: HDev -> Int)- isSigned = unsafeCoerce (isSigned :: HDev -> Bool)--instance Bounded CDev where- minBound = unsafeCoerce (minBound :: HDev)- maxBound = unsafeCoerce (maxBound :: HDev)--instance Integral CDev where- quot = unsafeCoerce (quot :: HDev -> HDev -> HDev)- rem = unsafeCoerce (rem :: HDev -> HDev -> HDev)- div = unsafeCoerce (div :: HDev -> HDev -> HDev)- mod = unsafeCoerce (mod :: HDev -> HDev -> HDev)- quotRem = unsafeCoerce (quotRem :: HDev -> HDev -> (HDev, HDev))- divMod = unsafeCoerce (divMod :: HDev -> HDev -> (HDev, HDev))- toInteger = unsafeCoerce (toInteger :: HDev -> Integer)-# endif-# endif--instance Applicative ReadP where- pure = return- (<*>) = ap--instance Alternative ReadP where- empty = mzero- (<|>) = mplus--instance Applicative ReadPrec where- pure = return- (<*>) = ap--instance Alternative ReadPrec where- empty = mzero- (<|>) = mplus--instance Functor Exception.Handler where- fmap f (Exception.Handler h) = Exception.Handler (fmap f . h)--instance-# if MIN_VERSION_base(4,4,0)- Arrow a-# else- ArrowApply a-# endif- => Functor (ArrowMonad a) where- fmap f (ArrowMonad m) = ArrowMonad $ m >>> arr f--instance-# if MIN_VERSION_base(4,4,0)- Arrow a-# else- ArrowApply a-# endif- => Applicative (ArrowMonad a) where- pure x = ArrowMonad (arr (const x))- ArrowMonad f <*> ArrowMonad x = ArrowMonad (f &&& x >>> arr (uncurry id))--instance-# if MIN_VERSION_base(4,4,0)- ArrowPlus a-# else- (ArrowApply a, ArrowPlus a)-# endif- => Alternative (ArrowMonad a) where- empty = ArrowMonad zeroArrow- ArrowMonad x <|> ArrowMonad y = ArrowMonad (x <+> y)--instance (ArrowApply a, ArrowPlus a) => MonadPlus (ArrowMonad a) where- mzero = ArrowMonad zeroArrow- ArrowMonad x `mplus` ArrowMonad y = ArrowMonad (x <+> y)-#endif--#if !(MIN_VERSION_base(4,7,0))-deriving instance F.Foldable (Const m)-deriving instance F.Foldable (Either a)-deriving instance T.Traversable (Const m)-deriving instance T.Traversable (Either a)--instance F.Foldable ((,) a) where- foldMap f (_, y) = f y-- foldr f z (_, y) = f y z--instance T.Traversable ((,) a) where- traverse f (x, y) = (,) x <$> f y--deriving instance Monoid a => Monoid (Const a b)-deriving instance Read a => Read (Down a)-deriving instance Show a => Show (Down a)-deriving instance Eq ErrorCall-deriving instance Ord ErrorCall-deriving instance Num a => Num (Sum a)-deriving instance Num a => Num (Product a)-deriving instance Data Version--- GHC Trac #8218-deriving instance Monad m => Monad (WrappedMonad m)-deriving instance Eq a => Eq (ZipList a)-deriving instance Ord a => Ord (ZipList a)-deriving instance Read a => Read (ZipList a)-deriving instance Show a => Show (ZipList a)-deriving instance Functor ArgOrder-deriving instance Functor OptDescr-deriving instance Functor ArgDescr-#endif--#if __GLASGOW_HASKELL__ >= 701 && !(MIN_VERSION_base(4,7,0))-deriving instance Eq (U1 p)-deriving instance Ord (U1 p)-deriving instance Read (U1 p)-deriving instance Show (U1 p)--deriving instance Eq p => Eq (Par1 p)-deriving instance Ord p => Ord (Par1 p)-deriving instance Read p => Read (Par1 p)-deriving instance Show p => Show (Par1 p)--deriving instance Eq (f p) => Eq (Rec1 f p)-deriving instance Ord (f p) => Ord (Rec1 f p)-deriving instance Read (f p) => Read (Rec1 f p)-deriving instance Show (f p) => Show (Rec1 f p)--deriving instance Eq c => Eq (K1 i c p)-deriving instance Ord c => Ord (K1 i c p)-deriving instance Read c => Read (K1 i c p)-deriving instance Show c => Show (K1 i c p)--deriving instance Eq (f p) => Eq (M1 i c f p)-deriving instance Ord (f p) => Ord (M1 i c f p)-deriving instance Read (f p) => Read (M1 i c f p)-deriving instance Show (f p) => Show (M1 i c f p)--deriving instance (Eq (f p), Eq (g p)) => Eq ((f :+: g) p)-deriving instance (Ord (f p), Ord (g p)) => Ord ((f :+: g) p)-deriving instance (Read (f p), Read (g p)) => Read ((f :+: g) p)-deriving instance (Show (f p), Show (g p)) => Show ((f :+: g) p)--deriving instance (Eq (f p), Eq (g p)) => Eq ((f :*: g) p)-deriving instance (Ord (f p), Ord (g p)) => Ord ((f :*: g) p)--- Due to a GHC bug (https://ghc.haskell.org/trac/ghc/ticket/9830), the derived--- Read and Show instances for infix data constructors will use the wrong--- precedence (prior to GHC 7.10).--- We'll manually derive Read :*: and Show :*: instances to avoid this.-instance (Read (f p), Read (g p)) => Read ((f :*: g) p) where- readPrec = parens . ReadPrec.prec 6 $ do- fp <- ReadPrec.step readPrec- Symbol ":*:" <- lexP- gp <- ReadPrec.step readPrec- return $ fp :*: gp- readListPrec = readListPrecDefault-instance (Show (f p), Show (g p)) => Show ((f :*: g) p) where- showsPrec p (l :*: r) = showParen (p > sixPrec) $- showsPrec (sixPrec + 1) l- . showString " :*: "- . showsPrec (sixPrec + 1) r- where sixPrec = 6--deriving instance Eq (f (g p)) => Eq ((f :.: g) p)-deriving instance Ord (f (g p)) => Ord ((f :.: g) p)-deriving instance Read (f (g p)) => Read ((f :.: g) p)-deriving instance Show (f (g p)) => Show ((f :.: g) p)-#endif--#if MIN_VERSION_base(4,7,0) && !(MIN_VERSION_base(4,8,0))--- | Construct tag-less 'Version'------ /Since: 4.8.0.0/-makeVersion :: [Int] -> Version-makeVersion b = Version b []---- | /Since: 4.8.0.0/-instance IsList Version where- type (Item Version) = Int- fromList = makeVersion- toList = versionBranch-#endif--#if !(MIN_VERSION_base(4,8,0))-deriving instance Eq a => Eq (Const a b)-deriving instance Ord a => Ord (Const a b)--instance Read a => Read (Const a b) where- readsPrec d = readParen (d > 10)- $ \r -> [(Const x,t) | ("Const", s) <- lex r, (x, t) <- readsPrec 11 s]--instance Show a => Show (Const a b) where- showsPrec d (Const x) = showParen (d > 10) $- showString "Const " . showsPrec 11 x--deriving instance Functor First-deriving instance Applicative First-deriving instance Monad First-deriving instance Functor Last-deriving instance Applicative Last-deriving instance Monad Last---- In base-4.3 and earlier, pattern matching on a Complex value invokes a--- RealFloat constraint due to the use of the DatatypeContexts extension.-# if MIN_VERSION_base(4,4,0)-instance Storable a-# else-instance (Storable a, RealFloat a)-# endif- => Storable (Complex a) where- sizeOf a = 2 * sizeOf (realPart a)- alignment a = alignment (realPart a)- peek p = do- q <- return $ castPtr p- r <- peek q- i <- peekElemOff q 1- return (r :+ i)- poke p (r :+ i) = do- q <-return $ (castPtr p)- poke q r- pokeElemOff q 1 i--instance (Storable a, Integral a) => Storable (Ratio a) where- sizeOf _ = 2 * sizeOf (undefined :: a)- alignment _ = alignment (undefined :: a )- peek p = do- q <- return $ castPtr p- r <- peek q- i <- peekElemOff q 1- return (r % i)- poke p (r :% i) = do- q <-return $ (castPtr p)- poke q r- pokeElemOff q 1 i-#endif--#if !(MIN_VERSION_base(4,9,0))-instance Storable () where- sizeOf _ = 0- alignment _ = 1- peek _ = return ()- poke _ _ = return ()--deriving instance Bits a => Bits (Const a b)-deriving instance Bounded a => Bounded (Const a b)-deriving instance Enum a => Enum (Const a b)-deriving instance Floating a => Floating (Const a b)-deriving instance Fractional a => Fractional (Const a b)-deriving instance Integral a => Integral (Const a b)-deriving instance IsString a => IsString (Const a b)-deriving instance Ix a => Ix (Const a b)-deriving instance Num a => Num (Const a b)-deriving instance Real a => Real (Const a b)-deriving instance RealFloat a => RealFloat (Const a b)-deriving instance RealFrac a => RealFrac (Const a b)-deriving instance Storable a => Storable (Const a b)--deriving instance Data All-deriving instance Data Monoid.Any-deriving instance Data a => Data (Dual a)-deriving instance Data a => Data (First a)-deriving instance Data a => Data (Last a)-deriving instance Data a => Data (Product a)-deriving instance Data a => Data (Sum a)--instance F.Foldable Dual where- foldMap = coerce-- foldl = coerce- foldl1 _ = getDual- foldr f z (Dual x) = f x z- foldr1 _ = getDual-# if MIN_VERSION_base(4,6,0)- foldl' = coerce- foldr' = F.foldr-# endif-# if MIN_VERSION_base(4,8,0)- elem = (. getDual) #. (==)- length _ = 1- maximum = getDual- minimum = getDual- null _ = False- product = getDual- sum = getDual- toList (Dual x) = [x]-# endif--instance F.Foldable Sum where- foldMap = coerce-- foldl = coerce- foldl1 _ = getSum- foldr f z (Sum x) = f x z- foldr1 _ = getSum-# if MIN_VERSION_base(4,6,0)- foldl' = coerce- foldr' = F.foldr-# endif-# if MIN_VERSION_base(4,8,0)- elem = (. getSum) #. (==)- length _ = 1- maximum = getSum- minimum = getSum- null _ = False- product = getSum- sum = getSum- toList (Sum x) = [x]-# endif--instance F.Foldable Product where- foldMap = coerce-- foldl = coerce- foldl1 _ = getProduct- foldr f z (Product x) = f x z- foldr1 _ = getProduct-# if MIN_VERSION_base(4,6,0)- foldl' = coerce- foldr' = F.foldr-# endif-# if MIN_VERSION_base(4,8,0)- elem = (. getProduct) #. (==)- length _ = 1- maximum = getProduct- minimum = getProduct- null _ = False- product = getProduct- sum = getProduct- toList (Product x) = [x]-# endif--# if MIN_VERSION_base(4,8,0)-(#.) :: Coercible b c => (b -> c) -> (a -> b) -> (a -> c)-(#.) _f = coerce-# endif--# if !(MIN_VERSION_base(4,7,0))-coerce :: a -> b-coerce = unsafeCoerce-# endif--instance Functor Dual where- fmap = coerce--instance Applicative Dual where- pure = Dual- (<*>) = coerce--instance Monad Dual where- return = Dual- m >>= k = k (getDual m)--instance Functor Sum where- fmap = coerce--instance Applicative Sum where- pure = Sum- (<*>) = coerce--instance Monad Sum where- return = Sum- m >>= k = k (getSum m)--instance Functor Product where- fmap = coerce--instance Applicative Product where- pure = Product- (<*>) = coerce--instance Monad Product where- return = Product- m >>= k = k (getProduct m)--instance F.Foldable First where- foldMap f = F.foldMap f . getFirst--instance F.Foldable Last where- foldMap f = F.foldMap f . getLast--instance Monoid a => Monoid (IO a) where- mempty = pure mempty- mappend = liftA2 mappend---- see: #10190 https://git.haskell.org/ghc.git/commitdiff/9db005a444722e31aca1956b058e069bcf3cacbd-instance Monoid a => Monad ((,) a) where- return x = (mempty, x)- (u, a) >>= k = case k a of (v, b) -> (u `mappend` v, b)--instance MonadFix Dual where- mfix f = Dual (fix (getDual . f))--instance MonadFix Sum where- mfix f = Sum (fix (getSum . f))--instance MonadFix Product where- mfix f = Product (fix (getProduct . f))--instance MonadFix First where- mfix f = First (mfix (getFirst . f))--instance MonadFix Last where- mfix f = Last (mfix (getLast . f))--instance T.Traversable Dual where- traverse f (Dual x) = Dual <$> f x--instance T.Traversable Sum where- traverse f (Sum x) = Sum <$> f x--instance T.Traversable Product where- traverse f (Product x) = Product <$> f x--instance T.Traversable First where- traverse f (First x) = First <$> T.traverse f x--instance T.Traversable Last where- traverse f (Last x) = Last <$> T.traverse f x--deriving instance F.Foldable ZipList-deriving instance T.Traversable ZipList--# if MIN_VERSION_base(4,4,0)-deriving instance Functor Complex-deriving instance F.Foldable Complex-deriving instance T.Traversable Complex--instance Applicative Complex where- pure a = a :+ a- f :+ g <*> a :+ b = f a :+ g b--instance Monad Complex where- return a = a :+ a- a :+ b >>= f = realPart (f a) :+ imagPart (f b)--instance MonadZip Dual where- -- Cannot use coerce, it's unsafe- mzipWith = liftM2--instance MonadZip Sum where- mzipWith = liftM2--instance MonadZip Product where- mzipWith = liftM2--instance MonadZip Maybe where- mzipWith = liftM2--instance MonadZip First where- mzipWith = liftM2--instance MonadZip Last where- mzipWith = liftM2-# endif--# if MIN_VERSION_base(4,7,0)-instance Alternative Proxy where- empty = Proxy- {-# INLINE empty #-}- _ <|> _ = Proxy- {-# INLINE (<|>) #-}--instance MonadPlus Proxy where-# if !(MIN_VERSION_base(4,8,0))- mzero = Proxy- {-# INLINE mzero #-}- mplus _ _ = Proxy- {-# INLINE mplus #-}-# endif--instance MonadZip Proxy where- mzipWith _ _ _ = Proxy- {-# INLINE mzipWith #-}--deriving instance FiniteBits a => FiniteBits (Const a b)-# endif--# if MIN_VERSION_base(4,8,0)-deriving instance (Data (f a), Typeable f, Typeable a)- => Data (Alt (f :: * -> *) (a :: *))--instance MonadFix f => MonadFix (Alt f) where- mfix f = Alt (mfix (getAlt . f))--instance MonadZip f => MonadZip (Alt f) where- mzipWith f (Alt ma) (Alt mb) = Alt (mzipWith f ma mb)--deriving instance Bits a => Bits (Identity a)-deriving instance Bounded a => Bounded (Identity a)-deriving instance Enum a => Enum (Identity a)-deriving instance FiniteBits a => FiniteBits (Identity a)-deriving instance Floating a => Floating (Identity a)-deriving instance Fractional a => Fractional (Identity a)-deriving instance Integral a => Integral (Identity a)-deriving instance IsString a => IsString (Identity a)-deriving instance Ix a => Ix (Identity a)-deriving instance Monoid a => Monoid (Identity a)-deriving instance Num a => Num (Identity a)-deriving instance Real a => Real (Identity a)-deriving instance RealFloat a => RealFloat (Identity a)-deriving instance RealFrac a => RealFrac (Identity a)-deriving instance Storable a => Storable (Identity a)-# endif--# if __GLASGOW_HASKELL__ >= 701-deriving instance Data p => Data (V1 p)-deriving instance Data p => Data (U1 p)-deriving instance Data p => Data (Par1 p)-deriving instance (Typeable i, Data p, Data c) => Data (K1 i c p)-deriving instance Data Generics.Fixity-deriving instance Data Associativity--deriving instance F.Foldable V1-deriving instance F.Foldable Par1-deriving instance F.Foldable f => F.Foldable (Rec1 f)-deriving instance F.Foldable (K1 i c)-deriving instance F.Foldable f => F.Foldable (M1 i c f)-deriving instance (F.Foldable f, F.Foldable g) => F.Foldable (f :+: g)-deriving instance (F.Foldable f, F.Foldable g) => F.Foldable (f :*: g)-deriving instance (F.Foldable f, F.Foldable g) => F.Foldable (f :.: g)--deriving instance Functor V1-deriving instance Functor Par1-deriving instance Functor f => Functor (Rec1 f)-deriving instance Functor (K1 i c)-deriving instance Functor f => Functor (M1 i c f)-deriving instance (Functor f, Functor g) => Functor (f :+: g)-deriving instance (Functor f, Functor g) => Functor (f :*: g)-deriving instance (Functor f, Functor g) => Functor (f :.: g)--instance MonadFix Par1 where- mfix f = Par1 (fix (unPar1 . f))--instance MonadFix f => MonadFix (Rec1 f) where- mfix f = Rec1 (mfix (unRec1 . f))--instance MonadFix f => MonadFix (M1 i c f) where- mfix f = M1 (mfix (unM1. f))--instance (MonadFix f, MonadFix g) => MonadFix (f :*: g) where- mfix f = (mfix (fstP . f)) :*: (mfix (sndP . f))- where- fstP (a :*: _) = a- sndP (_ :*: b) = b--instance MonadZip U1 where- mzipWith _ _ _ = U1--instance MonadZip Par1 where- mzipWith = liftM2--instance MonadZip f => MonadZip (Rec1 f) where- mzipWith f (Rec1 fa) (Rec1 fb) = Rec1 (mzipWith f fa fb)--instance MonadZip f => MonadZip (M1 i c f) where- mzipWith f (M1 fa) (M1 fb) = M1 (mzipWith f fa fb)--instance (MonadZip f, MonadZip g) => MonadZip (f :*: g) where- mzipWith f (x1 :*: y1) (x2 :*: y2) = mzipWith f x1 x2 :*: mzipWith f y1 y2--deriving instance T.Traversable V1-deriving instance T.Traversable Par1-deriving instance T.Traversable f => T.Traversable (Rec1 f)-deriving instance T.Traversable (K1 i c)-deriving instance T.Traversable f => T.Traversable (M1 i c f)-deriving instance (T.Traversable f, T.Traversable g) => T.Traversable (f :+: g)-deriving instance (T.Traversable f, T.Traversable g) => T.Traversable (f :*: g)-deriving instance (T.Traversable f, T.Traversable g) => T.Traversable (f :.: g)--deriving instance Bounded Associativity-deriving instance Enum Associativity-deriving instance Ix Associativity--deriving instance Eq (V1 p)-deriving instance Ord (V1 p)--- Implement Read instance manually to get around an old GHC bug--- (Trac #7931)-instance Read (V1 p) where- readPrec = parens ReadPrec.pfail- readList = readListDefault- readListPrec = readListPrecDefault-deriving instance Show (V1 p)--instance Functor U1 where- fmap _ _ = U1--instance Applicative U1 where- pure _ = U1- _ <*> _ = U1--instance Alternative U1 where- empty = U1- _ <|> _ = U1--instance Monad U1 where-# if !(MIN_VERSION_base(4,8,0))- return _ = U1-# endif- _ >>= _ = U1--instance MonadPlus U1 where-# if !(MIN_VERSION_base(4,8,0))- mzero = U1- mplus _ _ = U1-# endif--instance F.Foldable U1 where- foldMap _ _ = mempty- {-# INLINE foldMap #-}- fold _ = mempty- {-# INLINE fold #-}- foldr _ z _ = z- {-# INLINE foldr #-}- foldl _ z _ = z- {-# INLINE foldl #-}- foldl1 _ _ = error "foldl1: U1"- foldr1 _ _ = error "foldr1: U1"-# if MIN_VERSION_base(4,8,0)- length _ = 0- null _ = True- elem _ _ = False- sum _ = 0- product _ = 1-# endif--instance T.Traversable U1 where- traverse _ _ = pure U1- {-# INLINE traverse #-}- sequenceA _ = pure U1- {-# INLINE sequenceA #-}- mapM _ _ = return U1- {-# INLINE mapM #-}- sequence _ = return U1- {-# INLINE sequence #-}--instance Applicative Par1 where- pure a = Par1 a- Par1 f <*> Par1 x = Par1 (f x)--instance Monad Par1 where-# if !(MIN_VERSION_base(4,8,0))- return a = Par1 a-# endif- Par1 x >>= f = f x--instance Applicative f => Applicative (Rec1 f) where- pure a = Rec1 (pure a)- Rec1 f <*> Rec1 x = Rec1 (f <*> x)--instance Alternative f => Alternative (Rec1 f) where- empty = Rec1 empty- Rec1 l <|> Rec1 r = Rec1 (l <|> r)--instance Monad f => Monad (Rec1 f) where-# if !(MIN_VERSION_base(4,8,0))- return a = Rec1 (return a)-# endif- Rec1 x >>= f = Rec1 (x >>= \a -> unRec1 (f a))--instance MonadPlus f => MonadPlus (Rec1 f) where-# if !(MIN_VERSION_base(4,8,0))- mzero = Rec1 mzero- mplus (Rec1 a) (Rec1 b) = Rec1 (mplus a b)-# endif--instance Applicative f => Applicative (M1 i c f) where- pure a = M1 (pure a)- M1 f <*> M1 x = M1 (f <*> x)--instance Alternative f => Alternative (M1 i c f) where- empty = M1 empty- M1 l <|> M1 r = M1 (l <|> r)--instance Monad f => Monad (M1 i c f) where-# if !(MIN_VERSION_base(4,8,0))- return a = M1 (return a)-# endif- M1 x >>= f = M1 (x >>= \a -> unM1 (f a))--instance MonadPlus f => MonadPlus (M1 i c f) where-# if !(MIN_VERSION_base(4,8,0))- mzero = M1 mzero- mplus (M1 a) (M1 b) = M1 (mplus a b)-# endif--instance (Applicative f, Applicative g) => Applicative (f :*: g) where- pure a = pure a :*: pure a- (f :*: g) <*> (x :*: y) = (f <*> x) :*: (g <*> y)--instance (Alternative f, Alternative g) => Alternative (f :*: g) where- empty = empty :*: empty- (x1 :*: y1) <|> (x2 :*: y2) = (x1 <|> x2) :*: (y1 <|> y2)--instance (Monad f, Monad g) => Monad (f :*: g) where-# if !(MIN_VERSION_base(4,8,0))- return a = return a :*: return a-# endif- (m :*: n) >>= f = (m >>= \a -> fstP (f a)) :*: (n >>= \a -> sndP (f a))- where- fstP (a :*: _) = a- sndP (_ :*: b) = b--instance (MonadPlus f, MonadPlus g) => MonadPlus (f :*: g) where-# if !(MIN_VERSION_base(4,8,0))- mzero = mzero :*: mzero- (x1 :*: y1) `mplus` (x2 :*: y2) = (x1 `mplus` x2) :*: (y1 `mplus` y2)-# endif--instance (Applicative f, Applicative g) => Applicative (f :.: g) where- pure x = Comp1 (pure (pure x))- Comp1 f <*> Comp1 x = Comp1 (fmap (<*>) f <*> x)--instance (Alternative f, Applicative g) => Alternative (f :.: g) where- empty = Comp1 empty- Comp1 x <|> Comp1 y = Comp1 (x <|> y)--deriving instance (Data (f p), Typeable1 f, Data p) => Data (Rec1 f p)-deriving instance (Data p, Data (f p), Typeable c, Typeable i, Typeable1 f)- => Data (M1 i c f p)-deriving instance (Typeable1 f, Typeable1 g, Data p, Data (f p), Data (g p))- => Data ((f :+: g) p)-deriving instance (Typeable1 f, Typeable1 g, Data p, Data (f p), Data (g p))- => Data ((f :*: g) p)-deriving instance (Typeable1 f, Typeable1 g, Data p, Data (f (g p)))- => Data ((f :.: g) p)--# if MIN_VERSION_base(4,8,0)-instance Bifunctor (K1 i) where- bimap f _ (K1 c) = K1 (f c)-# endif-# endif-#endif--#if !(MIN_VERSION_base(4,10,0))-# if MIN_VERSION_base(4,9,0)-deriving instance (Typeable k, Data a, Typeable (b :: k)) => Data (Const a b)-# else-deriving instance (Data a, Data b) => Data (Const a b)-# endif--# if MIN_VERSION_base(4,9,0)-instance Eq1 NonEmpty where- liftEq eq (a :| as) (b :| bs) = eq a b && liftEq eq as bs--instance Ord1 NonEmpty where- liftCompare cmp (a :| as) (b :| bs) = cmp a b <> liftCompare cmp as bs--instance Read1 NonEmpty where- liftReadsPrec rdP rdL p s = readParen (p > 5) (\s' -> do- (a, s'') <- rdP 6 s'- (":|", s''') <- lex s''- (as, s'''') <- rdL s'''- return (a :| as, s'''')) s--instance Show1 NonEmpty where- liftShowsPrec shwP shwL p (a :| as) = showParen (p > 5) $- shwP 6 a . showString " :| " . shwL as--instance Semigroup a => Semigroup (IO a) where- (<>) = liftA2 (<>)--# if !defined(mingw32_HOST_OS) && !defined(ghcjs_HOST_OS)-instance Semigroup Event where- (<>) = mappend- stimes = stimesMonoid--instance Semigroup Lifetime where- (<>) = mappend- stimes = stimesMonoid-# endif-# endif-#endif--#if !(MIN_VERSION_base(4,11,0))-instance Alternative ZipList where- empty = ZipList []- ZipList xs <|> ZipList ys = ZipList (xs ++ drop (length xs) ys)--deriving instance Monoid a => Monoid (Down a)-deriving instance Num a => Num (Down a)--instance Functor Down where- fmap = coerce--instance Applicative Down where- pure = Down- (<*>) = coerce--instance Monad Down where- return = Down- Down a >>= k = k a--instance Monoid a => Monoid (Strict.ST s a) where- mempty = pure mempty- mappend = liftA2 mappend--# if MIN_VERSION_base(4,9,0)-instance Fail.MonadFail (Strict.ST s) where- fail s = errorWithoutStackTrace s--deriving instance Semigroup a => Semigroup (Down a)--instance Semigroup a => Semigroup (Strict.ST s a) where- (<>) = liftA2 (<>)-# endif--# if MIN_VERSION_base(4,10,0)-deriving instance Data IntPtr-deriving instance Data WordPtr-# else--- The constructors for IntPtr and WordPtr aren't exposed on older versions--- of base, so we're forced to hand-roll the Data instances here-instance Data IntPtr where- gfoldl k z iptr = z intPtr `k` unIntPtr iptr- gunfold k z _ = k (z intPtr)- toConstr !_ = cIntPtr- dataTypeOf _ = tIntPtr--intPtr :: Int -> IntPtr-intPtr = unsafeCoerce--unIntPtr :: IntPtr -> Int-unIntPtr = unsafeCoerce--tIntPtr :: DataType-tIntPtr = mkDataType "IntPtr" [cIntPtr]--cIntPtr :: Constr-cIntPtr = mkConstr tIntPtr "IntPtr" [] Data.Prefix--instance Data WordPtr where- gfoldl k z wptr = z wordPtr `k` unWordPtr wptr- gunfold k z _ = k (z wordPtr)- toConstr !_ = cWordPtr- dataTypeOf _ = tWordPtr--wordPtr :: Word -> WordPtr-wordPtr = unsafeCoerce--unWordPtr :: WordPtr -> Word-unWordPtr = unsafeCoerce--tWordPtr :: DataType-tWordPtr = mkDataType "WordPtr" [cWordPtr]--cWordPtr :: Constr-cWordPtr = mkConstr tWordPtr "WordPtr" [] Data.Prefix-# endif-#endif--#if !(MIN_VERSION_base(4,12,0))-instance MonadFix Down where- mfix f = Down (fix (getDown . f))- where getDown (Down x) = x-deriving instance Data a => Data (Down a)-deriving instance F.Foldable Down-deriving instance T.Traversable Down-# if MIN_VERSION_base(4,4,0)-instance MonadZip Down where- mzipWith = liftM2-# endif-# if MIN_VERSION_base(4,9,0)-instance Eq1 Down where- liftEq eq (Down x) (Down y) = eq x y-instance Ord1 Down where- liftCompare comp (Down x) (Down y) = comp x y-instance Read1 Down where- liftReadsPrec rp _ = readsData $- readsUnaryWith rp "Down" Down-instance Show1 Down where- liftShowsPrec sp _ d (Down x) = showsUnaryWith sp "Down" d x-# endif--# if __GLASGOW_HASKELL__ >= 701-instance Monoid c => Applicative (K1 i c) where- pure _ = K1 mempty- (<*>) = coerce (mappend :: c -> c -> c)-# if MIN_VERSION_base(4,10,0)- liftA2 = \_ -> coerce (mappend :: c -> c -> c)-# endif--instance Monoid (U1 p) where- mempty = U1-# if !(MIN_VERSION_base(4,11,0))- _ `mappend` _ = U1-# endif-deriving instance Monoid p => Monoid (Par1 p)-deriving instance Monoid (f p) => Monoid (Rec1 f p)-deriving instance Monoid c => Monoid (K1 i c p)-deriving instance Monoid (f p) => Monoid (M1 i c f p)-instance (Monoid (f p), Monoid (g p)) => Monoid ((f :*: g) p) where- mempty = mempty :*: mempty-# if !(MIN_VERSION_base(4,11,0))- (x1 :*: y1) `mappend` (x2 :*: y2) = (x1 `mappend` x2) :*: (y1 `mappend` y2)-# endif-deriving instance Monoid (f (g p)) => Monoid ((f :.: g) p)--# if MIN_VERSION_base(4,9,0)-instance Semigroup (V1 p) where- v <> _ = v-instance Semigroup (U1 p) where- _ <> _ = U1-deriving instance Semigroup p => Semigroup (Par1 p)-deriving instance Semigroup (f p) => Semigroup (Rec1 f p)-deriving instance Semigroup c => Semigroup (K1 i c p)-deriving instance Semigroup (f p) => Semigroup (M1 i c f p)-instance (Semigroup (f p), Semigroup (g p)) => Semigroup ((f :*: g) p) where- (x1 :*: y1) <> (x2 :*: y2) = (x1 <> x2) :*: (y1 <> y2)-deriving instance Semigroup (f (g p)) => Semigroup ((f :.: g) p)-# endif-# endif--# if MIN_VERSION_base(4,8,0)-deriving instance Foldable f => Foldable (Alt f)-deriving instance Traversable f => Traversable (Alt f)-# endif-#endif--#if __GLASGOW_HASKELL__ < 710-deriving instance Typeable All-deriving instance Typeable AnnotationWrapper-deriving instance Typeable Monoid.Any-deriving instance Typeable1 ArgDescr-deriving instance Typeable1 ArgOrder-deriving instance Typeable BlockReason-deriving instance Typeable1 Buffer-deriving instance Typeable3 BufferCodec-deriving instance Typeable1 BufferList-deriving instance Typeable BufferMode-deriving instance Typeable BufferState-deriving instance Typeable CFile-deriving instance Typeable CFpos-deriving instance Typeable CJmpBuf-deriving instance Typeable2 Const-deriving instance Typeable Constr-deriving instance Typeable ConstrRep-deriving instance Typeable DataRep-deriving instance Typeable DataType-deriving instance Typeable1 Down-deriving instance Typeable1 Dual-deriving instance Typeable1 Endo-deriving instance Typeable Errno-deriving instance Typeable1 First-deriving instance Typeable Data.Fixity-deriving instance Typeable GeneralCategory-deriving instance Typeable HandlePosn-deriving instance Typeable1 Exception.Handler-deriving instance Typeable HandleType-deriving instance Typeable IODeviceType-deriving instance Typeable IOErrorType-deriving instance Typeable IOMode-deriving instance Typeable1 Last-deriving instance Typeable Lexeme-deriving instance Typeable Newline-deriving instance Typeable NewlineMode-deriving instance Typeable Opaque-deriving instance Typeable1 OptDescr-deriving instance Typeable Pool-deriving instance Typeable1 Product-deriving instance Typeable1 ReadP-deriving instance Typeable1 ReadPrec-deriving instance Typeable SeekMode-deriving instance Typeable2 Lazy.ST-deriving instance Typeable2 STret-deriving instance Typeable1 Sum-deriving instance Typeable TextEncoding-deriving instance Typeable ThreadStatus-deriving instance Typeable1 ZipList--# if defined(mingw32_HOST_OS)-deriving instance Typeable CodePageArrays-deriving instance Typeable2 CompactArray-deriving instance Typeable1 ConvArray-deriving instance Typeable Console.Handler-# endif--# if MIN_VERSION_base(4,3,0)-deriving instance Typeable MaskingState-# endif--# if MIN_VERSION_base(4,4,0)-deriving instance Typeable CodingFailureMode-deriving instance Typeable CodingProgress-deriving instance Typeable Fingerprint--# if !defined(mingw32_HOST_OS) && !defined(__GHCJS__)-deriving instance Typeable Event-deriving instance Typeable EventManager-deriving instance Typeable FdKey-deriving instance Typeable TimeoutKey-# endif-# endif--# if __GLASGOW_HASKELL__ >= 701-deriving instance Typeable Arity-deriving instance Typeable Associativity-deriving instance Typeable C-deriving instance Typeable D-deriving instance Typeable Generics.Fixity-deriving instance Typeable3 K1-deriving instance Typeable NoSelector-deriving instance Typeable P-deriving instance Typeable1 Par1-deriving instance Typeable R-deriving instance Typeable S-deriving instance Typeable1 U1-deriving instance Typeable1 V1--# if __GLASGOW_HASKELL__ >= 708--- Data types which use poly-kinded Typeable...-deriving instance Typeable (:+:)-deriving instance Typeable (:*:)-deriving instance Typeable (:.:)-deriving instance Typeable M1-deriving instance Typeable Rec1-# else--- ...but we can hack around that if need be.-instance (Typeable1 f, Typeable1 g) => Typeable1 (f :+: g) where- typeOf1 t = mkTyConApp conSumTyCon [typeOf1 (f t), typeOf1 (g t)]- where- f :: (f :+: g) p -> f p- f = undefined-- g :: (f :+: g) p -> g p- g = undefined--conSumTyCon :: TyCon-conSumTyCon = mkTyCon3 ghcGenericsPackage "GHC.Generics" ":+:"--instance (Typeable1 f, Typeable1 g) => Typeable1 (f :*: g) where- typeOf1 t = mkTyConApp conProductTyCon [typeOf1 (f t), typeOf1 (g t)]- where- f :: (f :*: g) p -> f p- f = undefined-- g :: (f :*: g) p -> g p- g = undefined--conProductTyCon :: TyCon-conProductTyCon = mkTyCon3 ghcGenericsPackage "GHC.Generics" ":*:"--instance (Typeable1 f, Typeable1 g) => Typeable1 (f :.: g) where- typeOf1 t = mkTyConApp conComposeTyCon [typeOf1 (f t), typeOf1 (g t)]- where- f :: (f :.: g) p -> f p- f = undefined-- g :: (f :.: g) p -> g p- g = undefined--conComposeTyCon :: TyCon-conComposeTyCon = mkTyCon3 ghcGenericsPackage "GHC.Generics" ":.:"--instance (Typeable i, Typeable c, Typeable1 f) => Typeable1 (M1 i c f) where- typeOf1 t = mkTyConApp m1TyCon [typeOf (i t), typeOf (c t), typeOf1 (f t)]- where- i :: M1 i c f p -> i- i = undefined-- c :: M1 i c f p -> c- c = undefined-- f :: M1 i c f p -> f p- f = undefined--m1TyCon :: TyCon-m1TyCon = mkTyCon3 ghcGenericsPackage "GHC.Generics" "M1"--instance Typeable1 f => Typeable1 (Rec1 f) where- typeOf1 t = mkTyConApp rec1TyCon [typeOf1 (f t)]- where- f :: Rec1 f a -> f a- f = undefined--rec1TyCon :: TyCon-rec1TyCon = mkTyCon3 ghcGenericsPackage "GHC.Generics" "Rec1"--ghcGenericsPackage :: String-# if MIN_VERSION_base(4,6,0)-ghcGenericsPackage = "base"-# else-ghcGenericsPackage = "ghc-prim"-# endif-# endif-# endif--# if MIN_VERSION_base(4,5,0)-deriving instance Typeable CostCentre-deriving instance Typeable CostCentreStack-deriving instance Typeable GCStats-# endif--# if MIN_VERSION_base(4,6,0)-deriving instance Typeable CSigset-deriving instance Typeable ForeignPtrContents-deriving instance Typeable Nat-deriving instance Typeable1 NoIO-deriving instance Typeable Symbol-# endif--# if MIN_VERSION_ghc_prim(0,3,1)-deriving instance Typeable SPEC-# endif--# if MIN_VERSION_base(4,7,0)-deriving instance Typeable FieldFormat-deriving instance Typeable FormatAdjustment-deriving instance Typeable FormatParse-deriving instance Typeable FormatSign-deriving instance Typeable KProxy-deriving instance Typeable Number-deriving instance Typeable SomeNat-deriving instance Typeable SomeSymbol-deriving instance Typeable QSem -- This instance seems to have been removed- -- (accidentally?) in base-4.7.0.0-# endif--# if __GLASGOW_HASKELL__ >= 708--- Data types which use poly-kinded Typeable...-deriving instance Typeable ArrowMonad-deriving instance Typeable Kleisli-deriving instance Typeable WrappedArrow-deriving instance Typeable WrappedMonad-deriving instance Typeable Exts.Any-# else--- ...but we can hack around that if need be.-instance Typeable2 a => Typeable1 (ArrowMonad a) where- typeOf1 t = mkTyConApp arrowMonadTyCon [typeOf2 (a t)]- where- a :: ArrowMonad a b -> a () b- a = undefined--arrowMonadTyCon :: TyCon-# if MIN_VERSION_base(4,4,0)-arrowMonadTyCon = mkTyCon3 "base" "Control.Arrow" "ArrowMonad"-# else-arrowMonadTyCon = mkTyCon "Control.Arrow.ArrowMonad"-# endif--instance Typeable1 m => Typeable2 (Kleisli m) where- typeOf2 t = mkTyConApp kleisliTyCon [typeOf1 (m t)]- where- m :: Kleisli m a b -> m b- m = undefined--kleisliTyCon :: TyCon-# if MIN_VERSION_base(4,4,0)-kleisliTyCon = mkTyCon3 "base" "Control.Arrow" "Kleisli"-# else-kleisliTyCon = mkTyCon "Control.Arrow.Kleisli"-# endif--instance Typeable2 a => Typeable2 (WrappedArrow a) where- typeOf2 t = mkTyConApp wrappedArrowTyCon [typeOf2 (a t)]- where- a :: WrappedArrow a b c -> a b c- a = undefined--wrappedArrowTyCon :: TyCon-# if MIN_VERSION_base(4,4,0)-wrappedArrowTyCon = mkTyCon3 "base" "Control.Applicative" "WrappedArrow"-# else-wrappedArrowTyCon = mkTyCon "Control.Applicative.WrappedArrow"-# endif--instance Typeable1 m => Typeable1 (WrappedMonad m) where- typeOf1 t = mkTyConApp wrappedMonadTyCon [typeOf1 (m t)]- where- m :: WrappedMonad m a -> m a- m = undefined--wrappedMonadTyCon :: TyCon-# if MIN_VERSION_base(4,4,0)-wrappedMonadTyCon = mkTyCon3 "base" "Control.Applicative" "WrappedMonad"-# else-wrappedMonadTyCon = mkTyCon "Control.Applicative.WrappedMonad"-# endif---- GHC will get confused if you try deriving a Typeable instance for Any--- prior to GHC 7.8, sadly-instance Typeable Exts.Any where- typeOf _ = mkTyConApp anyTyCon []--anyTyCon :: TyCon-# if MIN_VERSION_base(4,4,0)-anyTyCon = mkTyCon3 "ghc-prim" "GHC.Prim" "Any"-# else-anyTyCon = mkTyCon "GHC.Prim.Any"-# endif-# endif--# if __GLASGOW_HASKELL__ >= 708--- Data types which have more than seven type arguments-deriving instance Typeable (,,,,,,,)-deriving instance Typeable (,,,,,,,,)-deriving instance Typeable (,,,,,,,,,)-deriving instance Typeable (,,,,,,,,,,)-deriving instance Typeable (,,,,,,,,,,,)-deriving instance Typeable (,,,,,,,,,,,,)-deriving instance Typeable (,,,,,,,,,,,,,)-deriving instance Typeable (,,,,,,,,,,,,,,)-deriving instance Typeable (,,,,,,,,,,,,,,,)-deriving instance Typeable (,,,,,,,,,,,,,,,,)-deriving instance Typeable (,,,,,,,,,,,,,,,,,)-deriving instance Typeable (,,,,,,,,,,,,,,,,,,)-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,)-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,,)-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,,,)-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,,,,)-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,,,,,)-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,,,,,,)-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,,,,,,,)-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,,,,,,,,)-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,,,,,,,,,)-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,,,,,,,,,,)-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)---- Typeclasses-deriving instance Typeable Arrow-deriving instance Typeable ArrowApply-deriving instance Typeable ArrowChoice-deriving instance Typeable ArrowLoop-deriving instance Typeable ArrowZero-deriving instance Typeable Bits-deriving instance Typeable Bounded-deriving instance Typeable BufferedIO-deriving instance Typeable Category-deriving instance Typeable Coercible-deriving instance Typeable Constructor-deriving instance Typeable Data-deriving instance Typeable Datatype-deriving instance Typeable Enum-deriving instance Typeable Exception-deriving instance Typeable Eq-deriving instance Typeable FiniteBits-deriving instance Typeable Floating-deriving instance Typeable F.Foldable-deriving instance Typeable Fractional-deriving instance Typeable Functor-deriving instance Typeable Generic-deriving instance Typeable Generic1-deriving instance Typeable GHCiSandboxIO-deriving instance Typeable HasResolution-deriving instance Typeable HPrintfType-deriving instance Typeable Integral-deriving instance Typeable IODevice-deriving instance Typeable IP-deriving instance Typeable IsChar-deriving instance Typeable IsList-deriving instance Typeable IsString-deriving instance Typeable Ix-deriving instance Typeable KnownNat-deriving instance Typeable KnownSymbol-deriving instance Typeable Monad-deriving instance Typeable MonadFix-deriving instance Typeable MonadPlus-deriving instance Typeable MonadZip-deriving instance Typeable Num-deriving instance Typeable Ord-deriving instance Typeable PrintfArg-deriving instance Typeable PrintfType-deriving instance Typeable RawIO-deriving instance Typeable Read-deriving instance Typeable Real-deriving instance Typeable RealFloat-deriving instance Typeable RealFrac-deriving instance Typeable Selector-deriving instance Typeable Show-deriving instance Typeable Storable-deriving instance Typeable TestCoercion-deriving instance Typeable TestEquality-deriving instance Typeable T.Traversable-deriving instance Typeable Typeable---- Constraints-deriving instance Typeable (~)-deriving instance Typeable Constraint---- Promoted data constructors-deriving instance Typeable '()-deriving instance Typeable '(,)-deriving instance Typeable '(,,)-deriving instance Typeable '(,,,)-deriving instance Typeable '(,,,,)-deriving instance Typeable '(,,,,,)-deriving instance Typeable '(,,,,,,)-deriving instance Typeable '(,,,,,,,)-deriving instance Typeable '(,,,,,,,,)-deriving instance Typeable '(,,,,,,,,,)-deriving instance Typeable '(,,,,,,,,,,)-deriving instance Typeable '(,,,,,,,,,,,)-deriving instance Typeable '(,,,,,,,,,,,,)-deriving instance Typeable '(,,,,,,,,,,,,,)-deriving instance Typeable '(,,,,,,,,,,,,,,)-deriving instance Typeable '(,,,,,,,,,,,,,,,)-deriving instance Typeable '(,,,,,,,,,,,,,,,,)-deriving instance Typeable '(,,,,,,,,,,,,,,,,,)-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,)-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,)-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,,)-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,,,)-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,,,,)-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,,,,,)-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,,,,,,)-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,,,,,,,)-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,,,,,,,,)-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,,,,,,,,,)-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,,,,,,,,,,)-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)-deriving instance Typeable '[]-deriving instance Typeable '(:)-deriving instance Typeable '(:%)-deriving instance Typeable '(:+)-deriving instance Typeable 'AbsoluteSeek-deriving instance Typeable 'All-deriving instance Typeable 'AlreadyExists-deriving instance Typeable 'Monoid.Any-deriving instance Typeable 'AppendHandle-deriving instance Typeable 'AppendMode-deriving instance Typeable 'BlockedIndefinitelyOnMVar-deriving instance Typeable 'BlockedIndefinitelyOnSTM-deriving instance Typeable 'BlockedOnBlackHole-deriving instance Typeable 'BlockedOnException-deriving instance Typeable 'BlockedOnForeignCall-deriving instance Typeable 'BlockedOnMVar-deriving instance Typeable 'BlockedOnOther-deriving instance Typeable 'BlockedOnSTM-deriving instance Typeable 'ClosedHandle-deriving instance Typeable 'ClosePunctuation-deriving instance Typeable 'ConnectorPunctuation-deriving instance Typeable 'Const-deriving instance Typeable 'Control-deriving instance Typeable 'CRLF-deriving instance Typeable 'CurrencySymbol-deriving instance Typeable 'DashPunctuation-deriving instance Typeable 'Deadlock-deriving instance Typeable 'DecimalNumber-deriving instance Typeable 'Denormal-deriving instance Typeable 'Directory-deriving instance Typeable 'DivideByZero-deriving instance Typeable 'Down-deriving instance Typeable 'Dual-deriving instance Typeable 'EnclosingMark-deriving instance Typeable 'Endo-deriving instance Typeable 'Exception.EOF-deriving instance Typeable 'EQ-deriving instance Typeable 'ErrorOnCodingFailure-deriving instance Typeable 'False-deriving instance Typeable 'FinalQuote-deriving instance Typeable 'First-deriving instance Typeable 'ForceSpecConstr-deriving instance Typeable 'Format-deriving instance Typeable 'GT-deriving instance Typeable 'HardwareFault-deriving instance Typeable 'HeapOverflow-deriving instance Typeable 'IgnoreCodingFailure-deriving instance Typeable 'IllegalOperation-deriving instance Typeable 'InappropriateType-deriving instance Typeable 'Data.Infix-deriving instance Typeable 'InitialQuote-deriving instance Typeable 'InputUnderflow-deriving instance Typeable 'Interrupted-deriving instance Typeable 'InvalidArgument-deriving instance Typeable 'InvalidSequence-deriving instance Typeable 'Just-deriving instance Typeable 'K1-deriving instance Typeable 'KProxy-deriving instance Typeable 'Last-deriving instance Typeable 'Left-deriving instance Typeable 'LeftAdjust-deriving instance Typeable 'LeftAssociative-deriving instance Typeable 'LetterNumber-deriving instance Typeable 'LF-deriving instance Typeable 'LineSeparator-deriving instance Typeable 'LossOfPrecision-deriving instance Typeable 'LowercaseLetter-deriving instance Typeable 'LT-deriving instance Typeable 'MaskedInterruptible-deriving instance Typeable 'MaskedUninterruptible-deriving instance Typeable 'MathSymbol-deriving instance Typeable 'ModifierLetter-deriving instance Typeable 'ModifierSymbol-deriving instance Typeable 'NestedAtomically-deriving instance Typeable 'NewlineMode-deriving instance Typeable 'NonSpacingMark-deriving instance Typeable 'NonTermination-deriving instance Typeable 'NoSpecConstr-deriving instance Typeable 'NoSuchThing-deriving instance Typeable 'NotAssigned-deriving instance Typeable 'NotAssociative-deriving instance Typeable 'Nothing-deriving instance Typeable 'O-deriving instance Typeable 'OpenPunctuation-deriving instance Typeable 'OtherError-deriving instance Typeable 'OtherLetter-deriving instance Typeable 'OtherNumber-deriving instance Typeable 'OtherPunctuation-deriving instance Typeable 'OtherSymbol-deriving instance Typeable 'OutputUnderflow-deriving instance Typeable 'Overflow-deriving instance Typeable 'Par1-deriving instance Typeable 'ParagraphSeparator-deriving instance Typeable 'PermissionDenied-deriving instance Typeable 'Data.Prefix-deriving instance Typeable 'PrivateUse-deriving instance Typeable 'Product-deriving instance Typeable 'ProtocolError-deriving instance Typeable 'RatioZeroDenominator-deriving instance Typeable 'RawDevice-deriving instance Typeable 'ReadBuffer-deriving instance Typeable 'ReadHandle-deriving instance Typeable 'ReadMode-deriving instance Typeable 'ReadWriteHandle-deriving instance Typeable 'ReadWriteMode-deriving instance Typeable 'RegularFile-deriving instance Typeable 'RelativeSeek-deriving instance Typeable 'ResourceBusy-deriving instance Typeable 'ResourceExhausted-deriving instance Typeable 'ResourceVanished-deriving instance Typeable 'Right-deriving instance Typeable 'RightAssociative-deriving instance Typeable 'RoundtripFailure-deriving instance Typeable 'SeekFromEnd-deriving instance Typeable 'SemiClosedHandle-deriving instance Typeable 'SignPlus-deriving instance Typeable 'SignSpace-deriving instance Typeable 'Space-deriving instance Typeable 'SpacingCombiningMark-deriving instance Typeable 'SPEC-deriving instance Typeable 'SPEC2-deriving instance Typeable 'StackOverflow-deriving instance Typeable 'Stream-deriving instance Typeable 'Sum-deriving instance Typeable 'Surrogate-deriving instance Typeable 'SystemError-deriving instance Typeable 'ThreadBlocked-deriving instance Typeable 'ThreadDied-deriving instance Typeable 'ThreadFinished-deriving instance Typeable 'ThreadKilled-deriving instance Typeable 'ThreadRunning-deriving instance Typeable 'TimeExpired-deriving instance Typeable 'TitlecaseLetter-deriving instance Typeable 'TransliterateCodingFailure-deriving instance Typeable 'True-deriving instance Typeable 'U1-deriving instance Typeable 'Underflow-deriving instance Typeable 'Unmasked-deriving instance Typeable 'UnsatisfiedConstraints-deriving instance Typeable 'UnsupportedOperation-deriving instance Typeable 'UppercaseLetter-deriving instance Typeable 'UserError-deriving instance Typeable 'UserInterrupt-deriving instance Typeable 'WriteBuffer-deriving instance Typeable 'WriteHandle-deriving instance Typeable 'WriteMode-deriving instance Typeable 'ZeroPad-deriving instance Typeable 'ZipList--# if defined(mingw32_HOST_OS)-deriving instance Typeable 'Break-deriving instance Typeable 'Close-deriving instance Typeable 'ControlC-deriving instance Typeable 'Logoff-deriving instance Typeable 'Shutdown-# endif-# endif-+{-# LANGUAGE DataKinds #-}+{-# LANGUAGE DeriveDataTypeable #-}+{-# LANGUAGE DeriveFoldable #-}+{-# LANGUAGE DeriveFunctor #-}+{-# LANGUAGE DeriveTraversable #-}+{-# LANGUAGE FlexibleContexts #-}+{-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE GeneralizedNewtypeDeriving #-}+{-# LANGUAGE KindSignatures #-}+{-# LANGUAGE PolyKinds #-}+{-# LANGUAGE ScopedTypeVariables #-}+{-# LANGUAGE StandaloneDeriving #-}+{-# LANGUAGE Trustworthy #-}+{-# LANGUAGE TypeFamilies #-}+{-# LANGUAGE TypeOperators #-}+{-# LANGUAGE UndecidableInstances #-}++#if __GLASGOW_HASKELL__ < 806+{-# LANGUAGE TypeInType #-}+#endif++{-# OPTIONS_GHC -Wno-deprecations #-}+{-# OPTIONS_GHC -Wno-orphans #-}+{-|+Exports orphan instances that mimic instances available in later versions of @base@.+To use them, simply @import Data.Orphans ()@.+-}+module Data.Orphans () where++#ifdef __GLASGOW_HASKELL__+# if !(MIN_VERSION_base(4,11,0))+import qualified Control.Monad.Fail as Fail (MonadFail(..))+# endif++# if !(MIN_VERSION_base(4,16,0))+import qualified Data.Functor.Product as Functor+# endif++# if !(MIN_VERSION_base(4,10,0))+import Data.Data as Data+# endif++# if !(MIN_VERSION_base(4,11,0))+import Control.Monad.ST as Strict+# endif++# if MIN_VERSION_base(4,11,0) && !(MIN_VERSION_base(4,21,0))+import GHC.Read (readField)+# endif++# if !(MIN_VERSION_base(4,12,0))+import qualified Data.Foldable as F (Foldable(..))+import qualified Data.Traversable as T (Traversable(..))+# endif++# if MIN_VERSION_base(4,15,0) && !(MIN_VERSION_base(4,16,0))+import GHC.Tuple (Solo(..))+# endif++# if !(MIN_VERSION_base(4,21,0))+import Data.Orphans.Prelude+import GHC.Generics as Generics hiding (prec)+# endif++#include "HsBaseConfig.h"++-------------------------------------------------------------------------------++# if !(MIN_VERSION_base(4,10,0))+deriving instance (Typeable k, Data a, Typeable (b :: k)) => Data (Const a b)++instance Eq1 NonEmpty where+ liftEq eq (a :| as) (b :| bs) = eq a b && liftEq eq as bs++instance Ord1 NonEmpty where+ liftCompare cmp (a :| as) (b :| bs) = cmp a b <> liftCompare cmp as bs++instance Read1 NonEmpty where+ liftReadsPrec rdP rdL p s = readParen (p > 5) (\s' -> do+ (a, s'') <- rdP 6 s'+ (":|", s''') <- lex s''+ (as, s'''') <- rdL s'''+ return (a :| as, s'''')) s++instance Show1 NonEmpty where+ liftShowsPrec shwP shwL p (a :| as) = showParen (p > 5) $+ shwP 6 a . showString " :| " . shwL as++instance Semigroup a => Semigroup (IO a) where+ (<>) = liftA2 (<>)++# if !defined(mingw32_HOST_OS) && !defined(ghcjs_HOST_OS)+instance Semigroup Event where+ (<>) = mappend+ stimes = stimesMonoid++instance Semigroup Lifetime where+ (<>) = mappend+ stimes = stimesMonoid+# endif+# endif++# if !(MIN_VERSION_base(4,11,0))+instance Alternative ZipList where+ empty = ZipList []+ ZipList xs <|> ZipList ys = ZipList (xs ++ drop (length xs) ys)++deriving instance Monoid a => Monoid (Down a)+deriving instance Num a => Num (Down a)++instance Functor Down where+ fmap = coerce++instance Applicative Down where+ pure = Down+ (<*>) = coerce++instance Monad Down where+ return = Down+ Down a >>= k = k a++instance Monoid a => Monoid (Strict.ST s a) where+ mempty = pure mempty+ mappend = liftA2 mappend++instance Fail.MonadFail (Strict.ST s) where+ fail s = errorWithoutStackTrace s++deriving instance Semigroup a => Semigroup (Down a)++instance Semigroup a => Semigroup (Strict.ST s a) where+ (<>) = liftA2 (<>)++# if MIN_VERSION_base(4,10,0)+deriving instance Data IntPtr+deriving instance Data WordPtr+# else+-- The constructors for IntPtr and WordPtr aren't exposed on older versions+-- of base, so we're forced to hand-roll the Data instances here+instance Data IntPtr where+ gfoldl k z iptr = z intPtr `k` unIntPtr iptr+ gunfold k z _ = k (z intPtr)+ toConstr !_ = cIntPtr+ dataTypeOf _ = tIntPtr++intPtr :: Int -> IntPtr+intPtr = unsafeCoerce++unIntPtr :: IntPtr -> Int+unIntPtr = unsafeCoerce++tIntPtr :: DataType+tIntPtr = mkDataType "IntPtr" [cIntPtr]++cIntPtr :: Constr+cIntPtr = mkConstr tIntPtr "IntPtr" [] Data.Prefix++instance Data WordPtr where+ gfoldl k z wptr = z wordPtr `k` unWordPtr wptr+ gunfold k z _ = k (z wordPtr)+ toConstr !_ = cWordPtr+ dataTypeOf _ = tWordPtr++wordPtr :: Word -> WordPtr+wordPtr = unsafeCoerce++unWordPtr :: WordPtr -> Word+unWordPtr = unsafeCoerce++tWordPtr :: DataType+tWordPtr = mkDataType "WordPtr" [cWordPtr]++cWordPtr :: Constr+cWordPtr = mkConstr tWordPtr "WordPtr" [] Data.Prefix+# endif+# endif++# if !(MIN_VERSION_base(4,12,0))+instance MonadFix Down where+ mfix f = Down (fix (getDown . f))+ where getDown (Down x) = x+deriving instance Data a => Data (Down a)+deriving instance F.Foldable Down+deriving instance T.Traversable Down+instance MonadZip Down where+ mzipWith = liftM2+instance Eq1 Down where+ liftEq eq (Down x) (Down y) = eq x y+instance Ord1 Down where+ liftCompare comp (Down x) (Down y) = case comp x y of+ LT -> GT+ EQ -> EQ+ GT -> LT+instance Read1 Down where+ liftReadsPrec rp _ = readsData $+ readsUnaryWith rp "Down" Down+instance Show1 Down where+ liftShowsPrec sp _ d (Down x) = showsUnaryWith sp "Down" d x++instance Monoid c => Applicative (K1 i c) where+ pure _ = K1 mempty+ (<*>) = coerce (mappend :: c -> c -> c)+# if MIN_VERSION_base(4,10,0)+ liftA2 = \_ -> coerce (mappend :: c -> c -> c)+# endif++instance Monoid (U1 p) where+ mempty = U1+# if !(MIN_VERSION_base(4,11,0))+ _ `mappend` _ = U1+# endif+deriving instance Monoid p => Monoid (Par1 p)+deriving instance Monoid (f p) => Monoid (Rec1 f p)+deriving instance Monoid c => Monoid (K1 i c p)+deriving instance Monoid (f p) => Monoid (M1 i c f p)+instance (Monoid (f p), Monoid (g p)) => Monoid ((f :*: g) p) where+ mempty = mempty :*: mempty+# if !(MIN_VERSION_base(4,11,0))+ (x1 :*: y1) `mappend` (x2 :*: y2) = (x1 `mappend` x2) :*: (y1 `mappend` y2)+# endif+deriving instance Monoid (f (g p)) => Monoid ((f :.: g) p)++instance Semigroup (V1 p) where+ v <> _ = v+instance Semigroup (U1 p) where+ _ <> _ = U1+deriving instance Semigroup p => Semigroup (Par1 p)+deriving instance Semigroup (f p) => Semigroup (Rec1 f p)+deriving instance Semigroup c => Semigroup (K1 i c p)+deriving instance Semigroup (f p) => Semigroup (M1 i c f p)+instance (Semigroup (f p), Semigroup (g p)) => Semigroup ((f :*: g) p) where+ (x1 :*: y1) <> (x2 :*: y2) = (x1 <> x2) :*: (y1 <> y2)+deriving instance Semigroup (f (g p)) => Semigroup ((f :.: g) p)++deriving instance Foldable f => Foldable (Alt f)+deriving instance Traversable f => Traversable (Alt f)+# endif++# if !(MIN_VERSION_base(4,14,0))+instance Functor ((,,) a b) where+ fmap f (a, b, c) = (a, b, f c)++instance (Monoid a, Monoid b) => Applicative ((,,) a b) where+ pure x = (mempty, mempty, x)+ (a, b, f) <*> (a', b', x) = (a `mappend` a', b `mappend` b', f x)++instance (Monoid a, Monoid b) => Monad ((,,) a b) where+ (u, v, a) >>= k =+ case k a of+ (u', v', b) ->+ (u `mappend` u', v `mappend` v', b)++instance Functor ((,,,) a b c) where+ fmap f (a, b, c, d) = (a, b, c, f d)++instance (Monoid a, Monoid b, Monoid c) => Applicative ((,,,) a b c) where+ pure x = (mempty, mempty, mempty, x)+ (a, b, c, f) <*> (a', b', c', x) =+ (a `mappend` a', b `mappend` b', c `mappend` c', f x)++instance (Monoid a, Monoid b, Monoid c) => Monad ((,,,) a b c) where+ (u, v, w, a) >>= k =+ case k a of+ (u', v', w', b) ->+ (u `mappend` u', v `mappend` v', w `mappend` w', b)++deriving instance Functor m => Functor (Kleisli m a)++instance Applicative m => Applicative (Kleisli m a) where+ pure = Kleisli . const . pure+ {-# INLINE pure #-}+ Kleisli f <*> Kleisli g = Kleisli $ \x -> f x <*> g x+ {-# INLINE (<*>) #-}+ Kleisli f *> Kleisli g = Kleisli $ \x -> f x *> g x+ {-# INLINE (*>) #-}+ Kleisli f <* Kleisli g = Kleisli $ \x -> f x <* g x+ {-# INLINE (<*) #-}++instance Alternative m => Alternative (Kleisli m a) where+ empty = Kleisli $ const empty+ {-# INLINE empty #-}+ Kleisli f <|> Kleisli g = Kleisli $ \x -> f x <|> g x+ {-# INLINE (<|>) #-}++instance Monad m => Monad (Kleisli m a) where+ Kleisli f >>= k = Kleisli $ \x -> f x >>= \a -> runKleisli (k a) x+ {-# INLINE (>>=) #-}++instance MonadPlus m => MonadPlus (Kleisli m a) where+ mzero = Kleisli $ const mzero+ {-# INLINE mzero #-}+ Kleisli f `mplus` Kleisli g = Kleisli $ \x -> f x `mplus` g x+ {-# INLINE mplus #-}++-- | Swaps @'minBound'@ and @'maxBound'@ of the underlying type.+instance Bounded a => Bounded (Down a) where+ minBound = Down maxBound+ maxBound = Down minBound++deriving instance Bits a => Bits (Down a)+deriving instance Floating a => Floating (Down a)+deriving instance Fractional a => Fractional (Down a)+deriving instance Ix a => Ix (Down a)+deriving instance Real a => Real (Down a)+deriving instance RealFrac a => RealFrac (Down a)+deriving instance RealFloat a => RealFloat (Down a)+deriving instance Storable a => Storable (Down a)+deriving instance FiniteBits a => FiniteBits (Down a)++deriving instance (Typeable2 a, Typeable b, Typeable c, Data (a b c))+ => Data (WrappedArrow a b c)+deriving instance (Typeable1 m, Typeable a, Data (m a))+ => Data (WrappedMonad m a)+deriving instance Data a => Data (ZipList a)++instance IsList (ZipList a) where+ type Item (ZipList a) = a+ fromList = ZipList+ toList = getZipList++instance (TestEquality f) => TestEquality (Compose f g) where+ testEquality (Compose x) (Compose y) =+ case testEquality x y of -- :: Maybe (g x :~: g y)+ Just Refl -> Just Refl -- :: Maybe (x :~: y)+ Nothing -> Nothing+# endif++# if !(MIN_VERSION_base(4,15,0))+instance (Ix a1, Ix a2, Ix a3, Ix a4, Ix a5, Ix a6) =>+ Ix (a1,a2,a3,a4,a5,a6) where+ range ((l1,l2,l3,l4,l5,l6),(u1,u2,u3,u4,u5,u6)) =+ [(i1,i2,i3,i4,i5,i6) | i1 <- range (l1,u1),+ i2 <- range (l2,u2),+ i3 <- range (l3,u3),+ i4 <- range (l4,u4),+ i5 <- range (l5,u5),+ i6 <- range (l6,u6)]++ unsafeIndex ((l1,l2,l3,l4,l5,l6),(u1,u2,u3,u4,u5,u6)) (i1,i2,i3,i4,i5,i6) =+ unsafeIndex (l6,u6) i6 + unsafeRangeSize (l6,u6) * (+ unsafeIndex (l5,u5) i5 + unsafeRangeSize (l5,u5) * (+ unsafeIndex (l4,u4) i4 + unsafeRangeSize (l4,u4) * (+ unsafeIndex (l3,u3) i3 + unsafeRangeSize (l3,u3) * (+ unsafeIndex (l2,u2) i2 + unsafeRangeSize (l2,u2) * (+ unsafeIndex (l1,u1) i1)))))++ inRange ((l1,l2,l3,l4,l5,l6),(u1,u2,u3,u4,u5,u6)) (i1,i2,i3,i4,i5,i6) =+ inRange (l1,u1) i1 && inRange (l2,u2) i2 &&+ inRange (l3,u3) i3 && inRange (l4,u4) i4 &&+ inRange (l5,u5) i5 && inRange (l6,u6) i6++ -- Default method for index++instance (Ix a1, Ix a2, Ix a3, Ix a4, Ix a5, Ix a6, Ix a7) =>+ Ix (a1,a2,a3,a4,a5,a6,a7) where+ range ((l1,l2,l3,l4,l5,l6,l7),(u1,u2,u3,u4,u5,u6,u7)) =+ [(i1,i2,i3,i4,i5,i6,i7) | i1 <- range (l1,u1),+ i2 <- range (l2,u2),+ i3 <- range (l3,u3),+ i4 <- range (l4,u4),+ i5 <- range (l5,u5),+ i6 <- range (l6,u6),+ i7 <- range (l7,u7)]++ unsafeIndex ((l1,l2,l3,l4,l5,l6,l7),(u1,u2,u3,u4,u5,u6,u7))+ (i1,i2,i3,i4,i5,i6,i7) =+ unsafeIndex (l7,u7) i7 + unsafeRangeSize (l7,u7) * (+ unsafeIndex (l6,u6) i6 + unsafeRangeSize (l6,u6) * (+ unsafeIndex (l5,u5) i5 + unsafeRangeSize (l5,u5) * (+ unsafeIndex (l4,u4) i4 + unsafeRangeSize (l4,u4) * (+ unsafeIndex (l3,u3) i3 + unsafeRangeSize (l3,u3) * (+ unsafeIndex (l2,u2) i2 + unsafeRangeSize (l2,u2) * (+ unsafeIndex (l1,u1) i1))))))++ inRange ((l1,l2,l3,l4,l5,l6,l7),(u1,u2,u3,u4,u5,u6,u7))+ (i1,i2,i3,i4,i5,i6,i7) =+ inRange (l1,u1) i1 && inRange (l2,u2) i2 &&+ inRange (l3,u3) i3 && inRange (l4,u4) i4 &&+ inRange (l5,u5) i5 && inRange (l6,u6) i6 &&+ inRange (l7,u7) i7++ -- Default method for index++instance (Ix a1, Ix a2, Ix a3, Ix a4, Ix a5, Ix a6, Ix a7, Ix a8) =>+ Ix (a1,a2,a3,a4,a5,a6,a7,a8) where+ range ((l1,l2,l3,l4,l5,l6,l7,l8),(u1,u2,u3,u4,u5,u6,u7,u8)) =+ [(i1,i2,i3,i4,i5,i6,i7,i8) | i1 <- range (l1,u1),+ i2 <- range (l2,u2),+ i3 <- range (l3,u3),+ i4 <- range (l4,u4),+ i5 <- range (l5,u5),+ i6 <- range (l6,u6),+ i7 <- range (l7,u7),+ i8 <- range (l8,u8)]++ unsafeIndex ((l1,l2,l3,l4,l5,l6,l7,l8),(u1,u2,u3,u4,u5,u6,u7,u8))+ (i1,i2,i3,i4,i5,i6,i7,i8) =+ unsafeIndex (l8,u8) i8 + unsafeRangeSize (l8,u8) * (+ unsafeIndex (l7,u7) i7 + unsafeRangeSize (l7,u7) * (+ unsafeIndex (l6,u6) i6 + unsafeRangeSize (l6,u6) * (+ unsafeIndex (l5,u5) i5 + unsafeRangeSize (l5,u5) * (+ unsafeIndex (l4,u4) i4 + unsafeRangeSize (l4,u4) * (+ unsafeIndex (l3,u3) i3 + unsafeRangeSize (l3,u3) * (+ unsafeIndex (l2,u2) i2 + unsafeRangeSize (l2,u2) * (+ unsafeIndex (l1,u1) i1)))))))++ inRange ((l1,l2,l3,l4,l5,l6,l7,l8),(u1,u2,u3,u4,u5,u6,u7,u8))+ (i1,i2,i3,i4,i5,i6,i7,i8) =+ inRange (l1,u1) i1 && inRange (l2,u2) i2 &&+ inRange (l3,u3) i3 && inRange (l4,u4) i4 &&+ inRange (l5,u5) i5 && inRange (l6,u6) i6 &&+ inRange (l7,u7) i7 && inRange (l8,u8) i8++ -- Default method for index++instance (Ix a1, Ix a2, Ix a3, Ix a4, Ix a5, Ix a6, Ix a7, Ix a8, Ix a9) =>+ Ix (a1,a2,a3,a4,a5,a6,a7,a8,a9) where+ range ((l1,l2,l3,l4,l5,l6,l7,l8,l9),(u1,u2,u3,u4,u5,u6,u7,u8,u9)) =+ [(i1,i2,i3,i4,i5,i6,i7,i8,i9) | i1 <- range (l1,u1),+ i2 <- range (l2,u2),+ i3 <- range (l3,u3),+ i4 <- range (l4,u4),+ i5 <- range (l5,u5),+ i6 <- range (l6,u6),+ i7 <- range (l7,u7),+ i8 <- range (l8,u8),+ i9 <- range (l9,u9)]++ unsafeIndex ((l1,l2,l3,l4,l5,l6,l7,l8,l9),(u1,u2,u3,u4,u5,u6,u7,u8,u9))+ (i1,i2,i3,i4,i5,i6,i7,i8,i9) =+ unsafeIndex (l9,u9) i9 + unsafeRangeSize (l9,u9) * (+ unsafeIndex (l8,u8) i8 + unsafeRangeSize (l8,u8) * (+ unsafeIndex (l7,u7) i7 + unsafeRangeSize (l7,u7) * (+ unsafeIndex (l6,u6) i6 + unsafeRangeSize (l6,u6) * (+ unsafeIndex (l5,u5) i5 + unsafeRangeSize (l5,u5) * (+ unsafeIndex (l4,u4) i4 + unsafeRangeSize (l4,u4) * (+ unsafeIndex (l3,u3) i3 + unsafeRangeSize (l3,u3) * (+ unsafeIndex (l2,u2) i2 + unsafeRangeSize (l2,u2) * (+ unsafeIndex (l1,u1) i1))))))))++ inRange ((l1,l2,l3,l4,l5,l6,l7,l8,l9),(u1,u2,u3,u4,u5,u6,u7,u8,u9))+ (i1,i2,i3,i4,i5,i6,i7,i8,i9) =+ inRange (l1,u1) i1 && inRange (l2,u2) i2 &&+ inRange (l3,u3) i3 && inRange (l4,u4) i4 &&+ inRange (l5,u5) i5 && inRange (l6,u6) i6 &&+ inRange (l7,u7) i7 && inRange (l8,u8) i8 &&+ inRange (l9,u9) i9++ -- Default method for index++instance (Ix a1, Ix a2, Ix a3, Ix a4, Ix a5, Ix a6, Ix a7, Ix a8, Ix a9,+ Ix aA) =>+ Ix (a1,a2,a3,a4,a5,a6,a7,a8,a9,aA) where+ range ((l1,l2,l3,l4,l5,l6,l7,l8,l9,lA),(u1,u2,u3,u4,u5,u6,u7,u8,u9,uA)) =+ [(i1,i2,i3,i4,i5,i6,i7,i8,i9,iA) | i1 <- range (l1,u1),+ i2 <- range (l2,u2),+ i3 <- range (l3,u3),+ i4 <- range (l4,u4),+ i5 <- range (l5,u5),+ i6 <- range (l6,u6),+ i7 <- range (l7,u7),+ i8 <- range (l8,u8),+ i9 <- range (l9,u9),+ iA <- range (lA,uA)]++ unsafeIndex ((l1,l2,l3,l4,l5,l6,l7,l8,l9,lA),+ (u1,u2,u3,u4,u5,u6,u7,u8,u9,uA))+ (i1,i2,i3,i4,i5,i6,i7,i8,i9,iA) =+ unsafeIndex (lA,uA) iA + unsafeRangeSize (lA,uA) * (+ unsafeIndex (l9,u9) i9 + unsafeRangeSize (l9,u9) * (+ unsafeIndex (l8,u8) i8 + unsafeRangeSize (l8,u8) * (+ unsafeIndex (l7,u7) i7 + unsafeRangeSize (l7,u7) * (+ unsafeIndex (l6,u6) i6 + unsafeRangeSize (l6,u6) * (+ unsafeIndex (l5,u5) i5 + unsafeRangeSize (l5,u5) * (+ unsafeIndex (l4,u4) i4 + unsafeRangeSize (l4,u4) * (+ unsafeIndex (l3,u3) i3 + unsafeRangeSize (l3,u3) * (+ unsafeIndex (l2,u2) i2 + unsafeRangeSize (l2,u2) * (+ unsafeIndex (l1,u1) i1)))))))))++ inRange ((l1,l2,l3,l4,l5,l6,l7,l8,l9,lA),(u1,u2,u3,u4,u5,u6,u7,u8,u9,uA))+ (i1,i2,i3,i4,i5,i6,i7,i8,i9,iA) =+ inRange (l1,u1) i1 && inRange (l2,u2) i2 &&+ inRange (l3,u3) i3 && inRange (l4,u4) i4 &&+ inRange (l5,u5) i5 && inRange (l6,u6) i6 &&+ inRange (l7,u7) i7 && inRange (l8,u8) i8 &&+ inRange (l9,u9) i9 && inRange (lA,uA) iA++ -- Default method for index++instance (Ix a1, Ix a2, Ix a3, Ix a4, Ix a5, Ix a6, Ix a7, Ix a8, Ix a9,+ Ix aA, Ix aB) =>+ Ix (a1,a2,a3,a4,a5,a6,a7,a8,a9,aA,aB) where+ range ((l1,l2,l3,l4,l5,l6,l7,l8,l9,lA,lB),+ (u1,u2,u3,u4,u5,u6,u7,u8,u9,uA,uB)) =+ [(i1,i2,i3,i4,i5,i6,i7,i8,i9,iA,iB) | i1 <- range (l1,u1),+ i2 <- range (l2,u2),+ i3 <- range (l3,u3),+ i4 <- range (l4,u4),+ i5 <- range (l5,u5),+ i6 <- range (l6,u6),+ i7 <- range (l7,u7),+ i8 <- range (l8,u8),+ i9 <- range (l9,u9),+ iA <- range (lA,uA),+ iB <- range (lB,uB)]++ unsafeIndex ((l1,l2,l3,l4,l5,l6,l7,l8,l9,lA,lB),+ (u1,u2,u3,u4,u5,u6,u7,u8,u9,uA,uB))+ (i1,i2,i3,i4,i5,i6,i7,i8,i9,iA,iB) =+ unsafeIndex (lB,uB) iB + unsafeRangeSize (lB,uB) * (+ unsafeIndex (lA,uA) iA + unsafeRangeSize (lA,uA) * (+ unsafeIndex (l9,u9) i9 + unsafeRangeSize (l9,u9) * (+ unsafeIndex (l8,u8) i8 + unsafeRangeSize (l8,u8) * (+ unsafeIndex (l7,u7) i7 + unsafeRangeSize (l7,u7) * (+ unsafeIndex (l6,u6) i6 + unsafeRangeSize (l6,u6) * (+ unsafeIndex (l5,u5) i5 + unsafeRangeSize (l5,u5) * (+ unsafeIndex (l4,u4) i4 + unsafeRangeSize (l4,u4) * (+ unsafeIndex (l3,u3) i3 + unsafeRangeSize (l3,u3) * (+ unsafeIndex (l2,u2) i2 + unsafeRangeSize (l2,u2) * (+ unsafeIndex (l1,u1) i1))))))))))++ inRange ((l1,l2,l3,l4,l5,l6,l7,l8,l9,lA,lB),+ (u1,u2,u3,u4,u5,u6,u7,u8,u9,uA,uB))+ (i1,i2,i3,i4,i5,i6,i7,i8,i9,iA,iB) =+ inRange (l1,u1) i1 && inRange (l2,u2) i2 &&+ inRange (l3,u3) i3 && inRange (l4,u4) i4 &&+ inRange (l5,u5) i5 && inRange (l6,u6) i6 &&+ inRange (l7,u7) i7 && inRange (l8,u8) i8 &&+ inRange (l9,u9) i9 && inRange (lA,uA) iA &&+ inRange (lB,uB) iB++ -- Default method for index++instance (Ix a1, Ix a2, Ix a3, Ix a4, Ix a5, Ix a6, Ix a7, Ix a8, Ix a9,+ Ix aA, Ix aB, Ix aC) =>+ Ix (a1,a2,a3,a4,a5,a6,a7,a8,a9,aA,aB,aC) where+ range ((l1,l2,l3,l4,l5,l6,l7,l8,l9,lA,lB,lC),+ (u1,u2,u3,u4,u5,u6,u7,u8,u9,uA,uB,uC)) =+ [(i1,i2,i3,i4,i5,i6,i7,i8,i9,iA,iB,iC) | i1 <- range (l1,u1),+ i2 <- range (l2,u2),+ i3 <- range (l3,u3),+ i4 <- range (l4,u4),+ i5 <- range (l5,u5),+ i6 <- range (l6,u6),+ i7 <- range (l7,u7),+ i8 <- range (l8,u8),+ i9 <- range (l9,u9),+ iA <- range (lA,uA),+ iB <- range (lB,uB),+ iC <- range (lC,uC)]++ unsafeIndex ((l1,l2,l3,l4,l5,l6,l7,l8,l9,lA,lB,lC),+ (u1,u2,u3,u4,u5,u6,u7,u8,u9,uA,uB,uC))+ (i1,i2,i3,i4,i5,i6,i7,i8,i9,iA,iB,iC) =+ unsafeIndex (lC,uC) iC + unsafeRangeSize (lC,uC) * (+ unsafeIndex (lB,uB) iB + unsafeRangeSize (lB,uB) * (+ unsafeIndex (lA,uA) iA + unsafeRangeSize (lA,uA) * (+ unsafeIndex (l9,u9) i9 + unsafeRangeSize (l9,u9) * (+ unsafeIndex (l8,u8) i8 + unsafeRangeSize (l8,u8) * (+ unsafeIndex (l7,u7) i7 + unsafeRangeSize (l7,u7) * (+ unsafeIndex (l6,u6) i6 + unsafeRangeSize (l6,u6) * (+ unsafeIndex (l5,u5) i5 + unsafeRangeSize (l5,u5) * (+ unsafeIndex (l4,u4) i4 + unsafeRangeSize (l4,u4) * (+ unsafeIndex (l3,u3) i3 + unsafeRangeSize (l3,u3) * (+ unsafeIndex (l2,u2) i2 + unsafeRangeSize (l2,u2) * (+ unsafeIndex (l1,u1) i1)))))))))))++ inRange ((l1,l2,l3,l4,l5,l6,l7,l8,l9,lA,lB,lC),+ (u1,u2,u3,u4,u5,u6,u7,u8,u9,uA,uB,uC))+ (i1,i2,i3,i4,i5,i6,i7,i8,i9,iA,iB,iC) =+ inRange (l1,u1) i1 && inRange (l2,u2) i2 &&+ inRange (l3,u3) i3 && inRange (l4,u4) i4 &&+ inRange (l5,u5) i5 && inRange (l6,u6) i6 &&+ inRange (l7,u7) i7 && inRange (l8,u8) i8 &&+ inRange (l9,u9) i9 && inRange (lA,uA) iA &&+ inRange (lB,uB) iB && inRange (lC,uC) iC++ -- Default method for index++instance (Ix a1, Ix a2, Ix a3, Ix a4, Ix a5, Ix a6, Ix a7, Ix a8, Ix a9,+ Ix aA, Ix aB, Ix aC, Ix aD) =>+ Ix (a1,a2,a3,a4,a5,a6,a7,a8,a9,aA,aB,aC,aD) where+ range ((l1,l2,l3,l4,l5,l6,l7,l8,l9,lA,lB,lC,lD),+ (u1,u2,u3,u4,u5,u6,u7,u8,u9,uA,uB,uC,uD)) =+ [(i1,i2,i3,i4,i5,i6,i7,i8,i9,iA,iB,iC,iD) | i1 <- range (l1,u1),+ i2 <- range (l2,u2),+ i3 <- range (l3,u3),+ i4 <- range (l4,u4),+ i5 <- range (l5,u5),+ i6 <- range (l6,u6),+ i7 <- range (l7,u7),+ i8 <- range (l8,u8),+ i9 <- range (l9,u9),+ iA <- range (lA,uA),+ iB <- range (lB,uB),+ iC <- range (lC,uC),+ iD <- range (lD,uD)]++ unsafeIndex ((l1,l2,l3,l4,l5,l6,l7,l8,l9,lA,lB,lC,lD),+ (u1,u2,u3,u4,u5,u6,u7,u8,u9,uA,uB,uC,uD))+ (i1,i2,i3,i4,i5,i6,i7,i8,i9,iA,iB,iC,iD) =+ unsafeIndex (lD,uD) iD + unsafeRangeSize (lD,uD) * (+ unsafeIndex (lC,uC) iC + unsafeRangeSize (lC,uC) * (+ unsafeIndex (lB,uB) iB + unsafeRangeSize (lB,uB) * (+ unsafeIndex (lA,uA) iA + unsafeRangeSize (lA,uA) * (+ unsafeIndex (l9,u9) i9 + unsafeRangeSize (l9,u9) * (+ unsafeIndex (l8,u8) i8 + unsafeRangeSize (l8,u8) * (+ unsafeIndex (l7,u7) i7 + unsafeRangeSize (l7,u7) * (+ unsafeIndex (l6,u6) i6 + unsafeRangeSize (l6,u6) * (+ unsafeIndex (l5,u5) i5 + unsafeRangeSize (l5,u5) * (+ unsafeIndex (l4,u4) i4 + unsafeRangeSize (l4,u4) * (+ unsafeIndex (l3,u3) i3 + unsafeRangeSize (l3,u3) * (+ unsafeIndex (l2,u2) i2 + unsafeRangeSize (l2,u2) * (+ unsafeIndex (l1,u1) i1))))))))))))++ inRange ((l1,l2,l3,l4,l5,l6,l7,l8,l9,lA,lB,lC,lD),+ (u1,u2,u3,u4,u5,u6,u7,u8,u9,uA,uB,uC,uD))+ (i1,i2,i3,i4,i5,i6,i7,i8,i9,iA,iB,iC,iD) =+ inRange (l1,u1) i1 && inRange (l2,u2) i2 &&+ inRange (l3,u3) i3 && inRange (l4,u4) i4 &&+ inRange (l5,u5) i5 && inRange (l6,u6) i6 &&+ inRange (l7,u7) i7 && inRange (l8,u8) i8 &&+ inRange (l9,u9) i9 && inRange (lA,uA) iA &&+ inRange (lB,uB) iB && inRange (lC,uC) iC &&+ inRange (lD,uD) iD++ -- Default method for index++instance (Ix a1, Ix a2, Ix a3, Ix a4, Ix a5, Ix a6, Ix a7, Ix a8, Ix a9,+ Ix aA, Ix aB, Ix aC, Ix aD, Ix aE) =>+ Ix (a1,a2,a3,a4,a5,a6,a7,a8,a9,aA,aB,aC,aD,aE) where+ range ((l1,l2,l3,l4,l5,l6,l7,l8,l9,lA,lB,lC,lD,lE),+ (u1,u2,u3,u4,u5,u6,u7,u8,u9,uA,uB,uC,uD,uE)) =+ [(i1,i2,i3,i4,i5,i6,i7,i8,i9,iA,iB,iC,iD,iE) | i1 <- range (l1,u1),+ i2 <- range (l2,u2),+ i3 <- range (l3,u3),+ i4 <- range (l4,u4),+ i5 <- range (l5,u5),+ i6 <- range (l6,u6),+ i7 <- range (l7,u7),+ i8 <- range (l8,u8),+ i9 <- range (l9,u9),+ iA <- range (lA,uA),+ iB <- range (lB,uB),+ iC <- range (lC,uC),+ iD <- range (lD,uD),+ iE <- range (lE,uE)]++ unsafeIndex ((l1,l2,l3,l4,l5,l6,l7,l8,l9,lA,lB,lC,lD,lE),+ (u1,u2,u3,u4,u5,u6,u7,u8,u9,uA,uB,uC,uD,uE))+ (i1,i2,i3,i4,i5,i6,i7,i8,i9,iA,iB,iC,iD,iE) =+ unsafeIndex (lE,uE) iE + unsafeRangeSize (lE,uE) * (+ unsafeIndex (lD,uD) iD + unsafeRangeSize (lD,uD) * (+ unsafeIndex (lC,uC) iC + unsafeRangeSize (lC,uC) * (+ unsafeIndex (lB,uB) iB + unsafeRangeSize (lB,uB) * (+ unsafeIndex (lA,uA) iA + unsafeRangeSize (lA,uA) * (+ unsafeIndex (l9,u9) i9 + unsafeRangeSize (l9,u9) * (+ unsafeIndex (l8,u8) i8 + unsafeRangeSize (l8,u8) * (+ unsafeIndex (l7,u7) i7 + unsafeRangeSize (l7,u7) * (+ unsafeIndex (l6,u6) i6 + unsafeRangeSize (l6,u6) * (+ unsafeIndex (l5,u5) i5 + unsafeRangeSize (l5,u5) * (+ unsafeIndex (l4,u4) i4 + unsafeRangeSize (l4,u4) * (+ unsafeIndex (l3,u3) i3 + unsafeRangeSize (l3,u3) * (+ unsafeIndex (l2,u2) i2 + unsafeRangeSize (l2,u2) * (+ unsafeIndex (l1,u1) i1)))))))))))))++ inRange ((l1,l2,l3,l4,l5,l6,l7,l8,l9,lA,lB,lC,lD,lE),+ (u1,u2,u3,u4,u5,u6,u7,u8,u9,uA,uB,uC,uD,uE))+ (i1,i2,i3,i4,i5,i6,i7,i8,i9,iA,iB,iC,iD,iE) =+ inRange (l1,u1) i1 && inRange (l2,u2) i2 &&+ inRange (l3,u3) i3 && inRange (l4,u4) i4 &&+ inRange (l5,u5) i5 && inRange (l6,u6) i6 &&+ inRange (l7,u7) i7 && inRange (l8,u8) i8 &&+ inRange (l9,u9) i9 && inRange (lA,uA) iA &&+ inRange (lB,uB) iB && inRange (lC,uC) iC &&+ inRange (lD,uD) iD && inRange (lE,uE) iE++ -- Default method for index++instance (Ix a1, Ix a2, Ix a3, Ix a4, Ix a5, Ix a6, Ix a7, Ix a8, Ix a9,+ Ix aA, Ix aB, Ix aC, Ix aD, Ix aE, Ix aF) =>+ Ix (a1,a2,a3,a4,a5,a6,a7,a8,a9,aA,aB,aC,aD,aE,aF) where+ range ((l1,l2,l3,l4,l5,l6,l7,l8,l9,lA,lB,lC,lD,lE,lF),+ (u1,u2,u3,u4,u5,u6,u7,u8,u9,uA,uB,uC,uD,uE,uF)) =+ [(i1,i2,i3,i4,i5,i6,i7,i8,i9,iA,iB,iC,iD,iE,iF) | i1 <- range (l1,u1),+ i2 <- range (l2,u2),+ i3 <- range (l3,u3),+ i4 <- range (l4,u4),+ i5 <- range (l5,u5),+ i6 <- range (l6,u6),+ i7 <- range (l7,u7),+ i8 <- range (l8,u8),+ i9 <- range (l9,u9),+ iA <- range (lA,uA),+ iB <- range (lB,uB),+ iC <- range (lC,uC),+ iD <- range (lD,uD),+ iE <- range (lE,uE),+ iF <- range (lF,uF)]++ unsafeIndex ((l1,l2,l3,l4,l5,l6,l7,l8,l9,lA,lB,lC,lD,lE,lF),+ (u1,u2,u3,u4,u5,u6,u7,u8,u9,uA,uB,uC,uD,uE,uF))+ (i1,i2,i3,i4,i5,i6,i7,i8,i9,iA,iB,iC,iD,iE,iF) =+ unsafeIndex (lF,uF) iF + unsafeRangeSize (lF,uF) * (+ unsafeIndex (lE,uE) iE + unsafeRangeSize (lE,uE) * (+ unsafeIndex (lD,uD) iD + unsafeRangeSize (lD,uD) * (+ unsafeIndex (lC,uC) iC + unsafeRangeSize (lC,uC) * (+ unsafeIndex (lB,uB) iB + unsafeRangeSize (lB,uB) * (+ unsafeIndex (lA,uA) iA + unsafeRangeSize (lA,uA) * (+ unsafeIndex (l9,u9) i9 + unsafeRangeSize (l9,u9) * (+ unsafeIndex (l8,u8) i8 + unsafeRangeSize (l8,u8) * (+ unsafeIndex (l7,u7) i7 + unsafeRangeSize (l7,u7) * (+ unsafeIndex (l6,u6) i6 + unsafeRangeSize (l6,u6) * (+ unsafeIndex (l5,u5) i5 + unsafeRangeSize (l5,u5) * (+ unsafeIndex (l4,u4) i4 + unsafeRangeSize (l4,u4) * (+ unsafeIndex (l3,u3) i3 + unsafeRangeSize (l3,u3) * (+ unsafeIndex (l2,u2) i2 + unsafeRangeSize (l2,u2) * (+ unsafeIndex (l1,u1) i1))))))))))))))++ inRange ((l1,l2,l3,l4,l5,l6,l7,l8,l9,lA,lB,lC,lD,lE,lF),+ (u1,u2,u3,u4,u5,u6,u7,u8,u9,uA,uB,uC,uD,uE,uF))+ (i1,i2,i3,i4,i5,i6,i7,i8,i9,iA,iB,iC,iD,iE,iF) =+ inRange (l1,u1) i1 && inRange (l2,u2) i2 &&+ inRange (l3,u3) i3 && inRange (l4,u4) i4 &&+ inRange (l5,u5) i5 && inRange (l6,u6) i6 &&+ inRange (l7,u7) i7 && inRange (l8,u8) i8 &&+ inRange (l9,u9) i9 && inRange (lA,uA) iA &&+ inRange (lB,uB) iB && inRange (lC,uC) iC &&+ inRange (lD,uD) iD && inRange (lE,uE) iE &&+ inRange (lF,uF) iF++ -- Default method for index++instance MonadZip Complex where+ mzipWith = liftA2++instance MonadFix Complex where+ mfix f = (let a :+ _ = f a in a) :+ (let _ :+ a = f a in a)+# endif++# if !(MIN_VERSION_base(4,16,0))+instance Eq1 Complex where+ liftEq eq (x :+ y) (u :+ v) = eq x u && eq y v++instance Read1 Complex where+# if MIN_VERSION_base(4,10,0)+ liftReadPrec rp _ = parens $ prec complexPrec $ do+ x <- step rp+ expectP (Symbol ":+")+ y <- step rp+ return (x :+ y)+ where+ complexPrec = 6++ liftReadListPrec = liftReadListPrecDefault+ liftReadList = liftReadListDefault+# else+ liftReadsPrec rdP _ p s = readParen (p > complexPrec) (\s' -> do+ (x, s'') <- rdP (complexPrec+1) s'+ (":+", s''') <- lex s''+ (y, s'''') <- rdP (complexPrec+1) s'''+ return (x :+ y, s'''')) s+ where+ complexPrec = 6+# endif++instance Show1 Complex where+ liftShowsPrec sp _ d (x :+ y) = showParen (d > complexPrec) $+ sp (complexPrec+1) x . showString " :+ " . sp (complexPrec+1) y+ where+ complexPrec = 6++instance Eq a => Eq2 ((,,) a) where+ liftEq2 e1 e2 (u1, x1, y1) (v1, x2, y2) =+ u1 == v1 &&+ e1 x1 x2 && e2 y1 y2++instance Ord a => Ord2 ((,,) a) where+ liftCompare2 comp1 comp2 (u1, x1, y1) (v1, x2, y2) =+ compare u1 v1 `mappend`+ comp1 x1 x2 `mappend` comp2 y1 y2++instance Read a => Read2 ((,,) a) where+# if MIN_VERSION_base(4,10,0)+ liftReadPrec2 rp1 _ rp2 _ = parens $ paren $ do+ x1 <- readPrec+ expectP (Punc ",")+ y1 <- rp1+ expectP (Punc ",")+ y2 <- rp2+ return (x1,y1,y2)++ liftReadListPrec2 = liftReadListPrec2Default+ liftReadList2 = liftReadList2Default+# else+ liftReadsPrec2 rp1 _ rp2 _ _ = readParen False $ \ r ->+ [((e1,e2,e3), y) | ("(",s) <- lex r,+ (e1,t) <- readsPrec 0 s,+ (",",u) <- lex t,+ (e2,v) <- rp1 0 u,+ (",",w) <- lex v,+ (e3,x) <- rp2 0 w,+ (")",y) <- lex x]+# endif++instance Show a => Show2 ((,,) a) where+ liftShowsPrec2 sp1 _ sp2 _ _ (x1,y1,y2)+ = showChar '(' . showsPrec 0 x1+ . showChar ',' . sp1 0 y1+ . showChar ',' . sp2 0 y2+ . showChar ')'++instance (Eq a, Eq b) => Eq1 ((,,) a b) where+ liftEq = liftEq2 (==)++instance (Ord a, Ord b) => Ord1 ((,,) a b) where+ liftCompare = liftCompare2 compare++instance (Read a, Read b) => Read1 ((,,) a b) where+# if MIN_VERSION_base(4,10,0)+ liftReadPrec = liftReadPrec2 readPrec readListPrec++ liftReadListPrec = liftReadListPrecDefault+ liftReadList = liftReadListDefault+# else+ liftReadsPrec = liftReadsPrec2 readsPrec readList+# endif++instance (Show a, Show b) => Show1 ((,,) a b) where+ liftShowsPrec = liftShowsPrec2 showsPrec showList++instance (Eq a, Eq b) => Eq2 ((,,,) a b) where+ liftEq2 e1 e2 (u1, u2, x1, y1) (v1, v2, x2, y2) =+ u1 == v1 &&+ u2 == v2 &&+ e1 x1 x2 && e2 y1 y2++instance (Ord a, Ord b) => Ord2 ((,,,) a b) where+ liftCompare2 comp1 comp2 (u1, u2, x1, y1) (v1, v2, x2, y2) =+ compare u1 v1 `mappend`+ compare u2 v2 `mappend`+ comp1 x1 x2 `mappend` comp2 y1 y2++instance (Read a, Read b) => Read2 ((,,,) a b) where+# if MIN_VERSION_base(4,10,0)+ liftReadPrec2 rp1 _ rp2 _ = parens $ paren $ do+ x1 <- readPrec+ expectP (Punc ",")+ x2 <- readPrec+ expectP (Punc ",")+ y1 <- rp1+ expectP (Punc ",")+ y2 <- rp2+ return (x1,x2,y1,y2)++ liftReadListPrec2 = liftReadListPrec2Default+ liftReadList2 = liftReadList2Default+# else+ liftReadsPrec2 rp1 _ rp2 _ _ = readParen False $ \ r ->+ [((e1,e2,e3,e4), s9) | ("(",s1) <- lex r,+ (e1,s2) <- readsPrec 0 s1,+ (",",s3) <- lex s2,+ (e2,s4) <- readsPrec 0 s3,+ (",",s5) <- lex s4,+ (e3,s6) <- rp1 0 s5,+ (",",s7) <- lex s6,+ (e4,s8) <- rp2 0 s7,+ (")",s9) <- lex s8]+# endif++instance (Show a, Show b) => Show2 ((,,,) a b) where+ liftShowsPrec2 sp1 _ sp2 _ _ (x1,x2,y1,y2)+ = showChar '(' . showsPrec 0 x1+ . showChar ',' . showsPrec 0 x2+ . showChar ',' . sp1 0 y1+ . showChar ',' . sp2 0 y2+ . showChar ')'++instance (Eq a, Eq b, Eq c) => Eq1 ((,,,) a b c) where+ liftEq = liftEq2 (==)++instance (Ord a, Ord b, Ord c) => Ord1 ((,,,) a b c) where+ liftCompare = liftCompare2 compare++instance (Read a, Read b, Read c) => Read1 ((,,,) a b c) where+# if MIN_VERSION_base(4,10,0)+ liftReadPrec = liftReadPrec2 readPrec readListPrec++ liftReadListPrec = liftReadListPrecDefault+ liftReadList = liftReadListDefault+# else+ liftReadsPrec = liftReadsPrec2 readsPrec readList+# endif++instance (Show a, Show b, Show c) => Show1 ((,,,) a b c) where+ liftShowsPrec = liftShowsPrec2 showsPrec showList++deriving instance Semigroup (f (g a)) => Semigroup (Compose f g a)+deriving instance Monoid (f (g a)) => Monoid (Compose f g a)++instance (Semigroup (f a), Semigroup (g a)) => Semigroup (Functor.Product f g a) where+ Functor.Pair x1 y1 <> Functor.Pair x2 y2 = Functor.Pair (x1 <> x2) (y1 <> y2)++instance (Monoid (f a), Monoid (g a)) => Monoid (Functor.Product f g a) where+ mempty = Functor.Pair mempty mempty+# if !(MIN_VERSION_base(4,11,0))+ Functor.Pair x1 y1 `mappend` Functor.Pair x2 y2 = Functor.Pair (x1 `mappend` x2) (y1 `mappend` y2)+# endif++# if MIN_VERSION_base(4,15,0)+instance Enum a => Enum (Solo a) where+ succ (Solo a) = Solo (succ a)+ pred (Solo a) = Solo (pred a)++ toEnum x = Solo (toEnum x)++ fromEnum (Solo x) = fromEnum x+ enumFrom (Solo x) = [Solo a | a <- enumFrom x]+ enumFromThen (Solo x) (Solo y) =+ [Solo a | a <- enumFromThen x y]+ enumFromTo (Solo x) (Solo y) =+ [Solo a | a <- enumFromTo x y]+ enumFromThenTo (Solo x) (Solo y) (Solo z) =+ [Solo a | a <- enumFromThenTo x y z]++deriving instance Eq a => Eq (Solo a)+deriving instance Ord a => Ord (Solo a)+deriving instance Bounded a => Bounded (Solo a)++instance Ix a => Ix (Solo a) where -- as derived+ {-# SPECIALISE instance Ix (Solo Int) #-}++ {-# INLINE range #-}+ range (Solo l, Solo u) =+ [ Solo i | i <- range (l,u) ]++ {-# INLINE unsafeIndex #-}+ unsafeIndex (Solo l, Solo u) (Solo i) =+ unsafeIndex (l,u) i++ {-# INLINE inRange #-}+ inRange (Solo l, Solo u) (Solo i) =+ inRange (l, u) i++ -- Default method for index+# endif+# endif++# if !(MIN_VERSION_base(4,16,1))+deriving instance Ix CChar+deriving instance Ix CSChar+deriving instance Ix CUChar+deriving instance Ix CShort+deriving instance Ix CUShort+deriving instance Ix CInt+deriving instance Ix CUInt+deriving instance Ix CLong+deriving instance Ix CULong+deriving instance Ix CLLong+deriving instance Ix CULLong+deriving instance Ix CPtrdiff+deriving instance Ix CSize+deriving instance Ix CWchar+deriving instance Ix CSigAtomic+deriving instance Ix CIntPtr+deriving instance Ix CUIntPtr+deriving instance Ix CIntMax+deriving instance Ix CUIntMax+# if MIN_VERSION_base(4,10,0)+deriving instance Ix CBool+# endif++# if MIN_VERSION_base(4,10,0)+-- These are guarded on base-4.10.0 because that was the first version which+-- exported their constructors, which is necessary to use+-- GeneralizedNewtypeDeriving. See+-- https://gitlab.haskell.org/ghc/ghc/-/issues/11983.+deriving instance Ix WordPtr+deriving instance Ix IntPtr+# endif++# if defined(HTYPE_DEV_T)+deriving instance Ix CDev+# endif+# if defined(HTYPE_INO_T)+deriving instance Ix CIno+# endif+# if defined(HTYPE_MODE_T)+deriving instance Ix CMode+# endif+# if defined(HTYPE_OFF_T)+deriving instance Ix COff+# endif+# if defined(HTYPE_PID_T)+deriving instance Ix CPid+# endif+# if defined(HTYPE_SSIZE_T)+deriving instance Ix CSsize+# endif+# if defined(HTYPE_GID_T)+deriving instance Ix CGid+# endif+# if defined(HTYPE_NLINK_T)+deriving instance Ix CNlink+# endif+# if defined(HTYPE_UID_T)+deriving instance Ix CUid+# endif+# if defined(HTYPE_CC_T)+deriving instance Ix CCc+# endif+# if defined(HTYPE_SPEED_T)+deriving instance Ix CSpeed+# endif+# if defined(HTYPE_TCFLAG_T)+deriving instance Ix CTcflag+# endif+# if defined(HTYPE_RLIM_T)+deriving instance Ix CRLim+# endif+deriving instance Ix Fd++# if MIN_VERSION_base(4,10,0)+# if defined(HTYPE_BLKSIZE_T)+deriving instance Ix CBlkSize+# endif+# if defined(HTYPE_BLKCNT_T)+deriving instance Ix CBlkCnt+# endif+# if defined(HTYPE_CLOCKID_T)+deriving instance Ix CClockId+# endif+# if defined(HTYPE_FSBLKCNT_T)+deriving instance Ix CFsBlkCnt+# endif+# if defined(HTYPE_FSFILCNT_T)+deriving instance Ix CFsFilCnt+# endif+# if defined(HTYPE_ID_T)+deriving instance Ix CId+# endif+# if defined(HTYPE_KEY_T)+deriving instance Ix CKey+# endif+# if defined(HTYPE_SOCKLEN_T)+deriving instance Ix CSocklen+# endif+# if defined(HTYPE_NFDS_T)+deriving instance Ix CNfds+# endif+# endif+# endif++# if !(MIN_VERSION_base(4,18,0))+instance Functor ((,,,,) a b c d) where+ fmap f (a, b, c, d, e) = (a, b, c, d, f e)+instance Functor ((,,,,,) a b c d e) where+ fmap fun (a, b, c, d, e, f) = (a, b, c, d, e, fun f)+instance Functor ((,,,,,,) a b c d e f) where+ fmap fun (a, b, c, d, e, f, g) = (a, b, c, d, e, f, fun g)++# if !(MIN_VERSION_base(4,14,0)) || MIN_VERSION_base(4,15,0)+-- | Swaps @'succ'@ and @'pred'@ of the underlying type.+instance (Enum a, Bounded a, Eq a) => Enum (Down a) where+ succ = fmap pred+ pred = fmap succ++ -- Here we use the fact that 'comparing (complement @Int)' behaves+ -- as an order-swapping `compare @Int`.+ fromEnum (Down x) = complement $ fromEnum x+ toEnum = Down . toEnum . complement++ enumFrom (Down x)+ | x == minBound+ = [Down x] -- We can't rely on 'enumFromThen _ (pred @a minBound)` behaving nicely,+ -- since 'enumFromThen _' might be strict and 'pred minBound' might throw+ | otherwise+ = coerce $ enumFromThen x (pred x)+ enumFromThen (Down x) (Down y) = coerce $ enumFromThen x y+# endif++# if MIN_VERSION_base(4,17,0)+instance (Generic1 f, Eq (Rep1 f a)) => Eq (Generically1 f a) where+ Generically1 x == Generically1 y = from1 x == from1 y+ Generically1 x /= Generically1 y = from1 x /= from1 y++instance (Generic1 f, Ord (Rep1 f a)) => Ord (Generically1 f a) where+ Generically1 x `compare` Generically1 y = from1 x `compare` from1 y+# endif+# endif++# if !(MIN_VERSION_base(4,19,0))+deriving instance Enum (f (g a)) => Enum (Compose f g a)+deriving instance Bounded (f (g a)) => Bounded (Compose f g a)+deriving instance Num (f (g a)) => Num (Compose f g a)++-- In base-4.18.0.0, the Ord instance for Compose was simplified to:+--+-- instance Ord (f (g a)) => Ord (Compose f g a)+--+-- Before that, the Ord instance was defined as:+--+-- instance (Ord1 f, Ord1 g, Ord a) => Ord (Compose f g a)+--+-- This makes deriving Real and Integral instances slightly more complicated for+-- these older versions of base, as there are no Real1 or Integral1 classes. We+-- opt for making the instance contexts more complicated instead.+# if MIN_VERSION_base(4,18,0)+deriving instance Real (f (g a)) => Real (Compose f g a)+deriving instance Integral (f (g a)) => Integral (Compose f g a)+# else+deriving instance (Real (f (g a)), Ord1 f, Ord1 g, Ord a) => Real (Compose f g a)+deriving instance (Integral (f (g a)), Ord1 f, Ord1 g, Ord a) => Integral (Compose f g a)+# endif++# if MIN_VERSION_base(4,18,0)+instance Eq (SChar c) where+ _ == _ = True+instance Ord (SChar c) where+ compare _ _ = EQ++instance Eq (SNat n) where+ _ == _ = True+instance Ord (SNat n) where+ compare _ _ = EQ++instance Eq (SSymbol s) where+ _ == _ = True+instance Ord (SSymbol s) where+ compare _ _ = EQ+# endif+# endif++# if !(MIN_VERSION_base(4,20,0))+deriving instance Fractional (f (g a)) => Fractional (Compose f g a)+deriving instance Floating (f (g a)) => Floating (Compose f g a)++-- RealFrac and RealFloat both have Ord as a superclass. For the reasons stated+-- above (near the Real/Integral instances for Compose), these+-- RealFrace/RealFloat instances are slightly more complicated for older+-- versions of base.+# if MIN_VERSION_base(4,18,0)+deriving instance RealFrac (f (g a)) => RealFrac (Compose f g a)+deriving instance RealFloat (f (g a)) => RealFloat (Compose f g a)+# else+deriving instance (RealFrac (f (g a)), Ord1 f, Ord1 g, Ord a) => RealFrac (Compose f g a)+deriving instance (RealFloat (f (g a)), Ord1 f, Ord1 g, Ord a) => RealFloat (Compose f g a)+# endif+# endif++# if !(MIN_VERSION_base(4,21,0))+instance Monoid a => MonadFix ((,) a) where+ -- See the CLC proposal thread for discussion and proofs of the laws: https://github.com/haskell/core-libraries-committee/issues/238+ mfix f = let a = f (snd a) in a++instance Eq1 V1 where+ liftEq _ = \_ _ -> True++instance Ord1 V1 where+ liftCompare _ = \_ _ -> EQ++instance Show1 V1 where+ liftShowsPrec _ _ _ = \_ -> showString "V1"++instance Read1 V1 where+ liftReadsPrec _ _ = readPrec_to_S pfail++# if MIN_VERSION_base(4,10,0)+ liftReadListPrec = liftReadListPrecDefault+ liftReadList = liftReadListDefault+# endif++instance Eq1 U1 where+ liftEq _ = \_ _ -> True++instance Ord1 U1 where+ liftCompare _ = \_ _ -> EQ++instance Show1 U1 where+ liftShowsPrec _ _ _ = \U1 -> showString "U1"++instance Read1 U1 where+# if MIN_VERSION_base(4,10,0)+ liftReadPrec _ _ =+ parens (expectP (Ident "U1") *> pure U1)++ liftReadListPrec = liftReadListPrecDefault+ liftReadList = liftReadListDefault+# else+ liftReadsPrec _ _ =+ readPrec_to_S $+ parens (expectP (Ident "U1") *> pure U1)+# endif++instance Eq1 Par1 where+ liftEq eq = \(Par1 a) (Par1 a') -> eq a a'++instance Ord1 Par1 where+ liftCompare cmp = \(Par1 a) (Par1 a') -> cmp a a'++instance Show1 Par1 where+ liftShowsPrec sp _ d = \(Par1 { unPar1 = a }) ->+ showsSingleFieldRecordWith sp "Par1" "unPar1" d a++instance Read1 Par1 where+# if MIN_VERSION_base(4,10,0)+ liftReadPrec rp _ =+ readSingleFieldRecordWith rp "Par1" "unPar1" Par1++ liftReadListPrec = liftReadListPrecDefault+ liftReadList = liftReadListDefault+# else+ liftReadsPrec rp _ =+ readPrec_to_S $+ readSingleFieldRecordWith (readS_to_Prec rp) "Par1" "unPar1" Par1+# endif++instance Eq1 f => Eq1 (Rec1 f) where+ liftEq eq = \(Rec1 a) (Rec1 a') -> liftEq eq a a'++instance Ord1 f => Ord1 (Rec1 f) where+ liftCompare cmp = \(Rec1 a) (Rec1 a') -> liftCompare cmp a a'++instance Show1 f => Show1 (Rec1 f) where+ liftShowsPrec sp sl d = \(Rec1 { unRec1 = a }) ->+ showsSingleFieldRecordWith (liftShowsPrec sp sl) "Rec1" "unRec1" d a++instance Read1 f => Read1 (Rec1 f) where+# if MIN_VERSION_base(4,10,0)+ liftReadPrec rp rl =+ readSingleFieldRecordWith (liftReadPrec rp rl) "Rec1" "unRec1" Rec1++ liftReadListPrec = liftReadListPrecDefault+ liftReadList = liftReadListDefault+# else+ liftReadsPrec rp rl =+ readPrec_to_S $+ readSingleFieldRecordWith+ (readS_to_Prec (liftReadsPrec rp rl))+ "Rec1"+ "unRec1"+ Rec1+# endif++instance Eq c => Eq1 (K1 i c) where+ liftEq _ = \(K1 a) (K1 a') -> a == a'++instance Ord c => Ord1 (K1 i c) where+ liftCompare _ = \(K1 a) (K1 a') -> compare a a'++instance Show c => Show1 (K1 i c) where+ liftShowsPrec _ _ d = \(K1 { unK1 = a }) ->+ showsSingleFieldRecordWith showsPrec "K1" "unK1" d a++instance Read c => Read1 (K1 i c) where+# if MIN_VERSION_base(4,10,0)+ liftReadPrec _ _ = readData $+ readSingleFieldRecordWith readPrec "K1" "unK1" K1++ liftReadListPrec = liftReadListPrecDefault+ liftReadList = liftReadListDefault+# else+ liftReadsPrec _ _ =+ readPrec_to_S $+ readData $+ readSingleFieldRecordWith readPrec "K1" "unK1" K1+# endif++instance Eq1 f => Eq1 (M1 i c f) where+ liftEq eq = \(M1 a) (M1 a') -> liftEq eq a a'++instance Ord1 f => Ord1 (M1 i c f) where+ liftCompare cmp = \(M1 a) (M1 a') -> liftCompare cmp a a'++instance Show1 f => Show1 (M1 i c f) where+ liftShowsPrec sp sl d = \(M1 { unM1 = a }) ->+ showsSingleFieldRecordWith (liftShowsPrec sp sl) "M1" "unM1" d a++instance Read1 f => Read1 (M1 i c f) where+# if MIN_VERSION_base(4,10,0)+ liftReadPrec rp rl = readData $+ readSingleFieldRecordWith (liftReadPrec rp rl) "M1" "unM1" M1++ liftReadListPrec = liftReadListPrecDefault+ liftReadList = liftReadListDefault+# else+ liftReadsPrec rp rl =+ readPrec_to_S $+ readData $+ readSingleFieldRecordWith+ (readS_to_Prec (liftReadsPrec rp rl))+ "M1"+ "unM1"+ M1+# endif++instance (Eq1 f, Eq1 g) => Eq1 (f :+: g) where+ liftEq eq = \lhs rhs -> case (lhs, rhs) of+ (L1 a, L1 a') -> liftEq eq a a'+ (R1 b, R1 b') -> liftEq eq b b'+ _ -> False++instance (Ord1 f, Ord1 g) => Ord1 (f :+: g) where+ liftCompare cmp = \lhs rhs -> case (lhs, rhs) of+ (L1 _, R1 _) -> LT+ (R1 _, L1 _) -> GT+ (L1 a, L1 a') -> liftCompare cmp a a'+ (R1 b, R1 b') -> liftCompare cmp b b'++instance (Show1 f, Show1 g) => Show1 (f :+: g) where+ liftShowsPrec sp sl d = \x -> case x of+ L1 a -> showsUnaryWith (liftShowsPrec sp sl) "L1" d a+ R1 b -> showsUnaryWith (liftShowsPrec sp sl) "R1" d b++instance (Read1 f, Read1 g) => Read1 (f :+: g) where+# if MIN_VERSION_base(4,10,0)+ liftReadPrec rp rl = readData $+ readUnaryWith (liftReadPrec rp rl) "L1" L1 <|>+ readUnaryWith (liftReadPrec rp rl) "R1" R1++ liftReadListPrec = liftReadListPrecDefault+ liftReadList = liftReadListDefault+# else+ liftReadsPrec rp rl =+ readPrec_to_S $+ readData $+ readUnaryWith (readS_to_Prec (liftReadsPrec rp rl)) "L1" L1 <|>+ readUnaryWith (readS_to_Prec (liftReadsPrec rp rl)) "R1" R1+# endif++instance (Eq1 f, Eq1 g) => Eq1 (f :*: g) where+ liftEq eq = \(f :*: g) (f' :*: g') -> liftEq eq f f' && liftEq eq g g'++instance (Ord1 f, Ord1 g) => Ord1 (f :*: g) where+ liftCompare cmp = \(f :*: g) (f' :*: g') -> liftCompare cmp f f' <> liftCompare cmp g g'++instance (Show1 f, Show1 g) => Show1 (f :*: g) where+ liftShowsPrec sp sl d = \(a :*: b) ->+ showsBinaryOpWith+ (liftShowsPrec sp sl)+ (liftShowsPrec sp sl)+ 7+ ":*:"+ d+ a+ b++instance (Read1 f, Read1 g) => Read1 (f :*: g) where+# if MIN_VERSION_base(4,10,0)+ liftReadPrec rp rl = parens $ prec 6 $+ readBinaryOpWith (liftReadPrec rp rl) (liftReadPrec rp rl) ":*:" (:*:)++ liftReadListPrec = liftReadListPrecDefault+ liftReadList = liftReadListDefault+# else+ liftReadsPrec rp rl =+ readPrec_to_S $+ parens $ prec 6 $+ readBinaryOpWith+ (readS_to_Prec (liftReadsPrec rp rl))+ (readS_to_Prec (liftReadsPrec rp rl))+ ":*:"+ (:*:)+# endif++instance (Eq1 f, Eq1 g) => Eq1 (f :.: g) where+ liftEq eq = \(Comp1 a) (Comp1 a') -> liftEq (liftEq eq) a a'++instance (Ord1 f, Ord1 g) => Ord1 (f :.: g) where+ liftCompare cmp = \(Comp1 a) (Comp1 a') -> liftCompare (liftCompare cmp) a a'++instance (Show1 f, Show1 g) => Show1 (f :.: g) where+ liftShowsPrec sp sl d = \(Comp1 { unComp1 = a }) ->+ showsSingleFieldRecordWith+ (liftShowsPrec (liftShowsPrec sp sl) (liftShowList sp sl))+ "Comp1"+ "unComp1"+ d+ a++instance (Read1 f, Read1 g) => Read1 (f :.: g) where+# if MIN_VERSION_base(4,10,0)+ liftReadPrec rp rl = readData $+ readSingleFieldRecordWith+ (liftReadPrec (liftReadPrec rp rl) (liftReadListPrec rp rl))+ "Comp1"+ "unComp1"+ Comp1++ liftReadListPrec = liftReadListPrecDefault+ liftReadList = liftReadListDefault+# else+ liftReadsPrec rp rl =+ readPrec_to_S $+ readData $+ readSingleFieldRecordWith+ (readS_to_Prec (liftReadsPrec (liftReadsPrec rp rl) (liftReadList rp rl)))+ "Comp1"+ "unComp1"+ Comp1+# endif++instance Eq1 UAddr where+ -- NB cannot use eqAddr# because its module isn't safe+ liftEq _ = \(UAddr a) (UAddr b) -> UAddr a == UAddr b++instance Ord1 UAddr where+ liftCompare _ = \(UAddr a) (UAddr b) -> compare (UAddr a) (UAddr b)++instance Show1 UAddr where+ liftShowsPrec _ _ = showsPrec++-- NB no Read1 for URec (Ptr ()) because there's no Read for Ptr.++instance Eq1 UChar where+ liftEq _ = \(UChar a) (UChar b) -> UChar a == UChar b++instance Ord1 UChar where+ liftCompare _ = \(UChar a) (UChar b) -> compare (UChar a) (UChar b)++instance Show1 UChar where+ liftShowsPrec _ _ = showsPrec++instance Eq1 UDouble where+ liftEq _ = \(UDouble a) (UDouble b) -> UDouble a == UDouble b++instance Ord1 UDouble where+ liftCompare _ = \(UDouble a) (UDouble b) -> compare (UDouble a) (UDouble b)++instance Show1 UDouble where+ liftShowsPrec _ _ = showsPrec++instance Eq1 UFloat where+ liftEq _ = \(UFloat a) (UFloat b) -> UFloat a == UFloat b++instance Ord1 UFloat where+ liftCompare _ = \(UFloat a) (UFloat b) -> compare (UFloat a) (UFloat b)++instance Show1 UFloat where+ liftShowsPrec _ _ = showsPrec++instance Eq1 UInt where+ liftEq _ = \(UInt a) (UInt b) -> UInt a == UInt b++instance Ord1 UInt where+ liftCompare _ = \(UInt a) (UInt b) -> compare (UInt a) (UInt b)++instance Show1 UInt where+ liftShowsPrec _ _ = showsPrec++instance Eq1 UWord where+ liftEq _ = \(UWord a) (UWord b) -> UWord a == UWord b++instance Ord1 UWord where+ liftCompare _ = \(UWord a) (UWord b) -> compare (UWord a) (UWord b)++instance Show1 UWord where+ liftShowsPrec _ _ = showsPrec++readSingleFieldRecordWith :: ReadPrec a -> String -> String -> (a -> t) -> ReadPrec t+readSingleFieldRecordWith rp name field cons = parens $ prec 11 $ do+ expectP $ Ident name+ expectP $ Punc "{"+ x <- readField field $ reset rp+ expectP $ Punc "}"+ pure $ cons x++readBinaryOpWith+ :: ReadPrec a+ -> ReadPrec b+ -> String+ -> (a -> b -> t)+ -> ReadPrec t+readBinaryOpWith rp1 rp2 name cons =+ cons <$> step rp1 <* expectP (Symbol name) <*> step rp2++# if !(MIN_VERSION_base(4,10,0))+readData :: ReadPrec a -> ReadPrec a+readData reader = parens $ prec 10 reader++readUnaryWith :: ReadPrec a -> String -> (a -> t) -> ReadPrec t+readUnaryWith rp name cons = do+ expectP $ Ident name+ x <- step rp+ return $ cons x+# endif++# if !(MIN_VERSION_base(4,11,0))+readField :: String -> ReadPrec a -> ReadPrec a+readField fieldName readVal = do+ expectP (Ident fieldName)+ expectP (Punc "=")+ readVal+{-# NOINLINE readField #-}+# endif++showsSingleFieldRecordWith :: (Int -> a -> ShowS) -> String -> String -> Int -> a -> ShowS+showsSingleFieldRecordWith sp name field d x =+ showParen (d > appPrec) $+ showString name . showString " {" . showString field . showString " = " . sp 0 x . showChar '}'++showsBinaryOpWith+ :: (Int -> a -> ShowS)+ -> (Int -> b -> ShowS)+ -> Int+ -> String+ -> Int+ -> a+ -> b+ -> ShowS+showsBinaryOpWith sp1 sp2 opPrec name d x y = showParen (d >= opPrec) $+ sp1 opPrec x . showChar ' ' . showString name . showChar ' ' . sp2 opPrec y++instance Show (UAddr p) where+ -- This Show instance would be equivalent to what deriving Show would generate,+ -- but because deriving Show doesn't support Addr# fields we define it manually.+ showsPrec d (UAddr x) =+ showParen (d > appPrec)+ (\y -> showString "UAddr {uAddr# = " (showsPrec 0 (Ptr x) (showChar '}' y)))+# endif #endif
src/Data/Orphans/Prelude.hs view
@@ -1,10 +1,13 @@ {-# LANGUAGE CPP #-}--#if __GLASGOW_HASKELL__ >= 706+{-# LANGUAGE ConstraintKinds #-}+{-# LANGUAGE KindSignatures #-} {-# LANGUAGE ExplicitNamespaces #-}++#if __GLASGOW_HASKELL__ >= 806+{-# LANGUAGE NoStarIsType #-} #endif -{-# OPTIONS_GHC -fno-warn-deprecations #-}+{-# OPTIONS_GHC -Wno-deprecations #-} {-| Exports modules that Data.Orphans needs. Because Data.Orphans uses several modules@@ -15,33 +18,48 @@ Note that this module does not export any modules that could introduce name clashes. -} module Data.Orphans.Prelude-#if MIN_VERSION_base(4,12,0)+#if !defined(__GLASGOW_HASKELL__) || MIN_VERSION_base(4,21,0) () where #else- (module OrphansPrelude, realPart, imagPart) where+ ( module OrphansPrelude+ , realPart+ , imagPart+ , Typeable1+ , Typeable2+ , Typeable3+ , Typeable4+ , Typeable5+ , Typeable6+ , Typeable7+ ) where import Control.Applicative as OrphansPrelude-import Control.Arrow as OrphansPrelude hiding (first, loop, second)+import Control.Arrow as OrphansPrelude hiding ((+++), first, loop, second) import Control.Category as OrphansPrelude hiding ((.), id) import Control.Concurrent.QSem as OrphansPrelude import Control.Monad as OrphansPrelude hiding (mapM, sequence) import Control.Monad.Fix as OrphansPrelude+import Control.Monad.Zip as OrphansPrelude +import Data.Bifunctor as OrphansPrelude import Data.Bits as OrphansPrelude import Data.Char as OrphansPrelude import Data.Complex as OrphansPrelude (Complex(..)) import Data.Data as OrphansPrelude (Data(..), Constr, DataType, mkConstr, mkDataType) import Data.Fixed as OrphansPrelude+import Data.Functor.Classes as OrphansPrelude+import Data.Functor.Compose as OrphansPrelude+import Data.Functor.Identity as OrphansPrelude import Data.Int as OrphansPrelude-import Data.Ix as OrphansPrelude import Data.List as OrphansPrelude (genericLength)-import Data.Monoid as OrphansPrelude- hiding ( Any(..)-# if MIN_VERSION_base(4,5,0)- , (<>)-# endif- )+import Data.Monoid as OrphansPrelude hiding (Any(..), (<>))+import Data.Ord as OrphansPrelude (Down(..))+import Data.Proxy as OrphansPrelude+import Data.Semigroup as OrphansPrelude (stimesMonoid) import Data.String as OrphansPrelude (IsString)+import Data.Type.Coercion as OrphansPrelude (Coercion, TestCoercion)+import Data.Type.Equality as OrphansPrelude ((:~:)(..), TestEquality(..))+import Data.Typeable as OrphansPrelude (Typeable) import Data.Version as OrphansPrelude import Data.Word as OrphansPrelude @@ -51,18 +69,28 @@ import Foreign.Ptr as OrphansPrelude import Foreign.Storable as OrphansPrelude +import GHC.Arr as OrphansPrelude (Ix(..)) import GHC.Base as OrphansPrelude import GHC.Conc as OrphansPrelude import GHC.Desugar as OrphansPrelude (AnnotationWrapper)+import GHC.Exts as OrphansPrelude (IsList(..), Ptr(..))+import GHC.Fingerprint as OrphansPrelude import GHC.ForeignPtr as OrphansPrelude+import GHC.GHCi as OrphansPrelude import GHC.IO.Buffer as OrphansPrelude import GHC.IO.BufferedIO as OrphansPrelude (BufferedIO) import GHC.IO.Device as OrphansPrelude (IODevice, IODeviceType(..), RawIO) import GHC.IO.Encoding as OrphansPrelude+import GHC.IO.Encoding.Failure as OrphansPrelude import GHC.IO.Handle as OrphansPrelude import GHC.IO.Handle.Types as OrphansPrelude+import GHC.Read as OrphansPrelude (expectP, paren) import GHC.Real as OrphansPrelude (Ratio(..), (%)) import GHC.ST as OrphansPrelude+import GHC.Show as OrphansPrelude (appPrec)+import GHC.Stack as OrphansPrelude+import GHC.Stats as OrphansPrelude+import GHC.TypeLits as OrphansPrelude hiding (type (*)) import Numeric as OrphansPrelude (showHex) @@ -72,6 +100,8 @@ import System.Posix.Types as OrphansPrelude import Text.Printf as OrphansPrelude+import Text.Read as OrphansPrelude+import Text.Read.Lex as OrphansPrelude (Number) import Unsafe.Coerce as OrphansPrelude (unsafeCoerce) @@ -79,63 +109,36 @@ import GHC.IO.Encoding.CodePage.Table as OrphansPrelude # endif -# if MIN_VERSION_base(4,4,0)-import Control.Monad.Zip as OrphansPrelude-import GHC.Fingerprint as OrphansPrelude-import GHC.IO.Encoding.Failure as OrphansPrelude--# if !defined(mingw32_HOST_OS) && !defined(__GHCJS__)+# if !defined(mingw32_HOST_OS) && !defined(__GHCJS__) import GHC.Event as OrphansPrelude-# endif--# if !(MIN_VERSION_base(4,10,0))-import Data.Typeable.Internal as OrphansPrelude # endif-# endif -# if MIN_VERSION_base(4,5,0)-import GHC.Stack as OrphansPrelude-import GHC.Stats as OrphansPrelude-# endif--# if MIN_VERSION_base(4,6,0)-import Data.Ord as OrphansPrelude (Down(..))-import GHC.GHCi as OrphansPrelude-import GHC.TypeLits as OrphansPrelude hiding (type (*))-# else-import GHC.Exts as OrphansPrelude (Down(..))-# endif--# if MIN_VERSION_base(4,6,0) && !(MIN_VERSION_base(4,8,2))-import GHC.IP as OrphansPrelude+# if !(MIN_VERSION_base(4,12,0))+import Data.List.NonEmpty as OrphansPrelude (NonEmpty(..))+import Data.Semigroup as OrphansPrelude (Semigroup(..)) # endif -# if MIN_VERSION_base(4,7,0)-import Data.Proxy as OrphansPrelude-import Data.Type.Coercion as OrphansPrelude (Coercion, TestCoercion)-import Data.Type.Equality as OrphansPrelude ((:~:), TestEquality)-import Text.Read.Lex as OrphansPrelude (Number)-# else-import Control.Concurrent.SampleVar as OrphansPrelude+# if !(MIN_VERSION_base(4,11,0))+import Data.Typeable ( Typeable1, Typeable2, Typeable3, Typeable4+ , Typeable5, Typeable6, Typeable7 ) # endif -# if MIN_VERSION_base(4,8,0)-import Data.Bifunctor as OrphansPrelude-import Data.Functor.Identity as OrphansPrelude-#endif--# if MIN_VERSION_base(4,9,0)-import Data.Functor.Classes as OrphansPrelude-import Data.List.NonEmpty as OrphansPrelude (NonEmpty(..))-import Data.Semigroup as OrphansPrelude (Semigroup(..), stimesMonoid)+# if MIN_VERSION_base(4,17,0) && !(MIN_VERSION_base(4,18,0))+import GHC.Generics as OrphansPrelude ( Generic(..), Generic1(..)+ , Generically(..), Generically1(..) ) # endif -# if MIN_VERSION_base(4,4,0) realPart, imagPart :: Complex a -> a-#else-realPart, imagPart :: RealFloat a => Complex a -> a-#endif realPart (x :+ _) = x imagPart (_ :+ y) = y +# if MIN_VERSION_base(4,11,0)+type Typeable1 (a :: Type -> Type) = Typeable a+type Typeable2 (a :: Type -> Type -> Type) = Typeable a+type Typeable3 (a :: Type -> Type -> Type -> Type) = Typeable a+type Typeable4 (a :: Type -> Type -> Type -> Type -> Type) = Typeable a+type Typeable5 (a :: Type -> Type -> Type -> Type -> Type -> Type) = Typeable a+type Typeable6 (a :: Type -> Type -> Type -> Type -> Type -> Type -> Type) = Typeable a+type Typeable7 (a :: Type -> Type -> Type -> Type -> Type -> Type -> Type -> Type) = Typeable a+# endif #endif
test/Control/Applicative/OrphansSpec.hs view
@@ -1,3 +1,4 @@+{-# LANGUAGE CPP #-} module Control.Applicative.OrphansSpec (main, spec) where import Test.Hspec@@ -17,7 +18,9 @@ Identity f <*> x = f <$> x instance Monad Identity where+#if !(MIN_VERSION_base(4,11,0)) return = Identity+#endif m >>= k = k (runIdentity m) main :: IO ()
test/Data/Bits/OrphansSpec.hs view
@@ -1,25 +1,18 @@-{-# LANGUAGE CPP #-} module Data.Bits.OrphansSpec (main, spec) where import Test.Hspec -#if MIN_VERSION_base(4,6,0) import Data.Bits import Data.Orphans ()-#endif main :: IO () main = hspec spec spec :: Spec spec =-#if MIN_VERSION_base(4,6,0) describe "Bits Bool instance" $ it "allows bitwise operations on Bools" $ do True .&. True `shouldBe` True True .&. False `shouldBe` False False .&. True `shouldBe` False False .&. False `shouldBe` False-#else- return ()-#endif
test/Data/Version/OrphansSpec.hs view
@@ -1,7 +1,5 @@ {-# LANGUAGE CPP #-}-#if MIN_VERSION_base(4,7,0) {-# LANGUAGE OverloadedLists #-}-#endif module Data.Version.OrphansSpec (main, spec) where import Test.Hspec@@ -18,14 +16,20 @@ describe "Data Version instance" $ it "allows obtaining a Version constructor" $ dataTypeName (dataTypeOf (Version [1,2,3] [])) `shouldBe`-#if __GLASGOW_HASKELL__ >= 801+#if __GLASGOW_HASKELL__ >= 801 && __GLASGOW_HASKELL__ < 903+ -- Some old versions of GHC incorrectly return "Version" due to+ -- https://gitlab.haskell.org/ghc/ghc/-/issues/20371. "Version"+#elif __GLASGOW_HASKELL__ >= 910+ -- In GHC 9.10 and later, Version is defined in+ -- GHC.Internal.Data.Version (in the ghc-internal library).+ "GHC.Internal.Data.Version.Version" #else+ -- In older versions of GHC, Version is defined in Data.Version (in the+ -- base library). "Data.Version.Version" #endif -#if MIN_VERSION_base(4,7,0) describe "IsList Version instance" $ it "creates a Version from an Int list" $ [1,2,3] `shouldBe` Version [1,2,3] []-#endif
test/GHC/Fingerprint/OrphansSpec.hs view
@@ -1,29 +1,22 @@-{-# LANGUAGE CPP #-} module GHC.Fingerprint.OrphansSpec (main, spec) where import Test.Hspec -#if MIN_VERSION_base(4,4,0) import Data.Orphans () import Data.Word (Word64) import GHC.Fingerprint.Type-#endif main :: IO () main = hspec spec spec :: Spec spec =-#if MIN_VERSION_base(4,4,0) describe "Fingerprint" $ it "has a Show instance" $ do let w1, w2 :: Word64 w1 = 0x0123456789abcdef w2 = 0x42- + f :: Fingerprint f = Fingerprint w1 w2 show f `shouldBe` "0123456789abcdef0000000000000042"-#else- return ()-#endif
test/System/Posix/Types/OrphansSpec.hs view
@@ -7,7 +7,7 @@ import Test.Hspec #if defined(HTYPE_DEV_T)-import Control.Applicative (liftA2)+import qualified Control.Applicative as App (liftA2) import Data.Bits (Bits(..)) import Data.Orphans ()@@ -16,7 +16,7 @@ import System.Posix.Types import Test.Hspec.QuickCheck (prop)-import Test.QuickCheck (NonZero(..))+import Test.QuickCheck (NonNegative(..), NonZero(..)) #endif main :: IO ()@@ -39,17 +39,17 @@ prop "implements rotate" $ pred2IntHDev rotate rotate prop "implements setBit" $- pred2IntHDev setBit setBit+ pred2NonNegIntHDev setBit setBit prop "implements clearBit" $- pred2IntHDev clearBit clearBit+ pred2NonNegIntHDev clearBit clearBit prop "implements complementBit" $- pred2IntHDev complementBit complementBit+ pred2NonNegIntHDev complementBit complementBit prop "implements testBit" $- pred2IntEq testBit testBit+ pred2NonNegIntEq testBit testBit prop "implements complement" $ pred1HDevHDev complement complement prop "implements bit" $- pred1IntHDev bit bit+ pred1NonNegIntHDev bit bit prop "implements bitSize" $ pred1HDevEq bitSize bitSize prop "implements isSigned" $@@ -82,7 +82,7 @@ -> (a -> b) -> (a -> c) -> a -> d-pred1Common = liftA2+pred1Common = App.liftA2 pred1HDev :: (b -> c -> Bool) -> (CDev -> b)@@ -96,8 +96,8 @@ pred1HDevHDev :: (CDev -> CDev) -> (HDev -> HDev) -> HDev -> Bool pred1HDevHDev = pred1HDev eqCDevHDev -pred1IntHDev :: (Int -> CDev) -> (Int -> HDev) -> Int -> Bool-pred1IntHDev = pred1Common eqCDevHDev+pred1NonNegIntHDev :: (Int -> CDev) -> (Int -> HDev) -> NonNegative Int -> Bool+pred1NonNegIntHDev f g (NonNegative x) = pred1Common eqCDevHDev f g x pred2Common :: (c -> d -> e) -> (a -> b -> c)@@ -138,11 +138,16 @@ -> HDev -> Int -> Bool pred2IntHDev = pred2Int eqCDevHDev -pred2IntEq :: Eq a- => (CDev -> Int -> a)- -> (HDev -> Int -> a)- -> HDev -> Int -> Bool-pred2IntEq = pred2Int (==)+pred2NonNegIntHDev :: (CDev -> Int -> CDev)+ -> (HDev -> Int -> HDev)+ -> HDev -> NonNegative Int -> Bool+pred2NonNegIntHDev f g hDev (NonNegative x) = pred2Int eqCDevHDev f g hDev x++pred2NonNegIntEq :: Eq a+ => (CDev -> Int -> a)+ -> (HDev -> Int -> a)+ -> HDev -> NonNegative Int -> Bool+pred2NonNegIntEq f g hDev (NonNegative x) = pred2Int (==) f g hDev x #else spec :: Spec spec = return ()