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.0.0
+version: 0.1.1.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
@@ -19,6 +19,7 @@
 library
   exposed-modules:
     Data.Set.NonEmpty
+    Data.Map.NonEmpty
   hs-source-dirs: src
   build-depends:
       base >=4.11 && <5
diff --git a/src/Data/Map/NonEmpty.hs b/src/Data/Map/NonEmpty.hs
new file mode 100644
--- /dev/null
+++ b/src/Data/Map/NonEmpty.hs
@@ -0,0 +1,38 @@
+module Data.Map.NonEmpty
+  ( NonEmptyMap
+  , singleton
+  , lookup
+  ) where
+
+import Prelude hiding (lookup)
+import Data.Bool (bool)
+
+import qualified Data.Map as M
+import qualified Data.Map.Strict as MS
+
+-- | A non-empty map.
+data NonEmptyMap k v = NonEmptyMap !k v !(M.Map k v)
+  deriving (Eq,Ord)
+
+-- | A map with a single element.
+singleton :: k -> v -> NonEmptyMap k v
+singleton k v = NonEmptyMap k v M.empty
+
+-- | Lookup the value at a key in the map.
+lookup :: Ord k => k -> NonEmptyMap k a -> Maybe a
+lookup a (NonEmptyMap k v xs) = maybe
+  (bool Nothing (Just v) (a == k))
+  Just
+  (M.lookup a xs)
+
+unionAppend :: (Ord k, Semigroup v)
+  => NonEmptyMap k v -> NonEmptyMap k v -> NonEmptyMap k v
+unionAppend (NonEmptyMap xk xv xs) (NonEmptyMap yk yv ys) = case compare xk yk of
+  EQ -> NonEmptyMap xk (xv <> yv) (MS.unionWith (<>) xs ys)
+  LT -> NonEmptyMap xk xv (MS.unionWith (<>) xs (M.insertWith (<>) yk yv ys))
+  GT -> NonEmptyMap yk yv (MS.unionWith (<>) (M.insertWith (<>) xk xv xs) ys)
+
+instance (Ord k, Semigroup v) => Semigroup (NonEmptyMap k v) where
+  (<>) = unionAppend
+
+
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
@@ -1,6 +1,8 @@
 module Data.Set.NonEmpty
   ( NonEmptySet
   , singleton
+  , member
+  , toSet
   , toNonEmpty
   , fromNonEmpty
   ) where
@@ -24,6 +26,17 @@
 -- | Convert a non-empty set to a non-empty list.
 toNonEmpty :: NonEmptySet a -> NonEmpty a
 toNonEmpty (NonEmptySet x xs) = x :| S.toList xs
+
+-- | Is the element in the set?
+member :: Ord a => a -> NonEmptySet a -> Bool
+member a (NonEmptySet x xs) = S.member a xs || a == x
+
+-- | Convert a non-empty set to a set.
+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. 
+toSet (NonEmptySet x xs) = S.insert x xs
 
 -- | Create a non-empty set from a non-empty list.
 fromNonEmpty :: Ord a => NonEmpty a -> NonEmptySet a