diff --git a/LICENSE b/LICENSE
new file mode 100644
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,20 @@
+Copyright (c) 2012 Dan Burton
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/ModularPrelude.hs b/ModularPrelude.hs
new file mode 100644
--- /dev/null
+++ b/ModularPrelude.hs
@@ -0,0 +1,8 @@
+{-# LANGUAGE NoImplicitPrelude #-}
+
+module ModularPrelude
+    ( module X
+    ) where
+
+import CorePrelude as X
+import Data.Default as X
diff --git a/ModularPrelude/ByteString.hs b/ModularPrelude/ByteString.hs
new file mode 100644
--- /dev/null
+++ b/ModularPrelude/ByteString.hs
@@ -0,0 +1,61 @@
+{-# LANGUAGE NoImplicitPrelude #-}
+
+module ModularPrelude.ByteString
+  ( ByteStringModule (..)
+  , _Data_ByteString_
+  ) where
+
+
+import ModularPrelude hiding (empty)
+import qualified Data.ByteString as S
+import qualified Filesystem.Path.CurrentOS as F
+
+
+data ByteStringModule = ByteString
+  { map       :: (Word8 -> Word8) -> ByteString -> ByteString
+  , concatMap :: (Word8 -> ByteString) -> ByteString -> ByteString
+  , filter    :: (Word8 -> Bool) -> ByteString -> ByteString
+  , length    :: ByteString -> Int
+  , singleton :: Word8 -> ByteString
+  , null      :: ByteString -> Bool
+  , pack      :: [Word8] -> ByteString
+  , unpack    :: ByteString -> [Word8]
+  , empty     :: ByteString
+  , readFile  :: FilePath -> IO ByteString
+  , writeFile :: FilePath -> ByteString -> IO ()
+  , break     :: (Word8 -> Bool) -> ByteString -> (ByteString, ByteString)
+  , span      :: (Word8 -> Bool) -> ByteString -> (ByteString, ByteString)
+  , dropWhile :: (Word8 -> Bool) -> ByteString -> ByteString
+  , takeWhile :: (Word8 -> Bool) -> ByteString -> ByteString
+  , any       :: (Word8 -> Bool) -> ByteString -> Bool
+  , all       :: (Word8 -> Bool) -> ByteString -> Bool
+  , splitAt   :: Int -> ByteString -> (ByteString, ByteString)
+  }
+
+
+_Data_ByteString_ :: ByteStringModule
+_Data_ByteString_ = ByteString
+  { map       = S.map
+  , concatMap = S.concatMap
+  , filter    = S.filter
+  , length    = S.length
+  , singleton = S.singleton
+  , null      = S.null
+  , pack      = S.pack
+  , unpack    = S.unpack
+  , empty     = S.empty
+  , readFile  = S.readFile . F.encodeString
+  , writeFile = S.writeFile . F.encodeString
+  , break     = S.break
+  , span      = S.span
+  , dropWhile = S.dropWhile
+  , takeWhile = S.takeWhile
+  , any       = S.any
+  , all       = S.all
+  , splitAt   = S.splitAt
+  }
+
+
+instance Default ByteStringModule where
+  def = _Data_ByteString_
+
diff --git a/ModularPrelude/Classy.hs b/ModularPrelude/Classy.hs
new file mode 100644
--- /dev/null
+++ b/ModularPrelude/Classy.hs
@@ -0,0 +1,141 @@
+{-# LANGUAGE NoImplicitPrelude, PolymorphicComponents #-}
+{-# LANGUAGE FlexibleContexts #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
+
+module ModularPrelude.Classy
+  ( ClassyModule (..)
+  , _ClassyPrelude_Classes_
+  ) where
+
+
+import ModularPrelude
+import Prelude (Read) -- This should be in CorePrelude
+import qualified ClassyPrelude as Classy
+import qualified ClassyPrelude.Classes as Classy
+import ClassyPrelude () -- Make sure we get all instances
+import ClassyPrelude.Classes
+  ( CanMap
+  , CanConcatMap
+  , CanFilter
+  , CanLength
+  , CanSingleton
+  , CanNull
+  , CanPack
+  , CanMapM
+  , CanMapM_
+  , CanLookup
+  , CanInsert
+  , CanDelete
+  , CanMember
+  , CanReadFile
+  , CanWriteFile
+  , CanStripPrefix
+  , CanBreak
+  , CanAny
+  , CanSplitAt
+  , CanFold
+  , CanWords
+  , CanSplit
+  , CanStripSuffix
+  , CanIsInfixOf
+  , CanReverse
+  , CanReplicate
+  )
+
+
+data ClassyModule = Classy
+  { map         :: CanMap       f i o => (i -> o) -> f
+  , concatMap   :: CanConcatMap f i o => (i -> o) -> f
+  , filter      :: CanFilter    f a   => (a -> Bool) -> f
+  , length      :: CanLength    c i   => c -> i
+  , singleton   :: CanSingleton c i   => i -> c
+  , null        :: CanNull      c     => c -> Bool
+  , pack        :: CanPack      c i   => [i] -> c
+  , unpack      :: CanPack      c i   => c -> [i]
+  , mapM        :: CanMapM    f m i o => (i -> m o) -> f
+  , mapM_       :: CanMapM_   f m i   => (i -> m o) -> f
+  , lookup      :: CanLookup    c k v => k -> c -> Maybe v
+  , insert      :: CanInsert    f     => f
+  , delete      :: CanDelete    c k   => k -> c -> c
+  , member      :: CanMember    c k   => k -> c -> Bool
+  , readFile    :: CanReadFile    a   => FilePath -> a
+  , writeFile   :: CanWriteFile   a   => FilePath -> a
+  , stripPrefix :: CanStripPrefix a   => a -> a -> Maybe a
+  , break       :: CanBreak     c i   => (i -> Bool) -> c -> (c, c)
+  , span        :: CanBreak     c i   => (i -> Bool) -> c -> (c, c)
+  , dropWhile   :: CanBreak     c i   => (i -> Bool) -> c -> c
+  , takeWhile   :: CanBreak     c i   => (i -> Bool) -> c -> c
+  , any         :: CanAny       c i   => (i -> Bool) -> c -> Bool
+  , all         :: CanAny       c i   => (i -> Bool) -> c -> Bool
+  , splitAt     :: CanSplitAt   c i   => i -> c -> (c, c)
+  , take        :: CanSplitAt   c i   => i -> c -> c
+  , drop        :: CanSplitAt   c i   => i -> c -> c
+  , fold        :: CanFold  f a accum => (accum -> a -> accum) -> accum -> f
+  , words       :: CanWords       t   => t -> [t]
+  , unwords     :: CanWords       t   => [t] -> t
+  , lines       :: CanWords       t   => t -> [t]
+  , unlines     :: CanWords       t   => [t] -> t
+  , split       :: CanSplit     c i   => (i -> Bool) -> c -> [c]
+  , stripSuffix :: CanStripSuffix a   => a -> a -> Maybe a
+  , isSuffixOf  :: CanStripSuffix a   => a -> a -> Bool
+  , isInfixOf   :: CanIsInfixOf   a   => a -> a -> Bool
+  , reverse     :: CanReverse     a   => a -> a
+  , replicate   :: CanReplicate a i l => l -> i -> a
+  , fromList    :: CanPack      c i   => [i] -> c
+  , toList      :: CanPack      c i   => c -> [i]
+  , show        :: (Show a, CanPack c Char) => a -> c  
+  , readMay     :: (Read b, CanPack a Char) => a -> Maybe b
+  , repack      :: (CanPack a i, CanPack b i) => a -> b
+  }
+
+
+_ClassyPrelude_Classes_ :: ClassyModule
+_ClassyPrelude_Classes_ = Classy
+  { map         = Classy.map
+  , concatMap   = Classy.concatMap
+  , filter      = Classy.filter
+  , length      = Classy.length
+  , singleton   = Classy.singleton
+  , null        = Classy.null
+  , pack        = Classy.pack
+  , unpack      = Classy.unpack
+  , mapM        = Classy.mapM
+  , mapM_       = Classy.mapM_
+  , lookup      = Classy.lookup
+  , insert      = Classy.insert
+  , delete      = Classy.delete
+  , member      = Classy.member
+  , readFile    = Classy.readFile
+  , writeFile   = Classy.writeFile
+  , stripPrefix = Classy.stripPrefix
+  , break       = Classy.break
+  , span        = Classy.span
+  , dropWhile   = Classy.dropWhile
+  , takeWhile   = Classy.takeWhile
+  , any         = Classy.any
+  , all         = Classy.all
+  , splitAt     = Classy.splitAt
+  , take        = Classy.take
+  , drop        = Classy.drop
+  , fold        = Classy.fold
+  , words       = Classy.words
+  , unwords     = Classy.unwords
+  , lines       = Classy.lines
+  , unlines     = Classy.unlines
+  , split       = Classy.split
+  , stripSuffix = Classy.stripSuffix
+  , isSuffixOf  = Classy.isSuffixOf
+  , isInfixOf   = Classy.isInfixOf
+  , reverse     = Classy.reverse
+  , replicate   = Classy.replicate
+  , fromList    = Classy.fromList
+  , toList      = Classy.toList
+  , show        = Classy.show
+  , readMay     = Classy.readMay
+  , repack      = Classy.repack
+  }
+
+
+instance Default ClassyModule where
+  def = _ClassyPrelude_Classes_
+
diff --git a/ModularPrelude/FilePath.hs b/ModularPrelude/FilePath.hs
new file mode 100644
--- /dev/null
+++ b/ModularPrelude/FilePath.hs
@@ -0,0 +1,31 @@
+{-# LANGUAGE NoImplicitPrelude #-}
+
+module ModularPrelude.FilePath
+  ( FilePathModule (..)
+  , _Filesystem_Path_CurrentOS_
+  ) where
+
+
+import Prelude (String)
+import ModularPrelude
+import qualified Filesystem.Path.CurrentOS as F
+
+
+data FilePathModule = FilePath
+  { pack        :: String -> FilePath
+  , unpack      :: FilePath -> String
+  , stripPrefix :: FilePath -> FilePath -> Maybe FilePath
+  }
+
+
+_Filesystem_Path_CurrentOS_ :: FilePathModule
+_Filesystem_Path_CurrentOS_ = FilePath
+  { pack        = F.decodeString
+  , unpack      = F.encodeString
+  , stripPrefix = F.stripPrefix
+  }
+
+
+instance Default FilePathModule where
+  def = _Filesystem_Path_CurrentOS_
+
diff --git a/ModularPrelude/From.hs b/ModularPrelude/From.hs
new file mode 100644
--- /dev/null
+++ b/ModularPrelude/From.hs
@@ -0,0 +1,19 @@
+{-# LANGUAGE NoImplicitPrelude #-}
+
+module ModularPrelude.From ( module X ) where
+
+import ModularPrelude.ByteString  as X (_Data_ByteString_)
+import ModularPrelude.LByteString as X (_Data_ByteString_Lazy_)
+import ModularPrelude.Text        as X (_Data_Text_)
+import ModularPrelude.LText       as X (_Data_Text_Lazy_)
+import ModularPrelude.Vector      as X (_Data_Vector_)
+import ModularPrelude.UVector     as X (_Data_Vector_Unboxed_)
+import ModularPrelude.Map         as X (_Data_Map_)
+import ModularPrelude.HashMap     as X (_Data_HashMap_Strict_)
+import ModularPrelude.LHashMap    as X (_Data_HashMap_Lazy_)
+import ModularPrelude.List        as X (_Data_List_)
+import ModularPrelude.Set         as X (_Data_Set_)
+import ModularPrelude.HashSet     as X (_Data_HashSet_)
+import ModularPrelude.FilePath    as X (_Filesystem_Path_CurrentOS_)
+import ModularPrelude.Classy      as X (_ClassyPrelude_Classes_)
+
diff --git a/ModularPrelude/HashMap.hs b/ModularPrelude/HashMap.hs
new file mode 100644
--- /dev/null
+++ b/ModularPrelude/HashMap.hs
@@ -0,0 +1,52 @@
+{-# LANGUAGE NoImplicitPrelude, PolymorphicComponents #-}
+
+module ModularPrelude.HashMap
+  ( HashMapModule (..)
+  , _Data_HashMap_Strict_
+  ) where
+
+
+import ModularPrelude hiding (empty)
+import qualified Data.HashMap.Strict as HashMap
+
+
+data HashMapModule = HashMap
+  { map       :: forall k a b. (a -> b) -> HashMap k a -> HashMap k b
+  , filter    :: forall k a. (k -> a -> Bool) -> HashMap k a -> HashMap k a
+  , length    :: forall k a. HashMap k a -> Int
+  , singleton :: forall k a. Hashable k => k -> a -> HashMap k a
+  , null      :: forall k a. HashMap k a -> Bool
+  , pack      :: forall k a. (Eq k, Hashable k) => [(k, a)] -> HashMap k a
+  , unpack    :: forall k a. HashMap k a -> [(k, a)]
+  , fromList  :: forall k a. (Eq k, Hashable k) => [(k, a)] -> HashMap k a
+  , toList    :: forall k a. HashMap k a -> [(k, a)]
+  , lookup    :: forall k a. (Eq k, Hashable k) => k -> HashMap k a -> Maybe a
+  , empty     :: forall k a. HashMap k a
+  , insert    :: forall k a. (Eq k, Hashable k) => k -> a -> HashMap k a -> HashMap k a
+  , delete    :: forall k a. (Eq k, Hashable k) => k -> HashMap k a -> HashMap k a
+  , member    :: forall k a. (Eq k, Hashable k) => k -> HashMap k a -> Bool
+  }
+
+
+_Data_HashMap_Strict_ :: HashMapModule
+_Data_HashMap_Strict_ = HashMap
+  { map       = HashMap.map
+  , filter    = HashMap.filterWithKey
+  , length    = HashMap.size
+  , singleton = HashMap.singleton
+  , null      = HashMap.null
+  , pack      = HashMap.fromList
+  , unpack    = HashMap.toList
+  , fromList  = HashMap.fromList
+  , toList    = HashMap.toList
+  , lookup    = HashMap.lookup
+  , empty     = HashMap.empty
+  , insert    = HashMap.insert
+  , delete    = HashMap.delete
+  , member    = HashMap.member
+  }
+
+
+instance Default HashMapModule where
+  def = _Data_HashMap_Strict_
+
diff --git a/ModularPrelude/HashSet.hs b/ModularPrelude/HashSet.hs
new file mode 100644
--- /dev/null
+++ b/ModularPrelude/HashSet.hs
@@ -0,0 +1,50 @@
+{-# LANGUAGE NoImplicitPrelude, PolymorphicComponents #-}
+
+module ModularPrelude.HashSet
+  ( HashSetModule (..)
+  , _Data_HashSet_
+  ) where
+
+
+import ModularPrelude hiding (empty)
+import qualified Data.HashSet as HashSet
+
+
+data HashSetModule = HashSet
+  { map         :: forall a b. (Hashable b, Eq b) => (a -> b) -> HashSet a -> HashSet b
+  , filter      :: forall a. (a -> Bool) -> HashSet a -> HashSet a
+  , length      :: forall a. HashSet a -> Int
+  , singleton   :: forall a. Hashable a => a -> HashSet a
+  , null        :: forall a. HashSet a -> Bool
+  , pack        :: forall a. (Eq a, Hashable a) => [a] -> HashSet a
+  , unpack      :: forall a. HashSet a -> [a]
+  , fromList    :: forall a. (Eq a, Hashable a) => [a] -> HashSet a
+  , toList      :: forall a. HashSet a -> [a]
+  , empty       :: forall a. HashSet a
+  , insert      :: forall a. (Eq a, Hashable a) => a -> HashSet a -> HashSet a
+  , delete      :: forall a. (Eq a, Hashable a) => a -> HashSet a -> HashSet a
+  , member      :: forall a. (Eq a, Hashable a) => a -> HashSet a -> Bool
+  }
+
+
+_Data_HashSet_ :: HashSetModule
+_Data_HashSet_ = HashSet
+  { map         = HashSet.map
+  , filter      = HashSet.filter
+  , length      = HashSet.size
+  , singleton   = HashSet.singleton
+  , null        = HashSet.null
+  , pack        = HashSet.fromList
+  , unpack      = HashSet.toList
+  , fromList    = HashSet.fromList
+  , toList      = HashSet.toList
+  , empty       = HashSet.empty
+  , insert      = HashSet.insert
+  , delete      = HashSet.delete
+  , member      = HashSet.member
+  }
+
+
+instance Default HashSetModule where
+  def = _Data_HashSet_
+
diff --git a/ModularPrelude/Import.hs b/ModularPrelude/Import.hs
new file mode 100644
--- /dev/null
+++ b/ModularPrelude/Import.hs
@@ -0,0 +1,40 @@
+{-# LANGUAGE NoImplicitPrelude #-}
+
+module ModularPrelude.Import where
+
+
+import           ModularPrelude
+import qualified ModularPrelude.From        as From
+
+
+import qualified ModularPrelude.ByteString  as Import
+import qualified ModularPrelude.LByteString as Import
+import qualified ModularPrelude.Text        as Import
+import qualified ModularPrelude.LText       as Import
+import qualified ModularPrelude.Vector      as Import
+import qualified ModularPrelude.UVector     as Import
+import qualified ModularPrelude.Map         as Import
+import qualified ModularPrelude.HashMap     as Import
+import qualified ModularPrelude.LHashMap    as Import
+import qualified ModularPrelude.List        as Import
+import qualified ModularPrelude.Set         as Import
+import qualified ModularPrelude.HashSet     as Import
+import qualified ModularPrelude.FilePath    as Import
+import qualified ModularPrelude.Classy      as Import
+
+
+import qualified Data.ByteString            as ByteString
+import qualified Data.ByteString.Lazy       as LByteString
+import qualified Data.Text                  as Text
+import qualified Data.Text.Lazy             as LText
+import qualified Data.Vector                as Vector
+import qualified Data.Vector.Unboxed        as UVector
+import qualified Data.Map                   as Map
+import qualified Data.HashMap.Strict        as HashMap
+import qualified Data.HashMap.Lazy          as LHashMap
+import qualified Data.List                  as List
+import qualified Data.Set                   as Set
+import qualified Data.HashSet               as HashSet
+import qualified Filesystem.Path.CurrentOS  as FilePath
+import qualified ClassyPrelude              as Classy
+
diff --git a/ModularPrelude/LByteString.hs b/ModularPrelude/LByteString.hs
new file mode 100644
--- /dev/null
+++ b/ModularPrelude/LByteString.hs
@@ -0,0 +1,61 @@
+{-# LANGUAGE NoImplicitPrelude #-}
+
+module ModularPrelude.LByteString
+  ( LByteStringModule (..)
+  , _Data_ByteString_Lazy_
+  ) where
+
+
+import ModularPrelude hiding (empty)
+import qualified Data.ByteString.Lazy as L
+import qualified Filesystem.Path.CurrentOS as F
+
+
+data LByteStringModule = LByteString
+  { map       :: (Word8 -> Word8) -> LByteString -> LByteString
+  , concatMap :: (Word8 -> LByteString) -> LByteString -> LByteString
+  , filter    :: (Word8 -> Bool) -> LByteString -> LByteString
+  , length    :: LByteString -> Int64
+  , singleton :: Word8 -> LByteString
+  , null      :: LByteString -> Bool
+  , pack      :: [Word8] -> LByteString
+  , unpack    :: LByteString -> [Word8]
+  , empty     :: LByteString
+  , readFile  :: FilePath -> IO LByteString
+  , writeFile :: FilePath -> LByteString -> IO ()
+  , break     :: (Word8 -> Bool) -> LByteString -> (LByteString, LByteString)
+  , span      :: (Word8 -> Bool) -> LByteString -> (LByteString, LByteString)
+  , dropWhile :: (Word8 -> Bool) -> LByteString -> LByteString
+  , takeWhile :: (Word8 -> Bool) -> LByteString -> LByteString
+  , any       :: (Word8 -> Bool) -> LByteString -> Bool
+  , all       :: (Word8 -> Bool) -> LByteString -> Bool
+  , splitAt   :: Int64 -> LByteString -> (LByteString, LByteString)
+  }
+
+
+_Data_ByteString_Lazy_ :: LByteStringModule
+_Data_ByteString_Lazy_ = LByteString
+  { map       = L.map
+  , concatMap = L.concatMap
+  , filter    = L.filter
+  , length    = L.length
+  , singleton = L.singleton
+  , null      = L.null
+  , pack      = L.pack
+  , unpack    = L.unpack
+  , empty     = L.empty
+  , readFile  = L.readFile . F.encodeString
+  , writeFile = L.writeFile . F.encodeString
+  , break     = L.break
+  , span      = L.span
+  , dropWhile = L.dropWhile
+  , takeWhile = L.takeWhile
+  , any       = L.any
+  , all       = L.all
+  , splitAt   = L.splitAt
+  }
+
+
+instance Default LByteStringModule where
+  def = _Data_ByteString_Lazy_
+
diff --git a/ModularPrelude/LHashMap.hs b/ModularPrelude/LHashMap.hs
new file mode 100644
--- /dev/null
+++ b/ModularPrelude/LHashMap.hs
@@ -0,0 +1,52 @@
+{-# LANGUAGE NoImplicitPrelude, PolymorphicComponents #-}
+
+module ModularPrelude.LHashMap
+  ( LHashMapModule (..)
+  , _Data_HashMap_Lazy_
+  ) where
+
+
+import ModularPrelude hiding (empty)
+import qualified Data.HashMap.Lazy as LHashMap
+
+
+data LHashMapModule = LHashMap
+  { map       :: forall k a b. (a -> b) -> HashMap k a -> HashMap k b
+  , filter    :: forall k a. (k -> a -> Bool) -> HashMap k a -> HashMap k a
+  , length    :: forall k a. HashMap k a -> Int
+  , singleton :: forall k a. Hashable k => k -> a -> HashMap k a
+  , null      :: forall k a. HashMap k a -> Bool
+  , pack      :: forall k a. (Eq k, Hashable k) => [(k, a)] -> HashMap k a
+  , unpack    :: forall k a. HashMap k a -> [(k, a)]
+  , fromList  :: forall k a. (Eq k, Hashable k) => [(k, a)] -> HashMap k a
+  , toList    :: forall k a. HashMap k a -> [(k, a)]
+  , lookup    :: forall k a. (Eq k, Hashable k) => k -> HashMap k a -> Maybe a
+  , empty     :: forall k a. HashMap k a
+  , insert    :: forall k a. (Eq k, Hashable k) => k -> a -> HashMap k a -> HashMap k a
+  , delete    :: forall k a. (Eq k, Hashable k) => k -> HashMap k a -> HashMap k a
+  , member    :: forall k a. (Eq k, Hashable k) => k -> HashMap k a -> Bool
+  }
+
+
+_Data_HashMap_Lazy_ :: LHashMapModule
+_Data_HashMap_Lazy_ = LHashMap
+  { map       = LHashMap.map
+  , filter    = LHashMap.filterWithKey
+  , length    = LHashMap.size
+  , singleton = LHashMap.singleton
+  , null      = LHashMap.null
+  , pack      = LHashMap.fromList
+  , unpack    = LHashMap.toList
+  , fromList  = LHashMap.fromList
+  , toList    = LHashMap.toList
+  , lookup    = LHashMap.lookup
+  , empty     = LHashMap.empty
+  , insert    = LHashMap.insert
+  , delete    = LHashMap.delete
+  , member    = LHashMap.member
+  }
+
+
+instance Default LHashMapModule where
+  def = _Data_HashMap_Lazy_
+
diff --git a/ModularPrelude/LText.hs b/ModularPrelude/LText.hs
new file mode 100644
--- /dev/null
+++ b/ModularPrelude/LText.hs
@@ -0,0 +1,62 @@
+{-# LANGUAGE NoImplicitPrelude #-}
+
+module ModularPrelude.LText
+  ( LTextModule (..)
+  , _Data_Text_Lazy_
+  ) where
+
+
+import ModularPrelude hiding (empty)
+import qualified Data.Text.Lazy as TL
+import qualified Data.Text.Lazy.IO as TL
+import qualified Filesystem.Path.CurrentOS as F
+
+
+data LTextModule = LText
+  { map       :: (Char -> Char) -> LText -> LText
+  , concatMap :: (Char -> LText) -> LText -> LText
+  , filter    :: (Char -> Bool) -> LText -> LText
+  , length    :: LText -> Int64
+  , singleton :: Char -> LText
+  , null      :: LText -> Bool
+  , pack      :: [Char] -> LText
+  , unpack    :: LText -> [Char]
+  , empty     :: LText
+  , readFile  :: FilePath -> IO LText
+  , writeFile :: FilePath -> LText -> IO ()
+  , break     :: (Char -> Bool) -> LText -> (LText, LText)
+  , span      :: (Char -> Bool) -> LText -> (LText, LText)
+  , dropWhile :: (Char -> Bool) -> LText -> LText
+  , takeWhile :: (Char -> Bool) -> LText -> LText
+  , any       :: (Char -> Bool) -> LText -> Bool
+  , all       :: (Char -> Bool) -> LText -> Bool
+  , splitAt   :: Int64 -> LText -> (LText, LText)
+  }
+
+
+_Data_Text_Lazy_ :: LTextModule
+_Data_Text_Lazy_ = LText
+  { map       = TL.map
+  , concatMap = TL.concatMap
+  , filter    = TL.filter
+  , length    = TL.length
+  , singleton = TL.singleton
+  , null      = TL.null
+  , pack      = TL.pack
+  , unpack    = TL.unpack
+  , empty     = TL.empty
+  , readFile  = TL.readFile . F.encodeString
+  , writeFile = TL.writeFile . F.encodeString
+  , break     = TL.break
+  , span      = TL.span
+  , dropWhile = TL.dropWhile
+  , takeWhile = TL.takeWhile
+  , any       = TL.any
+  , all       = TL.all
+  , splitAt   = TL.splitAt
+  }
+
+
+instance Default LTextModule where
+  def = _Data_Text_Lazy_
+
diff --git a/ModularPrelude/List.hs b/ModularPrelude/List.hs
new file mode 100644
--- /dev/null
+++ b/ModularPrelude/List.hs
@@ -0,0 +1,72 @@
+{-# LANGUAGE NoImplicitPrelude, PolymorphicComponents #-}
+
+module ModularPrelude.List
+  ( ListModule (..)
+  , _Data_List_
+  ) where
+
+
+import ModularPrelude hiding (empty)
+import qualified Data.List as List
+
+
+data ListModule = List
+  { map         :: forall a b. (a -> b) -> [a] -> [b]
+  , concatMap   :: forall a b. (a -> [b]) -> [a] -> [b]
+  , filter      :: forall a. (a -> Bool) -> [a] -> [a]
+  , length      :: forall a. [a] -> Int
+  , singleton   :: forall a. a -> [a]
+  , null        :: forall a. [a] -> Bool
+  , pack        :: forall a. [a] -> [a]
+  , unpack      :: forall a. [a] -> [a]
+  , fromList    :: forall a. [a] -> [a]
+  , toList      :: forall a. [a] -> [a]
+  , lookup      :: forall k a. Eq k => k -> [(k, a)] -> Maybe a
+  , empty       :: forall a. [a]
+  , insert      :: forall a. a -> [a] -> [a]
+  , delete      :: forall a. Eq a => a -> [a] -> [a]
+  , member      :: forall a. Eq a => a -> [a] -> Bool
+  , stripPrefix :: forall a. Eq a => [a] -> [a] -> Maybe [a]
+  , break       :: forall a. (a -> Bool) -> [a] -> ([a], [a])
+  , span        :: forall a. (a -> Bool) -> [a] -> ([a], [a])
+  , dropWhile   :: forall a. (a -> Bool) -> [a] -> [a]
+  , takeWhile   :: forall a. (a -> Bool) -> [a] -> [a]
+  , any         :: forall a. (a -> Bool) -> [a] -> Bool
+  , all         :: forall a. (a -> Bool) -> [a] -> Bool
+  , splitAt     :: forall a. Int -> [a] -> ([a], [a])
+  , fold        :: forall a b. (a -> b -> a) -> a -> [b] -> a
+  }
+
+
+_Data_List_ :: ListModule
+_Data_List_ = List
+  { map         = List.map
+  , concatMap   = List.concatMap
+  , filter      = List.filter
+  , length      = List.length
+  , singleton   = return
+  , null        = List.null
+  , pack        = id
+  , unpack      = id
+  , fromList    = id
+  , toList      = id
+  , lookup      = List.lookup
+  , empty       = []
+  , insert      = (:)
+  , delete      = List.delete
+  , member      = List.elem
+  , stripPrefix = List.stripPrefix
+  , break       = List.break
+  , span        = List.span
+  , dropWhile   = List.dropWhile
+  , takeWhile   = List.takeWhile
+  , any         = List.any
+  , all         = List.all
+  , splitAt     = List.splitAt
+  , fold        = List.foldl'
+  }
+
+
+instance Default ListModule where
+  def = _Data_List_
+
diff --git a/ModularPrelude/Map.hs b/ModularPrelude/Map.hs
new file mode 100644
--- /dev/null
+++ b/ModularPrelude/Map.hs
@@ -0,0 +1,52 @@
+{-# LANGUAGE NoImplicitPrelude, PolymorphicComponents #-}
+
+module ModularPrelude.Map
+  ( MapModule (..)
+  , _Data_Map_
+  ) where
+
+
+import ModularPrelude hiding (empty)
+import qualified Data.Map as Map
+
+
+data MapModule = Map
+  { map       :: forall k a b. (a -> b) -> Map k a -> Map k b
+  , filter    :: forall k a. Ord k => (k -> a -> Bool) -> Map k a -> Map k a
+  , length    :: forall k a. Map k a -> Int
+  , singleton :: forall k a. k -> a -> Map k a
+  , null      :: forall k a. Map k a -> Bool
+  , pack      :: forall k a. Ord k => [(k, a)] -> Map k a
+  , unpack    :: forall k a. Map k a -> [(k, a)]
+  , fromList  :: forall k a. Ord k => [(k, a)] -> Map k a
+  , toList    :: forall k a. Map k a -> [(k, a)]
+  , lookup    :: forall k a. Ord k => k -> Map k a -> Maybe a
+  , empty     :: forall k a. Map k a
+  , insert    :: forall k a. Ord k => k -> a -> Map k a -> Map k a
+  , delete    :: forall k a. Ord k => k -> Map k a -> Map k a
+  , member    :: forall k a. Ord k => k -> Map k a -> Bool
+  }
+
+
+_Data_Map_ :: MapModule
+_Data_Map_ = Map
+  { map       = Map.map
+  , filter    = Map.filterWithKey
+  , length    = Map.size
+  , singleton = Map.singleton
+  , null      = Map.null
+  , pack      = Map.fromList
+  , unpack    = Map.toList
+  , fromList  = Map.fromList
+  , toList    = Map.toList
+  , lookup    = Map.lookup
+  , empty     = Map.empty
+  , insert    = Map.insert
+  , delete    = Map.delete
+  , member    = Map.member
+  }
+
+
+instance Default MapModule where
+  def = _Data_Map_
+
diff --git a/ModularPrelude/Set.hs b/ModularPrelude/Set.hs
new file mode 100644
--- /dev/null
+++ b/ModularPrelude/Set.hs
@@ -0,0 +1,50 @@
+{-# LANGUAGE NoImplicitPrelude, PolymorphicComponents #-}
+
+module ModularPrelude.Set
+  ( SetModule (..)
+  , _Data_Set_
+  ) where
+
+
+import ModularPrelude hiding (empty)
+import qualified Data.Set as Set
+
+
+data SetModule = Set
+  { map         :: forall a b. (Ord a, Ord b) => (a -> b) -> Set a -> Set b
+  , filter      :: forall a. (a -> Bool) -> Set a -> Set a
+  , length      :: forall a. Set a -> Int
+  , singleton   :: forall a. a -> Set a
+  , null        :: forall a. Set a -> Bool
+  , pack        :: forall a. Ord a => [a] -> Set a
+  , unpack      :: forall a. Set a -> [a]
+  , fromList    :: forall a. Ord a => [a] -> Set a
+  , toList      :: forall a. Set a -> [a]
+  , empty       :: forall a. Set a
+  , insert      :: forall a. Ord a => a -> Set a -> Set a
+  , delete      :: forall a. Ord a => a -> Set a -> Set a
+  , member      :: forall a. Ord a => a -> Set a -> Bool
+  }
+
+
+_Data_Set_ :: SetModule
+_Data_Set_ = Set
+  { map         = Set.map
+  , filter      = Set.filter
+  , length      = Set.size
+  , singleton   = Set.singleton
+  , null        = Set.null
+  , pack        = Set.fromList
+  , unpack      = Set.toList
+  , fromList    = Set.fromList
+  , toList      = Set.toList
+  , empty       = Set.empty
+  , insert      = Set.insert
+  , delete      = Set.delete
+  , member      = Set.member
+  }
+
+
+instance Default SetModule where
+  def = _Data_Set_
+
diff --git a/ModularPrelude/Text.hs b/ModularPrelude/Text.hs
new file mode 100644
--- /dev/null
+++ b/ModularPrelude/Text.hs
@@ -0,0 +1,62 @@
+{-# LANGUAGE NoImplicitPrelude #-}
+
+module ModularPrelude.Text
+  ( TextModule (..)
+  , _Data_Text_
+  ) where
+
+
+import ModularPrelude hiding (empty)
+import qualified Data.Text as T
+import qualified Data.Text.IO as T
+import qualified Filesystem.Path.CurrentOS as F
+
+
+data TextModule = Text
+  { map       :: (Char -> Char) -> Text -> Text
+  , concatMap :: (Char -> Text) -> Text -> Text
+  , filter    :: (Char -> Bool) -> Text -> Text
+  , length    :: Text -> Int
+  , singleton :: Char -> Text
+  , null      :: Text -> Bool
+  , pack      :: [Char] -> Text
+  , unpack    :: Text -> [Char]
+  , empty     :: Text
+  , readFile  :: FilePath -> IO Text
+  , writeFile :: FilePath -> Text -> IO ()
+  , break     :: (Char -> Bool) -> Text -> (Text, Text)
+  , span      :: (Char -> Bool) -> Text -> (Text, Text)
+  , dropWhile :: (Char -> Bool) -> Text -> Text
+  , takeWhile :: (Char -> Bool) -> Text -> Text
+  , any       :: (Char -> Bool) -> Text -> Bool
+  , all       :: (Char -> Bool) -> Text -> Bool
+  , splitAt   :: Int -> Text -> (Text, Text)
+  }
+
+
+_Data_Text_ :: TextModule
+_Data_Text_ = Text
+  { map       = T.map
+  , concatMap = T.concatMap
+  , filter    = T.filter
+  , length    = T.length
+  , singleton = T.singleton
+  , null      = T.null
+  , pack      = T.pack
+  , unpack    = T.unpack
+  , empty     = T.empty
+  , readFile  = T.readFile . F.encodeString
+  , writeFile = T.writeFile . F.encodeString
+  , break     = T.break
+  , span      = T.span
+  , dropWhile = T.dropWhile
+  , takeWhile = T.takeWhile
+  , any       = T.any
+  , all       = T.all
+  , splitAt   = T.splitAt
+  }
+
+
+instance Default TextModule where
+  def = _Data_Text_
+
diff --git a/ModularPrelude/UVector.hs b/ModularPrelude/UVector.hs
new file mode 100644
--- /dev/null
+++ b/ModularPrelude/UVector.hs
@@ -0,0 +1,74 @@
+{-# LANGUAGE NoImplicitPrelude, PolymorphicComponents #-}
+
+module ModularPrelude.UVector
+  ( UVectorModule (..)
+  , _Data_Vector_Unboxed_
+  , UVector
+  ) where
+
+
+import ModularPrelude hiding (empty)
+import qualified Data.Vector.Unboxed as UV
+
+
+data UVectorModule = UVector
+  { map       :: forall a b. (Unbox a, Unbox b)
+                                   => (a -> b) -> UVector a -> UVector b
+  , concatMap :: forall a b. (Unbox a, Unbox b)
+                                   => (a -> UVector b) -> UVector a -> UVector b
+  , filter    :: forall a. Unbox a => (a -> Bool) -> UVector a -> UVector a
+  , length    :: forall a. Unbox a => UVector a -> Int
+  , singleton :: forall a. Unbox a => a -> UVector a
+  , null      :: forall a. Unbox a => UVector a -> Bool
+  , pack      :: forall a. Unbox a => [a] -> UVector a
+  , unpack    :: forall a. Unbox a => UVector a -> [a]
+  , fromList  :: forall a. Unbox a => [a] -> UVector a
+  , toList    :: forall a. Unbox a => UVector a -> [a]
+  , mapM      :: forall a b m. (Unbox a, Unbox b, Monad m)
+                                   => (a -> m b) -> UVector a -> m (UVector b)
+  , mapM_     :: forall a b m. (Unbox a, Unbox b, Monad m)
+                                   => (a -> m b) -> UVector a -> m ()
+  , empty     :: forall a. Unbox a => UVector a
+  , member    :: forall a. Unbox a => Eq a => a -> UVector a -> Bool
+  , break     :: forall a. Unbox a => (a -> Bool) -> UVector a -> (UVector a, UVector a)
+  , span      :: forall a. Unbox a => (a -> Bool) -> UVector a -> (UVector a, UVector a)
+  , dropWhile :: forall a. Unbox a => (a -> Bool) -> UVector a -> UVector a
+  , takeWhile :: forall a. Unbox a => (a -> Bool) -> UVector a -> UVector a
+  , any       :: forall a. Unbox a => (a -> Bool) -> UVector a -> Bool
+  , all       :: forall a. Unbox a => (a -> Bool) -> UVector a -> Bool
+  , splitAt   :: forall a. Unbox a => Int -> UVector a -> (UVector a, UVector a)
+  , fold      :: forall a b. (Unbox a, Unbox b)
+                                   => (a -> b -> a) -> a -> UVector b -> a
+  }
+
+
+_Data_Vector_Unboxed_ :: UVectorModule
+_Data_Vector_Unboxed_ = UVector
+  { map       = UV.map
+  , concatMap = UV.concatMap
+  , filter    = UV.filter
+  , length    = UV.length
+  , singleton = UV.singleton
+  , null      = UV.null
+  , pack      = UV.fromList
+  , unpack    = UV.toList
+  , fromList  = UV.fromList
+  , toList    = UV.toList
+  , mapM      = UV.mapM
+  , mapM_     = UV.mapM_
+  , empty     = UV.empty
+  , member    = UV.any . (==)
+  , break     = UV.break
+  , span      = UV.span
+  , dropWhile = UV.dropWhile
+  , takeWhile = UV.takeWhile
+  , any       = UV.any
+  , all       = UV.all
+  , splitAt   = UV.splitAt
+  , fold      = UV.foldl'
+  }
+
+
+instance Default UVectorModule where
+  def = _Data_Vector_Unboxed_
+
diff --git a/ModularPrelude/Vector.hs b/ModularPrelude/Vector.hs
new file mode 100644
--- /dev/null
+++ b/ModularPrelude/Vector.hs
@@ -0,0 +1,68 @@
+{-# LANGUAGE NoImplicitPrelude, PolymorphicComponents #-}
+
+module ModularPrelude.Vector
+  ( VectorModule (..)
+  , _Data_Vector_
+  ) where
+
+
+import ModularPrelude hiding (empty)
+import qualified Data.Vector as V
+
+
+data VectorModule = Vector
+  { map       :: forall a b. (a -> b) -> Vector a -> Vector b
+  , concatMap :: forall a b. (a -> Vector b) -> Vector a -> Vector b
+  , filter    :: forall a. (a -> Bool) -> Vector a -> Vector a
+  , length    :: forall a. Vector a -> Int
+  , singleton :: forall a. a -> Vector a
+  , null      :: forall a. Vector a -> Bool
+  , pack      :: forall a. [a] -> Vector a
+  , unpack    :: forall a. Vector a -> [a]
+  , fromList  :: forall a. [a] -> Vector a
+  , toList    :: forall a. Vector a -> [a]
+  , mapM      :: forall a b m. Monad m => (a -> m b) -> Vector a -> m (Vector b)
+  , mapM_     :: forall a b m. Monad m => (a -> m b) -> Vector a -> m ()
+  , empty     :: forall a. Vector a
+  , member    :: forall a. Eq a => a -> Vector a -> Bool
+  , break     :: forall a. (a -> Bool) -> Vector a -> (Vector a, Vector a)
+  , span      :: forall a. (a -> Bool) -> Vector a -> (Vector a, Vector a)
+  , dropWhile :: forall a.(a -> Bool) -> Vector a -> Vector a
+  , takeWhile :: forall a.(a -> Bool) -> Vector a -> Vector a
+  , any       :: forall a.(a -> Bool) -> Vector a -> Bool
+  , all       :: forall a.(a -> Bool) -> Vector a -> Bool
+  , splitAt   :: forall a.Int -> Vector a -> (Vector a, Vector a)
+  , fold      :: forall a b. (a -> b -> a) -> a -> Vector b -> a
+  }
+
+
+_Data_Vector_ :: VectorModule
+_Data_Vector_ = Vector
+  { map       = V.map
+  , concatMap = V.concatMap
+  , filter    = V.filter
+  , length    = V.length
+  , singleton = V.singleton
+  , null      = V.null
+  , pack      = V.fromList
+  , unpack    = V.toList
+  , fromList  = V.fromList
+  , toList    = V.toList
+  , mapM      = V.mapM
+  , mapM_     = V.mapM_
+  , empty     = V.empty
+  , member    = V.any . (==)
+  , break     = V.break
+  , span      = V.span
+  , dropWhile = V.dropWhile
+  , takeWhile = V.takeWhile
+  , any       = V.any
+  , all       = V.all
+  , splitAt   = V.splitAt
+  , fold      = V.foldl'
+  }
+
+
+instance Default VectorModule where
+  def = _Data_Vector_
+
diff --git a/Setup.hs b/Setup.hs
new file mode 100644
--- /dev/null
+++ b/Setup.hs
@@ -0,0 +1,2 @@
+import Distribution.Simple
+main = defaultMain
diff --git a/modular-prelude.cabal b/modular-prelude.cabal
new file mode 100644
--- /dev/null
+++ b/modular-prelude.cabal
@@ -0,0 +1,45 @@
+name:                modular-prelude
+version:             0.2.0.0
+synopsis:            A new Prelude featuring first class modules
+
+homepage:            https://github.com/DanBurton/modular-prelude#readme
+license:             MIT
+license-file:        LICENSE
+author:              Dan Burton
+maintainer:          danburton.email@gmail.com
+
+category:            Control
+build-type:          Simple
+cabal-version:       >=1.8
+
+library
+  exposed-modules:     ModularPrelude
+                     , ModularPrelude.Import
+                     , ModularPrelude.FilePath
+                     , ModularPrelude.From
+                     , ModularPrelude.Set
+                     , ModularPrelude.List
+                     , ModularPrelude.Classy
+                     , ModularPrelude.LByteString
+                     , ModularPrelude.Vector
+                     , ModularPrelude.HashSet
+                     , ModularPrelude.UVector
+                     , ModularPrelude.Text
+                     , ModularPrelude.Map
+                     , ModularPrelude.LHashMap
+                     , ModularPrelude.ByteString
+                     , ModularPrelude.LText
+                     , ModularPrelude.HashMap
+
+  build-depends:       base==4.*
+                     , basic-prelude==0.2.0.*
+                     , classy-prelude==0.2.*
+                     , data-default==0.5.0.*
+                     , system-filepath==0.4.*
+                     , hashable
+                     , bytestring
+                     , text
+                     , transformers
+                     , containers
+                     , unordered-containers
+                     , vector