base-compat-batteries-0.13.1/0000755000000000000000000000000007346545000014140 5ustar0000000000000000base-compat-batteries-0.13.1/CHANGES.markdown0000644000000000000000000001450507346545000016761 0ustar0000000000000000## 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.13.1/LICENSE0000644000000000000000000000214007346545000015142 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.13.1/README.markdown0000644000000000000000000000311407346545000016640 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.13.1/Setup.lhs0000644000000000000000000000011407346545000015744 0ustar0000000000000000#!/usr/bin/env runhaskell > import Distribution.Simple > main = defaultMain base-compat-batteries-0.13.1/base-compat-batteries.cabal0000644000000000000000000002251407346545000021303 0ustar0000000000000000name: base-compat-batteries version: 0.13.1 license: MIT license-file: LICENSE copyright: (c) 2012-2018 Simon Hengel, (c) 2014-2018 João Cristóvão, (c) 2015-2018 Ryan Scott author: Simon Hengel , João Cristóvão , Ryan Scott maintainer: Simon Hengel , João Cristóvão , Ryan Scott build-type: Simple cabal-version: >= 1.10 category: Compatibility synopsis: 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 == 7.0.4 , GHC == 7.2.2 , GHC == 7.4.2 , GHC == 7.6.3 , GHC == 7.8.4 , GHC == 7.10.3 , GHC == 8.0.2 , GHC == 8.2.2 , GHC == 8.4.4 , GHC == 8.6.5 , GHC == 8.8.4 , GHC == 8.10.7 , GHC == 9.0.2 , GHC == 9.2.7 , GHC == 9.4.5 , GHC == 9.6.2 , GHC == 9.8.1 source-repository head type: git location: https://github.com/haskell-compat/base-compat subdir: base-compat-batteries library ghc-options: -Wall default-language: Haskell2010 build-depends: base >= 4.3 && < 5, base-compat == 0.13.1, ghc-prim if !impl(ghc >= 7.8) build-depends: tagged >= 0.8.5 && < 0.9 if !impl(ghc >= 7.10) build-depends: nats >= 1.1.2 && < 1.2, void >= 0.7.2 && < 0.8 if !impl(ghc >= 8.0) build-depends: fail >= 4.9.0.0 && < 4.10, semigroups >= 0.18.4 && < 0.21, transformers >= 0.2 && < 0.7, transformers-compat >= 0.6 && < 0.8 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: -fno-warn-duplicate-exports if impl(ghc >= 7.10) ghc-options: -fno-warn-trustworthy-safe hs-source-dirs: src exposed-modules: Control.Concurrent.Compat Control.Concurrent.MVar.Compat Control.Exception.Compat Control.Monad.Compat Control.Monad.Fail.Compat Control.Monad.IO.Class.Compat Control.Monad.ST.Lazy.Unsafe.Compat Control.Monad.ST.Unsafe.Compat Data.Bifoldable.Compat Data.Bifoldable1.Compat Data.Bifunctor.Compat Data.Bitraversable.Compat Data.Bits.Compat Data.Bool.Compat Data.Complex.Compat Data.Either.Compat Data.Foldable.Compat Data.Foldable1.Compat Data.Function.Compat Data.Functor.Compat Data.Functor.Compose.Compat Data.Functor.Const.Compat Data.Functor.Contravariant.Compat Data.Functor.Identity.Compat Data.Functor.Product.Compat Data.Functor.Sum.Compat Data.IORef.Compat Data.List.Compat Data.List.NonEmpty.Compat Data.Monoid.Compat Data.Proxy.Compat Data.Ratio.Compat Data.Semigroup.Compat Data.STRef.Compat Data.String.Compat Data.Traversable.Compat Data.Tuple.Compat Data.Typeable.Compat Data.Type.Coercion.Compat Data.Type.Equality.Compat Data.Version.Compat Data.Void.Compat Data.Word.Compat Debug.Trace.Compat Foreign.Compat Foreign.ForeignPtr.Compat Foreign.ForeignPtr.Safe.Compat Foreign.ForeignPtr.Unsafe.Compat Foreign.Marshal.Alloc.Compat Foreign.Marshal.Array.Compat Foreign.Marshal.Compat Foreign.Marshal.Safe.Compat Foreign.Marshal.Unsafe.Compat Foreign.Marshal.Utils.Compat Numeric.Compat Numeric.Natural.Compat Prelude.Compat System.Environment.Compat System.Exit.Compat System.IO.Compat System.IO.Error.Compat System.IO.Unsafe.Compat Text.Read.Compat Text.Read.Lex.Compat Type.Reflection.Compat Control.Concurrent.Compat.Repl.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.3 && < 5 , base-compat-batteries , hspec >= 1.8 , QuickCheck build-tool-depends: hspec-discover:hspec-discover >= 1.8 base-compat-batteries-0.13.1/src/Control/Concurrent/0000755000000000000000000000000007346545000020471 5ustar0000000000000000base-compat-batteries-0.13.1/src/Control/Concurrent/Compat.hs0000644000000000000000000000025107346545000022246 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Control.Concurrent.Compat ( module Base ) where import "base-compat" Control.Concurrent.Compat as Base base-compat-batteries-0.13.1/src/Control/Concurrent/Compat/Repl/0000755000000000000000000000000007346545000022616 5ustar0000000000000000base-compat-batteries-0.13.1/src/Control/Concurrent/Compat/Repl/Batteries.hs0000644000000000000000000000047207346545000025077 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Control.Concurrent.Compat" -- from a globally unique namespace. module Control.Concurrent.Compat.Repl.Batteries ( module Control.Concurrent.Compat ) where import "this" Control.Concurrent.Compat base-compat-batteries-0.13.1/src/Control/Concurrent/MVar/0000755000000000000000000000000007346545000021336 5ustar0000000000000000base-compat-batteries-0.13.1/src/Control/Concurrent/MVar/Compat.hs0000644000000000000000000000026307346545000023116 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.13.1/src/Control/Concurrent/MVar/Compat/Repl/0000755000000000000000000000000007346545000023463 5ustar0000000000000000base-compat-batteries-0.13.1/src/Control/Concurrent/MVar/Compat/Repl/Batteries.hs0000644000000000000000000000051607346545000025743 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Control.Concurrent.MVar.Compat" -- from a globally unique namespace. module Control.Concurrent.MVar.Compat.Repl.Batteries ( module Control.Concurrent.MVar.Compat ) where import "this" Control.Concurrent.MVar.Compat base-compat-batteries-0.13.1/src/Control/Exception/0000755000000000000000000000000007346545000020305 5ustar0000000000000000base-compat-batteries-0.13.1/src/Control/Exception/Compat.hs0000644000000000000000000000024707346545000022067 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Control.Exception.Compat ( module Base ) where import "base-compat" Control.Exception.Compat as Base base-compat-batteries-0.13.1/src/Control/Exception/Compat/Repl/0000755000000000000000000000000007346545000022432 5ustar0000000000000000base-compat-batteries-0.13.1/src/Control/Exception/Compat/Repl/Batteries.hs0000644000000000000000000000046607346545000024716 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Control.Exception.Compat" -- from a globally unique namespace. module Control.Exception.Compat.Repl.Batteries ( module Control.Exception.Compat ) where import "this" Control.Exception.Compat base-compat-batteries-0.13.1/src/Control/Monad/0000755000000000000000000000000007346545000017405 5ustar0000000000000000base-compat-batteries-0.13.1/src/Control/Monad/Compat.hs0000644000000000000000000000032507346545000021164 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.13.1/src/Control/Monad/Compat/Repl/0000755000000000000000000000000007346545000021532 5ustar0000000000000000base-compat-batteries-0.13.1/src/Control/Monad/Compat/Repl/Batteries.hs0000644000000000000000000000044607346545000024014 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Control.Monad.Compat" -- from a globally unique namespace. module Control.Monad.Compat.Repl.Batteries ( module Control.Monad.Compat ) where import "this" Control.Monad.Compat base-compat-batteries-0.13.1/src/Control/Monad/Fail/0000755000000000000000000000000007346545000020260 5ustar0000000000000000base-compat-batteries-0.13.1/src/Control/Monad/Fail/Compat.hs0000644000000000000000000000037307346545000022042 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Control.Monad.Fail.Compat ( module Base ) where #if MIN_VERSION_base(4,9,0) import "base-compat" Control.Monad.Fail.Compat as Base #else import "fail" Control.Monad.Fail as Base #endif base-compat-batteries-0.13.1/src/Control/Monad/Fail/Compat/Repl/0000755000000000000000000000000007346545000022405 5ustar0000000000000000base-compat-batteries-0.13.1/src/Control/Monad/Fail/Compat/Repl/Batteries.hs0000644000000000000000000000047207346545000024666 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Control.Monad.Fail.Compat" -- from a globally unique namespace. module Control.Monad.Fail.Compat.Repl.Batteries ( module Control.Monad.Fail.Compat ) where import "this" Control.Monad.Fail.Compat base-compat-batteries-0.13.1/src/Control/Monad/IO/Class/0000755000000000000000000000000007346545000020761 5ustar0000000000000000base-compat-batteries-0.13.1/src/Control/Monad/IO/Class/Compat.hs0000644000000000000000000000040007346545000022532 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Control.Monad.IO.Class.Compat ( module Base ) where #if MIN_VERSION_base(4,9,0) import "base-compat" Control.Monad.IO.Class.Compat as Base #else import Control.Monad.IO.Class as Base #endif base-compat-batteries-0.13.1/src/Control/Monad/IO/Class/Compat/Repl/0000755000000000000000000000000007346545000023106 5ustar0000000000000000base-compat-batteries-0.13.1/src/Control/Monad/IO/Class/Compat/Repl/Batteries.hs0000644000000000000000000000051207346545000025362 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Control.Monad.IO.Class.Compat" -- from a globally unique namespace. module Control.Monad.IO.Class.Compat.Repl.Batteries ( module Control.Monad.IO.Class.Compat ) where import "this" Control.Monad.IO.Class.Compat base-compat-batteries-0.13.1/src/Control/Monad/ST/Lazy/Unsafe/0000755000000000000000000000000007346545000022073 5ustar0000000000000000base-compat-batteries-0.13.1/src/Control/Monad/ST/Lazy/Unsafe/Compat.hs0000644000000000000000000000027507346545000023656 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.13.1/src/Control/Monad/ST/Lazy/Unsafe/Compat/Repl/0000755000000000000000000000000007346545000024220 5ustar0000000000000000base-compat-batteries-0.13.1/src/Control/Monad/ST/Lazy/Unsafe/Compat/Repl/Batteries.hs0000644000000000000000000000054207346545000026477 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Control.Monad.ST.Lazy.Unsafe.Compat" -- from a globally unique namespace. module Control.Monad.ST.Lazy.Unsafe.Compat.Repl.Batteries ( module Control.Monad.ST.Lazy.Unsafe.Compat ) where import "this" Control.Monad.ST.Lazy.Unsafe.Compat base-compat-batteries-0.13.1/src/Control/Monad/ST/Unsafe/0000755000000000000000000000000007346545000021154 5ustar0000000000000000base-compat-batteries-0.13.1/src/Control/Monad/ST/Unsafe/Compat.hs0000644000000000000000000000026307346545000022734 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.13.1/src/Control/Monad/ST/Unsafe/Compat/Repl/0000755000000000000000000000000007346545000023301 5ustar0000000000000000base-compat-batteries-0.13.1/src/Control/Monad/ST/Unsafe/Compat/Repl/Batteries.hs0000644000000000000000000000051607346545000025561 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Control.Monad.ST.Unsafe.Compat" -- from a globally unique namespace. module Control.Monad.ST.Unsafe.Compat.Repl.Batteries ( module Control.Monad.ST.Unsafe.Compat ) where import "this" Control.Monad.ST.Unsafe.Compat base-compat-batteries-0.13.1/src/Data/Bifoldable/0000755000000000000000000000000007346545000017623 5ustar0000000000000000base-compat-batteries-0.13.1/src/Data/Bifoldable/Compat.hs0000644000000000000000000000040707346545000021403 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.13.1/src/Data/Bifoldable/Compat/Repl/0000755000000000000000000000000007346545000021750 5ustar0000000000000000base-compat-batteries-0.13.1/src/Data/Bifoldable/Compat/Repl/Batteries.hs0000644000000000000000000000045607346545000024233 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Data.Bifoldable.Compat" -- from a globally unique namespace. module Data.Bifoldable.Compat.Repl.Batteries ( module Data.Bifoldable.Compat ) where import "this" Data.Bifoldable.Compat base-compat-batteries-0.13.1/src/Data/Bifoldable1/0000755000000000000000000000000007346545000017704 5ustar0000000000000000base-compat-batteries-0.13.1/src/Data/Bifoldable1/Compat.hs0000644000000000000000000000041207346545000021460 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.13.1/src/Data/Bifoldable1/Compat/Repl/0000755000000000000000000000000007346545000022031 5ustar0000000000000000base-compat-batteries-0.13.1/src/Data/Bifoldable1/Compat/Repl/Batteries.hs0000644000000000000000000000046207346545000024311 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Data.Bifoldable1.Compat" -- from a globally unique namespace. module Data.Bifoldable1.Compat.Repl.Batteries ( module Data.Bifoldable1.Compat ) where import "this" Data.Bifoldable1.Compat base-compat-batteries-0.13.1/src/Data/Bifunctor/0000755000000000000000000000000007346545000017533 5ustar0000000000000000base-compat-batteries-0.13.1/src/Data/Bifunctor/Compat.hs0000644000000000000000000000040307346545000021307 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Data.Bifunctor.Compat ( module Base ) where #if MIN_VERSION_base(4,8,0) import "base-compat" Data.Bifunctor.Compat as Base #else import "bifunctor-classes-compat" Data.Bifunctor as Base #endif base-compat-batteries-0.13.1/src/Data/Bifunctor/Compat/Repl/0000755000000000000000000000000007346545000021660 5ustar0000000000000000base-compat-batteries-0.13.1/src/Data/Bifunctor/Compat/Repl/Batteries.hs0000644000000000000000000000045207346545000024137 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Data.Bifunctor.Compat" -- from a globally unique namespace. module Data.Bifunctor.Compat.Repl.Batteries ( module Data.Bifunctor.Compat ) where import "this" Data.Bifunctor.Compat base-compat-batteries-0.13.1/src/Data/Bitraversable/0000755000000000000000000000000007346545000020365 5ustar0000000000000000base-compat-batteries-0.13.1/src/Data/Bitraversable/Compat.hs0000644000000000000000000000042007346545000022140 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Data.Bitraversable.Compat ( module Base ) 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 #endif base-compat-batteries-0.13.1/src/Data/Bitraversable/Compat/Repl/0000755000000000000000000000000007346545000022512 5ustar0000000000000000base-compat-batteries-0.13.1/src/Data/Bitraversable/Compat/Repl/Batteries.hs0000644000000000000000000000047207346545000024773 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Data.Bitraversable.Compat" -- from a globally unique namespace. module Data.Bitraversable.Compat.Repl.Batteries ( module Data.Bitraversable.Compat ) where import "this" Data.Bitraversable.Compat base-compat-batteries-0.13.1/src/Data/Bits/0000755000000000000000000000000007346545000016501 5ustar0000000000000000base-compat-batteries-0.13.1/src/Data/Bits/Compat.hs0000644000000000000000000000022707346545000020261 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Data.Bits.Compat ( module Base ) where import "base-compat" Data.Bits.Compat as Base base-compat-batteries-0.13.1/src/Data/Bits/Compat/Repl/0000755000000000000000000000000007346545000020626 5ustar0000000000000000base-compat-batteries-0.13.1/src/Data/Bits/Compat/Repl/Batteries.hs0000644000000000000000000000042607346545000023106 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Data.Bits.Compat" -- from a globally unique namespace. module Data.Bits.Compat.Repl.Batteries ( module Data.Bits.Compat ) where import "this" Data.Bits.Compat base-compat-batteries-0.13.1/src/Data/Bool/0000755000000000000000000000000007346545000016473 5ustar0000000000000000base-compat-batteries-0.13.1/src/Data/Bool/Compat.hs0000644000000000000000000000022707346545000020253 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Data.Bool.Compat ( module Base ) where import "base-compat" Data.Bool.Compat as Base base-compat-batteries-0.13.1/src/Data/Bool/Compat/Repl/0000755000000000000000000000000007346545000020620 5ustar0000000000000000base-compat-batteries-0.13.1/src/Data/Bool/Compat/Repl/Batteries.hs0000644000000000000000000000042607346545000023100 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Data.Bool.Compat" -- from a globally unique namespace. module Data.Bool.Compat.Repl.Batteries ( module Data.Bool.Compat ) where import "this" Data.Bool.Compat base-compat-batteries-0.13.1/src/Data/Complex/0000755000000000000000000000000007346545000017207 5ustar0000000000000000base-compat-batteries-0.13.1/src/Data/Complex/Compat.hs0000644000000000000000000000023507346545000020766 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Data.Complex.Compat ( module Base ) where import "base-compat" Data.Complex.Compat as Base base-compat-batteries-0.13.1/src/Data/Complex/Compat/Repl/0000755000000000000000000000000007346545000021334 5ustar0000000000000000base-compat-batteries-0.13.1/src/Data/Complex/Compat/Repl/Batteries.hs0000644000000000000000000000044207346545000023612 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Data.Complex.Compat" -- from a globally unique namespace. module Data.Complex.Compat.Repl.Batteries ( module Data.Complex.Compat ) where import "this" Data.Complex.Compat base-compat-batteries-0.13.1/src/Data/Either/0000755000000000000000000000000007346545000017020 5ustar0000000000000000base-compat-batteries-0.13.1/src/Data/Either/Compat.hs0000644000000000000000000000023307346545000020575 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Data.Either.Compat ( module Base ) where import "base-compat" Data.Either.Compat as Base base-compat-batteries-0.13.1/src/Data/Either/Compat/Repl/0000755000000000000000000000000007346545000021145 5ustar0000000000000000base-compat-batteries-0.13.1/src/Data/Either/Compat/Repl/Batteries.hs0000644000000000000000000000043607346545000023426 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Data.Either.Compat" -- from a globally unique namespace. module Data.Either.Compat.Repl.Batteries ( module Data.Either.Compat ) where import "this" Data.Either.Compat base-compat-batteries-0.13.1/src/Data/Foldable/0000755000000000000000000000000007346545000017310 5ustar0000000000000000base-compat-batteries-0.13.1/src/Data/Foldable/Compat.hs0000644000000000000000000000023707346545000021071 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Data.Foldable.Compat ( module Base ) where import "base-compat" Data.Foldable.Compat as Base base-compat-batteries-0.13.1/src/Data/Foldable/Compat/Repl/0000755000000000000000000000000007346545000021435 5ustar0000000000000000base-compat-batteries-0.13.1/src/Data/Foldable/Compat/Repl/Batteries.hs0000644000000000000000000000044607346545000023717 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Data.Foldable.Compat" -- from a globally unique namespace. module Data.Foldable.Compat.Repl.Batteries ( module Data.Foldable.Compat ) where import "this" Data.Foldable.Compat base-compat-batteries-0.13.1/src/Data/Foldable1/0000755000000000000000000000000007346545000017371 5ustar0000000000000000base-compat-batteries-0.13.1/src/Data/Foldable1/Compat.hs0000644000000000000000000000040407346545000021146 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.13.1/src/Data/Foldable1/Compat/Repl/0000755000000000000000000000000007346545000021516 5ustar0000000000000000base-compat-batteries-0.13.1/src/Data/Foldable1/Compat/Repl/Batteries.hs0000644000000000000000000000045207346545000023775 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Data.Foldable1.Compat" -- from a globally unique namespace. module Data.Foldable1.Compat.Repl.Batteries ( module Data.Foldable1.Compat ) where import "this" Data.Foldable1.Compat base-compat-batteries-0.13.1/src/Data/Function/0000755000000000000000000000000007346545000017365 5ustar0000000000000000base-compat-batteries-0.13.1/src/Data/Function/Compat.hs0000644000000000000000000000023707346545000021146 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Data.Function.Compat ( module Base ) where import "base-compat" Data.Function.Compat as Base base-compat-batteries-0.13.1/src/Data/Function/Compat/Repl/0000755000000000000000000000000007346545000021512 5ustar0000000000000000base-compat-batteries-0.13.1/src/Data/Function/Compat/Repl/Batteries.hs0000644000000000000000000000044607346545000023774 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Data.Function.Compat" -- from a globally unique namespace. module Data.Function.Compat.Repl.Batteries ( module Data.Function.Compat ) where import "this" Data.Function.Compat base-compat-batteries-0.13.1/src/Data/Functor/0000755000000000000000000000000007346545000017220 5ustar0000000000000000base-compat-batteries-0.13.1/src/Data/Functor/Compat.hs0000644000000000000000000000023507346545000020777 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Data.Functor.Compat ( module Base ) where import "base-compat" Data.Functor.Compat as Base base-compat-batteries-0.13.1/src/Data/Functor/Compat/Repl/0000755000000000000000000000000007346545000021345 5ustar0000000000000000base-compat-batteries-0.13.1/src/Data/Functor/Compat/Repl/Batteries.hs0000644000000000000000000000044207346545000023623 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Data.Functor.Compat" -- from a globally unique namespace. module Data.Functor.Compat.Repl.Batteries ( module Data.Functor.Compat ) where import "this" Data.Functor.Compat base-compat-batteries-0.13.1/src/Data/Functor/Compose/0000755000000000000000000000000007346545000020625 5ustar0000000000000000base-compat-batteries-0.13.1/src/Data/Functor/Compose/Compat.hs0000644000000000000000000000037207346545000022406 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Data.Functor.Compose.Compat ( module Base ) where #if MIN_VERSION_base(4,9,0) import "base-compat" Data.Functor.Compose.Compat as Base #else import Data.Functor.Compose as Base #endif base-compat-batteries-0.13.1/src/Data/Functor/Compose/Compat/Repl/0000755000000000000000000000000007346545000022752 5ustar0000000000000000base-compat-batteries-0.13.1/src/Data/Functor/Compose/Compat/Repl/Batteries.hs0000644000000000000000000000050207346545000025225 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Data.Functor.Compose.Compat" -- from a globally unique namespace. module Data.Functor.Compose.Compat.Repl.Batteries ( module Data.Functor.Compose.Compat ) where import "this" Data.Functor.Compose.Compat base-compat-batteries-0.13.1/src/Data/Functor/Const/0000755000000000000000000000000007346545000020306 5ustar0000000000000000base-compat-batteries-0.13.1/src/Data/Functor/Const/Compat.hs0000644000000000000000000000025107346545000022063 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.13.1/src/Data/Functor/Const/Compat/Repl/0000755000000000000000000000000007346545000022433 5ustar0000000000000000base-compat-batteries-0.13.1/src/Data/Functor/Const/Compat/Repl/Batteries.hs0000644000000000000000000000047207346545000024714 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Data.Functor.Const.Compat" -- from a globally unique namespace. module Data.Functor.Const.Compat.Repl.Batteries ( module Data.Functor.Const.Compat ) where import "this" Data.Functor.Const.Compat base-compat-batteries-0.13.1/src/Data/Functor/Contravariant/0000755000000000000000000000000007346545000022033 5ustar0000000000000000base-compat-batteries-0.13.1/src/Data/Functor/Contravariant/Compat.hs0000644000000000000000000000043707346545000023616 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.13.1/src/Data/Functor/Contravariant/Compat/Repl/0000755000000000000000000000000007346545000024160 5ustar0000000000000000base-compat-batteries-0.13.1/src/Data/Functor/Contravariant/Compat/Repl/Batteries.hs0000644000000000000000000000053207346545000026436 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Data.Functor.Contravariant.Compat" -- from a globally unique namespace. module Data.Functor.Contravariant.Compat.Repl.Batteries ( module Data.Functor.Contravariant.Compat ) where import "this" Data.Functor.Contravariant.Compat base-compat-batteries-0.13.1/src/Data/Functor/Identity/0000755000000000000000000000000007346545000021011 5ustar0000000000000000base-compat-batteries-0.13.1/src/Data/Functor/Identity/Compat.hs0000644000000000000000000000037507346545000022575 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Data.Functor.Identity.Compat ( module Base ) where #if MIN_VERSION_base(4,8,0) import "base-compat" Data.Functor.Identity.Compat as Base #else import Data.Functor.Identity as Base #endif base-compat-batteries-0.13.1/src/Data/Functor/Identity/Compat/Repl/0000755000000000000000000000000007346545000023136 5ustar0000000000000000base-compat-batteries-0.13.1/src/Data/Functor/Identity/Compat/Repl/Batteries.hs0000644000000000000000000000050607346545000025415 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Data.Functor.Identity.Compat" -- from a globally unique namespace. module Data.Functor.Identity.Compat.Repl.Batteries ( module Data.Functor.Identity.Compat ) where import "this" Data.Functor.Identity.Compat base-compat-batteries-0.13.1/src/Data/Functor/Product/0000755000000000000000000000000007346545000020640 5ustar0000000000000000base-compat-batteries-0.13.1/src/Data/Functor/Product/Compat.hs0000644000000000000000000000037207346545000022421 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Data.Functor.Product.Compat ( module Base ) where #if MIN_VERSION_base(4,9,0) import "base-compat" Data.Functor.Product.Compat as Base #else import Data.Functor.Product as Base #endif base-compat-batteries-0.13.1/src/Data/Functor/Product/Compat/Repl/0000755000000000000000000000000007346545000022765 5ustar0000000000000000base-compat-batteries-0.13.1/src/Data/Functor/Product/Compat/Repl/Batteries.hs0000644000000000000000000000050207346545000025240 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Data.Functor.Product.Compat" -- from a globally unique namespace. module Data.Functor.Product.Compat.Repl.Batteries ( module Data.Functor.Product.Compat ) where import "this" Data.Functor.Product.Compat base-compat-batteries-0.13.1/src/Data/Functor/Sum/0000755000000000000000000000000007346545000017764 5ustar0000000000000000base-compat-batteries-0.13.1/src/Data/Functor/Sum/Compat.hs0000644000000000000000000000035607346545000021547 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Data.Functor.Sum.Compat ( module Base ) where #if MIN_VERSION_base(4,9,0) import "base-compat" Data.Functor.Sum.Compat as Base #else import Data.Functor.Sum as Base #endif base-compat-batteries-0.13.1/src/Data/Functor/Sum/Compat/Repl/0000755000000000000000000000000007346545000022111 5ustar0000000000000000base-compat-batteries-0.13.1/src/Data/Functor/Sum/Compat/Repl/Batteries.hs0000644000000000000000000000046207346545000024371 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Data.Functor.Sum.Compat" -- from a globally unique namespace. module Data.Functor.Sum.Compat.Repl.Batteries ( module Data.Functor.Sum.Compat ) where import "this" Data.Functor.Sum.Compat base-compat-batteries-0.13.1/src/Data/IORef/0000755000000000000000000000000007346545000016544 5ustar0000000000000000base-compat-batteries-0.13.1/src/Data/IORef/Compat.hs0000644000000000000000000000023107346545000020317 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Data.IORef.Compat ( module Base ) where import "base-compat" Data.IORef.Compat as Base base-compat-batteries-0.13.1/src/Data/IORef/Compat/Repl/0000755000000000000000000000000007346545000020671 5ustar0000000000000000base-compat-batteries-0.13.1/src/Data/IORef/Compat/Repl/Batteries.hs0000644000000000000000000000043207346545000023146 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Data.IORef.Compat" -- from a globally unique namespace. module Data.IORef.Compat.Repl.Batteries ( module Data.IORef.Compat ) where import "this" Data.IORef.Compat base-compat-batteries-0.13.1/src/Data/List/0000755000000000000000000000000007346545000016513 5ustar0000000000000000base-compat-batteries-0.13.1/src/Data/List/Compat.hs0000644000000000000000000000022707346545000020273 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Data.List.Compat ( module Base ) where import "base-compat" Data.List.Compat as Base base-compat-batteries-0.13.1/src/Data/List/Compat/Repl/0000755000000000000000000000000007346545000020640 5ustar0000000000000000base-compat-batteries-0.13.1/src/Data/List/Compat/Repl/Batteries.hs0000644000000000000000000000042607346545000023120 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Data.List.Compat" -- from a globally unique namespace. module Data.List.Compat.Repl.Batteries ( module Data.List.Compat ) where import "this" Data.List.Compat base-compat-batteries-0.13.1/src/Data/List/NonEmpty/0000755000000000000000000000000007346545000020264 5ustar0000000000000000base-compat-batteries-0.13.1/src/Data/List/NonEmpty/Compat.hs0000644000000000000000000000645207346545000022052 0ustar0000000000000000{-# LANGUAGE CPP, 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 , head , tail , last , init , singleton , (<|), cons , uncons , unfoldr , sort , reverse , inits , inits1 , tails , tails1 -- * Building streams , iterate , repeat , cycle , unfold , insert , some1 -- * Extracting sublists , take , drop , splitAt , takeWhile , dropWhile , span , break , filter , partition , group , groupBy , groupWith , groupAllWith , group1 , groupBy1 , groupWith1 , groupAllWith1 -- * Sublist predicates , isPrefixOf -- * \"Set\" operations , nub , nubBy -- * Indexing streams , (!!) -- * Zipping and unzipping streams , zip , zipWith , unzip -- * Converting to and from a list , fromList , toList , nonEmpty , xor ) where #if MIN_VERSION_base(4,9,0) import "base-compat" Data.List.NonEmpty.Compat #else import "semigroups" Data.List.NonEmpty import qualified "this" Prelude.Compat as Prelude import "this" Prelude.Compat ((.)) import qualified "this" Data.Foldable.Compat as Foldable import qualified "this" Data.List.Compat as List #endif #if !(MIN_VERSION_base(4,9,0)) -- | Construct a 'NonEmpty' list from a single element. -- -- /Since: 4.15/ singleton :: a -> NonEmpty a singleton a = a :| [] -- | The 'inits1' function takes a 'NonEmpty' stream @xs@ and returns all the -- 'NonEmpty' finite prefixes of @xs@, starting with the shortest. -- -- > inits1 (1 :| [2,3]) == (1 :| []) :| [1 :| [2], 1 :| [2,3]] -- > inits1 (1 :| []) == (1 :| []) :| [] -- -- /Since: 4.18/ inits1 :: NonEmpty a -> NonEmpty (NonEmpty a) inits1 = -- fromList is an unsafe function, but this usage should be safe, since: -- - `inits xs = [[], ..., init (init xs), init xs, xs]` -- - If `xs` is nonempty, it follows that `inits xs` contains at least one nonempty -- list, since `last (inits xs) = xs`. -- - The only empty element of `inits xs` is the first one (by the definition of `inits`) -- - Therefore, if we take all but the first element of `inits xs` i.e. -- `tail (inits xs)`, we have a nonempty list of nonempty lists fromList . Prelude.map fromList . List.tail . List.inits . Foldable.toList -- | The 'tails1' function takes a 'NonEmpty' stream @xs@ and returns all the -- non-empty suffixes of @xs@, starting with the longest. -- -- > tails1 (1 :| [2,3]) == (1 :| [2,3]) :| [2 :| [3], 3 :| []] -- > tails1 (1 :| []) == (1 :| []) :| [] -- -- /Since: 4.18/ tails1 :: NonEmpty a -> NonEmpty (NonEmpty a) tails1 = -- fromList is an unsafe function, but this usage should be safe, since: -- - `tails xs = [xs, tail xs, tail (tail xs), ..., []]` -- - If `xs` is nonempty, it follows that `tails xs` contains at least one nonempty -- list, since `head (tails xs) = xs`. -- - The only empty element of `tails xs` is the last one (by the definition of `tails`) -- - Therefore, if we take all but the last element of `tails xs` i.e. -- `init (tails xs)`, we have a nonempty list of nonempty lists fromList . Prelude.map fromList . List.init . List.tails . Foldable.toList #endif base-compat-batteries-0.13.1/src/Data/List/NonEmpty/Compat/Repl/0000755000000000000000000000000007346545000022411 5ustar0000000000000000base-compat-batteries-0.13.1/src/Data/List/NonEmpty/Compat/Repl/Batteries.hs0000644000000000000000000000047207346545000024672 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Data.List.NonEmpty.Compat" -- from a globally unique namespace. module Data.List.NonEmpty.Compat.Repl.Batteries ( module Data.List.NonEmpty.Compat ) where import "this" Data.List.NonEmpty.Compat base-compat-batteries-0.13.1/src/Data/Monoid/0000755000000000000000000000000007346545000017025 5ustar0000000000000000base-compat-batteries-0.13.1/src/Data/Monoid/Compat.hs0000644000000000000000000000031507346545000020603 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.13.1/src/Data/Monoid/Compat/Repl/0000755000000000000000000000000007346545000021152 5ustar0000000000000000base-compat-batteries-0.13.1/src/Data/Monoid/Compat/Repl/Batteries.hs0000644000000000000000000000043607346545000023433 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Data.Monoid.Compat" -- from a globally unique namespace. module Data.Monoid.Compat.Repl.Batteries ( module Data.Monoid.Compat ) where import "this" Data.Monoid.Compat base-compat-batteries-0.13.1/src/Data/Proxy/0000755000000000000000000000000007346545000016721 5ustar0000000000000000base-compat-batteries-0.13.1/src/Data/Proxy/Compat.hs0000644000000000000000000000034507346545000020502 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Data.Proxy.Compat ( module Base ) where #if MIN_VERSION_base(4,7,0) import "base-compat" Data.Proxy.Compat as Base #else import "tagged" Data.Proxy as Base #endif base-compat-batteries-0.13.1/src/Data/Proxy/Compat/Repl/0000755000000000000000000000000007346545000021046 5ustar0000000000000000base-compat-batteries-0.13.1/src/Data/Proxy/Compat/Repl/Batteries.hs0000644000000000000000000000043207346545000023323 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Data.Proxy.Compat" -- from a globally unique namespace. module Data.Proxy.Compat.Repl.Batteries ( module Data.Proxy.Compat ) where import "this" Data.Proxy.Compat base-compat-batteries-0.13.1/src/Data/Ratio/0000755000000000000000000000000007346545000016656 5ustar0000000000000000base-compat-batteries-0.13.1/src/Data/Ratio/Compat.hs0000644000000000000000000000023107346545000020431 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Data.Ratio.Compat ( module Base ) where import "base-compat" Data.Ratio.Compat as Base base-compat-batteries-0.13.1/src/Data/Ratio/Compat/Repl/0000755000000000000000000000000007346545000021003 5ustar0000000000000000base-compat-batteries-0.13.1/src/Data/Ratio/Compat/Repl/Batteries.hs0000644000000000000000000000043207346545000023260 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Data.Ratio.Compat" -- from a globally unique namespace. module Data.Ratio.Compat.Repl.Batteries ( module Data.Ratio.Compat ) where import "this" Data.Ratio.Compat base-compat-batteries-0.13.1/src/Data/STRef/0000755000000000000000000000000007346545000016563 5ustar0000000000000000base-compat-batteries-0.13.1/src/Data/STRef/Compat.hs0000644000000000000000000000023107346545000020336 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Data.STRef.Compat ( module Base ) where import "base-compat" Data.STRef.Compat as Base base-compat-batteries-0.13.1/src/Data/STRef/Compat/Repl/0000755000000000000000000000000007346545000020710 5ustar0000000000000000base-compat-batteries-0.13.1/src/Data/STRef/Compat/Repl/Batteries.hs0000644000000000000000000000043207346545000023165 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Data.STRef.Compat" -- from a globally unique namespace. module Data.STRef.Compat.Repl.Batteries ( module Data.STRef.Compat ) where import "this" Data.STRef.Compat base-compat-batteries-0.13.1/src/Data/Semigroup/0000755000000000000000000000000007346545000017552 5ustar0000000000000000base-compat-batteries-0.13.1/src/Data/Semigroup/Compat.hs0000644000000000000000000000120607346545000021330 0ustar0000000000000000{-# LANGUAGE CPP, 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 #if MIN_VERSION_base(4,9,0) import "base-compat" Data.Semigroup.Compat #else import "semigroups" Data.Semigroup #endif base-compat-batteries-0.13.1/src/Data/Semigroup/Compat/Repl/0000755000000000000000000000000007346545000021677 5ustar0000000000000000base-compat-batteries-0.13.1/src/Data/Semigroup/Compat/Repl/Batteries.hs0000644000000000000000000000045207346545000024156 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Data.Semigroup.Compat" -- from a globally unique namespace. module Data.Semigroup.Compat.Repl.Batteries ( module Data.Semigroup.Compat ) where import "this" Data.Semigroup.Compat base-compat-batteries-0.13.1/src/Data/String/0000755000000000000000000000000007346545000017046 5ustar0000000000000000base-compat-batteries-0.13.1/src/Data/String/Compat.hs0000644000000000000000000000023307346545000020623 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Data.String.Compat ( module Base ) where import "base-compat" Data.String.Compat as Base base-compat-batteries-0.13.1/src/Data/String/Compat/Repl/0000755000000000000000000000000007346545000021173 5ustar0000000000000000base-compat-batteries-0.13.1/src/Data/String/Compat/Repl/Batteries.hs0000644000000000000000000000043607346545000023454 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Data.String.Compat" -- from a globally unique namespace. module Data.String.Compat.Repl.Batteries ( module Data.String.Compat ) where import "this" Data.String.Compat base-compat-batteries-0.13.1/src/Data/Traversable/0000755000000000000000000000000007346545000020052 5ustar0000000000000000base-compat-batteries-0.13.1/src/Data/Traversable/Compat.hs0000644000000000000000000000024507346545000021632 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Data.Traversable.Compat ( module Base ) where import "base-compat" Data.Traversable.Compat as Base base-compat-batteries-0.13.1/src/Data/Traversable/Compat/Repl/0000755000000000000000000000000007346545000022177 5ustar0000000000000000base-compat-batteries-0.13.1/src/Data/Traversable/Compat/Repl/Batteries.hs0000644000000000000000000000046207346545000024457 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Data.Traversable.Compat" -- from a globally unique namespace. module Data.Traversable.Compat.Repl.Batteries ( module Data.Traversable.Compat ) where import "this" Data.Traversable.Compat base-compat-batteries-0.13.1/src/Data/Tuple/0000755000000000000000000000000007346545000016671 5ustar0000000000000000base-compat-batteries-0.13.1/src/Data/Tuple/Compat.hs0000644000000000000000000000235407346545000020454 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} #if __GLASGOW_HASKELL__ >= 708 {-# LANGUAGE PatternSynonyms #-} #endif -- | This uses the @OneTuple@ compatibility library to backport 'Solo' to old -- versions of GHC. Note that @OneTuple@ makes use of pattern synonyms, which -- cannot be defined on pre-7.8 versions of GHC. As such, it is not feasible -- to backport the @Solo@ data constructor on pre-7.8 versions of GHC, as -- @OneTuple@ defines this as a pattern synonym. 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 #elif __GLASGOW_HASKELL__ >= 800 Solo(MkSolo, Solo) #elif __GLASGOW_HASKELL__ >= 708 Solo(MkSolo) , pattern Solo #else Solo(MkSolo) #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.13.1/src/Data/Tuple/Compat/Repl/0000755000000000000000000000000007346545000021016 5ustar0000000000000000base-compat-batteries-0.13.1/src/Data/Tuple/Compat/Repl/Batteries.hs0000644000000000000000000000043207346545000023273 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Data.Tuple.Compat" -- from a globally unique namespace. module Data.Tuple.Compat.Repl.Batteries ( module Data.Tuple.Compat ) where import "this" Data.Tuple.Compat base-compat-batteries-0.13.1/src/Data/Type/Coercion/0000755000000000000000000000000007346545000020262 5ustar0000000000000000base-compat-batteries-0.13.1/src/Data/Type/Coercion/Compat.hs0000644000000000000000000000035707346545000022046 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Data.Type.Coercion.Compat ( #if MIN_VERSION_base(4,7,0) module Base #endif ) where #if MIN_VERSION_base(4,7,0) import "base-compat" Data.Type.Coercion.Compat as Base #endif base-compat-batteries-0.13.1/src/Data/Type/Coercion/Compat/Repl/0000755000000000000000000000000007346545000022407 5ustar0000000000000000base-compat-batteries-0.13.1/src/Data/Type/Coercion/Compat/Repl/Batteries.hs0000644000000000000000000000047207346545000024670 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Data.Type.Coercion.Compat" -- from a globally unique namespace. module Data.Type.Coercion.Compat.Repl.Batteries ( module Data.Type.Coercion.Compat ) where import "this" Data.Type.Coercion.Compat base-compat-batteries-0.13.1/src/Data/Type/Equality/0000755000000000000000000000000007346545000020316 5ustar0000000000000000base-compat-batteries-0.13.1/src/Data/Type/Equality/Compat.hs0000644000000000000000000000165207346545000022101 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} #if __GLASGOW_HASKELL__ >= 702 {-# LANGUAGE Trustworthy #-} #endif #if __GLASGOW_HASKELL__ >= 708 {-# LANGUAGE ExplicitNamespaces #-} #endif module Data.Type.Equality.Compat ( -- * The equality types (:~:)(..), #if __GLASGOW_HASKELL__ >= 800 type (~~), #endif #if __GLASGOW_HASKELL__ >= 800 (:~~:)(..), #endif -- * Working with equality sym, trans, castWith, gcastWith, #if __GLASGOW_HASKELL__ >= 706 apply, #endif inner, #if __GLASGOW_HASKELL__ >= 706 outer, #endif -- * Inferring equality from other types TestEquality(..), #if __GLASGOW_HASKELL__ >= 708 -- * Boolean type-level equality type (==), #endif ) where #if MIN_VERSION_base(4,7,0) import "base" Data.Type.Equality #else import "type-equality" Data.Type.Equality #endif #if MIN_VERSION_base(4,9,0) && !MIN_VERSION_base(4,10,0) import "type-equality" Data.Type.Equality.Hetero #endif base-compat-batteries-0.13.1/src/Data/Type/Equality/Compat/Repl/0000755000000000000000000000000007346545000022443 5ustar0000000000000000base-compat-batteries-0.13.1/src/Data/Type/Equality/Compat/Repl/Batteries.hs0000644000000000000000000000047207346545000024724 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Data.Type.Equality.Compat" -- from a globally unique namespace. module Data.Type.Equality.Compat.Repl.Batteries ( module Data.Type.Equality.Compat ) where import "this" Data.Type.Equality.Compat base-compat-batteries-0.13.1/src/Data/Typeable/0000755000000000000000000000000007346545000017345 5ustar0000000000000000base-compat-batteries-0.13.1/src/Data/Typeable/Compat.hs0000644000000000000000000000023707346545000021126 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Data.Typeable.Compat ( module Base ) where import "base-compat" Data.Typeable.Compat as Base base-compat-batteries-0.13.1/src/Data/Typeable/Compat/Repl/0000755000000000000000000000000007346545000021472 5ustar0000000000000000base-compat-batteries-0.13.1/src/Data/Typeable/Compat/Repl/Batteries.hs0000644000000000000000000000044607346545000023754 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Data.Typeable.Compat" -- from a globally unique namespace. module Data.Typeable.Compat.Repl.Batteries ( module Data.Typeable.Compat ) where import "this" Data.Typeable.Compat base-compat-batteries-0.13.1/src/Data/Version/0000755000000000000000000000000007346545000017225 5ustar0000000000000000base-compat-batteries-0.13.1/src/Data/Version/Compat.hs0000644000000000000000000000023507346545000021004 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Data.Version.Compat ( module Base ) where import "base-compat" Data.Version.Compat as Base base-compat-batteries-0.13.1/src/Data/Version/Compat/Repl/0000755000000000000000000000000007346545000021352 5ustar0000000000000000base-compat-batteries-0.13.1/src/Data/Version/Compat/Repl/Batteries.hs0000644000000000000000000000044207346545000023630 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Data.Version.Compat" -- from a globally unique namespace. module Data.Version.Compat.Repl.Batteries ( module Data.Version.Compat ) where import "this" Data.Version.Compat base-compat-batteries-0.13.1/src/Data/Void/0000755000000000000000000000000007346545000016501 5ustar0000000000000000base-compat-batteries-0.13.1/src/Data/Void/Compat.hs0000644000000000000000000000035407346545000020262 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Data.Void.Compat ( Void , absurd , vacuous ) where #if MIN_VERSION_base(4,8,0) import "base-compat" Data.Void.Compat as Base #else import "void" Data.Void as Base #endif base-compat-batteries-0.13.1/src/Data/Void/Compat/Repl/0000755000000000000000000000000007346545000020626 5ustar0000000000000000base-compat-batteries-0.13.1/src/Data/Void/Compat/Repl/Batteries.hs0000644000000000000000000000042607346545000023106 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Data.Void.Compat" -- from a globally unique namespace. module Data.Void.Compat.Repl.Batteries ( module Data.Void.Compat ) where import "this" Data.Void.Compat base-compat-batteries-0.13.1/src/Data/Word/0000755000000000000000000000000007346545000016513 5ustar0000000000000000base-compat-batteries-0.13.1/src/Data/Word/Compat.hs0000644000000000000000000000022707346545000020273 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Data.Word.Compat ( module Base ) where import "base-compat" Data.Word.Compat as Base base-compat-batteries-0.13.1/src/Data/Word/Compat/Repl/0000755000000000000000000000000007346545000020640 5ustar0000000000000000base-compat-batteries-0.13.1/src/Data/Word/Compat/Repl/Batteries.hs0000644000000000000000000000042607346545000023120 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Data.Word.Compat" -- from a globally unique namespace. module Data.Word.Compat.Repl.Batteries ( module Data.Word.Compat ) where import "this" Data.Word.Compat base-compat-batteries-0.13.1/src/Debug/Trace/0000755000000000000000000000000007346545000017013 5ustar0000000000000000base-compat-batteries-0.13.1/src/Debug/Trace/Compat.hs0000644000000000000000000000023307346545000020570 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Debug.Trace.Compat ( module Base ) where import "base-compat" Debug.Trace.Compat as Base base-compat-batteries-0.13.1/src/Debug/Trace/Compat/Repl/0000755000000000000000000000000007346545000021140 5ustar0000000000000000base-compat-batteries-0.13.1/src/Debug/Trace/Compat/Repl/Batteries.hs0000644000000000000000000000043607346545000023421 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Debug.Trace.Compat" -- from a globally unique namespace. module Debug.Trace.Compat.Repl.Batteries ( module Debug.Trace.Compat ) where import "this" Debug.Trace.Compat base-compat-batteries-0.13.1/src/Foreign/0000755000000000000000000000000007346545000016320 5ustar0000000000000000base-compat-batteries-0.13.1/src/Foreign/Compat.hs0000644000000000000000000000022307346545000020074 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Foreign.Compat ( module Base ) where import "base-compat" Foreign.Compat as Base base-compat-batteries-0.13.1/src/Foreign/Compat/Repl/0000755000000000000000000000000007346545000020445 5ustar0000000000000000base-compat-batteries-0.13.1/src/Foreign/Compat/Repl/Batteries.hs0000644000000000000000000000041607346545000022724 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Foreign.Compat" -- from a globally unique namespace. module Foreign.Compat.Repl.Batteries ( module Foreign.Compat ) where import "this" Foreign.Compat base-compat-batteries-0.13.1/src/Foreign/ForeignPtr/0000755000000000000000000000000007346545000020377 5ustar0000000000000000base-compat-batteries-0.13.1/src/Foreign/ForeignPtr/Compat.hs0000644000000000000000000000025107346545000022154 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Foreign.ForeignPtr.Compat ( module Base ) where import "base-compat" Foreign.ForeignPtr.Compat as Base base-compat-batteries-0.13.1/src/Foreign/ForeignPtr/Compat/Repl/0000755000000000000000000000000007346545000022524 5ustar0000000000000000base-compat-batteries-0.13.1/src/Foreign/ForeignPtr/Compat/Repl/Batteries.hs0000644000000000000000000000047207346545000025005 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Foreign.ForeignPtr.Compat" -- from a globally unique namespace. module Foreign.ForeignPtr.Compat.Repl.Batteries ( module Foreign.ForeignPtr.Compat ) where import "this" Foreign.ForeignPtr.Compat base-compat-batteries-0.13.1/src/Foreign/ForeignPtr/Safe/0000755000000000000000000000000007346545000021255 5ustar0000000000000000base-compat-batteries-0.13.1/src/Foreign/ForeignPtr/Safe/Compat.hs0000644000000000000000000000026307346545000023035 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.13.1/src/Foreign/ForeignPtr/Safe/Compat/Repl/0000755000000000000000000000000007346545000023402 5ustar0000000000000000base-compat-batteries-0.13.1/src/Foreign/ForeignPtr/Safe/Compat/Repl/Batteries.hs0000644000000000000000000000051607346545000025662 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Foreign.ForeignPtr.Safe.Compat" -- from a globally unique namespace. module Foreign.ForeignPtr.Safe.Compat.Repl.Batteries ( module Foreign.ForeignPtr.Safe.Compat ) where import "this" Foreign.ForeignPtr.Safe.Compat base-compat-batteries-0.13.1/src/Foreign/ForeignPtr/Unsafe/0000755000000000000000000000000007346545000021620 5ustar0000000000000000base-compat-batteries-0.13.1/src/Foreign/ForeignPtr/Unsafe/Compat.hs0000644000000000000000000000026707346545000023404 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.13.1/src/Foreign/ForeignPtr/Unsafe/Compat/Repl/0000755000000000000000000000000007346545000023745 5ustar0000000000000000base-compat-batteries-0.13.1/src/Foreign/ForeignPtr/Unsafe/Compat/Repl/Batteries.hs0000644000000000000000000000052607346545000026226 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Foreign.ForeignPtr.Unsafe.Compat" -- from a globally unique namespace. module Foreign.ForeignPtr.Unsafe.Compat.Repl.Batteries ( module Foreign.ForeignPtr.Unsafe.Compat ) where import "this" Foreign.ForeignPtr.Unsafe.Compat base-compat-batteries-0.13.1/src/Foreign/Marshal/Alloc/0000755000000000000000000000000007346545000020741 5ustar0000000000000000base-compat-batteries-0.13.1/src/Foreign/Marshal/Alloc/Compat.hs0000644000000000000000000000025707346545000022524 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.13.1/src/Foreign/Marshal/Alloc/Compat/Repl/0000755000000000000000000000000007346545000023066 5ustar0000000000000000base-compat-batteries-0.13.1/src/Foreign/Marshal/Alloc/Compat/Repl/Batteries.hs0000644000000000000000000000050607346545000025345 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Foreign.Marshal.Alloc.Compat" -- from a globally unique namespace. module Foreign.Marshal.Alloc.Compat.Repl.Batteries ( module Foreign.Marshal.Alloc.Compat ) where import "this" Foreign.Marshal.Alloc.Compat base-compat-batteries-0.13.1/src/Foreign/Marshal/Array/0000755000000000000000000000000007346545000020765 5ustar0000000000000000base-compat-batteries-0.13.1/src/Foreign/Marshal/Array/Compat.hs0000644000000000000000000000025707346545000022550 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.13.1/src/Foreign/Marshal/Array/Compat/Repl/0000755000000000000000000000000007346545000023112 5ustar0000000000000000base-compat-batteries-0.13.1/src/Foreign/Marshal/Array/Compat/Repl/Batteries.hs0000644000000000000000000000050607346545000025371 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Foreign.Marshal.Array.Compat" -- from a globally unique namespace. module Foreign.Marshal.Array.Compat.Repl.Batteries ( module Foreign.Marshal.Array.Compat ) where import "this" Foreign.Marshal.Array.Compat base-compat-batteries-0.13.1/src/Foreign/Marshal/0000755000000000000000000000000007346545000017707 5ustar0000000000000000base-compat-batteries-0.13.1/src/Foreign/Marshal/Compat.hs0000644000000000000000000000024307346545000021465 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Foreign.Marshal.Compat ( module Base ) where import "base-compat" Foreign.Marshal.Compat as Base base-compat-batteries-0.13.1/src/Foreign/Marshal/Compat/Repl/0000755000000000000000000000000007346545000022034 5ustar0000000000000000base-compat-batteries-0.13.1/src/Foreign/Marshal/Compat/Repl/Batteries.hs0000644000000000000000000000045607346545000024317 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Foreign.Marshal.Compat" -- from a globally unique namespace. module Foreign.Marshal.Compat.Repl.Batteries ( module Foreign.Marshal.Compat ) where import "this" Foreign.Marshal.Compat base-compat-batteries-0.13.1/src/Foreign/Marshal/Safe/0000755000000000000000000000000007346545000020565 5ustar0000000000000000base-compat-batteries-0.13.1/src/Foreign/Marshal/Safe/Compat.hs0000644000000000000000000000025507346545000022346 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.13.1/src/Foreign/Marshal/Safe/Compat/Repl/0000755000000000000000000000000007346545000022712 5ustar0000000000000000base-compat-batteries-0.13.1/src/Foreign/Marshal/Safe/Compat/Repl/Batteries.hs0000644000000000000000000000050207346545000025165 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Foreign.Marshal.Safe.Compat" -- from a globally unique namespace. module Foreign.Marshal.Safe.Compat.Repl.Batteries ( module Foreign.Marshal.Safe.Compat ) where import "this" Foreign.Marshal.Safe.Compat base-compat-batteries-0.13.1/src/Foreign/Marshal/Unsafe/0000755000000000000000000000000007346545000021130 5ustar0000000000000000base-compat-batteries-0.13.1/src/Foreign/Marshal/Unsafe/Compat.hs0000644000000000000000000000026107346545000022706 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.13.1/src/Foreign/Marshal/Unsafe/Compat/Repl/0000755000000000000000000000000007346545000023255 5ustar0000000000000000base-compat-batteries-0.13.1/src/Foreign/Marshal/Unsafe/Compat/Repl/Batteries.hs0000644000000000000000000000051207346545000025531 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Foreign.Marshal.Unsafe.Compat" -- from a globally unique namespace. module Foreign.Marshal.Unsafe.Compat.Repl.Batteries ( module Foreign.Marshal.Unsafe.Compat ) where import "this" Foreign.Marshal.Unsafe.Compat base-compat-batteries-0.13.1/src/Foreign/Marshal/Utils/0000755000000000000000000000000007346545000021007 5ustar0000000000000000base-compat-batteries-0.13.1/src/Foreign/Marshal/Utils/Compat.hs0000644000000000000000000000025707346545000022572 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.13.1/src/Foreign/Marshal/Utils/Compat/Repl/0000755000000000000000000000000007346545000023134 5ustar0000000000000000base-compat-batteries-0.13.1/src/Foreign/Marshal/Utils/Compat/Repl/Batteries.hs0000644000000000000000000000050607346545000025413 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Foreign.Marshal.Utils.Compat" -- from a globally unique namespace. module Foreign.Marshal.Utils.Compat.Repl.Batteries ( module Foreign.Marshal.Utils.Compat ) where import "this" Foreign.Marshal.Utils.Compat base-compat-batteries-0.13.1/src/Numeric/0000755000000000000000000000000007346545000016331 5ustar0000000000000000base-compat-batteries-0.13.1/src/Numeric/Compat.hs0000644000000000000000000000022307346545000020105 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Numeric.Compat ( module Base ) where import "base-compat" Numeric.Compat as Base base-compat-batteries-0.13.1/src/Numeric/Compat/Repl/0000755000000000000000000000000007346545000020456 5ustar0000000000000000base-compat-batteries-0.13.1/src/Numeric/Compat/Repl/Batteries.hs0000644000000000000000000000041607346545000022735 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Numeric.Compat" -- from a globally unique namespace. module Numeric.Compat.Repl.Batteries ( module Numeric.Compat ) where import "this" Numeric.Compat base-compat-batteries-0.13.1/src/Numeric/Natural/0000755000000000000000000000000007346545000017737 5ustar0000000000000000base-compat-batteries-0.13.1/src/Numeric/Natural/Compat.hs0000644000000000000000000000111507346545000021514 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} #if __GLASGOW_HASKELL__ >= 702 {-# LANGUAGE Trustworthy #-} #endif module Numeric.Natural.Compat ( module Base , minusNaturalMaybe ) where #if MIN_VERSION_base(4,8,0) import "base-compat" Numeric.Natural.Compat as Base #else import "nats" Numeric.Natural as Base import "this" Prelude.Compat -- | 'Natural' subtraction. Returns 'Nothing's for non-positive results. -- -- /Since: 4.18.0.0/ minusNaturalMaybe :: Natural -> Natural -> Maybe Natural minusNaturalMaybe x y | x < y = Nothing | otherwise = Just (x - y) #endif base-compat-batteries-0.13.1/src/Numeric/Natural/Compat/Repl/0000755000000000000000000000000007346545000022064 5ustar0000000000000000base-compat-batteries-0.13.1/src/Numeric/Natural/Compat/Repl/Batteries.hs0000644000000000000000000000045607346545000024347 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Numeric.Natural.Compat" -- from a globally unique namespace. module Numeric.Natural.Compat.Repl.Batteries ( module Numeric.Natural.Compat ) where import "this" Numeric.Natural.Compat base-compat-batteries-0.13.1/src/Prelude/0000755000000000000000000000000007346545000016327 5ustar0000000000000000base-compat-batteries-0.13.1/src/Prelude/Compat.hs0000644000000000000000000000065007346545000020107 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Prelude.Compat ( module Base #if !(MIN_VERSION_base(4,9,0)) , Fail.MonadFail(Fail.fail) , Semi.Semigroup((Semi.<>)) #endif ) where import "base-compat" Prelude.Compat as Base #if !(MIN_VERSION_base(4,9,0)) hiding (fail) #endif #if !(MIN_VERSION_base(4,9,0)) import "fail" Control.Monad.Fail as Fail import "semigroups" Data.Semigroup as Semi #endif base-compat-batteries-0.13.1/src/Prelude/Compat/Repl/0000755000000000000000000000000007346545000020454 5ustar0000000000000000base-compat-batteries-0.13.1/src/Prelude/Compat/Repl/Batteries.hs0000644000000000000000000000041607346545000022733 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Prelude.Compat" -- from a globally unique namespace. module Prelude.Compat.Repl.Batteries ( module Prelude.Compat ) where import "this" Prelude.Compat base-compat-batteries-0.13.1/src/System/Environment/0000755000000000000000000000000007346545000020517 5ustar0000000000000000base-compat-batteries-0.13.1/src/System/Environment/Compat.hs0000644000000000000000000000025107346545000022274 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module System.Environment.Compat ( module Base ) where import "base-compat" System.Environment.Compat as Base base-compat-batteries-0.13.1/src/System/Environment/Compat/Repl/0000755000000000000000000000000007346545000022644 5ustar0000000000000000base-compat-batteries-0.13.1/src/System/Environment/Compat/Repl/Batteries.hs0000644000000000000000000000047207346545000025125 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "System.Environment.Compat" -- from a globally unique namespace. module System.Environment.Compat.Repl.Batteries ( module System.Environment.Compat ) where import "this" System.Environment.Compat base-compat-batteries-0.13.1/src/System/Exit/0000755000000000000000000000000007346545000017124 5ustar0000000000000000base-compat-batteries-0.13.1/src/System/Exit/Compat.hs0000644000000000000000000000023307346545000020701 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module System.Exit.Compat ( module Base ) where import "base-compat" System.Exit.Compat as Base base-compat-batteries-0.13.1/src/System/Exit/Compat/Repl/0000755000000000000000000000000007346545000021251 5ustar0000000000000000base-compat-batteries-0.13.1/src/System/Exit/Compat/Repl/Batteries.hs0000644000000000000000000000043607346545000023532 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "System.Exit.Compat" -- from a globally unique namespace. module System.Exit.Compat.Repl.Batteries ( module System.Exit.Compat ) where import "this" System.Exit.Compat base-compat-batteries-0.13.1/src/System/IO/0000755000000000000000000000000007346545000016522 5ustar0000000000000000base-compat-batteries-0.13.1/src/System/IO/Compat.hs0000644000000000000000000000022707346545000020302 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module System.IO.Compat ( module Base ) where import "base-compat" System.IO.Compat as Base base-compat-batteries-0.13.1/src/System/IO/Compat/Repl/0000755000000000000000000000000007346545000020647 5ustar0000000000000000base-compat-batteries-0.13.1/src/System/IO/Compat/Repl/Batteries.hs0000644000000000000000000000042607346545000023127 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "System.IO.Compat" -- from a globally unique namespace. module System.IO.Compat.Repl.Batteries ( module System.IO.Compat ) where import "this" System.IO.Compat base-compat-batteries-0.13.1/src/System/IO/Error/0000755000000000000000000000000007346545000017613 5ustar0000000000000000base-compat-batteries-0.13.1/src/System/IO/Error/Compat.hs0000644000000000000000000000024307346545000021371 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.13.1/src/System/IO/Error/Compat/Repl/0000755000000000000000000000000007346545000021740 5ustar0000000000000000base-compat-batteries-0.13.1/src/System/IO/Error/Compat/Repl/Batteries.hs0000644000000000000000000000045607346545000024223 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "System.IO.Error.Compat" -- from a globally unique namespace. module System.IO.Error.Compat.Repl.Batteries ( module System.IO.Error.Compat ) where import "this" System.IO.Error.Compat base-compat-batteries-0.13.1/src/System/IO/Unsafe/0000755000000000000000000000000007346545000017743 5ustar0000000000000000base-compat-batteries-0.13.1/src/System/IO/Unsafe/Compat.hs0000644000000000000000000000024507346545000021523 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.13.1/src/System/IO/Unsafe/Compat/Repl/0000755000000000000000000000000007346545000022070 5ustar0000000000000000base-compat-batteries-0.13.1/src/System/IO/Unsafe/Compat/Repl/Batteries.hs0000644000000000000000000000046207346545000024350 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "System.IO.Unsafe.Compat" -- from a globally unique namespace. module System.IO.Unsafe.Compat.Repl.Batteries ( module System.IO.Unsafe.Compat ) where import "this" System.IO.Unsafe.Compat base-compat-batteries-0.13.1/src/Text/Read/0000755000000000000000000000000007346545000016526 5ustar0000000000000000base-compat-batteries-0.13.1/src/Text/Read/Compat.hs0000644000000000000000000000022707346545000020306 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Text.Read.Compat ( module Base ) where import "base-compat" Text.Read.Compat as Base base-compat-batteries-0.13.1/src/Text/Read/Compat/Repl/0000755000000000000000000000000007346545000020653 5ustar0000000000000000base-compat-batteries-0.13.1/src/Text/Read/Compat/Repl/Batteries.hs0000644000000000000000000000042607346545000023133 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Text.Read.Compat" -- from a globally unique namespace. module Text.Read.Compat.Repl.Batteries ( module Text.Read.Compat ) where import "this" Text.Read.Compat base-compat-batteries-0.13.1/src/Text/Read/Lex/0000755000000000000000000000000007346545000017256 5ustar0000000000000000base-compat-batteries-0.13.1/src/Text/Read/Lex/Compat.hs0000644000000000000000000000023707346545000021037 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.13.1/src/Text/Read/Lex/Compat/Repl/0000755000000000000000000000000007346545000021403 5ustar0000000000000000base-compat-batteries-0.13.1/src/Text/Read/Lex/Compat/Repl/Batteries.hs0000644000000000000000000000044607346545000023665 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Text.Read.Lex.Compat" -- from a globally unique namespace. module Text.Read.Lex.Compat.Repl.Batteries ( module Text.Read.Lex.Compat ) where import "this" Text.Read.Lex.Compat base-compat-batteries-0.13.1/src/Type/Reflection/0000755000000000000000000000000007346545000017742 5ustar0000000000000000base-compat-batteries-0.13.1/src/Type/Reflection/Compat.hs0000644000000000000000000000035307346545000021522 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.13.1/src/Type/Reflection/Compat/Repl/0000755000000000000000000000000007346545000022067 5ustar0000000000000000base-compat-batteries-0.13.1/src/Type/Reflection/Compat/Repl/Batteries.hs0000644000000000000000000000045607346545000024352 0ustar0000000000000000{-# LANGUAGE PackageImports #-} {-# OPTIONS_GHC -fno-warn-dodgy-exports -fno-warn-unused-imports #-} -- | Reexports "Type.Reflection.Compat" -- from a globally unique namespace. module Type.Reflection.Compat.Repl.Batteries ( module Type.Reflection.Compat ) where import "this" Type.Reflection.Compat base-compat-batteries-0.13.1/test/Control/Monad/0000755000000000000000000000000007346545000017575 5ustar0000000000000000base-compat-batteries-0.13.1/test/Control/Monad/CompatSpec.hs0000644000000000000000000000055607346545000022175 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.13.1/test/Data/Bits/0000755000000000000000000000000007346545000016671 5ustar0000000000000000base-compat-batteries-0.13.1/test/Data/Bits/CompatSpec.hs0000644000000000000000000000237007346545000021265 0ustar0000000000000000{-# LANGUAGE CPP #-} module 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 #if MIN_VERSION_base(4,7,0) 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) #endif base-compat-batteries-0.13.1/test/Data/Bool/0000755000000000000000000000000007346545000016663 5ustar0000000000000000base-compat-batteries-0.13.1/test/Data/Bool/CompatSpec.hs0000644000000000000000000000063007346545000021254 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.13.1/test/Data/Either/0000755000000000000000000000000007346545000017210 5ustar0000000000000000base-compat-batteries-0.13.1/test/Data/Either/CompatSpec.hs0000644000000000000000000000124107346545000021600 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.13.1/test/Data/Foldable/0000755000000000000000000000000007346545000017500 5ustar0000000000000000base-compat-batteries-0.13.1/test/Data/Foldable/CompatSpec.hs0000644000000000000000000000045707346545000022100 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.13.1/test/Data/Function/0000755000000000000000000000000007346545000017555 5ustar0000000000000000base-compat-batteries-0.13.1/test/Data/Function/CompatSpec.hs0000644000000000000000000000042307346545000022146 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.13.1/test/Data/Functor/0000755000000000000000000000000007346545000017410 5ustar0000000000000000base-compat-batteries-0.13.1/test/Data/Functor/CompatSpec.hs0000644000000000000000000000064007346545000022002 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.13.1/test/Data/IORef/0000755000000000000000000000000007346545000016734 5ustar0000000000000000base-compat-batteries-0.13.1/test/Data/IORef/CompatSpec.hs0000644000000000000000000000122207346545000021323 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.13.1/test/Data/List/0000755000000000000000000000000007346545000016703 5ustar0000000000000000base-compat-batteries-0.13.1/test/Data/List/CompatSpec.hs0000644000000000000000000000306107346545000021275 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.13.1/test/Data/Monoid/0000755000000000000000000000000007346545000017215 5ustar0000000000000000base-compat-batteries-0.13.1/test/Data/Monoid/CompatSpec.hs0000644000000000000000000000066307346545000021614 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.13.1/test/Data/STRef/0000755000000000000000000000000007346545000016753 5ustar0000000000000000base-compat-batteries-0.13.1/test/Data/STRef/CompatSpec.hs0000644000000000000000000000072007346545000021344 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.13.1/test/Data/Version/0000755000000000000000000000000007346545000017415 5ustar0000000000000000base-compat-batteries-0.13.1/test/Data/Version/CompatSpec.hs0000644000000000000000000000040107346545000022002 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.13.1/test/Data/Word/0000755000000000000000000000000007346545000016703 5ustar0000000000000000base-compat-batteries-0.13.1/test/Data/Word/CompatSpec.hs0000644000000000000000000000132107346545000021272 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.13.1/test/Foreign/Marshal/Alloc/0000755000000000000000000000000007346545000021131 5ustar0000000000000000base-compat-batteries-0.13.1/test/Foreign/Marshal/Alloc/CompatSpec.hs0000644000000000000000000000064507346545000023530 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.13.1/test/Foreign/Marshal/Utils/0000755000000000000000000000000007346545000021177 5ustar0000000000000000base-compat-batteries-0.13.1/test/Foreign/Marshal/Utils/CompatSpec.hs0000644000000000000000000000073207346545000023573 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.13.1/test/Numeric/0000755000000000000000000000000007346545000016521 5ustar0000000000000000base-compat-batteries-0.13.1/test/Numeric/CompatSpec.hs0000644000000000000000000000417407346545000021121 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.13.1/test/Prelude/0000755000000000000000000000000007346545000016517 5ustar0000000000000000base-compat-batteries-0.13.1/test/Prelude/CompatSpec.hs0000644000000000000000000000061607346545000021114 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.13.1/test/0000755000000000000000000000000007346545000015117 5ustar0000000000000000base-compat-batteries-0.13.1/test/SafeHaskellSpec.hs0000644000000000000000000000423707346545000020456 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude #-} #if __GLASGOW_HASKELL__ >= 704 {-# LANGUAGE Safe #-} #endif 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.13.1/test/Spec.hs0000644000000000000000000000005407346545000016344 0ustar0000000000000000{-# OPTIONS_GHC -F -pgmF hspec-discover #-} base-compat-batteries-0.13.1/test/System/Environment/0000755000000000000000000000000007346545000020707 5ustar0000000000000000base-compat-batteries-0.13.1/test/System/Environment/CompatSpec.hs0000644000000000000000000000763507346545000023314 0ustar0000000000000000{-# LANGUAGE CPP #-} module System.Environment.CompatSpec (main, spec) where import Test.Hspec #if __GLASGOW_HASKELL__ >= 704 import Test.QuickCheck #endif 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 #if __GLASGOW_HASKELL__ >= 704 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 #endif 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" #if __GLASGOW_HASKELL__ >= 704 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 #endif 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 #if __GLASGOW_HASKELL__ >= 704 it "works for arbitrary keys" $ property $ \k -> ('\NUL' `notElem` k && '=' `notElem` k && (not . null) k) ==> do setEnv k "foo" getEnv k `shouldReturn` "foo" #endif base-compat-batteries-0.13.1/test/TestHspecTrustworthy.hs0000644000000000000000000000033207346545000021672 0ustar0000000000000000{-# LANGUAGE CPP #-} #if __GLASGOW_HASKELL__ >= 702 {-# LANGUAGE Trustworthy #-} #endif -- | Reexports "Test.Hspec" from a @Trustworthy@ module. module TestHspecTrustworthy (module Test.Hspec) where import Test.Hspec base-compat-batteries-0.13.1/test/Text/Read/0000755000000000000000000000000007346545000016716 5ustar0000000000000000base-compat-batteries-0.13.1/test/Text/Read/CompatSpec.hs0000644000000000000000000000117607346545000021315 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)