base-compat-batteries-0.12.3/0000755000000000000000000000000007346545000014141 5ustar0000000000000000base-compat-batteries-0.12.3/CHANGES.markdown0000644000000000000000000001225307346545000016760 0ustar0000000000000000## 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.12.3/LICENSE0000644000000000000000000000214007346545000015143 0ustar0000000000000000Copyright (c) 2012-2018 Simon Hengel and Ryan Scott Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. base-compat-batteries-0.12.3/README.markdown0000644000000000000000000000311407346545000016641 0ustar0000000000000000# `base-compat` with extra batteries [![Hackage](https://img.shields.io/hackage/v/base-compat-batteries.svg)][Hackage: base-compat-batteries] [![Hackage Dependencies](https://img.shields.io/hackage-deps/v/base-compat-batteries.svg)](http://packdeps.haskellers.com/reverse/base-compat-batteries) [![Haskell Programming Language](https://img.shields.io/badge/language-Haskell-blue.svg)][Haskell.org] [![BSD3 License](http://img.shields.io/badge/license-MIT-brightgreen.svg)][tl;dr Legal: MIT] [Hackage: base-compat-batteries]: http://hackage.haskell.org/package/base-compat-batteries "base-compat-batteries package on Hackage" [Haskell.org]: http://www.haskell.org "The Haskell Programming Language" [tl;dr Legal: MIT]: https://tldrlegal.com/license/mit-license "MIT License" ## Scope `base-compat-batteries` provides functions available in later versions of `base` to a wider range of compilers, without requiring you to use CPP pragmas in your code. This package provides the same API as the [`base-compat`](http://hackage.haskell.org/package/base-compat) library, but depends on compatibility packages (such as `semigroups`) to offer a wider support window than `base-compat`, which has no dependencies. Like `base-compat`, `base-compat-batteries` does not add any orphan instances. There is a separate package [`base-orphans`](https://github.com/haskell-compat/base-orphans) for that. See [here](https://github.com/haskell-compat/base-compat/blob/master/base-compat/README.markdown#dependencies) for a more comprehensive list of differences between `base-compat` and `base-compat-batteries`. base-compat-batteries-0.12.3/Setup.lhs0000644000000000000000000000011407346545000015745 0ustar0000000000000000#!/usr/bin/env runhaskell > import Distribution.Simple > main = defaultMain base-compat-batteries-0.12.3/base-compat-batteries.cabal0000644000000000000000000002270207346545000021303 0ustar0000000000000000name: base-compat-batteries version: 0.12.3 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 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.12.3, 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: bifunctors >= 5.5.2 && < 5.6, type-equality >= 1 && < 1.1 if !impl(ghc >= 8.6) build-depends: contravariant >= 1.5 && < 1.6 if !impl(ghc >= 9.0) build-depends: OneTuple >= 0.3 && < 0.5 -- We want to consistently use `Solo` as the name of the data constructor -- for the base-compat-0.12.* series when building with a pre-9.6 version -- of GHC. This is only possible on pre-7.8 versions of GHC (which do not -- support pattern synonyms) with OneTuple-0.3.*, which defines a `Solo` -- data constructor. (In OneTuple-0.4.* and later, the data constructor is -- instead named `MkSolo`.) if !impl(ghc >= 7.8) build-depends: OneTuple == 0.3.* ghc-options: -fno-warn-duplicate-exports if impl(ghc >= 7.10) ghc-options: -fno-warn-trustworthy-safe hs-source-dirs: src exposed-modules: Control.Concurrent.Compat Control.Concurrent.MVar.Compat Control.Exception.Compat Control.Monad.Compat Control.Monad.Fail.Compat Control.Monad.IO.Class.Compat Control.Monad.ST.Lazy.Unsafe.Compat Control.Monad.ST.Unsafe.Compat Data.Bifoldable.Compat Data.Bifunctor.Compat Data.Bitraversable.Compat Data.Bits.Compat Data.Bool.Compat Data.Complex.Compat Data.Either.Compat Data.Foldable.Compat Data.Function.Compat Data.Functor.Compat Data.Functor.Compose.Compat Data.Functor.Const.Compat Data.Functor.Contravariant.Compat Data.Functor.Identity.Compat Data.Functor.Product.Compat Data.Functor.Sum.Compat Data.IORef.Compat Data.List.Compat Data.List.NonEmpty.Compat Data.Monoid.Compat Data.Proxy.Compat Data.Ratio.Compat Data.Semigroup.Compat Data.STRef.Compat Data.String.Compat Data.Tuple.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.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.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.Tuple.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 T91Spec 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.12.3/src/Control/Concurrent/0000755000000000000000000000000007346545000020472 5ustar0000000000000000base-compat-batteries-0.12.3/src/Control/Concurrent/Compat.hs0000644000000000000000000000025107346545000022247 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Control.Concurrent.Compat ( module Base ) where import "base-compat" Control.Concurrent.Compat as Base base-compat-batteries-0.12.3/src/Control/Concurrent/Compat/Repl/0000755000000000000000000000000007346545000022617 5ustar0000000000000000base-compat-batteries-0.12.3/src/Control/Concurrent/Compat/Repl/Batteries.hs0000644000000000000000000000047207346545000025100 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.12.3/src/Control/Concurrent/MVar/0000755000000000000000000000000007346545000021337 5ustar0000000000000000base-compat-batteries-0.12.3/src/Control/Concurrent/MVar/Compat.hs0000644000000000000000000000026307346545000023117 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Control.Concurrent.MVar.Compat ( module Base ) where import "base-compat" Control.Concurrent.MVar.Compat as Base base-compat-batteries-0.12.3/src/Control/Concurrent/MVar/Compat/Repl/0000755000000000000000000000000007346545000023464 5ustar0000000000000000base-compat-batteries-0.12.3/src/Control/Concurrent/MVar/Compat/Repl/Batteries.hs0000644000000000000000000000051607346545000025744 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.12.3/src/Control/Exception/0000755000000000000000000000000007346545000020306 5ustar0000000000000000base-compat-batteries-0.12.3/src/Control/Exception/Compat.hs0000644000000000000000000000024707346545000022070 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Control.Exception.Compat ( module Base ) where import "base-compat" Control.Exception.Compat as Base base-compat-batteries-0.12.3/src/Control/Exception/Compat/Repl/0000755000000000000000000000000007346545000022433 5ustar0000000000000000base-compat-batteries-0.12.3/src/Control/Exception/Compat/Repl/Batteries.hs0000644000000000000000000000046607346545000024717 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.12.3/src/Control/Monad/0000755000000000000000000000000007346545000017406 5ustar0000000000000000base-compat-batteries-0.12.3/src/Control/Monad/Compat.hs0000644000000000000000000000032507346545000021165 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Control.Monad.Compat ( module Base , fail ) where import "base-compat" Control.Monad.Compat as Base hiding (fail) import Control.Monad.Fail (fail) base-compat-batteries-0.12.3/src/Control/Monad/Compat/Repl/0000755000000000000000000000000007346545000021533 5ustar0000000000000000base-compat-batteries-0.12.3/src/Control/Monad/Compat/Repl/Batteries.hs0000644000000000000000000000044607346545000024015 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.12.3/src/Control/Monad/Fail/0000755000000000000000000000000007346545000020261 5ustar0000000000000000base-compat-batteries-0.12.3/src/Control/Monad/Fail/Compat.hs0000644000000000000000000000037307346545000022043 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.12.3/src/Control/Monad/Fail/Compat/Repl/0000755000000000000000000000000007346545000022406 5ustar0000000000000000base-compat-batteries-0.12.3/src/Control/Monad/Fail/Compat/Repl/Batteries.hs0000644000000000000000000000047207346545000024667 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.12.3/src/Control/Monad/IO/Class/0000755000000000000000000000000007346545000020762 5ustar0000000000000000base-compat-batteries-0.12.3/src/Control/Monad/IO/Class/Compat.hs0000644000000000000000000000040007346545000022533 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.12.3/src/Control/Monad/IO/Class/Compat/Repl/0000755000000000000000000000000007346545000023107 5ustar0000000000000000base-compat-batteries-0.12.3/src/Control/Monad/IO/Class/Compat/Repl/Batteries.hs0000644000000000000000000000051207346545000025363 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.12.3/src/Control/Monad/ST/Lazy/Unsafe/0000755000000000000000000000000007346545000022074 5ustar0000000000000000base-compat-batteries-0.12.3/src/Control/Monad/ST/Lazy/Unsafe/Compat.hs0000644000000000000000000000027507346545000023657 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Control.Monad.ST.Lazy.Unsafe.Compat ( module Base ) where import "base-compat" Control.Monad.ST.Lazy.Unsafe.Compat as Base base-compat-batteries-0.12.3/src/Control/Monad/ST/Lazy/Unsafe/Compat/Repl/0000755000000000000000000000000007346545000024221 5ustar0000000000000000base-compat-batteries-0.12.3/src/Control/Monad/ST/Lazy/Unsafe/Compat/Repl/Batteries.hs0000644000000000000000000000054207346545000026500 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.12.3/src/Control/Monad/ST/Unsafe/0000755000000000000000000000000007346545000021155 5ustar0000000000000000base-compat-batteries-0.12.3/src/Control/Monad/ST/Unsafe/Compat.hs0000644000000000000000000000026307346545000022735 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Control.Monad.ST.Unsafe.Compat ( module Base ) where import "base-compat" Control.Monad.ST.Unsafe.Compat as Base base-compat-batteries-0.12.3/src/Control/Monad/ST/Unsafe/Compat/Repl/0000755000000000000000000000000007346545000023302 5ustar0000000000000000base-compat-batteries-0.12.3/src/Control/Monad/ST/Unsafe/Compat/Repl/Batteries.hs0000644000000000000000000000051607346545000025562 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.12.3/src/Data/Bifoldable/0000755000000000000000000000000007346545000017624 5ustar0000000000000000base-compat-batteries-0.12.3/src/Data/Bifoldable/Compat.hs0000644000000000000000000000037107346545000021404 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 "bifunctors" Data.Bifoldable as Base #endif base-compat-batteries-0.12.3/src/Data/Bifoldable/Compat/Repl/0000755000000000000000000000000007346545000021751 5ustar0000000000000000base-compat-batteries-0.12.3/src/Data/Bifoldable/Compat/Repl/Batteries.hs0000644000000000000000000000045607346545000024234 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.12.3/src/Data/Bifunctor/0000755000000000000000000000000007346545000017534 5ustar0000000000000000base-compat-batteries-0.12.3/src/Data/Bifunctor/Compat.hs0000644000000000000000000000036507346545000021317 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 "bifunctors" Data.Bifunctor as Base #endif base-compat-batteries-0.12.3/src/Data/Bifunctor/Compat/Repl/0000755000000000000000000000000007346545000021661 5ustar0000000000000000base-compat-batteries-0.12.3/src/Data/Bifunctor/Compat/Repl/Batteries.hs0000644000000000000000000000045207346545000024140 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.12.3/src/Data/Bitraversable/0000755000000000000000000000000007346545000020366 5ustar0000000000000000base-compat-batteries-0.12.3/src/Data/Bitraversable/Compat.hs0000644000000000000000000000040207346545000022141 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 "bifunctors" Data.Bitraversable as Base #endif base-compat-batteries-0.12.3/src/Data/Bitraversable/Compat/Repl/0000755000000000000000000000000007346545000022513 5ustar0000000000000000base-compat-batteries-0.12.3/src/Data/Bitraversable/Compat/Repl/Batteries.hs0000644000000000000000000000047207346545000024774 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.12.3/src/Data/Bits/0000755000000000000000000000000007346545000016502 5ustar0000000000000000base-compat-batteries-0.12.3/src/Data/Bits/Compat.hs0000644000000000000000000000022707346545000020262 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Data.Bits.Compat ( module Base ) where import "base-compat" Data.Bits.Compat as Base base-compat-batteries-0.12.3/src/Data/Bits/Compat/Repl/0000755000000000000000000000000007346545000020627 5ustar0000000000000000base-compat-batteries-0.12.3/src/Data/Bits/Compat/Repl/Batteries.hs0000644000000000000000000000042607346545000023107 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.12.3/src/Data/Bool/0000755000000000000000000000000007346545000016474 5ustar0000000000000000base-compat-batteries-0.12.3/src/Data/Bool/Compat.hs0000644000000000000000000000022707346545000020254 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Data.Bool.Compat ( module Base ) where import "base-compat" Data.Bool.Compat as Base base-compat-batteries-0.12.3/src/Data/Bool/Compat/Repl/0000755000000000000000000000000007346545000020621 5ustar0000000000000000base-compat-batteries-0.12.3/src/Data/Bool/Compat/Repl/Batteries.hs0000644000000000000000000000042607346545000023101 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.12.3/src/Data/Complex/0000755000000000000000000000000007346545000017210 5ustar0000000000000000base-compat-batteries-0.12.3/src/Data/Complex/Compat.hs0000644000000000000000000000023507346545000020767 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Data.Complex.Compat ( module Base ) where import "base-compat" Data.Complex.Compat as Base base-compat-batteries-0.12.3/src/Data/Complex/Compat/Repl/0000755000000000000000000000000007346545000021335 5ustar0000000000000000base-compat-batteries-0.12.3/src/Data/Complex/Compat/Repl/Batteries.hs0000644000000000000000000000044207346545000023613 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.12.3/src/Data/Either/0000755000000000000000000000000007346545000017021 5ustar0000000000000000base-compat-batteries-0.12.3/src/Data/Either/Compat.hs0000644000000000000000000000023307346545000020576 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Data.Either.Compat ( module Base ) where import "base-compat" Data.Either.Compat as Base base-compat-batteries-0.12.3/src/Data/Either/Compat/Repl/0000755000000000000000000000000007346545000021146 5ustar0000000000000000base-compat-batteries-0.12.3/src/Data/Either/Compat/Repl/Batteries.hs0000644000000000000000000000043607346545000023427 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.12.3/src/Data/Foldable/0000755000000000000000000000000007346545000017311 5ustar0000000000000000base-compat-batteries-0.12.3/src/Data/Foldable/Compat.hs0000644000000000000000000000023707346545000021072 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Data.Foldable.Compat ( module Base ) where import "base-compat" Data.Foldable.Compat as Base base-compat-batteries-0.12.3/src/Data/Foldable/Compat/Repl/0000755000000000000000000000000007346545000021436 5ustar0000000000000000base-compat-batteries-0.12.3/src/Data/Foldable/Compat/Repl/Batteries.hs0000644000000000000000000000044607346545000023720 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.12.3/src/Data/Function/0000755000000000000000000000000007346545000017366 5ustar0000000000000000base-compat-batteries-0.12.3/src/Data/Function/Compat.hs0000644000000000000000000000023707346545000021147 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Data.Function.Compat ( module Base ) where import "base-compat" Data.Function.Compat as Base base-compat-batteries-0.12.3/src/Data/Function/Compat/Repl/0000755000000000000000000000000007346545000021513 5ustar0000000000000000base-compat-batteries-0.12.3/src/Data/Function/Compat/Repl/Batteries.hs0000644000000000000000000000044607346545000023775 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.12.3/src/Data/Functor/0000755000000000000000000000000007346545000017221 5ustar0000000000000000base-compat-batteries-0.12.3/src/Data/Functor/Compat.hs0000644000000000000000000000151307346545000021000 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude #-} module Data.Functor.Compat ( module Base , Functor(..) , ($>) , void , (<&>) ) where import Data.Functor as Base #if !(MIN_VERSION_base(4,7,0)) import Control.Monad.Compat (void) import Data.Function (flip) #endif #if !(MIN_VERSION_base(4,7,0)) infixl 4 $> -- | Flipped version of '$>'. -- -- /Since: 4.7.0.0/ ($>) :: Functor f => f a -> b -> f b ($>) = flip (<$) #endif #if !(MIN_VERSION_base(4,11,0)) -- | Flipped version of '<$>'. -- -- @ -- ('<&>') = 'flip' 'fmap' -- @ -- -- /Since: 4.11.0.0/ -- -- ==== __Examples__ -- Apply @(+1)@ to a list, a 'Data.Maybe.Just' and a 'Data.Either.Right': -- -- >>> Just 2 <&> (+1) -- Just 3 -- -- >>> [1,2,3] <&> (+1) -- [2,3,4] -- -- >>> Right 3 <&> (+1) -- Right 4 -- (<&>) :: Functor f => f a -> (a -> b) -> f b as <&> f = f <$> as infixl 1 <&> #endif base-compat-batteries-0.12.3/src/Data/Functor/Compat/Repl/0000755000000000000000000000000007346545000021346 5ustar0000000000000000base-compat-batteries-0.12.3/src/Data/Functor/Compat/Repl/Batteries.hs0000644000000000000000000000044207346545000023624 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.12.3/src/Data/Functor/Compose/0000755000000000000000000000000007346545000020626 5ustar0000000000000000base-compat-batteries-0.12.3/src/Data/Functor/Compose/Compat.hs0000644000000000000000000000037207346545000022407 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.12.3/src/Data/Functor/Compose/Compat/Repl/0000755000000000000000000000000007346545000022753 5ustar0000000000000000base-compat-batteries-0.12.3/src/Data/Functor/Compose/Compat/Repl/Batteries.hs0000644000000000000000000000050207346545000025226 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.12.3/src/Data/Functor/Const/0000755000000000000000000000000007346545000020307 5ustar0000000000000000base-compat-batteries-0.12.3/src/Data/Functor/Const/Compat.hs0000644000000000000000000000025107346545000022064 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Data.Functor.Const.Compat ( module Base ) where import "base-compat" Data.Functor.Const.Compat as Base base-compat-batteries-0.12.3/src/Data/Functor/Const/Compat/Repl/0000755000000000000000000000000007346545000022434 5ustar0000000000000000base-compat-batteries-0.12.3/src/Data/Functor/Const/Compat/Repl/Batteries.hs0000644000000000000000000000047207346545000024715 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.12.3/src/Data/Functor/Contravariant/0000755000000000000000000000000007346545000022034 5ustar0000000000000000base-compat-batteries-0.12.3/src/Data/Functor/Contravariant/Compat.hs0000644000000000000000000000043707346545000023617 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Data.Functor.Contravariant.Compat ( module Base ) where #if MIN_VERSION_base(4,12,0) import "base-compat" Data.Functor.Contravariant.Compat as Base #else import "contravariant" Data.Functor.Contravariant as Base #endif base-compat-batteries-0.12.3/src/Data/Functor/Contravariant/Compat/Repl/0000755000000000000000000000000007346545000024161 5ustar0000000000000000base-compat-batteries-0.12.3/src/Data/Functor/Contravariant/Compat/Repl/Batteries.hs0000644000000000000000000000053207346545000026437 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.12.3/src/Data/Functor/Identity/0000755000000000000000000000000007346545000021012 5ustar0000000000000000base-compat-batteries-0.12.3/src/Data/Functor/Identity/Compat.hs0000644000000000000000000000037507346545000022576 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.12.3/src/Data/Functor/Identity/Compat/Repl/0000755000000000000000000000000007346545000023137 5ustar0000000000000000base-compat-batteries-0.12.3/src/Data/Functor/Identity/Compat/Repl/Batteries.hs0000644000000000000000000000050607346545000025416 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.12.3/src/Data/Functor/Product/0000755000000000000000000000000007346545000020641 5ustar0000000000000000base-compat-batteries-0.12.3/src/Data/Functor/Product/Compat.hs0000644000000000000000000000037207346545000022422 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.12.3/src/Data/Functor/Product/Compat/Repl/0000755000000000000000000000000007346545000022766 5ustar0000000000000000base-compat-batteries-0.12.3/src/Data/Functor/Product/Compat/Repl/Batteries.hs0000644000000000000000000000050207346545000025241 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.12.3/src/Data/Functor/Sum/0000755000000000000000000000000007346545000017765 5ustar0000000000000000base-compat-batteries-0.12.3/src/Data/Functor/Sum/Compat.hs0000644000000000000000000000035607346545000021550 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.12.3/src/Data/Functor/Sum/Compat/Repl/0000755000000000000000000000000007346545000022112 5ustar0000000000000000base-compat-batteries-0.12.3/src/Data/Functor/Sum/Compat/Repl/Batteries.hs0000644000000000000000000000046207346545000024372 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.12.3/src/Data/IORef/0000755000000000000000000000000007346545000016545 5ustar0000000000000000base-compat-batteries-0.12.3/src/Data/IORef/Compat.hs0000644000000000000000000000023107346545000020320 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Data.IORef.Compat ( module Base ) where import "base-compat" Data.IORef.Compat as Base base-compat-batteries-0.12.3/src/Data/IORef/Compat/Repl/0000755000000000000000000000000007346545000020672 5ustar0000000000000000base-compat-batteries-0.12.3/src/Data/IORef/Compat/Repl/Batteries.hs0000644000000000000000000000043207346545000023147 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.12.3/src/Data/List/0000755000000000000000000000000007346545000016514 5ustar0000000000000000base-compat-batteries-0.12.3/src/Data/List/Compat.hs0000644000000000000000000000022707346545000020274 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Data.List.Compat ( module Base ) where import "base-compat" Data.List.Compat as Base base-compat-batteries-0.12.3/src/Data/List/Compat/Repl/0000755000000000000000000000000007346545000020641 5ustar0000000000000000base-compat-batteries-0.12.3/src/Data/List/Compat/Repl/Batteries.hs0000644000000000000000000000042607346545000023121 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.12.3/src/Data/List/NonEmpty/0000755000000000000000000000000007346545000020265 5ustar0000000000000000base-compat-batteries-0.12.3/src/Data/List/NonEmpty/Compat.hs0000644000000000000000000000321107346545000022041 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 , tails -- * Building streams , iterate , repeat , cycle , unfold , insert , some1 -- * Extracting sublists , take , drop , splitAt , takeWhile , dropWhile , span , break , filter , partition , group , groupBy , groupWith , groupAllWith , group1 , groupBy1 , groupWith1 , groupAllWith1 -- * Sublist predicates , isPrefixOf -- * \"Set\" operations , nub , nubBy -- * Indexing streams , (!!) -- * Zipping and unzipping streams , zip , zipWith , unzip -- * Converting to and from a list , fromList , toList , nonEmpty , xor ) where #if MIN_VERSION_base(4,9,0) import "base-compat" Data.List.NonEmpty.Compat #else import "semigroups" Data.List.NonEmpty #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 :| [] #endif base-compat-batteries-0.12.3/src/Data/List/NonEmpty/Compat/Repl/0000755000000000000000000000000007346545000022412 5ustar0000000000000000base-compat-batteries-0.12.3/src/Data/List/NonEmpty/Compat/Repl/Batteries.hs0000644000000000000000000000047207346545000024673 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.12.3/src/Data/Monoid/0000755000000000000000000000000007346545000017026 5ustar0000000000000000base-compat-batteries-0.12.3/src/Data/Monoid/Compat.hs0000644000000000000000000000031507346545000020604 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Data.Monoid.Compat ( module Base , (<>) ) where import "base-compat" Data.Monoid.Compat as Base hiding ((<>)) import Data.Semigroup ((<>)) base-compat-batteries-0.12.3/src/Data/Monoid/Compat/Repl/0000755000000000000000000000000007346545000021153 5ustar0000000000000000base-compat-batteries-0.12.3/src/Data/Monoid/Compat/Repl/Batteries.hs0000644000000000000000000000043607346545000023434 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.12.3/src/Data/Proxy/0000755000000000000000000000000007346545000016722 5ustar0000000000000000base-compat-batteries-0.12.3/src/Data/Proxy/Compat.hs0000644000000000000000000000034507346545000020503 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.12.3/src/Data/Proxy/Compat/Repl/0000755000000000000000000000000007346545000021047 5ustar0000000000000000base-compat-batteries-0.12.3/src/Data/Proxy/Compat/Repl/Batteries.hs0000644000000000000000000000043207346545000023324 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.12.3/src/Data/Ratio/0000755000000000000000000000000007346545000016657 5ustar0000000000000000base-compat-batteries-0.12.3/src/Data/Ratio/Compat.hs0000644000000000000000000000023107346545000020432 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Data.Ratio.Compat ( module Base ) where import "base-compat" Data.Ratio.Compat as Base base-compat-batteries-0.12.3/src/Data/Ratio/Compat/Repl/0000755000000000000000000000000007346545000021004 5ustar0000000000000000base-compat-batteries-0.12.3/src/Data/Ratio/Compat/Repl/Batteries.hs0000644000000000000000000000043207346545000023261 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.12.3/src/Data/STRef/0000755000000000000000000000000007346545000016564 5ustar0000000000000000base-compat-batteries-0.12.3/src/Data/STRef/Compat.hs0000644000000000000000000000023107346545000020337 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Data.STRef.Compat ( module Base ) where import "base-compat" Data.STRef.Compat as Base base-compat-batteries-0.12.3/src/Data/STRef/Compat/Repl/0000755000000000000000000000000007346545000020711 5ustar0000000000000000base-compat-batteries-0.12.3/src/Data/STRef/Compat/Repl/Batteries.hs0000644000000000000000000000043207346545000023166 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.12.3/src/Data/Semigroup/0000755000000000000000000000000007346545000017553 5ustar0000000000000000base-compat-batteries-0.12.3/src/Data/Semigroup/Compat.hs0000644000000000000000000000120607346545000021331 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.12.3/src/Data/Semigroup/Compat/Repl/0000755000000000000000000000000007346545000021700 5ustar0000000000000000base-compat-batteries-0.12.3/src/Data/Semigroup/Compat/Repl/Batteries.hs0000644000000000000000000000045207346545000024157 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.12.3/src/Data/String/0000755000000000000000000000000007346545000017047 5ustar0000000000000000base-compat-batteries-0.12.3/src/Data/String/Compat.hs0000644000000000000000000000023307346545000020624 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Data.String.Compat ( module Base ) where import "base-compat" Data.String.Compat as Base base-compat-batteries-0.12.3/src/Data/String/Compat/Repl/0000755000000000000000000000000007346545000021174 5ustar0000000000000000base-compat-batteries-0.12.3/src/Data/String/Compat/Repl/Batteries.hs0000644000000000000000000000043607346545000023455 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.12.3/src/Data/Tuple/0000755000000000000000000000000007346545000016672 5ustar0000000000000000base-compat-batteries-0.12.3/src/Data/Tuple/Compat.hs0000644000000000000000000000120107346545000020443 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} #if __GLASGOW_HASKELL__ >= 708 {-# LANGUAGE PatternSynonyms #-} #endif module Data.Tuple.Compat ( #if MIN_VERSION_ghc_prim(0,10,0) Solo(MkSolo, Solo) #elif __GLASGOW_HASKELL__ >= 708 && \ __GLASGOW_HASKELL__ < 800 && \ defined(MIN_VERSION_OneTuple) # if MIN_VERSION_OneTuple(0,4,0) Solo , pattern Solo # else Solo(Solo) # endif #else Solo(Solo) #endif , fst , snd , curry , uncurry , swap ) where #if MIN_VERSION_ghc_prim(0,7,0) import "base-compat" Data.Tuple.Compat #else import "base" Data.Tuple import "OneTuple" Data.Tuple.Solo #endif base-compat-batteries-0.12.3/src/Data/Tuple/Compat/Repl/0000755000000000000000000000000007346545000021017 5ustar0000000000000000base-compat-batteries-0.12.3/src/Data/Tuple/Compat/Repl/Batteries.hs0000644000000000000000000000043207346545000023274 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.12.3/src/Data/Type/Coercion/0000755000000000000000000000000007346545000020263 5ustar0000000000000000base-compat-batteries-0.12.3/src/Data/Type/Coercion/Compat.hs0000644000000000000000000000035707346545000022047 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.12.3/src/Data/Type/Coercion/Compat/Repl/0000755000000000000000000000000007346545000022410 5ustar0000000000000000base-compat-batteries-0.12.3/src/Data/Type/Coercion/Compat/Repl/Batteries.hs0000644000000000000000000000047207346545000024671 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.12.3/src/Data/Type/Equality/0000755000000000000000000000000007346545000020317 5ustar0000000000000000base-compat-batteries-0.12.3/src/Data/Type/Equality/Compat.hs0000644000000000000000000000165207346545000022102 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.12.3/src/Data/Type/Equality/Compat/Repl/0000755000000000000000000000000007346545000022444 5ustar0000000000000000base-compat-batteries-0.12.3/src/Data/Type/Equality/Compat/Repl/Batteries.hs0000644000000000000000000000047207346545000024725 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.12.3/src/Data/Version/0000755000000000000000000000000007346545000017226 5ustar0000000000000000base-compat-batteries-0.12.3/src/Data/Version/Compat.hs0000644000000000000000000000023507346545000021005 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Data.Version.Compat ( module Base ) where import "base-compat" Data.Version.Compat as Base base-compat-batteries-0.12.3/src/Data/Version/Compat/Repl/0000755000000000000000000000000007346545000021353 5ustar0000000000000000base-compat-batteries-0.12.3/src/Data/Version/Compat/Repl/Batteries.hs0000644000000000000000000000044207346545000023631 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.12.3/src/Data/Void/0000755000000000000000000000000007346545000016502 5ustar0000000000000000base-compat-batteries-0.12.3/src/Data/Void/Compat.hs0000644000000000000000000000035407346545000020263 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.12.3/src/Data/Void/Compat/Repl/0000755000000000000000000000000007346545000020627 5ustar0000000000000000base-compat-batteries-0.12.3/src/Data/Void/Compat/Repl/Batteries.hs0000644000000000000000000000042607346545000023107 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.12.3/src/Data/Word/0000755000000000000000000000000007346545000016514 5ustar0000000000000000base-compat-batteries-0.12.3/src/Data/Word/Compat.hs0000644000000000000000000000022707346545000020274 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Data.Word.Compat ( module Base ) where import "base-compat" Data.Word.Compat as Base base-compat-batteries-0.12.3/src/Data/Word/Compat/Repl/0000755000000000000000000000000007346545000020641 5ustar0000000000000000base-compat-batteries-0.12.3/src/Data/Word/Compat/Repl/Batteries.hs0000644000000000000000000000042607346545000023121 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.12.3/src/Debug/Trace/0000755000000000000000000000000007346545000017014 5ustar0000000000000000base-compat-batteries-0.12.3/src/Debug/Trace/Compat.hs0000644000000000000000000000023307346545000020571 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Debug.Trace.Compat ( module Base ) where import "base-compat" Debug.Trace.Compat as Base base-compat-batteries-0.12.3/src/Debug/Trace/Compat/Repl/0000755000000000000000000000000007346545000021141 5ustar0000000000000000base-compat-batteries-0.12.3/src/Debug/Trace/Compat/Repl/Batteries.hs0000644000000000000000000000043607346545000023422 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.12.3/src/Foreign/0000755000000000000000000000000007346545000016321 5ustar0000000000000000base-compat-batteries-0.12.3/src/Foreign/Compat.hs0000644000000000000000000000022307346545000020075 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Foreign.Compat ( module Base ) where import "base-compat" Foreign.Compat as Base base-compat-batteries-0.12.3/src/Foreign/Compat/Repl/0000755000000000000000000000000007346545000020446 5ustar0000000000000000base-compat-batteries-0.12.3/src/Foreign/Compat/Repl/Batteries.hs0000644000000000000000000000041607346545000022725 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.12.3/src/Foreign/ForeignPtr/0000755000000000000000000000000007346545000020400 5ustar0000000000000000base-compat-batteries-0.12.3/src/Foreign/ForeignPtr/Compat.hs0000644000000000000000000000025107346545000022155 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Foreign.ForeignPtr.Compat ( module Base ) where import "base-compat" Foreign.ForeignPtr.Compat as Base base-compat-batteries-0.12.3/src/Foreign/ForeignPtr/Compat/Repl/0000755000000000000000000000000007346545000022525 5ustar0000000000000000base-compat-batteries-0.12.3/src/Foreign/ForeignPtr/Compat/Repl/Batteries.hs0000644000000000000000000000047207346545000025006 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.12.3/src/Foreign/ForeignPtr/Safe/0000755000000000000000000000000007346545000021256 5ustar0000000000000000base-compat-batteries-0.12.3/src/Foreign/ForeignPtr/Safe/Compat.hs0000644000000000000000000000026307346545000023036 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Foreign.ForeignPtr.Safe.Compat ( module Base ) where import "base-compat" Foreign.ForeignPtr.Safe.Compat as Base base-compat-batteries-0.12.3/src/Foreign/ForeignPtr/Safe/Compat/Repl/0000755000000000000000000000000007346545000023403 5ustar0000000000000000base-compat-batteries-0.12.3/src/Foreign/ForeignPtr/Safe/Compat/Repl/Batteries.hs0000644000000000000000000000051607346545000025663 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.12.3/src/Foreign/ForeignPtr/Unsafe/0000755000000000000000000000000007346545000021621 5ustar0000000000000000base-compat-batteries-0.12.3/src/Foreign/ForeignPtr/Unsafe/Compat.hs0000644000000000000000000000026707346545000023405 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Foreign.ForeignPtr.Unsafe.Compat ( module Base ) where import "base-compat" Foreign.ForeignPtr.Unsafe.Compat as Base base-compat-batteries-0.12.3/src/Foreign/ForeignPtr/Unsafe/Compat/Repl/0000755000000000000000000000000007346545000023746 5ustar0000000000000000base-compat-batteries-0.12.3/src/Foreign/ForeignPtr/Unsafe/Compat/Repl/Batteries.hs0000644000000000000000000000052607346545000026227 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.12.3/src/Foreign/Marshal/Alloc/0000755000000000000000000000000007346545000020742 5ustar0000000000000000base-compat-batteries-0.12.3/src/Foreign/Marshal/Alloc/Compat.hs0000644000000000000000000000025707346545000022525 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Foreign.Marshal.Alloc.Compat ( module Base ) where import "base-compat" Foreign.Marshal.Alloc.Compat as Base base-compat-batteries-0.12.3/src/Foreign/Marshal/Alloc/Compat/Repl/0000755000000000000000000000000007346545000023067 5ustar0000000000000000base-compat-batteries-0.12.3/src/Foreign/Marshal/Alloc/Compat/Repl/Batteries.hs0000644000000000000000000000050607346545000025346 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.12.3/src/Foreign/Marshal/Array/0000755000000000000000000000000007346545000020766 5ustar0000000000000000base-compat-batteries-0.12.3/src/Foreign/Marshal/Array/Compat.hs0000644000000000000000000000025707346545000022551 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Foreign.Marshal.Array.Compat ( module Base ) where import "base-compat" Foreign.Marshal.Array.Compat as Base base-compat-batteries-0.12.3/src/Foreign/Marshal/Array/Compat/Repl/0000755000000000000000000000000007346545000023113 5ustar0000000000000000base-compat-batteries-0.12.3/src/Foreign/Marshal/Array/Compat/Repl/Batteries.hs0000644000000000000000000000050607346545000025372 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.12.3/src/Foreign/Marshal/0000755000000000000000000000000007346545000017710 5ustar0000000000000000base-compat-batteries-0.12.3/src/Foreign/Marshal/Compat.hs0000644000000000000000000000024307346545000021466 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Foreign.Marshal.Compat ( module Base ) where import "base-compat" Foreign.Marshal.Compat as Base base-compat-batteries-0.12.3/src/Foreign/Marshal/Compat/Repl/0000755000000000000000000000000007346545000022035 5ustar0000000000000000base-compat-batteries-0.12.3/src/Foreign/Marshal/Compat/Repl/Batteries.hs0000644000000000000000000000045607346545000024320 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.12.3/src/Foreign/Marshal/Safe/0000755000000000000000000000000007346545000020566 5ustar0000000000000000base-compat-batteries-0.12.3/src/Foreign/Marshal/Safe/Compat.hs0000644000000000000000000000025507346545000022347 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Foreign.Marshal.Safe.Compat ( module Base ) where import "base-compat" Foreign.Marshal.Safe.Compat as Base base-compat-batteries-0.12.3/src/Foreign/Marshal/Safe/Compat/Repl/0000755000000000000000000000000007346545000022713 5ustar0000000000000000base-compat-batteries-0.12.3/src/Foreign/Marshal/Safe/Compat/Repl/Batteries.hs0000644000000000000000000000050207346545000025166 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.12.3/src/Foreign/Marshal/Unsafe/0000755000000000000000000000000007346545000021131 5ustar0000000000000000base-compat-batteries-0.12.3/src/Foreign/Marshal/Unsafe/Compat.hs0000644000000000000000000000026107346545000022707 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Foreign.Marshal.Unsafe.Compat ( module Base ) where import "base-compat" Foreign.Marshal.Unsafe.Compat as Base base-compat-batteries-0.12.3/src/Foreign/Marshal/Unsafe/Compat/Repl/0000755000000000000000000000000007346545000023256 5ustar0000000000000000base-compat-batteries-0.12.3/src/Foreign/Marshal/Unsafe/Compat/Repl/Batteries.hs0000644000000000000000000000051207346545000025532 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.12.3/src/Foreign/Marshal/Utils/0000755000000000000000000000000007346545000021010 5ustar0000000000000000base-compat-batteries-0.12.3/src/Foreign/Marshal/Utils/Compat.hs0000644000000000000000000000025707346545000022573 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Foreign.Marshal.Utils.Compat ( module Base ) where import "base-compat" Foreign.Marshal.Utils.Compat as Base base-compat-batteries-0.12.3/src/Foreign/Marshal/Utils/Compat/Repl/0000755000000000000000000000000007346545000023135 5ustar0000000000000000base-compat-batteries-0.12.3/src/Foreign/Marshal/Utils/Compat/Repl/Batteries.hs0000644000000000000000000000050607346545000025414 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.12.3/src/Numeric/0000755000000000000000000000000007346545000016332 5ustar0000000000000000base-compat-batteries-0.12.3/src/Numeric/Compat.hs0000644000000000000000000000022307346545000020106 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Numeric.Compat ( module Base ) where import "base-compat" Numeric.Compat as Base base-compat-batteries-0.12.3/src/Numeric/Compat/Repl/0000755000000000000000000000000007346545000020457 5ustar0000000000000000base-compat-batteries-0.12.3/src/Numeric/Compat/Repl/Batteries.hs0000644000000000000000000000041607346545000022736 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.12.3/src/Numeric/Natural/0000755000000000000000000000000007346545000017740 5ustar0000000000000000base-compat-batteries-0.12.3/src/Numeric/Natural/Compat.hs0000644000000000000000000000036207346545000021520 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Numeric.Natural.Compat ( module Base ) where #if MIN_VERSION_base(4,8,0) import "base-compat" Numeric.Natural.Compat as Base #else import "nats" Numeric.Natural as Base #endif base-compat-batteries-0.12.3/src/Numeric/Natural/Compat/Repl/0000755000000000000000000000000007346545000022065 5ustar0000000000000000base-compat-batteries-0.12.3/src/Numeric/Natural/Compat/Repl/Batteries.hs0000644000000000000000000000045607346545000024350 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.12.3/src/Prelude/0000755000000000000000000000000007346545000016330 5ustar0000000000000000base-compat-batteries-0.12.3/src/Prelude/Compat.hs0000644000000000000000000000065007346545000020110 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.12.3/src/Prelude/Compat/Repl/0000755000000000000000000000000007346545000020455 5ustar0000000000000000base-compat-batteries-0.12.3/src/Prelude/Compat/Repl/Batteries.hs0000644000000000000000000000041607346545000022734 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.12.3/src/System/Environment/0000755000000000000000000000000007346545000020520 5ustar0000000000000000base-compat-batteries-0.12.3/src/System/Environment/Compat.hs0000644000000000000000000000025107346545000022275 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module System.Environment.Compat ( module Base ) where import "base-compat" System.Environment.Compat as Base base-compat-batteries-0.12.3/src/System/Environment/Compat/Repl/0000755000000000000000000000000007346545000022645 5ustar0000000000000000base-compat-batteries-0.12.3/src/System/Environment/Compat/Repl/Batteries.hs0000644000000000000000000000047207346545000025126 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.12.3/src/System/Exit/0000755000000000000000000000000007346545000017125 5ustar0000000000000000base-compat-batteries-0.12.3/src/System/Exit/Compat.hs0000644000000000000000000000023307346545000020702 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module System.Exit.Compat ( module Base ) where import "base-compat" System.Exit.Compat as Base base-compat-batteries-0.12.3/src/System/Exit/Compat/Repl/0000755000000000000000000000000007346545000021252 5ustar0000000000000000base-compat-batteries-0.12.3/src/System/Exit/Compat/Repl/Batteries.hs0000644000000000000000000000043607346545000023533 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.12.3/src/System/IO/0000755000000000000000000000000007346545000016523 5ustar0000000000000000base-compat-batteries-0.12.3/src/System/IO/Compat.hs0000644000000000000000000000022707346545000020303 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module System.IO.Compat ( module Base ) where import "base-compat" System.IO.Compat as Base base-compat-batteries-0.12.3/src/System/IO/Compat/Repl/0000755000000000000000000000000007346545000020650 5ustar0000000000000000base-compat-batteries-0.12.3/src/System/IO/Compat/Repl/Batteries.hs0000644000000000000000000000042607346545000023130 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.12.3/src/System/IO/Error/0000755000000000000000000000000007346545000017614 5ustar0000000000000000base-compat-batteries-0.12.3/src/System/IO/Error/Compat.hs0000644000000000000000000000024307346545000021372 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module System.IO.Error.Compat ( module Base ) where import "base-compat" System.IO.Error.Compat as Base base-compat-batteries-0.12.3/src/System/IO/Error/Compat/Repl/0000755000000000000000000000000007346545000021741 5ustar0000000000000000base-compat-batteries-0.12.3/src/System/IO/Error/Compat/Repl/Batteries.hs0000644000000000000000000000045607346545000024224 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.12.3/src/System/IO/Unsafe/0000755000000000000000000000000007346545000017744 5ustar0000000000000000base-compat-batteries-0.12.3/src/System/IO/Unsafe/Compat.hs0000644000000000000000000000024507346545000021524 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module System.IO.Unsafe.Compat ( module Base ) where import "base-compat" System.IO.Unsafe.Compat as Base base-compat-batteries-0.12.3/src/System/IO/Unsafe/Compat/Repl/0000755000000000000000000000000007346545000022071 5ustar0000000000000000base-compat-batteries-0.12.3/src/System/IO/Unsafe/Compat/Repl/Batteries.hs0000644000000000000000000000046207346545000024351 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.12.3/src/Text/Read/0000755000000000000000000000000007346545000016527 5ustar0000000000000000base-compat-batteries-0.12.3/src/Text/Read/Compat.hs0000644000000000000000000000022707346545000020307 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Text.Read.Compat ( module Base ) where import "base-compat" Text.Read.Compat as Base base-compat-batteries-0.12.3/src/Text/Read/Compat/Repl/0000755000000000000000000000000007346545000020654 5ustar0000000000000000base-compat-batteries-0.12.3/src/Text/Read/Compat/Repl/Batteries.hs0000644000000000000000000000042607346545000023134 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.12.3/src/Text/Read/Lex/0000755000000000000000000000000007346545000017257 5ustar0000000000000000base-compat-batteries-0.12.3/src/Text/Read/Lex/Compat.hs0000644000000000000000000000023707346545000021040 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Text.Read.Lex.Compat ( module Base ) where import "base-compat" Text.Read.Lex.Compat as Base base-compat-batteries-0.12.3/src/Text/Read/Lex/Compat/Repl/0000755000000000000000000000000007346545000021404 5ustar0000000000000000base-compat-batteries-0.12.3/src/Text/Read/Lex/Compat/Repl/Batteries.hs0000644000000000000000000000044607346545000023666 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.12.3/src/Type/Reflection/0000755000000000000000000000000007346545000017743 5ustar0000000000000000base-compat-batteries-0.12.3/src/Type/Reflection/Compat.hs0000644000000000000000000000035307346545000021523 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Type.Reflection.Compat ( #if MIN_VERSION_base(4,10,0) module Base #endif ) where #if MIN_VERSION_base(4,10,0) import "base-compat" Type.Reflection.Compat as Base #endif base-compat-batteries-0.12.3/src/Type/Reflection/Compat/Repl/0000755000000000000000000000000007346545000022070 5ustar0000000000000000base-compat-batteries-0.12.3/src/Type/Reflection/Compat/Repl/Batteries.hs0000644000000000000000000000045607346545000024353 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.12.3/test/Control/Monad/0000755000000000000000000000000007346545000017576 5ustar0000000000000000base-compat-batteries-0.12.3/test/Control/Monad/CompatSpec.hs0000644000000000000000000000055607346545000022176 0ustar0000000000000000module Control.Monad.CompatSpec (main, spec) where import Test.Hspec import Control.Monad.Compat import Prelude () import Prelude.Compat main :: IO () main = hspec spec spec :: Spec spec = do describe "(<$!>)" $ do it "is a strict version of (<$>)" $ do not <$!> [True, False] `shouldBe` not <$> [True, False] base-compat-batteries-0.12.3/test/Data/Bits/0000755000000000000000000000000007346545000016672 5ustar0000000000000000base-compat-batteries-0.12.3/test/Data/Bits/CompatSpec.hs0000644000000000000000000000237007346545000021266 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.12.3/test/Data/Bool/0000755000000000000000000000000007346545000016664 5ustar0000000000000000base-compat-batteries-0.12.3/test/Data/Bool/CompatSpec.hs0000644000000000000000000000063007346545000021255 0ustar0000000000000000module Data.Bool.CompatSpec (main, spec) where import Test.Hspec import Data.Bool.Compat main :: IO () main = hspec spec spec :: Spec spec = do describe "bool" $ do it "evaluates to first parameter if condition is False" $ do bool "KO" "OK" False `shouldBe` "KO" it "evaluates to second parameter if condition is True" $ do bool "KO" "OK" True `shouldBe` "OK" base-compat-batteries-0.12.3/test/Data/Either/0000755000000000000000000000000007346545000017211 5ustar0000000000000000base-compat-batteries-0.12.3/test/Data/Either/CompatSpec.hs0000644000000000000000000000124107346545000021601 0ustar0000000000000000module Data.Either.CompatSpec (main, spec) where import Test.Hspec import Data.Either.Compat main :: IO () main = hspec spec spec :: Spec spec = do describe "isLeft" $ do it "returns True for a Left value" $ do isLeft (Left "23" :: Either String String) `shouldBe` True it "returns False for a Right value" $ do isLeft (Right "23" :: Either String String) `shouldBe` False describe "isRight" $ do it "returns False for a Left value" $ do isRight (Left "23" :: Either String String) `shouldBe` False it "returns True for a Right value" $ do isRight (Right "23" :: Either String String) `shouldBe` True base-compat-batteries-0.12.3/test/Data/Foldable/0000755000000000000000000000000007346545000017501 5ustar0000000000000000base-compat-batteries-0.12.3/test/Data/Foldable/CompatSpec.hs0000644000000000000000000000045707346545000022101 0ustar0000000000000000module Data.Foldable.CompatSpec (main, spec) where import Test.Hspec import Data.Foldable.Compat main :: IO () main = hspec spec spec :: Spec spec = do describe "maximumBy" $ do it "runs in constant space" $ do maximumBy compare [1..10000] `shouldBe` (10000 :: Int) base-compat-batteries-0.12.3/test/Data/Function/0000755000000000000000000000000007346545000017556 5ustar0000000000000000base-compat-batteries-0.12.3/test/Data/Function/CompatSpec.hs0000644000000000000000000000042307346545000022147 0ustar0000000000000000module Data.Function.CompatSpec (main, spec) where import Test.Hspec import Data.Function.Compat main :: IO () main = hspec spec spec :: Spec spec = do describe "&" $ do it "reverses function application" $ do (False & not) `shouldBe` True base-compat-batteries-0.12.3/test/Data/Functor/0000755000000000000000000000000007346545000017411 5ustar0000000000000000base-compat-batteries-0.12.3/test/Data/Functor/CompatSpec.hs0000644000000000000000000000064007346545000022003 0ustar0000000000000000module Data.Functor.CompatSpec (main, spec) where import Test.Hspec import Data.Functor.Compat main :: IO () main = hspec spec spec :: Spec spec = do describe "void" $ do it "discards computation result" $ do void (return 1 :: IO Int) `shouldReturn` () describe "$>" $ do it "is the same as flipped <$" $ do (Just 5 :: Maybe Int) $> 6 `shouldBe` (Just 6 :: Maybe Int) base-compat-batteries-0.12.3/test/Data/IORef/0000755000000000000000000000000007346545000016735 5ustar0000000000000000base-compat-batteries-0.12.3/test/Data/IORef/CompatSpec.hs0000644000000000000000000000122207346545000021324 0ustar0000000000000000module Data.IORef.CompatSpec (main, spec) where import Test.Hspec import Control.Monad import Data.IORef.Compat main :: IO () main = hspec spec spec :: Spec spec = do describe "modifyIORef'" $ it "mutates the contents of an IORef strictly" $ do ref <- newIORef 0 replicateM_ 1000000 $ modifyIORef' ref (+1) readIORef ref `shouldReturn` (1000000 :: Int) describe "atomicModifyIORef'" $ it "atomically modifies the contents of an IORef strictly" $ do ref <- newIORef 0 replicateM_ 1000000 . atomicModifyIORef' ref $ \n -> (n+1, ()) readIORef ref `shouldReturn` (1000000 :: Int) base-compat-batteries-0.12.3/test/Data/List/0000755000000000000000000000000007346545000016704 5ustar0000000000000000base-compat-batteries-0.12.3/test/Data/List/CompatSpec.hs0000644000000000000000000000306107346545000021276 0ustar0000000000000000module Data.List.CompatSpec (main, spec) where import Test.Hspec import Data.List.Compat data Asymmetric = A | B deriving Show instance Eq Asymmetric where A == _ = True B == _ = False main :: IO () main = hspec spec spec :: Spec spec = do describe "dropWhileEnd" $ do it "drops the largest suffix of a list in which a predicate holds for all elements" $ do dropWhileEnd (== ' ') "foo " `shouldBe` "foo" dropWhileEnd (== ' ') "foo bar" `shouldBe` "foo bar" describe "isSubsequenceOf" $ do it "returns True if the first list is a subsequence of the second list" $ do isSubsequenceOf "GHC" "The Glorious Haskell Compiler" `shouldBe` True isSubsequenceOf "JHC" "The Glorious Haskell Compiler" `shouldBe` False describe "nub" $ it "preserves the order of arguments to (==)" $ nub [A, B] `shouldBe` [A] describe "nubBy" $ it "preserves the order of arguments to the equality function" $ nubBy (<) "12" `shouldBe` "1" describe "sortOn" $ do it "sorts a list by comparing the results of a key function applied to each element" $ do sortOn (>='b') "cba" `shouldBe` "acb" describe "uncons" $ do it "decomposes a list into its head and tail" $ do uncons "" `shouldBe` Nothing uncons "12" `shouldBe` Just ('1', "2") describe "union" $ it "nubs arguments in the same order as (==)" $ do union [A] [A, B] `shouldBe` [A] describe "unionBy" $ it "nubs arguments in the same order as nubBy's equality function" $ do unionBy (<) "1" "21" `shouldBe` "11" base-compat-batteries-0.12.3/test/Data/Monoid/0000755000000000000000000000000007346545000017216 5ustar0000000000000000base-compat-batteries-0.12.3/test/Data/Monoid/CompatSpec.hs0000644000000000000000000000066307346545000021615 0ustar0000000000000000module Data.Monoid.CompatSpec (main, spec) where import Test.Hspec import Test.QuickCheck import Data.Monoid.Compat import Prelude () import Prelude.Compat (IO, String, ($)) main :: IO () main = hspec spec spec :: Spec spec = do describe "<>" $ do it "is an infix synonym for mappend" $ do property $ \xs ys -> do xs <> ys `shouldBe` (mappend xs ys :: String) base-compat-batteries-0.12.3/test/Data/STRef/0000755000000000000000000000000007346545000016754 5ustar0000000000000000base-compat-batteries-0.12.3/test/Data/STRef/CompatSpec.hs0000644000000000000000000000072007346545000021345 0ustar0000000000000000module Data.STRef.CompatSpec (main, spec) where import Test.Hspec import Control.Monad import Control.Monad.ST import Data.STRef.Compat main :: IO () main = hspec spec spec :: Spec spec = describe "modifySTRef'" $ it "should mutate the contents of an STRef strictly" $ shouldBe (1000000 :: Int) $ runST $ do ref <- newSTRef 0 replicateM_ 1000000 $ modifySTRef' ref (+1) readSTRef ref base-compat-batteries-0.12.3/test/Data/Version/0000755000000000000000000000000007346545000017416 5ustar0000000000000000base-compat-batteries-0.12.3/test/Data/Version/CompatSpec.hs0000644000000000000000000000040107346545000022003 0ustar0000000000000000module Data.Version.CompatSpec (spec) where import Test.Hspec import Data.Version.Compat spec :: Spec spec = do describe "makeVersion" $ it "constructs a tagless Version" $ makeVersion [1,2,3] `shouldBe` Version [1,2,3] [] base-compat-batteries-0.12.3/test/Data/Word/0000755000000000000000000000000007346545000016704 5ustar0000000000000000base-compat-batteries-0.12.3/test/Data/Word/CompatSpec.hs0000644000000000000000000000132107346545000021273 0ustar0000000000000000module Data.Word.CompatSpec (main, spec) where import Test.Hspec import Data.Word.Compat main :: IO () main = hspec spec spec :: Spec spec = do describe "byteSwap16" $ it "reverses the order of bytes in a Word16 value" $ do byteSwap16 0x1100 `shouldBe` 0x0011 byteSwap16 0x1010 `shouldBe` 0x1010 describe "byteSwap32" $ it "reverses the order of bytes in a Word32 value" $ do byteSwap32 0x11001010 `shouldBe` 0x10100011 byteSwap32 0x10101111 `shouldBe` 0x11111010 describe "byteSwap64" $ it "reverses the order of bytes in a Word64 value" $ do byteSwap64 0x1010111110101111 `shouldBe` 0x1111101011111010 byteSwap64 0x1100000000000011 `shouldBe` 0x1100000000000011 base-compat-batteries-0.12.3/test/Foreign/Marshal/Alloc/0000755000000000000000000000000007346545000021132 5ustar0000000000000000base-compat-batteries-0.12.3/test/Foreign/Marshal/Alloc/CompatSpec.hs0000644000000000000000000000064507346545000023531 0ustar0000000000000000module Foreign.Marshal.Alloc.CompatSpec (main, spec) where import Test.Hspec import Control.Exception import Foreign.Marshal.Alloc.Compat import Foreign.Storable main :: IO () main = hspec spec spec :: Spec spec = do describe "calloc" $ it "allocates memory with bytes of value zero" $ do bracket calloc free $ \ptr -> do peek ptr `shouldReturn` (0 :: Int) base-compat-batteries-0.12.3/test/Foreign/Marshal/Utils/0000755000000000000000000000000007346545000021200 5ustar0000000000000000base-compat-batteries-0.12.3/test/Foreign/Marshal/Utils/CompatSpec.hs0000644000000000000000000000073207346545000023574 0ustar0000000000000000module Foreign.Marshal.Utils.CompatSpec (main, spec) where import Test.Hspec import Foreign.Marshal.Alloc import Foreign.Marshal.Utils.Compat import Foreign.Ptr import Foreign.Storable main :: IO () main = hspec spec spec :: Spec spec = do describe "fillBytes" $ it "fills a given number of bytes in memory area with a byte value" $ do alloca $ \ptr -> do let _ = ptr :: Ptr Int fillBytes ptr 0 $ sizeOf ptr peek ptr `shouldReturn` 0 base-compat-batteries-0.12.3/test/Numeric/0000755000000000000000000000000007346545000016522 5ustar0000000000000000base-compat-batteries-0.12.3/test/Numeric/CompatSpec.hs0000644000000000000000000000417407346545000021122 0ustar0000000000000000module Numeric.CompatSpec (main, spec) where import Test.Hspec import Numeric.Compat main :: IO () main = hspec spec spec :: Spec spec = do describe "showFFloatAlt" $ do it "shows a RealFloat value, always using decimal notation" $ showFFloatAlt Nothing (12 :: Double) "" `shouldBe` "12.0" it "allows to specify the number of decimal places" $ showFFloatAlt (Just 4) (12 :: Double) "" `shouldBe` "12.0000" describe "showGFloatAlt" $ do it "shows a RealFloat value, using decimal notation if the absolute value lies between 0.1 and 9,999,999" $ showGFloatAlt Nothing (12 :: Double) "" `shouldBe` "12.0" it "shows a RealFloat value, using decimal notation and specifying the number of decimal places" $ showGFloatAlt (Just 4) (12 :: Double) "" `shouldBe` "12.0000" it "shows a RealFloat value, using scientific notation if the absolute value falls outside of the range" $ showGFloatAlt Nothing (1234567890 :: Double) "" `shouldBe` "1.23456789e9" it "shows a RealFloat value, using scientific notation and specifying the number of decimal places" $ showGFloatAlt (Just 4) (1234567890 :: Double) "" `shouldBe` "1.2346e9" describe "readBin" $ do it "parses an entirely binary Integer" $ readBinInteger "00000111" `shouldBe` [(7, "")] it "does not parse a non-binary Integer" $ readBinInteger "-24" `shouldBe` [] it "parses the binary prefix of an Integer" $ readBinInteger "1011784372843778438743" `shouldBe` [(11,"784372843778438743")] describe "showBin" $ do it "shows small Ints in base 2" $ map (\ x -> showBinInt x "") [1..32] `shouldBe` [ "1","10","11","100","101","110","111","1000","1001","1010","1011","1100","1101","1110","1111" , "10000","10001","10010","10011","10100","10101","10110","10111","11000" , "11001","11010","11011","11100","11101","11110","11111","100000" ] it "shows a large Int in base 2" $ showBinInt 241324784 "" `shouldBe` "1110011000100101001011110000" where readBinInteger :: ReadS Integer readBinInteger = readBin showBinInt :: Int -> ShowS showBinInt = showBin base-compat-batteries-0.12.3/test/Prelude/0000755000000000000000000000000007346545000016520 5ustar0000000000000000base-compat-batteries-0.12.3/test/Prelude/CompatSpec.hs0000644000000000000000000000061607346545000021115 0ustar0000000000000000module Prelude.CompatSpec (main, spec) where import Test.Hspec import Prelude () import Prelude.Compat main :: IO () main = hspec spec spec :: Spec spec = do describe "($!)" $ do it "is infixr 0" $ do -- #54 (succ $! succ $! 0) `shouldBe` (2 :: Int) (succ $! 2 *** 2) `shouldBe` (5 :: Int) infixr 1 *** (***) :: Int -> Int -> Int (***) = (*) base-compat-batteries-0.12.3/test/0000755000000000000000000000000007346545000015120 5ustar0000000000000000base-compat-batteries-0.12.3/test/SafeHaskellSpec.hs0000644000000000000000000000403407346545000020452 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.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.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.Tuple.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.12.3/test/Spec.hs0000644000000000000000000000005407346545000016345 0ustar0000000000000000{-# OPTIONS_GHC -F -pgmF hspec-discover #-} base-compat-batteries-0.12.3/test/System/Environment/0000755000000000000000000000000007346545000020710 5ustar0000000000000000base-compat-batteries-0.12.3/test/System/Environment/CompatSpec.hs0000644000000000000000000000763507346545000023315 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.12.3/test/T91Spec.hs0000644000000000000000000000064007346545000016644 0ustar0000000000000000{-# OPTIONS_GHC -fno-warn-deprecations #-} -- | A regression test for https://github.com/haskell-compat/base-compat/issues/91. module T91Spec (main, spec) where import Data.Tuple.Compat import Test.Hspec (Expectation, Spec, describe, hspec, it) main :: IO () main = hspec spec spec :: Spec spec = describe "Solo data constructor" $ it "is always available" $ do Solo () `seq` return () :: Expectation base-compat-batteries-0.12.3/test/TestHspecTrustworthy.hs0000644000000000000000000000033207346545000021673 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.12.3/test/Text/Read/0000755000000000000000000000000007346545000016717 5ustar0000000000000000base-compat-batteries-0.12.3/test/Text/Read/CompatSpec.hs0000644000000000000000000000117607346545000021316 0ustar0000000000000000module Text.Read.CompatSpec (main, spec) where import Test.Hspec import Text.Read.Compat main :: IO () main = hspec spec spec :: Spec spec = do describe "readMaybe" $ do it "parses a value" $ do readMaybe "23" `shouldBe` (Just 23 :: Maybe Int) it "returns Nothing if parsing fails" $ do readMaybe "xx" `shouldBe` (Nothing :: Maybe Int) describe "readEither" $ do it "parses a value" $ do readEither "23" `shouldBe` (Right 23 :: Either String Int) it "returns Left if parsing fails" $ do readEither "xx" `shouldBe` (Left "Prelude.read: no parse" :: Either String Int)