packages feed

planet-mitchell (empty) → 0.0.0

raw patch · 256 files changed

+5693/−0 lines, 256 filesdep +Earleydep +aesondep +aeson-prettysetup-changed

Dependencies added: Earley, aeson, aeson-pretty, aeson-qq, ansi-terminal, approximate, array, async, atomic-primops, base, base-orphans, base16-bytestring, bits, bytestring, bytestring-lexing, case-insensitive, cborg, comonad, compact, constraints, containers, contravariant, contravariant-extras, deepseq, distributive, dlist, double-conversion, envparse, erf, exceptions, extra, fgl, filepath, foldl, free, gauge, generic-aeson, half, hashable, heaps, hedgehog, integer-logarithms, lens, lens-aeson, list-transformer, logict, managed, megaparsec, mmorph, monad-ste, mtl, multiset, mwc-random, network, network-info, network-uri, nf, optparse-applicative, parallel, parser-combinators, pointed, prettyprinter, prettyprinter-ansi-terminal, primitive, profunctors, psqueues, reactive-banana, reflection, regex-applicative, scientific, semigroupoids, semigroups, semilattices, serialise, split, stm, stm-chans, stm-containers, tagged, text, text-short, time, transformers, transformers-base, transformers-compat, typed-process, unagi-chan, unix, unliftio, unordered-containers, utf8-string, uuid, uuid-types, vault, vector, vector-builder, weigh, writer-cps-mtl

Files

