diff --git a/README.md b/README.md
--- a/README.md
+++ b/README.md
@@ -1,1 +1,6 @@
 # non-empty-containers
+
+`non-empty-containers` provides two new data structures, `NonEmptyMap` and
+`NonEmptySet`, by extending Haskell's built-in `Map` and `Set` data structures.
+
+Both structures are guaranteed to contain at least one element.
diff --git a/non-empty-containers.cabal b/non-empty-containers.cabal
--- a/non-empty-containers.cabal
+++ b/non-empty-containers.cabal
@@ -1,6 +1,6 @@
 cabal-version: 2.0
 name: non-empty-containers
-version: 0.1.2.0
+version: 0.1.4.0
 description: Please see the README on GitHub at <https://github.com/andrewthad/non-empty-containers#readme>
 homepage: https://github.com/andrewthad/non-empty-containers#readme
 bug-reports: https://github.com/andrewthad/non-empty-containers/issues
@@ -25,6 +25,10 @@
       base >=4.11 && <5
     , containers >= 0.5.10 && < 0.7
     , semigroupoids >= 5.2.0 && < 6.0
-  ghc-options: -O2 -Wall
+  ghc-options:
+    -O2
+    -Wall
+    -Wincomplete-record-updates
+    -Wincomplete-uni-patterns
+    -Wredundant-constraints
   default-language: Haskell2010
