base-compat-0.13.1/0000755000000000000000000000000007346545000012160 5ustar0000000000000000base-compat-0.13.1/CHANGES.markdown0000644000000000000000000003137607346545000015006 0ustar0000000000000000## Changes in 0.13.1 [2023.10.11] - Sync with `base-4.19`/GHC 9.8 - Backport `unzip` to `Data.Functor.Compat` - Backport `(!?)` and `unsnoc` to `Data.List.Compat` - Backport `getSolo` to `Data.Tuple.Compat` when building against `ghc-prim-0.8.0` (GHC 9.2) or later. To backport `getSolo` to older versions of GHC, import `Data.Tuple.Compat` from `base-compat-batteries` instead. - Backport `decT` and `hdecT` to `Data.Typeable.Compat` - Backport `decTypeRep` to `Type.Reflection.Compat` ## Changes in 0.13.0 [2023.03.10] - Sync with `base-4.18`/GHC 9.6 - Backport `liftA2` being re-exported from `Prelude.Compat`. - `Data.Tuple.Compat`'s `Solo` API now matches what is present in `Data.Tuple` in `base-4.18`. In particular, we now re-export both the `MkSolo` and `Solo` data constructors when building with `ghc-prim-0.10.0` or later, with `MkSolo` being preferred over `Solo`. If you want to backport `MkSolo` to earlier versions of GHC, import `Data.Tuple.Compat` from `base-compat-batteries` instead. - Backport `traceWith`, `traceShowWith`, and `traceEventWith` to `Debug.Trace`. Note that `traceEventWith` is only provided when building with `base-4.5` or later, as that is the first version of `base` to provide the `traceEvent` primitive on which `traceEventWith` is defined. - Backport `inits1` and `tails1` to `Data.List.NonEmpty.Compat`. - Backport `minusNaturalMaybe` to `Numeric.Natural.Compat`. - Backport `applyWhen` to `Data.Function.Compat`. - Backport `mapAccumM` and `forAccumM` to `Data.Traversable.Compat`. - Backport `heqT` to `Data.Typeable.Compat`. Note that `heqT` is only defined when building with `base-4.10` or later, as that is the first version of `base` to provide the primitives needed to define `heqT`. - Introduce `Data.Foldable1.Compat` and `Data.Bifoldable1.Compat` modules, which correspond to changes made in `base-4.18.0.0`. You may consider using `base-compat-batteries` instead if you want increase the range of `base` versions that are supported. ## Changes in 0.12.3 [2023.07.12] - This coincides with the `base-compat-batteries-0.12.3` release. Refer to the [`base-compat-batteries` changelog](https://github.com/haskell-compat/base-compat/blob/master/base-compat-batteries/CHANGES.markdown#changes-in-0123-20230712) for more details. ## Changes in 0.12.2 [2022.08.11] - Sync with `base-4.17`/GHC 9.4 - Backport `(.^.)`, `(.>>.)`, `(.<<.)`, `(!>>.)`, `(!<<.)`, `oneBits` to `Data.Bits.Compat` - Backport `pattern TypeRep` to `Type.Reflection.Compat` ## Changes in 0.12.1 [2021.10.30] - Backport `Solo` to `Data.Tuple.Compat` when building with `ghc-prim-0.7.0` or later ## Changes in 0.12.0 [2021.08.29] - Sync with `base-4.16`/GHC 9.2 - `Data.Semigroup.Compat{.Repl}` no longer re-exports the `Option` data type or the `option` function, as both have been removed in `base-4.16`. - Backport `readBin` and `showBin` to `Numeric.Compat` - Backport `readBinP` to `Text.Read.Lex.Compat` ## Changes in 0.11.2 [2020.09.30] - Sync with `base-4.15`/GHC 9.0 - Backport `singleton` to `Data.List.Compat` and `Data.List.NonEmpty.Compat` - Backport `hGetContents'`, `getContents'`, and `readFile'` added to `System.IO.Compat` ## 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.13.1/LICENSE0000644000000000000000000000214007346545000013162 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.13.1/README.markdown0000644000000000000000000004153107346545000014665 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`, `popCountDefault`, `(.^.)`, `(.>>.)`, `(.<<.)`, `(!>>.)`, and `(!<<.)` to `Data.Bits.Compat` * Added `toIntegralSized` and `oneBits` to `Data.Bits.Compat` (if using `base-4.7` or later) * 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` * `(&)` and `applyWhen` functions 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`, `traceShowM`, `traceWith`, `traceShowWith`, and `traceEventWith` 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`, `showGFloatAlt`, `readBin`, and `showBin` to `Numeric.Compat` * `lookupEnv`, `setEnv` and `unsetEnv` to `System.Environment.Compat` * `unsafeFixIO` and `unsafeDupablePerformIO` to `System.IO.Unsafe.IO` * `RuntimeRep`-polymorphic `($!)` to `Prelude.Compat` * `liftA2` is re-exported from `Prelude.Compat` * `RuntimeRep`-polymorphic `throw` to `Control.Exception.Compat` * `isResourceVanishedError`, `resourceVanishedErrorType`, and `isResourceVanishedErrorType` to `System.IO.Error.Compat` * `singleton` to `Data.List.Compat` and `Data.List.NonEmpty.Compat` * `inits1` and `tails1` to `Data.List.NonEmpty.Compat` * `hGetContents'`, `getContents'`, and `readFile'` to `System.IO.Compat` * `readBinP` to `Text.Read.Lex.Compat` * `withTypeable` and `pattern TypeRep` to `Type.Reflection.Compat` * `minusNaturalMaybe` to `Numeric.Natural.Compat` * `mapAccumM` and `forAccumM` to `Data.Traversable.Compat` * `heqT` to `Data.Typeable.Compat` * `unzip` to `Data.Functor.Compat` * `(!?)` and `unsnoc` to `Data.List.Compat` * `getSolo` to `Data.Tuple.Compat` * `decT` and `hdecT` to `Data.Typeable.Compat` * `decTypeRep` to `Type.Reflection.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: * [`bifunctor-classes-compat`](http://hackage.haskell.org/package/bifunctor-classes-compat) 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` * [`foldable1-classes-compat`](https://hackage.haskell.org/package/foldable1-classes-compat) for the [`Foldable1`](https://hackage.haskell.org/package/foldable1-classes-compat-0.1/docs/Data-Foldable1.html#t:Foldable1) and [`Bifoldable1`](https://hackage.haskell.org/package/foldable1-classes-compat-0.1/docs/Data-Bifoldable1.html#t:Bifoldable1) type classes, introduced in `base-4.18.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` * [`OneTuple`](http://hackage.haskell.org/package/OneTuple) for the [`Solo`](https://hackage.haskell.org/package/base-4.16.0.0/docs/Data-Tuple.html#t:Solo) data type, introduced in `ghc-prim-0.7.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` ## Version policy This package follows the [Haskell Package Versioning Policy](https://pvp.haskell.org/). As such, if a new `base-compat` release only adds new exports, then as a general rule, we will release it with a minor version bump. Moreover, since `base-compat` does not backport data type or class definitions (see the "What is not covered" section above), `base-compat` usually has fewer major version bumps than `base` itself. An exception to the general rule about adding new exports is the `Prelude.Compat` module. If a new `base-compat` release adds any new exports, then it will _always_ be accompanied by a major version bump, even if there are no other API changes. This is because of the special nature of `Prelude.Compat`, which is designed to be imported unqualified. Pre-emptively bumping the major version number is meant to signal to downstream libraries that they should check to see if the new `Prelude.Compat` additions will clash with identifiers of the same names in their code. ## Supported versions of GHC/`base` * `ghc-9.8.*` / `base-4.19.*` * `ghc-9.6.*` / `base-4.18.*` * `ghc-9.4.*` / `base-4.17.*` * `ghc-9.2.*` / `base-4.16.*` * `ghc-9.0.*` / `base-4.15.*` * `ghc-8.10.*` / `base-4.14.*` * `ghc-8.8.*` / `base-4.13.*` * `ghc-8.6.*` / `base-4.12.*` * `ghc-8.4.*` / `base-4.11.*` * `ghc-8.2.*` / `base-4.10.*` * `ghc-8.0.*` / `base-4.9.*` * `ghc-7.10.*` / `base-4.8.*` * `ghc-7.8.*` / `base-4.7.*` * `ghc-7.6.*` / `base-4.6.*` * `ghc-7.4.*` / `base-4.5.*` * `ghc-7.2.*` / `base-4.4.*` * `ghc-7.0.*` / `base-4.3.*` We also make an attempt to keep `base-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.13.1/Setup.lhs0000644000000000000000000000011407346545000013764 0ustar0000000000000000#!/usr/bin/env runhaskell > import Distribution.Simple > main = defaultMain base-compat-0.13.1/base-compat.cabal0000644000000000000000000001713507346545000015346 0ustar0000000000000000name: base-compat version: 0.13.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.10 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. extra-source-files: CHANGES.markdown, README.markdown tested-with: GHC == 7.0.4 , GHC == 7.2.2 , GHC == 7.4.2 , GHC == 7.6.3 , GHC == 7.8.4 , GHC == 7.10.3 , GHC == 8.0.2 , GHC == 8.2.2 , GHC == 8.4.4 , GHC == 8.6.5 , GHC == 8.8.4 , GHC == 8.10.7 , GHC == 9.0.2 , GHC == 9.2.7 , GHC == 9.4.5 , GHC == 9.6.2 , GHC == 9.8.1 source-repository head type: git location: https://github.com/haskell-compat/base-compat subdir: base-compat library ghc-options: -Wall default-language: Haskell2010 build-depends: base >= 4.3 && < 5, ghc-prim 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.Bifoldable1.Compat Data.Bifunctor.Compat Data.Bitraversable.Compat Data.Bits.Compat Data.Bool.Compat Data.Complex.Compat Data.Either.Compat Data.Foldable.Compat Data.Foldable1.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.Traversable.Compat Data.Tuple.Compat Data.Typeable.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.Compat System.IO.Error.Compat System.IO.Unsafe.Compat Text.Read.Compat Text.Read.Lex.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.Bifoldable1.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.Foldable1.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.Traversable.Compat.Repl Data.Tuple.Compat.Repl Data.Typeable.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.Compat.Repl System.IO.Error.Compat.Repl System.IO.Unsafe.Compat.Repl Text.Read.Compat.Repl Text.Read.Lex.Compat.Repl Type.Reflection.Compat.Repl base-compat-0.13.1/src/Control/Concurrent/0000755000000000000000000000000007346545000016511 5ustar0000000000000000base-compat-0.13.1/src/Control/Concurrent/Compat.hs0000644000000000000000000000241707346545000020274 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.13.1/src/Control/Concurrent/Compat/0000755000000000000000000000000007346545000017734 5ustar0000000000000000base-compat-0.13.1/src/Control/Concurrent/Compat/Repl.hs0000644000000000000000000000046007346545000021172 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.13.1/src/Control/Concurrent/MVar/0000755000000000000000000000000007346545000017356 5ustar0000000000000000base-compat-0.13.1/src/Control/Concurrent/MVar/Compat.hs0000644000000000000000000000122707346545000021137 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.13.1/src/Control/Concurrent/MVar/Compat/0000755000000000000000000000000007346545000020601 5ustar0000000000000000base-compat-0.13.1/src/Control/Concurrent/MVar/Compat/Repl.hs0000644000000000000000000000050407346545000022036 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.13.1/src/Control/Exception/0000755000000000000000000000000007346545000016325 5ustar0000000000000000base-compat-0.13.1/src/Control/Exception/Compat.hs0000644000000000000000000000144507346545000020110 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude #-} #if __GLASGOW_HASKELL__ >= 702 {-# LANGUAGE Trustworthy #-} #endif #if MIN_VERSION_base(4,10,0) {-# LANGUAGE DataKinds #-} {-# LANGUAGE MagicHash #-} {-# LANGUAGE PolyKinds #-} {-# LANGUAGE RankNTypes #-} # if __GLASGOW_HASKELL__ < 806 {-# LANGUAGE TypeInType #-} # endif #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.13.1/src/Control/Exception/Compat/0000755000000000000000000000000007346545000017550 5ustar0000000000000000base-compat-0.13.1/src/Control/Exception/Compat/Repl.hs0000644000000000000000000000045407346545000021011 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.13.1/src/Control/Monad/0000755000000000000000000000000007346545000015425 5ustar0000000000000000base-compat-0.13.1/src/Control/Monad/Compat.hs0000644000000000000000000001242607346545000017211 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.13.1/src/Control/Monad/Compat/0000755000000000000000000000000007346545000016650 5ustar0000000000000000base-compat-0.13.1/src/Control/Monad/Compat/Repl.hs0000644000000000000000000000043407346545000020107 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.13.1/src/Control/Monad/Fail/0000755000000000000000000000000007346545000016300 5ustar0000000000000000base-compat-0.13.1/src/Control/Monad/Fail/Compat.hs0000644000000000000000000000031207346545000020053 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.13.1/src/Control/Monad/Fail/Compat/0000755000000000000000000000000007346545000017523 5ustar0000000000000000base-compat-0.13.1/src/Control/Monad/Fail/Compat/Repl.hs0000644000000000000000000000046007346545000020761 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.13.1/src/Control/Monad/IO/Class/0000755000000000000000000000000007346545000017001 5ustar0000000000000000base-compat-0.13.1/src/Control/Monad/IO/Class/Compat.hs0000644000000000000000000000032207346545000020555 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.13.1/src/Control/Monad/IO/Class/Compat/0000755000000000000000000000000007346545000020224 5ustar0000000000000000base-compat-0.13.1/src/Control/Monad/IO/Class/Compat/Repl.hs0000644000000000000000000000050007346545000021455 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.13.1/src/Control/Monad/ST/Lazy/Unsafe/0000755000000000000000000000000007346545000020113 5ustar0000000000000000base-compat-0.13.1/src/Control/Monad/ST/Lazy/Unsafe/Compat.hs0000644000000000000000000000051307346545000021671 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.13.1/src/Control/Monad/ST/Lazy/Unsafe/Compat/0000755000000000000000000000000007346545000021336 5ustar0000000000000000base-compat-0.13.1/src/Control/Monad/ST/Lazy/Unsafe/Compat/Repl.hs0000644000000000000000000000053007346545000022572 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.13.1/src/Control/Monad/ST/Unsafe/0000755000000000000000000000000007346545000017174 5ustar0000000000000000base-compat-0.13.1/src/Control/Monad/ST/Unsafe/Compat.hs0000644000000000000000000000054707346545000020761 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.13.1/src/Control/Monad/ST/Unsafe/Compat/0000755000000000000000000000000007346545000020417 5ustar0000000000000000base-compat-0.13.1/src/Control/Monad/ST/Unsafe/Compat/Repl.hs0000644000000000000000000000050407346545000021654 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.13.1/src/Data/Bifoldable/0000755000000000000000000000000007346545000015643 5ustar0000000000000000base-compat-0.13.1/src/Data/Bifoldable/Compat.hs0000644000000000000000000000030607346545000017421 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.13.1/src/Data/Bifoldable/Compat/0000755000000000000000000000000007346545000017066 5ustar0000000000000000base-compat-0.13.1/src/Data/Bifoldable/Compat/Repl.hs0000644000000000000000000000044407346545000020326 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.13.1/src/Data/Bifoldable1/0000755000000000000000000000000007346545000015724 5ustar0000000000000000base-compat-0.13.1/src/Data/Bifoldable1/Compat.hs0000644000000000000000000000031007346545000017475 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude #-} module Data.Bifoldable1.Compat ( #if MIN_VERSION_base(4,18,0) module Base #endif ) where #if MIN_VERSION_base(4,18,0) import Data.Bifoldable1 as Base #endif base-compat-0.13.1/src/Data/Bifoldable1/Compat/0000755000000000000000000000000007346545000017147 5ustar0000000000000000base-compat-0.13.1/src/Data/Bifoldable1/Compat/Repl.hs0000644000000000000000000000045007346545000020404 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Data.Bifoldable1.Compat" -- from a globally unique namespace. module Data.Bifoldable1.Compat.Repl ( module Data.Bifoldable1.Compat ) where import "this" Data.Bifoldable1.Compat base-compat-0.13.1/src/Data/Bifunctor/0000755000000000000000000000000007346545000015553 5ustar0000000000000000base-compat-0.13.1/src/Data/Bifunctor/Compat.hs0000644000000000000000000000030207346545000017325 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.13.1/src/Data/Bifunctor/Compat/0000755000000000000000000000000007346545000016776 5ustar0000000000000000base-compat-0.13.1/src/Data/Bifunctor/Compat/Repl.hs0000644000000000000000000000044007346545000020232 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.13.1/src/Data/Bitraversable/0000755000000000000000000000000007346545000016405 5ustar0000000000000000base-compat-0.13.1/src/Data/Bitraversable/Compat.hs0000644000000000000000000000031407346545000020162 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.13.1/src/Data/Bitraversable/Compat/0000755000000000000000000000000007346545000017630 5ustar0000000000000000base-compat-0.13.1/src/Data/Bitraversable/Compat/Repl.hs0000644000000000000000000000046007346545000021066 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.13.1/src/Data/Bits/0000755000000000000000000000000007346545000014521 5ustar0000000000000000base-compat-0.13.1/src/Data/Bits/Compat.hs0000644000000000000000000001210607346545000016300 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude #-} {-# LANGUAGE BangPatterns, PatternGuards #-} module Data.Bits.Compat ( module Base , bitDefault , testBitDefault , popCountDefault , (.^.) , (.>>.) , (.<<.) #if MIN_VERSION_base(4,5,0) , (!>>.) , (!<<.) #endif #if MIN_VERSION_base(4,7,0) , toIntegralSized , oneBits #endif ) where import Data.Bits as Base #if !(MIN_VERSION_base(4,17,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,17,0)) -- | Infix version of 'xor'. -- -- /Since: 4.17/ (.^.) :: (Bits a) => a -> a -> a (.^.) = xor infixl 6 .^. -- | Infix version of 'shiftR'. -- -- /Since: 4.17/ (.>>.) :: (Bits a) => a -> Int -> a (.>>.) = shiftR infixl 8 .>>. -- | Infix version of 'shiftL'. -- -- /Since: 4.17/ (.<<.) :: (Bits a) => a -> Int -> a (.<<.) = shiftL infixl 8 .<<. # if MIN_VERSION_base(4,5,0) -- | Infix version of 'unsafeShiftR'. -- -- /Since: 4.17/ (!>>.) :: (Bits a) => a -> Int -> a (!>>.) = unsafeShiftR infixl 8 !>>. -- | Infix version of 'unsafeShiftL'. -- -- /Since: 4.17/ (!<<.) :: (Bits a) => a -> Int -> a (!<<.) = unsafeShiftL infixl 8 !<<. # endif #endif #if MIN_VERSION_base(4,7,0) # if !(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 # if !(MIN_VERSION_base(4,16,0)) -- | A more concise version of @complement zeroBits@. -- -- >>> complement (zeroBits :: Word) == (oneBits :: Word) -- True -- -- >>> complement (oneBits :: Word) == (zeroBits :: Word) -- True -- -- = Note -- -- The constraint on 'oneBits' is arguably too strong. However, as some types -- (such as 'Natural') have undefined 'complement', this is the only safe -- choice. -- -- /Since: 4.16/ oneBits :: (FiniteBits a) => a oneBits = complement zeroBits {-# INLINE oneBits #-} # endif #endif base-compat-0.13.1/src/Data/Bits/Compat/0000755000000000000000000000000007346545000015744 5ustar0000000000000000base-compat-0.13.1/src/Data/Bits/Compat/Repl.hs0000644000000000000000000000041407346545000017201 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.13.1/src/Data/Bool/0000755000000000000000000000000007346545000014513 5ustar0000000000000000base-compat-0.13.1/src/Data/Bool/Compat.hs0000644000000000000000000000060307346545000016271 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.13.1/src/Data/Bool/Compat/0000755000000000000000000000000007346545000015736 5ustar0000000000000000base-compat-0.13.1/src/Data/Bool/Compat/Repl.hs0000644000000000000000000000041407346545000017173 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.13.1/src/Data/Complex/0000755000000000000000000000000007346545000015227 5ustar0000000000000000base-compat-0.13.1/src/Data/Complex/Compat.hs0000644000000000000000000000251507346545000017011 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.13.1/src/Data/Complex/Compat/0000755000000000000000000000000007346545000016452 5ustar0000000000000000base-compat-0.13.1/src/Data/Complex/Compat/Repl.hs0000644000000000000000000000043007346545000017705 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.13.1/src/Data/Either/0000755000000000000000000000000007346545000015040 5ustar0000000000000000base-compat-0.13.1/src/Data/Either/Compat.hs0000644000000000000000000000231307346545000016616 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.13.1/src/Data/Either/Compat/0000755000000000000000000000000007346545000016263 5ustar0000000000000000base-compat-0.13.1/src/Data/Either/Compat/Repl.hs0000644000000000000000000000042407346545000017521 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.13.1/src/Data/Foldable/0000755000000000000000000000000007346545000015330 5ustar0000000000000000base-compat-0.13.1/src/Data/Foldable/Compat.hs0000644000000000000000000000305407346545000017111 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.13.1/src/Data/Foldable/Compat/0000755000000000000000000000000007346545000016553 5ustar0000000000000000base-compat-0.13.1/src/Data/Foldable/Compat/Repl.hs0000644000000000000000000000043407346545000020012 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.13.1/src/Data/Foldable1/0000755000000000000000000000000007346545000015411 5ustar0000000000000000base-compat-0.13.1/src/Data/Foldable1/Compat.hs0000644000000000000000000000030407346545000017165 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude #-} module Data.Foldable1.Compat ( #if MIN_VERSION_base(4,18,0) module Base #endif ) where #if MIN_VERSION_base(4,18,0) import Data.Foldable1 as Base #endif base-compat-0.13.1/src/Data/Foldable1/Compat/0000755000000000000000000000000007346545000016634 5ustar0000000000000000base-compat-0.13.1/src/Data/Foldable1/Compat/Repl.hs0000644000000000000000000000044007346545000020070 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Data.Foldable1.Compat" -- from a globally unique namespace. module Data.Foldable1.Compat.Repl ( module Data.Foldable1.Compat ) where import "this" Data.Foldable1.Compat base-compat-0.13.1/src/Data/Function/0000755000000000000000000000000007346545000015405 5ustar0000000000000000base-compat-0.13.1/src/Data/Function/Compat.hs0000644000000000000000000000226707346545000017173 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude #-} module Data.Function.Compat ( module Base , (&) , applyWhen ) where import Data.Function as Base #if !(MIN_VERSION_base(4,18,0)) import Prelude.Compat #endif #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 #if !(MIN_VERSION_base(4,18,0)) -- | 'applyWhen' applies a function to a value if a condition is true, -- otherwise, it returns the value unchanged. -- -- It is equivalent to @'flip' ('Data.Bool.bool' 'id')@. -- -- Algebraic properties: -- -- * @applyWhen 'True' = 'id'@ -- -- * @applyWhen 'False' f = 'id'@ -- -- /Since: 4.18.0.0/ applyWhen :: Bool -> (a -> a) -> a -> a applyWhen True f x = f x applyWhen False _ x = x -- Proofs: -- -- flip bool id = \q f -> bool id f q -- = \f q -> case q of -- True -> f = \x -> f x -- False -> id = \x -> x ∎ -- -- applyWhen True = \f x -> f x -- = \f -> \x -> f x = \f -> f = id ∎ -- -- applyWhen False f = \x -> x = id ∎ #endif base-compat-0.13.1/src/Data/Function/Compat/0000755000000000000000000000000007346545000016630 5ustar0000000000000000base-compat-0.13.1/src/Data/Function/Compat/Repl.hs0000644000000000000000000000043407346545000020067 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.13.1/src/Data/Functor/0000755000000000000000000000000007346545000015240 5ustar0000000000000000base-compat-0.13.1/src/Data/Functor/Compat.hs0000644000000000000000000000213707346545000017022 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude #-} module Data.Functor.Compat ( module Base , Functor(..) , ($>) , void , (<&>) , unzip ) 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,19,0)) import Data.Tuple (fst, snd) #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 #if !(MIN_VERSION_base(4,19,0)) -- | Generalization of @Data.List.@'Data.List.unzip'. -- -- /Since: 4.19.0.0/ unzip :: Functor f => f (a, b) -> (f a, f b) unzip xs = (fst <$> xs, snd <$> xs) #endif base-compat-0.13.1/src/Data/Functor/Compat/0000755000000000000000000000000007346545000016463 5ustar0000000000000000base-compat-0.13.1/src/Data/Functor/Compat/Repl.hs0000644000000000000000000000043007346545000017716 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.13.1/src/Data/Functor/Compose/0000755000000000000000000000000007346545000016645 5ustar0000000000000000base-compat-0.13.1/src/Data/Functor/Compose/Compat.hs0000644000000000000000000000031607346545000020424 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.13.1/src/Data/Functor/Compose/Compat/0000755000000000000000000000000007346545000020070 5ustar0000000000000000base-compat-0.13.1/src/Data/Functor/Compose/Compat/Repl.hs0000644000000000000000000000047007346545000021327 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.13.1/src/Data/Functor/Const/0000755000000000000000000000000007346545000016326 5ustar0000000000000000base-compat-0.13.1/src/Data/Functor/Const/Compat.hs0000644000000000000000000000020307346545000020100 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude #-} module Data.Functor.Const.Compat (Const(..)) where import Control.Applicative (Const(..)) base-compat-0.13.1/src/Data/Functor/Const/Compat/0000755000000000000000000000000007346545000017551 5ustar0000000000000000base-compat-0.13.1/src/Data/Functor/Const/Compat/Repl.hs0000644000000000000000000000046007346545000021007 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.13.1/src/Data/Functor/Contravariant/0000755000000000000000000000000007346545000020053 5ustar0000000000000000base-compat-0.13.1/src/Data/Functor/Contravariant/Compat.hs0000644000000000000000000000033407346545000021632 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.13.1/src/Data/Functor/Contravariant/Compat/0000755000000000000000000000000007346545000021276 5ustar0000000000000000base-compat-0.13.1/src/Data/Functor/Contravariant/Compat/Repl.hs0000644000000000000000000000052007346545000022531 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.13.1/src/Data/Functor/Identity/0000755000000000000000000000000007346545000017031 5ustar0000000000000000base-compat-0.13.1/src/Data/Functor/Identity/Compat.hs0000644000000000000000000000032007346545000020603 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.13.1/src/Data/Functor/Identity/Compat/0000755000000000000000000000000007346545000020254 5ustar0000000000000000base-compat-0.13.1/src/Data/Functor/Identity/Compat/Repl.hs0000644000000000000000000000047407346545000021517 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.13.1/src/Data/Functor/Product/0000755000000000000000000000000007346545000016660 5ustar0000000000000000base-compat-0.13.1/src/Data/Functor/Product/Compat.hs0000644000000000000000000000031607346545000020437 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.13.1/src/Data/Functor/Product/Compat/0000755000000000000000000000000007346545000020103 5ustar0000000000000000base-compat-0.13.1/src/Data/Functor/Product/Compat/Repl.hs0000644000000000000000000000047007346545000021342 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.13.1/src/Data/Functor/Sum/0000755000000000000000000000000007346545000016004 5ustar0000000000000000base-compat-0.13.1/src/Data/Functor/Sum/Compat.hs0000644000000000000000000000030607346545000017562 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.13.1/src/Data/Functor/Sum/Compat/0000755000000000000000000000000007346545000017227 5ustar0000000000000000base-compat-0.13.1/src/Data/Functor/Sum/Compat/Repl.hs0000644000000000000000000000045007346545000020464 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.13.1/src/Data/IORef/0000755000000000000000000000000007346545000014564 5ustar0000000000000000base-compat-0.13.1/src/Data/IORef/Compat.hs0000644000000000000000000000203507346545000016343 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.13.1/src/Data/IORef/Compat/0000755000000000000000000000000007346545000016007 5ustar0000000000000000base-compat-0.13.1/src/Data/IORef/Compat/Repl.hs0000644000000000000000000000042007346545000017241 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.13.1/src/Data/List/0000755000000000000000000000000007346545000014533 5ustar0000000000000000base-compat-0.13.1/src/Data/List/Compat.hs0000644000000000000000000002035407346545000016316 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude #-} {-# LANGUAGE BangPatterns #-} #if __GLASGOW_HASKELL__ >= 702 {-# LANGUAGE Trustworthy #-} #endif module Data.List.Compat ( module Base #if !(MIN_VERSION_base(4,19,0)) , (!?) , unsnoc #endif #if !(MIN_VERSION_base(4,15,0)) , singleton #endif #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) #endif #if !(MIN_VERSION_base(4,19,0)) 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 #if !(MIN_VERSION_base(4,15,0)) -- | Produce singleton list. -- -- >>> singleton True -- [True] -- -- /Since: 4.14.0.0/ -- singleton :: a -> [a] singleton x = [x] #endif #if !(MIN_VERSION_base(4,19,0)) infixl 9 !? -- | List index (subscript) operator, starting from 0. Returns 'Nothing' -- if the index is out of bounds -- -- >>> ['a', 'b', 'c'] !? 0 -- Just 'a' -- >>> ['a', 'b', 'c'] !? 2 -- Just 'c' -- >>> ['a', 'b', 'c'] !? 3 -- Nothing -- >>> ['a', 'b', 'c'] !? (-1) -- Nothing -- -- This is the total variant of the partial '!!' operator. -- -- WARNING: This function takes linear time in the index. (!?) :: [a] -> Int -> Maybe a {-# INLINABLE (!?) #-} xs !? n | n < 0 = Nothing | otherwise = foldr (\x r k -> case k of 0 -> Just x _ -> r (k-1)) (const Nothing) xs n -- | \(\mathcal{O}(n)\). Decompose a list into 'init' and 'last'. -- -- * If the list is empty, returns 'Nothing'. -- * If the list is non-empty, returns @'Just' (xs, x)@, -- where @xs@ is the 'init'ial part of the list and @x@ is its 'last' element. -- -- /Since: 4.19.0.0/ -- -- >>> unsnoc [] -- Nothing -- >>> unsnoc [1] -- Just ([],1) -- >>> unsnoc [1, 2, 3] -- Just ([1,2],3) -- -- Laziness: -- -- >>> fst <$> unsnoc [undefined] -- Just [] -- >>> head . fst <$> unsnoc (1 : undefined) -- Just *** Exception: Prelude.undefined -- >>> head . fst <$> unsnoc (1 : 2 : undefined) -- Just 1 -- -- 'unsnoc' is dual to 'uncons': for a finite list @xs@ -- -- > unsnoc xs = (\(hd, tl) -> (reverse tl, hd)) <$> uncons (reverse xs) -- unsnoc :: [a] -> Maybe ([a], a) -- The lazy pattern ~(a, b) is important to be productive on infinite lists -- and not to be prone to stack overflows. -- Expressing the recursion via 'foldr' provides for list fusion. unsnoc = foldr (\x -> Just . maybe ([], x) (\(~(a, b)) -> (x : a, b))) Nothing {-# INLINABLE unsnoc #-} #endif base-compat-0.13.1/src/Data/List/Compat/0000755000000000000000000000000007346545000015756 5ustar0000000000000000base-compat-0.13.1/src/Data/List/Compat/Repl.hs0000644000000000000000000000041407346545000017213 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.13.1/src/Data/List/NonEmpty/0000755000000000000000000000000007346545000016304 5ustar0000000000000000base-compat-0.13.1/src/Data/List/NonEmpty/Compat.hs0000644000000000000000000000664607346545000020077 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 , singleton , (<|), cons , uncons , unfoldr , sort , reverse , inits , inits1 , tails , tails1 -- * 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 # if !(MIN_VERSION_base(4,18,0)) import qualified Prelude.Compat as Prelude import Prelude.Compat ((.)) import qualified Data.Foldable.Compat as Foldable import qualified Data.List.Compat as List # endif #endif #if MIN_VERSION_base(4,9,0) # if !(MIN_VERSION_base(4,15,0)) -- | Construct a 'NonEmpty' list from a single element. -- -- /Since: 4.15/ singleton :: a -> NonEmpty a singleton a = a :| [] # endif # if !(MIN_VERSION_base(4,18,0)) -- | The 'inits1' function takes a 'NonEmpty' stream @xs@ and returns all the -- 'NonEmpty' finite prefixes of @xs@, starting with the shortest. -- -- > inits1 (1 :| [2,3]) == (1 :| []) :| [1 :| [2], 1 :| [2,3]] -- > inits1 (1 :| []) == (1 :| []) :| [] -- -- /Since: 4.18/ inits1 :: NonEmpty a -> NonEmpty (NonEmpty a) inits1 = -- fromList is an unsafe function, but this usage should be safe, since: -- - `inits xs = [[], ..., init (init xs), init xs, xs]` -- - If `xs` is nonempty, it follows that `inits xs` contains at least one nonempty -- list, since `last (inits xs) = xs`. -- - The only empty element of `inits xs` is the first one (by the definition of `inits`) -- - Therefore, if we take all but the first element of `inits xs` i.e. -- `tail (inits xs)`, we have a nonempty list of nonempty lists fromList . Prelude.map fromList . List.tail . List.inits . Foldable.toList -- | The 'tails1' function takes a 'NonEmpty' stream @xs@ and returns all the -- non-empty suffixes of @xs@, starting with the longest. -- -- > tails1 (1 :| [2,3]) == (1 :| [2,3]) :| [2 :| [3], 3 :| []] -- > tails1 (1 :| []) == (1 :| []) :| [] -- -- /Since: 4.18/ tails1 :: NonEmpty a -> NonEmpty (NonEmpty a) tails1 = -- fromList is an unsafe function, but this usage should be safe, since: -- - `tails xs = [xs, tail xs, tail (tail xs), ..., []]` -- - If `xs` is nonempty, it follows that `tails xs` contains at least one nonempty -- list, since `head (tails xs) = xs`. -- - The only empty element of `tails xs` is the last one (by the definition of `tails`) -- - Therefore, if we take all but the last element of `tails xs` i.e. -- `init (tails xs)`, we have a nonempty list of nonempty lists fromList . Prelude.map fromList . List.init . List.tails . Foldable.toList # endif #endif base-compat-0.13.1/src/Data/List/NonEmpty/Compat/0000755000000000000000000000000007346545000017527 5ustar0000000000000000base-compat-0.13.1/src/Data/List/NonEmpty/Compat/Repl.hs0000644000000000000000000000046007346545000020765 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.13.1/src/Data/Monoid/0000755000000000000000000000000007346545000015045 5ustar0000000000000000base-compat-0.13.1/src/Data/Monoid/Compat.hs0000644000000000000000000000070307346545000016624 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.13.1/src/Data/Monoid/Compat/0000755000000000000000000000000007346545000016270 5ustar0000000000000000base-compat-0.13.1/src/Data/Monoid/Compat/Repl.hs0000644000000000000000000000042407346545000017526 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.13.1/src/Data/Proxy/0000755000000000000000000000000007346545000014741 5ustar0000000000000000base-compat-0.13.1/src/Data/Proxy/Compat.hs0000644000000000000000000000124607346545000016523 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.13.1/src/Data/Proxy/Compat/0000755000000000000000000000000007346545000016164 5ustar0000000000000000base-compat-0.13.1/src/Data/Proxy/Compat/Repl.hs0000644000000000000000000000042007346545000017416 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.13.1/src/Data/Ratio/0000755000000000000000000000000007346545000014676 5ustar0000000000000000base-compat-0.13.1/src/Data/Ratio/Compat.hs0000644000000000000000000000151307346545000016455 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.13.1/src/Data/Ratio/Compat/0000755000000000000000000000000007346545000016121 5ustar0000000000000000base-compat-0.13.1/src/Data/Ratio/Compat/Repl.hs0000644000000000000000000000042007346545000017353 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.13.1/src/Data/STRef/0000755000000000000000000000000007346545000014603 5ustar0000000000000000base-compat-0.13.1/src/Data/STRef/Compat.hs0000644000000000000000000000075407346545000016370 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.13.1/src/Data/STRef/Compat/0000755000000000000000000000000007346545000016026 5ustar0000000000000000base-compat-0.13.1/src/Data/STRef/Compat/Repl.hs0000644000000000000000000000042007346545000017260 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.13.1/src/Data/Semigroup/0000755000000000000000000000000007346545000015572 5ustar0000000000000000base-compat-0.13.1/src/Data/Semigroup/Compat.hs0000644000000000000000000000126407346545000017354 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(..) -- * 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.13.1/src/Data/Semigroup/Compat/0000755000000000000000000000000007346545000017015 5ustar0000000000000000base-compat-0.13.1/src/Data/Semigroup/Compat/Repl.hs0000644000000000000000000000044007346545000020251 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.13.1/src/Data/String/0000755000000000000000000000000007346545000015066 5ustar0000000000000000base-compat-0.13.1/src/Data/String/Compat.hs0000644000000000000000000000040207346545000016641 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.13.1/src/Data/String/Compat/0000755000000000000000000000000007346545000016311 5ustar0000000000000000base-compat-0.13.1/src/Data/String/Compat/Repl.hs0000644000000000000000000000042407346545000017547 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.13.1/src/Data/Traversable/0000755000000000000000000000000007346545000016072 5ustar0000000000000000base-compat-0.13.1/src/Data/Traversable/Compat.hs0000644000000000000000000000561207346545000017655 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude #-} #if __GLASGOW_HASKELL__ >= 702 {-# LANGUAGE Trustworthy #-} #endif #if !(MIN_VERSION_base(4,18,0)) {-# LANGUAGE ScopedTypeVariables #-} #endif module Data.Traversable.Compat ( module Base , mapAccumM , forAccumM ) where import Data.Traversable as Base #if !(MIN_VERSION_base(4,18,0)) import Prelude.Compat import Control.Monad.Compat (liftM) # if MIN_VERSION_base(4,8,0) import Data.Coerce (Coercible, coerce) # else import Unsafe.Coerce (unsafeCoerce) # endif #endif #if !(MIN_VERSION_base(4,18,0)) -- | A state transformer monad parameterized by the state and inner monad. -- The implementation is copied from the transformers package with the -- return tuple swapped. -- -- /Since: 4.18.0.0/ newtype StateT s m a = StateT { runStateT :: s -> m (s, a) } -- | /Since: 4.18.0.0/ instance Monad m => Functor (StateT s m) where fmap = liftM {-# INLINE fmap #-} -- | /Since: 4.18.0.0/ instance Monad m => Applicative (StateT s m) where pure a = StateT $ \ s -> return (s, a) {-# INLINE pure #-} StateT mf <*> StateT mx = StateT $ \ s -> do (s', f) <- mf s (s'', x) <- mx s' return (s'', f x) {-# INLINE (<*>) #-} m *> k = m >>= \_ -> k {-# INLINE (*>) #-} # if MIN_VERSION_base(4,8,0) (#.) :: Coercible b c => (b -> c) -> (a -> b) -> (a -> c) (#.) _f = coerce # else (#.) :: (b -> c) -> (a -> b) -> (a -> c) (#.) _f = unsafeCoerce # endif -- | /Since: 4.18.0.0/ instance (Monad m) => Monad (StateT s m) where m >>= k = StateT $ \ s -> do (s', a) <- runStateT m s runStateT (k a) s' {-# INLINE (>>=) #-} # if !(MIN_VERSION_base(4,11,0)) return = pure # endif -- | The `mapAccumM` function behaves like a combination of `mapM` and -- `mapAccumL` that traverses the structure while evaluating the actions -- and passing an accumulating parameter from left to right. -- It returns a final value of this accumulator together with the new structure. -- The accummulator is often used for caching the intermediate results of a computation. -- -- @since 4.18.0.0 -- -- ==== __Examples__ -- -- Basic usage: -- -- >>> let expensiveDouble a = putStrLn ("Doubling " <> show a) >> pure (2 * a) -- >>> :{ -- mapAccumM (\cache a -> case lookup a cache of -- Nothing -> expensiveDouble a >>= \double -> pure ((a, double):cache, double) -- Just double -> pure (cache, double) -- ) [] [1, 2, 3, 1, 2, 3] -- :} -- Doubling 1 -- Doubling 2 -- Doubling 3 -- ([(3,6),(2,4),(1,2)],[2,4,6,2,4,6]) -- mapAccumM :: forall m t s a b. (Monad m, Traversable t) => (s -> a -> m (s, b)) -> s -> t a -> m (s, t b) mapAccumM f s t = runStateT (mapM (StateT #. flip f) t) s -- | 'forAccumM' is 'mapAccumM' with the arguments rearranged. -- -- @since 4.18.0.0 forAccumM :: (Monad m, Traversable t) => s -> t a -> (s -> a -> m (s, b)) -> m (s, t b) {-# INLINE forAccumM #-} forAccumM s t f = mapAccumM f s t #endif base-compat-0.13.1/src/Data/Traversable/Compat/0000755000000000000000000000000007346545000017315 5ustar0000000000000000base-compat-0.13.1/src/Data/Traversable/Compat/Repl.hs0000644000000000000000000000045007346545000020552 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Data.Traversable.Compat" -- from a globally unique namespace. module Data.Traversable.Compat.Repl ( module Data.Traversable.Compat ) where import "this" Data.Traversable.Compat base-compat-0.13.1/src/Data/Tuple/0000755000000000000000000000000007346545000014711 5ustar0000000000000000base-compat-0.13.1/src/Data/Tuple/Compat.hs0000644000000000000000000000156107346545000016473 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude #-} #if __GLASGOW_HASKELL__ >= 702 {-# LANGUAGE Safe #-} #endif #if MIN_VERSION_ghc_prim(0,7,0) {-# LANGUAGE PatternSynonyms #-} #endif -- | Note that we only re-export @MkSolo@ when building with @ghc-prim-0.10.0@ -- (bundled with GHC 9.6) or later. If you want to backport @MkSolo@ to older -- versions of GHC, import @Data.Tuple.Compat@ from @base-compat-batteries@ -- instead. module Data.Tuple.Compat ( fst , snd , curry , uncurry , swap #if MIN_VERSION_ghc_prim(0,10,0) , Solo(MkSolo,Solo) #elif MIN_VERSION_ghc_prim(0,7,0) , Solo(Solo) #endif #if MIN_VERSION_ghc_prim(0,8,0) , getSolo #endif ) where import Data.Tuple #if !(MIN_VERSION_base(4,16,0)) && MIN_VERSION_ghc_prim(0,7,0) import GHC.Tuple (Solo(..)) #endif #if MIN_VERSION_ghc_prim(0,8,0) && !(MIN_VERSION_ghc_prim(0,11,0)) import GHC.Tuple (getSolo) #endif base-compat-0.13.1/src/Data/Tuple/Compat/0000755000000000000000000000000007346545000016134 5ustar0000000000000000base-compat-0.13.1/src/Data/Tuple/Compat/Repl.hs0000644000000000000000000000042007346545000017366 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Data.Tuple.Compat" -- from a globally unique namespace. module Data.Tuple.Compat.Repl ( module Data.Tuple.Compat ) where import "this" Data.Tuple.Compat base-compat-0.13.1/src/Data/Type/Coercion/0000755000000000000000000000000007346545000016302 5ustar0000000000000000base-compat-0.13.1/src/Data/Type/Coercion/Compat.hs0000644000000000000000000000106507346545000020063 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.13.1/src/Data/Type/Coercion/Compat/0000755000000000000000000000000007346545000017525 5ustar0000000000000000base-compat-0.13.1/src/Data/Type/Coercion/Compat/Repl.hs0000644000000000000000000000046007346545000020763 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.13.1/src/Data/Type/Equality/0000755000000000000000000000000007346545000016336 5ustar0000000000000000base-compat-0.13.1/src/Data/Type/Equality/Compat.hs0000644000000000000000000000045107346545000020115 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.13.1/src/Data/Type/Equality/Compat/0000755000000000000000000000000007346545000017561 5ustar0000000000000000base-compat-0.13.1/src/Data/Type/Equality/Compat/Repl.hs0000644000000000000000000000046007346545000021017 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.13.1/src/Data/Typeable/0000755000000000000000000000000007346545000015365 5ustar0000000000000000base-compat-0.13.1/src/Data/Typeable/Compat.hs0000644000000000000000000000275407346545000017154 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude #-} #if __GLASGOW_HASKELL__ >= 702 {-# LANGUAGE Trustworthy #-} #endif #if MIN_VERSION_base(4,10,0) && !(MIN_VERSION_base(4,19,0)) {-# LANGUAGE GADTs #-} {-# LANGUAGE PolyKinds #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE TypeApplications #-} {-# LANGUAGE TypeOperators #-} #endif module Data.Typeable.Compat ( module Base #if MIN_VERSION_base(4,10,0) , heqT , decT , hdecT #endif ) where import Data.Typeable as Base #if MIN_VERSION_base(4,10,0) && !(MIN_VERSION_base(4,19,0)) import Prelude.Compat import Data.Void (Void) import qualified Type.Reflection.Compat as TR #endif #if MIN_VERSION_base(4,10,0) # if !(MIN_VERSION_base(4,18,0)) -- | Extract a witness of heterogeneous equality of two types -- -- /Since: 4.18.0.0/ heqT :: forall a b. (Typeable a, Typeable b) => Maybe (a :~~: b) heqT = ta `TR.eqTypeRep` tb where ta = TR.typeRep :: TR.TypeRep a tb = TR.typeRep :: TR.TypeRep b # endif # if !(MIN_VERSION_base(4,19,0)) -- | Decide an equality of two types -- -- /Since: 4.19.0.0/ decT :: forall a b. (Typeable a, Typeable b) => Either (a :~: b -> Void) (a :~: b) decT = case hdecT @a @b of Right HRefl -> Right Refl Left p -> Left (\Refl -> p HRefl) -- | Decide heterogeneous equality of two types. -- -- /Since: 4.19.0.0/ hdecT :: forall a b. (Typeable a, Typeable b) => Either (a :~~: b -> Void) (a :~~: b) hdecT = ta `TR.decTypeRep` tb where ta = TR.typeRep :: TR.TypeRep a tb = TR.typeRep :: TR.TypeRep b # endif #endif base-compat-0.13.1/src/Data/Typeable/Compat/0000755000000000000000000000000007346545000016610 5ustar0000000000000000base-compat-0.13.1/src/Data/Typeable/Compat/Repl.hs0000644000000000000000000000043407346545000020047 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Data.Typeable.Compat" -- from a globally unique namespace. module Data.Typeable.Compat.Repl ( module Data.Typeable.Compat ) where import "this" Data.Typeable.Compat base-compat-0.13.1/src/Data/Version/0000755000000000000000000000000007346545000015245 5ustar0000000000000000base-compat-0.13.1/src/Data/Version/Compat.hs0000644000000000000000000000047107346545000017026 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.13.1/src/Data/Version/Compat/0000755000000000000000000000000007346545000016470 5ustar0000000000000000base-compat-0.13.1/src/Data/Version/Compat/Repl.hs0000644000000000000000000000043007346545000017723 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.13.1/src/Data/Void/0000755000000000000000000000000007346545000014521 5ustar0000000000000000base-compat-0.13.1/src/Data/Void/Compat.hs0000644000000000000000000000027007346545000016277 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.13.1/src/Data/Void/Compat/0000755000000000000000000000000007346545000015744 5ustar0000000000000000base-compat-0.13.1/src/Data/Void/Compat/Repl.hs0000644000000000000000000000041407346545000017201 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.13.1/src/Data/Word/0000755000000000000000000000000007346545000014533 5ustar0000000000000000base-compat-0.13.1/src/Data/Word/Compat.hs0000644000000000000000000000226707346545000016321 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.13.1/src/Data/Word/Compat/0000755000000000000000000000000007346545000015756 5ustar0000000000000000base-compat-0.13.1/src/Data/Word/Compat/Repl.hs0000644000000000000000000000041407346545000017213 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.13.1/src/Debug/Trace/0000755000000000000000000000000007346545000015033 5ustar0000000000000000base-compat-0.13.1/src/Debug/Trace/Compat.hs0000644000000000000000000000502307346545000016612 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude #-} module Debug.Trace.Compat ( module Base , traceId , traceShowId , traceM , traceShowM , traceWith , traceShowWith #if MIN_VERSION_base(4,5,0) , traceEventWith #endif ) 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,18,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 #if !(MIN_VERSION_base(4,18,0)) {-| Like 'trace', but outputs the result of calling a function on the argument. >>> traceWith fst ("hello","world") hello ("hello","world") /Since: 4.18.0.0/ -} traceWith :: (a -> String) -> a -> a traceWith f a = trace (f a) a {-| Like 'traceWith', but uses 'show' on the result of the function to convert it to a 'String'. >>> traceShowWith length [1,2,3] 3 [1,2,3] /Since: 4.18.0.0/ -} traceShowWith :: Show b => (a -> b) -> a -> a traceShowWith f = traceWith (show . f) # if MIN_VERSION_base(4,5,0) -- | Like 'traceEvent', but emits the result of calling a function on its -- argument. -- -- /Since: 4.18.0.0/ traceEventWith :: (a -> String) -> a -> a traceEventWith f a = traceEvent (f a) a # endif #endif base-compat-0.13.1/src/Debug/Trace/Compat/0000755000000000000000000000000007346545000016256 5ustar0000000000000000base-compat-0.13.1/src/Debug/Trace/Compat/Repl.hs0000644000000000000000000000042407346545000017514 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.13.1/src/Foreign/0000755000000000000000000000000007346545000014340 5ustar0000000000000000base-compat-0.13.1/src/Foreign/Compat.hs0000644000000000000000000000035307346545000016120 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.13.1/src/Foreign/Compat/0000755000000000000000000000000007346545000015563 5ustar0000000000000000base-compat-0.13.1/src/Foreign/Compat/Repl.hs0000644000000000000000000000040407346545000017017 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.13.1/src/Foreign/ForeignPtr/0000755000000000000000000000000007346545000016417 5ustar0000000000000000base-compat-0.13.1/src/Foreign/ForeignPtr/Compat.hs0000644000000000000000000000177607346545000020211 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.13.1/src/Foreign/ForeignPtr/Compat/0000755000000000000000000000000007346545000017642 5ustar0000000000000000base-compat-0.13.1/src/Foreign/ForeignPtr/Compat/Repl.hs0000644000000000000000000000046007346545000021100 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.13.1/src/Foreign/ForeignPtr/Safe/0000755000000000000000000000000007346545000017275 5ustar0000000000000000base-compat-0.13.1/src/Foreign/ForeignPtr/Safe/Compat.hs0000644000000000000000000000164407346545000021061 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.13.1/src/Foreign/ForeignPtr/Safe/Compat/0000755000000000000000000000000007346545000020520 5ustar0000000000000000base-compat-0.13.1/src/Foreign/ForeignPtr/Safe/Compat/Repl.hs0000644000000000000000000000050407346545000021755 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.13.1/src/Foreign/ForeignPtr/Unsafe/0000755000000000000000000000000007346545000017640 5ustar0000000000000000base-compat-0.13.1/src/Foreign/ForeignPtr/Unsafe/Compat.hs0000644000000000000000000000045307346545000021421 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.13.1/src/Foreign/ForeignPtr/Unsafe/Compat/0000755000000000000000000000000007346545000021063 5ustar0000000000000000base-compat-0.13.1/src/Foreign/ForeignPtr/Unsafe/Compat/Repl.hs0000644000000000000000000000051407346545000022321 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.13.1/src/Foreign/Marshal/Alloc/0000755000000000000000000000000007346545000016761 5ustar0000000000000000base-compat-0.13.1/src/Foreign/Marshal/Alloc/Compat.hs0000644000000000000000000000237407346545000020546 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.13.1/src/Foreign/Marshal/Alloc/Compat/0000755000000000000000000000000007346545000020204 5ustar0000000000000000base-compat-0.13.1/src/Foreign/Marshal/Alloc/Compat/Repl.hs0000644000000000000000000000047407346545000021447 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.13.1/src/Foreign/Marshal/Array/0000755000000000000000000000000007346545000017005 5ustar0000000000000000base-compat-0.13.1/src/Foreign/Marshal/Array/Compat.hs0000644000000000000000000000143707346545000020571 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.13.1/src/Foreign/Marshal/Array/Compat/0000755000000000000000000000000007346545000020230 5ustar0000000000000000base-compat-0.13.1/src/Foreign/Marshal/Array/Compat/Repl.hs0000644000000000000000000000047407346545000021473 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.13.1/src/Foreign/Marshal/0000755000000000000000000000000007346545000015727 5ustar0000000000000000base-compat-0.13.1/src/Foreign/Marshal/Compat.hs0000644000000000000000000000056507346545000017514 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.13.1/src/Foreign/Marshal/Compat/0000755000000000000000000000000007346545000017152 5ustar0000000000000000base-compat-0.13.1/src/Foreign/Marshal/Compat/Repl.hs0000644000000000000000000000044407346545000020412 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.13.1/src/Foreign/Marshal/Safe/0000755000000000000000000000000007346545000016605 5ustar0000000000000000base-compat-0.13.1/src/Foreign/Marshal/Safe/Compat.hs0000644000000000000000000000105507346545000020365 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.13.1/src/Foreign/Marshal/Safe/Compat/0000755000000000000000000000000007346545000020030 5ustar0000000000000000base-compat-0.13.1/src/Foreign/Marshal/Safe/Compat/Repl.hs0000644000000000000000000000047007346545000021267 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.13.1/src/Foreign/Marshal/Unsafe/0000755000000000000000000000000007346545000017150 5ustar0000000000000000base-compat-0.13.1/src/Foreign/Marshal/Unsafe/Compat.hs0000644000000000000000000000040707346545000020730 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.13.1/src/Foreign/Marshal/Unsafe/Compat/0000755000000000000000000000000007346545000020373 5ustar0000000000000000base-compat-0.13.1/src/Foreign/Marshal/Unsafe/Compat/Repl.hs0000644000000000000000000000050007346545000021624 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.13.1/src/Foreign/Marshal/Utils/0000755000000000000000000000000007346545000017027 5ustar0000000000000000base-compat-0.13.1/src/Foreign/Marshal/Utils/Compat.hs0000644000000000000000000000117407346545000020611 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.13.1/src/Foreign/Marshal/Utils/Compat/0000755000000000000000000000000007346545000020252 5ustar0000000000000000base-compat-0.13.1/src/Foreign/Marshal/Utils/Compat/Repl.hs0000644000000000000000000000047407346545000021515 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.13.1/src/Numeric/0000755000000000000000000000000007346545000014351 5ustar0000000000000000base-compat-0.13.1/src/Numeric/Compat.hs0000644000000000000000000001207207346545000016132 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude #-} module Numeric.Compat ( module Base , showBin , showFFloatAlt , showGFloatAlt , showHFloat , readBin ) where import Numeric as Base #if !(MIN_VERSION_base(4,7,0)) import GHC.Float #endif #if !(MIN_VERSION_base(4,16,0)) import Data.Char (intToDigit) import Prelude import Text.ParserCombinators.ReadP (readP_to_S) import qualified Text.Read.Lex.Compat as L #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 #if !(MIN_VERSION_base(4,16,0)) -- | Read an unsigned number in binary notation. -- -- >>> readBin "10011" -- [(19,"")] readBin :: (Eq a, Num a) => ReadS a readBin = readP_to_S L.readBinP -- | Show /non-negative/ 'Integral' numbers in base 2. showBin :: (Integral a, Show a) => a -> ShowS showBin = showIntAtBase 2 intToDigit #endif base-compat-0.13.1/src/Numeric/Compat/0000755000000000000000000000000007346545000015574 5ustar0000000000000000base-compat-0.13.1/src/Numeric/Compat/Repl.hs0000644000000000000000000000040407346545000017030 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.13.1/src/Numeric/Natural/0000755000000000000000000000000007346545000015757 5ustar0000000000000000base-compat-0.13.1/src/Numeric/Natural/Compat.hs0000644000000000000000000000055407346545000017542 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude #-} #if __GLASGOW_HASKELL__ >= 702 {-# LANGUAGE Trustworthy #-} #endif module Numeric.Natural.Compat ( #if MIN_VERSION_base(4,8,0) module Base , minusNaturalMaybe #endif ) where #if MIN_VERSION_base(4,8,0) import Numeric.Natural as Base # if !(MIN_VERSION_base(4,18,0)) import GHC.Natural (minusNaturalMaybe) # endif #endif base-compat-0.13.1/src/Numeric/Natural/Compat/0000755000000000000000000000000007346545000017202 5ustar0000000000000000base-compat-0.13.1/src/Numeric/Natural/Compat/Repl.hs0000644000000000000000000000044407346545000020442 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.13.1/src/Prelude/0000755000000000000000000000000007346545000014347 5ustar0000000000000000base-compat-0.13.1/src/Prelude/Compat.hs0000644000000000000000000001102307346545000016123 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 #if MIN_VERSION_base(4,17,0) && !(MIN_VERSION_base(4,18,0)) {-# LANGUAGE ExplicitNamespaces #-} #endif module Prelude.Compat ( #if MIN_VERSION_base(4,18,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 , liftA2 , (<$) , 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 # if MIN_VERSION_base(4,17,0) -- The equality types , type (~) # endif #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 ) # if !(MIN_VERSION_base(4,18,0)) import Control.Applicative (liftA2) # 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 Control.Applicative import Data.Foldable.Compat import Data.Traversable # if !(MIN_VERSION_base(4,8,0)) 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.13.1/src/Prelude/Compat/0000755000000000000000000000000007346545000015572 5ustar0000000000000000base-compat-0.13.1/src/Prelude/Compat/Repl.hs0000644000000000000000000000040407346545000017026 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.13.1/src/System/Environment/0000755000000000000000000000000007346545000016537 5ustar0000000000000000base-compat-0.13.1/src/System/Environment/Compat.hs0000644000000000000000000001015007346545000020313 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.13.1/src/System/Environment/Compat/0000755000000000000000000000000007346545000017762 5ustar0000000000000000base-compat-0.13.1/src/System/Environment/Compat/Repl.hs0000644000000000000000000000046007346545000021220 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.13.1/src/System/Exit/0000755000000000000000000000000007346545000015144 5ustar0000000000000000base-compat-0.13.1/src/System/Exit/Compat.hs0000644000000000000000000000060707346545000016726 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.13.1/src/System/Exit/Compat/0000755000000000000000000000000007346545000016367 5ustar0000000000000000base-compat-0.13.1/src/System/Exit/Compat/Repl.hs0000644000000000000000000000042407346545000017625 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.13.1/src/System/IO/0000755000000000000000000000000007346545000014542 5ustar0000000000000000base-compat-0.13.1/src/System/IO/Compat.hs0000644000000000000000000000300707346545000016321 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude #-} module System.IO.Compat ( module Base , getContents' , hGetContents' , readFile' ) where import System.IO as Base #if !(MIN_VERSION_base(4,15,0)) import Prelude.Compat -- | The 'getContents'' operation returns all user input as a single string, -- which is fully read before being returned -- (same as 'hGetContents'' 'stdin'). -- -- /Since: 4.15.0.0/ getContents' :: IO String getContents' = hGetContents' stdin -- | The 'readFile'' function reads a file and -- returns the contents of the file as a string. -- The file is fully read before being returned, as with 'getContents''. -- -- /Since: 4.15.0.0/ readFile' :: FilePath -> IO String readFile' name = openFile name ReadMode >>= hGetContents' -- | The 'hGetContents'' operation reads all input on the given handle -- before returning it as a 'String' and closing the handle. -- -- /Since: 4.15.0.0/ hGetContents' :: Handle -> IO String hGetContents' h = hGetContents h >>= \s -> length s `seq` return s -- NB: The actual implementation of hGetContents' in `base` uses a lot of -- low-level code from GHC.IO.Handle.Text. What's worse, a lot of this -- low-level code isn't exported, so we'd have to reimplement large chunks -- of it in base-compat if we wanted to backport it. For now, I've opted for -- the simpler approach of simply defining hGetContents' in terms of -- hGetContents, which is the approach that the `extra` and `strict` libraries -- use. (Indeed, the code above is taken from `strict`.) #endif base-compat-0.13.1/src/System/IO/Compat/0000755000000000000000000000000007346545000015765 5ustar0000000000000000base-compat-0.13.1/src/System/IO/Compat/Repl.hs0000644000000000000000000000041407346545000017222 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "System.IO.Compat" -- from a globally unique namespace. module System.IO.Compat.Repl ( module System.IO.Compat ) where import "this" System.IO.Compat base-compat-0.13.1/src/System/IO/Error/0000755000000000000000000000000007346545000015633 5ustar0000000000000000base-compat-0.13.1/src/System/IO/Error/Compat.hs0000644000000000000000000000221407346545000017411 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.13.1/src/System/IO/Error/Compat/0000755000000000000000000000000007346545000017056 5ustar0000000000000000base-compat-0.13.1/src/System/IO/Error/Compat/Repl.hs0000644000000000000000000000044407346545000020316 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.13.1/src/System/IO/Unsafe/0000755000000000000000000000000007346545000015763 5ustar0000000000000000base-compat-0.13.1/src/System/IO/Unsafe/Compat.hs0000644000000000000000000000155407346545000017547 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.13.1/src/System/IO/Unsafe/Compat/0000755000000000000000000000000007346545000017206 5ustar0000000000000000base-compat-0.13.1/src/System/IO/Unsafe/Compat/Repl.hs0000644000000000000000000000045007346545000020443 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.13.1/src/Text/Read/0000755000000000000000000000000007346545000014546 5ustar0000000000000000base-compat-0.13.1/src/Text/Read/Compat.hs0000644000000000000000000000245507346545000016333 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.13.1/src/Text/Read/Compat/0000755000000000000000000000000007346545000015771 5ustar0000000000000000base-compat-0.13.1/src/Text/Read/Compat/Repl.hs0000644000000000000000000000041407346545000017226 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.13.1/src/Text/Read/Lex/0000755000000000000000000000000007346545000015276 5ustar0000000000000000base-compat-0.13.1/src/Text/Read/Lex/Compat.hs0000644000000000000000000000147607346545000017065 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude #-} #if __GLASGOW_HASKELL__ >= 702 {-# LANGUAGE Trustworthy #-} #endif module Text.Read.Lex.Compat ( module Base , readBinP ) where import Text.Read.Lex as Base #if !(MIN_VERSION_base(4,16,0)) import Data.Char (ord) import Prelude import Text.ParserCombinators.ReadP (ReadP) #endif #if !(MIN_VERSION_base(4,16,0)) readBinP :: (Eq a, Num a) => ReadP a readBinP = readIntP'2 {-# SPECIALISE readBinP :: ReadP Integer #-} readIntP'2 :: (Eq a, Num a) => ReadP a readIntP'2 = readIntP 2 isDigit valDigit where isDigit c = maybe False (const True) (valDig2 c) valDigit c = maybe 0 id (valDig2 c) {-# SPECIALISE readIntP'2 :: ReadP Integer #-} valDig2 :: Char -> Maybe Int valDig2 c | '0' <= c && c <= '1' = Just (ord c - ord '0') | otherwise = Nothing #endif base-compat-0.13.1/src/Text/Read/Lex/Compat/0000755000000000000000000000000007346545000016521 5ustar0000000000000000base-compat-0.13.1/src/Text/Read/Lex/Compat/Repl.hs0000644000000000000000000000043407346545000017760 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Text.Read.Lex.Compat" -- from a globally unique namespace. module Text.Read.Lex.Compat.Repl ( module Text.Read.Lex.Compat ) where import "this" Text.Read.Lex.Compat base-compat-0.13.1/src/Type/Reflection/0000755000000000000000000000000007346545000015762 5ustar0000000000000000base-compat-0.13.1/src/Type/Reflection/Compat.hs0000644000000000000000000000614507346545000017547 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude #-} #if __GLASGOW_HASKELL__ >= 702 {-# LANGUAGE Trustworthy #-} #endif #if MIN_VERSION_base(4,10,0) {-# LANGUAGE GADTs #-} {-# LANGUAGE PatternSynonyms #-} {-# LANGUAGE PolyKinds #-} {-# LANGUAGE RankNTypes #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE TypeOperators #-} {-# LANGUAGE ViewPatterns #-} # if !(MIN_VERSION_base(4,11,0)) {-# LANGUAGE TypeInType #-} # endif #endif module Type.Reflection.Compat ( #if MIN_VERSION_base(4,10,0) module Base , withTypeable , pattern TypeRep , decTypeRep #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) # if !(MIN_VERSION_base(4,11,0)) import GHC.Exts (TYPE) import Type.Reflection (Typeable, TypeRep) # endif # if !(MIN_VERSION_base(4,19,0)) import Data.Void (Void) import Prelude.Compat import Type.Reflection.Unsafe (typeRepFingerprint) import Unsafe.Coerce (unsafeCoerce) # endif # if !(MIN_VERSION_base(4,11,0)) -- | 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 # if !(MIN_VERSION_base(4,17,0)) -- | A 'TypeableInstance' wraps up a 'Typeable' instance for explicit -- handling. For internal use: for defining 'TypeRep' pattern. data TypeableInstance (a :: k) where TypeableInstance :: Typeable a => TypeableInstance a -- | Get a reified 'Typeable' instance from an explicit 'TypeRep'. -- -- For internal use: for defining 'TypeRep' pattern. typeableInstance :: forall a. TypeRep a -> TypeableInstance a typeableInstance rep = withTypeable rep TypeableInstance -- | A explicitly bidirectional pattern synonym to construct a -- concrete representation of a type. -- -- As an __expression__: Constructs a singleton @TypeRep a@ given a -- implicit 'Typeable a' constraint: -- -- @ -- TypeRep @a :: Typeable a => TypeRep a -- @ -- -- As a __pattern__: Matches on an explicit @TypeRep a@ witness bringing -- an implicit @Typeable a@ constraint into scope. -- -- @ -- f :: TypeRep a -> .. -- f TypeRep = {- Typeable a in scope -} -- @ -- -- /Since: 4.17.0.0/ pattern TypeRep :: forall a. () => Typeable a => TypeRep a pattern TypeRep <- (typeableInstance -> TypeableInstance) where TypeRep = typeRep # endif # if !(MIN_VERSION_base(4,19,0)) -- | Type equality decision -- -- /Since: 4.19.0.0/ decTypeRep :: forall k1 k2 (a :: k1) (b :: k2). TypeRep a -> TypeRep b -> Either (a :~~: b -> Void) (a :~~: b) decTypeRep a b | sameTypeRep a b = Right (unsafeCoerce HRefl) | otherwise = Left (\HRefl -> errorWithoutStackTrace ("decTypeRep: Impossible equality proof " ++ show a ++ " :~: " ++ show b)) {-# INLINEABLE decTypeRep #-} sameTypeRep :: forall k1 k2 (a :: k1) (b :: k2). TypeRep a -> TypeRep b -> Bool sameTypeRep a b = typeRepFingerprint a == typeRepFingerprint b # endif #endif base-compat-0.13.1/src/Type/Reflection/Compat/0000755000000000000000000000000007346545000017205 5ustar0000000000000000base-compat-0.13.1/src/Type/Reflection/Compat/Repl.hs0000644000000000000000000000044407346545000020445 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