base-compat-0.10.5/0000755000000000000000000000000013362115654012164 5ustar0000000000000000base-compat-0.10.5/base-compat.cabal0000644000000000000000000001543513362115654015353 0ustar0000000000000000name: base-compat version: 0.10.5 license: MIT license-file: LICENSE copyright: (c) 2012-2018 Simon Hengel, (c) 2014-2018 João Cristóvão, (c) 2015-2018 Ryan Scott author: Simon Hengel , João Cristóvão , Ryan Scott maintainer: Simon Hengel , João Cristóvão , Ryan Scott build-type: Simple cabal-version: >= 1.8 category: Compatibility synopsis: A compatibility layer for base description: Provides functions available in later versions of @base@ to a wider range of compilers, without requiring you to use CPP pragmas in your code. See the for what is covered. Also see the for recent changes. . Note that @base-compat@ does not add any orphan instances. There is a separate package, @@, for that. . In addition, @base-compat@ does not backport any data types or type classes. See @@ for more info. . @base-compat@ is designed to have zero dependencies. For a version of @base-compat@ that depends on compatibility libraries for a wider support window, see the @@ package. Most of the modules in this library have the same names as in @base-compat-batteries@ to make it easier to switch between the two. There also exist versions of each module with the suffix @.Repl@, which are distinct from anything in @base-compat-batteries@, to allow for easier use in GHCi. tested-with: GHC == 7.0.* , GHC == 7.2.* , GHC == 7.4.* , GHC == 7.6.* , GHC == 7.8.* , GHC == 7.10.* , GHC == 8.0.* , GHC == 8.2.* , GHC == 8.4.* , GHC == 8.6.* extra-source-files: CHANGES.markdown, README.markdown source-repository head type: git location: https://github.com/haskell-compat/base-compat subdir: base-compat library ghc-options: -Wall build-depends: base >= 4.3 && < 5 if !os(windows) && !os(halvm) build-depends: unix ghc-options: -fno-warn-duplicate-exports if impl(ghc >= 7.10) ghc-options: -fno-warn-trustworthy-safe hs-source-dirs: src exposed-modules: Control.Concurrent.Compat Control.Concurrent.MVar.Compat Control.Exception.Compat Control.Monad.Compat Control.Monad.Fail.Compat Control.Monad.IO.Class.Compat Control.Monad.ST.Lazy.Unsafe.Compat Control.Monad.ST.Unsafe.Compat Data.Bifoldable.Compat Data.Bifunctor.Compat Data.Bitraversable.Compat Data.Bits.Compat Data.Bool.Compat Data.Complex.Compat Data.Either.Compat Data.Foldable.Compat Data.Function.Compat Data.Functor.Compat Data.Functor.Compose.Compat Data.Functor.Const.Compat Data.Functor.Contravariant.Compat Data.Functor.Identity.Compat Data.Functor.Product.Compat Data.Functor.Sum.Compat Data.IORef.Compat Data.List.Compat Data.List.NonEmpty.Compat Data.Monoid.Compat Data.Proxy.Compat Data.Ratio.Compat Data.Semigroup.Compat Data.STRef.Compat Data.String.Compat Data.Type.Coercion.Compat Data.Version.Compat Data.Void.Compat Data.Word.Compat Debug.Trace.Compat Foreign.Compat Foreign.ForeignPtr.Compat Foreign.ForeignPtr.Safe.Compat Foreign.ForeignPtr.Unsafe.Compat Foreign.Marshal.Alloc.Compat Foreign.Marshal.Array.Compat Foreign.Marshal.Compat Foreign.Marshal.Safe.Compat Foreign.Marshal.Unsafe.Compat Foreign.Marshal.Utils.Compat Numeric.Compat Numeric.Natural.Compat Prelude.Compat System.Environment.Compat System.Exit.Compat System.IO.Unsafe.Compat Text.Read.Compat Type.Reflection.Compat Control.Concurrent.Compat.Repl Control.Concurrent.MVar.Compat.Repl Control.Exception.Compat.Repl Control.Monad.Compat.Repl Control.Monad.Fail.Compat.Repl Control.Monad.IO.Class.Compat.Repl Control.Monad.ST.Lazy.Unsafe.Compat.Repl Control.Monad.ST.Unsafe.Compat.Repl Data.Bifoldable.Compat.Repl Data.Bifunctor.Compat.Repl Data.Bitraversable.Compat.Repl Data.Bits.Compat.Repl Data.Bool.Compat.Repl Data.Complex.Compat.Repl Data.Either.Compat.Repl Data.Foldable.Compat.Repl Data.Function.Compat.Repl Data.Functor.Compat.Repl Data.Functor.Compose.Compat.Repl Data.Functor.Const.Compat.Repl Data.Functor.Contravariant.Compat.Repl Data.Functor.Identity.Compat.Repl Data.Functor.Product.Compat.Repl Data.Functor.Sum.Compat.Repl Data.IORef.Compat.Repl Data.List.Compat.Repl Data.List.NonEmpty.Compat.Repl Data.Monoid.Compat.Repl Data.Proxy.Compat.Repl Data.Ratio.Compat.Repl Data.Semigroup.Compat.Repl Data.STRef.Compat.Repl Data.String.Compat.Repl Data.Type.Coercion.Compat.Repl Data.Version.Compat.Repl Data.Void.Compat.Repl Data.Word.Compat.Repl Debug.Trace.Compat.Repl Foreign.Compat.Repl Foreign.ForeignPtr.Compat.Repl Foreign.ForeignPtr.Safe.Compat.Repl Foreign.ForeignPtr.Unsafe.Compat.Repl Foreign.Marshal.Alloc.Compat.Repl Foreign.Marshal.Array.Compat.Repl Foreign.Marshal.Compat.Repl Foreign.Marshal.Safe.Compat.Repl Foreign.Marshal.Unsafe.Compat.Repl Foreign.Marshal.Utils.Compat.Repl Numeric.Compat.Repl Numeric.Natural.Compat.Repl Prelude.Compat.Repl System.Environment.Compat.Repl System.Exit.Compat.Repl System.IO.Unsafe.Compat.Repl Text.Read.Compat.Repl Type.Reflection.Compat.Repl base-compat-0.10.5/README.markdown0000644000000000000000000003516613362115654014700 0ustar0000000000000000# A compatibility layer for `base` [![Hackage](https://img.shields.io/hackage/v/base-compat.svg)][Hackage: base-compat] [![Hackage Dependencies](https://img.shields.io/hackage-deps/v/base-compat.svg)](http://packdeps.haskellers.com/reverse/base-compat) [![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] [Hackage: base-compat]: http://hackage.haskell.org/package/base-compat "base-compat 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 The scope of `base-compat` is to provide functions available in later versions of base to a wider (older) range of compilers. In addition, successful library proposals that have been accepted to be part of upcoming versions of `base` are also included. This package is not intended to replace `base`, but to complement it. Note that `base-compat` does not add any orphan instances. There is a separate package [`base-orphans`](https://github.com/haskell-compat/base-orphans) for that. In addition, `base-compat` only backports functions. In particular, we purposefully do not backport data types or type classes introduced in newer versions of `base`. For more info, see the [Data types and type classes](#data-types-and-type-classes) section. `base-compat` is intentionally designed to have zero dependencies. As a consequence, there are some modules that can only be backported up to certain versions of `base`. If an even wider support window is desired in these scenarios, there also exists a `base-compat-batteries` package which augments `base-compat` with certain compatibility package dependencies. For more info, see the [Dependencies](#dependencies) section. ## Basic usage In your cabal file, you should have something like this: ``` build-depends: base >= 4.3 , base-compat >= 0.9.0 ``` Then, lets say you want to use the `isRight` function introduced with `base-4.7.0.0`. Replace: ``` import Data.Either ``` with ``` import Data.Either.Compat ``` _Note (1)_: There is no need to import both unqualified. The `.Compat` modules re-exports the original module. _Note (2)_: If a given module `.Compat` version is not defined, that either means that: * The module has not changed in recent base versions, thus no `.Compat` is needed. * The module has changed, but the changes depend on newer versions of GHC, and thus are not portable. * The module has changed, but those changes have not yet been merged in `base-compat`: patches are welcomed! ## Using `Prelude.Compat` If you want to use `Prelude.Compat` (which provides all the AMP/Traversable/Foldable changes from `base-4.8.0.0`), it's best to hide `Prelude`, e.g.: import Prelude () import Prelude.Compat main :: IO () main = mapM_ print (Just 23) Alternatively, you can use the `NoImplicitPrelude` language extension: {-# LANGUAGE NoImplicitPrelude #-} import Prelude.Compat main :: IO () main = mapM_ print (Just 23) Note that we use mapM_ :: (Foldable t, Monad m) => (a -> m b) -> t a -> m () from `Data.Foldable` here, which is only exposed from `Prelude` since `base-4.8.0.0`. Using this approach allows you to write code that works seamlessly with all versions of GHC that are supported by `base-compat`. ## What is covered So far the following is covered. ### For compatibility with the latest released version of `base` * `Prelude.Compat` incorporates the AMP/Foldable/Traversable changes and exposes the same interface as `Prelude` from `base-4.9.0.0` * `System.IO.Error.catch` is not re-exported from `Prelude.Compat` for older versions of `base` * `Text.Read.Compat.readMaybe` * `Text.Read.Compat.readEither` * `Data.Monoid.Compat.<>` * Added `bitDefault`, `testBitDefault`, and `popCountDefault` to `Data.Bits.Compat` * Added `toIntegralSized` to `Data.Bits.Compat` (if using `base-4.7`) * Added `bool` function to `Data.Bool.Compat` * Added `isLeft`, `isRight`, `fromLeft`, and `fromRight` to `Data.Either.Compat` * Added `forkFinally` to `Control.Concurrent.Compat` * Added `withMVarMasked` function to `Control.Concurrent.MVar.Compat` * Added `(<$!>)` function to `Control.Monad.Compat` * Weakened `RealFloat` constraints on `realPart`, `imagPart`, `conjugate`, `mkPolar`, and `cis` in `Data.Complex.Compat` * Added more efficient `maximumBy`/`minimumBy` to `Data.Foldable.Compat` * Added `($>)` and `void` functions to `Data.Functor.Compat` * `(&)` function to `Data.Function.Compat` * `($>)` and `void` functions to `Data.Functor.Compat` * `modifyIORef'`, `atomicModifyIORef'` and `atomicWriteIORef` to `Data.IORef.Compat` * `dropWhileEnd`, `isSubsequenceOf`, `sortOn`, and `uncons` functions to `Data.List.Compat` * Correct versions of `nub`, `nubBy`, `union`, and `unionBy` to `Data.List.Compat` * `asProxyTypeOf` with a generalized type signature to `Data.Proxy.Compat` * `modifySTRef'` to `Data.STRef.Compat` * `String`, `lines`, `words`, `unlines`, and `unwords` to `Data.String.Compat` * `gcoerceWith` to `Data.Type.Coercion.Compat` * `makeVersion` function to `Data.Version.Compat` * `traceId`, `traceShowId`, `traceM`, and `traceShowM` functions to `Debug.Trace.Compat` * `byteSwap16`, `byteSwap32`, and `byteSwap64` to `Data.Word.Compat` * `plusForeignPtr` to `Foreign.ForeignPtr.Compat` * `calloc` and `callocBytes` functions to `Foreign.Marshal.Alloc.Compat` * `callocArray` and `callocArray0` functions to `Foreign.Marshal.Array.Compat` * `fillBytes` to `Foreign.Marshal.Utils.Compat` * Added `Data.List.Compat.scanl'` * `showFFloatAlt` and `showGFloatAlt` to `Numeric.Compat` * `lookupEnv`, `setEnv` and `unsetEnv` to `System.Environment.Compat` * `unsafeFixIO` and `unsafeDupablePerformIO` to `System.IO.Unsafe.IO` * `RuntimeRep`-polymorphic `($!)` to `Prelude.Compat` * `RuntimeRep`-polymorphic `throw` to `Control.Exception.Compat` ## What is not covered ### Data types and type classes `base-compat` purposefully does not export any data types or type classes that were introduced in more recent versions of `base`. The main reasoning for this policy is that it is not some data types and type classes have had their APIs change in different versions of `base`, which makes having a consistent compatibility API for them practically impossible. As an example, consider the `FiniteBits` type class. It was introduced in [`base-4.7.0.0`](http://hackage.haskell.org/package/base-4.7.0.0/docs/Data-Bits.html#t:FiniteBits) with the following API: ```haskell class Bits b => FiniteBits b where finiteBitSize :: b -> Int ``` However, in [`base-4.8.0.0`](http://hackage.haskell.org/package/base-4.8.0.0/docs/Data-Bits.html#t:FiniteBits), `FiniteBits` gained additional functions: ```haskell class Bits b => FiniteBits b where finiteBitSize :: b -> Int countLeadingZeros :: b -> Int -- ^ @since 4.8.0.0 countTrailingZeros :: b -> Int -- ^ @since 4.8.0.0 ``` This raises the question: how can `FiniteBits` be backported consistently across all versions of `base`? One approach is to backport the API exposed in `base-4.8.0.0` on versions prior to `4.7.0.0`. The problem with this is that `countLeadingZeros` and `countTrailingZeros` are not exposed in `base-4.7.0.0`, so instances of `FiniteBits` would have to be declared like this: ```haskell instance FiniteBits Foo where finiteBitSize = ... #if MIN_VERSION_base(4,8,0) || !(MIN_VERSION_base(4,7,0)) countLeadingZeros = ... countTrailingZeros = ... #endif ``` Another approach is to backport the API from `base-4.7.0.0` and to declare additional methods outside of the class: ```haskell #if MIN_VERSION_base(4,7,0) && !(MIN_VERSION_base(4,8,0)) countLeadingZeros :: FiniteBits b => b -> Int countLeadingZeros = {- default implementation #-} #endif ``` The situation is only slightly better for classes which exist across all versions of `base`, but have grown their API. For example, it's tempting to define ```haskell #if !(MIN_VERSION_base(4,8,0)) displayException :: Exception e => e -> String displayException = show #endif ``` As with the previous approach, you won't be able to define new members of the type class without CPP guards. In other words, the non-CPP approach would limit uses to the lowest common denominator. As neither approach is a very satisfactory solution, and to embrace consistency, we do not pursue either approach. For similar reasons, we do not backport data types. ### Dependencies `base-compat` is designed to have zero dependencies (besides libraries that ship with GHC itself). A consequence of this choice is that there are certain modules that have a "limited" support window. An important example of this is `Prelude.Compat`, which backports the `Semigroup` class to versions of `base` older than 4.11 (when it was added to the `Prelude`). Because `Semigroup` was not added to `base` until `base-4.9`, `base-compat` cannot backport it to any earlier version of `base` than this. If you would instead desire to be able to use a version of `Prelude.Compat` that _does_ backport `Semigroup` to even older versions of `base`, even if it means pulling in other dependencies, then you are in luck. There also exists a `base-compat-batteries` package, which exposes a strict superset of the API in `base-compat`. `base-compat-batteries` has all the same modules as `base-compat`, but exposes more functionality on more versions of `base` by reexporting things from compatibility libraries whenever necessary. (For instance, `base-compat-batteries` exports the `Semigroup` class from the `semigroups` library when built against versions of `base` older than 4.9.) Because `base-compat` and `base-compat-batteries` have the same module names, they are quite easy to switch out for one another in library projects, at the expense of having clashing names if one tries to import them in GHCi. To work around this issue, `base-compat` and `base-compat-batteries` also provide copies of each module with the suffix `.Repl` (for `base-compat`) and `.Repl.Batteries` (for `base-compat-batteries`) to give them globally unique namespaces in the event one wants to import them into GHCi. Here is a list of compatibility libraries that `base-compat-batteries` depends on, paired with the things that each library backports: * [`bifunctors`](http://hackage.haskell.org/package/bifunctors) for: * The [`Bifunctor`](http://hackage.haskell.org/package/base-4.8.0.0/docs/Data-Bifunctor.html#t:Bifunctor) type class, introduced in `base-4.8.0.0` * The [`Bifoldable`](http://hackage.haskell.org/package/base-4.10.0.0/docs/Data-Bifoldable.html#t:Bifoldable) and [`Bitraversable`](http://hackage.haskell.org/package/base-4.10.0.0/docs/Data-Bitraversable.html#t:Bitraversable) type classes, introduced in `base-4.10.0.0` * [`contravariant`](http://hackage.haskell.org/package/contravariant) for the [`Contravariant`](http://hackage.haskell.org/package/base-4.12.0.0/docs/Data-Functor-Contravariant.html#t:Contravariant) type class, introduced in `base-4.12.0.0`. * [`fail`](http://hackage.haskell.org/package/fail) for the [`MonadFail`](http://hackage.haskell.org/package/base-4.9.0.0/docs/Control-Monad-Fail.html#t:MonadFail) type class, introduced in `base-4.9.0.0` * [`nats`](http://hackage.haskell.org/package/nats) for the [`Natural`](http://hackage.haskell.org/package/base-4.8.0.0/docs/Numeric-Natural.html) data type, introduced in `base-4.8.0.0` * [`semigroups`](http://hackage.haskell.org/package/semigroups) for the [`Semigroup`](http://hackage.haskell.org/package/base-4.9.0.0/docs/Data-Semigroup.html#t:Semigroup) typeclass and the [`NonEmpty`](http://hackage.haskell.org/package/base-4.9.0.0/docs/Data-List-NonEmpty.html#t:NonEmpty), [`Min`](http://hackage.haskell.org/package/base-4.9.0.0/docs/Data-Semigroup.html#t:Min), [`Max`](http://hackage.haskell.org/package/base-4.9.0.0/docs/Data-Semigroup.html#t:Max), [`First`](http://hackage.haskell.org/package/base-4.9.0.0/docs/Data-Semigroup.html#t:First), [`Last`](http://hackage.haskell.org/package/base-4.9.0.0/docs/Data-Semigroup.html#t:Last), [`WrappedMonoid`](http://hackage.haskell.org/package/base-4.9.0.0/docs/Data-Semigroup.html#t:WrappedMonoid), [`Option`](http://hackage.haskell.org/package/base-4.9.0.0/docs/Data-Semigroup.html#t:Option), and [`Arg`](http://hackage.haskell.org/package/base-4.9.0.0/docs/Data-Semigroup.html#t:Arg) data types, introduced in `base-4.9.0.0` * [`tagged`](http://hackage.haskell.org/package/tagged) for the [`Proxy`](http://hackage.haskell.org/package/base-4.7.0.0/docs/Data-Proxy.html#t:Proxy) data type, introduced in `base-4.7.0.0` * [`transformers`](http://hackage.haskell.org/package/transformers) for: * The [`Identity`](http://hackage.haskell.org/package/base-4.8.0.0/docs/Data-Functor-Identity.html#t:Identity) data type, introduced in `base-4.8.0.0` * The [`MonadIO`](http://hackage.haskell.org/package/base-4.9.0.0/docs/Control-Monad-IO-Class.html#t:MonadIO) type class; and the [`Compose`](http://hackage.haskell.org/package/base-4.9.0.0/docs/Data-Functor-Compose.html#t:Compose), [`Product`](http://hackage.haskell.org/package/base-4.9.0.0/docs/Data-Functor-Product.html#t:Product), and [`Sum`](http://hackage.haskell.org/package/base-4.9.0.0/docs/Data-Functor-Sum.html#t:Sum) data types, introduced in `base-4.9.0.0` * [`void`](http://hackage.haskell.org/package/void) for the [`Void`](http://hackage.haskell.org/package/base-4.8.0.0/docs/Data-Void.html#t:Void) data type, introduced in `base-4.8.0.0` ## Supported versions of GHC/`base` * `ghc-8.6.1` / `base-4.12.0.0` * `ghc-8.4.4` / `base-4.11.1.0` * `ghc-8.4.3` / `base-4.11.1.0` * `ghc-8.4.2` / `base-4.11.1.0` * `ghc-8.4.1` / `base-4.11.0.0` * `ghc-8.2.2` / `base-4.10.1.0` * `ghc-8.2.1` / `base-4.10.0.0` * `ghc-8.0.2` / `base-4.9.1.0` * `ghc-8.0.1` / `base-4.9.0.0` * `ghc-7.10.3` / `base-4.8.2.0` * `ghc-7.10.2` / `base-4.8.1.0` * `ghc-7.10.1` / `base-4.8.0.0` * `ghc-7.8.4` / `base-4.7.0.2` * `ghc-7.8.3` / `base-4.7.0.1` * `ghc-7.8.2` / `base-4.7.0.0` * `ghc-7.8.1` / `base-4.7.0.0` * `ghc-7.6.3` / `base-4.6.0.1` * `ghc-7.6.2` / `base-4.6.0.1` * `ghc-7.6.1` / `base-4.6.0.0` * `ghc-7.4.2` / `base-4.5.1.0` * `ghc-7.4.1` / `base-4.5.0.0` * `ghc-7.2.2` / `base-4.4.1.0` * `ghc-7.2.1` / `base-4.4.0.0` * `ghc-7.0.4` / `base-4.3.1.0` * `ghc-7.0.3` / `base-4.3.1.0` * `ghc-7.0.2` / `base-4.3.1.0` * `ghc-7.0.1` / `base-4.3.0.0` We also make an attempt to keep `base-compat` 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-compat-0.10.5/CHANGES.markdown0000644000000000000000000001726213362115654015010 0ustar0000000000000000## Changes in 0.10.5 [2018.10.18] - Enable `BangPatterns` in `Prelude.Compat`. ## Changes in 0.10.4 [2018.07.03] - Make more modules `Trustworthy`. In particular, fix a regression in which `Prelude.Compat` was inferred as `Unsafe` by explicitly marking it as `Trustwothy`. ## Changes in 0.10.3 [2018.07.02] - Backport the proper fixity for `($!)`, which was accidentally omitted in `base-compat-0.10.2`. ## Changes in 0.10.2 [2018.07.02] - Sync with `base-4.12`/GHC 8.6 - Backport `RuntimeRep`-polymorphic versions of `($!)` and `throw` to `Prelude.Compat` and `Control.Exception.Compat`, respectively (if using `base-4.10`/GHC 8.2 or later). - Introduce the `Data.Functor.Contravariant.Compat` module, which reexports `Data.Functor.Contravariant` if using `base-4.12`/GHC 8.6 or later. See `Data.Functor.Contravariant.Compat` in the corresponding `base-compat-batteries` release for a version with a wider support window. ## Changes in 0.10.1 [2018.04.10] - Add `Data.List.NonEmpty.Compat`. - Reexport `(Data.Semigroup.<>)` from `Data.Monoid.Compat` back to `base-4.9`. ## Changes in 0.10.0 [2018.04.05] - Sync with `base-4.11`/GHC 8.4 - Backport `Semigroup((<>))` to `Prelude.Compat`. Note that the `Semigroup` class has only been in `base` since `base-4.9`/GHC 8.0, so accordingly, this can only be backported back to GHC 8.0. If you wish to have a version of `Prelude.Compat` that backports `Semigroup` to older GHCs (by conditionally depending on the `semigroups` library), use the `Prelude.Compat` module from the `base-compat-batteries` package. - Backport `(<&>)` to `Data.Functor.Compat` - Backport `iterate'` to `Data.List.Compat` - Backport `showHFloat` to `Numeric.Compat` - Backport a `RuntimeRep`-polymorphic `withTypeable` function to `Type.Reflection.Compat`. (This is only exported on `base-4.10`/GHC 8.2.) - Introduce the following modules, back until the oldest version of `base` that can support backporting them. If you wish to use them in conjunction with older versions of `base`, use the `base-compat-batteries` package. - `Control.Monad.Fail.Compat` (back until `base-4.9`/GHC 8.0) - `Control.Monad.IO.Class.Compat` (back until `base-4.9`/GHC 8.0) - `Data.Bifunctor` (back until `base-4.8`/GHC 7.10) - `Data.Bifoldable` and `Data.Bitraversable` (back until `base-4.10`/GHC 8.2) - `Data.Functor.Compose.Compat`, `Data.Functor.Product.Compat`, and `Data.Functor.Sum.Compat` (back until `base-4.9`/GHC 8.0) - `Data.Functor.Identity.Compat` (back until `base-4.8`/GHC 7.10) - `Data.Semigroup.Compat` (back until `base-4.9`/GHC 8.0) - `Data.Void.Compat` (back until `base-4.8`/GHC 7.10) - `Numeric.Natural.Compat` (back until `base-4.8`/GHC 7.10) - Introduce versions of modules with the suffix `.Repl`. These simply reexport the contents of their counterparts without the `.Repl` suffix to provide a globally unique namespace to import from in the event one wants to import `base-compat` modules into GHCi. (In `base-compat-batteries`, the corresponding suffix is `.Repl.Batteries`.) ## Changes in 0.9.3 [2017.04.10] - Sync with `base-4.10`/GHC 8.2 - Backport `fromLeft`/`fromRight` to `Data.Either.Compat` - Backport implementations of `maximumBy`/`minimumBy` which use constant stack space to `Data.Foldable.Compat` - Backport `asProxyTypeOf` with a generalized type signature to `Data.Proxy.Compat` - Backport `gcoerceWith` to `Data.Type.Coercion.Compat` - Backport `plusForeignPtr` to `Foreign.ForeignPtr.Compat` ## Changes in 0.9.2 - Allow building on the HaLVM ## Changes in 0.9.1 - Use the more efficient version of `replicateM` and `replicateM_` introduced in `base-4.9` ## Changes in 0.9.0 - Sync with `base-4.9`/GHC 8.0 - Weakened `RealFloat` constraints on `realPart`, `imagPart`, `conjugate`, `mkPolar`, and `cis` in `Data.Complex.Compat` - Backport `Foreign.ForeignPtr.Safe` and `Foreign.Marshal.Safe` - Generalize `filterM`, `forever`, `mapAndUnzipM`, `zipWithM`, `zipWithM_`, `replicateM`, and `replicateM_` in `Control.Monad` from `Monad` to `Applicative` - Backport `.Unsafe.Compat` modules (for `Control.Monad.ST`, `Control.Monad.ST.Lazy`, `Foreign.ForeignPtr`, and `Foreign.Marshal`) - Backport `forkFinally` and `forkOSWithUnmask` to `Control.Concurrent.Compat` - Backport `Data.Functor.Const` - Backport `modifyIORef'`, `atomicModifyIORef'` and `atomicWriteIORef` to `Data.IORef.Compat` - `Data.Ratio.{denominator,numerator}` have no `Integral` constraint anymore - Backport `modifySTRef'` to `Data.STRef.Compat` - Export `String`, `lines`, `words`, `unlines`, and `unwords` to `Data.String.Compat` - Generalize `Debug.Trace.{traceM, traceShowM}` from `Monad` to `Applicative` - Backport `errorWithoutStackTrace` to `Prelude.Compat` - Backport `unsafeFixIO` and `unsafeDupablePerformIO` to `System.IO.Unsafe.Compat` ## Changes in 0.8.2 - Backport `bitDefault`, `testBitDefault`, and `popCountDefault` in `Data.Bits.Compat` to all versions of `base` - Backport `toIntegralSized` to `base-4.7` - Backport `nub` and `nubBy` (as well as `union` and `unionBy`, which are implemented in terms of them) to fix logic error in `Data.List.Compat` - Backport `byteSwap16`, `byteSwap32`, and `byteSwap64` to `Data.Word.Compat` - Backport `fillBytes` in `Foreign.Marshal.Utils.Compat` - Backport `showFFloatAlt` and `showGFloatAlt` to `Numeric.Compat` ## Changes in 0.8.1.1 - Fixed Windows build ## Changes in 0.8.1 - Implement `setEnv` and `unsetEnv` in `System.Environment.Compat` (which were ported from the `setenv` package). As a result, `base-compat` now depends on `unix` on POSIX-like operating systems. - Drop GHC 6.12 (and `base-4.2.0.0`) compatibility ## Changes in 0.8.0.1 - Retrospective version bump updating the changelog to reflect the changes made in 0.8.0 ## Changes 0.8.0 - All orphan instances were split off into a separate package, [`base-orphans`](https://github.com/haskell-compat/base-orphans) - `base-compat` no longer redefines the data types `Down` and `Alt`. See [here](https://github.com/haskell-compat/base-compat/issues/17) for the discussion that led to this change. - Update `Control.Monad.Compat` for `base-4.8.0.0` - Update `Data.List.Compat` for `base-4.8.0.0` - Update `Data.Foldable.Compat` for `base-4.8.0.0` ## Changes in 0.7.1 - Backported `Alt` to `Data.Monoid.Compat` - Backported `Down` to `Data.Ord.Compat` ## Changes in 0.7.0 - Add functions and orphan instances introduced by changes to `base-4.7.0.0` and `base-4.8.0.0` ## Changes in 0.6.0 - Update `Prelude.Compat` for `base-4.8.0.0` and AMP ## Changes in 0.5.0 - Remove Control.Exception.Base.Compat and GHC.Exception.Compat - Add System.Exit.Compat.die - Compatibility with base-4.7.1 ## Changes in 0.4.1 - Add `setEnv` and `unsetEnv` to `System.Environment.Compat` ## Changes in 0.4.0 - Major refactoring: base-compat no longer aims to replace all base, only new code is included in module .Compat - Removed stubbed modules - Removed generation scripts ## Changes in 0.3 - Added functions from Base 4.7 (bool, isLeft, isRight) - Added instances from Base 4.7 (Either Foldable, Traversable,...) ## Changes in 0.2.1 - Fix build on windows ## Changes in 0.2.0 - Re-export everything from base - provides access to `VERSION_base` and `MIN_VERSION_base` CPP macros (with `#include "base-compat.h"`) - Do not re-export `System.IO.Error.catch` from `Prelude` for `base` < 4.6.0 - Add `Eq`/`Ord` instance for `ErrorCall` - Remove `GHC.IOBase`, `GHC.Handle`, `Control.Concurrent.QSem`, `Control.Concurrent.QSemN`, `Control.Concurrent.SampleVar`, `Data.HashTable` ## Changes in 0.1.0 - Remove getExecutablePath, it did not work with GHC < 7.2 (patches welcome!) - Add `<>` base-compat-0.10.5/Setup.lhs0000644000000000000000000000011413362115654013770 0ustar0000000000000000#!/usr/bin/env runhaskell > import Distribution.Simple > main = defaultMain base-compat-0.10.5/LICENSE0000644000000000000000000000214013362115654013166 0ustar0000000000000000Copyright (c) 2012-2018 Simon Hengel and 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-compat-0.10.5/src/0000755000000000000000000000000013362115654012753 5ustar0000000000000000base-compat-0.10.5/src/Type/0000755000000000000000000000000013362115654013674 5ustar0000000000000000base-compat-0.10.5/src/Type/Reflection/0000755000000000000000000000000013362115654015766 5ustar0000000000000000base-compat-0.10.5/src/Type/Reflection/Compat.hs0000644000000000000000000000202613362115654017545 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude #-} #if __GLASGOW_HASKELL__ >= 702 {-# LANGUAGE Trustworthy #-} #endif #if MIN_VERSION_base(4,10,0) && !(MIN_VERSION_base(4,11,0)) {-# LANGUAGE RankNTypes #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE TypeInType #-} #endif module Type.Reflection.Compat ( #if MIN_VERSION_base(4,10,0) module Base , withTypeable #endif ) where #if MIN_VERSION_base(4,11,0) import Type.Reflection as Base #elif MIN_VERSION_base(4,10,0) import Type.Reflection as Base hiding (withTypeable) #endif #if MIN_VERSION_base(4,10,0) && !(MIN_VERSION_base(4,11,0)) import GHC.Exts (TYPE) import Type.Reflection (Typeable, TypeRep) import Unsafe.Coerce (unsafeCoerce) -- | Use a 'TypeRep' as 'Typeable' evidence. withTypeable :: forall (a :: k) (r :: TYPE rep). () => TypeRep a -> (Typeable a => r) -> r withTypeable rep k = unsafeCoerce k' rep where k' :: Gift a r k' = Gift k -- | A helper to satisfy the type checker in 'withTypeable'. newtype Gift a (r :: TYPE rep) = Gift (Typeable a => r) #endif base-compat-0.10.5/src/Type/Reflection/Compat/0000755000000000000000000000000013362115654017211 5ustar0000000000000000base-compat-0.10.5/src/Type/Reflection/Compat/Repl.hs0000644000000000000000000000044413362115654020451 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Type.Reflection.Compat" -- from a globally unique namespace. module Type.Reflection.Compat.Repl ( module Type.Reflection.Compat ) where import "this" Type.Reflection.Compat base-compat-0.10.5/src/Text/0000755000000000000000000000000013362115654013677 5ustar0000000000000000base-compat-0.10.5/src/Text/Read/0000755000000000000000000000000013362115654014552 5ustar0000000000000000base-compat-0.10.5/src/Text/Read/Compat.hs0000644000000000000000000000245513362115654016337 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude #-} module Text.Read.Compat ( -- * The 'Read' class Read(..), ReadS, -- * Haskell 2010 functions reads, read, readParen, lex, -- * New parsing functions module Text.ParserCombinators.ReadPrec, L.Lexeme(..), lexP, parens, readListDefault, readListPrecDefault, readEither, readMaybe ) where import Text.Read import Text.ParserCombinators.ReadPrec import qualified Text.Read.Lex as L #if !(MIN_VERSION_base(4,6,0)) import Prelude.Compat import qualified Text.ParserCombinators.ReadP as P -- | Parse a string using the 'Read' instance. -- Succeeds if there is exactly one valid result. -- A 'Left' value indicates a parse error. -- -- /Since: 4.6.0.0/ readEither :: Read a => String -> Either String a readEither s = case [ x | (x,"") <- readPrec_to_S read' minPrec s ] of [x] -> Right x [] -> Left "Prelude.read: no parse" _ -> Left "Prelude.read: ambiguous parse" where read' = do x <- readPrec lift P.skipSpaces return x -- | Parse a string using the 'Read' instance. -- Succeeds if there is exactly one valid result. -- -- /Since: 4.6.0.0/ readMaybe :: Read a => String -> Maybe a readMaybe s = case readEither s of Left _ -> Nothing Right a -> Just a #endif base-compat-0.10.5/src/Text/Read/Compat/0000755000000000000000000000000013362115654015775 5ustar0000000000000000base-compat-0.10.5/src/Text/Read/Compat/Repl.hs0000644000000000000000000000041413362115654017232 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Text.Read.Compat" -- from a globally unique namespace. module Text.Read.Compat.Repl ( module Text.Read.Compat ) where import "this" Text.Read.Compat base-compat-0.10.5/src/Control/0000755000000000000000000000000013362115654014373 5ustar0000000000000000base-compat-0.10.5/src/Control/Concurrent/0000755000000000000000000000000013362115654016515 5ustar0000000000000000base-compat-0.10.5/src/Control/Concurrent/Compat.hs0000644000000000000000000000241713362115654020300 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude #-} {-# LANGUAGE RankNTypes #-} #if __GLASGOW_HASKELL__ >= 702 {-# LANGUAGE Trustworthy #-} #endif module Control.Concurrent.Compat ( module Base , forkFinally , forkOSWithUnmask ) where import Control.Concurrent as Base #if !(MIN_VERSION_base(4,6,0)) import Control.Exception #endif #if !(MIN_VERSION_base(4,9,0)) import GHC.IO (unsafeUnmask) import Prelude #endif #if !(MIN_VERSION_base(4,6,0)) -- | fork a thread and call the supplied function when the thread is about -- to terminate, with an exception or a returned value. The function is -- called with asynchronous exceptions masked. -- -- > forkFinally action and_then = -- > mask $ \restore -> -- > forkIO $ try (restore action) >>= and_then -- -- This function is useful for informing the parent when a child -- terminates, for example. -- -- /Since: 4.6.0.0/ forkFinally :: IO a -> (Either SomeException a -> IO ()) -> IO ThreadId forkFinally action and_then = mask $ \restore -> forkIO $ try (restore action) >>= and_then #endif #if !(MIN_VERSION_base(4,9,0)) -- | Like 'forkIOWithUnmask', but the child thread is a bound thread, -- as with 'forkOS'. forkOSWithUnmask :: ((forall a . IO a -> IO a) -> IO ()) -> IO ThreadId forkOSWithUnmask io = forkOS (io unsafeUnmask) #endif base-compat-0.10.5/src/Control/Concurrent/MVar/0000755000000000000000000000000013362115654017362 5ustar0000000000000000base-compat-0.10.5/src/Control/Concurrent/MVar/Compat.hs0000644000000000000000000000122713362115654021143 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude #-} module Control.Concurrent.MVar.Compat ( module Base , withMVarMasked ) where import Control.Concurrent.MVar as Base #if !(MIN_VERSION_base(4,7,0)) import Control.Exception (mask_, onException) import Control.Monad (return) import Data.Function (($)) import System.IO (IO) {-| Like 'withMVar', but the @IO@ action in the second argument is executed with asynchronous exceptions masked. @since 4.7.0.0 -} {-# INLINE withMVarMasked #-} withMVarMasked :: MVar a -> (a -> IO b) -> IO b withMVarMasked m io = mask_ $ do a <- takeMVar m b <- io a `onException` putMVar m a putMVar m a return b #endif base-compat-0.10.5/src/Control/Concurrent/MVar/Compat/0000755000000000000000000000000013362115654020605 5ustar0000000000000000base-compat-0.10.5/src/Control/Concurrent/MVar/Compat/Repl.hs0000644000000000000000000000050413362115654022042 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Control.Concurrent.MVar.Compat" -- from a globally unique namespace. module Control.Concurrent.MVar.Compat.Repl ( module Control.Concurrent.MVar.Compat ) where import "this" Control.Concurrent.MVar.Compat base-compat-0.10.5/src/Control/Concurrent/Compat/0000755000000000000000000000000013362115654017740 5ustar0000000000000000base-compat-0.10.5/src/Control/Concurrent/Compat/Repl.hs0000644000000000000000000000046013362115654021176 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Control.Concurrent.Compat" -- from a globally unique namespace. module Control.Concurrent.Compat.Repl ( module Control.Concurrent.Compat ) where import "this" Control.Concurrent.Compat base-compat-0.10.5/src/Control/Exception/0000755000000000000000000000000013362115654016331 5ustar0000000000000000base-compat-0.10.5/src/Control/Exception/Compat.hs0000644000000000000000000000131013362115654020103 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude #-} #if __GLASGOW_HASKELL__ >= 702 {-# LANGUAGE Trustworthy #-} #endif #if MIN_VERSION_base(4,10,0) {-# LANGUAGE MagicHash #-} {-# LANGUAGE RankNTypes #-} {-# LANGUAGE TypeInType #-} #endif module Control.Exception.Compat ( module Base , throw ) where import Control.Exception as Base #if MIN_VERSION_base(4,10,0) && !(MIN_VERSION_base(4,12,0)) hiding (throw) import GHC.Exts (RuntimeRep, TYPE, raise#) -- | Throw an exception. Exceptions may be thrown from purely -- functional code, but may only be caught within the 'IO' monad. throw :: forall (r :: RuntimeRep). forall (a :: TYPE r). forall e. Exception e => e -> a throw e = raise# (toException e) #endif base-compat-0.10.5/src/Control/Exception/Compat/0000755000000000000000000000000013362115654017554 5ustar0000000000000000base-compat-0.10.5/src/Control/Exception/Compat/Repl.hs0000644000000000000000000000045413362115654021015 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Control.Exception.Compat" -- from a globally unique namespace. module Control.Exception.Compat.Repl ( module Control.Exception.Compat ) where import "this" Control.Exception.Compat base-compat-0.10.5/src/Control/Monad/0000755000000000000000000000000013362115654015431 5ustar0000000000000000base-compat-0.10.5/src/Control/Monad/Compat.hs0000644000000000000000000001226413362115654017215 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude #-} module Control.Monad.Compat ( module Base , Monad(..) , MonadPlus(..) #if !(MIN_VERSION_base(4,8,0)) , foldM , foldM_ , forM , forM_ , guard , mapM , mapM_ , msum , sequence , sequence_ , unless , when , (<$!>) #endif #if !(MIN_VERSION_base(4,9,0)) , forever , filterM , mapAndUnzipM , zipWithM , zipWithM_ , replicateM , replicateM_ #endif ) where #if MIN_VERSION_base(4,9,0) import Control.Monad as Base #else import Control.Monad as Base hiding ( forever , filterM , mapAndUnzipM , zipWithM , zipWithM_ , replicateM , replicateM_ # if !(MIN_VERSION_base(4,8,0)) , foldM , foldM_ , forM , forM_ , guard , mapM , mapM_ , msum , sequence , sequence_ , unless , when # endif ) import Control.Applicative import Data.Foldable.Compat import Data.Traversable import Prelude.Compat #endif #if !(MIN_VERSION_base(4,8,0)) -- | Conditional execution of 'Applicative' expressions. For example, -- -- > when debug (putStrLn "Debugging") -- -- will output the string @Debugging@ if the Boolean value @debug@ -- is 'True', and otherwise do nothing. when :: (Applicative f) => Bool -> f () -> f () {-# INLINEABLE when #-} {-# SPECIALISE when :: Bool -> IO () -> IO () #-} {-# SPECIALISE when :: Bool -> Maybe () -> Maybe () #-} when p s = if p then s else pure () -- | @'guard' b@ is @'pure' ()@ if @b@ is 'True', -- and 'empty' if @b@ is 'False'. guard :: (Alternative f) => Bool -> f () guard True = pure () guard False = empty -- | The reverse of 'when'. unless :: (Applicative f) => Bool -> f () -> f () {-# INLINEABLE unless #-} {-# SPECIALISE unless :: Bool -> IO () -> IO () #-} {-# SPECIALISE unless :: Bool -> Maybe () -> Maybe () #-} unless p s = if p then pure () else s {- | The 'foldM' function is analogous to 'foldl', except that its result is encapsulated in a monad. Note that 'foldM' works from left-to-right over the list arguments. This could be an issue where @('>>')@ and the `folded function' are not commutative. > foldM f a1 [x1, x2, ..., xm] == > do > a2 <- f a1 x1 > a3 <- f a2 x2 > ... > f am xm If right-to-left evaluation is required, the input list should be reversed. Note: 'foldM' is the same as 'foldlM' -} foldM :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m b {-# INLINEABLE foldM #-} {-# SPECIALISE foldM :: (a -> b -> IO a) -> a -> [b] -> IO a #-} {-# SPECIALISE foldM :: (a -> b -> Maybe a) -> a -> [b] -> Maybe a #-} foldM = foldlM -- | Like 'foldM', but discards the result. foldM_ :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m () {-# INLINEABLE foldM_ #-} {-# SPECIALISE foldM_ :: (a -> b -> IO a) -> a -> [b] -> IO () #-} {-# SPECIALISE foldM_ :: (a -> b -> Maybe a) -> a -> [b] -> Maybe () #-} foldM_ f a xs = foldlM f a xs >> return () infixl 4 <$!> -- | Strict version of 'Data.Functor.<$>'. -- -- /Since: 4.8.0.0/ (<$!>) :: Monad m => (a -> b) -> m a -> m b {-# INLINE (<$!>) #-} f <$!> m = do x <- m let z = f x z `seq` return z #endif #if !(MIN_VERSION_base(4,9,0)) -- | @'forever' act@ repeats the action infinitely. forever :: (Applicative f) => f a -> f b {-# INLINE forever #-} forever a = let a' = a *> a' in a' -- Use explicit sharing here, as it is prevents a space leak regardless of -- optimizations. -- | This generalizes the list-based 'filter' function. {-# INLINE filterM #-} filterM :: (Applicative m) => (a -> m Bool) -> [a] -> m [a] filterM p = foldr (\ x -> liftA2 (\ flg -> if flg then (x:) else id) (p x)) (pure []) -- | The 'mapAndUnzipM' function maps its first argument over a list, returning -- the result as a pair of lists. This function is mainly used with complicated -- data structures or a state-transforming monad. mapAndUnzipM :: (Applicative m) => (a -> m (b,c)) -> [a] -> m ([b], [c]) {-# INLINE mapAndUnzipM #-} mapAndUnzipM f xs = unzip <$> traverse f xs -- | The 'zipWithM' function generalizes 'zipWith' to arbitrary applicative functors. zipWithM :: (Applicative m) => (a -> b -> m c) -> [a] -> [b] -> m [c] {-# INLINE zipWithM #-} zipWithM f xs ys = sequenceA (zipWith f xs ys) -- | 'zipWithM_' is the extension of 'zipWithM' which ignores the final result. zipWithM_ :: (Applicative m) => (a -> b -> m c) -> [a] -> [b] -> m () {-# INLINE zipWithM_ #-} zipWithM_ f xs ys = sequenceA_ (zipWith f xs ys) -- | @'replicateM' n act@ performs the action @n@ times, -- gathering the results. replicateM :: (Applicative m) => Int -> m a -> m [a] {-# INLINEABLE replicateM #-} {-# SPECIALISE replicateM :: Int -> IO a -> IO [a] #-} {-# SPECIALISE replicateM :: Int -> Maybe a -> Maybe [a] #-} replicateM cnt0 f = loop cnt0 where loop cnt | cnt <= 0 = pure [] | otherwise = liftA2 (:) f (loop (cnt - 1)) -- | Like 'replicateM', but discards the result. replicateM_ :: (Applicative m) => Int -> m a -> m () {-# INLINEABLE replicateM_ #-} {-# SPECIALISE replicateM_ :: Int -> IO a -> IO () #-} {-# SPECIALISE replicateM_ :: Int -> Maybe a -> Maybe () #-} replicateM_ cnt0 f = loop cnt0 where loop cnt | cnt <= 0 = pure () | otherwise = f *> loop (cnt - 1) #endif base-compat-0.10.5/src/Control/Monad/Fail/0000755000000000000000000000000013362115654016304 5ustar0000000000000000base-compat-0.10.5/src/Control/Monad/Fail/Compat.hs0000644000000000000000000000031213362115654020057 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude #-} module Control.Monad.Fail.Compat ( #if MIN_VERSION_base(4,9,0) module Base #endif ) where #if MIN_VERSION_base(4,9,0) import Control.Monad.Fail as Base #endif base-compat-0.10.5/src/Control/Monad/Fail/Compat/0000755000000000000000000000000013362115654017527 5ustar0000000000000000base-compat-0.10.5/src/Control/Monad/Fail/Compat/Repl.hs0000644000000000000000000000046013362115654020765 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Control.Monad.Fail.Compat" -- from a globally unique namespace. module Control.Monad.Fail.Compat.Repl ( module Control.Monad.Fail.Compat ) where import "this" Control.Monad.Fail.Compat base-compat-0.10.5/src/Control/Monad/IO/0000755000000000000000000000000013362115654015740 5ustar0000000000000000base-compat-0.10.5/src/Control/Monad/IO/Class/0000755000000000000000000000000013362115654017005 5ustar0000000000000000base-compat-0.10.5/src/Control/Monad/IO/Class/Compat.hs0000644000000000000000000000032213362115654020561 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude #-} module Control.Monad.IO.Class.Compat ( #if MIN_VERSION_base(4,9,0) module Base #endif ) where #if MIN_VERSION_base(4,9,0) import Control.Monad.IO.Class as Base #endif base-compat-0.10.5/src/Control/Monad/IO/Class/Compat/0000755000000000000000000000000013362115654020230 5ustar0000000000000000base-compat-0.10.5/src/Control/Monad/IO/Class/Compat/Repl.hs0000644000000000000000000000050013362115654021461 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Control.Monad.IO.Class.Compat" -- from a globally unique namespace. module Control.Monad.IO.Class.Compat.Repl ( module Control.Monad.IO.Class.Compat ) where import "this" Control.Monad.IO.Class.Compat base-compat-0.10.5/src/Control/Monad/ST/0000755000000000000000000000000013362115654015757 5ustar0000000000000000base-compat-0.10.5/src/Control/Monad/ST/Lazy/0000755000000000000000000000000013362115654016676 5ustar0000000000000000base-compat-0.10.5/src/Control/Monad/ST/Lazy/Unsafe/0000755000000000000000000000000013362115654020117 5ustar0000000000000000base-compat-0.10.5/src/Control/Monad/ST/Lazy/Unsafe/Compat.hs0000644000000000000000000000051313362115654021675 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude #-} module Control.Monad.ST.Lazy.Unsafe.Compat ( -- * Unsafe operations unsafeInterleaveST , unsafeIOToST ) where #if MIN_VERSION_base(4,6,0) import Control.Monad.ST.Lazy.Unsafe (unsafeInterleaveST, unsafeIOToST) #else import Control.Monad.ST.Lazy (unsafeInterleaveST, unsafeIOToST) #endif base-compat-0.10.5/src/Control/Monad/ST/Lazy/Unsafe/Compat/0000755000000000000000000000000013362115654021342 5ustar0000000000000000base-compat-0.10.5/src/Control/Monad/ST/Lazy/Unsafe/Compat/Repl.hs0000644000000000000000000000053013362115654022576 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Control.Monad.ST.Lazy.Unsafe.Compat" -- from a globally unique namespace. module Control.Monad.ST.Lazy.Unsafe.Compat.Repl ( module Control.Monad.ST.Lazy.Unsafe.Compat ) where import "this" Control.Monad.ST.Lazy.Unsafe.Compat base-compat-0.10.5/src/Control/Monad/ST/Unsafe/0000755000000000000000000000000013362115654017200 5ustar0000000000000000base-compat-0.10.5/src/Control/Monad/ST/Unsafe/Compat.hs0000644000000000000000000000054713362115654020765 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude #-} module Control.Monad.ST.Unsafe.Compat ( -- * Unsafe operations unsafeInterleaveST , unsafeIOToST , unsafeSTToIO ) where #if MIN_VERSION_base(4,6,0) import Control.Monad.ST.Unsafe (unsafeInterleaveST, unsafeIOToST, unsafeSTToIO) #else import Control.Monad.ST (unsafeInterleaveST, unsafeIOToST, unsafeSTToIO) #endif base-compat-0.10.5/src/Control/Monad/ST/Unsafe/Compat/0000755000000000000000000000000013362115654020423 5ustar0000000000000000base-compat-0.10.5/src/Control/Monad/ST/Unsafe/Compat/Repl.hs0000644000000000000000000000050413362115654021660 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Control.Monad.ST.Unsafe.Compat" -- from a globally unique namespace. module Control.Monad.ST.Unsafe.Compat.Repl ( module Control.Monad.ST.Unsafe.Compat ) where import "this" Control.Monad.ST.Unsafe.Compat base-compat-0.10.5/src/Control/Monad/Compat/0000755000000000000000000000000013362115654016654 5ustar0000000000000000base-compat-0.10.5/src/Control/Monad/Compat/Repl.hs0000644000000000000000000000043413362115654020113 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Control.Monad.Compat" -- from a globally unique namespace. module Control.Monad.Compat.Repl ( module Control.Monad.Compat ) where import "this" Control.Monad.Compat base-compat-0.10.5/src/Data/0000755000000000000000000000000013362115654013624 5ustar0000000000000000base-compat-0.10.5/src/Data/Bits/0000755000000000000000000000000013362115654014525 5ustar0000000000000000base-compat-0.10.5/src/Data/Bits/Compat.hs0000644000000000000000000000745413362115654016316 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude #-} {-# LANGUAGE BangPatterns, PatternGuards #-} module Data.Bits.Compat ( module Base , bitDefault , testBitDefault , popCountDefault #if MIN_VERSION_base(4,7,0) , toIntegralSized #endif ) where import Data.Bits as Base #if !(MIN_VERSION_base(4,8,0)) import Prelude #endif #if !(MIN_VERSION_base(4,6,0)) -- | Default implementation for 'bit'. -- -- Note that: @bitDefault i = 1 `shiftL` i@ -- -- /Since: 4.6.0.0/ bitDefault :: (Bits a, Num a) => Int -> a bitDefault = \i -> 1 `shiftL` i {-# INLINE bitDefault #-} -- | Default implementation for 'testBit'. -- -- Note that: @testBitDefault x i = (x .&. bit i) /= 0@ -- -- /Since: 4.6.0.0/ testBitDefault :: (Bits a, Num a) => a -> Int -> Bool testBitDefault = \x i -> (x .&. bit i) /= 0 {-# INLINE testBitDefault #-} -- | Default implementation for 'popCount'. -- -- This implementation is intentionally naive. Instances are expected to provide -- an optimized implementation for their size. -- -- /Since: 4.6.0.0/ popCountDefault :: (Bits a, Num a) => a -> Int popCountDefault = go 0 where go !c 0 = c go c w = go (c+1) (w .&. (w - 1)) -- clear the least significant {-# INLINABLE popCountDefault #-} #endif #if MIN_VERSION_base(4,7,0) && !(MIN_VERSION_base(4,8,0)) -- | Attempt to convert an 'Integral' type @a@ to an 'Integral' type @b@ using -- the size of the types as measured by 'Bits' methods. -- -- A simpler version of this function is: -- -- > toIntegral :: (Integral a, Integral b) => a -> Maybe b -- > toIntegral x -- > | toInteger x == y = Just (fromInteger y) -- > | otherwise = Nothing -- > where -- > y = toInteger x -- -- This version requires going through 'Integer', which can be inefficient. -- However, @toIntegralSized@ is optimized to allow GHC to statically determine -- the relative type sizes (as measured by 'bitSizeMaybe' and 'isSigned') and -- avoid going through 'Integer' for many types. (The implementation uses -- 'fromIntegral', which is itself optimized with rules for @base@ types but may -- go through 'Integer' for some type pairs.) -- -- /Since: 4.8.0.0/ toIntegralSized :: (Integral a, Integral b, Bits a, Bits b) => a -> Maybe b toIntegralSized x -- See Note [toIntegralSized optimization] | maybe True (<= x) yMinBound , maybe True (x <=) yMaxBound = Just y | otherwise = Nothing where y = fromIntegral x xWidth = bitSizeMaybe x yWidth = bitSizeMaybe y yMinBound | isBitSubType x y = Nothing | isSigned x, not (isSigned y) = Just 0 | isSigned x, isSigned y , Just yW <- yWidth = Just (negate $ bit (yW-1)) -- Assumes sub-type | otherwise = Nothing yMaxBound | isBitSubType x y = Nothing | isSigned x, not (isSigned y) , Just xW <- xWidth, Just yW <- yWidth , xW <= yW+1 = Nothing -- Max bound beyond a's domain | Just yW <- yWidth = if isSigned y then Just (bit (yW-1)-1) else Just (bit yW-1) | otherwise = Nothing {-# INLINEABLE toIntegralSized #-} -- | 'True' if the size of @a@ is @<=@ the size of @b@, where size is measured -- by 'bitSizeMaybe' and 'isSigned'. isBitSubType :: (Bits a, Bits b) => a -> b -> Bool isBitSubType x y -- Reflexive | xWidth == yWidth, xSigned == ySigned = True -- Every integer is a subset of 'Integer' | ySigned, Nothing == yWidth = True | not xSigned, not ySigned, Nothing == yWidth = True -- Sub-type relations between fixed-with types | xSigned == ySigned, Just xW <- xWidth, Just yW <- yWidth = xW <= yW | not xSigned, ySigned, Just xW <- xWidth, Just yW <- yWidth = xW < yW | otherwise = False where xWidth = bitSizeMaybe x xSigned = isSigned x yWidth = bitSizeMaybe y ySigned = isSigned y {-# INLINE isBitSubType #-} #endif base-compat-0.10.5/src/Data/Bits/Compat/0000755000000000000000000000000013362115654015750 5ustar0000000000000000base-compat-0.10.5/src/Data/Bits/Compat/Repl.hs0000644000000000000000000000041413362115654017205 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Data.Bits.Compat" -- from a globally unique namespace. module Data.Bits.Compat.Repl ( module Data.Bits.Compat ) where import "this" Data.Bits.Compat base-compat-0.10.5/src/Data/Bifunctor/0000755000000000000000000000000013362115654015557 5ustar0000000000000000base-compat-0.10.5/src/Data/Bifunctor/Compat.hs0000644000000000000000000000030213362115654017331 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude #-} module Data.Bifunctor.Compat ( #if MIN_VERSION_base(4,8,0) module Base #endif ) where #if MIN_VERSION_base(4,8,0) import Data.Bifunctor as Base #endif base-compat-0.10.5/src/Data/Bifunctor/Compat/0000755000000000000000000000000013362115654017002 5ustar0000000000000000base-compat-0.10.5/src/Data/Bifunctor/Compat/Repl.hs0000644000000000000000000000044013362115654020236 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Data.Bifunctor.Compat" -- from a globally unique namespace. module Data.Bifunctor.Compat.Repl ( module Data.Bifunctor.Compat ) where import "this" Data.Bifunctor.Compat base-compat-0.10.5/src/Data/Bifoldable/0000755000000000000000000000000013362115654015647 5ustar0000000000000000base-compat-0.10.5/src/Data/Bifoldable/Compat.hs0000644000000000000000000000030613362115654017425 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude #-} module Data.Bifoldable.Compat ( #if MIN_VERSION_base(4,10,0) module Base #endif ) where #if MIN_VERSION_base(4,10,0) import Data.Bifoldable as Base #endif base-compat-0.10.5/src/Data/Bifoldable/Compat/0000755000000000000000000000000013362115654017072 5ustar0000000000000000base-compat-0.10.5/src/Data/Bifoldable/Compat/Repl.hs0000644000000000000000000000044413362115654020332 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Data.Bifoldable.Compat" -- from a globally unique namespace. module Data.Bifoldable.Compat.Repl ( module Data.Bifoldable.Compat ) where import "this" Data.Bifoldable.Compat base-compat-0.10.5/src/Data/Complex/0000755000000000000000000000000013362115654015233 5ustar0000000000000000base-compat-0.10.5/src/Data/Complex/Compat.hs0000644000000000000000000000251513362115654017015 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude #-} module Data.Complex.Compat ( module Base #if MIN_VERSION_base(4,4,0) && !(MIN_VERSION_base(4,8,0)) , realPart , imagPart , mkPolar , cis , conjugate #endif ) where #if !(MIN_VERSION_base(4,4,0)) || MIN_VERSION_base(4,8,0) import Data.Complex as Base #else import Data.Complex as Base hiding ( realPart , imagPart , mkPolar , cis , conjugate ) import Prelude #endif #if MIN_VERSION_base(4,4,0) && !(MIN_VERSION_base(4,8,0)) -- | Extracts the real part of a complex number. realPart :: Complex a -> a realPart (x :+ _) = x -- | Extracts the imaginary part of a complex number. imagPart :: Complex a -> a imagPart (_ :+ y) = y -- | The conjugate of a complex number. {-# SPECIALISE conjugate :: Complex Double -> Complex Double #-} conjugate :: Num a => Complex a -> Complex a conjugate (x:+y) = x :+ (-y) -- | Form a complex number from polar components of magnitude and phase. {-# SPECIALISE mkPolar :: Double -> Double -> Complex Double #-} mkPolar :: Floating a => a -> a -> Complex a mkPolar r theta = r * cos theta :+ r * sin theta -- | @'cis' t@ is a complex value with magnitude @1@ -- and phase @t@ (modulo @2*'pi'@). {-# SPECIALISE cis :: Double -> Complex Double #-} cis :: Floating a => a -> Complex a cis theta = cos theta :+ sin theta #endif base-compat-0.10.5/src/Data/Complex/Compat/0000755000000000000000000000000013362115654016456 5ustar0000000000000000base-compat-0.10.5/src/Data/Complex/Compat/Repl.hs0000644000000000000000000000043013362115654017711 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Data.Complex.Compat" -- from a globally unique namespace. module Data.Complex.Compat.Repl ( module Data.Complex.Compat ) where import "this" Data.Complex.Compat base-compat-0.10.5/src/Data/Monoid/0000755000000000000000000000000013362115654015051 5ustar0000000000000000base-compat-0.10.5/src/Data/Monoid/Compat.hs0000644000000000000000000000070313362115654016630 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude #-} module Data.Monoid.Compat ( module Base , (<>) ) where import Data.Monoid as Base #if MIN_VERSION_base(4,9,0) hiding ((<>)) #endif #if MIN_VERSION_base(4,9,0) import Data.Semigroup ((<>)) #endif #if !(MIN_VERSION_base(4,5,0)) && !(MIN_VERSION_base(4,9,0)) infixr 6 <> -- | An infix synonym for 'mappend'. -- -- /Since: 4.5.0.0/ (<>) :: Monoid m => m -> m -> m (<>) = mappend {-# INLINE (<>) #-} #endif base-compat-0.10.5/src/Data/Monoid/Compat/0000755000000000000000000000000013362115654016274 5ustar0000000000000000base-compat-0.10.5/src/Data/Monoid/Compat/Repl.hs0000644000000000000000000000042413362115654017532 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Data.Monoid.Compat" -- from a globally unique namespace. module Data.Monoid.Compat.Repl ( module Data.Monoid.Compat ) where import "this" Data.Monoid.Compat base-compat-0.10.5/src/Data/Type/0000755000000000000000000000000013362115654014545 5ustar0000000000000000base-compat-0.10.5/src/Data/Type/Coercion/0000755000000000000000000000000013362115654016306 5ustar0000000000000000base-compat-0.10.5/src/Data/Type/Coercion/Compat.hs0000644000000000000000000000106513362115654020067 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude #-} {-# LANGUAGE RankNTypes #-} #if __GLASGOW_HASKELL__ >= 702 {-# LANGUAGE Trustworthy #-} #endif module Data.Type.Coercion.Compat ( #if MIN_VERSION_base(4,7,0) module Base , gcoerceWith #endif ) where #if MIN_VERSION_base(4,7,0) import Data.Type.Coercion as Base # if !(MIN_VERSION_base(4,10,0)) import Data.Coerce (Coercible) -- | Generalized form of type-safe cast using representational equality -- -- /Since: 4.10.0.0/ gcoerceWith :: Coercion a b -> (Coercible a b => r) -> r gcoerceWith Coercion x = x # endif #endif base-compat-0.10.5/src/Data/Type/Coercion/Compat/0000755000000000000000000000000013362115654017531 5ustar0000000000000000base-compat-0.10.5/src/Data/Type/Coercion/Compat/Repl.hs0000644000000000000000000000046013362115654020767 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Data.Type.Coercion.Compat" -- from a globally unique namespace. module Data.Type.Coercion.Compat.Repl ( module Data.Type.Coercion.Compat ) where import "this" Data.Type.Coercion.Compat base-compat-0.10.5/src/Data/Void/0000755000000000000000000000000013362115654014525 5ustar0000000000000000base-compat-0.10.5/src/Data/Void/Compat.hs0000644000000000000000000000027013362115654016303 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude #-} module Data.Void.Compat ( #if MIN_VERSION_base(4,8,0) module Base #endif ) where #if MIN_VERSION_base(4,8,0) import Data.Void as Base #endif base-compat-0.10.5/src/Data/Void/Compat/0000755000000000000000000000000013362115654015750 5ustar0000000000000000base-compat-0.10.5/src/Data/Void/Compat/Repl.hs0000644000000000000000000000041413362115654017205 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Data.Void.Compat" -- from a globally unique namespace. module Data.Void.Compat.Repl ( module Data.Void.Compat ) where import "this" Data.Void.Compat base-compat-0.10.5/src/Data/STRef/0000755000000000000000000000000013362115654014607 5ustar0000000000000000base-compat-0.10.5/src/Data/STRef/Compat.hs0000644000000000000000000000075413362115654016374 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude #-} #if __GLASGOW_HASKELL__ >= 702 {-# LANGUAGE Trustworthy #-} #endif module Data.STRef.Compat ( module Base , modifySTRef' ) where import Data.STRef as Base #if !(MIN_VERSION_base(4,6,0)) import Control.Monad.ST (ST) import Prelude (seq) -- | Strict version of 'modifySTRef' -- -- /Since: 4.6.0.0/ modifySTRef' :: STRef s a -> (a -> a) -> ST s () modifySTRef' ref f = do x <- readSTRef ref let x' = f x x' `seq` writeSTRef ref x' #endif base-compat-0.10.5/src/Data/STRef/Compat/0000755000000000000000000000000013362115654016032 5ustar0000000000000000base-compat-0.10.5/src/Data/STRef/Compat/Repl.hs0000644000000000000000000000042013362115654017264 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Data.STRef.Compat" -- from a globally unique namespace. module Data.STRef.Compat.Repl ( module Data.STRef.Compat ) where import "this" Data.STRef.Compat base-compat-0.10.5/src/Data/List/0000755000000000000000000000000013362115654014537 5ustar0000000000000000base-compat-0.10.5/src/Data/List/Compat.hs0000644000000000000000000001434013362115654016320 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude #-} {-# LANGUAGE BangPatterns #-} #if __GLASGOW_HASKELL__ >= 702 {-# LANGUAGE Trustworthy #-} #endif module Data.List.Compat ( module Base #if !(MIN_VERSION_base(4,11,0)) , iterate' #endif #if !(MIN_VERSION_base(4,8,0)) , all , and , any , concat , concatMap , elem , find , foldl , foldl' , foldl1 , foldr , foldr1 , length , maximum , maximumBy , minimum , minimumBy , notElem , nub , nubBy , null , or , product , sum , union , unionBy , mapAccumL , mapAccumR , isSubsequenceOf , sortOn , uncons , scanl' #endif #if !(MIN_VERSION_base(4,5,0)) , dropWhileEnd #endif ) where #if MIN_VERSION_base(4,8,0) import Data.List as Base #else import Data.List as Base hiding ( all , and , any , concat , concatMap , elem , find , foldl , foldl' , foldl1 , foldr , foldr1 , length , maximum , maximumBy , minimum , minimumBy , notElem , nub , nubBy , null , or , product , sum , union , unionBy , mapAccumL , mapAccumR ) import Data.Foldable.Compat import Data.Traversable import Data.Ord (comparing) #endif #if !(MIN_VERSION_base(4,11,0)) import GHC.Exts (build) import Prelude.Compat hiding (foldr, null) #endif #if !(MIN_VERSION_base(4,5,0)) -- | The 'dropWhileEnd' function drops the largest suffix of a list -- in which the given predicate holds for all elements. For example: -- -- > dropWhileEnd isSpace "foo\n" == "foo" -- > dropWhileEnd isSpace "foo bar" == "foo bar" -- > dropWhileEnd isSpace ("foo\n" ++ undefined) == "foo" ++ undefined -- -- /Since: 4.5.0.0/ dropWhileEnd :: (a -> Bool) -> [a] -> [a] dropWhileEnd p = foldr (\x xs -> if p x && null xs then [] else x : xs) [] #endif #if !(MIN_VERSION_base(4,8,0)) -- | The 'isSubsequenceOf' function takes two lists and returns 'True' if the -- first list is a subsequence of the second list. -- -- @'isSubsequenceOf' x y@ is equivalent to @'elem' x ('subsequences' y)@. -- -- /Since: 4.8.0.0/ -- -- ==== __Examples__ -- -- >>> isSubsequenceOf "GHC" "The Glorious Haskell Compiler" -- True -- >>> isSubsequenceOf ['a','d'..'z'] ['a'..'z'] -- True -- >>> isSubsequenceOf [1..10] [10,9..0] -- False isSubsequenceOf :: (Eq a) => [a] -> [a] -> Bool isSubsequenceOf [] _ = True isSubsequenceOf _ [] = False isSubsequenceOf a@(x:a') (y:b) | x == y = isSubsequenceOf a' b | otherwise = isSubsequenceOf a b -- | Sort a list by comparing the results of a key function applied to each -- element. @sortOn f@ is equivalent to @sortBy . comparing f@, but has the -- performance advantage of only evaluating @f@ once for each element in the -- input list. This is called the decorate-sort-undecorate paradigm, or -- Schwartzian transform. -- -- /Since: 4.8.0.0/ sortOn :: Ord b => (a -> b) -> [a] -> [a] sortOn f = map snd . sortBy (comparing fst) . map (\x -> let y = f x in y `seq` (y, x)) -- | Decompose a list into its head and tail. If the list is empty, -- returns 'Nothing'. If the list is non-empty, returns @'Just' (x, xs)@, -- where @x@ is the head of the list and @xs@ its tail. -- -- /Since: 4.8.0.0/ uncons :: [a] -> Maybe (a, [a]) uncons [] = Nothing uncons (x:xs) = Just (x, xs) -- | A strictly accumulating version of 'scanl' {-# NOINLINE [1] scanl' #-} scanl' :: (b -> a -> b) -> b -> [a] -> [b] -- This peculiar form is needed to prevent scanl' from being rewritten -- in its own right hand side. scanl' = scanlGo' where scanlGo' :: (b -> a -> b) -> b -> [a] -> [b] scanlGo' f !q ls = q : (case ls of [] -> [] x:xs -> scanlGo' f (f q x) xs) -- | /O(n^2)/. The 'nub' function removes duplicate elements from a list. -- In particular, it keeps only the first occurrence of each element. -- (The name 'nub' means \`essence\'.) -- It is a special case of 'nubBy', which allows the programmer to supply -- their own equality test. nub :: (Eq a) => [a] -> [a] nub = nubBy (==) -- | The 'nubBy' function behaves just like 'nub', except it uses a -- user-supplied equality predicate instead of the overloaded '==' -- function. nubBy :: (a -> a -> Bool) -> [a] -> [a] -- stolen from HBC nubBy eq l = nubBy' l [] where nubBy' [] _ = [] nubBy' (y:ys) xs | elem_by eq y xs = nubBy' ys xs | otherwise = y : nubBy' ys (y:xs) -- Not exported: -- Note that we keep the call to `eq` with arguments in the -- same order as in the reference (prelude) implementation, -- and that this order is different from how `elem` calls (==). -- See #2528, #3280 and #7913. -- 'xs' is the list of things we've seen so far, -- 'y' is the potential new element elem_by :: (a -> a -> Bool) -> a -> [a] -> Bool elem_by _ _ [] = False elem_by eq y (x:xs) = x `eq` y || elem_by eq y xs -- | The 'union' function returns the list union of the two lists. -- For example, -- -- > "dog" `union` "cow" == "dogcw" -- -- Duplicates, and elements of the first list, are removed from the -- the second list, but if the first list contains duplicates, so will -- the result. -- It is a special case of 'unionBy', which allows the programmer to supply -- their own equality test. union :: (Eq a) => [a] -> [a] -> [a] union = unionBy (==) -- | The 'unionBy' function is the non-overloaded version of 'union'. unionBy :: (a -> a -> Bool) -> [a] -> [a] -> [a] unionBy eq xs ys = xs ++ foldl (flip (deleteBy eq)) (nubBy eq ys) xs #endif #if !(MIN_VERSION_base(4,11,0)) -- | 'iterate\'' is the strict version of 'iterate'. -- -- It ensures that the result of each application of force to weak head normal -- form before proceeding. {-# NOINLINE [1] iterate' #-} iterate' :: (a -> a) -> a -> [a] iterate' f x = let x' = f x in x' `seq` (x : iterate' f x') {-# INLINE [0] iterate'FB #-} -- See Note [Inline FB functions] iterate'FB :: (a -> b -> b) -> (a -> a) -> a -> b iterate'FB c f x0 = go x0 where go x = let x' = f x in x' `seq` (x `c` go x') {-# RULES "iterate'" [~1] forall f x. iterate' f x = build (\c _n -> iterate'FB c f x) "iterate'FB" [1] iterate'FB (:) = iterate' #-} #endif base-compat-0.10.5/src/Data/List/NonEmpty/0000755000000000000000000000000013362115654016310 5ustar0000000000000000base-compat-0.10.5/src/Data/List/NonEmpty/Compat.hs0000644000000000000000000000277713362115654020104 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude #-} -- | This backports the modern "Data.Semigroup" interface back to -- @base-4.9@/GHC 8.0. module Data.List.NonEmpty.Compat ( #if MIN_VERSION_base(4,9,0) -- * The type of non-empty streams NonEmpty(..) -- * Non-empty stream transformations , map , intersperse , scanl , scanr , scanl1 , scanr1 , transpose , sortBy , sortWith -- * Basic functions , length , head , tail , last , init , (<|), cons , uncons , unfoldr , sort , reverse , inits , tails -- * Building streams , iterate , repeat , cycle , unfold , insert , some1 -- * Extracting sublists , take , drop , splitAt , takeWhile , dropWhile , span , break , filter , partition , group , groupBy , groupWith , groupAllWith , group1 , groupBy1 , groupWith1 , groupAllWith1 -- * Sublist predicates , isPrefixOf -- * \"Set\" operations , nub , nubBy -- * Indexing streams , (!!) -- * Zipping and unzipping streams , zip , zipWith , unzip -- * Converting to and from a list , fromList , toList , nonEmpty , xor #endif ) where #if MIN_VERSION_base(4,9,0) import Data.List.NonEmpty #endif base-compat-0.10.5/src/Data/List/NonEmpty/Compat/0000755000000000000000000000000013362115654017533 5ustar0000000000000000base-compat-0.10.5/src/Data/List/NonEmpty/Compat/Repl.hs0000644000000000000000000000046013362115654020771 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Data.List.NonEmpty.Compat" -- from a globally unique namespace. module Data.List.NonEmpty.Compat.Repl ( module Data.List.NonEmpty.Compat ) where import "this" Data.List.NonEmpty.Compat base-compat-0.10.5/src/Data/List/Compat/0000755000000000000000000000000013362115654015762 5ustar0000000000000000base-compat-0.10.5/src/Data/List/Compat/Repl.hs0000644000000000000000000000041413362115654017217 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Data.List.Compat" -- from a globally unique namespace. module Data.List.Compat.Repl ( module Data.List.Compat ) where import "this" Data.List.Compat base-compat-0.10.5/src/Data/Proxy/0000755000000000000000000000000013362115654014745 5ustar0000000000000000base-compat-0.10.5/src/Data/Proxy/Compat.hs0000644000000000000000000000124613362115654016527 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude #-} module Data.Proxy.Compat ( #if MIN_VERSION_base(4,7,0) module Base, #endif asProxyTypeOf ) where #if MIN_VERSION_base(4,7,0) # if MIN_VERSION_base(4,10,0) import Data.Proxy as Base # else import Data.Proxy as Base hiding (asProxyTypeOf) # endif #endif #if !(MIN_VERSION_base(4,10,0)) import Prelude (const) -- | 'asProxyTypeOf' is a type-restricted version of 'const'. -- It is usually used as an infix operator, and its typing forces its first -- argument (which is usually overloaded) to have the same type as the tag -- of the second. asProxyTypeOf :: a -> proxy a -> a asProxyTypeOf = const {-# INLINE asProxyTypeOf #-} #endif base-compat-0.10.5/src/Data/Proxy/Compat/0000755000000000000000000000000013362115654016170 5ustar0000000000000000base-compat-0.10.5/src/Data/Proxy/Compat/Repl.hs0000644000000000000000000000042013362115654017422 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Data.Proxy.Compat" -- from a globally unique namespace. module Data.Proxy.Compat.Repl ( module Data.Proxy.Compat ) where import "this" Data.Proxy.Compat base-compat-0.10.5/src/Data/Word/0000755000000000000000000000000013362115654014537 5ustar0000000000000000base-compat-0.10.5/src/Data/Word/Compat.hs0000644000000000000000000000226713362115654016325 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude #-} module Data.Word.Compat ( module Base , byteSwap16 , byteSwap32 , byteSwap64 ) where import Data.Word as Base #if !(MIN_VERSION_base(4,7,0)) import Data.Bits -- | Swap bytes in 'Word16'. -- -- /Since: 4.7.0.0/ byteSwap16 :: Word16 -> Word16 byteSwap16 w = ((w `shiftR` 8) .&. 0x00ff) .|. ((w .&. 0x00ff) `shiftL` 8) -- | Reverse order of bytes in 'Word32'. -- -- /Since: 4.7.0.0/ byteSwap32 :: Word32 -> Word32 byteSwap32 w = ((w .&. 0xff000000) `shiftR` 24) .|. ((w .&. 0x00ff0000) `shiftR` 8) .|. ((w .&. 0x0000ff00) `shiftL` 8) .|. ((w .&. 0x000000ff) `shiftL` 24) -- | Reverse order of bytes in 'Word64'. -- -- /Since: 4.7.0.0/ byteSwap64 :: Word64 -> Word64 byteSwap64 w = ((w .&. 0xff00000000000000) `shiftR` 56) .|. ((w .&. 0x00ff000000000000) `shiftR` 40) .|. ((w .&. 0x0000ff0000000000) `shiftR` 24) .|. ((w .&. 0x000000ff00000000) `shiftR` 8) .|. ((w .&. 0x00000000ff000000) `shiftL` 8) .|. ((w .&. 0x0000000000ff0000) `shiftL` 24) .|. ((w .&. 0x000000000000ff00) `shiftL` 40) .|. ((w .&. 0x00000000000000ff) `shiftL` 56) #endif base-compat-0.10.5/src/Data/Word/Compat/0000755000000000000000000000000013362115654015762 5ustar0000000000000000base-compat-0.10.5/src/Data/Word/Compat/Repl.hs0000644000000000000000000000041413362115654017217 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Data.Word.Compat" -- from a globally unique namespace. module Data.Word.Compat.Repl ( module Data.Word.Compat ) where import "this" Data.Word.Compat base-compat-0.10.5/src/Data/Ratio/0000755000000000000000000000000013362115654014702 5ustar0000000000000000base-compat-0.10.5/src/Data/Ratio/Compat.hs0000644000000000000000000000151313362115654016461 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude #-} module Data.Ratio.Compat ( module Base #if MIN_VERSION_base(4,4,0) && !(MIN_VERSION_base(4,9,0)) , denominator , numerator #endif ) where #if !(MIN_VERSION_base(4,4,0)) || MIN_VERSION_base(4,9,0) import Data.Ratio as Base #else import Data.Ratio as Base hiding ( denominator , numerator ) import GHC.Real (Ratio(..)) #endif #if MIN_VERSION_base(4,4,0) && !(MIN_VERSION_base(4,9,0)) -- | Extract the numerator of the ratio in reduced form: -- the numerator and denominator have no common factor and the denominator -- is positive. numerator :: Ratio a -> a numerator (x :% _) = x -- | Extract the denominator of the ratio in reduced form: -- the numerator and denominator have no common factor and the denominator -- is positive. denominator :: Ratio a -> a denominator (_ :% y) = y #endif base-compat-0.10.5/src/Data/Ratio/Compat/0000755000000000000000000000000013362115654016125 5ustar0000000000000000base-compat-0.10.5/src/Data/Ratio/Compat/Repl.hs0000644000000000000000000000042013362115654017357 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Data.Ratio.Compat" -- from a globally unique namespace. module Data.Ratio.Compat.Repl ( module Data.Ratio.Compat ) where import "this" Data.Ratio.Compat base-compat-0.10.5/src/Data/Either/0000755000000000000000000000000013362115654015044 5ustar0000000000000000base-compat-0.10.5/src/Data/Either/Compat.hs0000644000000000000000000000231313362115654016622 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude #-} module Data.Either.Compat ( module Base , isLeft , isRight , fromLeft , fromRight ) where import Data.Either as Base #if !(MIN_VERSION_base(4,7,0)) import Data.Bool (Bool(..)) -- | Return `True` if the given value is a `Left`-value, `False` otherwise. -- -- /Since: 4.7.0.0/ isLeft :: Either a b -> Bool isLeft (Left _) = True isLeft (Right _) = False -- | Return `True` if the given value is a `Right`-value, `False` otherwise. -- -- /Since: 4.7.0.0/ isRight :: Either a b -> Bool isRight (Left _) = False isRight (Right _) = True #endif #if !(MIN_VERSION_base(4,10,0)) -- | Return the contents of a 'Left'-value or a default value otherwise. -- -- /Since: 4.10.0.0/ -- -- ==== __Examples__ -- -- Basic usage: -- -- >>> fromLeft 1 (Left 3) -- 3 -- >>> fromLeft 1 (Right "foo") -- 1 -- fromLeft :: a -> Either a b -> a fromLeft _ (Left a) = a fromLeft a _ = a -- | Return the contents of a 'Right'-value or a default value otherwise. -- -- /Since: 4.10.0.0/ -- -- ==== __Examples__ -- -- Basic usage: -- -- >>> fromRight 1 (Right 3) -- 3 -- >>> fromRight 1 (Left "foo") -- 1 -- fromRight :: b -> Either a b -> b fromRight _ (Right b) = b fromRight b _ = b #endif base-compat-0.10.5/src/Data/Either/Compat/0000755000000000000000000000000013362115654016267 5ustar0000000000000000base-compat-0.10.5/src/Data/Either/Compat/Repl.hs0000644000000000000000000000042413362115654017525 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Data.Either.Compat" -- from a globally unique namespace. module Data.Either.Compat.Repl ( module Data.Either.Compat ) where import "this" Data.Either.Compat base-compat-0.10.5/src/Data/IORef/0000755000000000000000000000000013362115654014570 5ustar0000000000000000base-compat-0.10.5/src/Data/IORef/Compat.hs0000644000000000000000000000203513362115654016347 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude #-} module Data.IORef.Compat ( module Base , modifyIORef' , atomicModifyIORef' , atomicWriteIORef ) where import Data.IORef as Base #if !(MIN_VERSION_base(4,6,0)) import Prelude -- |Strict version of 'modifyIORef' -- -- /Since: 4.6.0.0/ modifyIORef' :: IORef a -> (a -> a) -> IO () modifyIORef' ref f = do x <- readIORef ref let x' = f x x' `seq` writeIORef ref x' -- | Strict version of 'atomicModifyIORef'. This forces both the value stored -- in the 'IORef' as well as the value returned. -- -- /Since: 4.6.0.0/ atomicModifyIORef' :: IORef a -> (a -> (a,b)) -> IO b atomicModifyIORef' ref f = do b <- atomicModifyIORef ref $ \a -> case f a of v@(a',_) -> a' `seq` v b `seq` return b -- | Variant of 'writeIORef' with the \"barrier to reordering\" property that -- 'atomicModifyIORef' has. -- -- /Since: 4.6.0.0/ atomicWriteIORef :: IORef a -> a -> IO () atomicWriteIORef ref a = do x <- atomicModifyIORef ref (\_ -> (a, ())) x `seq` return () #endif base-compat-0.10.5/src/Data/IORef/Compat/0000755000000000000000000000000013362115654016013 5ustar0000000000000000base-compat-0.10.5/src/Data/IORef/Compat/Repl.hs0000644000000000000000000000042013362115654017245 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Data.IORef.Compat" -- from a globally unique namespace. module Data.IORef.Compat.Repl ( module Data.IORef.Compat ) where import "this" Data.IORef.Compat base-compat-0.10.5/src/Data/Functor/0000755000000000000000000000000013362115654015244 5ustar0000000000000000base-compat-0.10.5/src/Data/Functor/Compat.hs0000644000000000000000000000151313362115654017023 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude #-} module Data.Functor.Compat ( module Base , Functor(..) , ($>) , void , (<&>) ) where import Data.Functor as Base #if !(MIN_VERSION_base(4,7,0)) import Control.Monad.Compat (void) import Data.Function (flip) #endif #if !(MIN_VERSION_base(4,7,0)) infixl 4 $> -- | Flipped version of '$>'. -- -- /Since: 4.7.0.0/ ($>) :: Functor f => f a -> b -> f b ($>) = flip (<$) #endif #if !(MIN_VERSION_base(4,11,0)) -- | Flipped version of '<$>'. -- -- @ -- ('<&>') = 'flip' 'fmap' -- @ -- -- /Since: 4.11.0.0/ -- -- ==== __Examples__ -- Apply @(+1)@ to a list, a 'Data.Maybe.Just' and a 'Data.Either.Right': -- -- >>> Just 2 <&> (+1) -- Just 3 -- -- >>> [1,2,3] <&> (+1) -- [2,3,4] -- -- >>> Right 3 <&> (+1) -- Right 4 -- (<&>) :: Functor f => f a -> (a -> b) -> f b as <&> f = f <$> as infixl 1 <&> #endif base-compat-0.10.5/src/Data/Functor/Compose/0000755000000000000000000000000013362115654016651 5ustar0000000000000000base-compat-0.10.5/src/Data/Functor/Compose/Compat.hs0000644000000000000000000000031613362115654020430 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude #-} module Data.Functor.Compose.Compat ( #if MIN_VERSION_base(4,9,0) module Base #endif ) where #if MIN_VERSION_base(4,9,0) import Data.Functor.Compose as Base #endif base-compat-0.10.5/src/Data/Functor/Compose/Compat/0000755000000000000000000000000013362115654020074 5ustar0000000000000000base-compat-0.10.5/src/Data/Functor/Compose/Compat/Repl.hs0000644000000000000000000000047013362115654021333 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Data.Functor.Compose.Compat" -- from a globally unique namespace. module Data.Functor.Compose.Compat.Repl ( module Data.Functor.Compose.Compat ) where import "this" Data.Functor.Compose.Compat base-compat-0.10.5/src/Data/Functor/Sum/0000755000000000000000000000000013362115654016010 5ustar0000000000000000base-compat-0.10.5/src/Data/Functor/Sum/Compat.hs0000644000000000000000000000030613362115654017566 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude #-} module Data.Functor.Sum.Compat ( #if MIN_VERSION_base(4,9,0) module Base #endif ) where #if MIN_VERSION_base(4,9,0) import Data.Functor.Sum as Base #endif base-compat-0.10.5/src/Data/Functor/Sum/Compat/0000755000000000000000000000000013362115654017233 5ustar0000000000000000base-compat-0.10.5/src/Data/Functor/Sum/Compat/Repl.hs0000644000000000000000000000045013362115654020470 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Data.Functor.Sum.Compat" -- from a globally unique namespace. module Data.Functor.Sum.Compat.Repl ( module Data.Functor.Sum.Compat ) where import "this" Data.Functor.Sum.Compat base-compat-0.10.5/src/Data/Functor/Const/0000755000000000000000000000000013362115654016332 5ustar0000000000000000base-compat-0.10.5/src/Data/Functor/Const/Compat.hs0000644000000000000000000000020313362115654020104 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude #-} module Data.Functor.Const.Compat (Const(..)) where import Control.Applicative (Const(..)) base-compat-0.10.5/src/Data/Functor/Const/Compat/0000755000000000000000000000000013362115654017555 5ustar0000000000000000base-compat-0.10.5/src/Data/Functor/Const/Compat/Repl.hs0000644000000000000000000000046013362115654021013 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Data.Functor.Const.Compat" -- from a globally unique namespace. module Data.Functor.Const.Compat.Repl ( module Data.Functor.Const.Compat ) where import "this" Data.Functor.Const.Compat base-compat-0.10.5/src/Data/Functor/Product/0000755000000000000000000000000013362115654016664 5ustar0000000000000000base-compat-0.10.5/src/Data/Functor/Product/Compat.hs0000644000000000000000000000031613362115654020443 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude #-} module Data.Functor.Product.Compat ( #if MIN_VERSION_base(4,9,0) module Base #endif ) where #if MIN_VERSION_base(4,9,0) import Data.Functor.Product as Base #endif base-compat-0.10.5/src/Data/Functor/Product/Compat/0000755000000000000000000000000013362115654020107 5ustar0000000000000000base-compat-0.10.5/src/Data/Functor/Product/Compat/Repl.hs0000644000000000000000000000047013362115654021346 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Data.Functor.Product.Compat" -- from a globally unique namespace. module Data.Functor.Product.Compat.Repl ( module Data.Functor.Product.Compat ) where import "this" Data.Functor.Product.Compat base-compat-0.10.5/src/Data/Functor/Compat/0000755000000000000000000000000013362115654016467 5ustar0000000000000000base-compat-0.10.5/src/Data/Functor/Compat/Repl.hs0000644000000000000000000000043013362115654017722 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Data.Functor.Compat" -- from a globally unique namespace. module Data.Functor.Compat.Repl ( module Data.Functor.Compat ) where import "this" Data.Functor.Compat base-compat-0.10.5/src/Data/Functor/Identity/0000755000000000000000000000000013362115654017035 5ustar0000000000000000base-compat-0.10.5/src/Data/Functor/Identity/Compat.hs0000644000000000000000000000032013362115654020607 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude #-} module Data.Functor.Identity.Compat ( #if MIN_VERSION_base(4,8,0) module Base #endif ) where #if MIN_VERSION_base(4,8,0) import Data.Functor.Identity as Base #endif base-compat-0.10.5/src/Data/Functor/Identity/Compat/0000755000000000000000000000000013362115654020260 5ustar0000000000000000base-compat-0.10.5/src/Data/Functor/Identity/Compat/Repl.hs0000644000000000000000000000047413362115654021523 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Data.Functor.Identity.Compat" -- from a globally unique namespace. module Data.Functor.Identity.Compat.Repl ( module Data.Functor.Identity.Compat ) where import "this" Data.Functor.Identity.Compat base-compat-0.10.5/src/Data/Functor/Contravariant/0000755000000000000000000000000013362115654020057 5ustar0000000000000000base-compat-0.10.5/src/Data/Functor/Contravariant/Compat.hs0000644000000000000000000000033413362115654021636 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude #-} module Data.Functor.Contravariant.Compat ( #if MIN_VERSION_base(4,12,0) module Base #endif ) where #if MIN_VERSION_base(4,12,0) import Data.Functor.Contravariant as Base #endif base-compat-0.10.5/src/Data/Functor/Contravariant/Compat/0000755000000000000000000000000013362115654021302 5ustar0000000000000000base-compat-0.10.5/src/Data/Functor/Contravariant/Compat/Repl.hs0000644000000000000000000000052013362115654022535 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Data.Functor.Contravariant.Compat" -- from a globally unique namespace. module Data.Functor.Contravariant.Compat.Repl ( module Data.Functor.Contravariant.Compat ) where import "this" Data.Functor.Contravariant.Compat base-compat-0.10.5/src/Data/Bool/0000755000000000000000000000000013362115654014517 5ustar0000000000000000base-compat-0.10.5/src/Data/Bool/Compat.hs0000644000000000000000000000060313362115654016275 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude #-} module Data.Bool.Compat ( module Base , bool ) where import Data.Bool as Base #if !(MIN_VERSION_base(4,7,0)) -- | Case analysis for the 'Bool' type. -- @bool a b p@ evaluates to @a@ when @p@ is @False@, and evaluates to @b@ -- when @p@ is @True@. -- -- /Since: 4.7.0.0/ bool :: a -> a -> Bool -> a bool f _ False = f bool _ t True = t #endif base-compat-0.10.5/src/Data/Bool/Compat/0000755000000000000000000000000013362115654015742 5ustar0000000000000000base-compat-0.10.5/src/Data/Bool/Compat/Repl.hs0000644000000000000000000000041413362115654017177 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Data.Bool.Compat" -- from a globally unique namespace. module Data.Bool.Compat.Repl ( module Data.Bool.Compat ) where import "this" Data.Bool.Compat base-compat-0.10.5/src/Data/String/0000755000000000000000000000000013362115654015072 5ustar0000000000000000base-compat-0.10.5/src/Data/String/Compat.hs0000644000000000000000000000040213362115654016645 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude #-} module Data.String.Compat ( module Base , String , lines , words , unlines , unwords ) where import Data.String as Base #if !(MIN_VERSION_base(4,4,0)) import Prelude (String, lines, words, unlines, unwords) #endif base-compat-0.10.5/src/Data/String/Compat/0000755000000000000000000000000013362115654016315 5ustar0000000000000000base-compat-0.10.5/src/Data/String/Compat/Repl.hs0000644000000000000000000000042413362115654017553 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Data.String.Compat" -- from a globally unique namespace. module Data.String.Compat.Repl ( module Data.String.Compat ) where import "this" Data.String.Compat base-compat-0.10.5/src/Data/Bitraversable/0000755000000000000000000000000013362115654016411 5ustar0000000000000000base-compat-0.10.5/src/Data/Bitraversable/Compat.hs0000644000000000000000000000031413362115654020166 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude #-} module Data.Bitraversable.Compat ( #if MIN_VERSION_base(4,10,0) module Base #endif ) where #if MIN_VERSION_base(4,10,0) import Data.Bitraversable as Base #endif base-compat-0.10.5/src/Data/Bitraversable/Compat/0000755000000000000000000000000013362115654017634 5ustar0000000000000000base-compat-0.10.5/src/Data/Bitraversable/Compat/Repl.hs0000644000000000000000000000046013362115654021072 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Data.Bitraversable.Compat" -- from a globally unique namespace. module Data.Bitraversable.Compat.Repl ( module Data.Bitraversable.Compat ) where import "this" Data.Bitraversable.Compat base-compat-0.10.5/src/Data/Function/0000755000000000000000000000000013362115654015411 5ustar0000000000000000base-compat-0.10.5/src/Data/Function/Compat.hs0000644000000000000000000000070013362115654017165 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude #-} module Data.Function.Compat ( module Base , (&) ) where import Data.Function as Base #if !(MIN_VERSION_base(4,8,0)) infixl 1 & -- | '&' is a reverse application operator. This provides notational -- convenience. Its precedence is one higher than that of the forward -- application operator '$', which allows '&' to be nested in '$'. -- -- /Since: 4.8.0.0/ (&) :: a -> (a -> b) -> b x & f = f x #endif base-compat-0.10.5/src/Data/Function/Compat/0000755000000000000000000000000013362115654016634 5ustar0000000000000000base-compat-0.10.5/src/Data/Function/Compat/Repl.hs0000644000000000000000000000043413362115654020073 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Data.Function.Compat" -- from a globally unique namespace. module Data.Function.Compat.Repl ( module Data.Function.Compat ) where import "this" Data.Function.Compat base-compat-0.10.5/src/Data/Version/0000755000000000000000000000000013362115654015251 5ustar0000000000000000base-compat-0.10.5/src/Data/Version/Compat.hs0000644000000000000000000000047113362115654017032 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude #-} module Data.Version.Compat ( module Base , makeVersion ) where import Data.Version as Base #if !(MIN_VERSION_base(4,8,0)) import Prelude.Compat -- | Construct tag-less 'Version' -- -- /Since: 4.8.0.0/ makeVersion :: [Int] -> Version makeVersion b = Version b [] #endif base-compat-0.10.5/src/Data/Version/Compat/0000755000000000000000000000000013362115654016474 5ustar0000000000000000base-compat-0.10.5/src/Data/Version/Compat/Repl.hs0000644000000000000000000000043013362115654017727 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Data.Version.Compat" -- from a globally unique namespace. module Data.Version.Compat.Repl ( module Data.Version.Compat ) where import "this" Data.Version.Compat base-compat-0.10.5/src/Data/Semigroup/0000755000000000000000000000000013362115654015576 5ustar0000000000000000base-compat-0.10.5/src/Data/Semigroup/Compat.hs0000644000000000000000000000135713362115654017363 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude #-} -- | This backports the modern "Data.Semigroup" interface back to -- @base-4.9@/GHC 8.0. module Data.Semigroup.Compat ( #if MIN_VERSION_base(4,9,0) Semigroup(..) , stimesMonoid , stimesIdempotent , stimesIdempotentMonoid , mtimesDefault -- * Semigroups , Min(..) , Max(..) , First(..) , Last(..) , WrappedMonoid(..) -- * Re-exported monoids from Data.Monoid , Dual(..) , Endo(..) , All(..) , Any(..) , Sum(..) , Product(..) -- * A better monoid for Maybe , Option(..) , option -- * Difference lists of a semigroup , diff , cycle1 -- * ArgMin, ArgMax , Arg(..) , ArgMin , ArgMax #endif ) where #if MIN_VERSION_base(4,9,0) import Data.Semigroup #endif base-compat-0.10.5/src/Data/Semigroup/Compat/0000755000000000000000000000000013362115654017021 5ustar0000000000000000base-compat-0.10.5/src/Data/Semigroup/Compat/Repl.hs0000644000000000000000000000044013362115654020255 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Data.Semigroup.Compat" -- from a globally unique namespace. module Data.Semigroup.Compat.Repl ( module Data.Semigroup.Compat ) where import "this" Data.Semigroup.Compat base-compat-0.10.5/src/Data/Foldable/0000755000000000000000000000000013362115654015334 5ustar0000000000000000base-compat-0.10.5/src/Data/Foldable/Compat.hs0000644000000000000000000000305413362115654017115 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude #-} module Data.Foldable.Compat ( module Base #if !(MIN_VERSION_base(4,8,0)) , length , null #endif #if !(MIN_VERSION_base(4,10,0)) , maximumBy , minimumBy #endif ) where #if MIN_VERSION_base(4,10,0) import Data.Foldable as Base #else import Data.Foldable as Base hiding (maximumBy, minimumBy) import Prelude (Ordering(..)) #endif #if !(MIN_VERSION_base(4,8,0)) import Prelude (Bool(..), Int, (+)) -- | Test whether the structure is empty. The default implementation is -- optimized for structures that are similar to cons-lists, because there -- is no general way to do better. null :: Foldable t => t a -> Bool null = foldr (\_ _ -> False) True -- | Returns the size/length of a finite structure as an 'Int'. The -- default implementation is optimized for structures that are similar to -- cons-lists, because there is no general way to do better. length :: Foldable t => t a -> Int length = foldl' (\c _ -> c+1) 0 #endif #if !(MIN_VERSION_base(4,10,0)) -- | The largest element of a non-empty structure with respect to the -- given comparison function. maximumBy :: Foldable t => (a -> a -> Ordering) -> t a -> a maximumBy cmp = foldl1 max' where max' x y = case cmp x y of GT -> x _ -> y -- | The least element of a non-empty structure with respect to the -- given comparison function. minimumBy :: Foldable t => (a -> a -> Ordering) -> t a -> a minimumBy cmp = foldl1 min' where min' x y = case cmp x y of GT -> y _ -> x #endif base-compat-0.10.5/src/Data/Foldable/Compat/0000755000000000000000000000000013362115654016557 5ustar0000000000000000base-compat-0.10.5/src/Data/Foldable/Compat/Repl.hs0000644000000000000000000000043413362115654020016 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Data.Foldable.Compat" -- from a globally unique namespace. module Data.Foldable.Compat.Repl ( module Data.Foldable.Compat ) where import "this" Data.Foldable.Compat base-compat-0.10.5/src/Numeric/0000755000000000000000000000000013362115654014355 5ustar0000000000000000base-compat-0.10.5/src/Numeric/Compat.hs0000644000000000000000000001117213362115654016136 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude #-} module Numeric.Compat ( module Base , showFFloatAlt , showGFloatAlt , showHFloat ) where import Numeric as Base #if !(MIN_VERSION_base(4,7,0)) import Data.Char (intToDigit) import GHC.Float #endif #if !(MIN_VERSION_base(4,11,0)) import Prelude #endif #if !(MIN_VERSION_base(4,7,0)) -- | Show a signed 'RealFloat' value -- using standard decimal notation (e.g. @245000@, @0.0015@). -- -- This behaves as 'showFFloat', except that a decimal point -- is always guaranteed, even if not needed. -- -- /Since: 4.7.0.0/ showFFloatAlt :: (RealFloat a) => Maybe Int -> a -> ShowS showFFloatAlt d x = showString (formatRealFloatAlt FFFixed d True x) -- | Show a signed 'RealFloat' value -- using standard decimal notation for arguments whose absolute value lies -- between @0.1@ and @9,999,999@, and scientific notation otherwise. -- -- This behaves as 'showFFloat', except that a decimal point -- is always guaranteed, even if not needed. -- -- /Since: 4.7.0.0/ showGFloatAlt :: (RealFloat a) => Maybe Int -> a -> ShowS showGFloatAlt d x = showString (formatRealFloatAlt FFGeneric d True x) formatRealFloatAlt :: (RealFloat a) => FFFormat -> Maybe Int -> Bool -> a -> String formatRealFloatAlt fmt decs alt x | isNaN x = "NaN" | isInfinite x = if x < 0 then "-Infinity" else "Infinity" | x < 0 || isNegativeZero x = '-':doFmt fmt (floatToDigits (toInteger base) (-x)) | otherwise = doFmt fmt (floatToDigits (toInteger base) x) where base = 10 doFmt format (is, e) = let ds = map intToDigit is in case format of FFGeneric -> doFmt (if e < 0 || e > 7 then FFExponent else FFFixed) (is,e) FFExponent -> case decs of Nothing -> let show_e' = show (e-1) in case ds of "0" -> "0.0e0" [d] -> d : ".0e" ++ show_e' (d:ds') -> d : '.' : ds' ++ "e" ++ show_e' [] -> error "formatRealFloat/doFmt/FFExponent: []" Just dec -> let dec' = max dec 1 in case is of [0] -> '0' :'.' : take dec' (repeat '0') ++ "e0" _ -> let (ei,is') = roundTo base (dec'+1) is (d:ds') = map intToDigit (if ei > 0 then init is' else is') in d:'.':ds' ++ 'e':show (e-1+ei) FFFixed -> let mk0 ls = case ls of { "" -> "0" ; _ -> ls} in case decs of Nothing | e <= 0 -> "0." ++ replicate (-e) '0' ++ ds | otherwise -> let f 0 s rs = mk0 (reverse s) ++ '.':mk0 rs f n s "" = f (n-1) ('0':s) "" f n s (r:rs) = f (n-1) (r:s) rs in f e "" ds Just dec -> let dec' = max dec 0 in if e >= 0 then let (ei,is') = roundTo base (dec' + e) is (ls,rs) = splitAt (e+ei) (map intToDigit is') in mk0 ls ++ (if null rs && not alt then "" else '.':rs) else let (ei,is') = roundTo base dec' (replicate (-e) 0 ++ is) d:ds' = map intToDigit (if ei > 0 then is' else 0:is') in d : (if null ds' && not alt then "" else '.':ds') #endif #if !(MIN_VERSION_base(4,11,0)) {- | Show a floating-point value in the hexadecimal format, similar to the @%a@ specifier in C's printf. >>> showHFloat (212.21 :: Double) "" "0x1.a86b851eb851fp7" >>> showHFloat (-12.76 :: Float) "" "-0x1.9851ecp3" >>> showHFloat (-0 :: Double) "" "-0x0p+0" -} showHFloat :: RealFloat a => a -> ShowS showHFloat = showString . fmt where fmt x | isNaN x = "NaN" | isInfinite x = (if x < 0 then "-" else "") ++ "Infinity" | x < 0 || isNegativeZero x = '-' : cvt (-x) | otherwise = cvt x cvt x | x == 0 = "0x0p+0" | otherwise = case floatToDigits 2 x of r@([], _) -> error $ "Impossible happened: showHFloat: " ++ show r (d:ds, e) -> "0x" ++ show d ++ frac ds ++ "p" ++ show (e-1) -- Given binary digits, convert them to hex in blocks of 4 -- Special case: If all 0's, just drop it. frac digits | allZ digits = "" | otherwise = "." ++ hex digits where hex ds = case ds of [] -> "" [a] -> hexDigit a 0 0 0 "" [a,b] -> hexDigit a b 0 0 "" [a,b,c] -> hexDigit a b c 0 "" a : b : c : d : r -> hexDigit a b c d (hex r) hexDigit a b c d = showHex (8*a + 4*b + 2*c + d) allZ xs = case xs of x : more -> x == 0 && allZ more [] -> True #endif base-compat-0.10.5/src/Numeric/Natural/0000755000000000000000000000000013362115654015763 5ustar0000000000000000base-compat-0.10.5/src/Numeric/Natural/Compat.hs0000644000000000000000000000030413362115654017537 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude #-} module Numeric.Natural.Compat ( #if MIN_VERSION_base(4,8,0) module Base #endif ) where #if MIN_VERSION_base(4,8,0) import Numeric.Natural as Base #endif base-compat-0.10.5/src/Numeric/Natural/Compat/0000755000000000000000000000000013362115654017206 5ustar0000000000000000base-compat-0.10.5/src/Numeric/Natural/Compat/Repl.hs0000644000000000000000000000044413362115654020446 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Numeric.Natural.Compat" -- from a globally unique namespace. module Numeric.Natural.Compat.Repl ( module Numeric.Natural.Compat ) where import "this" Numeric.Natural.Compat base-compat-0.10.5/src/Numeric/Compat/0000755000000000000000000000000013362115654015600 5ustar0000000000000000base-compat-0.10.5/src/Numeric/Compat/Repl.hs0000644000000000000000000000040413362115654017034 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Numeric.Compat" -- from a globally unique namespace. module Numeric.Compat.Repl ( module Numeric.Compat ) where import "this" Numeric.Compat base-compat-0.10.5/src/Foreign/0000755000000000000000000000000013362115654014344 5ustar0000000000000000base-compat-0.10.5/src/Foreign/Compat.hs0000644000000000000000000000035313362115654016124 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude #-} #if __GLASGOW_HASKELL__ >= 702 {-# LANGUAGE Trustworthy #-} #endif module Foreign.Compat ( module Base , module Marshal ) where import Foreign as Base import Foreign.Marshal.Compat as Marshal base-compat-0.10.5/src/Foreign/Marshal/0000755000000000000000000000000013362115654015733 5ustar0000000000000000base-compat-0.10.5/src/Foreign/Marshal/Compat.hs0000644000000000000000000000056513362115654017520 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude #-} #if __GLASGOW_HASKELL__ >= 702 {-# LANGUAGE Trustworthy #-} #endif module Foreign.Marshal.Compat ( module Base , module Alloc , module Array , module Utils ) where import Foreign.Marshal as Base import Foreign.Marshal.Alloc.Compat as Alloc import Foreign.Marshal.Array.Compat as Array import Foreign.Marshal.Utils.Compat as Utils base-compat-0.10.5/src/Foreign/Marshal/Alloc/0000755000000000000000000000000013362115654016765 5ustar0000000000000000base-compat-0.10.5/src/Foreign/Marshal/Alloc/Compat.hs0000644000000000000000000000237413362115654020552 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude #-} {-# LANGUAGE ForeignFunctionInterface #-} module Foreign.Marshal.Alloc.Compat ( module Base , calloc , callocBytes ) where import Foreign.Marshal.Alloc as Base #if !(MIN_VERSION_base(4,8,0)) import Foreign.C.Types import Foreign.Ptr (Ptr, nullPtr) import Foreign.Storable (Storable(..)) import GHC.IO.Exception import Prelude.Compat -- |Like 'malloc' but memory is filled with bytes of value zero. -- {-# INLINE calloc #-} calloc :: Storable a => IO (Ptr a) calloc = doCalloc undefined where doCalloc :: Storable b => b -> IO (Ptr b) doCalloc dummy = callocBytes (sizeOf dummy) -- |Llike 'mallocBytes' but memory is filled with bytes of value zero. -- callocBytes :: Int -> IO (Ptr a) callocBytes size = failWhenNULL "calloc" $ _calloc 1 (fromIntegral size) -- asserts that the pointer returned from the action in the second argument is -- non-null -- failWhenNULL :: String -> IO (Ptr a) -> IO (Ptr a) failWhenNULL name f = do addr <- f if addr == nullPtr then ioError (IOError Nothing ResourceExhausted name "out of memory" Nothing Nothing) else return addr foreign import ccall unsafe "stdlib.h calloc" _calloc :: CSize -> CSize -> IO (Ptr a) #endif base-compat-0.10.5/src/Foreign/Marshal/Alloc/Compat/0000755000000000000000000000000013362115654020210 5ustar0000000000000000base-compat-0.10.5/src/Foreign/Marshal/Alloc/Compat/Repl.hs0000644000000000000000000000047413362115654021453 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Foreign.Marshal.Alloc.Compat" -- from a globally unique namespace. module Foreign.Marshal.Alloc.Compat.Repl ( module Foreign.Marshal.Alloc.Compat ) where import "this" Foreign.Marshal.Alloc.Compat base-compat-0.10.5/src/Foreign/Marshal/Unsafe/0000755000000000000000000000000013362115654017154 5ustar0000000000000000base-compat-0.10.5/src/Foreign/Marshal/Unsafe/Compat.hs0000644000000000000000000000040713362115654020734 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude #-} module Foreign.Marshal.Unsafe.Compat ( -- * Unsafe functions unsafeLocalState ) where #if MIN_VERSION_base(4,6,0) import Foreign.Marshal.Unsafe (unsafeLocalState) #else import Foreign.Marshal (unsafeLocalState) #endif base-compat-0.10.5/src/Foreign/Marshal/Unsafe/Compat/0000755000000000000000000000000013362115654020377 5ustar0000000000000000base-compat-0.10.5/src/Foreign/Marshal/Unsafe/Compat/Repl.hs0000644000000000000000000000050013362115654021630 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Foreign.Marshal.Unsafe.Compat" -- from a globally unique namespace. module Foreign.Marshal.Unsafe.Compat.Repl ( module Foreign.Marshal.Unsafe.Compat ) where import "this" Foreign.Marshal.Unsafe.Compat base-compat-0.10.5/src/Foreign/Marshal/Array/0000755000000000000000000000000013362115654017011 5ustar0000000000000000base-compat-0.10.5/src/Foreign/Marshal/Array/Compat.hs0000644000000000000000000000143713362115654020575 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude #-} module Foreign.Marshal.Array.Compat ( module Base , callocArray , callocArray0 ) where import Foreign.Marshal.Array as Base #if !(MIN_VERSION_base(4,8,0)) import Foreign.Marshal.Alloc.Compat import Foreign.Ptr (Ptr) import Foreign.Storable (Storable(..)) import Prelude.Compat -- |Like 'mallocArray', but allocated memory is filled with bytes of value zero. -- callocArray :: Storable a => Int -> IO (Ptr a) callocArray = doCalloc undefined where doCalloc :: Storable a' => a' -> Int -> IO (Ptr a') doCalloc dummy size = callocBytes (size * sizeOf dummy) -- |Like 'callocArray0', but allocated memory is filled with bytes of value -- zero. -- callocArray0 :: Storable a => Int -> IO (Ptr a) callocArray0 size = callocArray (size + 1) #endif base-compat-0.10.5/src/Foreign/Marshal/Array/Compat/0000755000000000000000000000000013362115654020234 5ustar0000000000000000base-compat-0.10.5/src/Foreign/Marshal/Array/Compat/Repl.hs0000644000000000000000000000047413362115654021477 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Foreign.Marshal.Array.Compat" -- from a globally unique namespace. module Foreign.Marshal.Array.Compat.Repl ( module Foreign.Marshal.Array.Compat ) where import "this" Foreign.Marshal.Array.Compat base-compat-0.10.5/src/Foreign/Marshal/Compat/0000755000000000000000000000000013362115654017156 5ustar0000000000000000base-compat-0.10.5/src/Foreign/Marshal/Compat/Repl.hs0000644000000000000000000000044413362115654020416 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Foreign.Marshal.Compat" -- from a globally unique namespace. module Foreign.Marshal.Compat.Repl ( module Foreign.Marshal.Compat ) where import "this" Foreign.Marshal.Compat base-compat-0.10.5/src/Foreign/Marshal/Utils/0000755000000000000000000000000013362115654017033 5ustar0000000000000000base-compat-0.10.5/src/Foreign/Marshal/Utils/Compat.hs0000644000000000000000000000117413362115654020615 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude #-} {-# LANGUAGE ForeignFunctionInterface #-} module Foreign.Marshal.Utils.Compat ( module Base , fillBytes ) where import Foreign.Marshal.Utils as Base #if !(MIN_VERSION_base(4,8,0)) import Data.Word (Word8) import Foreign.C.Types import Foreign.Ptr import Prelude -- |Fill a given number of bytes in memory area with a byte value. -- -- /Since: 4.8.0.0/ fillBytes :: Ptr a -> Word8 -> Int -> IO () fillBytes dest char size = do _ <- memset dest (fromIntegral char) (fromIntegral size) return () foreign import ccall unsafe "string.h" memset :: Ptr a -> CInt -> CSize -> IO (Ptr a) #endif base-compat-0.10.5/src/Foreign/Marshal/Utils/Compat/0000755000000000000000000000000013362115654020256 5ustar0000000000000000base-compat-0.10.5/src/Foreign/Marshal/Utils/Compat/Repl.hs0000644000000000000000000000047413362115654021521 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Foreign.Marshal.Utils.Compat" -- from a globally unique namespace. module Foreign.Marshal.Utils.Compat.Repl ( module Foreign.Marshal.Utils.Compat ) where import "this" Foreign.Marshal.Utils.Compat base-compat-0.10.5/src/Foreign/Marshal/Safe/0000755000000000000000000000000013362115654016611 5ustar0000000000000000base-compat-0.10.5/src/Foreign/Marshal/Safe/Compat.hs0000644000000000000000000000105513362115654020371 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude #-} module Foreign.Marshal.Safe.Compat ( -- | The module "Foreign.Marshal.Safe" re-exports the other modules in the -- @Foreign.Marshal@ hierarchy: module Foreign.Marshal.Alloc , module Foreign.Marshal.Array , module Foreign.Marshal.Error , module Foreign.Marshal.Pool , module Foreign.Marshal.Utils ) where import Foreign.Marshal.Alloc import Foreign.Marshal.Array import Foreign.Marshal.Error import Foreign.Marshal.Pool import Foreign.Marshal.Utils base-compat-0.10.5/src/Foreign/Marshal/Safe/Compat/0000755000000000000000000000000013362115654020034 5ustar0000000000000000base-compat-0.10.5/src/Foreign/Marshal/Safe/Compat/Repl.hs0000644000000000000000000000047013362115654021273 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Foreign.Marshal.Safe.Compat" -- from a globally unique namespace. module Foreign.Marshal.Safe.Compat.Repl ( module Foreign.Marshal.Safe.Compat ) where import "this" Foreign.Marshal.Safe.Compat base-compat-0.10.5/src/Foreign/ForeignPtr/0000755000000000000000000000000013362115654016423 5ustar0000000000000000base-compat-0.10.5/src/Foreign/ForeignPtr/Compat.hs0000644000000000000000000000177613362115654020215 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude #-} {-# LANGUAGE MagicHash #-} #if __GLASGOW_HASKELL__ >= 702 {-# LANGUAGE Trustworthy #-} #endif module Foreign.ForeignPtr.Compat ( module Base , plusForeignPtr ) where import Foreign.ForeignPtr as Base #if !(MIN_VERSION_base(4,10,0)) import GHC.Exts (Int(..), plusAddr#) import GHC.ForeignPtr (ForeignPtr(..)) plusForeignPtr :: ForeignPtr a -> Int -> ForeignPtr b -- ^Advances the given address by the given offset in bytes. -- -- The new 'ForeignPtr' shares the finalizer of the original, -- equivalent from a finalization standpoint to just creating another -- reference to the original. That is, the finalizer will not be -- called before the new 'ForeignPtr' is unreachable, nor will it be -- called an additional time due to this call, and the finalizer will -- be called with the same address that it would have had this call -- not happened, *not* the new address. -- -- /Since: 4.10.0.0/ plusForeignPtr (ForeignPtr addr c) (I# d) = ForeignPtr (plusAddr# addr d) c #endif base-compat-0.10.5/src/Foreign/ForeignPtr/Unsafe/0000755000000000000000000000000013362115654017644 5ustar0000000000000000base-compat-0.10.5/src/Foreign/ForeignPtr/Unsafe/Compat.hs0000644000000000000000000000045313362115654021425 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude #-} module Foreign.ForeignPtr.Unsafe.Compat ( -- ** Unsafe low-level operations unsafeForeignPtrToPtr ) where #if MIN_VERSION_base(4,6,0) import Foreign.ForeignPtr.Unsafe (unsafeForeignPtrToPtr) #else import Foreign.ForeignPtr (unsafeForeignPtrToPtr) #endif base-compat-0.10.5/src/Foreign/ForeignPtr/Unsafe/Compat/0000755000000000000000000000000013362115654021067 5ustar0000000000000000base-compat-0.10.5/src/Foreign/ForeignPtr/Unsafe/Compat/Repl.hs0000644000000000000000000000051413362115654022325 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Foreign.ForeignPtr.Unsafe.Compat" -- from a globally unique namespace. module Foreign.ForeignPtr.Unsafe.Compat.Repl ( module Foreign.ForeignPtr.Unsafe.Compat ) where import "this" Foreign.ForeignPtr.Unsafe.Compat base-compat-0.10.5/src/Foreign/ForeignPtr/Compat/0000755000000000000000000000000013362115654017646 5ustar0000000000000000base-compat-0.10.5/src/Foreign/ForeignPtr/Compat/Repl.hs0000644000000000000000000000046013362115654021104 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Foreign.ForeignPtr.Compat" -- from a globally unique namespace. module Foreign.ForeignPtr.Compat.Repl ( module Foreign.ForeignPtr.Compat ) where import "this" Foreign.ForeignPtr.Compat base-compat-0.10.5/src/Foreign/ForeignPtr/Safe/0000755000000000000000000000000013362115654017301 5ustar0000000000000000base-compat-0.10.5/src/Foreign/ForeignPtr/Safe/Compat.hs0000644000000000000000000000164413362115654021065 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude #-} #if __GLASGOW_HASKELL__ >= 702 {-# LANGUAGE Trustworthy #-} #endif module Foreign.ForeignPtr.Safe.Compat ( -- * Finalised data pointers ForeignPtr , FinalizerPtr #if defined(__HUGS__) || defined(__GLASGOW_HASKELL__) , FinalizerEnvPtr #endif -- ** Basic operations , newForeignPtr , newForeignPtr_ , addForeignPtrFinalizer #if defined(__HUGS__) || defined(__GLASGOW_HASKELL__) , newForeignPtrEnv , addForeignPtrFinalizerEnv #endif , withForeignPtr #ifdef __GLASGOW_HASKELL__ , finalizeForeignPtr #endif -- ** Low-level operations , touchForeignPtr , castForeignPtr -- ** Allocating managed memory , mallocForeignPtr , mallocForeignPtrBytes , mallocForeignPtrArray , mallocForeignPtrArray0 ) where import Foreign.ForeignPtr base-compat-0.10.5/src/Foreign/ForeignPtr/Safe/Compat/0000755000000000000000000000000013362115654020524 5ustar0000000000000000base-compat-0.10.5/src/Foreign/ForeignPtr/Safe/Compat/Repl.hs0000644000000000000000000000050413362115654021761 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Foreign.ForeignPtr.Safe.Compat" -- from a globally unique namespace. module Foreign.ForeignPtr.Safe.Compat.Repl ( module Foreign.ForeignPtr.Safe.Compat ) where import "this" Foreign.ForeignPtr.Safe.Compat base-compat-0.10.5/src/Foreign/Compat/0000755000000000000000000000000013362115654015567 5ustar0000000000000000base-compat-0.10.5/src/Foreign/Compat/Repl.hs0000644000000000000000000000040413362115654017023 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Foreign.Compat" -- from a globally unique namespace. module Foreign.Compat.Repl ( module Foreign.Compat ) where import "this" Foreign.Compat base-compat-0.10.5/src/System/0000755000000000000000000000000013362115654014237 5ustar0000000000000000base-compat-0.10.5/src/System/IO/0000755000000000000000000000000013362115654014546 5ustar0000000000000000base-compat-0.10.5/src/System/IO/Unsafe/0000755000000000000000000000000013362115654015767 5ustar0000000000000000base-compat-0.10.5/src/System/IO/Unsafe/Compat.hs0000644000000000000000000000155413362115654017553 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude #-} module System.IO.Unsafe.Compat ( module Base , unsafeFixIO , unsafeDupablePerformIO ) where import System.IO.Unsafe as Base #if !(MIN_VERSION_base(4,5,0)) import Control.Exception import Data.IORef import GHC.Base import GHC.IO -- | A slightly faster version of `System.IO.fixIO` that may not be -- safe to use with multiple threads. The unsafety arises when used -- like this: -- -- > unsafeFixIO $ \r -> do -- > forkIO (print r) -- > return (...) -- -- In this case, the child thread will receive a @NonTermination@ -- exception instead of waiting for the value of @r@ to be computed. -- -- /Since: 4.5.0.0/ unsafeFixIO :: (a -> IO a) -> IO a unsafeFixIO k = do ref <- newIORef (throw NonTermination) ans <- unsafeDupableInterleaveIO (readIORef ref) result <- k ans writeIORef ref result return result #endif base-compat-0.10.5/src/System/IO/Unsafe/Compat/0000755000000000000000000000000013362115654017212 5ustar0000000000000000base-compat-0.10.5/src/System/IO/Unsafe/Compat/Repl.hs0000644000000000000000000000045013362115654020447 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "System.IO.Unsafe.Compat" -- from a globally unique namespace. module System.IO.Unsafe.Compat.Repl ( module System.IO.Unsafe.Compat ) where import "this" System.IO.Unsafe.Compat base-compat-0.10.5/src/System/Environment/0000755000000000000000000000000013362115654016543 5ustar0000000000000000base-compat-0.10.5/src/System/Environment/Compat.hs0000644000000000000000000001015013362115654020317 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude #-} {-# LANGUAGE ForeignFunctionInterface #-} -- | Miscellaneous information about the system environment. module System.Environment.Compat ( getArgs , getProgName , getEnv , lookupEnv , setEnv , unsetEnv , withArgs , withProgName , getEnvironment ) where import System.Environment #if !(MIN_VERSION_base(4,7,0)) import Prelude.Compat # ifdef mingw32_HOST_OS import Control.Monad import Foreign.C import Foreign.Safe import GHC.Windows # else import qualified System.Posix.Env as Posix # endif # ifdef mingw32_HOST_OS # if defined(i386_HOST_ARCH) # define WINDOWS_CCONV stdcall # elif defined(x86_64_HOST_ARCH) # define WINDOWS_CCONV ccall # else # error Unknown mingw32 arch # endif foreign import WINDOWS_CCONV unsafe "windows.h GetLastError" c_GetLastError:: IO DWORD eRROR_ENVVAR_NOT_FOUND :: DWORD eRROR_ENVVAR_NOT_FOUND = 203 # endif # if !(MIN_VERSION_base(4,6,0)) -- | Return the value of the environment variable @var@, or @Nothing@ if -- there is no such value. -- -- For POSIX users, this is equivalent to 'System.Posix.Env.getEnv'. lookupEnv :: String -> IO (Maybe String) lookupEnv k = lookup k `fmap` getEnvironment # endif -- | @setEnv name value@ sets the specified environment variable to @value@. -- -- On Windows setting an environment variable to the /empty string/ removes -- that environment variable from the environment. For the sake of -- compatibility we adopt that behavior. In particular -- -- @ -- setEnv name \"\" -- @ -- -- has the same effect as -- -- @ -- `unsetEnv` name -- @ -- -- If you don't care about Windows support and want to set an environment -- variable to the empty string use @System.Posix.Env.setEnv@ from the @unix@ -- package instead. -- -- Throws `Control.Exception.IOException` if @name@ is the empty string or -- contains an equals sign. -- -- Note that setting Unicode values may not work correctly on versions of GHC -- prior to 7.2. setEnv :: String -> String -> IO () setEnv key value_ | null value = unsetEnv key | otherwise = setEnv_ key value where -- NOTE: Anything that follows NUL is ignored on both POSIX and Windows. -- We still strip it manually so that the null check above succeds if a -- value starts with NUL, and `unsetEnv` is called. This is important for -- two reasons. -- -- * On POSIX setting an environment variable to the empty string does not -- remove it. -- -- * On Windows setting an environment variable to the empty string -- removes that environment variable. A subsequent call to -- GetEnvironmentVariable will then return 0, but the calling thread's -- last-error code will not be updated, and hence a call to GetLastError -- may not return ERROR_ENVVAR_NOT_FOUND. The failed lookup will then -- result in a random error instead of the expected -- `isDoesNotExistError` (this is at least true for Windows XP, SP 3). -- Explicitly calling `unsetEnv` prevents this. value = takeWhile (/= '\NUL') value_ setEnv_ :: String -> String -> IO () # ifdef mingw32_HOST_OS setEnv_ key value = withCWString key $ \k -> withCWString value $ \v -> do success <- c_SetEnvironmentVariable k v unless success (throwGetLastError "setEnv") foreign import WINDOWS_CCONV unsafe "windows.h SetEnvironmentVariableW" c_SetEnvironmentVariable :: LPTSTR -> LPTSTR -> IO Bool # else setEnv_ k v = Posix.setEnv k v True # endif -- | @unsetEnv name@ removes the specified environment variable from the -- environment of the current process. -- -- Throws `Control.Exception.IOException` if @name@ is the empty string or -- contains an equals sign. unsetEnv :: String -> IO () # ifdef mingw32_HOST_OS unsetEnv key = withCWString key $ \k -> do success <- c_SetEnvironmentVariable k nullPtr unless success $ do -- We consider unsetting an environment variable that does not exist not as -- an error, hence we ignore eRROR_ENVVAR_NOT_FOUND. err <- c_GetLastError unless (err == eRROR_ENVVAR_NOT_FOUND) $ do throwGetLastError "unsetEnv" # else unsetEnv = Posix.unsetEnv # endif #endif base-compat-0.10.5/src/System/Environment/Compat/0000755000000000000000000000000013362115654017766 5ustar0000000000000000base-compat-0.10.5/src/System/Environment/Compat/Repl.hs0000644000000000000000000000046013362115654021224 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "System.Environment.Compat" -- from a globally unique namespace. module System.Environment.Compat.Repl ( module System.Environment.Compat ) where import "this" System.Environment.Compat base-compat-0.10.5/src/System/Exit/0000755000000000000000000000000013362115654015150 5ustar0000000000000000base-compat-0.10.5/src/System/Exit/Compat.hs0000644000000000000000000000060713362115654016732 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude #-} {-# LANGUAGE CPP #-} module System.Exit.Compat ( module Base , die ) where import System.Exit as Base #if !(MIN_VERSION_base(4,8,0)) import Prelude.Compat import System.IO -- | Write given error message to `stderr` and terminate with `exitFailure`. -- -- @since 4.8.0.0 die :: String -> IO a die err = hPutStrLn stderr err >> exitFailure #endif base-compat-0.10.5/src/System/Exit/Compat/0000755000000000000000000000000013362115654016373 5ustar0000000000000000base-compat-0.10.5/src/System/Exit/Compat/Repl.hs0000644000000000000000000000042413362115654017631 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "System.Exit.Compat" -- from a globally unique namespace. module System.Exit.Compat.Repl ( module System.Exit.Compat ) where import "this" System.Exit.Compat base-compat-0.10.5/src/Prelude/0000755000000000000000000000000013362115654014353 5ustar0000000000000000base-compat-0.10.5/src/Prelude/Compat.hs0000644000000000000000000001005513362115654016133 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude #-} #if __GLASGOW_HASKELL__ >= 702 {-# LANGUAGE Trustworthy #-} #endif #if MIN_VERSION_base(4,10,0) && !(MIN_VERSION_base(4,12,0)) {-# LANGUAGE BangPatterns #-} {-# LANGUAGE RankNTypes #-} {-# LANGUAGE TypeInType #-} #endif module Prelude.Compat ( #if MIN_VERSION_base(4,12,0) module Base #else either , all , and , any , concat , concatMap , mapM_ , notElem , or , sequence_ , (<$>) , maybe , lines , unlines , unwords , words , curry , fst , snd , uncurry , ($!) , (++) , (.) , (=<<) , asTypeOf , const , flip , id , map , otherwise , until , ioError , userError , (!!) , break , cycle , drop , dropWhile , filter , head , init , iterate , last , lookup , repeat , replicate , reverse , scanl , scanl1 , scanr , scanr1 , span , splitAt , tail , take , takeWhile , unzip , unzip3 , zip , zip3 , zipWith , zipWith3 , subtract , lex , readParen , (^) , (^^) , even , fromIntegral , gcd , lcm , odd , realToFrac , showChar , showParen , showString , shows , appendFile , getChar , getContents , getLine , interact , print , putChar , putStr , putStrLn , readFile , readIO , readLn , writeFile , read , reads , (&&) , not , (||) , ($) , error , errorWithoutStackTrace , undefined , seq , elem , foldMap , foldl , foldl1 , foldr , foldr1 , length , maximum , minimum , null , product , sum , mapM , sequence , sequenceA , traverse , (*>) , (<*) , (<*>) , pure , (<$) , fmap , (>>) , (>>=) , fail , return , mappend , mconcat , mempty # if MIN_VERSION_base(4,9,0) , (<>) # endif , maxBound , minBound , enumFrom , enumFromThen , enumFromThenTo , enumFromTo , fromEnum , pred , succ , toEnum , (**) , acos , acosh , asin , asinh , atan , atanh , cos , cosh , exp , log , logBase , pi , sin , sinh , sqrt , tan , tanh , atan2 , decodeFloat , encodeFloat , exponent , floatDigits , floatRadix , floatRange , isDenormalized , isIEEE , isInfinite , isNaN , isNegativeZero , scaleFloat , significand , (*) , (+) , (-) , abs , negate , signum , readList , readsPrec , (/) , fromRational , recip , div , divMod , mod , quot , quotRem , rem , toInteger , toRational , ceiling , floor , properFraction , round , truncate , show , showList , showsPrec , (/=) , (==) , (<) , (<=) , (>) , (>=) , compare , max , min -- classes , Applicative , Bounded , Enum , Eq , Floating , Foldable , Fractional , Functor , Integral , Monad , Monoid , Num (fromInteger) , Ord , Read , Real , RealFloat , RealFrac # if MIN_VERSION_base(4,9,0) , Semigroup # endif , Show , Traversable -- data types , IO , Char , Double , Float , Int , Integer , Word , Bool (True, False) , Either(Left, Right) , Maybe(Just, Nothing) , Ordering (EQ, GT, LT) -- type synonyms , FilePath , IOError , Rational , ReadS , ShowS , String #endif ) where #if MIN_VERSION_base(4,9,0) import Prelude as Base # if MIN_VERSION_base(4,10,0) && !(MIN_VERSION_base(4,12,0)) hiding (($!)) # endif #else import Prelude hiding ( length , null , foldr , mapM , sequence , all , and , any , concat , concatMap , mapM , mapM_ , notElem , or , sequence , sequence_ , elem , foldl , foldl1 , foldr1 , maximum , minimum , product , sum ) import Data.Foldable.Compat import Data.Traversable # if !(MIN_VERSION_base(4,8,0)) import Control.Applicative import Data.Monoid import Data.Word # endif #endif #if MIN_VERSION_base(4,9,0) && !(MIN_VERSION_base(4,11,0)) import Data.Semigroup as Base (Semigroup((<>))) #endif #if MIN_VERSION_base(4,10,0) && !(MIN_VERSION_base(4,12,0)) import GHC.Exts (TYPE) #endif #if !(MIN_VERSION_base(4,9,0)) -- | A variant of 'error' that does not produce a stack trace. -- -- /Since: 4.9.0.0/ errorWithoutStackTrace :: [Char] -> a errorWithoutStackTrace s = error s {-# NOINLINE errorWithoutStackTrace #-} #endif #if MIN_VERSION_base(4,10,0) && !(MIN_VERSION_base(4,12,0)) -- | Strict (call-by-value) application operator. It takes a function and an -- argument, evaluates the argument to weak head normal form (WHNF), then calls -- the function with that value. infixr 0 $! ($!) :: forall r a (b :: TYPE r). (a -> b) -> a -> b f $! x = let !vx = x in f vx -- see #2273 #endif base-compat-0.10.5/src/Prelude/Compat/0000755000000000000000000000000013362115654015576 5ustar0000000000000000base-compat-0.10.5/src/Prelude/Compat/Repl.hs0000644000000000000000000000040413362115654017032 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Prelude.Compat" -- from a globally unique namespace. module Prelude.Compat.Repl ( module Prelude.Compat ) where import "this" Prelude.Compat base-compat-0.10.5/src/Debug/0000755000000000000000000000000013362115654014001 5ustar0000000000000000base-compat-0.10.5/src/Debug/Trace/0000755000000000000000000000000013362115654015037 5ustar0000000000000000base-compat-0.10.5/src/Debug/Trace/Compat.hs0000644000000000000000000000332413362115654016620 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude #-} module Debug.Trace.Compat ( module Base , traceId , traceShowId , traceM , traceShowM ) where #if !(MIN_VERSION_base(4,7,0)) || MIN_VERSION_base(4,9,0) import Debug.Trace as Base #else import Debug.Trace as Base hiding ( traceM , traceShowM ) #endif #if !(MIN_VERSION_base(4,9,0)) import Prelude.Compat #endif #if !(MIN_VERSION_base(4,7,0)) {-| Like 'trace' but returns the message instead of a third value. /Since: 4.7.0.0/ -} traceId :: String -> String traceId a = trace a a {-| Like 'traceShow' but returns the shown value instead of a third value. /Since: 4.7.0.0/ -} traceShowId :: (Show a) => a -> a traceShowId a = trace (show a) a #endif #if !(MIN_VERSION_base(4,9,0)) {-| Like 'trace' but returning unit in an arbitrary 'Applicative' context. Allows for convenient use in do-notation. Note that the application of 'traceM' is not an action in the 'Applicative' context, as 'traceIO' is in the 'IO' type. While the fresh bindings in the following example will force the 'traceM' expressions to be reduced every time the @do@-block is executed, @traceM "not crashed"@ would only be reduced once, and the message would only be printed once. If your monad is in 'MonadIO', @liftIO . traceIO@ may be a better option. > ... = do > x <- ... > traceM $ "x: " ++ show x > y <- ... > traceM $ "y: " ++ show y /Since: 4.7.0.0/ -} traceM :: (Applicative f) => String -> f () traceM string = trace string $ pure () {-| Like 'traceM', but uses 'show' on the argument to convert it to a 'String'. > ... = do > x <- ... > traceShowM $ x > y <- ... > traceShowM $ x + y /Since: 4.7.0.0/ -} traceShowM :: (Show a, Applicative f) => a -> f () traceShowM = traceM . show #endif base-compat-0.10.5/src/Debug/Trace/Compat/0000755000000000000000000000000013362115654016262 5ustar0000000000000000base-compat-0.10.5/src/Debug/Trace/Compat/Repl.hs0000644000000000000000000000042413362115654017520 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Debug.Trace.Compat" -- from a globally unique namespace. module Debug.Trace.Compat.Repl ( module Debug.Trace.Compat ) where import "this" Debug.Trace.Compat