diff --git a/compiler/damlc/daml-stdlib-src/DA/Internal/LF.daml b/compiler/damlc/daml-stdlib-src/DA/Internal/LF.daml
index 06d47d8c9a52..3e72953e318a 100644
--- a/compiler/damlc/daml-stdlib-src/DA/Internal/LF.daml
+++ b/compiler/damlc/daml-stdlib-src/DA/Internal/LF.daml
@@ -21,9 +21,7 @@ module DA.Internal.LF
 
   , TextMap
 
-  #ifdef DAML_GENMAP
   , Map
-  #endif
 
   , Update
 
@@ -125,26 +123,24 @@ instance Ord Time where (<=) = primitive @"BELessEq"
 data TextMap a =
   TextMap Opaque
 
-#ifdef DAML_GENMAP
 -- | The `Map a b` type represents an associative array from keys of type `a`
 -- to values of type `b`. It uses the built-in equality for keys. Import
 -- `DA.Map` to use it.
 data Map a b =
   Map Opaque
-#endif
 
 -- | The `ContractId a` type represents an ID for a contract created from a template `a`.
 --   You can use the ID to fetch the contract, among other things.
 data ContractId a =
   ContractId Opaque
 instance Eq (ContractId a) where (==) = primitive @"BEEqualContractId"
-#ifdef DAML_GENERIC_COMPARISON
+
 instance Ord (ContractId a) where
   (<) = primitive @"BELess"
   (<=) = primitive @"BELessEq"
   (>) = primitive @"BEGreater"
   (>=) = primitive @"BEGreaterEq"
-#endif
+
 instance Show (ContractId a) where
 #ifdef DAML_CONTRACT_ID_TO_TEXT
   show cid = case primitive @"BEContractIdToText" cid of
@@ -267,13 +263,11 @@ data TypeRep = TypeRep Opaque
 instance Eq TypeRep where
   (==) = primitive @"BEEqual"
 
-#ifdef DAML_GENERIC_COMPARISON
 instance Ord TypeRep where
   (<=) = primitive @"BELessEq"
   (>=) = primitive @"BEGreaterEq"
   (<) = primitive @"BELess"
   (>) = primitive @"BEGreater"
-#endif -- DAML_GENERIC_COMPARISON
 #endif
 
 #ifdef DAML_EXCEPTIONS
