base-compat-batteries-0.11.1/0000755000000000000000000000000007346545000014136 5ustar0000000000000000base-compat-batteries-0.11.1/CHANGES.markdown0000755000000000000000000000724607346545000016766 0ustar0000000000000000## 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.11.1/LICENSE0000644000000000000000000000214007346545000015140 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.11.1/README.markdown0000755000000000000000000000311407346545000016641 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.11.1/Setup.lhs0000644000000000000000000000011407346545000015742 0ustar0000000000000000#!/usr/bin/env runhaskell > import Distribution.Simple > main = defaultMain base-compat-batteries-0.11.1/base-compat-batteries.cabal0000644000000000000000000002073207346545000021301 0ustar0000000000000000name: base-compat-batteries version: 0.11.1 license: MIT license-file: LICENSE copyright: (c) 2012-2018 Simon Hengel, (c) 2014-2018 João Cristóvão, (c) 2015-2018 Ryan Scott author: Simon Hengel , João Cristóvão , Ryan Scott maintainer: Simon Hengel , João Cristóvão , Ryan Scott build-type: Simple cabal-version: >= 1.8 category: Compatibility synopsis: 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@. tested-with: GHC == 7.0.4 , GHC == 7.2.2 , GHC == 7.4.2 , GHC == 7.6.3 , GHC == 7.8.4 , GHC == 7.10.3 , GHC == 8.0.2 , GHC == 8.2.2 , GHC == 8.4.4 , GHC == 8.6.5 , GHC == 8.8.2 , GHC == 8.10.1 extra-source-files: CHANGES.markdown, README.markdown source-repository head type: git location: https://github.com/haskell-compat/base-compat subdir: base-compat-batteries library ghc-options: -Wall build-depends: base >= 4.3 && < 5, base-compat == 0.11.1 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.20, transformers >= 0.2 && < 0.6, transformers-compat >= 0.6 && < 0.7 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 ghc-options: -fno-warn-duplicate-exports if impl(ghc >= 7.10) ghc-options: -fno-warn-trustworthy-safe hs-source-dirs: src exposed-modules: Control.Concurrent.Compat Control.Concurrent.MVar.Compat Control.Exception.Compat Control.Monad.Compat Control.Monad.Fail.Compat Control.Monad.IO.Class.Compat Control.Monad.ST.Lazy.Unsafe.Compat Control.Monad.ST.Unsafe.Compat Data.Bifoldable.Compat Data.Bifunctor.Compat Data.Bitraversable.Compat Data.Bits.Compat Data.Bool.Compat Data.Complex.Compat Data.Either.Compat Data.Foldable.Compat Data.Function.Compat Data.Functor.Compat Data.Functor.Compose.Compat Data.Functor.Const.Compat Data.Functor.Contravariant.Compat Data.Functor.Identity.Compat Data.Functor.Product.Compat Data.Functor.Sum.Compat Data.IORef.Compat Data.List.Compat Data.List.NonEmpty.Compat Data.Monoid.Compat Data.Proxy.Compat Data.Ratio.Compat Data.Semigroup.Compat Data.STRef.Compat Data.String.Compat Data.Type.Coercion.Compat Data.Type.Equality.Compat Data.Version.Compat Data.Void.Compat Data.Word.Compat Debug.Trace.Compat Foreign.Compat Foreign.ForeignPtr.Compat Foreign.ForeignPtr.Safe.Compat Foreign.ForeignPtr.Unsafe.Compat Foreign.Marshal.Alloc.Compat Foreign.Marshal.Array.Compat Foreign.Marshal.Compat Foreign.Marshal.Safe.Compat Foreign.Marshal.Unsafe.Compat Foreign.Marshal.Utils.Compat Numeric.Compat Numeric.Natural.Compat Prelude.Compat System.Environment.Compat System.Exit.Compat System.IO.Error.Compat System.IO.Unsafe.Compat Text.Read.Compat Type.Reflection.Compat Control.Concurrent.Compat.Repl.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.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.Error.Compat.Repl.Batteries System.IO.Unsafe.Compat.Repl.Batteries Text.Read.Compat.Repl.Batteries Type.Reflection.Compat.Repl.Batteries test-suite spec type: exitcode-stdio-1.0 ghc-options: -Wall hs-source-dirs: test main-is: Spec.hs other-modules: Control.Monad.CompatSpec Data.Bits.CompatSpec Data.Bool.CompatSpec Data.Either.CompatSpec Data.Foldable.CompatSpec Data.Function.CompatSpec Data.Functor.CompatSpec Data.IORef.CompatSpec Data.List.CompatSpec Data.Monoid.CompatSpec Data.STRef.CompatSpec Data.Version.CompatSpec Data.Word.CompatSpec Foreign.Marshal.Alloc.CompatSpec Foreign.Marshal.Utils.CompatSpec Numeric.CompatSpec Prelude.CompatSpec System.Environment.CompatSpec Text.Read.CompatSpec -- Other tests SafeHaskellSpec TestHspecTrustworthy build-depends: base >= 4.3 && < 5 , base-compat-batteries , hspec >= 1.8 , QuickCheck build-tool-depends: hspec-discover:hspec-discover >= 1.8 base-compat-batteries-0.11.1/src/Control/Concurrent/0000755000000000000000000000000007346545000020467 5ustar0000000000000000base-compat-batteries-0.11.1/src/Control/Concurrent/Compat.hs0000644000000000000000000000025107346545000022244 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Control.Concurrent.Compat ( module Base ) where import "base-compat" Control.Concurrent.Compat as Base base-compat-batteries-0.11.1/src/Control/Concurrent/Compat/Repl/0000755000000000000000000000000007346545000022614 5ustar0000000000000000base-compat-batteries-0.11.1/src/Control/Concurrent/Compat/Repl/Batteries.hs0000644000000000000000000000047207346545000025075 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.11.1/src/Control/Concurrent/MVar/0000755000000000000000000000000007346545000021334 5ustar0000000000000000base-compat-batteries-0.11.1/src/Control/Concurrent/MVar/Compat.hs0000644000000000000000000000026307346545000023114 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.11.1/src/Control/Concurrent/MVar/Compat/Repl/0000755000000000000000000000000007346545000023461 5ustar0000000000000000base-compat-batteries-0.11.1/src/Control/Concurrent/MVar/Compat/Repl/Batteries.hs0000644000000000000000000000051607346545000025741 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.11.1/src/Control/Exception/0000755000000000000000000000000007346545000020303 5ustar0000000000000000base-compat-batteries-0.11.1/src/Control/Exception/Compat.hs0000644000000000000000000000024707346545000022065 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Control.Exception.Compat ( module Base ) where import "base-compat" Control.Exception.Compat as Base base-compat-batteries-0.11.1/src/Control/Exception/Compat/Repl/0000755000000000000000000000000007346545000022430 5ustar0000000000000000base-compat-batteries-0.11.1/src/Control/Exception/Compat/Repl/Batteries.hs0000644000000000000000000000046607346545000024714 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.11.1/src/Control/Monad/0000755000000000000000000000000007346545000017403 5ustar0000000000000000base-compat-batteries-0.11.1/src/Control/Monad/Compat.hs0000644000000000000000000000032507346545000021162 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.11.1/src/Control/Monad/Compat/Repl/0000755000000000000000000000000007346545000021530 5ustar0000000000000000base-compat-batteries-0.11.1/src/Control/Monad/Compat/Repl/Batteries.hs0000644000000000000000000000044607346545000024012 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.11.1/src/Control/Monad/Fail/0000755000000000000000000000000007346545000020256 5ustar0000000000000000base-compat-batteries-0.11.1/src/Control/Monad/Fail/Compat.hs0000644000000000000000000000037307346545000022040 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.11.1/src/Control/Monad/Fail/Compat/Repl/0000755000000000000000000000000007346545000022403 5ustar0000000000000000base-compat-batteries-0.11.1/src/Control/Monad/Fail/Compat/Repl/Batteries.hs0000644000000000000000000000047207346545000024664 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.11.1/src/Control/Monad/IO/Class/0000755000000000000000000000000007346545000020757 5ustar0000000000000000base-compat-batteries-0.11.1/src/Control/Monad/IO/Class/Compat.hs0000644000000000000000000000040007346545000022530 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.11.1/src/Control/Monad/IO/Class/Compat/Repl/0000755000000000000000000000000007346545000023104 5ustar0000000000000000base-compat-batteries-0.11.1/src/Control/Monad/IO/Class/Compat/Repl/Batteries.hs0000644000000000000000000000051207346545000025360 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.11.1/src/Control/Monad/ST/Lazy/Unsafe/0000755000000000000000000000000007346545000022071 5ustar0000000000000000base-compat-batteries-0.11.1/src/Control/Monad/ST/Lazy/Unsafe/Compat.hs0000644000000000000000000000027507346545000023654 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.11.1/src/Control/Monad/ST/Lazy/Unsafe/Compat/Repl/0000755000000000000000000000000007346545000024216 5ustar0000000000000000base-compat-batteries-0.11.1/src/Control/Monad/ST/Lazy/Unsafe/Compat/Repl/Batteries.hs0000644000000000000000000000054207346545000026475 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.11.1/src/Control/Monad/ST/Unsafe/0000755000000000000000000000000007346545000021152 5ustar0000000000000000base-compat-batteries-0.11.1/src/Control/Monad/ST/Unsafe/Compat.hs0000644000000000000000000000026307346545000022732 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.11.1/src/Control/Monad/ST/Unsafe/Compat/Repl/0000755000000000000000000000000007346545000023277 5ustar0000000000000000base-compat-batteries-0.11.1/src/Control/Monad/ST/Unsafe/Compat/Repl/Batteries.hs0000644000000000000000000000051607346545000025557 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.11.1/src/Data/Bifoldable/0000755000000000000000000000000007346545000017621 5ustar0000000000000000base-compat-batteries-0.11.1/src/Data/Bifoldable/Compat.hs0000644000000000000000000000037107346545000021401 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.11.1/src/Data/Bifoldable/Compat/Repl/0000755000000000000000000000000007346545000021746 5ustar0000000000000000base-compat-batteries-0.11.1/src/Data/Bifoldable/Compat/Repl/Batteries.hs0000644000000000000000000000045607346545000024231 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.11.1/src/Data/Bifunctor/0000755000000000000000000000000007346545000017531 5ustar0000000000000000base-compat-batteries-0.11.1/src/Data/Bifunctor/Compat.hs0000644000000000000000000000036507346545000021314 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.11.1/src/Data/Bifunctor/Compat/Repl/0000755000000000000000000000000007346545000021656 5ustar0000000000000000base-compat-batteries-0.11.1/src/Data/Bifunctor/Compat/Repl/Batteries.hs0000644000000000000000000000045207346545000024135 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.11.1/src/Data/Bitraversable/0000755000000000000000000000000007346545000020363 5ustar0000000000000000base-compat-batteries-0.11.1/src/Data/Bitraversable/Compat.hs0000644000000000000000000000040207346545000022136 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.11.1/src/Data/Bitraversable/Compat/Repl/0000755000000000000000000000000007346545000022510 5ustar0000000000000000base-compat-batteries-0.11.1/src/Data/Bitraversable/Compat/Repl/Batteries.hs0000644000000000000000000000047207346545000024771 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.11.1/src/Data/Bits/0000755000000000000000000000000007346545000016477 5ustar0000000000000000base-compat-batteries-0.11.1/src/Data/Bits/Compat.hs0000644000000000000000000000022707346545000020257 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Data.Bits.Compat ( module Base ) where import "base-compat" Data.Bits.Compat as Base base-compat-batteries-0.11.1/src/Data/Bits/Compat/Repl/0000755000000000000000000000000007346545000020624 5ustar0000000000000000base-compat-batteries-0.11.1/src/Data/Bits/Compat/Repl/Batteries.hs0000644000000000000000000000042607346545000023104 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.11.1/src/Data/Bool/0000755000000000000000000000000007346545000016471 5ustar0000000000000000base-compat-batteries-0.11.1/src/Data/Bool/Compat.hs0000644000000000000000000000022707346545000020251 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Data.Bool.Compat ( module Base ) where import "base-compat" Data.Bool.Compat as Base base-compat-batteries-0.11.1/src/Data/Bool/Compat/Repl/0000755000000000000000000000000007346545000020616 5ustar0000000000000000base-compat-batteries-0.11.1/src/Data/Bool/Compat/Repl/Batteries.hs0000644000000000000000000000042607346545000023076 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.11.1/src/Data/Complex/0000755000000000000000000000000007346545000017205 5ustar0000000000000000base-compat-batteries-0.11.1/src/Data/Complex/Compat.hs0000644000000000000000000000023507346545000020764 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Data.Complex.Compat ( module Base ) where import "base-compat" Data.Complex.Compat as Base base-compat-batteries-0.11.1/src/Data/Complex/Compat/Repl/0000755000000000000000000000000007346545000021332 5ustar0000000000000000base-compat-batteries-0.11.1/src/Data/Complex/Compat/Repl/Batteries.hs0000644000000000000000000000044207346545000023610 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.11.1/src/Data/Either/0000755000000000000000000000000007346545000017016 5ustar0000000000000000base-compat-batteries-0.11.1/src/Data/Either/Compat.hs0000644000000000000000000000023307346545000020573 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Data.Either.Compat ( module Base ) where import "base-compat" Data.Either.Compat as Base base-compat-batteries-0.11.1/src/Data/Either/Compat/Repl/0000755000000000000000000000000007346545000021143 5ustar0000000000000000base-compat-batteries-0.11.1/src/Data/Either/Compat/Repl/Batteries.hs0000644000000000000000000000043607346545000023424 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.11.1/src/Data/Foldable/0000755000000000000000000000000007346545000017306 5ustar0000000000000000base-compat-batteries-0.11.1/src/Data/Foldable/Compat.hs0000644000000000000000000000023707346545000021067 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Data.Foldable.Compat ( module Base ) where import "base-compat" Data.Foldable.Compat as Base base-compat-batteries-0.11.1/src/Data/Foldable/Compat/Repl/0000755000000000000000000000000007346545000021433 5ustar0000000000000000base-compat-batteries-0.11.1/src/Data/Foldable/Compat/Repl/Batteries.hs0000644000000000000000000000044607346545000023715 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.11.1/src/Data/Function/0000755000000000000000000000000007346545000017363 5ustar0000000000000000base-compat-batteries-0.11.1/src/Data/Function/Compat.hs0000644000000000000000000000023707346545000021144 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Data.Function.Compat ( module Base ) where import "base-compat" Data.Function.Compat as Base base-compat-batteries-0.11.1/src/Data/Function/Compat/Repl/0000755000000000000000000000000007346545000021510 5ustar0000000000000000base-compat-batteries-0.11.1/src/Data/Function/Compat/Repl/Batteries.hs0000644000000000000000000000044607346545000023772 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.11.1/src/Data/Functor/0000755000000000000000000000000007346545000017216 5ustar0000000000000000base-compat-batteries-0.11.1/src/Data/Functor/Compat.hs0000644000000000000000000000151307346545000020775 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.11.1/src/Data/Functor/Compat/Repl/0000755000000000000000000000000007346545000021343 5ustar0000000000000000base-compat-batteries-0.11.1/src/Data/Functor/Compat/Repl/Batteries.hs0000644000000000000000000000044207346545000023621 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.11.1/src/Data/Functor/Compose/0000755000000000000000000000000007346545000020623 5ustar0000000000000000base-compat-batteries-0.11.1/src/Data/Functor/Compose/Compat.hs0000644000000000000000000000037207346545000022404 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.11.1/src/Data/Functor/Compose/Compat/Repl/0000755000000000000000000000000007346545000022750 5ustar0000000000000000base-compat-batteries-0.11.1/src/Data/Functor/Compose/Compat/Repl/Batteries.hs0000644000000000000000000000050207346545000025223 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.11.1/src/Data/Functor/Const/0000755000000000000000000000000007346545000020304 5ustar0000000000000000base-compat-batteries-0.11.1/src/Data/Functor/Const/Compat.hs0000644000000000000000000000025107346545000022061 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.11.1/src/Data/Functor/Const/Compat/Repl/0000755000000000000000000000000007346545000022431 5ustar0000000000000000base-compat-batteries-0.11.1/src/Data/Functor/Const/Compat/Repl/Batteries.hs0000644000000000000000000000047207346545000024712 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.11.1/src/Data/Functor/Contravariant/0000755000000000000000000000000007346545000022031 5ustar0000000000000000base-compat-batteries-0.11.1/src/Data/Functor/Contravariant/Compat.hs0000644000000000000000000000043707346545000023614 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.11.1/src/Data/Functor/Contravariant/Compat/Repl/0000755000000000000000000000000007346545000024156 5ustar0000000000000000base-compat-batteries-0.11.1/src/Data/Functor/Contravariant/Compat/Repl/Batteries.hs0000644000000000000000000000053207346545000026434 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.11.1/src/Data/Functor/Identity/0000755000000000000000000000000007346545000021007 5ustar0000000000000000base-compat-batteries-0.11.1/src/Data/Functor/Identity/Compat.hs0000644000000000000000000000037507346545000022573 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.11.1/src/Data/Functor/Identity/Compat/Repl/0000755000000000000000000000000007346545000023134 5ustar0000000000000000base-compat-batteries-0.11.1/src/Data/Functor/Identity/Compat/Repl/Batteries.hs0000644000000000000000000000050607346545000025413 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.11.1/src/Data/Functor/Product/0000755000000000000000000000000007346545000020636 5ustar0000000000000000base-compat-batteries-0.11.1/src/Data/Functor/Product/Compat.hs0000644000000000000000000000037207346545000022417 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.11.1/src/Data/Functor/Product/Compat/Repl/0000755000000000000000000000000007346545000022763 5ustar0000000000000000base-compat-batteries-0.11.1/src/Data/Functor/Product/Compat/Repl/Batteries.hs0000644000000000000000000000050207346545000025236 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.11.1/src/Data/Functor/Sum/0000755000000000000000000000000007346545000017762 5ustar0000000000000000base-compat-batteries-0.11.1/src/Data/Functor/Sum/Compat.hs0000644000000000000000000000035607346545000021545 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.11.1/src/Data/Functor/Sum/Compat/Repl/0000755000000000000000000000000007346545000022107 5ustar0000000000000000base-compat-batteries-0.11.1/src/Data/Functor/Sum/Compat/Repl/Batteries.hs0000644000000000000000000000046207346545000024367 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.11.1/src/Data/IORef/0000755000000000000000000000000007346545000016542 5ustar0000000000000000base-compat-batteries-0.11.1/src/Data/IORef/Compat.hs0000644000000000000000000000023107346545000020315 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Data.IORef.Compat ( module Base ) where import "base-compat" Data.IORef.Compat as Base base-compat-batteries-0.11.1/src/Data/IORef/Compat/Repl/0000755000000000000000000000000007346545000020667 5ustar0000000000000000base-compat-batteries-0.11.1/src/Data/IORef/Compat/Repl/Batteries.hs0000644000000000000000000000043207346545000023144 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.11.1/src/Data/List/0000755000000000000000000000000007346545000016511 5ustar0000000000000000base-compat-batteries-0.11.1/src/Data/List/Compat.hs0000644000000000000000000000022707346545000020271 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Data.List.Compat ( module Base ) where import "base-compat" Data.List.Compat as Base base-compat-batteries-0.11.1/src/Data/List/Compat/Repl/0000755000000000000000000000000007346545000020636 5ustar0000000000000000base-compat-batteries-0.11.1/src/Data/List/Compat/Repl/Batteries.hs0000644000000000000000000000042607346545000023116 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.11.1/src/Data/List/NonEmpty/0000755000000000000000000000000007346545000020262 5ustar0000000000000000base-compat-batteries-0.11.1/src/Data/List/NonEmpty/Compat.hs0000644000000000000000000000305607346545000022045 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} -- | This backports the modern "Data.Semigroup" interface back to -- @base-4.9@/GHC 8.0. 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 , (<|), 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 base-compat-batteries-0.11.1/src/Data/List/NonEmpty/Compat/Repl/0000755000000000000000000000000007346545000022407 5ustar0000000000000000base-compat-batteries-0.11.1/src/Data/List/NonEmpty/Compat/Repl/Batteries.hs0000644000000000000000000000047207346545000024670 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.11.1/src/Data/Monoid/0000755000000000000000000000000007346545000017023 5ustar0000000000000000base-compat-batteries-0.11.1/src/Data/Monoid/Compat.hs0000644000000000000000000000031507346545000020601 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.11.1/src/Data/Monoid/Compat/Repl/0000755000000000000000000000000007346545000021150 5ustar0000000000000000base-compat-batteries-0.11.1/src/Data/Monoid/Compat/Repl/Batteries.hs0000644000000000000000000000043607346545000023431 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.11.1/src/Data/Proxy/0000755000000000000000000000000007346545000016717 5ustar0000000000000000base-compat-batteries-0.11.1/src/Data/Proxy/Compat.hs0000644000000000000000000000034507346545000020500 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.11.1/src/Data/Proxy/Compat/Repl/0000755000000000000000000000000007346545000021044 5ustar0000000000000000base-compat-batteries-0.11.1/src/Data/Proxy/Compat/Repl/Batteries.hs0000644000000000000000000000043207346545000023321 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.11.1/src/Data/Ratio/0000755000000000000000000000000007346545000016654 5ustar0000000000000000base-compat-batteries-0.11.1/src/Data/Ratio/Compat.hs0000644000000000000000000000023107346545000020427 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Data.Ratio.Compat ( module Base ) where import "base-compat" Data.Ratio.Compat as Base base-compat-batteries-0.11.1/src/Data/Ratio/Compat/Repl/0000755000000000000000000000000007346545000021001 5ustar0000000000000000base-compat-batteries-0.11.1/src/Data/Ratio/Compat/Repl/Batteries.hs0000644000000000000000000000043207346545000023256 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.11.1/src/Data/STRef/0000755000000000000000000000000007346545000016561 5ustar0000000000000000base-compat-batteries-0.11.1/src/Data/STRef/Compat.hs0000644000000000000000000000023107346545000020334 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Data.STRef.Compat ( module Base ) where import "base-compat" Data.STRef.Compat as Base base-compat-batteries-0.11.1/src/Data/STRef/Compat/Repl/0000755000000000000000000000000007346545000020706 5ustar0000000000000000base-compat-batteries-0.11.1/src/Data/STRef/Compat/Repl/Batteries.hs0000644000000000000000000000043207346545000023163 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.11.1/src/Data/Semigroup/0000755000000000000000000000000007346545000017550 5ustar0000000000000000base-compat-batteries-0.11.1/src/Data/Semigroup/Compat.hs0000644000000000000000000000130107346545000021322 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(..) -- * A better monoid for Maybe , Option(..) , option -- * 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.11.1/src/Data/Semigroup/Compat/Repl/0000755000000000000000000000000007346545000021675 5ustar0000000000000000base-compat-batteries-0.11.1/src/Data/Semigroup/Compat/Repl/Batteries.hs0000644000000000000000000000045207346545000024154 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.11.1/src/Data/String/0000755000000000000000000000000007346545000017044 5ustar0000000000000000base-compat-batteries-0.11.1/src/Data/String/Compat.hs0000644000000000000000000000023307346545000020621 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Data.String.Compat ( module Base ) where import "base-compat" Data.String.Compat as Base base-compat-batteries-0.11.1/src/Data/String/Compat/Repl/0000755000000000000000000000000007346545000021171 5ustar0000000000000000base-compat-batteries-0.11.1/src/Data/String/Compat/Repl/Batteries.hs0000644000000000000000000000043607346545000023452 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.11.1/src/Data/Type/Coercion/0000755000000000000000000000000007346545000020260 5ustar0000000000000000base-compat-batteries-0.11.1/src/Data/Type/Coercion/Compat.hs0000644000000000000000000000035707346545000022044 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.11.1/src/Data/Type/Coercion/Compat/Repl/0000755000000000000000000000000007346545000022405 5ustar0000000000000000base-compat-batteries-0.11.1/src/Data/Type/Coercion/Compat/Repl/Batteries.hs0000644000000000000000000000047207346545000024666 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.11.1/src/Data/Type/Equality/0000755000000000000000000000000007346545000020314 5ustar0000000000000000base-compat-batteries-0.11.1/src/Data/Type/Equality/Compat.hs0000644000000000000000000000165207346545000022077 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.11.1/src/Data/Type/Equality/Compat/Repl/0000755000000000000000000000000007346545000022441 5ustar0000000000000000base-compat-batteries-0.11.1/src/Data/Type/Equality/Compat/Repl/Batteries.hs0000644000000000000000000000047207346545000024722 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.11.1/src/Data/Version/0000755000000000000000000000000007346545000017223 5ustar0000000000000000base-compat-batteries-0.11.1/src/Data/Version/Compat.hs0000644000000000000000000000023507346545000021002 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Data.Version.Compat ( module Base ) where import "base-compat" Data.Version.Compat as Base base-compat-batteries-0.11.1/src/Data/Version/Compat/Repl/0000755000000000000000000000000007346545000021350 5ustar0000000000000000base-compat-batteries-0.11.1/src/Data/Version/Compat/Repl/Batteries.hs0000644000000000000000000000044207346545000023626 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.11.1/src/Data/Void/0000755000000000000000000000000007346545000016477 5ustar0000000000000000base-compat-batteries-0.11.1/src/Data/Void/Compat.hs0000644000000000000000000000035407346545000020260 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.11.1/src/Data/Void/Compat/Repl/0000755000000000000000000000000007346545000020624 5ustar0000000000000000base-compat-batteries-0.11.1/src/Data/Void/Compat/Repl/Batteries.hs0000644000000000000000000000042607346545000023104 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.11.1/src/Data/Word/0000755000000000000000000000000007346545000016511 5ustar0000000000000000base-compat-batteries-0.11.1/src/Data/Word/Compat.hs0000644000000000000000000000022707346545000020271 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Data.Word.Compat ( module Base ) where import "base-compat" Data.Word.Compat as Base base-compat-batteries-0.11.1/src/Data/Word/Compat/Repl/0000755000000000000000000000000007346545000020636 5ustar0000000000000000base-compat-batteries-0.11.1/src/Data/Word/Compat/Repl/Batteries.hs0000644000000000000000000000042607346545000023116 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.11.1/src/Debug/Trace/0000755000000000000000000000000007346545000017011 5ustar0000000000000000base-compat-batteries-0.11.1/src/Debug/Trace/Compat.hs0000644000000000000000000000023307346545000020566 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Debug.Trace.Compat ( module Base ) where import "base-compat" Debug.Trace.Compat as Base base-compat-batteries-0.11.1/src/Debug/Trace/Compat/Repl/0000755000000000000000000000000007346545000021136 5ustar0000000000000000base-compat-batteries-0.11.1/src/Debug/Trace/Compat/Repl/Batteries.hs0000644000000000000000000000043607346545000023417 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.11.1/src/Foreign/0000755000000000000000000000000007346545000016316 5ustar0000000000000000base-compat-batteries-0.11.1/src/Foreign/Compat.hs0000644000000000000000000000022307346545000020072 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Foreign.Compat ( module Base ) where import "base-compat" Foreign.Compat as Base base-compat-batteries-0.11.1/src/Foreign/Compat/Repl/0000755000000000000000000000000007346545000020443 5ustar0000000000000000base-compat-batteries-0.11.1/src/Foreign/Compat/Repl/Batteries.hs0000644000000000000000000000041607346545000022722 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.11.1/src/Foreign/ForeignPtr/0000755000000000000000000000000007346545000020375 5ustar0000000000000000base-compat-batteries-0.11.1/src/Foreign/ForeignPtr/Compat.hs0000644000000000000000000000025107346545000022152 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Foreign.ForeignPtr.Compat ( module Base ) where import "base-compat" Foreign.ForeignPtr.Compat as Base base-compat-batteries-0.11.1/src/Foreign/ForeignPtr/Compat/Repl/0000755000000000000000000000000007346545000022522 5ustar0000000000000000base-compat-batteries-0.11.1/src/Foreign/ForeignPtr/Compat/Repl/Batteries.hs0000644000000000000000000000047207346545000025003 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.11.1/src/Foreign/ForeignPtr/Safe/0000755000000000000000000000000007346545000021253 5ustar0000000000000000base-compat-batteries-0.11.1/src/Foreign/ForeignPtr/Safe/Compat.hs0000644000000000000000000000026307346545000023033 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.11.1/src/Foreign/ForeignPtr/Safe/Compat/Repl/0000755000000000000000000000000007346545000023400 5ustar0000000000000000base-compat-batteries-0.11.1/src/Foreign/ForeignPtr/Safe/Compat/Repl/Batteries.hs0000644000000000000000000000051607346545000025660 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.11.1/src/Foreign/ForeignPtr/Unsafe/0000755000000000000000000000000007346545000021616 5ustar0000000000000000base-compat-batteries-0.11.1/src/Foreign/ForeignPtr/Unsafe/Compat.hs0000644000000000000000000000026707346545000023402 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.11.1/src/Foreign/ForeignPtr/Unsafe/Compat/Repl/0000755000000000000000000000000007346545000023743 5ustar0000000000000000base-compat-batteries-0.11.1/src/Foreign/ForeignPtr/Unsafe/Compat/Repl/Batteries.hs0000644000000000000000000000052607346545000026224 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.11.1/src/Foreign/Marshal/Alloc/0000755000000000000000000000000007346545000020737 5ustar0000000000000000base-compat-batteries-0.11.1/src/Foreign/Marshal/Alloc/Compat.hs0000644000000000000000000000025707346545000022522 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.11.1/src/Foreign/Marshal/Alloc/Compat/Repl/0000755000000000000000000000000007346545000023064 5ustar0000000000000000base-compat-batteries-0.11.1/src/Foreign/Marshal/Alloc/Compat/Repl/Batteries.hs0000644000000000000000000000050607346545000025343 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.11.1/src/Foreign/Marshal/Array/0000755000000000000000000000000007346545000020763 5ustar0000000000000000base-compat-batteries-0.11.1/src/Foreign/Marshal/Array/Compat.hs0000644000000000000000000000025707346545000022546 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.11.1/src/Foreign/Marshal/Array/Compat/Repl/0000755000000000000000000000000007346545000023110 5ustar0000000000000000base-compat-batteries-0.11.1/src/Foreign/Marshal/Array/Compat/Repl/Batteries.hs0000644000000000000000000000050607346545000025367 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.11.1/src/Foreign/Marshal/0000755000000000000000000000000007346545000017705 5ustar0000000000000000base-compat-batteries-0.11.1/src/Foreign/Marshal/Compat.hs0000644000000000000000000000024307346545000021463 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Foreign.Marshal.Compat ( module Base ) where import "base-compat" Foreign.Marshal.Compat as Base base-compat-batteries-0.11.1/src/Foreign/Marshal/Compat/Repl/0000755000000000000000000000000007346545000022032 5ustar0000000000000000base-compat-batteries-0.11.1/src/Foreign/Marshal/Compat/Repl/Batteries.hs0000644000000000000000000000045607346545000024315 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.11.1/src/Foreign/Marshal/Safe/0000755000000000000000000000000007346545000020563 5ustar0000000000000000base-compat-batteries-0.11.1/src/Foreign/Marshal/Safe/Compat.hs0000644000000000000000000000025507346545000022344 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.11.1/src/Foreign/Marshal/Safe/Compat/Repl/0000755000000000000000000000000007346545000022710 5ustar0000000000000000base-compat-batteries-0.11.1/src/Foreign/Marshal/Safe/Compat/Repl/Batteries.hs0000644000000000000000000000050207346545000025163 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.11.1/src/Foreign/Marshal/Unsafe/0000755000000000000000000000000007346545000021126 5ustar0000000000000000base-compat-batteries-0.11.1/src/Foreign/Marshal/Unsafe/Compat.hs0000644000000000000000000000026107346545000022704 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.11.1/src/Foreign/Marshal/Unsafe/Compat/Repl/0000755000000000000000000000000007346545000023253 5ustar0000000000000000base-compat-batteries-0.11.1/src/Foreign/Marshal/Unsafe/Compat/Repl/Batteries.hs0000644000000000000000000000051207346545000025527 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.11.1/src/Foreign/Marshal/Utils/0000755000000000000000000000000007346545000021005 5ustar0000000000000000base-compat-batteries-0.11.1/src/Foreign/Marshal/Utils/Compat.hs0000644000000000000000000000025707346545000022570 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.11.1/src/Foreign/Marshal/Utils/Compat/Repl/0000755000000000000000000000000007346545000023132 5ustar0000000000000000base-compat-batteries-0.11.1/src/Foreign/Marshal/Utils/Compat/Repl/Batteries.hs0000644000000000000000000000050607346545000025411 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.11.1/src/Numeric/0000755000000000000000000000000007346545000016327 5ustar0000000000000000base-compat-batteries-0.11.1/src/Numeric/Compat.hs0000644000000000000000000000022307346545000020103 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Numeric.Compat ( module Base ) where import "base-compat" Numeric.Compat as Base base-compat-batteries-0.11.1/src/Numeric/Compat/Repl/0000755000000000000000000000000007346545000020454 5ustar0000000000000000base-compat-batteries-0.11.1/src/Numeric/Compat/Repl/Batteries.hs0000644000000000000000000000041607346545000022733 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.11.1/src/Numeric/Natural/0000755000000000000000000000000007346545000017735 5ustar0000000000000000base-compat-batteries-0.11.1/src/Numeric/Natural/Compat.hs0000644000000000000000000000036207346545000021515 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.11.1/src/Numeric/Natural/Compat/Repl/0000755000000000000000000000000007346545000022062 5ustar0000000000000000base-compat-batteries-0.11.1/src/Numeric/Natural/Compat/Repl/Batteries.hs0000644000000000000000000000045607346545000024345 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.11.1/src/Prelude/0000755000000000000000000000000007346545000016325 5ustar0000000000000000base-compat-batteries-0.11.1/src/Prelude/Compat.hs0000644000000000000000000000065007346545000020105 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.11.1/src/Prelude/Compat/Repl/0000755000000000000000000000000007346545000020452 5ustar0000000000000000base-compat-batteries-0.11.1/src/Prelude/Compat/Repl/Batteries.hs0000644000000000000000000000041607346545000022731 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.11.1/src/System/Environment/0000755000000000000000000000000007346545000020515 5ustar0000000000000000base-compat-batteries-0.11.1/src/System/Environment/Compat.hs0000644000000000000000000000025107346545000022272 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module System.Environment.Compat ( module Base ) where import "base-compat" System.Environment.Compat as Base base-compat-batteries-0.11.1/src/System/Environment/Compat/Repl/0000755000000000000000000000000007346545000022642 5ustar0000000000000000base-compat-batteries-0.11.1/src/System/Environment/Compat/Repl/Batteries.hs0000644000000000000000000000047207346545000025123 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.11.1/src/System/Exit/0000755000000000000000000000000007346545000017122 5ustar0000000000000000base-compat-batteries-0.11.1/src/System/Exit/Compat.hs0000644000000000000000000000023307346545000020677 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module System.Exit.Compat ( module Base ) where import "base-compat" System.Exit.Compat as Base base-compat-batteries-0.11.1/src/System/Exit/Compat/Repl/0000755000000000000000000000000007346545000021247 5ustar0000000000000000base-compat-batteries-0.11.1/src/System/Exit/Compat/Repl/Batteries.hs0000644000000000000000000000043607346545000023530 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.11.1/src/System/IO/Error/0000755000000000000000000000000007346545000017611 5ustar0000000000000000base-compat-batteries-0.11.1/src/System/IO/Error/Compat.hs0000644000000000000000000000024307346545000021367 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.11.1/src/System/IO/Error/Compat/Repl/0000755000000000000000000000000007346545000021736 5ustar0000000000000000base-compat-batteries-0.11.1/src/System/IO/Error/Compat/Repl/Batteries.hs0000644000000000000000000000045607346545000024221 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.11.1/src/System/IO/Unsafe/0000755000000000000000000000000007346545000017741 5ustar0000000000000000base-compat-batteries-0.11.1/src/System/IO/Unsafe/Compat.hs0000644000000000000000000000024507346545000021521 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.11.1/src/System/IO/Unsafe/Compat/Repl/0000755000000000000000000000000007346545000022066 5ustar0000000000000000base-compat-batteries-0.11.1/src/System/IO/Unsafe/Compat/Repl/Batteries.hs0000644000000000000000000000046207346545000024346 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.11.1/src/Text/Read/0000755000000000000000000000000007346545000016524 5ustar0000000000000000base-compat-batteries-0.11.1/src/Text/Read/Compat.hs0000644000000000000000000000022707346545000020304 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, PackageImports #-} module Text.Read.Compat ( module Base ) where import "base-compat" Text.Read.Compat as Base base-compat-batteries-0.11.1/src/Text/Read/Compat/Repl/0000755000000000000000000000000007346545000020651 5ustar0000000000000000base-compat-batteries-0.11.1/src/Text/Read/Compat/Repl/Batteries.hs0000644000000000000000000000042607346545000023131 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.11.1/src/Type/Reflection/0000755000000000000000000000000007346545000017740 5ustar0000000000000000base-compat-batteries-0.11.1/src/Type/Reflection/Compat.hs0000644000000000000000000000035307346545000021520 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.11.1/src/Type/Reflection/Compat/Repl/0000755000000000000000000000000007346545000022065 5ustar0000000000000000base-compat-batteries-0.11.1/src/Type/Reflection/Compat/Repl/Batteries.hs0000644000000000000000000000045607346545000024350 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.11.1/test/Control/Monad/0000755000000000000000000000000007346545000017573 5ustar0000000000000000base-compat-batteries-0.11.1/test/Control/Monad/CompatSpec.hs0000644000000000000000000000055607346545000022173 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.11.1/test/Data/Bits/0000755000000000000000000000000007346545000016667 5ustar0000000000000000base-compat-batteries-0.11.1/test/Data/Bits/CompatSpec.hs0000644000000000000000000000237007346545000021263 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.11.1/test/Data/Bool/0000755000000000000000000000000007346545000016661 5ustar0000000000000000base-compat-batteries-0.11.1/test/Data/Bool/CompatSpec.hs0000644000000000000000000000063007346545000021252 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.11.1/test/Data/Either/0000755000000000000000000000000007346545000017206 5ustar0000000000000000base-compat-batteries-0.11.1/test/Data/Either/CompatSpec.hs0000644000000000000000000000124107346545000021576 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.11.1/test/Data/Foldable/0000755000000000000000000000000007346545000017476 5ustar0000000000000000base-compat-batteries-0.11.1/test/Data/Foldable/CompatSpec.hs0000644000000000000000000000045707346545000022076 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.11.1/test/Data/Function/0000755000000000000000000000000007346545000017553 5ustar0000000000000000base-compat-batteries-0.11.1/test/Data/Function/CompatSpec.hs0000644000000000000000000000042307346545000022144 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.11.1/test/Data/Functor/0000755000000000000000000000000007346545000017406 5ustar0000000000000000base-compat-batteries-0.11.1/test/Data/Functor/CompatSpec.hs0000644000000000000000000000064007346545000022000 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.11.1/test/Data/IORef/0000755000000000000000000000000007346545000016732 5ustar0000000000000000base-compat-batteries-0.11.1/test/Data/IORef/CompatSpec.hs0000644000000000000000000000122207346545000021321 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.11.1/test/Data/List/0000755000000000000000000000000007346545000016701 5ustar0000000000000000base-compat-batteries-0.11.1/test/Data/List/CompatSpec.hs0000644000000000000000000000306107346545000021273 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.11.1/test/Data/Monoid/0000755000000000000000000000000007346545000017213 5ustar0000000000000000base-compat-batteries-0.11.1/test/Data/Monoid/CompatSpec.hs0000644000000000000000000000066307346545000021612 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.11.1/test/Data/STRef/0000755000000000000000000000000007346545000016751 5ustar0000000000000000base-compat-batteries-0.11.1/test/Data/STRef/CompatSpec.hs0000644000000000000000000000072007346545000021342 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.11.1/test/Data/Version/0000755000000000000000000000000007346545000017413 5ustar0000000000000000base-compat-batteries-0.11.1/test/Data/Version/CompatSpec.hs0000644000000000000000000000040107346545000022000 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.11.1/test/Data/Word/0000755000000000000000000000000007346545000016701 5ustar0000000000000000base-compat-batteries-0.11.1/test/Data/Word/CompatSpec.hs0000644000000000000000000000132107346545000021270 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.11.1/test/Foreign/Marshal/Alloc/0000755000000000000000000000000007346545000021127 5ustar0000000000000000base-compat-batteries-0.11.1/test/Foreign/Marshal/Alloc/CompatSpec.hs0000644000000000000000000000064507346545000023526 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.11.1/test/Foreign/Marshal/Utils/0000755000000000000000000000000007346545000021175 5ustar0000000000000000base-compat-batteries-0.11.1/test/Foreign/Marshal/Utils/CompatSpec.hs0000644000000000000000000000073207346545000023571 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.11.1/test/Numeric/0000755000000000000000000000000007346545000016517 5ustar0000000000000000base-compat-batteries-0.11.1/test/Numeric/CompatSpec.hs0000644000000000000000000000226307346545000021114 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" base-compat-batteries-0.11.1/test/Prelude/0000755000000000000000000000000007346545000016515 5ustar0000000000000000base-compat-batteries-0.11.1/test/Prelude/CompatSpec.hs0000644000000000000000000000061607346545000021112 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.11.1/test/0000755000000000000000000000000007346545000015115 5ustar0000000000000000base-compat-batteries-0.11.1/test/SafeHaskellSpec.hs0000644000000000000000000000367707346545000020463 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.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.Error () import Text.Read.Compat () import Type.Reflection.Compat () main :: IO () main = hspec spec spec :: Spec spec = pure () base-compat-batteries-0.11.1/test/Spec.hs0000644000000000000000000000005407346545000016342 0ustar0000000000000000{-# OPTIONS_GHC -F -pgmF hspec-discover #-} base-compat-batteries-0.11.1/test/System/Environment/0000755000000000000000000000000007346545000020705 5ustar0000000000000000base-compat-batteries-0.11.1/test/System/Environment/CompatSpec.hs0000644000000000000000000000763507346545000023312 0ustar0000000000000000{-# LANGUAGE CPP #-} module System.Environment.CompatSpec (main, spec) where import Test.Hspec #if __GLASGOW_HASKELL__ >= 702 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__ >= 702 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__ >= 702 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__ >= 702 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.11.1/test/TestHspecTrustworthy.hs0000644000000000000000000000033207346545000021670 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.11.1/test/Text/Read/0000755000000000000000000000000007346545000016714 5ustar0000000000000000base-compat-batteries-0.11.1/test/Text/Read/CompatSpec.hs0000644000000000000000000000117607346545000021313 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)