base-compat-0.11.1/0000755000000000000000000000000007346545000012156 5ustar0000000000000000base-compat-0.11.1/CHANGES.markdown0000755000000000000000000002310507346545000014776 0ustar0000000000000000## Changes in 0.11.1 [2020.01.27] - Sync with `base-4.14`/GHC 8.10 - Backport `isResourceVanishedError`, `resourceVanishedErrorType`, and `isResourceVanishedErrorType` to `System.IO.Error.Compat`. ## Changes in 0.11.0 [2019.09.06] - Sync with `base-4.13`/GHC 8.8 - Backport `MonadFail(fail)` to `Prelude.Compat` and `Control.Monad.Compat`. Because `Prelude.Compat.fail` now corresponds to the `fail` from `MonadFail` instead of `Monad`, some care is required to implement `Monad.fail` on pre-8.8 versions of GHC. The following template is recommended: ```haskell import Prelude.Compat import qualified Control.Monad as Monad import qualified Control.Monad.Fail as Fail data Blah a = ... instance Functor Blah where ... instance Applicative Blah where ... instance Monad.Monad Blah where (>>=) = ... #if !(MIN_VERSION_base(4,13,0)) fail = Fail.fail #endif instance Fail.MonadFail Blah where fail = ... ``` This approach is also backwards-compatible with previous releases of `base-compat`. Note that the `MonadFail` 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`/`Control.Monad.Compat` that backports `MonadFail` to older GHCs (by conditionally depending on the `fail` library), use the `Prelude.Compat`/`Control.Monad.Compat` modules from the `base-compat-batteries` package. - Introduce the `Data.Type.Equality.Compat` module, which re-exports `Data.Type.Equality` if using `base-4.7`/GHC-7.8 or later. If using an older version of `base`, this module is empty. If you wish to have a version of `Data.Type.Equality.Compat` with older GHCs (by conditionally depending on the `type-equality` library), use the `Data.Type.Equality.Compat` module from the `base-compat-batteries` package. ## 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.11.1/LICENSE0000644000000000000000000000214007346545000013160 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.11.1/README.markdown0000755000000000000000000003435107346545000014670 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` * `isResourceVanishedError`, `resourceVanishedErrorType`, and `isResourceVanishedErrorType` to `System.IO.Error.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.10.*` / `base-4.14.*` * `ghc-8.8.*` / `base-4.13.*` * `ghc-8.6.*` / `base-4.12.*` * `ghc-8.4.*` / `base-4.11.*` * `ghc-8.2.*` / `base-4.10.*` * `ghc-8.0.*` / `base-4.9.*` * `ghc-7.10.*` / `base-4.8.*` * `ghc-7.8.*` / `base-4.7.*` * `ghc-7.6.*` / `base-4.6.*` * `ghc-7.4.*` / `base-4.5.*` * `ghc-7.2.*` / `base-4.4.*` * `ghc-7.0.*` / `base-4.3.*` We also make an attempt to keep `base-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.11.1/Setup.lhs0000644000000000000000000000011407346545000013762 0ustar0000000000000000#!/usr/bin/env runhaskell > import Distribution.Simple > main = defaultMain base-compat-0.11.1/base-compat.cabal0000644000000000000000000001574407346545000015350 0ustar0000000000000000name: base-compat version: 0.11.1 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.4 , GHC == 7.2.2 , GHC == 7.4.2 , GHC == 7.6.3 , GHC == 7.8.4 , GHC == 7.10.3 , GHC == 8.0.2 , GHC == 8.2.2 , GHC == 8.4.4 , GHC == 8.6.5 , GHC == 8.8.2 , GHC == 8.10.1 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.Type.Equality.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.Error.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.Type.Equality.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.Error.Compat.Repl System.IO.Unsafe.Compat.Repl Text.Read.Compat.Repl Type.Reflection.Compat.Repl base-compat-0.11.1/src/Control/Concurrent/0000755000000000000000000000000007346545000016507 5ustar0000000000000000base-compat-0.11.1/src/Control/Concurrent/Compat.hs0000644000000000000000000000241707346545000020272 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.11.1/src/Control/Concurrent/Compat/0000755000000000000000000000000007346545000017732 5ustar0000000000000000base-compat-0.11.1/src/Control/Concurrent/Compat/Repl.hs0000644000000000000000000000046007346545000021170 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.11.1/src/Control/Concurrent/MVar/0000755000000000000000000000000007346545000017354 5ustar0000000000000000base-compat-0.11.1/src/Control/Concurrent/MVar/Compat.hs0000644000000000000000000000122707346545000021135 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.11.1/src/Control/Concurrent/MVar/Compat/0000755000000000000000000000000007346545000020577 5ustar0000000000000000base-compat-0.11.1/src/Control/Concurrent/MVar/Compat/Repl.hs0000644000000000000000000000050407346545000022034 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.11.1/src/Control/Exception/0000755000000000000000000000000007346545000016323 5ustar0000000000000000base-compat-0.11.1/src/Control/Exception/Compat.hs0000644000000000000000000000131007346545000020075 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.11.1/src/Control/Exception/Compat/0000755000000000000000000000000007346545000017546 5ustar0000000000000000base-compat-0.11.1/src/Control/Exception/Compat/Repl.hs0000644000000000000000000000045407346545000021007 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.11.1/src/Control/Monad/0000755000000000000000000000000007346545000015423 5ustar0000000000000000base-compat-0.11.1/src/Control/Monad/Compat.hs0000644000000000000000000001242607346545000017207 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude #-} module Control.Monad.Compat ( module Base , Monad #if MIN_VERSION_base(4,9,0) , MonadFail #endif , fail , 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 hiding (fail) import Control.Monad.Fail 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.11.1/src/Control/Monad/Compat/0000755000000000000000000000000007346545000016646 5ustar0000000000000000base-compat-0.11.1/src/Control/Monad/Compat/Repl.hs0000644000000000000000000000043407346545000020105 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.11.1/src/Control/Monad/Fail/0000755000000000000000000000000007346545000016276 5ustar0000000000000000base-compat-0.11.1/src/Control/Monad/Fail/Compat.hs0000644000000000000000000000031207346545000020051 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.11.1/src/Control/Monad/Fail/Compat/0000755000000000000000000000000007346545000017521 5ustar0000000000000000base-compat-0.11.1/src/Control/Monad/Fail/Compat/Repl.hs0000644000000000000000000000046007346545000020757 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.11.1/src/Control/Monad/IO/Class/0000755000000000000000000000000007346545000016777 5ustar0000000000000000base-compat-0.11.1/src/Control/Monad/IO/Class/Compat.hs0000644000000000000000000000032207346545000020553 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.11.1/src/Control/Monad/IO/Class/Compat/0000755000000000000000000000000007346545000020222 5ustar0000000000000000base-compat-0.11.1/src/Control/Monad/IO/Class/Compat/Repl.hs0000644000000000000000000000050007346545000021453 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.11.1/src/Control/Monad/ST/Lazy/Unsafe/0000755000000000000000000000000007346545000020111 5ustar0000000000000000base-compat-0.11.1/src/Control/Monad/ST/Lazy/Unsafe/Compat.hs0000644000000000000000000000051307346545000021667 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.11.1/src/Control/Monad/ST/Lazy/Unsafe/Compat/0000755000000000000000000000000007346545000021334 5ustar0000000000000000base-compat-0.11.1/src/Control/Monad/ST/Lazy/Unsafe/Compat/Repl.hs0000644000000000000000000000053007346545000022570 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.11.1/src/Control/Monad/ST/Unsafe/0000755000000000000000000000000007346545000017172 5ustar0000000000000000base-compat-0.11.1/src/Control/Monad/ST/Unsafe/Compat.hs0000644000000000000000000000054707346545000020757 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.11.1/src/Control/Monad/ST/Unsafe/Compat/0000755000000000000000000000000007346545000020415 5ustar0000000000000000base-compat-0.11.1/src/Control/Monad/ST/Unsafe/Compat/Repl.hs0000644000000000000000000000050407346545000021652 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.11.1/src/Data/Bifoldable/0000755000000000000000000000000007346545000015641 5ustar0000000000000000base-compat-0.11.1/src/Data/Bifoldable/Compat.hs0000644000000000000000000000030607346545000017417 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.11.1/src/Data/Bifoldable/Compat/0000755000000000000000000000000007346545000017064 5ustar0000000000000000base-compat-0.11.1/src/Data/Bifoldable/Compat/Repl.hs0000644000000000000000000000044407346545000020324 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.11.1/src/Data/Bifunctor/0000755000000000000000000000000007346545000015551 5ustar0000000000000000base-compat-0.11.1/src/Data/Bifunctor/Compat.hs0000644000000000000000000000030207346545000017323 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.11.1/src/Data/Bifunctor/Compat/0000755000000000000000000000000007346545000016774 5ustar0000000000000000base-compat-0.11.1/src/Data/Bifunctor/Compat/Repl.hs0000644000000000000000000000044007346545000020230 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.11.1/src/Data/Bitraversable/0000755000000000000000000000000007346545000016403 5ustar0000000000000000base-compat-0.11.1/src/Data/Bitraversable/Compat.hs0000644000000000000000000000031407346545000020160 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.11.1/src/Data/Bitraversable/Compat/0000755000000000000000000000000007346545000017626 5ustar0000000000000000base-compat-0.11.1/src/Data/Bitraversable/Compat/Repl.hs0000644000000000000000000000046007346545000021064 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.11.1/src/Data/Bits/0000755000000000000000000000000007346545000014517 5ustar0000000000000000base-compat-0.11.1/src/Data/Bits/Compat.hs0000644000000000000000000000745407346545000016310 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.11.1/src/Data/Bits/Compat/0000755000000000000000000000000007346545000015742 5ustar0000000000000000base-compat-0.11.1/src/Data/Bits/Compat/Repl.hs0000644000000000000000000000041407346545000017177 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.11.1/src/Data/Bool/0000755000000000000000000000000007346545000014511 5ustar0000000000000000base-compat-0.11.1/src/Data/Bool/Compat.hs0000644000000000000000000000060307346545000016267 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.11.1/src/Data/Bool/Compat/0000755000000000000000000000000007346545000015734 5ustar0000000000000000base-compat-0.11.1/src/Data/Bool/Compat/Repl.hs0000644000000000000000000000041407346545000017171 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.11.1/src/Data/Complex/0000755000000000000000000000000007346545000015225 5ustar0000000000000000base-compat-0.11.1/src/Data/Complex/Compat.hs0000644000000000000000000000251507346545000017007 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.11.1/src/Data/Complex/Compat/0000755000000000000000000000000007346545000016450 5ustar0000000000000000base-compat-0.11.1/src/Data/Complex/Compat/Repl.hs0000644000000000000000000000043007346545000017703 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.11.1/src/Data/Either/0000755000000000000000000000000007346545000015036 5ustar0000000000000000base-compat-0.11.1/src/Data/Either/Compat.hs0000644000000000000000000000231307346545000016614 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.11.1/src/Data/Either/Compat/0000755000000000000000000000000007346545000016261 5ustar0000000000000000base-compat-0.11.1/src/Data/Either/Compat/Repl.hs0000644000000000000000000000042407346545000017517 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.11.1/src/Data/Foldable/0000755000000000000000000000000007346545000015326 5ustar0000000000000000base-compat-0.11.1/src/Data/Foldable/Compat.hs0000644000000000000000000000305407346545000017107 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.11.1/src/Data/Foldable/Compat/0000755000000000000000000000000007346545000016551 5ustar0000000000000000base-compat-0.11.1/src/Data/Foldable/Compat/Repl.hs0000644000000000000000000000043407346545000020010 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.11.1/src/Data/Function/0000755000000000000000000000000007346545000015403 5ustar0000000000000000base-compat-0.11.1/src/Data/Function/Compat.hs0000644000000000000000000000070007346545000017157 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.11.1/src/Data/Function/Compat/0000755000000000000000000000000007346545000016626 5ustar0000000000000000base-compat-0.11.1/src/Data/Function/Compat/Repl.hs0000644000000000000000000000043407346545000020065 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.11.1/src/Data/Functor/0000755000000000000000000000000007346545000015236 5ustar0000000000000000base-compat-0.11.1/src/Data/Functor/Compat.hs0000644000000000000000000000151307346545000017015 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.11.1/src/Data/Functor/Compat/0000755000000000000000000000000007346545000016461 5ustar0000000000000000base-compat-0.11.1/src/Data/Functor/Compat/Repl.hs0000644000000000000000000000043007346545000017714 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.11.1/src/Data/Functor/Compose/0000755000000000000000000000000007346545000016643 5ustar0000000000000000base-compat-0.11.1/src/Data/Functor/Compose/Compat.hs0000644000000000000000000000031607346545000020422 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.11.1/src/Data/Functor/Compose/Compat/0000755000000000000000000000000007346545000020066 5ustar0000000000000000base-compat-0.11.1/src/Data/Functor/Compose/Compat/Repl.hs0000644000000000000000000000047007346545000021325 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.11.1/src/Data/Functor/Const/0000755000000000000000000000000007346545000016324 5ustar0000000000000000base-compat-0.11.1/src/Data/Functor/Const/Compat.hs0000644000000000000000000000020307346545000020076 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude #-} module Data.Functor.Const.Compat (Const(..)) where import Control.Applicative (Const(..)) base-compat-0.11.1/src/Data/Functor/Const/Compat/0000755000000000000000000000000007346545000017547 5ustar0000000000000000base-compat-0.11.1/src/Data/Functor/Const/Compat/Repl.hs0000644000000000000000000000046007346545000021005 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.11.1/src/Data/Functor/Contravariant/0000755000000000000000000000000007346545000020051 5ustar0000000000000000base-compat-0.11.1/src/Data/Functor/Contravariant/Compat.hs0000644000000000000000000000033407346545000021630 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.11.1/src/Data/Functor/Contravariant/Compat/0000755000000000000000000000000007346545000021274 5ustar0000000000000000base-compat-0.11.1/src/Data/Functor/Contravariant/Compat/Repl.hs0000644000000000000000000000052007346545000022527 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.11.1/src/Data/Functor/Identity/0000755000000000000000000000000007346545000017027 5ustar0000000000000000base-compat-0.11.1/src/Data/Functor/Identity/Compat.hs0000644000000000000000000000032007346545000020601 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.11.1/src/Data/Functor/Identity/Compat/0000755000000000000000000000000007346545000020252 5ustar0000000000000000base-compat-0.11.1/src/Data/Functor/Identity/Compat/Repl.hs0000644000000000000000000000047407346545000021515 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.11.1/src/Data/Functor/Product/0000755000000000000000000000000007346545000016656 5ustar0000000000000000base-compat-0.11.1/src/Data/Functor/Product/Compat.hs0000644000000000000000000000031607346545000020435 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.11.1/src/Data/Functor/Product/Compat/0000755000000000000000000000000007346545000020101 5ustar0000000000000000base-compat-0.11.1/src/Data/Functor/Product/Compat/Repl.hs0000644000000000000000000000047007346545000021340 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.11.1/src/Data/Functor/Sum/0000755000000000000000000000000007346545000016002 5ustar0000000000000000base-compat-0.11.1/src/Data/Functor/Sum/Compat.hs0000644000000000000000000000030607346545000017560 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.11.1/src/Data/Functor/Sum/Compat/0000755000000000000000000000000007346545000017225 5ustar0000000000000000base-compat-0.11.1/src/Data/Functor/Sum/Compat/Repl.hs0000644000000000000000000000045007346545000020462 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.11.1/src/Data/IORef/0000755000000000000000000000000007346545000014562 5ustar0000000000000000base-compat-0.11.1/src/Data/IORef/Compat.hs0000644000000000000000000000203507346545000016341 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.11.1/src/Data/IORef/Compat/0000755000000000000000000000000007346545000016005 5ustar0000000000000000base-compat-0.11.1/src/Data/IORef/Compat/Repl.hs0000644000000000000000000000042007346545000017237 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.11.1/src/Data/List/0000755000000000000000000000000007346545000014531 5ustar0000000000000000base-compat-0.11.1/src/Data/List/Compat.hs0000644000000000000000000001434007346545000016312 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.11.1/src/Data/List/Compat/0000755000000000000000000000000007346545000015754 5ustar0000000000000000base-compat-0.11.1/src/Data/List/Compat/Repl.hs0000644000000000000000000000041407346545000017211 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.11.1/src/Data/List/NonEmpty/0000755000000000000000000000000007346545000016302 5ustar0000000000000000base-compat-0.11.1/src/Data/List/NonEmpty/Compat.hs0000644000000000000000000000277707346545000020076 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.11.1/src/Data/List/NonEmpty/Compat/0000755000000000000000000000000007346545000017525 5ustar0000000000000000base-compat-0.11.1/src/Data/List/NonEmpty/Compat/Repl.hs0000644000000000000000000000046007346545000020763 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.11.1/src/Data/Monoid/0000755000000000000000000000000007346545000015043 5ustar0000000000000000base-compat-0.11.1/src/Data/Monoid/Compat.hs0000644000000000000000000000070307346545000016622 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.11.1/src/Data/Monoid/Compat/0000755000000000000000000000000007346545000016266 5ustar0000000000000000base-compat-0.11.1/src/Data/Monoid/Compat/Repl.hs0000644000000000000000000000042407346545000017524 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.11.1/src/Data/Proxy/0000755000000000000000000000000007346545000014737 5ustar0000000000000000base-compat-0.11.1/src/Data/Proxy/Compat.hs0000644000000000000000000000124607346545000016521 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.11.1/src/Data/Proxy/Compat/0000755000000000000000000000000007346545000016162 5ustar0000000000000000base-compat-0.11.1/src/Data/Proxy/Compat/Repl.hs0000644000000000000000000000042007346545000017414 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.11.1/src/Data/Ratio/0000755000000000000000000000000007346545000014674 5ustar0000000000000000base-compat-0.11.1/src/Data/Ratio/Compat.hs0000644000000000000000000000151307346545000016453 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.11.1/src/Data/Ratio/Compat/0000755000000000000000000000000007346545000016117 5ustar0000000000000000base-compat-0.11.1/src/Data/Ratio/Compat/Repl.hs0000644000000000000000000000042007346545000017351 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.11.1/src/Data/STRef/0000755000000000000000000000000007346545000014601 5ustar0000000000000000base-compat-0.11.1/src/Data/STRef/Compat.hs0000644000000000000000000000075407346545000016366 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.11.1/src/Data/STRef/Compat/0000755000000000000000000000000007346545000016024 5ustar0000000000000000base-compat-0.11.1/src/Data/STRef/Compat/Repl.hs0000644000000000000000000000042007346545000017256 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.11.1/src/Data/Semigroup/0000755000000000000000000000000007346545000015570 5ustar0000000000000000base-compat-0.11.1/src/Data/Semigroup/Compat.hs0000644000000000000000000000135707346545000017355 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.11.1/src/Data/Semigroup/Compat/0000755000000000000000000000000007346545000017013 5ustar0000000000000000base-compat-0.11.1/src/Data/Semigroup/Compat/Repl.hs0000644000000000000000000000044007346545000020247 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.11.1/src/Data/String/0000755000000000000000000000000007346545000015064 5ustar0000000000000000base-compat-0.11.1/src/Data/String/Compat.hs0000644000000000000000000000040207346545000016637 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.11.1/src/Data/String/Compat/0000755000000000000000000000000007346545000016307 5ustar0000000000000000base-compat-0.11.1/src/Data/String/Compat/Repl.hs0000644000000000000000000000042407346545000017545 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.11.1/src/Data/Type/Coercion/0000755000000000000000000000000007346545000016300 5ustar0000000000000000base-compat-0.11.1/src/Data/Type/Coercion/Compat.hs0000644000000000000000000000106507346545000020061 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.11.1/src/Data/Type/Coercion/Compat/0000755000000000000000000000000007346545000017523 5ustar0000000000000000base-compat-0.11.1/src/Data/Type/Coercion/Compat/Repl.hs0000644000000000000000000000046007346545000020761 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.11.1/src/Data/Type/Equality/0000755000000000000000000000000007346545000016334 5ustar0000000000000000base-compat-0.11.1/src/Data/Type/Equality/Compat.hs0000644000000000000000000000045107346545000020113 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude #-} {-# LANGUAGE RankNTypes #-} #if __GLASGOW_HASKELL__ >= 702 {-# LANGUAGE Trustworthy #-} #endif module Data.Type.Equality.Compat ( #if MIN_VERSION_base(4,7,0) module Base #endif ) where #if MIN_VERSION_base(4,7,0) import Data.Type.Equality as Base #endif base-compat-0.11.1/src/Data/Type/Equality/Compat/0000755000000000000000000000000007346545000017557 5ustar0000000000000000base-compat-0.11.1/src/Data/Type/Equality/Compat/Repl.hs0000644000000000000000000000046007346545000021015 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Data.Type.Equality.Compat" -- from a globally unique namespace. module Data.Type.Equality.Compat.Repl ( module Data.Type.Equality.Compat ) where import "this" Data.Type.Equality.Compat base-compat-0.11.1/src/Data/Version/0000755000000000000000000000000007346545000015243 5ustar0000000000000000base-compat-0.11.1/src/Data/Version/Compat.hs0000644000000000000000000000047107346545000017024 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.11.1/src/Data/Version/Compat/0000755000000000000000000000000007346545000016466 5ustar0000000000000000base-compat-0.11.1/src/Data/Version/Compat/Repl.hs0000644000000000000000000000043007346545000017721 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.11.1/src/Data/Void/0000755000000000000000000000000007346545000014517 5ustar0000000000000000base-compat-0.11.1/src/Data/Void/Compat.hs0000644000000000000000000000027007346545000016275 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.11.1/src/Data/Void/Compat/0000755000000000000000000000000007346545000015742 5ustar0000000000000000base-compat-0.11.1/src/Data/Void/Compat/Repl.hs0000644000000000000000000000041407346545000017177 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.11.1/src/Data/Word/0000755000000000000000000000000007346545000014531 5ustar0000000000000000base-compat-0.11.1/src/Data/Word/Compat.hs0000644000000000000000000000226707346545000016317 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.11.1/src/Data/Word/Compat/0000755000000000000000000000000007346545000015754 5ustar0000000000000000base-compat-0.11.1/src/Data/Word/Compat/Repl.hs0000644000000000000000000000041407346545000017211 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.11.1/src/Debug/Trace/0000755000000000000000000000000007346545000015031 5ustar0000000000000000base-compat-0.11.1/src/Debug/Trace/Compat.hs0000644000000000000000000000332407346545000016612 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.11.1/src/Debug/Trace/Compat/0000755000000000000000000000000007346545000016254 5ustar0000000000000000base-compat-0.11.1/src/Debug/Trace/Compat/Repl.hs0000644000000000000000000000042407346545000017512 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 base-compat-0.11.1/src/Foreign/0000755000000000000000000000000007346545000014336 5ustar0000000000000000base-compat-0.11.1/src/Foreign/Compat.hs0000644000000000000000000000035307346545000016116 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.11.1/src/Foreign/Compat/0000755000000000000000000000000007346545000015561 5ustar0000000000000000base-compat-0.11.1/src/Foreign/Compat/Repl.hs0000644000000000000000000000040407346545000017015 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.11.1/src/Foreign/ForeignPtr/0000755000000000000000000000000007346545000016415 5ustar0000000000000000base-compat-0.11.1/src/Foreign/ForeignPtr/Compat.hs0000644000000000000000000000177607346545000020207 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.11.1/src/Foreign/ForeignPtr/Compat/0000755000000000000000000000000007346545000017640 5ustar0000000000000000base-compat-0.11.1/src/Foreign/ForeignPtr/Compat/Repl.hs0000644000000000000000000000046007346545000021076 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.11.1/src/Foreign/ForeignPtr/Safe/0000755000000000000000000000000007346545000017273 5ustar0000000000000000base-compat-0.11.1/src/Foreign/ForeignPtr/Safe/Compat.hs0000644000000000000000000000164407346545000021057 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.11.1/src/Foreign/ForeignPtr/Safe/Compat/0000755000000000000000000000000007346545000020516 5ustar0000000000000000base-compat-0.11.1/src/Foreign/ForeignPtr/Safe/Compat/Repl.hs0000644000000000000000000000050407346545000021753 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.11.1/src/Foreign/ForeignPtr/Unsafe/0000755000000000000000000000000007346545000017636 5ustar0000000000000000base-compat-0.11.1/src/Foreign/ForeignPtr/Unsafe/Compat.hs0000644000000000000000000000045307346545000021417 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.11.1/src/Foreign/ForeignPtr/Unsafe/Compat/0000755000000000000000000000000007346545000021061 5ustar0000000000000000base-compat-0.11.1/src/Foreign/ForeignPtr/Unsafe/Compat/Repl.hs0000644000000000000000000000051407346545000022317 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.11.1/src/Foreign/Marshal/Alloc/0000755000000000000000000000000007346545000016757 5ustar0000000000000000base-compat-0.11.1/src/Foreign/Marshal/Alloc/Compat.hs0000644000000000000000000000237407346545000020544 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.11.1/src/Foreign/Marshal/Alloc/Compat/0000755000000000000000000000000007346545000020202 5ustar0000000000000000base-compat-0.11.1/src/Foreign/Marshal/Alloc/Compat/Repl.hs0000644000000000000000000000047407346545000021445 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.11.1/src/Foreign/Marshal/Array/0000755000000000000000000000000007346545000017003 5ustar0000000000000000base-compat-0.11.1/src/Foreign/Marshal/Array/Compat.hs0000644000000000000000000000143707346545000020567 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.11.1/src/Foreign/Marshal/Array/Compat/0000755000000000000000000000000007346545000020226 5ustar0000000000000000base-compat-0.11.1/src/Foreign/Marshal/Array/Compat/Repl.hs0000644000000000000000000000047407346545000021471 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.11.1/src/Foreign/Marshal/0000755000000000000000000000000007346545000015725 5ustar0000000000000000base-compat-0.11.1/src/Foreign/Marshal/Compat.hs0000644000000000000000000000056507346545000017512 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.11.1/src/Foreign/Marshal/Compat/0000755000000000000000000000000007346545000017150 5ustar0000000000000000base-compat-0.11.1/src/Foreign/Marshal/Compat/Repl.hs0000644000000000000000000000044407346545000020410 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.11.1/src/Foreign/Marshal/Safe/0000755000000000000000000000000007346545000016603 5ustar0000000000000000base-compat-0.11.1/src/Foreign/Marshal/Safe/Compat.hs0000644000000000000000000000105507346545000020363 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.11.1/src/Foreign/Marshal/Safe/Compat/0000755000000000000000000000000007346545000020026 5ustar0000000000000000base-compat-0.11.1/src/Foreign/Marshal/Safe/Compat/Repl.hs0000644000000000000000000000047007346545000021265 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.11.1/src/Foreign/Marshal/Unsafe/0000755000000000000000000000000007346545000017146 5ustar0000000000000000base-compat-0.11.1/src/Foreign/Marshal/Unsafe/Compat.hs0000644000000000000000000000040707346545000020726 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.11.1/src/Foreign/Marshal/Unsafe/Compat/0000755000000000000000000000000007346545000020371 5ustar0000000000000000base-compat-0.11.1/src/Foreign/Marshal/Unsafe/Compat/Repl.hs0000644000000000000000000000050007346545000021622 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.11.1/src/Foreign/Marshal/Utils/0000755000000000000000000000000007346545000017025 5ustar0000000000000000base-compat-0.11.1/src/Foreign/Marshal/Utils/Compat.hs0000644000000000000000000000117407346545000020607 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.11.1/src/Foreign/Marshal/Utils/Compat/0000755000000000000000000000000007346545000020250 5ustar0000000000000000base-compat-0.11.1/src/Foreign/Marshal/Utils/Compat/Repl.hs0000644000000000000000000000047407346545000021513 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.11.1/src/Numeric/0000755000000000000000000000000007346545000014347 5ustar0000000000000000base-compat-0.11.1/src/Numeric/Compat.hs0000644000000000000000000001117207346545000016130 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.11.1/src/Numeric/Compat/0000755000000000000000000000000007346545000015572 5ustar0000000000000000base-compat-0.11.1/src/Numeric/Compat/Repl.hs0000644000000000000000000000040407346545000017026 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.11.1/src/Numeric/Natural/0000755000000000000000000000000007346545000015755 5ustar0000000000000000base-compat-0.11.1/src/Numeric/Natural/Compat.hs0000644000000000000000000000030407346545000017531 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.11.1/src/Numeric/Natural/Compat/0000755000000000000000000000000007346545000017200 5ustar0000000000000000base-compat-0.11.1/src/Numeric/Natural/Compat/Repl.hs0000644000000000000000000000044407346545000020440 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.11.1/src/Prelude/0000755000000000000000000000000007346545000014345 5ustar0000000000000000base-compat-0.11.1/src/Prelude/Compat.hs0000644000000000000000000001041507346545000016125 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 #if MIN_VERSION_base(4,9,0) , MonadFail #endif , 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 hiding ( # if !(MIN_VERSION_base(4,13,0)) fail # if MIN_VERSION_base(4,10,0) && !(MIN_VERSION_base(4,12,0)) , ($!) # endif # 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,9,0) && !(MIN_VERSION_base(4,13,0)) import Control.Monad.Fail as Base (MonadFail(fail)) #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.11.1/src/Prelude/Compat/0000755000000000000000000000000007346545000015570 5ustar0000000000000000base-compat-0.11.1/src/Prelude/Compat/Repl.hs0000644000000000000000000000040407346545000017024 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.11.1/src/System/Environment/0000755000000000000000000000000007346545000016535 5ustar0000000000000000base-compat-0.11.1/src/System/Environment/Compat.hs0000644000000000000000000001015007346545000020311 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.11.1/src/System/Environment/Compat/0000755000000000000000000000000007346545000017760 5ustar0000000000000000base-compat-0.11.1/src/System/Environment/Compat/Repl.hs0000644000000000000000000000046007346545000021216 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.11.1/src/System/Exit/0000755000000000000000000000000007346545000015142 5ustar0000000000000000base-compat-0.11.1/src/System/Exit/Compat.hs0000644000000000000000000000060707346545000016724 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.11.1/src/System/Exit/Compat/0000755000000000000000000000000007346545000016365 5ustar0000000000000000base-compat-0.11.1/src/System/Exit/Compat/Repl.hs0000644000000000000000000000042407346545000017623 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.11.1/src/System/IO/Error/0000755000000000000000000000000007346545000015631 5ustar0000000000000000base-compat-0.11.1/src/System/IO/Error/Compat.hs0000644000000000000000000000221407346545000017407 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude #-} module System.IO.Error.Compat ( module Base , isResourceVanishedError , resourceVanishedErrorType , isResourceVanishedErrorType ) where import System.IO.Error as Base #if !(MIN_VERSION_base(4,14,0)) import GHC.IO.Exception (IOErrorType(..)) import Prelude.Compat -- | An error indicating that the operation failed because the -- resource vanished. See 'resourceVanishedErrorType'. -- -- /Since 4.14.0.0/ isResourceVanishedError :: IOError -> Bool isResourceVanishedError = isResourceVanishedErrorType . ioeGetErrorType -- | I\/O error where the operation failed because the resource vanished. -- This happens when, for example, attempting to write to a closed -- socket or attempting to write to a named pipe that was deleted. -- -- /Since 4.14.0.0/ resourceVanishedErrorType :: IOErrorType resourceVanishedErrorType = ResourceVanished -- | I\/O error where the operation failed because the resource vanished. -- See 'resourceVanishedErrorType'. -- -- /Since 4.14.0.0/ isResourceVanishedErrorType :: IOErrorType -> Bool isResourceVanishedErrorType ResourceVanished = True isResourceVanishedErrorType _ = False #endif base-compat-0.11.1/src/System/IO/Error/Compat/0000755000000000000000000000000007346545000017054 5ustar0000000000000000base-compat-0.11.1/src/System/IO/Error/Compat/Repl.hs0000644000000000000000000000044407346545000020314 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "System.IO.Error.Compat" -- from a globally unique namespace. module System.IO.Error.Compat.Repl ( module System.IO.Error.Compat ) where import "this" System.IO.Error.Compat base-compat-0.11.1/src/System/IO/Unsafe/0000755000000000000000000000000007346545000015761 5ustar0000000000000000base-compat-0.11.1/src/System/IO/Unsafe/Compat.hs0000644000000000000000000000155407346545000017545 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.11.1/src/System/IO/Unsafe/Compat/0000755000000000000000000000000007346545000017204 5ustar0000000000000000base-compat-0.11.1/src/System/IO/Unsafe/Compat/Repl.hs0000644000000000000000000000045007346545000020441 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.11.1/src/Text/Read/0000755000000000000000000000000007346545000014544 5ustar0000000000000000base-compat-0.11.1/src/Text/Read/Compat.hs0000644000000000000000000000245507346545000016331 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.11.1/src/Text/Read/Compat/0000755000000000000000000000000007346545000015767 5ustar0000000000000000base-compat-0.11.1/src/Text/Read/Compat/Repl.hs0000644000000000000000000000041407346545000017224 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.11.1/src/Type/Reflection/0000755000000000000000000000000007346545000015760 5ustar0000000000000000base-compat-0.11.1/src/Type/Reflection/Compat.hs0000644000000000000000000000202607346545000017537 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.11.1/src/Type/Reflection/Compat/0000755000000000000000000000000007346545000017203 5ustar0000000000000000base-compat-0.11.1/src/Type/Reflection/Compat/Repl.hs0000644000000000000000000000044407346545000020443 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