diff --git a/compiler/damlc/daml-stdlib-src/DA/Internal/Template/Functions.daml b/compiler/damlc/daml-stdlib-src/DA/Internal/Template/Functions.daml
index 08dc9c14c57a..ae9f850b25a4 100644
--- a/compiler/damlc/daml-stdlib-src/DA/Internal/Template/Functions.daml
+++ b/compiler/damlc/daml-stdlib-src/DA/Internal/Template/Functions.daml
@@ -2,7 +2,6 @@
 -- SPDX-License-Identifier: Apache-2.0
 
 {-# LANGUAGE AllowAmbiguousTypes #-}
-{-# LANGUAGE CPP #-}
 {-# LANGUAGE NoImplicitPrelude #-}
 {-# LANGUAGE ScopedTypeVariables #-}
 
@@ -13,16 +12,12 @@
 -- | MOVE Prelude Daml-LF primitives, just templates/contracts
 module DA.Internal.Template.Functions where
 
-#ifdef DAML_ANY_TYPE
 import DA.Internal.Any
-#endif
 import DA.Internal.LF
 import DA.Internal.Prelude
 import DA.Internal.Template
 
-#ifdef DAML_GENMAP && DAML_ANY_TYPE
 import GHC.Types (primitive)
-#endif
 
 type TemplateOrInterface t =
   ( HasTemplateTypeRep t
@@ -227,28 +222,19 @@ instance IsParties (Optional Party) where
   toParties None = []
   toParties (Some p) = [p]
 
-#ifdef DAML_GENERIC_COMPARISON && DAML_ANY_TYPE
-
 instance Eq AnyTemplate where
   (==) = primitive @"BEEqual"
-
 instance Eq AnyChoice where
   (==) = primitive @"BEEqual"
-
 instance Eq AnyContractKey where
   (==) = primitive @"BEEqual"
 
 instance Ord AnyTemplate where
   (<=) = primitive @"BELessEq"
-
 instance Ord AnyChoice where
   (<=) = primitive @"BELessEq"
-
 instance Ord AnyContractKey where
   (<=) = primitive @"BELessEq"
-#endif
-
-#ifdef DAML_TYPE_REP
 
 -- | Generate a unique textual representation of the template id.
 templateTypeRep : forall t. HasTemplateTypeRep t => TemplateTypeRep
@@ -257,11 +243,7 @@ templateTypeRep = TemplateTypeRep (_templateTypeRep ([] : [t]))
 instance Eq TemplateTypeRep where
   TemplateTypeRep a == TemplateTypeRep b = a == b
 
-#ifdef DAML_GENERIC_COMPARISON
 deriving instance Ord TemplateTypeRep
-#endif
-
-#ifdef DAML_ANY_TYPE
 
 -- | Wrap the template in `AnyTemplate`.
 --
@@ -325,8 +307,6 @@ fromAnyContractKey (AnyContractKey any rep)
   | Some k <- _fromAnyContractKey ([] : [t]) any
   , templateTypeRep @t == rep = Some k
   | otherwise = None
-#endif
-#endif
 
 deriving instance Eq Archive
 deriving instance Show Archive
diff --git a/compiler/damlc/daml-stdlib-src/DA/List/BuiltinOrder.daml b/compiler/damlc/daml-stdlib-src/DA/List/BuiltinOrder.daml
index 030695df5ccf..28a524f06ae1 100644
--- a/compiler/damlc/daml-stdlib-src/DA/List/BuiltinOrder.daml
+++ b/compiler/damlc/daml-stdlib-src/DA/List/BuiltinOrder.daml
@@ -1,10 +1,5 @@
 -- Copyright (c) 2021 Digital Asset (Switzerland) GmbH and/or its affiliates. All rights reserved.
 -- SPDX-License-Identifier: Apache-2.0
-{-# LANGUAGE CPP #-}
-
-#ifndef DAML_GENMAP
-module DA.List.BuiltinOrder where
-#else
 
 -- | Note: This is only supported in DAML-LF 1.11 or later.
 --
@@ -151,4 +146,3 @@ goUniqueOn f m (x :: xs) =
   in case Map.lookup (f x) m of
     None -> goUniqueOn f (Map.insert k () m) xs
     Some _ -> False
-#endif
diff --git a/compiler/damlc/daml-stdlib-src/DA/Map.daml b/compiler/damlc/daml-stdlib-src/DA/Map.daml
index e39578ff5943..b09c009c2d31 100644
--- a/compiler/damlc/daml-stdlib-src/DA/Map.daml
+++ b/compiler/damlc/daml-stdlib-src/DA/Map.daml
@@ -1,17 +1,6 @@
 -- Copyright (c) 2021 Digital Asset (Switzerland) GmbH and/or its affiliates. All rights reserved.
 -- SPDX-License-Identifier: Apache-2.0
 
-{-# LANGUAGE CPP #-}
-
-
-#ifndef DAML_GENMAP
-
--- | HIDE
-module DA.Map where
-
-#else
-
-
 -- | Note: This is only supported in DAML-LF 1.11 or later.
 --
 -- This module exports the generic map type `Map k v` and associated
@@ -240,5 +229,3 @@ instance Ord k => Foldable.Foldable (Map k) where
 
 instance Ord k => Traversable.Traversable (Map k) where
   mapA f x = fmap fromList $ mapA (\(k, v) -> fmap (k,) $ f v) $ toList x
-
-#endif
diff --git a/compiler/damlc/daml-stdlib-src/DA/Next/Map.daml b/compiler/damlc/daml-stdlib-src/DA/Next/Map.daml
deleted file mode 100644
index f5427ec123fc..000000000000
--- a/compiler/damlc/daml-stdlib-src/DA/Next/Map.daml
+++ /dev/null
@@ -1,196 +0,0 @@
--- Copyright (c) 2021 Digital Asset (Switzerland) GmbH and/or its affiliates. All rights reserved.
--- SPDX-License-Identifier: Apache-2.0
-
-{-# LANGUAGE CPP #-}
-
-#ifdef DAML_GENMAP
-
--- | `DA.Next.Map` is deprecated. Please use `DA.Map` instead.
-module DA.Next.Map
-  {-# DEPRECATED "DA.Next.Map is deprecated. Please use DA.Map instead." #-}
-
-#else
-
--- | Map - A `Map` is an associative array data type composed of a
--- collection of key/value pairs such that each possible key appears
--- at most once in the collection.
-module DA.Next.Map
-
-#endif
-
-  ( Map
-  , MapKey (..)
-  , empty
-  , size
-  , toList
-  , fromList
-  , fromListWith
-  , toTextMap
-  , fromTextMap
-  , null
-  , lookup
-  , member
-  , filter
-  , filterWithKey
-  , delete
-  , insert
-  , union
-  , merge
-  ) where
-
-import Prelude hiding (lookup, null, filter, empty)
-import DA.Foldable qualified as Foldable
-import DA.Text
-import DA.TextMap (TextMap)
-import DA.TextMap qualified as TextMap
-import DA.Traversable qualified as Traversable
-import DA.Tuple
-
--- | A `Map k v` is an associative array data type composed of a
--- collection of key/value pairs of key type `k` and value type `v`
--- such that each possible key appears at most once in the collection.
-newtype Map k v = Map with textMap : TextMap v
-  deriving (Eq, Ord, Foldable.Foldable)
-
--- | A class for types that can be used as keys for the `Map` type.
--- All keys `k` must satisfy `keyFromText (keyToText k) == k`.
-class Eq k => MapKey k where
-  -- | Turn a key into its textual representation. This function must be
-  -- injective.
-  keyToText : k -> Text
-  -- | Recover a key from its textual representation. `keyFromText x` is
-  -- allowed to fail whenever there is _no_ key `k` with `keyToText k == x`.
-  -- Whenever such a `k` does exist, then it must satisfy
-  -- `keyFromText x == k`.
-  keyFromText : Text -> k
-
-instance MapKey Text where
-  keyToText x = x
-  keyFromText x = x
-
-keyFromTextNote : Text -> Text -> Text
-keyFromTextNote target t =
-  "keyFromText: could not parse " <> show t <> " as '" <> target <> "'"
-
-instance MapKey Party where
-  keyToText = partyToText
-  keyFromText t =
-    case partyFromText t of
-      None -> error (keyFromTextNote "Party" t)
-      Some x -> x
-
-instance MapKey Int where
-  keyToText = show
-  keyFromText t =
-    case parseInt t of
-      None -> error (keyFromTextNote "Int" t)
-      Some x -> x
-
-instance MapKey Decimal where
-  keyToText = show
-  keyFromText t =
-    case parseDecimal t of
-      None -> error (keyFromTextNote "Decimal" t)
-      Some x -> x
-
--- | Create a map from a list of key/value pairs.
-fromList : MapKey k => [(k, v)] -> Map k v
-fromList kvs = Map $ TextMap.fromList $ map (first keyToText) kvs
-
--- | Create a map from a list of key/value pairs with a combining
--- function. Examples:
--- ```
---   fromListWith (<>) [(5,"a"), (5,"b"), (3,"b"), (3,"a"), (5,"c")] == fromList [(3, "ba"), (5, "abc")]
---   fromListWith (<>) [] == (empty : Map Int Text)
--- ```
-fromListWith : MapKey k => (v -> v -> v) -> [(k, v)] -> Map k v
-fromListWith f kvs = Map $ TextMap.fromListWith f $ map (first keyToText) kvs
-
--- | Convert the map to a list of key/value pairs where the keys are
--- in ascending order of their textual representation.
-toList : MapKey k => Map k v -> [(k, v)]
-toList (Map t) = map (first keyFromText) $ TextMap.toList t
-
--- | Create a `Map` from a `TextMap`.
-fromTextMap : TextMap v -> Map Text v
-fromTextMap = Map
-
--- | Convert a `Map` into a `TextMap`.
-toTextMap : MapKey k => Map k v -> TextMap v
-toTextMap (Map t) = t
-
--- | The empty map.
-empty : Map k v
-empty = Map TextMap.empty
-
--- | Number of elements in the map.
-size : Map k v -> Int
-size (Map t) = TextMap.size t
-
--- | Is the map empty?
-null : Map k v -> Bool
-null m = size m == 0
-
--- | Lookup the value at a key in the map.
-lookup : MapKey k => k -> Map k v -> Optional v
-lookup k (Map t) = TextMap.lookup (keyToText k) t
-
--- | Is the key a member of the map?
-member : MapKey k => k -> Map k v -> Bool
-member k (Map t) = TextMap.member (keyToText k) t
-
--- | Filter the `Map` using a predicate: keep only the entries where the
--- value satisfies the predicate.
-filter : MapKey k => (v -> Bool) -> Map k v -> Map k v
-filter p = filterWithKey (const p)
-
--- | Filter the `Map` using a predicate: keep only the entries which
--- satisfy the predicate.
-filterWithKey : MapKey k => (k -> v -> Bool) -> Map k v -> Map k v
-filterWithKey p (Map t) = Map $ TextMap.filterWithKey (p . keyFromText) t
-
--- | Delete a key and its value from the map. When the key is not a
--- member of the map, the original map is returned.
-delete : MapKey k => k -> Map k v -> Map k v
-delete k (Map t) = Map $ TextMap.delete (keyToText k) t
-
--- | Insert a new key/value pair in the map. If the key is already
--- present in the map, the associated value is replaced with the
--- supplied value.
-insert : MapKey k => k -> v -> Map k v -> Map k v
-insert k v (Map t) = Map $ TextMap.insert (keyToText k) v t
-
--- | The union of two maps, preferring the first map when equal
--- keys are encountered.
-union : MapKey k => Map k v -> Map k v -> Map k v
-union (Map t1) (Map t2) = Map $ TextMap.union t1 t2
-
--- | Merge two maps. `merge f g h x y` applies `f` to all key/value pairs
--- whose key only appears in `x`, `g` to all pairs whose key only appears
--- in `y` and `h` to all pairs whose key appears in both `x` and `y`.
--- In the end, all pairs yielding `Some` are collected as the result.
-merge
-  :  MapKey k
-  => (k -> a -> Optional c)
-  -> (k -> b -> Optional c)
-  -> (k -> a -> b -> Optional c)
-  -> Map k a
-  -> Map k b
-  -> Map k c
-merge f g h (Map xs) (Map ys) = Map $ TextMap.merge (f . keyFromText) (g . keyFromText) (h . keyFromText) xs ys
-
-instance (MapKey k, Show k, Show v) => Show (Map k v) where
-  show m = "Map " <> show (toList m)
-
-deriving instance MapKey k => Semigroup (Map k v)
-
--- TODO(MH): The converter to Daml-LF can't handle deriving this right now.
--- It fails with "Coercion with symco."
--- deriving instance MapKey k => Monoid (Map k v)
-instance MapKey k => Monoid (Map k v) where
-  mempty = empty
-
-deriving instance MapKey k => Functor (Map k)
-
-instance MapKey k => Traversable.Traversable (Map k) where
-  mapA f (Map t) = fmap Map $ Traversable.mapA f t
diff --git a/compiler/damlc/daml-stdlib-src/DA/Next/Set.daml b/compiler/damlc/daml-stdlib-src/DA/Next/Set.daml
deleted file mode 100644
index a48ea63fc116..000000000000
--- a/compiler/damlc/daml-stdlib-src/DA/Next/Set.daml
+++ /dev/null
@@ -1,130 +0,0 @@
--- Copyright (c) 2021 Digital Asset (Switzerland) GmbH and/or its affiliates. All rights reserved.
--- SPDX-License-Identifier: Apache-2.0
-{-# OPTIONS -Wno-deprecations #-}
-{-# LANGUAGE CPP #-}
-
-#ifdef DAML_GENMAP
-
--- | `DA.Next.Set` is deprecated. Please use `DA.Set` instead.
-module DA.Next.Set
-  {-# DEPRECATED "DA.Next.Set is deprecated. Please use DA.Set instead." #-}
-
-#else
-
--- | Set - The `Set a` type represents a set of elements of type
--- `a`. Most operations require that `a` be an instance of the `MapKey`
--- type class.
-module DA.Next.Set
-
-#endif
-
-  ( Set
-  , empty
-  , size
-  , toList
-  , fromList
-  , toTextMap
-  , fromTextMap
-  , member
-  , null
-  , insert
-  , filter
-  , delete
-  , singleton
-  , union
-  , intersection
-  , difference
-  )
-where
-
-import Prelude hiding (filter, null, empty)
-import DA.Next.Map (MapKey (..))
-import DA.TextMap (TextMap)
-import DA.TextMap qualified as TextMap
-
--- | The type of a set.
-newtype Set a = Set with textMap : TextMap ()
-  deriving (Eq, Ord)
--- NOTE(MH): This is not a newtype wrapper around the `Map` type such that
--- people using `Set` over the Ledger API don't have to wrap every set into
--- two layers of newtypes.
-
--- | The empty set.
-empty : Set a
-empty = Set TextMap.empty
-
--- | The number of elements in the set.
-size : Set a -> Int
-size (Set t) = TextMap.size t
-
--- | Convert the set to a list of elements.
-toList : MapKey a => Set a -> [a]
-toList (Set t) = map (keyFromText . fst) $ TextMap.toList t
-
--- | Create a set from a list of elements.
-fromList : MapKey a => [a] -> Set a
-fromList xs = Set $ TextMap.fromList $ map (\x -> (keyToText x, ())) xs
-
--- | Convert a `Set` into a `TextMap`.
-toTextMap : Set Text -> TextMap ()
-toTextMap (Set t) = t
-
--- | Create a `Set` from a `TextMap`.
-fromTextMap : TextMap () -> Set Text
-fromTextMap = Set
-
--- | Is the element in the set?
-member : MapKey a => a -> Set a -> Bool
-member x (Set t) = TextMap.member (keyToText x) t
-
--- | Is this the empty set?
-null : Set a -> Bool
-null (Set t) = TextMap.null t
-
--- | Insert an element in a set. If the set already contains an
--- element equal to the given value, it is replaced with the new
--- value.
-insert : MapKey a => a -> Set a -> Set a
-insert x (Set t) = Set $ TextMap.insert (keyToText x) () t
-
--- | Filter all elements that satisfy the predicate.
-filter : MapKey a => (a -> Bool) -> Set a -> Set a
-filter p (Set t) = Set $ TextMap.filterWithKey (\x () -> p (keyFromText x)) t
-
--- | Delete an element from a set.
-delete : MapKey a => a -> Set a -> Set a
-delete x (Set t) = Set $ TextMap.delete (keyToText x) t
-
--- | Create a singleton set.
-singleton : MapKey a => a -> Set a
-singleton x = insert x empty
-
--- | The union of two sets, preferring the first set when equal
--- elements are encountered.
-union : MapKey a => Set a -> Set a -> Set a
-union (Set t1) (Set t2) = Set $ TextMap.union t1 t2
-
--- | The intersection of two sets. Elements of the result come from
--- the first set.
-intersection : MapKey a => Set a -> Set a -> Set a
-intersection s1 s2 = filter (`member` s2) s1
-
--- | `difference x y` returns the set consisting of all
--- elements in `x` that are not in `y`.
---
--- >>> fromList [1, 2, 3] `difference` fromList [1, 4]
--- fromList [2, 3]
-difference : MapKey a => Set a -> Set a -> Set a
-difference s1 s2 = filter (\x -> not (x `member` s2)) s1
-
-instance (MapKey a, Show a) => Show (Set a) where
-  show s = "Set " <> show (toList s)
-
-instance IsParties (Set Party) where
-  toParties = toList
-
-instance MapKey a => Semigroup (Set a) where
-  (<>) = union
-
-instance MapKey a => Monoid (Set a) where
-  mempty = empty
diff --git a/compiler/damlc/daml-stdlib-src/DA/Set.daml b/compiler/damlc/daml-stdlib-src/DA/Set.daml
index 70b0d63df5ca..65fa735f4742 100644
--- a/compiler/damlc/daml-stdlib-src/DA/Set.daml
+++ b/compiler/damlc/daml-stdlib-src/DA/Set.daml
@@ -4,13 +4,6 @@
 {-# LANGUAGE CPP #-}
 {-# OPTIONS_GHC -Wno-orphans #-}
 
-#ifndef DAML_GENMAP
-
--- | HIDE
-module DA.Set where
-
-#else
-
 -- | Note: This is only supported in DAML-LF 1.11 or later.
 --
 -- This module exports the generic set type `Set k` and associated
@@ -159,4 +152,3 @@ instance Foldable.Foldable Set where
   foldMap f xs = Foldable.foldMap f (DA.Set.toList xs)
   length = size
   null = DA.Set.null
-#endif
diff --git a/compiler/damlc/daml-stdlib-src/DA/Set/Types.daml b/compiler/damlc/daml-stdlib-src/DA/Set/Types.daml
index 9826a53f5f53..c985c6980ce0 100644
--- a/compiler/damlc/daml-stdlib-src/DA/Set/Types.daml
+++ b/compiler/damlc/daml-stdlib-src/DA/Set/Types.daml
@@ -3,13 +3,6 @@
 
 {-# LANGUAGE CPP #-}
 
-#ifndef DAML_GENMAP
-
--- | HIDE
-module DA.Set.Types where
-
-#else
-
 -- | MOVE DA.Set
 module DA.Set.Types where
 
@@ -18,5 +11,3 @@ import DA.Internal.LF (Map)
 -- | The type of a set. This is a wrapper over the `Map` type.
 data Set k = Set with
     map : Map k ()
-
-#endif
diff --git a/compiler/damlc/daml-stdlib-src/LibraryModules.daml b/compiler/damlc/daml-stdlib-src/LibraryModules.daml
index 43d957b544db..ffa924eccb40 100644
--- a/compiler/damlc/daml-stdlib-src/LibraryModules.daml
+++ b/compiler/damlc/daml-stdlib-src/LibraryModules.daml
@@ -40,8 +40,6 @@ import DA.Math
 import DA.Maybe.Total
 import DA.Maybe
 import DA.Monoid
-import DA.Next.Map
-import DA.Next.Set
 import DA.NonEmpty
 import DA.Numeric
 import DA.Optional.Total
diff --git a/compiler/damlc/tests/daml-test-files/NextMap.daml b/compiler/damlc/tests/daml-test-files/NextMap.daml
deleted file mode 100644
index 1f07d40c29ae..000000000000
--- a/compiler/damlc/tests/daml-test-files/NextMap.daml
+++ /dev/null
@@ -1,77 +0,0 @@
--- We test for deprecations in NextMapDeprecated
-{-# OPTIONS -Wno-deprecations #-}
--- Copyright (c) 2020, Digital Asset (Switzerland) GmbH and/or its affiliates.
--- All rights reserved.
--- @ERROR could not parse ""notaparty"" as 'Party'
--- @ERROR could not parse "not-an-int" as 'Int'
--- @ERROR could not parse "not-a-decimal" as 'Decimal'
-module NextMap where
-
-import DA.Next.Map as M
-import DA.Assert
-
-testEmpty = scenario do
-  0 === size M.empty
-  [] === toList (M.empty : Map Int Decimal)
-
-testSize = scenario do
-  0 === size (fromList ([] : [(Int, Decimal)]))
-  3 === size (fromList ([(1, 2.0), (2, 9.0), (3, 2.2)] : [(Int, Decimal)]))
-
-testToList = scenario do
-  [(1, "c"), (2, "a"), (5, "b")] === toList (fromList [(2, "a"), (5, "b"), (1, "c")])
-
-testFromList = scenario do
-  False === member 2 (fromList [(1, "a"), (3, "b"), (4, "c")])
-  True === member 3 (fromList [(1, "a"), (3, "b"), (4, "c")])
-  [(1, "b")] === toList (fromList [(1, "a"), (1, "c"), (1, "b")])
-
-testFromListWith = scenario do
-  fromListWith (<>) [(5,"a"), (5,"b"), (3,"b"), (3,"a"), (5,"c")] === fromList [(3, "ba"), (5, "abc")]
-  fromListWith (<>) [] === (M.empty : Map Int Text)
-
-testMember = scenario do
-  False === member "a" (fromList ([("", 1.0), ("b", 2.0), ("c", 3.0)] : [(Text, Decimal)]))
-  True === member "" (fromList ([("", 1.0), ("b", 2.0), ("c", 3.0)] : [(Text, Decimal)]))
-  False === member 2 (fromList [])
-
-testLookup = scenario do
-  None === M.lookup "a" (fromList ([("", 1.0), ("b", 2.0), ("c", 3.0)] : [(Text, Decimal)]))
-  Some 1.0 === M.lookup "" (fromList ([("", 1.0), ("b", 2.0), ("c", 3.0)] : [(Text, Decimal)]))
-  None === M.lookup 2 (fromList ([] : [(Int, Text)]))
-
-testNull = scenario do
-  True === M.null M.empty
-  False === M.null (insert 5 "a" M.empty)
-  False === M.null (fromList [(1, "a"), (2, "b"), (3, "c")])
-  True === M.null (fromList ([] : [(Int, Party)]))
-
-testInsert = scenario do
-  [(1, True), (2, False), (3, True), (4, False), (5, False)] === toList
-    (foldl (\a b -> uncurry insert b a) M.empty [(3, True), (1, False), (4, False), (2, True), (5, False), (2, False), (1, True)])
-
-testFilterWithKey = scenario do
-  [(1, True), (2, False), (3, True)] === toList (M.filterWithKey (\k v -> k < 3 || v) (fromList [(3, True), (1, False), (4, False), (2, True), (5, False), (2, False), (1, True)]))
-
-testDelete = scenario do
-  [(2, False), (3, True), (4, False), (5, False)] === toList (delete 1 (fromList [(3, True), (1, False), (4, False), (2, True), (5, False), (2, False), (1, True)]))
-  [(1, False), (2, True)] === toList (delete 3 (fromList [(2, False), (1, True), (2, True), (1, False)]))
-
-testMerge = scenario do
-  let m1 = fromList [(3, "aa"), (1, "bb"), (4, "cc"), (2, "dd"), (6, "ee")]
-  let m2 = fromList [(1, "a"), (3, "b"), (2, "c"), (5, "d"), (0, "e")]
-
-  [] === toList (merge (\_ v -> Some v) (\_ v -> Some v) (\_ v _ -> Some v) M.empty (M.empty : Map Int Text))
-  [] === toList (merge (\_ v -> Some v) (\_ v -> Some v) (\_ _ _ -> None) m1 m1)
-  [(1, "bb"), (3, "aa")] === toList (merge (\_ v -> if v <= "bb" then Some v else None) (\_ v -> Some v) (\_ _ _ -> None) m1 M.empty)
-  [(1, "a"), (3, "b")] === toList (merge (\_ v -> Some v) (\_ v -> if v <= "bb" then Some v else None) (\_ _ _ -> None) M.empty m2)
-  [(1,"bb"), (2,"dd"), (3,"aa")] === toList (merge (\_ _ -> None) (\_ _ -> None) (\_ v _ -> Some v) m1 m2)
-
-testMapKeyParty = scenario do
-  pure $ keyFromText @Party "\"notaparty\""
-
-testMapKeyInt = scenario do
-  pure $ keyFromText @Int "not-an-int"
-
-testMapKeyDecimal = scenario do
-  pure $ keyFromText @Decimal "not-a-decimal"
diff --git a/compiler/damlc/tests/daml-test-files/NextMapDeprecated.daml b/compiler/damlc/tests/daml-test-files/NextMapDeprecated.daml
deleted file mode 100644
index 5df6d87584b0..000000000000
--- a/compiler/damlc/tests/daml-test-files/NextMapDeprecated.daml
+++ /dev/null
@@ -1,8 +0,0 @@
--- Copyright (c) 2021, Digital Asset (Switzerland) GmbH and/or its affiliates.
--- All rights reserved.
-
--- @SINCE-LF 1.11
--- @WARN DA.Next.Map is deprecated. Please use DA.Map instead.
-module NextMapDeprecated where
-import DA.Next.Map ()
-
diff --git a/compiler/damlc/tests/daml-test-files/NextSet.daml b/compiler/damlc/tests/daml-test-files/NextSet.daml
deleted file mode 100644
index 05c239ded68e..000000000000
--- a/compiler/damlc/tests/daml-test-files/NextSet.daml
+++ /dev/null
@@ -1,67 +0,0 @@
--- We test for deprecations in NextMapDeprecated
-{-# OPTIONS -Wno-deprecations #-}
--- Copyright (c) 2020, Digital Asset (Switzerland) GmbH and/or its affiliates.
--- All rights reserved.
-
-module NextSet where
-
-import DA.Next.Set as S
-import DA.Assert
-
-testEmpty = scenario do
-  0 === size S.empty
-  [] === toList (S.empty : Set Decimal)
-
-testSize = scenario do
-  0 === size (fromList ([] : [Decimal]))
-  3 === size (fromList [1, 2, 3])
-
-testToList = scenario do
-  [1, 2, 5] === toList (fromList [2, 5, 1])
-
-testFromList = scenario do
-  False === member 2 (fromList [1, 3, 4])
-  True === member 3 (fromList [1, 3, 4])
-  [1] === toList (fromList [1, 1, 1, 1])
-
-testMember = scenario do
-  False === member "a" (fromList ["", "b", "c"])
-  True === member "" (fromList ["", "b", "c"])
-  False === member 2 (fromList [])
-
-testNull = scenario do
-  True === S.null S.empty
-  False === S.null (insert 5 S.empty)
-  False === S.null (fromList [1, 2, 3])
-  True === S.null (fromList ([] : [Int]))
-
-testInsert = scenario do
-  [1, 2, 3, 4, 5] === toList (foldl (\a b -> insert b a) S.empty [3, 1, 4, 2, 5, 2, 1])
-
-testFilter = scenario do
-  [1, 2] === toList (S.filter (<3) (fromList [3, 1, 4, 2, 5, 2, 1]))
-
-testDelete = scenario do
-  [2, 3, 4, 5] === toList (delete 1 (fromList [3, 1, 4, 2, 5, 2, 1]))
-  [1, 2] === toList (delete 3 (fromList [2, 1, 2, 1]))
-
-testSingleton = scenario do
-  [1] === toList (singleton 1)
-
-testUnion = scenario do
-  [1, 2, 3, 4, 5] === toList (fromList [1, 5, 3] `union` fromList [4, 3, 2])
-  [2, 4] === toList (S.empty `union` fromList [4, 2])
-  [1, 3, 5] === toList (fromList [1, 5, 3] `union` S.empty)
-  [] === toList (S.empty `union` fromList ([] : [Int]))
-
-testIntersection = scenario do
-  [3, 5, 9] === toList (intersection (fromList [9, 1, 5, 6, 8, 3]) (fromList [4, 3, 7, 2, 5, 9]))
-  [] === toList (intersection S.empty (fromList [4, 2]))
-  [] === toList (intersection (fromList [1, 5, 3]) S.empty)
-  [] === toList (intersection S.empty (fromList ([] : [Int])))
-
-testDifference = scenario do
-  [1, 6] === toList (difference (fromList [1, 5, 3, 6]) (fromList [4, 3, 2, 5]))
-  [] === toList (difference S.empty (fromList [4, 2]))
-  [1, 3, 5] === toList (difference (fromList [1, 5, 3]) S.empty)
-  [] === toList (difference S.empty (fromList ([] : [Int])))
diff --git a/compiler/damlc/tests/daml-test-files/NextSetDeprecated.daml b/compiler/damlc/tests/daml-test-files/NextSetDeprecated.daml
deleted file mode 100644
index ab5c0c8e0653..000000000000
--- a/compiler/damlc/tests/daml-test-files/NextSetDeprecated.daml
+++ /dev/null
@@ -1,8 +0,0 @@
--- Copyright (c) 2021, Digital Asset (Switzerland) GmbH and/or its affiliates.
--- All rights reserved.
-
--- @SINCE-LF 1.11
--- @WARN DA.Next.Set is deprecated. Please use DA.Set instead.
-module NextSetDeprecated where
-import DA.Next.Set ()
-
diff --git a/compiler/damlc/tests/src/DA/Test/UnstableTypes.hs b/compiler/damlc/tests/src/DA/Test/UnstableTypes.hs
index c540ba5fecb6..3803fde196de 100644
--- a/compiler/damlc/tests/src/DA/Test/UnstableTypes.hs
+++ b/compiler/damlc/tests/src/DA/Test/UnstableTypes.hs
@@ -67,8 +67,6 @@ damlStdlibTypes ver
         ]
     types = map (bimap LF.ModuleName LF.TypeConName)
         [ (["DA", "Random"], ["Minstd"])
-        , (["DA", "Next", "Set"], ["Set"])
-        , (["DA", "Next", "Map"], ["Map"])
         , (["DA", "Generics"], ["DecidedStrictness"])
         , (["DA", "Generics"], ["SourceStrictness"])
         , (["DA", "Generics"], ["SourceUnpackedness"])
@@ -80,4 +78,3 @@ damlStdlibTypes ver
         , (["DA", "Generics"], ["U1"])
         , (["DA", "Stack"], ["SrcLoc"])
         ]
-
diff --git a/daml-lf/tests/scenario/stable/contract-key-through-exercises/EXPECTED.ledger b/daml-lf/tests/scenario/stable/contract-key-through-exercises/EXPECTED.ledger
index 87a7bcc55345..4b0986482338 100644
--- a/daml-lf/tests/scenario/stable/contract-key-through-exercises/EXPECTED.ledger
+++ b/daml-lf/tests/scenario/stable/contract-key-through-exercises/EXPECTED.ledger
@@ -5,7 +5,7 @@ TX #0 1970-01-01T00:00:00Z [Test:48] version: 14
 │   referenced by #1:0
 │   known to (since): Alice (#0), Bob (#0)
 └─> create Test:KeyOps@XXXXXXXX
-    with: { signatories = DA.Next.Set:Set@XXXXXXXX{ textMap = TextMap(Alice -> <unit>) }, counterParty = 'Bob' }
+    with: { signatories = DA.Set.Types:Set@XXXXXXXX{ map = GenMap('Alice' -> <unit>) }, counterParty = 'Bob' }
 
 TX #1 1970-01-01T00:00:00Z [Test:49] version: 14
 #1:0 version: 14
@@ -17,30 +17,30 @@ TX #1 1970-01-01T00:00:00Z [Test:49] version: 14
     │   referenced by #2:0, #3:0, #5:0
     │   known to (since): Alice (#1), Bob (#1)
     └─> create Test:KeyOps@XXXXXXXX
-        with: { signatories = DA.Next.Set:Set@XXXXXXXX{ textMap = TextMap(Alice -> <unit>, Bob -> <unit>) }, counterParty = 'Bob' }
+        with: { signatories = DA.Set.Types:Set@XXXXXXXX{ map = GenMap('Alice' -> <unit>, 'Bob' -> <unit>) }, counterParty = 'Bob' }
 
 TX #2 1970-01-01T00:00:00Z [Test:51] version: 14
 #2:0 version: 14
 │   known to (since): Alice (#2), Bob (#2)
 └─> Alice exercises LookupGivenKey:Test:KeyOps@XXXXXXXX on 00420cfea44e4d7f536caf95c9a45394bdc0994e38cbff3b02c444d39bd3ba3d9a
-    with { actor = 'Alice', keyMaintainers = DA.Next.Set:Set@XXXXXXXX{ textMap = TextMap(Alice -> <unit>) } }
+    with { actor = 'Alice', keyMaintainers = DA.Set.Types:Set@XXXXXXXX{ map = GenMap('Alice' -> <unit>) } }
     children:
     #2:1 version: 14
     │   known to (since): Alice (#2), Bob (#2)
     └─> lookup by key Test:BasicKey@XXXXXXXX
-    key { textMap = TextMap(Alice -> <unit>) }
+    key { map = GenMap('Alice' -> <unit>) }
     not found
 
 TX #3 1970-01-01T00:00:00Z [Test:54] version: 14
 #3:0 version: 14
 │   known to (since): Alice (#3), Bob (#3)
 └─> Bob exercises LookupGivenKey:Test:KeyOps@XXXXXXXX on 00420cfea44e4d7f536caf95c9a45394bdc0994e38cbff3b02c444d39bd3ba3d9a
-    with { actor = 'Bob', keyMaintainers = DA.Next.Set:Set@XXXXXXXX{ textMap = TextMap(Alice -> <unit>) } }
+    with { actor = 'Bob', keyMaintainers = DA.Set.Types:Set@XXXXXXXX{ map = GenMap('Alice' -> <unit>) } }
     children:
     #3:1 version: 14
     │   known to (since): Alice (#3), Bob (#3)
     └─> lookup by key Test:BasicKey@XXXXXXXX
-    key { textMap = TextMap(Alice -> <unit>) }
+    key { map = GenMap('Alice' -> <unit>) }
     not found
 
 TX #4 1970-01-01T00:00:00Z [Test:57] version: 14
@@ -48,19 +48,19 @@ TX #4 1970-01-01T00:00:00Z [Test:57] version: 14
 │   referenced by #5:1
 │   known to (since): Alice (#4)
 └─> create Test:BasicKey@XXXXXXXX
-    with: { owners = DA.Next.Set:Set@XXXXXXXX{ textMap = TextMap(Alice -> <unit>) } }
-key { textMap = TextMap(Alice -> <unit>) }
+    with: { owners = DA.Set.Types:Set@XXXXXXXX{ map = GenMap('Alice' -> <unit>) } }
+key { map = GenMap('Alice' -> <unit>) }
 
 TX #5 1970-01-01T00:00:00Z [Test:59] version: 14
 #5:0 version: 14
 │   known to (since): Alice (#5), Bob (#5)
 └─> Alice exercises LookupGivenKey:Test:KeyOps@XXXXXXXX on 00420cfea44e4d7f536caf95c9a45394bdc0994e38cbff3b02c444d39bd3ba3d9a
-    with { actor = 'Alice', keyMaintainers = DA.Next.Set:Set@XXXXXXXX{ textMap = TextMap(Alice -> <unit>) } }
+    with { actor = 'Alice', keyMaintainers = DA.Set.Types:Set@XXXXXXXX{ map = GenMap('Alice' -> <unit>) } }
     children:
     #5:1 version: 14
     │   known to (since): Alice (#5), Bob (#5)
     └─> lookup by key Test:BasicKey@XXXXXXXX
-    key { textMap = TextMap(Alice -> <unit>) }
+    key { map = GenMap('Alice' -> <unit>) }
     found 003cb3efc384096d3804f43242d5a20876071b307e08fb06787cf6a3786ee833b2
 
 mustFailAt actAs: {'Bob'} readAs: {} [Test:62]
diff --git a/daml-lf/tests/scenario/stable/contract-key-through-exercises/Test.daml b/daml-lf/tests/scenario/stable/contract-key-through-exercises/Test.daml
index a6f2390d6eb4..671b437c63ed 100644
--- a/daml-lf/tests/scenario/stable/contract-key-through-exercises/Test.daml
+++ b/daml-lf/tests/scenario/stable/contract-key-through-exercises/Test.daml
@@ -3,8 +3,8 @@
 
 module Test where
 
-import qualified DA.Next.Set as S
-import DA.Next.Set (Set)
+import qualified DA.Set as S
+import DA.Set (Set)
 
 template BasicKey
   with
diff --git a/docs/source/upgrade/example/carbon-upgrade-trigger/daml/UpgradeTrigger.daml b/docs/source/upgrade/example/carbon-upgrade-trigger/daml/UpgradeTrigger.daml
index 649159902a58..6153c95f6649 100644
--- a/docs/source/upgrade/example/carbon-upgrade-trigger/daml/UpgradeTrigger.daml
+++ b/docs/source/upgrade/example/carbon-upgrade-trigger/daml/UpgradeTrigger.daml
@@ -6,11 +6,7 @@ module UpgradeTrigger where
 
 import DA.Assert
 import DA.Foldable
-#ifdef DAML_GENMAP && DAML_GENERIC_COMPARISON
 import qualified DA.Map as Map
-#else
-import qualified DA.Next.Map as Map
-#endif
 import Daml.Trigger
 import Daml.Trigger.Assert
 import qualified Daml.Script as Script
diff --git a/triggers/daml/Daml/Trigger.daml b/triggers/daml/Daml/Trigger.daml
index 1dd8b3b5c9fb..3a0d124d83ee 100644
--- a/triggers/daml/Daml/Trigger.daml
+++ b/triggers/daml/Daml/Trigger.daml
@@ -52,13 +52,8 @@ import DA.Action
 import DA.Action.State (execState)
 import DA.Foldable (any)
 import DA.Functor ((<&>))
-#ifdef DAML_GENMAP && DAML_GENERIC_COMPARISON
 import DA.Map (Map)
 import qualified DA.Map as Map
-#else
-import DA.Next.Map (Map)
-import qualified DA.Next.Map as Map
-#endif
 import DA.Optional
 
 import Daml.Trigger.Internal
@@ -71,11 +66,8 @@ import qualified Daml.Trigger.LowLevel as LowLevel
 getContracts : forall a. Template a => ACS -> [(ContractId a, a)]
 getContracts acs@(ACS tpls _) = mapOptional fromAny
                                 $ filter (\(cid, _) -> not $ cid `elem` allPending)
-#ifdef DAML_GENMAP && DAML_GENERIC_COMPARISON
                                 $ optional [] Map.toList
-                                $ Map.lookup (templateTypeRep @a)
-#endif
-                                  tpls
+                                $ Map.lookup (templateTypeRep @a) tpls
   where
     fromAny (cid, tpl) = (,) <$> fromAnyContractId cid <*> fromAnyTemplate tpl
     allPending = getPendingContracts acs
@@ -86,11 +78,7 @@ getPendingContracts (ACS _ pending) = concatMap snd $ Map.toList pending
 getContractById : forall a. Template a => ContractId a -> ACS -> Optional a
 getContractById id (ACS tpls pending) = do
   let aid = toAnyContractId id
-#ifdef DAML_GENMAP && DAML_GENERIC_COMPARISON
       implSpecific = Map.lookup aid <=< Map.lookup (templateTypeRep @a)
-#else
-      implSpecific = fmap snd . find ((aid ==) . fst)
-#endif
   aa <- implSpecific tpls
   a <- fromAnyTemplate aa
   if any (elem aid) pending then None else Some a
diff --git a/triggers/daml/Daml/Trigger/Assert.daml b/triggers/daml/Daml/Trigger/Assert.daml
index a27344cf3b58..68aa12c46d81 100644
--- a/triggers/daml/Daml/Trigger/Assert.daml
+++ b/triggers/daml/Daml/Trigger/Assert.daml
@@ -14,13 +14,8 @@ module Daml.Trigger.Assert
  ) where
 
 import qualified DA.List as List
-#ifdef DAML_GENMAP && DAML_GENERIC_COMPARISON
 import DA.Map (Map)
 import qualified DA.Map as Map
-#else
-import DA.Next.Map (Map)
-import qualified DA.Next.Map as Map
-#endif
 import qualified DA.Text as Text
 
 import Daml.Trigger hiding (queryContractId)
diff --git a/triggers/daml/Daml/Trigger/Internal.daml b/triggers/daml/Daml/Trigger/Internal.daml
index b40c81518321..602977be6fca 100644
--- a/triggers/daml/Daml/Trigger/Internal.daml
+++ b/triggers/daml/Daml/Trigger/Internal.daml
@@ -24,14 +24,9 @@ module Daml.Trigger.Internal
 
 import DA.Action.State
 import DA.Functor ((<&>))
-#ifdef DAML_GENMAP && DAML_GENERIC_COMPARISON
 import DA.Map (Map)
 import qualified DA.Map as Map
 import DA.Optional (fromOptional)
-#else
-import DA.Next.Map (Map)
-import qualified DA.Next.Map as Map
-#endif
 
 import Daml.Trigger.LowLevel hiding (Trigger)
 
@@ -42,13 +37,7 @@ import Daml.Trigger.LowLevel hiding (Trigger)
 
 -- This will change to a Map once we have proper maps in Daml-LF
 data ACS = ACS
-  { activeContracts :
-#ifdef DAML_GENMAP && DAML_GENERIC_COMPARISON
-      Map.Map TemplateTypeRep
-        (Map.Map AnyContractId AnyTemplate)
-#else
-      [(AnyContractId, AnyTemplate)]
-#endif
+  { activeContracts : Map.Map TemplateTypeRep (Map.Map AnyContractId AnyTemplate)
   , pendingContracts : Map CommandId [AnyContractId]
   }
 
@@ -113,44 +102,27 @@ addCommands m (Commands cid cmds) = Map.insert cid cmds m
 
 -- | HIDE
 insertTpl : AnyContractId -> AnyTemplate -> ACS -> ACS
-#ifdef DAML_GENMAP && DAML_GENERIC_COMPARISON
 insertTpl cid tpl acs = acs { activeContracts = Map.alter addct cid.templateId acs.activeContracts }
   where addct = Some . Map.insert cid tpl . fromOptional mempty
-#else
-insertTpl cid tpl acs = acs { activeContracts = (cid, tpl) :: acs.activeContracts }
-#endif
 
 -- | HIDE
-#ifdef DAML_GENMAP && DAML_GENERIC_COMPARISON
 groupActiveContracts :
   [(AnyContractId, AnyTemplate)] -> Map.Map TemplateTypeRep (Map.Map AnyContractId AnyTemplate)
 groupActiveContracts = foldr (\v@(cid, _) -> Map.alter (addct v) cid.templateId) Map.empty
   where addct (cid, tpl) = Some . Map.insert cid tpl . fromOptional mempty
-#else
-groupActiveContracts : forall a. a -> a
-groupActiveContracts a = a
-#endif
 
 -- | HIDE
 deleteTpl : AnyContractId -> ACS -> ACS
-#ifdef DAML_GENMAP && DAML_GENERIC_COMPARISON
 deleteTpl cid acs = acs { activeContracts = Map.alter rmct cid.templateId acs.activeContracts }
   where rmct om = do
           m <- om
           let m' = Map.delete cid m
           if Map.null m' then None else Some m'
-#else
-deleteTpl cid acs = acs { activeContracts = filter (\(cid', _) -> cid /= cid') acs.activeContracts }
-#endif
 
 -- | HIDE
 lookupTpl : Template a => AnyContractId -> ACS -> Optional a
 lookupTpl cid acs = do
-#ifdef DAML_GENMAP && DAML_GENERIC_COMPARISON
   tpl <- Map.lookup cid =<< Map.lookup cid.templateId acs.activeContracts
-#else
-  (_, tpl) <- find ((cid ==) . fst) acs.activeContracts
-#endif
   fromAnyTemplate tpl
 
 -- | HIDE
diff --git a/triggers/daml/Daml/Trigger/LowLevel.daml b/triggers/daml/Daml/Trigger/LowLevel.daml
index db3f41bc40ea..0c08e1129a49 100644
--- a/triggers/daml/Daml/Trigger/LowLevel.daml
+++ b/triggers/daml/Daml/Trigger/LowLevel.daml
@@ -1,6 +1,5 @@
 -- Copyright (c) 2021 Digital Asset (Switzerland) GmbH and/or its affiliates. All rights reserved.
 -- SPDX-License-Identifier: Apache-2.0
-{-# LANGUAGE CPP #-}
 {-# LANGUAGE AllowAmbiguousTypes #-}
 
 module Daml.Trigger.LowLevel
@@ -47,9 +46,6 @@ module Daml.Trigger.LowLevel
 import DA.Action.State
 import DA.Action.State.Class
 import DA.Functor ((<&>))
-#ifndef DAML_GENMAP && DAML_GENERIC_COMPARISON
-import DA.Next.Map (MapKey(..))
-#endif
 import DA.Time (RelTime(..))
 import Daml.Script.Free (Free(..), lift, foldFree)
 
@@ -60,9 +56,7 @@ data AnyContractId = AnyContractId
   , contractId : ContractId ()
   } deriving Eq
 
-#ifdef DAML_GENERIC_COMPARISON
 deriving instance Ord AnyContractId
-#endif
 
 -- We can’t derive the Show instance since TemplateTypeRep does not have a Show instance
 -- but it is useful for debugging so we add one that omits the type.
@@ -93,11 +87,7 @@ newtype EventId = EventId Text
   deriving (Show, Eq)
 
 newtype CommandId = CommandId Text
-#ifndef DAML_GENMAP && DAML_GENERIC_COMPARISON
-  deriving (Show, Eq, Ord, MapKey)
-#else
   deriving (Show, Eq, Ord)
-#endif
 
 data Transaction = Transaction
  { transactionId : TransactionId
@@ -272,7 +262,7 @@ liftStateT ma = StateT $ \s -> (,s) <$> ma
 instance Action m => Applicative (StateT s m) where
   pure a = StateT (\s -> pure (a, s))
   f <*> x = f >>= (<$> x)
-  
+
 instance Action m => Action (StateT s m) where
   StateT x >>= f = StateT $ \s -> do
     (x', s') <- x s
diff --git a/triggers/tests/daml/TemplateIdFilter.daml b/triggers/tests/daml/TemplateIdFilter.daml
index a8f874cd0813..5212ea7fc247 100644
--- a/triggers/tests/daml/TemplateIdFilter.daml
+++ b/triggers/tests/daml/TemplateIdFilter.daml
@@ -5,11 +5,7 @@
 module TemplateIdFilter where
 
 import Prelude hiding (test)
-#ifdef DAML_GENMAP && DAML_GENERIC_COMPARISON
 import qualified DA.Map as Map
-#else
-import qualified DA.Next.Map as Map
-#endif
 import Daml.Trigger
 
 test : RegisteredTemplates -> Trigger ()
diff --git a/triggers/tests/scenarios/Rule.daml b/triggers/tests/scenarios/Rule.daml
index c0fcb48cba50..f78d1fc49fae 100644
--- a/triggers/tests/scenarios/Rule.daml
+++ b/triggers/tests/scenarios/Rule.daml
@@ -6,11 +6,7 @@ module Rule where
 
 import DA.Action
 import DA.Assert
-#ifdef DAML_GENMAP && DAML_GENERIC_COMPARISON
 import qualified DA.Map as Map
-#else
-import qualified DA.Next.Map as Map
-#endif
 import Daml.Trigger
 import Daml.Trigger.Assert
 import qualified Daml.Script as Script