base-orphans-0.9.1/0000755000000000000000000000000007346545000012274 5ustar0000000000000000base-orphans-0.9.1/CHANGES.markdown0000644000000000000000000002157407346545000015121 0ustar0000000000000000## 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`: - `Applicative` instance for `K1` - `Semigroup` instances for `U1`, `Par1`, `Rec1`, `K1`, `M1`, `(:*:)`, `(:.:)`, and `V1` - `Monoid` instances for `U1`, `Par1`, `Rec1`, `K1`, `M1`, `(:*:)`, and `(:.:)` * `Foldable` and `Traversable` instances for `Data.Monoid.Alt` * `MonadFix`, `MonadZip`, `Data`, `Foldable`, `Traversable`, `Eq1`, `Ord1`, `Read1`, and `Show1` instances for `Data.Ord.Down` ## Changes in 0.7 [2018.03.08] - Backported new instances from GHC 8.4/`base-4.11` * `Alternative` instance for `ZipList` * `Data` instance for `IntPtr` and `WordPtr` * `Num`, `Functor`, `Applicative`, `Monad`, `Semigroup`, and `Monoid` instances for `Data.Ord.Down` * `MonadFail`, `Semigroup`, and `Monoid` instances for strict `ST` ## Changes in 0.6 [2017.04.10] - Backported new instances from GHC 8.2/`base-4.10` (see https://github.com/haskell-compat/base-orphans/issues/39): * `Data` instance for `Const` * `Eq1`, `Ord1`, `Read1`, and `Show1` instances for `NonEmpty` * `Semigroup` instances for `IO`, `Event`, and `Lifetime` - Backported `Typeable` instances for `(:+:)`, `(:*:)`, `(:.:)`, `M1`, `Rec1`, `ArrowMonad`, `Kleisli`, `WrappedArrow`, `WrappedMonad`, and `Any` on GHC 7.6 and earlier - Backported `Data` instances for `(:+:)`, `(:*:)`, `(:.:)`, `M1`, and `Rec1` on GHC 7.6 and earlier ## Changes in 0.5.4 - Backported `Bits`, `FiniteBits`, `Floating`, `Fractional`, `Integral`, `IsString`, `Num`, `Real`, `RealFloat`, and `RealFrac` instances for `Identity` and `Const` (introduced in `base-4.9`) ## Changes in 0.5.3 - Backported `Alternative`, `MonadPlus` and `MonadZip` instances for `U1` and `Proxy`, and made the `Functor`, `Foldable`, `Traversable`, `Alternative`, and `Monad` instances for `U1` lazier to correspond with `base-4.9` ## Changes in 0.5.2 - Backported `Enum`, `Bounded`, `Ix`, `Functor`, `Applicative`, `Monad`, `MonadFix`, `MonadPlus`, `MonadZip`, `Foldable`, `Traversable`, and `Data` instances for datatypes in the `GHC.Generics` module (introduced in `base-4.9`) ## Changes in 0.5.1 - The `Storable` instances for `Complex` and `Ratio` are now exactly as lazy as their counterparts in `base` (see issue [#36](https://github.com/haskell-compat/base-orphans/issues/36)) ## Changes in 0.5.0 - GHC 8.0 compatibility - Backported instances introduced in GHC 8.0/`base-4.9` (see https://github.com/haskell-compat/base-orphans/issues/32) ## Changes in 0.4.5 - Import `Control.Monad.Instances` (which exports `Functor` and `Monad` instances for `(->) r`, and `Functor` instances for `(,) a` and `Either a`) on GHCs before 7.6. This ensures that these instances will always be in scope, and you won't have to import a module which is deprecated on recent GHC releases. - Fix build on GHC HEAD (again) ## Changes in 0.4.4 - Fix build on GHC HEAD ## Changes in 0.4.3 - Fix build on OSes where `HTYPE_DEV_T = Int32` (e.g., OS X) ## Changes in 0.4.2 - `Functor` instances for `Handler` - `Functor`. `Applicative`, `Alternative`, and `MonadPlus` instances for `ArrowMonad` - Expose `Read` and `Show` instances for `Down` on GHCs before 7.8 - `Bits`, `Bounded`, and `Integral` instances for `CDev` ## Changes in 0.4.1 - Fixed imports on GHC < 7.8 on Windows ## Changes in 0.4.0 - Removed all `Generic` and `Generic1` instances. These have been moved to the `generic-deriving` library. ## Changes in 0.3.3 - `Typeable` instances for `(~)`, `Any`, `Constraint`, `CSigset`, `Handler`, `Opaque`, `SPEC`, and every promotable data constructor in `base` ## Changes in 0.3.2 - `Storable (Complex a)` instance no longer requires a `RealFloat a` constraint if using `base-4.4` or later ## Changes in 0.3.1 - `Functor`, `Applicative`, and `Monad` instances for `First` and `Last` ## Changes in 0.3.0 - `Show` instance for `Fingerprint` - `Data.Orphans` is now `Trustworthy` - Backported the `Generic` and `Generic1` instances available in `base-4.7.0.0` to GHC 7.2, 7.4, and 7.6, namely * `Const`, `WrappedMonad`, and `ZipList` from `Control.Applicative` * `WrappedArrow` from `Control.Category` * `All`, `Any`, `Dual`, `Endo`, `First`, `Last`, `Product`, and `Sum` from `Data.Monoid` * `U1`, `Par1`, `Rec1`, `K1`, `M1`, `(:+:)`, `(:*:)`, `(:.:)`, `Arity`, `Associativity`, and `Fixity` from `GHC.Generics` ## Changes in 0.2.0 - Drop GHC 6.12 (and `base-4.2.0.0`) compatibility - Fix Windows, GHCJS build - `Read` instance for `Fixed` - `Applicative` instances for strict and lazy `ST` - `Typeable` instance for `SampleVar` - `Applicative` and `Alternative` instances for `ReadP` and `ReadPrec` - `Typeable` instance for `KProxy` - `Typeable` instances for more data types in `GHC.`-prefixed modules - `Generic` instances for `Arity`, `Associativity`, and `Fixity` from the `GHC.Generics` module - Corrected the `Generic` instance for `(:*:)` to work around GHC bug #9830 base-orphans-0.9.1/LICENSE0000644000000000000000000000221107346545000013275 0ustar0000000000000000Copyright (c) 2015-2017 Simon Hengel , João Cristóvão , Ryan Scott Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. base-orphans-0.9.1/README.markdown0000644000000000000000000001531207346545000014777 0ustar0000000000000000# `base-orphans` [![Hackage](https://img.shields.io/hackage/v/base-orphans.svg)][Hackage: base-orphans] [![Hackage Dependencies](https://img.shields.io/hackage-deps/v/base-orphans.svg)](http://packdeps.haskellers.com/reverse/base-orphans) [![Haskell Programming Language](https://img.shields.io/badge/language-Haskell-blue.svg)][Haskell.org] [![BSD3 License](http://img.shields.io/badge/license-MIT-brightgreen.svg)][tl;dr Legal: MIT] [![Build Status](https://github.com/haskell-compat/base-orphans/workflows/Haskell-CI/badge.svg)](https://github.com/haskell-compat/base-orphans/actions?query=workflow%3AHaskell-CI) [Hackage: base-orphans]: http://hackage.haskell.org/package/base-orphans "base-orphans package on Hackage" [Haskell.org]: http://www.haskell.org "The Haskell Programming Language" [tl;dr Legal: MIT]: https://tldrlegal.com/license/mit-license "MIT License" ## Scope `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 [base-compat](http://hackage.haskell.org/package/base-compat). Note that `base-orphans` doesn't cover every possible instance. See the [What is not covered](#what-is-not-covered) section for exceptions. ## Usage To use `base-orphans`, simply `import Data.Orphans ()`. ## What is covered * `Alternative`, `MonadPlus`, and `MonadZip` instances for `Proxy` * `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`, `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`, `Dual`, `First`, `Last`, `Product`, and `Sum` * `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`, `WordPtr`, `WrappedArrow` and `WrappedMonad` * `Data`, `MonadFix` and `MonadZip` instances for `Alt`, `Dual`, `First`, `Last`, `Product`, and `Sum` * `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` * `Enum`, `Bounded`, `Num`, `Real`, and `Integral` 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` and `MonadZip` instances for `Complex` * `MonadZip` instance for `Maybe` * `Monoid`, `Eq`, `Ord`, `Read`, and `Show` instances for `Const` * `Monoid` instances for `Identity` and `IO` * `Num` instance for `Sum` and `Product` * `Read` instance for `Fixed` * `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` * `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 `base-orphans` does not define the following instances: * `Generic` or `Generic1` instances. These can be found in the [`Generics.Deriving.Instances`](https://hackage.haskell.org/package/generic-deriving-1.8.0/docs/Generics-Deriving-Instances.html) module of the [`generic-deriving`](https://hackage.haskell.org/package/generic-deriving) library. * The `Alternative IO` and `MonadPlus IO` instances. These can be found in the [`Control.Monad.Trans.Error`](http://hackage.haskell.org/package/transformers-0.4.3.0/docs/src/Control-Monad-Trans-Error.html#line-69) module of the [`transformers`](http://hackage.haskell.org/package/transformers) library. ## Supported versions of GHC/`base` * `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.*` * `ghc-7.10.*` / `base-4.8.*` * `ghc-7.8.*` / `base-4.7.*` * `ghc-7.6.*` / `base-4.6.*` * `ghc-7.4.*` / `base-4.5.*` * `ghc-7.2.*` / `base-4.4.*` * `ghc-7.0.*` / `base-4.3.*` 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, please report it! Patches are welcome; add tests for new code! base-orphans-0.9.1/Setup.hs0000644000000000000000000000005607346545000013731 0ustar0000000000000000import Distribution.Simple main = defaultMain base-orphans-0.9.1/base-orphans.cabal0000644000000000000000000000622407346545000015646 0ustar0000000000000000cabal-version: 1.12 -- This file has been generated from package.yaml by hpack version 0.35.4. -- -- see: https://github.com/sol/hpack -- -- hash: 4e4482d938177240bd3d33937246a570b07764edf79c92c1609492b56b35944b name: base-orphans version: 0.9.1 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 @@. . See the README for what instances are covered: . See also the section. category: Compatibility homepage: https://github.com/haskell-compat/base-orphans#readme bug-reports: https://github.com/haskell-compat/base-orphans/issues author: Simon Hengel , João Cristóvão , Ryan Scott maintainer: Simon Hengel , João Cristóvão , Ryan Scott copyright: (c) 2012-2017 Simon Hengel, (c) 2014-2017 João Cristóvão, (c) 2015-2017 Ryan Scott license: MIT license-file: LICENSE build-type: Simple tested-with: GHC == 7.0.4 , GHC == 7.2.2 , GHC == 7.4.2 , GHC == 7.6.3 , GHC == 7.8.4 , GHC == 7.10.3 , 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.5 , GHC == 9.6.2 , GHC == 9.8.1 extra-source-files: CHANGES.markdown README.markdown source-repository head type: git location: https://github.com/haskell-compat/base-orphans library hs-source-dirs: src ghc-options: -Wall build-depends: base >=4.3 && <5 , ghc-prim exposed-modules: Data.Orphans other-modules: Data.Orphans.Prelude default-language: Haskell2010 test-suite spec type: exitcode-stdio-1.0 main-is: Spec.hs hs-source-dirs: test ghc-options: -Wall build-depends: QuickCheck , base >=4.3 && <5 , base-orphans , hspec ==2.* build-tool-depends: hspec-discover:hspec-discover == 2.* other-modules: Control.Applicative.OrphansSpec Control.Exception.OrphansSpec Data.Bits.OrphansSpec Data.Foldable.OrphansSpec Data.Monoid.OrphansSpec Data.Traversable.OrphansSpec Data.Version.OrphansSpec Foreign.Storable.OrphansSpec GHC.Fingerprint.OrphansSpec System.Posix.Types.IntWord System.Posix.Types.OrphansSpec Paths_base_orphans default-language: Haskell2010 base-orphans-0.9.1/src/Data/0000755000000000000000000000000007346545000013734 5ustar0000000000000000base-orphans-0.9.1/src/Data/Orphans.hs0000644000000000000000000027102107346545000015705 0ustar0000000000000000{-# 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 #-} {-# LANGUAGE UndecidableInstances #-} #if __GLASGOW_HASKELL__ >= 702 {-# LANGUAGE Trustworthy #-} #endif #if __GLASGOW_HASKELL__ >= 706 {-# LANGUAGE PolyKinds #-} #endif #if __GLASGOW_HASKELL__ >= 708 {-# LANGUAGE DataKinds #-} # if __GLASGOW_HASKELL__ < 710 {-# LANGUAGE NullaryTypeClasses #-} # endif #endif #if __GLASGOW_HASKELL__ >= 800 && __GLASGOW_HASKELL__ < 806 {-# 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 hiding (prec) #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 #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,9,0) && !(MIN_VERSION_base(4,16,0)) import qualified Data.Functor.Product as Functor #endif #if MIN_VERSION_base(4,10,0) && !(MIN_VERSION_base(4,16,0)) import GHC.Read (expectP, paren) #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 MIN_VERSION_base(4,15,0) && !(MIN_VERSION_base(4,16,0)) import GHC.Tuple (Solo(..)) #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,19,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 instance Ord TyCon where compare x y = compare (tyConString x) (tyConString y) -- http://hackage.haskell.org/package/base-4.3.0.0/docs/Data-Typeable.html#t:TypeRep -- Notice that the `TypeRep` constructor is not exported -- and no pure accessor to its `Key` field is provided. instance Ord TypeRep where compare x y = compare (typeRepTyCon x) (typeRepTyCon x) `mappend` compare (typeRepArgs x) (typeRepArgs y) #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) = 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 # 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 !(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) # if !(MIN_VERSION_base(4,8,0)) return x = (mempty, mempty, x) # endif 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) # if !(MIN_VERSION_base(4,8,0)) return x = (mempty, mempty, mempty, x) # endif 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 (>>=) #-} # if !(MIN_VERSION_base(4,8,0)) return = Kleisli . const . return {-# INLINE return #-} # endif 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) # if MIN_VERSION_base(4,7,0) deriving instance FiniteBits a => FiniteBits (Down a) # endif 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) # if MIN_VERSION_base(4,7,0) instance IsList (ZipList a) where type Item (ZipList a) = a fromList = ZipList toList = getZipList # endif # if MIN_VERSION_base(4,9,0) 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 #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 # if MIN_VERSION_base(4,4,0) 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 #endif #if !(MIN_VERSION_base(4,16,0)) # if MIN_VERSION_base(4,9,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 # 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)) # if MIN_VERSION_base(4,5,0) -- These are guarded on base-4.5.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/5529. 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 # endif # 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 MIN_VERSION_base(4,5,0) -- These are guarded on base-4.5.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/5529. # 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 # endif # 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)) # if MIN_VERSION_base(4,9,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 # 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 __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 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 #endif base-orphans-0.9.1/src/Data/Orphans/0000755000000000000000000000000007346545000015346 5ustar0000000000000000base-orphans-0.9.1/src/Data/Orphans/Prelude.hs0000644000000000000000000001361507346545000017310 0ustar0000000000000000{-# LANGUAGE CPP #-} {-# LANGUAGE KindSignatures #-} #if __GLASGOW_HASKELL__ >= 706 {-# LANGUAGE ConstraintKinds #-} {-# LANGUAGE ExplicitNamespaces #-} #endif #if __GLASGOW_HASKELL__ >= 806 {-# LANGUAGE NoStarIsType #-} #endif {-# OPTIONS_GHC -fno-warn-deprecations #-} {-| Exports modules that Data.Orphans needs. Because Data.Orphans uses several modules that only need to be in scope for certain versions of GHC, exporting all of the modules separately eliminates the need to use CPP pragmas for GHC-version-specific imports. This makes it much easier to be -Wall-compliant. Note that this module does not export any modules that could introduce name clashes. -} module Data.Orphans.Prelude #if MIN_VERSION_base(4,19,0) () where #else ( 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.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 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.Int 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.String as OrphansPrelude (IsString) import Data.Typeable as OrphansPrelude (Typeable) import Data.Version as OrphansPrelude import Data.Word as OrphansPrelude import Foreign.C.Error as OrphansPrelude import Foreign.C.Types as OrphansPrelude import Foreign.Marshal.Pool as OrphansPrelude 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.ForeignPtr 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.Handle as OrphansPrelude import GHC.IO.Handle.Types as OrphansPrelude import GHC.Real as OrphansPrelude (Ratio(..), (%)) import GHC.ST as OrphansPrelude import Numeric as OrphansPrelude (showHex) import System.Console.GetOpt as OrphansPrelude import System.IO as OrphansPrelude import System.Posix.Internals as OrphansPrelude import System.Posix.Types as OrphansPrelude import Text.Printf as OrphansPrelude import Text.Read as OrphansPrelude import Unsafe.Coerce as OrphansPrelude (unsafeCoerce) # if defined(mingw32_HOST_OS) 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__) import GHC.Event as OrphansPrelude # if !(MIN_VERSION_base(4,7,0)) hiding (step) # endif # 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 # 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 GHC.Exts as OrphansPrelude (IsList(..)) import Text.Read.Lex as OrphansPrelude (Number) # else import Control.Concurrent.SampleVar as OrphansPrelude # 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.Functor.Compose as OrphansPrelude import Data.Semigroup as OrphansPrelude (stimesMonoid) # endif # if MIN_VERSION_base(4,9,0) && !(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,11,0)) import Data.Typeable ( Typeable1, Typeable2, Typeable3, Typeable4 , Typeable5, Typeable6, Typeable7 ) # endif # 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 base-orphans-0.9.1/test/Control/Applicative/0000755000000000000000000000000007346545000017134 5ustar0000000000000000base-orphans-0.9.1/test/Control/Applicative/OrphansSpec.hs0000644000000000000000000000217407346545000021721 0ustar0000000000000000{-# LANGUAGE CPP #-} module Control.Applicative.OrphansSpec (main, spec) where import Test.Hspec import Control.Applicative import Data.Orphans () import Data.Monoid import Prelude -- simplest one to use newtype Identity a = Identity { runIdentity :: a } instance Functor Identity where fmap f = Identity . f . runIdentity instance Applicative Identity where pure = Identity 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 () main = hspec spec spec :: Spec spec = do describe "Monoid (Const a b)" $ do it "mempty returns an empty const" $ getConst (mempty :: (Const String Int)) `shouldBe` "" it "mappends const part" $ getConst ((Const "aaa" :: Const String Int) `mappend` (Const "bbb" :: Const String Int)) `shouldBe` "aaabbb" describe "Monad (WrappedMonad m)" $ it "allows to use a Monad interface in a WrappedMonad" $ (runIdentity . unwrapMonad $ (WrapMonad (return 1 :: Identity Int)) >> (WrapMonad (return 2 :: Identity Int))) `shouldBe` (2::Int) base-orphans-0.9.1/test/Control/Exception/0000755000000000000000000000000007346545000016631 5ustar0000000000000000base-orphans-0.9.1/test/Control/Exception/OrphansSpec.hs0000644000000000000000000000057707346545000021423 0ustar0000000000000000module Control.Exception.OrphansSpec (main, spec) where import Test.Hspec import Control.Exception import Data.Orphans () main :: IO () main = hspec spec spec :: Spec spec = do describe "ErrorCall" $ do it "has an Eq instance" $ do ErrorCall "foo" `shouldBe` ErrorCall "foo" it "has an Ord instance" $ do ErrorCall "foo" `shouldSatisfy` (> ErrorCall "bar") base-orphans-0.9.1/test/Data/Bits/0000755000000000000000000000000007346545000015025 5ustar0000000000000000base-orphans-0.9.1/test/Data/Bits/OrphansSpec.hs0000644000000000000000000000077507346545000017617 0ustar0000000000000000{-# 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 base-orphans-0.9.1/test/Data/Foldable/0000755000000000000000000000000007346545000015634 5ustar0000000000000000base-orphans-0.9.1/test/Data/Foldable/OrphansSpec.hs0000644000000000000000000000273607346545000020425 0ustar0000000000000000module Data.Foldable.OrphansSpec (main, spec) where import Test.Hspec import Control.Applicative import Data.Foldable as F import Data.Monoid import Data.Orphans () import Prelude main :: IO () main = hspec spec spec :: Spec spec = do describe "Either Foldable Instance" $ do it "foldMap returns mempty for a Left value" $ foldMap (`mappend` "+") (Left "abc" :: Either String String) `shouldBe` mempty it "foldMap returns the result of the function on the Right value" $ foldMap (`mappend` "+") (Right "abc" :: Either String String) `shouldBe` "abc+" it "foldr returns the accumulator for a Left value" $ F.foldr mappend "+" (Left "abc" :: Either String String) `shouldBe` "+" it "foldr returns the result of the function on the Right value and accumulator" $ F.foldr mappend "+" (Right "abc" :: Either String String) `shouldBe` "abc+" describe "(,) Foldable Instance" $ do it "foldMap returns the result of the function applied to the second element" $ foldMap (`mappend` "+") ("xyz","abc") `shouldBe` "abc+" it "foldr returns the result of the function on the second element of the tuple and accumulator" $ F.foldr mappend "+" ("xyz","abc") `shouldBe` "abc+" describe "Const m Foldable Instance" $ do it "foldMap always returns mempty" $ foldMap (`mappend` "+") (Const "abc") `shouldBe` "" it "foldr applies the function to the accumulator and mempty" $ do F.foldr mappend "+" (Const "abc") `shouldBe` "+" base-orphans-0.9.1/test/Data/Monoid/0000755000000000000000000000000007346545000015351 5ustar0000000000000000base-orphans-0.9.1/test/Data/Monoid/OrphansSpec.hs0000644000000000000000000000066407346545000020140 0ustar0000000000000000module Data.Monoid.OrphansSpec (main, spec) where import Test.Hspec import Data.Monoid import Data.Orphans () main :: IO () main = hspec spec spec :: Spec spec = do describe "Num (Sum a) instance" $ it "allows a Sum value to be created from a number" $ 1 `shouldBe` Sum (1 :: Int) describe "Num (Product a) instance" $ it "allows a Product value to be created from a number" $ 1 `shouldBe` Product (1 :: Int) base-orphans-0.9.1/test/Data/Traversable/0000755000000000000000000000000007346545000016376 5ustar0000000000000000base-orphans-0.9.1/test/Data/Traversable/OrphansSpec.hs0000644000000000000000000000143607346545000021163 0ustar0000000000000000module Data.Traversable.OrphansSpec (main, spec) where import Test.Hspec import Control.Applicative import Data.Orphans () import Data.Traversable import Prelude main :: IO () main = hspec spec spec :: Spec spec = do describe "Either Traversable Instance" $ do it "traverses a Left value" $ traverse (:[]) (Left 5 :: Either Int String) `shouldBe` [Left 5] it "traverses a Right Value" $ traverse (:[]) (Right "aaa" :: Either Int String) `shouldBe` [Right "aaa"] describe "(,) a Traversable Instance" $ do it "traverses a (,) a value" $ traverse (:[]) (5::Int,"aaa") `shouldBe` [(5,"aaa")] describe "Const m Traversable Instance" $ do it "traverses a Const a value" $ do fmap getConst (traverse (:[]) (Const 5 :: Const Int String)) `shouldBe` [5] base-orphans-0.9.1/test/Data/Version/0000755000000000000000000000000007346545000015551 5ustar0000000000000000base-orphans-0.9.1/test/Data/Version/OrphansSpec.hs0000644000000000000000000000154607346545000020340 0ustar0000000000000000{-# LANGUAGE CPP #-} #if MIN_VERSION_base(4,7,0) {-# LANGUAGE OverloadedLists #-} #endif module Data.Version.OrphansSpec (main, spec) where import Test.Hspec import Data.Data import Data.Orphans () import Data.Version main :: IO () main = hspec spec spec :: Spec spec = do describe "Data Version instance" $ it "allows obtaining a Version constructor" $ dataTypeName (dataTypeOf (Version [1,2,3] [])) `shouldBe` -- Some old versions of GHC incorrectly return "Version" instead of -- "Data.Version.Version" due to -- https://gitlab.haskell.org/ghc/ghc/-/issues/20371. #if __GLASGOW_HASKELL__ >= 801 && __GLASGOW_HASKELL__ < 903 "Version" #else "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 base-orphans-0.9.1/test/Foreign/Storable/0000755000000000000000000000000007346545000016417 5ustar0000000000000000base-orphans-0.9.1/test/Foreign/Storable/OrphansSpec.hs0000644000000000000000000000145707346545000021207 0ustar0000000000000000module Foreign.Storable.OrphansSpec (main, spec) where import Test.Hspec import Data.Complex import Data.Orphans () import Data.Ratio import Foreign.Storable main :: IO () main = hspec spec spec :: Spec spec = do describe "Storable Complex instance" $ do it "has twice the sizeOf its realPart" $ do sizeOf (undefined :: Complex Double) `shouldBe` 2*sizeOf (1 :: Double) it "has the alignment of its realPart" $ do alignment (undefined :: Complex Double) `shouldBe` alignment (1 :: Double) describe "Storable Ratio instance" $ do it "has twice the sizeOf its parameterized type" $ do sizeOf (undefined :: Ratio Int) `shouldBe` 2*sizeOf (1 :: Int) it "has the alignment of its parameterized type" $ do alignment (undefined :: Ratio Int) `shouldBe` alignment (1 :: Int) base-orphans-0.9.1/test/GHC/Fingerprint/0000755000000000000000000000000007346545000016143 5ustar0000000000000000base-orphans-0.9.1/test/GHC/Fingerprint/OrphansSpec.hs0000644000000000000000000000111107346545000020716 0ustar0000000000000000{-# 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 base-orphans-0.9.1/test/0000755000000000000000000000000007346545000013253 5ustar0000000000000000base-orphans-0.9.1/test/Spec.hs0000644000000000000000000000005407346545000014500 0ustar0000000000000000{-# OPTIONS_GHC -F -pgmF hspec-discover #-} base-orphans-0.9.1/test/System/Posix/Types/0000755000000000000000000000000007346545000016745 5ustar0000000000000000base-orphans-0.9.1/test/System/Posix/Types/IntWord.hs0000644000000000000000000000016207346545000020666 0ustar0000000000000000module System.Posix.Types.IntWord (module IntWord) where import Data.Int as IntWord import Data.Word as IntWord base-orphans-0.9.1/test/System/Posix/Types/OrphansSpec.hs0000644000000000000000000001144207346545000021530 0ustar0000000000000000{-# LANGUAGE CPP #-} {-# OPTIONS_GHC -fno-warn-deprecations #-} module System.Posix.Types.OrphansSpec (main, spec) where #include "HsBaseConfig.h" import Test.Hspec #if defined(HTYPE_DEV_T) import qualified Control.Applicative as App (liftA2) import Data.Bits (Bits(..)) import Data.Orphans () import System.Posix.Types.IntWord import System.Posix.Types import Test.Hspec.QuickCheck (prop) import Test.QuickCheck (NonNegative(..), NonZero(..)) #endif main :: IO () main = hspec spec #if defined(HTYPE_DEV_T) type HDev = HTYPE_DEV_T spec :: Spec spec = describe "CDev" $ do describe "Bits instance" $ do prop "implements (.&.)" $ pred2HDevHDev (.&.) (.&.) prop "implements (.|.)" $ pred2HDevHDev (.|.) (.|.) prop "implements xor" $ pred2HDevHDev xor xor prop "implements shift" $ pred2IntHDev shift shift prop "implements rotate" $ pred2IntHDev rotate rotate prop "implements setBit" $ pred2NonNegIntHDev setBit setBit prop "implements clearBit" $ pred2NonNegIntHDev clearBit clearBit prop "implements complementBit" $ pred2NonNegIntHDev complementBit complementBit prop "implements testBit" $ pred2NonNegIntEq testBit testBit prop "implements complement" $ pred1HDevHDev complement complement prop "implements bit" $ pred1NonNegIntHDev bit bit prop "implements bitSize" $ pred1HDevEq bitSize bitSize prop "implements isSigned" $ pred1HDevEq isSigned isSigned describe "Bounded instance" $ do it "implements minBound" $ toInteger (minBound :: CDev) `shouldBe` toInteger (minBound :: HDev) it "implements maxBound" $ toInteger (maxBound :: CDev) `shouldBe` toInteger (maxBound :: HDev) describe "Integral instance" $ do prop "implements quot" $ pred2HDevHDev quot quot prop "implements rem" $ pred2HDevHDev rem rem prop "implements div" $ pred2HDevHDev div div prop "implements mod" $ pred2HDevHDev mod mod prop "implements quotRem" $ pred2HDevPair quotRem quotRem prop "implements divMod" $ pred2HDevPair divMod divMod prop "implements toInteger" $ pred1HDevEq toInteger toInteger eqCDevHDev :: CDev -> HDev -> Bool eqCDevHDev cDev hDev = toInteger cDev == toInteger hDev pred1Common :: (b -> c -> d) -> (a -> b) -> (a -> c) -> a -> d pred1Common = App.liftA2 pred1HDev :: (b -> c -> Bool) -> (CDev -> b) -> (HDev -> c) -> HDev -> Bool pred1HDev p f = pred1Common p (f . fromIntegral) pred1HDevEq :: Eq a => (CDev -> a) -> (HDev -> a) -> HDev -> Bool pred1HDevEq = pred1HDev (==) pred1HDevHDev :: (CDev -> CDev) -> (HDev -> HDev) -> HDev -> Bool pred1HDevHDev = pred1HDev 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) -> (a -> b -> d) -> a -> b -> e pred2Common p f g x y = p (f x y) (g x y) pred2HDev :: (a -> b -> Bool) -> (CDev -> CDev -> a) -> (HDev -> HDev -> b) -> NonZero HDev -> NonZero HDev -> Bool pred2HDev eqv cDevPred hDevPred = pred2Common eqv (\nz1 nz2 -> cDevPred (fromIntegral $ getNonZero nz1) (fromIntegral $ getNonZero nz2)) (\nz1 nz2 -> hDevPred (getNonZero nz1) (getNonZero nz2)) pred2HDevHDev :: (CDev -> CDev -> CDev) -> (HDev -> HDev -> HDev) -> NonZero HDev -> NonZero HDev -> Bool pred2HDevHDev = pred2HDev eqCDevHDev pred2HDevPair :: (CDev -> CDev -> (CDev, CDev)) -> (HDev -> HDev -> (HDev, HDev)) -> NonZero HDev -> NonZero HDev -> Bool pred2HDevPair = pred2HDev $ \(cDev1, cDev2) (hDev1, hDev2) -> toInteger cDev1 == toInteger hDev1 && toInteger cDev2 == toInteger hDev2 pred2Int :: (a -> b -> Bool) -> (CDev -> Int -> a) -> (HDev -> Int -> b) -> HDev -> Int -> Bool pred2Int eqv cDevPred = pred2Common eqv (cDevPred . fromIntegral) pred2IntHDev :: (CDev -> Int -> CDev) -> (HDev -> Int -> HDev) -> HDev -> Int -> Bool pred2IntHDev = pred2Int eqCDevHDev 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 () #endif