0.3 Release (#115)

* Add total ConvertText alternative to Conv

* Explain ConvertText's meaning

* Rename convertText to toS for compatibility

* 0.3.0 Refactor (#111)

* Begin work on 0.3 refactor

* Remove old docs folder

* Fix dodgy exports

* 4.8 constraint for null and length

* Guards for Semigroup export for base<4.9

* Fix Data.Bits exports

* Guards for typeable exports

* Remove unused pragmas

* Update hlint.yaml

* Use liftM because of pre-AMP quirkk

* Data.Char exports

* Rework Exception exports

* Fix bounds

* Adding Monad.Fail shim

* Fix displayException export

* Explicit GHC.Prim import for ancient ghc

* Explicit raise# for base-4.7

* Flush legacy testing infrastructure

* Update git location

* Update README

* Add Partial module

* Add concurrency exports

* Explicit GHC.Float exports

* Bounds for threadWaitReadSTM, threadWaitWriteSTM, forkOSWithUnmask

* Fix for weird undocumented underflowError weirdness

* forkOSWithUnask for base>4.8

* Fix GHC.Real exports pre base-4.7

* Fix withMVarMasked for base-4.7

* Update nix derivation

* Update derivation

* Update derivation

* Explicit functor exports

* <$ export

* Overwrite binary

* Fix some missing exports

* Update Changelog

* Minor export fixes base<4.9

* Explicit exports

* Export handler

* Generate export lists for multiple versions (#114)

* Generate export lists for #112

* Make export lists format OccName uniformly

* Make compile on ancient GHC

* Use Foldable.concat

* Hacks to make ghc-7.6 API happy

* liftIO shim

* Fix sortOn warning

* Update ChangeLog

* Update base bounds

* Export conventions

* Update Haddocks

* Document GHC magic

.ghci

@@ -1,3 +1,4 @@
 :set -XNoImplicitPrelude
 :set -XOverloadedStrings
-import Prelude ()
+:set -isrc
+:load Protolude

.github/workflows/hlint.yml

@@ -44,7 +44,7 @@ jobs:
     - name: Install hlint
       run: |
         cabal update
-        cabal new-install hlint --installdir=dist-newstyle
+        cabal new-install hlint --installdir=dist-newstyle --overwrite-policy=always
     - name: Run hlint
       run: |
         dist-newstyle/hlint -g

.gitignore

@@ -6,3 +6,4 @@ cabal.sandbox.config
 *.hi
 *.o
 stack.yaml.lock
+dist-newstyle

.hlint.yaml

@@ -3,7 +3,11 @@
 - ignore: {name: Redundant lambda}
 - ignore: {name: Collapse lambdas}
 - ignore: {name: Use String}
+- ignore: {name: Use fmap, within: Protolude.Monad}
 - ignore: {name: Use putStr, within: Protolude.Show}
 - ignore: {name: Use putStrLn, within: Protolude.Show}
+- ignore: {name: Use bimap, within: Protolude.Bifunctor}
+- ignore: {name: Use first, within: Protolude.Bifunctor}
+- ignore: {name: Use sortOn}
 # CPP preprocessor oddities
 - ignore: {name: Unused LANGUAGE pragma, within: [Protolude.Base, Protolude.CallStack, Protolude.Conv, Protolude.Error]}

ChangeLog.md

@@ -1,3 +1,33 @@
+0.3.0
+=====
+
+* GHC 8.10.1 support
+* Use `Protolude.ConvertText` as the default string conversion class. This
+  removes partial functions when converting to/from ByteStrings.
+* Provide `Protolude.Conv` as a compatibility layer for old string conversion
+  interface.
+* Migrated `Debug` and `Unsafe` to `Protolude.Debug` and `Protolude.Unsafe`.
+* Export Unicode functions:
+  - `intToDigit`
+  - `isAlpha`
+  - `isAlphaNum`
+  - `isAscii`
+  - `isControl`
+  - `isDigit`
+  - `isHexDigit`
+  - `isLetter`
+  - `isLower`
+  - `isPrint`
+  - `isSpace`
+  - `isUpper`
+* Export `MonadFail` class.
+* Export `gcast` from Data.Typeable.
+* Export `typeOf` from Data.Typeable.
+* Export `Handler` from Control.Exception.
+* Export `yield` from Control.Concurrency.
+* Provide compatibility module `Protolude.Partial` as single export for unsafe
+  partial functions with the same naming conventions as Prelude.
+
 0.2.4
 =====
 
@@ -7,7 +37,7 @@
 =====
 
 * GHC 8.6.1 support
-* Expose `fromLeft` and `fromRight`.
+* Export `fromLeft` and `fromRight`.
 * Mask `always` and `alwaysSucceeds` from STM export for stm-2.5.
 
 0.2.2

Exports.hs

@@ -0,0 +1,59 @@
+{-# LANGUAGE CPP #-}
+module Main
+  ( main,
+  )
+where
+
+import Control.Applicative ((<$>))
+import Control.Monad.Trans
+import Data.Foldable (concat)
+import qualified Data.List as List
+import Data.Maybe
+import Data.Ord (comparing)
+import DynFlags
+import GHC
+import GhcMonad
+import GHC.Paths
+import Outputable
+import System.FilePath.Posix
+import Prelude hiding (concat, mod)
+
+autoModule :: FilePath -> IO ()
+autoModule mod = runGhc (Just GHC.Paths.libdir) $ do
+  dflags <- GHC.getSessionDynFlags
+#if (__GLASGOW_HASKELL__ > 706)
+  _ <- setSessionDynFlags ( dflags `gopt_set` Opt_GhciSandbox )
+#else
+  _ <- setSessionDynFlags ( dflags `dopt_set` Opt_GhciSandbox )
+#endif
+  target <- guessTarget ("src" </> addExtension mod ".hs") Nothing
+  setTargets [target]
+  _ <- load LoadAllTargets
+  modSum <- getModSummary $ mkModuleName mod
+  p <- GHC.parseModule modSum
+  t <- typecheckModule p
+  let modInfo = tm_checked_module_info t
+  let exports = modInfoExports modInfo
+  exportThings <- sequence <$> mapM lookupName exports
+  let sortedThings = List.sortBy (comparing getOccName) (concat exportThings)
+  GhcMonad.liftIO (mapM_ (showThing dflags) sortedThings)
+
+showNamed :: NamedThing a => DynFlags -> a -> IO ()
+showNamed df a = do
+  let nm = showSDoc df (ppr (getOccName a))
+  let mod = showSDoc df (ppr (nameModule (getName a)))
+  putStrLn (nm ++ " from " ++ mod)
+
+showThing :: DynFlags -> TyThing -> IO ()
+showThing df (AnId a) = showNamed df a
+#if (__GLASGOW_HASKELL__ > 706)
+showThing df (AConLike a) = showNamed df a
+#endif
+showThing df (ATyCon a) = showNamed df a
+showThing _ _ = error "Should never happen."
+
+--showGhc :: (Outputable a) => a -> String
+--showGhc = showPpr unsafeGlobalDynFlags
+
+main :: IO ()
+main = autoModule "Protolude"

LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2016-2019, Stephen Diehl
+Copyright (c) 2016-2020, Stephen Diehl
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to

README.md

@@ -25,7 +25,6 @@ Design points:
 * Unsafe functions are prefixed with "unsafe" in separate module.
 * Compiler agnostic, GHC internal modules are abstracted out into Base.
 * ``sum`` and ``product`` are strict by default.
-* Compatibility with GHC 8.0.
 * Includes Semiring for GHC >= 7.6.
 * Includes Bifunctor for GHC >= 7.6.
 * Includes Semigroup for GHC >= 7.6.
@@ -48,6 +47,21 @@ Supports:
  * GHC 8.4.1
  * GHC 8.6.1
  * GHC 8.8.1
+ * GHC 8.10.1
+
+Stack LTS:
+
+* lts-4.x
+* lts-5.x
+* lts-6.x
+* lts-7.x
+* lts-8.x
+* lts-9.x
+* lts-10.x
+* lts-11.x
+* lts-12.x
+* lts-13.x
+* lts-14.x
 
 Usage
 -----
@@ -56,7 +70,7 @@ To try out standalone prelude at the interactive shell, from the Protolude
 project directory run.
 
 ```haskell
-$ stack exec ghci
+$ stack repl
 > import Protolude
 ```
 
@@ -81,11 +95,6 @@ Then in your modules:
 import Protolude
 ```
 
-Exported Functions
-------------------
-
-The list of exports can be browsed [here](http://hackage.haskell.org/package/protolude-0.2.3/docs/Protolude.html).
-
 Dependencies
 ------------
 
@@ -98,17 +107,17 @@ tracks Stack LTS resolver.
 | -----------         |   -------- |  -------- |
 | array               |        0.4 |       0.6 |
 | async               |        2.0 |       2.3 |
-| base                |        4.6 |      4.13 |
+| base                |        4.6 |      4.14 |
 | bytestring          |       0.10 |      0.11 |
 | containers          |        0.5 |       0.7 |
 | deepseq             |        1.3 |       1.5 |
 | ghc-prim            |        0.3 |       0.6 |
-| hashable            |        1.2 |       1.3 |
+| hashable            |        1.2 |       1.4 |
 | mtl                 |        2.1 |       2.3 |
 | stm                 |        2.4 |       2.6 |
 | text                |        1.2 |       1.3 |
 | transformers        |        0.4 |       0.6 |
-|                     |            |           |
+| fail                |        4.9 |      4.10 |
 
 Structure
 ---------
@@ -171,8 +180,43 @@ business logic use well-typed checked exceptions of the ``ExceptT`` variety.
 It has been renamed to ``identity`` to reserve the ``id`` identifier for the
 more common use case of business logic.
 
+* **But what if I want the partial functions?**
+
+You if you need partial functions for backwards compatibility you can use the
+`Protolude.Partial` module and mask the safe definitions as needed.
+
+```haskell
+import Protolude hiding (head)
+import Protolude.Partial (head)
+```
+
+Development Tools
+-----------------
+
+**GHC Magic**
+
+To build the `exports` management tool use:
+
+```bash
+$ cabal new-build exports --flag dev
+$ cabal run exports
+```
+
+This tool uses GHC's internal compile symbol table to generate a list of exports
+and keep the export list of protolude stable across different versions of GHC
+and base.
+
+**Continious Integration**
+
+There is a massive test suite that tests all versions of GHC 7.6 - GHC HEAD
+alongside all Stack resolvers to ensure no regressions. Any pull requests or
+patch has to pass the 40 integrity checks before being considered. Any pull
+request must keep the export list consistent across GHC and Base version and not
+have any accidental symbol dropping or drift without updating the export golden
+tests.
+
 License
 -------
 
 Released under the MIT License.
-Copyright (c) 2016-2019, Stephen Diehl
+Copyright (c) 2016-2020, Stephen Diehl

all_stack.sh

@@ -1,6 +1,5 @@
-set +e
+set -e
 
-stack build --resolver lts-2.0
 stack build --resolver lts-3.0
 stack build --resolver lts-4.0
 stack build --resolver lts-5.0

docs/.gitignore

@@ -1 +0,0 @@
-_build

docs/Applicative.md

@@ -1,90 +0,0 @@
-Applicative
-===========
-
-Functor
--------
-
-```haskell
-class Functor (f :: * -> *) where
-  fmap :: (a -> b) -> f a -> f b
-  (<$) :: a -> f b -> f a
-```
-
-```haskell
-(<$>) :: Functor f => (a -> b) -> f a -> f b
-```
-
-```haskell
-($>) :: Functor f => f a -> b -> f b
-```
-
-Applicatives 
--------
-
-```haskell
-class Functor f => Applicative (f :: * -> *) where
-  pure :: a -> f a
-  (<*>) :: f (a -> b) -> f a -> f b
-  (*>) :: f a -> f b -> f b
-  (<*) :: f a -> f b -> f a
-```
-
-```haskell
-orAlt :: (Alternative f, Monoid a) => f a -> f a
-```
-
-```haskell
-orEmpty :: Alternative f => Bool -> a -> f a
-```
-
-```haskell
-eitherA :: (Alternative f) => f a -> f b -> f (Either a b)
-```
-
-```haskell
-pass :: Applicative f => f ()
-```
-
-
-Alternative 
--------
-
-```haskell
-class Applicative f => Alternative (f :: * -> *) where
-  empty :: f a
-  (<|>) :: f a -> f a -> f a
-  some :: f a -> f [a]
-  many :: f a -> f [a]
-```
-
-```haskell
-(<|>) :: Alternative f => f a -> f a -> f a
-```
-
-```haskell
-many :: Alternative f => f a -> f [a]
-```
-
-```haskell
-some :: Alternative f => f a -> f [a]
-```
-
-```haskell
-optional :: Alternative f => f a -> f (Maybe a)
-```
-
-```haskell
-liftA :: Applicative f => (a -> b) -> f a -> f b
-```
-
-```haskell
-empty :: Alternative f => f a
-```
-
-```haskell
-guarded :: (Alternative f) => (a -> Bool) -> a -> f a
-```
-
-```haskell
-guardedA :: (Functor f, Alternative t) => (a -> f Bool) -> a -> f (t a)
-```

docs/Bifunctor.md

@@ -1,2 +0,0 @@
-Bifunctor
-=========

docs/Bits.md

@@ -1,202 +0,0 @@
-Bits
-====
-
-```haskell
-{-# LANGUAGE BinaryLiterals #-}
-```
-
-```python
-42 = 0b101010
-```
-
-Bit Operations
---------------
-
-#### .&.
-
-```haskell
-(.&.) :: Bits a => a -> a -> a
-```
-
-*Example*:
-
-#### .|.
-
-```haskell
-(.|.) :: Bits a => a -> a -> a
-```
-
-*Example*:
-
-#### xor
-
-```haskell
-xor :: Bits a => a -> a -> a
-```
-
-*Example*:
-
-```haskell
-> True `xor` False
-True
-
-> True `xor` True
-False
-
-> 0b101 `xor` 0b011
-6 -- 0b110
-```
-
-#### complement
-
-```haskell
-complement :: Bits a => a -> a
-```
-
-```haskell
-> complement True
-False
-
-> complement 0b101
--2 -- -0b010
-```
-
-*Example*:
-
-#### shift
-
-*Example*:
-
-```haskell
-shift :: Bits a => a -> Int -> a
-```
-
-*Example*:
-
-#### rotate
-
-```haskell
-rotate :: Bits a => a -> Int -> a
-```
-
-*Example*:
-
-#### zeroBits
-
-```haskell
-zeroBits :: Bits a => a
-```
-
-*Example*:
-
-#### bit
-
-```haskell
-bit :: Bits a => Int -> a
-```
-
-*Example*:
-
-Bit Testing
-------------
-
-```haskell
-setBit :: Bits a => a -> Int -> a
-```
-
-```haskell
-clearBit :: Bits a => a -> Int -> a
-```
-
-#### complementBit
-
-```haskell
-complementBit :: Bits a => a -> Int -> a
-```
-
-*Example*:
-
-```haskell
-λ> 0b100 `complementBit` 1
-6 -- 0b110
-```
-
-#### testBit
-
-```haskell
-testBit :: Bits a => a -> Int -> Bool
-```
-
-*Example*:
-
-```haskell
-> 0b10 `testBit` 0
-False
-> 0b10 `testBit` 1
-True
-```
-
-#### isSigned
-
-```haskell
-isSigned :: Bits a => a -> Bool
-```
-
-```haskell
-> isSigned 42
-True
-> isSigned True
-False
-```
-
-Bit Size
-------------
-
-```haskell
-bitSize :: Bits a => a -> Int
-```
-
-```haskell
-popCount :: Bits a => a -> Int
-```
-
-Bit Shifting
-------------
-
-```haskell
-shiftL :: Bits a => a -> Int -> a
-```
-
-```haskell
-shiftR :: Bits a => a -> Int -> a
-```
-
-Bit Rotation
-------------
-
-```haskell
-rotate :: Bits a => a -> Int -> a
-```
-
-```haskell
-rotateL :: Bits a => a -> Int -> a
-```
-
-```haskell
-rotateR :: Bits a => a -> Int -> a
-```
-
-Byte Swapping
-------------
-
-```haskell
-byteSwap16 :: Word16 -> Word16
-```
-
-```haskell
-byteSwap32 :: Word32 -> Word32
-```
-
-```haskell
-byteSwap64 :: Word64 -> Word64
-```

docs/Bool.md

@@ -1,6 +0,0 @@
-Bool
-=====
-
-```haskell
-bool :: a -> a -> Bool -> a
-```

docs/Concurrency.md

@@ -1,2 +0,0 @@
-Concurrency
-===========

docs/Debug.md

@@ -1,96 +0,0 @@
-Debug
-=====
-
-Stubbing
---------
-
-#### undefined
-
-```haskell
-undefined :: a
-```
-
-An undefined expression standing in for an incomplete program, unevaluated type
-witness, or unreachable code branch.
-
-*Example*:
-
-```haskell
-> import Foreign.Storable 
-> print (sizeOf (undefined :: Int))
-8
-```
-
-#### notImplemented
-
-```haskell
-notImplemented :: a
-```
-
-An undefined expression standing in for a yet to completed program.
-
-*Example*:
-
-```haskell
-main :: IO ()
-main = notImplemented
-```
-
-Tracing
--------
-
-#### trace
-
-```haskell
-trace :: Print b => b -> a -> a
-```
-
-*Example*:
-
-#### traceM
-
-```haskell
-traceM :: (Monad m) => Text -> m ()
-```
-
-*Example*:
-
-#### traceId
-
-```haskell
-traceId :: Text -> Text
-```
-
-*Example*:
-
-#### traceShowM
-
-```haskell
-traceShowM :: (P.Show a, Monad m) => a -> m ()
-```
-
-*Example*:
-
-#### traceShowId
-
-```haskell
-traceShowId :: P.Show a => a -> a
-```
-
-*Example*:
-
-#### traceShow
-
-```haskell
-traceShow :: P.Show a => a -> b -> b
-```
-
-*Example*:
-
-#### traceIO
-
-```haskell
-traceIO :: Print b => b -> a -> IO a
-```
-
-*Example*:

docs/Either.md

@@ -1,2 +0,0 @@
-Either
-======

docs/Exceptions.md

@@ -1,126 +0,0 @@
-Exceptions
-==========
-
-MonadError
-----------
-
-```haskell
-class Monad m => MonadError e (m :: * -> *) | m -> e where
-  throwError :: e -> m a
-  catchError :: m a -> (e -> m a) -> m a
-```
-
-#### Except
-
-```haskell
-type Except e = ExceptT e Identity
-```
-
-*Example*:
-
-```haskell
-```
-
-#### ExceptT
-
-```haskell
-newtype ExceptT e (m :: * -> *) a
-  = Control.Monad.Trans.Except.ExceptT (m (Either e a))
-```
-
-*Example*:
-
-```haskell
-```
-
-#### throwError
-
-```haskell
-throwError :: MonadError e m => e -> m a
-```
-
-#### catchError
-
-```haskell
-catchError :: MonadError e m => m a -> (e -> m a) -> m a
-```
-
-#### runExcept
-
-```haskell
-runExcept :: Except e a -> Either e a
-```
-
-#### runExceptT
-
-```haskell
-runExceptT :: ExceptT e m a -> m (Either e a)
-```
-
-Exceptions
-----------
-
-```haskell
-class (Typeable e, Show e) => Exception e where
-  toException :: e -> SomeException
-  fromException :: SomeException -> Maybe e
-  GHC.Exception.displayException :: e -> String
-```
-
-#### throwIO
-
-```haskell
-throwIO :: (MonadIO m, Exception e) => e -> m a
-```
-
-#### throwSTM
-
-```haskell
-throwSTM :: Exception e => e -> STM a
-```
-
-#### throwTo
-
-```haskell
-throwTo :: (MonadIO m, Exception e) => ThreadId -> e -> m ()
-```
-
-Utilities
----------
-
-#### hush
-
-```haskell
-hush :: Alternative m => Either e a -> m a
-```
-
-#### note
-
-```haskell
-note :: (MonadError e m, Applicative m) => e -> Maybe a -> m a
-```
-
-#### tryIO
-
-```haskell
-tryIO :: MonadIO m => IO a -> ExceptT IOException m a
-```
-
-Fatal Errors
-------------
-
-```haskell
-data FatalError = FatalError {fatalErrorMessage :: Text}
-```
-
-#### panic
-
-```haskell
-panic :: Text -> a
-```
-
-Terminate with an uncatchable fatal error.
-
-```haskell
-> panic "Fatal error occured. 
-```

docs/Files.md

@@ -1,74 +0,0 @@
-Files
-=====
-
-Basic IO
---------
-
-#### readFile
-
-```haskell
-readFile :: FilePath -> IO Text
-```
-
-#### writeFile
-
-```haskell
-writeFile :: FilePath -> Text -> IO ()
-```
-
-#### appendFile
-
-```haskell
-appendFile :: FilePath -> Text -> IO ()
-```
-
-Console
--------
-
-#### getLine
-
-```haskell
-getLine :: IO Text
-```
-
-#### getContents
-
-```haskell
-getContents :: IO Text
-```
-
-#### interact
-
-```haskell
-interact :: (Text -> Text) -> IO ()
-```
-
-File Handles
-------------
-
-```haskell
-data IOMode 
-  = ReadMode
-  | WriteMode
-  | AppendMode
-  | ReadWriteMode
-```
-
-#### openFile
-
-```haskell
-openFile :: FilePath -> IOMode -> IO Handle
-```
-
-#### withFile
-
-```haskell
-withFile :: FilePath -> IOMode -> (Handle -> IO r) -> IO r
-```
-
-
-#### stdin
-#### stdout
-#### stderr
-#### Handle
-#### FilePath

docs/Folds.md

@@ -1,171 +0,0 @@
-Folds
-=====
-
-Basic Folds
------------
-
-```haskell
-foldMap :: (Foldable t, Monoid m) => (a -> m) -> t a -> m
-```
-
-```haskell
-foldr :: Foldable t => (a -> b -> b) -> b -> t a -> b
-```
-
-```haskell
-foldl :: Foldable t => (b -> a -> b) -> b -> t a -> b
-```
-
-```haskell
-foldr' :: Foldable t => (a -> b -> b) -> b -> t a -> b
-```
-
-```haskell
-foldl' :: Foldable t => (b -> a -> b) -> b -> t a -> b
-```
-
-```haskell
-fold :: Foldable t => Monoid m => t m -> m
-```
-
-```haskell
-toList :: Foldable t => t a -> [a]
-```
-
-```haskell
-null :: Foldable t => t a -> Bool
-```
-
-```haskell
-length :: Foldable t => t a -> Int
-```
-
-```haskell
-elem :: (Eq a, Foldable t) => a -> t a -> Bool
-```
-
-```haskell
-maximum :: (Ord a, Foldable t) => t a -> a
-```
-
-```haskell
-minimum :: (Ord a, Foldable t) => t a -> a
-```
-
-```haskell
-sum :: (Num a, Foldable f) => f a -> a
-```
-
-```haskell
-product :: (Num a, Foldable f) => f a -> a
-```
-
-#### Folding actions
-
-```haskell
-traverse_ :: (Foldable t, Applicative f) => (a -> f b) -> t a -> f ()
-```
-
-```haskell
-for_ :: (Foldable t, Applicative f) => t a -> (a -> f b) -> f ()
-```
-
-*Example*:
-
-```haskell
->>> for_ [1..4] print
-1
-2
-3
-4
-```
-
-
-#### Applicative Folds
-
-```haskell
-sequenceA_ :: (Foldable t, Applicative f) => t (f a) -> f ()
-```
-
-```haskell
-asum :: (Foldable t, Alternative f) => t (f a) -> f a
-```
-
-#### Monadic Folds
-
-```haskell
-mapM_ :: (Foldable t, Monad m) => (a -> m b) -> t a -> m ()
-```
-
-```haskell
-forM_ :: (Foldable t, Monad m) => t a -> (a -> m b) -> m ()
-```
-
-```haskell
-sequence_ :: (Foldable t, Monad m) => t (m a) -> m ()
-```
-
-```haskell
-msum :: (Foldable t, MonadPlus m) => t (m a) -> m a
-```
-
-```haskell
-foldrM :: (Foldable t, Monad m) => (a -> b -> m b) -> b -> t a -> m b
-```
-
-```haskell
-foldlM :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m b
-```
-
-#### Specialized folds
-
-```haskell
-concat :: Foldable t => t [a] -> [a]
-```
-
-```haskell
-concatMap :: Foldable t => (a -> [b]) -> t a -> [b]
-```
-
-```haskell
-and :: Foldable t => t Bool -> Bool
-```
-
-```haskell
-or :: Foldable t => t Bool -> Bool
-```
-
-```haskell
-any :: Foldable t => (a -> Bool) -> t a -> Bool
-```
-
-```haskell
-all :: Foldable t => (a -> Bool) -> t a -> Bool
-```
-
-```haskell
-maximumBy :: Foldable t => (a -> a -> Ordering) -> t a -> a
-```
-
-```haskell
-minimumBy :: Foldable t => (a -> a -> Ordering) -> t a -> a
-```
-
-#### Searches
-
-```haskell
-notElem :: (Foldable t, Eq a) => a -> t a -> Bool
-```
-
-```haskell
-find :: Foldable t => (a -> Bool) -> t a -> Maybe a
-```
-
-
-```haskell
-foldr1May :: (a -> a -> a) -> [a] -> Maybe a
-```
-
-```haskell
-foldl1May :: (a -> a -> a) -> [a] -> Maybe a
-```

docs/Function.md

@@ -1,153 +0,0 @@
-Functions
-=========
-
-Composition
------------
-
-#### $
-
-```haskell
-($) :: (a -> b) -> a -> b
-```
-
-Infix form of function application. Applies a function from ``a → b`` to an
-argument ``a``.
-
-*Example*:
-
-```haskell
-> take 2 $ [1,2,3]
-[1,2]
-```
-
-#### .
-
-```haskell
-(.) :: (b -> c) -> (a -> b) -> a -> c
-```
-
-Function composition. Composes a function ``f`` (``b → c``)  with a function
-``g`` (``a → b``) yielding ``f ∘ g``.
-
-*Example*:
-
-```haskell
-> map (negate . abs) [-1,0,1]  
-[-1,0,-1]
-```
-
-#### &
-
-```haskell
-(&) :: a -> (a -> b) -> b
-```
-
-Flipped form of ``($)`` which applies an argument ``a`` to a function ``a → b``.
-
-*Example*:
-
-```haskell
-> [1,2,3] & take 2
-[1,2]
-
-> replicate 10 3 & take 5 & tail
-[3,3,3,3]
-```
-
-#### flip
-
-```haskell
-flip :: (a -> b -> c) -> b -> a -> c
-```
-
-Flip takes a function of two arguments and returns a function taking the them in
-reverse order.
-
-*Example*:
-
-```haskell
-λ> flip take [1,2,3] 2
-[1,2]
-```
-
-#### on
-
-```haskell
-on :: (b -> b -> c) -> (a -> b) -> a -> a -> c
-```
-
-*Example*:
-
-```haskell
-> sortBy (compare `on` fst) [(1,2), (3,4), (0,1)]
-[(0,1),(1,2),(3,4)]
-```
-
-#### const
-
-```haskell
-const :: a -> b -> a
-```
-
-*Example*:
-
-#### fix
-
-```haskell
-fix :: (a -> a) -> a
-```
-
-*Example*:
-
-#### identity
-
-```haskell
-identity :: a -> a
-```
-
-The identity function maps any value to itself.
-
-#### applyN
-
-Apply a function to a value `n` times.
-
-*Example*:
-
-```haskell
-applyN :: Int -> (a -> a) -> a -> a
-```
-
-```haskell
-> applyN 25 (+2) 0
-50
-
-> applyN 3 (1:) []
-[1,1,1]
-```
-
-Strictness
------------
-
-#### $!
-
-```haskell
-($!) :: NFData a => (a -> b) -> a -> b
-```
-
-*Example*:
-
-#### $!!
-
-```haskell
-($!!) :: NFData a => (a -> b) -> a -> b
-```
-
-*Example*:
-
-#### force
-
-```haskell
-force :: NFData a => a -> a
-```
-
-*Example*:

docs/Functor.md

@@ -1,41 +0,0 @@
-Functor
-=======
-
-#### map
-
-```haskell
-map :: Functor f => (a -> b) -> f a -> f b
-```
-
-#### $>
-
-```haskell
-($>) :: Functor f => f a -> b -> f b
-```
-
-#### <$>
-
-```haskell
-(<$>) :: Functor f => (a -> b) -> f a -> f b
-```
-
-####  <<$>>
-
-```haskell
-(<<$>>) :: (Functor f, Functor g) => (a -> b) -> f (g a) -> f (g b)
-```
-
-#### void
-
-```haskell
-void :: Functor f => f a -> f ()
-```
-
-#### foreach
-
-```haskell
-foreach :: Functor f => f a -> (a -> b) -> f b
-(<&>)   :: Functor f => f a -> (a -> b) -> f b
-```
-
-

docs/Generics.md

@@ -1,2 +0,0 @@
-Generics
-========

docs/Hashing.md

@@ -1,14 +0,0 @@
-Hashing
-=======
-
-```haskell
-hashWithSalt :: Hashable a => Int -> a -> Int
-```
-
-```haskell
-hash :: Hashable a => a -> Int
-```
-
-```haskell
-hashUsing :: Hashable b => (a -> b) -> Int -> a -> Int
-```

docs/List.md

@@ -1,158 +0,0 @@
-List
-====
-
-Slicing
--------
-
-#### head
-
-```haskell
-head :: Foldable f => f a -> Maybe a
-```
-
-#### tailMay
-
-```haskell
-tailMay :: [a] -> Maybe [a]
-```
-
-#### tailSafe
-
-```haskell
-tailSafe :: [a] -> [a]
-```
-
-#### initMay
-
-```haskell
-initMay :: [a] -> Maybe [a]
-```
-
-#### initSafe
-
-```haskell
-initSafe :: [a] -> [a]
-```
-
-#### initDef
-
-```haskell
-initDef :: [a] -> [a] -> [a]
-```
-
-#### lastMay
-
-```haskell
-lastMay :: [a] -> Maybe a
-```
-
-#### lastDef
-
-```haskell
-lastDef :: a -> [a] -> a
-```
-
-#### drop
-
-```haskell
-drop :: Int -> [a] -> [a]
-```
-
-#### take
-
-```haskell
-take :: Int -> [a] -> [a]
-```
-
-Unpacking
----------
-
-#### uncons
-
-```haskell
-uncons :: [a] -> Maybe (a, [a])
-```
-
-#### unsnoc
-
-```haskell
-unsnoc :: [x] -> Maybe ([x],x)
-```
-
-#### list
-
-```haskell
-list :: [b] -> (a -> b) -> [a] -> [b]
-```
-
-Sorting
----------
-
-#### sortOn
-
-```haskell
-sortOn :: Ord o => (a -> o) -> [a] -> [a]
-```
-
-Removing
----------
-
-#### ordNub
-
-```haskell
-ordNub :: Ord a => [a] -> [a]
-```
-
-Splitting
----------
-
-#### splitAt
-
-```haskell
-splitAt :: Int -> [a] -> ([a], [a])
-```
-
-#### intercalate
-
-```haskell
-intercalate :: [a] -> [[a]] -> [a]
-```
-
-Comparison
----------
-
-#### isPrefixOf
-
-```haskell
-isPrefixOf :: Eq a => [a] -> [a] -> Bool
-```
-
-Filtering
----------
-
-#### filter
-
-```haskell
-filter :: (a -> Bool) -> [a] -> [a]
-```
-
-#### replicate
-
-```haskell
-replicate :: Int -> a -> [a]
-```
-
-Indexing
---------
-
-#### atMay
-
-```haskell
-atMay :: [a] -> Int -> Maybe a
-```
-
-#### atDef
-
-```haskell
-atDef :: a -> [a] -> Int -> a
-```

docs/Makefile

@@ -1,225 +0,0 @@
-# Makefile for Sphinx documentation
-#
-
-# You can set these variables from the command line.
-SPHINXOPTS    =
-SPHINXBUILD   = sphinx-build
-PAPER         =
-BUILDDIR      = _build
-
-# Internal variables.
-PAPEROPT_a4     = -D latex_paper_size=a4
-PAPEROPT_letter = -D latex_paper_size=letter
-ALLSPHINXOPTS   = -d $(BUILDDIR)/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) .
-# the i18n builder cannot share the environment and doctrees with the others
-I18NSPHINXOPTS  = $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) .
-
-.PHONY: help
-help:
-	@echo "Please use \`make <target>' where <target> is one of"
-	@echo "  html       to make standalone HTML files"
-	@echo "  dirhtml    to make HTML files named index.html in directories"
-	@echo "  singlehtml to make a single large HTML file"
-	@echo "  pickle     to make pickle files"
-	@echo "  json       to make JSON files"
-	@echo "  htmlhelp   to make HTML files and a HTML help project"
-	@echo "  qthelp     to make HTML files and a qthelp project"
-	@echo "  applehelp  to make an Apple Help Book"
-	@echo "  devhelp    to make HTML files and a Devhelp project"
-	@echo "  epub       to make an epub"
-	@echo "  epub3      to make an epub3"
-	@echo "  latex      to make LaTeX files, you can set PAPER=a4 or PAPER=letter"
-	@echo "  latexpdf   to make LaTeX files and run them through pdflatex"
-	@echo "  latexpdfja to make LaTeX files and run them through platex/dvipdfmx"
-	@echo "  text       to make text files"
-	@echo "  man        to make manual pages"
-	@echo "  texinfo    to make Texinfo files"
-	@echo "  info       to make Texinfo files and run them through makeinfo"
-	@echo "  gettext    to make PO message catalogs"
-	@echo "  changes    to make an overview of all changed/added/deprecated items"
-	@echo "  xml        to make Docutils-native XML files"
-	@echo "  pseudoxml  to make pseudoxml-XML files for display purposes"
-	@echo "  linkcheck  to check all external links for integrity"
-	@echo "  doctest    to run all doctests embedded in the documentation (if enabled)"
-	@echo "  coverage   to run coverage check of the documentation (if enabled)"
-	@echo "  dummy      to check syntax errors of document sources"
-
-.PHONY: clean
-clean:
-	rm -rf $(BUILDDIR)/*
-
-.PHONY: html
-html:
-	$(SPHINXBUILD) -b html $(ALLSPHINXOPTS) $(BUILDDIR)/html
-	@echo
-	@echo "Build finished. The HTML pages are in $(BUILDDIR)/html."
-
-.PHONY: dirhtml
-dirhtml:
-	$(SPHINXBUILD) -b dirhtml $(ALLSPHINXOPTS) $(BUILDDIR)/dirhtml
-	@echo
-	@echo "Build finished. The HTML pages are in $(BUILDDIR)/dirhtml."
-
-.PHONY: singlehtml
-singlehtml:
-	$(SPHINXBUILD) -b singlehtml $(ALLSPHINXOPTS) $(BUILDDIR)/singlehtml
-	@echo
-	@echo "Build finished. The HTML page is in $(BUILDDIR)/singlehtml."
-
-.PHONY: pickle
-pickle:
-	$(SPHINXBUILD) -b pickle $(ALLSPHINXOPTS) $(BUILDDIR)/pickle
-	@echo
-	@echo "Build finished; now you can process the pickle files."
-
-.PHONY: json
-json:
-	$(SPHINXBUILD) -b json $(ALLSPHINXOPTS) $(BUILDDIR)/json
-	@echo
-	@echo "Build finished; now you can process the JSON files."
-
-.PHONY: htmlhelp
-htmlhelp:
-	$(SPHINXBUILD) -b htmlhelp $(ALLSPHINXOPTS) $(BUILDDIR)/htmlhelp
-	@echo
-	@echo "Build finished; now you can run HTML Help Workshop with the" \
-	      ".hhp project file in $(BUILDDIR)/htmlhelp."
-
-.PHONY: qthelp
-qthelp:
-	$(SPHINXBUILD) -b qthelp $(ALLSPHINXOPTS) $(BUILDDIR)/qthelp
-	@echo
-	@echo "Build finished; now you can run "qcollectiongenerator" with the" \
-	      ".qhcp project file in $(BUILDDIR)/qthelp, like this:"
-	@echo "# qcollectiongenerator $(BUILDDIR)/qthelp/protolude.qhcp"
-	@echo "To view the help file:"
-	@echo "# assistant -collectionFile $(BUILDDIR)/qthelp/protolude.qhc"
-
-.PHONY: applehelp
-applehelp:
-	$(SPHINXBUILD) -b applehelp $(ALLSPHINXOPTS) $(BUILDDIR)/applehelp
-	@echo
-	@echo "Build finished. The help book is in $(BUILDDIR)/applehelp."
-	@echo "N.B. You won't be able to view it unless you put it in" \
-	      "~/Library/Documentation/Help or install it in your application" \
-	      "bundle."
-
-.PHONY: devhelp
-devhelp:
-	$(SPHINXBUILD) -b devhelp $(ALLSPHINXOPTS) $(BUILDDIR)/devhelp
-	@echo
-	@echo "Build finished."
-	@echo "To view the help file:"
-	@echo "# mkdir -p $$HOME/.local/share/devhelp/protolude"
-	@echo "# ln -s $(BUILDDIR)/devhelp $$HOME/.local/share/devhelp/protolude"
-	@echo "# devhelp"
-
-.PHONY: epub
-epub:
-	$(SPHINXBUILD) -b epub $(ALLSPHINXOPTS) $(BUILDDIR)/epub
-	@echo
-	@echo "Build finished. The epub file is in $(BUILDDIR)/epub."
-
-.PHONY: epub3
-epub3:
-	$(SPHINXBUILD) -b epub3 $(ALLSPHINXOPTS) $(BUILDDIR)/epub3
-	@echo
-	@echo "Build finished. The epub3 file is in $(BUILDDIR)/epub3."
-
-.PHONY: latex
-latex:
-	$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
-	@echo
-	@echo "Build finished; the LaTeX files are in $(BUILDDIR)/latex."
-	@echo "Run \`make' in that directory to run these through (pdf)latex" \
-	      "(use \`make latexpdf' here to do that automatically)."
-
-.PHONY: latexpdf
-latexpdf:
-	$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
-	@echo "Running LaTeX files through pdflatex..."
-	$(MAKE) -C $(BUILDDIR)/latex all-pdf
-	@echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex."
-
-.PHONY: latexpdfja
-latexpdfja:
-	$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
-	@echo "Running LaTeX files through platex and dvipdfmx..."
-	$(MAKE) -C $(BUILDDIR)/latex all-pdf-ja
-	@echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex."
-
-.PHONY: text
-text:
-	$(SPHINXBUILD) -b text $(ALLSPHINXOPTS) $(BUILDDIR)/text
-	@echo
-	@echo "Build finished. The text files are in $(BUILDDIR)/text."
-
-.PHONY: man
-man:
-	$(SPHINXBUILD) -b man $(ALLSPHINXOPTS) $(BUILDDIR)/man
-	@echo
-	@echo "Build finished. The manual pages are in $(BUILDDIR)/man."
-
-.PHONY: texinfo
-texinfo:
-	$(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo
-	@echo
-	@echo "Build finished. The Texinfo files are in $(BUILDDIR)/texinfo."
-	@echo "Run \`make' in that directory to run these through makeinfo" \
-	      "(use \`make info' here to do that automatically)."
-
-.PHONY: info
-info:
-	$(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo
-	@echo "Running Texinfo files through makeinfo..."
-	make -C $(BUILDDIR)/texinfo info
-	@echo "makeinfo finished; the Info files are in $(BUILDDIR)/texinfo."
-
-.PHONY: gettext
-gettext:
-	$(SPHINXBUILD) -b gettext $(I18NSPHINXOPTS) $(BUILDDIR)/locale
-	@echo
-	@echo "Build finished. The message catalogs are in $(BUILDDIR)/locale."
-
-.PHONY: changes
-changes:
-	$(SPHINXBUILD) -b changes $(ALLSPHINXOPTS) $(BUILDDIR)/changes
-	@echo
-	@echo "The overview file is in $(BUILDDIR)/changes."
-
-.PHONY: linkcheck
-linkcheck:
-	$(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) $(BUILDDIR)/linkcheck
-	@echo
-	@echo "Link check complete; look for any errors in the above output " \
-	      "or in $(BUILDDIR)/linkcheck/output.txt."
-
-.PHONY: doctest
-doctest:
-	$(SPHINXBUILD) -b doctest $(ALLSPHINXOPTS) $(BUILDDIR)/doctest
-	@echo "Testing of doctests in the sources finished, look at the " \
-	      "results in $(BUILDDIR)/doctest/output.txt."
-
-.PHONY: coverage
-coverage:
-	$(SPHINXBUILD) -b coverage $(ALLSPHINXOPTS) $(BUILDDIR)/coverage
-	@echo "Testing of coverage in the sources finished, look at the " \
-	      "results in $(BUILDDIR)/coverage/python.txt."
-
-.PHONY: xml
-xml:
-	$(SPHINXBUILD) -b xml $(ALLSPHINXOPTS) $(BUILDDIR)/xml
-	@echo
-	@echo "Build finished. The XML files are in $(BUILDDIR)/xml."
-
-.PHONY: pseudoxml
-pseudoxml:
-	$(SPHINXBUILD) -b pseudoxml $(ALLSPHINXOPTS) $(BUILDDIR)/pseudoxml
-	@echo
-	@echo "Build finished. The pseudo-XML files are in $(BUILDDIR)/pseudoxml."
-
-.PHONY: dummy
-dummy:
-	$(SPHINXBUILD) -b dummy $(ALLSPHINXOPTS) $(BUILDDIR)/dummy
-	@echo
-	@echo "Build finished. Dummy builder generates no files."

docs/Maybe.md

@@ -1,38 +0,0 @@
-Maybe
-=====
-
-```haskell
-maybe :: b -> (a -> b) -> Maybe a -> b
-```
-
-```haskell
-isJust :: Maybe a -> Bool
-```
-
-```haskell
-isNothing :: Maybe a -> Bool
-```
-
-```haskell
-fromJust :: Maybe a -> a
-```
-
-```haskell
-fromMaybe :: a -> Maybe a -> a
-```
-
-```haskell
-listToMaybe :: [a] -> Maybe a
-```
-
-```haskell
-maybeToList :: Maybe a -> [a]
-```
-
-```haskell
-catMaybes :: [Maybe a] -> [a]
-```
-
-```haskell
-mapMaybe :: (a -> Maybe b) -> [a] -> [b]
-```

docs/Monad.md

@@ -1,150 +0,0 @@
-Monads
-======
-
-Monad
------
-
-```haskell
-class Applicative m => Monad (m :: * -> *) where
-  (>>=) :: m a -> (a -> m b) -> m b
-  (>>) :: m a -> m b -> m b
-  return :: a -> m a
-```
-
-```haskell
-(>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c
-```
-
-```haskell
-(<=<) :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c
-```
-
-```haskell
-(>>) :: Monad m => m a -> m b -> m b
-```
-
-```haskell
-(>>=) :: Monad m => m a -> (a -> m b) -> m b
-```
-
-```haskell
-forever :: Monad m => m a -> m b
-```
-
-```haskell
-join :: Monad m => m (m a) -> m a
-```
-
-```haskell
-filterM :: Monad m => (a -> m Bool) -> [a] -> m [a]
-```
-
-```haskell
-mapAndUnzipM :: Monad m => (a -> m (b, c)) -> [a] -> m ([b], [c])
-```
-
-```haskell
-zipWithM :: Monad m => (a -> b -> m c) -> [a] -> [b] -> m [c]
-```
-
-```haskell
-zipWithM_ :: Monad m => (a -> b -> m c) -> [a] -> [b] -> m ()
-```
-
-```haskell
-foldM :: (Monad m, Foldable t) => (b -> a -> m b) -> b -> t a -> m b
-```
-
-```haskell
-foldM_ :: (Monad m, Foldable t) => (b -> a -> m b) -> b -> t a -> m ()
-```
-
-```haskell
-replicateM :: Monad m => Int -> m a -> m [a]
-```
-
-```haskell
-replicateM_ :: Monad m => Int -> m a -> m ()
-```
-
-```haskell
-concatMapM :: Monad m => (a -> m [b]) -> [a] -> m [b]
-```
-
-```haskell
-guard :: Alternative f => Bool -> f ()
-```
-
-```haskell
-when :: Applicative f => Bool -> f () -> f ()
-```
-
-```haskell
-unless :: Applicative f => Bool -> f () -> f ()
-```
-
-```haskell
-liftM :: Monad m => (a1 -> r) -> m a1 -> m r
-```
-
-```haskell
-liftM2 :: Monad m => (a1 -> a2 -> r) -> m a1 -> m a2 -> m r
-```
-
-```haskell
-liftM3 :: Monad m => (a1 -> a2 -> a3 -> r) -> m a1 -> m a2 -> m a3 -> m r
-```
-
-```haskell
-liftM4 :: Monad m => (a1 -> a2 -> a3 -> a4 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m r
-```
-
-```haskell
-liftM5 :: Monad m => (a1 -> a2 -> a3 -> a4 -> a5 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m a5 -> m r
-```
-
-```haskell
-liftM' :: Monad m => (a -> b) -> m a -> m b
-```
-
-```haskell
-liftM2' :: Monad m => (a -> b -> c) -> m a -> m b -> m c
-```
-
-```haskell
-ap :: Monad m => m (a -> b) -> m a -> m b
-```
-
-```haskell
-(<$!>) :: Monad m => (a -> b) -> m a -> m b
-```
-
-```haskell
-whenM :: Monad m => m Bool -> m () -> m ()
-```
-
-```haskell
-unlessM :: Monad m => m Bool -> m () -> m ()
-```
-
-```haskell
-ifM :: Monad m => m Bool -> m a -> m a -> m a
-```
-
-```haskell
-guardM :: MonadPlus m => m Bool -> m ()
-```
-
-MonadPlus
------
-
-```haskell
-class (Alternative m, Monad m) => MonadPlus (m :: * -> *) where
-  mzero :: m a
-  mplus :: m a -> m a -> m a
-  	-- Defined in ‘GHC.Base’
-```
-
-```haskell
-mfilter :: MonadPlus m => (a -> Bool) -> m a -> m a
-```

docs/Monoid.md

@@ -1,79 +0,0 @@
-Monoid
-======
-
-Monoid
-------
-
-#### mempty
-
-```haskell
-mempty :: Monoid a => a
-```
-
-#### <>
-
-```haskell
-(<>) :: Monoid m => m -> m -> m
-```
-
-```haskell
-mappend :: Monoid a => a -> a -> a
-```
-
-#### mconcat
-
-```haskell
-mconcat :: Monoid a => [a] -> a
-```
-
-Semigroup
----------
-
-#### <>
-
-```haskell
-(<>) :: Semigroup a => a -> a -> a
-```
-
-#### sconcat
-
-```haskell
-sconcat :: Semigroup a => NonEmpty a -> a
-```
-
-#### stimes
-
-```haskell
-stimes :: (Semigroup a, Integral b) => b -> a -> a
-```
-
-```haskell
-option :: b -> (a -> b) -> Option a -> b
-```
-
-```haskell
-diff :: Semigroup m => m -> Endo m
-```
-
-```haskell
-cycle1 :: Semigroup m => m -> m
-```
-
-```haskell
-stimesMonoid :: (Integral b, Monoid a) => b -> a -> a
-```
-
-```haskell
-stimesIdempotent :: Integral b => b -> a -> a
-```
-
-```haskell
-stimesIdempotentMonoid :: (Integral b, Monoid a) => b -> a -> a
-```
-
-```haskell
-mtimesDefault :: (Integral b, Monoid a) => b -> a -> a
-```
-
-NonEmpty
----------

docs/Numbers.md

@@ -1,31 +0,0 @@
-Numbers
-=======
-
-* Int8 
-* Int16 
-* Int32 
-* Int64 
-* Integer
-* Word  
-* Word8 
-* Word16
-* Word32
-* Word64
-
-Arithemtic 
-----------
-
-Trigonometric 
--------------
-
-Comparisons
------------
-
-Ratios
-------
-
-Complex Numbers
----------------
-
-Conversions
------------

docs/Reader.md

@@ -1,2 +0,0 @@
-Reader
-======

docs/ST.md

@@ -1,2 +0,0 @@
-ST
-==

docs/State.md

@@ -1,2 +0,0 @@
-State
-=====

docs/Strings.md

@@ -1,122 +0,0 @@
-Strings
-=======
-
-```haskell
-import qualified Data.Text as T
-import qualified Data.Text.Lazy as L
-```
-
-Text
-----
-
-The Text type represents Unicode character strings, in a time and space-efficient manner. This package provides text processing capabilities that are optimized for performance critical use, both in terms of large data quantities and high speed.
-
-LText
------
-
-Bytestring
-----------
-
-LBytestring
------------
-
-Encoding
-----------
-
-#### encodeUtf8
-
-```haskell
-encodeUtf8 :: Text -> ByteString
-```
-
-```haskell
-> encodeUtf8 "ポケット"
-"\227\131\157\227\130\177\227\131\131\227\131\136"
-```
-
-#### decodeUtf8
-
-```haskell
-decodeUtf8 :: ByteString -> Text
-```
-
-```haskell
-> putStrLn $ decodeUtf8 "\227\131\157\227\130\177\227\131\131\227\131\136"
-ポケット
-```
-
-#### decodeUtf8'
-
-```haskell
-decodeUtf8' :: ByteString -> Either UnicodeException Text
-```
-
-#### decodeUtf8With
-
-```haskell
-decodeUtf8With :: OnDecodeError -> ByteString -> Text
-```
-
-#### UnicodeException
-
-```haskell
-data UnicodeException
-  = DecodeError [Char] (Maybe Word8)
-  | EncodeError [Char] (Maybe Char)
-```
-
-Strictness
-----------
-
-#### fromStrict
-
-```haskell
-fromStrict :: Text -> LText
-```
-
-#### toStrict
-
-```haskell
-toStrict :: LText -> Text
-```
-
-Conversion
-----------
-
-```haskell
-class StringConv a b where
-  strConv :: Leniency -> a -> b
-
-data Leniency = Lenient | Strict
-```
-
-#### toS
-
-```haskell
-toS :: StringConv a b => a -> b
-```
-
-#### toSL
-
-```haskell
-toSL :: StringConv a b => a -> b
-```
-
-*Example*:
-
-```haskell
-a :: LByteString
-a = "Einstein"
-
-b :: Text
-b = "Feynmann"
-
-c :: ByteString
-c = "Schrödinger"
-
-example1 :: ByteString
-example1 = toS b
-
-example2 :: Bool
-example2 = (a == toS b) && (toS b == c)
-```

docs/Transformers.md

@@ -1,2 +0,0 @@
-Transformers
-============

docs/Traversals.md

@@ -1,2 +0,0 @@
-Traversals
-==========

docs/Tuple.md

@@ -1,76 +0,0 @@
-Tuples
-======
-
-#### fst
-
-```haskell
-fst :: (a, b) -> a
-```
-
-Extract the first component of a pair.
-
-*Example*:
-
-```haskell
-> fst (1,2)
-```
-
-#### snd
-
-```haskell
-snd :: (a, b) -> b
-```
-
-Extract the second component of a pair.
-
-*Example*:
-
-```haskell
-> snd (1,2)
-2
-```
-
-#### swap
-
-```haskell
-swap :: (a, b) -> (b, a)
-```
-
-Swap the components of a pair.
-
-*Example*:
-
-```haskell
-> swap (1,2)
-(2,1)
-```
-
-#### curry
-
-```haskell
-curry :: ((a, b) -> c) -> a -> b -> c
-```
-
-curry converts an uncurried function to a curried function.
-
-*Example*:
-
-```haskell
-> curry fst 1 2
-1
-```
-
-#### uncurry
-
-```haskell
-uncurry :: (a -> b -> c) -> (a, b) -> c
-```
-
-uncurry converts a curried function to a function on pairs.
-
-*Example*:
-
-```haskell
-> uncurry (+) (1,2)
-3
-```

docs/TypeLevel.md

@@ -1,95 +0,0 @@
-Type Level
-==========
-
-```haskell
-data Coercion (a :: k) (b :: k) where
-  Coercion :: forall (k :: BOX) (a :: k) (b :: k).  Coercible a b => Coercion a b
-```
-
-```haskell
-coerceWith :: Coercion a b -> a -> b
-```
-
-#### Empty
-
-```haskell
-data Void
-```
-
-```haskell
-absurd :: Void -> a
-```
-
-```haskell
-vacuous :: Functor f => f Void -> f a
-```
-
-#### Proxy
-
-```haskell
-data Proxy (t :: k) = Proxy
-```
-
-#### Symbol
-
-```haskell
-symbolVal :: KnownSymbol n => proxy n -> String
-```
-
-*Example*:
-
-```haskell
-b :: String
-b = symbolVal (Proxy :: Proxy "foo")
-```
-
-```haskell
-someSymbolVal :: String -> SomeSymbol
-```
-
-*Example*:
-
-#### Nat
-
-```haskell
-natVal :: KnownNat n => proxy n -> Integer
-```
-
-*Example*:
-
-```haskell
-a :: Integer
-a = natVal (Proxy :: Proxy 1)
-```
-
-```haskell
-someNatVal :: Integer -> Maybe SomeNat
-```
-
-*Example*:
-
-#### Type Equality
-
-```haskell
-(:~:) :: k -> k -> *
-```
-
-```haskell
-(==) :: k -> k -> Bool
-```
-
-```haskell
-sym :: a :~: b -> b :~: a
-```
-
-```haskell
-trans :: a :~: b -> b :~: c -> a :~: c
-```
-
-```haskell
-castWith :: a :~: b -> a -> b
-```
-
-```haskell
-gcastWith :: a :~: b -> ((a ~ b) => r) -> r
-```

docs/Unsafe.md

@@ -1,2 +0,0 @@
-Unsafe
-======

docs/conf.py

@@ -1,348 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# protolude documentation build configuration file, created by
-# sphinx-quickstart on Thu Dec  8 09:08:30 2016.
-#
-# This file is execfile()d with the current directory set to its
-# containing dir.
-#
-# Note that not all possible configuration values are present in this
-# autogenerated file.
-#
-# All configuration values have a default; values that are commented out
-# serve to show the default.
-
-# If extensions (or modules to document with autodoc) are in another directory,
-# add these directories to sys.path here. If the directory is relative to the
-# documentation root, use os.path.abspath to make it absolute, like shown here.
-#
-# import os
-# import sys
-# sys.path.insert(0, os.path.abspath('.'))
-
-import sphinx_rtd_theme
-from recommonmark.parser import CommonMarkParser
-
-# -- General configuration ------------------------------------------------
-
-# If your documentation needs a minimal Sphinx version, state it here.
-#
-# needs_sphinx = '1.0'
-
-# Add any Sphinx extension module names here, as strings. They can be
-# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
-# ones.
-extensions = [
-    'sphinx.ext.githubpages',
-]
-
-# Add any paths that contain templates here, relative to this directory.
-templates_path = ['_templates']
-
-# The suffix(es) of source filenames.
-# You can specify multiple suffix as a list of string:
-#
-# source_suffix = ['.rst', '.md']
-
-source_parsers = {
-    '.md': CommonMarkParser,
-}
-source_suffix = ['.rst', '.md']
-
-# The encoding of source files.
-#
-# source_encoding = 'utf-8-sig'
-
-# The master toctree document.
-master_doc = 'index'
-
-# General information about the project.
-project = u'protolude'
-copyright = u'2016, Stephen Diehl'
-author = u'Stephen Diehl'
-
-# The version info for the project you're documenting, acts as replacement for
-# |version| and |release|, also used in various other places throughout the
-# built documents.
-#
-# The short X.Y version.
-version = u'0.1.11'
-# The full version, including alpha/beta/rc tags.
-release = u'0.1.11'
-
-# The language for content autogenerated by Sphinx. Refer to documentation
-# for a list of supported languages.
-#
-# This is also used if you do content translation via gettext catalogs.
-# Usually you set "language" from the command line for these cases.
-language = None
-
-# There are two options for replacing |today|: either, you set today to some
-# non-false value, then it is used:
-#
-# today = ''
-#
-# Else, today_fmt is used as the format for a strftime call.
-#
-# today_fmt = '%B %d, %Y'
-
-# List of patterns, relative to source directory, that match files and
-# directories to ignore when looking for source files.
-# This patterns also effect to html_static_path and html_extra_path
-exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store']
-
-# The reST default role (used for this markup: `text`) to use for all
-# documents.
-#
-# default_role = None
-
-# If true, '()' will be appended to :func: etc. cross-reference text.
-#
-# add_function_parentheses = True
-
-# If true, the current module name will be prepended to all description
-# unit titles (such as .. function::).
-#
-# add_module_names = True
-
-# If true, sectionauthor and moduleauthor directives will be shown in the
-# output. They are ignored by default.
-#
-# show_authors = False
-
-# The name of the Pygments (syntax highlighting) style to use.
-pygments_style = 'sphinx'
-
-# A list of ignored prefixes for module index sorting.
-# modindex_common_prefix = []
-
-# If true, keep warnings as "system message" paragraphs in the built documents.
-# keep_warnings = False
-
-# If true, `todo` and `todoList` produce output, else they produce nothing.
-todo_include_todos = False
-
-
-# -- Options for HTML output ----------------------------------------------
-
-# The theme to use for HTML and HTML Help pages.  See the documentation for
-# a list of builtin themes.
-#
-html_theme = "sphinx_rtd_theme"
-
-# Theme options are theme-specific and customize the look and feel of a theme
-# further.  For a list of options available for each theme, see the
-# documentation.
-#
-# html_theme_options = {}
-
-# Add any paths that contain custom themes here, relative to this directory.
-# html_theme_path = []
-html_theme_path = [sphinx_rtd_theme.get_html_theme_path()]
-
-# The name for this set of Sphinx documents.
-# "<project> v<release> documentation" by default.
-#
-# html_title = u'protolude v0.1.11'
-
-# A shorter title for the navigation bar.  Default is the same as html_title.
-#
-# html_short_title = None
-
-# The name of an image file (relative to this directory) to place at the top
-# of the sidebar.
-#
-# html_logo = None
-
-# The name of an image file (relative to this directory) to use as a favicon of
-# the docs.  This file should be a Windows icon file (.ico) being 16x16 or 32x32
-# pixels large.
-#
-# html_favicon = None
-
-# Add any paths that contain custom static files (such as style sheets) here,
-# relative to this directory. They are copied after the builtin static files,
-# so a file named "default.css" will overwrite the builtin "default.css".
-html_static_path = ['_static']
-
-# Add any extra paths that contain custom files (such as robots.txt or
-# .htaccess) here, relative to this directory. These files are copied
-# directly to the root of the documentation.
-#
-# html_extra_path = []
-
-# If not None, a 'Last updated on:' timestamp is inserted at every page
-# bottom, using the given strftime format.
-# The empty string is equivalent to '%b %d, %Y'.
-#
-# html_last_updated_fmt = None
-
-# If true, SmartyPants will be used to convert quotes and dashes to
-# typographically correct entities.
-#
-# html_use_smartypants = True
-
-# Custom sidebar templates, maps document names to template names.
-#
-# html_sidebars = {}
-
-# Additional templates that should be rendered to pages, maps page names to
-# template names.
-#
-# html_additional_pages = {}
-
-# If false, no module index is generated.
-#
-# html_domain_indices = True
-
-# If false, no index is generated.
-#
-# html_use_index = True
-
-# If true, the index is split into individual pages for each letter.
-#
-# html_split_index = False
-
-# If true, links to the reST sources are added to the pages.
-#
-# html_show_sourcelink = True
-
-# If true, "Created using Sphinx" is shown in the HTML footer. Default is True.
-#
-# html_show_sphinx = True
-
-# If true, "(C) Copyright ..." is shown in the HTML footer. Default is True.
-#
-# html_show_copyright = True
-
-# If true, an OpenSearch description file will be output, and all pages will
-# contain a <link> tag referring to it.  The value of this option must be the
-# base URL from which the finished HTML is served.
-#
-# html_use_opensearch = ''
-
-# This is the file name suffix for HTML files (e.g. ".xhtml").
-# html_file_suffix = None
-
-# Language to be used for generating the HTML full-text search index.
-# Sphinx supports the following languages:
-#   'da', 'de', 'en', 'es', 'fi', 'fr', 'hu', 'it', 'ja'
-#   'nl', 'no', 'pt', 'ro', 'ru', 'sv', 'tr', 'zh'
-#
-# html_search_language = 'en'
-
-# A dictionary with options for the search language support, empty by default.
-# 'ja' uses this config value.
-# 'zh' user can custom change `jieba` dictionary path.
-#
-# html_search_options = {'type': 'default'}
-
-# The name of a javascript file (relative to the configuration directory) that
-# implements a search results scorer. If empty, the default will be used.
-#
-# html_search_scorer = 'scorer.js'
-
-# Output file base name for HTML help builder.
-htmlhelp_basename = 'protoludedoc'
-
-# -- Options for LaTeX output ---------------------------------------------
-
-latex_elements = {
-     # The paper size ('letterpaper' or 'a4paper').
-     #
-     # 'papersize': 'letterpaper',
-
-     # The font size ('10pt', '11pt' or '12pt').
-     #
-     # 'pointsize': '10pt',
-
-     # Additional stuff for the LaTeX preamble.
-     #
-     # 'preamble': '',
-
-     # Latex figure (float) alignment
-     #
-     # 'figure_align': 'htbp',
-}
-
-# Grouping the document tree into LaTeX files. List of tuples
-# (source start file, target name, title,
-#  author, documentclass [howto, manual, or own class]).
-latex_documents = [
-    (master_doc, 'protolude.tex', u'protolude Documentation',
-     u'Stephen Diehl', 'manual'),
-]
-
-# The name of an image file (relative to this directory) to place at the top of
-# the title page.
-#
-# latex_logo = None
-
-# For "manual" documents, if this is true, then toplevel headings are parts,
-# not chapters.
-#
-# latex_use_parts = False
-
-# If true, show page references after internal links.
-#
-# latex_show_pagerefs = False
-
-# If true, show URL addresses after external links.
-#
-# latex_show_urls = False
-
-# Documents to append as an appendix to all manuals.
-#
-# latex_appendices = []
-
-# It false, will not define \strong, \code, 	itleref, \crossref ... but only
-# \sphinxstrong, ..., \sphinxtitleref, ... To help avoid clash with user added
-# packages.
-#
-# latex_keep_old_macro_names = True
-
-# If false, no module index is generated.
-#
-# latex_domain_indices = True
-
-
-# -- Options for manual page output ---------------------------------------
-
-# One entry per manual page. List of tuples
-# (source start file, name, description, authors, manual section).
-man_pages = [
-    (master_doc, 'protolude', u'protolude Documentation',
-     [author], 1)
-]
-
-# If true, show URL addresses after external links.
-#
-# man_show_urls = False
-
-
-# -- Options for Texinfo output -------------------------------------------
-
-# Grouping the document tree into Texinfo files. List of tuples
-# (source start file, target name, title, author,
-#  dir menu entry, description, category)
-texinfo_documents = [
-    (master_doc, 'protolude', u'protolude Documentation',
-     author, 'protolude', 'One line description of project.',
-     'Miscellaneous'),
-]
-
-# Documents to append as an appendix to all manuals.
-#
-# texinfo_appendices = []
-
-# If false, no module index is generated.
-#
-# texinfo_domain_indices = True
-
-# How to display URL addresses: 'footnote', 'no', or 'inline'.
-#
-# texinfo_show_urls = 'footnote'
-
-# If true, do not generate a @detailmenu in the "Top" node's menu.
-#
-# texinfo_no_detailmenu = False

docs/index.rst

@@ -1,47 +0,0 @@
-Protolude Documentation
-=======================
-
-An alternative Prelude.
-
-.. toctree::
-   :maxdepth: 0
-  Function     
-  Strings      
-  Bool         
-  Numbers      
-  Printing     
-  Files        
-  Debug
-  Bits
-  Functor
-  Applicative  
-  Monad        
-  Maybe        
-  Either       
-  Monoid       
-  Semigroup    
-  Bifunctor    
-  List         
-  Folds        
-  Traversals   
-  Transformers 
-  Reader       
-  State        
-  Exceptions   
-  ST           
-  Concurrency  
-  Storable     
-  System      
-  Map          
-  Set          
-  Tuple      
-  Generics     
-  Hashing
-  TypeLevel    
-  Unsafe       
-
-Indices and tables
-==================
-
-* :ref:`genindex`
-* :ref:`search`

export_lists/protolude-10.exports

@@ -0,0 +1,960 @@
+$ from GHC.Base
+$! from Protolude.Base
+$!! from Control.DeepSeq
+$> from Data.Functor
+% from GHC.Real
+& from Data.Function
+&& from GHC.Classes
+&&^ from Protolude.Bool
+* from GHC.Num
+* from GHC.Types
+** from GHC.Float
+*> from GHC.Base
++ from GHC.Num
+++ from GHC.Base
+- from GHC.Num
+. from GHC.Base
+.&. from Data.Bits
+.|. from Data.Bits
+/ from GHC.Real
+/= from GHC.Classes
+:% from GHC.Real
+:*: from GHC.Generics
+:*: from GHC.Generics
+:+ from Data.Complex
+:+: from GHC.Generics
+:.: from GHC.Generics
+:| from Data.List.NonEmpty
+:~: from Data.Type.Equality
+< from GHC.Classes
+<$ from GHC.Base
+<$!> from Control.Monad
+<$> from Data.Functor
+<&&> from Protolude.Bool
+<&> from Protolude.Functor
+<* from GHC.Base
+<**> from GHC.Base
+<*> from GHC.Base
+<.> from Protolude.Semiring
+<<$>> from Protolude.Functor
+<<*>> from Protolude.Applicative
+<= from GHC.Classes
+<=< from Control.Monad
+<> from Data.Monoid
+<|> from GHC.Base
+<||> from Protolude.Bool
+=<< from GHC.Base
+== from GHC.Classes
+== from Data.Type.Equality
+> from GHC.Classes
+>= from GHC.Classes
+>=> from Control.Monad
+>> from GHC.Base
+>>= from GHC.Base
+All from Data.Monoid
+All from Data.Monoid
+AllocationLimitExceeded from GHC.IO.Exception
+AllocationLimitExceeded from GHC.IO.Exception
+Alt from Data.Monoid
+Alt from Data.Monoid
+Alternative from GHC.Base
+Any from Data.Monoid
+Any from Data.Monoid
+AppendMode from GHC.IO.IOMode
+Applicative from GHC.Base
+ArithException from GHC.Exception
+ArrayException from GHC.IO.Exception
+AssertionFailed from GHC.IO.Exception
+AssertionFailed from GHC.IO.Exception
+Associativity from GHC.Generics
+Async from Control.Concurrent.Async
+AsyncException from GHC.IO.Exception
+Bifunctor from Data.Bifunctor
+Bits from Data.Bits
+BlockedIndefinitelyOnMVar from GHC.IO.Exception
+BlockedIndefinitelyOnMVar from GHC.IO.Exception
+BlockedIndefinitelyOnSTM from GHC.IO.Exception
+BlockedIndefinitelyOnSTM from GHC.IO.Exception
+Bool from GHC.Types
+Bounded from GHC.Enum
+ByteString from Data.ByteString.Internal
+C1 from GHC.Generics
+CallStack from GHC.Stack.Types
+Chan from Control.Concurrent.Chan
+Char from GHC.Types
+CmpNat from GHC.TypeNats
+Coercible from GHC.Types
+Coercion from Data.Type.Coercion
+Coercion from Data.Type.Coercion
+Comp1 from GHC.Generics
+CompactionFailed from GHC.IO.Exception
+CompactionFailed from GHC.IO.Exception
+Complex from Data.Complex
+Concurrently from Control.Concurrent.Async
+Concurrently from Control.Concurrent.Async
+Const from Data.Functor.Const
+Const from Data.Functor.Const
+Constraint from GHC.Types
+Constructor from GHC.Generics
+D# from GHC.Types
+D1 from GHC.Generics
+Datatype from GHC.Generics
+Deadlock from GHC.IO.Exception
+Deadlock from GHC.IO.Exception
+Denormal from GHC.Exception
+DivideByZero from GHC.Exception
+Double from GHC.Types
+Down from Data.Ord
+Down from Data.Ord
+Dual from Data.Monoid
+Dual from Data.Monoid
+EQ from GHC.Types
+Either from Data.Either
+Endo from Data.Monoid
+Endo from Data.Monoid
+Enum from GHC.Enum
+Eq from GHC.Classes
+ErrorCall from GHC.Exception
+ErrorCall from GHC.Exception
+ErrorCallWithLocation from GHC.Exception
+Except from Control.Monad.Trans.Except
+ExceptT from Control.Monad.Trans.Except
+ExceptT from Control.Monad.Trans.Except
+Exception from GHC.Exception
+ExitCode from GHC.IO.Exception
+ExitFailure from GHC.IO.Exception
+ExitSuccess from GHC.IO.Exception
+F# from GHC.Types
+False from GHC.Types
+FatalError from Protolude.Panic
+FatalError from Protolude.Panic
+FilePath from GHC.IO
+FiniteBits from Data.Bits
+First from Data.Monoid
+First from Data.Monoid
+Fixity from GHC.Generics
+FixityI from GHC.Generics
+Float from GHC.Types
+Floating from GHC.Float
+Foldable from Data.Foldable
+Fractional from GHC.Real
+FunPtr from GHC.Ptr
+Functor from GHC.Base
+GT from GHC.Types
+Generic from GHC.Generics
+Generic1 from GHC.Generics
+Handle from GHC.IO.Handle.Types
+HasCallStack from GHC.Stack.Types
+HasField from GHC.Records
+Hashable from Data.Hashable.Class
+HeapOverflow from GHC.IO.Exception
+IO from GHC.Types
+IOException from GHC.IO.Exception
+IOMode from GHC.IO.IOMode
+Identity from Data.Functor.Identity
+Identity from Data.Functor.Identity
+IndexOutOfBounds from GHC.IO.Exception
+Infix from GHC.Generics
+InfixI from GHC.Generics
+Int from GHC.Types
+Int16 from GHC.Int
+Int32 from GHC.Int
+Int64 from GHC.Int
+Int8 from GHC.Int
+IntMap from Data.IntMap.Internal
+IntPtr from Foreign.Ptr
+IntSet from Data.IntSet.Internal
+Integer from GHC.Integer.Type
+Integral from GHC.Real
+IsLabel from GHC.OverloadedLabels
+IsString from Data.String
+Just from GHC.Base
+K1 from GHC.Generics
+K1 from GHC.Generics
+KnownNat from GHC.TypeNats
+KnownSymbol from GHC.TypeLits
+L1 from GHC.Generics
+LByteString from Protolude
+LT from GHC.Types
+LText from Protolude
+Last from Data.Monoid
+Last from Data.Monoid
+Left from Data.Either
+LeftAssociative from GHC.Generics
+Leniency from Protolude.Conv
+Lenient from Protolude.Conv
+Location from GHC.ExecutionStack.Internal
+Location from GHC.ExecutionStack.Internal
+LossOfPrecision from GHC.Exception
+M1 from GHC.Generics
+M1 from GHC.Generics
+MVar from GHC.MVar
+Map from Data.Map.Internal
+MaskedInterruptible from GHC.IO
+MaskedUninterruptible from GHC.IO
+MaskingState from GHC.IO
+Maybe from GHC.Base
+Meta from GHC.Generics
+MetaCons from GHC.Generics
+MetaData from GHC.Generics
+MetaSel from GHC.Generics
+Monad from GHC.Base
+MonadError from Control.Monad.Error.Class
+MonadIO from Control.Monad.IO.Class
+MonadPlus from GHC.Base
+MonadReader from Control.Monad.Reader.Class
+MonadState from Control.Monad.State.Class
+Monoid from GHC.Base
+NFData from Control.DeepSeq
+Nat from GHC.Types
+NestedAtomically from Control.Exception.Base
+NestedAtomically from Control.Exception.Base
+NoMethodError from Control.Exception.Base
+NoMethodError from Control.Exception.Base
+NonEmpty from Data.List.NonEmpty
+NonTermination from Control.Exception.Base
+NonTermination from Control.Exception.Base
+NotAssociative from GHC.Generics
+Nothing from GHC.Base
+Num from GHC.Num
+OnDecodeError from Data.Text.Encoding.Error
+OnError from Data.Text.Encoding.Error
+Option from Data.Semigroup
+Option from Data.Semigroup
+Ord from GHC.Classes
+Ordering from GHC.Types
+Overflow from GHC.Exception
+PatternMatchFail from Control.Exception.Base
+PatternMatchFail from Control.Exception.Base
+Prefix from GHC.Generics
+PrefixI from GHC.Generics
+Print from Protolude.Show
+Product from Data.Monoid
+Product from Data.Monoid
+Proxy from Data.Proxy
+Proxy from Data.Proxy
+Ptr from GHC.Ptr
+QSem from Control.Concurrent.QSem
+QSemN from Control.Concurrent.QSemN
+R1 from GHC.Generics
+Ratio from GHC.Real
+RatioZeroDenominator from GHC.Exception
+Rational from GHC.Real
+Read from GHC.Read
+ReadMode from GHC.IO.IOMode
+ReadWriteMode from GHC.IO.IOMode
+Reader from Control.Monad.Trans.Reader
+ReaderT from Control.Monad.Trans.Reader
+ReaderT from Control.Monad.Trans.Reader
+Real from GHC.Real
+RealFloat from GHC.Float
+RealFrac from GHC.Real
+Rec0 from GHC.Generics
+RecConError from Control.Exception.Base
+RecConError from Control.Exception.Base
+RecSelError from Control.Exception.Base
+RecSelError from Control.Exception.Base
+RecUpdError from Control.Exception.Base
+RecUpdError from Control.Exception.Base
+Refl from Data.Type.Equality
+Rep from GHC.Generics
+Right from Data.Either
+RightAssociative from GHC.Generics
+S1 from GHC.Generics
+ST from GHC.ST
+STM from GHC.Conc.Sync
+Selector from GHC.Generics
+Semigroup from Data.Semigroup
+Semiring from Protolude.Semiring
+Seq from Data.Sequence.Internal
+Set from Data.Set.Internal
+Show from GHC.Show
+SomeAsyncException from GHC.IO.Exception
+SomeAsyncException from GHC.IO.Exception
+SomeException from GHC.Exception
+SomeException from GHC.Exception
+SomeNat from GHC.TypeNats
+SomeNat from GHC.TypeNats
+SomeSymbol from GHC.TypeLits
+SomeSymbol from GHC.TypeLits
+SrcLoc from GHC.ExecutionStack.Internal
+SrcLoc from GHC.ExecutionStack.Internal
+StablePtr from GHC.Stable
+StackOverflow from GHC.IO.Exception
+State from Control.Monad.Trans.State.Lazy
+StateT from Control.Monad.Trans.State.Lazy
+StateT from Control.Monad.Trans.State.Lazy
+StaticPtr from GHC.StaticPtr
+Storable from Foreign.Storable
+Strict from Protolude.Conv
+StringConv from Protolude.Conv
+Sum from Data.Monoid
+Sum from Data.Monoid
+Symbol from GHC.Types
+Text from Data.Text.Internal
+ThreadId from GHC.Conc.Sync
+ThreadKilled from GHC.IO.Exception
+Traversable from Data.Traversable
+True from GHC.Types
+Type from GHC.Types
+TypeError from Control.Exception.Base
+TypeError from Control.Exception.Base
+TypeRep from Data.Typeable
+Typeable from Data.Typeable.Internal
+U1 from GHC.Generics
+U1 from GHC.Generics
+URec from GHC.Generics
+UndefinedElement from GHC.IO.Exception
+Underflow from GHC.Exception
+UnicodeException from Data.Text.Encoding.Error
+Unmasked from GHC.IO
+UserInterrupt from GHC.IO.Exception
+V1 from GHC.Generics
+Void from Data.Void
+Word from GHC.Types
+Word16 from GHC.Word
+Word32 from GHC.Word
+Word64 from GHC.Word
+Word8 from GHC.Word
+WordPtr from Foreign.Ptr
+WrappedMonoid from Data.Semigroup
+WriteMode from GHC.IO.IOMode
+ZipList from Control.Applicative
+ZipList from Control.Applicative
+^ from GHC.Real
+^%^ from GHC.Real
+^^ from GHC.Real
+^^%^^ from GHC.Real
+abs from GHC.Num
+absurd from Data.Void
+acos from GHC.Float
+acosh from GHC.Float
+addMVarFinalizer from Control.Concurrent.MVar
+all from Data.Foldable
+allowInterrupt from Control.Exception
+always from GHC.Conc.Sync
+alwaysSucceeds from GHC.Conc.Sync
+and from Data.Foldable
+any from Data.Foldable
+ap from GHC.Base
+appEndo from Data.Monoid
+appendFile from Data.Text.IO
+applyN from Protolude
+asTypeOf from GHC.Base
+asin from GHC.Float
+asinh from GHC.Float
+ask from Control.Monad.Reader.Class
+asks from Control.Monad.Reader.Class
+asum from Data.Foldable
+async from Control.Concurrent.Async
+asyncBound from Control.Concurrent.Async
+asyncExceptionFromException from GHC.IO.Exception
+asyncExceptionToException from GHC.IO.Exception
+asyncOn from Control.Concurrent.Async
+asyncThreadId from Control.Concurrent.Async
+atDef from Protolude.Safe
+atMay from Protolude.Safe
+atan from GHC.Float
+atan2 from GHC.Float
+atanh from GHC.Float
+atomically from GHC.Conc.Sync
+bimap from Data.Bifunctor
+bit from Data.Bits
+bitDefault from Data.Bits
+bitSize from Data.Bits
+bitSizeMaybe from Data.Bits
+bool from Protolude.Bool
+boundedEnumFrom from GHC.Enum
+boundedEnumFromThen from GHC.Enum
+bracket from Control.Exception.Base
+bracketOnError from Control.Exception.Base
+bracket_ from Control.Exception.Base
+break from GHC.List
+byteSwap16 from GHC.Word
+byteSwap32 from GHC.Word
+byteSwap64 from GHC.Word
+callStack from GHC.Stack
+cancel from Control.Concurrent.Async
+cancelWith from Control.Concurrent.Async
+cast from Data.Typeable
+castWith from Data.Type.Equality
+catMaybes from Data.Maybe
+catch from GHC.IO
+catchE from Control.Monad.Trans.Except
+catchError from Control.Monad.Error.Class
+catchJust from Control.Exception.Base
+catchSTM from GHC.Conc.Sync
+catches from Control.Exception
+ceiling from GHC.Real
+check from Control.Monad.STM
+chr from GHC.Char
+cis from Data.Complex
+clearBit from Data.Bits
+coerceWith from Data.Type.Coercion
+compare from GHC.Classes
+comparing from Data.Ord
+complement from Data.Bits
+complementBit from Data.Bits
+conFixity from GHC.Generics
+conIsRecord from GHC.Generics
+conName from GHC.Generics
+concat from Data.Foldable
+concatMap from Data.Foldable
+concatMapM from Protolude.Monad
+concurrently from Control.Concurrent.Async
+conjugate from Data.Complex
+const from GHC.Base
+cos from GHC.Float
+cosh from GHC.Float
+countLeadingZeros from Data.Bits
+countTrailingZeros from Data.Bits
+currentCallStack from GHC.Stack.CCS
+curry from Data.Tuple
+cycle from GHC.List
+cycle1 from Data.Semigroup
+datatypeName from GHC.Generics
+decodeFloat from GHC.Float
+decodeUtf8 from Data.Text.Encoding
+decodeUtf8' from Data.Text.Encoding
+decodeUtf8With from Data.Text.Encoding
+deepseq from Control.DeepSeq
+denominator from GHC.Real
+die from Protolude
+diff from Data.Semigroup
+displayException from GHC.Exception
+div from GHC.Real
+divMod from GHC.Real
+divZeroError from GHC.Real
+drop from GHC.List
+dropWhile from GHC.List
+dupChan from Control.Concurrent.Chan
+either from Data.Either
+eitherA from Protolude.Applicative
+elem from Data.Foldable
+empty from GHC.Base
+encodeFloat from GHC.Float
+encodeUtf8 from Data.Text.Encoding
+enumFrom from GHC.Enum
+enumFromThen from GHC.Enum
+enumFromThenTo from GHC.Enum
+enumFromTo from GHC.Enum
+eqT from Data.Typeable
+evalState from Control.Monad.Trans.State.Lazy
+evalStateT from Control.Monad.Trans.State.Lazy
+evaluate from GHC.IO
+even from GHC.Real
+execState from Control.Monad.Trans.State.Lazy
+execStateT from Control.Monad.Trans.State.Lazy
+exitFailure from System.Exit
+exitSuccess from System.Exit
+exitWith from System.Exit
+exp from GHC.Float
+expm1 from GHC.Float
+exponent from GHC.Float
+fatalErrorMessage from Protolude.Panic
+filter from GHC.List
+filterM from Control.Monad
+finally from Control.Exception.Base
+find from Data.Foldable
+finiteBitSize from Data.Bits
+first from Data.Bifunctor
+fix from Data.Function
+fixST from GHC.ST
+flip from GHC.Base
+floatDigits from GHC.Float
+floatRadix from GHC.Float
+floatRange from GHC.Float
+floor from GHC.Real
+fmap from GHC.Base
+fmapDefault from Data.Traversable
+fold from Data.Foldable
+foldM from Control.Monad
+foldM_ from Control.Monad
+foldMap from Data.Foldable
+foldMapDefault from Data.Traversable
+foldl from Data.Foldable
+foldl' from Data.Foldable
+foldl1May from Protolude.Safe
+foldl1May' from Protolude.Safe
+foldlM from Data.Foldable
+foldr from Data.Foldable
+foldr' from Data.Foldable
+foldr1May from Protolude.Safe
+foldrM from Data.Foldable
+for from Data.Traversable
+forM from Data.Traversable
+forM_ from Data.Foldable
+for_ from Data.Foldable
+force from Control.DeepSeq
+foreach from Protolude.Functor
+forever from Control.Monad
+forkFinally from Control.Concurrent
+forkIO from GHC.Conc.Sync
+forkIOWithUnmask from GHC.Conc.Sync
+forkOS from Control.Concurrent
+forkOSWithUnmask from Control.Concurrent
+forkOn from GHC.Conc.Sync
+forkOnWithUnmask from GHC.Conc.Sync
+from from GHC.Generics
+fromEnum from GHC.Enum
+fromException from GHC.Exception
+fromInteger from GHC.Num
+fromIntegral from GHC.Real
+fromLabel from GHC.OverloadedLabels
+fromLeft from Data.Either
+fromMaybe from Data.Maybe
+fromRational from GHC.Real
+fromRight from Data.Either
+fromStrict from Data.Text.Lazy
+fst from Data.Tuple
+functionName from GHC.ExecutionStack.Internal
+gcastWith from Data.Type.Equality
+gcd from GHC.Real
+gcdInt' from GHC.Real
+gcdWord' from GHC.Real
+genericDrop from Data.OldList
+genericLength from Data.OldList
+genericReplicate from Data.OldList
+genericSplitAt from Data.OldList
+genericTake from Data.OldList
+get from Control.Monad.State.Class
+getAll from Data.Monoid
+getAlt from Data.Monoid
+getAny from Data.Monoid
+getArgs from System.Environment
+getCallStack from GHC.Stack.Types
+getChanContents from Control.Concurrent.Chan
+getConst from Data.Functor.Const
+getContents from Data.Text.IO
+getDual from Data.Monoid
+getField from GHC.Records
+getFirst from Data.Monoid
+getLast from Data.Monoid
+getLine from Data.Text.IO
+getMaskingState from GHC.IO
+getNumCapabilities from GHC.Conc.Sync
+getOption from Data.Semigroup
+getProduct from Data.Monoid
+getStackTrace from GHC.ExecutionStack
+getSum from Data.Monoid
+getZipList from Control.Applicative
+gets from Control.Monad.State.Class
+group from Data.OldList
+groupBy from Data.OldList
+guard from Control.Monad
+guardM from Protolude.Bool
+guarded from Protolude
+guardedA from Protolude
+hPutStr from Protolude.Show
+hPutStrLn from Protolude.Show
+handle from Control.Exception.Base
+handleJust from Control.Exception.Base
+hash from Data.Hashable.Class
+hashUsing from Data.Hashable.Class
+hashWithSalt from Data.Hashable.Class
+head from Protolude.List
+headDef from Protolude.Safe
+headMay from Protolude.Safe
+hush from Protolude.Exceptions
+identity from Protolude
+ifM from Protolude.Bool
+ignore from Data.Text.Encoding.Error
+imagPart from Data.Complex
+infinity from GHC.Real
+initDef from Protolude.Safe
+initMay from Protolude.Safe
+initSafe from Protolude.Safe
+inits from Data.OldList
+integralEnumFrom from GHC.Real
+integralEnumFromThen from GHC.Real
+integralEnumFromThenTo from GHC.Real
+integralEnumFromTo from GHC.Real
+interact from Data.Text.IO
+intercalate from Data.OldList
+interruptible from GHC.IO
+intersperse from Data.OldList
+ioError from GHC.IO.Exception
+isCurrentThreadBound from Control.Concurrent
+isDenormalized from GHC.Float
+isEmptyChan from Control.Concurrent.Chan
+isEmptyMVar from GHC.MVar
+isIEEE from GHC.Float
+isInfinite from GHC.Float
+isJust from Data.Maybe
+isLeft from Data.Either
+isNaN from GHC.Float
+isNegativeZero from GHC.Float
+isNewtype from GHC.Generics
+isNothing from Data.Maybe
+isPrefixOf from Data.OldList
+isRight from Data.Either
+isSigned from Data.Bits
+iterate from GHC.List
+join from GHC.Base
+killThread from GHC.Conc.Sync
+lastDef from Protolude.Safe
+lastMay from Protolude.Safe
+lcm from GHC.Real
+leftToMaybe from Protolude.Either
+lefts from Data.Either
+length from Data.Foldable
+lenientDecode from Data.Text.Encoding.Error
+lift from Control.Monad.Trans.Class
+liftA from GHC.Base
+liftA2 from GHC.Base
+liftA3 from GHC.Base
+liftAA2 from Protolude.Applicative
+liftIO from Control.Monad.IO.Class
+liftIO1 from Protolude
+liftIO2 from Protolude
+liftM from GHC.Base
+liftM' from Protolude.Monad
+liftM2 from GHC.Base
+liftM2' from Protolude.Monad
+liftM3 from GHC.Base
+liftM4 from GHC.Base
+liftM5 from GHC.Base
+lines from Data.Text
+link from Control.Concurrent.Async
+link2 from Control.Concurrent.Async
+list from Protolude.List
+listToMaybe from Data.Maybe
+local from Control.Monad.Reader.Class
+log from GHC.Float
+log1mexp from GHC.Float
+log1p from GHC.Float
+log1pexp from GHC.Float
+logBase from GHC.Float
+magnitude from Data.Complex
+many from GHC.Base
+map from Protolude
+mapAccumL from Data.Traversable
+mapAccumR from Data.Traversable
+mapAndUnzipM from Control.Monad
+mapExcept from Control.Monad.Trans.Except
+mapExceptT from Control.Monad.Trans.Except
+mapException from Control.Exception.Base
+mapM from Data.Traversable
+mapM_ from Data.Foldable
+mapMaybe from Data.Maybe
+mappend from GHC.Base
+mask from GHC.IO
+mask_ from GHC.IO
+max from GHC.Classes
+maxBound from GHC.Enum
+maxInt from GHC.Base
+maximum from Data.Foldable
+maximumBy from Data.Foldable
+maximumDef from Protolude.Safe
+maximumMay from Protolude.Safe
+maybe from Data.Maybe
+maybeEmpty from Protolude.Either
+maybeToEither from Protolude.Either
+maybeToLeft from Protolude.Either
+maybeToList from Data.Maybe
+maybeToRight from Protolude.Either
+mconcat from GHC.Base
+mempty from GHC.Base
+mfilter from Control.Monad
+min from GHC.Classes
+minBound from GHC.Enum
+minInt from GHC.Base
+minimum from Data.Foldable
+minimumBy from Data.Foldable
+minimumDef from Protolude.Safe
+minimumMay from Protolude.Safe
+mkPolar from Data.Complex
+mkWeakMVar from Control.Concurrent.MVar
+mkWeakThreadId from GHC.Conc.Sync
+mod from GHC.Real
+modify from Control.Monad.State.Class
+modifyMVar from Control.Concurrent.MVar
+modifyMVarMasked from Control.Concurrent.MVar
+modifyMVarMasked_ from Control.Concurrent.MVar
+modifyMVar_ from Control.Concurrent.MVar
+moduleName from GHC.Generics
+mplus from GHC.Base
+msum from Data.Foldable
+mtimesDefault from Data.Semigroup
+myThreadId from GHC.Conc.Sync
+mzero from GHC.Base
+natVal from GHC.TypeLits
+negate from GHC.Num
+newChan from Control.Concurrent.Chan
+newEmptyMVar from GHC.MVar
+newMVar from GHC.MVar
+newQSem from Control.Concurrent.QSem
+newQSemN from Control.Concurrent.QSemN
+nonEmpty from Data.List.NonEmpty
+not from GHC.Classes
+notANumber from GHC.Real
+notElem from Data.Foldable
+notImplemented from Debug
+note from Protolude.Exceptions
+null from Data.Foldable
+numerator from GHC.Real
+numericEnumFrom from GHC.Real
+numericEnumFromThen from GHC.Real
+numericEnumFromThenTo from GHC.Real
+numericEnumFromTo from GHC.Real
+objectName from GHC.ExecutionStack.Internal
+odd from GHC.Real
+on from Data.Function
+onException from Control.Exception.Base
+one from Protolude.Semiring
+openFile from GHC.IO.Handle.FD
+option from Data.Semigroup
+optional from Control.Applicative
+or from Data.Foldable
+orAlt from Protolude.Applicative
+orElse from GHC.Conc.Sync
+orEmpty from Protolude.Applicative
+ord from GHC.Base
+ordNub from Protolude.List
+otherwise from GHC.Base
+overflowError from GHC.Real
+packageName from GHC.Generics
+panic from Protolude.Panic
+partitionEithers from Data.Either
+pass from Protolude
+permutations from Data.OldList
+phase from Data.Complex
+pi from GHC.Float
+polar from Data.Complex
+poll from Control.Concurrent.Async
+popCount from Data.Bits
+popCountDefault from Data.Bits
+pred from GHC.Enum
+prettyCallStack from GHC.Exception
+prettySrcLoc from GHC.Exception
+print from Protolude
+product from Protolude.List
+properFraction from GHC.Real
+pure from GHC.Base
+purer from Protolude.Applicative
+put from Control.Monad.State.Class
+putByteString from Protolude.Show
+putErrLn from Protolude.Show
+putErrText from Protolude.Show
+putLByteString from Protolude.Show
+putLText from Protolude.Show
+putMVar from GHC.MVar
+putStr from Protolude.Show
+putStrLn from Protolude.Show
+putText from Protolude.Show
+quot from GHC.Real
+quotRem from GHC.Real
+race from Control.Concurrent.Async
+race_ from Control.Concurrent.Async
+ratioPrec from GHC.Real
+ratioPrec1 from GHC.Real
+ratioZeroDenominatorError from GHC.Real
+readChan from Control.Concurrent.Chan
+readEither from Text.Read
+readFile from Data.Text.IO
+readMVar from GHC.MVar
+readMaybe from Text.Read
+reader from Control.Monad.Reader.Class
+reads from Text.Read
+realPart from Data.Complex
+realToFrac from GHC.Real
+recip from GHC.Real
+reduce from GHC.Real
+rem from GHC.Real
+repeat from GHC.List
+replace from Data.Text.Encoding.Error
+replicate from GHC.List
+replicateM from Control.Monad
+replicateM_ from Control.Monad
+repr from Data.Type.Coercion
+retry from GHC.Conc.Sync
+return from GHC.Base
+reverse from GHC.List
+rightToMaybe from Protolude.Either
+rights from Data.Either
+rnf from Control.DeepSeq
+rotate from Data.Bits
+rotateL from Data.Bits
+rotateR from Data.Bits
+round from GHC.Real
+rtsSupportsBoundThreads from Control.Concurrent
+runConcurrently from Control.Concurrent.Async
+runExcept from Control.Monad.Trans.Except
+runExceptT from Control.Monad.Trans.Except
+runIdentity from Data.Functor.Identity
+runInBoundThread from Control.Concurrent
+runInUnboundThread from Control.Concurrent
+runReader from Control.Monad.Trans.Reader
+runReaderT from Control.Monad.Trans.Reader
+runST from GHC.ST
+runState from Control.Monad.Trans.State.Lazy
+runStateT from Control.Monad.Trans.State.Lazy
+scaleFloat from GHC.Float
+scanl from GHC.List
+scanl' from GHC.List
+scanr from GHC.List
+sconcat from Data.Semigroup
+second from Data.Bifunctor
+selDecidedStrictness from GHC.Generics
+selName from GHC.Generics
+selSourceStrictness from GHC.Generics
+selSourceUnpackedness from GHC.Generics
+seq from GHC.Prim
+sequence from Data.Traversable
+sequenceA from Data.Traversable
+sequenceA_ from Data.Foldable
+sequence_ from Data.Foldable
+setBit from Data.Bits
+setNumCapabilities from GHC.Conc.Sync
+shift from Data.Bits
+shiftL from Data.Bits
+shiftR from Data.Bits
+show from Protolude
+showStackTrace from GHC.ExecutionStack
+signalQSem from Control.Concurrent.QSem
+signalQSemN from Control.Concurrent.QSemN
+significand from GHC.Float
+signum from GHC.Num
+sin from GHC.Float
+sinh from GHC.Float
+snd from Data.Tuple
+some from GHC.Base
+someNatVal from GHC.TypeLits
+someSymbolVal from GHC.TypeLits
+sort from Data.OldList
+sortBy from Data.OldList
+sortOn from Protolude.List
+sourceColumn from GHC.ExecutionStack.Internal
+sourceFile from GHC.ExecutionStack.Internal
+sourceLine from GHC.ExecutionStack.Internal
+splitAt from GHC.List
+sqrt from GHC.Float
+srcLoc from GHC.ExecutionStack.Internal
+state from Control.Monad.State.Class
+stderr from GHC.IO.Handle.FD
+stdin from GHC.IO.Handle.FD
+stdout from GHC.IO.Handle.FD
+stimes from Data.Semigroup
+stimesIdempotent from Data.Semigroup
+stimesIdempotentMonoid from Data.Semigroup
+stimesMonoid from Data.Semigroup
+strConv from Protolude.Conv
+strictDecode from Data.Text.Encoding.Error
+subsequences from Data.OldList
+subtract from GHC.Num
+succ from GHC.Enum
+sum from Protolude.List
+swap from Data.Tuple
+swapMVar from Control.Concurrent.MVar
+sym from Data.Type.Equality
+symbolVal from GHC.TypeLits
+tailDef from Protolude.Safe
+tailMay from Protolude.Safe
+tailSafe from Protolude.Safe
+tails from Data.OldList
+take from GHC.List
+takeMVar from GHC.MVar
+takeWhile from GHC.List
+tan from GHC.Float
+tanh from GHC.Float
+testBit from Data.Bits
+testBitDefault from Data.Bits
+threadCapability from GHC.Conc.Sync
+threadDelay from GHC.Conc.IO
+threadWaitRead from Control.Concurrent
+threadWaitReadSTM from Control.Concurrent
+threadWaitWrite from Control.Concurrent
+threadWaitWriteSTM from Control.Concurrent
+throwE from Control.Monad.Trans.Except
+throwError from Control.Monad.Error.Class
+throwIO from Protolude
+throwSTM from GHC.Conc.Sync
+throwTo from Protolude
+to from GHC.Generics
+toEnum from GHC.Enum
+toException from GHC.Exception
+toInteger from GHC.Real
+toIntegralSized from Data.Bits
+toList from Data.Foldable
+toRational from GHC.Real
+toS from Protolude.Conv
+toSL from Protolude.Conv
+toStrict from Data.Text.Lazy
+trace from Debug
+traceIO from Debug
+traceId from Debug
+traceM from Debug
+traceShow from Debug
+traceShowId from Debug
+traceShowM from Debug
+trans from Data.Type.Equality
+transpose from Data.OldList
+traverse from Data.Traversable
+traverse_ from Data.Foldable
+truncate from GHC.Real
+try from Control.Exception.Base
+tryIO from Protolude.Exceptions
+tryJust from Control.Exception.Base
+tryPutMVar from GHC.MVar
+tryReadMVar from GHC.MVar
+tryTakeMVar from GHC.MVar
+typeRep from Data.Typeable
+unComp1 from GHC.Generics
+unGetChan from Control.Concurrent.Chan
+unK1 from GHC.Generics
+unM1 from GHC.Generics
+uncons from Protolude
+uncurry from Data.Tuple
+undefined from Debug
+unfoldr from Data.OldList
+uninterruptibleMask from GHC.IO
+uninterruptibleMask_ from GHC.IO
+unless from Control.Monad
+unlessM from Protolude.Bool
+unlines from Data.Text
+unsnoc from Protolude
+until from GHC.Base
+unwords from Data.Text
+unzip from GHC.List
+vacuous from Data.Void
+void from Data.Functor
+wait from Control.Concurrent.Async
+waitAny from Control.Concurrent.Async
+waitAnyCancel from Control.Concurrent.Async
+waitAnyCatch from Control.Concurrent.Async
+waitAnyCatchCancel from Control.Concurrent.Async
+waitBoth from Control.Concurrent.Async
+waitCatch from Control.Concurrent.Async
+waitEither from Control.Concurrent.Async
+waitEitherCancel from Control.Concurrent.Async
+waitEitherCatch from Control.Concurrent.Async
+waitEitherCatchCancel from Control.Concurrent.Async
+waitEither_ from Control.Concurrent.Async
+waitQSem from Control.Concurrent.QSem
+waitQSemN from Control.Concurrent.QSemN
+when from GHC.Base
+whenM from Protolude.Bool
+withAsync from Control.Concurrent.Async
+withAsyncBound from Control.Concurrent.Async
+withAsyncOn from Control.Concurrent.Async
+withExcept from Control.Monad.Trans.Except
+withExceptT from Control.Monad.Trans.Except
+withFile from System.IO
+withFrozenCallStack from GHC.Stack
+withMVar from Control.Concurrent.MVar
+withMVarMasked from Control.Concurrent.MVar
+withState from Control.Monad.Trans.State.Lazy
+witness from Debug
+words from Data.Text
+writeChan from Control.Concurrent.Chan
+writeFile from Data.Text.IO
+writeList2Chan from Control.Concurrent.Chan
+xor from Data.Bits
+zero from Protolude.Semiring
+zeroBits from Data.Bits
+zip from GHC.List
+zipWith from GHC.List
+zipWithM from Control.Monad
+zipWithM_ from Control.Monad
+|| from GHC.Classes
+||^ from Protolude.Bool

export_lists/protolude-11.exports

@@ -0,0 +1,960 @@
+$ from GHC.Base
+$! from Protolude.Base
+$!! from Control.DeepSeq
+$> from Data.Functor
+% from GHC.Real
+& from Data.Function
+&& from GHC.Classes
+&&^ from Protolude.Bool
+* from GHC.Num
+* from GHC.Types
+** from GHC.Float
+*> from GHC.Base
++ from GHC.Num
+++ from GHC.Base
+- from GHC.Num
+. from GHC.Base
+.&. from Data.Bits
+.|. from Data.Bits
+/ from GHC.Real
+/= from GHC.Classes
+:% from GHC.Real
+:*: from GHC.Generics
+:*: from GHC.Generics
+:+ from Data.Complex
+:+: from GHC.Generics
+:.: from GHC.Generics
+:| from Data.List.NonEmpty
+:~: from Data.Type.Equality
+< from GHC.Classes
+<$ from GHC.Base
+<$!> from Control.Monad
+<$> from Data.Functor
+<&&> from Protolude.Bool
+<&> from Protolude.Functor
+<* from GHC.Base
+<**> from GHC.Base
+<*> from GHC.Base
+<.> from Protolude.Semiring
+<<$>> from Protolude.Functor
+<<*>> from Protolude.Applicative
+<= from GHC.Classes
+<=< from Control.Monad
+<> from Data.Monoid
+<|> from GHC.Base
+<||> from Protolude.Bool
+=<< from GHC.Base
+== from GHC.Classes
+== from Data.Type.Equality
+> from GHC.Classes
+>= from GHC.Classes
+>=> from Control.Monad
+>> from GHC.Base
+>>= from GHC.Base
+All from Data.Monoid
+All from Data.Monoid
+AllocationLimitExceeded from GHC.IO.Exception
+AllocationLimitExceeded from GHC.IO.Exception
+Alt from Data.Monoid
+Alt from Data.Monoid
+Alternative from GHC.Base
+Any from Data.Monoid
+Any from Data.Monoid
+AppendMode from GHC.IO.IOMode
+Applicative from GHC.Base
+ArithException from GHC.Exception
+ArrayException from GHC.IO.Exception
+AssertionFailed from GHC.IO.Exception
+AssertionFailed from GHC.IO.Exception
+Associativity from GHC.Generics
+Async from Control.Concurrent.Async
+AsyncException from GHC.IO.Exception
+Bifunctor from Data.Bifunctor
+Bits from Data.Bits
+BlockedIndefinitelyOnMVar from GHC.IO.Exception
+BlockedIndefinitelyOnMVar from GHC.IO.Exception
+BlockedIndefinitelyOnSTM from GHC.IO.Exception
+BlockedIndefinitelyOnSTM from GHC.IO.Exception
+Bool from GHC.Types
+Bounded from GHC.Enum
+ByteString from Data.ByteString.Internal
+C1 from GHC.Generics
+CallStack from GHC.Stack.Types
+Chan from Control.Concurrent.Chan
+Char from GHC.Types
+CmpNat from GHC.TypeNats
+Coercible from GHC.Types
+Coercion from Data.Type.Coercion
+Coercion from Data.Type.Coercion
+Comp1 from GHC.Generics
+CompactionFailed from GHC.IO.Exception
+CompactionFailed from GHC.IO.Exception
+Complex from Data.Complex
+Concurrently from Control.Concurrent.Async
+Concurrently from Control.Concurrent.Async
+Const from Data.Functor.Const
+Const from Data.Functor.Const
+Constraint from GHC.Types
+Constructor from GHC.Generics
+D# from GHC.Types
+D1 from GHC.Generics
+Datatype from GHC.Generics
+Deadlock from GHC.IO.Exception
+Deadlock from GHC.IO.Exception
+Denormal from GHC.Exception
+DivideByZero from GHC.Exception
+Double from GHC.Types
+Down from Data.Ord
+Down from Data.Ord
+Dual from Data.Monoid
+Dual from Data.Monoid
+EQ from GHC.Types
+Either from Data.Either
+Endo from Data.Monoid
+Endo from Data.Monoid
+Enum from GHC.Enum
+Eq from GHC.Classes
+ErrorCall from GHC.Exception
+ErrorCall from GHC.Exception
+ErrorCallWithLocation from GHC.Exception
+Except from Control.Monad.Trans.Except
+ExceptT from Control.Monad.Trans.Except
+ExceptT from Control.Monad.Trans.Except
+Exception from GHC.Exception
+ExitCode from GHC.IO.Exception
+ExitFailure from GHC.IO.Exception
+ExitSuccess from GHC.IO.Exception
+F# from GHC.Types
+False from GHC.Types
+FatalError from Protolude.Panic
+FatalError from Protolude.Panic
+FilePath from GHC.IO
+FiniteBits from Data.Bits
+First from Data.Monoid
+First from Data.Monoid
+Fixity from GHC.Generics
+FixityI from GHC.Generics
+Float from GHC.Types
+Floating from GHC.Float
+Foldable from Data.Foldable
+Fractional from GHC.Real
+FunPtr from GHC.Ptr
+Functor from GHC.Base
+GT from GHC.Types
+Generic from GHC.Generics
+Generic1 from GHC.Generics
+Handle from GHC.IO.Handle.Types
+HasCallStack from GHC.Stack.Types
+HasField from GHC.Records
+Hashable from Data.Hashable.Class
+HeapOverflow from GHC.IO.Exception
+IO from GHC.Types
+IOException from GHC.IO.Exception
+IOMode from GHC.IO.IOMode
+Identity from Data.Functor.Identity
+Identity from Data.Functor.Identity
+IndexOutOfBounds from GHC.IO.Exception
+Infix from GHC.Generics
+InfixI from GHC.Generics
+Int from GHC.Types
+Int16 from GHC.Int
+Int32 from GHC.Int
+Int64 from GHC.Int
+Int8 from GHC.Int
+IntMap from Data.IntMap.Internal
+IntPtr from Foreign.Ptr
+IntSet from Data.IntSet.Internal
+Integer from GHC.Integer.Type
+Integral from GHC.Real
+IsLabel from GHC.OverloadedLabels
+IsString from Data.String
+Just from GHC.Base
+K1 from GHC.Generics
+K1 from GHC.Generics
+KnownNat from GHC.TypeNats
+KnownSymbol from GHC.TypeLits
+L1 from GHC.Generics
+LByteString from Protolude
+LT from GHC.Types
+LText from Protolude
+Last from Data.Monoid
+Last from Data.Monoid
+Left from Data.Either
+LeftAssociative from GHC.Generics
+Leniency from Protolude.Conv
+Lenient from Protolude.Conv
+Location from GHC.ExecutionStack.Internal
+Location from GHC.ExecutionStack.Internal
+LossOfPrecision from GHC.Exception
+M1 from GHC.Generics
+M1 from GHC.Generics
+MVar from GHC.MVar
+Map from Data.Map.Internal
+MaskedInterruptible from GHC.IO
+MaskedUninterruptible from GHC.IO
+MaskingState from GHC.IO
+Maybe from GHC.Base
+Meta from GHC.Generics
+MetaCons from GHC.Generics
+MetaData from GHC.Generics
+MetaSel from GHC.Generics
+Monad from GHC.Base
+MonadError from Control.Monad.Error.Class
+MonadIO from Control.Monad.IO.Class
+MonadPlus from GHC.Base
+MonadReader from Control.Monad.Reader.Class
+MonadState from Control.Monad.State.Class
+Monoid from GHC.Base
+NFData from Control.DeepSeq
+Nat from GHC.Types
+NestedAtomically from Control.Exception.Base
+NestedAtomically from Control.Exception.Base
+NoMethodError from Control.Exception.Base
+NoMethodError from Control.Exception.Base
+NonEmpty from Data.List.NonEmpty
+NonTermination from Control.Exception.Base
+NonTermination from Control.Exception.Base
+NotAssociative from GHC.Generics
+Nothing from GHC.Base
+Num from GHC.Num
+OnDecodeError from Data.Text.Encoding.Error
+OnError from Data.Text.Encoding.Error
+Option from Data.Semigroup
+Option from Data.Semigroup
+Ord from GHC.Classes
+Ordering from GHC.Types
+Overflow from GHC.Exception
+PatternMatchFail from Control.Exception.Base
+PatternMatchFail from Control.Exception.Base
+Prefix from GHC.Generics
+PrefixI from GHC.Generics
+Print from Protolude.Show
+Product from Data.Monoid
+Product from Data.Monoid
+Proxy from Data.Proxy
+Proxy from Data.Proxy
+Ptr from GHC.Ptr
+QSem from Control.Concurrent.QSem
+QSemN from Control.Concurrent.QSemN
+R1 from GHC.Generics
+Ratio from GHC.Real
+RatioZeroDenominator from GHC.Exception
+Rational from GHC.Real
+Read from GHC.Read
+ReadMode from GHC.IO.IOMode
+ReadWriteMode from GHC.IO.IOMode
+Reader from Control.Monad.Trans.Reader
+ReaderT from Control.Monad.Trans.Reader
+ReaderT from Control.Monad.Trans.Reader
+Real from GHC.Real
+RealFloat from GHC.Float
+RealFrac from GHC.Real
+Rec0 from GHC.Generics
+RecConError from Control.Exception.Base
+RecConError from Control.Exception.Base
+RecSelError from Control.Exception.Base
+RecSelError from Control.Exception.Base
+RecUpdError from Control.Exception.Base
+RecUpdError from Control.Exception.Base
+Refl from Data.Type.Equality
+Rep from GHC.Generics
+Right from Data.Either
+RightAssociative from GHC.Generics
+S1 from GHC.Generics
+ST from GHC.ST
+STM from GHC.Conc.Sync
+Selector from GHC.Generics
+Semigroup from Data.Semigroup
+Semiring from Protolude.Semiring
+Seq from Data.Sequence.Internal
+Set from Data.Set.Internal
+Show from GHC.Show
+SomeAsyncException from GHC.IO.Exception
+SomeAsyncException from GHC.IO.Exception
+SomeException from GHC.Exception
+SomeException from GHC.Exception
+SomeNat from GHC.TypeNats
+SomeNat from GHC.TypeNats
+SomeSymbol from GHC.TypeLits
+SomeSymbol from GHC.TypeLits
+SrcLoc from GHC.ExecutionStack.Internal
+SrcLoc from GHC.ExecutionStack.Internal
+StablePtr from GHC.Stable
+StackOverflow from GHC.IO.Exception
+State from Control.Monad.Trans.State.Lazy
+StateT from Control.Monad.Trans.State.Lazy
+StateT from Control.Monad.Trans.State.Lazy
+StaticPtr from GHC.StaticPtr
+Storable from Foreign.Storable
+Strict from Protolude.Conv
+StringConv from Protolude.Conv
+Sum from Data.Monoid
+Sum from Data.Monoid
+Symbol from GHC.Types
+Text from Data.Text.Internal
+ThreadId from GHC.Conc.Sync
+ThreadKilled from GHC.IO.Exception
+Traversable from Data.Traversable
+True from GHC.Types
+Type from GHC.Types
+TypeError from Control.Exception.Base
+TypeError from Control.Exception.Base
+TypeRep from Data.Typeable
+Typeable from Data.Typeable.Internal
+U1 from GHC.Generics
+U1 from GHC.Generics
+URec from GHC.Generics
+UndefinedElement from GHC.IO.Exception
+Underflow from GHC.Exception
+UnicodeException from Data.Text.Encoding.Error
+Unmasked from GHC.IO
+UserInterrupt from GHC.IO.Exception
+V1 from GHC.Generics
+Void from Data.Void
+Word from GHC.Types
+Word16 from GHC.Word
+Word32 from GHC.Word
+Word64 from GHC.Word
+Word8 from GHC.Word
+WordPtr from Foreign.Ptr
+WrappedMonoid from Data.Semigroup
+WriteMode from GHC.IO.IOMode
+ZipList from Control.Applicative
+ZipList from Control.Applicative
+^ from GHC.Real
+^%^ from GHC.Real
+^^ from GHC.Real
+^^%^^ from GHC.Real
+abs from GHC.Num
+absurd from Data.Void
+acos from GHC.Float
+acosh from GHC.Float
+addMVarFinalizer from Control.Concurrent.MVar
+all from Data.Foldable
+allowInterrupt from Control.Exception
+always from GHC.Conc.Sync
+alwaysSucceeds from GHC.Conc.Sync
+and from Data.Foldable
+any from Data.Foldable
+ap from GHC.Base
+appEndo from Data.Monoid
+appendFile from Data.Text.IO
+applyN from Protolude
+asTypeOf from GHC.Base
+asin from GHC.Float
+asinh from GHC.Float
+ask from Control.Monad.Reader.Class
+asks from Control.Monad.Reader.Class
+asum from Data.Foldable
+async from Control.Concurrent.Async
+asyncBound from Control.Concurrent.Async
+asyncExceptionFromException from GHC.IO.Exception
+asyncExceptionToException from GHC.IO.Exception
+asyncOn from Control.Concurrent.Async
+asyncThreadId from Control.Concurrent.Async
+atDef from Protolude.Safe
+atMay from Protolude.Safe
+atan from GHC.Float
+atan2 from GHC.Float
+atanh from GHC.Float
+atomically from GHC.Conc.Sync
+bimap from Data.Bifunctor
+bit from Data.Bits
+bitDefault from Data.Bits
+bitSize from Data.Bits
+bitSizeMaybe from Data.Bits
+bool from Protolude.Bool
+boundedEnumFrom from GHC.Enum
+boundedEnumFromThen from GHC.Enum
+bracket from Control.Exception.Base
+bracketOnError from Control.Exception.Base
+bracket_ from Control.Exception.Base
+break from GHC.List
+byteSwap16 from GHC.Word
+byteSwap32 from GHC.Word
+byteSwap64 from GHC.Word
+callStack from GHC.Stack
+cancel from Control.Concurrent.Async
+cancelWith from Control.Concurrent.Async
+cast from Data.Typeable
+castWith from Data.Type.Equality
+catMaybes from Data.Maybe
+catch from GHC.IO
+catchE from Control.Monad.Trans.Except
+catchError from Control.Monad.Error.Class
+catchJust from Control.Exception.Base
+catchSTM from GHC.Conc.Sync
+catches from Control.Exception
+ceiling from GHC.Real
+check from Control.Monad.STM
+chr from GHC.Char
+cis from Data.Complex
+clearBit from Data.Bits
+coerceWith from Data.Type.Coercion
+compare from GHC.Classes
+comparing from Data.Ord
+complement from Data.Bits
+complementBit from Data.Bits
+conFixity from GHC.Generics
+conIsRecord from GHC.Generics
+conName from GHC.Generics
+concat from Data.Foldable
+concatMap from Data.Foldable
+concatMapM from Protolude.Monad
+concurrently from Control.Concurrent.Async
+conjugate from Data.Complex
+const from GHC.Base
+cos from GHC.Float
+cosh from GHC.Float
+countLeadingZeros from Data.Bits
+countTrailingZeros from Data.Bits
+currentCallStack from GHC.Stack.CCS
+curry from Data.Tuple
+cycle from GHC.List
+cycle1 from Data.Semigroup
+datatypeName from GHC.Generics
+decodeFloat from GHC.Float
+decodeUtf8 from Data.Text.Encoding
+decodeUtf8' from Data.Text.Encoding
+decodeUtf8With from Data.Text.Encoding
+deepseq from Control.DeepSeq
+denominator from GHC.Real
+die from Protolude
+diff from Data.Semigroup
+displayException from GHC.Exception
+div from GHC.Real
+divMod from GHC.Real
+divZeroError from GHC.Real
+drop from GHC.List
+dropWhile from GHC.List
+dupChan from Control.Concurrent.Chan
+either from Data.Either
+eitherA from Protolude.Applicative
+elem from Data.Foldable
+empty from GHC.Base
+encodeFloat from GHC.Float
+encodeUtf8 from Data.Text.Encoding
+enumFrom from GHC.Enum
+enumFromThen from GHC.Enum
+enumFromThenTo from GHC.Enum
+enumFromTo from GHC.Enum
+eqT from Data.Typeable
+evalState from Control.Monad.Trans.State.Lazy
+evalStateT from Control.Monad.Trans.State.Lazy
+evaluate from GHC.IO
+even from GHC.Real
+execState from Control.Monad.Trans.State.Lazy
+execStateT from Control.Monad.Trans.State.Lazy
+exitFailure from System.Exit
+exitSuccess from System.Exit
+exitWith from System.Exit
+exp from GHC.Float
+expm1 from GHC.Float
+exponent from GHC.Float
+fatalErrorMessage from Protolude.Panic
+filter from GHC.List
+filterM from Control.Monad
+finally from Control.Exception.Base
+find from Data.Foldable
+finiteBitSize from Data.Bits
+first from Data.Bifunctor
+fix from Data.Function
+fixST from GHC.ST
+flip from GHC.Base
+floatDigits from GHC.Float
+floatRadix from GHC.Float
+floatRange from GHC.Float
+floor from GHC.Real
+fmap from GHC.Base
+fmapDefault from Data.Traversable
+fold from Data.Foldable
+foldM from Control.Monad
+foldM_ from Control.Monad
+foldMap from Data.Foldable
+foldMapDefault from Data.Traversable
+foldl from Data.Foldable
+foldl' from Data.Foldable
+foldl1May from Protolude.Safe
+foldl1May' from Protolude.Safe
+foldlM from Data.Foldable
+foldr from Data.Foldable
+foldr' from Data.Foldable
+foldr1May from Protolude.Safe
+foldrM from Data.Foldable
+for from Data.Traversable
+forM from Data.Traversable
+forM_ from Data.Foldable
+for_ from Data.Foldable
+force from Control.DeepSeq
+foreach from Protolude.Functor
+forever from Control.Monad
+forkFinally from Control.Concurrent
+forkIO from GHC.Conc.Sync
+forkIOWithUnmask from GHC.Conc.Sync
+forkOS from Control.Concurrent
+forkOSWithUnmask from Control.Concurrent
+forkOn from GHC.Conc.Sync
+forkOnWithUnmask from GHC.Conc.Sync
+from from GHC.Generics
+fromEnum from GHC.Enum
+fromException from GHC.Exception
+fromInteger from GHC.Num
+fromIntegral from GHC.Real
+fromLabel from GHC.OverloadedLabels
+fromLeft from Data.Either
+fromMaybe from Data.Maybe
+fromRational from GHC.Real
+fromRight from Data.Either
+fromStrict from Data.Text.Lazy
+fst from Data.Tuple
+functionName from GHC.ExecutionStack.Internal
+gcastWith from Data.Type.Equality
+gcd from GHC.Real
+gcdInt' from GHC.Real
+gcdWord' from GHC.Real
+genericDrop from Data.OldList
+genericLength from Data.OldList
+genericReplicate from Data.OldList
+genericSplitAt from Data.OldList
+genericTake from Data.OldList
+get from Control.Monad.State.Class
+getAll from Data.Monoid
+getAlt from Data.Monoid
+getAny from Data.Monoid
+getArgs from System.Environment
+getCallStack from GHC.Stack.Types
+getChanContents from Control.Concurrent.Chan
+getConst from Data.Functor.Const
+getContents from Data.Text.IO
+getDual from Data.Monoid
+getField from GHC.Records
+getFirst from Data.Monoid
+getLast from Data.Monoid
+getLine from Data.Text.IO
+getMaskingState from GHC.IO
+getNumCapabilities from GHC.Conc.Sync
+getOption from Data.Semigroup
+getProduct from Data.Monoid
+getStackTrace from GHC.ExecutionStack
+getSum from Data.Monoid
+getZipList from Control.Applicative
+gets from Control.Monad.State.Class
+group from Data.OldList
+groupBy from Data.OldList
+guard from Control.Monad
+guardM from Protolude.Bool
+guarded from Protolude
+guardedA from Protolude
+hPutStr from Protolude.Show
+hPutStrLn from Protolude.Show
+handle from Control.Exception.Base
+handleJust from Control.Exception.Base
+hash from Data.Hashable.Class
+hashUsing from Data.Hashable.Class
+hashWithSalt from Data.Hashable.Class
+head from Protolude.List
+headDef from Protolude.Safe
+headMay from Protolude.Safe
+hush from Protolude.Exceptions
+identity from Protolude
+ifM from Protolude.Bool
+ignore from Data.Text.Encoding.Error
+imagPart from Data.Complex
+infinity from GHC.Real
+initDef from Protolude.Safe
+initMay from Protolude.Safe
+initSafe from Protolude.Safe
+inits from Data.OldList
+integralEnumFrom from GHC.Real
+integralEnumFromThen from GHC.Real
+integralEnumFromThenTo from GHC.Real
+integralEnumFromTo from GHC.Real
+interact from Data.Text.IO
+intercalate from Data.OldList
+interruptible from GHC.IO
+intersperse from Data.OldList
+ioError from GHC.IO.Exception
+isCurrentThreadBound from Control.Concurrent
+isDenormalized from GHC.Float
+isEmptyChan from Control.Concurrent.Chan
+isEmptyMVar from GHC.MVar
+isIEEE from GHC.Float
+isInfinite from GHC.Float
+isJust from Data.Maybe
+isLeft from Data.Either
+isNaN from GHC.Float
+isNegativeZero from GHC.Float
+isNewtype from GHC.Generics
+isNothing from Data.Maybe
+isPrefixOf from Data.OldList
+isRight from Data.Either
+isSigned from Data.Bits
+iterate from GHC.List
+join from GHC.Base
+killThread from GHC.Conc.Sync
+lastDef from Protolude.Safe
+lastMay from Protolude.Safe
+lcm from GHC.Real
+leftToMaybe from Protolude.Either
+lefts from Data.Either
+length from Data.Foldable
+lenientDecode from Data.Text.Encoding.Error
+lift from Control.Monad.Trans.Class
+liftA from GHC.Base
+liftA2 from GHC.Base
+liftA3 from GHC.Base
+liftAA2 from Protolude.Applicative
+liftIO from Control.Monad.IO.Class
+liftIO1 from Protolude
+liftIO2 from Protolude
+liftM from GHC.Base
+liftM' from Protolude.Monad
+liftM2 from GHC.Base
+liftM2' from Protolude.Monad
+liftM3 from GHC.Base
+liftM4 from GHC.Base
+liftM5 from GHC.Base
+lines from Data.Text
+link from Control.Concurrent.Async
+link2 from Control.Concurrent.Async
+list from Protolude.List
+listToMaybe from Data.Maybe
+local from Control.Monad.Reader.Class
+log from GHC.Float
+log1mexp from GHC.Float
+log1p from GHC.Float
+log1pexp from GHC.Float
+logBase from GHC.Float
+magnitude from Data.Complex
+many from GHC.Base
+map from Protolude
+mapAccumL from Data.Traversable
+mapAccumR from Data.Traversable
+mapAndUnzipM from Control.Monad
+mapExcept from Control.Monad.Trans.Except
+mapExceptT from Control.Monad.Trans.Except
+mapException from Control.Exception.Base
+mapM from Data.Traversable
+mapM_ from Data.Foldable
+mapMaybe from Data.Maybe
+mappend from GHC.Base
+mask from GHC.IO
+mask_ from GHC.IO
+max from GHC.Classes
+maxBound from GHC.Enum
+maxInt from GHC.Base
+maximum from Data.Foldable
+maximumBy from Data.Foldable
+maximumDef from Protolude.Safe
+maximumMay from Protolude.Safe
+maybe from Data.Maybe
+maybeEmpty from Protolude.Either
+maybeToEither from Protolude.Either
+maybeToLeft from Protolude.Either
+maybeToList from Data.Maybe
+maybeToRight from Protolude.Either
+mconcat from GHC.Base
+mempty from GHC.Base
+mfilter from Control.Monad
+min from GHC.Classes
+minBound from GHC.Enum
+minInt from GHC.Base
+minimum from Data.Foldable
+minimumBy from Data.Foldable
+minimumDef from Protolude.Safe
+minimumMay from Protolude.Safe
+mkPolar from Data.Complex
+mkWeakMVar from Control.Concurrent.MVar
+mkWeakThreadId from GHC.Conc.Sync
+mod from GHC.Real
+modify from Control.Monad.State.Class
+modifyMVar from Control.Concurrent.MVar
+modifyMVarMasked from Control.Concurrent.MVar
+modifyMVarMasked_ from Control.Concurrent.MVar
+modifyMVar_ from Control.Concurrent.MVar
+moduleName from GHC.Generics
+mplus from GHC.Base
+msum from Data.Foldable
+mtimesDefault from Data.Semigroup
+myThreadId from GHC.Conc.Sync
+mzero from GHC.Base
+natVal from GHC.TypeLits
+negate from GHC.Num
+newChan from Control.Concurrent.Chan
+newEmptyMVar from GHC.MVar
+newMVar from GHC.MVar
+newQSem from Control.Concurrent.QSem
+newQSemN from Control.Concurrent.QSemN
+nonEmpty from Data.List.NonEmpty
+not from GHC.Classes
+notANumber from GHC.Real
+notElem from Data.Foldable
+notImplemented from Debug
+note from Protolude.Exceptions
+null from Data.Foldable
+numerator from GHC.Real
+numericEnumFrom from GHC.Real
+numericEnumFromThen from GHC.Real
+numericEnumFromThenTo from GHC.Real
+numericEnumFromTo from GHC.Real
+objectName from GHC.ExecutionStack.Internal
+odd from GHC.Real
+on from Data.Function
+onException from Control.Exception.Base
+one from Protolude.Semiring
+openFile from GHC.IO.Handle.FD
+option from Data.Semigroup
+optional from Control.Applicative
+or from Data.Foldable
+orAlt from Protolude.Applicative
+orElse from GHC.Conc.Sync
+orEmpty from Protolude.Applicative
+ord from GHC.Base
+ordNub from Protolude.List
+otherwise from GHC.Base
+overflowError from GHC.Real
+packageName from GHC.Generics
+panic from Protolude.Panic
+partitionEithers from Data.Either
+pass from Protolude
+permutations from Data.OldList
+phase from Data.Complex
+pi from GHC.Float
+polar from Data.Complex
+poll from Control.Concurrent.Async
+popCount from Data.Bits
+popCountDefault from Data.Bits
+pred from GHC.Enum
+prettyCallStack from GHC.Exception
+prettySrcLoc from GHC.Exception
+print from Protolude
+product from Protolude.List
+properFraction from GHC.Real
+pure from GHC.Base
+purer from Protolude.Applicative
+put from Control.Monad.State.Class
+putByteString from Protolude.Show
+putErrLn from Protolude.Show
+putErrText from Protolude.Show
+putLByteString from Protolude.Show
+putLText from Protolude.Show
+putMVar from GHC.MVar
+putStr from Protolude.Show
+putStrLn from Protolude.Show
+putText from Protolude.Show
+quot from GHC.Real
+quotRem from GHC.Real
+race from Control.Concurrent.Async
+race_ from Control.Concurrent.Async
+ratioPrec from GHC.Real
+ratioPrec1 from GHC.Real
+ratioZeroDenominatorError from GHC.Real
+readChan from Control.Concurrent.Chan
+readEither from Text.Read
+readFile from Data.Text.IO
+readMVar from GHC.MVar
+readMaybe from Text.Read
+reader from Control.Monad.Reader.Class
+reads from Text.Read
+realPart from Data.Complex
+realToFrac from GHC.Real
+recip from GHC.Real
+reduce from GHC.Real
+rem from GHC.Real
+repeat from GHC.List
+replace from Data.Text.Encoding.Error
+replicate from GHC.List
+replicateM from Control.Monad
+replicateM_ from Control.Monad
+repr from Data.Type.Coercion
+retry from GHC.Conc.Sync
+return from GHC.Base
+reverse from GHC.List
+rightToMaybe from Protolude.Either
+rights from Data.Either
+rnf from Control.DeepSeq
+rotate from Data.Bits
+rotateL from Data.Bits
+rotateR from Data.Bits
+round from GHC.Real
+rtsSupportsBoundThreads from Control.Concurrent
+runConcurrently from Control.Concurrent.Async
+runExcept from Control.Monad.Trans.Except
+runExceptT from Control.Monad.Trans.Except
+runIdentity from Data.Functor.Identity
+runInBoundThread from Control.Concurrent
+runInUnboundThread from Control.Concurrent
+runReader from Control.Monad.Trans.Reader
+runReaderT from Control.Monad.Trans.Reader
+runST from GHC.ST
+runState from Control.Monad.Trans.State.Lazy
+runStateT from Control.Monad.Trans.State.Lazy
+scaleFloat from GHC.Float
+scanl from GHC.List
+scanl' from GHC.List
+scanr from GHC.List
+sconcat from Data.Semigroup
+second from Data.Bifunctor
+selDecidedStrictness from GHC.Generics
+selName from GHC.Generics
+selSourceStrictness from GHC.Generics
+selSourceUnpackedness from GHC.Generics
+seq from GHC.Prim
+sequence from Data.Traversable
+sequenceA from Data.Traversable
+sequenceA_ from Data.Foldable
+sequence_ from Data.Foldable
+setBit from Data.Bits
+setNumCapabilities from GHC.Conc.Sync
+shift from Data.Bits
+shiftL from Data.Bits
+shiftR from Data.Bits
+show from Protolude
+showStackTrace from GHC.ExecutionStack
+signalQSem from Control.Concurrent.QSem
+signalQSemN from Control.Concurrent.QSemN
+significand from GHC.Float
+signum from GHC.Num
+sin from GHC.Float
+sinh from GHC.Float
+snd from Data.Tuple
+some from GHC.Base
+someNatVal from GHC.TypeLits
+someSymbolVal from GHC.TypeLits
+sort from Data.OldList
+sortBy from Data.OldList
+sortOn from Protolude.List
+sourceColumn from GHC.ExecutionStack.Internal
+sourceFile from GHC.ExecutionStack.Internal
+sourceLine from GHC.ExecutionStack.Internal
+splitAt from GHC.List
+sqrt from GHC.Float
+srcLoc from GHC.ExecutionStack.Internal
+state from Control.Monad.State.Class
+stderr from GHC.IO.Handle.FD
+stdin from GHC.IO.Handle.FD
+stdout from GHC.IO.Handle.FD
+stimes from Data.Semigroup
+stimesIdempotent from Data.Semigroup
+stimesIdempotentMonoid from Data.Semigroup
+stimesMonoid from Data.Semigroup
+strConv from Protolude.Conv
+strictDecode from Data.Text.Encoding.Error
+subsequences from Data.OldList
+subtract from GHC.Num
+succ from GHC.Enum
+sum from Protolude.List
+swap from Data.Tuple
+swapMVar from Control.Concurrent.MVar
+sym from Data.Type.Equality
+symbolVal from GHC.TypeLits
+tailDef from Protolude.Safe
+tailMay from Protolude.Safe
+tailSafe from Protolude.Safe
+tails from Data.OldList
+take from GHC.List
+takeMVar from GHC.MVar
+takeWhile from GHC.List
+tan from GHC.Float
+tanh from GHC.Float
+testBit from Data.Bits
+testBitDefault from Data.Bits
+threadCapability from GHC.Conc.Sync
+threadDelay from GHC.Conc.IO
+threadWaitRead from Control.Concurrent
+threadWaitReadSTM from Control.Concurrent
+threadWaitWrite from Control.Concurrent
+threadWaitWriteSTM from Control.Concurrent
+throwE from Control.Monad.Trans.Except
+throwError from Control.Monad.Error.Class
+throwIO from Protolude
+throwSTM from GHC.Conc.Sync
+throwTo from Protolude
+to from GHC.Generics
+toEnum from GHC.Enum
+toException from GHC.Exception
+toInteger from GHC.Real
+toIntegralSized from Data.Bits
+toList from Data.Foldable
+toRational from GHC.Real
+toS from Protolude.Conv
+toSL from Protolude.Conv
+toStrict from Data.Text.Lazy
+trace from Debug
+traceIO from Debug
+traceId from Debug
+traceM from Debug
+traceShow from Debug
+traceShowId from Debug
+traceShowM from Debug
+trans from Data.Type.Equality
+transpose from Data.OldList
+traverse from Data.Traversable
+traverse_ from Data.Foldable
+truncate from GHC.Real
+try from Control.Exception.Base
+tryIO from Protolude.Exceptions
+tryJust from Control.Exception.Base
+tryPutMVar from GHC.MVar
+tryReadMVar from GHC.MVar
+tryTakeMVar from GHC.MVar
+typeRep from Data.Typeable
+unComp1 from GHC.Generics
+unGetChan from Control.Concurrent.Chan
+unK1 from GHC.Generics
+unM1 from GHC.Generics
+uncons from Protolude
+uncurry from Data.Tuple
+undefined from Debug
+unfoldr from Data.OldList
+uninterruptibleMask from GHC.IO
+uninterruptibleMask_ from GHC.IO
+unless from Control.Monad
+unlessM from Protolude.Bool
+unlines from Data.Text
+unsnoc from Protolude
+until from GHC.Base
+unwords from Data.Text
+unzip from GHC.List
+vacuous from Data.Void
+void from Data.Functor
+wait from Control.Concurrent.Async
+waitAny from Control.Concurrent.Async
+waitAnyCancel from Control.Concurrent.Async
+waitAnyCatch from Control.Concurrent.Async
+waitAnyCatchCancel from Control.Concurrent.Async
+waitBoth from Control.Concurrent.Async
+waitCatch from Control.Concurrent.Async
+waitEither from Control.Concurrent.Async
+waitEitherCancel from Control.Concurrent.Async
+waitEitherCatch from Control.Concurrent.Async
+waitEitherCatchCancel from Control.Concurrent.Async
+waitEither_ from Control.Concurrent.Async
+waitQSem from Control.Concurrent.QSem
+waitQSemN from Control.Concurrent.QSemN
+when from GHC.Base
+whenM from Protolude.Bool
+withAsync from Control.Concurrent.Async
+withAsyncBound from Control.Concurrent.Async
+withAsyncOn from Control.Concurrent.Async
+withExcept from Control.Monad.Trans.Except
+withExceptT from Control.Monad.Trans.Except
+withFile from System.IO
+withFrozenCallStack from GHC.Stack
+withMVar from Control.Concurrent.MVar
+withMVarMasked from Control.Concurrent.MVar
+withState from Control.Monad.Trans.State.Lazy
+witness from Debug
+words from Data.Text
+writeChan from Control.Concurrent.Chan
+writeFile from Data.Text.IO
+writeList2Chan from Control.Concurrent.Chan
+xor from Data.Bits
+zero from Protolude.Semiring
+zeroBits from Data.Bits
+zip from GHC.List
+zipWith from GHC.List
+zipWithM from Control.Monad
+zipWithM_ from Control.Monad
+|| from GHC.Classes
+||^ from Protolude.Bool

export_lists/protolude-12.exports

@@ -0,0 +1,958 @@
+$ from GHC.Base
+$! from Protolude.Base
+$!! from Control.DeepSeq
+$> from Data.Functor
+% from GHC.Real
+& from Data.Function
+&& from GHC.Classes
+&&^ from Protolude.Bool
+* from GHC.Num
+* from GHC.Types
+** from GHC.Float
+*> from GHC.Base
++ from GHC.Num
+++ from GHC.Base
+- from GHC.Num
+. from GHC.Base
+.&. from Data.Bits
+.|. from Data.Bits
+/ from GHC.Real
+/= from GHC.Classes
+:% from GHC.Real
+:*: from GHC.Generics
+:*: from GHC.Generics
+:+ from Data.Complex
+:+: from GHC.Generics
+:.: from GHC.Generics
+:| from GHC.Base
+:~: from Data.Type.Equality
+< from GHC.Classes
+<$ from GHC.Base
+<$!> from Control.Monad
+<$> from Data.Functor
+<&&> from Protolude.Bool
+<&> from Data.Functor
+<* from GHC.Base
+<**> from GHC.Base
+<*> from GHC.Base
+<.> from Protolude.Semiring
+<<$>> from Protolude.Functor
+<<*>> from Protolude.Applicative
+<= from GHC.Classes
+<=< from Control.Monad
+<> from GHC.Base
+<|> from GHC.Base
+<||> from Protolude.Bool
+=<< from GHC.Base
+== from GHC.Classes
+== from Data.Type.Equality
+> from GHC.Classes
+>= from GHC.Classes
+>=> from Control.Monad
+>> from GHC.Base
+>>= from GHC.Base
+All from Data.Semigroup.Internal
+All from Data.Semigroup.Internal
+AllocationLimitExceeded from GHC.IO.Exception
+AllocationLimitExceeded from GHC.IO.Exception
+Alt from Data.Semigroup.Internal
+Alt from Data.Semigroup.Internal
+Alternative from GHC.Base
+Any from Data.Semigroup.Internal
+Any from Data.Semigroup.Internal
+AppendMode from GHC.IO.IOMode
+Applicative from GHC.Base
+ArithException from GHC.Exception
+ArrayException from GHC.IO.Exception
+AssertionFailed from GHC.IO.Exception
+AssertionFailed from GHC.IO.Exception
+Associativity from GHC.Generics
+Async from Control.Concurrent.Async
+AsyncException from GHC.IO.Exception
+Bifunctor from Data.Bifunctor
+Bits from Data.Bits
+BlockedIndefinitelyOnMVar from GHC.IO.Exception
+BlockedIndefinitelyOnMVar from GHC.IO.Exception
+BlockedIndefinitelyOnSTM from GHC.IO.Exception
+BlockedIndefinitelyOnSTM from GHC.IO.Exception
+Bool from GHC.Types
+Bounded from GHC.Enum
+ByteString from Data.ByteString.Internal
+C1 from GHC.Generics
+CallStack from GHC.Stack.Types
+Chan from Control.Concurrent.Chan
+Char from GHC.Types
+CmpNat from GHC.TypeNats
+Coercible from GHC.Types
+Coercion from Data.Type.Coercion
+Coercion from Data.Type.Coercion
+Comp1 from GHC.Generics
+CompactionFailed from GHC.IO.Exception
+CompactionFailed from GHC.IO.Exception
+Complex from Data.Complex
+Concurrently from Control.Concurrent.Async
+Concurrently from Control.Concurrent.Async
+Const from Data.Functor.Const
+Const from Data.Functor.Const
+Constraint from GHC.Types
+Constructor from GHC.Generics
+D# from GHC.Types
+D1 from GHC.Generics
+Datatype from GHC.Generics
+Deadlock from GHC.IO.Exception
+Deadlock from GHC.IO.Exception
+Denormal from GHC.Exception
+DivideByZero from GHC.Exception
+Double from GHC.Types
+Down from Data.Ord
+Down from Data.Ord
+Dual from Data.Semigroup.Internal
+Dual from Data.Semigroup.Internal
+EQ from GHC.Types
+Either from Data.Either
+Endo from Data.Semigroup.Internal
+Endo from Data.Semigroup.Internal
+Enum from GHC.Enum
+Eq from GHC.Classes
+ErrorCall from GHC.Exception
+ErrorCall from GHC.Exception
+ErrorCallWithLocation from GHC.Exception
+Except from Control.Monad.Trans.Except
+ExceptT from Control.Monad.Trans.Except
+ExceptT from Control.Monad.Trans.Except
+Exception from GHC.Exception
+ExitCode from GHC.IO.Exception
+ExitFailure from GHC.IO.Exception
+ExitSuccess from GHC.IO.Exception
+F# from GHC.Types
+False from GHC.Types
+FatalError from Protolude.Panic
+FatalError from Protolude.Panic
+FilePath from GHC.IO
+FiniteBits from Data.Bits
+First from Data.Monoid
+First from Data.Monoid
+Fixity from GHC.Generics
+FixityI from GHC.Generics
+Float from GHC.Types
+Floating from GHC.Float
+Foldable from Data.Foldable
+Fractional from GHC.Real
+FunPtr from GHC.Ptr
+Functor from GHC.Base
+GT from GHC.Types
+Generic from GHC.Generics
+Generic1 from GHC.Generics
+Handle from GHC.IO.Handle.Types
+HasCallStack from GHC.Stack.Types
+HasField from GHC.Records
+Hashable from Data.Hashable.Class
+HeapOverflow from GHC.IO.Exception
+IO from GHC.Types
+IOException from GHC.IO.Exception
+IOMode from GHC.IO.IOMode
+Identity from Data.Functor.Identity
+Identity from Data.Functor.Identity
+IndexOutOfBounds from GHC.IO.Exception
+Infix from GHC.Generics
+InfixI from GHC.Generics
+Int from GHC.Types
+Int16 from GHC.Int
+Int32 from GHC.Int
+Int64 from GHC.Int
+Int8 from GHC.Int
+IntMap from Data.IntMap.Internal
+IntPtr from Foreign.Ptr
+IntSet from Data.IntSet.Internal
+Integer from GHC.Integer.Type
+Integral from GHC.Real
+IsLabel from GHC.OverloadedLabels
+IsString from Data.String
+Just from GHC.Base
+K1 from GHC.Generics
+K1 from GHC.Generics
+KnownNat from GHC.TypeNats
+KnownSymbol from GHC.TypeLits
+L1 from GHC.Generics
+LByteString from Protolude
+LT from GHC.Types
+LText from Protolude
+Last from Data.Monoid
+Last from Data.Monoid
+Left from Data.Either
+LeftAssociative from GHC.Generics
+Leniency from Protolude.Conv
+Lenient from Protolude.Conv
+Location from GHC.ExecutionStack.Internal
+Location from GHC.ExecutionStack.Internal
+LossOfPrecision from GHC.Exception
+M1 from GHC.Generics
+M1 from GHC.Generics
+MVar from GHC.MVar
+Map from Data.Map.Internal
+MaskedInterruptible from GHC.IO
+MaskedUninterruptible from GHC.IO
+MaskingState from GHC.IO
+Maybe from GHC.Base
+Meta from GHC.Generics
+MetaCons from GHC.Generics
+MetaData from GHC.Generics
+MetaSel from GHC.Generics
+Monad from GHC.Base
+MonadError from Control.Monad.Error.Class
+MonadIO from Control.Monad.IO.Class
+MonadPlus from GHC.Base
+MonadReader from Control.Monad.Reader.Class
+MonadState from Control.Monad.State.Class
+Monoid from GHC.Base
+NFData from Control.DeepSeq
+Nat from GHC.Types
+NestedAtomically from Control.Exception.Base
+NestedAtomically from Control.Exception.Base
+NoMethodError from Control.Exception.Base
+NoMethodError from Control.Exception.Base
+NonEmpty from GHC.Base
+NonTermination from Control.Exception.Base
+NonTermination from Control.Exception.Base
+NotAssociative from GHC.Generics
+Nothing from GHC.Base
+Num from GHC.Num
+OnDecodeError from Data.Text.Encoding.Error
+OnError from Data.Text.Encoding.Error
+Option from Data.Semigroup
+Option from Data.Semigroup
+Ord from GHC.Classes
+Ordering from GHC.Types
+Overflow from GHC.Exception
+PatternMatchFail from Control.Exception.Base
+PatternMatchFail from Control.Exception.Base
+Prefix from GHC.Generics
+PrefixI from GHC.Generics
+Print from Protolude.Show
+Product from Data.Semigroup.Internal
+Product from Data.Semigroup.Internal
+Proxy from Data.Proxy
+Proxy from Data.Proxy
+Ptr from GHC.Ptr
+QSem from Control.Concurrent.QSem
+QSemN from Control.Concurrent.QSemN
+R1 from GHC.Generics
+Ratio from GHC.Real
+RatioZeroDenominator from GHC.Exception
+Rational from GHC.Real
+Read from GHC.Read
+ReadMode from GHC.IO.IOMode
+ReadWriteMode from GHC.IO.IOMode
+Reader from Control.Monad.Trans.Reader
+ReaderT from Control.Monad.Trans.Reader
+ReaderT from Control.Monad.Trans.Reader
+Real from GHC.Real
+RealFloat from GHC.Float
+RealFrac from GHC.Real
+Rec0 from GHC.Generics
+RecConError from Control.Exception.Base
+RecConError from Control.Exception.Base
+RecSelError from Control.Exception.Base
+RecSelError from Control.Exception.Base
+RecUpdError from Control.Exception.Base
+RecUpdError from Control.Exception.Base
+Refl from Data.Type.Equality
+Rep from GHC.Generics
+Right from Data.Either
+RightAssociative from GHC.Generics
+S1 from GHC.Generics
+ST from GHC.ST
+STM from GHC.Conc.Sync
+Selector from GHC.Generics
+Semigroup from GHC.Base
+Semiring from Protolude.Semiring
+Seq from Data.Sequence.Internal
+Set from Data.Set.Internal
+Show from GHC.Show
+SomeAsyncException from GHC.IO.Exception
+SomeAsyncException from GHC.IO.Exception
+SomeException from GHC.Exception
+SomeException from GHC.Exception
+SomeNat from GHC.TypeNats
+SomeNat from GHC.TypeNats
+SomeSymbol from GHC.TypeLits
+SomeSymbol from GHC.TypeLits
+SrcLoc from GHC.ExecutionStack.Internal
+SrcLoc from GHC.ExecutionStack.Internal
+StablePtr from GHC.Stable
+StackOverflow from GHC.IO.Exception
+State from Control.Monad.Trans.State.Lazy
+StateT from Control.Monad.Trans.State.Lazy
+StateT from Control.Monad.Trans.State.Lazy
+StaticPtr from GHC.StaticPtr
+Storable from Foreign.Storable
+Strict from Protolude.Conv
+StringConv from Protolude.Conv
+Sum from Data.Semigroup.Internal
+Sum from Data.Semigroup.Internal
+Symbol from GHC.Types
+Text from Data.Text.Internal
+ThreadId from GHC.Conc.Sync
+ThreadKilled from GHC.IO.Exception
+Traversable from Data.Traversable
+True from GHC.Types
+Type from GHC.Types
+TypeError from Control.Exception.Base
+TypeError from Control.Exception.Base
+TypeRep from Data.Typeable
+Typeable from Data.Typeable.Internal
+U1 from GHC.Generics
+U1 from GHC.Generics
+URec from GHC.Generics
+UndefinedElement from GHC.IO.Exception
+Underflow from GHC.Exception
+UnicodeException from Data.Text.Encoding.Error
+Unmasked from GHC.IO
+UserInterrupt from GHC.IO.Exception
+V1 from GHC.Generics
+Void from Data.Void
+Word from GHC.Types
+Word16 from GHC.Word
+Word32 from GHC.Word
+Word64 from GHC.Word
+Word8 from GHC.Word
+WordPtr from Foreign.Ptr
+WrappedMonoid from Data.Semigroup
+WriteMode from GHC.IO.IOMode
+ZipList from Control.Applicative
+ZipList from Control.Applicative
+^ from GHC.Real
+^%^ from GHC.Real
+^^ from GHC.Real
+^^%^^ from GHC.Real
+abs from GHC.Num
+absurd from Data.Void
+acos from GHC.Float
+acosh from GHC.Float
+addMVarFinalizer from Control.Concurrent.MVar
+all from Data.Foldable
+allowInterrupt from Control.Exception
+always from GHC.Conc.Sync
+alwaysSucceeds from GHC.Conc.Sync
+and from Data.Foldable
+any from Data.Foldable
+ap from GHC.Base
+appEndo from Data.Semigroup.Internal
+appendFile from Data.Text.IO
+applyN from Protolude
+asTypeOf from GHC.Base
+asin from GHC.Float
+asinh from GHC.Float
+ask from Control.Monad.Reader.Class
+asks from Control.Monad.Reader.Class
+asum from Data.Foldable
+async from Control.Concurrent.Async
+asyncBound from Control.Concurrent.Async
+asyncExceptionFromException from GHC.IO.Exception
+asyncExceptionToException from GHC.IO.Exception
+asyncOn from Control.Concurrent.Async
+asyncThreadId from Control.Concurrent.Async
+atDef from Protolude.Safe
+atMay from Protolude.Safe
+atan from GHC.Float
+atan2 from GHC.Float
+atanh from GHC.Float
+atomically from GHC.Conc.Sync
+bimap from Data.Bifunctor
+bit from Data.Bits
+bitDefault from Data.Bits
+bitSize from Data.Bits
+bitSizeMaybe from Data.Bits
+bool from Protolude.Bool
+boundedEnumFrom from GHC.Enum
+boundedEnumFromThen from GHC.Enum
+bracket from Control.Exception.Base
+bracketOnError from Control.Exception.Base
+bracket_ from Control.Exception.Base
+break from GHC.List
+byteSwap16 from GHC.Word
+byteSwap32 from GHC.Word
+byteSwap64 from GHC.Word
+callStack from GHC.Stack
+cancel from Control.Concurrent.Async
+cancelWith from Control.Concurrent.Async
+cast from Data.Typeable
+castWith from Data.Type.Equality
+catMaybes from Data.Maybe
+catch from GHC.IO
+catchE from Control.Monad.Trans.Except
+catchError from Control.Monad.Error.Class
+catchJust from Control.Exception.Base
+catchSTM from GHC.Conc.Sync
+catches from Control.Exception
+ceiling from GHC.Real
+check from Control.Monad.STM
+chr from GHC.Char
+cis from Data.Complex
+clearBit from Data.Bits
+coerceWith from Data.Type.Coercion
+compare from GHC.Classes
+comparing from Data.Ord
+complement from Data.Bits
+complementBit from Data.Bits
+conFixity from GHC.Generics
+conIsRecord from GHC.Generics
+conName from GHC.Generics
+concat from Data.Foldable
+concatMap from Data.Foldable
+concatMapM from Protolude.Monad
+concurrently from Control.Concurrent.Async
+conjugate from Data.Complex
+const from GHC.Base
+cos from GHC.Float
+cosh from GHC.Float
+countLeadingZeros from Data.Bits
+countTrailingZeros from Data.Bits
+currentCallStack from GHC.Stack.CCS
+curry from Data.Tuple
+cycle from GHC.List
+cycle1 from Data.Semigroup
+datatypeName from GHC.Generics
+decodeFloat from GHC.Float
+decodeUtf8 from Data.Text.Encoding
+decodeUtf8' from Data.Text.Encoding
+decodeUtf8With from Data.Text.Encoding
+deepseq from Control.DeepSeq
+denominator from GHC.Real
+die from Protolude
+diff from Data.Semigroup
+displayException from GHC.Exception
+div from GHC.Real
+divMod from GHC.Real
+divZeroError from GHC.Real
+drop from GHC.List
+dropWhile from GHC.List
+dupChan from Control.Concurrent.Chan
+either from Data.Either
+eitherA from Protolude.Applicative
+elem from Data.Foldable
+empty from GHC.Base
+encodeFloat from GHC.Float
+encodeUtf8 from Data.Text.Encoding
+enumFrom from GHC.Enum
+enumFromThen from GHC.Enum
+enumFromThenTo from GHC.Enum
+enumFromTo from GHC.Enum
+eqT from Data.Typeable
+evalState from Control.Monad.Trans.State.Lazy
+evalStateT from Control.Monad.Trans.State.Lazy
+evaluate from GHC.IO
+even from GHC.Real
+execState from Control.Monad.Trans.State.Lazy
+execStateT from Control.Monad.Trans.State.Lazy
+exitFailure from System.Exit
+exitSuccess from System.Exit
+exitWith from System.Exit
+exp from GHC.Float
+expm1 from GHC.Float
+exponent from GHC.Float
+fatalErrorMessage from Protolude.Panic
+filter from GHC.List
+filterM from Control.Monad
+finally from Control.Exception.Base
+find from Data.Foldable
+finiteBitSize from Data.Bits
+first from Data.Bifunctor
+fix from Data.Function
+fixST from GHC.ST
+flip from GHC.Base
+floatDigits from GHC.Float
+floatRadix from GHC.Float
+floatRange from GHC.Float
+floor from GHC.Real
+fmap from GHC.Base
+fmapDefault from Data.Traversable
+fold from Data.Foldable
+foldM from Control.Monad
+foldM_ from Control.Monad
+foldMap from Data.Foldable
+foldMapDefault from Data.Traversable
+foldl from Data.Foldable
+foldl' from Data.Foldable
+foldl1May from Protolude.Safe
+foldl1May' from Protolude.Safe
+foldlM from Data.Foldable
+foldr from Data.Foldable
+foldr' from Data.Foldable
+foldr1May from Protolude.Safe
+foldrM from Data.Foldable
+for from Data.Traversable
+forM from Data.Traversable
+forM_ from Data.Foldable
+for_ from Data.Foldable
+force from Control.DeepSeq
+foreach from Protolude.Functor
+forever from Control.Monad
+forkFinally from Control.Concurrent
+forkIO from GHC.Conc.Sync
+forkIOWithUnmask from GHC.Conc.Sync
+forkOS from Control.Concurrent
+forkOSWithUnmask from Control.Concurrent
+forkOn from GHC.Conc.Sync
+forkOnWithUnmask from GHC.Conc.Sync
+from from GHC.Generics
+fromEnum from GHC.Enum
+fromException from GHC.Exception
+fromInteger from GHC.Num
+fromIntegral from GHC.Real
+fromLabel from GHC.OverloadedLabels
+fromLeft from Data.Either
+fromMaybe from Data.Maybe
+fromRational from GHC.Real
+fromRight from Data.Either
+fromStrict from Data.Text.Lazy
+fst from Data.Tuple
+functionName from GHC.ExecutionStack.Internal
+gcastWith from Data.Type.Equality
+gcd from GHC.Real
+gcdInt' from GHC.Real
+gcdWord' from GHC.Real
+genericDrop from Data.OldList
+genericLength from Data.OldList
+genericReplicate from Data.OldList
+genericSplitAt from Data.OldList
+genericTake from Data.OldList
+get from Control.Monad.State.Class
+getAll from Data.Semigroup.Internal
+getAlt from Data.Semigroup.Internal
+getAny from Data.Semigroup.Internal
+getArgs from System.Environment
+getCallStack from GHC.Stack.Types
+getChanContents from Control.Concurrent.Chan
+getConst from Data.Functor.Const
+getContents from Data.Text.IO
+getDual from Data.Semigroup.Internal
+getField from GHC.Records
+getFirst from Data.Monoid
+getLast from Data.Monoid
+getLine from Data.Text.IO
+getMaskingState from GHC.IO
+getNumCapabilities from GHC.Conc.Sync
+getOption from Data.Semigroup
+getProduct from Data.Semigroup.Internal
+getStackTrace from GHC.ExecutionStack
+getSum from Data.Semigroup.Internal
+getZipList from Control.Applicative
+gets from Control.Monad.State.Class
+group from Data.OldList
+groupBy from Data.OldList
+guard from Control.Monad
+guardM from Protolude.Bool
+guarded from Protolude
+guardedA from Protolude
+hPutStr from Protolude.Show
+hPutStrLn from Protolude.Show
+handle from Control.Exception.Base
+handleJust from Control.Exception.Base
+hash from Data.Hashable.Class
+hashUsing from Data.Hashable.Class
+hashWithSalt from Data.Hashable.Class
+head from Protolude.List
+headDef from Protolude.Safe
+headMay from Protolude.Safe
+hush from Protolude.Exceptions
+identity from Protolude
+ifM from Protolude.Bool
+ignore from Data.Text.Encoding.Error
+imagPart from Data.Complex
+infinity from GHC.Real
+initDef from Protolude.Safe
+initMay from Protolude.Safe
+initSafe from Protolude.Safe
+inits from Data.OldList
+integralEnumFrom from GHC.Real
+integralEnumFromThen from GHC.Real
+integralEnumFromThenTo from GHC.Real
+integralEnumFromTo from GHC.Real
+interact from Data.Text.IO
+intercalate from Data.OldList
+interruptible from GHC.IO
+intersperse from Data.OldList
+ioError from GHC.IO.Exception
+isCurrentThreadBound from Control.Concurrent
+isDenormalized from GHC.Float
+isEmptyMVar from GHC.MVar
+isIEEE from GHC.Float
+isInfinite from GHC.Float
+isJust from Data.Maybe
+isLeft from Data.Either
+isNaN from GHC.Float
+isNegativeZero from GHC.Float
+isNewtype from GHC.Generics
+isNothing from Data.Maybe
+isPrefixOf from Data.OldList
+isRight from Data.Either
+isSigned from Data.Bits
+iterate from GHC.List
+join from GHC.Base
+killThread from GHC.Conc.Sync
+lastDef from Protolude.Safe
+lastMay from Protolude.Safe
+lcm from GHC.Real
+leftToMaybe from Protolude.Either
+lefts from Data.Either
+length from Data.Foldable
+lenientDecode from Data.Text.Encoding.Error
+lift from Control.Monad.Trans.Class
+liftA from GHC.Base
+liftA2 from GHC.Base
+liftA3 from GHC.Base
+liftAA2 from Protolude.Applicative
+liftIO from Control.Monad.IO.Class
+liftIO1 from Protolude
+liftIO2 from Protolude
+liftM from GHC.Base
+liftM' from Protolude.Monad
+liftM2 from GHC.Base
+liftM2' from Protolude.Monad
+liftM3 from GHC.Base
+liftM4 from GHC.Base
+liftM5 from GHC.Base
+lines from Data.Text
+link from Control.Concurrent.Async
+link2 from Control.Concurrent.Async
+list from Protolude.List
+listToMaybe from Data.Maybe
+local from Control.Monad.Reader.Class
+log from GHC.Float
+log1mexp from GHC.Float
+log1p from GHC.Float
+log1pexp from GHC.Float
+logBase from GHC.Float
+magnitude from Data.Complex
+many from GHC.Base
+map from Protolude
+mapAccumL from Data.Traversable
+mapAccumR from Data.Traversable
+mapAndUnzipM from Control.Monad
+mapExcept from Control.Monad.Trans.Except
+mapExceptT from Control.Monad.Trans.Except
+mapException from Control.Exception.Base
+mapM from Data.Traversable
+mapM_ from Data.Foldable
+mapMaybe from Data.Maybe
+mappend from GHC.Base
+mask from GHC.IO
+mask_ from GHC.IO
+max from GHC.Classes
+maxBound from GHC.Enum
+maxInt from GHC.Base
+maximum from Data.Foldable
+maximumBy from Data.Foldable
+maximumDef from Protolude.Safe
+maximumMay from Protolude.Safe
+maybe from Data.Maybe
+maybeEmpty from Protolude.Either
+maybeToEither from Protolude.Either
+maybeToLeft from Protolude.Either
+maybeToList from Data.Maybe
+maybeToRight from Protolude.Either
+mconcat from GHC.Base
+mempty from GHC.Base
+mfilter from Control.Monad
+min from GHC.Classes
+minBound from GHC.Enum
+minInt from GHC.Base
+minimum from Data.Foldable
+minimumBy from Data.Foldable
+minimumDef from Protolude.Safe
+minimumMay from Protolude.Safe
+mkPolar from Data.Complex
+mkWeakMVar from Control.Concurrent.MVar
+mkWeakThreadId from GHC.Conc.Sync
+mod from GHC.Real
+modify from Control.Monad.State.Class
+modifyMVar from Control.Concurrent.MVar
+modifyMVarMasked from Control.Concurrent.MVar
+modifyMVarMasked_ from Control.Concurrent.MVar
+modifyMVar_ from Control.Concurrent.MVar
+moduleName from GHC.Generics
+mplus from GHC.Base
+msum from Data.Foldable
+mtimesDefault from Data.Semigroup
+myThreadId from GHC.Conc.Sync
+mzero from GHC.Base
+natVal from GHC.TypeLits
+negate from GHC.Num
+newChan from Control.Concurrent.Chan
+newEmptyMVar from GHC.MVar
+newMVar from GHC.MVar
+newQSem from Control.Concurrent.QSem
+newQSemN from Control.Concurrent.QSemN
+nonEmpty from Data.List.NonEmpty
+not from GHC.Classes
+notANumber from GHC.Real
+notElem from Data.Foldable
+notImplemented from Debug
+note from Protolude.Exceptions
+null from Data.Foldable
+numerator from GHC.Real
+numericEnumFrom from GHC.Real
+numericEnumFromThen from GHC.Real
+numericEnumFromThenTo from GHC.Real
+numericEnumFromTo from GHC.Real
+objectName from GHC.ExecutionStack.Internal
+odd from GHC.Real
+on from Data.Function
+onException from Control.Exception.Base
+one from Protolude.Semiring
+openFile from GHC.IO.Handle.FD
+option from Data.Semigroup
+optional from Control.Applicative
+or from Data.Foldable
+orAlt from Protolude.Applicative
+orElse from GHC.Conc.Sync
+orEmpty from Protolude.Applicative
+ord from GHC.Base
+ordNub from Protolude.List
+otherwise from GHC.Base
+overflowError from GHC.Real
+packageName from GHC.Generics
+panic from Protolude.Panic
+partitionEithers from Data.Either
+pass from Protolude
+permutations from Data.OldList
+phase from Data.Complex
+pi from GHC.Float
+polar from Data.Complex
+poll from Control.Concurrent.Async
+popCount from Data.Bits
+popCountDefault from Data.Bits
+pred from GHC.Enum
+prettyCallStack from GHC.Exception
+prettySrcLoc from GHC.Exception
+print from Protolude
+product from Protolude.List
+properFraction from GHC.Real
+pure from GHC.Base
+purer from Protolude.Applicative
+put from Control.Monad.State.Class
+putByteString from Protolude.Show
+putErrLn from Protolude.Show
+putErrText from Protolude.Show
+putLByteString from Protolude.Show
+putLText from Protolude.Show
+putMVar from GHC.MVar
+putStr from Protolude.Show
+putStrLn from Protolude.Show
+putText from Protolude.Show
+quot from GHC.Real
+quotRem from GHC.Real
+race from Control.Concurrent.Async
+race_ from Control.Concurrent.Async
+ratioPrec from GHC.Real
+ratioPrec1 from GHC.Real
+ratioZeroDenominatorError from GHC.Real
+readChan from Control.Concurrent.Chan
+readEither from Text.Read
+readFile from Data.Text.IO
+readMVar from GHC.MVar
+readMaybe from Text.Read
+reader from Control.Monad.Reader.Class
+reads from Text.Read
+realPart from Data.Complex
+realToFrac from GHC.Real
+recip from GHC.Real
+reduce from GHC.Real
+rem from GHC.Real
+repeat from GHC.List
+replace from Data.Text.Encoding.Error
+replicate from GHC.List
+replicateM from Control.Monad
+replicateM_ from Control.Monad
+repr from Data.Type.Coercion
+retry from GHC.Conc.Sync
+return from GHC.Base
+reverse from GHC.List
+rightToMaybe from Protolude.Either
+rights from Data.Either
+rnf from Control.DeepSeq
+rotate from Data.Bits
+rotateL from Data.Bits
+rotateR from Data.Bits
+round from GHC.Real
+rtsSupportsBoundThreads from Control.Concurrent
+runConcurrently from Control.Concurrent.Async
+runExcept from Control.Monad.Trans.Except
+runExceptT from Control.Monad.Trans.Except
+runIdentity from Data.Functor.Identity
+runInBoundThread from Control.Concurrent
+runInUnboundThread from Control.Concurrent
+runReader from Control.Monad.Trans.Reader
+runReaderT from Control.Monad.Trans.Reader
+runST from GHC.ST
+runState from Control.Monad.Trans.State.Lazy
+runStateT from Control.Monad.Trans.State.Lazy
+scaleFloat from GHC.Float
+scanl from GHC.List
+scanl' from GHC.List
+scanr from GHC.List
+sconcat from GHC.Base
+second from Data.Bifunctor
+selDecidedStrictness from GHC.Generics
+selName from GHC.Generics
+selSourceStrictness from GHC.Generics
+selSourceUnpackedness from GHC.Generics
+seq from GHC.Prim
+sequence from Data.Traversable
+sequenceA from Data.Traversable
+sequenceA_ from Data.Foldable
+sequence_ from Data.Foldable
+setBit from Data.Bits
+setNumCapabilities from GHC.Conc.Sync
+shift from Data.Bits
+shiftL from Data.Bits
+shiftR from Data.Bits
+show from Protolude
+showStackTrace from GHC.ExecutionStack
+signalQSem from Control.Concurrent.QSem
+signalQSemN from Control.Concurrent.QSemN
+significand from GHC.Float
+signum from GHC.Num
+sin from GHC.Float
+sinh from GHC.Float
+snd from Data.Tuple
+some from GHC.Base
+someNatVal from GHC.TypeLits
+someSymbolVal from GHC.TypeLits
+sort from Data.OldList
+sortBy from Data.OldList
+sortOn from Protolude.List
+sourceColumn from GHC.ExecutionStack.Internal
+sourceFile from GHC.ExecutionStack.Internal
+sourceLine from GHC.ExecutionStack.Internal
+splitAt from GHC.List
+sqrt from GHC.Float
+srcLoc from GHC.ExecutionStack.Internal
+state from Control.Monad.State.Class
+stderr from GHC.IO.Handle.FD
+stdin from GHC.IO.Handle.FD
+stdout from GHC.IO.Handle.FD
+stimes from GHC.Base
+stimesIdempotent from Data.Semigroup.Internal
+stimesIdempotentMonoid from Data.Semigroup.Internal
+stimesMonoid from Data.Semigroup.Internal
+strConv from Protolude.Conv
+strictDecode from Data.Text.Encoding.Error
+subsequences from Data.OldList
+subtract from GHC.Num
+succ from GHC.Enum
+sum from Protolude.List
+swap from Data.Tuple
+swapMVar from Control.Concurrent.MVar
+sym from Data.Type.Equality
+symbolVal from GHC.TypeLits
+tailDef from Protolude.Safe
+tailMay from Protolude.Safe
+tailSafe from Protolude.Safe
+tails from Data.OldList
+take from GHC.List
+takeMVar from GHC.MVar
+takeWhile from GHC.List
+tan from GHC.Float
+tanh from GHC.Float
+testBit from Data.Bits
+testBitDefault from Data.Bits
+threadCapability from GHC.Conc.Sync
+threadDelay from GHC.Conc.IO
+threadWaitRead from Control.Concurrent
+threadWaitReadSTM from Control.Concurrent
+threadWaitWrite from Control.Concurrent
+threadWaitWriteSTM from Control.Concurrent
+throwE from Control.Monad.Trans.Except
+throwError from Control.Monad.Error.Class
+throwIO from Protolude
+throwSTM from GHC.Conc.Sync
+throwTo from Protolude
+to from GHC.Generics
+toEnum from GHC.Enum
+toException from GHC.Exception
+toInteger from GHC.Real
+toIntegralSized from Data.Bits
+toList from Data.Foldable
+toRational from GHC.Real
+toS from Protolude.Conv
+toSL from Protolude.Conv
+toStrict from Data.Text.Lazy
+trace from Debug
+traceIO from Debug
+traceId from Debug
+traceM from Debug
+traceShow from Debug
+traceShowId from Debug
+traceShowM from Debug
+trans from Data.Type.Equality
+transpose from Data.OldList
+traverse from Data.Traversable
+traverse_ from Data.Foldable
+truncate from GHC.Real
+try from Control.Exception.Base
+tryIO from Protolude.Exceptions
+tryJust from Control.Exception.Base
+tryPutMVar from GHC.MVar
+tryReadMVar from GHC.MVar
+tryTakeMVar from GHC.MVar
+typeRep from Data.Typeable
+unComp1 from GHC.Generics
+unK1 from GHC.Generics
+unM1 from GHC.Generics
+uncons from Protolude
+uncurry from Data.Tuple
+undefined from Debug
+unfoldr from Data.OldList
+uninterruptibleMask from GHC.IO
+uninterruptibleMask_ from GHC.IO
+unless from Control.Monad
+unlessM from Protolude.Bool
+unlines from Data.Text
+unsnoc from Protolude
+until from GHC.Base
+unwords from Data.Text
+unzip from GHC.List
+vacuous from Data.Void
+void from Data.Functor
+wait from Control.Concurrent.Async
+waitAny from Control.Concurrent.Async
+waitAnyCancel from Control.Concurrent.Async
+waitAnyCatch from Control.Concurrent.Async
+waitAnyCatchCancel from Control.Concurrent.Async
+waitBoth from Control.Concurrent.Async
+waitCatch from Control.Concurrent.Async
+waitEither from Control.Concurrent.Async
+waitEitherCancel from Control.Concurrent.Async
+waitEitherCatch from Control.Concurrent.Async
+waitEitherCatchCancel from Control.Concurrent.Async
+waitEither_ from Control.Concurrent.Async
+waitQSem from Control.Concurrent.QSem
+waitQSemN from Control.Concurrent.QSemN
+when from GHC.Base
+whenM from Protolude.Bool
+withAsync from Control.Concurrent.Async
+withAsyncBound from Control.Concurrent.Async
+withAsyncOn from Control.Concurrent.Async
+withExcept from Control.Monad.Trans.Except
+withExceptT from Control.Monad.Trans.Except
+withFile from System.IO
+withFrozenCallStack from GHC.Stack
+withMVar from Control.Concurrent.MVar
+withMVarMasked from Control.Concurrent.MVar
+withState from Control.Monad.Trans.State.Lazy
+witness from Debug
+words from Data.Text
+writeChan from Control.Concurrent.Chan
+writeFile from Data.Text.IO
+writeList2Chan from Control.Concurrent.Chan
+xor from Data.Bits
+zero from Protolude.Semiring
+zeroBits from Data.Bits
+zip from GHC.List
+zipWith from GHC.List
+zipWithM from Control.Monad
+zipWithM_ from Control.Monad
+|| from GHC.Classes
+||^ from Protolude.Bool

export_lists/protolude-13.exports

@@ -0,0 +1,959 @@
+$ from GHC.Base
+$! from Protolude.Base
+$!! from Control.DeepSeq
+$> from Data.Functor
+% from GHC.Real
+& from Data.Function
+&& from GHC.Classes
+&&^ from Protolude.Bool
+* from GHC.Num
+** from GHC.Float
+*> from GHC.Base
++ from GHC.Num
+++ from GHC.Base
+- from GHC.Num
+. from GHC.Base
+.&. from Data.Bits
+.|. from Data.Bits
+/ from GHC.Real
+/= from GHC.Classes
+:% from GHC.Real
+:*: from GHC.Generics
+:*: from GHC.Generics
+:+ from Data.Complex
+:+: from GHC.Generics
+:.: from GHC.Generics
+:| from GHC.Base
+:~: from Data.Type.Equality
+< from GHC.Classes
+<$ from GHC.Base
+<$!> from Control.Monad
+<$> from Data.Functor
+<&&> from Protolude.Bool
+<&> from Data.Functor
+<* from GHC.Base
+<**> from GHC.Base
+<*> from GHC.Base
+<.> from Protolude.Semiring
+<<$>> from Protolude.Functor
+<<*>> from Protolude.Applicative
+<= from GHC.Classes
+<=< from Control.Monad
+<> from GHC.Base
+<|> from GHC.Base
+<||> from Protolude.Bool
+=<< from GHC.Base
+== from GHC.Classes
+== from Data.Type.Equality
+> from GHC.Classes
+>= from GHC.Classes
+>=> from Control.Monad
+>> from GHC.Base
+>>= from GHC.Base
+All from Data.Semigroup.Internal
+All from Data.Semigroup.Internal
+AllocationLimitExceeded from GHC.IO.Exception
+AllocationLimitExceeded from GHC.IO.Exception
+Alt from Data.Semigroup.Internal
+Alt from Data.Semigroup.Internal
+Alternative from GHC.Base
+Any from Data.Semigroup.Internal
+Any from Data.Semigroup.Internal
+Ap from Data.Monoid
+Ap from Data.Monoid
+AppendMode from GHC.IO.IOMode
+Applicative from GHC.Base
+ArithException from GHC.Exception.Type
+ArrayException from GHC.IO.Exception
+AssertionFailed from GHC.IO.Exception
+AssertionFailed from GHC.IO.Exception
+Associativity from GHC.Generics
+Async from Control.Concurrent.Async
+AsyncException from GHC.IO.Exception
+Bifunctor from Data.Bifunctor
+Bits from Data.Bits
+BlockedIndefinitelyOnMVar from GHC.IO.Exception
+BlockedIndefinitelyOnMVar from GHC.IO.Exception
+BlockedIndefinitelyOnSTM from GHC.IO.Exception
+BlockedIndefinitelyOnSTM from GHC.IO.Exception
+Bool from GHC.Types
+Bounded from GHC.Enum
+ByteString from Data.ByteString.Internal
+C1 from GHC.Generics
+CallStack from GHC.Stack.Types
+Chan from Control.Concurrent.Chan
+Char from GHC.Types
+CmpNat from GHC.TypeNats
+Coercible from GHC.Types
+Coercion from Data.Type.Coercion
+Coercion from Data.Type.Coercion
+Comp1 from GHC.Generics
+CompactionFailed from GHC.IO.Exception
+CompactionFailed from GHC.IO.Exception
+Complex from Data.Complex
+Concurrently from Control.Concurrent.Async
+Concurrently from Control.Concurrent.Async
+Const from Data.Functor.Const
+Const from Data.Functor.Const
+Constraint from GHC.Types
+Constructor from GHC.Generics
+D# from GHC.Types
+D1 from GHC.Generics
+Datatype from GHC.Generics
+Deadlock from GHC.IO.Exception
+Deadlock from GHC.IO.Exception
+Denormal from GHC.Exception.Type
+DivideByZero from GHC.Exception.Type
+Double from GHC.Types
+Down from Data.Ord
+Down from Data.Ord
+Dual from Data.Semigroup.Internal
+Dual from Data.Semigroup.Internal
+EQ from GHC.Types
+Either from Data.Either
+Endo from Data.Semigroup.Internal
+Endo from Data.Semigroup.Internal
+Enum from GHC.Enum
+Eq from GHC.Classes
+ErrorCall from GHC.Exception
+ErrorCall from GHC.Exception
+ErrorCallWithLocation from GHC.Exception
+Except from Control.Monad.Trans.Except
+ExceptT from Control.Monad.Trans.Except
+ExceptT from Control.Monad.Trans.Except
+Exception from GHC.Exception.Type
+ExitCode from GHC.IO.Exception
+ExitFailure from GHC.IO.Exception
+ExitSuccess from GHC.IO.Exception
+F# from GHC.Types
+False from GHC.Types
+FatalError from Protolude.Panic
+FatalError from Protolude.Panic
+FilePath from GHC.IO
+FiniteBits from Data.Bits
+First from Data.Monoid
+First from Data.Monoid
+Fixity from GHC.Generics
+FixityI from GHC.Generics
+Float from GHC.Types
+Floating from GHC.Float
+Foldable from Data.Foldable
+Fractional from GHC.Real
+FunPtr from GHC.Ptr
+Functor from GHC.Base
+GT from GHC.Types
+Generic from GHC.Generics
+Generic1 from GHC.Generics
+Handle from GHC.IO.Handle.Types
+HasCallStack from GHC.Stack.Types
+HasField from GHC.Records
+Hashable from Data.Hashable.Class
+HeapOverflow from GHC.IO.Exception
+IO from GHC.Types
+IOException from GHC.IO.Exception
+IOMode from GHC.IO.IOMode
+Identity from Data.Functor.Identity
+Identity from Data.Functor.Identity
+IndexOutOfBounds from GHC.IO.Exception
+Infix from GHC.Generics
+InfixI from GHC.Generics
+Int from GHC.Types
+Int16 from GHC.Int
+Int32 from GHC.Int
+Int64 from GHC.Int
+Int8 from GHC.Int
+IntMap from Data.IntMap.Internal
+IntPtr from Foreign.Ptr
+IntSet from Data.IntSet.Internal
+Integer from GHC.Integer.Type
+Integral from GHC.Real
+IsLabel from GHC.OverloadedLabels
+IsString from Data.String
+Just from GHC.Maybe
+K1 from GHC.Generics
+K1 from GHC.Generics
+KnownNat from GHC.TypeNats
+KnownSymbol from GHC.TypeLits
+L1 from GHC.Generics
+LByteString from Protolude
+LT from GHC.Types
+LText from Protolude
+Last from Data.Monoid
+Last from Data.Monoid
+Left from Data.Either
+LeftAssociative from GHC.Generics
+Leniency from Protolude.Conv
+Lenient from Protolude.Conv
+Location from GHC.ExecutionStack.Internal
+Location from GHC.ExecutionStack.Internal
+LossOfPrecision from GHC.Exception.Type
+M1 from GHC.Generics
+M1 from GHC.Generics
+MVar from GHC.MVar
+Map from Data.Map.Internal
+MaskedInterruptible from GHC.IO
+MaskedUninterruptible from GHC.IO
+MaskingState from GHC.IO
+Maybe from GHC.Maybe
+Meta from GHC.Generics
+MetaCons from GHC.Generics
+MetaData from GHC.Generics
+MetaSel from GHC.Generics
+Monad from GHC.Base
+MonadError from Control.Monad.Error.Class
+MonadIO from Control.Monad.IO.Class
+MonadPlus from GHC.Base
+MonadReader from Control.Monad.Reader.Class
+MonadState from Control.Monad.State.Class
+Monoid from GHC.Base
+NFData from Control.DeepSeq
+Nat from GHC.Types
+NestedAtomically from Control.Exception.Base
+NestedAtomically from Control.Exception.Base
+NoMethodError from Control.Exception.Base
+NoMethodError from Control.Exception.Base
+NonEmpty from GHC.Base
+NonTermination from Control.Exception.Base
+NonTermination from Control.Exception.Base
+NotAssociative from GHC.Generics
+Nothing from GHC.Maybe
+Num from GHC.Num
+OnDecodeError from Data.Text.Encoding.Error
+OnError from Data.Text.Encoding.Error
+Option from Data.Semigroup
+Option from Data.Semigroup
+Ord from GHC.Classes
+Ordering from GHC.Types
+Overflow from GHC.Exception.Type
+PatternMatchFail from Control.Exception.Base
+PatternMatchFail from Control.Exception.Base
+Prefix from GHC.Generics
+PrefixI from GHC.Generics
+Print from Protolude.Show
+Product from Data.Semigroup.Internal
+Product from Data.Semigroup.Internal
+Proxy from Data.Proxy
+Proxy from Data.Proxy
+Ptr from GHC.Ptr
+QSem from Control.Concurrent.QSem
+QSemN from Control.Concurrent.QSemN
+R1 from GHC.Generics
+Ratio from GHC.Real
+RatioZeroDenominator from GHC.Exception.Type
+Rational from GHC.Real
+Read from GHC.Read
+ReadMode from GHC.IO.IOMode
+ReadWriteMode from GHC.IO.IOMode
+Reader from Control.Monad.Trans.Reader
+ReaderT from Control.Monad.Trans.Reader
+ReaderT from Control.Monad.Trans.Reader
+Real from GHC.Real
+RealFloat from GHC.Float
+RealFrac from GHC.Real
+Rec0 from GHC.Generics
+RecConError from Control.Exception.Base
+RecConError from Control.Exception.Base
+RecSelError from Control.Exception.Base
+RecSelError from Control.Exception.Base
+RecUpdError from Control.Exception.Base
+RecUpdError from Control.Exception.Base
+Refl from Data.Type.Equality
+Rep from GHC.Generics
+Right from Data.Either
+RightAssociative from GHC.Generics
+S1 from GHC.Generics
+ST from GHC.ST
+STM from GHC.Conc.Sync
+Selector from GHC.Generics
+Semigroup from GHC.Base
+Semiring from Protolude.Semiring
+Seq from Data.Sequence.Internal
+Set from Data.Set.Internal
+Show from GHC.Show
+SomeAsyncException from GHC.IO.Exception
+SomeAsyncException from GHC.IO.Exception
+SomeException from GHC.Exception.Type
+SomeException from GHC.Exception.Type
+SomeNat from GHC.TypeNats
+SomeNat from GHC.TypeNats
+SomeSymbol from GHC.TypeLits
+SomeSymbol from GHC.TypeLits
+SrcLoc from GHC.ExecutionStack.Internal
+SrcLoc from GHC.ExecutionStack.Internal
+StablePtr from GHC.Stable
+StackOverflow from GHC.IO.Exception
+State from Control.Monad.Trans.State.Lazy
+StateT from Control.Monad.Trans.State.Lazy
+StateT from Control.Monad.Trans.State.Lazy
+StaticPtr from GHC.StaticPtr
+Storable from Foreign.Storable
+Strict from Protolude.Conv
+StringConv from Protolude.Conv
+Sum from Data.Semigroup.Internal
+Sum from Data.Semigroup.Internal
+Symbol from GHC.Types
+Text from Data.Text.Internal
+ThreadId from GHC.Conc.Sync
+ThreadKilled from GHC.IO.Exception
+Traversable from Data.Traversable
+True from GHC.Types
+Type from GHC.Types
+TypeError from Control.Exception.Base
+TypeError from Control.Exception.Base
+TypeRep from Data.Typeable
+Typeable from Data.Typeable.Internal
+U1 from GHC.Generics
+U1 from GHC.Generics
+URec from GHC.Generics
+UndefinedElement from GHC.IO.Exception
+Underflow from GHC.Exception.Type
+UnicodeException from Data.Text.Encoding.Error
+Unmasked from GHC.IO
+UserInterrupt from GHC.IO.Exception
+V1 from GHC.Generics
+Void from Data.Void
+Word from GHC.Types
+Word16 from GHC.Word
+Word32 from GHC.Word
+Word64 from GHC.Word
+Word8 from GHC.Word
+WordPtr from Foreign.Ptr
+WrappedMonoid from Data.Semigroup
+WriteMode from GHC.IO.IOMode
+ZipList from Control.Applicative
+ZipList from Control.Applicative
+^ from GHC.Real
+^%^ from GHC.Real
+^^ from GHC.Real
+^^%^^ from GHC.Real
+abs from GHC.Num
+absurd from Data.Void
+acos from GHC.Float
+acosh from GHC.Float
+addMVarFinalizer from Control.Concurrent.MVar
+all from Data.Foldable
+allowInterrupt from Control.Exception
+and from Data.Foldable
+any from Data.Foldable
+ap from GHC.Base
+appEndo from Data.Semigroup.Internal
+appendFile from Data.Text.IO
+applyN from Protolude
+asTypeOf from GHC.Base
+asin from GHC.Float
+asinh from GHC.Float
+ask from Control.Monad.Reader.Class
+asks from Control.Monad.Reader.Class
+asum from Data.Foldable
+async from Control.Concurrent.Async
+asyncBound from Control.Concurrent.Async
+asyncExceptionFromException from GHC.IO.Exception
+asyncExceptionToException from GHC.IO.Exception
+asyncOn from Control.Concurrent.Async
+asyncThreadId from Control.Concurrent.Async
+atDef from Protolude.Safe
+atMay from Protolude.Safe
+atan from GHC.Float
+atan2 from GHC.Float
+atanh from GHC.Float
+atomically from GHC.Conc.Sync
+bimap from Data.Bifunctor
+bit from Data.Bits
+bitDefault from Data.Bits
+bitSize from Data.Bits
+bitSizeMaybe from Data.Bits
+bool from Protolude.Bool
+boundedEnumFrom from GHC.Enum
+boundedEnumFromThen from GHC.Enum
+bracket from Control.Exception.Base
+bracketOnError from Control.Exception.Base
+bracket_ from Control.Exception.Base
+break from GHC.List
+byteSwap16 from GHC.Word
+byteSwap32 from GHC.Word
+byteSwap64 from GHC.Word
+callStack from GHC.Stack
+cancel from Control.Concurrent.Async
+cancelWith from Control.Concurrent.Async
+cast from Data.Typeable
+castWith from Data.Type.Equality
+catMaybes from Data.Maybe
+catch from GHC.IO
+catchE from Control.Monad.Trans.Except
+catchError from Control.Monad.Error.Class
+catchJust from Control.Exception.Base
+catchSTM from GHC.Conc.Sync
+catches from Control.Exception
+ceiling from GHC.Real
+check from Control.Monad.STM
+chr from GHC.Char
+cis from Data.Complex
+clearBit from Data.Bits
+coerceWith from Data.Type.Coercion
+compare from GHC.Classes
+comparing from Data.Ord
+complement from Data.Bits
+complementBit from Data.Bits
+conFixity from GHC.Generics
+conIsRecord from GHC.Generics
+conName from GHC.Generics
+concat from Data.Foldable
+concatMap from Data.Foldable
+concatMapM from Protolude.Monad
+concurrently from Control.Concurrent.Async
+conjugate from Data.Complex
+const from GHC.Base
+cos from GHC.Float
+cosh from GHC.Float
+countLeadingZeros from Data.Bits
+countTrailingZeros from Data.Bits
+currentCallStack from GHC.Stack.CCS
+curry from Data.Tuple
+cycle from GHC.List
+cycle1 from Data.Semigroup
+datatypeName from GHC.Generics
+decodeFloat from GHC.Float
+decodeUtf8 from Data.Text.Encoding
+decodeUtf8' from Data.Text.Encoding
+decodeUtf8With from Data.Text.Encoding
+deepseq from Control.DeepSeq
+denominator from GHC.Real
+die from Protolude
+diff from Data.Semigroup
+displayException from GHC.Exception.Type
+div from GHC.Real
+divMod from GHC.Real
+divZeroError from GHC.Real
+drop from GHC.List
+dropWhile from GHC.List
+dupChan from Control.Concurrent.Chan
+either from Data.Either
+eitherA from Protolude.Applicative
+elem from Data.Foldable
+empty from GHC.Base
+encodeFloat from GHC.Float
+encodeUtf8 from Data.Text.Encoding
+enumFrom from GHC.Enum
+enumFromThen from GHC.Enum
+enumFromThenTo from GHC.Enum
+enumFromTo from GHC.Enum
+eqT from Data.Typeable
+evalState from Control.Monad.Trans.State.Lazy
+evalStateT from Control.Monad.Trans.State.Lazy
+evaluate from GHC.IO
+even from GHC.Real
+execState from Control.Monad.Trans.State.Lazy
+execStateT from Control.Monad.Trans.State.Lazy
+exitFailure from System.Exit
+exitSuccess from System.Exit
+exitWith from System.Exit
+exp from GHC.Float
+expm1 from GHC.Float
+exponent from GHC.Float
+fatalErrorMessage from Protolude.Panic
+filter from GHC.List
+filterM from Control.Monad
+finally from Control.Exception.Base
+find from Data.Foldable
+finiteBitSize from Data.Bits
+first from Data.Bifunctor
+fix from Data.Function
+fixST from Control.Monad.ST.Imp
+flip from GHC.Base
+floatDigits from GHC.Float
+floatRadix from GHC.Float
+floatRange from GHC.Float
+floor from GHC.Real
+fmap from GHC.Base
+fmapDefault from Data.Traversable
+fold from Data.Foldable
+foldM from Control.Monad
+foldM_ from Control.Monad
+foldMap from Data.Foldable
+foldMapDefault from Data.Traversable
+foldl from Data.Foldable
+foldl' from Data.Foldable
+foldl1May from Protolude.Safe
+foldl1May' from Protolude.Safe
+foldlM from Data.Foldable
+foldr from Data.Foldable
+foldr' from Data.Foldable
+foldr1May from Protolude.Safe
+foldrM from Data.Foldable
+for from Data.Traversable
+forM from Data.Traversable
+forM_ from Data.Foldable
+for_ from Data.Foldable
+force from Control.DeepSeq
+foreach from Protolude.Functor
+forever from Control.Monad
+forkFinally from Control.Concurrent
+forkIO from GHC.Conc.Sync
+forkIOWithUnmask from GHC.Conc.Sync
+forkOS from Control.Concurrent
+forkOSWithUnmask from Control.Concurrent
+forkOn from GHC.Conc.Sync
+forkOnWithUnmask from GHC.Conc.Sync
+from from GHC.Generics
+fromEnum from GHC.Enum
+fromException from GHC.Exception.Type
+fromInteger from GHC.Num
+fromIntegral from GHC.Real
+fromLabel from GHC.OverloadedLabels
+fromLeft from Data.Either
+fromMaybe from Data.Maybe
+fromRational from GHC.Real
+fromRight from Data.Either
+fromStrict from Data.Text.Lazy
+fst from Data.Tuple
+functionName from GHC.ExecutionStack.Internal
+gcastWith from Data.Type.Equality
+gcd from GHC.Real
+gcdInt' from GHC.Real
+gcdWord' from GHC.Real
+genericDrop from Data.OldList
+genericLength from Data.OldList
+genericReplicate from Data.OldList
+genericSplitAt from Data.OldList
+genericTake from Data.OldList
+get from Control.Monad.State.Class
+getAll from Data.Semigroup.Internal
+getAlt from Data.Semigroup.Internal
+getAny from Data.Semigroup.Internal
+getAp from Data.Monoid
+getArgs from System.Environment
+getCallStack from GHC.Stack.Types
+getChanContents from Control.Concurrent.Chan
+getConst from Data.Functor.Const
+getContents from Data.Text.IO
+getDual from Data.Semigroup.Internal
+getField from GHC.Records
+getFirst from Data.Monoid
+getLast from Data.Monoid
+getLine from Data.Text.IO
+getMaskingState from GHC.IO
+getNumCapabilities from GHC.Conc.Sync
+getOption from Data.Semigroup
+getProduct from Data.Semigroup.Internal
+getStackTrace from GHC.ExecutionStack
+getSum from Data.Semigroup.Internal
+getZipList from Control.Applicative
+gets from Control.Monad.State.Class
+group from Data.OldList
+groupBy from Data.OldList
+guard from Control.Monad
+guardM from Protolude.Bool
+guarded from Protolude
+guardedA from Protolude
+hPutStr from Protolude.Show
+hPutStrLn from Protolude.Show
+handle from Control.Exception.Base
+handleJust from Control.Exception.Base
+hash from Data.Hashable.Class
+hashUsing from Data.Hashable.Class
+hashWithSalt from Data.Hashable.Class
+head from Protolude.List
+headDef from Protolude.Safe
+headMay from Protolude.Safe
+hush from Protolude.Exceptions
+identity from Protolude
+ifM from Protolude.Bool
+ignore from Data.Text.Encoding.Error
+imagPart from Data.Complex
+infinity from GHC.Real
+initDef from Protolude.Safe
+initMay from Protolude.Safe
+initSafe from Protolude.Safe
+inits from Data.OldList
+integralEnumFrom from GHC.Real
+integralEnumFromThen from GHC.Real
+integralEnumFromThenTo from GHC.Real
+integralEnumFromTo from GHC.Real
+interact from Data.Text.IO
+intercalate from Data.OldList
+interruptible from GHC.IO
+intersperse from Data.OldList
+ioError from GHC.IO.Exception
+isCurrentThreadBound from Control.Concurrent
+isDenormalized from GHC.Float
+isEmptyMVar from GHC.MVar
+isIEEE from GHC.Float
+isInfinite from GHC.Float
+isJust from Data.Maybe
+isLeft from Data.Either
+isNaN from GHC.Float
+isNegativeZero from GHC.Float
+isNewtype from GHC.Generics
+isNothing from Data.Maybe
+isPrefixOf from Data.OldList
+isRight from Data.Either
+isSigned from Data.Bits
+iterate from GHC.List
+join from GHC.Base
+killThread from GHC.Conc.Sync
+lastDef from Protolude.Safe
+lastMay from Protolude.Safe
+lcm from GHC.Real
+leftToMaybe from Protolude.Either
+lefts from Data.Either
+length from Data.Foldable
+lenientDecode from Data.Text.Encoding.Error
+lift from Control.Monad.Trans.Class
+liftA from GHC.Base
+liftA2 from GHC.Base
+liftA3 from GHC.Base
+liftAA2 from Protolude.Applicative
+liftIO from Control.Monad.IO.Class
+liftIO1 from Protolude
+liftIO2 from Protolude
+liftM from GHC.Base
+liftM' from Protolude.Monad
+liftM2 from GHC.Base
+liftM2' from Protolude.Monad
+liftM3 from GHC.Base
+liftM4 from GHC.Base
+liftM5 from GHC.Base
+lines from Data.Text
+link from Control.Concurrent.Async
+link2 from Control.Concurrent.Async
+list from Protolude.List
+listToMaybe from Data.Maybe
+local from Control.Monad.Reader.Class
+log from GHC.Float
+log1mexp from GHC.Float
+log1p from GHC.Float
+log1pexp from GHC.Float
+logBase from GHC.Float
+magnitude from Data.Complex
+many from GHC.Base
+map from Protolude
+mapAccumL from Data.Traversable
+mapAccumR from Data.Traversable
+mapAndUnzipM from Control.Monad
+mapExcept from Control.Monad.Trans.Except
+mapExceptT from Control.Monad.Trans.Except
+mapException from Control.Exception.Base
+mapM from Data.Traversable
+mapM_ from Data.Foldable
+mapMaybe from Data.Maybe
+mappend from GHC.Base
+mask from GHC.IO
+mask_ from GHC.IO
+max from GHC.Classes
+maxBound from GHC.Enum
+maxInt from GHC.Base
+maximum from Data.Foldable
+maximumBy from Data.Foldable
+maximumDef from Protolude.Safe
+maximumMay from Protolude.Safe
+maybe from Data.Maybe
+maybeEmpty from Protolude.Either
+maybeToEither from Protolude.Either
+maybeToLeft from Protolude.Either
+maybeToList from Data.Maybe
+maybeToRight from Protolude.Either
+mconcat from GHC.Base
+mempty from GHC.Base
+mfilter from Control.Monad
+min from GHC.Classes
+minBound from GHC.Enum
+minInt from GHC.Base
+minimum from Data.Foldable
+minimumBy from Data.Foldable
+minimumDef from Protolude.Safe
+minimumMay from Protolude.Safe
+mkPolar from Data.Complex
+mkWeakMVar from Control.Concurrent.MVar
+mkWeakThreadId from GHC.Conc.Sync
+mod from GHC.Real
+modify from Control.Monad.State.Class
+modifyMVar from Control.Concurrent.MVar
+modifyMVarMasked from Control.Concurrent.MVar
+modifyMVarMasked_ from Control.Concurrent.MVar
+modifyMVar_ from Control.Concurrent.MVar
+moduleName from GHC.Generics
+mplus from GHC.Base
+msum from Data.Foldable
+mtimesDefault from Data.Semigroup
+myThreadId from GHC.Conc.Sync
+mzero from GHC.Base
+natVal from GHC.TypeLits
+negate from GHC.Num
+newChan from Control.Concurrent.Chan
+newEmptyMVar from GHC.MVar
+newMVar from GHC.MVar
+newQSem from Control.Concurrent.QSem
+newQSemN from Control.Concurrent.QSemN
+nonEmpty from Data.List.NonEmpty
+not from GHC.Classes
+notANumber from GHC.Real
+notElem from Data.Foldable
+notImplemented from Debug
+note from Protolude.Exceptions
+null from Data.Foldable
+numerator from GHC.Real
+numericEnumFrom from GHC.Real
+numericEnumFromThen from GHC.Real
+numericEnumFromThenTo from GHC.Real
+numericEnumFromTo from GHC.Real
+objectName from GHC.ExecutionStack.Internal
+odd from GHC.Real
+on from Data.Function
+onException from Control.Exception.Base
+one from Protolude.Semiring
+openFile from GHC.IO.Handle.FD
+option from Data.Semigroup
+optional from Control.Applicative
+or from Data.Foldable
+orAlt from Protolude.Applicative
+orElse from GHC.Conc.Sync
+orEmpty from Protolude.Applicative
+ord from GHC.Base
+ordNub from Protolude.List
+otherwise from GHC.Base
+overflowError from GHC.Real
+packageName from GHC.Generics
+panic from Protolude.Panic
+partitionEithers from Data.Either
+pass from Protolude
+permutations from Data.OldList
+phase from Data.Complex
+pi from GHC.Float
+polar from Data.Complex
+poll from Control.Concurrent.Async
+popCount from Data.Bits
+popCountDefault from Data.Bits
+pred from GHC.Enum
+prettyCallStack from GHC.Exception
+prettySrcLoc from GHC.Exception
+print from Protolude
+product from Protolude.List
+properFraction from GHC.Real
+pure from GHC.Base
+purer from Protolude.Applicative
+put from Control.Monad.State.Class
+putByteString from Protolude.Show
+putErrLn from Protolude.Show
+putErrText from Protolude.Show
+putLByteString from Protolude.Show
+putLText from Protolude.Show
+putMVar from GHC.MVar
+putStr from Protolude.Show
+putStrLn from Protolude.Show
+putText from Protolude.Show
+quot from GHC.Real
+quotRem from GHC.Real
+race from Control.Concurrent.Async
+race_ from Control.Concurrent.Async
+ratioPrec from GHC.Real
+ratioPrec1 from GHC.Real
+ratioZeroDenominatorError from GHC.Real
+readChan from Control.Concurrent.Chan
+readEither from Text.Read
+readFile from Data.Text.IO
+readMVar from GHC.MVar
+readMaybe from Text.Read
+reader from Control.Monad.Reader.Class
+reads from Text.Read
+realPart from Data.Complex
+realToFrac from GHC.Real
+recip from GHC.Real
+reduce from GHC.Real
+rem from GHC.Real
+repeat from GHC.List
+replace from Data.Text.Encoding.Error
+replicate from GHC.List
+replicateM from Control.Monad
+replicateM_ from Control.Monad
+repr from Data.Type.Coercion
+retry from GHC.Conc.Sync
+return from GHC.Base
+reverse from GHC.List
+rightToMaybe from Protolude.Either
+rights from Data.Either
+rnf from Control.DeepSeq
+rotate from Data.Bits
+rotateL from Data.Bits
+rotateR from Data.Bits
+round from GHC.Real
+rtsSupportsBoundThreads from Control.Concurrent
+runConcurrently from Control.Concurrent.Async
+runExcept from Control.Monad.Trans.Except
+runExceptT from Control.Monad.Trans.Except
+runIdentity from Data.Functor.Identity
+runInBoundThread from Control.Concurrent
+runInUnboundThread from Control.Concurrent
+runReader from Control.Monad.Trans.Reader
+runReaderT from Control.Monad.Trans.Reader
+runST from GHC.ST
+runState from Control.Monad.Trans.State.Lazy
+runStateT from Control.Monad.Trans.State.Lazy
+scaleFloat from GHC.Float
+scanl from GHC.List
+scanl' from GHC.List
+scanr from GHC.List
+sconcat from GHC.Base
+second from Data.Bifunctor
+selDecidedStrictness from GHC.Generics
+selName from GHC.Generics
+selSourceStrictness from GHC.Generics
+selSourceUnpackedness from GHC.Generics
+seq from GHC.Prim
+sequence from Data.Traversable
+sequenceA from Data.Traversable
+sequenceA_ from Data.Foldable
+sequence_ from Data.Foldable
+setBit from Data.Bits
+setNumCapabilities from GHC.Conc.Sync
+shift from Data.Bits
+shiftL from Data.Bits
+shiftR from Data.Bits
+show from Protolude
+showStackTrace from GHC.ExecutionStack
+signalQSem from Control.Concurrent.QSem
+signalQSemN from Control.Concurrent.QSemN
+significand from GHC.Float
+signum from GHC.Num
+sin from GHC.Float
+sinh from GHC.Float
+snd from Data.Tuple
+some from GHC.Base
+someNatVal from GHC.TypeLits
+someSymbolVal from GHC.TypeLits
+sort from Data.OldList
+sortBy from Data.OldList
+sortOn from Protolude.List
+sourceColumn from GHC.ExecutionStack.Internal
+sourceFile from GHC.ExecutionStack.Internal
+sourceLine from GHC.ExecutionStack.Internal
+splitAt from GHC.List
+sqrt from GHC.Float
+srcLoc from GHC.ExecutionStack.Internal
+state from Control.Monad.State.Class
+stderr from GHC.IO.Handle.FD
+stdin from GHC.IO.Handle.FD
+stdout from GHC.IO.Handle.FD
+stimes from GHC.Base
+stimesIdempotent from Data.Semigroup.Internal
+stimesIdempotentMonoid from Data.Semigroup.Internal
+stimesMonoid from Data.Semigroup.Internal
+strConv from Protolude.Conv
+strictDecode from Data.Text.Encoding.Error
+subsequences from Data.OldList
+subtract from GHC.Num
+succ from GHC.Enum
+sum from Protolude.List
+swap from Data.Tuple
+swapMVar from Control.Concurrent.MVar
+sym from Data.Type.Equality
+symbolVal from GHC.TypeLits
+tailDef from Protolude.Safe
+tailMay from Protolude.Safe
+tailSafe from Protolude.Safe
+tails from Data.OldList
+take from GHC.List
+takeMVar from GHC.MVar
+takeWhile from GHC.List
+tan from GHC.Float
+tanh from GHC.Float
+testBit from Data.Bits
+testBitDefault from Data.Bits
+threadCapability from GHC.Conc.Sync
+threadDelay from GHC.Conc.IO
+threadWaitRead from Control.Concurrent
+threadWaitReadSTM from Control.Concurrent
+threadWaitWrite from Control.Concurrent
+threadWaitWriteSTM from Control.Concurrent
+throwE from Control.Monad.Trans.Except
+throwError from Control.Monad.Error.Class
+throwIO from Protolude
+throwSTM from GHC.Conc.Sync
+throwTo from Protolude
+to from GHC.Generics
+toEnum from GHC.Enum
+toException from GHC.Exception.Type
+toInteger from GHC.Real
+toIntegralSized from Data.Bits
+toList from Data.Foldable
+toRational from GHC.Real
+toS from Protolude.Conv
+toSL from Protolude.Conv
+toStrict from Data.Text.Lazy
+trace from Debug
+traceIO from Debug
+traceId from Debug
+traceM from Debug
+traceShow from Debug
+traceShowId from Debug
+traceShowM from Debug
+trans from Data.Type.Equality
+transpose from Data.OldList
+traverse from Data.Traversable
+traverse_ from Data.Foldable
+truncate from GHC.Real
+try from Control.Exception.Base
+tryIO from Protolude.Exceptions
+tryJust from Control.Exception.Base
+tryPutMVar from GHC.MVar
+tryReadMVar from GHC.MVar
+tryTakeMVar from GHC.MVar
+typeRep from Data.Typeable
+unComp1 from GHC.Generics
+unK1 from GHC.Generics
+unM1 from GHC.Generics
+uncons from Protolude
+uncurry from Data.Tuple
+undefined from Debug
+underflowError from GHC.Real
+unfoldr from Data.OldList
+uninterruptibleMask from GHC.IO
+uninterruptibleMask_ from GHC.IO
+unless from Control.Monad
+unlessM from Protolude.Bool
+unlines from Data.Text
+unsnoc from Protolude
+until from GHC.Base
+unwords from Data.Text
+unzip from GHC.List
+vacuous from Data.Void
+void from Data.Functor
+wait from Control.Concurrent.Async
+waitAny from Control.Concurrent.Async
+waitAnyCancel from Control.Concurrent.Async
+waitAnyCatch from Control.Concurrent.Async
+waitAnyCatchCancel from Control.Concurrent.Async
+waitBoth from Control.Concurrent.Async
+waitCatch from Control.Concurrent.Async
+waitEither from Control.Concurrent.Async
+waitEitherCancel from Control.Concurrent.Async
+waitEitherCatch from Control.Concurrent.Async
+waitEitherCatchCancel from Control.Concurrent.Async
+waitEither_ from Control.Concurrent.Async
+waitQSem from Control.Concurrent.QSem
+waitQSemN from Control.Concurrent.QSemN
+when from GHC.Base
+whenM from Protolude.Bool
+withAsync from Control.Concurrent.Async
+withAsyncBound from Control.Concurrent.Async
+withAsyncOn from Control.Concurrent.Async
+withExcept from Control.Monad.Trans.Except
+withExceptT from Control.Monad.Trans.Except
+withFile from System.IO
+withFrozenCallStack from GHC.Stack
+withMVar from Control.Concurrent.MVar
+withMVarMasked from Control.Concurrent.MVar
+withState from Control.Monad.Trans.State.Lazy
+witness from Debug
+words from Data.Text
+writeChan from Control.Concurrent.Chan
+writeFile from Data.Text.IO
+writeList2Chan from Control.Concurrent.Chan
+xor from Data.Bits
+zero from Protolude.Semiring
+zeroBits from Data.Bits
+zip from GHC.List
+zipWith from GHC.List
+zipWithM from Control.Monad
+zipWithM_ from Control.Monad
+|| from GHC.Classes
+||^ from Protolude.Bool

export_lists/protolude-14.exports

@@ -0,0 +1,959 @@
+$ from GHC.Base
+$! from Protolude.Base
+$!! from Control.DeepSeq
+$> from Data.Functor
+% from GHC.Real
+& from Data.Function
+&& from GHC.Classes
+&&^ from Protolude.Bool
+* from GHC.Num
+** from GHC.Float
+*> from GHC.Base
++ from GHC.Num
+++ from GHC.Base
+- from GHC.Num
+. from GHC.Base
+.&. from Data.Bits
+.|. from Data.Bits
+/ from GHC.Real
+/= from GHC.Classes
+:% from GHC.Real
+:*: from GHC.Generics
+:*: from GHC.Generics
+:+ from Data.Complex
+:+: from GHC.Generics
+:.: from GHC.Generics
+:| from GHC.Base
+:~: from Data.Type.Equality
+< from GHC.Classes
+<$ from GHC.Base
+<$!> from Control.Monad
+<$> from Data.Functor
+<&&> from Protolude.Bool
+<&> from Data.Functor
+<* from GHC.Base
+<**> from GHC.Base
+<*> from GHC.Base
+<.> from Protolude.Semiring
+<<$>> from Protolude.Functor
+<<*>> from Protolude.Applicative
+<= from GHC.Classes
+<=< from Control.Monad
+<> from GHC.Base
+<|> from GHC.Base
+<||> from Protolude.Bool
+=<< from GHC.Base
+== from GHC.Classes
+== from Data.Type.Equality
+> from GHC.Classes
+>= from GHC.Classes
+>=> from Control.Monad
+>> from GHC.Base
+>>= from GHC.Base
+All from Data.Semigroup.Internal
+All from Data.Semigroup.Internal
+AllocationLimitExceeded from GHC.IO.Exception
+AllocationLimitExceeded from GHC.IO.Exception
+Alt from Data.Semigroup.Internal
+Alt from Data.Semigroup.Internal
+Alternative from GHC.Base
+Any from Data.Semigroup.Internal
+Any from Data.Semigroup.Internal
+Ap from Data.Monoid
+Ap from Data.Monoid
+AppendMode from GHC.IO.IOMode
+Applicative from GHC.Base
+ArithException from GHC.Exception.Type
+ArrayException from GHC.IO.Exception
+AssertionFailed from GHC.IO.Exception
+AssertionFailed from GHC.IO.Exception
+Associativity from GHC.Generics
+Async from Control.Concurrent.Async
+AsyncException from GHC.IO.Exception
+Bifunctor from Data.Bifunctor
+Bits from Data.Bits
+BlockedIndefinitelyOnMVar from GHC.IO.Exception
+BlockedIndefinitelyOnMVar from GHC.IO.Exception
+BlockedIndefinitelyOnSTM from GHC.IO.Exception
+BlockedIndefinitelyOnSTM from GHC.IO.Exception
+Bool from GHC.Types
+Bounded from GHC.Enum
+ByteString from Data.ByteString.Internal
+C1 from GHC.Generics
+CallStack from GHC.Stack.Types
+Chan from Control.Concurrent.Chan
+Char from GHC.Types
+CmpNat from GHC.TypeNats
+Coercible from GHC.Types
+Coercion from Data.Type.Coercion
+Coercion from Data.Type.Coercion
+Comp1 from GHC.Generics
+CompactionFailed from GHC.IO.Exception
+CompactionFailed from GHC.IO.Exception
+Complex from Data.Complex
+Concurrently from Control.Concurrent.Async
+Concurrently from Control.Concurrent.Async
+Const from Data.Functor.Const
+Const from Data.Functor.Const
+Constraint from GHC.Types
+Constructor from GHC.Generics
+D# from GHC.Types
+D1 from GHC.Generics
+Datatype from GHC.Generics
+Deadlock from GHC.IO.Exception
+Deadlock from GHC.IO.Exception
+Denormal from GHC.Exception.Type
+DivideByZero from GHC.Exception.Type
+Double from GHC.Types
+Down from Data.Ord
+Down from Data.Ord
+Dual from Data.Semigroup.Internal
+Dual from Data.Semigroup.Internal
+EQ from GHC.Types
+Either from Data.Either
+Endo from Data.Semigroup.Internal
+Endo from Data.Semigroup.Internal
+Enum from GHC.Enum
+Eq from GHC.Classes
+ErrorCall from GHC.Exception
+ErrorCall from GHC.Exception
+ErrorCallWithLocation from GHC.Exception
+Except from Control.Monad.Trans.Except
+ExceptT from Control.Monad.Trans.Except
+ExceptT from Control.Monad.Trans.Except
+Exception from GHC.Exception.Type
+ExitCode from GHC.IO.Exception
+ExitFailure from GHC.IO.Exception
+ExitSuccess from GHC.IO.Exception
+F# from GHC.Types
+False from GHC.Types
+FatalError from Protolude.Panic
+FatalError from Protolude.Panic
+FilePath from GHC.IO
+FiniteBits from Data.Bits
+First from Data.Monoid
+First from Data.Monoid
+Fixity from GHC.Generics
+FixityI from GHC.Generics
+Float from GHC.Types
+Floating from GHC.Float
+Foldable from Data.Foldable
+Fractional from GHC.Real
+FunPtr from GHC.Ptr
+Functor from GHC.Base
+GT from GHC.Types
+Generic from GHC.Generics
+Generic1 from GHC.Generics
+Handle from GHC.IO.Handle.Types
+HasCallStack from GHC.Stack.Types
+HasField from GHC.Records
+Hashable from Data.Hashable.Class
+HeapOverflow from GHC.IO.Exception
+IO from GHC.Types
+IOException from GHC.IO.Exception
+IOMode from GHC.IO.IOMode
+Identity from Data.Functor.Identity
+Identity from Data.Functor.Identity
+IndexOutOfBounds from GHC.IO.Exception
+Infix from GHC.Generics
+InfixI from GHC.Generics
+Int from GHC.Types
+Int16 from GHC.Int
+Int32 from GHC.Int
+Int64 from GHC.Int
+Int8 from GHC.Int
+IntMap from Data.IntMap.Internal
+IntPtr from Foreign.Ptr
+IntSet from Data.IntSet.Internal
+Integer from GHC.Integer.Type
+Integral from GHC.Real
+IsLabel from GHC.OverloadedLabels
+IsString from Data.String
+Just from GHC.Maybe
+K1 from GHC.Generics
+K1 from GHC.Generics
+KnownNat from GHC.TypeNats
+KnownSymbol from GHC.TypeLits
+L1 from GHC.Generics
+LByteString from Protolude
+LT from GHC.Types
+LText from Protolude
+Last from Data.Monoid
+Last from Data.Monoid
+Left from Data.Either
+LeftAssociative from GHC.Generics
+Leniency from Protolude.Conv
+Lenient from Protolude.Conv
+Location from GHC.ExecutionStack.Internal
+Location from GHC.ExecutionStack.Internal
+LossOfPrecision from GHC.Exception.Type
+M1 from GHC.Generics
+M1 from GHC.Generics
+MVar from GHC.MVar
+Map from Data.Map.Internal
+MaskedInterruptible from GHC.IO
+MaskedUninterruptible from GHC.IO
+MaskingState from GHC.IO
+Maybe from GHC.Maybe
+Meta from GHC.Generics
+MetaCons from GHC.Generics
+MetaData from GHC.Generics
+MetaSel from GHC.Generics
+Monad from GHC.Base
+MonadError from Control.Monad.Error.Class
+MonadIO from Control.Monad.IO.Class
+MonadPlus from GHC.Base
+MonadReader from Control.Monad.Reader.Class
+MonadState from Control.Monad.State.Class
+Monoid from GHC.Base
+NFData from Control.DeepSeq
+Nat from GHC.Types
+NestedAtomically from Control.Exception.Base
+NestedAtomically from Control.Exception.Base
+NoMethodError from Control.Exception.Base
+NoMethodError from Control.Exception.Base
+NonEmpty from GHC.Base
+NonTermination from Control.Exception.Base
+NonTermination from Control.Exception.Base
+NotAssociative from GHC.Generics
+Nothing from GHC.Maybe
+Num from GHC.Num
+OnDecodeError from Data.Text.Encoding.Error
+OnError from Data.Text.Encoding.Error
+Option from Data.Semigroup
+Option from Data.Semigroup
+Ord from GHC.Classes
+Ordering from GHC.Types
+Overflow from GHC.Exception.Type
+PatternMatchFail from Control.Exception.Base
+PatternMatchFail from Control.Exception.Base
+Prefix from GHC.Generics
+PrefixI from GHC.Generics
+Print from Protolude.Show
+Product from Data.Semigroup.Internal
+Product from Data.Semigroup.Internal
+Proxy from Data.Proxy
+Proxy from Data.Proxy
+Ptr from GHC.Ptr
+QSem from Control.Concurrent.QSem
+QSemN from Control.Concurrent.QSemN
+R1 from GHC.Generics
+Ratio from GHC.Real
+RatioZeroDenominator from GHC.Exception.Type
+Rational from GHC.Real
+Read from GHC.Read
+ReadMode from GHC.IO.IOMode
+ReadWriteMode from GHC.IO.IOMode
+Reader from Control.Monad.Trans.Reader
+ReaderT from Control.Monad.Trans.Reader
+ReaderT from Control.Monad.Trans.Reader
+Real from GHC.Real
+RealFloat from GHC.Float
+RealFrac from GHC.Real
+Rec0 from GHC.Generics
+RecConError from Control.Exception.Base
+RecConError from Control.Exception.Base
+RecSelError from Control.Exception.Base
+RecSelError from Control.Exception.Base
+RecUpdError from Control.Exception.Base
+RecUpdError from Control.Exception.Base
+Refl from Data.Type.Equality
+Rep from GHC.Generics
+Right from Data.Either
+RightAssociative from GHC.Generics
+S1 from GHC.Generics
+ST from GHC.ST
+STM from GHC.Conc.Sync
+Selector from GHC.Generics
+Semigroup from GHC.Base
+Semiring from Protolude.Semiring
+Seq from Data.Sequence.Internal
+Set from Data.Set.Internal
+Show from GHC.Show
+SomeAsyncException from GHC.IO.Exception
+SomeAsyncException from GHC.IO.Exception
+SomeException from GHC.Exception.Type
+SomeException from GHC.Exception.Type
+SomeNat from GHC.TypeNats
+SomeNat from GHC.TypeNats
+SomeSymbol from GHC.TypeLits
+SomeSymbol from GHC.TypeLits
+SrcLoc from GHC.ExecutionStack.Internal
+SrcLoc from GHC.ExecutionStack.Internal
+StablePtr from GHC.Stable
+StackOverflow from GHC.IO.Exception
+State from Control.Monad.Trans.State.Lazy
+StateT from Control.Monad.Trans.State.Lazy
+StateT from Control.Monad.Trans.State.Lazy
+StaticPtr from GHC.StaticPtr
+Storable from Foreign.Storable
+Strict from Protolude.Conv
+StringConv from Protolude.Conv
+Sum from Data.Semigroup.Internal
+Sum from Data.Semigroup.Internal
+Symbol from GHC.Types
+Text from Data.Text.Internal
+ThreadId from GHC.Conc.Sync
+ThreadKilled from GHC.IO.Exception
+Traversable from Data.Traversable
+True from GHC.Types
+Type from GHC.Types
+TypeError from Control.Exception.Base
+TypeError from Control.Exception.Base
+TypeRep from Data.Typeable
+Typeable from Data.Typeable.Internal
+U1 from GHC.Generics
+U1 from GHC.Generics
+URec from GHC.Generics
+UndefinedElement from GHC.IO.Exception
+Underflow from GHC.Exception.Type
+UnicodeException from Data.Text.Encoding.Error
+Unmasked from GHC.IO
+UserInterrupt from GHC.IO.Exception
+V1 from GHC.Generics
+Void from Data.Void
+Word from GHC.Types
+Word16 from GHC.Word
+Word32 from GHC.Word
+Word64 from GHC.Word
+Word8 from GHC.Word
+WordPtr from Foreign.Ptr
+WrappedMonoid from Data.Semigroup
+WriteMode from GHC.IO.IOMode
+ZipList from Control.Applicative
+ZipList from Control.Applicative
+^ from GHC.Real
+^%^ from GHC.Real
+^^ from GHC.Real
+^^%^^ from GHC.Real
+abs from GHC.Num
+absurd from Data.Void
+acos from GHC.Float
+acosh from GHC.Float
+addMVarFinalizer from Control.Concurrent.MVar
+all from Data.Foldable
+allowInterrupt from Control.Exception
+and from Data.Foldable
+any from Data.Foldable
+ap from GHC.Base
+appEndo from Data.Semigroup.Internal
+appendFile from Data.Text.IO
+applyN from Protolude
+asTypeOf from GHC.Base
+asin from GHC.Float
+asinh from GHC.Float
+ask from Control.Monad.Reader.Class
+asks from Control.Monad.Reader.Class
+asum from Data.Foldable
+async from Control.Concurrent.Async
+asyncBound from Control.Concurrent.Async
+asyncExceptionFromException from GHC.IO.Exception
+asyncExceptionToException from GHC.IO.Exception
+asyncOn from Control.Concurrent.Async
+asyncThreadId from Control.Concurrent.Async
+atDef from Protolude.Safe
+atMay from Protolude.Safe
+atan from GHC.Float
+atan2 from GHC.Float
+atanh from GHC.Float
+atomically from GHC.Conc.Sync
+bimap from Data.Bifunctor
+bit from Data.Bits
+bitDefault from Data.Bits
+bitSize from Data.Bits
+bitSizeMaybe from Data.Bits
+bool from Protolude.Bool
+boundedEnumFrom from GHC.Enum
+boundedEnumFromThen from GHC.Enum
+bracket from Control.Exception.Base
+bracketOnError from Control.Exception.Base
+bracket_ from Control.Exception.Base
+break from GHC.List
+byteSwap16 from GHC.Word
+byteSwap32 from GHC.Word
+byteSwap64 from GHC.Word
+callStack from GHC.Stack
+cancel from Control.Concurrent.Async
+cancelWith from Control.Concurrent.Async
+cast from Data.Typeable
+castWith from Data.Type.Equality
+catMaybes from Data.Maybe
+catch from GHC.IO
+catchE from Control.Monad.Trans.Except
+catchError from Control.Monad.Error.Class
+catchJust from Control.Exception.Base
+catchSTM from GHC.Conc.Sync
+catches from Control.Exception
+ceiling from GHC.Real
+check from Control.Monad.STM
+chr from GHC.Char
+cis from Data.Complex
+clearBit from Data.Bits
+coerceWith from Data.Type.Coercion
+compare from GHC.Classes
+comparing from Data.Ord
+complement from Data.Bits
+complementBit from Data.Bits
+conFixity from GHC.Generics
+conIsRecord from GHC.Generics
+conName from GHC.Generics
+concat from Data.Foldable
+concatMap from Data.Foldable
+concatMapM from Protolude.Monad
+concurrently from Control.Concurrent.Async
+conjugate from Data.Complex
+const from GHC.Base
+cos from GHC.Float
+cosh from GHC.Float
+countLeadingZeros from Data.Bits
+countTrailingZeros from Data.Bits
+currentCallStack from GHC.Stack.CCS
+curry from Data.Tuple
+cycle from GHC.List
+cycle1 from Data.Semigroup
+datatypeName from GHC.Generics
+decodeFloat from GHC.Float
+decodeUtf8 from Data.Text.Encoding
+decodeUtf8' from Data.Text.Encoding
+decodeUtf8With from Data.Text.Encoding
+deepseq from Control.DeepSeq
+denominator from GHC.Real
+die from Protolude
+diff from Data.Semigroup
+displayException from GHC.Exception.Type
+div from GHC.Real
+divMod from GHC.Real
+divZeroError from GHC.Real
+drop from GHC.List
+dropWhile from GHC.List
+dupChan from Control.Concurrent.Chan
+either from Data.Either
+eitherA from Protolude.Applicative
+elem from Data.Foldable
+empty from GHC.Base
+encodeFloat from GHC.Float
+encodeUtf8 from Data.Text.Encoding
+enumFrom from GHC.Enum
+enumFromThen from GHC.Enum
+enumFromThenTo from GHC.Enum
+enumFromTo from GHC.Enum
+eqT from Data.Typeable
+evalState from Control.Monad.Trans.State.Lazy
+evalStateT from Control.Monad.Trans.State.Lazy
+evaluate from GHC.IO
+even from GHC.Real
+execState from Control.Monad.Trans.State.Lazy
+execStateT from Control.Monad.Trans.State.Lazy
+exitFailure from System.Exit
+exitSuccess from System.Exit
+exitWith from System.Exit
+exp from GHC.Float
+expm1 from GHC.Float
+exponent from GHC.Float
+fatalErrorMessage from Protolude.Panic
+filter from GHC.List
+filterM from Control.Monad
+finally from Control.Exception.Base
+find from Data.Foldable
+finiteBitSize from Data.Bits
+first from Data.Bifunctor
+fix from Data.Function
+fixST from Control.Monad.ST.Imp
+flip from GHC.Base
+floatDigits from GHC.Float
+floatRadix from GHC.Float
+floatRange from GHC.Float
+floor from GHC.Real
+fmap from GHC.Base
+fmapDefault from Data.Traversable
+fold from Data.Foldable
+foldM from Control.Monad
+foldM_ from Control.Monad
+foldMap from Data.Foldable
+foldMapDefault from Data.Traversable
+foldl from Data.Foldable
+foldl' from Data.Foldable
+foldl1May from Protolude.Safe
+foldl1May' from Protolude.Safe
+foldlM from Data.Foldable
+foldr from Data.Foldable
+foldr' from Data.Foldable
+foldr1May from Protolude.Safe
+foldrM from Data.Foldable
+for from Data.Traversable
+forM from Data.Traversable
+forM_ from Data.Foldable
+for_ from Data.Foldable
+force from Control.DeepSeq
+foreach from Protolude.Functor
+forever from Control.Monad
+forkFinally from Control.Concurrent
+forkIO from GHC.Conc.Sync
+forkIOWithUnmask from GHC.Conc.Sync
+forkOS from Control.Concurrent
+forkOSWithUnmask from Control.Concurrent
+forkOn from GHC.Conc.Sync
+forkOnWithUnmask from GHC.Conc.Sync
+from from GHC.Generics
+fromEnum from GHC.Enum
+fromException from GHC.Exception.Type
+fromInteger from GHC.Num
+fromIntegral from GHC.Real
+fromLabel from GHC.OverloadedLabels
+fromLeft from Data.Either
+fromMaybe from Data.Maybe
+fromRational from GHC.Real
+fromRight from Data.Either
+fromStrict from Data.Text.Lazy
+fst from Data.Tuple
+functionName from GHC.ExecutionStack.Internal
+gcastWith from Data.Type.Equality
+gcd from GHC.Real
+gcdInt' from GHC.Real
+gcdWord' from GHC.Real
+genericDrop from Data.OldList
+genericLength from Data.OldList
+genericReplicate from Data.OldList
+genericSplitAt from Data.OldList
+genericTake from Data.OldList
+get from Control.Monad.State.Class
+getAll from Data.Semigroup.Internal
+getAlt from Data.Semigroup.Internal
+getAny from Data.Semigroup.Internal
+getAp from Data.Monoid
+getArgs from System.Environment
+getCallStack from GHC.Stack.Types
+getChanContents from Control.Concurrent.Chan
+getConst from Data.Functor.Const
+getContents from Data.Text.IO
+getDual from Data.Semigroup.Internal
+getField from GHC.Records
+getFirst from Data.Monoid
+getLast from Data.Monoid
+getLine from Data.Text.IO
+getMaskingState from GHC.IO
+getNumCapabilities from GHC.Conc.Sync
+getOption from Data.Semigroup
+getProduct from Data.Semigroup.Internal
+getStackTrace from GHC.ExecutionStack
+getSum from Data.Semigroup.Internal
+getZipList from Control.Applicative
+gets from Control.Monad.State.Class
+group from Data.OldList
+groupBy from Data.OldList
+guard from Control.Monad
+guardM from Protolude.Bool
+guarded from Protolude
+guardedA from Protolude
+hPutStr from Protolude.Show
+hPutStrLn from Protolude.Show
+handle from Control.Exception.Base
+handleJust from Control.Exception.Base
+hash from Data.Hashable.Class
+hashUsing from Data.Hashable.Class
+hashWithSalt from Data.Hashable.Class
+head from Protolude.List
+headDef from Protolude.Safe
+headMay from Protolude.Safe
+hush from Protolude.Exceptions
+identity from Protolude
+ifM from Protolude.Bool
+ignore from Data.Text.Encoding.Error
+imagPart from Data.Complex
+infinity from GHC.Real
+initDef from Protolude.Safe
+initMay from Protolude.Safe
+initSafe from Protolude.Safe
+inits from Data.OldList
+integralEnumFrom from GHC.Real
+integralEnumFromThen from GHC.Real
+integralEnumFromThenTo from GHC.Real
+integralEnumFromTo from GHC.Real
+interact from Data.Text.IO
+intercalate from Data.OldList
+interruptible from GHC.IO
+intersperse from Data.OldList
+ioError from GHC.IO.Exception
+isCurrentThreadBound from Control.Concurrent
+isDenormalized from GHC.Float
+isEmptyMVar from GHC.MVar
+isIEEE from GHC.Float
+isInfinite from GHC.Float
+isJust from Data.Maybe
+isLeft from Data.Either
+isNaN from GHC.Float
+isNegativeZero from GHC.Float
+isNewtype from GHC.Generics
+isNothing from Data.Maybe
+isPrefixOf from Data.OldList
+isRight from Data.Either
+isSigned from Data.Bits
+iterate from GHC.List
+join from GHC.Base
+killThread from GHC.Conc.Sync
+lastDef from Protolude.Safe
+lastMay from Protolude.Safe
+lcm from GHC.Real
+leftToMaybe from Protolude.Either
+lefts from Data.Either
+length from Data.Foldable
+lenientDecode from Data.Text.Encoding.Error
+lift from Control.Monad.Trans.Class
+liftA from GHC.Base
+liftA2 from GHC.Base
+liftA3 from GHC.Base
+liftAA2 from Protolude.Applicative
+liftIO from Control.Monad.IO.Class
+liftIO1 from Protolude
+liftIO2 from Protolude
+liftM from GHC.Base
+liftM' from Protolude.Monad
+liftM2 from GHC.Base
+liftM2' from Protolude.Monad
+liftM3 from GHC.Base
+liftM4 from GHC.Base
+liftM5 from GHC.Base
+lines from Data.Text
+link from Control.Concurrent.Async
+link2 from Control.Concurrent.Async
+list from Protolude.List
+listToMaybe from Data.Maybe
+local from Control.Monad.Reader.Class
+log from GHC.Float
+log1mexp from GHC.Float
+log1p from GHC.Float
+log1pexp from GHC.Float
+logBase from GHC.Float
+magnitude from Data.Complex
+many from GHC.Base
+map from Protolude
+mapAccumL from Data.Traversable
+mapAccumR from Data.Traversable
+mapAndUnzipM from Control.Monad
+mapExcept from Control.Monad.Trans.Except
+mapExceptT from Control.Monad.Trans.Except
+mapException from Control.Exception.Base
+mapM from Data.Traversable
+mapM_ from Data.Foldable
+mapMaybe from Data.Maybe
+mappend from GHC.Base
+mask from GHC.IO
+mask_ from GHC.IO
+max from GHC.Classes
+maxBound from GHC.Enum
+maxInt from GHC.Base
+maximum from Data.Foldable
+maximumBy from Data.Foldable
+maximumDef from Protolude.Safe
+maximumMay from Protolude.Safe
+maybe from Data.Maybe
+maybeEmpty from Protolude.Either
+maybeToEither from Protolude.Either
+maybeToLeft from Protolude.Either
+maybeToList from Data.Maybe
+maybeToRight from Protolude.Either
+mconcat from GHC.Base
+mempty from GHC.Base
+mfilter from Control.Monad
+min from GHC.Classes
+minBound from GHC.Enum
+minInt from GHC.Base
+minimum from Data.Foldable
+minimumBy from Data.Foldable
+minimumDef from Protolude.Safe
+minimumMay from Protolude.Safe
+mkPolar from Data.Complex
+mkWeakMVar from Control.Concurrent.MVar
+mkWeakThreadId from GHC.Conc.Sync
+mod from GHC.Real
+modify from Control.Monad.State.Class
+modifyMVar from Control.Concurrent.MVar
+modifyMVarMasked from Control.Concurrent.MVar
+modifyMVarMasked_ from Control.Concurrent.MVar
+modifyMVar_ from Control.Concurrent.MVar
+moduleName from GHC.Generics
+mplus from GHC.Base
+msum from Data.Foldable
+mtimesDefault from Data.Semigroup
+myThreadId from GHC.Conc.Sync
+mzero from GHC.Base
+natVal from GHC.TypeLits
+negate from GHC.Num
+newChan from Control.Concurrent.Chan
+newEmptyMVar from GHC.MVar
+newMVar from GHC.MVar
+newQSem from Control.Concurrent.QSem
+newQSemN from Control.Concurrent.QSemN
+nonEmpty from Data.List.NonEmpty
+not from GHC.Classes
+notANumber from GHC.Real
+notElem from Data.Foldable
+notImplemented from Debug
+note from Protolude.Exceptions
+null from Data.Foldable
+numerator from GHC.Real
+numericEnumFrom from GHC.Real
+numericEnumFromThen from GHC.Real
+numericEnumFromThenTo from GHC.Real
+numericEnumFromTo from GHC.Real
+objectName from GHC.ExecutionStack.Internal
+odd from GHC.Real
+on from Data.Function
+onException from Control.Exception.Base
+one from Protolude.Semiring
+openFile from GHC.IO.Handle.FD
+option from Data.Semigroup
+optional from Control.Applicative
+or from Data.Foldable
+orAlt from Protolude.Applicative
+orElse from GHC.Conc.Sync
+orEmpty from Protolude.Applicative
+ord from GHC.Base
+ordNub from Protolude.List
+otherwise from GHC.Base
+overflowError from GHC.Real
+packageName from GHC.Generics
+panic from Protolude.Panic
+partitionEithers from Data.Either
+pass from Protolude
+permutations from Data.OldList
+phase from Data.Complex
+pi from GHC.Float
+polar from Data.Complex
+poll from Control.Concurrent.Async
+popCount from Data.Bits
+popCountDefault from Data.Bits
+pred from GHC.Enum
+prettyCallStack from GHC.Exception
+prettySrcLoc from GHC.Exception
+print from Protolude
+product from Protolude.List
+properFraction from GHC.Real
+pure from GHC.Base
+purer from Protolude.Applicative
+put from Control.Monad.State.Class
+putByteString from Protolude.Show
+putErrLn from Protolude.Show
+putErrText from Protolude.Show
+putLByteString from Protolude.Show
+putLText from Protolude.Show
+putMVar from GHC.MVar
+putStr from Protolude.Show
+putStrLn from Protolude.Show
+putText from Protolude.Show
+quot from GHC.Real
+quotRem from GHC.Real
+race from Control.Concurrent.Async
+race_ from Control.Concurrent.Async
+ratioPrec from GHC.Real
+ratioPrec1 from GHC.Real
+ratioZeroDenominatorError from GHC.Real
+readChan from Control.Concurrent.Chan
+readEither from Text.Read
+readFile from Data.Text.IO
+readMVar from GHC.MVar
+readMaybe from Text.Read
+reader from Control.Monad.Reader.Class
+reads from Text.Read
+realPart from Data.Complex
+realToFrac from GHC.Real
+recip from GHC.Real
+reduce from GHC.Real
+rem from GHC.Real
+repeat from GHC.List
+replace from Data.Text.Encoding.Error
+replicate from GHC.List
+replicateM from Control.Monad
+replicateM_ from Control.Monad
+repr from Data.Type.Coercion
+retry from GHC.Conc.Sync
+return from GHC.Base
+reverse from GHC.List
+rightToMaybe from Protolude.Either
+rights from Data.Either
+rnf from Control.DeepSeq
+rotate from Data.Bits
+rotateL from Data.Bits
+rotateR from Data.Bits
+round from GHC.Real
+rtsSupportsBoundThreads from Control.Concurrent
+runConcurrently from Control.Concurrent.Async
+runExcept from Control.Monad.Trans.Except
+runExceptT from Control.Monad.Trans.Except
+runIdentity from Data.Functor.Identity
+runInBoundThread from Control.Concurrent
+runInUnboundThread from Control.Concurrent
+runReader from Control.Monad.Trans.Reader
+runReaderT from Control.Monad.Trans.Reader
+runST from GHC.ST
+runState from Control.Monad.Trans.State.Lazy
+runStateT from Control.Monad.Trans.State.Lazy
+scaleFloat from GHC.Float
+scanl from GHC.List
+scanl' from GHC.List
+scanr from GHC.List
+sconcat from GHC.Base
+second from Data.Bifunctor
+selDecidedStrictness from GHC.Generics
+selName from GHC.Generics
+selSourceStrictness from GHC.Generics
+selSourceUnpackedness from GHC.Generics
+seq from GHC.Prim
+sequence from Data.Traversable
+sequenceA from Data.Traversable
+sequenceA_ from Data.Foldable
+sequence_ from Data.Foldable
+setBit from Data.Bits
+setNumCapabilities from GHC.Conc.Sync
+shift from Data.Bits
+shiftL from Data.Bits
+shiftR from Data.Bits
+show from Protolude
+showStackTrace from GHC.ExecutionStack
+signalQSem from Control.Concurrent.QSem
+signalQSemN from Control.Concurrent.QSemN
+significand from GHC.Float
+signum from GHC.Num
+sin from GHC.Float
+sinh from GHC.Float
+snd from Data.Tuple
+some from GHC.Base
+someNatVal from GHC.TypeLits
+someSymbolVal from GHC.TypeLits
+sort from Data.OldList
+sortBy from Data.OldList
+sortOn from Protolude.List
+sourceColumn from GHC.ExecutionStack.Internal
+sourceFile from GHC.ExecutionStack.Internal
+sourceLine from GHC.ExecutionStack.Internal
+splitAt from GHC.List
+sqrt from GHC.Float
+srcLoc from GHC.ExecutionStack.Internal
+state from Control.Monad.State.Class
+stderr from GHC.IO.Handle.FD
+stdin from GHC.IO.Handle.FD
+stdout from GHC.IO.Handle.FD
+stimes from GHC.Base
+stimesIdempotent from Data.Semigroup.Internal
+stimesIdempotentMonoid from Data.Semigroup.Internal
+stimesMonoid from Data.Semigroup.Internal
+strConv from Protolude.Conv
+strictDecode from Data.Text.Encoding.Error
+subsequences from Data.OldList
+subtract from GHC.Num
+succ from GHC.Enum
+sum from Protolude.List
+swap from Data.Tuple
+swapMVar from Control.Concurrent.MVar
+sym from Data.Type.Equality
+symbolVal from GHC.TypeLits
+tailDef from Protolude.Safe
+tailMay from Protolude.Safe
+tailSafe from Protolude.Safe
+tails from Data.OldList
+take from GHC.List
+takeMVar from GHC.MVar
+takeWhile from GHC.List
+tan from GHC.Float
+tanh from GHC.Float
+testBit from Data.Bits
+testBitDefault from Data.Bits
+threadCapability from GHC.Conc.Sync
+threadDelay from GHC.Conc.IO
+threadWaitRead from Control.Concurrent
+threadWaitReadSTM from Control.Concurrent
+threadWaitWrite from Control.Concurrent
+threadWaitWriteSTM from Control.Concurrent
+throwE from Control.Monad.Trans.Except
+throwError from Control.Monad.Error.Class
+throwIO from Protolude
+throwSTM from GHC.Conc.Sync
+throwTo from Protolude
+to from GHC.Generics
+toEnum from GHC.Enum
+toException from GHC.Exception.Type
+toInteger from GHC.Real
+toIntegralSized from Data.Bits
+toList from Data.Foldable
+toRational from GHC.Real
+toS from Protolude.Conv
+toSL from Protolude.Conv
+toStrict from Data.Text.Lazy
+trace from Debug
+traceIO from Debug
+traceId from Debug
+traceM from Debug
+traceShow from Debug
+traceShowId from Debug
+traceShowM from Debug
+trans from Data.Type.Equality
+transpose from Data.OldList
+traverse from Data.Traversable
+traverse_ from Data.Foldable
+truncate from GHC.Real
+try from Control.Exception.Base
+tryIO from Protolude.Exceptions
+tryJust from Control.Exception.Base
+tryPutMVar from GHC.MVar
+tryReadMVar from GHC.MVar
+tryTakeMVar from GHC.MVar
+typeRep from Data.Typeable
+unComp1 from GHC.Generics
+unK1 from GHC.Generics
+unM1 from GHC.Generics
+uncons from Protolude
+uncurry from Data.Tuple
+undefined from Debug
+underflowError from GHC.Real
+unfoldr from Data.OldList
+uninterruptibleMask from GHC.IO
+uninterruptibleMask_ from GHC.IO
+unless from Control.Monad
+unlessM from Protolude.Bool
+unlines from Data.Text
+unsnoc from Protolude
+until from GHC.Base
+unwords from Data.Text
+unzip from GHC.List
+vacuous from Data.Void
+void from Data.Functor
+wait from Control.Concurrent.Async
+waitAny from Control.Concurrent.Async
+waitAnyCancel from Control.Concurrent.Async
+waitAnyCatch from Control.Concurrent.Async
+waitAnyCatchCancel from Control.Concurrent.Async
+waitBoth from Control.Concurrent.Async
+waitCatch from Control.Concurrent.Async
+waitEither from Control.Concurrent.Async
+waitEitherCancel from Control.Concurrent.Async
+waitEitherCatch from Control.Concurrent.Async
+waitEitherCatchCancel from Control.Concurrent.Async
+waitEither_ from Control.Concurrent.Async
+waitQSem from Control.Concurrent.QSem
+waitQSemN from Control.Concurrent.QSemN
+when from GHC.Base
+whenM from Protolude.Bool
+withAsync from Control.Concurrent.Async
+withAsyncBound from Control.Concurrent.Async
+withAsyncOn from Control.Concurrent.Async
+withExcept from Control.Monad.Trans.Except
+withExceptT from Control.Monad.Trans.Except
+withFile from System.IO
+withFrozenCallStack from GHC.Stack
+withMVar from Control.Concurrent.MVar
+withMVarMasked from Control.Concurrent.MVar
+withState from Control.Monad.Trans.State.Lazy
+witness from Debug
+words from Data.Text
+writeChan from Control.Concurrent.Chan
+writeFile from Data.Text.IO
+writeList2Chan from Control.Concurrent.Chan
+xor from Data.Bits
+zero from Protolude.Semiring
+zeroBits from Data.Bits
+zip from GHC.List
+zipWith from GHC.List
+zipWithM from Control.Monad
+zipWithM_ from Control.Monad
+|| from GHC.Classes
+||^ from Protolude.Bool

export_lists/protolude-7.exports

@@ -0,0 +1,956 @@
+$ from GHC.Base
+$! from Protolude.Base
+$!! from Control.DeepSeq
+$> from Data.Functor
+% from GHC.Real
+& from Data.Function
+&& from GHC.Classes
+&&^ from Protolude.Bool
+* from GHC.Num
+* from GHC.Types
+** from GHC.Float
+*> from GHC.Base
++ from GHC.Num
+++ from GHC.Base
+- from GHC.Num
+. from GHC.Base
+.&. from Data.Bits
+.|. from Data.Bits
+/ from GHC.Real
+/= from GHC.Classes
+:% from GHC.Real
+:*: from GHC.Generics
+:*: from GHC.Generics
+:+ from Data.Complex
+:+: from GHC.Generics
+:.: from GHC.Generics
+:| from Data.List.NonEmpty
+:~: from Data.Type.Equality
+< from GHC.Classes
+<$ from GHC.Base
+<$!> from Control.Monad
+<$> from Data.Functor
+<&&> from Protolude.Bool
+<&> from Protolude.Functor
+<* from GHC.Base
+<**> from GHC.Base
+<*> from GHC.Base
+<.> from Protolude.Semiring
+<<$>> from Protolude.Functor
+<<*>> from Protolude.Applicative
+<= from GHC.Classes
+<=< from Control.Monad
+<> from Data.Monoid
+<|> from GHC.Base
+<||> from Protolude.Bool
+=<< from GHC.Base
+== from GHC.Classes
+== from Data.Type.Equality
+> from GHC.Classes
+>= from GHC.Classes
+>=> from Control.Monad
+>> from GHC.Base
+>>= from GHC.Base
+All from Data.Monoid
+All from Data.Monoid
+AllocationLimitExceeded from GHC.IO.Exception
+AllocationLimitExceeded from GHC.IO.Exception
+Alt from Data.Monoid
+Alt from Data.Monoid
+Alternative from GHC.Base
+Any from Data.Monoid
+Any from Data.Monoid
+AppendMode from GHC.IO.IOMode
+Applicative from GHC.Base
+ArithException from GHC.Exception
+ArrayException from GHC.IO.Exception
+AssertionFailed from GHC.IO.Exception
+AssertionFailed from GHC.IO.Exception
+Associativity from GHC.Generics
+Async from Control.Concurrent.Async
+AsyncException from GHC.IO.Exception
+Bifunctor from Data.Bifunctor
+Bits from Data.Bits
+BlockedIndefinitelyOnMVar from GHC.IO.Exception
+BlockedIndefinitelyOnMVar from GHC.IO.Exception
+BlockedIndefinitelyOnSTM from GHC.IO.Exception
+BlockedIndefinitelyOnSTM from GHC.IO.Exception
+Bool from GHC.Types
+Bounded from GHC.Enum
+ByteString from Data.ByteString.Internal
+C1 from GHC.Generics
+CallStack from GHC.Stack.Types
+Chan from Control.Concurrent.Chan
+Char from GHC.Types
+CmpNat from GHC.TypeLits
+Coercible from GHC.Types
+Coercion from Data.Type.Coercion
+Coercion from Data.Type.Coercion
+Comp1 from GHC.Generics
+Complex from Data.Complex
+Concurrently from Control.Concurrent.Async
+Concurrently from Control.Concurrent.Async
+Const from Data.Functor.Const
+Const from Data.Functor.Const
+Constraint from GHC.Types
+Constructor from GHC.Generics
+D# from GHC.Types
+D1 from GHC.Generics
+Datatype from GHC.Generics
+Deadlock from GHC.IO.Exception
+Deadlock from GHC.IO.Exception
+Denormal from GHC.Exception
+DivideByZero from GHC.Exception
+Double from GHC.Types
+Down from Data.Ord
+Down from Data.Ord
+Dual from Data.Monoid
+Dual from Data.Monoid
+EQ from GHC.Types
+Either from Data.Either
+Endo from Data.Monoid
+Endo from Data.Monoid
+Enum from GHC.Enum
+Eq from GHC.Classes
+ErrorCall from GHC.Exception
+ErrorCall from GHC.Exception
+ErrorCallWithLocation from GHC.Exception
+Except from Control.Monad.Trans.Except
+ExceptT from Control.Monad.Trans.Except
+ExceptT from Control.Monad.Trans.Except
+Exception from GHC.Exception
+ExitCode from GHC.IO.Exception
+ExitFailure from GHC.IO.Exception
+ExitSuccess from GHC.IO.Exception
+F# from GHC.Types
+False from GHC.Types
+FatalError from Protolude.Panic
+FatalError from Protolude.Panic
+FilePath from GHC.IO
+FiniteBits from Data.Bits
+First from Data.Monoid
+First from Data.Monoid
+Fixity from GHC.Generics
+FixityI from GHC.Generics
+Float from GHC.Types
+Floating from GHC.Float
+Foldable from Data.Foldable
+Fractional from GHC.Real
+FunPtr from GHC.Ptr
+Functor from GHC.Base
+GT from GHC.Types
+Generic from GHC.Generics
+Generic1 from GHC.Generics
+Handle from GHC.IO.Handle.Types
+HasCallStack from GHC.Stack.Types
+Hashable from Data.Hashable.Class
+HeapOverflow from GHC.IO.Exception
+IO from GHC.Types
+IOException from GHC.IO.Exception
+IOMode from GHC.IO.IOMode
+Identity from Data.Functor.Identity
+Identity from Data.Functor.Identity
+IndexOutOfBounds from GHC.IO.Exception
+Infix from GHC.Generics
+InfixI from GHC.Generics
+Int from GHC.Types
+Int16 from GHC.Int
+Int32 from GHC.Int
+Int64 from GHC.Int
+Int8 from GHC.Int
+IntMap from Data.IntMap.Base
+IntPtr from Foreign.Ptr
+IntSet from Data.IntSet.Base
+Integer from GHC.Integer.Type
+Integral from GHC.Real
+IsLabel from GHC.OverloadedLabels
+IsString from Data.String
+Just from GHC.Base
+K1 from GHC.Generics
+K1 from GHC.Generics
+KnownNat from GHC.TypeLits
+KnownSymbol from GHC.TypeLits
+L1 from GHC.Generics
+LByteString from Protolude
+LT from GHC.Types
+LText from Protolude
+Last from Data.Monoid
+Last from Data.Monoid
+Left from Data.Either
+LeftAssociative from GHC.Generics
+Leniency from Protolude.Conv
+Lenient from Protolude.Conv
+Location from GHC.ExecutionStack.Internal
+Location from GHC.ExecutionStack.Internal
+LossOfPrecision from GHC.Exception
+M1 from GHC.Generics
+M1 from GHC.Generics
+MVar from GHC.MVar
+Map from Data.Map.Base
+MaskedInterruptible from GHC.IO
+MaskedUninterruptible from GHC.IO
+MaskingState from GHC.IO
+Maybe from GHC.Base
+Meta from GHC.Generics
+MetaCons from GHC.Generics
+MetaData from GHC.Generics
+MetaSel from GHC.Generics
+Monad from GHC.Base
+MonadError from Control.Monad.Error.Class
+MonadIO from Control.Monad.IO.Class
+MonadPlus from GHC.Base
+MonadReader from Control.Monad.Reader.Class
+MonadState from Control.Monad.State.Class
+Monoid from GHC.Base
+NFData from Control.DeepSeq
+Nat from GHC.Types
+NestedAtomically from Control.Exception.Base
+NestedAtomically from Control.Exception.Base
+NoMethodError from Control.Exception.Base
+NoMethodError from Control.Exception.Base
+NonEmpty from Data.List.NonEmpty
+NonTermination from Control.Exception.Base
+NonTermination from Control.Exception.Base
+NotAssociative from GHC.Generics
+Nothing from GHC.Base
+Num from GHC.Num
+OnDecodeError from Data.Text.Encoding.Error
+OnError from Data.Text.Encoding.Error
+Option from Data.Semigroup
+Option from Data.Semigroup
+Ord from GHC.Classes
+Ordering from GHC.Types
+Overflow from GHC.Exception
+PatternMatchFail from Control.Exception.Base
+PatternMatchFail from Control.Exception.Base
+Prefix from GHC.Generics
+PrefixI from GHC.Generics
+Print from Protolude.Show
+Product from Data.Monoid
+Product from Data.Monoid
+Proxy from Data.Proxy
+Proxy from Data.Proxy
+Ptr from GHC.Ptr
+QSem from Control.Concurrent.QSem
+QSemN from Control.Concurrent.QSemN
+R1 from GHC.Generics
+Ratio from GHC.Real
+RatioZeroDenominator from GHC.Exception
+Rational from GHC.Real
+Read from GHC.Read
+ReadMode from GHC.IO.IOMode
+ReadWriteMode from GHC.IO.IOMode
+Reader from Control.Monad.Trans.Reader
+ReaderT from Control.Monad.Trans.Reader
+ReaderT from Control.Monad.Trans.Reader
+Real from GHC.Real
+RealFloat from GHC.Float
+RealFrac from GHC.Real
+Rec0 from GHC.Generics
+RecConError from Control.Exception.Base
+RecConError from Control.Exception.Base
+RecSelError from Control.Exception.Base
+RecSelError from Control.Exception.Base
+RecUpdError from Control.Exception.Base
+RecUpdError from Control.Exception.Base
+Refl from Data.Type.Equality
+Rep from GHC.Generics
+Right from Data.Either
+RightAssociative from GHC.Generics
+S1 from GHC.Generics
+ST from GHC.ST
+STM from GHC.Conc.Sync
+Selector from GHC.Generics
+Semigroup from Data.Semigroup
+Semiring from Protolude.Semiring
+Seq from Data.Sequence
+Set from Data.Set.Base
+Show from GHC.Show
+SomeAsyncException from GHC.IO.Exception
+SomeAsyncException from GHC.IO.Exception
+SomeException from GHC.Exception
+SomeException from GHC.Exception
+SomeNat from GHC.TypeLits
+SomeNat from GHC.TypeLits
+SomeSymbol from GHC.TypeLits
+SomeSymbol from GHC.TypeLits
+SrcLoc from GHC.ExecutionStack.Internal
+SrcLoc from GHC.ExecutionStack.Internal
+StablePtr from GHC.Stable
+StackOverflow from GHC.IO.Exception
+State from Control.Monad.Trans.State.Lazy
+StateT from Control.Monad.Trans.State.Lazy
+StateT from Control.Monad.Trans.State.Lazy
+StaticPtr from GHC.StaticPtr
+Storable from Foreign.Storable
+Strict from Protolude.Conv
+StringConv from Protolude.Conv
+Sum from Data.Monoid
+Sum from Data.Monoid
+Symbol from GHC.Types
+Text from Data.Text.Internal
+ThreadId from GHC.Conc.Sync
+ThreadKilled from GHC.IO.Exception
+Traversable from Data.Traversable
+True from GHC.Types
+Type from GHC.Types
+TypeError from Control.Exception.Base
+TypeError from Control.Exception.Base
+TypeRep from Data.Typeable.Internal
+Typeable from Data.Typeable.Internal
+U1 from GHC.Generics
+U1 from GHC.Generics
+URec from GHC.Generics
+UndefinedElement from GHC.IO.Exception
+Underflow from GHC.Exception
+UnicodeException from Data.Text.Encoding.Error
+Unmasked from GHC.IO
+UserInterrupt from GHC.IO.Exception
+V1 from GHC.Generics
+Void from Data.Void
+Word from GHC.Types
+Word16 from GHC.Word
+Word32 from GHC.Word
+Word64 from GHC.Word
+Word8 from GHC.Word
+WordPtr from Foreign.Ptr
+WrappedMonoid from Data.Semigroup
+WriteMode from GHC.IO.IOMode
+ZipList from Control.Applicative
+ZipList from Control.Applicative
+^ from GHC.Real
+^%^ from GHC.Real
+^^ from GHC.Real
+^^%^^ from GHC.Real
+abs from GHC.Num
+absurd from Data.Void
+acos from GHC.Float
+acosh from GHC.Float
+addMVarFinalizer from Control.Concurrent.MVar
+all from Data.Foldable
+allowInterrupt from Control.Exception
+always from GHC.Conc.Sync
+alwaysSucceeds from GHC.Conc.Sync
+and from Data.Foldable
+any from Data.Foldable
+ap from GHC.Base
+appEndo from Data.Monoid
+appendFile from Data.Text.IO
+applyN from Protolude
+asTypeOf from GHC.Base
+asin from GHC.Float
+asinh from GHC.Float
+ask from Control.Monad.Reader.Class
+asks from Control.Monad.Reader.Class
+asum from Data.Foldable
+async from Control.Concurrent.Async
+asyncBound from Control.Concurrent.Async
+asyncExceptionFromException from GHC.IO.Exception
+asyncExceptionToException from GHC.IO.Exception
+asyncOn from Control.Concurrent.Async
+asyncThreadId from Control.Concurrent.Async
+atDef from Protolude.Safe
+atMay from Protolude.Safe
+atan from GHC.Float
+atan2 from GHC.Float
+atanh from GHC.Float
+atomically from GHC.Conc.Sync
+bimap from Data.Bifunctor
+bit from Data.Bits
+bitDefault from Data.Bits
+bitSize from Data.Bits
+bitSizeMaybe from Data.Bits
+bool from Protolude.Bool
+boundedEnumFrom from GHC.Enum
+boundedEnumFromThen from GHC.Enum
+bracket from Control.Exception.Base
+bracketOnError from Control.Exception.Base
+bracket_ from Control.Exception.Base
+break from GHC.List
+byteSwap16 from GHC.Word
+byteSwap32 from GHC.Word
+byteSwap64 from GHC.Word
+callStack from GHC.Stack
+cancel from Control.Concurrent.Async
+cancelWith from Control.Concurrent.Async
+cast from Data.Typeable
+castWith from Data.Type.Equality
+catMaybes from Data.Maybe
+catch from Control.Exception.Base
+catchE from Control.Monad.Trans.Except
+catchError from Control.Monad.Error.Class
+catchJust from Control.Exception.Base
+catchSTM from GHC.Conc.Sync
+catches from Control.Exception
+ceiling from GHC.Real
+check from Control.Monad.STM
+chr from GHC.Char
+cis from Data.Complex
+clearBit from Data.Bits
+coerceWith from Data.Type.Coercion
+compare from GHC.Classes
+comparing from Data.Ord
+complement from Data.Bits
+complementBit from Data.Bits
+conFixity from GHC.Generics
+conIsRecord from GHC.Generics
+conName from GHC.Generics
+concat from Data.Foldable
+concatMap from Data.Foldable
+concatMapM from Protolude.Monad
+concurrently from Control.Concurrent.Async
+conjugate from Data.Complex
+const from GHC.Base
+cos from GHC.Float
+cosh from GHC.Float
+countLeadingZeros from Data.Bits
+countTrailingZeros from Data.Bits
+currentCallStack from GHC.Stack.CCS
+curry from Data.Tuple
+cycle from GHC.List
+cycle1 from Data.Semigroup
+datatypeName from GHC.Generics
+decodeFloat from GHC.Float
+decodeUtf8 from Data.Text.Encoding
+decodeUtf8' from Data.Text.Encoding
+decodeUtf8With from Data.Text.Encoding
+deepseq from Control.DeepSeq
+denominator from GHC.Real
+die from Protolude
+diff from Data.Semigroup
+displayException from GHC.Exception
+div from GHC.Real
+divMod from GHC.Real
+divZeroError from GHC.Real
+drop from GHC.List
+dropWhile from GHC.List
+dupChan from Control.Concurrent.Chan
+either from Data.Either
+eitherA from Protolude.Applicative
+elem from Data.Foldable
+empty from GHC.Base
+encodeFloat from GHC.Float
+encodeUtf8 from Data.Text.Encoding
+enumFrom from GHC.Enum
+enumFromThen from GHC.Enum
+enumFromThenTo from GHC.Enum
+enumFromTo from GHC.Enum
+eqT from Data.Typeable
+evalState from Control.Monad.Trans.State.Lazy
+evalStateT from Control.Monad.Trans.State.Lazy
+evaluate from GHC.IO
+even from GHC.Real
+execState from Control.Monad.Trans.State.Lazy
+execStateT from Control.Monad.Trans.State.Lazy
+exitFailure from System.Exit
+exitSuccess from System.Exit
+exitWith from System.Exit
+exp from GHC.Float
+expm1 from GHC.Float
+exponent from GHC.Float
+fatalErrorMessage from Protolude.Panic
+filter from GHC.List
+filterM from Control.Monad
+finally from Control.Exception.Base
+find from Data.Foldable
+finiteBitSize from Data.Bits
+first from Data.Bifunctor
+fix from Data.Function
+fixST from GHC.ST
+flip from GHC.Base
+floatDigits from GHC.Float
+floatRadix from GHC.Float
+floatRange from GHC.Float
+floor from GHC.Real
+fmap from GHC.Base
+fmapDefault from Data.Traversable
+fold from Data.Foldable
+foldM from Control.Monad
+foldM_ from Control.Monad
+foldMap from Data.Foldable
+foldMapDefault from Data.Traversable
+foldl from Data.Foldable
+foldl' from Data.Foldable
+foldl1May from Protolude.Safe
+foldl1May' from Protolude.Safe
+foldlM from Data.Foldable
+foldr from Data.Foldable
+foldr' from Data.Foldable
+foldr1May from Protolude.Safe
+foldrM from Data.Foldable
+for from Data.Traversable
+forM from Data.Traversable
+forM_ from Data.Foldable
+for_ from Data.Foldable
+force from Control.DeepSeq
+foreach from Protolude.Functor
+forever from Control.Monad
+forkFinally from Control.Concurrent
+forkIO from GHC.Conc.Sync
+forkIOWithUnmask from GHC.Conc.Sync
+forkOS from Control.Concurrent
+forkOSWithUnmask from Control.Concurrent
+forkOn from GHC.Conc.Sync
+forkOnWithUnmask from GHC.Conc.Sync
+from from GHC.Generics
+fromEnum from GHC.Enum
+fromException from GHC.Exception
+fromInteger from GHC.Num
+fromIntegral from GHC.Real
+fromLabel from GHC.OverloadedLabels
+fromLeft from Protolude.Either
+fromMaybe from Data.Maybe
+fromRational from GHC.Real
+fromRight from Protolude.Either
+fromStrict from Data.Text.Lazy
+fst from Data.Tuple
+functionName from GHC.ExecutionStack.Internal
+gcastWith from Data.Type.Equality
+gcd from GHC.Real
+gcdInt' from GHC.Real
+gcdWord' from GHC.Real
+genericDrop from Data.OldList
+genericLength from Data.OldList
+genericReplicate from Data.OldList
+genericSplitAt from Data.OldList
+genericTake from Data.OldList
+get from Control.Monad.State.Class
+getAll from Data.Monoid
+getAlt from Data.Monoid
+getAny from Data.Monoid
+getArgs from System.Environment
+getCallStack from GHC.Stack.Types
+getChanContents from Control.Concurrent.Chan
+getConst from Data.Functor.Const
+getContents from Data.Text.IO
+getDual from Data.Monoid
+getFirst from Data.Monoid
+getLast from Data.Monoid
+getLine from Data.Text.IO
+getMaskingState from GHC.IO
+getNumCapabilities from GHC.Conc.Sync
+getOption from Data.Semigroup
+getProduct from Data.Monoid
+getStackTrace from GHC.ExecutionStack
+getSum from Data.Monoid
+getZipList from Control.Applicative
+gets from Control.Monad.State.Class
+group from Data.OldList
+groupBy from Data.OldList
+guard from Control.Monad
+guardM from Protolude.Bool
+guarded from Protolude
+guardedA from Protolude
+hPutStr from Protolude.Show
+hPutStrLn from Protolude.Show
+handle from Control.Exception.Base
+handleJust from Control.Exception.Base
+hash from Data.Hashable.Class
+hashUsing from Data.Hashable.Class
+hashWithSalt from Data.Hashable.Class
+head from Protolude.List
+headDef from Protolude.Safe
+headMay from Protolude.Safe
+hush from Protolude.Exceptions
+identity from Protolude
+ifM from Protolude.Bool
+ignore from Data.Text.Encoding.Error
+imagPart from Data.Complex
+infinity from GHC.Real
+initDef from Protolude.Safe
+initMay from Protolude.Safe
+initSafe from Protolude.Safe
+inits from Data.OldList
+integralEnumFrom from GHC.Real
+integralEnumFromThen from GHC.Real
+integralEnumFromThenTo from GHC.Real
+integralEnumFromTo from GHC.Real
+interact from Data.Text.IO
+intercalate from Data.OldList
+interruptible from GHC.IO
+intersperse from Data.OldList
+ioError from GHC.IO.Exception
+isCurrentThreadBound from Control.Concurrent
+isDenormalized from GHC.Float
+isEmptyChan from Control.Concurrent.Chan
+isEmptyMVar from GHC.MVar
+isIEEE from GHC.Float
+isInfinite from GHC.Float
+isJust from Data.Maybe
+isLeft from Data.Either
+isNaN from GHC.Float
+isNegativeZero from GHC.Float
+isNewtype from GHC.Generics
+isNothing from Data.Maybe
+isPrefixOf from Data.OldList
+isRight from Data.Either
+isSigned from Data.Bits
+iterate from GHC.List
+join from GHC.Base
+killThread from GHC.Conc.Sync
+lastDef from Protolude.Safe
+lastMay from Protolude.Safe
+lcm from GHC.Real
+leftToMaybe from Protolude.Either
+lefts from Data.Either
+length from Data.Foldable
+lenientDecode from Data.Text.Encoding.Error
+lift from Control.Monad.Trans.Class
+liftA from GHC.Base
+liftA2 from GHC.Base
+liftA3 from GHC.Base
+liftAA2 from Protolude.Applicative
+liftIO from Control.Monad.IO.Class
+liftIO1 from Protolude
+liftIO2 from Protolude
+liftM from GHC.Base
+liftM' from Protolude.Monad
+liftM2 from GHC.Base
+liftM2' from Protolude.Monad
+liftM3 from GHC.Base
+liftM4 from GHC.Base
+liftM5 from GHC.Base
+lines from Data.Text
+link from Control.Concurrent.Async
+link2 from Control.Concurrent.Async
+list from Protolude.List
+listToMaybe from Data.Maybe
+local from Control.Monad.Reader.Class
+log from GHC.Float
+log1mexp from GHC.Float
+log1p from GHC.Float
+log1pexp from GHC.Float
+logBase from GHC.Float
+magnitude from Data.Complex
+many from GHC.Base
+map from Protolude
+mapAccumL from Data.Traversable
+mapAccumR from Data.Traversable
+mapAndUnzipM from Control.Monad
+mapExcept from Control.Monad.Trans.Except
+mapExceptT from Control.Monad.Trans.Except
+mapException from Control.Exception.Base
+mapM from Data.Traversable
+mapM_ from Data.Foldable
+mapMaybe from Data.Maybe
+mappend from GHC.Base
+mask from GHC.IO
+mask_ from GHC.IO
+max from GHC.Classes
+maxBound from GHC.Enum
+maxInt from GHC.Base
+maximum from Data.Foldable
+maximumBy from Data.Foldable
+maximumDef from Protolude.Safe
+maximumMay from Protolude.Safe
+maybe from Data.Maybe
+maybeEmpty from Protolude.Either
+maybeToEither from Protolude.Either
+maybeToLeft from Protolude.Either
+maybeToList from Data.Maybe
+maybeToRight from Protolude.Either
+mconcat from GHC.Base
+mempty from GHC.Base
+mfilter from Control.Monad
+min from GHC.Classes
+minBound from GHC.Enum
+minInt from GHC.Base
+minimum from Data.Foldable
+minimumBy from Data.Foldable
+minimumDef from Protolude.Safe
+minimumMay from Protolude.Safe
+mkPolar from Data.Complex
+mkWeakMVar from Control.Concurrent.MVar
+mkWeakThreadId from GHC.Conc.Sync
+mod from GHC.Real
+modify from Control.Monad.State.Class
+modifyMVar from Control.Concurrent.MVar
+modifyMVarMasked from Control.Concurrent.MVar
+modifyMVarMasked_ from Control.Concurrent.MVar
+modifyMVar_ from Control.Concurrent.MVar
+moduleName from GHC.Generics
+mplus from GHC.Base
+msum from Data.Foldable
+mtimesDefault from Data.Semigroup
+myThreadId from GHC.Conc.Sync
+mzero from GHC.Base
+natVal from GHC.TypeLits
+negate from GHC.Num
+newChan from Control.Concurrent.Chan
+newEmptyMVar from GHC.MVar
+newMVar from GHC.MVar
+newQSem from Control.Concurrent.QSem
+newQSemN from Control.Concurrent.QSemN
+nonEmpty from Data.List.NonEmpty
+not from GHC.Classes
+notANumber from GHC.Real
+notElem from Data.Foldable
+notImplemented from Debug
+note from Protolude.Exceptions
+null from Data.Foldable
+numerator from GHC.Real
+numericEnumFrom from GHC.Real
+numericEnumFromThen from GHC.Real
+numericEnumFromThenTo from GHC.Real
+numericEnumFromTo from GHC.Real
+objectName from GHC.ExecutionStack.Internal
+odd from GHC.Real
+on from Data.Function
+onException from Control.Exception.Base
+one from Protolude.Semiring
+openFile from GHC.IO.Handle.FD
+option from Data.Semigroup
+optional from Control.Applicative
+or from Data.Foldable
+orAlt from Protolude.Applicative
+orElse from GHC.Conc.Sync
+orEmpty from Protolude.Applicative
+ord from GHC.Base
+ordNub from Protolude.List
+otherwise from GHC.Base
+overflowError from GHC.Real
+packageName from GHC.Generics
+panic from Protolude.Panic
+partitionEithers from Data.Either
+pass from Protolude
+permutations from Data.OldList
+phase from Data.Complex
+pi from GHC.Float
+polar from Data.Complex
+poll from Control.Concurrent.Async
+popCount from Data.Bits
+popCountDefault from Data.Bits
+pred from GHC.Enum
+prettyCallStack from GHC.Exception
+prettySrcLoc from GHC.Exception
+print from Protolude
+product from Protolude.List
+properFraction from GHC.Real
+pure from GHC.Base
+purer from Protolude.Applicative
+put from Control.Monad.State.Class
+putByteString from Protolude.Show
+putErrLn from Protolude.Show
+putErrText from Protolude.Show
+putLByteString from Protolude.Show
+putLText from Protolude.Show
+putMVar from GHC.MVar
+putStr from Protolude.Show
+putStrLn from Protolude.Show
+putText from Protolude.Show
+quot from GHC.Real
+quotRem from GHC.Real
+race from Control.Concurrent.Async
+race_ from Control.Concurrent.Async
+ratioPrec from GHC.Real
+ratioPrec1 from GHC.Real
+ratioZeroDenominatorError from GHC.Real
+readChan from Control.Concurrent.Chan
+readEither from Text.Read
+readFile from Data.Text.IO
+readMVar from GHC.MVar
+readMaybe from Text.Read
+reader from Control.Monad.Reader.Class
+reads from Text.Read
+realPart from Data.Complex
+realToFrac from GHC.Real
+recip from GHC.Real
+reduce from GHC.Real
+rem from GHC.Real
+repeat from GHC.List
+replace from Data.Text.Encoding.Error
+replicate from GHC.List
+replicateM from Control.Monad
+replicateM_ from Control.Monad
+repr from Data.Type.Coercion
+retry from GHC.Conc.Sync
+return from GHC.Base
+reverse from GHC.List
+rightToMaybe from Protolude.Either
+rights from Data.Either
+rnf from Control.DeepSeq
+rotate from Data.Bits
+rotateL from Data.Bits
+rotateR from Data.Bits
+round from GHC.Real
+rtsSupportsBoundThreads from Control.Concurrent
+runConcurrently from Control.Concurrent.Async
+runExcept from Control.Monad.Trans.Except
+runExceptT from Control.Monad.Trans.Except
+runIdentity from Data.Functor.Identity
+runInBoundThread from Control.Concurrent
+runInUnboundThread from Control.Concurrent
+runReader from Control.Monad.Trans.Reader
+runReaderT from Control.Monad.Trans.Reader
+runST from GHC.ST
+runState from Control.Monad.Trans.State.Lazy
+runStateT from Control.Monad.Trans.State.Lazy
+scaleFloat from GHC.Float
+scanl from GHC.List
+scanl' from GHC.List
+scanr from GHC.List
+sconcat from Data.Semigroup
+second from Data.Bifunctor
+selDecidedStrictness from GHC.Generics
+selName from GHC.Generics
+selSourceStrictness from GHC.Generics
+selSourceUnpackedness from GHC.Generics
+seq from GHC.Prim
+sequence from Data.Traversable
+sequenceA from Data.Traversable
+sequenceA_ from Data.Foldable
+sequence_ from Data.Foldable
+setBit from Data.Bits
+setNumCapabilities from GHC.Conc.Sync
+shift from Data.Bits
+shiftL from Data.Bits
+shiftR from Data.Bits
+show from Protolude
+showStackTrace from GHC.ExecutionStack
+signalQSem from Control.Concurrent.QSem
+signalQSemN from Control.Concurrent.QSemN
+significand from GHC.Float
+signum from GHC.Num
+sin from GHC.Float
+sinh from GHC.Float
+snd from Data.Tuple
+some from GHC.Base
+someNatVal from GHC.TypeLits
+someSymbolVal from GHC.TypeLits
+sort from Data.OldList
+sortBy from Data.OldList
+sortOn from Protolude.List
+sourceColumn from GHC.ExecutionStack.Internal
+sourceFile from GHC.ExecutionStack.Internal
+sourceLine from GHC.ExecutionStack.Internal
+splitAt from GHC.List
+sqrt from GHC.Float
+srcLoc from GHC.ExecutionStack.Internal
+state from Control.Monad.State.Class
+stderr from GHC.IO.Handle.FD
+stdin from GHC.IO.Handle.FD
+stdout from GHC.IO.Handle.FD
+stimes from Data.Semigroup
+stimesIdempotent from Data.Semigroup
+stimesIdempotentMonoid from Data.Semigroup
+stimesMonoid from Data.Semigroup
+strConv from Protolude.Conv
+strictDecode from Data.Text.Encoding.Error
+subsequences from Data.OldList
+subtract from GHC.Num
+succ from GHC.Enum
+sum from Protolude.List
+swap from Data.Tuple
+swapMVar from Control.Concurrent.MVar
+sym from Data.Type.Equality
+symbolVal from GHC.TypeLits
+tailDef from Protolude.Safe
+tailMay from Protolude.Safe
+tailSafe from Protolude.Safe
+tails from Data.OldList
+take from GHC.List
+takeMVar from GHC.MVar
+takeWhile from GHC.List
+tan from GHC.Float
+tanh from GHC.Float
+testBit from Data.Bits
+testBitDefault from Data.Bits
+threadCapability from GHC.Conc.Sync
+threadDelay from GHC.Conc.IO
+threadWaitRead from Control.Concurrent
+threadWaitReadSTM from Control.Concurrent
+threadWaitWrite from Control.Concurrent
+threadWaitWriteSTM from Control.Concurrent
+throwE from Control.Monad.Trans.Except
+throwError from Control.Monad.Error.Class
+throwIO from Protolude
+throwSTM from GHC.Conc.Sync
+throwTo from Protolude
+to from GHC.Generics
+toEnum from GHC.Enum
+toException from GHC.Exception
+toInteger from GHC.Real
+toIntegralSized from Data.Bits
+toList from Data.Foldable
+toRational from GHC.Real
+toS from Protolude.Conv
+toSL from Protolude.Conv
+toStrict from Data.Text.Lazy
+trace from Debug
+traceIO from Debug
+traceId from Debug
+traceM from Debug
+traceShow from Debug
+traceShowId from Debug
+traceShowM from Debug
+trans from Data.Type.Equality
+transpose from Data.OldList
+traverse from Data.Traversable
+traverse_ from Data.Foldable
+truncate from GHC.Real
+try from Control.Exception.Base
+tryIO from Protolude.Exceptions
+tryJust from Control.Exception.Base
+tryPutMVar from GHC.MVar
+tryReadMVar from GHC.MVar
+tryTakeMVar from GHC.MVar
+typeRep from Data.Typeable.Internal
+unComp1 from GHC.Generics
+unGetChan from Control.Concurrent.Chan
+unK1 from GHC.Generics
+unM1 from GHC.Generics
+uncons from Protolude
+uncurry from Data.Tuple
+undefined from Debug
+unfoldr from Data.OldList
+uninterruptibleMask from GHC.IO
+uninterruptibleMask_ from GHC.IO
+unless from Control.Monad
+unlessM from Protolude.Bool
+unlines from Data.Text
+unsnoc from Protolude
+until from GHC.Base
+unwords from Data.Text
+unzip from GHC.List
+vacuous from Data.Void
+void from Data.Functor
+wait from Control.Concurrent.Async
+waitAny from Control.Concurrent.Async
+waitAnyCancel from Control.Concurrent.Async
+waitAnyCatch from Control.Concurrent.Async
+waitAnyCatchCancel from Control.Concurrent.Async
+waitBoth from Control.Concurrent.Async
+waitCatch from Control.Concurrent.Async
+waitEither from Control.Concurrent.Async
+waitEitherCancel from Control.Concurrent.Async
+waitEitherCatch from Control.Concurrent.Async
+waitEitherCatchCancel from Control.Concurrent.Async
+waitEither_ from Control.Concurrent.Async
+waitQSem from Control.Concurrent.QSem
+waitQSemN from Control.Concurrent.QSemN
+when from GHC.Base
+whenM from Protolude.Bool
+withAsync from Control.Concurrent.Async
+withAsyncBound from Control.Concurrent.Async
+withAsyncOn from Control.Concurrent.Async
+withExcept from Control.Monad.Trans.Except
+withExceptT from Control.Monad.Trans.Except
+withFile from System.IO
+withFrozenCallStack from GHC.Stack
+withMVar from Control.Concurrent.MVar
+withMVarMasked from Control.Concurrent.MVar
+withState from Control.Monad.Trans.State.Lazy
+witness from Debug
+words from Data.Text
+writeChan from Control.Concurrent.Chan
+writeFile from Data.Text.IO
+writeList2Chan from Control.Concurrent.Chan
+xor from Data.Bits
+zero from Protolude.Semiring
+zeroBits from Data.Bits
+zip from GHC.List
+zipWith from GHC.List
+zipWithM from Control.Monad
+zipWithM_ from Control.Monad
+|| from GHC.Classes
+||^ from Protolude.Bool

export_lists/protolude-8.exports

@@ -0,0 +1,956 @@
+$ from GHC.Base
+$! from Protolude.Base
+$!! from Control.DeepSeq
+$> from Data.Functor
+% from GHC.Real
+& from Data.Function
+&& from GHC.Classes
+&&^ from Protolude.Bool
+* from GHC.Num
+* from GHC.Types
+** from GHC.Float
+*> from GHC.Base
++ from GHC.Num
+++ from GHC.Base
+- from GHC.Num
+. from GHC.Base
+.&. from Data.Bits
+.|. from Data.Bits
+/ from GHC.Real
+/= from GHC.Classes
+:% from GHC.Real
+:*: from GHC.Generics
+:*: from GHC.Generics
+:+ from Data.Complex
+:+: from GHC.Generics
+:.: from GHC.Generics
+:| from Data.List.NonEmpty
+:~: from Data.Type.Equality
+< from GHC.Classes
+<$ from GHC.Base
+<$!> from Control.Monad
+<$> from Data.Functor
+<&&> from Protolude.Bool
+<&> from Protolude.Functor
+<* from GHC.Base
+<**> from GHC.Base
+<*> from GHC.Base
+<.> from Protolude.Semiring
+<<$>> from Protolude.Functor
+<<*>> from Protolude.Applicative
+<= from GHC.Classes
+<=< from Control.Monad
+<> from Data.Monoid
+<|> from GHC.Base
+<||> from Protolude.Bool
+=<< from GHC.Base
+== from GHC.Classes
+== from Data.Type.Equality
+> from GHC.Classes
+>= from GHC.Classes
+>=> from Control.Monad
+>> from GHC.Base
+>>= from GHC.Base
+All from Data.Monoid
+All from Data.Monoid
+AllocationLimitExceeded from GHC.IO.Exception
+AllocationLimitExceeded from GHC.IO.Exception
+Alt from Data.Monoid
+Alt from Data.Monoid
+Alternative from GHC.Base
+Any from Data.Monoid
+Any from Data.Monoid
+AppendMode from GHC.IO.IOMode
+Applicative from GHC.Base
+ArithException from GHC.Exception
+ArrayException from GHC.IO.Exception
+AssertionFailed from GHC.IO.Exception
+AssertionFailed from GHC.IO.Exception
+Associativity from GHC.Generics
+Async from Control.Concurrent.Async
+AsyncException from GHC.IO.Exception
+Bifunctor from Data.Bifunctor
+Bits from Data.Bits
+BlockedIndefinitelyOnMVar from GHC.IO.Exception
+BlockedIndefinitelyOnMVar from GHC.IO.Exception
+BlockedIndefinitelyOnSTM from GHC.IO.Exception
+BlockedIndefinitelyOnSTM from GHC.IO.Exception
+Bool from GHC.Types
+Bounded from GHC.Enum
+ByteString from Data.ByteString.Internal
+C1 from GHC.Generics
+CallStack from GHC.Stack.Types
+Chan from Control.Concurrent.Chan
+Char from GHC.Types
+CmpNat from GHC.TypeLits
+Coercible from GHC.Types
+Coercion from Data.Type.Coercion
+Coercion from Data.Type.Coercion
+Comp1 from GHC.Generics
+Complex from Data.Complex
+Concurrently from Control.Concurrent.Async
+Concurrently from Control.Concurrent.Async
+Const from Data.Functor.Const
+Const from Data.Functor.Const
+Constraint from GHC.Types
+Constructor from GHC.Generics
+D# from GHC.Types
+D1 from GHC.Generics
+Datatype from GHC.Generics
+Deadlock from GHC.IO.Exception
+Deadlock from GHC.IO.Exception
+Denormal from GHC.Exception
+DivideByZero from GHC.Exception
+Double from GHC.Types
+Down from Data.Ord
+Down from Data.Ord
+Dual from Data.Monoid
+Dual from Data.Monoid
+EQ from GHC.Types
+Either from Data.Either
+Endo from Data.Monoid
+Endo from Data.Monoid
+Enum from GHC.Enum
+Eq from GHC.Classes
+ErrorCall from GHC.Exception
+ErrorCall from GHC.Exception
+ErrorCallWithLocation from GHC.Exception
+Except from Control.Monad.Trans.Except
+ExceptT from Control.Monad.Trans.Except
+ExceptT from Control.Monad.Trans.Except
+Exception from GHC.Exception
+ExitCode from GHC.IO.Exception
+ExitFailure from GHC.IO.Exception
+ExitSuccess from GHC.IO.Exception
+F# from GHC.Types
+False from GHC.Types
+FatalError from Protolude.Panic
+FatalError from Protolude.Panic
+FilePath from GHC.IO
+FiniteBits from Data.Bits
+First from Data.Monoid
+First from Data.Monoid
+Fixity from GHC.Generics
+FixityI from GHC.Generics
+Float from GHC.Types
+Floating from GHC.Float
+Foldable from Data.Foldable
+Fractional from GHC.Real
+FunPtr from GHC.Ptr
+Functor from GHC.Base
+GT from GHC.Types
+Generic from GHC.Generics
+Generic1 from GHC.Generics
+Handle from GHC.IO.Handle.Types
+HasCallStack from GHC.Stack.Types
+Hashable from Data.Hashable.Class
+HeapOverflow from GHC.IO.Exception
+IO from GHC.Types
+IOException from GHC.IO.Exception
+IOMode from GHC.IO.IOMode
+Identity from Data.Functor.Identity
+Identity from Data.Functor.Identity
+IndexOutOfBounds from GHC.IO.Exception
+Infix from GHC.Generics
+InfixI from GHC.Generics
+Int from GHC.Types
+Int16 from GHC.Int
+Int32 from GHC.Int
+Int64 from GHC.Int
+Int8 from GHC.Int
+IntMap from Data.IntMap.Base
+IntPtr from Foreign.Ptr
+IntSet from Data.IntSet.Base
+Integer from GHC.Integer.Type
+Integral from GHC.Real
+IsLabel from GHC.OverloadedLabels
+IsString from Data.String
+Just from GHC.Base
+K1 from GHC.Generics
+K1 from GHC.Generics
+KnownNat from GHC.TypeLits
+KnownSymbol from GHC.TypeLits
+L1 from GHC.Generics
+LByteString from Protolude
+LT from GHC.Types
+LText from Protolude
+Last from Data.Monoid
+Last from Data.Monoid
+Left from Data.Either
+LeftAssociative from GHC.Generics
+Leniency from Protolude.Conv
+Lenient from Protolude.Conv
+Location from GHC.ExecutionStack.Internal
+Location from GHC.ExecutionStack.Internal
+LossOfPrecision from GHC.Exception
+M1 from GHC.Generics
+M1 from GHC.Generics
+MVar from GHC.MVar
+Map from Data.Map.Base
+MaskedInterruptible from GHC.IO
+MaskedUninterruptible from GHC.IO
+MaskingState from GHC.IO
+Maybe from GHC.Base
+Meta from GHC.Generics
+MetaCons from GHC.Generics
+MetaData from GHC.Generics
+MetaSel from GHC.Generics
+Monad from GHC.Base
+MonadError from Control.Monad.Error.Class
+MonadIO from Control.Monad.IO.Class
+MonadPlus from GHC.Base
+MonadReader from Control.Monad.Reader.Class
+MonadState from Control.Monad.State.Class
+Monoid from GHC.Base
+NFData from Control.DeepSeq
+Nat from GHC.Types
+NestedAtomically from Control.Exception.Base
+NestedAtomically from Control.Exception.Base
+NoMethodError from Control.Exception.Base
+NoMethodError from Control.Exception.Base
+NonEmpty from Data.List.NonEmpty
+NonTermination from Control.Exception.Base
+NonTermination from Control.Exception.Base
+NotAssociative from GHC.Generics
+Nothing from GHC.Base
+Num from GHC.Num
+OnDecodeError from Data.Text.Encoding.Error
+OnError from Data.Text.Encoding.Error
+Option from Data.Semigroup
+Option from Data.Semigroup
+Ord from GHC.Classes
+Ordering from GHC.Types
+Overflow from GHC.Exception
+PatternMatchFail from Control.Exception.Base
+PatternMatchFail from Control.Exception.Base
+Prefix from GHC.Generics
+PrefixI from GHC.Generics
+Print from Protolude.Show
+Product from Data.Monoid
+Product from Data.Monoid
+Proxy from Data.Proxy
+Proxy from Data.Proxy
+Ptr from GHC.Ptr
+QSem from Control.Concurrent.QSem
+QSemN from Control.Concurrent.QSemN
+R1 from GHC.Generics
+Ratio from GHC.Real
+RatioZeroDenominator from GHC.Exception
+Rational from GHC.Real
+Read from GHC.Read
+ReadMode from GHC.IO.IOMode
+ReadWriteMode from GHC.IO.IOMode
+Reader from Control.Monad.Trans.Reader
+ReaderT from Control.Monad.Trans.Reader
+ReaderT from Control.Monad.Trans.Reader
+Real from GHC.Real
+RealFloat from GHC.Float
+RealFrac from GHC.Real
+Rec0 from GHC.Generics
+RecConError from Control.Exception.Base
+RecConError from Control.Exception.Base
+RecSelError from Control.Exception.Base
+RecSelError from Control.Exception.Base
+RecUpdError from Control.Exception.Base
+RecUpdError from Control.Exception.Base
+Refl from Data.Type.Equality
+Rep from GHC.Generics
+Right from Data.Either
+RightAssociative from GHC.Generics
+S1 from GHC.Generics
+ST from GHC.ST
+STM from GHC.Conc.Sync
+Selector from GHC.Generics
+Semigroup from Data.Semigroup
+Semiring from Protolude.Semiring
+Seq from Data.Sequence
+Set from Data.Set.Base
+Show from GHC.Show
+SomeAsyncException from GHC.IO.Exception
+SomeAsyncException from GHC.IO.Exception
+SomeException from GHC.Exception
+SomeException from GHC.Exception
+SomeNat from GHC.TypeLits
+SomeNat from GHC.TypeLits
+SomeSymbol from GHC.TypeLits
+SomeSymbol from GHC.TypeLits
+SrcLoc from GHC.ExecutionStack.Internal
+SrcLoc from GHC.ExecutionStack.Internal
+StablePtr from GHC.Stable
+StackOverflow from GHC.IO.Exception
+State from Control.Monad.Trans.State.Lazy
+StateT from Control.Monad.Trans.State.Lazy
+StateT from Control.Monad.Trans.State.Lazy
+StaticPtr from GHC.StaticPtr
+Storable from Foreign.Storable
+Strict from Protolude.Conv
+StringConv from Protolude.Conv
+Sum from Data.Monoid
+Sum from Data.Monoid
+Symbol from GHC.Types
+Text from Data.Text.Internal
+ThreadId from GHC.Conc.Sync
+ThreadKilled from GHC.IO.Exception
+Traversable from Data.Traversable
+True from GHC.Types
+Type from GHC.Types
+TypeError from Control.Exception.Base
+TypeError from Control.Exception.Base
+TypeRep from Data.Typeable.Internal
+Typeable from Data.Typeable.Internal
+U1 from GHC.Generics
+U1 from GHC.Generics
+URec from GHC.Generics
+UndefinedElement from GHC.IO.Exception
+Underflow from GHC.Exception
+UnicodeException from Data.Text.Encoding.Error
+Unmasked from GHC.IO
+UserInterrupt from GHC.IO.Exception
+V1 from GHC.Generics
+Void from Data.Void
+Word from GHC.Types
+Word16 from GHC.Word
+Word32 from GHC.Word
+Word64 from GHC.Word
+Word8 from GHC.Word
+WordPtr from Foreign.Ptr
+WrappedMonoid from Data.Semigroup
+WriteMode from GHC.IO.IOMode
+ZipList from Control.Applicative
+ZipList from Control.Applicative
+^ from GHC.Real
+^%^ from GHC.Real
+^^ from GHC.Real
+^^%^^ from GHC.Real
+abs from GHC.Num
+absurd from Data.Void
+acos from GHC.Float
+acosh from GHC.Float
+addMVarFinalizer from Control.Concurrent.MVar
+all from Data.Foldable
+allowInterrupt from Control.Exception
+always from GHC.Conc.Sync
+alwaysSucceeds from GHC.Conc.Sync
+and from Data.Foldable
+any from Data.Foldable
+ap from GHC.Base
+appEndo from Data.Monoid
+appendFile from Data.Text.IO
+applyN from Protolude
+asTypeOf from GHC.Base
+asin from GHC.Float
+asinh from GHC.Float
+ask from Control.Monad.Reader.Class
+asks from Control.Monad.Reader.Class
+asum from Data.Foldable
+async from Control.Concurrent.Async
+asyncBound from Control.Concurrent.Async
+asyncExceptionFromException from GHC.IO.Exception
+asyncExceptionToException from GHC.IO.Exception
+asyncOn from Control.Concurrent.Async
+asyncThreadId from Control.Concurrent.Async
+atDef from Protolude.Safe
+atMay from Protolude.Safe
+atan from GHC.Float
+atan2 from GHC.Float
+atanh from GHC.Float
+atomically from GHC.Conc.Sync
+bimap from Data.Bifunctor
+bit from Data.Bits
+bitDefault from Data.Bits
+bitSize from Data.Bits
+bitSizeMaybe from Data.Bits
+bool from Protolude.Bool
+boundedEnumFrom from GHC.Enum
+boundedEnumFromThen from GHC.Enum
+bracket from Control.Exception.Base
+bracketOnError from Control.Exception.Base
+bracket_ from Control.Exception.Base
+break from GHC.List
+byteSwap16 from GHC.Word
+byteSwap32 from GHC.Word
+byteSwap64 from GHC.Word
+callStack from GHC.Stack
+cancel from Control.Concurrent.Async
+cancelWith from Control.Concurrent.Async
+cast from Data.Typeable
+castWith from Data.Type.Equality
+catMaybes from Data.Maybe
+catch from Control.Exception.Base
+catchE from Control.Monad.Trans.Except
+catchError from Control.Monad.Error.Class
+catchJust from Control.Exception.Base
+catchSTM from GHC.Conc.Sync
+catches from Control.Exception
+ceiling from GHC.Real
+check from Control.Monad.STM
+chr from GHC.Char
+cis from Data.Complex
+clearBit from Data.Bits
+coerceWith from Data.Type.Coercion
+compare from GHC.Classes
+comparing from Data.Ord
+complement from Data.Bits
+complementBit from Data.Bits
+conFixity from GHC.Generics
+conIsRecord from GHC.Generics
+conName from GHC.Generics
+concat from Data.Foldable
+concatMap from Data.Foldable
+concatMapM from Protolude.Monad
+concurrently from Control.Concurrent.Async
+conjugate from Data.Complex
+const from GHC.Base
+cos from GHC.Float
+cosh from GHC.Float
+countLeadingZeros from Data.Bits
+countTrailingZeros from Data.Bits
+currentCallStack from GHC.Stack.CCS
+curry from Data.Tuple
+cycle from GHC.List
+cycle1 from Data.Semigroup
+datatypeName from GHC.Generics
+decodeFloat from GHC.Float
+decodeUtf8 from Data.Text.Encoding
+decodeUtf8' from Data.Text.Encoding
+decodeUtf8With from Data.Text.Encoding
+deepseq from Control.DeepSeq
+denominator from GHC.Real
+die from Protolude
+diff from Data.Semigroup
+displayException from GHC.Exception
+div from GHC.Real
+divMod from GHC.Real
+divZeroError from GHC.Real
+drop from GHC.List
+dropWhile from GHC.List
+dupChan from Control.Concurrent.Chan
+either from Data.Either
+eitherA from Protolude.Applicative
+elem from Data.Foldable
+empty from GHC.Base
+encodeFloat from GHC.Float
+encodeUtf8 from Data.Text.Encoding
+enumFrom from GHC.Enum
+enumFromThen from GHC.Enum
+enumFromThenTo from GHC.Enum
+enumFromTo from GHC.Enum
+eqT from Data.Typeable
+evalState from Control.Monad.Trans.State.Lazy
+evalStateT from Control.Monad.Trans.State.Lazy
+evaluate from GHC.IO
+even from GHC.Real
+execState from Control.Monad.Trans.State.Lazy
+execStateT from Control.Monad.Trans.State.Lazy
+exitFailure from System.Exit
+exitSuccess from System.Exit
+exitWith from System.Exit
+exp from GHC.Float
+expm1 from GHC.Float
+exponent from GHC.Float
+fatalErrorMessage from Protolude.Panic
+filter from GHC.List
+filterM from Control.Monad
+finally from Control.Exception.Base
+find from Data.Foldable
+finiteBitSize from Data.Bits
+first from Data.Bifunctor
+fix from Data.Function
+fixST from GHC.ST
+flip from GHC.Base
+floatDigits from GHC.Float
+floatRadix from GHC.Float
+floatRange from GHC.Float
+floor from GHC.Real
+fmap from GHC.Base
+fmapDefault from Data.Traversable
+fold from Data.Foldable
+foldM from Control.Monad
+foldM_ from Control.Monad
+foldMap from Data.Foldable
+foldMapDefault from Data.Traversable
+foldl from Data.Foldable
+foldl' from Data.Foldable
+foldl1May from Protolude.Safe
+foldl1May' from Protolude.Safe
+foldlM from Data.Foldable
+foldr from Data.Foldable
+foldr' from Data.Foldable
+foldr1May from Protolude.Safe
+foldrM from Data.Foldable
+for from Data.Traversable
+forM from Data.Traversable
+forM_ from Data.Foldable
+for_ from Data.Foldable
+force from Control.DeepSeq
+foreach from Protolude.Functor
+forever from Control.Monad
+forkFinally from Control.Concurrent
+forkIO from GHC.Conc.Sync
+forkIOWithUnmask from GHC.Conc.Sync
+forkOS from Control.Concurrent
+forkOSWithUnmask from Control.Concurrent
+forkOn from GHC.Conc.Sync
+forkOnWithUnmask from GHC.Conc.Sync
+from from GHC.Generics
+fromEnum from GHC.Enum
+fromException from GHC.Exception
+fromInteger from GHC.Num
+fromIntegral from GHC.Real
+fromLabel from GHC.OverloadedLabels
+fromLeft from Protolude.Either
+fromMaybe from Data.Maybe
+fromRational from GHC.Real
+fromRight from Protolude.Either
+fromStrict from Data.Text.Lazy
+fst from Data.Tuple
+functionName from GHC.ExecutionStack.Internal
+gcastWith from Data.Type.Equality
+gcd from GHC.Real
+gcdInt' from GHC.Real
+gcdWord' from GHC.Real
+genericDrop from Data.OldList
+genericLength from Data.OldList
+genericReplicate from Data.OldList
+genericSplitAt from Data.OldList
+genericTake from Data.OldList
+get from Control.Monad.State.Class
+getAll from Data.Monoid
+getAlt from Data.Monoid
+getAny from Data.Monoid
+getArgs from System.Environment
+getCallStack from GHC.Stack.Types
+getChanContents from Control.Concurrent.Chan
+getConst from Data.Functor.Const
+getContents from Data.Text.IO
+getDual from Data.Monoid
+getFirst from Data.Monoid
+getLast from Data.Monoid
+getLine from Data.Text.IO
+getMaskingState from GHC.IO
+getNumCapabilities from GHC.Conc.Sync
+getOption from Data.Semigroup
+getProduct from Data.Monoid
+getStackTrace from GHC.ExecutionStack
+getSum from Data.Monoid
+getZipList from Control.Applicative
+gets from Control.Monad.State.Class
+group from Data.OldList
+groupBy from Data.OldList
+guard from Control.Monad
+guardM from Protolude.Bool
+guarded from Protolude
+guardedA from Protolude
+hPutStr from Protolude.Show
+hPutStrLn from Protolude.Show
+handle from Control.Exception.Base
+handleJust from Control.Exception.Base
+hash from Data.Hashable.Class
+hashUsing from Data.Hashable.Class
+hashWithSalt from Data.Hashable.Class
+head from Protolude.List
+headDef from Protolude.Safe
+headMay from Protolude.Safe
+hush from Protolude.Exceptions
+identity from Protolude
+ifM from Protolude.Bool
+ignore from Data.Text.Encoding.Error
+imagPart from Data.Complex
+infinity from GHC.Real
+initDef from Protolude.Safe
+initMay from Protolude.Safe
+initSafe from Protolude.Safe
+inits from Data.OldList
+integralEnumFrom from GHC.Real
+integralEnumFromThen from GHC.Real
+integralEnumFromThenTo from GHC.Real
+integralEnumFromTo from GHC.Real
+interact from Data.Text.IO
+intercalate from Data.OldList
+interruptible from GHC.IO
+intersperse from Data.OldList
+ioError from GHC.IO.Exception
+isCurrentThreadBound from Control.Concurrent
+isDenormalized from GHC.Float
+isEmptyChan from Control.Concurrent.Chan
+isEmptyMVar from GHC.MVar
+isIEEE from GHC.Float
+isInfinite from GHC.Float
+isJust from Data.Maybe
+isLeft from Data.Either
+isNaN from GHC.Float
+isNegativeZero from GHC.Float
+isNewtype from GHC.Generics
+isNothing from Data.Maybe
+isPrefixOf from Data.OldList
+isRight from Data.Either
+isSigned from Data.Bits
+iterate from GHC.List
+join from GHC.Base
+killThread from GHC.Conc.Sync
+lastDef from Protolude.Safe
+lastMay from Protolude.Safe
+lcm from GHC.Real
+leftToMaybe from Protolude.Either
+lefts from Data.Either
+length from Data.Foldable
+lenientDecode from Data.Text.Encoding.Error
+lift from Control.Monad.Trans.Class
+liftA from GHC.Base
+liftA2 from GHC.Base
+liftA3 from GHC.Base
+liftAA2 from Protolude.Applicative
+liftIO from Control.Monad.IO.Class
+liftIO1 from Protolude
+liftIO2 from Protolude
+liftM from GHC.Base
+liftM' from Protolude.Monad
+liftM2 from GHC.Base
+liftM2' from Protolude.Monad
+liftM3 from GHC.Base
+liftM4 from GHC.Base
+liftM5 from GHC.Base
+lines from Data.Text
+link from Control.Concurrent.Async
+link2 from Control.Concurrent.Async
+list from Protolude.List
+listToMaybe from Data.Maybe
+local from Control.Monad.Reader.Class
+log from GHC.Float
+log1mexp from GHC.Float
+log1p from GHC.Float
+log1pexp from GHC.Float
+logBase from GHC.Float
+magnitude from Data.Complex
+many from GHC.Base
+map from Protolude
+mapAccumL from Data.Traversable
+mapAccumR from Data.Traversable
+mapAndUnzipM from Control.Monad
+mapExcept from Control.Monad.Trans.Except
+mapExceptT from Control.Monad.Trans.Except
+mapException from Control.Exception.Base
+mapM from Data.Traversable
+mapM_ from Data.Foldable
+mapMaybe from Data.Maybe
+mappend from GHC.Base
+mask from GHC.IO
+mask_ from GHC.IO
+max from GHC.Classes
+maxBound from GHC.Enum
+maxInt from GHC.Base
+maximum from Data.Foldable
+maximumBy from Data.Foldable
+maximumDef from Protolude.Safe
+maximumMay from Protolude.Safe
+maybe from Data.Maybe
+maybeEmpty from Protolude.Either
+maybeToEither from Protolude.Either
+maybeToLeft from Protolude.Either
+maybeToList from Data.Maybe
+maybeToRight from Protolude.Either
+mconcat from GHC.Base
+mempty from GHC.Base
+mfilter from Control.Monad
+min from GHC.Classes
+minBound from GHC.Enum
+minInt from GHC.Base
+minimum from Data.Foldable
+minimumBy from Data.Foldable
+minimumDef from Protolude.Safe
+minimumMay from Protolude.Safe
+mkPolar from Data.Complex
+mkWeakMVar from Control.Concurrent.MVar
+mkWeakThreadId from GHC.Conc.Sync
+mod from GHC.Real
+modify from Control.Monad.State.Class
+modifyMVar from Control.Concurrent.MVar
+modifyMVarMasked from Control.Concurrent.MVar
+modifyMVarMasked_ from Control.Concurrent.MVar
+modifyMVar_ from Control.Concurrent.MVar
+moduleName from GHC.Generics
+mplus from GHC.Base
+msum from Data.Foldable
+mtimesDefault from Data.Semigroup
+myThreadId from GHC.Conc.Sync
+mzero from GHC.Base
+natVal from GHC.TypeLits
+negate from GHC.Num
+newChan from Control.Concurrent.Chan
+newEmptyMVar from GHC.MVar
+newMVar from GHC.MVar
+newQSem from Control.Concurrent.QSem
+newQSemN from Control.Concurrent.QSemN
+nonEmpty from Data.List.NonEmpty
+not from GHC.Classes
+notANumber from GHC.Real
+notElem from Data.Foldable
+notImplemented from Debug
+note from Protolude.Exceptions
+null from Data.Foldable
+numerator from GHC.Real
+numericEnumFrom from GHC.Real
+numericEnumFromThen from GHC.Real
+numericEnumFromThenTo from GHC.Real
+numericEnumFromTo from GHC.Real
+objectName from GHC.ExecutionStack.Internal
+odd from GHC.Real
+on from Data.Function
+onException from Control.Exception.Base
+one from Protolude.Semiring
+openFile from GHC.IO.Handle.FD
+option from Data.Semigroup
+optional from Control.Applicative
+or from Data.Foldable
+orAlt from Protolude.Applicative
+orElse from GHC.Conc.Sync
+orEmpty from Protolude.Applicative
+ord from GHC.Base
+ordNub from Protolude.List
+otherwise from GHC.Base
+overflowError from GHC.Real
+packageName from GHC.Generics
+panic from Protolude.Panic
+partitionEithers from Data.Either
+pass from Protolude
+permutations from Data.OldList
+phase from Data.Complex
+pi from GHC.Float
+polar from Data.Complex
+poll from Control.Concurrent.Async
+popCount from Data.Bits
+popCountDefault from Data.Bits
+pred from GHC.Enum
+prettyCallStack from GHC.Exception
+prettySrcLoc from GHC.Exception
+print from Protolude
+product from Protolude.List
+properFraction from GHC.Real
+pure from GHC.Base
+purer from Protolude.Applicative
+put from Control.Monad.State.Class
+putByteString from Protolude.Show
+putErrLn from Protolude.Show
+putErrText from Protolude.Show
+putLByteString from Protolude.Show
+putLText from Protolude.Show
+putMVar from GHC.MVar
+putStr from Protolude.Show
+putStrLn from Protolude.Show
+putText from Protolude.Show
+quot from GHC.Real
+quotRem from GHC.Real
+race from Control.Concurrent.Async
+race_ from Control.Concurrent.Async
+ratioPrec from GHC.Real
+ratioPrec1 from GHC.Real
+ratioZeroDenominatorError from GHC.Real
+readChan from Control.Concurrent.Chan
+readEither from Text.Read
+readFile from Data.Text.IO
+readMVar from GHC.MVar
+readMaybe from Text.Read
+reader from Control.Monad.Reader.Class
+reads from Text.Read
+realPart from Data.Complex
+realToFrac from GHC.Real
+recip from GHC.Real
+reduce from GHC.Real
+rem from GHC.Real
+repeat from GHC.List
+replace from Data.Text.Encoding.Error
+replicate from GHC.List
+replicateM from Control.Monad
+replicateM_ from Control.Monad
+repr from Data.Type.Coercion
+retry from GHC.Conc.Sync
+return from GHC.Base
+reverse from GHC.List
+rightToMaybe from Protolude.Either
+rights from Data.Either
+rnf from Control.DeepSeq
+rotate from Data.Bits
+rotateL from Data.Bits
+rotateR from Data.Bits
+round from GHC.Real
+rtsSupportsBoundThreads from Control.Concurrent
+runConcurrently from Control.Concurrent.Async
+runExcept from Control.Monad.Trans.Except
+runExceptT from Control.Monad.Trans.Except
+runIdentity from Data.Functor.Identity
+runInBoundThread from Control.Concurrent
+runInUnboundThread from Control.Concurrent
+runReader from Control.Monad.Trans.Reader
+runReaderT from Control.Monad.Trans.Reader
+runST from GHC.ST
+runState from Control.Monad.Trans.State.Lazy
+runStateT from Control.Monad.Trans.State.Lazy
+scaleFloat from GHC.Float
+scanl from GHC.List
+scanl' from GHC.List
+scanr from GHC.List
+sconcat from Data.Semigroup
+second from Data.Bifunctor
+selDecidedStrictness from GHC.Generics
+selName from GHC.Generics
+selSourceStrictness from GHC.Generics
+selSourceUnpackedness from GHC.Generics
+seq from GHC.Prim
+sequence from Data.Traversable
+sequenceA from Data.Traversable
+sequenceA_ from Data.Foldable
+sequence_ from Data.Foldable
+setBit from Data.Bits
+setNumCapabilities from GHC.Conc.Sync
+shift from Data.Bits
+shiftL from Data.Bits
+shiftR from Data.Bits
+show from Protolude
+showStackTrace from GHC.ExecutionStack
+signalQSem from Control.Concurrent.QSem
+signalQSemN from Control.Concurrent.QSemN
+significand from GHC.Float
+signum from GHC.Num
+sin from GHC.Float
+sinh from GHC.Float
+snd from Data.Tuple
+some from GHC.Base
+someNatVal from GHC.TypeLits
+someSymbolVal from GHC.TypeLits
+sort from Data.OldList
+sortBy from Data.OldList
+sortOn from Protolude.List
+sourceColumn from GHC.ExecutionStack.Internal
+sourceFile from GHC.ExecutionStack.Internal
+sourceLine from GHC.ExecutionStack.Internal
+splitAt from GHC.List
+sqrt from GHC.Float
+srcLoc from GHC.ExecutionStack.Internal
+state from Control.Monad.State.Class
+stderr from GHC.IO.Handle.FD
+stdin from GHC.IO.Handle.FD
+stdout from GHC.IO.Handle.FD
+stimes from Data.Semigroup
+stimesIdempotent from Data.Semigroup
+stimesIdempotentMonoid from Data.Semigroup
+stimesMonoid from Data.Semigroup
+strConv from Protolude.Conv
+strictDecode from Data.Text.Encoding.Error
+subsequences from Data.OldList
+subtract from GHC.Num
+succ from GHC.Enum
+sum from Protolude.List
+swap from Data.Tuple
+swapMVar from Control.Concurrent.MVar
+sym from Data.Type.Equality
+symbolVal from GHC.TypeLits
+tailDef from Protolude.Safe
+tailMay from Protolude.Safe
+tailSafe from Protolude.Safe
+tails from Data.OldList
+take from GHC.List
+takeMVar from GHC.MVar
+takeWhile from GHC.List
+tan from GHC.Float
+tanh from GHC.Float
+testBit from Data.Bits
+testBitDefault from Data.Bits
+threadCapability from GHC.Conc.Sync
+threadDelay from GHC.Conc.IO
+threadWaitRead from Control.Concurrent
+threadWaitReadSTM from Control.Concurrent
+threadWaitWrite from Control.Concurrent
+threadWaitWriteSTM from Control.Concurrent
+throwE from Control.Monad.Trans.Except
+throwError from Control.Monad.Error.Class
+throwIO from Protolude
+throwSTM from GHC.Conc.Sync
+throwTo from Protolude
+to from GHC.Generics
+toEnum from GHC.Enum
+toException from GHC.Exception
+toInteger from GHC.Real
+toIntegralSized from Data.Bits
+toList from Data.Foldable
+toRational from GHC.Real
+toS from Protolude.Conv
+toSL from Protolude.Conv
+toStrict from Data.Text.Lazy
+trace from Debug
+traceIO from Debug
+traceId from Debug
+traceM from Debug
+traceShow from Debug
+traceShowId from Debug
+traceShowM from Debug
+trans from Data.Type.Equality
+transpose from Data.OldList
+traverse from Data.Traversable
+traverse_ from Data.Foldable
+truncate from GHC.Real
+try from Control.Exception.Base
+tryIO from Protolude.Exceptions
+tryJust from Control.Exception.Base
+tryPutMVar from GHC.MVar
+tryReadMVar from GHC.MVar
+tryTakeMVar from GHC.MVar
+typeRep from Data.Typeable.Internal
+unComp1 from GHC.Generics
+unGetChan from Control.Concurrent.Chan
+unK1 from GHC.Generics
+unM1 from GHC.Generics
+uncons from Protolude
+uncurry from Data.Tuple
+undefined from Debug
+unfoldr from Data.OldList
+uninterruptibleMask from GHC.IO
+uninterruptibleMask_ from GHC.IO
+unless from Control.Monad
+unlessM from Protolude.Bool
+unlines from Data.Text
+unsnoc from Protolude
+until from GHC.Base
+unwords from Data.Text
+unzip from GHC.List
+vacuous from Data.Void
+void from Data.Functor
+wait from Control.Concurrent.Async
+waitAny from Control.Concurrent.Async
+waitAnyCancel from Control.Concurrent.Async
+waitAnyCatch from Control.Concurrent.Async
+waitAnyCatchCancel from Control.Concurrent.Async
+waitBoth from Control.Concurrent.Async
+waitCatch from Control.Concurrent.Async
+waitEither from Control.Concurrent.Async
+waitEitherCancel from Control.Concurrent.Async
+waitEitherCatch from Control.Concurrent.Async
+waitEitherCatchCancel from Control.Concurrent.Async
+waitEither_ from Control.Concurrent.Async
+waitQSem from Control.Concurrent.QSem
+waitQSemN from Control.Concurrent.QSemN
+when from GHC.Base
+whenM from Protolude.Bool
+withAsync from Control.Concurrent.Async
+withAsyncBound from Control.Concurrent.Async
+withAsyncOn from Control.Concurrent.Async
+withExcept from Control.Monad.Trans.Except
+withExceptT from Control.Monad.Trans.Except
+withFile from System.IO
+withFrozenCallStack from GHC.Stack
+withMVar from Control.Concurrent.MVar
+withMVarMasked from Control.Concurrent.MVar
+withState from Control.Monad.Trans.State.Lazy
+witness from Debug
+words from Data.Text
+writeChan from Control.Concurrent.Chan
+writeFile from Data.Text.IO
+writeList2Chan from Control.Concurrent.Chan
+xor from Data.Bits
+zero from Protolude.Semiring
+zeroBits from Data.Bits
+zip from GHC.List
+zipWith from GHC.List
+zipWithM from Control.Monad
+zipWithM_ from Control.Monad
+|| from GHC.Classes
+||^ from Protolude.Bool

export_lists/protolude-9.exports

@@ -0,0 +1,956 @@
+$ from GHC.Base
+$! from Protolude.Base
+$!! from Control.DeepSeq
+$> from Data.Functor
+% from GHC.Real
+& from Data.Function
+&& from GHC.Classes
+&&^ from Protolude.Bool
+* from GHC.Num
+* from GHC.Types
+** from GHC.Float
+*> from GHC.Base
++ from GHC.Num
+++ from GHC.Base
+- from GHC.Num
+. from GHC.Base
+.&. from Data.Bits
+.|. from Data.Bits
+/ from GHC.Real
+/= from GHC.Classes
+:% from GHC.Real
+:*: from GHC.Generics
+:*: from GHC.Generics
+:+ from Data.Complex
+:+: from GHC.Generics
+:.: from GHC.Generics
+:| from Data.List.NonEmpty
+:~: from Data.Type.Equality
+< from GHC.Classes
+<$ from GHC.Base
+<$!> from Control.Monad
+<$> from Data.Functor
+<&&> from Protolude.Bool
+<&> from Protolude.Functor
+<* from GHC.Base
+<**> from GHC.Base
+<*> from GHC.Base
+<.> from Protolude.Semiring
+<<$>> from Protolude.Functor
+<<*>> from Protolude.Applicative
+<= from GHC.Classes
+<=< from Control.Monad
+<> from Data.Monoid
+<|> from GHC.Base
+<||> from Protolude.Bool
+=<< from GHC.Base
+== from GHC.Classes
+== from Data.Type.Equality
+> from GHC.Classes
+>= from GHC.Classes
+>=> from Control.Monad
+>> from GHC.Base
+>>= from GHC.Base
+All from Data.Monoid
+All from Data.Monoid
+AllocationLimitExceeded from GHC.IO.Exception
+AllocationLimitExceeded from GHC.IO.Exception
+Alt from Data.Monoid
+Alt from Data.Monoid
+Alternative from GHC.Base
+Any from Data.Monoid
+Any from Data.Monoid
+AppendMode from GHC.IO.IOMode
+Applicative from GHC.Base
+ArithException from GHC.Exception
+ArrayException from GHC.IO.Exception
+AssertionFailed from GHC.IO.Exception
+AssertionFailed from GHC.IO.Exception
+Associativity from GHC.Generics
+Async from Control.Concurrent.Async
+AsyncException from GHC.IO.Exception
+Bifunctor from Data.Bifunctor
+Bits from Data.Bits
+BlockedIndefinitelyOnMVar from GHC.IO.Exception
+BlockedIndefinitelyOnMVar from GHC.IO.Exception
+BlockedIndefinitelyOnSTM from GHC.IO.Exception
+BlockedIndefinitelyOnSTM from GHC.IO.Exception
+Bool from GHC.Types
+Bounded from GHC.Enum
+ByteString from Data.ByteString.Internal
+C1 from GHC.Generics
+CallStack from GHC.Stack.Types
+Chan from Control.Concurrent.Chan
+Char from GHC.Types
+CmpNat from GHC.TypeLits
+Coercible from GHC.Types
+Coercion from Data.Type.Coercion
+Coercion from Data.Type.Coercion
+Comp1 from GHC.Generics
+Complex from Data.Complex
+Concurrently from Control.Concurrent.Async
+Concurrently from Control.Concurrent.Async
+Const from Data.Functor.Const
+Const from Data.Functor.Const
+Constraint from GHC.Types
+Constructor from GHC.Generics
+D# from GHC.Types
+D1 from GHC.Generics
+Datatype from GHC.Generics
+Deadlock from GHC.IO.Exception
+Deadlock from GHC.IO.Exception
+Denormal from GHC.Exception
+DivideByZero from GHC.Exception
+Double from GHC.Types
+Down from Data.Ord
+Down from Data.Ord
+Dual from Data.Monoid
+Dual from Data.Monoid
+EQ from GHC.Types
+Either from Data.Either
+Endo from Data.Monoid
+Endo from Data.Monoid
+Enum from GHC.Enum
+Eq from GHC.Classes
+ErrorCall from GHC.Exception
+ErrorCall from GHC.Exception
+ErrorCallWithLocation from GHC.Exception
+Except from Control.Monad.Trans.Except
+ExceptT from Control.Monad.Trans.Except
+ExceptT from Control.Monad.Trans.Except
+Exception from GHC.Exception
+ExitCode from GHC.IO.Exception
+ExitFailure from GHC.IO.Exception
+ExitSuccess from GHC.IO.Exception
+F# from GHC.Types
+False from GHC.Types
+FatalError from Protolude.Panic
+FatalError from Protolude.Panic
+FilePath from GHC.IO
+FiniteBits from Data.Bits
+First from Data.Monoid
+First from Data.Monoid
+Fixity from GHC.Generics
+FixityI from GHC.Generics
+Float from GHC.Types
+Floating from GHC.Float
+Foldable from Data.Foldable
+Fractional from GHC.Real
+FunPtr from GHC.Ptr
+Functor from GHC.Base
+GT from GHC.Types
+Generic from GHC.Generics
+Generic1 from GHC.Generics
+Handle from GHC.IO.Handle.Types
+HasCallStack from GHC.Stack.Types
+Hashable from Data.Hashable.Class
+HeapOverflow from GHC.IO.Exception
+IO from GHC.Types
+IOException from GHC.IO.Exception
+IOMode from GHC.IO.IOMode
+Identity from Data.Functor.Identity
+Identity from Data.Functor.Identity
+IndexOutOfBounds from GHC.IO.Exception
+Infix from GHC.Generics
+InfixI from GHC.Generics
+Int from GHC.Types
+Int16 from GHC.Int
+Int32 from GHC.Int
+Int64 from GHC.Int
+Int8 from GHC.Int
+IntMap from Data.IntMap.Base
+IntPtr from Foreign.Ptr
+IntSet from Data.IntSet.Base
+Integer from GHC.Integer.Type
+Integral from GHC.Real
+IsLabel from GHC.OverloadedLabels
+IsString from Data.String
+Just from GHC.Base
+K1 from GHC.Generics
+K1 from GHC.Generics
+KnownNat from GHC.TypeLits
+KnownSymbol from GHC.TypeLits
+L1 from GHC.Generics
+LByteString from Protolude
+LT from GHC.Types
+LText from Protolude
+Last from Data.Monoid
+Last from Data.Monoid
+Left from Data.Either
+LeftAssociative from GHC.Generics
+Leniency from Protolude.Conv
+Lenient from Protolude.Conv
+Location from GHC.ExecutionStack.Internal
+Location from GHC.ExecutionStack.Internal
+LossOfPrecision from GHC.Exception
+M1 from GHC.Generics
+M1 from GHC.Generics
+MVar from GHC.MVar
+Map from Data.Map.Base
+MaskedInterruptible from GHC.IO
+MaskedUninterruptible from GHC.IO
+MaskingState from GHC.IO
+Maybe from GHC.Base
+Meta from GHC.Generics
+MetaCons from GHC.Generics
+MetaData from GHC.Generics
+MetaSel from GHC.Generics
+Monad from GHC.Base
+MonadError from Control.Monad.Error.Class
+MonadIO from Control.Monad.IO.Class
+MonadPlus from GHC.Base
+MonadReader from Control.Monad.Reader.Class
+MonadState from Control.Monad.State.Class
+Monoid from GHC.Base
+NFData from Control.DeepSeq
+Nat from GHC.Types
+NestedAtomically from Control.Exception.Base
+NestedAtomically from Control.Exception.Base
+NoMethodError from Control.Exception.Base
+NoMethodError from Control.Exception.Base
+NonEmpty from Data.List.NonEmpty
+NonTermination from Control.Exception.Base
+NonTermination from Control.Exception.Base
+NotAssociative from GHC.Generics
+Nothing from GHC.Base
+Num from GHC.Num
+OnDecodeError from Data.Text.Encoding.Error
+OnError from Data.Text.Encoding.Error
+Option from Data.Semigroup
+Option from Data.Semigroup
+Ord from GHC.Classes
+Ordering from GHC.Types
+Overflow from GHC.Exception
+PatternMatchFail from Control.Exception.Base
+PatternMatchFail from Control.Exception.Base
+Prefix from GHC.Generics
+PrefixI from GHC.Generics
+Print from Protolude.Show
+Product from Data.Monoid
+Product from Data.Monoid
+Proxy from Data.Proxy
+Proxy from Data.Proxy
+Ptr from GHC.Ptr
+QSem from Control.Concurrent.QSem
+QSemN from Control.Concurrent.QSemN
+R1 from GHC.Generics
+Ratio from GHC.Real
+RatioZeroDenominator from GHC.Exception
+Rational from GHC.Real
+Read from GHC.Read
+ReadMode from GHC.IO.IOMode
+ReadWriteMode from GHC.IO.IOMode
+Reader from Control.Monad.Trans.Reader
+ReaderT from Control.Monad.Trans.Reader
+ReaderT from Control.Monad.Trans.Reader
+Real from GHC.Real
+RealFloat from GHC.Float
+RealFrac from GHC.Real
+Rec0 from GHC.Generics
+RecConError from Control.Exception.Base
+RecConError from Control.Exception.Base
+RecSelError from Control.Exception.Base
+RecSelError from Control.Exception.Base
+RecUpdError from Control.Exception.Base
+RecUpdError from Control.Exception.Base
+Refl from Data.Type.Equality
+Rep from GHC.Generics
+Right from Data.Either
+RightAssociative from GHC.Generics
+S1 from GHC.Generics
+ST from GHC.ST
+STM from GHC.Conc.Sync
+Selector from GHC.Generics
+Semigroup from Data.Semigroup
+Semiring from Protolude.Semiring
+Seq from Data.Sequence
+Set from Data.Set.Base
+Show from GHC.Show
+SomeAsyncException from GHC.IO.Exception
+SomeAsyncException from GHC.IO.Exception
+SomeException from GHC.Exception
+SomeException from GHC.Exception
+SomeNat from GHC.TypeLits
+SomeNat from GHC.TypeLits
+SomeSymbol from GHC.TypeLits
+SomeSymbol from GHC.TypeLits
+SrcLoc from GHC.ExecutionStack.Internal
+SrcLoc from GHC.ExecutionStack.Internal
+StablePtr from GHC.Stable
+StackOverflow from GHC.IO.Exception
+State from Control.Monad.Trans.State.Lazy
+StateT from Control.Monad.Trans.State.Lazy
+StateT from Control.Monad.Trans.State.Lazy
+StaticPtr from GHC.StaticPtr
+Storable from Foreign.Storable
+Strict from Protolude.Conv
+StringConv from Protolude.Conv
+Sum from Data.Monoid
+Sum from Data.Monoid
+Symbol from GHC.Types
+Text from Data.Text.Internal
+ThreadId from GHC.Conc.Sync
+ThreadKilled from GHC.IO.Exception
+Traversable from Data.Traversable
+True from GHC.Types
+Type from GHC.Types
+TypeError from Control.Exception.Base
+TypeError from Control.Exception.Base
+TypeRep from Data.Typeable.Internal
+Typeable from Data.Typeable.Internal
+U1 from GHC.Generics
+U1 from GHC.Generics
+URec from GHC.Generics
+UndefinedElement from GHC.IO.Exception
+Underflow from GHC.Exception
+UnicodeException from Data.Text.Encoding.Error
+Unmasked from GHC.IO
+UserInterrupt from GHC.IO.Exception
+V1 from GHC.Generics
+Void from Data.Void
+Word from GHC.Types
+Word16 from GHC.Word
+Word32 from GHC.Word
+Word64 from GHC.Word
+Word8 from GHC.Word
+WordPtr from Foreign.Ptr
+WrappedMonoid from Data.Semigroup
+WriteMode from GHC.IO.IOMode
+ZipList from Control.Applicative
+ZipList from Control.Applicative
+^ from GHC.Real
+^%^ from GHC.Real
+^^ from GHC.Real
+^^%^^ from GHC.Real
+abs from GHC.Num
+absurd from Data.Void
+acos from GHC.Float
+acosh from GHC.Float
+addMVarFinalizer from Control.Concurrent.MVar
+all from Data.Foldable
+allowInterrupt from Control.Exception
+always from GHC.Conc.Sync
+alwaysSucceeds from GHC.Conc.Sync
+and from Data.Foldable
+any from Data.Foldable
+ap from GHC.Base
+appEndo from Data.Monoid
+appendFile from Data.Text.IO
+applyN from Protolude
+asTypeOf from GHC.Base
+asin from GHC.Float
+asinh from GHC.Float
+ask from Control.Monad.Reader.Class
+asks from Control.Monad.Reader.Class
+asum from Data.Foldable
+async from Control.Concurrent.Async
+asyncBound from Control.Concurrent.Async
+asyncExceptionFromException from GHC.IO.Exception
+asyncExceptionToException from GHC.IO.Exception
+asyncOn from Control.Concurrent.Async
+asyncThreadId from Control.Concurrent.Async
+atDef from Protolude.Safe
+atMay from Protolude.Safe
+atan from GHC.Float
+atan2 from GHC.Float
+atanh from GHC.Float
+atomically from GHC.Conc.Sync
+bimap from Data.Bifunctor
+bit from Data.Bits
+bitDefault from Data.Bits
+bitSize from Data.Bits
+bitSizeMaybe from Data.Bits
+bool from Protolude.Bool
+boundedEnumFrom from GHC.Enum
+boundedEnumFromThen from GHC.Enum
+bracket from Control.Exception.Base
+bracketOnError from Control.Exception.Base
+bracket_ from Control.Exception.Base
+break from GHC.List
+byteSwap16 from GHC.Word
+byteSwap32 from GHC.Word
+byteSwap64 from GHC.Word
+callStack from GHC.Stack
+cancel from Control.Concurrent.Async
+cancelWith from Control.Concurrent.Async
+cast from Data.Typeable
+castWith from Data.Type.Equality
+catMaybes from Data.Maybe
+catch from Control.Exception.Base
+catchE from Control.Monad.Trans.Except
+catchError from Control.Monad.Error.Class
+catchJust from Control.Exception.Base
+catchSTM from GHC.Conc.Sync
+catches from Control.Exception
+ceiling from GHC.Real
+check from Control.Monad.STM
+chr from GHC.Char
+cis from Data.Complex
+clearBit from Data.Bits
+coerceWith from Data.Type.Coercion
+compare from GHC.Classes
+comparing from Data.Ord
+complement from Data.Bits
+complementBit from Data.Bits
+conFixity from GHC.Generics
+conIsRecord from GHC.Generics
+conName from GHC.Generics
+concat from Data.Foldable
+concatMap from Data.Foldable
+concatMapM from Protolude.Monad
+concurrently from Control.Concurrent.Async
+conjugate from Data.Complex
+const from GHC.Base
+cos from GHC.Float
+cosh from GHC.Float
+countLeadingZeros from Data.Bits
+countTrailingZeros from Data.Bits
+currentCallStack from GHC.Stack.CCS
+curry from Data.Tuple
+cycle from GHC.List
+cycle1 from Data.Semigroup
+datatypeName from GHC.Generics
+decodeFloat from GHC.Float
+decodeUtf8 from Data.Text.Encoding
+decodeUtf8' from Data.Text.Encoding
+decodeUtf8With from Data.Text.Encoding
+deepseq from Control.DeepSeq
+denominator from GHC.Real
+die from Protolude
+diff from Data.Semigroup
+displayException from GHC.Exception
+div from GHC.Real
+divMod from GHC.Real
+divZeroError from GHC.Real
+drop from GHC.List
+dropWhile from GHC.List
+dupChan from Control.Concurrent.Chan
+either from Data.Either
+eitherA from Protolude.Applicative
+elem from Data.Foldable
+empty from GHC.Base
+encodeFloat from GHC.Float
+encodeUtf8 from Data.Text.Encoding
+enumFrom from GHC.Enum
+enumFromThen from GHC.Enum
+enumFromThenTo from GHC.Enum
+enumFromTo from GHC.Enum
+eqT from Data.Typeable
+evalState from Control.Monad.Trans.State.Lazy
+evalStateT from Control.Monad.Trans.State.Lazy
+evaluate from GHC.IO
+even from GHC.Real
+execState from Control.Monad.Trans.State.Lazy
+execStateT from Control.Monad.Trans.State.Lazy
+exitFailure from System.Exit
+exitSuccess from System.Exit
+exitWith from System.Exit
+exp from GHC.Float
+expm1 from GHC.Float
+exponent from GHC.Float
+fatalErrorMessage from Protolude.Panic
+filter from GHC.List
+filterM from Control.Monad
+finally from Control.Exception.Base
+find from Data.Foldable
+finiteBitSize from Data.Bits
+first from Data.Bifunctor
+fix from Data.Function
+fixST from GHC.ST
+flip from GHC.Base
+floatDigits from GHC.Float
+floatRadix from GHC.Float
+floatRange from GHC.Float
+floor from GHC.Real
+fmap from GHC.Base
+fmapDefault from Data.Traversable
+fold from Data.Foldable
+foldM from Control.Monad
+foldM_ from Control.Monad
+foldMap from Data.Foldable
+foldMapDefault from Data.Traversable
+foldl from Data.Foldable
+foldl' from Data.Foldable
+foldl1May from Protolude.Safe
+foldl1May' from Protolude.Safe
+foldlM from Data.Foldable
+foldr from Data.Foldable
+foldr' from Data.Foldable
+foldr1May from Protolude.Safe
+foldrM from Data.Foldable
+for from Data.Traversable
+forM from Data.Traversable
+forM_ from Data.Foldable
+for_ from Data.Foldable
+force from Control.DeepSeq
+foreach from Protolude.Functor
+forever from Control.Monad
+forkFinally from Control.Concurrent
+forkIO from GHC.Conc.Sync
+forkIOWithUnmask from GHC.Conc.Sync
+forkOS from Control.Concurrent
+forkOSWithUnmask from Control.Concurrent
+forkOn from GHC.Conc.Sync
+forkOnWithUnmask from GHC.Conc.Sync
+from from GHC.Generics
+fromEnum from GHC.Enum
+fromException from GHC.Exception
+fromInteger from GHC.Num
+fromIntegral from GHC.Real
+fromLabel from GHC.OverloadedLabels
+fromLeft from Protolude.Either
+fromMaybe from Data.Maybe
+fromRational from GHC.Real
+fromRight from Protolude.Either
+fromStrict from Data.Text.Lazy
+fst from Data.Tuple
+functionName from GHC.ExecutionStack.Internal
+gcastWith from Data.Type.Equality
+gcd from GHC.Real
+gcdInt' from GHC.Real
+gcdWord' from GHC.Real
+genericDrop from Data.OldList
+genericLength from Data.OldList
+genericReplicate from Data.OldList
+genericSplitAt from Data.OldList
+genericTake from Data.OldList
+get from Control.Monad.State.Class
+getAll from Data.Monoid
+getAlt from Data.Monoid
+getAny from Data.Monoid
+getArgs from System.Environment
+getCallStack from GHC.Stack.Types
+getChanContents from Control.Concurrent.Chan
+getConst from Data.Functor.Const
+getContents from Data.Text.IO
+getDual from Data.Monoid
+getFirst from Data.Monoid
+getLast from Data.Monoid
+getLine from Data.Text.IO
+getMaskingState from GHC.IO
+getNumCapabilities from GHC.Conc.Sync
+getOption from Data.Semigroup
+getProduct from Data.Monoid
+getStackTrace from GHC.ExecutionStack
+getSum from Data.Monoid
+getZipList from Control.Applicative
+gets from Control.Monad.State.Class
+group from Data.OldList
+groupBy from Data.OldList
+guard from Control.Monad
+guardM from Protolude.Bool
+guarded from Protolude
+guardedA from Protolude
+hPutStr from Protolude.Show
+hPutStrLn from Protolude.Show
+handle from Control.Exception.Base
+handleJust from Control.Exception.Base
+hash from Data.Hashable.Class
+hashUsing from Data.Hashable.Class
+hashWithSalt from Data.Hashable.Class
+head from Protolude.List
+headDef from Protolude.Safe
+headMay from Protolude.Safe
+hush from Protolude.Exceptions
+identity from Protolude
+ifM from Protolude.Bool
+ignore from Data.Text.Encoding.Error
+imagPart from Data.Complex
+infinity from GHC.Real
+initDef from Protolude.Safe
+initMay from Protolude.Safe
+initSafe from Protolude.Safe
+inits from Data.OldList
+integralEnumFrom from GHC.Real
+integralEnumFromThen from GHC.Real
+integralEnumFromThenTo from GHC.Real
+integralEnumFromTo from GHC.Real
+interact from Data.Text.IO
+intercalate from Data.OldList
+interruptible from GHC.IO
+intersperse from Data.OldList
+ioError from GHC.IO.Exception
+isCurrentThreadBound from Control.Concurrent
+isDenormalized from GHC.Float
+isEmptyChan from Control.Concurrent.Chan
+isEmptyMVar from GHC.MVar
+isIEEE from GHC.Float
+isInfinite from GHC.Float
+isJust from Data.Maybe
+isLeft from Data.Either
+isNaN from GHC.Float
+isNegativeZero from GHC.Float
+isNewtype from GHC.Generics
+isNothing from Data.Maybe
+isPrefixOf from Data.OldList
+isRight from Data.Either
+isSigned from Data.Bits
+iterate from GHC.List
+join from GHC.Base
+killThread from GHC.Conc.Sync
+lastDef from Protolude.Safe
+lastMay from Protolude.Safe
+lcm from GHC.Real
+leftToMaybe from Protolude.Either
+lefts from Data.Either
+length from Data.Foldable
+lenientDecode from Data.Text.Encoding.Error
+lift from Control.Monad.Trans.Class
+liftA from GHC.Base
+liftA2 from GHC.Base
+liftA3 from GHC.Base
+liftAA2 from Protolude.Applicative
+liftIO from Control.Monad.IO.Class
+liftIO1 from Protolude
+liftIO2 from Protolude
+liftM from GHC.Base
+liftM' from Protolude.Monad
+liftM2 from GHC.Base
+liftM2' from Protolude.Monad
+liftM3 from GHC.Base
+liftM4 from GHC.Base
+liftM5 from GHC.Base
+lines from Data.Text
+link from Control.Concurrent.Async
+link2 from Control.Concurrent.Async
+list from Protolude.List
+listToMaybe from Data.Maybe
+local from Control.Monad.Reader.Class
+log from GHC.Float
+log1mexp from GHC.Float
+log1p from GHC.Float
+log1pexp from GHC.Float
+logBase from GHC.Float
+magnitude from Data.Complex
+many from GHC.Base
+map from Protolude
+mapAccumL from Data.Traversable
+mapAccumR from Data.Traversable
+mapAndUnzipM from Control.Monad
+mapExcept from Control.Monad.Trans.Except
+mapExceptT from Control.Monad.Trans.Except
+mapException from Control.Exception.Base
+mapM from Data.Traversable
+mapM_ from Data.Foldable
+mapMaybe from Data.Maybe
+mappend from GHC.Base
+mask from GHC.IO
+mask_ from GHC.IO
+max from GHC.Classes
+maxBound from GHC.Enum
+maxInt from GHC.Base
+maximum from Data.Foldable
+maximumBy from Data.Foldable
+maximumDef from Protolude.Safe
+maximumMay from Protolude.Safe
+maybe from Data.Maybe
+maybeEmpty from Protolude.Either
+maybeToEither from Protolude.Either
+maybeToLeft from Protolude.Either
+maybeToList from Data.Maybe
+maybeToRight from Protolude.Either
+mconcat from GHC.Base
+mempty from GHC.Base
+mfilter from Control.Monad
+min from GHC.Classes
+minBound from GHC.Enum
+minInt from GHC.Base
+minimum from Data.Foldable
+minimumBy from Data.Foldable
+minimumDef from Protolude.Safe
+minimumMay from Protolude.Safe
+mkPolar from Data.Complex
+mkWeakMVar from Control.Concurrent.MVar
+mkWeakThreadId from GHC.Conc.Sync
+mod from GHC.Real
+modify from Control.Monad.State.Class
+modifyMVar from Control.Concurrent.MVar
+modifyMVarMasked from Control.Concurrent.MVar
+modifyMVarMasked_ from Control.Concurrent.MVar
+modifyMVar_ from Control.Concurrent.MVar
+moduleName from GHC.Generics
+mplus from GHC.Base
+msum from Data.Foldable
+mtimesDefault from Data.Semigroup
+myThreadId from GHC.Conc.Sync
+mzero from GHC.Base
+natVal from GHC.TypeLits
+negate from GHC.Num
+newChan from Control.Concurrent.Chan
+newEmptyMVar from GHC.MVar
+newMVar from GHC.MVar
+newQSem from Control.Concurrent.QSem
+newQSemN from Control.Concurrent.QSemN
+nonEmpty from Data.List.NonEmpty
+not from GHC.Classes
+notANumber from GHC.Real
+notElem from Data.Foldable
+notImplemented from Debug
+note from Protolude.Exceptions
+null from Data.Foldable
+numerator from GHC.Real
+numericEnumFrom from GHC.Real
+numericEnumFromThen from GHC.Real
+numericEnumFromThenTo from GHC.Real
+numericEnumFromTo from GHC.Real
+objectName from GHC.ExecutionStack.Internal
+odd from GHC.Real
+on from Data.Function
+onException from Control.Exception.Base
+one from Protolude.Semiring
+openFile from GHC.IO.Handle.FD
+option from Data.Semigroup
+optional from Control.Applicative
+or from Data.Foldable
+orAlt from Protolude.Applicative
+orElse from GHC.Conc.Sync
+orEmpty from Protolude.Applicative
+ord from GHC.Base
+ordNub from Protolude.List
+otherwise from GHC.Base
+overflowError from GHC.Real
+packageName from GHC.Generics
+panic from Protolude.Panic
+partitionEithers from Data.Either
+pass from Protolude
+permutations from Data.OldList
+phase from Data.Complex
+pi from GHC.Float
+polar from Data.Complex
+poll from Control.Concurrent.Async
+popCount from Data.Bits
+popCountDefault from Data.Bits
+pred from GHC.Enum
+prettyCallStack from GHC.Exception
+prettySrcLoc from GHC.Exception
+print from Protolude
+product from Protolude.List
+properFraction from GHC.Real
+pure from GHC.Base
+purer from Protolude.Applicative
+put from Control.Monad.State.Class
+putByteString from Protolude.Show
+putErrLn from Protolude.Show
+putErrText from Protolude.Show
+putLByteString from Protolude.Show
+putLText from Protolude.Show
+putMVar from GHC.MVar
+putStr from Protolude.Show
+putStrLn from Protolude.Show
+putText from Protolude.Show
+quot from GHC.Real
+quotRem from GHC.Real
+race from Control.Concurrent.Async
+race_ from Control.Concurrent.Async
+ratioPrec from GHC.Real
+ratioPrec1 from GHC.Real
+ratioZeroDenominatorError from GHC.Real
+readChan from Control.Concurrent.Chan
+readEither from Text.Read
+readFile from Data.Text.IO
+readMVar from GHC.MVar
+readMaybe from Text.Read
+reader from Control.Monad.Reader.Class
+reads from Text.Read
+realPart from Data.Complex
+realToFrac from GHC.Real
+recip from GHC.Real
+reduce from GHC.Real
+rem from GHC.Real
+repeat from GHC.List
+replace from Data.Text.Encoding.Error
+replicate from GHC.List
+replicateM from Control.Monad
+replicateM_ from Control.Monad
+repr from Data.Type.Coercion
+retry from GHC.Conc.Sync
+return from GHC.Base
+reverse from GHC.List
+rightToMaybe from Protolude.Either
+rights from Data.Either
+rnf from Control.DeepSeq
+rotate from Data.Bits
+rotateL from Data.Bits
+rotateR from Data.Bits
+round from GHC.Real
+rtsSupportsBoundThreads from Control.Concurrent
+runConcurrently from Control.Concurrent.Async
+runExcept from Control.Monad.Trans.Except
+runExceptT from Control.Monad.Trans.Except
+runIdentity from Data.Functor.Identity
+runInBoundThread from Control.Concurrent
+runInUnboundThread from Control.Concurrent
+runReader from Control.Monad.Trans.Reader
+runReaderT from Control.Monad.Trans.Reader
+runST from GHC.ST
+runState from Control.Monad.Trans.State.Lazy
+runStateT from Control.Monad.Trans.State.Lazy
+scaleFloat from GHC.Float
+scanl from GHC.List
+scanl' from GHC.List
+scanr from GHC.List
+sconcat from Data.Semigroup
+second from Data.Bifunctor
+selDecidedStrictness from GHC.Generics
+selName from GHC.Generics
+selSourceStrictness from GHC.Generics
+selSourceUnpackedness from GHC.Generics
+seq from GHC.Prim
+sequence from Data.Traversable
+sequenceA from Data.Traversable
+sequenceA_ from Data.Foldable
+sequence_ from Data.Foldable
+setBit from Data.Bits
+setNumCapabilities from GHC.Conc.Sync
+shift from Data.Bits
+shiftL from Data.Bits
+shiftR from Data.Bits
+show from Protolude
+showStackTrace from GHC.ExecutionStack
+signalQSem from Control.Concurrent.QSem
+signalQSemN from Control.Concurrent.QSemN
+significand from GHC.Float
+signum from GHC.Num
+sin from GHC.Float
+sinh from GHC.Float
+snd from Data.Tuple
+some from GHC.Base
+someNatVal from GHC.TypeLits
+someSymbolVal from GHC.TypeLits
+sort from Data.OldList
+sortBy from Data.OldList
+sortOn from Protolude.List
+sourceColumn from GHC.ExecutionStack.Internal
+sourceFile from GHC.ExecutionStack.Internal
+sourceLine from GHC.ExecutionStack.Internal
+splitAt from GHC.List
+sqrt from GHC.Float
+srcLoc from GHC.ExecutionStack.Internal
+state from Control.Monad.State.Class
+stderr from GHC.IO.Handle.FD
+stdin from GHC.IO.Handle.FD
+stdout from GHC.IO.Handle.FD
+stimes from Data.Semigroup
+stimesIdempotent from Data.Semigroup
+stimesIdempotentMonoid from Data.Semigroup
+stimesMonoid from Data.Semigroup
+strConv from Protolude.Conv
+strictDecode from Data.Text.Encoding.Error
+subsequences from Data.OldList
+subtract from GHC.Num
+succ from GHC.Enum
+sum from Protolude.List
+swap from Data.Tuple
+swapMVar from Control.Concurrent.MVar
+sym from Data.Type.Equality
+symbolVal from GHC.TypeLits
+tailDef from Protolude.Safe
+tailMay from Protolude.Safe
+tailSafe from Protolude.Safe
+tails from Data.OldList
+take from GHC.List
+takeMVar from GHC.MVar
+takeWhile from GHC.List
+tan from GHC.Float
+tanh from GHC.Float
+testBit from Data.Bits
+testBitDefault from Data.Bits
+threadCapability from GHC.Conc.Sync
+threadDelay from GHC.Conc.IO
+threadWaitRead from Control.Concurrent
+threadWaitReadSTM from Control.Concurrent
+threadWaitWrite from Control.Concurrent
+threadWaitWriteSTM from Control.Concurrent
+throwE from Control.Monad.Trans.Except
+throwError from Control.Monad.Error.Class
+throwIO from Protolude
+throwSTM from GHC.Conc.Sync
+throwTo from Protolude
+to from GHC.Generics
+toEnum from GHC.Enum
+toException from GHC.Exception
+toInteger from GHC.Real
+toIntegralSized from Data.Bits
+toList from Data.Foldable
+toRational from GHC.Real
+toS from Protolude.Conv
+toSL from Protolude.Conv
+toStrict from Data.Text.Lazy
+trace from Debug
+traceIO from Debug
+traceId from Debug
+traceM from Debug
+traceShow from Debug
+traceShowId from Debug
+traceShowM from Debug
+trans from Data.Type.Equality
+transpose from Data.OldList
+traverse from Data.Traversable
+traverse_ from Data.Foldable
+truncate from GHC.Real
+try from Control.Exception.Base
+tryIO from Protolude.Exceptions
+tryJust from Control.Exception.Base
+tryPutMVar from GHC.MVar
+tryReadMVar from GHC.MVar
+tryTakeMVar from GHC.MVar
+typeRep from Data.Typeable.Internal
+unComp1 from GHC.Generics
+unGetChan from Control.Concurrent.Chan
+unK1 from GHC.Generics
+unM1 from GHC.Generics
+uncons from Protolude
+uncurry from Data.Tuple
+undefined from Debug
+unfoldr from Data.OldList
+uninterruptibleMask from GHC.IO
+uninterruptibleMask_ from GHC.IO
+unless from Control.Monad
+unlessM from Protolude.Bool
+unlines from Data.Text
+unsnoc from Protolude
+until from GHC.Base
+unwords from Data.Text
+unzip from GHC.List
+vacuous from Data.Void
+void from Data.Functor
+wait from Control.Concurrent.Async
+waitAny from Control.Concurrent.Async
+waitAnyCancel from Control.Concurrent.Async
+waitAnyCatch from Control.Concurrent.Async
+waitAnyCatchCancel from Control.Concurrent.Async
+waitBoth from Control.Concurrent.Async
+waitCatch from Control.Concurrent.Async
+waitEither from Control.Concurrent.Async
+waitEitherCancel from Control.Concurrent.Async
+waitEitherCatch from Control.Concurrent.Async
+waitEitherCatchCancel from Control.Concurrent.Async
+waitEither_ from Control.Concurrent.Async
+waitQSem from Control.Concurrent.QSem
+waitQSemN from Control.Concurrent.QSemN
+when from GHC.Base
+whenM from Protolude.Bool
+withAsync from Control.Concurrent.Async
+withAsyncBound from Control.Concurrent.Async
+withAsyncOn from Control.Concurrent.Async
+withExcept from Control.Monad.Trans.Except
+withExceptT from Control.Monad.Trans.Except
+withFile from System.IO
+withFrozenCallStack from GHC.Stack
+withMVar from Control.Concurrent.MVar
+withMVarMasked from Control.Concurrent.MVar
+withState from Control.Monad.Trans.State.Lazy
+witness from Debug
+words from Data.Text
+writeChan from Control.Concurrent.Chan
+writeFile from Data.Text.IO
+writeList2Chan from Control.Concurrent.Chan
+xor from Data.Bits
+zero from Protolude.Semiring
+zeroBits from Data.Bits
+zip from GHC.List
+zipWith from GHC.List
+zipWithM from Control.Monad
+zipWithM_ from Control.Monad
+|| from GHC.Classes
+||^ from Protolude.Bool

protolude.cabal

@@ -1,5 +1,5 @@
 name:                protolude
-version:             0.2.4
+version:             0.3.0
 synopsis:            A small prelude.
 description:         A sensible set of defaults for writing custom Preludes.
 homepage:            https://github.com/sdiehl/protolude
@@ -7,7 +7,7 @@ license:             MIT
 license-file:        LICENSE
 author:              Stephen Diehl
 maintainer:          stephen.m.diehl@gmail.com
-copyright:           2016-2019 Stephen Diehl
+copyright:           2016-2020 Stephen Diehl
 category:            Prelude
 build-type:          Simple
 cabal-version:       >=1.10
@@ -28,33 +28,41 @@ tested-with:
   GHC == 8.4.1,
   GHC == 8.6.1,
   GHC == 8.8.1
-extra-source-files: README.md CHANGES.md
+  GHC == 8.10.1
+extra-source-files: README.md ChangeLog.md
+
+flag dev
+  description: Build development tools
+  manual: True
+  default: False
 
 Source-Repository head
     type: git
-    location: git@github.com:sdiehl/protolude.git
+    location: git@github.com:protolude/protolude.git
 
 library
   exposed-modules:     
     Protolude
-    Unsafe
-    Debug
-    Protolude.Exceptions
     Protolude.Base
-    Protolude.Applicative
-    Protolude.Bool
-    Protolude.List
     Protolude.Monad
+    Protolude.Safe
+    Protolude.List
+    Protolude.Bool
     Protolude.Show
     Protolude.Conv
+    Protolude.ConvertText
     Protolude.Either
     Protolude.Functor
     Protolude.Semiring
     Protolude.Bifunctor
-    Protolude.CallStack
+    Protolude.Applicative
     Protolude.Error
     Protolude.Panic
-    Protolude.Safe
+    Protolude.CallStack
+    Protolude.Exceptions
+    Protolude.Partial
+    Protolude.Debug
+    Protolude.Unsafe
 
   default-extensions:
     NoImplicitPrelude
@@ -81,6 +89,26 @@ library
     mtl                 >= 2.1  && <2.3,
     mtl-compat          >= 0.2  && <0.3,
     transformers-compat >= 0.4  && <0.7
+  if !impl(ghc >= 8.0)
+    Build-Depends: fail >= 4.9 && <4.10
 
   hs-source-dirs:      src
   default-language:    Haskell2010
+
+executable exports
+  main-is: Exports.hs
+  default-language:    Haskell2010
+  if flag(dev)
+    buildable: True
+  else
+    buildable: False
+  build-depends:
+    protolude,
+    base >= 4.6  && <4.14,
+    ghc,
+    ghc-paths,
+    directory,
+    process,
+    transformers,
+    mtl,
+    filepath

src/Protolude.hs

@@ -1,50 +1,158 @@
-{-# LANGUAGE BangPatterns #-}
 {-# LANGUAGE CPP #-}
 {-# LANGUAGE Trustworthy #-}
+{-# LANGUAGE BangPatterns #-}
 {-# LANGUAGE FlexibleContexts #-}
 {-# LANGUAGE NoImplicitPrelude #-}
 {-# LANGUAGE ExplicitNamespaces #-}
 {-# OPTIONS_GHC -fno-warn-unused-imports #-}
 
 module Protolude (
-  module X,
+  -- * Base functions
   module Base,
   identity,
-  map,
-  uncons,
-  unsnoc,
-  applyN,
-  print,
-  throwIO,
-  throwTo,
-  show,
   pass,
-  guarded,
-  guardedA,
-  LText,
-  LByteString,
-  liftIO1,
-  liftIO2,
 #if !MIN_VERSION_base(4,8,0)
   (&),
   scanl',
 #endif
+  -- * Function functions
+  module Function,
+  applyN,
+  -- * List functions
+  module List,
+  map,
+  uncons,
+  unsnoc,
+  -- * Data Structures
+  module DataStructures,
+  -- * Show functions
+  module Show,
+  show,
+  print,
+  -- * Bool functions
+  module Bool,
+  -- * Monad functions
+  module Monad,
+  liftIO1,
+  liftIO2,
+  -- * Functor functions
+  module Functor,
+  -- * Either functions
+  module Either,
+  -- * Applicative functions
+  module Applicative,
+  guarded,
+  guardedA,
+  -- * String conversion
+  module ConvertText,
+  -- * Debug functions
+  module Debug,
+
+  -- * Panic functions
+  module Panic,
+  -- * Exception functions
+  module Exception,
+  Protolude.throwIO,
+  Protolude.throwTo,
+  -- * Semiring functions
+  module Semiring,
+
+  -- * String functions
+  module String,
+  -- * Safe functions
+  module Safe,
+  -- * Eq functions
+  module Eq,
+  -- * Ord functions
+  module Ord,
+  -- * Traversable functions
+  module Traversable,
+  -- * Foldable functions
+  module Foldable,
+  -- * Semigroup functions
+#if MIN_VERSION_base(4,9,0)
+  module Semigroup,
+#endif
+  -- * Monoid functions
+  module Monoid,
+  -- * Bifunctor functions
+  module Bifunctor,
+  -- * Bifunctor functions
+  module Hashable,
+
+  -- * Deepseq functions
+  module DeepSeq,
+
+  -- * Tuple functions
+  module Tuple,
+
+  module Typeable,
+
+#if MIN_VERSION_base(4,7,0)
+  -- * Typelevel programming
+  module Typelevel,
+#endif
+
+  -- * Monads
+  module Fail,
+  module State,
+  module Reader,
+  module Except,
+  module Trans,
+  module ST,
+  module STM,
+
+  -- * Integers
+  module Int,
+  module Bits,
+
+  -- * Complex functions
+  module Complex,
+
+  -- * Char functions
+  module Char,
+
+  -- * Maybe functions
+  module Maybe,
+
+  -- * Generics functions
+  module Generics,
+
+  -- * ByteString functions
+  module ByteString,
+  LByteString,
+
+  -- * Text functions
+  module Text,
+  LText,
+
+  -- * Read functions
+  module Read,
+
+  -- * System functions
+  module System,
   die,
+
+  -- * Concurrency functions
+  module Concurrency,
+
+  -- * Foreign functions
+  module Foreign,
 ) where
 
 -- Protolude module exports.
-import Debug as X
+import Protolude.Debug as Debug
-import Protolude.List as X
+import Protolude.List as List
-import Protolude.Show as X
+import Protolude.Show as Show
-import Protolude.Bool as X
+import Protolude.Bool as Bool
-import Protolude.Monad as X
+import Protolude.Monad as Monad
-import Protolude.Functor as X
+import Protolude.Functor as Functor
-import Protolude.Either as X
+import Protolude.Either as Either
-import Protolude.Applicative as X
+import Protolude.Applicative as Applicative
-import Protolude.Conv as X
+import Protolude.ConvertText as ConvertText
-import Protolude.Panic as X
+import Protolude.Panic as Panic
-import Protolude.Exceptions as X
+import Protolude.Exceptions as Exception
-import Protolude.Semiring as X
+import Protolude.Semiring as Semiring
 
 import Protolude.Base as Base hiding (
     putStr           -- Overriden by Show.putStr
@@ -61,10 +169,10 @@ import qualified Protolude.Base as PBase
 
 -- Used for 'show', not exported.
 import Data.String (String)
-import Data.String as X (IsString)
+import Data.String as String (IsString)
 
 -- Maybe'ized version of partial functions
-import Protolude.Safe as X (
+import Protolude.Safe as Safe (
     headMay
   , headDef
   , initMay
@@ -87,11 +195,11 @@ import Protolude.Safe as X (
   )
 
 -- Applicatives
-import Control.Applicative as X (
+import Control.Applicative as Applicative (
     Applicative(..)
   , Alternative(..)
-  , Const(..)
+  , Const(Const,getConst)
-  , ZipList(..)
+  , ZipList(ZipList,getZipList)
   , (<**>)
   , liftA
   , liftA2
@@ -100,32 +208,63 @@ import Control.Applicative as X (
   )
 
 -- Base typeclasses
-import Data.Eq as X (
+import Data.Eq as Eq (
     Eq(..)
   )
-import Data.Ord as X (
+import Data.Ord as Ord (
     Ord(..)
-  , Ordering(..)
+  , Ordering(LT,EQ,GT)
-  , Down(..)
+  , Down(Down)
   , comparing
   )
-import Data.Traversable as X
+import Data.Traversable as Traversable
-import Data.Foldable as X hiding (
+import Data.Foldable as Foldable (
-    foldr1
+    Foldable,
-  , foldl1
+    fold,
-  , product
+    foldMap,
-  , sum
+    foldr,
+    foldr',
+    foldl,
+    foldl',
+    toList,
+#if MIN_VERSION_base(4,8,0)
+    null,
+    length,
+#endif
+    elem,
+    maximum,
+    minimum,
+    foldrM,
+    foldlM,
+    traverse_,
+    for_,
+    mapM_,
+    forM_,
+    sequence_,
+    sequenceA_,
+    asum,
+    msum,
+    concat,
+    concatMap,
+    and,
+    or,
+    any,
+    all,
+    maximumBy,
+    minimumBy,
+    notElem,
+    find,
   )
-import Data.Functor.Identity as X (
+import Data.Functor.Identity as Functor (
-    Identity(..)
+    Identity(Identity, runIdentity)
   )
 
 #if MIN_VERSION_base(4,9,0)
-import Data.List.NonEmpty as X (
+import Data.List.NonEmpty as List (
-    NonEmpty(..)
+    NonEmpty((:|))
   , nonEmpty
   )
-import Data.Semigroup as X (
+import Data.Semigroup as Semigroup (
     Semigroup(sconcat, stimes)
   , WrappedMonoid
   , Option(..)
@@ -139,16 +278,16 @@ import Data.Semigroup as X (
   )
 #endif
 
-import Data.Monoid as X
+import Data.Monoid as Monoid
 
 #if !MIN_VERSION_base(4,8,0)
-import Protolude.Bifunctor as X (Bifunctor(..))
+import Protolude.Bifunctor as Bifunctor (Bifunctor(bimap, first, second))
 #else
-import Data.Bifunctor as X (Bifunctor(..))
+import Data.Bifunctor as Bifunctor (Bifunctor(bimap, first, second))
 #endif
 
 -- Deepseq
-import Control.DeepSeq as X (
+import Control.DeepSeq as DeepSeq (
     NFData(..)
   , ($!!)
   , deepseq
@@ -156,7 +295,7 @@ import Control.DeepSeq as X (
   )
 
 -- Data structures
-import Data.Tuple as X (
+import Data.Tuple as Tuple (
     fst
   , snd
   , curry
@@ -164,7 +303,7 @@ import Data.Tuple as X (
   , swap
   )
 
-import Data.List as X (
+import Data.List as List (
     splitAt
   , break
   , intercalate
@@ -211,39 +350,43 @@ import Data.List (tail)
 #endif
 
 -- Hashing
-import Data.Hashable as X (
+import Data.Hashable as Hashable (
     Hashable
   , hash
   , hashWithSalt
   , hashUsing
   )
 
-import Data.Map as X (Map)
+import Data.Map as DataStructures (Map)
-import Data.Set as X (Set)
+import Data.Set as DataStructures (Set)
-import Data.Sequence as X (Seq)
+import Data.Sequence as DataStructures (Seq)
-import Data.IntMap as X (IntMap)
+import Data.IntMap as DataStructures (IntMap)
-import Data.IntSet as X (IntSet)
+import Data.IntSet as DataStructures (IntSet)
+
+import Data.Typeable as Typeable (
+    TypeRep
+  , Typeable
+  , typeOf
+  , cast
+  , gcast
+#if MIN_VERSION_base(4,7,0)
+  , typeRep
+  , eqT
+#endif
+  )
 
 #if MIN_VERSION_base(4,7,0)
-import Data.Proxy as X (
+import Data.Proxy as Typelevel (
     Proxy(..)
   )
 
-import Data.Typeable as X (
+import Data.Type.Coercion as Typelevel (
-    TypeRep
-  , Typeable
-  , typeRep
-  , cast
-  , eqT
-  )
-
-import Data.Type.Coercion as X (
     Coercion(..)
   , coerceWith
   , repr
   )
 
-import Data.Type.Equality as X (
+import Data.Type.Equality as Typelevel (
     (:~:)(..)
   , type (==)
   , sym
@@ -255,15 +398,19 @@ import Data.Type.Equality as X (
 #endif
 
 #if MIN_VERSION_base(4,8,0)
-import Data.Void as X (
+import Data.Void as Typelevel (
     Void
   , absurd
   , vacuous
   )
 #endif
 
+import Control.Monad.Fail as Fail (
+    MonadFail
+  )
+
 -- Monad transformers
-import Control.Monad.State as X (
+import Control.Monad.State as State (
     MonadState
   , State
   , StateT(StateT)
@@ -283,7 +430,7 @@ import Control.Monad.State as X (
   , evalStateT
   )
 
-import Control.Monad.Reader as X (
+import Control.Monad.Reader as Reader (
     MonadReader
   , Reader
   , ReaderT(ReaderT)
@@ -295,12 +442,12 @@ import Control.Monad.Reader as X (
   , runReaderT
   )
 
-import Control.Monad.Trans.Except as X (
+import Control.Monad.Trans.Except as Except (
     throwE
   , catchE
   )
 
-import Control.Monad.Except as X (
+import Control.Monad.Except as Except (
     MonadError
   , Except
   , ExceptT(ExceptT)
@@ -314,25 +461,60 @@ import Control.Monad.Except as X (
   , withExceptT
   )
 
-import Control.Monad.Trans as X (
+import Control.Monad.Trans as Trans (
     MonadIO
   , lift
   , liftIO
   )
 
 -- Base types
-import Data.Int as X (
+import Data.Int as Int (
     Int
   , Int8
   , Int16
   , Int32
   , Int64
   )
-import Data.Bits as X hiding (
+import Data.Bits as Bits (
-    unsafeShiftL
+  Bits,
-  , unsafeShiftR
+  (.&.),
+  (.|.),
+  xor,
+  complement,
+  shift,
+  rotate,
+#if MIN_VERSION_base(4,7,0)
+  zeroBits,
+#endif
+  bit,
+  setBit,
+  clearBit,
+  complementBit,
+  testBit,
+#if MIN_VERSION_base(4,7,0)
+  bitSizeMaybe,
+#endif
+  bitSize,
+  isSigned,
+  shiftL,
+  shiftR,
+  rotateL,
+  rotateR,
+  popCount,
+#if MIN_VERSION_base(4,7,0)
+  FiniteBits,
+  finiteBitSize,
+  bitDefault,
+  testBitDefault,
+  popCountDefault,
+#endif
+#if MIN_VERSION_base(4,8,0)
+  toIntegralSized,
+  countLeadingZeros,
+  countTrailingZeros,
+#endif
   )
-import Data.Word as X (
+import Data.Word as Bits (
     Word
   , Word8
   , Word16
@@ -345,8 +527,8 @@ import Data.Word as X (
 #endif
   )
 
-import Data.Either as X (
+import Data.Either as Either (
-    Either(..)
+    Either(Left,Right)
   , either
   , lefts
   , rights
@@ -357,8 +539,8 @@ import Data.Either as X (
 #endif
   )
 
-import Data.Complex as X (
+import Data.Complex as Complex (
-    Complex(..)
+    Complex((:+))
   , realPart
   , imagPart
   , mkPolar
@@ -368,11 +550,47 @@ import Data.Complex as X (
   , phase
   , conjugate
   )
-import Data.Char as X (chr)
+import Data.Char as Char (
-import Data.Bool as X hiding (bool)
+    Char
-import Data.Maybe as X hiding (fromJust)
+  , ord
+  , chr
+  , digitToInt
+  , intToDigit
+  , toUpper
+  , toLower
+  , toTitle
+  , isAscii
+  , isLetter
+  , isDigit
+  , isHexDigit
+  , isPrint
+  , isAlpha
+  , isAlphaNum
+  , isUpper
+  , isLower
+  , isSpace
+  , isControl
+  )
+import Data.Bool as Bool (
+  Bool(True, False),
+  (&&),
+  (||),
+  not,
+  otherwise
+  )
+import Data.Maybe as Maybe (
+    Maybe(Nothing, Just)
+  , maybe
+  , isJust
+  , isNothing
+  , fromMaybe
+  , listToMaybe
+  , maybeToList
+  , catMaybes
+  , mapMaybe
+  )
 
-import Data.Function as X (
+import Data.Function as Function (
     const
   , (.)
   , ($)
@@ -385,7 +603,7 @@ import Data.Function as X (
   )
 
 -- Genericss
-import GHC.Generics as X (
+import GHC.Generics as Generics (
     Generic(..)
   , Generic1
   , Rep
@@ -414,10 +632,10 @@ import GHC.Generics as X (
 
 -- ByteString
 import qualified Data.ByteString.Lazy
-import Data.ByteString as X (ByteString)
+import Data.ByteString as ByteString (ByteString)
 
 -- Text
-import Data.Text as X (
+import Data.Text as Text (
     Text
   , lines
   , words
@@ -426,7 +644,7 @@ import Data.Text as X (
   )
 import qualified Data.Text.Lazy
 
-import Data.Text.IO as X (
+import Data.Text.IO as Text (
     getLine
   , getContents
   , interact
@@ -435,19 +653,19 @@ import Data.Text.IO as X (
   , appendFile
   )
 
-import Data.Text.Lazy as X (
+import Data.Text.Lazy as Text (
     toStrict
   , fromStrict
   )
 
-import Data.Text.Encoding as X (
+import Data.Text.Encoding as Text (
     encodeUtf8
   , decodeUtf8
   , decodeUtf8'
   , decodeUtf8With
   )
 
-import Data.Text.Encoding.Error as X (
+import Data.Text.Encoding.Error as Text (
     OnDecodeError
   , OnError
   , UnicodeException
@@ -458,15 +676,15 @@ import Data.Text.Encoding.Error as X (
   )
 
 -- IO
-import System.Environment as X (getArgs)
+import System.Environment as System (getArgs)
 import qualified System.Exit
-import System.Exit as X (
+import System.Exit as System (
     ExitCode(..)
   , exitWith
   , exitFailure
   , exitSuccess
   )
-import System.IO as X (
+import System.IO as System (
     Handle
   , FilePath
   , IOMode(..)
@@ -478,24 +696,92 @@ import System.IO as X (
   )
 
 -- ST
-import Control.Monad.ST as X (
+import Control.Monad.ST as ST (
     ST
   , runST
   , fixST
   )
 
 -- Concurrency and Parallelism
-import Control.Exception as X hiding (
+import Control.Exception as Exception (
-    throw    -- Impure throw is forbidden.
+    Exception,
-  , throwIO
+    toException,
-  , throwTo
+    fromException,
-  , assert
+#if MIN_VERSION_base(4,8,0)
-  , Handler(..)
+    displayException,
+#endif
+    SomeException(SomeException)
+  , IOException
+  , ArithException(
+    Overflow,
+    Underflow,
+    LossOfPrecision,
+    DivideByZero,
+    Denormal,
+    RatioZeroDenominator
+    )
+  , ArrayException(IndexOutOfBounds, UndefinedElement)
+  , AssertionFailed(AssertionFailed)
+#if MIN_VERSION_base(4,7,0)
+  , SomeAsyncException(SomeAsyncException)
+  , asyncExceptionToException
+  , asyncExceptionFromException
+#endif
+  , AsyncException(StackOverflow, HeapOverflow, ThreadKilled, UserInterrupt)
+  , NonTermination(NonTermination)
+  , NestedAtomically(NestedAtomically)
+  , BlockedIndefinitelyOnMVar(BlockedIndefinitelyOnMVar)
+  , BlockedIndefinitelyOnSTM(BlockedIndefinitelyOnSTM)
+#if MIN_VERSION_base(4,8,0)
+  , AllocationLimitExceeded(AllocationLimitExceeded)
+#endif
+#if MIN_VERSION_base(4,10,0)
+  , CompactionFailed(CompactionFailed)
+#endif
+  , Deadlock(Deadlock)
+  , NoMethodError(NoMethodError)
+  , PatternMatchFail(PatternMatchFail)
+  , RecConError(RecConError)
+  , RecSelError(RecSelError)
+  , RecUpdError(RecUpdError)
+#if MIN_VERSION_base(4,9,0)
+  , ErrorCall(ErrorCall, ErrorCallWithLocation)
+#else
+  , ErrorCall(ErrorCall)
+#endif
+#if MIN_VERSION_base(4,9,0)
+  , TypeError(TypeError)
+#endif
+  , ioError
+  , catch
+  , catches
+  , Handler(Handler)
+  , catchJust
+  , handle
+  , handleJust
+  , try
+  , tryJust
+  , evaluate
+  , mapException
+  , mask
+  , mask_
+  , uninterruptibleMask
+  , uninterruptibleMask_
+  , MaskingState(..)
+  , getMaskingState
+#if MIN_VERSION_base(4,9,0)
+  , interruptible
+#endif
+  , allowInterrupt
+  , bracket
+  , bracket_
+  , bracketOnError
+  , finally
+  , onException
   )
+import qualified Control.Exception as PException
 
-import qualified Control.Exception
+import Control.Monad.STM as STM (
-
-import Control.Monad.STM as X (
     STM
   , atomically
 #if !(MIN_VERSION_stm(2,5,0))
@@ -508,11 +794,84 @@ import Control.Monad.STM as X (
   , throwSTM
   , catchSTM
   )
-import Control.Concurrent as X hiding (
+
-    throwTo
+import Control.Concurrent.MVar as Concurrency (
-  , yield
+    MVar
+  , newEmptyMVar
+  , newMVar
+  , takeMVar
+  , putMVar
+  , readMVar
+  , swapMVar
+  , tryTakeMVar
+  , tryPutMVar
+  , isEmptyMVar
+  , withMVar
+#if MIN_VERSION_base(4,7,0)
+  , withMVarMasked
+#endif
+  , modifyMVar_
+  , modifyMVar
+  , modifyMVarMasked_
+  , modifyMVarMasked
+#if MIN_VERSION_base(4,7,0)
+  , tryReadMVar
+  , mkWeakMVar
+#endif
+  , addMVarFinalizer
   )
-import Control.Concurrent.Async as X (
+import Control.Concurrent.Chan as Concurrency (
+    Chan
+  , newChan
+  , writeChan
+  , readChan
+  , dupChan
+  , getChanContents
+  , writeList2Chan
+  )
+import Control.Concurrent.QSem as Concurrency (
+    QSem
+  , newQSem
+  , waitQSem
+  , signalQSem
+  )
+import Control.Concurrent.QSemN as Concurrency (
+    QSemN
+  , newQSemN
+  , waitQSemN
+  , signalQSemN
+  )
+import Control.Concurrent as Concurrency (
+    ThreadId
+  , forkIO
+  , forkFinally
+  , forkIOWithUnmask
+  , killThread
+  , forkOn
+  , forkOnWithUnmask
+  , getNumCapabilities
+  , setNumCapabilities
+  , threadCapability
+  , yield
+  , threadDelay
+  , threadWaitRead
+  , threadWaitWrite
+#if MIN_VERSION_base(4,7,0)
+  , threadWaitReadSTM
+  , threadWaitWriteSTM
+#endif
+  , rtsSupportsBoundThreads
+  , forkOS
+#if MIN_VERSION_base(4,9,0)
+  , forkOSWithUnmask
+#endif
+  , isCurrentThreadBound
+  , runInBoundThread
+  , runInUnboundThread
+  , mkWeakThreadId
+  , myThreadId
+  )
+import Control.Concurrent.Async as Concurrency (
     Async(..)
   , Concurrently(..)
   , async
@@ -544,12 +903,12 @@ import Control.Concurrent.Async as X (
   , concurrently
   )
 
-import Foreign.Ptr as X (IntPtr, WordPtr)
+import Foreign.Ptr as Foreign (IntPtr, WordPtr)
-import Foreign.Storable as X (Storable)
+import Foreign.Storable as Foreign (Storable)
-import Foreign.StablePtr as X (StablePtr)
+import Foreign.StablePtr as Foreign (StablePtr)
 
 -- Read instances hiding unsafe builtins (read)
-import Text.Read as X (
+import Text.Read as Read (
     Read
   , reads
   , readMaybe
@@ -568,44 +927,52 @@ infixl 1 &
 x & f = f x
 #endif
 
+-- | The identity function, returns the give value unchanged.
 identity :: a -> a
 identity x = x
 
-map :: Functor f => (a -> b) -> f a -> f b
+map :: Functor.Functor f => (a -> b) -> f a -> f b
-map = fmap
+map = Functor.fmap
 
 uncons :: [a] -> Maybe (a, [a])
 uncons [] = Nothing
 uncons (x:xs) = Just (x, xs)
 
 unsnoc :: [x] -> Maybe ([x],x)
-unsnoc = foldr go Nothing
+unsnoc = Foldable.foldr go Nothing
   where
     go x mxs = Just (case mxs of
        Nothing -> ([], x)
        Just (xs, e) -> (x:xs, e))
 
+-- | Apply a function n times to a given value
 applyN :: Int -> (a -> a) -> a -> a
-applyN n f = X.foldr (.) identity (X.replicate n f)
+applyN n f = Foldable.foldr (.) identity (List.replicate n f)
 
-print :: (X.MonadIO m, PBase.Show a) => a -> m ()
+-- | The print function outputs a value of any printable type to the standard
+-- output device. Printable types are those that are instances of class Show;
+-- print converts values to strings for output using the show operation and adds
+-- a newline.
+print :: (Trans.MonadIO m, PBase.Show a) => a -> m ()
 print = liftIO . PBase.print
 
-throwIO :: (X.MonadIO m, Exception e) => e -> m a
+-- | Lifted throwIO
-throwIO = liftIO . Control.Exception.throwIO
+throwIO :: (Trans.MonadIO m, Exception e) => e -> m a
+throwIO = liftIO . PException.throwIO
 
-throwTo :: (X.MonadIO m, Exception e) => ThreadId -> e -> m ()
+-- | Lifted throwTo
-throwTo tid e = liftIO (Control.Exception.throwTo tid e)
+throwTo :: (Trans.MonadIO m, Exception e) => ThreadId -> e -> m ()
+throwTo tid e = liftIO (PException.throwTo tid e)
 
 -- | Do nothing returning unit inside applicative.
 pass :: Applicative f => f ()
 pass = pure ()
 
 guarded :: (Alternative f) => (a -> Bool) -> a -> f a
-guarded p x = X.bool empty (pure x) (p x)
+guarded p x = Bool.bool empty (pure x) (p x)
 
-guardedA :: (Functor f, Alternative t) => (a -> f Bool) -> a -> f (t a)
+guardedA :: (Functor.Functor f, Alternative t) => (a -> f Bool) -> a -> f (t a)
-guardedA p x = X.bool empty (pure x) <$> p x
+guardedA p x = Bool.bool empty (pure x) `Functor.fmap` p x
 
 -- | Lift an 'IO' operation with 1 argument into another monad
 liftIO1 :: MonadIO m => (a -> IO b) -> a -> m b
@@ -615,18 +982,18 @@ liftIO1 = (.) liftIO
 liftIO2 :: MonadIO m => (a -> b -> IO c) -> a -> b -> m c
 liftIO2 = ((.).(.)) liftIO
 
-show :: (Show a, StringConv String b) => a -> b
+show :: (Show a, ConvertText String b) => a -> b
-show x = toS (PBase.show x)
+show x = ConvertText.toS (PBase.show x)
 {-# SPECIALIZE show :: Show  a => a -> Text  #-}
 {-# SPECIALIZE show :: Show  a => a -> LText  #-}
-{-# SPECIALIZE show :: Show  a => a -> ByteString  #-}
-{-# SPECIALIZE show :: Show  a => a -> LByteString  #-}
 {-# SPECIALIZE show :: Show  a => a -> String  #-}
 
 #if MIN_VERSION_base(4,8,0)
+-- | Terminate main process with failure
 die :: Text -> IO a
-die err = System.Exit.die (toS err)
+die err = System.Exit.die (ConvertText.toS err)
 #else
+-- | Terminate main process with failure
 die :: Text -> IO a
 die err = hPutStrLn stderr err >> exitFailure
 #endif

src/Protolude/Applicative.hs

@@ -1,20 +1,21 @@
 {-# LANGUAGE Safe #-}
 {-# LANGUAGE NoImplicitPrelude #-}
 
-module Protolude.Applicative (
+module Protolude.Applicative
-  orAlt,
+  ( orAlt,
-  orEmpty,
+    orEmpty,
-  eitherA,
+    eitherA,
-  purer,
+    purer,
-  liftAA2,
+    liftAA2,
-  (<<*>>),
+    (<<*>>),
-) where
+  )
+where
 
-import Data.Bool (Bool)
-import Data.Function ((.))
-import Data.Either (Either(..))
-import Data.Monoid (Monoid(..))
 import Control.Applicative
+import Data.Bool (Bool)
+import Data.Either (Either (Left, Right))
+import Data.Function ((.))
+import Data.Monoid (Monoid (mempty))
 
 orAlt :: (Alternative f, Monoid a) => f a -> f a
 orAlt f = f <|> pure mempty
@@ -33,5 +34,5 @@ liftAA2 = liftA2 . liftA2
 
 infixl 4 <<*>>
 
-(<<*>>) :: (Applicative f, Applicative g)  => f (g (a -> b)) -> f (g a) -> f (g b)
+(<<*>>) :: (Applicative f, Applicative g) => f (g (a -> b)) -> f (g a) -> f (g b)
 (<<*>>) = liftA2 (<*>)

src/Protolude/Base.hs

@@ -1,11 +1,12 @@
 {-# LANGUAGE CPP #-}
+{-# LANGUAGE MagicHash #-}
 {-# LANGUAGE Unsafe #-}
 {-# LANGUAGE BangPatterns #-}
 {-# LANGUAGE NoImplicitPrelude #-}
 {-# LANGUAGE ExplicitNamespaces #-}
 
 module Protolude.Base (
-  module X,
+  module Base,
   ($!),
 ) where
 
@@ -13,35 +14,118 @@ module Protolude.Base (
 #if defined(__GLASGOW_HASKELL__) && ( __GLASGOW_HASKELL__ >= 600 )
 
 -- Base GHC types
-import GHC.Num as X (
+import GHC.Num as Base (
-    Num(..)
+    Num(
+      (+),
+      (-),
+      (*),
+      negate,
+      abs,
+      signum,
+      fromInteger
+    )
   , Integer
   , subtract
   )
-import GHC.Enum as X (
+import GHC.Enum as Base (
-    Bounded(..)
+    Bounded(minBound, maxBound)
-  , Enum(..)
+  , Enum(
+      succ,
+      pred,
+      toEnum,
+      fromEnum,
+      enumFrom,
+      enumFromThen,
+      enumFromTo,
+      enumFromThenTo
+    )
   , boundedEnumFrom
   , boundedEnumFromThen
   )
-import GHC.Real as X
+import GHC.Real as Base (
-import GHC.Float as X (
+    (%)
-    Float(..)
+  , (/)
-  , Double(..)
+  , Fractional
+  , Integral
+  , Ratio
+  , Rational
+  , Real
+  , RealFrac
+  , (^)
+  , (^%^)
+  , (^^)
+  , (^^%^^)
+  , ceiling
+  , denominator
+  , div
+  , divMod
+#if MIN_VERSION_base(4,7,0)
+  , divZeroError
+#endif
+  , even
+  , floor
+  , fromIntegral
+  , fromRational
+  , gcd
+#if MIN_VERSION_base(4,9,0)
+  , gcdInt'
+  , gcdWord'
+#endif
+  , infinity
+  , integralEnumFrom
+  , integralEnumFromThen
+  , integralEnumFromThenTo
+  , integralEnumFromTo
+  , lcm
+  , mod
+  , notANumber
+  , numerator
+  , numericEnumFrom
+  , numericEnumFromThen
+  , numericEnumFromThenTo
+  , numericEnumFromTo
+  , odd
+#if MIN_VERSION_base(4,7,0)
+  , overflowError
+#endif
+  , properFraction
+  , quot
+  , quotRem
+  , ratioPrec
+  , ratioPrec1
+#if MIN_VERSION_base(4,7,0)
+  , ratioZeroDenominatorError
+#endif
+  , realToFrac
+  , recip
+  , reduce
+  , rem
+  , round
+  , showSigned
+  , toInteger
+  , toRational
+  , truncate
+#if MIN_VERSION_base(4,12,0)
+  , underflowError
+#endif
+  )
+import GHC.Float as Base (
+    Float(F#)
+  , Double(D#)
   , Floating (..)
   , RealFloat(..)
   , showFloat
   , showSignedFloat
   )
-import GHC.Show as X (
+import GHC.Show as Base (
-    Show(..)
+    Show(showsPrec, show, showList)
   )
-import GHC.Exts as X (
+import GHC.Exts as Base (
     Constraint
   , Ptr
   , FunPtr
   )
-import GHC.Base as X (
+import GHC.Base as Base (
     (++)
   , seq
   , asTypeOf
@@ -52,13 +136,13 @@ import GHC.Base as X (
   )
 
 -- Exported for lifting into new functions.
-import System.IO as X (
+import System.IO as Base (
     print
   , putStr
   , putStrLn
   )
 
-import GHC.Types as X (
+import GHC.Types as Base (
     Bool
   , Char
   , Int
@@ -71,22 +155,22 @@ import GHC.Types as X (
   )
 
 #if ( __GLASGOW_HASKELL__ >= 710 )
-import GHC.StaticPtr as X (StaticPtr)
+import GHC.StaticPtr as Base (StaticPtr)
 #endif
 
 #if ( __GLASGOW_HASKELL__ >= 800 )
-import GHC.OverloadedLabels as X (
+import GHC.OverloadedLabels as Base (
-    IsLabel(..)
+    IsLabel(fromLabel)
   )
 
-import GHC.ExecutionStack as X (
+import GHC.ExecutionStack as Base (
-    Location(..)
+    Location(Location, srcLoc, objectName, functionName)
-  , SrcLoc(..)
+  , SrcLoc(SrcLoc, sourceColumn, sourceLine, sourceColumn)
   , getStackTrace
   , showStackTrace
   )
 
-import GHC.Stack as X (
+import GHC.Stack as Base (
     CallStack
   , type HasCallStack
   , callStack
@@ -99,11 +183,11 @@ import GHC.Stack as X (
 #endif
 
 #if ( __GLASGOW_HASKELL__ >= 710 )
-import GHC.TypeLits as X (
+import GHC.TypeLits as Base (
     Symbol
-  , SomeSymbol(..)
+  , SomeSymbol(SomeSymbol)
   , Nat
-  , SomeNat(..)
+  , SomeNat(SomeNat)
   , CmpNat
   , KnownSymbol
   , KnownNat
@@ -115,13 +199,13 @@ import GHC.TypeLits as X (
 #endif
 
 #if ( __GLASGOW_HASKELL__ >= 802 )
-import GHC.Records as X (
+import GHC.Records as Base (
-    HasField(..)
+    HasField(getField)
   )
 #endif
 
 #if ( __GLASGOW_HASKELL__ >= 800 )
-import Data.Kind as X (
+import Data.Kind as Base (
   type Type
 #if ( __GLASGOW_HASKELL__ < 805 )
   , type (*)

src/Protolude/Bifunctor.hs

@@ -1,13 +1,17 @@
 {-# LANGUAGE Safe #-}
 {-# LANGUAGE NoImplicitPrelude #-}
 
-module Protolude.Bifunctor (
+module Protolude.Bifunctor
-  Bifunctor(..)
+  ( Bifunctor,
-) where
+    bimap,
+    first,
+    second,
+  )
+where
 
-import Data.Function (id, (.))
+import Control.Applicative (Const (Const))
-import Data.Either (Either(..))
+import Data.Either (Either (Left, Right))
-import Control.Applicative ( Const(..) )
+import Data.Function ((.), id)
 
 class Bifunctor p where
   {-# MINIMAL bimap | first, second #-}

src/Protolude/Bool.hs

@@ -13,7 +13,7 @@ module Protolude.Bool (
 , (<||>)
 ) where
 
-import Data.Bool (Bool(..), (&&), (||))
+import Data.Bool (Bool(True, False), (&&), (||))
 import Data.Function (flip)
 import Control.Applicative(Applicative, liftA2)
 import Control.Monad (Monad, MonadPlus, return, when, unless, guard, (>>=), (=<<))

src/Protolude/Conv.hs

@@ -2,11 +2,14 @@
 {-# LANGUAGE FlexibleInstances #-}
 {-# LANGUAGE TypeSynonymInstances #-}
 
+-- | An alternative to 'Protolude.ConvertText' that includes
+-- partial conversions. Not re-exported by 'Protolude'.
 module Protolude.Conv (
-  StringConv (..)
+  StringConv
+, strConv
 , toS
 , toSL
-, Leniency (..)
+, Leniency (Lenient, Strict)
 ) where
 
 import Data.ByteString.Char8      as B
@@ -18,8 +21,8 @@ import Data.Text.Lazy             as LT
 import Data.Text.Lazy.Encoding    as LT
 
 import Protolude.Base
-import Data.Eq (Eq(..))
+import Data.Eq (Eq)
-import Data.Ord (Ord(..))
+import Data.Ord (Ord)
 import Data.Function ((.), id)
 import Data.String (String)
 import Control.Applicative (pure)

src/Protolude/ConvertText.hs

@@ -0,0 +1,44 @@
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE Safe #-}
+
+-- | Non-partial text conversion typeclass and functions.
+-- For an alternative with partial conversions import 'Protolude.Conv'.
+module Protolude.ConvertText (
+  ConvertText (toS)
+, toUtf8
+, toUtf8Lazy
+) where
+
+import qualified Data.ByteString      as B
+import qualified Data.ByteString.Lazy as LB
+import qualified Data.Text            as T
+import qualified Data.Text.Lazy       as LT
+
+import Data.Function (id, (.))
+import Data.String (String)
+import Data.Text.Encoding (encodeUtf8)
+
+-- | Convert from one Unicode textual type to another. Not for serialization/deserialization,
+-- so doesn't have instances for bytestrings.
+class ConvertText a b where
+  toS :: a -> b
+
+instance ConvertText String String where toS = id
+instance ConvertText String T.Text where toS = T.pack
+instance ConvertText String LT.Text where toS = LT.pack
+
+instance ConvertText T.Text String where toS = T.unpack
+instance ConvertText T.Text LT.Text where toS = LT.fromStrict
+instance ConvertText T.Text T.Text where toS = id
+
+instance ConvertText LT.Text String where toS = LT.unpack
+instance ConvertText LT.Text T.Text where toS = LT.toStrict
+instance ConvertText LT.Text LT.Text where toS = id
+
+toUtf8 :: ConvertText a T.Text => a -> B.ByteString
+toUtf8 =
+  encodeUtf8 . toS
+
+toUtf8Lazy :: ConvertText a T.Text => a -> LB.ByteString
+toUtf8Lazy =
+  LB.fromStrict . encodeUtf8 . toS

src/Protolude/Debug.hs

@@ -2,7 +2,7 @@
 {-# LANGUAGE NoImplicitPrelude #-}
 {-# OPTIONS_GHC -fno-warn-warnings-deprecations #-}
 
-module Debug (
+module Protolude.Debug (
   undefined,
   trace,
   traceM,

src/Protolude/Either.hs

@@ -15,8 +15,8 @@ module Protolude.Either (
 
 import Data.Function (const)
 import Data.Monoid (Monoid, mempty)
-import Data.Maybe (Maybe(..), maybe)
+import Data.Maybe (Maybe(Nothing, Just), maybe)
-import Data.Either (Either(..), either)
+import Data.Either (Either(Left, Right), either)
 #if MIN_VERSION_base(4,10,0)
 import Data.Either (fromLeft, fromRight)
 #else

src/Protolude/Error.hs

@@ -1,6 +1,6 @@
 {-# LANGUAGE CPP #-}
-{-# LANGUAGE MagicHash #-}
 {-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE MagicHash #-}
 {-# LANGUAGE ImplicitParams #-}
 {-# LANGUAGE ExistentialQuantification #-}
 #if ( __GLASGOW_HASKELL__ >= 800 )
@@ -15,12 +15,12 @@ module Protolude.Error
 ( error
 ) where
 
-import GHC.Prim
 import Data.Text (Text, unpack)
 
 #if MIN_VERSION_base(4,9,0)
 -- Full stack trace.
 
+import GHC.Prim (TYPE, raise#)
 import GHC.Types (RuntimeRep)
 import Protolude.CallStack (HasCallStack)
 import GHC.Exception (errorCallWithCallStackException)
@@ -32,6 +32,7 @@ error s = raise# (errorCallWithCallStackException (unpack s) ?callStack)
 #elif MIN_VERSION_base(4,7,0)
 -- Basic Call Stack with callsite.
 
+import GHC.Prim (raise#)
 import GHC.Exception (errorCallException)
 
 {-# WARNING error "'error' remains in code" #-}

src/Protolude/Exceptions.hs

@@ -12,11 +12,11 @@ import Protolude.Base (IO)
 import Data.Function ((.))
 import Control.Monad.Trans (liftIO)
 import Control.Monad.IO.Class (MonadIO)
-import Control.Monad.Except (ExceptT(..), MonadError, throwError)
+import Control.Monad.Except (ExceptT(ExceptT), MonadError, throwError)
 import Control.Exception as Exception
 import Control.Applicative
 import Data.Maybe (Maybe, maybe)
-import Data.Either (Either(..))
+import Data.Either (Either(Left,Right))
 
 hush :: Alternative m => Either e a -> m a
 hush (Left _)  = empty

src/Protolude/Functor.hs

@@ -3,8 +3,9 @@
 {-# LANGUAGE NoImplicitPrelude #-}
 
 module Protolude.Functor (
-  Functor(..),
+  Functor(fmap),
   ($>),
+  (<$),
   (<$>),
   (<<$>>),
   (<&>),
@@ -12,23 +13,23 @@ module Protolude.Functor (
   foreach,
 ) where
 
-import Data.Function ((.))
+import Data.Function ((.), flip)
-import Data.Function (flip)
-
 #if MIN_VERSION_base(4,11,0)
 import Data.Functor ((<&>))
 #endif
 
 #if MIN_VERSION_base(4,7,0)
 import Data.Functor (
-    Functor(..)
+    Functor(fmap)
+  , (<$)
   , ($>)
   , (<$>)
   , void
   )
 #else
 import Data.Functor (
-    Functor(..)
+    Functor(fmap)
+  , (<$)
   , (<$>)
   )
 

src/Protolude/List.hs

@@ -1,25 +1,26 @@
-{-# LANGUAGE Safe #-}
 {-# LANGUAGE NoImplicitPrelude #-}
+{-# LANGUAGE Safe #-}
 
-module Protolude.List (
+module Protolude.List
-  head,
+  ( head,
-  ordNub,
+    ordNub,
-  sortOn,
+    sortOn,
-  list,
+    list,
-  product,
+    product,
-  sum,
+    sum,
-  groupBy,
+    groupBy,
-) where
+  )
+where
 
-import Data.List (sortBy, groupBy)
+import Control.Applicative (pure)
-import Data.Maybe (Maybe(..))
+import Data.Foldable (Foldable, foldl', foldr)
-import Data.Ord (Ord, comparing)
-import Data.Foldable (Foldable, foldr, foldl')
 import Data.Function ((.))
 import Data.Functor (fmap)
-import Control.Applicative (pure)
+import Data.List (groupBy, sortBy)
+import Data.Maybe (Maybe (Nothing))
+import Data.Ord (Ord, comparing)
 import qualified Data.Set as Set
-import GHC.Num (Num, (+), (*))
+import GHC.Num ((*), (+), Num)
 
 head :: (Foldable f) => f a -> Maybe a
 head = foldr (\x _ -> pure x) Nothing
@@ -31,16 +32,16 @@ sortOn = sortBy . comparing
 ordNub :: (Ord a) => [a] -> [a]
 ordNub l = go Set.empty l
   where
-    go _ []     = []
+    go _ [] = []
-    go s (x:xs) =
+    go s (x : xs) =
       if x `Set.member` s
-      then go s xs
+        then go s xs
-      else x : go (Set.insert x s) xs
+        else x : go (Set.insert x s) xs
 
 list :: [b] -> (a -> b) -> [a] -> [b]
 list def f xs = case xs of
   [] -> def
-  _  -> fmap f xs
+  _ -> fmap f xs
 
 {-# INLINE product #-}
 product :: (Foldable f, Num a) => f a -> a

src/Protolude/Monad.hs

@@ -4,7 +4,7 @@
 
 module Protolude.Monad (
     Monad((>>=), return)
-  , MonadPlus(..)
+  , MonadPlus(mzero, mplus)
 
   , (=<<)
   , (>=>)

src/Protolude/Panic.hs

@@ -7,7 +7,7 @@
 #endif
 
 module Protolude.Panic (
-  FatalError(..),
+  FatalError(FatalError, fatalErrorMessage),
   panic,
 ) where
 
@@ -18,7 +18,7 @@ import Data.Typeable (Typeable)
 import Control.Exception as X
 
 -- | Uncatchable exceptions thrown and never caught.
-data FatalError = FatalError { fatalErrorMessage :: Text }
+newtype FatalError = FatalError { fatalErrorMessage :: Text }
   deriving (Show, Typeable)
 
 instance Exception FatalError

src/Protolude/Partial.hs

@@ -0,0 +1,26 @@
+module Protolude.Partial
+  ( head,
+    init,
+    tail,
+    last,
+    foldl,
+    foldr,
+    foldl',
+    foldr',
+    foldr1,
+    foldl1,
+    cycle,
+    maximum,
+    minimum,
+    (!!),
+    sum,
+    product,
+    fromJust,
+    read,
+  )
+where
+
+import Data.Foldable (foldl, foldl', foldl1, foldr, foldr', foldr1, product, sum)
+import Data.List ((!!), cycle, head, init, last, maximum, minimum, tail)
+import Data.Maybe (fromJust)
+import Text.Read (read)

src/Protolude/Safe.hs

@@ -26,12 +26,12 @@ module Protolude.Safe (
 ) where
 
 
-import Data.Ord (Ord(..))
+import Data.Ord (Ord, (<))
 import Data.Int (Int)
 import Data.Char (Char)
 import Data.Bool (Bool, otherwise)
-import Data.Maybe (Maybe(..), fromMaybe)
+import Data.Maybe (Maybe(Nothing, Just), fromMaybe)
-import Data.Either (Either(..))
+import Data.Either (Either(Left, Right))
 import Data.Function ((.))
 import Data.List (null, head, last, tail, init, maximum, minimum, foldr1, foldl1, foldl1', (++))
 

src/Protolude/Semiring.hs

@@ -1,10 +1,13 @@
 {-# LANGUAGE Safe #-}
 {-# LANGUAGE NoImplicitPrelude #-}
 
-module Protolude.Semiring (
+module Protolude.Semiring
-  Semiring(..),
+  ( Semiring,
-  zero,
+    one,
-) where
+    (<.>),
+    zero,
+  )
+where
 
 import Data.Monoid
 

src/Protolude/Show.hs

@@ -1,35 +1,35 @@
-{-# LANGUAGE Trustworthy #-}
+{-# LANGUAGE ExtendedDefaultRules #-}
 {-# LANGUAGE FlexibleContexts #-}
 {-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE NoImplicitPrelude #-}
-{-# LANGUAGE TypeSynonymInstances #-}
-{-# LANGUAGE ExtendedDefaultRules #-}
 
-module Protolude.Show (
+module Protolude.Show
-  Print(..),
+  ( Print,
-  putText,
+    hPutStr,
-  putErrText,
+    putStr,
-  putLText,
+    hPutStrLn,
-  putByteString,
+    putStrLn,
-  putLByteString,
+    putErrLn,
-) where
+    putText,
-
+    putErrText,
-import qualified System.IO as Base
+    putLText,
-import qualified Protolude.Base as Base
+    putByteString,
-import Data.Function ((.))
+    putLByteString,
+  )
+where
 
 import Control.Monad.IO.Class (MonadIO, liftIO)
 import qualified Data.ByteString.Char8 as BS
 import qualified Data.ByteString.Lazy.Char8 as BL
-
+import Data.Function ((.))
 import qualified Data.Text as T
 import qualified Data.Text.IO as T
-
 import qualified Data.Text.Lazy as TL
 import qualified Data.Text.Lazy.IO as TL
-
+import qualified Protolude.Base as Base
-import System.IO (Handle, stdout, stderr)
+import qualified System.IO as Base
-
+import System.IO (Handle, stderr, stdout)
 
 class Print a where
   hPutStr :: MonadIO m => Handle -> a -> m ()
@@ -38,7 +38,7 @@ class Print a where
   hPutStrLn :: MonadIO m => Handle -> a -> m ()
   putStrLn :: MonadIO m => a -> m ()
   putStrLn = hPutStrLn stdout
-  putErrLn ::  MonadIO m => a -> m ()
+  putErrLn :: MonadIO m => a -> m ()
   putErrLn = hPutStrLn stderr
 
 instance Print T.Text where

src/Protolude/Unsafe.hs

@@ -1,7 +1,7 @@
 {-# LANGUAGE Unsafe #-}
 {-# LANGUAGE NoImplicitPrelude #-}
 
-module Unsafe (
+module Protolude.Unsafe (
   unsafeHead,
   unsafeTail,
   unsafeInit,
@@ -9,9 +9,12 @@ module Unsafe (
   unsafeFromJust,
   unsafeIndex,
   unsafeThrow,
+  unsafeRead,
 ) where
 
 import Protolude.Base (Int)
+import Data.Char (Char)
+import Text.Read (Read, read)
 import qualified Data.List as List
 import qualified Data.Maybe as Maybe
 import qualified Control.Exception as Exc
@@ -36,3 +39,6 @@ unsafeIndex = (List.!!)
 
 unsafeThrow :: Exc.Exception e => e -> a
 unsafeThrow = Exc.throw
+
+unsafeRead :: Read a => [Char] -> a
+unsafeRead = Text.Read.read

stack-10.0.yaml

@@ -1,6 +0,0 @@
-resolver: lts-10.0
-packages:
-- '.'
-extra-deps:
-flags: {}
-extra-package-dbs: []

stack-10.0.yaml.lock

@@ -1,12 +0,0 @@
-# This file was autogenerated by Stack.
-# You should not edit this file by hand.
-# For more information, please see the documentation at:
-#   https://docs.haskellstack.org/en/stable/lock_files
-
-packages: []
-snapshots:
-- completed:
-    size: 566883
-    url: https://raw.githubusercontent.com/commercialhaskell/stackage-snapshots/master/lts/10/0.yaml
-    sha256: d0ee122a83faa02a679829d43b3485b21827c3cc1cce0db8ac8957b78d45bee3
-  original: lts-10.0

stack-11.0.yaml

@@ -1,6 +0,0 @@
-resolver: lts-11.0
-packages:
-- '.'
-extra-deps:
-flags: {}
-extra-package-dbs: []

stack-11.0.yaml.lock

@@ -1,12 +0,0 @@
-# This file was autogenerated by Stack.
-# You should not edit this file by hand.
-# For more information, please see the documentation at:
-#   https://docs.haskellstack.org/en/stable/lock_files
-
-packages: []
-snapshots:
-- completed:
-    size: 504512
-    url: https://raw.githubusercontent.com/commercialhaskell/stackage-snapshots/master/lts/11/0.yaml
-    sha256: 2587f446431d8c77bcb963ca8ff0a839a7b7f77042b5a98901b6b47c61fdd8f8
-  original: lts-11.0

stack-12.0.yaml

@@ -1,6 +0,0 @@
-resolver: lts-12.0
-packages:
-- '.'
-extra-deps:
-flags: {}
-extra-package-dbs: []

stack-12.0.yaml.lock

@@ -1,12 +0,0 @@
-# This file was autogenerated by Stack.
-# You should not edit this file by hand.
-# For more information, please see the documentation at:
-#   https://docs.haskellstack.org/en/stable/lock_files
-
-packages: []
-snapshots:
-- completed:
-    size: 499178
-    url: https://raw.githubusercontent.com/commercialhaskell/stackage-snapshots/master/lts/12/0.yaml
-    sha256: 3e9a7b96708cd9196ce7e5396143725097a71f2e9ca8dc19f03f5082642bc1b5
-  original: lts-12.0

stack-13.0.yaml

@@ -1,6 +0,0 @@
-resolver: lts-13.0
-packages:
-- '.'
-extra-deps:
-flags: {}
-extra-package-dbs: []

stack-13.0.yaml.lock

@@ -1,12 +0,0 @@
-# This file was autogenerated by Stack.
-# You should not edit this file by hand.
-# For more information, please see the documentation at:
-#   https://docs.haskellstack.org/en/stable/lock_files
-
-packages: []
-snapshots:
-- completed:
-    size: 491155
-    url: https://raw.githubusercontent.com/commercialhaskell/stackage-snapshots/master/lts/13/0.yaml
-    sha256: 8d3c33e0feab8e04b9ed31452e0219a2b827ed1338c809f79d986c71a177e6ba
-  original: lts-13.0

stack-14.0.yaml

@@ -1,6 +0,0 @@
-resolver: lts-14.0
-packages:
-- '.'
-extra-deps:
-flags: {}
-extra-package-dbs: []

stack-14.0.yaml.lock

@@ -1,12 +0,0 @@
-# This file was autogenerated by Stack.
-# You should not edit this file by hand.
-# For more information, please see the documentation at:
-#   https://docs.haskellstack.org/en/stable/lock_files
-
-packages: []
-snapshots:
-- completed:
-    size: 523443
-    url: https://raw.githubusercontent.com/commercialhaskell/stackage-snapshots/master/lts/14/0.yaml
-    sha256: 283773e7120f5446d961eab35ea95c9af9c24187cc178537bd29273200a05171
-  original: lts-14.0

stack-7.10.yaml

@@ -1,6 +0,0 @@
-resolver: lts-6.24
-packages:
-- '.'
-extra-deps:
-flags: {}
-extra-package-dbs: []

stack-7.10.yaml.lock

@@ -1,12 +0,0 @@
-# This file was autogenerated by Stack.
-# You should not edit this file by hand.
-# For more information, please see the documentation at:
-#   https://docs.haskellstack.org/en/stable/lock_files
-
-packages: []
-snapshots:
-- completed:
-    size: 424557
-    url: https://raw.githubusercontent.com/commercialhaskell/stackage-snapshots/master/lts/6/24.yaml
-    sha256: 9d3250ce23b40d596f772bb6b6a94751ae39a7c4077050247eea5c4975bb942d
-  original: lts-6.24

stack-7.8.yaml

@@ -1,6 +0,0 @@
-resolver: lts-2.22
-packages:
-- '.'
-extra-deps:
-flags: {}
-extra-package-dbs: []

stack-7.8.yaml.lock

@@ -1,12 +0,0 @@
-# This file was autogenerated by Stack.
-# You should not edit this file by hand.
-# For more information, please see the documentation at:
-#   https://docs.haskellstack.org/en/stable/lock_files
-
-packages: []
-snapshots:
-- completed:
-    size: 222517
-    url: https://raw.githubusercontent.com/commercialhaskell/stackage-snapshots/master/lts/2/22.yaml
-    sha256: e88a72a77e2223a96478ad8c1234d3271dca012a881dc195b8b9565d44245e3c
-  original: lts-2.22

stack-8.0.yaml

@@ -1,6 +0,0 @@
-resolver: lts-7.8
-packages:
-- '.'
-extra-deps:
-flags: {}
-extra-package-dbs: []

stack-8.0.yaml.lock

@@ -1,12 +0,0 @@
-# This file was autogenerated by Stack.
-# You should not edit this file by hand.
-# For more information, please see the documentation at:
-#   https://docs.haskellstack.org/en/stable/lock_files
-
-packages: []
-snapshots:
-- completed:
-    size: 421254
-    url: https://raw.githubusercontent.com/commercialhaskell/stackage-snapshots/master/lts/7/8.yaml
-    sha256: 6c23440fac4e17615e869c98e7c4bd40ce4a4333a95da82d2176ab598d5db63f
-  original: lts-7.8

stack-9.0.yaml

@@ -1,6 +0,0 @@
-resolver: lts-9.0
-packages:
-- '.'
-extra-deps:
-flags: {}
-extra-package-dbs: []

stack-9.0.yaml.lock

@@ -1,12 +0,0 @@
-# This file was autogenerated by Stack.
-# You should not edit this file by hand.
-# For more information, please see the documentation at:
-#   https://docs.haskellstack.org/en/stable/lock_files
-
-packages: []
-snapshots:
-- completed:
-    size: 533451
-    url: https://raw.githubusercontent.com/commercialhaskell/stackage-snapshots/master/lts/9/0.yaml
-    sha256: 27f29b231b39ea68e967a7a4346b2693a49d77c50f41fc0c276e11189a538da7
-  original: lts-9.0

stack.yaml

@@ -1,6 +1,7 @@
-resolver: lts-7.14
+resolver: lts-14.0
 packages:
 - '.'
 extra-deps:
+- fail-4.9.0.0
 flags: {}
 extra-package-dbs: []

test_stack_lts.sh

@@ -1,32 +1,14 @@
 #!/usr/bin/env bash
-set +e
+set -e
 
-echo -e "\e[92mLTS 7.8"
+stack build --resolver lts-4.0
-STACK_YAML=stack-7.8.yaml  stack build  --no-terminal
+stack build --resolver lts-5.0
-
+stack build --resolver lts-6.0
-echo -e "\e[92mLTS 7.10"
+stack build --resolver lts-7.0
-STACK_YAML=stack-7.10.yaml stack build  --no-terminal
+stack build --resolver lts-8.0
-
+stack build --resolver lts-9.0
-echo -e "\e[92mLTS 8.0"
+stack build --resolver lts-10.0
-STACK_YAML=stack-8.0.yaml  stack build  --no-terminal
+stack build --resolver lts-11.0
-
+stack build --resolver lts-12.0
-echo -e "\e[92mLTS 9.0"
+stack build --resolver lts-13.0
-STACK_YAML=stack-9.0.yaml  stack build  --no-terminal
+stack build --resolver lts-14.0
-
-echo -e "\e[92mLTS 10.0"
-STACK_YAML=stack-10.0.yaml  stack build  --no-terminal
-
-echo -e "\e[92mLTS 11.0"
-STACK_YAML=stack-11.0.yaml  stack build  --no-terminal
-
-echo -e "\e[92mLTS 12.0"
-STACK_YAML=stack-12.0.yaml  stack build  --no-terminal
-
-echo -e "\e[92mLTS 13.0"
-STACK_YAML=stack-13.0.yaml  stack build  --no-terminal
-
-echo -e "\e[92mLTS 13.0"
-STACK_YAML=stack-14.0.yaml  stack build  --no-terminal
-
-echo -e "\e[92mLTS 14.0"
-STACK_YAML=stack-14.0.yaml  stack build  --no-terminal