diff --git a/CHANGELOG.md b/CHANGELOG.md
new file mode 100644
--- /dev/null
+++ b/CHANGELOG.md
@@ -0,0 +1,5 @@
+# Revision history for deep-maps
+
+## 0.1.0.0 -- 2021-11-30
+
+* Deep monoidal maps
diff --git a/README.md b/README.md
new file mode 100644
--- /dev/null
+++ b/README.md
@@ -0,0 +1,100 @@
+# deep-maps
+
+[![ci](https://img.shields.io/github/workflow/status/cigsender/deep-map/Haskell-CI)](https://github.com/cigsender/deep-map/actions/workflows/ci.yml)
+[![Hackage](https://img.shields.io/hackage/v/deep-map?color=purple)](https://hackage.haskell.org/package/deep-map)
+[![license](https://img.shields.io/github/license/cigsender/deep-map?color=purple)]()
+
+A `DeepMap` is a map that has several layers of keys.
+
+```hs
+type DeepMap :: [Type] -> Type -> Type
+data DeepMap ks v where
+    Bare :: v -> DeepMap '[] v
+    Nest :: Map k (DeepMap ks v) -> DeepMap (k ': ks) v
+```
+
+For a given `(k ': ks) :: [Type]`, the type `DeepMap (k ': ks) v` is isomorphic to lists of the form `[(k, k0, .., kn, v)]` where `ks = '[k0, ..., kn]`, but with better performance.
+
+## Example
+
+Say you have a table of order IDs, dates, customer IDs, and the total price for that order; and you'd like to track some statistics.
+
+```hs
+newtype OrderID = OrderID Int
+newtype CustomerID = CustomerID Text
+newtype Price = Sum Double
+
+type Table = DeepMap '[Day, OrderID, CustomerID] Price
+
+table :: Table
+table =
+  fromList3
+    [ (YearMonthDay 2021 1 1, OrderID 1, CustomerID "Melanie", Sum 13.12)
+    , (YearMonthDay 2021 1 1, OrderID 2, CustomerID "Sock", Sum 4.20)
+    , (YearMonthDay 2021 1 2, OrderID 3, CustomerID "Sock", Sum 69.69)
+    , (YearMonthDay 2021 1 2, OrderID 4, CustomerID "Fiona", Sum 5.00)
+    ]
+
+totalSales :: Table -> Price
+totalSales = fold
+
+-- How much did customers spend on a given day?
+-- (note: use a DeepMap accumulator to fold within the Semigroup)
+dailySales :: Table -> Map Day Price
+dailySales = toMap . foldMapWithKey3 (\d _o _c p -> d @| p)
+
+-- Who purchased something on which day?
+dailyCustomers :: Table -> Map Day [CustomerID]
+dailyCustomers = toMap . foldMapWithKey3 (\d _o c _p -> d @| [c])
+
+-- How much has a customer paid throughout history?
+totalPerCustomer :: Table -> DeepMap '[CustomerID] Price
+totalPerCustomer = foldShallow . foldShallow
+{- = foldMapWithKey3 (\_d _o c p -> c @| p) -}
+
+-- What days did each customer purchase something?
+customerSaleDates :: Table -> Map CustomerID [Day]
+customerSaleDates = toMap . foldMapWithKey3 (\d _o c _p -> c @| [d])
+{- = toMap . Map.foldMapWithKey (\d cs -> foldMap (@| [d]) cs) . dailyCustomers -}
+
+-- How much did a customer spend for each order?
+-- Useful if e.g. several customers could chip into the same order.
+orderTotalPerCustomer :: Table -> DeepMap '[CustomerID, OrderID] Price
+orderTotalPerCustomer = invertKeys . foldShallow
+
+-- Using (@!) will NOT throw an error!
+-- It's the infix version of `findWithDefault mempty`.
+sockTotal :: Table -> Double
+sockTotal t = getSum $ totalPerCustomer t @!| CustomerID "Sock"
+```
+
+## Shallow & deep functions
+
+You might have noticed the difference between `fold` and `foldShallow` in the above example:
+
+```hs
+fold :: (Monoid v) => DeepMap (k ': ks) v -> v
+foldShallow :: (Monoid (DeepMap ks v)) => DeepMap (k ': ks) v -> DeepMap ks v
+```
+
+Here are a few other pairs of similar functions, that operate at different depths:
+
+```hs
+fmap :: (v -> w) -> DeepMap ks v -> DeepMap ks w
+mapShallow :: (DeepMap ks v -> DeepMap ls w) -> DeepMap (k ': ks) v -> DeepMap (k ': ls) w
+
+traverse :: (Applicative f) => (v -> f w) -> DeepMap ks v -> f (DeepMap ks w)
+traverseShallow :: (Applicative f) => (DeepMap ks v -> f (DeepMap ls w)) -> DeepMap (k ': ks) v -> f (DeepMap (k ': ls) w)
+
+mapMaybe :: (v -> Maybe w) -> DeepMap (k ': ks) v -> DeepMap (k ': ks) w
+mapShallowMaybe :: (DeepMap ks v -> Maybe (DeepMap ls w)) -> DeepMap (k ': ks) v -> DeepMap (k ': ls) w
+
+mapEither ::
+  (v -> Either w x) ->
+  DeepMap (k ': ks) v ->
+  (DeepMap (k ': ks) w, DeepMap (k ': ks) x)
+mapShallowEither ::
+  (DeepMap ks v -> Either (DeepMap ls w) (DeepMap ms x)) ->
+  DeepMap (k ': ks) v ->
+  (DeepMap (k ': ls) w, DeepMap (k ': ms) x)
+```
diff --git a/deep-map.cabal b/deep-map.cabal
new file mode 100644
--- /dev/null
+++ b/deep-map.cabal
@@ -0,0 +1,87 @@
+cabal-version: 2.4
+name: deep-map
+version: 0.1.0.0
+category: Data, Statistics
+synopsis: Deeply-nested, multiple key type maps.
+description: Please see the README at https://github.com/cigsender/deep-map
+homepage: https://github.com/cigsender/deep-map
+bug-reports: https://github.com/cigsender/deep-map/issues
+license: BSD-3-Clause
+copyright: 2021 Melanie Brown
+author: Melanie Brown
+maintainer: brown.m@pm.me
+tested-with:
+  -- GHC ^>= 9.2,
+  GHC ^>= 9.0,
+  GHC ^>= 8.10,
+  GHC ^>= 8.8,
+  GHC ^>= 8.6,
+  GHC ^>= 8.4
+extra-source-files:
+  README.md
+  CHANGELOG.md
+
+common extensions
+  ghc-options: -Wall
+  default-language:
+    Haskell2010
+  default-extensions:
+    BangPatterns
+    ConstraintKinds
+    DataKinds
+    DeriveDataTypeable
+    DeriveFoldable
+    DeriveFunctor
+    DeriveGeneric
+    DeriveLift
+    DeriveTraversable
+    DerivingStrategies
+    EmptyCase
+    FlexibleContexts
+    FlexibleInstances
+    GADTs
+    GeneralizedNewtypeDeriving
+    LambdaCase
+    MultiParamTypeClasses
+    MultiWayIf
+    NamedFieldPuns
+    OverloadedStrings
+    PatternSynonyms
+    PolyKinds
+    QuasiQuotes
+    RecordWildCards
+    ScopedTypeVariables
+    StandaloneDeriving
+    TupleSections
+    TypeApplications
+    TypeFamilies
+    TypeOperators
+    ViewPatterns
+
+library
+  import: extensions
+  hs-source-dirs:
+    src
+  build-depends:
+    base >= 4.11 && < 5
+    , containers >= 0.5.11 && < 0.7
+    , indexed-traversable ^>= 0.1.2
+  exposed-modules:
+    Data.Map.Deep
+
+test-suite test-readme
+  import: extensions
+  hs-source-dirs:
+    tests
+  type:
+    exitcode-stdio-1.0
+  main-is:
+    test-readme.hs
+  build-depends:
+    deep-map
+    , base
+    , containers
+    , hedgehog
+    , text
+    , time
+    , time-compat
diff --git a/src/Data/Map/Deep.hs b/src/Data/Map/Deep.hs
new file mode 100644
--- /dev/null
+++ b/src/Data/Map/Deep.hs
@@ -0,0 +1,2171 @@
+{-# LANGUAGE UndecidableInstances #-}
+
+-- |
+-- Module       : Data.Map.Deep
+-- Copyright    : (c) Melanie Brown 2021
+-- License      : BSD3 (see the file LICENSE)
+-- Maintainer   : brown.m@pm.me
+--
+-- This module defines a deeply-nested, semigroup-lifting map datatype,
+-- whose keys are indexed by a type-level list.
+--
+-- Its interface is intended to mimic that of 'Data.Map' from the
+-- @containers@ package, with additional convenience functions for working with deep nestings.
+module Data.Map.Deep
+  ( -- * Map type
+    DeepMap (..),
+    onBare2,
+    onNest2,
+
+    -- * Construction
+    empty,
+    singleton,
+    (@>),
+    (@|),
+
+    -- ** From Unordered Lists
+    fromList,
+    fromList1,
+    fromList2,
+    fromList3,
+    fromList4,
+    fromList5,
+    fromListWith,
+    fromListWith1,
+    fromListWithKey,
+    fromListWithKey1,
+    fromListWithKey2,
+    fromListWithKey3,
+    fromListWithKey4,
+    fromListWithKey5,
+
+    -- ** Single-depth map isomorphisms
+    toMap,
+    fromMap,
+
+    -- * Insertion
+    insert,
+    insert1,
+    insert2,
+    insert3,
+    insert4,
+    insert5,
+    insertWith,
+    insertWith1,
+    insertWith2,
+    insertWith3,
+    insertWith4,
+    insertWith5,
+    insertWithKey,
+    insertWithKey1,
+    insertWithKey2,
+    insertWithKey3,
+    insertWithKey4,
+    insertWithKey5,
+    insertLookupWithKey,
+    insertLookupWithKey1,
+    insertLookupWithKey2,
+    insertLookupWithKey3,
+    insertLookupWithKey4,
+    insertLookupWithKey5,
+    overwrite,
+    overwrite1,
+    overwrite2,
+    overwrite3,
+    overwrite4,
+    overwrite5,
+    overwriteLookup,
+    overwriteLookup1,
+    overwriteLookup2,
+    overwriteLookup3,
+    overwriteLookup4,
+    overwriteLookup5,
+
+    -- * Deletion\/Update
+    delete,
+    delete1,
+    delete2,
+    delete3,
+    delete4,
+    delete5,
+    adjust,
+    adjust1,
+    adjust2,
+    adjust3,
+    adjust4,
+    adjust5,
+    adjustWithKey,
+    adjustWithKey1,
+    adjustWithKey2,
+    adjustWithKey3,
+    adjustWithKey4,
+    adjustWithKey5,
+    update,
+    update1,
+    update2,
+    update3,
+    update4,
+    update5,
+    updateWithKey,
+    updateWithKey1,
+    updateWithKey2,
+    updateWithKey3,
+    updateWithKey4,
+    updateWithKey5,
+    updateLookupWithKey,
+    updateLookupWithKey1,
+    updateLookupWithKey2,
+    updateLookupWithKey3,
+    updateLookupWithKey4,
+    updateLookupWithKey5,
+    alter,
+    alter1,
+    alter2,
+    alter3,
+    alter4,
+    alter5,
+    alterF,
+    alterF1,
+    alterF2,
+    alterF3,
+    alterF4,
+    alterF5,
+
+    -- * Query
+
+    -- ** Lookup
+    lookup,
+    (@?),
+    (@?|),
+    (@??),
+    (@??|),
+    (@!),
+    (@!|),
+    findWithDefault,
+    findWithDefault1,
+    findWithDefault2,
+    findWithDefault3,
+    findWithDefault4,
+    findWithDefault5,
+    member,
+    notMember,
+    lookupLT,
+    lookupGT,
+    lookupLE,
+    lookupGE,
+
+    -- ** Size
+    null,
+    size,
+
+    -- * Combine
+
+    -- ** Union
+    union,
+    unionWith,
+    unionWith1,
+    unionWith2,
+    unionWith3,
+    unionWith4,
+    unionWith5,
+    unionWithKey,
+    unionWithKey1,
+    unionWithKey2,
+    unionWithKey3,
+    unionWithKey4,
+    unionWithKey5,
+    unions,
+    unionsWith,
+    unionsWith1,
+
+    -- ** Difference
+    difference,
+    (\\),
+    differenceWith,
+    differenceWith1,
+    differenceWithKey,
+    differenceWithKey1,
+
+    -- ** Intersection
+    intersection,
+    intersectionWith,
+    intersectionWith1,
+    intersectionWithKey,
+    intersectionWithKey1,
+    intersectionWithKey2,
+    intersectionWithKey3,
+    intersectionWithKey4,
+    intersectionWithKey5,
+
+    -- * Traversal
+
+    -- ** Map
+    mapShallow,
+    mapShallowWithKey,
+    mapWithKey1,
+    mapWithKey2,
+    mapWithKey3,
+    mapWithKey4,
+    mapWithKey5,
+    traverseShallow,
+    traverseShallowWithKey,
+    traverseWithKey1,
+    traverseWithKey2,
+    traverseWithKey3,
+    traverseWithKey4,
+    traverseWithKey5,
+    traverseMaybeWithKey,
+    traverseMaybeWithKey1,
+    traverseMaybeWithKey2,
+    traverseMaybeWithKey3,
+    traverseMaybeWithKey4,
+    traverseMaybeWithKey5,
+    mapAccum,
+    mapAccum1,
+    mapAccumR,
+    mapAccumR1,
+    mapAccumWithKey,
+    mapAccumWithKey1,
+    mapAccumWithKey2,
+    mapAccumWithKey3,
+    mapAccumWithKey4,
+    mapAccumWithKey5,
+    mapAccumRWithKey,
+    mapAccumRWithKey1,
+    mapAccumRWithKey2,
+    mapAccumRWithKey3,
+    mapAccumRWithKey4,
+    mapAccumRWithKey5,
+    mapKeys,
+    mapKeys1,
+    mapKeys2,
+    mapKeys3,
+    mapKeys4,
+    mapKeys5,
+    mapKeysWith,
+    mapKeysWith1,
+    mapKeysWith2,
+    mapKeysWith3,
+    mapKeysWith4,
+    mapKeysWith5,
+    traverseKeys,
+    traverseKeysWith,
+    mapKeysM,
+    mapKeysM1,
+    mapKeysM2,
+    mapKeysM3,
+    mapKeysM4,
+    mapKeysM5,
+    mapKeysMWith,
+    mapKeysMWith1,
+    mapKeysMWith2,
+    mapKeysMWith3,
+    mapKeysMWith4,
+    mapKeysMWith5,
+
+    -- * Folds
+    foldr,
+    foldl,
+    foldShallow,
+    foldrWithKey,
+    foldrWithKey1,
+    foldrWithKey2,
+    foldrWithKey3,
+    foldrWithKey4,
+    foldrWithKey5,
+    foldlWithKey,
+    foldlWithKey1,
+    foldlWithKey2,
+    foldlWithKey3,
+    foldlWithKey4,
+    foldlWithKey5,
+    foldMapWithKey,
+    foldMapWithKey1,
+    foldMapWithKey2,
+    foldMapWithKey3,
+    foldMapWithKey4,
+    foldMapWithKey5,
+
+    -- ** Strict folds
+    foldr',
+    foldl',
+    foldrWithKey',
+    foldrWithKey1',
+    foldrWithKey2',
+    foldrWithKey3',
+    foldrWithKey4',
+    foldrWithKey5',
+    foldlWithKey',
+    foldlWithKey1',
+    foldlWithKey2',
+    foldlWithKey3',
+    foldlWithKey4',
+    foldlWithKey5',
+
+    -- * Conversion
+    elems,
+    elems1,
+    keys,
+    assocs,
+    assocs1,
+    keysSet,
+    invertKeys,
+
+    -- ** Lists
+    toList,
+
+    -- *** Ordered lists
+    toAscList,
+    toDescList,
+
+    -- * Filter
+    filter,
+    filter1,
+    filter2,
+    filter3,
+    filter4,
+    filter5,
+    filterWithKey,
+    filterWithKey1,
+    filterWithKey2,
+    filterWithKey3,
+    filterWithKey4,
+    filterWithKey5,
+    restrictKeys,
+    restrictKeys2,
+    restrictKeys3,
+    restrictKeys4,
+    restrictKeys5,
+    withoutKeys,
+    withoutKeys2,
+    withoutKeys3,
+    withoutKeys4,
+    withoutKeys5,
+    partition,
+    partition1,
+    partition2,
+    partition3,
+    partition4,
+    partition5,
+    partitionWithKey,
+    partitionWithKey1,
+    partitionWithKey2,
+    partitionWithKey3,
+    partitionWithKey4,
+    partitionWithKey5,
+    takeWhileAntitone,
+    dropWhileAntitone,
+    spanAntitone,
+    mapMaybe,
+    mapShallowMaybe,
+    mapShallowMaybeWithKey,
+    mapMaybeWithKey1,
+    mapMaybeWithKey2,
+    mapMaybeWithKey3,
+    mapMaybeWithKey4,
+    mapMaybeWithKey5,
+    mapEither,
+    mapShallowEither,
+    mapShallowEitherWithKey,
+    mapEitherWithKey1,
+    mapEitherWithKey2,
+    mapEitherWithKey3,
+    mapEitherWithKey4,
+    mapEitherWithKey5,
+    split,
+    splitLookup,
+    splitRoot,
+
+    -- * Submap
+    isSubmapOf,
+    isSubmapOfBy,
+    isProperSubmapOf,
+    isProperSubmapOfBy,
+
+    -- * Indexed
+    lookupIndex,
+    findIndex,
+    elemAt,
+    updateAt,
+    deleteAt,
+    take,
+    drop,
+    splitAt,
+
+    -- * Min\/Max
+    lookupMin,
+    lookupMax,
+    findMin,
+    findMax,
+    deleteMin,
+    deleteMax,
+    deleteFindMin,
+    deleteFindMax,
+    updateMin,
+    updateMax,
+    updateMinWithKey,
+    updateMaxWithKey,
+    minView,
+    maxView,
+    minViewWithKey,
+    maxViewWithKey,
+  )
+where
+
+import Control.Arrow (Arrow ((&&&)), ArrowChoice ((+++), (|||)), (***))
+import Data.Bool (bool)
+import Data.Data
+import Data.Either (isLeft)
+import Data.Foldable (Foldable (fold, foldl', foldr', toList))
+import Data.Foldable.WithIndex (FoldableWithIndex)
+import Data.Functor ((<&>))
+import Data.Functor.Compose (Compose (..))
+import Data.Functor.Const (Const (..))
+import Data.Functor.Identity (Identity (..))
+import Data.Functor.WithIndex (FunctorWithIndex)
+import Data.Kind (Type)
+import Data.Map.Strict (Map)
+import qualified Data.Map.Strict as Map
+import Data.Maybe (fromMaybe)
+import Data.Set (Set)
+import qualified Data.Set as Set
+import Data.Traversable.WithIndex
+import GHC.Generics
+import Prelude hiding
+  ( drop,
+    filter,
+    lookup,
+    map,
+    null,
+    splitAt,
+    take,
+  )
+
+data DeepMap (ks :: [Type]) (v :: Type) :: Type where
+  Bare :: {getBare :: v} -> DeepMap '[] v
+  Nest :: {getNest :: Map k (DeepMap ks v)} -> DeepMap (k ': ks) v
+
+instance (Eq v) => Eq (DeepMap '[] v) where
+  Bare v1 == Bare v2 = v1 == v2
+
+instance (Eq k, Eq (DeepMap ks v)) => Eq (DeepMap (k ': ks) v) where
+  Nest v1 == Nest v2 = v1 == v2
+
+instance (Ord v) => Ord (DeepMap '[] v) where
+  Bare v1 <= Bare v2 = v1 <= v2
+
+instance (Ord k, Ord (DeepMap ks v)) => Ord (DeepMap (k ': ks) v) where
+  Nest v1 <= Nest v2 = v1 <= v2
+
+instance (Show v) => Show (DeepMap '[] v) where
+  show (Bare v) = "Bare " <> show v
+
+instance (Show k, Show (DeepMap ks v)) => Show (DeepMap (k ': ks) v) where
+  show (Nest v) = "Nest {" <> show v <> "}"
+
+instance (Semigroup v) => Semigroup (DeepMap '[] v) where
+  (<>) = onBare2 (<>)
+
+instance (Ord k, Semigroup (DeepMap ks v)) => Semigroup (DeepMap (k ': ks) v) where
+  (<>) = onNest2 $ Map.unionWith (<>)
+
+instance (Monoid v) => Monoid (DeepMap '[] v) where
+  mempty = Bare mempty
+
+instance (Ord k, Semigroup (DeepMap ks v)) => Monoid (DeepMap (k ': ks) v) where
+  mempty = Nest mempty
+
+deriving instance Functor (DeepMap ks)
+
+deriving instance Foldable (DeepMap ks)
+
+deriving instance Traversable (DeepMap ks)
+
+instance FunctorWithIndex () (DeepMap '[])
+
+instance FoldableWithIndex () (DeepMap '[])
+
+instance TraversableWithIndex () (DeepMap '[]) where
+  itraverse f (Bare v) = Bare <$> f () v
+
+instance (TraversableWithIndex ki (DeepMap ks)) => FunctorWithIndex (k, ki) (DeepMap (k ': ks))
+
+instance (TraversableWithIndex ki (DeepMap ks)) => FoldableWithIndex (k, ki) (DeepMap (k ': ks))
+
+instance (TraversableWithIndex ki (DeepMap ks)) => TraversableWithIndex (k, ki) (DeepMap (k ': ks)) where
+  itraverse f = traverseShallowWithKey (itraverse . curry f)
+
+deriving instance (Typeable v) => Typeable (DeepMap '[] v)
+
+deriving instance (Typeable k, Typeable (DeepMap ks v)) => Typeable (DeepMap (k ': ks) v)
+
+tyDeepMap :: DataType
+tyDeepMap = mkDataType "Data.Map.Monoidal.Deep.DeepMap" [conBare, conNest]
+
+conBare, conNest :: Constr
+conBare = mkConstr tyDeepMap "Bare" [] Data.Data.Prefix
+conNest = mkConstr tyDeepMap "Nest" [] Data.Data.Prefix
+
+instance (Data v) => Data (DeepMap '[] v) where
+  dataTypeOf _ = tyDeepMap
+  toConstr (Bare _) = conBare
+  gunfold k z _ = k (z Bare)
+
+instance (Ord k, Data k, Typeable ks, Typeable v, Data (DeepMap ks v)) => Data (DeepMap (k ': ks) v) where
+  dataTypeOf _ = tyDeepMap
+  toConstr (Nest _) = conNest
+  gunfold k z _ = k (z Nest)
+
+instance (Generic v) => Generic (DeepMap '[] v) where
+  type Rep (DeepMap '[] v) = Const v
+  from (Bare v) = Const v
+  to (Const v) = Bare v
+
+instance (Ord k, Generic k, Generic (DeepMap ks v)) => Generic (DeepMap (k ': ks) v) where
+  type Rep (DeepMap (k ': ks) v) = Compose [] (Const k :*: Rep (DeepMap ks v))
+  from m = Compose $ (\(k, dm) -> Const k :*: from dm) <$> assocs m
+  to (Compose kvs) = Nest . Map.fromList $ (\(Const k :*: dm') -> (k, to dm')) <$> kvs
+
+-- | Apply a two-argument function through a shallow 'DeepMap', akin to 'liftA2'.
+onBare2 :: (v -> w -> x) -> DeepMap '[] v -> DeepMap '[] w -> DeepMap '[] x
+onBare2 f (Bare v) (Bare w) = Bare $ f v w
+
+-- | Apply a two-argument function through a shallow 'DeepMap', akin to 'liftA2'.
+onBare2F :: (Functor f) => (v -> w -> f x) -> DeepMap '[] v -> DeepMap '[] w -> f (DeepMap '[] x)
+onBare2F f (Bare v) (Bare w) = Bare <$> f v w
+
+-- | Apply a two-argument 'Map' function through a deep 'DeepMap', akin to 'liftA2'.
+onNest2 :: (Map k (DeepMap ks v) -> Map k (DeepMap ls w) -> Map k (DeepMap ms x)) -> DeepMap (k ': ks) v -> DeepMap (k ': ls) w -> DeepMap (k ': ms) x
+onNest2 f (Nest v) (Nest w) = Nest $ f v w
+
+-- | Half of the isomorphism of a depth-1 'DeepMap' to a 'Data.Map.Strict.Map'. See also 'fromMap'.
+toMap :: DeepMap (k ': '[]) v -> Map k v
+toMap (Nest m) = getBare <$> m
+
+-- | Half of the isomorphism of a depth-1 'DeepMap' to a 'Data.Map.Strict.Map'. See also 'toMap'.
+fromMap :: Map k v -> DeepMap '[k] v
+fromMap m = Nest (Bare <$> m)
+
+-- | A singleton 'DeepMap'. Use with '(@|)' to create deep nestings:
+--
+-- >>> "Outer" @> 0 @| [5]
+-- Nest {fromList [("Outer",Nest {fromList [(0,Bare [5])]})]}
+infixr 6 @>
+
+(@>) :: k -> DeepMap ks v -> DeepMap (k ': ks) v
+k @> a = Nest $ Map.singleton k a
+{-# INLINE (@>) #-}
+
+-- | Infix synonym for 'singleton'. Use with '(@>)' to create deep nestings:
+--
+-- >>> "Outer" @> 0 @| [5]
+-- Nest {fromList [("Outer",Nest {fromList [(0,Bare [5])]})]}
+infixr 6 @|
+
+(@|) :: k -> v -> DeepMap '[k] v
+k @| a = Nest . Map.singleton k $ Bare a
+{-# INLINE (@|) #-}
+
+-- | /O(1)/. The empty, arbitrary positive-depth 'DeepMap'.
+empty :: DeepMap (k ': ks) v
+empty = Nest Map.empty
+
+-- | /O(1)/. A depth-1 'DeepMap' with a single key/value pair.
+singleton :: k -> v -> DeepMap '[k] v
+singleton k v = Nest . Map.singleton k $ Bare v
+
+-- | /O(n)/. Return all submaps of the map in ascending order of its keys. Subject to list fusion.
+elems :: DeepMap (k ': ks) v -> [DeepMap ks v]
+elems (Nest m) = Map.elems m
+
+-- | /O(n)/. Return all values of the singly-nested map in ascending order of its keys. Subject to list fusion.
+elems1 :: DeepMap '[k] v -> [v]
+elems1 m = getBare <$> elems m
+
+-- | /O(n)/. Return all keys of the map in ascending order. Subject to list fusion.
+keys :: DeepMap (k ': ks) v -> [k]
+keys (Nest m) = Map.keys m
+
+-- | /O(n)/. Return all pairs of the map in ascending key order. Subject to list fusion.
+assocs :: DeepMap (k ': ks) v -> [(k, DeepMap ks v)]
+assocs (Nest m) = Map.assocs m
+
+-- | /O(n)/. Return all pairs of the singly-nested map in ascending key order. Subject to list fusion.
+assocs1 :: DeepMap '[k] v -> [(k, v)]
+assocs1 dm = fmap getBare <$> assocs dm
+
+-- | /O(n)/. The set of all keys of the map.
+keysSet :: DeepMap (k ': ks) v -> Set k
+keysSet (Nest m) = Map.keysSet m
+
+-- | /O(n log n)/. Build a deeper 'DeepMap' from a list of key/'DeepMap' pairs.
+--   If the list contains more than one value for the same key,
+--   the values are combined using '(<>)'.
+fromList :: (Ord k, Semigroup (DeepMap ks v)) => [(k, DeepMap ks v)] -> DeepMap (k ': ks) v
+fromList kvs = Nest $ Map.fromListWith (flip (<>)) kvs
+
+-- | /O(n log n)/. Build a depth-1 'DeepMap' from a list of key/value pairs.
+--   If the list contains more than one value for the same key,
+--   the values are combined using '(<>)'.
+fromList1 :: (Ord k, Semigroup v) => [(k, v)] -> DeepMap '[k] v
+fromList1 = foldMap (uncurry (@|))
+
+-- | /O(n log n)/. Build a depth-2 'DeepMap' from a list of keys and values.
+--   If the list contains more than one value for the same keys,
+--   the values are combined using '(<>)'.
+fromList2 :: (Ord k0, Ord k1, Semigroup v) => [(k0, k1, v)] -> DeepMap '[k0, k1] v
+fromList2 = foldMap (\(k0, k1, v) -> k0 @> k1 @| v)
+
+-- | /O(n log n)/. Build a depth-3 'DeepMap' from a list of keys and values.
+--   If the list contains more than one value for the same keys,
+--   the values are combined using '(<>)'.
+fromList3 :: (Ord k0, Ord k1, Ord k2, Semigroup v) => [(k0, k1, k2, v)] -> DeepMap '[k0, k1, k2] v
+fromList3 = foldMap (\(k0, k1, k2, v) -> k0 @> k1 @> k2 @| v)
+
+-- | /O(n log n)/. Build a depth-4 'DeepMap' from a list of keys and values.
+--   If the list contains more than one value for the same keys,
+--   the values are combined using '(<>)'.
+fromList4 :: (Ord k0, Ord k1, Ord k2, Ord k3, Semigroup v) => [(k0, k1, k2, k3, v)] -> DeepMap '[k0, k1, k2, k3] v
+fromList4 = foldMap (\(k0, k1, k2, k3, v) -> k0 @> k1 @> k2 @> k3 @| v)
+
+-- | /O(n log n)/. Build a depth-5 'DeepMap' from a list of keys and values.
+--   If the list contains more than one value for the same keys,
+--   the values are combined using '(<>)'.
+fromList5 :: (Ord k0, Ord k1, Ord k2, Ord k3, Ord k4, Semigroup v) => [(k0, k1, k2, k3, k4, v)] -> DeepMap '[k0, k1, k2, k3, k4] v
+fromList5 = foldMap (\(k0, k1, k2, k3, k4, v) -> k0 @> k1 @> k2 @> k3 @> k4 @| v)
+
+-- | /O(n log n)/. Build a deeper 'DeepMap' from a list of key/'DeepMap' pairs
+--   using the provided combining function.
+fromListWith :: (Ord k) => (DeepMap ks v -> DeepMap ks v -> DeepMap ks v) -> [(k, DeepMap ks v)] -> DeepMap (k ': ks) v
+fromListWith f kvs = Nest $ Map.fromListWith f kvs
+
+-- | /O(n log n)/. Build a depth-1 'DeepMap' from a list of key/value pairs
+--   using the provided combining function.
+fromListWith1 :: (Ord k) => (v -> v -> v) -> [(k, v)] -> DeepMap '[k] v
+fromListWith1 f kvs = Nest $ Bare <$> Map.fromListWith f kvs
+
+-- | /O(n log n)/. Build a deeper 'DeepMap' from a list of key/'DeepMap' pairs with a combining function.
+fromListWithKey :: (Ord k) => (k -> DeepMap ks v -> DeepMap ks v -> DeepMap ks v) -> [(k, DeepMap ks v)] -> DeepMap (k ': ks) v
+fromListWithKey f kvs = Nest $ Map.fromListWithKey f kvs
+
+-- | /O(n log n)/. Build a depth-1 'DeepMap' from a list of key/value pairs with a combining function.
+fromListWithKey1 :: (Ord k) => (k -> v -> v -> v) -> [(k, v)] -> DeepMap '[k] v
+fromListWithKey1 f kvs = Nest $ Bare <$> Map.fromListWithKey f kvs
+
+-- | /O(n log n)/. Build a depth-2 'DeepMap' from a list of keys and values with a combining function.
+fromListWithKey2 :: (Ord k0, Ord k1) => (k0 -> k1 -> v -> v -> v) -> [(k0, k1, v)] -> DeepMap '[k0, k1] v
+fromListWithKey2 f kvs =
+  fromListWithKey (unionWithKey1 . f) $
+    (\(k0, k1, v) -> (k0, k1 @| v)) <$> kvs
+
+-- | /O(n log n)/. Build a depth-3 'DeepMap' from a list of keys and values with a combining function.
+fromListWithKey3 :: (Ord k0, Ord k1, Ord k2) => (k0 -> k1 -> k2 -> v -> v -> v) -> [(k0, k1, k2, v)] -> DeepMap '[k0, k1, k2] v
+fromListWithKey3 f kvs =
+  fromListWithKey (unionWithKey2 . f) $
+    (\(k0, k1, k2, v) -> (k0, k1 @> k2 @| v)) <$> kvs
+
+-- | /O(n log n)/. Build a depth-3 'DeepMap' from a list of keys and values with a combining function.
+fromListWithKey4 :: (Ord k0, Ord k1, Ord k2, Ord k3) => (k0 -> k1 -> k2 -> k3 -> v -> v -> v) -> [(k0, k1, k2, k3, v)] -> DeepMap '[k0, k1, k2, k3] v
+fromListWithKey4 f kvs =
+  fromListWithKey (unionWithKey3 . f) $
+    (\(k0, k1, k2, k3, v) -> (k0, k1 @> k2 @> k3 @| v)) <$> kvs
+
+-- | /O(n log n)/. Build a depth-3 'DeepMap' from a list of keys and values with a combining function.
+fromListWithKey5 :: (Ord k0, Ord k1, Ord k2, Ord k3, Ord k4) => (k0 -> k1 -> k2 -> k3 -> k4 -> v -> v -> v) -> [(k0, k1, k2, k3, k4, v)] -> DeepMap '[k0, k1, k2, k3, k4] v
+fromListWithKey5 f kvs =
+  fromListWithKey (unionWithKey4 . f) $
+    (\(k0, k1, k2, k3, k4, v) -> (k0, k1 @> k2 @> k3 @> k4 @| v)) <$> kvs
+
+-- | /O(log n)/. Insert a key/'DeepMap' pair into the 'DeepMap'. If the key is already
+--   present in the map, the associated value is combined with the new value as @old '<>' new@.
+--   The overwriting behaviour from @containers@ can be recovered
+--   by wrapping values in 'Data.Semigroup.Last' or by using 'overwrite'.
+insert :: (Ord k, Semigroup (DeepMap ks v)) => k -> DeepMap ks v -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v
+insert k dm (Nest m) = Nest $ Map.insertWith (flip (<>)) k dm m
+
+-- | /O(log n)/. Insert a new key and value into a depth-1 'DeepMap'. If the key is already
+--   present in the map, the associated value is combined with the new value as @old '<>' new@.
+--   The overwriting behaviour from @containers@ can be recovered
+--   by wrapping values in 'Data.Semigroup.Last' or by using 'overwrite1'.
+insert1 :: (Ord k, Semigroup v) => k -> v -> DeepMap '[k] v -> DeepMap '[k] v
+insert1 k v m = m <> k @| v
+
+-- | /O(log n)/. Insert a new key-chain/value pair into a depth-2 'DeepMap'. If the key is already
+--   present in the map, the associated value is combined with the new value as @old '<>' new@.
+--   The overwriting behaviour from @containers@ can be recovered
+--   by wrapping values in 'Data.Semigroup.Last' or by using 'overwrite2'.
+insert2 :: (Ord k0, Ord k1, Semigroup v) => k0 -> k1 -> v -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
+insert2 k0 k1 v m = m <> k0 @> k1 @| v
+
+-- | /O(log n)/. Insert a new key-chain/value pair into a depth-3 'DeepMap'. If the key is already
+--   present in the map, the associated value is combined with the new value as @old '<>' new@.
+--   so the overwriting behaviour from @containers@ can be recovered
+--   by wrapping values in 'Data.Semigroup.Last' or by using 'overwrite3'.
+insert3 :: (Ord k0, Ord k1, Ord k2, Semigroup v) => k0 -> k1 -> k2 -> v -> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v
+insert3 k0 k1 k2 v m = m <> k0 @> k1 @> k2 @| v
+
+-- | /O(log n)/. Insert a new key-chain/value pair into a depth-4 'DeepMap'. If the key is already
+--   present in the map, the associated value is combined with the new value as @old '<>' new@.
+--   so the overwriting behaviour from @containers@ can be recovered
+--   by wrapping values in 'Data.Semigroup.Last' or by using 'overwrite4'.
+insert4 :: (Ord k0, Ord k1, Ord k2, Ord k3, Semigroup v) => k0 -> k1 -> k2 -> k3 -> v -> DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] v
+insert4 k0 k1 k2 k3 v m = m <> k0 @> k1 @> k2 @> k3 @| v
+
+-- | /O(log n)/. Insert a new key-chain/value pair into a depth-5 'DeepMap'. If the key is already
+--   present in the map, the associated value is combined with the new value as @old '<>' new@.
+--   so the overwriting behaviour from @containers@ can be recovered
+--   by wrapping values in 'Data.Semigroup.Last' or by using 'overwrite5'.
+insert5 :: (Ord k0, Ord k1, Ord k2, Ord k3, Ord k4, Semigroup v) => k0 -> k1 -> k2 -> k3 -> k4 -> v -> DeepMap '[k0, k1, k2, k3, k4] v -> DeepMap '[k0, k1, k2, k3, k4] v
+insert5 k0 k1 k2 k3 k4 v m = m <> k0 @> k1 @> k2 @> k3 @> k4 @| v
+
+-- | /O(log n)/. Insert a new key/'DeepMap' pair into the 'DeepMap'. If the key is already
+--   present in the map, the associated value is replaced by the new value.
+overwrite :: (Ord k) => k -> DeepMap ks v -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v
+overwrite k v (Nest m) = Nest $ Map.insert k v m
+
+-- | /O(log n)/. Insert a new key/value pair into a depth-1 'DeepMap'. If the key is already
+--   present in the map, the associated value is replaced by the new value.
+overwrite1 :: (Ord k) => k -> v -> DeepMap '[k] v -> DeepMap '[k] v
+overwrite1 k v = overwrite k (Bare v)
+
+-- | /O(log n)/. Insert a new key-chain/value pair into a depth-2 'DeepMap'. If the key is already
+--   present in the map, the associated value is replaced by the new value.
+overwrite2 :: (Ord k0, Ord k1) => k0 -> k1 -> v -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
+overwrite2 k0 k1 v m = overwrite k0 (overwrite k1 (Bare v) . fromMaybe empty $ m @? k0) m
+
+-- | /O(log n)/. Insert a new key-chain/value pair into a depth-3 'DeepMap'. If the key is already
+--   present in the map, the associated value is replaced by the new value.
+overwrite3 :: (Ord k0, Ord k1, Ord k2) => k0 -> k1 -> k2 -> v -> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v
+overwrite3 k0 k1 k2 v m = overwrite k0 (overwrite2 k1 k2 v . fromMaybe empty $ m @? k0) m
+
+-- | /O(log n)/. Insert a new key-chain/value pair into a depth-4 'DeepMap'. If the key is already
+--   present in the map, the associated value is replaced by the new value.
+overwrite4 :: (Ord k0, Ord k1, Ord k2, Ord k3) => k0 -> k1 -> k2 -> k3 -> v -> DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] v
+overwrite4 k0 k1 k2 k3 v m = overwrite k0 (overwrite3 k1 k2 k3 v . fromMaybe empty $ m @? k0) m
+
+-- | /O(log n)/. Insert a new key-chain/value pair into a depth-5 'DeepMap'. If the key is already
+--   present in the map, the associated value is replaced by the new value.
+overwrite5 :: (Ord k0, Ord k1, Ord k2, Ord k3, Ord k4) => k0 -> k1 -> k2 -> k3 -> k4 -> v -> DeepMap '[k0, k1, k2, k3, k4] v -> DeepMap '[k0, k1, k2, k3, k4] v
+overwrite5 k0 k1 k2 k3 k4 v m = overwrite k0 (overwrite4 k1 k2 k3 k4 v . fromMaybe empty $ m @? k0) m
+
+-- | /O(log n)/. Combines replacement and retrieval.
+overwriteLookup :: (Ord k) => k -> DeepMap ks v -> DeepMap (k ': ks) v -> (Maybe (DeepMap ks v), DeepMap (k ': ks) v)
+overwriteLookup k v (Nest m) = Nest <$> Map.insertLookupWithKey (const const) k v m
+
+-- | /O(log n)/. Combines replacement and retrieval at depth 1.
+overwriteLookup1 :: (Ord k) => k -> v -> DeepMap '[k] v -> (Maybe v, DeepMap '[k] v)
+overwriteLookup1 k v m = (m @?| k, overwrite1 k v m)
+
+-- | /O(log n)/. Combines replacement and retrieval at depth 2.
+overwriteLookup2 :: (Ord k0, Ord k1) => k0 -> k1 -> v -> DeepMap '[k0, k1] v -> (Maybe v, DeepMap '[k0, k1] v)
+overwriteLookup2 k0 k1 v m = (m @? k0 @??| k1, overwrite2 k0 k1 v m)
+
+-- | /O(log n)/. Combines replacement and retrieval at depth 3.
+overwriteLookup3 :: (Ord k0, Ord k1, Ord k2) => k0 -> k1 -> k2 -> v -> DeepMap '[k0, k1, k2] v -> (Maybe v, DeepMap '[k0, k1, k2] v)
+overwriteLookup3 k0 k1 k2 v m = (m @? k0 @?? k1 @??| k2, overwrite3 k0 k1 k2 v m)
+
+-- | /O(log n)/. Combines replacement and retrieval at depth 4.
+overwriteLookup4 :: (Ord k0, Ord k1, Ord k2, Ord k3) => k0 -> k1 -> k2 -> k3 -> v -> DeepMap '[k0, k1, k2, k3] v -> (Maybe v, DeepMap '[k0, k1, k2, k3] v)
+overwriteLookup4 k0 k1 k2 k3 v m = (m @? k0 @?? k1 @?? k2 @??| k3, overwrite4 k0 k1 k2 k3 v m)
+
+-- | /O(log n)/. Combines replacement and retrieval at depth 5.
+overwriteLookup5 :: (Ord k0, Ord k1, Ord k2, Ord k3, Ord k4) => k0 -> k1 -> k2 -> k3 -> k4 -> v -> DeepMap '[k0, k1, k2, k3, k4] v -> (Maybe v, DeepMap '[k0, k1, k2, k3, k4] v)
+overwriteLookup5 k0 k1 k2 k3 k4 v m = (m @? k0 @?? k1 @?? k2 @?? k3 @??| k4, overwrite5 k0 k1 k2 k3 k4 v m)
+
+-- | /O(log n)/. Insert with a function, combining new value and old value
+--   using the supplied function.
+--
+--   @'insertWith' (~~) k new m@ will insert @new@ at @k@ if there is no value present,
+--   or overwrite with @old ~~ new@ if there was already a value @old@ at @k@.
+insertWith :: (Ord k) => (DeepMap ks v -> DeepMap ks v -> DeepMap ks v) -> k -> DeepMap ks v -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v
+insertWith f k v (Nest m) = Nest $ Map.insertWith f k v m
+
+-- | /O(log n)/. Insert with a function, combining new value and old value
+--   using the supplied function.
+--
+--   @'insertWith1' (~~) k new m@ will insert @new@ at @k@ if there is no value present,
+--   or overwrite with @old ~~ new@ if there was already a value @old@ at @k@.
+insertWith1 :: (Ord k) => (v -> v -> v) -> k -> v -> DeepMap '[k] v -> DeepMap '[k] v
+insertWith1 f k v = insertWith (onBare2 f) k (Bare v)
+
+-- | /O(log n)/. Insert with a function, combining new value and old value
+--   using the supplied function.
+insertWith2 :: (Ord k0, Ord k1) => (v -> v -> v) -> k0 -> k1 -> v -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
+insertWith2 f k0 k1 v m = case m @? k0 of
+  Nothing -> overwrite2 k0 k1 v m
+  Just dm -> overwrite k0 (insertWith1 f k1 v dm) m
+
+-- | /O(log n)/. Insert with a function, combining new value and old value
+--   using the supplied function.
+insertWith3 :: (Ord k0, Ord k1, Ord k2) => (v -> v -> v) -> k0 -> k1 -> k2 -> v -> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v
+insertWith3 f k0 k1 k2 v m = case m @? k0 of
+  Nothing -> overwrite3 k0 k1 k2 v m
+  Just dm -> overwrite k0 (insertWith2 f k1 k2 v dm) m
+
+-- | /O(log n)/. Insert with a function, combining new value and old value
+--   using the supplied function.
+insertWith4 :: (Ord k0, Ord k1, Ord k2, Ord k3) => (v -> v -> v) -> k0 -> k1 -> k2 -> k3 -> v -> DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] v
+insertWith4 f k0 k1 k2 k3 v m = case m @? k0 of
+  Nothing -> overwrite4 k0 k1 k2 k3 v m
+  Just dm -> overwrite k0 (insertWith3 f k1 k2 k3 v dm) m
+
+-- | /O(log n)/. Insert with a function, combining new value and old value
+--   using the supplied function.
+insertWith5 :: (Ord k0, Ord k1, Ord k2, Ord k3, Ord k4) => (v -> v -> v) -> k0 -> k1 -> k2 -> k3 -> k4 -> v -> DeepMap '[k0, k1, k2, k3, k4] v -> DeepMap '[k0, k1, k2, k3, k4] v
+insertWith5 f k0 k1 k2 k3 k4 v m = case m @? k0 of
+  Nothing -> overwrite5 k0 k1 k2 k3 k4 v m
+  Just dm -> overwrite k0 (insertWith4 f k1 k2 k3 k4 v dm) m
+
+-- | /O(log n)/. Insert with a function, combining new value and old value
+--   using the supplied function.
+--
+--   @'insertWithKey' f k new m@ will insert @new@ at @k@ if there is no value present,
+--   or @f k old new@ if there was already a value @old@ at @k@.
+--   The key passed to @f@ is the one passed to 'insertWithKey', not the one present in the map.
+insertWithKey :: (Ord k) => (k -> DeepMap ks v -> DeepMap ks v -> DeepMap ks v) -> k -> DeepMap ks v -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v
+insertWithKey f k v (Nest m) = Nest $ Map.insertWithKey f k v m
+
+-- | /O(log n)/. Insert with a function, combining new value and old value
+--   using the supplied function with access to the given keys.
+insertWithKey1 :: (Ord k) => (k -> v -> v -> v) -> k -> v -> DeepMap '[k] v -> DeepMap '[k] v
+insertWithKey1 f k v = insertWithKey (onBare2 . f) k (Bare v)
+
+-- | /O(log n)/. Insert with a function, combining new value and old value
+--   using the supplied function with access to the given keys.
+insertWithKey2 :: (Ord k0, Ord k1) => (k0 -> k1 -> v -> v -> v) -> k0 -> k1 -> v -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
+insertWithKey2 f k0 k1 v m = case m @? k0 of
+  Nothing -> overwrite2 k0 k1 v m
+  Just dm -> overwrite k0 (insertWithKey1 (f k0) k1 v dm) m
+
+-- | /O(log n)/. Insert with a function, combining new value and old value
+--   using the supplied function with access to the given keys.
+insertWithKey3 :: (Ord k0, Ord k1, Ord k2) => (k0 -> k1 -> k2 -> v -> v -> v) -> k0 -> k1 -> k2 -> v -> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v
+insertWithKey3 f k0 k1 k2 v m = case m @? k0 of
+  Nothing -> overwrite3 k0 k1 k2 v m
+  Just dm -> overwrite k0 (insertWithKey2 (f k0) k1 k2 v dm) m
+
+-- | /O(log n)/. Insert with a function, combining new value and old value
+--   using the supplied function with access to the given keys.
+insertWithKey4 :: (Ord k0, Ord k1, Ord k2, Ord k3) => (k0 -> k1 -> k2 -> k3 -> v -> v -> v) -> k0 -> k1 -> k2 -> k3 -> v -> DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] v
+insertWithKey4 f k0 k1 k2 k3 v m = case m @? k0 of
+  Nothing -> overwrite4 k0 k1 k2 k3 v m
+  Just dm -> overwrite k0 (insertWithKey3 (f k0) k1 k2 k3 v dm) m
+
+-- | /O(log n)/. Insert with a function, combining new value and old value
+--   using the supplied function with access to the given keys.
+insertWithKey5 :: (Ord k0, Ord k1, Ord k2, Ord k3, Ord k4) => (k0 -> k1 -> k2 -> k3 -> k4 -> v -> v -> v) -> k0 -> k1 -> k2 -> k3 -> k4 -> v -> DeepMap '[k0, k1, k2, k3, k4] v -> DeepMap '[k0, k1, k2, k3, k4] v
+insertWithKey5 f k0 k1 k2 k3 k4 v m = case m @? k0 of
+  Nothing -> overwrite5 k0 k1 k2 k3 k4 v m
+  Just dm -> overwrite k0 (insertWithKey4 (f k0) k1 k2 k3 k4 v dm) m
+
+-- | /O(log n)/. Combines insertion and retrieval.
+--
+-- > 'insertLookupWithKey' f k new == 'lookup' k &&& 'insertWithKey' f k new
+insertLookupWithKey :: (Ord k) => (k -> DeepMap ks v -> DeepMap ks v -> DeepMap ks v) -> k -> DeepMap ks v -> DeepMap (k ': ks) v -> (Maybe (DeepMap ks v), DeepMap (k ': ks) v)
+insertLookupWithKey f k v (Nest m) = Nest <$> Map.insertLookupWithKey f k v m
+
+-- | /O(log n)/. Combines insertion and retrieval.
+insertLookupWithKey1 :: (Ord k) => (k -> v -> v -> v) -> k -> v -> DeepMap '[k] v -> (Maybe v, DeepMap '[k] v)
+insertLookupWithKey1 f k v m = (m @?| k, insertWithKey1 f k v m)
+
+-- | /O(log n)/. Combines insertion and retrieval.
+insertLookupWithKey2 :: (Ord k0, Ord k1) => (k0 -> k1 -> v -> v -> v) -> k0 -> k1 -> v -> DeepMap '[k0, k1] v -> (Maybe v, DeepMap '[k0, k1] v)
+insertLookupWithKey2 f k0 k1 v m = (m @? k0 @??| k1, insertWithKey2 f k0 k1 v m)
+
+-- | /O(log n)/. Combines insertion and retrieval.
+insertLookupWithKey3 :: (Ord k0, Ord k1, Ord k2) => (k0 -> k1 -> k2 -> v -> v -> v) -> k0 -> k1 -> k2 -> v -> DeepMap '[k0, k1, k2] v -> (Maybe v, DeepMap '[k0, k1, k2] v)
+insertLookupWithKey3 f k0 k1 k2 v m = (m @? k0 @?? k1 @??| k2, insertWithKey3 f k0 k1 k2 v m)
+
+-- | /O(log n)/. Combines insertion and retrieval.
+insertLookupWithKey4 :: (Ord k0, Ord k1, Ord k2, Ord k3) => (k0 -> k1 -> k2 -> k3 -> v -> v -> v) -> k0 -> k1 -> k2 -> k3 -> v -> DeepMap '[k0, k1, k2, k3] v -> (Maybe v, DeepMap '[k0, k1, k2, k3] v)
+insertLookupWithKey4 f k0 k1 k2 k3 v m = (m @? k0 @?? k1 @?? k2 @??| k3, insertWithKey4 f k0 k1 k2 k3 v m)
+
+-- | /O(log n)/. Combines insertion and retrieval.
+insertLookupWithKey5 :: (Ord k0, Ord k1, Ord k2, Ord k3, Ord k4) => (k0 -> k1 -> k2 -> k3 -> k4 -> v -> v -> v) -> k0 -> k1 -> k2 -> k3 -> k4 -> v -> DeepMap '[k0, k1, k2, k3, k4] v -> (Maybe v, DeepMap '[k0, k1, k2, k3, k4] v)
+insertLookupWithKey5 f k0 k1 k2 k3 k4 v m = (m @? k0 @?? k1 @?? k2 @?? k3 @??| k4, insertWithKey5 f k0 k1 k2 k3 k4 v m)
+
+-- | /O(log n)/. Delete a key and its value from the map, or do nothing if the key is missing.
+delete :: (Ord k) => k -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v
+delete k (Nest m) = Nest $ Map.delete k m
+
+-- | /O(log n)/. Delete a key and its value from the map, or do nothing if the key is missing.
+delete1 :: (Ord k) => k -> DeepMap '[k] v -> DeepMap '[k] v
+delete1 = delete
+
+-- | /O(log n)/. Delete a key and its value from the map, or do nothing if the key is missing.
+delete2 :: (Ord k0, Ord k1) => k0 -> k1 -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
+delete2 k0 k1 m = case m @? k0 of
+  Nothing -> m
+  Just dm -> overwrite k0 (delete1 k1 dm) m
+
+-- | /O(log n)/. Delete a key and its value from the map, or do nothing if the key is missing.
+delete3 :: (Ord k0, Ord k1, Ord k2) => k0 -> k1 -> k2 -> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v
+delete3 k0 k1 k2 m = case m @? k0 of
+  Nothing -> m
+  Just dm -> overwrite k0 (delete2 k1 k2 dm) m
+
+-- | /O(log n)/. Delete a key and its value from the map, or do nothing if the key is missing.
+delete4 :: (Ord k0, Ord k1, Ord k2, Ord k3) => k0 -> k1 -> k2 -> k3 -> DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] v
+delete4 k0 k1 k2 k3 m = case m @? k0 of
+  Nothing -> m
+  Just dm -> overwrite k0 (delete3 k1 k2 k3 dm) m
+
+-- | /O(log n)/. Delete a key and its value from the map, or do nothing if the key is missing.
+delete5 :: (Ord k0, Ord k1, Ord k2, Ord k3, Ord k4) => k0 -> k1 -> k2 -> k3 -> k4 -> DeepMap '[k0, k1, k2, k3, k4] v -> DeepMap '[k0, k1, k2, k3, k4] v
+delete5 k0 k1 k2 k3 k4 m = case m @? k0 of
+  Nothing -> m
+  Just dm -> overwrite k0 (delete4 k1 k2 k3 k4 dm) m
+
+-- | /O(log n)/. Change a value at a specific key with the result of the provided function,
+--   or do nothing if the key is missing.
+adjust :: (Ord k) => (DeepMap ks v -> DeepMap ks v) -> k -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v
+adjust f k (Nest m) = Nest $ Map.adjust f k m
+
+-- | /O(log n)/. Change a value at a specific key with the result of the provided function,
+--   or do nothing if the key is missing.
+adjust1 :: (Ord k) => (v -> v) -> k -> DeepMap '[k] v -> DeepMap '[k] v
+adjust1 f = adjust (fmap f)
+
+-- | /O(log n)/. Change a value at specific keys with the result of the provided function,
+--   or do nothing if the key is missing.
+adjust2 :: (Ord k0, Ord k1) => (v -> v) -> k0 -> k1 -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
+adjust2 f k0 k1 m = case m @? k0 of
+  Nothing -> m
+  Just dm -> overwrite k0 (adjust1 f k1 dm) m
+
+-- | /O(log n)/. Change a value at specific keys with the result of the provided function,
+--   or do nothing if the key is missing.
+adjust3 :: (Ord k0, Ord k1, Ord k2) => (v -> v) -> k0 -> k1 -> k2 -> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v
+adjust3 f k0 k1 k2 m = case m @? k0 of
+  Nothing -> m
+  Just dm -> overwrite k0 (adjust2 f k1 k2 dm) m
+
+-- | /O(log n)/. Change a value at specific keys with the result of the provided function,
+--   or do nothing if the key is missing.
+adjust4 :: (Ord k0, Ord k1, Ord k2, Ord k3) => (v -> v) -> k0 -> k1 -> k2 -> k3 -> DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] v
+adjust4 f k0 k1 k2 k3 m = case m @? k0 of
+  Nothing -> m
+  Just dm -> overwrite k0 (adjust3 f k1 k2 k3 dm) m
+
+-- | /O(log n)/. Change a value at specific keys with the result of the provided function,
+--   or do nothing if the key is missing.
+adjust5 :: (Ord k0, Ord k1, Ord k2, Ord k3, Ord k4) => (v -> v) -> k0 -> k1 -> k2 -> k3 -> k4 -> DeepMap '[k0, k1, k2, k3, k4] v -> DeepMap '[k0, k1, k2, k3, k4] v
+adjust5 f k0 k1 k2 k3 k4 m = case m @? k0 of
+  Nothing -> m
+  Just dm -> overwrite k0 (adjust4 f k1 k2 k3 k4 dm) m
+
+-- | /O(log n)/. Change a value at a specific key with access to the key itself,
+--   or do nothing if the key is missing.
+adjustWithKey :: (Ord k) => (k -> DeepMap ks v -> DeepMap ks v) -> k -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v
+adjustWithKey f k (Nest m) = Nest $ Map.adjustWithKey f k m
+
+-- | /O(log n)/. Change a value at a specific key with access to the key itself,
+--   or do nothing if the key is missing.
+adjustWithKey1 :: (Ord k) => (k -> v -> v) -> k -> DeepMap '[k] v -> DeepMap '[k] v
+adjustWithKey1 f = adjustWithKey (fmap . f)
+
+-- | /O(log n)/. Change a value at a specific key with access to the key itself,
+--   or do nothing if the key is missing.
+adjustWithKey2 :: (Ord k0, Ord k1) => (k0 -> k1 -> v -> v) -> k0 -> k1 -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
+adjustWithKey2 f k0 k1 m = case m @? k0 of
+  Nothing -> m
+  Just dm -> overwrite k0 (adjustWithKey1 (f k0) k1 dm) m
+
+-- | /O(log n)/. Change a value at a specific key with access to the key itself,
+--   or do nothing if the key is missing.
+adjustWithKey3 :: (Ord k0, Ord k1, Ord k2) => (k0 -> k1 -> k2 -> v -> v) -> k0 -> k1 -> k2 -> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v
+adjustWithKey3 f k0 k1 k2 m = case m @? k0 of
+  Nothing -> m
+  Just dm -> overwrite k0 (adjustWithKey2 (f k0) k1 k2 dm) m
+
+-- | /O(log n)/. Change a value at a specific key with access to the key itself,
+--   or do nothing if the key is missing.
+adjustWithKey4 :: (Ord k0, Ord k1, Ord k2, Ord k3) => (k0 -> k1 -> k2 -> k3 -> v -> v) -> k0 -> k1 -> k2 -> k3 -> DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] v
+adjustWithKey4 f k0 k1 k2 k3 m = case m @? k0 of
+  Nothing -> m
+  Just dm -> overwrite k0 (adjustWithKey3 (f k0) k1 k2 k3 dm) m
+
+-- | /O(log n)/. Change a value at a specific key with access to the key itself,
+--   or do nothing if the key is missing.
+adjustWithKey5 :: (Ord k0, Ord k1, Ord k2, Ord k3, Ord k4) => (k0 -> k1 -> k2 -> k3 -> k4 -> v -> v) -> k0 -> k1 -> k2 -> k3 -> k4 -> DeepMap '[k0, k1, k2, k3, k4] v -> DeepMap '[k0, k1, k2, k3, k4] v
+adjustWithKey5 f k0 k1 k2 k3 k4 m = case m @? k0 of
+  Nothing -> m
+  Just dm -> overwrite k0 (adjustWithKey4 (f k0) k1 k2 k3 k4 dm) m
+
+-- | /O(log n)/. Change a 'DeepMap' at a specific key. If the function evaluates to 'Nothing',
+--   the key and submap are removed. If the key is missing, do nothing.
+update :: (Ord k) => (DeepMap ks v -> Maybe (DeepMap ks v)) -> k -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v
+update f k (Nest m) = Nest $ Map.update f k m
+
+-- | /O(log n)/. Change a 'DeepMap' at a specific key. If the function evaluates to 'Nothing',
+--   the key and submap are removed. If the key is missing, do nothing.
+update1 :: (Ord k) => (v -> Maybe v) -> k -> DeepMap '[k] v -> DeepMap '[k] v
+update1 f = update (traverse f)
+
+-- | /O(log n)/. Change a 'DeepMap' at a specific key. If the function evaluates to 'Nothing',
+--   the key and submap are removed. If the key is missing, do nothing.
+update2 :: (Ord k0, Ord k1) => (v -> Maybe v) -> k0 -> k1 -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
+update2 f k0 k1 m = case m @? k0 of
+  Nothing -> m
+  Just dm -> overwrite k0 (update1 f k1 dm) m
+
+-- | /O(log n)/. Change a 'DeepMap' at a specific key. If the function evaluates to 'Nothing',
+--   the key and submap are removed. If the key is missing, do nothing.
+update3 :: (Ord k0, Ord k1, Ord k2) => (v -> Maybe v) -> k0 -> k1 -> k2 -> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v
+update3 f k0 k1 k2 m = case m @? k0 of
+  Nothing -> m
+  Just dm -> overwrite k0 (update2 f k1 k2 dm) m
+
+-- | /O(log n)/. Change a 'DeepMap' at a specific key. If the function evaluates to 'Nothing',
+--   the key and submap are removed. If the key is missing, do nothing.
+update4 :: (Ord k0, Ord k1, Ord k2, Ord k3) => (v -> Maybe v) -> k0 -> k1 -> k2 -> k3 -> DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] v
+update4 f k0 k1 k2 k3 m = case m @? k0 of
+  Nothing -> m
+  Just dm -> overwrite k0 (update3 f k1 k2 k3 dm) m
+
+-- | /O(log n)/. Change a 'DeepMap' at a specific key. If the function evaluates to 'Nothing',
+--   the key and submap are removed. If the key is missing, do nothing.
+update5 :: (Ord k0, Ord k1, Ord k2, Ord k3, Ord k4) => (v -> Maybe v) -> k0 -> k1 -> k2 -> k3 -> k4 -> DeepMap '[k0, k1, k2, k3, k4] v -> DeepMap '[k0, k1, k2, k3, k4] v
+update5 f k0 k1 k2 k3 k4 m = case m @? k0 of
+  Nothing -> m
+  Just dm -> overwrite k0 (update4 f k1 k2 k3 k4 dm) m
+
+-- | /O(log n)/. Change a 'DeepMap' at a specific key, with access to the key itself.
+--   If the function evaluates to 'Nothing', the key and submap are removed.
+--   If the key is missing, do nothing.
+updateWithKey :: (Ord k) => (k -> DeepMap ks v -> Maybe (DeepMap ks v)) -> k -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v
+updateWithKey f k (Nest m) = Nest $ Map.updateWithKey f k m
+
+-- | /O(log n)/. Change a value at a specific key with access to the key itself.
+--   If the function evaluates to 'Nothing', the key and value are removed.
+--   If the key is missing, do nothing.
+updateWithKey1 :: (Ord k) => (k -> v -> Maybe v) -> k -> DeepMap '[k] v -> DeepMap '[k] v
+updateWithKey1 f = updateWithKey (traverse . f)
+
+-- | /O(log n)/. Change a value at specific keys with access to the keys themselves.
+--   If the function evaluates to 'Nothing', the keys and value are removed.
+--   If the keys are missing, do nothing.
+updateWithKey2 :: (Ord k0, Ord k1) => (k0 -> k1 -> v -> Maybe v) -> k0 -> k1 -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
+updateWithKey2 f k0 k1 m = case m @? k0 of
+  Nothing -> m
+  Just dm -> overwrite k0 (updateWithKey1 (f k0) k1 dm) m
+
+-- | /O(log n)/. Change a value at specific keys with access to the keys themselves.
+--   If the function evaluates to 'Nothing', the keys and value are removed.
+--   If the keys are missing, do nothing.
+updateWithKey3 :: (Ord k0, Ord k1, Ord k2) => (k0 -> k1 -> k2 -> v -> Maybe v) -> k0 -> k1 -> k2 -> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v
+updateWithKey3 f k0 k1 k2 m = case m @? k0 of
+  Nothing -> m
+  Just dm -> overwrite k0 (updateWithKey2 (f k0) k1 k2 dm) m
+
+-- | /O(log n)/. Change a value at specific keys with access to the keys themselves.
+--   If the function evaluates to 'Nothing', the keys and value are removed.
+--   If the keys are missing, do nothing.
+updateWithKey4 :: (Ord k0, Ord k1, Ord k2, Ord k3) => (k0 -> k1 -> k2 -> k3 -> v -> Maybe v) -> k0 -> k1 -> k2 -> k3 -> DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] v
+updateWithKey4 f k0 k1 k2 k3 m = case m @? k0 of
+  Nothing -> m
+  Just dm -> overwrite k0 (updateWithKey3 (f k0) k1 k2 k3 dm) m
+
+-- | /O(log n)/. Change a value at specific keys with access to the keys themselves.
+--   If the function evaluates to 'Nothing', the keys and value are removed.
+--   If the keys are missing, do nothing.
+updateWithKey5 :: (Ord k0, Ord k1, Ord k2, Ord k3, Ord k4) => (k0 -> k1 -> k2 -> k3 -> k4 -> v -> Maybe v) -> k0 -> k1 -> k2 -> k3 -> k4 -> DeepMap '[k0, k1, k2, k3, k4] v -> DeepMap '[k0, k1, k2, k3, k4] v
+updateWithKey5 f k0 k1 k2 k3 k4 m = case m @? k0 of
+  Nothing -> m
+  Just dm -> overwrite k0 (updateWithKey4 (f k0) k1 k2 k3 k4 dm) m
+
+-- | /O(log n)/. Combines change and retrieval.
+--
+-- > 'updateLookupWithKey' f k == 'lookup' k &&& 'updateWithKey' f k
+updateLookupWithKey :: (Ord k) => (k -> DeepMap ks v -> Maybe (DeepMap ks v)) -> k -> DeepMap (k ': ks) v -> (Maybe (DeepMap ks v), DeepMap (k ': ks) v)
+updateLookupWithKey f k (Nest m) = Nest <$> Map.updateLookupWithKey f k m
+
+-- | /O(log n)/. Combines change and retrieval.
+updateLookupWithKey1 :: (Ord k) => (k -> v -> Maybe v) -> k -> DeepMap '[k] v -> (Maybe v, DeepMap '[k] v)
+updateLookupWithKey1 f k m = (m @?| k, updateWithKey1 f k m)
+
+-- | /O(log n)/. Combines change and retrieval.
+updateLookupWithKey2 :: (Ord k0, Ord k1) => (k0 -> k1 -> v -> Maybe v) -> k0 -> k1 -> DeepMap '[k0, k1] v -> (Maybe v, DeepMap '[k0, k1] v)
+updateLookupWithKey2 f k0 k1 m = (m @? k0 @??| k1, updateWithKey2 f k0 k1 m)
+
+-- | /O(log n)/. Combines change and retrieval.
+updateLookupWithKey3 :: (Ord k0, Ord k1, Ord k2) => (k0 -> k1 -> k2 -> v -> Maybe v) -> k0 -> k1 -> k2 -> DeepMap '[k0, k1, k2] v -> (Maybe v, DeepMap '[k0, k1, k2] v)
+updateLookupWithKey3 f k0 k1 k2 m = (m @? k0 @?? k1 @??| k2, updateWithKey3 f k0 k1 k2 m)
+
+-- | /O(log n)/. Combines change and retrieval.
+updateLookupWithKey4 :: (Ord k0, Ord k1, Ord k2, Ord k3) => (k0 -> k1 -> k2 -> k3 -> v -> Maybe v) -> k0 -> k1 -> k2 -> k3 -> DeepMap '[k0, k1, k2, k3] v -> (Maybe v, DeepMap '[k0, k1, k2, k3] v)
+updateLookupWithKey4 f k0 k1 k2 k3 m = (m @? k0 @?? k1 @?? k2 @??| k3, updateWithKey4 f k0 k1 k2 k3 m)
+
+-- | /O(log n)/. Combines change and retrieval.
+updateLookupWithKey5 :: (Ord k0, Ord k1, Ord k2, Ord k3, Ord k4) => (k0 -> k1 -> k2 -> k3 -> k4 -> v -> Maybe v) -> k0 -> k1 -> k2 -> k3 -> k4 -> DeepMap '[k0, k1, k2, k3, k4] v -> (Maybe v, DeepMap '[k0, k1, k2, k3, k4] v)
+updateLookupWithKey5 f k0 k1 k2 k3 k4 m = (m @? k0 @?? k1 @?? k2 @?? k3 @??| k4, updateWithKey5 f k0 k1 k2 k3 k4 m)
+
+-- | /O(log n)/. Can be used to 'insert', 'overwrite', 'delete', or 'update' a value.
+alter :: (Ord k) => (Maybe (DeepMap ks v) -> Maybe (DeepMap ks v)) -> k -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v
+alter f k (Nest m) = Nest $ Map.alter f k m
+
+-- | /O(log n)/. Can be used to 'insert', 'overwrite', 'delete', or 'update' a value.
+alter1 :: (Ord k) => (Maybe v -> Maybe v) -> k -> DeepMap '[k] v -> DeepMap '[k] v
+alter1 f = alter (fmap Bare . f . fmap getBare)
+
+-- | /O(log n)/. Can be used to 'insert', 'overwrite', 'delete', or 'update' a value.
+alter2 :: (Ord k0, Ord k1) => (Maybe v -> Maybe v) -> k0 -> k1 -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
+alter2 f k0 k1 m = case f $ m @? k0 @??| k1 of
+  Nothing -> delete2 k0 k1 m
+  Just v -> overwrite2 k0 k1 v m
+
+-- | /O(log n)/. Can be used to 'insert', 'overwrite', 'delete', or 'update' a value.
+alter3 :: (Ord k0, Ord k1, Ord k2) => (Maybe v -> Maybe v) -> k0 -> k1 -> k2 -> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v
+alter3 f k0 k1 k2 m = case f $ m @? k0 @?? k1 @??| k2 of
+  Nothing -> delete3 k0 k1 k2 m
+  Just v -> overwrite3 k0 k1 k2 v m
+
+-- | /O(log n)/. Can be used to 'insert', 'overwrite', 'delete', or 'update' a value.
+alter4 :: (Ord k0, Ord k1, Ord k2, Ord k3) => (Maybe v -> Maybe v) -> k0 -> k1 -> k2 -> k3 -> DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] v
+alter4 f k0 k1 k2 k3 m = case f $ m @? k0 @?? k1 @?? k2 @??| k3 of
+  Nothing -> delete4 k0 k1 k2 k3 m
+  Just v -> overwrite4 k0 k1 k2 k3 v m
+
+-- | /O(log n)/. Can be used to 'insert', 'overwrite', 'delete', or 'update' a value.
+alter5 :: (Ord k0, Ord k1, Ord k2, Ord k3, Ord k4) => (Maybe v -> Maybe v) -> k0 -> k1 -> k2 -> k3 -> k4 -> DeepMap '[k0, k1, k2, k3, k4] v -> DeepMap '[k0, k1, k2, k3, k4] v
+alter5 f k0 k1 k2 k3 k4 m = case f $ m @? k0 @?? k1 @?? k2 @?? k3 @??| k4 of
+  Nothing -> delete5 k0 k1 k2 k3 k4 m
+  Just v -> overwrite5 k0 k1 k2 k3 k4 v m
+
+alterF :: (Functor f, Ord k) => (Maybe (DeepMap ks v) -> f (Maybe (DeepMap ks v))) -> k -> DeepMap (k ': ks) v -> f (DeepMap (k ': ks) v)
+alterF f k (Nest m) = Nest <$> Map.alterF f k m
+
+alterF1 :: (Functor f, Ord k) => (Maybe v -> f (Maybe v)) -> k -> DeepMap '[k] v -> f (DeepMap '[k] v)
+alterF1 f = alterF (fmap (fmap Bare) . f . fmap getBare)
+
+alterF2 :: (Functor f, Ord k0, Ord k1) => (Maybe v -> f (Maybe v)) -> k0 -> k1 -> DeepMap '[k0, k1] v -> f (DeepMap '[k0, k1] v)
+alterF2 f k0 k1 m =
+  f (m @? k0 @??| k1) <&> \case
+    Nothing -> delete2 k0 k1 m
+    Just v -> overwrite2 k0 k1 v m
+
+alterF3 :: (Functor f, Ord k0, Ord k1, Ord k2) => (Maybe v -> f (Maybe v)) -> k0 -> k1 -> k2 -> DeepMap '[k0, k1, k2] v -> f (DeepMap '[k0, k1, k2] v)
+alterF3 f k0 k1 k2 m =
+  f (m @? k0 @?? k1 @??| k2) <&> \case
+    Nothing -> delete3 k0 k1 k2 m
+    Just v -> overwrite3 k0 k1 k2 v m
+
+alterF4 :: (Functor f, Ord k0, Ord k1, Ord k2, Ord k3) => (Maybe v -> f (Maybe v)) -> k0 -> k1 -> k2 -> k3 -> DeepMap '[k0, k1, k2, k3] v -> f (DeepMap '[k0, k1, k2, k3] v)
+alterF4 f k0 k1 k2 k3 m =
+  f (m @? k0 @?? k1 @?? k2 @??| k3) <&> \case
+    Nothing -> delete4 k0 k1 k2 k3 m
+    Just v -> overwrite4 k0 k1 k2 k3 v m
+
+alterF5 :: (Functor f, Ord k0, Ord k1, Ord k2, Ord k3, Ord k4) => (Maybe v -> f (Maybe v)) -> k0 -> k1 -> k2 -> k3 -> k4 -> DeepMap '[k0, k1, k2, k3, k4] v -> f (DeepMap '[k0, k1, k2, k3, k4] v)
+alterF5 f k0 k1 k2 k3 k4 m =
+  f (m @? k0 @?? k1 @?? k2 @?? k3 @??| k4) <&> \case
+    Nothing -> delete5 k0 k1 k2 k3 k4 m
+    Just v -> overwrite5 k0 k1 k2 k3 k4 v m
+
+-- | /O(log n)/. Lookup the value at a key.
+lookup :: (Ord k) => k -> DeepMap (k ': ks) v -> Maybe (DeepMap ks v)
+lookup k (Nest m) = Map.lookup k m
+
+-- | /O(log n)/. Lookup the value at a key.
+lookup1 :: (Ord k) => k -> DeepMap '[k] v -> Maybe v
+lookup1 k (Nest m) = getBare <$> Map.lookup k m
+
+-- | /O(log n)/. A flipped, infix variant of 'lookup'.
+(@?) :: (Ord k) => DeepMap (k ': ks) v -> k -> Maybe (DeepMap ks v)
+(@?) = flip lookup
+
+-- | /O(log n)/. A flipped, infix variant of 'lookup1'.
+(@?|) :: (Ord k) => DeepMap '[k] v -> k -> Maybe v
+(@?|) = flip lookup1
+
+-- | /O(log n)/. Facilitates chaining of lookups. For @m :: DeepMap '[k0, k1, k2] v@,
+--
+-- >>> m @? k0 @?? k1 @??| k2 == (m @? k0) >>= (@? k1) >>= (@?| k2)
+(@??) :: (Ord k) => Maybe (DeepMap (k ': ks) v) -> k -> Maybe (DeepMap ks v)
+mm @?? k = mm >>= (@? k)
+
+-- | /O(log n)/. Facilitates chaining of lookups. For @m :: DeepMap '[k0, k1, k2] v@,
+--
+-- >>> m @? k0 @?? k1 @??| k2 == (m @? k0) >>= (@? k1) >>= (@?| k2)
+(@??|) :: (Ord k) => Maybe (DeepMap '[k] v) -> k -> Maybe v
+mm @??| k = mm >>= (@?| k)
+
+-- | /O(log n)/. A version of '(@?)' that returns 'mempty' when the element cannot be found.
+(@!) :: (Ord k, Monoid (DeepMap ks v)) => DeepMap (k ': ks) v -> k -> DeepMap ks v
+(@!) = (fromMaybe mempty .) . (@?)
+
+-- | /O(log n)/. A version of '(@?|)' that returns 'mempty' when the element cannot be found.
+(@!|) :: (Ord k, Monoid v) => DeepMap '[k] v -> k -> v
+(@!|) = (fromMaybe mempty .) . (@?|)
+
+-- | /O(log n)/. Lookup the 'DeepMap' at a key, with a default if the key is missing.
+findWithDefault :: (Ord k) => DeepMap ks v -> k -> DeepMap (k ': ks) v -> DeepMap ks v
+findWithDefault a = (fromMaybe a .) . lookup
+
+-- | /O(log n)/. Lookup the value at a key, with a default if the key is missing.
+findWithDefault1 :: (Ord k) => v -> k -> DeepMap '[k] v -> v
+findWithDefault1 a k m = fromMaybe a $ m @?| k
+
+-- | /O(log n)/. Lookup the value at a key, with a default if the key is missing.
+findWithDefault2 :: (Ord k0, Ord k1) => v -> k0 -> k1 -> DeepMap '[k0, k1] v -> v
+findWithDefault2 a k0 k1 m = fromMaybe a $ m @? k0 @??| k1
+
+-- | /O(log n)/. Lookup the value at a key, with a default if the key is missing.
+findWithDefault3 :: (Ord k0, Ord k1, Ord k2) => v -> k0 -> k1 -> k2 -> DeepMap '[k0, k1, k2] v -> v
+findWithDefault3 a k0 k1 k2 m = fromMaybe a $ m @? k0 @?? k1 @??| k2
+
+-- | /O(log n)/. Lookup the value at a key, with a default if the key is missing.
+findWithDefault4 :: (Ord k0, Ord k1, Ord k2, Ord k3) => v -> k0 -> k1 -> k2 -> k3 -> DeepMap '[k0, k1, k2, k3] v -> v
+findWithDefault4 a k0 k1 k2 k3 m = fromMaybe a $ m @? k0 @?? k1 @?? k2 @??| k3
+
+-- | /O(log n)/. Lookup the value at a key, with a default if the key is missing.
+findWithDefault5 :: (Ord k0, Ord k1, Ord k2, Ord k3, Ord k4) => v -> k0 -> k1 -> k2 -> k3 -> k4 -> DeepMap '[k0, k1, k2, k3, k4] v -> v
+findWithDefault5 a k0 k1 k2 k3 k4 m = fromMaybe a $ m @? k0 @?? k1 @?? k2 @?? k3 @??| k4
+
+-- | /O(log n)/. Is the key a member of the map? See also 'notMember'.
+member :: (Ord k) => k -> DeepMap (k ': ks) v -> Bool
+member k (Nest m) = Map.member k m
+
+-- | /O(log n)/. Is the key missing from the map? See also 'member'.
+notMember :: (Ord k) => k -> DeepMap (k ': ks) v -> Bool
+notMember k (Nest m) = Map.notMember k m
+
+-- | Find the next smallest key to the given one, and return its key/value pair.
+lookupLT :: (Ord k) => k -> DeepMap (k ': ks) v -> Maybe (k, DeepMap ks v)
+lookupLT k (Nest m) = Map.lookupLT k m
+
+-- | Find the next largest key to the given one, and return its key/value pair.
+lookupGT :: (Ord k) => k -> DeepMap (k ': ks) v -> Maybe (k, DeepMap ks v)
+lookupGT k (Nest m) = Map.lookupGT k m
+
+-- | Find the largest key up to the given one, and return its key/value pair.
+lookupLE :: (Ord k) => k -> DeepMap (k ': ks) v -> Maybe (k, DeepMap ks v)
+lookupLE k (Nest m) = Map.lookupLE k m
+
+-- | Find the smallest key down to the given one, and return its key/value pair.
+lookupGE :: (Ord k) => k -> DeepMap (k ': ks) v -> Maybe (k, DeepMap ks v)
+lookupGE k (Nest m) = Map.lookupGE k m
+
+-- | /O(1)/. Is the 'DeepMap' empty?
+null :: DeepMap (k ': ks) v -> Bool
+null (Nest m) = Map.null m
+
+-- | /O(1)/. The number of outermost keys in the 'DeepMap'.
+size :: DeepMap (k ': ks) v -> Int
+size (Nest m) = Map.size m
+
+-- | /O(m log(n \/ m + 1)), m <= n/. Join two 'DeepMap's together using '(<>)' to combine
+--   the values of duplicate keys.
+--
+--   To retain 'Data.Map'\'s left-biased functionality, use @'unionWith' 'const'@.
+union :: (Ord k, Semigroup (DeepMap ks v)) => DeepMap (k ': ks) v -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v
+union = (<>)
+
+-- | /O(m log(n \/ m + 1)), m <= n/. Join two 'DeepMap's with a combining function.
+unionWith :: (Ord k) => (DeepMap ks v -> DeepMap ks v -> DeepMap ks v) -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v
+unionWith f = onNest2 (Map.unionWith f)
+
+-- | /O(m log(n \/ m + 1)), m <= n/. Join two 'DeepMap's with a combining function.
+unionWith1 :: (Ord k) => (v -> v -> v) -> DeepMap '[k] v -> DeepMap '[k] v -> DeepMap '[k] v
+unionWith1 f = onNest2 (Map.unionWith (onBare2 f))
+
+-- | /O(m log(n \/ m + 1)), m <= n/. Join two 'DeepMap's with a combining function.
+unionWith2 :: (Ord k0, Ord k1) => (v -> v -> v) -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
+unionWith2 f = unionWith (unionWith1 f)
+
+-- | /O(m log(n \/ m + 1)), m <= n/. Join two 'DeepMap's with a combining function.
+unionWith3 :: (Ord k0, Ord k1, Ord k2) => (v -> v -> v) -> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v
+unionWith3 f = unionWith (unionWith2 f)
+
+-- | /O(m log(n \/ m + 1)), m <= n/. Join two 'DeepMap's with a combining function.
+unionWith4 :: (Ord k0, Ord k1, Ord k2, Ord k3) => (v -> v -> v) -> DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] v
+unionWith4 f = unionWith (unionWith3 f)
+
+-- | /O(m log(n \/ m + 1)), m <= n/. Join two 'DeepMap's with a combining function.
+unionWith5 :: (Ord k0, Ord k1, Ord k2, Ord k3, Ord k4) => (v -> v -> v) -> DeepMap '[k0, k1, k2, k3, k4] v -> DeepMap '[k0, k1, k2, k3, k4] v -> DeepMap '[k0, k1, k2, k3, k4] v
+unionWith5 f = unionWith (unionWith4 f)
+
+-- | /O(m log(n \/ m + 1)), m <= n/. Join two maps with a combining function with access to the keys.
+unionWithKey :: (Ord k) => (k -> DeepMap ks v -> DeepMap ks v -> DeepMap ks v) -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v
+unionWithKey f = onNest2 (Map.unionWithKey f)
+
+-- | /O(m log(n \/ m + 1)), m <= n/. Join two 'DeepMap's with a combining function with access to the keys.
+unionWithKey1 :: (Ord k) => (k -> v -> v -> v) -> DeepMap '[k] v -> DeepMap '[k] v -> DeepMap '[k] v
+unionWithKey1 f = onNest2 (Map.unionWithKey $ onBare2 . f)
+
+-- | /O(m log(n \/ m + 1)), m <= n/. Join two 'DeepMap's with a combining function with access to the keys.
+unionWithKey2 :: (Ord k0, Ord k1) => (k0 -> k1 -> v -> v -> v) -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
+unionWithKey2 f = unionWithKey (unionWithKey1 . f)
+
+-- | /O(m log(n \/ m + 1)), m <= n/. Join two 'DeepMap's with a combining function with access to the keys.
+unionWithKey3 :: (Ord k0, Ord k1, Ord k2) => (k0 -> k1 -> k2 -> v -> v -> v) -> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v
+unionWithKey3 f = unionWithKey (unionWithKey2 . f)
+
+-- | /O(m log(n \/ m + 1)), m <= n/. Join two 'DeepMap's with a combining function with access to the keys.
+unionWithKey4 :: (Ord k0, Ord k1, Ord k2, Ord k3) => (k0 -> k1 -> k2 -> k3 -> v -> v -> v) -> DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] v
+unionWithKey4 f = unionWithKey (unionWithKey3 . f)
+
+-- | /O(m log(n \/ m + 1)), m <= n/. Join two 'DeepMap's with a combining function with access to the keys.
+unionWithKey5 :: (Ord k0, Ord k1, Ord k2, Ord k3, Ord k4) => (k0 -> k1 -> k2 -> k3 -> k4 -> v -> v -> v) -> DeepMap '[k0, k1, k2, k3, k4] v -> DeepMap '[k0, k1, k2, k3, k4] v -> DeepMap '[k0, k1, k2, k3, k4] v
+unionWithKey5 f = unionWithKey (unionWithKey4 . f)
+
+-- | A synonym for 'fold'. To retain 'Data.Map'\'s functionality, use @'unionsWith' 'const'@.
+unions :: (Foldable t, Ord k, Semigroup (DeepMap ks v)) => t (DeepMap (k ': ks) v) -> DeepMap (k ': ks) v
+unions = fold
+
+-- | The union of a list of 'DeepMap's, combining with a specified operation.
+unionsWith :: (Foldable t, Ord k) => (DeepMap ks v -> DeepMap ks v -> DeepMap ks v) -> t (DeepMap (k ': ks) v) -> DeepMap (k ': ks) v
+unionsWith f = foldl (unionWith f) empty
+
+-- | The union of a list of 'DeepMap's, combining with a specified operation.
+unionsWith1 :: (Foldable t, Ord k) => (v -> v -> v) -> t (DeepMap '[k] v) -> DeepMap '[k] v
+unionsWith1 f = foldl (unionWith1 f) empty
+
+-- | /O(m log(n \/ m + 1)), m <= n/. The set-difference of the keys in a 'DeepMap',
+--   keeping the values of the left-hand map.
+difference :: (Ord k) => DeepMap (k ': ks) v -> DeepMap (k ': ls) w -> DeepMap (k ': ks) v
+difference = onNest2 Map.difference
+
+-- | Infix synonym for 'difference'.
+(\\) :: (Ord k) => DeepMap (k ': ks) v -> DeepMap (k ': ls) w -> DeepMap (k ': ks) v
+(\\) = difference
+
+-- | /O(n + m)/. Difference with a combining function. Deletes keys if the value is 'Nothing'.
+differenceWith :: (Ord k) => (DeepMap ks v -> DeepMap ls w -> Maybe (DeepMap ks v)) -> DeepMap (k ': ks) v -> DeepMap (k ': ls) w -> DeepMap (k ': ks) v
+differenceWith f = onNest2 (Map.differenceWith f)
+
+-- | /O(n + m)/. Difference with a combining function. Deletes keys if the value is 'Nothing'.
+differenceWith1 :: (Ord k) => (v -> w -> Maybe v) -> DeepMap '[k] v -> DeepMap '[k] w -> DeepMap '[k] v
+differenceWith1 f = onNest2 (Map.differenceWith $ onBare2F f)
+
+-- | /O(n + m)/. Difference with a combining function. Deletes keys if the value is 'Nothing'.
+differenceWithKey :: (Ord k) => (k -> DeepMap ks v -> DeepMap ls w -> Maybe (DeepMap ks v)) -> DeepMap (k ': ks) v -> DeepMap (k ': ls) w -> DeepMap (k ': ks) v
+differenceWithKey f = onNest2 (Map.differenceWithKey f)
+
+-- | /O(n + m)/. Difference with a combining function. Deletes keys if the value is 'Nothing'.
+differenceWithKey1 :: (Ord k) => (k -> v -> w -> Maybe v) -> DeepMap '[k] v -> DeepMap '[k] w -> DeepMap '[k] v
+differenceWithKey1 f = onNest2 (Map.differenceWithKey $ onBare2F . f)
+
+-- | /O(m log(n \/ m + 1)), m <= n/. The set-intersection of the keys in a map,
+--   keeping the values of the left-hand map.
+intersection :: (Ord k) => DeepMap (k ': ks) v -> DeepMap (k ': ls) w -> DeepMap (k ': ks) v
+intersection = onNest2 Map.intersection
+
+-- | /O(m log(n \/ m + 1)), m <= n/. Intersection with a combining function.
+intersectionWith :: (Ord k) => (DeepMap ks v -> DeepMap ls w -> DeepMap ms x) -> DeepMap (k ': ks) v -> DeepMap (k ': ls) w -> DeepMap (k ': ms) x
+intersectionWith f = onNest2 (Map.intersectionWith f)
+
+-- | /O(m log(n \/ m + 1)), m <= n/. Intersection with a combining function.
+intersectionWith1 :: (Ord k) => (v -> w -> x) -> DeepMap '[k] v -> DeepMap '[k] w -> DeepMap '[k] x
+intersectionWith1 f = onNest2 (Map.intersectionWith $ onBare2 f)
+
+-- | /O(m log(n \/ m + 1)), m <= n/. Intersection with a combining function.
+intersectionWithKey :: (Ord k) => (k -> DeepMap ks v -> DeepMap ls w -> DeepMap ms x) -> DeepMap (k ': ks) v -> DeepMap (k ': ls) w -> DeepMap (k ': ms) x
+intersectionWithKey f = onNest2 (Map.intersectionWithKey f)
+
+-- | /O(m log(n \/ m + 1)), m <= n/. Intersection with a combining function.
+intersectionWithKey1 :: (Ord k) => (k -> v -> w -> x) -> DeepMap '[k] v -> DeepMap '[k] w -> DeepMap '[k] x
+intersectionWithKey1 f = onNest2 (Map.intersectionWithKey $ onBare2 . f)
+
+-- | /O(m log(n \/ m + 1)), m <= n/. Intersection with a combining function.
+intersectionWithKey2 :: (Ord k0, Ord k1) => (k0 -> k1 -> v -> w -> x) -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] w -> DeepMap '[k0, k1] x
+intersectionWithKey2 f = intersectionWithKey (intersectionWithKey1 . f)
+
+-- | /O(m log(n \/ m + 1)), m <= n/. Intersection with a combining function.
+intersectionWithKey3 :: (Ord k0, Ord k1, Ord k2) => (k0 -> k1 -> k2 -> v -> w -> x) -> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] w -> DeepMap '[k0, k1, k2] x
+intersectionWithKey3 f = intersectionWithKey (intersectionWithKey2 . f)
+
+-- | /O(m log(n \/ m + 1)), m <= n/. Intersection with a combining function.
+intersectionWithKey4 :: (Ord k0, Ord k1, Ord k2, Ord k3) => (k0 -> k1 -> k2 -> k3 -> v -> w -> x) -> DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] w -> DeepMap '[k0, k1, k2, k3] x
+intersectionWithKey4 f = intersectionWithKey (intersectionWithKey3 . f)
+
+-- | /O(m log(n \/ m + 1)), m <= n/. Intersection with a combining function.
+intersectionWithKey5 :: (Ord k0, Ord k1, Ord k2, Ord k3, Ord k4) => (k0 -> k1 -> k2 -> k3 -> k4 -> v -> w -> x) -> DeepMap '[k0, k1, k2, k3, k4] v -> DeepMap '[k0, k1, k2, k3, k4] w -> DeepMap '[k0, k1, k2, k3, k4] x
+intersectionWithKey5 f = intersectionWithKey (intersectionWithKey4 . f)
+
+-- | /O(n)/. Strictly more general than 'fmap' in that it may change the types of the inner keys.
+mapShallow :: (DeepMap ks v -> DeepMap ls w) -> DeepMap (k ': ks) v -> DeepMap (k ': ls) w
+mapShallow f (Nest m) = Nest $ fmap f m
+
+-- | /O(n)/. Like 'mapShallow' but the function has access to the outer keys.
+mapShallowWithKey :: (k -> DeepMap ks v -> DeepMap ls w) -> DeepMap (k ': ks) v -> DeepMap (k ': ls) w
+mapShallowWithKey f (Nest m) = Nest $ Map.mapWithKey f m
+
+-- | /O(n)/. Like 'fmap' but the function has access to the outer keys.
+mapWithKey1 :: (k -> v -> w) -> DeepMap '[k] v -> DeepMap '[k] w
+mapWithKey1 f (Nest m) = Nest $ Map.mapWithKey (fmap . f) m
+
+-- | /O(n)/. Like 'fmap' but the function has access to the outer keys.
+mapWithKey2 :: (k0 -> k1 -> v -> w) -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] w
+mapWithKey2 f = mapShallowWithKey (mapWithKey1 . f)
+
+-- | /O(n)/. Like 'fmap' but the function has access to the outer keys.
+mapWithKey3 :: (k0 -> k1 -> k2 -> v -> w) -> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] w
+mapWithKey3 f = mapShallowWithKey (mapWithKey2 . f)
+
+-- | /O(n)/. Like 'fmap' but the function has access to the outer keys.
+mapWithKey4 :: (k0 -> k1 -> k2 -> k3 -> v -> w) -> DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] w
+mapWithKey4 f = mapShallowWithKey (mapWithKey3 . f)
+
+-- | /O(n)/. Like 'fmap' but the function has access to the outer keys.
+mapWithKey5 :: (k0 -> k1 -> k2 -> k3 -> k4 -> v -> w) -> DeepMap '[k0, k1, k2, k3, k4] v -> DeepMap '[k0, k1, k2, k3, k4] w
+mapWithKey5 f = mapShallowWithKey (mapWithKey4 . f)
+
+-- | /O(n)/. Strictly more general than 'traverse' in that it may change the types of the inner keys.
+traverseShallow :: (Applicative f) => (DeepMap ks v -> f (DeepMap ls w)) -> DeepMap (k ': ks) v -> f (DeepMap (k ': ls) w)
+traverseShallow f (Nest m) = Nest <$> traverse f m
+
+-- | /O(n)/. Like 'traverseShallow' but the function has access to the keys.
+traverseShallowWithKey :: (Applicative f) => (k -> DeepMap ks v -> f (DeepMap ls w)) -> DeepMap (k ': ks) v -> f (DeepMap (k ': ls) w)
+traverseShallowWithKey f (Nest m) = Nest <$> Map.traverseWithKey f m
+
+-- | /O(n)/. Like 'traverse' but the function has access to the keys.
+traverseWithKey1 :: (Applicative f) => (k -> v -> f w) -> DeepMap '[k] v -> f (DeepMap '[k] w)
+traverseWithKey1 f (Nest m) = Nest <$> Map.traverseWithKey (traverse . f) m
+
+-- | /O(n)/. Like 'traverse' but the function has access to the keys.
+traverseWithKey2 :: (Applicative f) => (k0 -> k1 -> v -> f w) -> DeepMap '[k0, k1] v -> f (DeepMap '[k0, k1] w)
+traverseWithKey2 f = traverseShallowWithKey (traverseWithKey1 . f)
+
+-- | /O(n)/. Like 'traverse' but the function has access to the keys.
+traverseWithKey3 :: (Applicative f) => (k0 -> k1 -> k2 -> v -> f w) -> DeepMap '[k0, k1, k2] v -> f (DeepMap '[k0, k1, k2] w)
+traverseWithKey3 f = traverseShallowWithKey (traverseWithKey2 . f)
+
+-- | /O(n)/. Like 'traverse' but the function has access to the keys.
+traverseWithKey4 :: (Applicative f) => (k0 -> k1 -> k2 -> k3 -> v -> f w) -> DeepMap '[k0, k1, k2, k3] v -> f (DeepMap '[k0, k1, k2, k3] w)
+traverseWithKey4 f = traverseShallowWithKey (traverseWithKey3 . f)
+
+-- | /O(n)/. Like 'traverse' but the function has access to the keys.
+traverseWithKey5 :: (Applicative f) => (k0 -> k1 -> k2 -> k3 -> k4 -> v -> f w) -> DeepMap '[k0, k1, k2, k3, k4] v -> f (DeepMap '[k0, k1, k2, k3, k4] w)
+traverseWithKey5 f = traverseShallowWithKey (traverseWithKey4 . f)
+
+-- | /O(n)/. Traverse keys/submaps and collect the 'Just' results.
+traverseMaybeWithKey :: (Applicative f) => (k -> DeepMap ks v -> f (Maybe (DeepMap ls w))) -> DeepMap (k ': ks) v -> f (DeepMap (k ': ls) w)
+traverseMaybeWithKey f (Nest m) = Nest <$> Map.traverseMaybeWithKey f m
+
+-- | /O(n)/. Traverse keys/values and collect the 'Just' results.
+traverseMaybeWithKey1 :: (Applicative f) => (k -> v -> f (Maybe w)) -> DeepMap '[k] v -> f (DeepMap '[k] w)
+traverseMaybeWithKey1 f (Nest m) = Nest <$> Map.traverseMaybeWithKey (\k (Bare v) -> fmap Bare <$> f k v) m
+
+-- | /O(n)/. Traverse keys/values and collect the 'Just' results.
+traverseMaybeWithKey2 :: (Applicative f) => (k0 -> k1 -> v -> f (Maybe w)) -> DeepMap '[k0, k1] v -> f (DeepMap '[k0, k1] w)
+traverseMaybeWithKey2 f = traverseMaybeWithKey (fmap (fmap Just) . traverseMaybeWithKey1 . f)
+
+-- | /O(n)/. Traverse keys/values and collect the 'Just' results.
+traverseMaybeWithKey3 :: (Applicative f) => (k0 -> k1 -> k2 -> v -> f (Maybe w)) -> DeepMap '[k0, k1, k2] v -> f (DeepMap '[k0, k1, k2] w)
+traverseMaybeWithKey3 f = traverseMaybeWithKey (fmap (fmap Just) . traverseMaybeWithKey2 . f)
+
+-- | /O(n)/. Traverse keys/values and collect the 'Just' results.
+traverseMaybeWithKey4 :: (Applicative f) => (k0 -> k1 -> k2 -> k3 -> v -> f (Maybe w)) -> DeepMap '[k0, k1, k2, k3] v -> f (DeepMap '[k0, k1, k2, k3] w)
+traverseMaybeWithKey4 f = traverseMaybeWithKey (fmap (fmap Just) . traverseMaybeWithKey3 . f)
+
+-- | /O(n)/. Traverse keys/values and collect the 'Just' results.
+traverseMaybeWithKey5 :: (Applicative f) => (k0 -> k1 -> k2 -> k3 -> k4 -> v -> f (Maybe w)) -> DeepMap '[k0, k1, k2, k3, k4] v -> f (DeepMap '[k0, k1, k2, k3, k4] w)
+traverseMaybeWithKey5 f = traverseMaybeWithKey (fmap (fmap Just) . traverseMaybeWithKey4 . f)
+
+-- | /O(n)/. Thread an accumulating argument through the 'DeepMap' in ascending order of keys.
+mapAccum :: (acc -> DeepMap ks v -> (acc, DeepMap ls w)) -> acc -> DeepMap (k ': ks) v -> (acc, DeepMap (k ': ls) w)
+mapAccum f acc (Nest m) = Nest <$> Map.mapAccum f acc m
+
+-- | /O(n)/. Thread an accumulating argument through the 'DeepMap' in ascending order of keys.
+mapAccum1 :: (acc -> v -> (acc, w)) -> acc -> DeepMap '[k] v -> (acc, DeepMap '[k] w)
+mapAccum1 f = mapAccum (\a (Bare v) -> Bare <$> f a v)
+
+-- | /O(n)/. Thread an accumulating argument through the 'DeepMap' in descending order of keys.
+mapAccumR :: (acc -> DeepMap ks v -> (acc, DeepMap ls w)) -> acc -> DeepMap (k ': ks) v -> (acc, DeepMap (k ': ls) w)
+mapAccumR f acc (Nest m) = Nest <$> Map.mapAccum f acc m
+
+-- | /O(n)/. Thread an accumulating argument through the 'DeepMap' in descending order of keys.
+mapAccumR1 :: (acc -> v -> (acc, w)) -> acc -> DeepMap '[k] v -> (acc, DeepMap '[k] w)
+mapAccumR1 f = mapAccumR (\a (Bare v) -> Bare <$> f a v)
+
+-- | /O(n)/. Like 'mapAccum' but the function has access to the keys.
+mapAccumWithKey :: (acc -> k -> DeepMap ks v -> (acc, DeepMap ls w)) -> acc -> DeepMap (k ': ks) v -> (acc, DeepMap (k ': ls) w)
+mapAccumWithKey f acc (Nest m) = Nest <$> Map.mapAccumWithKey f acc m
+
+-- | /O(n)/. Like 'mapAccum' but the function has access to the keys.
+mapAccumWithKey1 :: (acc -> k -> v -> (acc, w)) -> acc -> DeepMap '[k] v -> (acc, DeepMap '[k] w)
+mapAccumWithKey1 f = mapAccumWithKey (\k a (Bare v) -> Bare <$> f k a v)
+
+-- | /O(n)/. Like 'mapAccum' but the function has access to the keys.
+mapAccumWithKey2 :: (acc -> k0 -> k1 -> v -> (acc, w)) -> acc -> DeepMap '[k0, k1] v -> (acc, DeepMap '[k0, k1] w)
+mapAccumWithKey2 f = mapAccumWithKey (\a k0 -> mapAccumWithKey1 (`f` k0) a)
+
+-- | /O(n)/. Like 'mapAccum' but the function has access to the keys.
+mapAccumWithKey3 :: (acc -> k0 -> k1 -> k2 -> v -> (acc, w)) -> acc -> DeepMap '[k0, k1, k2] v -> (acc, DeepMap '[k0, k1, k2] w)
+mapAccumWithKey3 f = mapAccumWithKey (\a k0 -> mapAccumWithKey2 (`f` k0) a)
+
+-- | /O(n)/. Like 'mapAccum' but the function has access to the keys.
+mapAccumWithKey4 :: (acc -> k0 -> k1 -> k2 -> k3 -> v -> (acc, w)) -> acc -> DeepMap '[k0, k1, k2, k3] v -> (acc, DeepMap '[k0, k1, k2, k3] w)
+mapAccumWithKey4 f = mapAccumWithKey (\a k0 -> mapAccumWithKey3 (`f` k0) a)
+
+-- | /O(n)/. Like 'mapAccum' but the function has access to the keys.
+mapAccumWithKey5 :: (acc -> k0 -> k1 -> k2 -> k3 -> k4 -> v -> (acc, w)) -> acc -> DeepMap '[k0, k1, k2, k3, k4] v -> (acc, DeepMap '[k0, k1, k2, k3, k4] w)
+mapAccumWithKey5 f = mapAccumWithKey (\a k0 -> mapAccumWithKey4 (`f` k0) a)
+
+-- | /O(n)/. Like 'mapAccumR' but the function has access to the keys.
+mapAccumRWithKey :: (acc -> k -> DeepMap ks v -> (acc, DeepMap ls w)) -> acc -> DeepMap (k ': ks) v -> (acc, DeepMap (k ': ls) w)
+mapAccumRWithKey f acc (Nest m) = Nest <$> Map.mapAccumRWithKey f acc m
+
+-- | /O(n)/. Like 'mapAccumR' but the function has access to the keys.
+mapAccumRWithKey1 :: (acc -> k -> v -> (acc, w)) -> acc -> DeepMap '[k] v -> (acc, DeepMap '[k] w)
+mapAccumRWithKey1 f = mapAccumRWithKey (\k a (Bare v) -> Bare <$> f k a v)
+
+-- | /O(n)/. Like 'mapAccumR' but the function has access to the keys.
+mapAccumRWithKey2 :: (acc -> k0 -> k1 -> v -> (acc, w)) -> acc -> DeepMap '[k0, k1] v -> (acc, DeepMap '[k0, k1] w)
+mapAccumRWithKey2 f = mapAccumRWithKey (\a k0 -> mapAccumRWithKey1 (`f` k0) a)
+
+-- | /O(n)/. Like 'mapAccumR' but the function has access to the keys.
+mapAccumRWithKey3 :: (acc -> k0 -> k1 -> k2 -> v -> (acc, w)) -> acc -> DeepMap '[k0, k1, k2] v -> (acc, DeepMap '[k0, k1, k2] w)
+mapAccumRWithKey3 f = mapAccumRWithKey (\a k0 -> mapAccumRWithKey2 (`f` k0) a)
+
+-- | /O(n)/. Like 'mapAccumR' but the function has access to the keys.
+mapAccumRWithKey4 :: (acc -> k0 -> k1 -> k2 -> k3 -> v -> (acc, w)) -> acc -> DeepMap '[k0, k1, k2, k3] v -> (acc, DeepMap '[k0, k1, k2, k3] w)
+mapAccumRWithKey4 f = mapAccumRWithKey (\a k0 -> mapAccumRWithKey3 (`f` k0) a)
+
+-- | /O(n)/. Like 'mapAccumR' but the function has access to the keys.
+mapAccumRWithKey5 :: (acc -> k0 -> k1 -> k2 -> k3 -> k4 -> v -> (acc, w)) -> acc -> DeepMap '[k0, k1, k2, k3, k4] v -> (acc, DeepMap '[k0, k1, k2, k3, k4] w)
+mapAccumRWithKey5 f = mapAccumRWithKey (\a k0 -> mapAccumRWithKey4 (`f` k0) a)
+
+-- | /O(n log n)/. Map a function over the outer keys of a 'DeepMap'.
+--   If the function maps two or more @j@-keys to the same @k@-key,
+--   the values of the @j@-keys are combined with '(<>)'.
+--
+--   To retain 'Data.Map'\'s greatest-biased functionality, use @'mapKeysWith' 'const'@.
+mapKeys :: (Ord k, Semigroup (DeepMap ks v)) => (j -> k) -> DeepMap (j ': ks) v -> DeepMap (k ': ks) v
+mapKeys f (Nest m) = Nest $ Map.mapKeysWith (<>) f m
+
+-- | /O(n log n)/. Map a function over the keys of a 'DeepMap'.
+mapKeys1 :: (Ord k, Semigroup v) => (j -> k) -> DeepMap '[j] v -> DeepMap '[k] v
+mapKeys1 = mapKeys
+
+-- | /O(n log n)/. Map a function over the keys of a 'DeepMap'.
+mapKeys2 :: (Ord k0, Ord k1, Semigroup (DeepMap ks v)) => (j0 -> k0) -> (j1 -> k1) -> DeepMap (j0 ': j1 ': ks) v -> DeepMap (k0 ': k1 ': ks) v
+mapKeys2 f0 f1 m = mapKeys f0 $ mapShallow (mapKeys f1) m
+
+-- | /O(n log n)/. Map a function over the keys of a 'DeepMap'.
+mapKeys3 :: (Ord k0, Ord k1, Ord k2, Semigroup (DeepMap ks v)) => (j0 -> k0) -> (j1 -> k1) -> (j2 -> k2) -> DeepMap (j0 ': j1 ': j2 ': ks) v -> DeepMap (k0 ': k1 ': k2 ': ks) v
+mapKeys3 f0 f1 f2 m = mapKeys f0 $ mapShallow (mapKeys2 f1 f2) m
+
+-- | /O(n log n)/. Map a function over the keys of a 'DeepMap'.
+mapKeys4 :: (Ord k0, Ord k1, Ord k2, Ord k3, Semigroup (DeepMap ks v)) => (j0 -> k0) -> (j1 -> k1) -> (j2 -> k2) -> (j3 -> k3) -> DeepMap (j0 ': j1 ': j2 ': j3 ': ks) v -> DeepMap (k0 ': k1 ': k2 ': k3 ': ks) v
+mapKeys4 f0 f1 f2 f3 m = mapKeys f0 $ mapShallow (mapKeys3 f1 f2 f3) m
+
+-- | /O(n log n)/. Map a function over the keys of a 'DeepMap'.
+mapKeys5 :: (Ord k0, Ord k1, Ord k2, Ord k3, Ord k4, Semigroup (DeepMap ks v)) => (j0 -> k0) -> (j1 -> k1) -> (j2 -> k2) -> (j3 -> k3) -> (j4 -> k4) -> DeepMap (j0 ': j1 ': j2 ': j3 ': j4 ': ks) v -> DeepMap (k0 ': k1 ': k2 ': k3 ': k4 ': ks) v
+mapKeys5 f0 f1 f2 f3 f4 m = mapKeys f0 $ mapShallow (mapKeys4 f1 f2 f3 f4) m
+
+-- | /O(n log n)/. Map a function over the outer keys of a 'DeepMap' with a combining function.
+mapKeysWith :: (Ord k) => (DeepMap ks v -> DeepMap ks v -> DeepMap ks v) -> (j -> k) -> DeepMap (j ': ks) v -> DeepMap (k ': ks) v
+mapKeysWith (~~) f (Nest m) = Nest $ Map.mapKeysWith (~~) f m
+
+-- | /O(n log n)/. Map a function over the keys of a 'DeepMap' with a value-combining function.
+mapKeysWith1 :: (Ord k) => (v -> v -> v) -> (j -> k) -> DeepMap '[j] v -> DeepMap '[k] v
+mapKeysWith1 (~~) = mapKeysWith (onBare2 (~~))
+
+-- | /O(n log n)/. Map a function over the keys of a 'DeepMap' with a value-combining function.
+mapKeysWith2 :: (Ord k0, Ord k1) => (v -> v -> v) -> (j0 -> k0) -> (j1 -> k1) -> DeepMap '[j0, j1] v -> DeepMap '[k0, k1] v
+mapKeysWith2 (~~) f0 f1 m = mapKeysWith (unionWith1 (~~)) f0 $ mapShallow (mapKeysWith1 (~~) f1) m
+
+-- | /O(n log n)/. Map a function over the keys of a 'DeepMap' with a value-combining function.
+mapKeysWith3 :: (Ord k0, Ord k1, Ord k2) => (v -> v -> v) -> (j0 -> k0) -> (j1 -> k1) -> (j2 -> k2) -> DeepMap '[j0, j1, j2] v -> DeepMap '[k0, k1, k2] v
+mapKeysWith3 (~~) f0 f1 f2 m = mapKeysWith (unionWith2 (~~)) f0 $ mapShallow (mapKeysWith2 (~~) f1 f2) m
+
+-- | /O(n log n)/. Map a function over the keys of a 'DeepMap' with a value-combining function.
+mapKeysWith4 :: (Ord k0, Ord k1, Ord k2, Ord k3) => (v -> v -> v) -> (j0 -> k0) -> (j1 -> k1) -> (j2 -> k2) -> (j3 -> k3) -> DeepMap '[j0, j1, j2, j3] v -> DeepMap '[k0, k1, k2, k3] v
+mapKeysWith4 (~~) f0 f1 f2 f3 m = mapKeysWith (unionWith3 (~~)) f0 $ mapShallow (mapKeysWith3 (~~) f1 f2 f3) m
+
+-- | /O(n log n)/. Map a function over the keys of a 'DeepMap' with a value-combining function.
+mapKeysWith5 :: (Ord k0, Ord k1, Ord k2, Ord k3, Ord k4) => (v -> v -> v) -> (j0 -> k0) -> (j1 -> k1) -> (j2 -> k2) -> (j3 -> k3) -> (j4 -> k4) -> DeepMap '[j0, j1, j2, j3, j4] v -> DeepMap '[k0, k1, k2, k3, k4] v
+mapKeysWith5 (~~) f0 f1 f2 f3 f4 m = mapKeysWith (unionWith4 (~~)) f0 $ mapShallow (mapKeysWith4 (~~) f1 f2 f3 f4) m
+
+-- | /O(n log n)/. Map an applicative function over the outer keys and collect the results.
+traverseKeys :: (Applicative f, Ord k, Semigroup (DeepMap ks v)) => (j -> f k) -> DeepMap (j ': ks) v -> f (DeepMap (k ': ks) v)
+traverseKeys f (Nest m) = Nest <$> traverseKeysMap f m
+  where
+    traverseKeysMap :: (Applicative f, Ord k) => (j -> f k) -> Map j a -> f (Map k a)
+    traverseKeysMap f0 = fmap Map.fromList . traverse (\(j, a) -> (,a) <$> f0 j) . Map.assocs
+
+-- | /O(n log n)/. Map an applicative function over the outer keys of the map
+--   and collect the results using the specified combining function.
+traverseKeysWith :: (Applicative f, Ord k) => (DeepMap ks v -> DeepMap ks v -> DeepMap ks v) -> (j -> f k) -> DeepMap (j ': ks) v -> f (DeepMap (k ': ks) v)
+traverseKeysWith (~~) f (Nest m) = Nest <$> traverseKeysWithMap (~~) f m
+  where
+    traverseKeysWithMap :: (Applicative f, Ord k) => (a -> a -> a) -> (j -> f k) -> Map j a -> f (Map k a)
+    traverseKeysWithMap c f0 = fmap (Map.fromListWith c) . traverse (\(j, a) -> (,a) <$> f0 j) . Map.assocs
+
+-- | /O(n log n)/. Map a monadic function over the keys of a 'DeepMap' and collect the results.
+mapKeysM :: (Monad m, Ord k, Semigroup (DeepMap ks v)) => (j -> m k) -> DeepMap (j ': ks) v -> m (DeepMap (k ': ks) v)
+mapKeysM = traverseKeys
+
+-- | /O(n log n)/. Map a monadic function over the keys of a 'DeepMap' and collect the results.
+mapKeysM1 :: (Monad m, Ord k, Semigroup (DeepMap ks v)) => (j -> m k) -> DeepMap (j ': ks) v -> m (DeepMap (k ': ks) v)
+mapKeysM1 = mapKeysM
+
+-- | /O(n log n)/. Map a monadic function over the keys of a 'DeepMap' and collect the results.
+--
+-- Sadly @traverseKeys2@ can't have this type signature because we'd end up with a twice-wrapped 'Applicative' and no way out.
+mapKeysM2 :: (Monad m, Ord k0, Ord k1, Semigroup (DeepMap ks v)) => (j0 -> m k0) -> (j1 -> m k1) -> DeepMap (j0 ': j1 ': ks) v -> m (DeepMap (k0 ': k1 ': ks) v)
+mapKeysM2 f0 f1 m = mapKeysM f0 =<< traverseShallow (mapKeysM1 f1) m
+
+-- | /O(n log n)/. Map a monadic function over the keys of a 'DeepMap' and collect the results.
+mapKeysM3 :: (Monad m, Ord k0, Ord k1, Ord k2, Semigroup (DeepMap ks v)) => (j0 -> m k0) -> (j1 -> m k1) -> (j2 -> m k2) -> DeepMap (j0 ': j1 ': j2 ': ks) v -> m (DeepMap (k0 ': k1 ': k2 ': ks) v)
+mapKeysM3 f0 f1 f2 m = mapKeysM f0 =<< traverseShallow (mapKeysM2 f1 f2) m
+
+-- | /O(n log n)/. Map a monadic function over the keys of a 'DeepMap' and collect the results.
+mapKeysM4 :: (Monad m, Ord k0, Ord k1, Ord k2, Ord k3, Semigroup (DeepMap ks v)) => (j0 -> m k0) -> (j1 -> m k1) -> (j2 -> m k2) -> (j3 -> m k3) -> DeepMap (j0 ': j1 ': j2 ': j3 ': ks) v -> m (DeepMap (k0 ': k1 ': k2 ': k3 ': ks) v)
+mapKeysM4 f0 f1 f2 f3 m = mapKeysM f0 =<< traverseShallow (mapKeysM3 f1 f2 f3) m
+
+-- | /O(n log n)/. Map a monadic function over the keys of a 'DeepMap' and collect the results.
+mapKeysM5 :: (Monad m, Ord k0, Ord k1, Ord k2, Ord k3, Ord k4, Semigroup (DeepMap ks v)) => (j0 -> m k0) -> (j1 -> m k1) -> (j2 -> m k2) -> (j3 -> m k3) -> (j4 -> m k4) -> DeepMap (j0 ': j1 ': j2 ': j3 ': j4 ': ks) v -> m (DeepMap (k0 ': k1 ': k2 ': k3 ': k4 ': ks) v)
+mapKeysM5 f0 f1 f2 f3 f4 m = mapKeysM f0 =<< traverseShallow (mapKeysM4 f1 f2 f3 f4) m
+
+-- | /O(n log n)/. Map a monadic function over the outer keys of a 'DeepMap' with a submap-combining function.
+mapKeysMWith :: (Monad m, Ord k) => (DeepMap ks v -> DeepMap ks v -> DeepMap ks v) -> (j -> m k) -> DeepMap (j ': ks) v -> m (DeepMap (k ': ks) v)
+mapKeysMWith = traverseKeysWith
+
+-- | /O(n log n)/. Map a monadic function over the keys of a 'DeepMap' with a value-combining function.
+mapKeysMWith1 :: (Monad m, Ord k) => (v -> v -> v) -> (j -> m k) -> DeepMap '[j] v -> m (DeepMap '[k] v)
+mapKeysMWith1 (~~) = mapKeysMWith (onBare2 (~~))
+
+-- | /O(n log n)/. Map a monadic function over the keys of a 'DeepMap' with a value-combining function.
+mapKeysMWith2 :: (Monad m, Ord k0, Ord k1) => (v -> v -> v) -> (j0 -> m k0) -> (j1 -> m k1) -> DeepMap '[j0, j1] v -> m (DeepMap '[k0, k1] v)
+mapKeysMWith2 (~~) f0 f1 m = mapKeysMWith (unionWith1 (~~)) f0 =<< traverseShallow (mapKeysMWith1 (~~) f1) m
+
+-- | /O(n log n)/. Map a monadic function over the keys of a 'DeepMap' with a value-combining function.
+mapKeysMWith3 :: (Monad m, Ord k0, Ord k1, Ord k2) => (v -> v -> v) -> (j0 -> m k0) -> (j1 -> m k1) -> (j2 -> m k2) -> DeepMap '[j0, j1, j2] v -> m (DeepMap '[k0, k1, k2] v)
+mapKeysMWith3 (~~) f0 f1 f2 m = mapKeysMWith (unionWith2 (~~)) f0 =<< traverseShallow (mapKeysMWith2 (~~) f1 f2) m
+
+-- | /O(n log n)/. Map a monadic function over the keys of a 'DeepMap' with a value-combining function.
+mapKeysMWith4 :: (Monad m, Ord k0, Ord k1, Ord k2, Ord k3) => (v -> v -> v) -> (j0 -> m k0) -> (j1 -> m k1) -> (j2 -> m k2) -> (j3 -> m k3) -> DeepMap '[j0, j1, j2, j3] v -> m (DeepMap '[k0, k1, k2, k3] v)
+mapKeysMWith4 (~~) f0 f1 f2 f3 m = mapKeysMWith (unionWith3 (~~)) f0 =<< traverseShallow (mapKeysMWith3 (~~) f1 f2 f3) m
+
+-- | /O(n log n)/. Map a monadic function over the keys of a 'DeepMap' with a value-combining function.
+mapKeysMWith5 :: (Monad m, Ord k0, Ord k1, Ord k2, Ord k3, Ord k4) => (v -> v -> v) -> (j0 -> m k0) -> (j1 -> m k1) -> (j2 -> m k2) -> (j3 -> m k3) -> (j4 -> m k4) -> DeepMap '[j0, j1, j2, j3, j4] v -> m (DeepMap '[k0, k1, k2, k3, k4] v)
+mapKeysMWith5 (~~) f0 f1 f2 f3 f4 m = mapKeysMWith (unionWith4 (~~)) f0 =<< traverseShallow (mapKeysMWith4 (~~) f1 f2 f3 f4) m
+
+foldShallow :: (Monoid (DeepMap ks v)) => DeepMap (k ': ks) v -> DeepMap ks v
+foldShallow (Nest m) = fold m
+
+-- | /O(n)/. Fold the keys and submaps in the 'DeepMap' using the given right-associative binary operator.
+foldrWithKey :: (k -> DeepMap ks v -> b -> b) -> b -> DeepMap (k ': ks) v -> b
+foldrWithKey f z (Nest m) = Map.foldrWithKey f z m
+
+-- | /O(n)/. Fold the keys and values using the given right-associative binary operator.
+foldrWithKey1 :: (k -> v -> b -> b) -> b -> DeepMap '[k] v -> b
+foldrWithKey1 f = foldrWithKey (\k (Bare v) -> f k v)
+
+-- | /O(n)/. Fold the keys and values using the given right-associative binary operator.
+foldrWithKey2 :: (k0 -> k1 -> v -> b -> b) -> b -> DeepMap '[k0, k1] v -> b
+foldrWithKey2 f = foldrWithKey (\k0 dm b -> foldrWithKey1 (f k0) b dm)
+
+-- | /O(n)/. Fold the keys and values using the given right-associative binary operator.
+foldrWithKey3 :: (k0 -> k1 -> k2 -> v -> b -> b) -> b -> DeepMap '[k0, k1, k2] v -> b
+foldrWithKey3 f = foldrWithKey (\k0 dm b -> foldrWithKey2 (f k0) b dm)
+
+-- | /O(n)/. Fold the keys and values using the given right-associative binary operator.
+foldrWithKey4 :: (k0 -> k1 -> k2 -> k3 -> v -> b -> b) -> b -> DeepMap '[k0, k1, k2, k3] v -> b
+foldrWithKey4 f = foldrWithKey (\k0 dm b -> foldrWithKey3 (f k0) b dm)
+
+-- | /O(n)/. Fold the keys and values using the given right-associative binary operator.
+foldrWithKey5 :: (k0 -> k1 -> k2 -> k3 -> k3 -> v -> b -> b) -> b -> DeepMap '[k0, k1, k2, k3, k3] v -> b
+foldrWithKey5 f = foldrWithKey (\k0 dm b -> foldrWithKey4 (f k0) b dm)
+
+-- | /O(n)/. Fold the keys and submaps in the 'DeepMap' using the given left-associative binary operator.
+foldlWithKey :: (b -> k -> DeepMap ks v -> b) -> b -> DeepMap (k ': ks) v -> b
+foldlWithKey f z (Nest m) = Map.foldlWithKey f z m
+
+-- | /O(n)/. Fold the keys and values in the 'DeepMap' using the given left-associative binary operator.
+foldlWithKey1 :: (b -> k -> v -> b) -> b -> DeepMap '[k] v -> b
+foldlWithKey1 f = foldlWithKey (\b k (Bare v) -> f b k v)
+
+-- | /O(n)/. Fold the keys and values in the 'DeepMap' using the given left-associative binary operator.
+foldlWithKey2 :: (b -> k0 -> k1 -> v -> b) -> b -> DeepMap '[k0, k1] v -> b
+foldlWithKey2 f = foldlWithKey (\b k0 -> foldlWithKey1 (`f` k0) b)
+
+-- | /O(n)/. Fold the keys and values in the 'DeepMap' using the given left-associative binary operator.
+foldlWithKey3 :: (b -> k0 -> k1 -> k2 -> v -> b) -> b -> DeepMap '[k0, k1, k2] v -> b
+foldlWithKey3 f = foldlWithKey (\b k0 -> foldlWithKey2 (`f` k0) b)
+
+-- | /O(n)/. Fold the keys and values in the 'DeepMap' using the given left-associative binary operator.
+foldlWithKey4 :: (b -> k0 -> k1 -> k2 -> k3 -> v -> b) -> b -> DeepMap '[k0, k1, k2, k3] v -> b
+foldlWithKey4 f = foldlWithKey (\b k0 -> foldlWithKey3 (`f` k0) b)
+
+-- | /O(n)/. Strictly fold the keys and values in the 'DeepMap' using the given left-associative binary operator.
+foldlWithKey5 :: (b -> k0 -> k1 -> k2 -> k3 -> k4 -> v -> b) -> b -> DeepMap '[k0, k1, k2, k3, k4] v -> b
+foldlWithKey5 f = foldlWithKey (\b k0 -> foldlWithKey4 (`f` k0) b)
+
+-- | /O(n)/. Strictly fold the keys and submaps in the 'DeepMap' using the given right-associative binary operator.
+foldrWithKey' :: (k -> DeepMap ks v -> b -> b) -> b -> DeepMap (k ': ks) v -> b
+foldrWithKey' f z (Nest m) = Map.foldrWithKey' f z m
+
+-- | /O(n)/. Strictly fold the keys and values using the given right-associative binary operator.
+foldrWithKey1' :: (k -> v -> b -> b) -> b -> DeepMap '[k] v -> b
+foldrWithKey1' f = foldrWithKey' (\k (Bare v) -> f k v)
+
+-- | /O(n)/. Strictly fold the keys and values using the given right-associative binary operator.
+foldrWithKey2' :: (k0 -> k1 -> v -> b -> b) -> b -> DeepMap '[k0, k1] v -> b
+foldrWithKey2' f = foldrWithKey' (\k0 dm b -> foldrWithKey1' (f k0) b dm)
+
+-- | /O(n)/. Strictly fold the keys and values using the given right-associative binary operator.
+foldrWithKey3' :: (k0 -> k1 -> k2 -> v -> b -> b) -> b -> DeepMap '[k0, k1, k2] v -> b
+foldrWithKey3' f = foldrWithKey' (\k0 dm b -> foldrWithKey2' (f k0) b dm)
+
+-- | /O(n)/. Strictly fold the keys and values using the given right-associative binary operator.
+foldrWithKey4' :: (k0 -> k1 -> k2 -> k3 -> v -> b -> b) -> b -> DeepMap '[k0, k1, k2, k3] v -> b
+foldrWithKey4' f = foldrWithKey' (\k0 dm b -> foldrWithKey3' (f k0) b dm)
+
+-- | /O(n)/. Strictly fold the keys and values using the given right-associative binary operator.
+foldrWithKey5' :: (k0 -> k1 -> k2 -> k3 -> k3 -> v -> b -> b) -> b -> DeepMap '[k0, k1, k2, k3, k3] v -> b
+foldrWithKey5' f = foldrWithKey' (\k0 dm b -> foldrWithKey4' (f k0) b dm)
+
+-- | /O(n)/. Strictly fold the keys and submaps in the 'DeepMap' using the given left-associative binary operator.
+foldlWithKey' :: (b -> k -> DeepMap ks v -> b) -> b -> DeepMap (k ': ks) v -> b
+foldlWithKey' f z (Nest m) = Map.foldlWithKey' f z m
+
+-- | /O(n)/. Strictly fold the keys and values in the 'DeepMap' using the given left-associative binary operator.
+foldlWithKey1' :: (b -> k -> v -> b) -> b -> DeepMap '[k] v -> b
+foldlWithKey1' f = foldlWithKey' (\b k (Bare v) -> f b k v)
+
+-- | /O(n)/. Strictly fold the keys and values in the 'DeepMap' using the given left-associative binary operator.
+foldlWithKey2' :: (b -> k0 -> k1 -> v -> b) -> b -> DeepMap '[k0, k1] v -> b
+foldlWithKey2' f = foldlWithKey' (\b k0 -> foldlWithKey1' (`f` k0) b)
+
+-- | /O(n)/. Strictly fold the keys and values in the 'DeepMap' using the given left-associative binary operator.
+foldlWithKey3' :: (b -> k0 -> k1 -> k2 -> v -> b) -> b -> DeepMap '[k0, k1, k2] v -> b
+foldlWithKey3' f = foldlWithKey (\b k0 -> foldlWithKey2' (`f` k0) b)
+
+-- | /O(n)/. Strictly fold the keys and values in the 'DeepMap' using the given left-associative binary operator.
+foldlWithKey4' :: (b -> k0 -> k1 -> k2 -> k3 -> v -> b) -> b -> DeepMap '[k0, k1, k2, k3] v -> b
+foldlWithKey4' f = foldlWithKey' (\b k0 -> foldlWithKey3' (`f` k0) b)
+
+-- | /O(n)/. Fold the keys and values in the 'DeepMap' using the given left-associative binary operator.
+foldlWithKey5' :: (b -> k0 -> k1 -> k2 -> k3 -> k4 -> v -> b) -> b -> DeepMap '[k0, k1, k2, k3, k4] v -> b
+foldlWithKey5' f = foldlWithKey' (\b k0 -> foldlWithKey4' (`f` k0) b)
+
+-- | /O(n)/. Fold the keys and submaps using the given monoid.
+foldMapWithKey :: (Monoid m) => (k -> DeepMap ks v -> m) -> DeepMap (k ': ks) v -> m
+foldMapWithKey f (Nest m) = Map.foldMapWithKey f m
+
+-- | /O(n)/. Fold the keys and values in the map using the given monoid.
+foldMapWithKey1 :: (Monoid m) => (k -> v -> m) -> DeepMap '[k] v -> m
+foldMapWithKey1 f = foldMapWithKey (\k (Bare v) -> f k v)
+
+-- | /O(n)/. Fold the keys and values in the map using the given monoid.
+foldMapWithKey2 :: (Monoid m) => (k0 -> k1 -> v -> m) -> DeepMap '[k0, k1] v -> m
+foldMapWithKey2 f = foldMapWithKey (foldMapWithKey1 . f)
+
+-- | /O(n)/. Fold the keys and values in the map using the given monoid.
+foldMapWithKey3 :: (Monoid m) => (k0 -> k1 -> k2 -> v -> m) -> DeepMap '[k0, k1, k2] v -> m
+foldMapWithKey3 f = foldMapWithKey (foldMapWithKey2 . f)
+
+-- | /O(n)/. Fold the keys and values in the map using the given monoid.
+foldMapWithKey4 :: (Monoid m) => (k0 -> k1 -> k2 -> k3 -> v -> m) -> DeepMap '[k0, k1, k2, k3] v -> m
+foldMapWithKey4 f = foldMapWithKey (foldMapWithKey3 . f)
+
+-- | /O(n)/. Fold the keys and values in the map using the given monoid.
+foldMapWithKey5 :: (Monoid m) => (k0 -> k1 -> k2 -> k3 -> k4 -> v -> m) -> DeepMap '[k0, k1, k2, k3, k4] v -> m
+foldMapWithKey5 f = foldMapWithKey (foldMapWithKey4 . f)
+
+-- | /O(n)/. Convert the map to a list of key/submap pairs where the keys are in ascending order.
+--   Subject to list fusion.
+toAscList :: DeepMap (k ': ks) v -> [(k, DeepMap ks v)]
+toAscList (Nest m) = Map.toAscList m
+
+-- | /O(n)/. Convert the map to a list of key/submap pairs where the keys are in descending order.
+--   Subject to list fusion.
+toDescList :: DeepMap (k ': ks) v -> [(k, DeepMap ks v)]
+toDescList (Nest m) = Map.toDescList m
+
+-- | /O(n)/. Filter all submaps that satisfy the predicate.
+filter :: (DeepMap ks v -> Bool) -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v
+filter p (Nest m) = Nest $ Map.filter p m
+
+-- | /O(n)/. Filter all values that satisfy the predicate.
+filter1 :: (v -> Bool) -> DeepMap '[k] v -> DeepMap '[k] v
+filter1 p (Nest m) = Nest $ Map.filter (p . getBare) m
+
+-- | /O(n)/. Filter all values that satisfy the predicate.
+filter2 :: (v -> Bool) -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
+filter2 p m = mapShallow (filter1 p) $ filter (any p) m
+
+-- | /O(n)/. Filter all values that satisfy the predicate.
+filter3 :: (v -> Bool) -> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v
+filter3 p m = mapShallow (filter2 p) $ filter (any p) m
+
+-- | /O(n)/. Filter all values that satisfy the predicate.
+filter4 :: (v -> Bool) -> DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] v
+filter4 p m = mapShallow (filter3 p) $ filter (any p) m
+
+-- | /O(n)/. Filter all values that satisfy the predicate.
+filter5 :: (v -> Bool) -> DeepMap '[k0, k1, k2, k3, k4] v -> DeepMap '[k0, k1, k2, k3, k4] v
+filter5 p m = mapShallow (filter4 p) $ filter (any p) m
+
+-- | /O(n)/. Filter all key/submap pairs that satisfy the predicate.
+filterWithKey :: (k -> DeepMap ks v -> Bool) -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v
+filterWithKey p (Nest m) = Nest $ Map.filterWithKey p m
+
+-- | /O(n)/. Filter all key/value pairs that satisfy the predicate.
+filterWithKey1 :: (k -> v -> Bool) -> DeepMap '[k] v -> DeepMap '[k] v
+filterWithKey1 p m = runIdentity $ traverseMaybeWithKey1 (\k0 -> Identity . (bool (const Nothing) Just =<< p k0)) m
+
+-- | /O(n)/. Filter all key-chain/value pairs that satisfy the predicate.
+filterWithKey2 :: (k0 -> k1 -> v -> Bool) -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] v
+filterWithKey2 p m = runIdentity $ traverseMaybeWithKey2 (\k0 k1 -> Identity . (bool (const Nothing) Just =<< p k0 k1)) m
+
+-- | /O(n)/. Filter all key-chain/value pairs that satisfy the predicate.
+filterWithKey3 :: (k0 -> k1 -> k2 -> v -> Bool) -> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] v
+filterWithKey3 p m = runIdentity $ traverseMaybeWithKey3 (\k0 k1 k2 -> Identity . (bool (const Nothing) Just =<< p k0 k1 k2)) m
+
+-- | /O(n)/. Filter all key-chain/value pairs that satisfy the predicate.
+filterWithKey4 :: (k0 -> k1 -> k2 -> k3 -> v -> Bool) -> DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] v
+filterWithKey4 p m = runIdentity $ traverseMaybeWithKey4 (\k0 k1 k2 k3 -> Identity . (bool (const Nothing) Just =<< p k0 k1 k2 k3)) m
+
+-- | /O(n)/. Filter all key-chain/value pairs that satisfy the predicate.
+filterWithKey5 :: (k0 -> k1 -> k2 -> k3 -> k4 -> v -> Bool) -> DeepMap '[k0, k1, k2, k3, k4] v -> DeepMap '[k0, k1, k2, k3, k4] v
+filterWithKey5 p m = runIdentity $ traverseMaybeWithKey5 (\k0 k1 k2 k3 k4 -> Identity . (bool (const Nothing) Just =<< p k0 k1 k2 k3 k4)) m
+
+-- | /O(m log(n \/ m + 1)), m <= n/. Restrict a 'Map' to only the keys in a given 'Set'.
+restrictKeys :: (Ord k) => DeepMap (k ': ks) v -> Set k -> DeepMap (k ': ks) v
+restrictKeys (Nest m) s = Nest $ Map.restrictKeys m s
+
+-- | /O(m log(n \/ m + 1)), m <= n/. Restrict a 'Map' to only the keys in a given 'Set'.
+restrictKeys2 :: (Ord k0, Ord k1) => DeepMap (k0 ': k1 ': ks) v -> Set (k0, k1) -> DeepMap (k0 ': k1 ': ks) v
+restrictKeys2 m s = mapShallow (\dm -> restrictKeys dm (Set.map snd s)) $ restrictKeys m (Set.map fst s)
+
+-- | /O(m log(n \/ m + 1)), m <= n/. Restrict a 'Map' to only the keys in a given 'Set'.
+restrictKeys3 :: (Ord k0, Ord k1, Ord k2) => DeepMap (k0 ': k1 ': k2 ': ks) v -> Set (k0, k1, k2) -> DeepMap (k0 ': k1 ': k2 ': ks) v
+restrictKeys3 m s =
+  mapShallow (\dm -> restrictKeys2 dm (Set.map (\(_, b, c) -> (b, c)) s)) $
+    restrictKeys m (Set.map (\(a, _, _) -> a) s)
+
+-- | /O(m log(n \/ m + 1)), m <= n/. Restrict a 'Map' to only the keys in a given 'Set'.
+restrictKeys4 :: (Ord k0, Ord k1, Ord k2, Ord k3) => DeepMap (k0 ': k1 ': k2 ': k3 ': ks) v -> Set (k0, k1, k2, k3) -> DeepMap (k0 ': k1 ': k2 ': k3 ': ks) v
+restrictKeys4 m s = mapShallow (\dm -> restrictKeys3 dm (Set.map (\(_, b, c, d) -> (b, c, d)) s)) $ restrictKeys m (Set.map (\(a, _, _, _) -> a) s)
+
+-- | /O(m log(n \/ m + 1)), m <= n/. Restrict a 'Map' to only the keys in a given 'Set'.
+restrictKeys5 :: (Ord k0, Ord k1, Ord k2, Ord k3, Ord k4) => DeepMap (k0 ': k1 ': k2 ': k3 ': k4 ': ks) v -> Set (k0, k1, k2, k3, k4) -> DeepMap (k0 ': k1 ': k2 ': k3 ': k4 ': ks) v
+restrictKeys5 m s = mapShallow (\dm -> restrictKeys4 dm (Set.map (\(_, b, c, d, e) -> (b, c, d, e)) s)) $ restrictKeys m (Set.map (\(a, _, _, _, _) -> a) s)
+
+-- | /O(m log(n \/ m + 1)), m <= n/. Remove all the keys in a 'Set' from a 'Map'.
+withoutKeys :: (Ord k) => DeepMap (k ': ks) v -> Set k -> DeepMap (k ': ks) v
+withoutKeys (Nest m) s = Nest $ Map.withoutKeys m s
+
+-- | /O(m log(n \/ m + 1)), m <= n/. Remove all the keys in a 'Set' from a 'Map'.
+withoutKeys2 :: (Ord k0, Ord k1) => DeepMap (k0 ': k1 ': ks) v -> Set (k0, k1) -> DeepMap (k0 ': k1 ': ks) v
+withoutKeys2 m s = mapShallow (\dm -> withoutKeys dm (Set.map snd s)) $ withoutKeys m (Set.map fst s)
+
+-- | /O(m log(n \/ m + 1)), m <= n/. Remove all the keys in a 'Set' from a 'Map'.
+withoutKeys3 :: (Ord k0, Ord k1, Ord k2) => DeepMap (k0 ': k1 ': k2 ': ks) v -> Set (k0, k1, k2) -> DeepMap (k0 ': k1 ': k2 ': ks) v
+withoutKeys3 m s = mapShallow (\dm -> withoutKeys2 dm (Set.map (\(_, b, c) -> (b, c)) s)) $ withoutKeys m (Set.map (\(a, _, _) -> a) s)
+
+-- | /O(m log(n \/ m + 1)), m <= n/. Remove all the keys in a 'Set' from a 'Map'.
+withoutKeys4 :: (Ord k0, Ord k1, Ord k2, Ord k3) => DeepMap (k0 ': k1 ': k2 ': k3 ': ks) v -> Set (k0, k1, k2, k3) -> DeepMap (k0 ': k1 ': k2 ': k3 ': ks) v
+withoutKeys4 m s = mapShallow (\dm -> withoutKeys3 dm (Set.map (\(_, b, c, d) -> (b, c, d)) s)) $ withoutKeys m (Set.map (\(a, _, _, _) -> a) s)
+
+-- | /O(m log(n \/ m + 1)), m <= n/. Remove all the keys in a 'Set' from a 'Map'.
+withoutKeys5 :: (Ord k0, Ord k1, Ord k2, Ord k3, Ord k4) => DeepMap (k0 ': k1 ': k2 ': k3 ': k4 ': ks) v -> Set (k0, k1, k2, k3, k4) -> DeepMap (k0 ': k1 ': k2 ': k3 ': k4 ': ks) v
+withoutKeys5 m s = mapShallow (\dm -> withoutKeys4 dm (Set.map (\(_, b, c, d, e) -> (b, c, d, e)) s)) $ withoutKeys m (Set.map (\(a, _, _, _, _) -> a) s)
+
+-- | /O(n)/. Partition the map according to a predicate (satisfied, failed).
+partition :: (DeepMap ks v -> Bool) -> DeepMap (k ': ks) v -> (DeepMap (k ': ks) v, DeepMap (k ': ks) v)
+partition p (Nest m) = Nest *** Nest $ Map.partition p m
+
+-- | /O(n)/. Partition the map according to a predicate (satisfied, failed).
+partition1 :: (v -> Bool) -> DeepMap '[k] v -> (DeepMap '[k] v, DeepMap '[k] v)
+partition1 p = partition (p . getBare)
+
+-- | /O(n)/. Partition the map according to a predicate (satisfied, failed).
+partition2 :: (v -> Bool) -> DeepMap '[k0, k1] v -> (DeepMap '[k0, k1] v, DeepMap '[k0, k1] v)
+partition2 p = filter2 p &&& filter2 (not . p)
+
+-- | /O(n)/. Partition the map according to a predicate (satisfied, failed).
+partition3 :: (v -> Bool) -> DeepMap '[k0, k1, k2] v -> (DeepMap '[k0, k1, k2] v, DeepMap '[k0, k1, k2] v)
+partition3 p = filter3 p &&& filter3 (not . p)
+
+-- | /O(n)/. Partition the map according to a predicate (satisfied, failed).
+partition4 :: (v -> Bool) -> DeepMap '[k0, k1, k2, k3] v -> (DeepMap '[k0, k1, k2, k3] v, DeepMap '[k0, k1, k2, k3] v)
+partition4 p = filter4 p &&& filter4 (not . p)
+
+-- | /O(n)/. Partition the map according to a predicate (satisfied, failed).
+partition5 :: (v -> Bool) -> DeepMap '[k0, k1, k2, k3, k4] v -> (DeepMap '[k0, k1, k2, k3, k4] v, DeepMap '[k0, k1, k2, k3, k4] v)
+partition5 p = filter5 p &&& filter5 (not . p)
+
+-- | /O(n)/. Partition the map according to a predicate (satisfied, failed).
+partitionWithKey :: (k -> DeepMap ks v -> Bool) -> DeepMap (k ': ks) v -> (DeepMap (k ': ks) v, DeepMap (k ': ks) v)
+partitionWithKey p (Nest m) = Nest *** Nest $ Map.partitionWithKey p m
+
+-- | /O(n)/. Partition the map according to a predicate (satisfied, failed).
+partitionWithKey1 :: (k -> v -> Bool) -> DeepMap '[k] v -> (DeepMap '[k] v, DeepMap '[k] v)
+partitionWithKey1 p = partitionWithKey (\k -> p k . getBare)
+
+-- | /O(n)/. Partition the map according to a predicate (satisfied, failed).
+partitionWithKey2 :: (k0 -> k1 -> v -> Bool) -> DeepMap '[k0, k1] v -> (DeepMap '[k0, k1] v, DeepMap '[k0, k1] v)
+partitionWithKey2 p = filterWithKey2 p &&& filterWithKey2 (\k0 k1 -> not . p k0 k1)
+
+-- | /O(n)/. Partition the map according to a predicate (satisfied, failed).
+partitionWithKey3 :: (k0 -> k1 -> k2 -> v -> Bool) -> DeepMap '[k0, k1, k2] v -> (DeepMap '[k0, k1, k2] v, DeepMap '[k0, k1, k2] v)
+partitionWithKey3 p = filterWithKey3 p &&& filterWithKey3 (\k0 k1 k2 -> not . p k0 k1 k2)
+
+-- | /O(n)/. Partition the map according to a predicate (satisfied, failed).
+partitionWithKey4 :: (k0 -> k1 -> k2 -> k3 -> v -> Bool) -> DeepMap '[k0, k1, k2, k3] v -> (DeepMap '[k0, k1, k2, k3] v, DeepMap '[k0, k1, k2, k3] v)
+partitionWithKey4 p = filterWithKey4 p &&& filterWithKey4 (\k0 k1 k2 k3 -> not . p k0 k1 k2 k3)
+
+-- | /O(n)/. Partition the map according to a predicate (satisfied, failed).
+partitionWithKey5 :: (k0 -> k1 -> k2 -> k3 -> k4 -> v -> Bool) -> DeepMap '[k0, k1, k2, k3, k4] v -> (DeepMap '[k0, k1, k2, k3, k4] v, DeepMap '[k0, k1, k2, k3, k4] v)
+partitionWithKey5 p = filterWithKey5 p &&& filterWithKey5 (\k0 k1 k2 k3 k4 -> not . p k0 k1 k2 k3 k4)
+
+-- | /O(n)/. Take while a predicate on the keys holds. See the note at 'spanAntitone'.
+takeWhileAntitone :: (k -> Bool) -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v
+takeWhileAntitone p (Nest m) = Nest $ Map.takeWhileAntitone p m
+
+-- | /O(n)/. Drop while a predicate on the keys holds. See the note at 'spanAntitone'.
+dropWhileAntitone :: (k -> Bool) -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v
+dropWhileAntitone p (Nest m) = Nest $ Map.dropWhileAntitone p m
+
+-- | /O(n)/. Take while a predicate on the keys holds.
+--
+--   __NOTE:__ if p is not actually antitone, then 'spanAntitone' will split the map
+--   at some unspecified point where the predicate switches from holding to not holding
+--   (where the predicate is seen to hold before the first key and to fail after the last key).
+spanAntitone :: (k -> Bool) -> DeepMap (k ': ks) v -> (DeepMap (k ': ks) v, DeepMap (k ': ks) v)
+spanAntitone p (Nest m) = Nest *** Nest $ Map.spanAntitone p m
+
+-- | /O(n)/. Map values and collect the 'Just' results.
+mapMaybe :: (v -> Maybe w) -> DeepMap (k ': ks) v -> DeepMap (k ': ks) w
+mapMaybe f (Nest m) = Nest $ Map.mapMaybe (traverse f) m
+
+-- | /O(n)/. Map values and collect the 'Just' results. Strictly more general than 'mapMaybe' in that the types of the inner keys can change.
+mapShallowMaybe :: (DeepMap ks v -> Maybe (DeepMap ls w)) -> DeepMap (k ': ks) v -> DeepMap (k ': ls) w
+mapShallowMaybe f (Nest m) = Nest $ Map.mapMaybe f m
+
+-- | /O(n)/. Map values and collect the 'Just' results.
+mapShallowMaybeWithKey :: (k -> DeepMap ks v -> Maybe (DeepMap ls w)) -> DeepMap (k ': ks) v -> DeepMap (k ': ls) w
+mapShallowMaybeWithKey f (Nest m) = Nest $ Map.mapMaybeWithKey f m
+
+-- | /O(n)/. Map values and collect the 'Just' results.
+mapMaybeWithKey1 :: (k -> v -> Maybe w) -> DeepMap '[k] v -> DeepMap '[k] w
+mapMaybeWithKey1 f = mapShallowMaybeWithKey (\k -> fmap Bare . f k . getBare)
+
+-- | /O(n)/. Map values and collect the 'Just' results.
+mapMaybeWithKey2 :: (k0 -> k1 -> v -> Maybe w) -> DeepMap '[k0, k1] v -> DeepMap '[k0, k1] w
+mapMaybeWithKey2 f m =
+  let g k0 k1 v = Identity $ f k0 k1 v
+   in runIdentity $ traverseMaybeWithKey (fmap (fmap Just) . traverseMaybeWithKey1 . g) m
+
+-- | /O(n)/. Map values and collect the 'Just' results.
+mapMaybeWithKey3 :: (k0 -> k1 -> k2 -> v -> Maybe w) -> DeepMap '[k0, k1, k2] v -> DeepMap '[k0, k1, k2] w
+mapMaybeWithKey3 f m =
+  let g k0 k1 k2 v = Identity $ f k0 k1 k2 v
+   in runIdentity $ traverseMaybeWithKey (fmap (fmap Just) . traverseMaybeWithKey2 . g) m
+
+-- | /O(n)/. Map values and collect the 'Just' results.
+mapMaybeWithKey4 :: (k0 -> k1 -> k2 -> k3 -> v -> Maybe w) -> DeepMap '[k0, k1, k2, k3] v -> DeepMap '[k0, k1, k2, k3] w
+mapMaybeWithKey4 f m =
+  let g k0 k1 k2 k3 v = Identity $ f k0 k1 k2 k3 v
+   in runIdentity $ traverseMaybeWithKey (fmap (fmap Just) . traverseMaybeWithKey3 . g) m
+
+-- | /O(n)/. Map values and collect the 'Just' results.
+mapMaybeWithKey5 :: (k0 -> k1 -> k2 -> k3 -> k4 -> v -> Maybe w) -> DeepMap '[k0, k1, k2, k3, k4] v -> DeepMap '[k0, k1, k2, k3, k4] w
+mapMaybeWithKey5 f m =
+  let g k0 k1 k2 k3 k4 v = Identity $ f k0 k1 k2 k3 k4 v
+   in runIdentity $ traverseMaybeWithKey (fmap (fmap Just) . traverseMaybeWithKey4 . g) m
+
+-- | /O(n)/. Map values and collect the 'Left' and 'Right' results separately.
+mapEither :: (v -> Either w x) -> DeepMap (k ': ks) v -> (DeepMap (k ': ks) w, DeepMap (k ': ks) x)
+mapEither f m = (mapMaybe ((Just ||| const Nothing) . f) m, mapMaybe ((const Nothing ||| Just) . f) m)
+
+-- | /O(n)/. Map values and collect the 'Left' and 'Right' results separately.
+mapShallowEither :: (DeepMap ks v -> Either (DeepMap ls w) (DeepMap ms x)) -> DeepMap (k ': ks) v -> (DeepMap (k ': ls) w, DeepMap (k ': ms) x)
+mapShallowEither f (Nest m) = Nest *** Nest $ Map.mapEither f m
+
+-- | /O(n)/. Map values and collect the 'Left' and 'Right' results separately.
+mapShallowEitherWithKey :: (k -> DeepMap ks v -> Either (DeepMap ls w) (DeepMap ms x)) -> DeepMap (k ': ks) v -> (DeepMap (k ': ls) w, DeepMap (k ': ms) x)
+mapShallowEitherWithKey f (Nest m) = Nest *** Nest $ Map.mapEitherWithKey f m
+
+-- | /O(n)/. Map values and collect the 'Left' and 'Right' results separately.
+mapEitherWithKey1 :: (k -> v -> Either w x) -> DeepMap '[k] v -> (DeepMap '[k] w, DeepMap '[k] x)
+mapEitherWithKey1 f (Nest m) = Nest *** Nest $ Map.mapEitherWithKey (\k -> (Bare +++ Bare) . f k . getBare) m
+
+-- | /O(n)/. Map values and collect the 'Left' and 'Right' results separately.
+mapEitherWithKey2 :: (k0 -> k1 -> v -> Either w x) -> DeepMap '[k0, k1] v -> (DeepMap '[k0, k1] w, DeepMap '[k0, k1] x)
+mapEitherWithKey2 f m =
+  (mapMaybe (Just ||| const Nothing) *** mapMaybe (const Nothing ||| Just)) . partition2 isLeft $
+    mapShallowWithKey (\k0 -> mapShallowWithKey $ fmap . f k0) m
+
+-- | /O(n)/. Map values and collect the 'Left' and 'Right' results separately.
+mapEitherWithKey3 :: (k0 -> k1 -> k2 -> v -> Either w x) -> DeepMap '[k0, k1, k2] v -> (DeepMap '[k0, k1, k2] w, DeepMap '[k0, k1, k2] x)
+mapEitherWithKey3 f m =
+  (mapMaybe (Just ||| const Nothing) *** mapMaybe (const Nothing ||| Just)) . partition3 isLeft $
+    mapShallowWithKey
+      ( \k0 -> mapShallowWithKey $ \k1 ->
+          mapShallowWithKey $ fmap . f k0 k1
+      )
+      m
+
+-- | /O(n)/. Map values and collect the 'Left' and 'Right' results separately.
+mapEitherWithKey4 :: (k0 -> k1 -> k2 -> k3 -> v -> Either w x) -> DeepMap '[k0, k1, k2, k3] v -> (DeepMap '[k0, k1, k2, k3] w, DeepMap '[k0, k1, k2, k3] x)
+mapEitherWithKey4 f m =
+  (mapMaybe (Just ||| const Nothing) *** mapMaybe (const Nothing ||| Just)) . partition4 isLeft $
+    mapShallowWithKey
+      ( \k0 -> mapShallowWithKey $ \k1 ->
+          mapShallowWithKey $ \k2 ->
+            mapShallowWithKey $ fmap . f k0 k1 k2
+      )
+      m
+
+-- | /O(n)/. Map values and collect the 'Left' and 'Right' results separately.
+mapEitherWithKey5 :: (k0 -> k1 -> k2 -> k3 -> k4 -> v -> Either w x) -> DeepMap '[k0, k1, k2, k3, k4] v -> (DeepMap '[k0, k1, k2, k3, k4] w, DeepMap '[k0, k1, k2, k3, k4] x)
+mapEitherWithKey5 f m =
+  (mapMaybe (Just ||| const Nothing) *** mapMaybe (const Nothing ||| Just)) . partition5 isLeft $
+    mapShallowWithKey
+      ( \k0 -> mapShallowWithKey $ \k1 ->
+          mapShallowWithKey $ \k2 ->
+            mapShallowWithKey $ \k3 ->
+              mapShallowWithKey $ fmap . f k0 k1 k2 k3
+      )
+      m
+
+-- | /O(log n)/. Partition the map by comparing keys ((smaller, larger) than given).
+split :: (Ord k) => k -> DeepMap (k ': ks) v -> (DeepMap (k ': ks) v, DeepMap (k ': ks) v)
+split k (Nest m) = Nest *** Nest $ Map.split k m
+
+-- | /O(log n)/. Like 'split' but the middle coordinate 'lookup's the value at the key.
+splitLookup :: (Ord k) => k -> DeepMap (k ': ks) v -> (DeepMap (k ': ks) v, Maybe (DeepMap ks v), DeepMap (k ': ks) v)
+splitLookup k (Nest m) = (\(n, y, p) -> (Nest n, y, Nest p)) $ Map.splitLookup k m
+
+-- | /O(1)/. Decompose a map into pieces based on the structure of the underlying tree.
+splitRoot :: DeepMap (k ': ks) v -> [DeepMap (k ': ks) v]
+splitRoot (Nest m) = Nest <$> Map.splitRoot m
+
+-- | /O(m log(n \/ m + 1)), m <= n/. Returns 'True' if all the keys in the left map
+--   exist in the right, __and__ their values all agree.
+isSubmapOf :: (Ord k, Eq (DeepMap ks v)) => DeepMap (k ': ks) v -> DeepMap (k ': ks) v -> Bool
+isSubmapOf (Nest m) (Nest n) = Map.isSubmapOf m n
+
+-- | /O(m log(n \/ m + 1)), m <= n/. Returns 'True' if all the keys in the left map
+--   exist in the right, __and__ the function returns 'True' when applied to respective values.
+isSubmapOfBy :: (Ord k) => (DeepMap ks v -> DeepMap ks v -> Bool) -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v -> Bool
+isSubmapOfBy f (Nest m) (Nest n) = Map.isSubmapOfBy f m n
+
+-- | /O(m log(n \/ m + 1)), m <= n/. Returns 'True' if all the keys in the left map
+--   exist in the right, __and__ their values all agree, __and__ the maps are not equal.
+isProperSubmapOf :: (Ord k, Eq (DeepMap ks v)) => DeepMap (k ': ks) v -> DeepMap (k ': ks) v -> Bool
+isProperSubmapOf (Nest m) (Nest n) = Map.isProperSubmapOf m n
+
+-- | /O(m log(n \/ m + 1)), m <= n/. Returns 'True' if all the keys in the left map
+--   exist in the right, __and__ the function returns 'True' when applied to respective values,
+--   __and__ the maps are not equal.
+isProperSubmapOfBy :: (Ord k) => (DeepMap ks v -> DeepMap ks v -> Bool) -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v -> Bool
+isProperSubmapOfBy f (Nest m) (Nest n) = Map.isProperSubmapOfBy f m n
+
+-- | /O(log n)/. Lookup the /index/ of a key, which is its zero-based index
+--   in the ordered sequence of keys.
+--
+-- > 'lookupIndex' k m == 'Data.List.findIndex' k ('keys' m)
+lookupIndex :: (Ord k) => k -> DeepMap (k ': ks) v -> Maybe Int
+lookupIndex k (Nest m) = Map.lookupIndex k m
+
+-- | /O(log n)/. Lookup the /index/ of a key, which is its zero-based index
+--   in the ordered sequence of keys. Calls 'error' when the key is not in the map.
+findIndex :: (Ord k) => k -> DeepMap (k ': ks) v -> Int
+findIndex i (Nest m) = Map.findIndex i m
+
+-- | /O(log n)/. Retrieve an element by its /index/. Calls 'error' if @i@ is outside
+--   the range @0 <= i < 'size' m@.
+elemAt :: (Ord k) => Int -> DeepMap (k ': ks) v -> (k, DeepMap ks v)
+elemAt i (Nest m) = Map.elemAt i m
+
+-- | /O(log n)/. Update the element by its /index/. Calls 'error' if @i@ is outside
+--   the range @0 <= i < 'size' m@.
+updateAt :: (Ord k) => (k -> DeepMap ks v -> Maybe (DeepMap ks v)) -> Int -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v
+updateAt f i (Nest m) = Nest $ Map.updateAt f i m
+
+-- | /O(log n)/. Delete the element by its /index/. Calls 'error' if @i@ is outside
+--   the range @0 <= i < 'size' m@.
+deleteAt :: (Ord k) => (k -> DeepMap ks v -> Maybe (DeepMap ks v)) -> Int -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v
+deleteAt f i (Nest m) = Nest $ Map.updateAt f i m
+
+-- | Take the smallest @n@ keys.
+take :: Int -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v
+take n (Nest m) = Nest $ Map.take n m
+
+-- | Drop the smallest @n@ keys.
+drop :: Int -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v
+drop n (Nest m) = Nest $ Map.take n m
+
+-- | /O(n)/. Split a map at a particular index.
+splitAt :: Int -> DeepMap (k ': ks) v -> (DeepMap (k ': ks) v, DeepMap (k ': ks) v)
+splitAt i (Nest m) = Nest *** Nest $ Map.splitAt i m
+
+-- | /O(log n)/. The minimal key of the map, or 'Nothing' if the map is empty.
+lookupMin :: DeepMap (k ': ks) v -> Maybe (k, DeepMap ks v)
+lookupMin (Nest m) = Map.lookupMin m
+
+-- | /O(log n)/. The maximal key of the map, or 'Nothing' if the map is empty.
+lookupMax :: DeepMap (k ': ks) v -> Maybe (k, DeepMap ks v)
+lookupMax (Nest m) = Map.lookupMax m
+
+-- | /O(log n)/. The minimal key of the map, or 'error' if the map is empty.
+findMin :: DeepMap (k ': ks) v -> (k, DeepMap ks v)
+findMin (Nest m) = Map.findMin m
+
+-- | /O(log n)/. The maximal key of the map, or 'error' if the map is empty.
+findMax :: DeepMap (k ': ks) v -> (k, DeepMap ks v)
+findMax (Nest m) = Map.findMax m
+
+-- | /O(log n)/. Delete the minimal key.
+deleteMin :: DeepMap (k ': ks) v -> DeepMap (k ': ks) v
+deleteMin (Nest m) = Nest $ Map.deleteMin m
+
+-- | /O(log n)/. Delete the maximal key.
+deleteMax :: DeepMap (k ': ks) v -> DeepMap (k ': ks) v
+deleteMax (Nest m) = Nest $ Map.deleteMax m
+
+-- | /O(log n)/. Delete and return the minimal key of the map, or 'error' if the map is empty.
+deleteFindMin :: DeepMap (k ': ks) v -> ((k, DeepMap ks v), DeepMap (k ': ks) v)
+deleteFindMin (Nest m) = Nest <$> Map.deleteFindMin m
+
+-- | /O(log n)/. Delete and return the maximal key of the map, or 'error' if the map is empty.
+deleteFindMax :: DeepMap (k ': ks) v -> ((k, DeepMap ks v), DeepMap (k ': ks) v)
+deleteFindMax (Nest m) = Nest <$> Map.deleteFindMax m
+
+-- | /O(log n)/. Update the value at the minimal key.
+updateMin :: (DeepMap ks v -> Maybe (DeepMap ks v)) -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v
+updateMin f (Nest m) = Nest $ Map.updateMin f m
+
+-- | /O(log n)/. Update the value at the maximal key.
+updateMax :: (DeepMap ks v -> Maybe (DeepMap ks v)) -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v
+updateMax f (Nest m) = Nest $ Map.updateMax f m
+
+-- | /O(log n)/. Update the value at the minimal key.
+updateMinWithKey :: (k -> DeepMap ks v -> Maybe (DeepMap ks v)) -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v
+updateMinWithKey f (Nest m) = Nest $ Map.updateMinWithKey f m
+
+-- | /O(log n)/. Update the value at the maximal key.
+updateMaxWithKey :: (k -> DeepMap ks v -> Maybe (DeepMap ks v)) -> DeepMap (k ': ks) v -> DeepMap (k ': ks) v
+updateMaxWithKey f (Nest m) = Nest $ Map.updateMaxWithKey f m
+
+-- | /O(log n)/. Retrieve the value associated with the minimal key of the map,
+--   and the map stripped of that element, or 'Nothing' if passed an empty map.
+minView :: DeepMap (k ': ks) v -> Maybe (DeepMap ks v, DeepMap (k ': ks) v)
+minView (Nest m) = fmap Nest <$> Map.minView m
+
+-- | /O(log n)/. Retrieve the value associated with the maximal key of the map,
+--   and the map stripped of that element, or 'Nothing' if passed an empty map.
+maxView :: DeepMap (k ': ks) v -> Maybe (DeepMap ks v, DeepMap (k ': ks) v)
+maxView (Nest m) = fmap Nest <$> Map.maxView m
+
+-- | /O(log n)/. Retrieve the minimal key/value pair of the map,
+--   and the map stripped of that element, or 'Nothing' if passed an empty map.
+minViewWithKey :: DeepMap (k ': ks) v -> Maybe ((k, DeepMap ks v), DeepMap (k ': ks) v)
+minViewWithKey (Nest m) = fmap Nest <$> Map.minViewWithKey m
+
+-- | /O(log n)/. Retrieve the maximal key/value pair of the map,
+--   and the map stripped of that element, or 'Nothing' if passed an empty map.
+maxViewWithKey :: DeepMap (k ': ks) v -> Maybe ((k, DeepMap ks v), DeepMap (k ': ks) v)
+maxViewWithKey (Nest m) = fmap Nest <$> Map.maxViewWithKey m
+
+-- | "Transpose" a 'DeepMap', by swapping the outer two "dimensions".
+invertKeys :: (Ord j, Ord k, Semigroup (DeepMap ks v)) => DeepMap (j ': k ': ks) v -> DeepMap (k ': j ': ks) v
+invertKeys m = fold [k @> j @> mv | (j, mk) <- assocs m, (k, mv) <- assocs mk]
diff --git a/tests/test-readme.hs b/tests/test-readme.hs
new file mode 100644
--- /dev/null
+++ b/tests/test-readme.hs
@@ -0,0 +1,59 @@
+{-# LANGUAGE TemplateHaskell #-}
+
+module Main where
+
+import Data.Foldable (fold)
+import Data.Map.Deep
+import Data.Map.Strict (Map)
+import Data.Semigroup (Sum (..))
+import Data.Text (Text)
+import Data.Time.Compat
+import Hedgehog
+import Hedgehog.Main (defaultMain)
+
+newtype OrderID = OrderID Int deriving (Eq, Ord, Show)
+
+newtype CustomerID = CustomerID Text deriving (Eq, Ord, Show)
+
+type Price = Sum Double
+
+type Table = DeepMap '[Day, OrderID, CustomerID] Price
+
+table :: Table
+table =
+  fromList3
+    [ (YearMonthDay 2021 1 1, OrderID 1, CustomerID "Melanie", Sum 13.12),
+      (YearMonthDay 2021 1 1, OrderID 2, CustomerID "Sock", Sum 4.20),
+      (YearMonthDay 2021 1 2, OrderID 3, CustomerID "Sock", Sum 69.69),
+      (YearMonthDay 2021 1 2, OrderID 4, CustomerID "Fiona", Sum 5.00)
+    ]
+
+totalSales :: Table -> Price
+totalSales = fold
+
+prop_totalsales :: Property
+prop_totalsales = property $ totalSales table === Sum (13.12 + 4.20 + 69.69 + 5.00)
+
+dailySales :: Table -> Map Day Price
+dailySales = toMap . foldMapWithKey3 (\d _o _c p -> d @| p)
+
+dailyCustomers :: Table -> Map Day [CustomerID]
+dailyCustomers = toMap . foldMapWithKey3 (\d _o c _p -> d @| [c])
+
+totalPerCustomer :: Table -> DeepMap '[CustomerID] Price
+totalPerCustomer = foldShallow . foldShallow
+
+customerSaleDates :: Table -> Map CustomerID [Day]
+customerSaleDates = toMap . foldMapWithKey3 (\d _o c _p -> c @| [d])
+
+orderTotalPerCustomer :: Table -> DeepMap '[CustomerID, OrderID] Price
+orderTotalPerCustomer = invertKeys . foldShallow
+
+sockTotal :: Table -> Double
+sockTotal t = getSum $ totalPerCustomer t @!| CustomerID "Sock"
+
+prop_socktotal :: Property
+prop_socktotal = property $ sockTotal table === (69.69 + 4.20)
+
+main :: IO ()
+main = print table >> defaultMain [checkParallel $$(discover)]