base-compat-batteries-0.14.1/0000755000000000000000000000000007346545000014141 5ustar0000000000000000base-compat-batteries-0.14.1/CHANGES.markdown0000644000000000000000000001570607346545000016766 0ustar0000000000000000## Changes in 0.14.1 [2024.12.06] - This coincides with the `base-compat-batteries-0.14.1` release. Refer to the [`base-compat-batteries` changelog](https://github.com/haskell-compat/base-compat/blob/master/base-compat-batteries/CHANGES.markdown#changes-in-0141-20241206) for more details. - Drop support for pre-8.0 versions of GHC. ## Changes in 0.14.0 [2024.04.30] - This coincides with the `base-compat-batteries-0.14.0` release. Refer to the [`base-compat-batteries` changelog](https://github.com/haskell-compat/base-compat/blob/master/base-compat-batteries/CHANGES.markdown#changes-in-0140-20240430) for more details. ## Changes in 0.13.1 [2023.10.11] - This coincides with the `base-compat-batteries-0.13.1` release. Refer to the [`base-compat-batteries` changelog](https://github.com/haskell-compat/base-compat/blob/master/base-compat-batteries/CHANGES.markdown#changes-in-0131-20231011) for more details. ## Changes in 0.13.0 [2023.03.10] - This coincides with the `base-compat-0.13.0` release. Refer to the [`base-compat` changelog](https://github.com/haskell-compat/base-compat/blob/master/base-compat/CHANGES.markdown#changes-in-0130-20230310) for more details. - Require `OneTuple-0.4` or later on GHC 7.4+, as that is the first `OneTuple` release to backport the `MkSolo` data constuctor for `Solo`. See `Data.Tuple.Compat`. - Introduce `Data.Foldable1.Compat` and `Data.Bifoldable1.Compat` modules, which correspond to changes made in `base-4.18.0.0`. `base-compat-batteries` uses the `foldable1-classes-compat` library to backport this code to older versions of `base`. - Depend on `bifunctor-classes-compat` to backport the `Bifunctor`, `Bifoldable`, and `Bitraversable` classes instead of the `bifunctors` library, which has more dependencies. ## Changes in 0.12.3 [2023.07.12] - Allow building with `OneTuple-0.4.*`. ## Changes in 0.12.2 [2022.08.11] - This coincides with the `base-compat-0.12.2` release. Refer to the [`base-compat` changelog](https://github.com/haskell-compat/base-compat/blob/master/base-compat/CHANGES.markdown#changes-in-0122-20220811) for more details. ## Changes in 0.12.1 [2021.10.30] - Backport `Solo` to the `Data.Tuple.Compat` module. If using `ghc-prim-0.7.0` or later, `Solo` is taken from `ghc-prim`. If using an older version of `ghc-prim`, `Solo` is taken from the `OneTuple` compatibility library. - This coincides with the `base-compat-0.12.1` release. Refer to the [`base-compat` changelog](https://github.com/haskell-compat/base-compat/blob/master/base-compat/CHANGES.markdown#changes-in-0121-20211030) for more details. ## Changes in 0.12.0 [2021.08.29] - `Data.Semigroup.Compat{.Repl.Batteries}` no longer re-exports the `Option` data type or the `option` function, as both have been removed in `base-4.16`. - This coincides with the `base-compat-0.12.0` release. Refer to the [`base-compat` changelog](https://github.com/haskell-compat/base-compat/blob/master/base-compat/CHANGES.markdown#changes-in-0120-20210829) for more details. ## Changes in 0.11.2 [2020.09.30] - This coincides with the `base-compat-0.11.2` release. Refer to the [`base-compat` changelog](https://github.com/haskell-compat/base-compat/blob/master/base-compat/CHANGES.markdown#changes-in-0112-20200930) for more details. ## Changes in 0.11.1 [2020.01.27] - This coincides with the `base-compat-0.11.1` release. Refer to the [`base-compat` changelog](https://github.com/haskell-compat/base-compat/blob/master/base-compat/CHANGES.markdown#changes-in-0111-20200127) for more details. ## Changes in 0.11.0 [2019.09.06] - Reexport `MonadFail(fail)` from `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-batteries`. - Introduce the `Data.Type.Equality.Compat` module, which reexports `Data.Type.Equality` from `base` (if using a sufficiently recent version of GHC) or the `type-equality` library (if using an old GHC). - This coincides with the `base-compat-0.11.0` release. Refer to the [`base-compat` changelog](https://github.com/haskell-compat/base-compat/blob/master/base-compat/CHANGES.markdown#changes-in-0110-20190906) for more details. ## Changes in 0.10.5 [2018.10.18] - This coincides with the `base-compat-0.10.5` release. Refer to the [`base-compat` changelog](https://github.com/haskell-compat/base-compat/blob/master/base-compat/CHANGES.markdown#changes-in-0105-20181018) for more details. ## Changes in 0.10.4 [2018.07.03] - Add a `SafeHaskellSpec` test which ensures that certain modules (such as `Prelude.Compat`) can be imported in the presence of `Safe`. - This coincides with the `base-compat-0.10.4` release. Refer to the [`base-compat` changelog](https://github.com/haskell-compat/base-compat/blob/master/base-compat/CHANGES.markdown#changes-in-0104-20180703) for more details. ## Changes in 0.10.3 [2018.07.02] - This coincides with the `base-compat-0.10.3` release. Refer to the [`base-compat` changelog](https://github.com/haskell-compat/base-compat/blob/master/base-compat/CHANGES.markdown#changes-in-0103-20180702) for more details. ## Changes in 0.10.2 [2018.07.02] - Sync with `base-4.12`/GHC 8.6 - Introduce the `Data.Functor.Contravariant.Compat` module, which reexports `Data.Functor.Contravariant` from `base` (if using GHC 8.6 or later) or the `contravariant` library (if using an earlier version of GHC). - This coincides with the `base-compat-0.10.2` release. Refer to the [`base-compat` changelog](https://github.com/haskell-compat/base-compat/blob/master/base-compat/CHANGES.markdown#changes-in-0102-20180702) for more details. ## Changes in 0.10.1 [2018.04.10] - Add `Data.List.NonEmpty.Compat`. - Reexport `(Data.Semigroup.<>)` from `Data.Monoid.Compat`. - Tighten lower bounds of compat package dependencies. - This coincides with the `base-compat-0.10.1` release. Refer to the [`base-compat` changelog](https://github.com/haskell-compat/base-compat/blob/master/base-compat/CHANGES.markdown#changes-in-0101-20180410) for more details. ## Changes in 0.10.0 [2018.04.05] - Sync with `base-4.11`/GHC 8.4 - This coincides with the `base-compat-0.10` release. Refer to the [`base-compat` changelog](https://github.com/haskell-compat/base-compat/blob/master/base-compat/CHANGES.markdown#changes-in-0100-20180405) for more details. base-compat-batteries-0.14.1/LICENSE0000644000000000000000000000214007346545000015143 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-batteries-0.14.1/README.markdown0000644000000000000000000000311407346545000016641 0ustar0000000000000000# `base-compat` with extra batteries [![Hackage](https://img.shields.io/hackage/v/base-compat-batteries.svg)][Hackage: base-compat-batteries] [![Hackage Dependencies](https://img.shields.io/hackage-deps/v/base-compat-batteries.svg)](http://packdeps.haskellers.com/reverse/base-compat-batteries) [![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-batteries]: http://hackage.haskell.org/package/base-compat-batteries "base-compat-batteries package on Hackage" [Haskell.org]: http://www.haskell.org "The Haskell Programming Language" [tl;dr Legal: MIT]: https://tldrlegal.com/license/mit-license "MIT License" ## Scope `base-compat-batteries` provides functions available in later versions of `base` to a wider range of compilers, without requiring you to use CPP pragmas in your code. This package provides the same API as the [`base-compat`](http://hackage.haskell.org/package/base-compat) library, but depends on compatibility packages (such as `semigroups`) to offer a wider support window than `base-compat`, which has no dependencies. Like `base-compat`, `base-compat-batteries` does not add any orphan instances. There is a separate package [`base-orphans`](https://github.com/haskell-compat/base-orphans) for that. See [here](https://github.com/haskell-compat/base-compat/blob/master/base-compat/README.markdown#dependencies) for a more comprehensive list of differences between `base-compat` and `base-compat-batteries`. base-compat-batteries-0.14.1/Setup.lhs0000644000000000000000000000011407346545000015745 0ustar0000000000000000#!/usr/bin/env runhaskell > import Distribution.Simple > main = defaultMain base-compat-batteries-0.14.1/base-compat-batteries.cabal0000644000000000000000000002140107346545000021276 0ustar0000000000000000name: base-compat-batteries version: 0.14.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: base-compat with extra batteries 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. . This package provides the same API as the @@ library, but depends on compatibility packages (such as @semigroups@) to offer a wider support window than @base-compat@, which has no dependencies. Most of the modules in this library have the same names as in @base-compat@ to make it easier to switch between the two. There also exist versions of each module with the suffix @.Repl.Batteries@, which are distinct from anything in @base-compat@, to allow for easier use in GHCi. . See @@ for a more comprehensive list of differences between @base-compat@ and @base-compat-batteries@. extra-source-files: CHANGES.markdown, README.markdown tested-with: GHC == 8.0.2 , GHC == 8.2.2 , GHC == 8.4.4 , GHC == 8.6.5 , GHC == 8.8.4 , GHC == 8.10.7 , GHC == 9.0.2 , GHC == 9.2.8 , GHC == 9.4.8 , GHC == 9.6.6 , GHC == 9.8.2 , GHC == 9.10.1 , GHC == 9.12.1 source-repository head type: git location: https://github.com/haskell-compat/base-compat subdir: base-compat-batteries library ghc-options: -Wall default-language: Haskell2010 build-depends: base >= 4.9 && < 5, base-compat == 0.14.1, ghc-prim if !impl(ghc >= 8.2) build-depends: bifunctor-classes-compat >= 0.1 && < 0.2, type-equality >= 1 && < 1.1 if !impl(ghc >= 8.6) build-depends: contravariant >= 1.5 && < 1.6 if !impl(ghc >= 9.6) build-depends: foldable1-classes-compat >= 0.1 && < 0.2, OneTuple >= 0.4 && < 0.5 ghc-options: -Wno-duplicate-exports -Wno-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.Batteries Control.Concurrent.MVar.Compat.Repl.Batteries Control.Exception.Compat.Repl.Batteries Control.Monad.Compat.Repl.Batteries Control.Monad.Fail.Compat.Repl.Batteries Control.Monad.IO.Class.Compat.Repl.Batteries Control.Monad.ST.Lazy.Unsafe.Compat.Repl.Batteries Control.Monad.ST.Unsafe.Compat.Repl.Batteries Data.Bifoldable.Compat.Repl.Batteries Data.Bifoldable1.Compat.Repl.Batteries Data.Bifunctor.Compat.Repl.Batteries Data.Bitraversable.Compat.Repl.Batteries Data.Bits.Compat.Repl.Batteries Data.Bool.Compat.Repl.Batteries Data.Complex.Compat.Repl.Batteries Data.Either.Compat.Repl.Batteries Data.Foldable.Compat.Repl.Batteries Data.Foldable1.Compat.Repl.Batteries Data.Function.Compat.Repl.Batteries Data.Functor.Compat.Repl.Batteries Data.Functor.Compose.Compat.Repl.Batteries Data.Functor.Const.Compat.Repl.Batteries Data.Functor.Identity.Compat.Repl.Batteries Data.Functor.Contravariant.Compat.Repl.Batteries Data.Functor.Product.Compat.Repl.Batteries Data.Functor.Sum.Compat.Repl.Batteries Data.IORef.Compat.Repl.Batteries Data.List.Compat.Repl.Batteries Data.List.NonEmpty.Compat.Repl.Batteries Data.Monoid.Compat.Repl.Batteries Data.Proxy.Compat.Repl.Batteries Data.Ratio.Compat.Repl.Batteries Data.Semigroup.Compat.Repl.Batteries Data.STRef.Compat.Repl.Batteries Data.String.Compat.Repl.Batteries Data.Traversable.Compat.Repl.Batteries Data.Tuple.Compat.Repl.Batteries Data.Typeable.Compat.Repl.Batteries Data.Type.Coercion.Compat.Repl.Batteries Data.Type.Equality.Compat.Repl.Batteries Data.Version.Compat.Repl.Batteries Data.Void.Compat.Repl.Batteries Data.Word.Compat.Repl.Batteries Debug.Trace.Compat.Repl.Batteries Foreign.Compat.Repl.Batteries Foreign.ForeignPtr.Compat.Repl.Batteries Foreign.ForeignPtr.Safe.Compat.Repl.Batteries Foreign.ForeignPtr.Unsafe.Compat.Repl.Batteries Foreign.Marshal.Alloc.Compat.Repl.Batteries Foreign.Marshal.Array.Compat.Repl.Batteries Foreign.Marshal.Compat.Repl.Batteries Foreign.Marshal.Safe.Compat.Repl.Batteries Foreign.Marshal.Unsafe.Compat.Repl.Batteries Foreign.Marshal.Utils.Compat.Repl.Batteries Numeric.Compat.Repl.Batteries Numeric.Natural.Compat.Repl.Batteries Prelude.Compat.Repl.Batteries System.Environment.Compat.Repl.Batteries System.Exit.Compat.Repl.Batteries System.IO.Compat.Repl.Batteries System.IO.Error.Compat.Repl.Batteries System.IO.Unsafe.Compat.Repl.Batteries Text.Read.Compat.Repl.Batteries Text.Read.Lex.Compat.Repl.Batteries Type.Reflection.Compat.Repl.Batteries test-suite spec type: exitcode-stdio-1.0 ghc-options: -Wall default-language: Haskell2010 hs-source-dirs: test main-is: Spec.hs other-modules: Control.Monad.CompatSpec Data.Bits.CompatSpec Data.Bool.CompatSpec Data.Either.CompatSpec Data.Foldable.CompatSpec Data.Function.CompatSpec Data.Functor.CompatSpec Data.IORef.CompatSpec Data.List.CompatSpec Data.Monoid.CompatSpec Data.STRef.CompatSpec Data.Version.CompatSpec Data.Word.CompatSpec Foreign.Marshal.Alloc.CompatSpec Foreign.Marshal.Utils.CompatSpec Numeric.CompatSpec Prelude.CompatSpec System.Environment.CompatSpec Text.Read.CompatSpec -- Other tests SafeHaskellSpec TestHspecTrustworthy build-depends: base >= 4.9 && < 5 , base-compat-batteries , hspec >= 1.8 , QuickCheck build-tool-depends: hspec-discover:hspec-discover >= 1.8 base-compat-batteries-0.14.1/src/Control/Concurrent/0000755000000000000000000000000007346545000020472 5ustar0000000000000000base-compat-batteries-0.14.1/src/Control/Concurrent/Compat.hs0000644000000000000000000000025107346545000022247 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Control.Concurrent.Compat ( module Base ) where import "base-compat" Control.Concurrent.Compat as Base base-compat-batteries-0.14.1/src/Control/Concurrent/Compat/Repl/0000755000000000000000000000000007346545000022617 5ustar0000000000000000base-compat-batteries-0.14.1/src/Control/Concurrent/Compat/Repl/Batteries.hs0000644000000000000000000000046007346545000025075 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -Wno-dodgy-exports -Wno-unused-imports #-} -- | Reexports "Control.Concurrent.Compat" -- from a globally unique namespace. module Control.Concurrent.Compat.Repl.Batteries ( module Control.Concurrent.Compat ) where import "this" Control.Concurrent.Compat base-compat-batteries-0.14.1/src/Control/Concurrent/MVar/0000755000000000000000000000000007346545000021337 5ustar0000000000000000base-compat-batteries-0.14.1/src/Control/Concurrent/MVar/Compat.hs0000644000000000000000000000026307346545000023117 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Control.Concurrent.MVar.Compat ( module Base ) where import "base-compat" Control.Concurrent.MVar.Compat as Base base-compat-batteries-0.14.1/src/Control/Concurrent/MVar/Compat/Repl/0000755000000000000000000000000007346545000023464 5ustar0000000000000000base-compat-batteries-0.14.1/src/Control/Concurrent/MVar/Compat/Repl/Batteries.hs0000644000000000000000000000050407346545000025741 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -Wno-dodgy-exports -Wno-unused-imports #-} -- | Reexports "Control.Concurrent.MVar.Compat" -- from a globally unique namespace. module Control.Concurrent.MVar.Compat.Repl.Batteries ( module Control.Concurrent.MVar.Compat ) where import "this" Control.Concurrent.MVar.Compat base-compat-batteries-0.14.1/src/Control/Exception/0000755000000000000000000000000007346545000020306 5ustar0000000000000000base-compat-batteries-0.14.1/src/Control/Exception/Compat.hs0000644000000000000000000000024707346545000022070 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Control.Exception.Compat ( module Base ) where import "base-compat" Control.Exception.Compat as Base base-compat-batteries-0.14.1/src/Control/Exception/Compat/Repl/0000755000000000000000000000000007346545000022433 5ustar0000000000000000base-compat-batteries-0.14.1/src/Control/Exception/Compat/Repl/Batteries.hs0000644000000000000000000000045407346545000024714 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -Wno-dodgy-exports -Wno-unused-imports #-} -- | Reexports "Control.Exception.Compat" -- from a globally unique namespace. module Control.Exception.Compat.Repl.Batteries ( module Control.Exception.Compat ) where import "this" Control.Exception.Compat base-compat-batteries-0.14.1/src/Control/Monad/0000755000000000000000000000000007346545000017406 5ustar0000000000000000base-compat-batteries-0.14.1/src/Control/Monad/Compat.hs0000644000000000000000000000032507346545000021165 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Control.Monad.Compat ( module Base , fail ) where import "base-compat" Control.Monad.Compat as Base hiding (fail) import Control.Monad.Fail (fail) base-compat-batteries-0.14.1/src/Control/Monad/Compat/Repl/0000755000000000000000000000000007346545000021533 5ustar0000000000000000base-compat-batteries-0.14.1/src/Control/Monad/Compat/Repl/Batteries.hs0000644000000000000000000000043407346545000024012 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -Wno-dodgy-exports -Wno-unused-imports #-} -- | Reexports "Control.Monad.Compat" -- from a globally unique namespace. module Control.Monad.Compat.Repl.Batteries ( module Control.Monad.Compat ) where import "this" Control.Monad.Compat base-compat-batteries-0.14.1/src/Control/Monad/Fail/0000755000000000000000000000000007346545000020261 5ustar0000000000000000base-compat-batteries-0.14.1/src/Control/Monad/Fail/Compat.hs0000644000000000000000000000024407346545000022040 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude, PackageImports #-} module Control.Monad.Fail.Compat ( module Base ) where import "base-compat" Control.Monad.Fail.Compat as Base base-compat-batteries-0.14.1/src/Control/Monad/Fail/Compat/Repl/0000755000000000000000000000000007346545000022406 5ustar0000000000000000base-compat-batteries-0.14.1/src/Control/Monad/Fail/Compat/Repl/Batteries.hs0000644000000000000000000000046007346545000024664 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -Wno-dodgy-exports -Wno-unused-imports #-} -- | Reexports "Control.Monad.Fail.Compat" -- from a globally unique namespace. module Control.Monad.Fail.Compat.Repl.Batteries ( module Control.Monad.Fail.Compat ) where import "this" Control.Monad.Fail.Compat base-compat-batteries-0.14.1/src/Control/Monad/IO/Class/0000755000000000000000000000000007346545000020762 5ustar0000000000000000base-compat-batteries-0.14.1/src/Control/Monad/IO/Class/Compat.hs0000644000000000000000000000025407346545000022542 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude, PackageImports #-} module Control.Monad.IO.Class.Compat ( module Base ) where import "base-compat" Control.Monad.IO.Class.Compat as Base base-compat-batteries-0.14.1/src/Control/Monad/IO/Class/Compat/Repl/0000755000000000000000000000000007346545000023107 5ustar0000000000000000base-compat-batteries-0.14.1/src/Control/Monad/IO/Class/Compat/Repl/Batteries.hs0000644000000000000000000000050007346545000025360 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -Wno-dodgy-exports -Wno-unused-imports #-} -- | Reexports "Control.Monad.IO.Class.Compat" -- from a globally unique namespace. module Control.Monad.IO.Class.Compat.Repl.Batteries ( module Control.Monad.IO.Class.Compat ) where import "this" Control.Monad.IO.Class.Compat base-compat-batteries-0.14.1/src/Control/Monad/ST/Lazy/Unsafe/0000755000000000000000000000000007346545000022074 5ustar0000000000000000base-compat-batteries-0.14.1/src/Control/Monad/ST/Lazy/Unsafe/Compat.hs0000644000000000000000000000027507346545000023657 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Control.Monad.ST.Lazy.Unsafe.Compat ( module Base ) where import "base-compat" Control.Monad.ST.Lazy.Unsafe.Compat as Base base-compat-batteries-0.14.1/src/Control/Monad/ST/Lazy/Unsafe/Compat/Repl/0000755000000000000000000000000007346545000024221 5ustar0000000000000000base-compat-batteries-0.14.1/src/Control/Monad/ST/Lazy/Unsafe/Compat/Repl/Batteries.hs0000644000000000000000000000053007346545000026475 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -Wno-dodgy-exports -Wno-unused-imports #-} -- | Reexports "Control.Monad.ST.Lazy.Unsafe.Compat" -- from a globally unique namespace. module Control.Monad.ST.Lazy.Unsafe.Compat.Repl.Batteries ( module Control.Monad.ST.Lazy.Unsafe.Compat ) where import "this" Control.Monad.ST.Lazy.Unsafe.Compat base-compat-batteries-0.14.1/src/Control/Monad/ST/Unsafe/0000755000000000000000000000000007346545000021155 5ustar0000000000000000base-compat-batteries-0.14.1/src/Control/Monad/ST/Unsafe/Compat.hs0000644000000000000000000000026307346545000022735 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Control.Monad.ST.Unsafe.Compat ( module Base ) where import "base-compat" Control.Monad.ST.Unsafe.Compat as Base base-compat-batteries-0.14.1/src/Control/Monad/ST/Unsafe/Compat/Repl/0000755000000000000000000000000007346545000023302 5ustar0000000000000000base-compat-batteries-0.14.1/src/Control/Monad/ST/Unsafe/Compat/Repl/Batteries.hs0000644000000000000000000000050407346545000025557 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -Wno-dodgy-exports -Wno-unused-imports #-} -- | Reexports "Control.Monad.ST.Unsafe.Compat" -- from a globally unique namespace. module Control.Monad.ST.Unsafe.Compat.Repl.Batteries ( module Control.Monad.ST.Unsafe.Compat ) where import "this" Control.Monad.ST.Unsafe.Compat base-compat-batteries-0.14.1/src/Data/Bifoldable/0000755000000000000000000000000007346545000017624 5ustar0000000000000000base-compat-batteries-0.14.1/src/Data/Bifoldable/Compat.hs0000644000000000000000000000040707346545000021404 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Data.Bifoldable.Compat ( module Base ) where #if MIN_VERSION_base(4,10,0) import "base-compat" Data.Bifoldable.Compat as Base #else import "bifunctor-classes-compat" Data.Bifoldable as Base #endif base-compat-batteries-0.14.1/src/Data/Bifoldable/Compat/Repl/0000755000000000000000000000000007346545000021751 5ustar0000000000000000base-compat-batteries-0.14.1/src/Data/Bifoldable/Compat/Repl/Batteries.hs0000644000000000000000000000044407346545000024231 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -Wno-dodgy-exports -Wno-unused-imports #-} -- | Reexports "Data.Bifoldable.Compat" -- from a globally unique namespace. module Data.Bifoldable.Compat.Repl.Batteries ( module Data.Bifoldable.Compat ) where import "this" Data.Bifoldable.Compat base-compat-batteries-0.14.1/src/Data/Bifoldable1/0000755000000000000000000000000007346545000017705 5ustar0000000000000000base-compat-batteries-0.14.1/src/Data/Bifoldable1/Compat.hs0000644000000000000000000000041207346545000021461 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Data.Bifoldable1.Compat ( module Base ) where #if MIN_VERSION_base(4,18,0) import "base-compat" Data.Bifoldable1.Compat as Base #else import "foldable1-classes-compat" Data.Bifoldable1 as Base #endif base-compat-batteries-0.14.1/src/Data/Bifoldable1/Compat/Repl/0000755000000000000000000000000007346545000022032 5ustar0000000000000000base-compat-batteries-0.14.1/src/Data/Bifoldable1/Compat/Repl/Batteries.hs0000644000000000000000000000045007346545000024307 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -Wno-dodgy-exports -Wno-unused-imports #-} -- | Reexports "Data.Bifoldable1.Compat" -- from a globally unique namespace. module Data.Bifoldable1.Compat.Repl.Batteries ( module Data.Bifoldable1.Compat ) where import "this" Data.Bifoldable1.Compat base-compat-batteries-0.14.1/src/Data/Bifunctor/0000755000000000000000000000000007346545000017534 5ustar0000000000000000base-compat-batteries-0.14.1/src/Data/Bifunctor/Compat.hs0000644000000000000000000000023407346545000021312 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude, PackageImports #-} module Data.Bifunctor.Compat ( module Base ) where import "base-compat" Data.Bifunctor.Compat as Base base-compat-batteries-0.14.1/src/Data/Bifunctor/Compat/Repl/0000755000000000000000000000000007346545000021661 5ustar0000000000000000base-compat-batteries-0.14.1/src/Data/Bifunctor/Compat/Repl/Batteries.hs0000644000000000000000000000044007346545000024135 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -Wno-dodgy-exports -Wno-unused-imports #-} -- | Reexports "Data.Bifunctor.Compat" -- from a globally unique namespace. module Data.Bifunctor.Compat.Repl.Batteries ( module Data.Bifunctor.Compat ) where import "this" Data.Bifunctor.Compat base-compat-batteries-0.14.1/src/Data/Bitraversable/0000755000000000000000000000000007346545000020366 5ustar0000000000000000base-compat-batteries-0.14.1/src/Data/Bitraversable/Compat.hs0000644000000000000000000000272307346545000022151 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Data.Bitraversable.Compat ( module Base , firstA , secondA ) where #if MIN_VERSION_base(4,10,0) import "base-compat" Data.Bitraversable.Compat as Base #else import "bifunctor-classes-compat" Data.Bitraversable as Base import Prelude.Compat #endif #if !MIN_VERSION_base(4,10,0) -- | Traverses only over the first argument. -- -- @'firstA' f ≡ 'bitraverse' f 'pure'@ -- ==== __Examples__ -- -- Basic usage: -- -- >>> firstA listToMaybe (Left []) -- Nothing -- -- >>> firstA listToMaybe (Left [1, 2, 3]) -- Just (Left 1) -- -- >>> firstA listToMaybe (Right [4, 5]) -- Just (Right [4, 5]) -- -- >>> firstA listToMaybe ([1, 2, 3], [4, 5]) -- Just (1,[4, 5]) -- -- >>> firstA listToMaybe ([], [4, 5]) -- Nothing -- @since 4.21.0.0 firstA :: Bitraversable t => Applicative f => (a -> f c) -> t a b -> f (t c b) firstA f = bitraverse f pure -- | Traverses only over the second argument. -- -- @'secondA' f ≡ 'bitraverse' 'pure' f@ -- -- ==== __Examples__ -- -- Basic usage: -- -- >>> secondA (find odd) (Left []) -- Just (Left []) -- -- >>> secondA (find odd) (Left [1, 2, 3]) -- Just (Left [1,2,3]) -- -- >>> secondA (find odd) (Right [4, 5]) -- Just (Right 5) -- -- >>> secondA (find odd) ([1, 2, 3], [4, 5]) -- Just ([1,2,3],5) -- -- >>> secondA (find odd) ([1,2,3], [4]) -- Nothing -- -- @since 4.21.0.0 secondA :: Bitraversable t => Applicative f => (b -> f c) -> t a b -> f (t a c) secondA f = bitraverse pure f #endif base-compat-batteries-0.14.1/src/Data/Bitraversable/Compat/Repl/0000755000000000000000000000000007346545000022513 5ustar0000000000000000base-compat-batteries-0.14.1/src/Data/Bitraversable/Compat/Repl/Batteries.hs0000644000000000000000000000046007346545000024771 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -Wno-dodgy-exports -Wno-unused-imports #-} -- | Reexports "Data.Bitraversable.Compat" -- from a globally unique namespace. module Data.Bitraversable.Compat.Repl.Batteries ( module Data.Bitraversable.Compat ) where import "this" Data.Bitraversable.Compat base-compat-batteries-0.14.1/src/Data/Bits/0000755000000000000000000000000007346545000016502 5ustar0000000000000000base-compat-batteries-0.14.1/src/Data/Bits/Compat.hs0000644000000000000000000000022707346545000020262 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Data.Bits.Compat ( module Base ) where import "base-compat" Data.Bits.Compat as Base base-compat-batteries-0.14.1/src/Data/Bits/Compat/Repl/0000755000000000000000000000000007346545000020627 5ustar0000000000000000base-compat-batteries-0.14.1/src/Data/Bits/Compat/Repl/Batteries.hs0000644000000000000000000000041407346545000023104 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -Wno-dodgy-exports -Wno-unused-imports #-} -- | Reexports "Data.Bits.Compat" -- from a globally unique namespace. module Data.Bits.Compat.Repl.Batteries ( module Data.Bits.Compat ) where import "this" Data.Bits.Compat base-compat-batteries-0.14.1/src/Data/Bool/0000755000000000000000000000000007346545000016474 5ustar0000000000000000base-compat-batteries-0.14.1/src/Data/Bool/Compat.hs0000644000000000000000000000022707346545000020254 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Data.Bool.Compat ( module Base ) where import "base-compat" Data.Bool.Compat as Base base-compat-batteries-0.14.1/src/Data/Bool/Compat/Repl/0000755000000000000000000000000007346545000020621 5ustar0000000000000000base-compat-batteries-0.14.1/src/Data/Bool/Compat/Repl/Batteries.hs0000644000000000000000000000041407346545000023076 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -Wno-dodgy-exports -Wno-unused-imports #-} -- | Reexports "Data.Bool.Compat" -- from a globally unique namespace. module Data.Bool.Compat.Repl.Batteries ( module Data.Bool.Compat ) where import "this" Data.Bool.Compat base-compat-batteries-0.14.1/src/Data/Complex/0000755000000000000000000000000007346545000017210 5ustar0000000000000000base-compat-batteries-0.14.1/src/Data/Complex/Compat.hs0000644000000000000000000000023507346545000020767 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Data.Complex.Compat ( module Base ) where import "base-compat" Data.Complex.Compat as Base base-compat-batteries-0.14.1/src/Data/Complex/Compat/Repl/0000755000000000000000000000000007346545000021335 5ustar0000000000000000base-compat-batteries-0.14.1/src/Data/Complex/Compat/Repl/Batteries.hs0000644000000000000000000000043007346545000023610 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -Wno-dodgy-exports -Wno-unused-imports #-} -- | Reexports "Data.Complex.Compat" -- from a globally unique namespace. module Data.Complex.Compat.Repl.Batteries ( module Data.Complex.Compat ) where import "this" Data.Complex.Compat base-compat-batteries-0.14.1/src/Data/Either/0000755000000000000000000000000007346545000017021 5ustar0000000000000000base-compat-batteries-0.14.1/src/Data/Either/Compat.hs0000644000000000000000000000023307346545000020576 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Data.Either.Compat ( module Base ) where import "base-compat" Data.Either.Compat as Base base-compat-batteries-0.14.1/src/Data/Either/Compat/Repl/0000755000000000000000000000000007346545000021146 5ustar0000000000000000base-compat-batteries-0.14.1/src/Data/Either/Compat/Repl/Batteries.hs0000644000000000000000000000042407346545000023424 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -Wno-dodgy-exports -Wno-unused-imports #-} -- | Reexports "Data.Either.Compat" -- from a globally unique namespace. module Data.Either.Compat.Repl.Batteries ( module Data.Either.Compat ) where import "this" Data.Either.Compat base-compat-batteries-0.14.1/src/Data/Foldable/0000755000000000000000000000000007346545000017311 5ustar0000000000000000base-compat-batteries-0.14.1/src/Data/Foldable/Compat.hs0000644000000000000000000000023707346545000021072 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Data.Foldable.Compat ( module Base ) where import "base-compat" Data.Foldable.Compat as Base base-compat-batteries-0.14.1/src/Data/Foldable/Compat/Repl/0000755000000000000000000000000007346545000021436 5ustar0000000000000000base-compat-batteries-0.14.1/src/Data/Foldable/Compat/Repl/Batteries.hs0000644000000000000000000000043407346545000023715 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -Wno-dodgy-exports -Wno-unused-imports #-} -- | Reexports "Data.Foldable.Compat" -- from a globally unique namespace. module Data.Foldable.Compat.Repl.Batteries ( module Data.Foldable.Compat ) where import "this" Data.Foldable.Compat base-compat-batteries-0.14.1/src/Data/Foldable1/0000755000000000000000000000000007346545000017372 5ustar0000000000000000base-compat-batteries-0.14.1/src/Data/Foldable1/Compat.hs0000644000000000000000000000040407346545000021147 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Data.Foldable1.Compat ( module Base ) where #if MIN_VERSION_base(4,18,0) import "base-compat" Data.Foldable1.Compat as Base #else import "foldable1-classes-compat" Data.Foldable1 as Base #endif base-compat-batteries-0.14.1/src/Data/Foldable1/Compat/Repl/0000755000000000000000000000000007346545000021517 5ustar0000000000000000base-compat-batteries-0.14.1/src/Data/Foldable1/Compat/Repl/Batteries.hs0000644000000000000000000000044007346545000023773 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -Wno-dodgy-exports -Wno-unused-imports #-} -- | Reexports "Data.Foldable1.Compat" -- from a globally unique namespace. module Data.Foldable1.Compat.Repl.Batteries ( module Data.Foldable1.Compat ) where import "this" Data.Foldable1.Compat base-compat-batteries-0.14.1/src/Data/Function/0000755000000000000000000000000007346545000017366 5ustar0000000000000000base-compat-batteries-0.14.1/src/Data/Function/Compat.hs0000644000000000000000000000023707346545000021147 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Data.Function.Compat ( module Base ) where import "base-compat" Data.Function.Compat as Base base-compat-batteries-0.14.1/src/Data/Function/Compat/Repl/0000755000000000000000000000000007346545000021513 5ustar0000000000000000base-compat-batteries-0.14.1/src/Data/Function/Compat/Repl/Batteries.hs0000644000000000000000000000043407346545000023772 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -Wno-dodgy-exports -Wno-unused-imports #-} -- | Reexports "Data.Function.Compat" -- from a globally unique namespace. module Data.Function.Compat.Repl.Batteries ( module Data.Function.Compat ) where import "this" Data.Function.Compat base-compat-batteries-0.14.1/src/Data/Functor/0000755000000000000000000000000007346545000017221 5ustar0000000000000000base-compat-batteries-0.14.1/src/Data/Functor/Compat.hs0000644000000000000000000000023507346545000021000 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Data.Functor.Compat ( module Base ) where import "base-compat" Data.Functor.Compat as Base base-compat-batteries-0.14.1/src/Data/Functor/Compat/Repl/0000755000000000000000000000000007346545000021346 5ustar0000000000000000base-compat-batteries-0.14.1/src/Data/Functor/Compat/Repl/Batteries.hs0000644000000000000000000000043007346545000023621 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -Wno-dodgy-exports -Wno-unused-imports #-} -- | Reexports "Data.Functor.Compat" -- from a globally unique namespace. module Data.Functor.Compat.Repl.Batteries ( module Data.Functor.Compat ) where import "this" Data.Functor.Compat base-compat-batteries-0.14.1/src/Data/Functor/Compose/0000755000000000000000000000000007346545000020626 5ustar0000000000000000base-compat-batteries-0.14.1/src/Data/Functor/Compose/Compat.hs0000644000000000000000000000025007346545000022402 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude, PackageImports #-} module Data.Functor.Compose.Compat ( module Base ) where import "base-compat" Data.Functor.Compose.Compat as Base base-compat-batteries-0.14.1/src/Data/Functor/Compose/Compat/Repl/0000755000000000000000000000000007346545000022753 5ustar0000000000000000base-compat-batteries-0.14.1/src/Data/Functor/Compose/Compat/Repl/Batteries.hs0000644000000000000000000000047007346545000025232 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -Wno-dodgy-exports -Wno-unused-imports #-} -- | Reexports "Data.Functor.Compose.Compat" -- from a globally unique namespace. module Data.Functor.Compose.Compat.Repl.Batteries ( module Data.Functor.Compose.Compat ) where import "this" Data.Functor.Compose.Compat base-compat-batteries-0.14.1/src/Data/Functor/Const/0000755000000000000000000000000007346545000020307 5ustar0000000000000000base-compat-batteries-0.14.1/src/Data/Functor/Const/Compat.hs0000644000000000000000000000025107346545000022064 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Data.Functor.Const.Compat ( module Base ) where import "base-compat" Data.Functor.Const.Compat as Base base-compat-batteries-0.14.1/src/Data/Functor/Const/Compat/Repl/0000755000000000000000000000000007346545000022434 5ustar0000000000000000base-compat-batteries-0.14.1/src/Data/Functor/Const/Compat/Repl/Batteries.hs0000644000000000000000000000046007346545000024712 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -Wno-dodgy-exports -Wno-unused-imports #-} -- | Reexports "Data.Functor.Const.Compat" -- from a globally unique namespace. module Data.Functor.Const.Compat.Repl.Batteries ( module Data.Functor.Const.Compat ) where import "this" Data.Functor.Const.Compat base-compat-batteries-0.14.1/src/Data/Functor/Contravariant/0000755000000000000000000000000007346545000022034 5ustar0000000000000000base-compat-batteries-0.14.1/src/Data/Functor/Contravariant/Compat.hs0000644000000000000000000000043707346545000023617 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Data.Functor.Contravariant.Compat ( module Base ) where #if MIN_VERSION_base(4,12,0) import "base-compat" Data.Functor.Contravariant.Compat as Base #else import "contravariant" Data.Functor.Contravariant as Base #endif base-compat-batteries-0.14.1/src/Data/Functor/Contravariant/Compat/Repl/0000755000000000000000000000000007346545000024161 5ustar0000000000000000base-compat-batteries-0.14.1/src/Data/Functor/Contravariant/Compat/Repl/Batteries.hs0000644000000000000000000000052007346545000026434 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -Wno-dodgy-exports -Wno-unused-imports #-} -- | Reexports "Data.Functor.Contravariant.Compat" -- from a globally unique namespace. module Data.Functor.Contravariant.Compat.Repl.Batteries ( module Data.Functor.Contravariant.Compat ) where import "this" Data.Functor.Contravariant.Compat base-compat-batteries-0.14.1/src/Data/Functor/Identity/0000755000000000000000000000000007346545000021012 5ustar0000000000000000base-compat-batteries-0.14.1/src/Data/Functor/Identity/Compat.hs0000644000000000000000000000025207346545000022570 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude, PackageImports #-} module Data.Functor.Identity.Compat ( module Base ) where import "base-compat" Data.Functor.Identity.Compat as Base base-compat-batteries-0.14.1/src/Data/Functor/Identity/Compat/Repl/0000755000000000000000000000000007346545000023137 5ustar0000000000000000base-compat-batteries-0.14.1/src/Data/Functor/Identity/Compat/Repl/Batteries.hs0000644000000000000000000000047407346545000025422 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -Wno-dodgy-exports -Wno-unused-imports #-} -- | Reexports "Data.Functor.Identity.Compat" -- from a globally unique namespace. module Data.Functor.Identity.Compat.Repl.Batteries ( module Data.Functor.Identity.Compat ) where import "this" Data.Functor.Identity.Compat base-compat-batteries-0.14.1/src/Data/Functor/Product/0000755000000000000000000000000007346545000020641 5ustar0000000000000000base-compat-batteries-0.14.1/src/Data/Functor/Product/Compat.hs0000644000000000000000000000025007346545000022415 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude, PackageImports #-} module Data.Functor.Product.Compat ( module Base ) where import "base-compat" Data.Functor.Product.Compat as Base base-compat-batteries-0.14.1/src/Data/Functor/Product/Compat/Repl/0000755000000000000000000000000007346545000022766 5ustar0000000000000000base-compat-batteries-0.14.1/src/Data/Functor/Product/Compat/Repl/Batteries.hs0000644000000000000000000000047007346545000025245 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -Wno-dodgy-exports -Wno-unused-imports #-} -- | Reexports "Data.Functor.Product.Compat" -- from a globally unique namespace. module Data.Functor.Product.Compat.Repl.Batteries ( module Data.Functor.Product.Compat ) where import "this" Data.Functor.Product.Compat base-compat-batteries-0.14.1/src/Data/Functor/Sum/0000755000000000000000000000000007346545000017765 5ustar0000000000000000base-compat-batteries-0.14.1/src/Data/Functor/Sum/Compat.hs0000644000000000000000000000024007346545000021540 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude, PackageImports #-} module Data.Functor.Sum.Compat ( module Base ) where import "base-compat" Data.Functor.Sum.Compat as Base base-compat-batteries-0.14.1/src/Data/Functor/Sum/Compat/Repl/0000755000000000000000000000000007346545000022112 5ustar0000000000000000base-compat-batteries-0.14.1/src/Data/Functor/Sum/Compat/Repl/Batteries.hs0000644000000000000000000000045007346545000024367 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -Wno-dodgy-exports -Wno-unused-imports #-} -- | Reexports "Data.Functor.Sum.Compat" -- from a globally unique namespace. module Data.Functor.Sum.Compat.Repl.Batteries ( module Data.Functor.Sum.Compat ) where import "this" Data.Functor.Sum.Compat base-compat-batteries-0.14.1/src/Data/IORef/0000755000000000000000000000000007346545000016545 5ustar0000000000000000base-compat-batteries-0.14.1/src/Data/IORef/Compat.hs0000644000000000000000000000023107346545000020320 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Data.IORef.Compat ( module Base ) where import "base-compat" Data.IORef.Compat as Base base-compat-batteries-0.14.1/src/Data/IORef/Compat/Repl/0000755000000000000000000000000007346545000020672 5ustar0000000000000000base-compat-batteries-0.14.1/src/Data/IORef/Compat/Repl/Batteries.hs0000644000000000000000000000042007346545000023144 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -Wno-dodgy-exports -Wno-unused-imports #-} -- | Reexports "Data.IORef.Compat" -- from a globally unique namespace. module Data.IORef.Compat.Repl.Batteries ( module Data.IORef.Compat ) where import "this" Data.IORef.Compat base-compat-batteries-0.14.1/src/Data/List/0000755000000000000000000000000007346545000016514 5ustar0000000000000000base-compat-batteries-0.14.1/src/Data/List/Compat.hs0000644000000000000000000000022707346545000020274 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Data.List.Compat ( module Base ) where import "base-compat" Data.List.Compat as Base base-compat-batteries-0.14.1/src/Data/List/Compat/Repl/0000755000000000000000000000000007346545000020641 5ustar0000000000000000base-compat-batteries-0.14.1/src/Data/List/Compat/Repl/Batteries.hs0000644000000000000000000000041407346545000023116 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -Wno-dodgy-exports -Wno-unused-imports #-} -- | Reexports "Data.List.Compat" -- from a globally unique namespace. module Data.List.Compat.Repl.Batteries ( module Data.List.Compat ) where import "this" Data.List.Compat base-compat-batteries-0.14.1/src/Data/List/NonEmpty/0000755000000000000000000000000007346545000020265 5ustar0000000000000000base-compat-batteries-0.14.1/src/Data/List/NonEmpty/Compat.hs0000644000000000000000000000231307346545000022043 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude, PackageImports #-} module Data.List.NonEmpty.Compat ( -- * The type of non-empty streams NonEmpty(..) -- * Non-empty stream transformations , map , intersperse , scanl , scanr , scanl1 , scanr1 , transpose , sortBy , sortWith -- * Basic functions , length , compareLength , head , tail , last , init , singleton , (<|), cons , uncons , unfoldr , sort , sortOn , reverse , inits , inits1 , tails , tails1 , append , appendList , prependList -- * 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 , permutations , permutations1 -- * 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 ) where import "base-compat" Data.List.NonEmpty.Compat base-compat-batteries-0.14.1/src/Data/List/NonEmpty/Compat/Repl/0000755000000000000000000000000007346545000022412 5ustar0000000000000000base-compat-batteries-0.14.1/src/Data/List/NonEmpty/Compat/Repl/Batteries.hs0000644000000000000000000000046007346545000024670 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -Wno-dodgy-exports -Wno-unused-imports #-} -- | Reexports "Data.List.NonEmpty.Compat" -- from a globally unique namespace. module Data.List.NonEmpty.Compat.Repl.Batteries ( module Data.List.NonEmpty.Compat ) where import "this" Data.List.NonEmpty.Compat base-compat-batteries-0.14.1/src/Data/Monoid/0000755000000000000000000000000007346545000017026 5ustar0000000000000000base-compat-batteries-0.14.1/src/Data/Monoid/Compat.hs0000644000000000000000000000031507346545000020604 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Data.Monoid.Compat ( module Base , (<>) ) where import "base-compat" Data.Monoid.Compat as Base hiding ((<>)) import Data.Semigroup ((<>)) base-compat-batteries-0.14.1/src/Data/Monoid/Compat/Repl/0000755000000000000000000000000007346545000021153 5ustar0000000000000000base-compat-batteries-0.14.1/src/Data/Monoid/Compat/Repl/Batteries.hs0000644000000000000000000000042407346545000023431 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -Wno-dodgy-exports -Wno-unused-imports #-} -- | Reexports "Data.Monoid.Compat" -- from a globally unique namespace. module Data.Monoid.Compat.Repl.Batteries ( module Data.Monoid.Compat ) where import "this" Data.Monoid.Compat base-compat-batteries-0.14.1/src/Data/Proxy/0000755000000000000000000000000007346545000016722 5ustar0000000000000000base-compat-batteries-0.14.1/src/Data/Proxy/Compat.hs0000644000000000000000000000022407346545000020477 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude, PackageImports #-} module Data.Proxy.Compat ( module Base ) where import "base-compat" Data.Proxy.Compat as Base base-compat-batteries-0.14.1/src/Data/Proxy/Compat/Repl/0000755000000000000000000000000007346545000021047 5ustar0000000000000000base-compat-batteries-0.14.1/src/Data/Proxy/Compat/Repl/Batteries.hs0000644000000000000000000000042007346545000023321 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -Wno-dodgy-exports -Wno-unused-imports #-} -- | Reexports "Data.Proxy.Compat" -- from a globally unique namespace. module Data.Proxy.Compat.Repl.Batteries ( module Data.Proxy.Compat ) where import "this" Data.Proxy.Compat base-compat-batteries-0.14.1/src/Data/Ratio/0000755000000000000000000000000007346545000016657 5ustar0000000000000000base-compat-batteries-0.14.1/src/Data/Ratio/Compat.hs0000644000000000000000000000023107346545000020432 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Data.Ratio.Compat ( module Base ) where import "base-compat" Data.Ratio.Compat as Base base-compat-batteries-0.14.1/src/Data/Ratio/Compat/Repl/0000755000000000000000000000000007346545000021004 5ustar0000000000000000base-compat-batteries-0.14.1/src/Data/Ratio/Compat/Repl/Batteries.hs0000644000000000000000000000042007346545000023256 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -Wno-dodgy-exports -Wno-unused-imports #-} -- | Reexports "Data.Ratio.Compat" -- from a globally unique namespace. module Data.Ratio.Compat.Repl.Batteries ( module Data.Ratio.Compat ) where import "this" Data.Ratio.Compat base-compat-batteries-0.14.1/src/Data/STRef/0000755000000000000000000000000007346545000016564 5ustar0000000000000000base-compat-batteries-0.14.1/src/Data/STRef/Compat.hs0000644000000000000000000000023107346545000020337 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Data.STRef.Compat ( module Base ) where import "base-compat" Data.STRef.Compat as Base base-compat-batteries-0.14.1/src/Data/STRef/Compat/Repl/0000755000000000000000000000000007346545000020711 5ustar0000000000000000base-compat-batteries-0.14.1/src/Data/STRef/Compat/Repl/Batteries.hs0000644000000000000000000000042007346545000023163 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -Wno-dodgy-exports -Wno-unused-imports #-} -- | Reexports "Data.STRef.Compat" -- from a globally unique namespace. module Data.STRef.Compat.Repl.Batteries ( module Data.STRef.Compat ) where import "this" Data.STRef.Compat base-compat-batteries-0.14.1/src/Data/Semigroup/0000755000000000000000000000000007346545000017553 5ustar0000000000000000base-compat-batteries-0.14.1/src/Data/Semigroup/Compat.hs0000644000000000000000000000106507346545000021334 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude, PackageImports #-} module Data.Semigroup.Compat ( 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 ) where import "base-compat" Data.Semigroup.Compat base-compat-batteries-0.14.1/src/Data/Semigroup/Compat/Repl/0000755000000000000000000000000007346545000021700 5ustar0000000000000000base-compat-batteries-0.14.1/src/Data/Semigroup/Compat/Repl/Batteries.hs0000644000000000000000000000044007346545000024154 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -Wno-dodgy-exports -Wno-unused-imports #-} -- | Reexports "Data.Semigroup.Compat" -- from a globally unique namespace. module Data.Semigroup.Compat.Repl.Batteries ( module Data.Semigroup.Compat ) where import "this" Data.Semigroup.Compat base-compat-batteries-0.14.1/src/Data/String/0000755000000000000000000000000007346545000017047 5ustar0000000000000000base-compat-batteries-0.14.1/src/Data/String/Compat.hs0000644000000000000000000000023307346545000020624 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Data.String.Compat ( module Base ) where import "base-compat" Data.String.Compat as Base base-compat-batteries-0.14.1/src/Data/String/Compat/Repl/0000755000000000000000000000000007346545000021174 5ustar0000000000000000base-compat-batteries-0.14.1/src/Data/String/Compat/Repl/Batteries.hs0000644000000000000000000000042407346545000023452 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -Wno-dodgy-exports -Wno-unused-imports #-} -- | Reexports "Data.String.Compat" -- from a globally unique namespace. module Data.String.Compat.Repl.Batteries ( module Data.String.Compat ) where import "this" Data.String.Compat base-compat-batteries-0.14.1/src/Data/Traversable/0000755000000000000000000000000007346545000020053 5ustar0000000000000000base-compat-batteries-0.14.1/src/Data/Traversable/Compat.hs0000644000000000000000000000024507346545000021633 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Data.Traversable.Compat ( module Base ) where import "base-compat" Data.Traversable.Compat as Base base-compat-batteries-0.14.1/src/Data/Traversable/Compat/Repl/0000755000000000000000000000000007346545000022200 5ustar0000000000000000base-compat-batteries-0.14.1/src/Data/Traversable/Compat/Repl/Batteries.hs0000644000000000000000000000045007346545000024455 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -Wno-dodgy-exports -Wno-unused-imports #-} -- | Reexports "Data.Traversable.Compat" -- from a globally unique namespace. module Data.Traversable.Compat.Repl.Batteries ( module Data.Traversable.Compat ) where import "this" Data.Traversable.Compat base-compat-batteries-0.14.1/src/Data/Tuple/0000755000000000000000000000000007346545000016672 5ustar0000000000000000base-compat-batteries-0.14.1/src/Data/Tuple/Compat.hs0000644000000000000000000000151707346545000020455 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} {-# LANGUAGE PatternSynonyms #-} -- | This uses the @OneTuple@ compatibility library to backport 'Solo' to old -- versions of GHC. module Data.Tuple.Compat ( #if MIN_VERSION_ghc_prim(0,10,0) Solo(MkSolo, Solo) #elif MIN_VERSION_ghc_prim(0,7,0) Solo(Solo) , pattern MkSolo #else Solo(MkSolo, Solo) #endif , getSolo , fst , snd , curry , uncurry , swap ) where #if MIN_VERSION_ghc_prim(0,10,0) import "base-compat" Data.Tuple.Compat #elif MIN_VERSION_ghc_prim(0,8,0) import "base-compat" Data.Tuple.Compat import "OneTuple" Data.Tuple.Solo (pattern MkSolo) #elif MIN_VERSION_ghc_prim(0,7,0) import "base-compat" Data.Tuple.Compat import "OneTuple" Data.Tuple.Solo (pattern MkSolo, getSolo) #else import "base" Data.Tuple import "OneTuple" Data.Tuple.Solo #endif base-compat-batteries-0.14.1/src/Data/Tuple/Compat/Repl/0000755000000000000000000000000007346545000021017 5ustar0000000000000000base-compat-batteries-0.14.1/src/Data/Tuple/Compat/Repl/Batteries.hs0000644000000000000000000000042007346545000023271 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -Wno-dodgy-exports -Wno-unused-imports #-} -- | Reexports "Data.Tuple.Compat" -- from a globally unique namespace. module Data.Tuple.Compat.Repl.Batteries ( module Data.Tuple.Compat ) where import "this" Data.Tuple.Compat base-compat-batteries-0.14.1/src/Data/Type/Coercion/0000755000000000000000000000000007346545000020263 5ustar0000000000000000base-compat-batteries-0.14.1/src/Data/Type/Coercion/Compat.hs0000644000000000000000000000024407346545000022042 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude, PackageImports #-} module Data.Type.Coercion.Compat ( module Base ) where import "base-compat" Data.Type.Coercion.Compat as Base base-compat-batteries-0.14.1/src/Data/Type/Coercion/Compat/Repl/0000755000000000000000000000000007346545000022410 5ustar0000000000000000base-compat-batteries-0.14.1/src/Data/Type/Coercion/Compat/Repl/Batteries.hs0000644000000000000000000000046007346545000024666 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -Wno-dodgy-exports -Wno-unused-imports #-} -- | Reexports "Data.Type.Coercion.Compat" -- from a globally unique namespace. module Data.Type.Coercion.Compat.Repl.Batteries ( module Data.Type.Coercion.Compat ) where import "this" Data.Type.Coercion.Compat base-compat-batteries-0.14.1/src/Data/Type/Equality/0000755000000000000000000000000007346545000020317 5ustar0000000000000000base-compat-batteries-0.14.1/src/Data/Type/Equality/Compat.hs0000644000000000000000000000105407346545000022076 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} {-# LANGUAGE Trustworthy #-} {-# LANGUAGE ExplicitNamespaces #-} module Data.Type.Equality.Compat ( -- * The equality types (:~:)(..), type (~~), (:~~:)(..), -- * Working with equality sym, trans, castWith, gcastWith, apply, inner, outer, -- * Inferring equality from other types TestEquality(..), -- * Boolean type-level equality type (==), ) where import "base" Data.Type.Equality #if !MIN_VERSION_base(4,10,0) import "type-equality" Data.Type.Equality.Hetero #endif base-compat-batteries-0.14.1/src/Data/Type/Equality/Compat/Repl/0000755000000000000000000000000007346545000022444 5ustar0000000000000000base-compat-batteries-0.14.1/src/Data/Type/Equality/Compat/Repl/Batteries.hs0000644000000000000000000000046007346545000024722 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -Wno-dodgy-exports -Wno-unused-imports #-} -- | Reexports "Data.Type.Equality.Compat" -- from a globally unique namespace. module Data.Type.Equality.Compat.Repl.Batteries ( module Data.Type.Equality.Compat ) where import "this" Data.Type.Equality.Compat base-compat-batteries-0.14.1/src/Data/Typeable/0000755000000000000000000000000007346545000017346 5ustar0000000000000000base-compat-batteries-0.14.1/src/Data/Typeable/Compat.hs0000644000000000000000000000023707346545000021127 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Data.Typeable.Compat ( module Base ) where import "base-compat" Data.Typeable.Compat as Base base-compat-batteries-0.14.1/src/Data/Typeable/Compat/Repl/0000755000000000000000000000000007346545000021473 5ustar0000000000000000base-compat-batteries-0.14.1/src/Data/Typeable/Compat/Repl/Batteries.hs0000644000000000000000000000043407346545000023752 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -Wno-dodgy-exports -Wno-unused-imports #-} -- | Reexports "Data.Typeable.Compat" -- from a globally unique namespace. module Data.Typeable.Compat.Repl.Batteries ( module Data.Typeable.Compat ) where import "this" Data.Typeable.Compat base-compat-batteries-0.14.1/src/Data/Version/0000755000000000000000000000000007346545000017226 5ustar0000000000000000base-compat-batteries-0.14.1/src/Data/Version/Compat.hs0000644000000000000000000000023507346545000021005 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Data.Version.Compat ( module Base ) where import "base-compat" Data.Version.Compat as Base base-compat-batteries-0.14.1/src/Data/Version/Compat/Repl/0000755000000000000000000000000007346545000021353 5ustar0000000000000000base-compat-batteries-0.14.1/src/Data/Version/Compat/Repl/Batteries.hs0000644000000000000000000000043007346545000023626 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -Wno-dodgy-exports -Wno-unused-imports #-} -- | Reexports "Data.Version.Compat" -- from a globally unique namespace. module Data.Version.Compat.Repl.Batteries ( module Data.Version.Compat ) where import "this" Data.Version.Compat base-compat-batteries-0.14.1/src/Data/Void/0000755000000000000000000000000007346545000016502 5ustar0000000000000000base-compat-batteries-0.14.1/src/Data/Void/Compat.hs0000644000000000000000000000023607346545000020262 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude, PackageImports #-} module Data.Void.Compat ( Void , absurd , vacuous ) where import "base-compat" Data.Void.Compat as Base base-compat-batteries-0.14.1/src/Data/Void/Compat/Repl/0000755000000000000000000000000007346545000020627 5ustar0000000000000000base-compat-batteries-0.14.1/src/Data/Void/Compat/Repl/Batteries.hs0000644000000000000000000000041407346545000023104 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -Wno-dodgy-exports -Wno-unused-imports #-} -- | Reexports "Data.Void.Compat" -- from a globally unique namespace. module Data.Void.Compat.Repl.Batteries ( module Data.Void.Compat ) where import "this" Data.Void.Compat base-compat-batteries-0.14.1/src/Data/Word/0000755000000000000000000000000007346545000016514 5ustar0000000000000000base-compat-batteries-0.14.1/src/Data/Word/Compat.hs0000644000000000000000000000022707346545000020274 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Data.Word.Compat ( module Base ) where import "base-compat" Data.Word.Compat as Base base-compat-batteries-0.14.1/src/Data/Word/Compat/Repl/0000755000000000000000000000000007346545000020641 5ustar0000000000000000base-compat-batteries-0.14.1/src/Data/Word/Compat/Repl/Batteries.hs0000644000000000000000000000041407346545000023116 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -Wno-dodgy-exports -Wno-unused-imports #-} -- | Reexports "Data.Word.Compat" -- from a globally unique namespace. module Data.Word.Compat.Repl.Batteries ( module Data.Word.Compat ) where import "this" Data.Word.Compat base-compat-batteries-0.14.1/src/Debug/Trace/0000755000000000000000000000000007346545000017014 5ustar0000000000000000base-compat-batteries-0.14.1/src/Debug/Trace/Compat.hs0000644000000000000000000000023307346545000020571 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Debug.Trace.Compat ( module Base ) where import "base-compat" Debug.Trace.Compat as Base base-compat-batteries-0.14.1/src/Debug/Trace/Compat/Repl/0000755000000000000000000000000007346545000021141 5ustar0000000000000000base-compat-batteries-0.14.1/src/Debug/Trace/Compat/Repl/Batteries.hs0000644000000000000000000000042407346545000023417 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -Wno-dodgy-exports -Wno-unused-imports #-} -- | Reexports "Debug.Trace.Compat" -- from a globally unique namespace. module Debug.Trace.Compat.Repl.Batteries ( module Debug.Trace.Compat ) where import "this" Debug.Trace.Compat base-compat-batteries-0.14.1/src/Foreign/0000755000000000000000000000000007346545000016321 5ustar0000000000000000base-compat-batteries-0.14.1/src/Foreign/Compat.hs0000644000000000000000000000022307346545000020075 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Foreign.Compat ( module Base ) where import "base-compat" Foreign.Compat as Base base-compat-batteries-0.14.1/src/Foreign/Compat/Repl/0000755000000000000000000000000007346545000020446 5ustar0000000000000000base-compat-batteries-0.14.1/src/Foreign/Compat/Repl/Batteries.hs0000644000000000000000000000040407346545000022722 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -Wno-dodgy-exports -Wno-unused-imports #-} -- | Reexports "Foreign.Compat" -- from a globally unique namespace. module Foreign.Compat.Repl.Batteries ( module Foreign.Compat ) where import "this" Foreign.Compat base-compat-batteries-0.14.1/src/Foreign/ForeignPtr/0000755000000000000000000000000007346545000020400 5ustar0000000000000000base-compat-batteries-0.14.1/src/Foreign/ForeignPtr/Compat.hs0000644000000000000000000000025107346545000022155 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Foreign.ForeignPtr.Compat ( module Base ) where import "base-compat" Foreign.ForeignPtr.Compat as Base base-compat-batteries-0.14.1/src/Foreign/ForeignPtr/Compat/Repl/0000755000000000000000000000000007346545000022525 5ustar0000000000000000base-compat-batteries-0.14.1/src/Foreign/ForeignPtr/Compat/Repl/Batteries.hs0000644000000000000000000000046007346545000025003 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -Wno-dodgy-exports -Wno-unused-imports #-} -- | Reexports "Foreign.ForeignPtr.Compat" -- from a globally unique namespace. module Foreign.ForeignPtr.Compat.Repl.Batteries ( module Foreign.ForeignPtr.Compat ) where import "this" Foreign.ForeignPtr.Compat base-compat-batteries-0.14.1/src/Foreign/ForeignPtr/Safe/0000755000000000000000000000000007346545000021256 5ustar0000000000000000base-compat-batteries-0.14.1/src/Foreign/ForeignPtr/Safe/Compat.hs0000644000000000000000000000026307346545000023036 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Foreign.ForeignPtr.Safe.Compat ( module Base ) where import "base-compat" Foreign.ForeignPtr.Safe.Compat as Base base-compat-batteries-0.14.1/src/Foreign/ForeignPtr/Safe/Compat/Repl/0000755000000000000000000000000007346545000023403 5ustar0000000000000000base-compat-batteries-0.14.1/src/Foreign/ForeignPtr/Safe/Compat/Repl/Batteries.hs0000644000000000000000000000050407346545000025660 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -Wno-dodgy-exports -Wno-unused-imports #-} -- | Reexports "Foreign.ForeignPtr.Safe.Compat" -- from a globally unique namespace. module Foreign.ForeignPtr.Safe.Compat.Repl.Batteries ( module Foreign.ForeignPtr.Safe.Compat ) where import "this" Foreign.ForeignPtr.Safe.Compat base-compat-batteries-0.14.1/src/Foreign/ForeignPtr/Unsafe/0000755000000000000000000000000007346545000021621 5ustar0000000000000000base-compat-batteries-0.14.1/src/Foreign/ForeignPtr/Unsafe/Compat.hs0000644000000000000000000000026707346545000023405 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Foreign.ForeignPtr.Unsafe.Compat ( module Base ) where import "base-compat" Foreign.ForeignPtr.Unsafe.Compat as Base base-compat-batteries-0.14.1/src/Foreign/ForeignPtr/Unsafe/Compat/Repl/0000755000000000000000000000000007346545000023746 5ustar0000000000000000base-compat-batteries-0.14.1/src/Foreign/ForeignPtr/Unsafe/Compat/Repl/Batteries.hs0000644000000000000000000000051407346545000026224 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -Wno-dodgy-exports -Wno-unused-imports #-} -- | Reexports "Foreign.ForeignPtr.Unsafe.Compat" -- from a globally unique namespace. module Foreign.ForeignPtr.Unsafe.Compat.Repl.Batteries ( module Foreign.ForeignPtr.Unsafe.Compat ) where import "this" Foreign.ForeignPtr.Unsafe.Compat base-compat-batteries-0.14.1/src/Foreign/Marshal/Alloc/0000755000000000000000000000000007346545000020742 5ustar0000000000000000base-compat-batteries-0.14.1/src/Foreign/Marshal/Alloc/Compat.hs0000644000000000000000000000025707346545000022525 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Foreign.Marshal.Alloc.Compat ( module Base ) where import "base-compat" Foreign.Marshal.Alloc.Compat as Base base-compat-batteries-0.14.1/src/Foreign/Marshal/Alloc/Compat/Repl/0000755000000000000000000000000007346545000023067 5ustar0000000000000000base-compat-batteries-0.14.1/src/Foreign/Marshal/Alloc/Compat/Repl/Batteries.hs0000644000000000000000000000047407346545000025352 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -Wno-dodgy-exports -Wno-unused-imports #-} -- | Reexports "Foreign.Marshal.Alloc.Compat" -- from a globally unique namespace. module Foreign.Marshal.Alloc.Compat.Repl.Batteries ( module Foreign.Marshal.Alloc.Compat ) where import "this" Foreign.Marshal.Alloc.Compat base-compat-batteries-0.14.1/src/Foreign/Marshal/Array/0000755000000000000000000000000007346545000020766 5ustar0000000000000000base-compat-batteries-0.14.1/src/Foreign/Marshal/Array/Compat.hs0000644000000000000000000000025707346545000022551 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Foreign.Marshal.Array.Compat ( module Base ) where import "base-compat" Foreign.Marshal.Array.Compat as Base base-compat-batteries-0.14.1/src/Foreign/Marshal/Array/Compat/Repl/0000755000000000000000000000000007346545000023113 5ustar0000000000000000base-compat-batteries-0.14.1/src/Foreign/Marshal/Array/Compat/Repl/Batteries.hs0000644000000000000000000000047407346545000025376 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -Wno-dodgy-exports -Wno-unused-imports #-} -- | Reexports "Foreign.Marshal.Array.Compat" -- from a globally unique namespace. module Foreign.Marshal.Array.Compat.Repl.Batteries ( module Foreign.Marshal.Array.Compat ) where import "this" Foreign.Marshal.Array.Compat base-compat-batteries-0.14.1/src/Foreign/Marshal/0000755000000000000000000000000007346545000017710 5ustar0000000000000000base-compat-batteries-0.14.1/src/Foreign/Marshal/Compat.hs0000644000000000000000000000024307346545000021466 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Foreign.Marshal.Compat ( module Base ) where import "base-compat" Foreign.Marshal.Compat as Base base-compat-batteries-0.14.1/src/Foreign/Marshal/Compat/Repl/0000755000000000000000000000000007346545000022035 5ustar0000000000000000base-compat-batteries-0.14.1/src/Foreign/Marshal/Compat/Repl/Batteries.hs0000644000000000000000000000044407346545000024315 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -Wno-dodgy-exports -Wno-unused-imports #-} -- | Reexports "Foreign.Marshal.Compat" -- from a globally unique namespace. module Foreign.Marshal.Compat.Repl.Batteries ( module Foreign.Marshal.Compat ) where import "this" Foreign.Marshal.Compat base-compat-batteries-0.14.1/src/Foreign/Marshal/Safe/0000755000000000000000000000000007346545000020566 5ustar0000000000000000base-compat-batteries-0.14.1/src/Foreign/Marshal/Safe/Compat.hs0000644000000000000000000000025507346545000022347 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Foreign.Marshal.Safe.Compat ( module Base ) where import "base-compat" Foreign.Marshal.Safe.Compat as Base base-compat-batteries-0.14.1/src/Foreign/Marshal/Safe/Compat/Repl/0000755000000000000000000000000007346545000022713 5ustar0000000000000000base-compat-batteries-0.14.1/src/Foreign/Marshal/Safe/Compat/Repl/Batteries.hs0000644000000000000000000000047007346545000025172 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -Wno-dodgy-exports -Wno-unused-imports #-} -- | Reexports "Foreign.Marshal.Safe.Compat" -- from a globally unique namespace. module Foreign.Marshal.Safe.Compat.Repl.Batteries ( module Foreign.Marshal.Safe.Compat ) where import "this" Foreign.Marshal.Safe.Compat base-compat-batteries-0.14.1/src/Foreign/Marshal/Unsafe/0000755000000000000000000000000007346545000021131 5ustar0000000000000000base-compat-batteries-0.14.1/src/Foreign/Marshal/Unsafe/Compat.hs0000644000000000000000000000026107346545000022707 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Foreign.Marshal.Unsafe.Compat ( module Base ) where import "base-compat" Foreign.Marshal.Unsafe.Compat as Base base-compat-batteries-0.14.1/src/Foreign/Marshal/Unsafe/Compat/Repl/0000755000000000000000000000000007346545000023256 5ustar0000000000000000base-compat-batteries-0.14.1/src/Foreign/Marshal/Unsafe/Compat/Repl/Batteries.hs0000644000000000000000000000050007346545000025527 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -Wno-dodgy-exports -Wno-unused-imports #-} -- | Reexports "Foreign.Marshal.Unsafe.Compat" -- from a globally unique namespace. module Foreign.Marshal.Unsafe.Compat.Repl.Batteries ( module Foreign.Marshal.Unsafe.Compat ) where import "this" Foreign.Marshal.Unsafe.Compat base-compat-batteries-0.14.1/src/Foreign/Marshal/Utils/0000755000000000000000000000000007346545000021010 5ustar0000000000000000base-compat-batteries-0.14.1/src/Foreign/Marshal/Utils/Compat.hs0000644000000000000000000000025707346545000022573 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Foreign.Marshal.Utils.Compat ( module Base ) where import "base-compat" Foreign.Marshal.Utils.Compat as Base base-compat-batteries-0.14.1/src/Foreign/Marshal/Utils/Compat/Repl/0000755000000000000000000000000007346545000023135 5ustar0000000000000000base-compat-batteries-0.14.1/src/Foreign/Marshal/Utils/Compat/Repl/Batteries.hs0000644000000000000000000000047407346545000025420 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -Wno-dodgy-exports -Wno-unused-imports #-} -- | Reexports "Foreign.Marshal.Utils.Compat" -- from a globally unique namespace. module Foreign.Marshal.Utils.Compat.Repl.Batteries ( module Foreign.Marshal.Utils.Compat ) where import "this" Foreign.Marshal.Utils.Compat base-compat-batteries-0.14.1/src/Numeric/0000755000000000000000000000000007346545000016332 5ustar0000000000000000base-compat-batteries-0.14.1/src/Numeric/Compat.hs0000644000000000000000000000022307346545000020106 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Numeric.Compat ( module Base ) where import "base-compat" Numeric.Compat as Base base-compat-batteries-0.14.1/src/Numeric/Compat/Repl/0000755000000000000000000000000007346545000020457 5ustar0000000000000000base-compat-batteries-0.14.1/src/Numeric/Compat/Repl/Batteries.hs0000644000000000000000000000040407346545000022733 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -Wno-dodgy-exports -Wno-unused-imports #-} -- | Reexports "Numeric.Compat" -- from a globally unique namespace. module Numeric.Compat.Repl.Batteries ( module Numeric.Compat ) where import "this" Numeric.Compat base-compat-batteries-0.14.1/src/Numeric/Natural/0000755000000000000000000000000007346545000017740 5ustar0000000000000000base-compat-batteries-0.14.1/src/Numeric/Natural/Compat.hs0000644000000000000000000000031707346545000021520 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude, PackageImports #-} {-# LANGUAGE Trustworthy #-} module Numeric.Natural.Compat ( module Base , minusNaturalMaybe ) where import "base-compat" Numeric.Natural.Compat as Base base-compat-batteries-0.14.1/src/Numeric/Natural/Compat/Repl/0000755000000000000000000000000007346545000022065 5ustar0000000000000000base-compat-batteries-0.14.1/src/Numeric/Natural/Compat/Repl/Batteries.hs0000644000000000000000000000044407346545000024345 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -Wno-dodgy-exports -Wno-unused-imports #-} -- | Reexports "Numeric.Natural.Compat" -- from a globally unique namespace. module Numeric.Natural.Compat.Repl.Batteries ( module Numeric.Natural.Compat ) where import "this" Numeric.Natural.Compat base-compat-batteries-0.14.1/src/Prelude/0000755000000000000000000000000007346545000016330 5ustar0000000000000000base-compat-batteries-0.14.1/src/Prelude/Compat.hs0000644000000000000000000000021607346545000020106 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude, PackageImports #-} module Prelude.Compat ( module Base ) where import "base-compat" Prelude.Compat as Base base-compat-batteries-0.14.1/src/Prelude/Compat/Repl/0000755000000000000000000000000007346545000020455 5ustar0000000000000000base-compat-batteries-0.14.1/src/Prelude/Compat/Repl/Batteries.hs0000644000000000000000000000040407346545000022731 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -Wno-dodgy-exports -Wno-unused-imports #-} -- | Reexports "Prelude.Compat" -- from a globally unique namespace. module Prelude.Compat.Repl.Batteries ( module Prelude.Compat ) where import "this" Prelude.Compat base-compat-batteries-0.14.1/src/System/Environment/0000755000000000000000000000000007346545000020520 5ustar0000000000000000base-compat-batteries-0.14.1/src/System/Environment/Compat.hs0000644000000000000000000000025107346545000022275 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module System.Environment.Compat ( module Base ) where import "base-compat" System.Environment.Compat as Base base-compat-batteries-0.14.1/src/System/Environment/Compat/Repl/0000755000000000000000000000000007346545000022645 5ustar0000000000000000base-compat-batteries-0.14.1/src/System/Environment/Compat/Repl/Batteries.hs0000644000000000000000000000046007346545000025123 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -Wno-dodgy-exports -Wno-unused-imports #-} -- | Reexports "System.Environment.Compat" -- from a globally unique namespace. module System.Environment.Compat.Repl.Batteries ( module System.Environment.Compat ) where import "this" System.Environment.Compat base-compat-batteries-0.14.1/src/System/Exit/0000755000000000000000000000000007346545000017125 5ustar0000000000000000base-compat-batteries-0.14.1/src/System/Exit/Compat.hs0000644000000000000000000000023307346545000020702 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module System.Exit.Compat ( module Base ) where import "base-compat" System.Exit.Compat as Base base-compat-batteries-0.14.1/src/System/Exit/Compat/Repl/0000755000000000000000000000000007346545000021252 5ustar0000000000000000base-compat-batteries-0.14.1/src/System/Exit/Compat/Repl/Batteries.hs0000644000000000000000000000042407346545000023530 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -Wno-dodgy-exports -Wno-unused-imports #-} -- | Reexports "System.Exit.Compat" -- from a globally unique namespace. module System.Exit.Compat.Repl.Batteries ( module System.Exit.Compat ) where import "this" System.Exit.Compat base-compat-batteries-0.14.1/src/System/IO/0000755000000000000000000000000007346545000016523 5ustar0000000000000000base-compat-batteries-0.14.1/src/System/IO/Compat.hs0000644000000000000000000000022707346545000020303 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module System.IO.Compat ( module Base ) where import "base-compat" System.IO.Compat as Base base-compat-batteries-0.14.1/src/System/IO/Compat/Repl/0000755000000000000000000000000007346545000020650 5ustar0000000000000000base-compat-batteries-0.14.1/src/System/IO/Compat/Repl/Batteries.hs0000644000000000000000000000041407346545000023125 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -Wno-dodgy-exports -Wno-unused-imports #-} -- | Reexports "System.IO.Compat" -- from a globally unique namespace. module System.IO.Compat.Repl.Batteries ( module System.IO.Compat ) where import "this" System.IO.Compat base-compat-batteries-0.14.1/src/System/IO/Error/0000755000000000000000000000000007346545000017614 5ustar0000000000000000base-compat-batteries-0.14.1/src/System/IO/Error/Compat.hs0000644000000000000000000000024307346545000021372 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module System.IO.Error.Compat ( module Base ) where import "base-compat" System.IO.Error.Compat as Base base-compat-batteries-0.14.1/src/System/IO/Error/Compat/Repl/0000755000000000000000000000000007346545000021741 5ustar0000000000000000base-compat-batteries-0.14.1/src/System/IO/Error/Compat/Repl/Batteries.hs0000644000000000000000000000044407346545000024221 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -Wno-dodgy-exports -Wno-unused-imports #-} -- | Reexports "System.IO.Error.Compat" -- from a globally unique namespace. module System.IO.Error.Compat.Repl.Batteries ( module System.IO.Error.Compat ) where import "this" System.IO.Error.Compat base-compat-batteries-0.14.1/src/System/IO/Unsafe/0000755000000000000000000000000007346545000017744 5ustar0000000000000000base-compat-batteries-0.14.1/src/System/IO/Unsafe/Compat.hs0000644000000000000000000000024507346545000021524 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module System.IO.Unsafe.Compat ( module Base ) where import "base-compat" System.IO.Unsafe.Compat as Base base-compat-batteries-0.14.1/src/System/IO/Unsafe/Compat/Repl/0000755000000000000000000000000007346545000022071 5ustar0000000000000000base-compat-batteries-0.14.1/src/System/IO/Unsafe/Compat/Repl/Batteries.hs0000644000000000000000000000045007346545000024346 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -Wno-dodgy-exports -Wno-unused-imports #-} -- | Reexports "System.IO.Unsafe.Compat" -- from a globally unique namespace. module System.IO.Unsafe.Compat.Repl.Batteries ( module System.IO.Unsafe.Compat ) where import "this" System.IO.Unsafe.Compat base-compat-batteries-0.14.1/src/Text/Read/0000755000000000000000000000000007346545000016527 5ustar0000000000000000base-compat-batteries-0.14.1/src/Text/Read/Compat.hs0000644000000000000000000000022707346545000020307 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Text.Read.Compat ( module Base ) where import "base-compat" Text.Read.Compat as Base base-compat-batteries-0.14.1/src/Text/Read/Compat/Repl/0000755000000000000000000000000007346545000020654 5ustar0000000000000000base-compat-batteries-0.14.1/src/Text/Read/Compat/Repl/Batteries.hs0000644000000000000000000000041407346545000023131 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -Wno-dodgy-exports -Wno-unused-imports #-} -- | Reexports "Text.Read.Compat" -- from a globally unique namespace. module Text.Read.Compat.Repl.Batteries ( module Text.Read.Compat ) where import "this" Text.Read.Compat base-compat-batteries-0.14.1/src/Text/Read/Lex/0000755000000000000000000000000007346545000017257 5ustar0000000000000000base-compat-batteries-0.14.1/src/Text/Read/Lex/Compat.hs0000644000000000000000000000023707346545000021040 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Text.Read.Lex.Compat ( module Base ) where import "base-compat" Text.Read.Lex.Compat as Base base-compat-batteries-0.14.1/src/Text/Read/Lex/Compat/Repl/0000755000000000000000000000000007346545000021404 5ustar0000000000000000base-compat-batteries-0.14.1/src/Text/Read/Lex/Compat/Repl/Batteries.hs0000644000000000000000000000043407346545000023663 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -Wno-dodgy-exports -Wno-unused-imports #-} -- | Reexports "Text.Read.Lex.Compat" -- from a globally unique namespace. module Text.Read.Lex.Compat.Repl.Batteries ( module Text.Read.Lex.Compat ) where import "this" Text.Read.Lex.Compat base-compat-batteries-0.14.1/src/Type/Reflection/0000755000000000000000000000000007346545000017743 5ustar0000000000000000base-compat-batteries-0.14.1/src/Type/Reflection/Compat.hs0000644000000000000000000000035307346545000021523 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Type.Reflection.Compat ( #if MIN_VERSION_base(4,10,0) module Base #endif ) where #if MIN_VERSION_base(4,10,0) import "base-compat" Type.Reflection.Compat as Base #endif base-compat-batteries-0.14.1/src/Type/Reflection/Compat/Repl/0000755000000000000000000000000007346545000022070 5ustar0000000000000000base-compat-batteries-0.14.1/src/Type/Reflection/Compat/Repl/Batteries.hs0000644000000000000000000000044407346545000024350 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -Wno-dodgy-exports -Wno-unused-imports #-} -- | Reexports "Type.Reflection.Compat" -- from a globally unique namespace. module Type.Reflection.Compat.Repl.Batteries ( module Type.Reflection.Compat ) where import "this" Type.Reflection.Compat base-compat-batteries-0.14.1/test/Control/Monad/0000755000000000000000000000000007346545000017576 5ustar0000000000000000base-compat-batteries-0.14.1/test/Control/Monad/CompatSpec.hs0000644000000000000000000000055607346545000022176 0ustar0000000000000000module Control.Monad.CompatSpec (main, spec) where import Test.Hspec import Control.Monad.Compat import Prelude () import Prelude.Compat main :: IO () main = hspec spec spec :: Spec spec = do describe "(<$!>)" $ do it "is a strict version of (<$>)" $ do not <$!> [True, False] `shouldBe` not <$> [True, False] base-compat-batteries-0.14.1/test/Data/Bits/0000755000000000000000000000000007346545000016672 5ustar0000000000000000base-compat-batteries-0.14.1/test/Data/Bits/CompatSpec.hs0000644000000000000000000000230007346545000021257 0ustar0000000000000000module Data.Bits.CompatSpec (main, spec) where import Test.Hspec import Data.Bits.Compat main :: IO () main = hspec spec spec :: Spec spec = do describe "bitDefault" $ it "sets the ith bit with all other bits clear" $ do bitDefault 0 `shouldBe` (1 :: Int) bitDefault 1 `shouldBe` (2 :: Int) bitDefault 2 `shouldBe` (4 :: Int) bitDefault 3 `shouldBe` (8 :: Int) describe "testBitDefault" $ it "returns True if the nth bit of the argument is 1" $ do testBitDefault (10 :: Int) 0 `shouldBe` False testBitDefault (10 :: Int) 1 `shouldBe` True testBitDefault (10 :: Int) 2 `shouldBe` False testBitDefault (10 :: Int) 3 `shouldBe` True describe "popCountDefault" $ it "returns the number of set bits in the argument" $ do popCountDefault (0 :: Int) `shouldBe` 0 popCountDefault (1 :: Int) `shouldBe` 1 popCountDefault (10 :: Int) `shouldBe` 2 describe "toIntegralSized" $ it "converts an Integral type to another as measured by bitSizeMaybe" $ do toIntegralSized (42 :: Integer) `shouldBe` (Just 42 :: Maybe Int) toIntegralSized (12345678901234567890 :: Integer) `shouldBe` (Nothing :: Maybe Int) base-compat-batteries-0.14.1/test/Data/Bool/0000755000000000000000000000000007346545000016664 5ustar0000000000000000base-compat-batteries-0.14.1/test/Data/Bool/CompatSpec.hs0000644000000000000000000000063007346545000021255 0ustar0000000000000000module Data.Bool.CompatSpec (main, spec) where import Test.Hspec import Data.Bool.Compat main :: IO () main = hspec spec spec :: Spec spec = do describe "bool" $ do it "evaluates to first parameter if condition is False" $ do bool "KO" "OK" False `shouldBe` "KO" it "evaluates to second parameter if condition is True" $ do bool "KO" "OK" True `shouldBe` "OK" base-compat-batteries-0.14.1/test/Data/Either/0000755000000000000000000000000007346545000017211 5ustar0000000000000000base-compat-batteries-0.14.1/test/Data/Either/CompatSpec.hs0000644000000000000000000000124107346545000021601 0ustar0000000000000000module Data.Either.CompatSpec (main, spec) where import Test.Hspec import Data.Either.Compat main :: IO () main = hspec spec spec :: Spec spec = do describe "isLeft" $ do it "returns True for a Left value" $ do isLeft (Left "23" :: Either String String) `shouldBe` True it "returns False for a Right value" $ do isLeft (Right "23" :: Either String String) `shouldBe` False describe "isRight" $ do it "returns False for a Left value" $ do isRight (Left "23" :: Either String String) `shouldBe` False it "returns True for a Right value" $ do isRight (Right "23" :: Either String String) `shouldBe` True base-compat-batteries-0.14.1/test/Data/Foldable/0000755000000000000000000000000007346545000017501 5ustar0000000000000000base-compat-batteries-0.14.1/test/Data/Foldable/CompatSpec.hs0000644000000000000000000000045707346545000022101 0ustar0000000000000000module Data.Foldable.CompatSpec (main, spec) where import Test.Hspec import Data.Foldable.Compat main :: IO () main = hspec spec spec :: Spec spec = do describe "maximumBy" $ do it "runs in constant space" $ do maximumBy compare [1..10000] `shouldBe` (10000 :: Int) base-compat-batteries-0.14.1/test/Data/Function/0000755000000000000000000000000007346545000017556 5ustar0000000000000000base-compat-batteries-0.14.1/test/Data/Function/CompatSpec.hs0000644000000000000000000000042307346545000022147 0ustar0000000000000000module Data.Function.CompatSpec (main, spec) where import Test.Hspec import Data.Function.Compat main :: IO () main = hspec spec spec :: Spec spec = do describe "&" $ do it "reverses function application" $ do (False & not) `shouldBe` True base-compat-batteries-0.14.1/test/Data/Functor/0000755000000000000000000000000007346545000017411 5ustar0000000000000000base-compat-batteries-0.14.1/test/Data/Functor/CompatSpec.hs0000644000000000000000000000064007346545000022003 0ustar0000000000000000module Data.Functor.CompatSpec (main, spec) where import Test.Hspec import Data.Functor.Compat main :: IO () main = hspec spec spec :: Spec spec = do describe "void" $ do it "discards computation result" $ do void (return 1 :: IO Int) `shouldReturn` () describe "$>" $ do it "is the same as flipped <$" $ do (Just 5 :: Maybe Int) $> 6 `shouldBe` (Just 6 :: Maybe Int) base-compat-batteries-0.14.1/test/Data/IORef/0000755000000000000000000000000007346545000016735 5ustar0000000000000000base-compat-batteries-0.14.1/test/Data/IORef/CompatSpec.hs0000644000000000000000000000122207346545000021324 0ustar0000000000000000module Data.IORef.CompatSpec (main, spec) where import Test.Hspec import Control.Monad import Data.IORef.Compat main :: IO () main = hspec spec spec :: Spec spec = do describe "modifyIORef'" $ it "mutates the contents of an IORef strictly" $ do ref <- newIORef 0 replicateM_ 1000000 $ modifyIORef' ref (+1) readIORef ref `shouldReturn` (1000000 :: Int) describe "atomicModifyIORef'" $ it "atomically modifies the contents of an IORef strictly" $ do ref <- newIORef 0 replicateM_ 1000000 . atomicModifyIORef' ref $ \n -> (n+1, ()) readIORef ref `shouldReturn` (1000000 :: Int) base-compat-batteries-0.14.1/test/Data/List/0000755000000000000000000000000007346545000016704 5ustar0000000000000000base-compat-batteries-0.14.1/test/Data/List/CompatSpec.hs0000644000000000000000000000306107346545000021276 0ustar0000000000000000module Data.List.CompatSpec (main, spec) where import Test.Hspec import Data.List.Compat data Asymmetric = A | B deriving Show instance Eq Asymmetric where A == _ = True B == _ = False main :: IO () main = hspec spec spec :: Spec spec = do describe "dropWhileEnd" $ do it "drops the largest suffix of a list in which a predicate holds for all elements" $ do dropWhileEnd (== ' ') "foo " `shouldBe` "foo" dropWhileEnd (== ' ') "foo bar" `shouldBe` "foo bar" describe "isSubsequenceOf" $ do it "returns True if the first list is a subsequence of the second list" $ do isSubsequenceOf "GHC" "The Glorious Haskell Compiler" `shouldBe` True isSubsequenceOf "JHC" "The Glorious Haskell Compiler" `shouldBe` False describe "nub" $ it "preserves the order of arguments to (==)" $ nub [A, B] `shouldBe` [A] describe "nubBy" $ it "preserves the order of arguments to the equality function" $ nubBy (<) "12" `shouldBe` "1" describe "sortOn" $ do it "sorts a list by comparing the results of a key function applied to each element" $ do sortOn (>='b') "cba" `shouldBe` "acb" describe "uncons" $ do it "decomposes a list into its head and tail" $ do uncons "" `shouldBe` Nothing uncons "12" `shouldBe` Just ('1', "2") describe "union" $ it "nubs arguments in the same order as (==)" $ do union [A] [A, B] `shouldBe` [A] describe "unionBy" $ it "nubs arguments in the same order as nubBy's equality function" $ do unionBy (<) "1" "21" `shouldBe` "11" base-compat-batteries-0.14.1/test/Data/Monoid/0000755000000000000000000000000007346545000017216 5ustar0000000000000000base-compat-batteries-0.14.1/test/Data/Monoid/CompatSpec.hs0000644000000000000000000000066307346545000021615 0ustar0000000000000000module Data.Monoid.CompatSpec (main, spec) where import Test.Hspec import Test.QuickCheck import Data.Monoid.Compat import Prelude () import Prelude.Compat (IO, String, ($)) main :: IO () main = hspec spec spec :: Spec spec = do describe "<>" $ do it "is an infix synonym for mappend" $ do property $ \xs ys -> do xs <> ys `shouldBe` (mappend xs ys :: String) base-compat-batteries-0.14.1/test/Data/STRef/0000755000000000000000000000000007346545000016754 5ustar0000000000000000base-compat-batteries-0.14.1/test/Data/STRef/CompatSpec.hs0000644000000000000000000000072007346545000021345 0ustar0000000000000000module Data.STRef.CompatSpec (main, spec) where import Test.Hspec import Control.Monad import Control.Monad.ST import Data.STRef.Compat main :: IO () main = hspec spec spec :: Spec spec = describe "modifySTRef'" $ it "should mutate the contents of an STRef strictly" $ shouldBe (1000000 :: Int) $ runST $ do ref <- newSTRef 0 replicateM_ 1000000 $ modifySTRef' ref (+1) readSTRef ref base-compat-batteries-0.14.1/test/Data/Version/0000755000000000000000000000000007346545000017416 5ustar0000000000000000base-compat-batteries-0.14.1/test/Data/Version/CompatSpec.hs0000644000000000000000000000040107346545000022003 0ustar0000000000000000module Data.Version.CompatSpec (spec) where import Test.Hspec import Data.Version.Compat spec :: Spec spec = do describe "makeVersion" $ it "constructs a tagless Version" $ makeVersion [1,2,3] `shouldBe` Version [1,2,3] [] base-compat-batteries-0.14.1/test/Data/Word/0000755000000000000000000000000007346545000016704 5ustar0000000000000000base-compat-batteries-0.14.1/test/Data/Word/CompatSpec.hs0000644000000000000000000000132107346545000021273 0ustar0000000000000000module Data.Word.CompatSpec (main, spec) where import Test.Hspec import Data.Word.Compat main :: IO () main = hspec spec spec :: Spec spec = do describe "byteSwap16" $ it "reverses the order of bytes in a Word16 value" $ do byteSwap16 0x1100 `shouldBe` 0x0011 byteSwap16 0x1010 `shouldBe` 0x1010 describe "byteSwap32" $ it "reverses the order of bytes in a Word32 value" $ do byteSwap32 0x11001010 `shouldBe` 0x10100011 byteSwap32 0x10101111 `shouldBe` 0x11111010 describe "byteSwap64" $ it "reverses the order of bytes in a Word64 value" $ do byteSwap64 0x1010111110101111 `shouldBe` 0x1111101011111010 byteSwap64 0x1100000000000011 `shouldBe` 0x1100000000000011 base-compat-batteries-0.14.1/test/Foreign/Marshal/Alloc/0000755000000000000000000000000007346545000021132 5ustar0000000000000000base-compat-batteries-0.14.1/test/Foreign/Marshal/Alloc/CompatSpec.hs0000644000000000000000000000064507346545000023531 0ustar0000000000000000module Foreign.Marshal.Alloc.CompatSpec (main, spec) where import Test.Hspec import Control.Exception import Foreign.Marshal.Alloc.Compat import Foreign.Storable main :: IO () main = hspec spec spec :: Spec spec = do describe "calloc" $ it "allocates memory with bytes of value zero" $ do bracket calloc free $ \ptr -> do peek ptr `shouldReturn` (0 :: Int) base-compat-batteries-0.14.1/test/Foreign/Marshal/Utils/0000755000000000000000000000000007346545000021200 5ustar0000000000000000base-compat-batteries-0.14.1/test/Foreign/Marshal/Utils/CompatSpec.hs0000644000000000000000000000073207346545000023574 0ustar0000000000000000module Foreign.Marshal.Utils.CompatSpec (main, spec) where import Test.Hspec import Foreign.Marshal.Alloc import Foreign.Marshal.Utils.Compat import Foreign.Ptr import Foreign.Storable main :: IO () main = hspec spec spec :: Spec spec = do describe "fillBytes" $ it "fills a given number of bytes in memory area with a byte value" $ do alloca $ \ptr -> do let _ = ptr :: Ptr Int fillBytes ptr 0 $ sizeOf ptr peek ptr `shouldReturn` 0 base-compat-batteries-0.14.1/test/Numeric/0000755000000000000000000000000007346545000016522 5ustar0000000000000000base-compat-batteries-0.14.1/test/Numeric/CompatSpec.hs0000644000000000000000000000417407346545000021122 0ustar0000000000000000module Numeric.CompatSpec (main, spec) where import Test.Hspec import Numeric.Compat main :: IO () main = hspec spec spec :: Spec spec = do describe "showFFloatAlt" $ do it "shows a RealFloat value, always using decimal notation" $ showFFloatAlt Nothing (12 :: Double) "" `shouldBe` "12.0" it "allows to specify the number of decimal places" $ showFFloatAlt (Just 4) (12 :: Double) "" `shouldBe` "12.0000" describe "showGFloatAlt" $ do it "shows a RealFloat value, using decimal notation if the absolute value lies between 0.1 and 9,999,999" $ showGFloatAlt Nothing (12 :: Double) "" `shouldBe` "12.0" it "shows a RealFloat value, using decimal notation and specifying the number of decimal places" $ showGFloatAlt (Just 4) (12 :: Double) "" `shouldBe` "12.0000" it "shows a RealFloat value, using scientific notation if the absolute value falls outside of the range" $ showGFloatAlt Nothing (1234567890 :: Double) "" `shouldBe` "1.23456789e9" it "shows a RealFloat value, using scientific notation and specifying the number of decimal places" $ showGFloatAlt (Just 4) (1234567890 :: Double) "" `shouldBe` "1.2346e9" describe "readBin" $ do it "parses an entirely binary Integer" $ readBinInteger "00000111" `shouldBe` [(7, "")] it "does not parse a non-binary Integer" $ readBinInteger "-24" `shouldBe` [] it "parses the binary prefix of an Integer" $ readBinInteger "1011784372843778438743" `shouldBe` [(11,"784372843778438743")] describe "showBin" $ do it "shows small Ints in base 2" $ map (\ x -> showBinInt x "") [1..32] `shouldBe` [ "1","10","11","100","101","110","111","1000","1001","1010","1011","1100","1101","1110","1111" , "10000","10001","10010","10011","10100","10101","10110","10111","11000" , "11001","11010","11011","11100","11101","11110","11111","100000" ] it "shows a large Int in base 2" $ showBinInt 241324784 "" `shouldBe` "1110011000100101001011110000" where readBinInteger :: ReadS Integer readBinInteger = readBin showBinInt :: Int -> ShowS showBinInt = showBin base-compat-batteries-0.14.1/test/Prelude/0000755000000000000000000000000007346545000016520 5ustar0000000000000000base-compat-batteries-0.14.1/test/Prelude/CompatSpec.hs0000644000000000000000000000061607346545000021115 0ustar0000000000000000module Prelude.CompatSpec (main, spec) where import Test.Hspec import Prelude () import Prelude.Compat main :: IO () main = hspec spec spec :: Spec spec = do describe "($!)" $ do it "is infixr 0" $ do -- #54 (succ $! succ $! 0) `shouldBe` (2 :: Int) (succ $! 2 *** 2) `shouldBe` (5 :: Int) infixr 1 *** (***) :: Int -> Int -> Int (***) = (*) base-compat-batteries-0.14.1/test/0000755000000000000000000000000007346545000015120 5ustar0000000000000000base-compat-batteries-0.14.1/test/SafeHaskellSpec.hs0000644000000000000000000000416407346545000020456 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE Safe #-} module SafeHaskellSpec (main, spec) where import TestHspecTrustworthy -- The following modules should not be Unsafe (#56): import Control.Concurrent.Compat () import Control.Concurrent.MVar.Compat () import Control.Exception.Compat () import Control.Monad.Compat () import Control.Monad.Fail.Compat () import Control.Monad.IO.Class.Compat () import Data.Bifoldable.Compat () import Data.Bifoldable1.Compat () import Data.Bifunctor.Compat () import Data.Bitraversable.Compat () import Data.Bits.Compat () import Data.Bool.Compat () import Data.Complex.Compat () import Data.Either.Compat () import Data.Foldable.Compat () import Data.Foldable1.Compat () import Data.Function.Compat () import Data.Functor.Compat () import Data.Functor.Compose.Compat () import Data.Functor.Const.Compat () import Data.Functor.Contravariant.Compat () import Data.Functor.Identity.Compat () import Data.Functor.Product.Compat () import Data.Functor.Sum.Compat () import Data.IORef.Compat () import Data.List.Compat () import Data.List.NonEmpty.Compat () import Data.Monoid.Compat () import Data.Proxy.Compat () import Data.Ratio.Compat () import Data.Semigroup.Compat () import Data.STRef.Compat () import Data.String.Compat () import Data.Traversable.Compat () import Data.Tuple.Compat () import Data.Typeable.Compat () import Data.Type.Coercion.Compat () import Data.Type.Equality.Compat () import Data.Version.Compat () import Data.Void.Compat () import Data.Word.Compat () import Foreign.Compat () import Foreign.ForeignPtr.Compat () import Foreign.ForeignPtr.Safe.Compat () import Foreign.Marshal.Alloc.Compat () import Foreign.Marshal.Array.Compat () import Foreign.Marshal.Compat () import Foreign.Marshal.Safe.Compat () import Foreign.Marshal.Utils.Compat () import Numeric.Compat () import Numeric.Natural.Compat () import Prelude.Compat import System.Environment.Compat () import System.Exit.Compat () import System.IO.Compat () import System.IO.Error.Compat () import Text.Read.Compat () import Text.Read.Lex.Compat () import Type.Reflection.Compat () main :: IO () main = hspec spec spec :: Spec spec = pure () base-compat-batteries-0.14.1/test/Spec.hs0000644000000000000000000000005407346545000016345 0ustar0000000000000000{-# OPTIONS_GHC -F -pgmF hspec-discover #-} base-compat-batteries-0.14.1/test/System/Environment/0000755000000000000000000000000007346545000020710 5ustar0000000000000000base-compat-batteries-0.14.1/test/System/Environment/CompatSpec.hs0000644000000000000000000000736007346545000023310 0ustar0000000000000000module System.Environment.CompatSpec (main, spec) where import Test.Hspec import Test.QuickCheck import qualified Control.Exception as E import GHC.IO.Exception (IOErrorType (InvalidArgument)) import System.Environment.Compat import System.IO.Error main :: IO () main = hspec spec withEnv :: String -> String -> IO a -> IO a withEnv k v action = E.bracket save restore $ \_ -> do setEnv k v >> action where save = lookupEnv k restore = maybe (unsetEnv k) (setEnv k) withoutEnv :: String -> IO a -> IO a withoutEnv k action = E.bracket save restore $ \_ -> do unsetEnv k >> action where save = lookupEnv k restore = maybe (unsetEnv k) (setEnv k) spec :: Spec spec = do describe "lookupEnv" $ do it "returns specified environment variable" $ do withEnv "FOOBAR" "23" $ do lookupEnv "FOOBAR" `shouldReturn` Just "23" it "returns Nothing if specified environment variable is not set" $ do withoutEnv "FOOBAR" $ do lookupEnv "FOOBAR" `shouldReturn` Nothing describe "unsetEnv" $ do it "removes specified environment variable" $ do setEnv "FOO" "foo" unsetEnv "FOO" getEnv "FOO" `shouldThrow` isDoesNotExistError it "does nothing if specified environment variable is not set" $ do unsetEnv "BAR" unsetEnv "BAR" getEnv "BAR" `shouldThrow` isDoesNotExistError it "throws an exception if key is the empty string" $ do unsetEnv "" `shouldThrow` (== InvalidArgument) . ioeGetErrorType it "throws an exception if key contains '='" $ do unsetEnv "some=key" `shouldThrow` (== InvalidArgument) . ioeGetErrorType it "works for arbitrary keys" $ property $ \k -> ('\NUL' `notElem` k && '=' `notElem` k && (not . null) k) ==> do setEnv k "foo" unsetEnv k getEnv k `shouldThrow` isDoesNotExistError describe "setEnv" $ do it "sets specified environment variable to given value" $ do unsetEnv "FOO" setEnv "FOO" "foo" getEnv "FOO" `shouldReturn` "foo" it "resets specified environment variable, if it is already set" $ do unsetEnv "FOO" setEnv "FOO" "foo" setEnv "FOO" "bar" getEnv "FOO" `shouldReturn` "bar" it "removes specified environment variable when value is the empty string" $ do setEnv "FOO" "foo" setEnv "FOO" "" getEnv "FOO" `shouldThrow` isDoesNotExistError it "removes specified environment variable when first character of value is NUL" $ do setEnv "FOO" "foo" setEnv "FOO" "\NULfoo" getEnv "FOO" `shouldThrow` isDoesNotExistError it "truncates value at NUL character" $ do unsetEnv "FOO" setEnv "FOO" "foo\NULbar" getEnv "FOO" `shouldReturn` "foo" it "truncates key at NUL character" $ do unsetEnv "FOO" setEnv "FOO\NULBAR" "foo" getEnv "FOO" `shouldReturn` "foo" it "works for unicode" $ do unsetEnv "FOO" setEnv "FOO" "foo-\955-bar" getEnv "FOO" `shouldReturn` "foo-\955-bar" it "works for arbitrary values" $ property $ \v -> ('\NUL' `notElem` v && (not . null) v) ==> do setEnv "FOO" v getEnv "FOO" `shouldReturn` v it "works for unicode keys" $ do setEnv "foo-\955-bar" "foo" getEnv "foo-\955-bar" `shouldReturn` "foo" it "throws an exception if key is the empty string" $ do setEnv "" "foo" `shouldThrow` (== InvalidArgument) . ioeGetErrorType it "throws an exception if key contains '='" $ do setEnv "some=key" "foo" `shouldThrow` (== InvalidArgument) . ioeGetErrorType it "works for arbitrary keys" $ property $ \k -> ('\NUL' `notElem` k && '=' `notElem` k && (not . null) k) ==> do setEnv k "foo" getEnv k `shouldReturn` "foo" base-compat-batteries-0.14.1/test/TestHspecTrustworthy.hs0000644000000000000000000000023707346545000021677 0ustar0000000000000000{-# LANGUAGE Trustworthy #-} -- | Reexports "Test.Hspec" from a @Trustworthy@ module. module TestHspecTrustworthy (module Test.Hspec) where import Test.Hspec base-compat-batteries-0.14.1/test/Text/Read/0000755000000000000000000000000007346545000016717 5ustar0000000000000000base-compat-batteries-0.14.1/test/Text/Read/CompatSpec.hs0000644000000000000000000000117607346545000021316 0ustar0000000000000000module Text.Read.CompatSpec (main, spec) where import Test.Hspec import Text.Read.Compat main :: IO () main = hspec spec spec :: Spec spec = do describe "readMaybe" $ do it "parses a value" $ do readMaybe "23" `shouldBe` (Just 23 :: Maybe Int) it "returns Nothing if parsing fails" $ do readMaybe "xx" `shouldBe` (Nothing :: Maybe Int) describe "readEither" $ do it "parses a value" $ do readEither "23" `shouldBe` (Right 23 :: Either String Int) it "returns Left if parsing fails" $ do readEither "xx" `shouldBe` (Left "Prelude.read: no parse" :: Either String Int)