diff --git a/BasicPrelude.hs b/BasicPrelude.hs
--- a/BasicPrelude.hs
+++ b/BasicPrelude.hs
@@ -1,163 +1,135 @@
 {-# LANGUAGE NoImplicitPrelude #-}
+
 module BasicPrelude
-    ( -- * Standard
-      -- ** Operators
-      (Prelude.$)
-    , (Prelude.&&)
-    , (Prelude.||)
-    , (Control.Category..)
-      -- ** Functions
-    , Prelude.not
-    , Prelude.otherwise
-    , Prelude.fst
-    , Prelude.snd
-    , Control.Category.id
-    , Prelude.maybe
-    , Prelude.either
-    , Prelude.flip
-    , Prelude.const
-    , Prelude.error
-    , Prelude.zip
-    , Prelude.unzip
-    , Prelude.zipWith
-    , Prelude.or
-    , Data.Text.IO.putStrLn
-    , Prelude.elem
-    , Prelude.odd
-    , Prelude.even
-    , Prelude.uncurry
-      -- ** Type classes
-    , Prelude.Ord (..)
-    , Prelude.Eq (..)
-    , Prelude.Enum (..)
-    , Prelude.Show
-    , Prelude.Functor (..)
-    , Prelude.Monad (..)
-    , (Control.Monad.=<<)
-      -- ** Numeric type classes
-    , Prelude.Num (..)
-    , Prelude.Real (..)
-    , Prelude.Integral (..)
-    , Prelude.Fractional (..)
-    , Prelude.Floating (..)
-    , Prelude.RealFrac (..)
-    , Prelude.RealFloat(..)
-      -- ** Data types
-    , Prelude.Maybe (..)
-    , Prelude.Ordering (..)
-    , Prelude.Bool (..)
-    , Prelude.Char
-    , Prelude.IO
-    , Prelude.Either (..)
-      -- * Re-exports
-      -- ** Packed reps
-    , ByteString
-    , LByteString
-    , Text
-    , LText
-      -- ** Containers
-    , Map
-    , HashMap
-    , Set
-    , HashSet
-    , Vector
-    , Hashable
-      -- ** Numbers
-    , Word
-    , Word8
-    , Word64
-    , Prelude.Int
-    , Int64
-    , Prelude.Integer
-    , Prelude.Rational
-    , Prelude.Float
-    , Prelude.Double
-      -- ** Numeric functions
-    , (Prelude.^)
-    , (Prelude.^^)
-    , Prelude.subtract
-    , Prelude.fromIntegral
-    , Prelude.realToFrac
-      -- ** Monoids
-    , Monoid (..)
-    , concat
-    , (++)
-      -- ** Arrow
-    , Control.Arrow.first
-    , Control.Arrow.second
-    , (Control.Arrow.***)
-    , (Control.Arrow.&&&)
-      -- ** Maybe
-    , Data.Maybe.mapMaybe
-    , Data.Maybe.catMaybes
-    , Data.Maybe.fromMaybe
-      -- ** Either
-    , Data.Either.partitionEithers
-      -- ** Applicative
-    , Control.Applicative.Applicative (..)
-    , (Control.Applicative.<$>)
-      -- ** Monad
-    , (Control.Monad.>=>)
-      -- ** Transformers
-    , Control.Monad.Trans.Class.lift
-    , Control.Monad.IO.Class.MonadIO
-    , Control.Monad.IO.Class.liftIO
-      -- ** Exceptions
-    , Control.Exception.Exception (..)
-    , Control.Exception.SomeException
-    , Control.Exception.throwIO
-      -- ** Files
-    , F.FilePath
-    , (F.</>)
-    , (F.<.>)
-    , F.hasExtension
-    , F.basename
-    , F.filename
-      -- ** Print
-    , Prelude.print
-    ) where
+  ( module CorePrelude
+  , module Data.List
+  , module Prelude
+  , module Data.Text
+  , module Data.Text.Lazy.IO
+  , module Control.Monad
+  , map
+  , show
+  , read
+  , sum
+  , product
+  , putStr
+  , getLine
+  , getContents
+  , readFile
+  , writeFile
+  , appendFile
+  , readIO
+  ) where
 
-import qualified Prelude
-import Prelude (Char, (.))
+import qualified Data.Text as T
+import qualified Data.Text.IO as T
+import qualified Data.Text.Lazy.IO as TL
+import qualified Prelude as P
+import qualified Filesystem.Path.CurrentOS as F
 
-import Data.Hashable (Hashable)
+import CorePrelude
 
-import Data.Monoid (Monoid (..))
-import qualified Control.Arrow
-import qualified Control.Applicative
-import qualified Control.Category
-import qualified Control.Monad
-import qualified Control.Exception
+import Data.List hiding
+  ( -- already in CorePrelude
+    (++)
+  , concat
+  
+    -- prefer Text versions instead
+  , lines
+  , words
+  , unlines
+  , unwords
+  , intercalate
+  
+    -- prefer map = fmap instead
+  , map
+    
+    -- prefer strict versions
+  , sum
+  , product
+  )
 
-import qualified Filesystem.Path.CurrentOS as F
+import Prelude
+  ( Bounded (..)
+  , gcd
+  , lcm
+  , seq
+  , ($!)
+  , curry
+  , until
+  , asTypeOf
+  , undefined
+  , String
+  , ReadS
+  , ShowS
+  , Read (..)
+  , Show (showsPrec, showList)
+  , reads
+  , shows
+  , showChar
+  , showString
+  , showParen
+  , readParen
+  , lex
+  , IOError
+  , ioError
+  , userError
+  , putChar
+  , getChar
+  , readLn
+  )
 
-import Data.Word (Word8, Word64, Word)
-import Data.Int (Int64)
+import Data.Text
+  ( lines
+  , words
+  , unlines
+  , unwords
+  , intercalate
+  )
 
-import qualified Data.Text.IO
+import Data.Text.Lazy.IO
+  ( interact
+  )
 
-import qualified Data.Maybe
-import qualified Data.Either
+-- Import *all of the things* from Control.Monad,
+-- specifically, the list-based things that
+-- CorePrelude doesn't export
+import Control.Monad
 
-import qualified Control.Monad.Trans.Class
-import qualified Control.Monad.IO.Class
 
-import Data.ByteString (ByteString)
-import qualified Data.ByteString.Lazy
-import Data.Text (Text)
-import qualified Data.Text.Lazy
-import Data.Vector (Vector)
-import Data.Map (Map)
-import Data.Set (Set)
-import Data.HashMap.Strict (HashMap)
-import Data.HashSet (HashSet)
+map :: (Functor f) => (a -> b) -> f a -> f b
+map = fmap
 
-type LText = Data.Text.Lazy.Text
-type LByteString = Data.ByteString.Lazy.ByteString
+show :: Show a => a -> Text
+show = T.pack . P.show
 
-concat :: Monoid w => [w] -> w
-concat = mconcat
+read :: Read a => Text -> a
+read = P.read . T.unpack
 
-infixr 5  ++
-(++) :: Monoid w => w -> w -> w
-(++) = mappend
+sum :: Num a => [a] -> a
+sum = foldl' (+) 0
+
+product :: Num a => [a] -> a
+product = foldl' (*) 1
+
+putStr :: Text -> IO ()
+putStr = T.putStr
+
+getLine :: IO Text
+getLine = T.getLine
+
+getContents :: IO LText
+getContents = TL.getContents
+
+readFile :: FilePath -> IO Text
+readFile = T.readFile . F.encodeString
+
+writeFile :: FilePath -> Text -> IO ()
+writeFile = T.writeFile . F.encodeString
+
+appendFile :: FilePath -> Text -> IO ()
+appendFile = T.appendFile . F.encodeString
+
+readIO :: Read a => Text -> IO a
+readIO = P.readIO . T.unpack
+
diff --git a/CorePrelude.hs b/CorePrelude.hs
new file mode 100644
--- /dev/null
+++ b/CorePrelude.hs
@@ -0,0 +1,191 @@
+{-# LANGUAGE NoImplicitPrelude #-}
+module CorePrelude
+    ( -- * Standard
+      -- ** Operators
+      (Prelude.$)
+    , (Prelude.$!)
+    , (Prelude.&&)
+    , (Prelude.||)
+    , (Control.Category..)
+      -- ** Functions
+    , Prelude.not
+    , Prelude.otherwise
+    , Prelude.fst
+    , Prelude.snd
+    , Control.Category.id
+    , Prelude.maybe
+    , Prelude.either
+    , Prelude.flip
+    , Prelude.const
+    , Prelude.error
+    , Prelude.zip
+    , Prelude.unzip
+    , Prelude.zipWith
+    , Prelude.or
+    , Data.Text.IO.putStrLn
+    , Prelude.elem
+    , Prelude.odd
+    , Prelude.even
+    , Prelude.uncurry
+    , Prelude.curry
+    , Data.Tuple.swap
+    , Prelude.until
+    , Prelude.asTypeOf
+    , Prelude.undefined
+    , Prelude.seq
+      -- ** Type classes
+    , Prelude.Ord (..)
+    , Prelude.Eq (..)
+    , Prelude.Enum (..)
+    , Prelude.Show
+    , Prelude.Functor (..)
+    , Prelude.Monad (..)
+    , (Control.Monad.=<<)
+      -- ** Numeric type classes
+    , Prelude.Num (..)
+    , Prelude.Real (..)
+    , Prelude.Integral (..)
+    , Prelude.Fractional (..)
+    , Prelude.Floating (..)
+    , Prelude.RealFrac (..)
+    , Prelude.RealFloat(..)
+      -- ** Data types
+    , Prelude.Maybe (..)
+    , Prelude.Ordering (..)
+    , Prelude.Bool (..)
+    , Prelude.Char
+    , Prelude.IO
+    , Prelude.Either (..)
+      -- * Re-exports
+      -- ** Packed reps
+    , ByteString
+    , LByteString
+    , Text
+    , LText
+      -- ** Containers
+    , Map
+    , HashMap
+    , Set
+    , HashSet
+    , Vector
+    , UVector
+    , Unbox
+    , Hashable
+      -- ** Numbers
+    , Word
+    , Word8
+    , Word32
+    , Word64
+    , Prelude.Int
+    , Int32
+    , Int64
+    , Prelude.Integer
+    , Prelude.Rational
+    , Prelude.Float
+    , Prelude.Double
+      -- ** Numeric functions
+    , (Prelude.^)
+    , (Prelude.^^)
+    , Prelude.subtract
+    , Prelude.fromIntegral
+    , Prelude.realToFrac
+      -- ** Monoids
+    , Monoid (..)
+    , empty
+    , concat
+    , (++)
+      -- ** Arrow
+    , Control.Arrow.first
+    , Control.Arrow.second
+    , (Control.Arrow.***)
+    , (Control.Arrow.&&&)
+      -- ** Maybe
+    , Data.Maybe.mapMaybe
+    , Data.Maybe.catMaybes
+    , Data.Maybe.fromMaybe
+      -- ** Either
+    , Data.Either.partitionEithers
+      -- ** Ord
+    , Data.Function.on
+    , Data.Ord.comparing
+    , equating
+      -- ** Applicative
+    , Control.Applicative.Applicative (..)
+    , (Control.Applicative.<$>)
+      -- ** Monad
+    , (Control.Monad.>=>)
+      -- ** Transformers
+    , Control.Monad.Trans.Class.lift
+    , Control.Monad.IO.Class.MonadIO
+    , Control.Monad.IO.Class.liftIO
+      -- ** Exceptions
+    , Control.Exception.Exception (..)
+    , Control.Exception.SomeException
+    , Control.Exception.throwIO
+      -- ** Files
+    , F.FilePath
+    , (F.</>)
+    , (F.<.>)
+    , F.hasExtension
+    , F.basename
+    , F.filename
+      -- ** Print
+    , Prelude.print
+    ) where
+
+import qualified Prelude
+import Prelude (Char, (.), Eq, Bool)
+
+import Data.Hashable (Hashable)
+import Data.Vector.Unboxed (Unbox)
+
+import Data.Monoid (Monoid (..))
+import qualified Control.Arrow
+import qualified Control.Applicative
+import qualified Control.Category
+import qualified Control.Monad
+import qualified Control.Exception
+
+import qualified Filesystem.Path.CurrentOS as F
+
+import Data.Word (Word8, Word32, Word64, Word)
+import Data.Int (Int32, Int64)
+
+import qualified Data.Text.IO
+
+import qualified Data.Maybe
+import qualified Data.Either
+import qualified Data.Ord
+import qualified Data.Function
+import qualified Data.Tuple
+
+import qualified Control.Monad.Trans.Class
+import qualified Control.Monad.IO.Class
+
+import Data.ByteString (ByteString)
+import qualified Data.ByteString.Lazy
+import Data.Text (Text)
+import qualified Data.Text.Lazy
+import Data.Vector (Vector)
+import qualified Data.Vector.Unboxed
+import Data.Map (Map)
+import Data.Set (Set)
+import Data.HashMap.Strict (HashMap)
+import Data.HashSet (HashSet)
+
+type LText = Data.Text.Lazy.Text
+type LByteString = Data.ByteString.Lazy.ByteString
+type UVector = Data.Vector.Unboxed.Vector
+
+empty :: Monoid w => w
+empty = mempty
+
+concat :: Monoid w => [w] -> w
+concat = mconcat
+
+infixr 5  ++
+(++) :: Monoid w => w -> w -> w
+(++) = mappend
+
+equating :: Eq a => (b -> a) -> b -> b -> Bool
+equating = Data.Function.on (Prelude.==)
diff --git a/basic-prelude.cabal b/basic-prelude.cabal
--- a/basic-prelude.cabal
+++ b/basic-prelude.cabal
@@ -1,6 +1,18 @@
 name:                basic-prelude
-version:             0.1.0.0
-synopsis:            An enhanced core prelude, meant for building up more complete preludes on top of.
+version:             0.2.0.0
+synopsis:            An enhanced core prelude; a common foundation for alternate preludes.
+description:
+    The premise of @basic-prelude@ is that there are a lot of very commonly desired features missing from the standard @Prelude@, such as commonly used operators (@\<$\>@ and @>=>@, for instance) and imports for common datatypes (e.g., @ByteString@ and @Vector@). At the same time, there are lots of other components which are more debatable, such as providing polymorphic versions of common functions.
+    .
+    So @basic-prelude@ is intended to give a common foundation for a number of alternate preludes. The package provides two modules: @CorePrelude@ provides the common ground for other preludes to build on top of, while @BasicPrelude@ exports @CorePrelude@ together with commonly used list functions to provide a drop-in replacement for the standard @Prelude@.
+    .
+    Users wishing to have an improved @Prelude@ can use @BasicPrelude@. Developers wishing to create a new prelude should use @CorePrelude@.
+    .
+    Release history:
+    .
+    [0.2] Renamed @BasicPrelude@ to @CorePrelude@ and added a new @BasicPrelude@ module provided a full-featured @Prelude@ alternative. Also added a number of new exports.
+    .
+    [0.1] Initial version, code taken from @classy-prelude@ with a few minor tweaks.
 
 homepage:            https://github.com/snoyberg/basic-prelude
 license:             MIT
@@ -13,7 +25,7 @@
 cabal-version:       >=1.8
 
 library
-  exposed-modules:     BasicPrelude
+  exposed-modules:     BasicPrelude, CorePrelude
   build-depends:       base                     >= 4       && < 5
                      , hashable
                      , bytestring