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

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.List as X
-import Protolude.Show as X
-import Protolude.Bool as X
-import Protolude.Monad as X
-import Protolude.Functor as X
-import Protolude.Either as X
-import Protolude.Applicative as X
-import Protolude.Conv as X
-import Protolude.Panic as X
-import Protolude.Exceptions as X
-import Protolude.Semiring as X
+import Protolude.Debug as Debug
+import Protolude.List as List
+import Protolude.Show as Show
+import Protolude.Bool as Bool
+import Protolude.Monad as Monad
+import Protolude.Functor as Functor
+import Protolude.Either as Either
+import Protolude.Applicative as Applicative
+import Protolude.ConvertText as ConvertText
+import Protolude.Panic as Panic
+import Protolude.Exceptions as Exception
+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(..)
-  , ZipList(..)
+  , Const(Const,getConst)
+  , 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(..)
-  , Down(..)
+  , Ordering(LT,EQ,GT)
+  , Down(Down)
   , comparing
   )
-import Data.Traversable as X
-import Data.Foldable as X hiding (
-    foldr1
-  , foldl1
-  , product
-  , sum
+import Data.Traversable as Traversable
+import Data.Foldable as Foldable (
+    Foldable,
+    fold,
+    foldMap,
+    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 (
-    Identity(..)
+import Data.Functor.Identity as Functor (
+    Identity(Identity, runIdentity)
   )
 
 #if MIN_VERSION_base(4,9,0)
-import Data.List.NonEmpty as X (
-    NonEmpty(..)
+import Data.List.NonEmpty as List (
+    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.Set as X (Set)
-import Data.Sequence as X (Seq)
-import Data.IntMap as X (IntMap)
-import Data.IntSet as X (IntSet)
+import Data.Map as DataStructures (Map)
+import Data.Set as DataStructures (Set)
+import Data.Sequence as DataStructures (Seq)
+import Data.IntMap as DataStructures (IntMap)
+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 (
-    TypeRep
-  , Typeable
-  , typeRep
-  , cast
-  , eqT
-  )
-
-import Data.Type.Coercion as X (
+import Data.Type.Coercion as Typelevel (
     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 (
-    unsafeShiftL
-  , unsafeShiftR
+import Data.Bits as Bits (
+  Bits,
+  (.&.),
+  (.|.),
+  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 (
-    Either(..)
+import Data.Either as Either (
+    Either(Left,Right)
   , either
   , lefts
   , rights
@@ -357,8 +539,8 @@ import Data.Either as X (
 #endif
   )
 
-import Data.Complex as X (
-    Complex(..)
+import Data.Complex as Complex (
+    Complex((:+))
   , realPart
   , imagPart
   , mkPolar
@@ -368,11 +550,47 @@ import Data.Complex as X (
   , phase
   , conjugate
   )
-import Data.Char as X (chr)
-import Data.Bool as X hiding (bool)
-import Data.Maybe as X hiding (fromJust)
+import Data.Char as Char (
+    Char
+  , 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 (
-    throw    -- Impure throw is forbidden.
-  , throwIO
-  , throwTo
-  , assert
-  , Handler(..)
+import Control.Exception as Exception (
+    Exception,
+    toException,
+    fromException,
+#if MIN_VERSION_base(4,8,0)
+    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 X (
+import Control.Monad.STM as STM (
     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
-  , yield
+
+import Control.Concurrent.MVar as Concurrency (
+    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.Storable as X (Storable)
-import Foreign.StablePtr as X (StablePtr)
+import Foreign.Ptr as Foreign (IntPtr, WordPtr)
+import Foreign.Storable as Foreign (Storable)
+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 = fmap
+map :: Functor.Functor f => (a -> b) -> f a -> f b
+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
-throwIO = liftIO . Control.Exception.throwIO
+-- | Lifted throwIO
+throwIO :: (Trans.MonadIO m, Exception e) => e -> m a
+throwIO = liftIO . PException.throwIO
 
-throwTo :: (X.MonadIO m, Exception e) => ThreadId -> e -> m ()
-throwTo tid e = liftIO (Control.Exception.throwTo tid e)
+-- | Lifted throwTo
+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 p x = X.bool empty (pure x) <$> p x
+guardedA :: (Functor.Functor f, Alternative t) => (a -> f Bool) -> a -> f (t a)
+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 x = toS (PBase.show x)
+show :: (Show a, ConvertText String b) => a -> b
+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 (
-  orAlt,
-  orEmpty,
-  eitherA,
-  purer,
-  liftAA2,
-  (<<*>>),
-) where
+module Protolude.Applicative
+  ( orAlt,
+    orEmpty,
+    eitherA,
+    purer,
+    liftAA2,
+    (<<*>>),
+  )
+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 (
-    Num(..)
+import GHC.Num as Base (
+    Num(
+      (+),
+      (-),
+      (*),
+      negate,
+      abs,
+      signum,
+      fromInteger
+    )
   , Integer
   , subtract
   )
-import GHC.Enum as X (
-    Bounded(..)
-  , Enum(..)
+import GHC.Enum as Base (
+    Bounded(minBound, maxBound)
+  , Enum(
+      succ,
+      pred,
+      toEnum,
+      fromEnum,
+      enumFrom,
+      enumFromThen,
+      enumFromTo,
+      enumFromThenTo
+    )
   , boundedEnumFrom
   , boundedEnumFromThen
   )
-import GHC.Real as X
-import GHC.Float as X (
-    Float(..)
-  , Double(..)
+import GHC.Real as Base (
+    (%)
+  , (/)
+  , 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 (
-    Show(..)
+import GHC.Show as Base (
+    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 (
-    IsLabel(..)
+import GHC.OverloadedLabels as Base (
+    IsLabel(fromLabel)
   )
 
-import GHC.ExecutionStack as X (
-    Location(..)
-  , SrcLoc(..)
+import GHC.ExecutionStack as Base (
+    Location(Location, srcLoc, objectName, functionName)
+  , 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 (
-    HasField(..)
+import GHC.Records as Base (
+    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 (
-  Bifunctor(..)
-) where
+module Protolude.Bifunctor
+  ( Bifunctor,
+    bimap,
+    first,
+    second,
+  )
+where
 
-import Data.Function (id, (.))
-import Data.Either (Either(..))
-import Control.Applicative ( Const(..) )
+import Control.Applicative (Const (Const))
+import Data.Either (Either (Left, Right))
+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.Ord (Ord(..))
+import Data.Eq (Eq)
+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.Either (Either(..), either)
+import Data.Maybe (Maybe(Nothing, Just), maybe)
+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 (
-  head,
-  ordNub,
-  sortOn,
-  list,
-  product,
-  sum,
-  groupBy,
-) where
+module Protolude.List
+  ( head,
+    ordNub,
+    sortOn,
+    list,
+    product,
+    sum,
+    groupBy,
+  )
+where
 
-import Data.List (sortBy, groupBy)
-import Data.Maybe (Maybe(..))
-import Data.Ord (Ord, comparing)
-import Data.Foldable (Foldable, foldr, foldl')
+import Control.Applicative (pure)
+import Data.Foldable (Foldable, foldl', foldr)
 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 s (x:xs) =
+    go _ [] = []
+    go s (x : xs) =
       if x `Set.member` s
-      then go s xs
-      else x : go (Set.insert x s) xs
+        then go 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.Either (Either(..))
+import Data.Maybe (Maybe(Nothing, Just), fromMaybe)
+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 (
-  Semiring(..),
-  zero,
-) where
+module Protolude.Semiring
+  ( Semiring,
+    one,
+    (<.>),
+    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 (
-  Print(..),
-  putText,
-  putErrText,
-  putLText,
-  putByteString,
-  putLByteString,
-) where
-
-import qualified System.IO as Base
-import qualified Protolude.Base as Base
-import Data.Function ((.))
+module Protolude.Show
+  ( Print,
+    hPutStr,
+    putStr,
+    hPutStrLn,
+    putStrLn,
+    putErrLn,
+    putText,
+    putErrText,
+    putLText,
+    putByteString,
+    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 System.IO (Handle, stdout, stderr)
-
+import qualified Protolude.Base as Base
+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