+ .travis.yml view
@@ -0,0 +1,25 @@+sudo: false+language: generic++cache:+  directories:+  - $HOME/.stack+  - $TRAVIS_BUILD_DIR/.stack-work/install++addons:+  apt:+    packages:+      - libgmp-dev++before_install:+  - mkdir -p ~/.local/bin+  - export PATH=$HOME/.local/bin:$PATH+  - travis_retry curl -L https://get.haskellstack.org/stable/linux-x86_64.tar.gz | tar xz --wildcards --strip-components=1 -C ~/.local/bin '*/stack'++install:+  - stack --no-terminal setup+  - stack --no-terminal build --fast --only-dependencies++script:+  - stack --no-terminal build --fast --bench --no-run-benchmarks+  - curl -sL https://raw.github.com/ndmitchell/weeder/master/misc/travis.sh | sh -s .
+ CHANGELOG.md view
@@ -0,0 +1,11 @@+# Changelog++All notable changes to this project will be documented in this file.++The format is based on [Keep a Changelog](http://keepachangelog.com/)+and this project adheres to the [Haskell Package Versioning Policy](https://pvp.haskell.org/).++## [0.0.0] - 2018-09-20++### Added+- Initial release
+ LICENSE view
@@ -0,0 +1,11 @@+Copyright 2018 Mitchell Rosen++Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:++1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.++2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.++3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.++THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ README.md view
@@ -0,0 +1,39 @@+### Summary++`planet-mitchell` is my very own Haskell package planet.++It contains no new code, only re-exports from `base` and various well-known+packages, similar to [https://hackage.haskell.org/package/rebase](rebase).++- `Control.`, `Data.`, `Foreign.`, etc. module prefixes are stripped. The idea+  here is that, if a name such as `Applicative` is sufficiently unambiguous in+  the Haskell ecosystem, it deserves as short a module name as possible.++  See the [elm standard library](http://package.elm-lang.org/packages/elm-lang/core/latest)+  for inspiration.++- The module hierarchy is not faithful to the underlying packages. Many modules+  contain related re-exports from multiple packages, and I've invented a few new+  sin-bin modules such as `Concurrency`, `Parallelism`, `Eval`, and `Debug`.++- To reduce API surface area and encourage a consistent vocabulary, redundant+  functions like `sequence` and `mapM` are not re-exported.++- Odd, uncommon, and deprecated types and functions (like `WrappedApplicative`)+  are not re-exported.++- Partial functions are discouraged and mostly live in `.Partial` modules. (This+  is a work-in-progress).++- Unsafe functions are discouraged and mostly live in `.Unsafe` modules. (This+  is a work-in-progress).++- `String` is heavily discouraged, and many `String` IO functions are not+  re-exported; `Text` and/or `ByteString` versions are re-exported instead.++- Generalizations like `MonadIO` / `MonadUnliftIO` are used where possible.++### Stability++Alpha quality, massive breaking changes should be expected and no changelog will+be kept for some time. Don't use this package.
+ Setup.hs view
@@ -0,0 +1,2 @@+import Distribution.Simple+main = defaultMain
+ planet-mitchell.cabal view
@@ -0,0 +1,402 @@+cabal-version: 2.0++author: Mitchell Rosen+build-type: Simple+category: Prelude+description:+  Planet Mitchell.+  .+  This package provides a curated, highly unstable collection of reorganized+  re-exports. Mostly for personal use at the moment, me but please poke around+  and see README.md for a bit more information ;)+license-file: LICENSE+license: BSD3+maintainer: Mitchell Rosen <mitchellwrosen@gmail.com>+name: planet-mitchell+synopsis: Planet Mitchell+tested-with: GHC == 8.4.3+version: 0.0.0+homepage: https://github.com/mitchellwrosen/planet-mitchell+bug-reports: https://github.com/mitchellwrosen/planet-mitchell/issues+copyright: (c) 2018, Mitchell Rosen++extra-source-files:+  .travis.yml+  CHANGELOG.md+  README.md++source-repository head+  type: git+  location: git://github.com/mitchellwrosen/planet-mitchell.git++library+  hs-source-dirs: src+  ghc-options:+    -Weverything+    -fno-warn-safe+    -fno-warn-unsafe+    -- TODO re-enable+    -fno-warn-missing-import-lists+  default-extensions: NoImplicitPrelude+  default-language: Haskell2010++  build-depends:+      aeson ^>= 1.3.1 || ^>= 1.4.0+    , base ^>= 4.10 || ^>= 4.11+    , base-orphans ^>= 0.8+    , aeson-pretty ^>= 0.8.7+    , aeson-qq ^>= 0.8.2+    , ansi-terminal ^>= 0.8.0+    , approximate ^>= 0.3.1+    , array ^>= 0.5.2+    , async ^>= 2.2.1+    , atomic-primops ^>= 0.8+    , base16-bytestring ^>= 0.1.1+    , bits ^>= 0.5.0+    , bytestring ^>= 0.10.8+    , bytestring-lexing ^>= 0.5.0+    , case-insensitive ^>= 1.2.0+    , cborg ^>= 0.2.0+    , comonad ^>= 5.0+    , compact ^>= 0.1.0+    , constraints ^>= 0.10+    , containers ^>= 0.5.11+    , contravariant ^>= 1.4.1+    , contravariant-extras ^>= 0.3.4+    , deepseq ^>= 1.4.3+    , distributive ^>= 0.5.3+    , dlist ^>= 0.8.0+    , double-conversion ^>= 2.0.2.0+    , Earley ^>= 0.12.0+    , envparse ^>= 0.4+    , erf ^>= 2.0.0+    , exceptions ^>= 0.10.0+    , extra ^>= 1.6.9 || ^>= 1.6.10 || ^>= 1.6.11+    , fgl ^>= 5.6.0+    , filepath ^>= 1.4.2+    , foldl ^>= 1.4.0+    , free ^>= 5.1+    , gauge ^>= 0.2.1+    , generic-aeson ^>= 0.2.0.9+    , half ^>= 0.3+    , hashable ^>= 1.2.7+    , heaps ^>= 0.3.0+    , hedgehog ^>= 0.5.3 || ^>= 0.6+    , integer-logarithms ^>= 1.0.2+    , lens ^>= 4.16.1+    , lens-aeson ^>= 1.0.2+    , list-transformer ^>= 1.0.4+    , logict ^>= 0.6.0+    , managed ^>= 1.0.6+    , megaparsec ^>= 6.5.0+    , mmorph ^>= 1.1.2+    , monad-ste ^>= 0.1.0+    , mtl ^>= 2.2.2+    , multiset ^>= 0.3.4+    , mwc-random ^>= 0.13.6+    , network ^>= 2.7.0+    , network-info ^>= 0.2.0+    , network-uri ^>= 2.6.1+    , nf ^>= 1.0.1+    , optparse-applicative ^>= 0.14.2+    , parallel ^>= 3.2.1+    , parser-combinators ^>= 1.0.0+    , pointed ^>= 5.0.1+    , prettyprinter ^>= 1.2.0+    , prettyprinter-ansi-terminal ^>= 1.1.1+    , primitive ^>= 0.6.4+    , profunctors ^>= 5.2 || ^>= 5.3+    , psqueues ^>= 0.2.7+    , reactive-banana ^>= 1.2.0+    , reflection ^>= 2.1+    , regex-applicative ^>= 0.3.3+    , scientific ^>= 0.3.6+    , semigroupoids ^>= 5.3.1+    , semigroups ^>= 0.18.4+    , semilattices ^>= 0.0.0+    , serialise ^>= 0.2.0+    , split ^>= 0.2.3.3+    , stm ^>= 2.4.5+    , stm-chans ^>= 3.0.0+    , stm-containers ^>= 0.2.16+    , tagged ^>= 0.8.5+    , text ^>= 1.2.3+    , text-short ^>= 0.1.2+    , time ^>= 1.8 || ^>= 1.9.1+    , transformers ^>= 0.5.5+    , transformers-base ^>= 0.4.5+    , transformers-compat ^>= 0.6.2+    , typed-process ^>= 0.2.2+    , unagi-chan ^>= 0.4.1+    , unix ^>= 2.7.2+    , unliftio ^>= 0.2.7.0+    , unordered-containers ^>= 0.2.9+    , utf8-string ^>= 1.0.1.1+    , uuid ^>= 1.3.13+    , uuid-types ^>= 1.0.3+    , vault ^>= 0.3.1+    , vector ^>= 0.12.0+    , vector-builder ^>= 0.3.6+    , weigh ^>= 0.0.12+    , writer-cps-mtl ^>= 0.1.1++  exposed-modules:+    Ala.Compose+    Ala.Const+    Ala.Identity+    Ala.Product+    Ala.Sum+    Applicative+    Array+    Array.Partial+    Benchmark+    Bifoldable+    Bifoldable.Partial+    Bifunctor+    Bitraversable+    Bits+    Bool+    Bounded+    ByteString+    ByteString.Base16+    ByteString.Latin1+    ByteString.Latin1.Partial+    ByteString.Lazy+    ByteString.Lazy.Base16+    ByteString.Lazy.Latin1+    ByteString.Lazy.Utf8+    ByteString.Partial+    ByteString.Short+    ByteString.Short.Partial+    ByteString.Utf8+    CaseInsensitive+    Category+    Char+    Char.Partial+    Clock+    Coerce+    Coerce.Unsafe+    Comonad+    CompactRegion+    Concurrency+    Concurrency.Chan+    Concurrency.Counter+    Concurrency.IORef+    Concurrency.MVar+    Concurrency.QSem+    Concurrency.TBChan+    Concurrency.TBMChan+    Concurrency.TBMQueue+    Concurrency.TBQueue+    Concurrency.TBimap+    Concurrency.TChan+    Concurrency.TMChan+    Concurrency.TMQueue+    Concurrency.TMVar+    Concurrency.TMap+    Concurrency.TMultimap+    Concurrency.TSem+    Concurrency.TSet+    Concurrency.TVar+    Constraint+    Cont+    Contravariant+    Copointed+    Data+    Debug+    Decidable+    Distributive+    Divisible+    Dynamic+    Either+    Enum+    Environment+    Equality+    Error+    Eval+    Except+    Exception+    FRP+    Field+    File+    File.Binary+    File.Text+    Foldable+    Foldable.Partial+    Foldl+    Function+    Functor+    Generic+    Graph.Adjacency+    Graph.Inductive+    Groupoid+    Hashable+    Heap+    IO+    IO.Unsafe+    Ix+    Json+    Json.Decode+    Json.Encode+    Label+    List+    List.Builder+    List.Builder.Partial+    List.Partial+    List1+    List1.Partial+    ListT+    Logic+    Managed+    Map+    Map.Hash+    Map.Int+    Map.Int.Lazy+    Map.Lazy+    Maybe+    Maybe.Partial+    MaybeT+    Mitchell.Prelude+    Monad+    Monad.Base+    Monad.Fail+    Monad.Fix+    Monad.Plus+    Monad.Trans+    Monad.Zip+    Monoid+    MultiSet+    MultiSet.Int+    Numeric.Approximate+    Numeric.Complex+    Numeric.Double+    Numeric.Erf+    Numeric.Fast+    Numeric.Float+    Numeric.Floating+    Numeric.Fractional+    Numeric.Half+    Numeric.Int+    Numeric.Integer+    Numeric.Integral+    Numeric.InvErf+    Numeric.Nat+    Numeric.Natural+    Numeric.Num+    Numeric.Product+    Numeric.Ratio+    Numeric.Real+    Numeric.RealFloat+    Numeric.RealFrac+    Numeric.Scientific+    Numeric.Sum+    Numeric.Word+    Optic.Fold+    Optic.Getter+    Optic.Getting+    Optic.Iso+    Optic.Iso.Reversing+    Optic.Iso.Strict+    Optic.Lens+    Optic.Lens.At+    Optic.Lens.Contains+    Optic.Prism+    Optic.Prism.Cons+    Optic.Prism.Empty+    Optic.Prism.Snoc+    Optic.Review+    Optic.Setter+    Optic.Traversal+    Optic.Traversal.Each+    Optic.Traversal.Ixed+    Ord+    Parallelism+    Parser.Binary+    Parser.Cli+    Parser.Earley+    Parser.Env+    Parser.Text+    Pointed+    Posix+    Predicate+    Pretty+    Prim+    Printf+    Process+    Profunctor+    Proxy+    Ptr+    Ptr.Foreign+    Ptr.Fun+    Ptr.Stable+    Ptr.Static+    Ptr.Weak+    Queue.Prio.Hash+    Queue.Prio.Int+    Queue.Prio.Ord+    Random+    Read+    Read.Partial+    Reader+    Reflection+    Regex+    RuntimeSystem+    ST+    Semigroup+    Semigroupoid+    Semilattice+    Sequence+    Serialise+    Set+    Set.Hash+    Set.Int+    Show+    Socket+    StableName+    State+    Storable+    Symbol+    System+    Tagged+    Terminal+    Test+    Test.Gen+    Test.Range+    Text+    Text.Lazy+    Text.Lazy.Builder+    Text.Partial+    Text.Short+    Text.Short.Partial+    Text.Short.Unsafe+    Time+    Traversable+    Tree+    Tuple+    Type+    Typeable+    URI+    UUID+    Unique+    Vault+    Vault.Lazy+    Vector+    Vector.Builder+    Vector.Generic+    Vector.Generic.Mutable+    Vector.Mutable+    Vector.Primitive+    Vector.Storable+    Vector.Unboxed+    Void+    Weigh+    Writer++-- benchmark semaphore+--   hs-source-dirs: bench+--   main-is: Semaphore.hs+--   ghc-options: -Wall+--   type: exitcode-stdio-1.0+--   ghc-options: -O -rtsopts -threaded "-with-rtsopts=-N4 -qg"+--   build-depends: planet-mitchell+--   default-language: Haskell2010
+ src/Ala/Compose.hs view
@@ -0,0 +1,5 @@+module Ala.Compose+  ( Compose(..)+  ) where++import Data.Functor.Compose (Compose(Compose, getCompose))
+ src/Ala/Const.hs view
@@ -0,0 +1,5 @@+module Ala.Const+  ( Const(..)+  ) where++import Data.Functor.Const (Const(Const, getConst))
+ src/Ala/Identity.hs view
@@ -0,0 +1,11 @@+module Ala.Identity+  ( Identity(..)+  , IdentityT(..)+  , mapIdentityT+  , generalize+  ) where++import Control.Monad.Morph          (generalize)+import Control.Monad.Trans.Identity (IdentityT(IdentityT, runIdentityT),+                                     mapIdentityT)+import Data.Functor.Identity        (Identity(Identity, runIdentity))
+ src/Ala/Product.hs view
@@ -0,0 +1,5 @@+module Ala.Product+  ( Product(..)+  ) where++import Data.Functor.Product (Product(Pair))
+ src/Ala/Sum.hs view
@@ -0,0 +1,5 @@+module Ala.Sum+  ( Sum(..)+  ) where++import Data.Functor.Sum (Sum(InL, InR))
+ src/Applicative.hs view
@@ -0,0 +1,61 @@+module Applicative+  ( -- * Applicative+    Applicative(..)+  , between+  , filterM+  , forever+  , liftA3+  , replicateM+  , replicateM_+  , unless+  , when+  , zipWithM+  , zipWithM_+    -- * Alternative+  , Alternative((<|>), empty, many)+  , endBy+  , endBy1+  , guard+  , manyTill+  , optional+  , sepBy+  , sepEndBy+  , sepBy1+  , sepEndBy1+  , skipMany+  , skipManyTill+  , skipSome+  , skipSomeTill+  , some1+  , someTill+    -- ** Newtypes+  , Alt(..)+    -- * Free applicative+  , Ap(..)+  , runAp+  , runAp_+  , liftAp+  , iterAp+  , hoistAp+  , retractAp+  ) where++import Control.Applicative                      (Alternative(empty, many, (<|>)),+                                                 Applicative(liftA2, pure, (*>), (<*), (<*>), (<*>)),+                                                 liftA3)+import Control.Applicative.Combinators          (between, endBy, manyTill,+                                                 sepBy, sepEndBy, skipMany,+                                                 skipManyTill, skipSome,+                                                 skipSomeTill)+import Control.Applicative.Combinators.NonEmpty (endBy1, sepBy1, sepEndBy1,+                                                 someTill)+import Control.Applicative.Free                 (Ap(Ap, Pure), hoistAp, iterAp,+                                                 liftAp, retractAp, runAp,+                                                 runAp_)+import Control.Monad                            (filterM, forever, guard,+                                                 replicateM, replicateM_,+                                                 unless, when, zipWithM,+                                                 zipWithM_)+import Data.Functor.Alt                         (optional)+import Data.List.NonEmpty                       (some1)+import Data.Monoid                              (Alt(Alt, getAlt))
+ src/Array.hs view
@@ -0,0 +1,12 @@+module Array+  ( Array+  , array+  , bounds+  , indices+  , assocs+  , (//)+  , accum+  , ixmap+  ) where++import Data.Array
+ src/Array/Partial.hs view
@@ -0,0 +1,5 @@+module Array.Partial+  ( (!)+  ) where++import Data.Array
+ src/Benchmark.hs view
@@ -0,0 +1,23 @@+module Benchmark+  ( -- * Running benchmarks+    defaultMain+    -- * Constructing benchmarks+    -- ** Benchmark+  , Benchmark+  , bench+  , bgroup+  , env+  , envWithCleanup+    -- ** Benchmarkable+  , Benchmarkable+  , nfIO+  , whnfIO+  , nf+  , whnf+  , perBatchEnv+  , perBatchEnvWithCleanup+  , perRunEnv+  , perRunEnvWithCleanup+  ) where++import Gauge
+ src/Bifoldable.hs view
@@ -0,0 +1,34 @@+module Bifoldable+  ( -- * Bifoldable+    Bifoldable(bifold, bifoldMap, bifoldr)+  , bifoldr'+  , bifoldrM+  , bifoldl'+  , bifoldlM+  , bitraverse_+  , bifor_+  , bisequence_+  , biasum+  , biList+  , binull+  , bilength+  , bielem+  , bisum+  , biproduct+  , biconcatMap+  , biand+  , bior+  , biany+  , biall+  , binotElem+  , bifind+    -- * Bifoldable1+  , Bifoldable1(..)+  , bitraverse1_+  , bifor1_+  , bisequenceA1_+  ) where++import Data.Bifoldable+import Data.Semigroup.Bifoldable (Bifoldable1(bifold1, bifoldMap1), bifor1_,+                                  bisequenceA1_, bitraverse1_)
+ src/Bifoldable/Partial.hs view
@@ -0,0 +1,10 @@+module Bifoldable.Partial+  ( bifoldl1+  , bifoldr1+  , bimaximum+  , bimaximumBy+  , biminimum+  , biminimumBy+  ) where++import Data.Bifoldable
+ src/Bifunctor.hs view
@@ -0,0 +1,11 @@+module Bifunctor+  ( -- * Bifunctor+    Bifunctor(..)+  , Swapped(..)+    -- * Biapply+  , Biapply(..)+  ) where++import Control.Lens.Iso (Swapped(swapped))+import Data.Bifunctor+import Data.Bifunctor.Apply (Biapply((<<.>>), (.>>), (<<.)))
+ src/Bitraversable.hs view
@@ -0,0 +1,22 @@+module Bitraversable+  ( -- * Bitraversable+    Bitraversable(..)+  , bisequence+  , bifor+  , bimapAccumL+  , bimapAccumR+    -- ** Default @Bifunctor@ implementation+  , bimapDefault+    -- ** Default @Bifoldable@ implementation+  , bifoldMapDefault+    -- * Bitraversable1+  , Bitraversable1(..)+    -- ** Default @Bifoldable1@ implementation+  , bifoldMap1Default+  ) where++import Data.Bitraversable           (Bitraversable(bitraverse),+                                     bifoldMapDefault, bifor, bimapAccumL,+                                     bimapAccumR, bimapDefault, bisequence)+import Data.Semigroup.Bitraversable (Bitraversable1(bisequence1, bitraverse1),+                                     bifoldMap1Default)
+ src/Bits.hs view
@@ -0,0 +1,16 @@+module Bits+  ( -- * Bits+    Bits(..)+  , srl+  , toIntegralSized+  , FiniteBits(..)+  , Ranked(..)+  , msb+    -- * Default @Bits@ implementations+  , bitDefault+  , testBitDefault+  , popCountDefault+  ) where++import Data.Bits+import Data.Bits.Extras
+ src/Bool.hs view
@@ -0,0 +1,23 @@+{-# LANGUAGE ExplicitNamespaces #-}++module Bool+  ( -- * Boolean+    Bool(..)+  , (&&)+  , (||)+  , not+  , otherwise+  , bool+    -- ** Newtypes+  , All(..)+  , Any(..)+    -- * Boolean type functions+  , If+  , type (&&)+  , type (||)+  , Not+  ) where++import Data.Bool+import Data.Monoid+import Data.Type.Bool
+ src/Bounded.hs view
@@ -0,0 +1,13 @@+module Bounded+  ( -- * Bounded+    Bounded(..)+  , Lower(..)+  , Upper(..)+    -- ** Newtypes+  , Bound(..)+  ) where++import Data.Semilattice.Bound+import Data.Semilattice.Lower+import Data.Semilattice.Upper+import GHC.Enum
+ src/ByteString.hs view
@@ -0,0 +1,86 @@+module ByteString+  ( -- * ByteString+    ByteString+  , all+  , any+  , asHexadecimal+  , append+  , break+  , breakEnd+  , breakSubstring+  , concat+  , concatMap+  , cons+  , copy+  , count+  , drop+  , dropWhile+  , elem+  , elemIndex+  , elemIndexEnd+  , elemIndices+  , empty+  , filter+  , find+  , findIndex+  , findIndices+  , foldl'+  , foldr+  , group+  , groupBy+  , index+  , inits+  , intercalate+  , intersperse+  , isInfixOf+  , isPrefixOf+  , isSuffixOf+  , length+  , map+  , mapAccumL+  , mapAccumR+  , notElem+  , null+  , pack+  , packCString+  , packCStringLen+  , partition+  , replicate+  , reverse+  , scanl+  , scanl1+  , scanr+  , scanr1+  , singleton+  , snoc+  , sort+  , span+  , spanEnd+  , split+  , splitAt+  , splitWith+  , stripPrefix+  , stripSuffix+  , tails+  , take+  , takeWhile+  , transpose+  , uncons+  , unfoldr+  , unfoldrN+  , unpack+  , unsnoc+  , unzip+  , useAsCString+  , useAsCStringLen+  , zip+  , zipWith+    -- ** Optics+  , bytes+  , packedBytes+  , unpackedBytes+  ) where++import Data.ByteString+import Data.ByteString.Lens+import Data.ByteString.Lex.Integral (asHexadecimal)
+ src/ByteString/Base16.hs view
@@ -0,0 +1,6 @@+module ByteString.Base16+  ( encode+  , decode+  ) where++import Data.ByteString.Base16 (decode, encode)
+ src/ByteString/Latin1.hs view
@@ -0,0 +1,96 @@+module ByteString.Latin1+  ( -- * Latin-1 ByteString+    all+  , any+  , append+  , break+  , breakEnd+  , breakSubstring+  , concat+  , concatMap+  , cons+  , copy+  , count+  , drop+  , dropWhile+  , elem+  , elemIndex+  , elemIndexEnd+  , elemIndices+  , empty+  , filter+  , find+  , findIndex+  , findIndices+  , foldl'+  , foldr'+  , foldr+  , group+  , groupBy+  , inits+  , intercalate+  , intersperse+  , isInfixOf+  , isPrefixOf+  , isSuffixOf+  , length+  , lines+  , map+  , mapAccumL+  , mapAccumR+  , notElem+  , null+  , pack+  , packCString+  , packCStringLen+  , packDecimal+  , packHexadecimal+  , packOctal+  , readDecimal+  , readInt+  , readInteger+  , readHexadecimal+  , readOctal+  , readSigned+  , replicate+  , reverse+  , scanl+  , scanl1+  , scanr+  , scanr1+  , singleton+  , snoc+  , sort+  , span+  , spanEnd+  , split+  , splitAt+  , splitWith+  , stripPrefix+  , stripSuffix+  , tails+  , take+  , takeWhile+  , transpose+  , uncons+  , unfoldr+  , unfoldrN+  , unlines+  , unpack+  , unsnoc+  , unwords+  , unzip+  , useAsCString+  , useAsCStringLen+  , words+  , zip+  , zipWith+    -- ** Optics+  , chars+  , packedChars+  , unpackedChars+  ) where++import Data.ByteString.Char8+import Data.ByteString.Lens         (chars, packedChars, unpackedChars)+import Data.ByteString.Lex.Integral
+ src/ByteString/Latin1/Partial.hs view
@@ -0,0 +1,14 @@+module ByteString.Latin1.Partial+  ( foldl1'+  , foldr1+  , foldr1'+  , head+  , index+  , init+  , last+  , maximum+  , minimum+  , tail+  ) where++import Data.ByteString.Char8
+ src/ByteString/Lazy.hs view
@@ -0,0 +1,11 @@+module ByteString.Lazy+  ( -- FIXME+    module Data.ByteString.Lazy+    -- ** Optics+  , bytes+  , packedBytes+  , unpackedBytes+  ) where++import Data.ByteString.Lazy+import Data.ByteString.Lens (bytes, packedBytes, unpackedBytes)
+ src/ByteString/Lazy/Base16.hs view
@@ -0,0 +1,6 @@+module ByteString.Lazy.Base16+  ( encode+  , decode+  ) where++import Data.ByteString.Base16.Lazy (decode, encode)
+ src/ByteString/Lazy/Latin1.hs view
@@ -0,0 +1,5 @@+module ByteString.Lazy.Latin1+  ( module Data.ByteString.Lazy.Char8+  ) where++import Data.ByteString.Lazy.Char8
+ src/ByteString/Lazy/Utf8.hs view
@@ -0,0 +1,19 @@+module ByteString.Lazy.Utf8+  ( break+  , drop+  , foldl+  , foldr+  , fromString+  , length+  , span+  , splitAt+  , take+  , toString+  , uncons+    -- ** Optics+  , utf8+  ) where++import Data.ByteString.Lazy.UTF8 (break, drop, foldl, foldr, fromString, length,+                                  span, splitAt, take, toString, uncons)+import Data.Text.Lazy.Lens       (utf8)
+ src/ByteString/Partial.hs view
@@ -0,0 +1,13 @@+module ByteString.Partial+  ( foldl1'+  , foldr1+  , foldr1'+  , head+  , init+  , last+  , maximum+  , minimum+  , tail+  ) where++import Data.ByteString
+ src/ByteString/Short.hs view
@@ -0,0 +1,14 @@+module ByteString.Short+  ( -- * ShortByteString+    ShortByteString+  , toShort+  , fromShort+  , pack+  , unpack+  , empty+  , null+  , length+  ) where++import Data.ByteString.Short (ShortByteString, empty, fromShort, length, null,+                              pack, toShort, unpack)
+ src/ByteString/Short/Partial.hs view
@@ -0,0 +1,6 @@+module ByteString.Short.Partial+  ( -- * ShortByteString+    index+  ) where++import Data.ByteString.Short (index)
+ src/ByteString/Utf8.hs view
@@ -0,0 +1,19 @@+module ByteString.Utf8+  ( break+  , drop+  , foldl+  , foldr+  , fromString+  , length+  , span+  , splitAt+  , take+  , toString+  , uncons+    -- ** Optics+  , utf8+  ) where++import Data.ByteString.UTF8  (break, drop, foldl, foldr, fromString, length,+                              span, splitAt, take, toString, uncons)+import Data.Text.Strict.Lens (utf8)
+ src/CaseInsensitive.hs view
@@ -0,0 +1,7 @@+-- TODO find a better home for CaseInsensitive++module CaseInsensitive+  ( module Data.CaseInsensitive+  ) where++import Data.CaseInsensitive
+ src/Category.hs view
@@ -0,0 +1,7 @@+module Category+  ( Category(..)+  , (>>>)+  , (<<<)+  ) where++import Control.Category
+ src/Char.hs view
@@ -0,0 +1,37 @@+module Char+  ( -- * Char+    Char+  , isControl+  , isSpace+  , isLower+  , isUpper+  , isAlpha+  , isAlphaNum+  , isPrint+  , isDigit+  , isOctDigit+  , isHexDigit+  , isLetter+  , isMark+  , isNumber+  , isPunctuation+  , isSymbol+  , isSeparator+  , isAscii+  , isAsciiUpper+  , isAsciiLower+  , isLatin1+  , GeneralCategory(..)+  , generalCategory+  , toUpper+  , toLower+  , toTitle+  , ord+  , showChar+  , showLitChar+  , lexLitChar+  , readLitChar+  ) where++import Data.Char+import GHC.Show  (showChar)
+ src/Char/Partial.hs view
@@ -0,0 +1,7 @@+module Char.Partial+  ( digitToInt+  , intToDigit+  , chr+  ) where++import Data.Char (chr, digitToInt, intToDigit)
+ src/Clock.hs view
@@ -0,0 +1,18 @@+{-# LANGUAGE CPP #-}++module Clock+  (+#if MIN_VERSION_base(4,11,0)+    -- * Monotonic time+    getMonotonicTime,+    getMonotonicTimeNSec,+#endif+    -- * CPU time+    getCPUTime,+    cpuTimePrecision,+  ) where++#if MIN_VERSION_base(4,11,0)+import GHC.Clock+#endif+import System.CPUTime
+ src/Coerce.hs view
@@ -0,0 +1,16 @@+module Coerce+  ( -- * Coercible+    Coercible+  , coerce+    -- * Coercion+  , Coercion(..)+  , coerceWith+  , gcoerceWith+  , sym+  , trans+  , repr+  , TestCoercion(..)+  ) where++import Data.Coerce+import Data.Type.Coercion
+ src/Coerce/Unsafe.hs view
@@ -0,0 +1,5 @@+module Coerce.Unsafe+  ( unsafeCoerce+  ) where++import Unsafe.Coerce (unsafeCoerce)
+ src/Comonad.hs view
@@ -0,0 +1,20 @@+module Comonad+  ( -- * Comonad+    Comonad(..)+  , wfix+  , cfix+  , kfix+  , (=>=)+  , (=<=)+  , (<<=)+  , (=>>)+    -- * ComonadApply+  , ComonadApply(..)+  , (<@@>)+  , liftW2+  , liftW3+    -- * Newtypes+  , Cokleisli(..)+  ) where++import Control.Comonad
+ src/CompactRegion.hs view
@@ -0,0 +1,17 @@+module CompactRegion+  ( -- * Compact+    Compact+  , compact+  , compactWithSharing+  , compactAdd+  , compactAddWithSharing+  , compactSized+  , getCompact+  , inCompact+  , isCompact+  , compactSize+  , CompactionFailed(..)+  ) where++import Control.Exception (CompactionFailed(..))+import Data.Compact
+ src/Concurrency.hs view
@@ -0,0 +1,115 @@+module Concurrency+  ( -- * Concurrency+    -- ** High-level concurrency+    concurrently+  , concurrently_+  , race+  , race_+  , mapConcurrently+  , mapConcurrently_+  , forConcurrently+  , forConcurrently_+  , replicateConcurrently+  , replicateConcurrently_+  , Concurrently(..)+    -- ** Low-level concurrency using @async@+  , Async+  , async+  , asyncBound+  , asyncOn+  , asyncWithUnmask+  , asyncOnWithUnmask+  , cancel+  , uninterruptibleCancel+  , cancelWith+  , withAsync+  , withAsyncBound+  , withAsyncOn+  , withAsyncWithUnmask+  , withAsyncOnWithUnmask+  , wait+  , waitSTM+  , waitCatch+  , waitCatchSTM+  , waitAny+  , waitAnySTM+  , waitAnyCatch+  , waitAnyCatchSTM+  , waitAnyCancel+  , waitAnyCatchCancel+  , waitEither+  , waitEitherSTM+  , waitEither_+  , waitEitherSTM_+  , waitEitherCatch+  , waitEitherCatchSTM+  , waitEitherCancel+  , waitEitherCatchCancel+  , waitBoth+  , waitBothSTM+  , poll+  , pollSTM+  , link+  , link2+  , asyncThreadId+  , compareAsyncs+  , ExceptionInLinkedThread(..)+  , AsyncCancelled(..)+    -- ** Lower-level concurrency using @forkIO@+  , forkIO+  , forkWithUnmask+  , forkOn+  , forkOnWithUnmask+  , forkFinally+  , throwTo+  , killThread+    -- * STM+  , STM+  , atomically+  , retry+  , throwSTM+  , catchSTM+  , unsafeIOToSTM+    -- * Delay+  , threadDelay+  , registerDelay+    -- * Cooperative concurrency+  , yield+    -- * Thread info+  , ThreadId+  , myThreadId+  , mkWeakThreadId+  , ThreadStatus(..)+  , BlockReason(..)+  , threadStatus+  , threadCapability+  , labelThread+    -- * File descriptor blocking+  , threadWaitRead+  , threadWaitReadSTM+  , threadWaitWrite+  , threadWaitWriteSTM+  , closeFdWith+    -- * Re-exports+  , module Concurrency.IORef+  , module Concurrency.MVar+  , module Concurrency.TVar+  , module Concurrency.TMVar+  ) where++import Control.Concurrent.Async (AsyncCancelled(..),+                                 ExceptionInLinkedThread(..), compareAsyncs)+import GHC.Conc                 (BlockReason(BlockedOnBlackHole, BlockedOnException, BlockedOnForeignCall, BlockedOnMVar, BlockedOnOther, BlockedOnSTM),+                                 ThreadStatus(..), catchSTM, closeFdWith,+                                 labelThread, retry, threadStatus,+                                 threadWaitReadSTM, threadWaitWriteSTM,+                                 throwSTM, unsafeIOToSTM)+import UnliftIO.Async+import UnliftIO.Concurrent+import UnliftIO.STM++-- Re-exports+import Concurrency.IORef+import Concurrency.MVar+import Concurrency.TMVar+import Concurrency.TVar
+ src/Concurrency/Chan.hs view
@@ -0,0 +1,19 @@+module Concurrency.Chan+  ( -- * Creating channels+    newChan+  , InChan+  , OutChan+    -- * Reading+  , readChan+  , readChanOnException+  , tryReadChan+  , Element(..)+  , estimatedLength+    -- * Writing+  , writeChan+  , tryWriteChan+    -- * Broadcasting+  , dupChan+  ) where++import Control.Concurrent.Chan.Unagi.Bounded
+ src/Concurrency/Counter.hs view
@@ -0,0 +1,11 @@+module Concurrency.Counter+  ( -- * Counter+    AtomicCounter+  , newCounter+  , incrCounter+  , incrCounter_+  , readCounter+  , casCounter+  ) where++import Data.Atomics.Counter
+ src/Concurrency/IORef.hs view
@@ -0,0 +1,27 @@+module Concurrency.IORef+  ( -- * IORef+    IORef+  , newIORef+  , readIORef+  , writeIORef+  , writeIORef'+  , modifyIORef+  , modifyIORef'+  , atomicModifyIORef+  , atomicModifyIORef'+  , atomicWriteIORef+  , atomicWriteIORef'+  , mkWeakIORef+    -- * Atomic check-and-set+  , Ticket+  , peekTicket+  , readForCAS+  , casIORef+  , casIORef2+  , atomicModifyIORefCAS+  , atomicModifyIORefCAS_+  ) where++import Data.Atomics+import Data.IORef.Extra (atomicWriteIORef', writeIORef')+import UnliftIO.IORef
+ src/Concurrency/MVar.hs view
@@ -0,0 +1,23 @@+module Concurrency.MVar+  ( -- * MVar+    MVar+  , newEmptyMVar+  , newMVar+  , takeMVar+  , putMVar+  , readMVar+  , swapMVar+  , tryTakeMVar+  , tryPutMVar+  , isEmptyMVar+  , withMVar+  , withMVarMasked+  , modifyMVar_+  , modifyMVar+  , modifyMVarMasked_+  , modifyMVarMasked+  , tryReadMVar+  , mkWeakMVar+  ) where++import UnliftIO.MVar
+ src/Concurrency/QSem.hs view
@@ -0,0 +1,15 @@+module Concurrency.QSem+  ( -- * QSem+    QSem+  , newQSem+  , waitQSem+  , signalQSem+    -- * QSemN+  , QSemN+  , newQSemN+  , waitQSemN+  , signalQSemN+  ) where++import Control.Concurrent.QSem+import Control.Concurrent.QSemN
+ src/Concurrency/TBChan.hs view
@@ -0,0 +1,5 @@+module Concurrency.TBChan+  ( module Control.Concurrent.STM.TBChan+  ) where++import Control.Concurrent.STM.TBChan
+ src/Concurrency/TBMChan.hs view
@@ -0,0 +1,5 @@+module Concurrency.TBMChan+  ( module Control.Concurrent.STM.TBMChan+  ) where++import Control.Concurrent.STM.TBMChan
+ src/Concurrency/TBMQueue.hs view
@@ -0,0 +1,5 @@+module Concurrency.TBMQueue+  ( module Control.Concurrent.STM.TBMQueue+  ) where++import Control.Concurrent.STM.TBMQueue
+ src/Concurrency/TBQueue.hs view
@@ -0,0 +1,22 @@+module Concurrency.TBQueue+  (+    TBQueue+  , newTBQueue+  , newTBQueueIO+  , readTBQueue+  , tryReadTBQueue+  , flushTBQueue+  , peekTBQueue+  , tryPeekTBQueue+  , writeTBQueue+  , unGetTBQueue+  , isEmptyTBQueue+  , isFullTBQueue+  ) where++import Control.Concurrent.STM.TBQueue (flushTBQueue)+import UnliftIO.STM                   (TBQueue, isEmptyTBQueue, isFullTBQueue,+                                       newTBQueue, newTBQueueIO, peekTBQueue,+                                       readTBQueue, tryPeekTBQueue,+                                       tryReadTBQueue, unGetTBQueue,+                                       writeTBQueue)
+ src/Concurrency/TBimap.hs view
@@ -0,0 +1,5 @@+module Concurrency.TBimap+  ( module STMContainers.Bimap+  ) where++import STMContainers.Bimap
+ src/Concurrency/TChan.hs view
@@ -0,0 +1,19 @@+module Concurrency.TChan+  ( -- * TChan+    TChan+  , newTChan+  , newTChanIO+  , newBroadcastTChan+  , newBroadcastTChanIO+  , dupTChan+  , cloneTChan+  , readTChan+  , tryReadTChan+  , peekTChan+  , tryPeekTChan+  , writeTChan+  , unGetTChan+  , isEmptyTChan+  ) where++import UnliftIO.STM
+ src/Concurrency/TMChan.hs view
@@ -0,0 +1,5 @@+module Concurrency.TMChan+  ( module Control.Concurrent.STM.TMChan+  ) where++import Control.Concurrent.STM.TMChan
+ src/Concurrency/TMQueue.hs view
@@ -0,0 +1,5 @@+module Concurrency.TMQueue+  ( module Control.Concurrent.STM.TMQueue+  ) where++import Control.Concurrent.STM.TMQueue
+ src/Concurrency/TMVar.hs view
@@ -0,0 +1,19 @@+module Concurrency.TMVar+  ( -- * TMVar+    TMVar+  , newTMVar+  , newTMVarIO+  , newEmptyTMVar+  , newEmptyTMVarIO+  , takeTMVar+  , tryTakeTMVar+  , putTMVar+  , tryPutTMVar+  , readTMVar+  , tryReadTMVar+  , swapTMVar+  , isEmptyTMVar+  , mkWeakTMVar+  ) where++import UnliftIO.STM
+ src/Concurrency/TMap.hs view
@@ -0,0 +1,5 @@+module Concurrency.TMap+  ( module STMContainers.Map+  ) where++import STMContainers.Map
+ src/Concurrency/TMultimap.hs view
@@ -0,0 +1,5 @@+module Concurrency.TMultimap+  ( module STMContainers.Multimap+  ) where++import STMContainers.Multimap
+ src/Concurrency/TSem.hs view
@@ -0,0 +1,10 @@+module Concurrency.TSem+  ( -- * TSem+    TSem+  , newTSem+  , waitTSem+  , signalTSem+  , signalTSemN+  ) where++import Control.Concurrent.STM.TSem
+ src/Concurrency/TSet.hs view
@@ -0,0 +1,5 @@+module Concurrency.TSet+  ( module STMContainers.Set+  ) where++import STMContainers.Set
+ src/Concurrency/TVar.hs view
@@ -0,0 +1,15 @@+module Concurrency.TVar+  ( -- * TVar+    TVar+  , newTVar+  , newTVarIO+  , readTVar+  , readTVarIO+  , writeTVar+  , modifyTVar+  , modifyTVar'+  , swapTVar+  , mkWeakTVar+  ) where++import UnliftIO.STM
+ src/Constraint.hs view
@@ -0,0 +1,10 @@+-- | <https://hackage.haskell.org/package/constraints>++module Constraint+  ( -- * Re-exports+    module Data.Constraint+  , module Data.Constraint.Forall+  ) where++import Data.Constraint+import Data.Constraint.Forall
+ src/Cont.hs view
@@ -0,0 +1,17 @@+module Cont+  ( -- * Cont+    Cont+  , cont+  , runCont+  , mapCont+  , withCont+    -- * ContT+  , ContT(..)+  , mapContT+  , withContT+    -- * MonadCont+  , MonadCont(..)+  ) where++import Control.Monad.Cont.Class+import Control.Monad.Trans.Cont
+ src/Contravariant.hs view
@@ -0,0 +1,13 @@+module Contravariant+  ( -- * Contravariant+    Contravariant(..)+  , phantom+  , (>$<)+  , (>$$<)+  , ($<)+    -- ** Optics+  , contramapped+  ) where++import Control.Lens.Setter        (contramapped)+import Data.Functor.Contravariant
+ src/Copointed.hs view
@@ -0,0 +1,6 @@+module Copointed+  ( -- * Copointed+    Copointed(..)+  ) where++import Data.Copointed (Copointed(copoint))
+ src/Data.hs view
@@ -0,0 +1,50 @@+module Data+  ( module Data.Data+  , gtraverse+  , Plated+  , plate+  , template+  , tinplate+  , uniplate+  , biplate+  , children+  , rewrite+  , rewriteOf+  , rewriteOn+  , rewriteOnOf+  , rewriteM+  , rewriteMOf+  , rewriteMOn+  , rewriteMOnOf+  , universe+  , universeOf+  , universeOn+  , universeOnOf+  , cosmos+  , cosmosOf+  , cosmosOn+  , cosmosOnOf+  , transform+  , transformOf+  , transformOnOf+  , transformM+  , transformMOf+  , transformMOn+  , transformMOnOf+  , contexts+  , contextsOf+  , contextsOn+  , contextsOnOf+  , holes+  , holesOn+  , holesOnOf+  , para+  , paraOf+  , deep+  , composOpFold+  , parts+  ) where++import Control.Lens.Plated+import Data.Data+import Data.Data.Lens
+ src/Debug.hs view
@@ -0,0 +1,69 @@+{-# LANGUAGE PackageImports #-}++module Debug+  ( -- * Tracing strings+    trace+  , traceId+  , traceShow+  , traceShowId+  , traceStack+  , traceM+  , traceShowM+  , traceEvent+  , traceEventIO+  , traceMarker+  , traceMarkerIO+    -- * Simulated call stack+  , CallStack+  , currentCallStack+  , whoCreated+  , HasCallStack+  , callStack+  , emptyCallStack+  , freezeCallStack+  , fromCallSiteList+  , getCallStack+  , popCallStack+  , prettyCallStack+  , pushCallStack+  , withFrozenCallStack+  , GHC.Stack.SrcLoc(..)+  , prettySrcLoc+    -- * Execution stack (requires @libdw@)+  , Location(..)+  , getStackTrace+  , showStackTrace+  ) where++import "base" Prelude++import Debug.Trace+import GHC.ExecutionStack hiding (Location(..), getStackTrace)+import GHC.Stack++import qualified GHC.ExecutionStack++data Location = Location+  { objectName :: String+  , functionName :: String+  , srcLoc :: Maybe (String, Int, Int)+  }++mkLoc :: GHC.ExecutionStack.Location -> Location+mkLoc loc =+  Location+    { objectName = GHC.ExecutionStack.objectName loc+    , functionName = GHC.ExecutionStack.functionName loc+    , srcLoc = fmap mkSrcLoc (GHC.ExecutionStack.srcLoc loc)+    }++mkSrcLoc :: GHC.ExecutionStack.SrcLoc -> (String, Int, Int)+mkSrcLoc loc =+  ( GHC.ExecutionStack.sourceFile loc+  , GHC.ExecutionStack.sourceLine loc+  , GHC.ExecutionStack.sourceColumn loc+  )++getStackTrace :: IO (Maybe [Location])+getStackTrace =+  (fmap.fmap.fmap) mkLoc (GHC.ExecutionStack.getStackTrace)
+ src/Decidable.hs view
@@ -0,0 +1,10 @@+module Decidable+  ( -- * Decidable+    Decidable(..)+  , chosen+  , lost+  , contramany+  ) where++import Contravariant.Extras+import Data.Functor.Contravariant.Divisible
+ src/Distributive.hs view
@@ -0,0 +1,9 @@+module Distributive+  ( -- * Distributive+    Distributive(..)+  , cotraverse+  , comapM+  , fmapCollect+  ) where++import Data.Distributive
+ src/Divisible.hs view
@@ -0,0 +1,12 @@+module Divisible+  ( Divisible(..)+  , divided+  , conquered+  , contrazip3+  , contrazip4+  , contrazip5+  , Supplied(..)+  ) where++import Contravariant.Extras+import Data.Functor.Contravariant.Divisible
+ src/Dynamic.hs view
@@ -0,0 +1,10 @@+module Dynamic+  ( -- * Dynamic+    Dynamic(..)+  , toDyn+  , fromDynamic+  , dynApply+  , dynTypeRep+  ) where++import Data.Dynamic
+ src/Either.hs view
@@ -0,0 +1,20 @@+module Either+  ( Either(..)+  , either+  , eitherM+  , lefts+  , rights+  , isLeft+  , isRight+  , fromLeft+  , fromRight+  , partitionEithers+    -- ** Optics+  , _Left+  , _Right+  ) where++import Control.Lens.Prism  (_Left, _Right)+import Control.Monad.Extra (eitherM)+import Data.Either         (Either(Left, Right), either, fromLeft, fromRight,+                            isLeft, isRight, lefts, partitionEithers, rights)
+ src/Enum.hs view
@@ -0,0 +1,5 @@+module Enum+  ( Enum(..)+  ) where++import GHC.Enum
+ src/Environment.hs view
@@ -0,0 +1,26 @@+{-# LANGUAGE CPP #-}++module Environment+  ( getArgs+  , getFullArgs+  , withArgs+  , getProgName+  , withProgName+  , getExecutablePath+  , getEnvironment+#if MIN_VERSION_base(4,11,0)+  , getEnv+  , getEnvDefault+#else+  , lookupEnv+#endif+  , setEnv+  , unsetEnv+  ) where++import GHC.Environment+#if MIN_VERSION_base(4,11,0)+import System.Environment.Blank+#else+import UnliftIO.Environment+#endif
+ src/Equality.hs view
@@ -0,0 +1,32 @@+{-# LANGUAGE ExplicitNamespaces #-}++module Equality+  (+    Eq(..)+  , Equivalence(..)+  , defaultEquivalence+  , comparisonEquivalence+  , Eq1(..)+  , eq1+  , liftEqDefault+  , Eq2(..)+  , eq2+    -- * Propositional equality+  , (:~:)(..)+  , (:~~:)(..)+  , sym+  , trans+  , castWith+  , gcastWith+  , apply+  , inner+  , outer+  , TestEquality(..)+  , type (==)+  ) where++import Data.Eq+import Data.Functor.Classes+import Data.Functor.Classes.Generic+import Data.Functor.Contravariant+import Data.Type.Equality
+ src/Error.hs view
@@ -0,0 +1,11 @@+module Error+  ( -- * Error+    error+  , errorWithoutStackTrace+  , undefined+  , throw+  , assert+  ) where++import Control.Exception+import GHC.Err
+ src/Eval.hs view
@@ -0,0 +1,46 @@+module Eval+  ( -- * Weak head normal form+    seq+  , lazy+  , ($!)+  , evaluate+    -- * Normal form+  , NF+  , makeNF+  , getNF+  , NFData(..)+  , deepseq+  , force+  , ($!!)+  , (<$!!>)+  , rwhnf+  , NFData1(..)+  , rnf1+  , NFData2(..)+  , rnf2+    -- * Evaluation strategies+  , Eval+  , runEval+  , Strategy+  , using+  , withStrategy+  , dot+  , rseq+  , rdeepseq+  , evalTraversable+  , evalList+  , evalTuple2+  , evalTuple3+  , evalTuple4+  , evalTuple5+  , evalTuple6+  , evalTuple7+  , evalTuple8+  , evalTuple9+  ) where++import Control.DeepSeq+import Control.Exception+import Control.Parallel.Strategies hiding (rwhnf)+import Data.NF+import GHC.Base
+ src/Except.hs view
@@ -0,0 +1,13 @@+module Except+  ( -- * ExceptT+    ExceptT(..)+  , runExceptT+  , mapExceptT+  , withExceptT+    -- * MonadError+  , MonadError(..)+  , liftEither+  ) where++import Control.Monad.Error.Class+import Control.Monad.Trans.Except
+ src/Exception.hs view
@@ -0,0 +1,63 @@+module Exception+  ( -- * Throwing exceptions+    throwIO+  , MonadThrow(..)+    -- ** Throwing specific exceptions+  , ioError+  , userError+  , exitWith+  , exitFailure+  , exitSuccess+  , die+    -- * Catching exceptions+  , catch+  , catchAny+  , catches+  , Handler(..)+  , catchJust+  , handle+  , handleJust+  , try+  , tryAny+  , tryJust+  , tryIO+    -- * Cleanup+  , bracket+  , bracket_+  , bracketOnError+  , finally+  , onException+    -- * Masking exceptions+  , MaskingState(..)+  , mask+  , mask_+  , uninterruptibleMask+  , uninterruptibleMask_+  , getMaskingState+  , interruptible+  , allowInterrupt+    -- * Exception types+  , SomeException(..)+  , Exception(..)+  , mapException+  , ExitCode(..)+  , IOException+    -- ** Asynchronous exceptions+  , SomeAsyncException(..)+  , AsyncException(..)+  , asyncExceptionToException+  , asyncExceptionFromException+  ) where++import Control.Exception   (AsyncException(..), Exception(..), IOException,+                            MaskingState(..), SomeAsyncException(..),+                            SomeException(..), allowInterrupt,+                            asyncExceptionFromException,+                            asyncExceptionToException, getMaskingState,+                            interruptible, ioError, mapException)+import Control.Monad.Catch (MonadThrow(throwM))+import System.Exit         (ExitCode(..), die, exitFailure, exitSuccess,+                            exitWith)+import System.IO.Error     (userError)+import UnliftIO.Exception  hiding (Exception(..), IOException,+                            SomeAsyncException(..), SomeException(..))
+ src/FRP.hs view
@@ -0,0 +1,9 @@+module FRP+  ( module Control.Event.Handler+  , module Reactive.Banana.Combinators+  , module Reactive.Banana.Frameworks+  ) where++import Control.Event.Handler+import Reactive.Banana.Combinators+import Reactive.Banana.Frameworks
+ src/Field.hs view
@@ -0,0 +1,5 @@+module Field+  ( HasField(..)+  ) where++import GHC.Records
+ src/File.hs view
@@ -0,0 +1,50 @@+module File+  ( -- * File path+    FilePath+    -- * File handle+  , Handle+    -- ** Standard file handles+  , stdin+  , stdout+  , stderr+    -- ** File handle queries+  , hFileSize+  , hGetEcho+  , hGetPosn+  , hIsClosed+  , hIsEOF+  , hIsOpen+  , hIsReadable+  , hIsSeekable+  , hIsTerminalDevice+  , hIsWritable+  , hReady+  , hShow+  , hTell+  , hWaitForInput+    -- ** File handle operations+  , hClose+  , hFlush+  , hSeek+  , hSetBinaryMode+  , hSetBuffering+  , hSetEcho+  , hSetFileSize+  , hSetPosn+    -- ** File handle types+  , BufferMode(..)+  , HandlePosn+  , IOMode(..)+  , SeekMode(..)+    -- * Re-exports+  , module System.FilePath+  , module UnliftIO.Temporary+  , module UnliftIO.Directory+  ) where++import System.FilePath    hiding (FilePath)+import System.IO          (FilePath, HandlePosn, SeekMode(..), hGetPosn,+                           hSetBinaryMode, hSetPosn, hShow)+import UnliftIO.Directory+import UnliftIO.IO+import UnliftIO.Temporary
+ src/File/Binary.hs view
@@ -0,0 +1,28 @@+-- | Binary file handling.++module File.Binary+  ( -- * File path operations+    withBinaryFile+    -- ** Reading+  , readFile+  , readFileDeserialise+    -- ** Writing+  , writeFile+  , writeFileSerialise+  , appendFile+    -- * File handle operations+    -- ** Reading+  , getContents+  , hGetContents+  , hGet+  , hGetSome+  , hGetNonBlocking+    -- ** Writing+  , putStr+  , hPutStr+  , hPutNonBlocking+  ) where++import Codec.Serialise (readFileDeserialise, writeFileSerialise)+import Data.ByteString+import UnliftIO.IO     (withBinaryFile)
+ src/File/Text.hs view
@@ -0,0 +1,49 @@+-- | Textual file handling.++module File.Text+  (+    -- * File path operations+    withFile+  , openFileBlocking+    -- ** Reading+  , readFile+    -- ** Writing+  , writeFile+  , appendFile+    -- * File handle operations+    -- ** Reading+  , getChar+  , getLine+  , getContents+  , hGetChar+  , hGetLine+  , hGetChunk+  , hGetContents+    -- ** Writing+  , putStr+  , putStrLn+  , print+  , hPutStr+  , hPutStrLn+  , hPrint+    -- * File encoding+  , TextEncoding+  , hSetEncoding+  , hGetEncoding+  , latin1+  , utf8+  , utf8_bom+  , utf16+  , utf16le+  , utf16be+  , utf32+  , utf32le+  , utf32be+  ) where++import Data.Text.IO+import GHC.IO.Handle.FD (openFileBlocking)+import System.IO        (TextEncoding, getChar, hGetChar, hGetEncoding, hPrint,+                         hSetEncoding, latin1, print, utf16, utf16be, utf16le,+                         utf32, utf32be, utf32le, utf8, utf8_bom)+import UnliftIO.IO      (withFile)
+ src/Foldable.hs view
@@ -0,0 +1,48 @@+module Foldable+  ( -- * Foldable+    Foldable(fold, foldMap, foldr, foldr', foldl', toList, null, length,+      elem, sum, product)+  , foldrM+  , foldlM+  , traverse_+  , for_+  , sequenceA_+  , asum+  , msum+  , concatMap+  , and+  , or+  , all+  , notElem+  , find+  , foldM+  , foldM_+  , foldMapBy+  , foldBy+  , inits+  , tails+  , insert+  , group+  , groupBy+  , groupWith+  , groupAllWith+    -- * Foldable1+  , Foldable1(..)+  , asum1+  , foldlM1+  , foldrM1+  , for1_+  , intercalate1+  , intercalateMap1+  , sequenceA1_+  , traverse1_+  ) where++import Control.Monad+import Data.Foldable+import Data.List.NonEmpty      (group, groupAllWith, groupBy, groupWith, inits,+                                insert, tails)+import Data.Reflection+import Data.Semigroup.Foldable (Foldable1(fold1, foldMap1, toNonEmpty), asum1,+                                foldlM1, foldrM1, for1_, intercalate1,+                                intercalateMap1, sequenceA1_, traverse1_)
+ src/Foldable/Partial.hs view
@@ -0,0 +1,9 @@+module Foldable.Partial+  ( foldr1+  , maximum+  , maximumBy+  , minimum+  , minimumBy+  ) where++import Data.Foldable
+ src/Foldl.hs view
@@ -0,0 +1,5 @@+module Foldl+  ( module Control.Foldl+  ) where++import Control.Foldl
+ src/Function.hs view
@@ -0,0 +1,20 @@+module Function+  ( ($)+  , ($!)+  , (&)+  , asTypeOf+  , const+  , fix+  , flip+  , loop+  , on+  , until+  , Endo(..)+  , Op(..)+  ) where++import Control.Monad.Extra        (loop)+import Data.Function+import Data.Functor.Contravariant+import Data.Semigroup             (Endo(Endo, appEndo))+import GHC.Base
+ src/Functor.hs view
@@ -0,0 +1,47 @@+{-# LANGUAGE CPP #-}++module Functor+  ( -- * Functor+    Functor(..)+  , (<$>)+  , ($>)+#if MIN_VERSION_base(4,11,0)+  , (<&>)+#endif+  , void+  , unzip+    -- ** Optics+  , mapped+    -- * Apply+  , Apply(..)+  , liftF3+    -- ** Newtypes+  , MaybeApply(..)+  , Static(..)+    -- * Alt+  , Alt(..)+    -- * Plus+  , Plus(..)+    -- * Bind+  , Bind(..)+  , (-<<)+    -- * Extend+  , Extend(..)+    -- * MFunctor+  , MFunctor(..)+  ) where++import Control.Lens.Setter (mapped)+import Control.Monad.Morph (MFunctor, hoist)+import Data.Functor        (Functor(fmap, (<$)), void, ($>), (<$>))+#if MIN_VERSION_base(4,11,0)+import Data.Functor ((<&>))+#endif+import Data.Functor.Alt         (Alt((<!>)))+import Data.Functor.Apply       (Apply(liftF2, (.>), (<.), (<.>)),+                                 MaybeApply(MaybeApply, runMaybeApply), liftF3)+import Data.Functor.Bind        (Bind(join, (>>-)), (-<<))+import Data.Functor.Extend      (Extend(duplicated, extended))+import Data.Functor.Plus        (Plus(zero))+import Data.List.NonEmpty       (unzip)+import Data.Semigroupoid.Static (Static(Static, runStatic))
+ src/Generic.hs view
@@ -0,0 +1,5 @@+module Generic+  ( module GHC.Generics+  ) where++import GHC.Generics
+ src/Graph/Adjacency.hs view
@@ -0,0 +1,5 @@+module Graph.Adjacency+  ( module Data.Graph+  ) where++import Data.Graph
+ src/Graph/Inductive.hs view
@@ -0,0 +1,219 @@+module Graph.Inductive+  ( -- * Graph+    Gr+  , UGr+    -- * Static graphs+  , Graph(..)+  , mkUGraph+  , order+  , size+  , nodes+  , edges+  , context+  , lab+  , neighbors+  , lneighbors+  , suc+  , pre+  , lsuc+  , lpre+  , out+  , inn+  , outdeg+  , indeg+  , deg+  , hasNeighbor+  , hasNeighborAdj+  , hasEdge+  , hasLEdge+  , equal+  , gelem+  , gsel+  , gfold+  , ufold+  , hasLoop+  , isSimple+  , newNodes+    -- ** Articulation points+  , ap+    -- ** Breadth-first search+  , bfs+  , bfsn+  , bfsWith+  , bfsnWith+  , level+  , leveln+  , bfe+  , bfen+  , bft+  , lbft+  , esp+  , lesp+    -- ** Depth-first search+  , CFun+  , dfs+  , dfs'+  , dfsWith+  , dfsWith'+  , dff+  , dff'+  , dffWith+  , dffWith'+  , xdfsWith+  , xdfWith+  , xdffWith+  , udfs+  , udfs'+  , udff+  , udff'+  , udffWith+  , udffWith'+  , rdff+  , rdff'+  , rdfs'+  , rdffWith+  , rdffWith'+  , topsort+  , topsort'+  , scc+  , reachable+  , components+  , noComponents+  , isConnected+  , condensation+    -- ** Dominators+  , dom+  , iDom+    -- ** Voronoi diagrams+  , Voronoi+  , gvdIn+  , gvdOut+  , voronoiSet+  , nearestNode+  , nearestDist+  , nearestPath+    -- ** Independent node sets+  , indep+  , indepSize+    -- ** Minimum spanning trees+  , msTreeAt+  , msTree+  , msPath+    -- ** Max flow+  , getRevEdges+  , augmentGraph+  , updAdjList+  , updateFlow+  , mfmg+  , mf+  , maxFlowgraph+  , maxFlow+  , Network+  , ekSimple+  , ekFused+  , ekList+    -- ** Shortest path+  , Heap+  , spTree+  , sp+  , spLength+  , dijkstra+    -- * Dynamic graphs+  , DynGraph(..)+  , buildGr+  , insNode+  , insNodes+  , insEdge+  , insEdges+  , delNode+  , delNodes+  , delEdge+  , delEdges+  , delLEdge+  , delAllLEdge+  , gmap+  , nmap+  , emap+  , nemap+  , gfiltermap+  , nfilter+  , labnfilter+  , labfilter+  , subgraph+  , grev+  , undir+  , unlab+  , efilter+  , elfilter+    -- ** Bi-connected components+  , bcc+    -- ** Pretty-printing+  , prettify+  , prettyPrint+    -- ** Transitive/reflexive closure+  , trc+  , rc+  , tc+    -- * Misc. types+    -- ** Node+  , Node+  , LNode+  , UNode+    -- ** Edge+  , Edge+  , LEdge+  , UEdge+  , toEdge+  , edgeLabel+  , toLEdge+    -- ** Context+  , Context+  , MContext+  , UContext+  , node'+  , lab'+  , labNode'+  , neighbors'+  , lneighbors'+  , suc'+  , pre'+  , lpre'+  , lsuc'+  , out'+  , inn'+  , outdeg'+  , indeg'+  , deg'+    -- ** Decomposition+  , Decomp+  , GDecomp+  , UDecomp+    -- ** Path+  , Path+  , LPath(..)+  , UPath+    -- ** Tree+  , RTree+  , LRTree+    -- ** Adj+  , Adj+    -- ** OrdGr+  , OrdGr(..)+  ) where++import Data.Graph.Inductive.Basic+import Data.Graph.Inductive.Graph+import Data.Graph.Inductive.PatriciaTree+import Data.Graph.Inductive.Query++-- TODO:+-- DFS+-- Dominators+-- GVD+-- Indep+-- MST+-- MaxFlow+-- MaxFlow2+-- Monad+-- SP+-- TransClos
+ src/Groupoid.hs view
@@ -0,0 +1,5 @@+module Groupoid+  ( Groupoid(..)+  ) where++import Data.Groupoid (Groupoid(inv))
+ src/Hashable.hs view
@@ -0,0 +1,16 @@+module Hashable+ ( -- * Hashable+   Hashable(..)+ , hashUsing+ , hashPtr+ , hashPtrWithSalt+ , hashByteArray+ , hashByteArrayWithSalt+ , Hashed+ , hashed+ , unhashed+ , mapHashed+ , traverseHashed+ ) where++import Data.Hashable
+ src/Heap.hs view
@@ -0,0 +1,5 @@+module Heap+  ( module Data.Heap+  ) where++import Data.Heap
+ src/IO.hs view
@@ -0,0 +1,17 @@+module IO+  ( -- * IO+    IO+  , MonadIO(..)+  , fixIO+  , timeout+  , once+  , onceFork+    -- * IO exceptions+  , module System.IO.Error+  ) where++import Control.Concurrent.Extra (once, onceFork)+import Control.Monad.IO.Class   (MonadIO(..))+import System.IO+import System.IO.Error+import UnliftIO.Timeout         (timeout)
+ src/IO/Unsafe.hs view
@@ -0,0 +1,9 @@+module IO.Unsafe+  ( unsafePerformIO+  , unsafeDupablePerformIO+  , unsafeInterleaveIO+  , unsafeFixIO+  ) where++import System.IO.Unsafe (unsafeDupablePerformIO, unsafeFixIO,+                         unsafeInterleaveIO, unsafePerformIO)
+ src/Ix.hs view
@@ -0,0 +1,5 @@+module Ix+  ( Ix(..)+  ) where++import Data.Ix
+ src/Json.hs view
@@ -0,0 +1,35 @@+-- |+-- JSON functionality common to both encoding and decoding. Re-exported by both+-- "Json.Encode" and "Json.Decode" for convenience.++module Json+  (+    Value(..)+  , Primitive(..)+    -- * Prisms+  , AsNumber+  , _Number+  , _Double+  , _Integer+  , _Integral+  , nonNull+  , AsPrimitive+  , _Primitive+  , _String+  , _Bool+  , _Null+  , AsValue+  , _Value+  , _Object+  , _Array+  , AsJSON+  , _JSON+    -- * Traversals+  , key+  , members+  , nth+  , values+  ) where++import Data.Aeson      (Value(..))+import Data.Aeson.Lens
+ src/Json/Decode.hs view
@@ -0,0 +1,58 @@+module Json.Decode+  ( -- * Decoding+    FromJSON(..)+  , gparseJson+  , FromJSONKey(..)+  , FromJSONKeyFunction(..)+  , fromJSON+  , decode+  , decode'+  , decodeStrict+  , decodeStrict'+  , eitherDecode+  , eitherDecode'+  , eitherDecodeStrict+  , eitherDecodeStrict'+  , decodeWith+  , decodeStrictWith+  , eitherDecodeWith+  , eitherDecodeStrictWith+  , withObject+  , withText+  , withArray+  , withScientific+  , withBool+  , withEmbeddedJSON+  , (.:)+  , (.:?)+  , (.:!)+  , (.!=)+  , parseField+  , parseFieldMaybe+  , parseFieldMaybe'+  , explicitParseField+  , explicitParseFieldMaybe+  , explicitParseFieldMaybe'+  , Parser+  , Result(..)+  , parse+  , parseMaybe+  , parseEither+  , iparse+  , json+  , json'+  , value+  , value'+  , jstring+  , scientific+    -- * Re-exports+  , module Json+  ) where++import Json++import Data.Aeson+import Data.Aeson.Internal+import Data.Aeson.Parser+import Data.Aeson.Types+import Generics.Generic.Aeson (gparseJson)
+ src/Json/Encode.hs view
@@ -0,0 +1,85 @@+module Json.Encode+  ( -- * Encoding+    Array+  , emptyArray+  , Object+  , emptyObject+  , ToJSON(..)+  , gtoJson+  , ToJSONKey(..)+  , ToJSONKeyFunction(..)+  , encode+  , encodeToLazyText+  , encodePretty+  , KeyValue+  , (.=)+  , object+    -- ** Direct encoding+  , Encoding+  , Encoding'+  , encodingToLazyByteString+  , Series+  , pairs+  , pair+  , pair'+  , foldable+  , emptyArray_+  , emptyObject_+  , text+  , lazyText+  , string+  , list+  , dict+  , null_+  , bool+  , int8+  , int16+  , int32+  , int64+  , int+  , word8+  , word16+  , word32+  , word64+  , word+  , integer+  , float+  , double+  , scientific+  , int8Text+  , int16Text+  , int32Text+  , int64Text+  , intText+  , word8Text+  , word16Text+  , word32Text+  , word64Text+  , wordText+  , integerText+  , floatText+  , doubleText+  , scientificText+  , day+  , localTime+  , utcTime+  , timeOfDay+  , zonedTime+  , value+    -- ** Quasi-quotation+  , aesonQQ+    -- * Newtypes+  , DotNetTime(..)+    -- * Re-exports+  , module Json+  ) where++import Json++import Data.Aeson+import Data.Aeson.Encode.Pretty (encodePretty)+import Data.Aeson.Encoding+import Data.Aeson.QQ            (aesonQQ)+import Data.Aeson.Text+import Data.Aeson.Types+import Generics.Generic.Aeson   (gtoJson)
+ src/Label.hs view
@@ -0,0 +1,5 @@+module Label+  ( IsLabel(..)+  ) where++import GHC.OverloadedLabels
+ src/List.hs view
@@ -0,0 +1,173 @@+{-# LANGUAGE CPP #-}++module List+  ( -- * List+    (++)+  , (\\)+  , allSame+  , anySame+  , break+  , breakOn+  , breakOnEnd+  , breakEnd+  , chop+  , cons+  , cycle+  , delete+  , deleteBy+  , deleteFirstsBy+  , disjoint+  , divvy+  , drop+  , dropEnd+  , dropPrefix+  , dropSuffix+  , dropWhile+  , dropWhileEnd+  , elemIndex+  , elemIndices+  , endBy+  , filter+  , findIndex+  , findIndices+  , genericDrop+  , genericIndex+  , genericLength+  , genericReplicate+  , genericSplitAt+  , genericTake+  , group+  , groupBy+  , groupOn+  , groupSort+  , groupSortBy+  , groupSortOn+  , inits+  , insert+  , insertBy+  , intercalate+  , intersect+  , intersectBy+  , intersperse+  , isInfixOf+  , isPrefixOf+  , isSubsequenceOf+  , isSuffixOf+  , iterate+#if MIN_VERSION_base(4,11,0)+  , iterate'+#endif+  , lookup+  , map+  , nub+  , nubBy+  , nubOn+  , nubOrd+  , nubOrdBy+  , nubOrdOn+  , nubSort+  , nubSortBy+  , nubSortOn+  , partition+  , permutations+  , repeat+  , replicate+  , reverse+  , scanl+  , scanl'+  , scanl1+  , scanr+  , scanr1+  , sort+  , sortBy+  , sortOn+  , span+  , spanEnd+  , split+  , splitAt+  , splitAtEnd+  , splitOn+  , snoc+  , stripInfix+  , stripInfixEnd+  , stripPrefix+  , stripSuffix+  , subsequences+  , tails+  , take+  , takeEnd+  , takeWhile+  , takeWhileEnd+  , transpose+  , uncons+  , unfoldr+  , union+  , unionBy+  , unsnoc+  , unzip+  , unzip3+  , unzip4+  , unzip5+  , unzip6+  , unzip7+  , wordsBy+  , zip+  , zip3+  , zip4+  , zip5+  , zip6+  , zip7+  , zipWith+  , zipWith3+  , zipWith4+  , zipWith5+  , zipWith6+  , zipWith7+    -- ** String+  , String+  , words+  , unwords+  , lines+  , unlines+  , lower+  , upper+  , trim+  , trimStart+  , trimEnd+  , showString+  , lexDigits+  , IsString(..)+    -- ** Optics+  , prefixed+  , suffixed+  ) where++import Data.List (break, cycle, delete, deleteBy, deleteFirstsBy, drop,+                  dropWhile, dropWhileEnd, elemIndex, elemIndices, filter,+                  findIndex, findIndices, genericDrop, genericIndex,+                  genericLength, genericReplicate, genericSplitAt, genericTake,+                  group, groupBy, inits, insert, insertBy, intercalate,+                  intersect, intersectBy, intersperse, isInfixOf, isPrefixOf,+                  isSubsequenceOf, isSuffixOf, iterate, lines, lookup, map, nub,+                  nubBy, partition, permutations, repeat, replicate, reverse,+                  scanl, scanl', scanl1, scanr, scanr1, sort, sortBy, sortOn,+                  span, splitAt, stripPrefix, subsequences, tails, take,+                  takeWhile, transpose, uncons, unfoldr, union, unionBy,+                  unlines, unwords, unzip, unzip3, unzip4, unzip5, unzip6,+                  unzip7, words, zip, zip3, zip4, zip5, zip6, zip7, zipWith,+                  zipWith3, zipWith4, zipWith5, zipWith6, zipWith7, (++), (\\))+#if MIN_VERSION_base(4,11,0)+import Data.List (iterate')+#endif+import Data.List.Extra (allSame, anySame, breakEnd, breakOn, breakOnEnd, cons,+                        disjoint, dropEnd, dropPrefix, dropSuffix, groupOn,+                        groupSort, groupSortBy, groupSortOn, lower, nubOn,+                        nubOrd, nubOrdBy, nubOrdOn, nubSort, nubSortBy,+                        nubSortOn, snoc, spanEnd, split, splitAtEnd, stripInfix,+                        stripInfixEnd, stripSuffix, takeEnd, takeWhileEnd, trim,+                        trimEnd, trimStart, unsnoc, upper, wordsBy)+import Data.List.Lens  (prefixed, suffixed)+import Data.List.Split (chop, divvy, endBy, splitOn)+import Data.String     (IsString(fromString), String)+import GHC.Show        (showString)+import Numeric         (lexDigits)
+ src/List/Builder.hs view
@@ -0,0 +1,20 @@+module List.Builder+  ( -- * List builder+    DList(Nil, Cons)+  , fromList+  , toList+  , apply+  , empty+  , singleton+  , cons+  , snoc+  , append+  , concat+  , replicate+  , list+  , unfoldr+  , foldr+  , map+  ) where++import Data.DList
+ src/List/Builder/Partial.hs view
@@ -0,0 +1,6 @@+module List.Builder.Partial+  ( head+  , tail+  ) where++import Data.DList
+ src/List/Partial.hs view
@@ -0,0 +1,11 @@+module List.Partial+  ( (!!)+  , chunksOf+  , head+  , init+  , last+  , tail+  ) where++import Data.List       (head, init, last, tail, (!!))+import Data.List.Extra (chunksOf)
+ src/List1.hs view
@@ -0,0 +1,46 @@+module List1+  ( NonEmpty(..)+  , break+  , cons+  , cycle+  , drop+  , dropWhile+  , filter+  , group1+  , groupAllWith1+  , groupBy1+  , groupWith1+  , head+  , init+  , intersperse+  , isPrefixOf+  , iterate+  , last+  , map+  , nonEmpty+  , nub+  , nubBy+  , partition+  , repeat+  , reverse+  , scanl+  , scanl1+  , scanr+  , scanr1+  , sort+  , sortBy+  , sortWith+  , span+  , splitAt+  , tail+  , take+  , takeWhile+  , transpose+  , uncons+  , unfoldr+  , xor+  , zip+  , zipWith+  ) where++import Data.List.NonEmpty
+ src/List1/Partial.hs view
@@ -0,0 +1,6 @@+module List1.Partial+  ( (!!)+  , fromList+  ) where++import Data.List.NonEmpty (fromList, (!!))
+ src/ListT.hs view
@@ -0,0 +1,14 @@+module ListT+  ( ListT(..)+  , runListT+  , fold+  , foldM+  , select+  , take+  , drop+  , takeWhile+  , unfold+  , zip+  ) where++import List.Transformer
+ src/Logic.hs view
@@ -0,0 +1,24 @@+module Logic+  ( -- ** Logic+    Logic+  , logic+  , runLogic+  , observeAll+    -- ** LogicT+  , LogicT(..)+  , runLogicT+  , observeT+  , observeManyT+  , observeAllT+    -- ** MonadLogic+  , MonadLogic+  , msplit+  , interleave+  , (>>-)+  , ifte+  , once+  , reflect+  , lnot+  ) where++import Control.Monad.Logic
+ src/Managed.hs view
@@ -0,0 +1,12 @@+module Managed+  ( -- * Managed+    Managed+  , managed+  , managed_+  , with+  , runManaged+    -- * MonadManaged+  , MonadManaged(..)+  ) where++import Control.Monad.Managed
+ src/Map.hs view
@@ -0,0 +1,5 @@+module Map+  ( module Data.Map.Strict+  ) where++import Data.Map.Strict
+ src/Map/Hash.hs view
@@ -0,0 +1,5 @@+module Map.Hash+  ( module Data.HashMap.Strict+  ) where++import Data.HashMap.Strict
+ src/Map/Int.hs view
@@ -0,0 +1,5 @@+module Map.Int+  ( module Data.IntMap.Strict+  ) where++import Data.IntMap.Strict
+ src/Map/Int/Lazy.hs view
@@ -0,0 +1,5 @@+module Map.Int.Lazy+  ( module Data.IntMap.Lazy+  ) where++import Data.IntMap.Lazy
+ src/Map/Lazy.hs view
@@ -0,0 +1,5 @@+module Map.Lazy+  ( module Data.Map.Lazy+  ) where++import Data.Map.Lazy
+ src/Maybe.hs view
@@ -0,0 +1,27 @@+module Maybe+  ( -- * Maybe+    Maybe(..)+  , maybe+  , maybeM+  , isJust+  , isNothing+  , fromMaybe+  , listToMaybe+  , maybeToList+  , catMaybes+  , mapMaybe+    -- ** Prisms+  , _Just+  , _Nothing+    -- ** Newtypes+  , Option(..)+  , option+  , First(..)+  , Last(..)+  ) where++import Control.Lens.Prism  (_Just, _Nothing)+import Control.Monad.Extra (maybeM)+import Data.Maybe+import Data.Monoid+import Data.Semigroup      (Option(..), option)
+ src/Maybe/Partial.hs view
@@ -0,0 +1,5 @@+module Maybe.Partial+  ( fromJust+  ) where++import Data.Maybe (fromJust)
+ src/MaybeT.hs view
@@ -0,0 +1,7 @@+module MaybeT+  ( -- * MaybeT+    MaybeT(..)+  , mapMaybeT+  ) where++import Control.Monad.Trans.Maybe
+ src/Mitchell/Prelude.hs view
@@ -0,0 +1,376 @@+{-# LANGUAGE CPP #-}++module Mitchell.Prelude+  ( -- * Ala.Identity+    Identity(..)+    -- * Applicative+  , Applicative(..)+  , filterM+  , forever+  , liftA3+  , replicateM+  , replicateM_+  , unless+  , when+  , zipWithM+  , zipWithM_+  , Alternative((<|>), empty)+  , guard+  , optional+    -- * Bool+  , Bool(..)+  , (&&)+  , (||)+  , not+  , otherwise+    -- * Bounded+  , Bounded(..)+  , ByteString+    -- * Category+  , Category(..)+  , (>>>)+  , (<<<)+    -- * Char+  , Char+#if MIN_VERSION_base(4,11,0)+    -- * Clock+  , getMonotonicTime+  , getMonotonicTimeNSec+#endif+    -- * Coerce+  , Coercible+  , coerce+    -- * Debug+  , trace+  , traceId+  , traceShow+  , traceShowId+  , traceStack+  , traceM+  , traceShowM+    -- * Either+  , Either(Left, Right)+  , either+  , eitherM+  , _Left+  , _Right+    -- * Enum+  , Enum(..)+    -- * Equality+  , Eq(..)+    -- * Error+  , assert+  , error+  , undefined+    -- * Exception+  , Exception+  , SomeException(..)+  , SomeAsyncException(..)+  , throwIO+    -- * File+  , stdin+  , stdout+  , stderr+    -- * File.Text+  , hGetChar+  , hGetLine+  , hGetContents+  , putStr+  , putStrLn+  , print+  , hPutStr+  , hPutStrLn+  , hPrint+    -- * Foldable+  , Foldable(..)+  , foldrM+  , foldlM+  , traverse_+  , for_+  , sequenceA_+  , asum+  , msum+  , concatMap+  , and+  , or+  , all+  , notElem+  , find+  , foldM+  , foldM_+  , foldMapBy+  , foldBy+    -- * Function+  , ($)+  , ($!)+  , (&)+  , const+  , fix+  , flip+  , until+  , Endo(..)+    -- * Functor+  , Functor(..)+  , (<$>)+  , ($>)+#if MIN_VERSION_base(4,11,0)+  , (<&>)+#endif+  , void+    -- * Generic+  , Generic+    -- * Hashable+  , Hashable+    -- * IO+  , IO+  , MonadIO(..)+    -- * List+  , (++)+  , cycle+  , iterate+#if MIN_VERSION_base(4,11,0)+  , iterate'+#endif+  , map+  , repeat+  , replicate+  , scanl+  , scanl'+  , scanl1+  , scanr+  , scanr1+  , unfoldr+    -- * Map+  , Map+    -- * Map.Hash+  , HashMap+    -- * Map.Int+  , IntMap+    -- * Maybe+  , Maybe(..)+  , maybe+  , maybeM+  , fromMaybe+  , catMaybes+  , mapMaybe+  , _Nothing+  , _Just+    -- * Monad+  , Monad(..)+  , (=<<)+  , (>=>)+  , (<=<)+  , unlessM+  , whenJustM+  , whenM+  , whileM+    -- * Monad.Trans+  , MonadTrans(..)+    -- * Monoid+  , Monoid+  , mconcat+  , mempty+    -- * Numeric.Double+  , Double+    -- * Numeric.Float+  , Float+    -- * Numeric.Floating+  , Floating(..)+    -- * Numeric.Fractional+  , Fractional(..)+    -- * Numeric.Int+  , Int+  , Int8+  , Int16+  , Int32+  , Int64+    -- * Numeric.Integer+  , Integer+    -- * Numeric.Integral+  , Integral(..)+  , even+  , odd+  , gcd+  , lcm+  , fromIntegral+    -- * Numeric.Nat+  , Nat+  , KnownNat+  , natVal+  , natVal'+  , SomeNat(..)+  , someNatVal+    -- * Numeric.Num+  , Num(..)+  , subtract+    -- * Numeric.Real+  , Real(..)+  , div'+  , mod'+  , divMod'+  , realToFrac+    -- * Numeric.RealFloat+  , RealFloat(..)+    -- * Numeric.RealFrac+  , RealFrac(..)+    -- * Numeric.Word+  , Word+  , Word8+  , Word16+  , Word32+  , Word64+    -- * Optic.Fold+  , (^?)+  , preview+  , has+  , folded+    -- * Optic.Getting+  , (^.)+  , view+    -- * Optic.Lens+  , Lens+  , Lens'+  , lens+    -- * Optic.Lens.At+  , At(..)+    -- * Optic.Prism+  , Prism+  , prism+  , is+    -- * Optic.Setter+  , (.~)+  , (%~)+  , over+  , set+    -- * Optic.Traversal+  , Traversal+    -- * Optic.Traversal.Ixed+  , Ixed(..)+  , Index+  , IxValue+    -- * Ord+  , Ord(..)+  , Ordering(..)+    -- * Semigroup+  , Semigroup(..)+    -- * Sequence+  , Seq+    -- * Set+  , Set+    -- * Set.Hash+  , HashSet+    -- * Set.Int+  , IntSet+    -- * Show+  , Show(show)+    -- * Text+  , Text+    -- * Traversable+  , Traversable(..)+  , for+    -- * Tuple+  , fst+  , snd+  , Field1(..)+  , Field2(..)+  , Field3(..)+  , Field4(..)+  , Field5(..)+  , Field6(..)+    -- * Void+  , Void+  ) where++import Ala.Identity (Identity(Identity, runIdentity))+import Applicative  (Alternative(empty, (<|>)), Applicative, filterM, forever,+                     guard, liftA2, liftA3, optional, pure, replicateM,+                     replicateM_, unless, when, zipWithM, zipWithM_, (*>), (<*),+                     (<*>))+import Bool         (Bool(False, True), not, otherwise, (&&), (||))+import Bounded      (Bounded(maxBound, minBound))+import ByteString   (ByteString)+import Category     (Category(id, (.)), (<<<), (>>>))+import Char         (Char)+#if MIN_VERSION_base(4,11,0)+import Clock (getMonotonicTime, getMonotonicTimeNSec)+#endif+import Coerce    (Coercible, coerce)+import Debug     (trace, traceId, traceM, traceShow, traceShowId, traceShowM,+                  traceStack)+import Either    (Either(Left, Right), either)+import Either    (eitherM)+import Either    (_Left, _Right)+import Enum      (Enum(enumFrom, enumFromThen, enumFromThenTo, enumFromTo, fromEnum, pred, succ, toEnum))+import Equality  (Eq((/=), (==)))+import Error     (assert, error, undefined)+import Exception (Exception, SomeAsyncException(SomeAsyncException),+                  SomeException(SomeException), throwIO)+import File      (stderr, stdin, stdout)+import File.Text (hGetChar, hPrint, print)+import File.Text (hGetContents, hGetLine, hPutStr, hPutStrLn, putStr, putStrLn)+import Foldable  (Foldable(elem, fold, foldMap, foldl', foldr, foldr', length, null, product, sum, toList),+                  all, and, asum, concatMap, find, foldM, foldM_, foldlM,+                  foldrM, for_, msum, notElem, or, sequenceA_, traverse_)+import Foldable  (foldBy, foldMapBy)+import Function  (Endo(Endo, appEndo), const, fix, flip, until, ($), ($!), (&))+import Functor   (Functor(fmap, (<$)), void, ($>), (<$>))+#if MIN_VERSION_base(4,11,0)+import Functor ((<&>))+#endif+import Generic  (Generic)+import Hashable (Hashable)+import IO       (IO, MonadIO(liftIO))+import List     (cycle, iterate, map, repeat, replicate, scanl, scanl', scanl1,+                 scanr, scanr1, unfoldr, (++))+#if MIN_VERSION_base(4,11,0)+import List (iterate')+#endif+import Map                  (Map)+import Map.Hash             (HashMap)+import Map.Int              (IntMap)+import Maybe                (Maybe(Just, Nothing), catMaybes, fromMaybe,+                             mapMaybe, maybe)+import Maybe                (maybeM)+import Maybe                (_Just, _Nothing)+import Monad                (Monad((>>=)), (<=<), (=<<), (>=>))+import Monad                (unlessM, whenJustM, whenM, whileM)+import Monad.Trans          (MonadTrans(lift))+import Monoid               (Monoid, mconcat, mempty)+import Numeric.Double       (Double)+import Numeric.Float        (Float)+import Numeric.Floating     (Floating(..))+import Numeric.Fractional   (Fractional(..))+import Numeric.Int          (Int, Int16, Int32, Int64, Int8)+import Numeric.Integer      (Integer)+import Numeric.Integral     (Integral(..), even, fromIntegral, gcd, lcm, odd)+import Numeric.Nat          (KnownNat, Nat, SomeNat(..), natVal, natVal',+                             someNatVal)+import Numeric.Num          (Num(..), subtract)+import Numeric.Real         (Real(..), div', divMod', mod', realToFrac)+import Numeric.RealFloat    (RealFloat(..))+import Numeric.RealFrac     (RealFrac(..))+import Numeric.Word         (Word, Word16, Word32, Word64, Word8)+import Optic.Fold           (folded, has, preview, (^?))+import Optic.Getting        (view, (^.))+import Optic.Lens           (Lens, Lens', lens)+import Optic.Lens.At        (At(at))+import Optic.Prism          (Prism, is, prism)+import Optic.Setter         (over, set, (%~), (.~))+import Optic.Traversal      (Traversal)+import Optic.Traversal.Ixed (Index, IxValue, Ixed(ix))+import Ord                  (Ord(compare, max, min, (<), (<=), (>), (>=)),+                             Ordering(EQ, GT, LT))+import Semigroup            (Semigroup((<>)))+import Sequence             (Seq)+import Set                  (Set)+import Set.Hash             (HashSet)+import Set.Int              (IntSet)+import Show                 (Show, show)+import Text                 (Text)+import Traversable          (Traversable(sequenceA, traverse), for)+import Tuple                (fst, snd)+import Tuple                (Field1(_1), Field2(_2), Field3(_3), Field4(_4),+                             Field5(_5), Field6(_6))+import Void                 (Void)++import Data.Orphans ()
+ src/Monad.hs view
@@ -0,0 +1,29 @@+module Monad+  ( -- * Monad+    Monad((>>=), return)+  , (=<<)+  , (>=>)+  , (<=<)+  , (<$!>)+  , join+  , loopM+  , unlessM+  , whenJustM+  , whenM+  , whileM+    -- ** Newtypes+  , Kleisli(..)+    -- * MMonad+  , MMonad(..)+  , squash+  , (>|>)+  , (<|<)+  , (=<|)+  , (|>=)+  ) where++import Control.Arrow       (Kleisli(Kleisli, runKleisli))+import Control.Monad       (Monad(return, (>>=)), join, (<$!>), (<=<), (=<<),+                            (>=>))+import Control.Monad.Extra (loopM, unlessM, whenJustM, whenM, whileM)+import Control.Monad.Morph (MMonad(embed), squash, (<|<), (=<|), (>|>), (|>=))
+ src/Monad/Base.hs view
@@ -0,0 +1,5 @@+module Monad.Base+  ( MonadBase(..)+  ) where++import Control.Monad.Base (MonadBase(..))
+ src/Monad/Fail.hs view
@@ -0,0 +1,5 @@+module Monad.Fail+  ( MonadFail(..)+  ) where++import Control.Monad.Fail
+ src/Monad/Fix.hs view
@@ -0,0 +1,5 @@+module Monad.Fix+  ( MonadFix(..)+  ) where++import Control.Monad.Fix (MonadFix(..))
+ src/Monad/Plus.hs view
@@ -0,0 +1,23 @@+module Monad.Plus+  ( MonadPlus(..)+  , endBy+  , endBy1+  , many+  , mfilter+  , sepBy1+  , sepEndBy1+  , someTill+  , manyTill+  , sepBy+  , sepEndBy+  , skipMany+  , skipManyTill+  , skipSome+  , skipSomeTill+  ) where++import Control.Monad                      (MonadPlus(..), mfilter)+import Control.Monad.Combinators          (endBy, many, manyTill, sepBy,+                                           sepEndBy, skipMany, skipManyTill,+                                           skipSome, skipSomeTill)+import Control.Monad.Combinators.NonEmpty (endBy1, sepBy1, sepEndBy1, someTill)
+ src/Monad/Trans.hs view
@@ -0,0 +1,30 @@+module Monad.Trans+  ( -- * MonadTrans+    MonadTrans(..)+    -- * Free monad transformer+  , FreeF(..)+  , liftF+  , Free+  , free+  , runFree+  , retract+  , iter+  , iterM+  , FreeT(..)+  , iterT+  , iterTM+  , hoistFreeT+  , foldFreeT+  , transFreeT+  , joinFreeT+  , retractT+  , MonadFree(..)+  ) where++import Control.Monad.Trans.Class (MonadTrans(..))+import Control.Monad.Trans.Free  (Free, FreeF(Free, Pure),+                                  FreeT(FreeT, runFreeT), MonadFree(wrap),+                                  foldFreeT, free, hoistFreeT, iter, iterM,+                                  iterT, iterTM, joinFreeT, liftF, retract,+                                  retractT, runFree, transFreeT)+
+ src/Monad/Zip.hs view
@@ -0,0 +1,5 @@+module Monad.Zip+  ( MonadZip(..)+  ) where++import Control.Monad.Zip (MonadZip(..))
+ src/Monoid.hs view
@@ -0,0 +1,8 @@+module Monoid+  ( -- * Monoid+    Monoid(mconcat, mempty)+  , gmempty+  ) where++import Data.Monoid+import Data.Semigroup.Generic
+ src/MultiSet.hs view
@@ -0,0 +1,68 @@+module MultiSet+  ( -- * MultiSet+    MultiSet+  , Occur+  , null+  , size+  , distinctSize+  , member+  , notMember+  , occur+  , isSubsetOf+  , isProperSubsetOf+  , empty+  , singleton+  , insert+  , insertMany+  , delete+  , deleteMany+  , deleteAll+  , union+  , unions+  , maxUnion+  , difference+  , intersection+  , filter+  , partition+  , split+  , splitOccur+  , map+  , mapMonotonic+  , mapMaybe+  , mapEither+  , concatMap+  , unionsMap+  , bind+  , join+  , fold+  , foldOccur+  , findMin+  , findMax+  , deleteMin+  , deleteMax+  , deleteMinAll+  , deleteMaxAll+  , deleteFindMin+  , deleteFindMax+  , maxView+  , minView+  , elems+  , distinctElems+  , toList+  , toAscList+  , toOccurList+  , toAscOccurList+  , fromList+  , fromAscList+  , fromDistinctAscList+  , fromOccurList+  , fromAscOccurList+  , fromDistinctAscOccurList+  , toMap+  , fromMap+  , fromOccurMap+  , toSet+  , fromSet+  ) where++import Data.MultiSet
+ src/MultiSet/Int.hs view
@@ -0,0 +1,68 @@+module MultiSet.Int+  ( -- * IntMultiSet+    IntMultiSet+  , Key+  , null+  , size+  , distinctSize+  , member+  , notMember+  , occur+  , isSubsetOf+  , isProperSubsetOf+  , empty+  , singleton+  , insert+  , insertMany+  , delete+  , deleteMany+  , deleteAll+  , union+  , unions+  , maxUnion+  , difference+  , intersection+  , filter+  , partition+  , split+  , splitOccur+  , map+  , mapMonotonic+  , mapMaybe+  , mapEither+  , concatMap+  , unionsMap+  , bind+  , join+  , fold+  , foldOccur+  , findMin+  , findMax+  , deleteMin+  , deleteMax+  , deleteMinAll+  , deleteMaxAll+  , deleteFindMin+  , deleteFindMax+  , maxView+  , minView+  , elems+  , distinctElems+  , toList+  , toAscList+  , toOccurList+  , toAscOccurList+  , fromList+  , fromAscList+  , fromDistinctAscList+  , fromOccurList+  , fromAscOccurList+  , fromDistinctAscOccurList+  , toMap+  , fromMap+  , fromOccurMap+  , toSet+  , fromSet+  ) where++import Data.IntMultiSet
+ src/Numeric/Approximate.hs view
@@ -0,0 +1,12 @@+module Numeric.Approximate+  ( -- * Approximate+    Approximate(..)+  , HasApproximate(..)+  , exact+  , zero+  , one+  , withMin+  , withMax+  ) where++import Data.Approximate.Type
+ src/Numeric/Complex.hs view
@@ -0,0 +1,22 @@+module Numeric.Complex+  ( -- * Complex+    Complex+  , realPart+  , imagPart+  , mkPolar+  , cis+  , polar+  , magnitude+  , phase+  , conjugate+    -- ** Optics+  , _realPart+  , _imagPart+  , _polar+  , _magnitude+  , _phase+  , _conjugate+  ) where++import Data.Complex+import Data.Complex.Lens
+ src/Numeric/Double.hs view
@@ -0,0 +1,12 @@+module Numeric.Double+  ( -- * Double+    Double+  , toExponential+  , toFixed+  , toPrecision+  , toShortest+  ) where++import Data.Double.Conversion.Text (toExponential, toFixed, toPrecision,+                                    toShortest)+import GHC.Float
+ src/Numeric/Erf.hs view
@@ -0,0 +1,5 @@+module Numeric.Erf+  ( Erf(..)+  ) where++import Data.Number.Erf
+ src/Numeric/Fast.hs view
@@ -0,0 +1,6 @@+module Numeric.Fast+  ( Fast(..)+  , blog+  ) where++import Data.Approximate.Numerics
+ src/Numeric/Float.hs view
@@ -0,0 +1,5 @@+module Numeric.Float+  ( Float+  ) where++import GHC.Float
+ src/Numeric/Floating.hs view
@@ -0,0 +1,5 @@+module Numeric.Floating+  ( Floating(..)+  ) where++import GHC.Float
+ src/Numeric/Fractional.hs view
@@ -0,0 +1,5 @@+module Numeric.Fractional+  ( Fractional(..)+  ) where++import GHC.Real
+ src/Numeric/Half.hs view
@@ -0,0 +1,21 @@+{-# LANGUAGE PackageImports, PatternSynonyms #-}++module Numeric.Half+  ( Half(..)+  , isZero+  , fromHalf+  , toHalf+  , pattern POS_INF+  , pattern NEG_INF+  , pattern QNaN+  , pattern SNaN+  , pattern HALF_MIN+  , pattern HALF_NRM_MIN+  , pattern HALF_MAX+  , pattern HALF_EPSILON+  , pattern HALF_DIG+  , pattern HALF_MIN_10_EXP+  , pattern HALF_MAX_10_EXP+  ) where++import "half" Numeric.Half
+ src/Numeric/Int.hs view
@@ -0,0 +1,11 @@+module Numeric.Int+  ( Int+  , intLog2+  , Int8+  , Int16+  , Int32+  , Int64+  ) where++import GHC.Int                      (Int, Int16, Int32, Int64, Int8)+import Math.NumberTheory.Logarithms (intLog2)
+ src/Numeric/Integer.hs view
@@ -0,0 +1,10 @@+module Numeric.Integer+  ( -- * Integer+    Integer+  , integerLogBase+  , integerLog2+  , integerLog10+  ) where++import GHC.Num+import Math.NumberTheory.Logarithms (integerLog10, integerLog2, integerLogBase)
+ src/Numeric/Integral.hs view
@@ -0,0 +1,17 @@+module Numeric.Integral+  ( -- * Integral+    Integral(..)+  , even+  , odd+  , gcd+  , lcm+  , fromIntegral+    -- ** Show+  , showInt+  , showIntAtBase+  , showOct+  , showHex+  ) where++import GHC.Real+import Numeric  (showHex, showInt, showIntAtBase, showOct)
+ src/Numeric/InvErf.hs view
@@ -0,0 +1,5 @@+module Numeric.InvErf+  ( InvErf(..)+  ) where++import Data.Number.Erf
+ src/Numeric/Nat.hs view
@@ -0,0 +1,120 @@+{-# LANGUAGE CPP, ExplicitNamespaces #-}+#if __GLASGOW_HASKELL__ >= 806+{-# LANGUAGE NoStarIsType #-}+#endif++module Numeric.Nat+  ( -- * Nat+    Nat+  , KnownNat+  , natVal+  , natVal'+  , SomeNat(..)+  , someNatVal+  , sameNat+  , type (<=)+  , type (<=?)+  , type (+)+  , type (*)+  , type (^)+  , type (-)+  , Min+  , Max+  , Lcm+  , Gcd+  , Divides+#if MIN_VERSION_base(4,11,0)+  , Div+  , Mod+  , Log2+#endif+  , CmpNat+    -- ** Constraints+  , plusNat+  , timesNat+  , powNat+  , minNat+  , maxNat+  , gcdNat+  , lcmNat+  , divNat+  , modNat+  , plusZero+  , timesZero+  , timesOne+  , powZero+  , powOne+  , maxZero+  , minZero+  , gcdZero+  , gcdOne+  , lcmZero+  , lcmOne+  , plusAssociates+  , timesAssociates+  , minAssociates+  , maxAssociates+  , gcdAssociates+  , lcmAssociates+  , plusCommutes+  , timesCommutes+  , minCommutes+  , maxCommutes+  , gcdCommutes+  , lcmCommutes+  , plusDistributesOverTimes+  , timesDistributesOverPow+  , timesDistributesOverGcd+  , timesDistributesOverLcm+  , minDistributesOverPlus+  , minDistributesOverTimes+  , minDistributesOverPow1+  , minDistributesOverPow2+  , minDistributesOverMax+  , maxDistributesOverPlus+  , maxDistributesOverTimes+  , maxDistributesOverPow1+  , maxDistributesOverPow2+  , maxDistributesOverMin+  , gcdDistributesOverLcm+  , lcmDistributesOverGcd+  , minIsIdempotent+  , maxIsIdempotent+  , lcmIsIdempotent+  , gcdIsIdempotent+  , plusIsCancellative+  , timesIsCancellative+  , dividesPlus+  , dividesTimes+  , dividesMin+  , dividesMax+  , dividesPow+  , dividesGcd+  , dividesLcm+  , plusMonotone1+  , plusMonotone2+  , timesMonotone1+  , timesMonotone2+  , powMonotone1+  , powMonotone2+  , minMonotone1+  , minMonotone2+  , maxMonotone1+  , maxMonotone2+  , divMonotone1+  , divMonotone2+  , euclideanNat+  , plusMod+  , timesMod+  , modBound+  , dividesDef+  , timesDiv+  , eqLe+  , leEq+  , leId+  , leTrans+  , zeroLe+  ) where++import Data.Constraint.Nat+import GHC.TypeLits
+ src/Numeric/Natural.hs view
@@ -0,0 +1,11 @@+{-# LANGUAGE PackageImports #-}++module Numeric.Natural+  ( Natural+  , naturalLogBase+  , naturalLog2+  , naturalLog10+  ) where++import Math.NumberTheory.Logarithms (naturalLog10, naturalLog2, naturalLogBase)+import "base" Numeric.Natural
+ src/Numeric/Num.hs view
@@ -0,0 +1,12 @@+module Numeric.Num+  ( Num(..)+  , subtract+    -- ** Read+  , readInt+  , readDec+  , readOct+  , readHex+  ) where++import GHC.Num (Num(..), subtract)+import Numeric
+ src/Numeric/Product.hs view
@@ -0,0 +1,5 @@+module Numeric.Product+  ( Product(..)+  ) where++import Data.Monoid
+ src/Numeric/Ratio.hs view
@@ -0,0 +1,12 @@+module Numeric.Ratio+  ( Ratio+  , Rational+  , (%)+  , numerator+  , denominator+  , approxRational+  , fromRat+  ) where++import Data.Ratio+import GHC.Float  (fromRat)
+ src/Numeric/Real.hs view
@@ -0,0 +1,16 @@+module Numeric.Real+  ( -- * Real+    Real(..)+  , div'+  , mod'+  , divMod'+  , realToFrac+    -- ** Show+  , showSigned+    -- ** Read+  , readSigned+  ) where++import Data.Fixed (div', divMod', mod')+import GHC.Real   (Real(..), realToFrac, showSigned)+import Numeric    (readSigned)
+ src/Numeric/RealFloat.hs view
@@ -0,0 +1,20 @@+{-# LANGUAGE CPP #-}++module Numeric.RealFloat+  ( -- * RealFloat+    RealFloat(..)+  , floatToDigits+    -- ** Show+  , showEFloat+  , showFFloat+  , showGFloat+  , showFFloatAlt+  , showGFloatAlt+  , showFloat+#if MIN_VERSION_base(4,11,0)+  , showHFloat+#endif+  ) where++import GHC.Float+import Numeric
+ src/Numeric/RealFrac.hs view
@@ -0,0 +1,9 @@+module Numeric.RealFrac+  ( -- * RealFrac+    RealFrac(..)+    -- ** Read+  , readFloat+  ) where++import GHC.Real (RealFrac(..))+import Numeric  (readFloat)
+ src/Numeric/Scientific.hs view
@@ -0,0 +1,5 @@+module Numeric.Scientific+  ( module Data.Scientific+  ) where++import Data.Scientific
+ src/Numeric/Sum.hs view
@@ -0,0 +1,5 @@+module Numeric.Sum+  ( Sum(..)+  ) where++import Data.Monoid
+ src/Numeric/Word.hs view
@@ -0,0 +1,16 @@+module Numeric.Word+  ( -- * Word+    Word+  , wordLog2+  , Word8+  , Word16+  , byteSwap16+  , Word32+  , byteSwap32+  , Word64+  , byteSwap64+  ) where++import GHC.Word (Word, Word16, Word32, Word64, Word8, byteSwap16, byteSwap32,+                 byteSwap64)+import Math.NumberTheory.Logarithms (wordLog2)
+ src/Optic/Fold.hs view
@@ -0,0 +1,65 @@+module Optic.Fold+  ( -- * Fold+    Fold+  , (^..)+  , (^?)+  , pre+  , preview+  , previews+  , preuse+  , preuses+  , has+  , hasn't+  , folding+  , folded+  , folded64+  , unfolded+  , iterated+  , filtered+  , backwards+  , repeated+  , replicated+  , cycled+  , takingWhile+  , droppingWhile+  , foldMapOf+  , foldMapByOf+  , foldOf+  , foldByOf+  , foldrOf+  , foldrOf'+  , foldrMOf+  , foldlOf'+  , foldlMOf+  , toListOf+  , toNonEmptyOf+  , anyOf+  , allOf+  , noneOf+  , andOf+  , orOf+  , productOf+  , sumOf+  , traverseOf_+  , forOf_+  , sequenceAOf_+  , asumOf+  , msumOf+  , concatMapOf+  , elemOf+  , notElemOf+  , lengthOf+  , nullOf+  , notNullOf+  , firstOf+  , lastOf+  , maximumOf+  , minimumOf+  , maximumByOf+  , minimumByOf+  , findOf+  , findMOf+  , lookupOf+  ) where++import Control.Lens.Fold
+ src/Optic/Getter.hs view
@@ -0,0 +1,7 @@+module Optic.Getter+  ( -- * Getter+    Getter+  , to+  ) where++import Control.Lens.Getter
+ src/Optic/Getting.hs view
@@ -0,0 +1,11 @@+module Optic.Getting+  ( -- * Getting+    Getting+  , (^.)+  , view+  , views+  , use+  , uses+  ) where++import Control.Lens.Getter
+ src/Optic/Iso.hs view
@@ -0,0 +1,14 @@+module Optic.Iso+  ( -- * Iso+    Iso+  , Iso'+  , iso+  , from+  , under+  , enum+  , curried+  , uncurried+  , flipped+  ) where++import Control.Lens.Iso
+ src/Optic/Iso/Reversing.hs view
@@ -0,0 +1,7 @@+module Optic.Iso.Reversing+  ( -- * Reversing+    Reversing(..)+  , reversed+  ) where++import Control.Lens.Iso (Reversing(reversing), reversed)
+ src/Optic/Iso/Strict.hs view
@@ -0,0 +1,7 @@+module Optic.Iso.Strict+  ( -- * Strict+    Strict(..)+  , lazy+  ) where++import Control.Lens.Iso (Strict(strict), lazy)
+ src/Optic/Lens.hs view
@@ -0,0 +1,8 @@+module Optic.Lens+  ( -- * Lens+    Lens+  , Lens'+  , lens+  ) where++import Control.Lens.Lens (Lens, Lens', lens)
+ src/Optic/Lens/At.hs view
@@ -0,0 +1,10 @@+module Optic.Lens.At+  ( -- * At+    At(..)+  , sans+    -- ** Re-exports+  , module Optic.Traversal.Ixed+  ) where++import Control.Lens.At      (At(at), sans)+import Optic.Traversal.Ixed
+ src/Optic/Lens/Contains.hs view
@@ -0,0 +1,7 @@+module Optic.Lens.Contains+  ( -- * Contains+    Contains(..)+  , Index+  ) where++import Control.Lens.At (Contains(contains), Index)
+ src/Optic/Prism.hs view
@@ -0,0 +1,12 @@+module Optic.Prism+  ( -- * Prism+    Prism+  , Prism'+  , prism+  , prism'+  , is+  , only+  ) where++import Control.Lens.Extras (is)+import Control.Lens.Prism  (Prism, Prism', only, prism, prism')
+ src/Optic/Prism/Cons.hs view
@@ -0,0 +1,15 @@+{-# LANGUAGE PatternSynonyms #-}++module Optic.Prism.Cons+  ( -- * Cons+    Cons(..)+  , (<|)+  , cons+  , uncons+  , _head+  , _tail+  , pattern (:<)+  ) where++import Control.Lens.Cons (pattern (:<), Cons(_Cons), cons, uncons, (<|), _head,+                          _tail)
+ src/Optic/Prism/Empty.hs view
@@ -0,0 +1,9 @@+{-# LANGUAGE PatternSynonyms #-}++module Optic.Prism.Empty+  ( -- * Empty+    AsEmpty(..)+  , pattern Empty+  ) where++import Control.Lens.Empty (AsEmpty(_Empty), pattern Empty)
+ src/Optic/Prism/Snoc.hs view
@@ -0,0 +1,15 @@+{-# LANGUAGE PatternSynonyms #-}++module Optic.Prism.Snoc+  ( -- * Snoc+    Snoc(..)+  , (|>)+  , snoc+  , unsnoc+  , _init+  , _last+  , pattern (:>)+  ) where++import Control.Lens.Cons (pattern (:>), Snoc(_Snoc), snoc, unsnoc, _init, _last,+                          (|>))
+ src/Optic/Review.hs view
@@ -0,0 +1,7 @@+module Optic.Review+  ( -- * Review+    Review+  , review+  ) where++import Control.Lens.Review (Review, review)
+ src/Optic/Setter.hs view
@@ -0,0 +1,21 @@+module Optic.Setter+  ( -- * Setter+    Setter+  , Setter'+  , (.~)+  , (%~)+  , (+~)+  , (-~)+  , (*~)+  , (//~)+  , (^~)+  , (^^~)+  , (**~)+  , (||~)+  , (&&~)+  , set+  , over+  ) where++import Control.Lens.Setter (Setter, Setter', over, set, (%~), (&&~), (**~),+                            (*~), (+~), (-~), (.~), (//~), (^^~), (^~), (||~))
+ src/Optic/Traversal.hs view
@@ -0,0 +1,11 @@+module Optic.Traversal+  ( -- * Traversal+    Traversal+  , Traversal'+  , traverseOf+  , forOf+  , sequenceAOf+  ) where++import Control.Lens.Traversal (Traversal, Traversal', forOf, sequenceAOf,+                               traverseOf)
+ src/Optic/Traversal/Each.hs view
@@ -0,0 +1,6 @@+module Optic.Traversal.Each+  ( -- * Each+    Each(..)+  ) where++import Control.Lens.Each (Each(each))
+ src/Optic/Traversal/Ixed.hs view
@@ -0,0 +1,8 @@+module Optic.Traversal.Ixed+  ( -- * Ixed+    Ixed(..)+  , Index+  , IxValue+  ) where++import Control.Lens.At (Index, IxValue, Ixed(ix))
+ src/Ord.hs view
@@ -0,0 +1,24 @@+module Ord+  ( Ord(..)+  , Ordering(..)+  , Comparison(..)+  , defaultComparison+  , comparing+  , Down(..)+  , Min(..)+  , Max(..)+  , Arg(..)+  , ArgMin+  , ArgMax+  , Ord1(..)+  , compare1+  , liftCompareDefault+  , Ord2(..)+  , compare2+  ) where++import Data.Functor.Classes+import Data.Functor.Classes.Generic+import Data.Functor.Contravariant+import Data.Ord+import Data.Semigroup
+ src/Parallelism.hs view
@@ -0,0 +1,26 @@+module Parallelism+  ( par+  , pseq+  , rpar+  , rparWith+  , parTraversable+  , parList+  , parListChunk+  , parMap+  , parTuple2+  , parTuple3+  , parTuple4+  , parTuple5+  , parTuple6+  , parTuple7+  , parTuple8+  , parTuple9+    -- * Re-exports+  , module Eval+  ) where++import Control.Parallel.Strategies+import GHC.Conc++-- Re-exports+import Eval
+ src/Parser/Binary.hs view
@@ -0,0 +1,7 @@+module Parser.Binary+  ( module Text.Megaparsec+  , module Text.Megaparsec.Byte+  ) where++import Text.Megaparsec+import Text.Megaparsec.Byte
+ src/Parser/Cli.hs view
@@ -0,0 +1,5 @@+module Parser.Cli+  ( module Options.Applicative+  ) where++import Options.Applicative
+ src/Parser/Earley.hs view
@@ -0,0 +1,7 @@+module Parser.Earley+  ( module Text.Earley+  , module Text.Earley.Mixfix+  ) where++import Text.Earley+import Text.Earley.Mixfix
+ src/Parser/Env.hs view
@@ -0,0 +1,5 @@+module Parser.Env+  ( module Env+  ) where++import Env
+ src/Parser/Text.hs view
@@ -0,0 +1,7 @@+module Parser.Text+  ( module Text.Megaparsec+  , module Text.Megaparsec.Char+  ) where++import Text.Megaparsec+import Text.Megaparsec.Char
+ src/Pointed.hs view
@@ -0,0 +1,6 @@+module Pointed+  ( -- * Pointed+    Pointed(..)+  ) where++import Data.Pointed (Pointed(point))
+ src/Posix.hs view
@@ -0,0 +1,5 @@+module Posix+  ( module System.Posix.Types+  ) where++import System.Posix.Types
+ src/Predicate.hs view
@@ -0,0 +1,5 @@+module Predicate+  ( Predicate(..)+  ) where++import Data.Functor.Contravariant
+ src/Pretty.hs view
@@ -0,0 +1,7 @@+module Pretty+  ( module Data.Text.Prettyprint.Doc+  , module Data.Text.Prettyprint.Doc.Render.Terminal+  ) where++import Data.Text.Prettyprint.Doc+import Data.Text.Prettyprint.Doc.Render.Terminal
+ src/Prim.hs view
@@ -0,0 +1,22 @@+module Prim+  ( -- * Re-exports+    module Control.Monad.Primitive+  , module Data.Primitive.Addr+  , module Data.Primitive.Array+  , module Data.Primitive.ByteArray+  , module Data.Primitive.MachDeps+  , module Data.Primitive.MutVar+  , module Data.Primitive.SmallArray+  , module Data.Primitive.Types+  , module Data.Primitive.UnliftedArray+  ) where++import Control.Monad.Primitive+import Data.Primitive.Addr+import Data.Primitive.Array+import Data.Primitive.ByteArray+import Data.Primitive.MachDeps+import Data.Primitive.MutVar+import Data.Primitive.SmallArray+import Data.Primitive.Types+import Data.Primitive.UnliftedArray
+ src/Printf.hs view
@@ -0,0 +1,5 @@+module Printf+  ( module Text.Printf+  ) where++import Text.Printf
+ src/Process.hs view
@@ -0,0 +1,35 @@+module Process+  ( -- * Spawning processes+    -- ** High-level Haskell API+    module System.Process.Typed+    -- ** Low-level POSIX API+  , forkProcess+  , forkProcessWithUnmask+    -- ** Waiting+  , getProcessStatus+  , getAnyProcessStatus+  , getGroupProcessStatus+    -- * Exiting the current process+  , exitImmediately+    -- * Replacing the current process+  , executeFile+    -- * Process info+  , getProcessID+  , getParentProcessID+    -- ** Process groups+  , getProcessGroupID+  , getProcessGroupIDOf+  , createProcessGroupFor+  , joinProcessGroup+  , setProcessGroupIDOf+  , createSession+  ) where++import System.Posix.Process (createProcessGroupFor, createSession, executeFile,+                             exitImmediately, forkProcess,+                             forkProcessWithUnmask, getAnyProcessStatus,+                             getGroupProcessStatus, getParentProcessID,+                             getProcessGroupID, getProcessGroupIDOf,+                             getProcessID, getProcessStatus, joinProcessGroup,+                             setProcessGroupIDOf)+import System.Process.Typed
+ src/Profunctor.hs view
@@ -0,0 +1,5 @@+module Profunctor+  ( Profunctor(..)+  ) where++import Data.Profunctor
+ src/Proxy.hs view
@@ -0,0 +1,7 @@+module Proxy+  ( Proxy(..)+  , asProxyTypeOf+  , KProxy(..)+  ) where++import Data.Proxy
+ src/Ptr.hs view
@@ -0,0 +1,70 @@+module Ptr+  ( Ptr+  , nullPtr+  , castPtr+  , plusPtr+  , alignPtr+  , minusPtr+  , alloca+  , allocaBytes+  , allocaBytesAligned+  , malloc+  , mallocBytes+  , calloc+  , callocBytes+  , realloc+  , reallocBytes+  , copyBytes+  , moveBytes+  , fillBytes+  , free+  , mallocArray+  , mallocArray0+  , allocaArray+  , allocaArray0+  , reallocArray+  , reallocArray0+  , callocArray+  , callocArray0+  , peekArray+  , peekArray0+  , pokeArray+  , pokeArray0+  , newArray+  , newArray0+  , withArray+  , withArray0+  , withArrayLen+  , withArrayLen0+  , copyArray+  , moveArray+  , lengthArray0+  , advancePtr+  , Pool+  , newPool+  , freePool+  , withPool+  , pooledMalloc+  , pooledMallocBytes+  , pooledRealloc+  , pooledReallocBytes+  , pooledMallocArray+  , pooledMallocArray0+  , pooledReallocArray+  , pooledReallocArray0+  , pooledNew+  , pooledNewArray+  , pooledNewArray0+  , IntPtr(..)+  , ptrToIntPtr+  , intPtrToPtr+  , WordPtr(..)+  , ptrToWordPtr+  , wordPtrToPtr+  ) where++import Foreign.Marshal.Alloc+import Foreign.Marshal.Array+import Foreign.Marshal.Pool+import Foreign.Marshal.Utils+import Foreign.Ptr
+ src/Ptr/Foreign.hs view
@@ -0,0 +1,21 @@+module Ptr.Foreign+  ( ForeignPtr+  , newForeignPtr+  , newForeignPtr_+  , addForeignPtrFinalizer+  , newForeignPtrEnv+  , addForeignPtrFinalizerEnv+  , withForeignPtr+  , finalizeForeignPtr+  , touchForeignPtr+  , castForeignPtr+  , plusForeignPtr+  , mallocForeignPtr+  , mallocForeignPtrBytes+  , mallocForeignPtrArray+  , mallocForeignPtrArray0+  , unsafeForeignPtrToPtr+  ) where++import Foreign.ForeignPtr+import Foreign.ForeignPtr.Unsafe
+ src/Ptr/Fun.hs view
@@ -0,0 +1,15 @@+module Ptr.Fun+  ( FunPtr+  , nullFunPtr+  , castFunPtr+  , castFunPtrToPtr+  , castPtrToFunPtr+  , freeHaskellFunPtr+  , FinalizerPtr+  , FinalizerEnvPtr+  , finalizerFree+  ) where++import Foreign.ForeignPtr+import Foreign.Marshal.Alloc+import Foreign.Ptr
+ src/Ptr/Stable.hs view
@@ -0,0 +1,10 @@+module Ptr.Stable+  ( StablePtr+  , newStablePtr+  , deRefStablePtr+  , freeStablePtr+  , castStablePtrToPtr+  , castPtrToStablePtr+  ) where++import Foreign.StablePtr
+ src/Ptr/Static.hs view
@@ -0,0 +1,13 @@+module Ptr.Static+  ( StaticPtr+  , deRefStaticPtr+  , StaticKey+  , staticKey+  , unsafeLookupStaticPtr+  , StaticPtrInfo(..)+  , staticPtrInfo+  , staticPtrKeys+  , IsStatic(..)+  ) where++import GHC.StaticPtr
+ src/Ptr/Weak.hs view
@@ -0,0 +1,11 @@+module Ptr.Weak+  ( Weak+  , mkWeak+  , deRefWeak+  , finalize+  , mkWeakPtr+  , addFinalizer+  , mkWeakPair+  ) where++import System.Mem.Weak
+ src/Queue/Prio/Hash.hs view
@@ -0,0 +1,34 @@+module Queue.Prio.Hash+  ( -- * HashPSQ+    HashPSQ+    -- * Construction+  , empty+  , singleton+  , fromList+    -- * Querying+  , null+  , size+  , member+  , lookup+  , findMin+  , minView+  , atMostView+    -- * Insertion+  , insert+  , insertView+    -- * Deletion+  , delete+  , deleteView+    -- * Alteration+  , alter+  , alterMin+    -- * Mapping+  , map+  , unsafeMapMonotonic+    -- * Folding+  , toList+  , keys+  , fold'+  ) where++import Data.HashPSQ
+ src/Queue/Prio/Int.hs view
@@ -0,0 +1,34 @@+module Queue.Prio.Int+  ( -- * IntPSQ+    IntPSQ+    -- * Construction+  , empty+  , singleton+  , fromList+    -- * Querying+  , null+  , size+  , member+  , lookup+  , findMin+  , minView+  , atMostView+    -- * Insertion+  , insert+  , insertView+    -- * Deletion+  , delete+  , deleteView+    -- * Alteration+  , alter+  , alterMin+    -- * Mapping+  , map+  , unsafeMapMonotonic+    -- * Folding+  , toList+  , keys+  , fold'+  ) where++import Data.IntPSQ
+ src/Queue/Prio/Ord.hs view
@@ -0,0 +1,35 @@+module Queue.Prio.Ord+  ( -- * OrdPSQ+    OrdPSQ+    -- * Construction+  , empty+  , singleton+  , fromList+    -- * Querying+  , null+  , size+  , member+  , lookup+  , findMin+  , minView+  , atMostView+    -- * Insertion+  , insert+  , insertView+    -- * Deletion+  , delete+  , deleteView+    -- * Alteration+  , alter+  , alterMin+    -- * Mapping+  , map+  , unsafeMapMonotonic+    -- * Folding+  , toList+  , toAscList+  , keys+  , fold'+  ) where++import Data.OrdPSQ
+ src/Random.hs view
@@ -0,0 +1,9 @@+module Random+  ( module System.Random.MWC+  , module System.Random.MWC.CondensedTable+  , module System.Random.MWC.Distributions+  ) where++import System.Random.MWC+import System.Random.MWC.CondensedTable+import System.Random.MWC.Distributions
+ src/Read.hs view
@@ -0,0 +1,28 @@+module Read+  ( Read(..)+  , ReadS+  , reads+  , readMaybe+  , readEither+  , readParen+  , readsData+  , readData+  , readsUnaryWith+  , readUnaryWith+  , readsBinaryWith+  , readBinaryWith+  , Read1(..)+  , readsPrec1+  , readPrec1+  , liftReadListDefault+  , liftReadListPrecDefault+  , Read2(..)+  , readsPrec2+  , readPrec2+  , liftReadList2Default+  , liftReadListPrec2Default+  ) where++import Data.Functor.Classes+import GHC.Read+import Text.Read
+ src/Read/Partial.hs view
@@ -0,0 +1,5 @@+module Read.Partial+  ( read+  ) where++import Text.Read (read)
+ src/Reader.hs view
@@ -0,0 +1,20 @@+module Reader+  ( -- * Reader+    Reader+  , runReader+  , mapReader+  , withReader+    -- * ReaderT+  , ReaderT(..)+  , mapReaderT+  , withReaderT+    -- * MonadReader+  , MonadReader(..)+    -- * Magnify+  , Magnify+  , magnify+  ) where++import Control.Lens.Zoom          (Magnify(magnify))+import Control.Monad.Reader.Class+import Control.Monad.Trans.Reader
+ src/Reflection.hs view
@@ -0,0 +1,9 @@+module Reflection+  ( Reifies(..)+  , reify+  , reifyNat+  , reifySymbol+  , reifyTypeable+  ) where++import Data.Reflection
+ src/Regex.hs view
@@ -0,0 +1,36 @@+module Regex+  ( -- * Regex+    RE+  , Greediness(..)+    -- * Building regular expressions+    -- ** Generic combinators+  , sym+  , psym+  , msym+  , anySym+  , few+  , reFoldl+  , withMatched+    -- ** Strings+  , string+    -- ** Digits+  , digit+  , hexDigit+    -- ** Numbers+  , signed+  , decimal+  , hexadecimal+    -- * Running regular expressions+  , match+  , (=~)+  , replace+  , findFirstPrefix+  , findLongestPrefix+  , findShortestPrefix+  , findFirstInfix+  , findLongestInfix+  , findShortestInfix+  ) where++import Text.Regex.Applicative+import Text.Regex.Applicative.Common
+ src/RuntimeSystem.hs view
@@ -0,0 +1,59 @@+module RuntimeSystem+  ( -- * Garbage collection+    performGC+  , performMajorGC+  , performMinorGC+    -- * Allocation counter and limits+  , setAllocationCounter+  , getAllocationCounter+  , enableAllocationLimit+  , disableAllocationLimit+    -- * Capabilities+  , getNumCapabilities+  , setNumCapabilities+    -- * Spark pool+  , numSparks+  , runSparks+    -- * Processors+  , getNumProcessors+    -- * Uncaught exception handler+  , getUncaughtExceptionHandler+  , setUncaughtExceptionHandler+    -- * Event manager+  , EventManager+  , getSystemEventManager+  , new+  , Event+  , evtRead+  , evtWrite+  , IOCallback+  , FdKey+  , Lifetime+  , registerFd+  , unregisterFd+  , unregisterFd_+  , closeFd+    -- * Timer manager+  , TimerManager+  , TimeoutCallback+  , TimeoutKey+  , registerTimeout+  , updateTimeout+  , unregisterTimeout+    -- * Runtime stats+  , RTSStats(..)+  , GCDetails(..)+  , RtsTime+  , getRTSStats+  , getRTSStatsEnabled+    -- * Memory barriers+  , storeLoadBarrier+  , loadLoadBarrier+  , writeBarrier+  ) where++import Data.Atomics+import GHC.Conc+import GHC.Event+import GHC.Stats+import System.Mem
+ src/ST.hs view
@@ -0,0 +1,28 @@+module ST+  ( -- * ST+    ST+  , runST+  , fixST+  , RealWorld+  , stToIO+    -- * STE+  , STE+  , runSTE+  , fixSTE+  , throwSTE+  , handleSTE+  , unsafeInterleaveSTE+  , unsafeIOToSTE+  , unsafeSTEToIO+    -- * STRef+  , STRef+  , newSTRef+  , readSTRef+  , writeSTRef+  , modifySTRef+  , modifySTRef'+  ) where++import Control.Monad.ST+import Control.Monad.STE.Internal+import Data.STRef
+ src/Semigroup.hs view
@@ -0,0 +1,14 @@+module Semigroup+  ( -- * Semigroup+    Semigroup(..)+  , gmappend+    -- * Newtypes+  , First(..)+  , Last(..)+  , Dual(..)+  , diff+  , cycle1+  ) where++import Data.Semigroup+import Data.Semigroup.Generic
+ src/Semigroupoid.hs view
@@ -0,0 +1,10 @@+module Semigroupoid+  ( -- * Semigroupoid+    Semigroupoid(..)+    -- ** Newtypes+  , Semi(..)+  , Dual(..)+  ) where++import Data.Semigroupoid      (Semi(Semi, getSemi), Semigroupoid(o))+import Data.Semigroupoid.Dual (Dual(Dual, getDual))
+ src/Semilattice.hs view
@@ -0,0 +1,9 @@+module Semilattice+  ( Join(..)+  , Meet(..)+  , Order(..)+  ) where++import Data.Semilattice.Join+import Data.Semilattice.Meet+import Data.Semilattice.Order
+ src/Sequence.hs view
@@ -0,0 +1,14 @@+module Sequence+  ( -- * Sequence+    module Data.Sequence+    -- ** Optics+  , viewL+  , viewR+  , sliced+  , slicedTo+  , slicedFrom+  , seqOf+  ) where++import Data.Sequence+import Data.Sequence.Lens
+ src/Serialise.hs view
@@ -0,0 +1,19 @@+module Serialise+  ( -- * Encoding+    serialise+  , serialiseIncremental+    -- * Decoding+  , deserialiseOrFail+  , deserialiseIncremental+  , DeserialiseFailure(..)+  , ByteOffset+  , IDecode(..)+    -- * Serialise class+  , Serialise(..)+  ) where++import Codec.CBOR.Read (ByteOffset)+import Codec.Serialise (DeserialiseFailure(DeserialiseFailure),+                        IDecode(Done, Fail, Partial), Serialise(decode, encode),+                        deserialiseIncremental, deserialiseOrFail, serialise,+                        serialiseIncremental)
+ src/Set.hs view
@@ -0,0 +1,10 @@+module Set+  ( -- * Set+    module Data.Set+    -- ** Optics+  , setmapped+  , setOf+  ) where++import Data.Set+import Data.Set.Lens (setOf, setmapped)
+ src/Set/Hash.hs view
@@ -0,0 +1,9 @@+module Set.Hash+  ( -- * HashSet+    module Data.HashSet+    -- ** Optics+  , setOf+  ) where++import Data.HashSet+import Data.HashSet.Lens (setOf)
+ src/Set/Int.hs view
@@ -0,0 +1,11 @@+module Set.Int+  ( -- * IntSet+    module Data.IntSet+    -- ** Optics+  , members+  , setmapped+  , setOf+  ) where++import Data.IntSet+import Data.IntSet.Lens (members, setOf, setmapped)
+ src/Show.hs view
@@ -0,0 +1,18 @@+module Show+  ( Show(..)+  , ShowS+  , shows+  , showParen+  , showListWith+  , showsUnaryWith+  , showsBinaryWith+  , Show1(..)+  , showsPrec1+  , liftShowsPrecDefault+  , Show2(..)+  , showsPrec2+  ) where++import Data.Functor.Classes+import Data.Functor.Classes.Generic+import Text.Show
+ src/Socket.hs view
@@ -0,0 +1,85 @@+module Socket+  ( Socket(..)+  , Family(..)+  , isSupportedFamily+  , SocketType(..)+  , isSupportedSocketType+  , SockAddr(..)+  , isSupportedSockAddr+  , SocketStatus(..)+  , HostAddress+  , iNADDR_ANY+  , hostAddressToTuple+  , tupleToHostAddress+  , HostAddress6+  , iN6ADDR_ANY+  , hostAddress6ToTuple+  , tupleToHostAddress6+  , FlowInfo+  , ScopeID+  , htonl+  , ntohl+  , ShutdownCmd(..)+  , ProtocolNumber+  , defaultProtocol+  , PortNumber+  , aNY_PORT+  , HostName+  , ServiceName+  , AddrInfo(..)+  , AddrInfoFlag(..)+  , addrInfoFlagImplemented+  , defaultHints+  , getAddrInfo+  , NameInfoFlag(..)+  , getNameInfo+  , socket+  , socketPair+  , connect+  , bind+  , listen+  , accept+  , getPeerName+  , getSocketName+  , getPeerCred+  , socketPort+  , socketToHandle+  , send+  , sendTo+  , sendAll+  , sendAllTo+  , sendBuf+  , sendBufTo+  , sendFd+  , sendMany+  , sendManyTo+  , recv+  , recvFrom+  , recvBuf+  , recvBufFrom+  , recvFd+  , inet_addr+  , inet_ntoa+  , shutdown+  , close+  , isConnected+  , isBound+  , isListening+  , isReadable+  , isWritable+  , SocketOption(..)+  , isSupportedSocketOption+  , getSocketOption+  , setSocketOption+  , sOMAXCONN+  , sOL_SOCKET+  , sCM_RIGHTS+  , maxListenQueue+  , withSocketsDo+  , fdSocket+  , mkSocket+  , setNonBlockIfNeeded+  ) where++import Network.Socket            hiding (recv, recvFrom, send, sendTo)+import Network.Socket.ByteString
+ src/StableName.hs view
@@ -0,0 +1,8 @@+module StableName+  ( StableName+  , makeStableName+  , hashStableName+  , eqStableName+  ) where++import System.Mem.StableName
+ src/State.hs view
@@ -0,0 +1,31 @@+module State+  ( -- * State+    State+  , runState+  , evalState+  , execState+  , mapState+  , withState+    -- * StateT+  , StateT(..)+  , evalStateT+  , execStateT+  , mapStateT+  , withStateT+    -- * MonadState+  , MonadState(..)+  , gets+  , modify+  , modify'+    -- * Zoom+  , Zoom+  , zoom+  , Zoomed+  ) where++import Control.Lens.Zoom                (Zoom(zoom), Zoomed)+import Control.Monad.State.Class        (MonadState(..), gets, modify, modify')+import Control.Monad.Trans.State.Strict (State, StateT(..), evalState,+                                         evalStateT, execState, execStateT,+                                         mapState, mapStateT, runState,+                                         withState, withStateT)
+ src/Storable.hs view
@@ -0,0 +1,5 @@+module Storable+  ( Storable(..)+  ) where++import Foreign.Storable
+ src/Symbol.hs view
@@ -0,0 +1,39 @@+{-# LANGUAGE ExplicitNamespaces #-}++module Symbol+  ( -- * Symbol+    Symbol+  , KnownSymbol+  , symbolVal+  , symbolVal'+  , SomeSymbol(..)+  , someSymbolVal+  , sameSymbol+  , AppendSymbol+  , CmpSymbol+  , type (++)+  , Take+  , Drop+  , Length+  , appendSymbol+  , appendUnit1+  , appendUnit2+  , appendAssociates+  , takeSymbol+  , dropSymbol+  , takeAppendDrop+  , lengthSymbol+  , takeLength+  , take0+  , takeEmpty+  , dropLength+  , drop0+  , dropEmpty+  , lengthTake+  , lengthDrop+  , dropDrop+  , takeTake+  ) where++import Data.Constraint.Symbol+import GHC.TypeLits
+ src/System.hs view
@@ -0,0 +1,29 @@+{-# LANGUAGE CPP #-}++module System+  ( -- * System info+#if MIN_VERSION_base(4,11,0)+    ByteOrder(..),+    targetByteOrder,+#endif+    os,+    isWindows,+    isMac,+    arch,+    compilerName,+    compilerVersion,+    -- * Network info+    getNetworkInterfaces,+    NetworkInterface(..),+    IPv4(..),+    IPv6(..),+    MAC(..),+  ) where++#if MIN_VERSION_base(4,11,0)+import GHC.ByteOrder+#endif+import Network.Info      (IPv4(IPv4), IPv6(IPv6), MAC(MAC), NetworkInterface(NetworkInterface, ipv4, ipv6, mac, name),+                          getNetworkInterfaces)+import System.Info+import System.Info.Extra
+ src/Tagged.hs view
@@ -0,0 +1,5 @@+module Tagged+  ( module Data.Tagged+  ) where++import Data.Tagged
+ src/Terminal.hs view
@@ -0,0 +1,5 @@+module Terminal+  ( module System.Console.ANSI+  ) where++import System.Console.ANSI
+ src/Test.hs view
@@ -0,0 +1,5 @@+module Test+  ( module Hedgehog+  ) where++import Hedgehog
+ src/Test/Gen.hs view
@@ -0,0 +1,5 @@+module Test.Gen+  ( module Hedgehog.Gen+  ) where++import Hedgehog.Gen
+ src/Test/Range.hs view
@@ -0,0 +1,5 @@+module Test.Range+  ( module Hedgehog.Range+  ) where++import Hedgehog.Range
+ src/Text.hs view
@@ -0,0 +1,112 @@+{-# LANGUAGE MagicHash #-}++module Text+  ( -- * Text+    Text+  , Reader+  , IReader+  , all+  , any+  , append+  , break+  , breakOn+  , breakOnAll+  , breakOnEnd+  , center+  , chunksOf+  , commonPrefixes+  , compareLength+  , concat+  , concatMap+  , cons+  , copy+  , decimal+  , decodeUtf8'+  , double+  , drop+  , dropAround+  , dropEnd+  , dropWhile+  , dropWhileEnd+  , empty+  , encodeUtf16BE+  , encodeUtf16LE+  , encodeUtf32BE+  , encodeUtf32LE+  , encodeUtf8+  , filter+  , find+  , findIndex+  , foldl'+  , foldr+  , group+  , groupBy+  , hexadecimal+  , inits+  , intercalate+  , intersperse+  , isInfixOf+  , isPrefixOf+  , isSuffixOf+  , justifyLeft+  , justifyRight+  , length+  , lines+  , map+  , mapAccumL+  , mapAccumR+  , null+  , pack+  , partition+  , rational+  , replace+  , replicate+  , reverse+  , scanl+  , scanl1+  , scanr+  , scanr1+  , signed+  , singleton+  , snoc+  , span+  , split+  , splitAt+  , strip+  , stripEnd+  , stripPrefix+  , stripStart+  , stripSuffix+  , tails+  , take+  , takeEnd+  , takeWhile+  , takeWhileEnd+  , toCaseFold+  , toLower+  , toTitle+  , toUpper+  , transpose+  , uncons+  , unfoldr+  , unfoldrN+  , unlines+  , unpack+  , unpackCString#+  , unsnoc+  , unwords+  , words+  , zip+  , zipWith+    -- ** Optics+  , packed+  , unpacked+  , text+  , builder+  ) where++import Data.Text+import Data.Text.Encoding+import Data.Text.Internal.Read (IReader)+import Data.Text.Read+import Data.Text.Strict.Lens   (builder, packed, text, unpacked)
+ src/Text/Lazy.hs view
@@ -0,0 +1,14 @@+module Text.Lazy+  ( -- * Text+    module Data.Text.Lazy+  , module Data.Text.Lazy.Encoding+    -- ** Optics+  , packed+  , unpacked+  , text+  , builder+  ) where++import Data.Text.Lazy+import Data.Text.Lazy.Encoding+import Data.Text.Lazy.Lens     (builder, packed, text, unpacked)
+ src/Text/Lazy/Builder.hs view
@@ -0,0 +1,21 @@+module Text.Lazy.Builder+  ( -- * Builder+    Builder+  , toLazyText+  , toLazyTextWith+  , singleton+  , fromText+  , fromLazyText+  , fromString+  , flush+  , decimal+  , hexadecimal+  , FPFormat(..)+  , realFloat+  , formatRealFloat+  ) where++import Data.Text.Lazy.Builder+import Data.Text.Lazy.Builder.Int       (decimal, hexadecimal)+import Data.Text.Lazy.Builder.RealFloat (FPFormat(..), formatRealFloat,+                                         realFloat)
+ src/Text/Partial.hs view
@@ -0,0 +1,22 @@+module Text.Partial+  ( count+  , decodeLatin1+  , decodeUtf16BE+  , decodeUtf16LE+  , decodeUtf32BE+  , decodeUtf32LE+  , decodeUtf8+  , foldl1'+  , foldr1+  , head+  , index+  , init+  , last+  , maximum+  , minimum+  , splitOn+  , tail+  ) where++import Data.Text+import Data.Text.Encoding
+ src/Text/Short.hs view
@@ -0,0 +1,5 @@+module Text.Short+  ( module Data.Text.Short+  ) where++import Data.Text.Short
+ src/Text/Short/Partial.hs view
@@ -0,0 +1,5 @@+module Text.Short.Partial+  ( module Data.Text.Short.Partial+  ) where++import Data.Text.Short.Partial
+ src/Text/Short/Unsafe.hs view
@@ -0,0 +1,5 @@+module Text.Short.Unsafe+  ( module Data.Text.Short.Unsafe+  ) where++import Data.Text.Short.Unsafe
+ src/Time.hs view
@@ -0,0 +1,5 @@+module Time+  ( module Data.Time+  ) where++import Data.Time
+ src/Traversable.hs view
@@ -0,0 +1,21 @@+module Traversable+  ( -- * Traversable+    Traversable(..)+  , for+  , mapAccumL+  , mapAccumR+  , traverseBy+  , sequenceBy+    -- ** Default @Functor@ implementation+  , fmapDefault+    -- ** Default @Foldable@ implementation+  , foldMapDefault+    -- * Traversable1+  , Traversable1(..)+  ) where++import Data.Reflection            (sequenceBy, traverseBy)+import Data.Semigroup.Traversable (Traversable1(sequence1, traverse1))+import Data.Traversable           (Traversable(sequenceA, traverse),+                                   fmapDefault, foldMapDefault, for, mapAccumL,+                                   mapAccumR)
+ src/Tree.hs view
@@ -0,0 +1,14 @@+module Tree+  ( module Data.Tree+  , postorder+  , postorderF+  , preorder+  , preorderF+    -- ** Optics+  , root+  , branches+  ) where++import Data.Graph.Inductive.Basic (postorder, postorderF, preorder, preorderF)+import Data.Tree+import Data.Tree.Lens             (branches, root)
+ src/Tuple.hs view
@@ -0,0 +1,51 @@+module Tuple+  ( fst+  , snd+  , curry+  , uncurry+  , swap+  , dupe+    -- ** Optics+  , Field1(..)+  , _1'+  , Field2(..)+  , _2'+  , Field3(..)+  , _3'+  , Field4(..)+  , _4'+  , Field5(..)+  , _5'+  , Field6(..)+  , _6'+  , Field7(..)+  , _7'+  , Field8(..)+  , _8'+  , Field9(..)+  , _9'+  , Field10(..)+  , _10'+  , Field11(..)+  , _11'+  , Field12(..)+  , _12'+  , Field13(..)+  , _13'+  , Field14(..)+  , _14'+  , Field15(..)+  , _15'+  , Field16(..)+  , _16'+  , Field17(..)+  , _17'+  , Field18(..)+  , _18'+  , Field19(..)+  , _19'+  ) where++import Control.Lens.Tuple+import Data.Tuple+import Data.Tuple.Extra
+ src/Type.hs view
@@ -0,0 +1,8 @@+module Type+  ( Type+  , TypeError+  , ErrorMessage(..)+  ) where++import Data.Kind+import GHC.TypeLits
+ src/Typeable.hs view
@@ -0,0 +1,44 @@+{-# LANGUAGE PatternSynonyms #-}++module Typeable+  ( Typeable+  , cast+  , eqT+  , gcast+  , gcast1+  , gcast2+  , TypeRep+  , typeRep+  , typeOf+  , withTypeable+  , pattern App+  , pattern Con+  , pattern Con'+  , pattern Fun+  , typeRepTyCon+  , rnfTypeRep+  , eqTypeRep+  , typeRepKind+  , splitApps+  , SomeTypeRep(..)+  , someTypeRep+  , someTypeRepTyCon+  , rnfSomeTypeRep+  , TyCon+  , tyConPackage+  , tyConModule+  , tyConName+  , rnfTyCon+  , Module+  , moduleName+  , modulePackage+  , rnfModule+    -- ** Optics+  , _cast+  , _gcast+  ) where++import Data.Typeable      hiding (TypeRep, rnfTypeRep, typeOf, typeRep,+                           typeRepTyCon)+import Data.Typeable.Lens (_cast, _gcast)+import Type.Reflection
+ src/URI.hs view
@@ -0,0 +1,5 @@+module URI+  ( module Network.URI+  ) where++import Network.URI
+ src/UUID.hs view
@@ -0,0 +1,19 @@+module UUID+  ( UUID+  , toText+  , fromText+  , toByteString+  , fromByteString+  , toWords+  , fromWords+  , null+  , nil+  , generateNamed+  , namespaceDNS+  , namespaceURL+  , namespaceOID+  , namespaceX500+  ) where++import Data.UUID.Types+import Data.UUID.V5
+ src/Unique.hs view
@@ -0,0 +1,7 @@+module Unique+  ( Unique+  , newUnique+  , hashUnique+  ) where++import Data.Unique
+ src/Vault.hs view
@@ -0,0 +1,5 @@+module Vault+  ( module Data.Vault.Strict+  ) where++import Data.Vault.Strict
+ src/Vault/Lazy.hs view
@@ -0,0 +1,5 @@+module Vault.Lazy+  ( module Data.Vault.Lazy+  ) where++import Data.Vault.Lazy
+ src/Vector.hs view
@@ -0,0 +1,12 @@+module Vector+  ( -- * Vector+    module Data.Vector+    -- ** Optics+  , toVectorOf+  , vector+  , forced+  , sliced+  ) where++import Data.Vector+import Data.Vector.Lens (forced, sliced, toVectorOf, vector)
+ src/Vector/Builder.hs view
@@ -0,0 +1,9 @@+module Vector.Builder+  ( -- * Builder+    Builder+  , empty+  , singleton+  , vector+  ) where++import VectorBuilder.Builder (Builder, empty, singleton, vector)
+ src/Vector/Generic.hs view
@@ -0,0 +1,7 @@+module Vector.Generic+  ( module Data.Vector.Generic+  , build+  ) where++import Data.Vector.Generic+import VectorBuilder.Vector (build)
+ src/Vector/Generic/Mutable.hs view
@@ -0,0 +1,7 @@+module Vector.Generic.Mutable+  ( module Data.Vector.Generic.Mutable+  , build+  ) where++import Data.Vector.Generic.Mutable+import VectorBuilder.MVector (build)
+ src/Vector/Mutable.hs view
@@ -0,0 +1,5 @@+module Vector.Mutable+  ( module Data.Vector.Mutable+  ) where++import Data.Vector.Mutable
+ src/Vector/Primitive.hs view
@@ -0,0 +1,5 @@+module Vector.Primitive+  ( module Data.Vector.Primitive+  ) where++import Data.Vector.Primitive
+ src/Vector/Storable.hs view
@@ -0,0 +1,5 @@+module Vector.Storable+  ( module Data.Vector.Storable+  ) where++import Data.Vector.Storable
+ src/Vector/Unboxed.hs view
@@ -0,0 +1,5 @@+module Vector.Unboxed+  ( module Data.Vector.Unboxed+  ) where++import Data.Vector.Unboxed
+ src/Void.hs view
@@ -0,0 +1,7 @@+module Void+  ( Void+  , absurd+  , vacuous+  ) where++import Data.Void
+ src/Weigh.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE PackageImports #-}++module Weigh+  ( module X+  ) where++import "weigh" Weigh as X
+ src/Writer.hs view
@@ -0,0 +1,19 @@+module Writer+  ( -- * Writer+    Writer+  , runWriter+  , execWriter+  , mapWriter+    -- * WriterT+  , WriterT+  , writerT+  , runWriterT+  , execWriterT+  , mapWriterT+    -- * MonadWriter+  , MonadWriter(..)+  , listens+  , censor+  ) where++import Control.Monad.Writer.CPS