-
diff --git a/src/Data/Map/NonEmpty.hs b/src/Data/Map/NonEmpty.hs
--- a/src/Data/Map/NonEmpty.hs
+++ b/src/Data/Map/NonEmpty.hs
@@ -1,3 +1,4 @@
+{-# LANGUAGE BangPatterns  #-}
 {-# LANGUAGE DeriveFunctor #-}
 
 module Data.Map.NonEmpty
@@ -6,18 +7,19 @@
   , lookup
   , foldl1'
   , foldr1'
-  , 
+  , mapWithKey
+  , toNonEmpty
+  , toMap
   ) where
 
-import Prelude hiding (lookup,foldr1,foldr)
-import Data.Bool (bool)
-import Data.Semigroup.Foldable (Foldable1)
-import Data.List.NonEmpty (NonEmpty((:|)))
-
-import qualified Data.Foldable as F
-import qualified Data.Map as M
-import qualified Data.Map.Strict as MS
+import           Data.Bool               (bool)
+import qualified Data.Foldable           as F
+import           Data.List.NonEmpty      (NonEmpty((:|)))
+import qualified Data.Map                as M
+import qualified Data.Map.Strict         as MS
+import           Data.Semigroup.Foldable (Foldable1)
 import qualified Data.Semigroup.Foldable
+import           Prelude                 hiding (foldr, foldr1, lookup)
 
 -- | A non-empty map.
 data NonEmptyMap k v = NonEmptyMap !k v !(M.Map k v)
@@ -43,12 +45,12 @@
 
 foldr1 :: (v -> v -> v) -> NonEmptyMap k v -> v
 foldr1 f (NonEmptyMap _ v m) = case M.maxView m of
-  Nothing -> v
+  Nothing     -> v
   Just (y,m') -> f v (M.foldr f y m')
 
 foldMap1 :: Semigroup m => (v -> m) -> NonEmptyMap k v -> m
 foldMap1 f (NonEmptyMap _ v m) = case M.maxView m of
-  Nothing -> f v
+  Nothing     -> f v
   Just (x,m') -> f v <> M.foldr (\c d -> f c <> d) (f x) m'
 
 instance (Ord k, Semigroup v) => Semigroup (NonEmptyMap k v) where
@@ -59,7 +61,7 @@
   foldMap f (NonEmptyMap _ v m) = f v <> foldMap f m
   foldl f a (NonEmptyMap _ v m) = M.foldl f (f a v) m
   foldr f a (NonEmptyMap _ v m) = case M.maxView m of
-    Nothing -> f v a
+    Nothing     -> f v a
     Just (y,m') -> f v (M.foldr f (f y a) m')
   foldl1 f (NonEmptyMap _ v m) = M.foldl f v m
   foldr1 = foldr1
@@ -81,5 +83,14 @@
 
 foldr1' :: (v -> v -> v) -> NonEmptyMap k v -> v
 foldr1' f (NonEmptyMap _ v m) = case M.maxView m of
-  Nothing -> v
+  Nothing     -> v
   Just (y,m') -> let !k = M.foldr' f y m' in f v k
+
+mapWithKey :: (k -> v -> w) -> NonEmptyMap k v -> NonEmptyMap k w
+mapWithKey f (NonEmptyMap k v m) = NonEmptyMap k (f k v) (M.mapWithKey f m)
+
+toNonEmpty :: NonEmptyMap k v -> NonEmpty (k,v)
+toNonEmpty (NonEmptyMap k v m) = (k,v) :| M.toList m
+
+toMap :: Ord k => NonEmptyMap k v -> M.Map k v
+toMap (NonEmptyMap k v m) = M.insert k v m
diff --git a/src/Data/Set/NonEmpty.hs b/src/Data/Set/NonEmpty.hs
--- a/src/Data/Set/NonEmpty.hs
+++ b/src/Data/Set/NonEmpty.hs
@@ -8,14 +8,12 @@
   , fromNonEmpty
   ) where
 
-import Prelude hiding (foldr1,foldr)
-
-import Data.List.NonEmpty
-import Data.Semigroup.Foldable (Foldable1)
-
-import qualified Data.Set as S
-import qualified Data.Foldable as F
+import qualified Data.Foldable           as F
+import           Data.List.NonEmpty
+import           Data.Semigroup.Foldable (Foldable1)
 import qualified Data.Semigroup.Foldable
+import qualified Data.Set                as S
+import           Prelude                 hiding (foldr, foldr1)
 
 -- | A non-empty set.
 data NonEmptySet a = NonEmptySet !a !(S.Set a)
@@ -41,11 +39,11 @@
 toSet :: Ord a => NonEmptySet a -> S.Set a
 -- We should be able to write this without an Ord constraint.
 -- I cannot find anything in Data.Set.Internal that allows
--- me to do an unsafe insert on the left-hand side of a set. 
+-- me to do an unsafe insert on the left-hand side of a set.
 toSet (NonEmptySet x xs) = S.insert x xs
 
 -- | Attempt to create a non-empty set from a set.
-fromSet :: Ord a => S.Set a -> Maybe (NonEmptySet a)
+fromSet :: S.Set a -> Maybe (NonEmptySet a)
 fromSet s = fmap (uncurry NonEmptySet) (S.minView s)
 
 -- | Create a non-empty set from a non-empty list.
@@ -61,17 +59,17 @@
 
 foldr :: (a -> b -> b) -> b -> NonEmptySet a -> b
 foldr f b (NonEmptySet a m) = case S.maxView m of
-  Nothing -> f a b
+  Nothing     -> f a b
   Just (y,m') -> f a (S.foldr f (f y b) m')
 
 foldr1 :: (a -> a -> a) -> NonEmptySet a -> a
 foldr1 f (NonEmptySet a s) = case S.maxView s of
-  Nothing -> a
+  Nothing     -> a
   Just (m,s') -> f a (S.foldr f m s')
 
 foldMap1 :: Semigroup m => (a -> m) -> NonEmptySet a -> m
 foldMap1 f (NonEmptySet a s) = case S.maxView s of
-  Nothing -> f a
+  Nothing     -> f a
   Just (m,s') -> f a <> S.foldr (\c d -> f c <> d) (f m) s'
 
 instance Show a => Show (NonEmptySet a) where
@@ -87,7 +85,7 @@
   minimum (NonEmptySet a _) = a
   maximum (NonEmptySet a s) = case S.lookupMax s of
     Nothing -> a
-    Just m -> m
+    Just m  -> m
   length (NonEmptySet _ s) = 1 + S.size s
   null _ = False
 
@@ -101,4 +99,3 @@
     EQ -> NonEmptySet x (xs <> ys)
     LT -> NonEmptySet x (xs <> S.insert y ys)
     GT -> NonEmptySet y (S.insert x xs <> ys)
-