diff --git a/lib/src/iterable/built_iterable.dart b/lib/src/iterable/built_iterable.dart
index 7011f7d..db132f5 100644
--- a/lib/src/iterable/built_iterable.dart
+++ b/lib/src/iterable/built_iterable.dart
@@ -11,4 +11,6 @@ abstract class BuiltIterable<E> implements Iterable<E> {
 
   /// Converts to a [BuiltSet].
   BuiltSet<E> toBuiltSet();
+
+  const BuiltIterable();
 }
diff --git a/lib/src/list/built_list.dart b/lib/src/list/built_list.dart
index 089cfbd..88abc7e 100644
--- a/lib/src/list/built_list.dart
+++ b/lib/src/list/built_list.dart
@@ -15,23 +15,27 @@ part of '../list.dart';
 /// for the general properties of Built Collections.
 abstract class BuiltList<E> implements Iterable<E>, BuiltIterable<E> {
   final List<E> _list;
-  int? _hashCode;
 
   /// Instantiates with elements from an [Iterable].
   factory BuiltList([Iterable iterable = const []]) {
-    if (iterable is _BuiltList && iterable.hasExactElementType(E)) {
+    if ((iterable is _BuiltList && iterable.hasExactElementType(E)) ||
+        (iterable is _ConstBuiltList && iterable.hasExactElementType(E))) {
       return iterable as BuiltList<E>;
     } else {
       return _BuiltList<E>.from(iterable);
     }
   }
 
+  const factory BuiltList.fromList([List<E> list]) =
+      _ConstBuiltList<E>.withSafeList;
+
   /// Instantiates with elements from an [Iterable<E>].
   ///
   /// `E` must not be `dynamic`.
   factory BuiltList.of(Iterable<E> iterable) {
-    if (iterable is _BuiltList<E> && iterable.hasExactElementType(E)) {
-      return iterable;
+    if ((iterable is _BuiltList<E> && iterable.hasExactElementType(E)) ||
+        iterable is _ConstBuiltList<E> && iterable.hasExactElementType(E)) {
+      return iterable as BuiltList<E>;
     } else {
       return _BuiltList<E>.of(iterable);
     }
@@ -61,10 +65,7 @@ abstract class BuiltList<E> implements Iterable<E>, BuiltIterable<E> {
   /// A `BuiltList` is only equal to another `BuiltList` with equal elements in
   /// the same order. Then, the `hashCode` is guaranteed to be the same.
   @override
-  int get hashCode {
-    _hashCode ??= hashObjects(_list);
-    return _hashCode!;
-  }
+  int get hashCode => hashObjects(_list);
 
   /// Deep equality.
   ///
@@ -234,11 +235,19 @@ abstract class BuiltList<E> implements Iterable<E>, BuiltIterable<E> {
 
   // Internal.
 
-  BuiltList._(this._list);
+  const BuiltList._(this._list);
 }
 
 /// Default implementation of the public [BuiltList] interface.
 class _BuiltList<E> extends BuiltList<E> {
+  int? _hashCode;
+
+  @override
+  int get hashCode {
+    _hashCode ??= super.hashCode;
+    return _hashCode!;
+  }
+
   _BuiltList.withSafeList(List<E> list) : super._(list);
 
   _BuiltList.from([Iterable iterable = const []])
@@ -265,6 +274,12 @@ class _BuiltList<E> extends BuiltList<E> {
   bool hasExactElementType(Type type) => E == type;
 }
 
+/// An alternative implementation of BuiltList that supports a const constructor
+class _ConstBuiltList<E> extends BuiltList<E> {
+  const _ConstBuiltList.withSafeList([List<E> list = const []]) : super._(list);
+  bool hasExactElementType(Type type) => E == type;
+}
+
 /// Extensions for [BuiltList] on [List].
 extension BuiltListExtension<T> on List<T> {
   /// Converts to a [BuiltList].
diff --git a/lib/src/list/list_builder.dart b/lib/src/list/list_builder.dart
index a9a1413..4bc895f 100644
--- a/lib/src/list/list_builder.dart
+++ b/lib/src/list/list_builder.dart
@@ -13,7 +13,7 @@ part of '../list.dart';
 /// for the general properties of Built Collections.
 class ListBuilder<E> {
   late List<E> _list;
-  _BuiltList<E>? _listOwner;
+  BuiltList<E>? _listOwner;
 
   /// Instantiates with elements from an [Iterable].
   factory ListBuilder([Iterable iterable = const []]) {
@@ -38,7 +38,7 @@ class ListBuilder<E> {
 
   /// Replaces all elements with elements from an [Iterable].
   void replace(Iterable iterable) {
-    if (iterable is _BuiltList<E>) {
+    if (iterable is BuiltList<E>) {
       _setOwner(iterable);
     } else {
       _setSafeList(List<E>.from(iterable));
@@ -258,7 +258,7 @@ class ListBuilder<E> {
 
   ListBuilder._uninitialized();
 
-  void _setOwner(_BuiltList<E> listOwner) {
+  void _setOwner(BuiltList<E> listOwner) {
     _list = listOwner._list;
     _listOwner = listOwner;
   }
diff --git a/lib/src/list_multimap/built_list_multimap.dart b/lib/src/list_multimap/built_list_multimap.dart
index 3092ed5..8d95d0b 100644
--- a/lib/src/list_multimap/built_list_multimap.dart
+++ b/lib/src/list_multimap/built_list_multimap.dart
@@ -17,19 +17,16 @@ part of '../list_multimap.dart';
 abstract class BuiltListMultimap<K, V> {
   final Map<K, BuiltList<V>> _map;
 
-  // Precomputed.
-  final BuiltList<V> _emptyList = BuiltList<V>();
-
-  // Cached.
-  int? _hashCode;
-  Iterable<K>? _keys;
-  Iterable<V>? _values;
+  const factory BuiltListMultimap.fromMap([Map<K, BuiltList<V>> map]) =
+      _ConstBuiltListMultimap.withSafeMap;
 
   /// Instantiates with elements from a [Map], [ListMultimap] or
   /// [BuiltListMultimap].
   factory BuiltListMultimap([multimap = const {}]) {
     if (multimap is _BuiltListMultimap &&
-        multimap.hasExactKeyAndValueTypes(K, V)) {
+            multimap.hasExactKeyAndValueTypes(K, V) ||
+        multimap is _ConstBuiltListMultimap &&
+            multimap.hasExactKeyAndValueTypes(K, V)) {
       return multimap as BuiltListMultimap<K, V>;
     } else if (multimap is Map) {
       return _BuiltListMultimap<K, V>.copy(multimap.keys, (k) => multimap[k]);
@@ -72,11 +69,12 @@ abstract class BuiltListMultimap<K, V> {
   /// to be the same.
   @override
   int get hashCode {
-    _hashCode ??= hashObjects(_map.keys
-        .map((key) => hash2(key.hashCode, _map[key].hashCode))
-        .toList(growable: false)
-      ..sort());
-    return _hashCode!;
+    return hashObjects(
+      _map.keys
+          .map((key) => hash2(key.hashCode, _map[key].hashCode))
+          .toList(growable: false)
+        ..sort(),
+    );
   }
 
   /// Deep equality.
@@ -109,7 +107,7 @@ abstract class BuiltListMultimap<K, V> {
   /// As [ListMultimap], but results are [BuiltList]s and not mutable.
   BuiltList<V> operator [](Object? key) {
     var result = _map[key];
-    return result ?? _emptyList;
+    return result ?? BuiltList<V>();
   }
 
   /// As [ListMultimap.containsKey].
@@ -142,24 +140,18 @@ abstract class BuiltListMultimap<K, V> {
 
   /// As [ListMultimap.keys], but result is stable; it always returns the same
   /// instance.
-  Iterable<K> get keys {
-    _keys ??= _map.keys;
-    return _keys!;
-  }
+  Iterable<K> get keys => _map.keys;
 
   /// As [ListMultimap.length].
   int get length => _map.length;
 
   /// As [ListMultimap.values], but result is stable; it always returns the
   /// same instance.
-  Iterable<V> get values {
-    _values ??= _map.values.expand((x) => x);
-    return _values!;
-  }
+  Iterable<V> get values => _map.values.expand((x) => x);
 
   // Internal.
 
-  BuiltListMultimap._(this._map);
+  const BuiltListMultimap._(this._map);
 }
 
 /// Default implementation of the public [BuiltListMultimap] interface.
@@ -177,5 +169,46 @@ class _BuiltListMultimap<K, V> extends BuiltListMultimap<K, V> {
     }
   }
 
+  // Precomputed.
+  final BuiltList<V> _emptyList = BuiltList<V>();
+
+  /// As [ListMultimap], but results are [BuiltList]s and not mutable.
+  @override
+  BuiltList<V> operator [](Object? key) {
+    var result = _map[key];
+    // Precomputed.
+    return result ?? _emptyList;
+  }
+
+  // Cached.
+  int? _hashCode;
+  Iterable<K>? _keys;
+  Iterable<V>? _values;
+
+  @override
+  Iterable<V> get values {
+    _values ??= super.values;
+    return _values!;
+  }
+
+  @override
+  Iterable<K> get keys {
+    _keys ??= super.keys;
+    return _keys!;
+  }
+
+  @override
+  int get hashCode {
+    _hashCode ??= super.hashCode;
+    return _hashCode!;
+  }
+
+  bool hasExactKeyAndValueTypes(Type key, Type value) => K == key && V == value;
+}
+
+class _ConstBuiltListMultimap<K, V> extends BuiltListMultimap<K, V> {
+  const _ConstBuiltListMultimap.withSafeMap(
+      [Map<K, BuiltList<V>> src = const {}])
+      : super._(src);
   bool hasExactKeyAndValueTypes(Type key, Type value) => K == key && V == value;
 }
diff --git a/lib/src/list_multimap/list_multimap_builder.dart b/lib/src/list_multimap/list_multimap_builder.dart
index 2c4b23b..d7bbc13 100644
--- a/lib/src/list_multimap/list_multimap_builder.dart
+++ b/lib/src/list_multimap/list_multimap_builder.dart
@@ -17,7 +17,7 @@ class ListMultimapBuilder<K, V> {
   late Map<K, BuiltList<V>> _builtMap;
   // Instance that _builtMap belongs to. If present, _builtMap must not be
   // mutated.
-  _BuiltListMultimap<K, V>? _builtMapOwner;
+  BuiltListMultimap<K, V>? _builtMapOwner;
   // ListBuilders for keys that are being changed.
   late Map<K, ListBuilder<V>> _builderMap;
 
@@ -57,7 +57,7 @@ class ListMultimapBuilder<K, V> {
   ///
   /// Any [ListBuilder]s associated with this collection are disconnected.
   void replace(dynamic multimap) {
-    if (multimap is _BuiltListMultimap<K, V>) {
+    if (multimap is BuiltListMultimap<K, V>) {
       _setOwner(multimap);
     } else if (multimap is Map) {
       _setWithCopyAndCheck(multimap.keys, (k) => multimap[k]);
@@ -178,7 +178,7 @@ class ListMultimapBuilder<K, V> {
 
   ListMultimapBuilder._uninitialized();
 
-  void _setOwner(_BuiltListMultimap<K, V> builtListMultimap) {
+  void _setOwner(BuiltListMultimap<K, V> builtListMultimap) {
     _builtMapOwner = builtListMultimap;
     _builtMap = builtListMultimap._map;
     _builderMap = <K, ListBuilder<V>>{};
diff --git a/lib/src/map/built_map.dart b/lib/src/map/built_map.dart
index 99a3ec6..f7b7acd 100644
--- a/lib/src/map/built_map.dart
+++ b/lib/src/map/built_map.dart
@@ -19,11 +19,6 @@ abstract class BuiltMap<K, V> {
   final _MapFactory<K, V>? _mapFactory;
   final Map<K, V> _map;
 
-  // Cached.
-  int? _hashCode;
-  Iterable<K>? _keys;
-  Iterable<V>? _values;
-
   /// Instantiates with elements from a [Map] or [BuiltMap].
   factory BuiltMap([map = const {}]) {
     if (map is _BuiltMap && map.hasExactKeyAndValueTypes(K, V)) {
@@ -35,6 +30,9 @@ abstract class BuiltMap<K, V> {
     }
   }
 
+  const factory BuiltMap.fromMap([Map<K, V> map]) =
+      _ConstBuiltMap<K, V>.withSafeMap;
+
   /// Instantiates with elements from a [Map].
   factory BuiltMap.from(Map map) {
     return _BuiltMap<K, V>.copyAndCheckTypes(map.keys, (k) => map[k]);
@@ -54,8 +52,7 @@ abstract class BuiltMap<K, V> {
   /// Converts to a [MapBuilder] for modification.
   ///
   /// The `BuiltMap` remains immutable and can continue to be used.
-  MapBuilder<K, V> toBuilder() =>
-      MapBuilder<K, V>._fromBuiltMap(this as _BuiltMap<K, V>);
+  MapBuilder<K, V> toBuilder() => MapBuilder<K, V>._fromBuiltMap(this);
 
   /// Converts to a [MapBuilder], applies updates to it, and builds.
   BuiltMap<K, V> rebuild(Function(MapBuilder<K, V>) updates) =>
@@ -82,13 +79,10 @@ abstract class BuiltMap<K, V> {
   /// A `BuiltMap` is only equal to another `BuiltMap` with equal key/value
   /// pairs in any order. Then, the `hashCode` is guaranteed to be the same.
   @override
-  int get hashCode {
-    _hashCode ??= hashObjects(_map.keys
-        .map((key) => hash2(key.hashCode, _map[key].hashCode))
-        .toList(growable: false)
-      ..sort());
-    return _hashCode!;
-  }
+  int get hashCode => hashObjects(_map.keys
+      .map((key) => hash2(key.hashCode, _map[key].hashCode))
+      .toList(growable: false)
+    ..sort());
 
   /// Deep equality.
   ///
@@ -132,20 +126,14 @@ abstract class BuiltMap<K, V> {
   bool get isNotEmpty => _map.isNotEmpty;
 
   /// As [Map.keys], but result is stable; it always returns the same instance.
-  Iterable<K> get keys {
-    _keys ??= _map.keys;
-    return _keys!;
-  }
+  Iterable<K> get keys => _map.keys;
 
   /// As [Map.length].
   int get length => _map.length;
 
   /// As [Map.values], but result is stable; it always returns the same
   /// instance.
-  Iterable<V> get values {
-    _values ??= _map.values;
-    return _values!;
-  }
+  Iterable<V> get values => _map.values;
 
   /// As [Map.entries].
   Iterable<MapEntry<K, V>> get entries => _map.entries;
@@ -156,11 +144,16 @@ abstract class BuiltMap<K, V> {
 
   // Internal.
 
-  BuiltMap._(this._mapFactory, this._map);
+  const BuiltMap._(this._mapFactory, this._map);
 }
 
 /// Default implementation of the public [BuiltMap] interface.
 class _BuiltMap<K, V> extends BuiltMap<K, V> {
+  // Cached.
+  int? _hashCode;
+  Iterable<K>? _keys;
+  Iterable<V>? _values;
+
   _BuiltMap.withSafeMap(_MapFactory<K, V>? mapFactory, Map<K, V> map)
       : super._(mapFactory, map);
 
@@ -196,9 +189,32 @@ class _BuiltMap<K, V> extends BuiltMap<K, V> {
     }
   }
 
+  @override
+  Iterable<V> get values {
+    _values ??= super.values;
+    return _values!;
+  }
+
+  @override
+  Iterable<K> get keys {
+    _keys ??= super.keys;
+    return _keys!;
+  }
+
+  @override
+  int get hashCode {
+    _hashCode ??= super.hashCode;
+    return _hashCode!;
+  }
+
   bool hasExactKeyAndValueTypes(Type key, Type value) => K == key && V == value;
 }
 
+class _ConstBuiltMap<K, V> extends BuiltMap<K, V> {
+  const _ConstBuiltMap.withSafeMap([Map<K, V> map = const {}])
+      : super._(null, map);
+}
+
 /// Extensions for [BuiltMap] on [Map].
 extension BuiltMapExtension<K, V> on Map<K, V> {
   /// Converts to a [BuiltMap].
diff --git a/lib/src/map/map_builder.dart b/lib/src/map/map_builder.dart
index d44948d..a858e95 100644
--- a/lib/src/map/map_builder.dart
+++ b/lib/src/map/map_builder.dart
@@ -15,7 +15,7 @@ class MapBuilder<K, V> {
   /// Used by [_createMap] to instantiate [_map]. The default value is `null`.
   _MapFactory<K, V>? _mapFactory;
   late Map<K, V> _map;
-  _BuiltMap<K, V>? _mapOwner;
+  BuiltMap<K, V>? _mapOwner;
 
   /// Instantiates with elements from a [Map] or [BuiltMap].
   factory MapBuilder([map = const {}]) {
@@ -38,7 +38,7 @@ class MapBuilder<K, V> {
 
   /// Replaces all elements with elements from a [Map] or [BuiltMap].
   void replace(Object map) {
-    if (map is _BuiltMap<K, V> && map._mapFactory == _mapFactory) {
+    if (map is BuiltMap<K, V> && map._mapFactory == _mapFactory) {
       _setOwner(map);
     } else if (map is BuiltMap) {
       var replacement = _createMap();
@@ -167,12 +167,12 @@ class MapBuilder<K, V> {
 
   MapBuilder._uninitialized();
 
-  MapBuilder._fromBuiltMap(_BuiltMap<K, V> map)
+  MapBuilder._fromBuiltMap(BuiltMap<K, V> map)
       : _mapFactory = map._mapFactory,
         _map = map._map,
         _mapOwner = map;
 
-  void _setOwner(_BuiltMap<K, V> mapOwner) {
+  void _setOwner(BuiltMap<K, V> mapOwner) {
     assert(mapOwner._mapFactory == _mapFactory,
         "Can't reuse a built map that uses a different base");
     _mapOwner = mapOwner;
diff --git a/lib/src/set/built_set.dart b/lib/src/set/built_set.dart
index 7038902..82e44b4 100644
--- a/lib/src/set/built_set.dart
+++ b/lib/src/set/built_set.dart
@@ -18,7 +18,6 @@ typedef _SetFactory<E> = Set<E> Function();
 abstract class BuiltSet<E> implements Iterable<E>, BuiltIterable<E> {
   final _SetFactory<E>? _setFactory;
   final Set<E> _set;
-  int? _hashCode;
 
   /// Instantiates with elements from an [Iterable].
   factory BuiltSet([Iterable iterable = const []]) => BuiltSet.from(iterable);
@@ -41,6 +40,8 @@ abstract class BuiltSet<E> implements Iterable<E>, BuiltIterable<E> {
     }
   }
 
+  const factory BuiltSet.fromSet([Set<E> set]) = _ConstBuiltSet.withSafeSet;
+
   /// Creates a [SetBuilder], applies updates to it, and builds.
   factory BuiltSet.build(Function(SetBuilder<E>) updates) =>
       (SetBuilder<E>()..update(updates)).build();
@@ -48,8 +49,7 @@ abstract class BuiltSet<E> implements Iterable<E>, BuiltIterable<E> {
   /// Converts to a [SetBuilder] for modification.
   ///
   /// The `BuiltSet` remains immutable and can continue to be used.
-  SetBuilder<E> toBuilder() =>
-      SetBuilder<E>._fromBuiltSet(this as _BuiltSet<E>);
+  SetBuilder<E> toBuilder() => SetBuilder<E>._fromBuiltSet(this);
 
   /// Converts to a [SetBuilder], applies updates to it, and builds.
   BuiltSet<E> rebuild(Function(SetBuilder<E>) updates) =>
@@ -67,9 +67,9 @@ abstract class BuiltSet<E> implements Iterable<E>, BuiltIterable<E> {
   /// any order. Then, the `hashCode` is guaranteed to be the same.
   @override
   int get hashCode {
-    _hashCode ??= hashObjects(
-        _set.map((e) => e.hashCode).toList(growable: false)..sort());
-    return _hashCode!;
+    return hashObjects(
+      _set.map((e) => e.hashCode).toList(growable: false)..sort(),
+    );
   }
 
   /// Deep equality.
@@ -223,11 +223,19 @@ abstract class BuiltSet<E> implements Iterable<E>, BuiltIterable<E> {
 
   // Internal.
 
-  BuiltSet._(this._setFactory, this._set);
+  const BuiltSet._(this._setFactory, this._set);
 }
 
 /// Default implementation of the public [BuiltSet] interface.
 class _BuiltSet<E> extends BuiltSet<E> {
+  int? _hashCode;
+
+  @override
+  int get hashCode {
+    _hashCode ??= super.hashCode;
+    return _hashCode!;
+  }
+
   _BuiltSet.withSafeSet(_SetFactory<E>? setFactory, Set<E> set)
       : super._(setFactory, set);
 
@@ -253,6 +261,10 @@ class _BuiltSet<E> extends BuiltSet<E> {
   bool hasExactElementType(Type type) => E == type;
 }
 
+class _ConstBuiltSet<E> extends BuiltSet<E> {
+  const _ConstBuiltSet.withSafeSet([Set<E> s = const {}]) : super._(null, s);
+}
+
 /// Extensions for [BuiltSet] on [Set].
 extension BuiltSetExtension<T> on Set<T> {
   /// Converts to a [BuiltSet].
diff --git a/lib/src/set/set_builder.dart b/lib/src/set/set_builder.dart
index 3d128aa..6dda7a2 100644
--- a/lib/src/set/set_builder.dart
+++ b/lib/src/set/set_builder.dart
@@ -15,7 +15,7 @@ class SetBuilder<E> {
   /// Used by [_createSet] to instantiate [_set]. The default value is `null`.
   _SetFactory<E>? _setFactory;
   late Set<E> _set;
-  _BuiltSet<E>? _setOwner;
+  BuiltSet<E>? _setOwner;
 
   /// Instantiates with elements from an [Iterable].
   factory SetBuilder([Iterable iterable = const []]) {
@@ -38,7 +38,7 @@ class SetBuilder<E> {
 
   /// Replaces all elements with elements from an [Iterable].
   void replace(Iterable iterable) {
-    if (iterable is _BuiltSet<E> && iterable._setFactory == _setFactory) {
+    if (iterable is BuiltSet<E> && iterable._setFactory == _setFactory) {
       _withOwner(iterable);
     } else {
       // Can't use addAll because it requires an Iterable<E>.
@@ -184,12 +184,12 @@ class SetBuilder<E> {
 
   SetBuilder._uninitialized();
 
-  SetBuilder._fromBuiltSet(_BuiltSet<E> set)
+  SetBuilder._fromBuiltSet(BuiltSet<E> set)
       : _setFactory = set._setFactory,
         _set = set._set,
         _setOwner = set;
 
-  void _withOwner(_BuiltSet<E> setOwner) {
+  void _withOwner(BuiltSet<E> setOwner) {
     assert(setOwner._setFactory == _setFactory,
         "Can't reuse a built set that uses a different base");
     _set = setOwner._set;
diff --git a/lib/src/set_multimap/built_set_multimap.dart b/lib/src/set_multimap/built_set_multimap.dart
index 469f599..de5fb52 100644
--- a/lib/src/set_multimap/built_set_multimap.dart
+++ b/lib/src/set_multimap/built_set_multimap.dart
@@ -16,19 +16,13 @@ part of '../set_multimap.dart';
 abstract class BuiltSetMultimap<K, V> {
   final Map<K, BuiltSet<V>> _map;
 
-  // Precomputed.
-  final BuiltSet<V> _emptySet = BuiltSet<V>();
-
-  // Cached.
-  int? _hashCode;
-  Iterable<K>? _keys;
-  Iterable<V>? _values;
-
   /// Instantiates with elements from a [Map], [SetMultimap] or
   /// [BuiltSetMultimap].
   factory BuiltSetMultimap([multimap = const {}]) {
-    if (multimap is _BuiltSetMultimap &&
-        multimap.hasExactKeyAndValueTypes(K, V)) {
+    if ((multimap is _BuiltSetMultimap &&
+            multimap.hasExactKeyAndValueTypes(K, V)) ||
+        (multimap is _ConstBuiltSetMultimap &&
+            multimap.hasExactKeyAndValueTypes(K, V))) {
       return multimap as BuiltSetMultimap<K, V>;
     } else if (multimap is Map) {
       return _BuiltSetMultimap<K, V>.copyAndCheck(
@@ -42,6 +36,9 @@ abstract class BuiltSetMultimap<K, V> {
     }
   }
 
+  const factory BuiltSetMultimap.fromMap([Map<K, BuiltSet<V>> map]) =
+      _ConstBuiltSetMultimap.withSafeSet;
+
   /// Creates a [SetMultimapBuilder], applies updates to it, and builds.
   factory BuiltSetMultimap.build(Function(SetMultimapBuilder<K, V>) updates) =>
       (SetMultimapBuilder<K, V>()..update(updates)).build();
@@ -72,11 +69,10 @@ abstract class BuiltSetMultimap<K, V> {
   /// to be the same.
   @override
   int get hashCode {
-    _hashCode ??= hashObjects(_map.keys
+    return hashObjects(_map.keys
         .map((key) => hash2(key.hashCode, _map[key].hashCode))
         .toList(growable: false)
       ..sort());
-    return _hashCode!;
   }
 
   /// Deep equality.
@@ -109,7 +105,7 @@ abstract class BuiltSetMultimap<K, V> {
   /// As [SetMultimap], but results are [BuiltSet]s and not mutable.
   BuiltSet<V>? operator [](Object? key) {
     var result = _map[key];
-    return identical(result, null) ? _emptySet : result;
+    return identical(result, null) ? BuiltSet<V>() : result;
   }
 
   /// As [SetMultimap.containsKey].
@@ -142,28 +138,55 @@ abstract class BuiltSetMultimap<K, V> {
 
   /// As [SetMultimap.keys], but result is stable; it always returns the same
   /// instance.
-  Iterable<K> get keys {
-    _keys ??= _map.keys;
-    return _keys!;
-  }
+  Iterable<K> get keys => _map.keys;
 
   /// As [SetMultimap.length].
   int get length => _map.length;
 
   /// As [SetMultimap.values], but result is stable; it always returns the
   /// same instance.
-  Iterable<V> get values {
-    _values ??= _map.values.expand((x) => x);
-    return _values!;
-  }
+  Iterable<V> get values => _map.values.expand((x) => x);
 
   // Internal.
 
-  BuiltSetMultimap._(this._map);
+  const BuiltSetMultimap._(this._map);
 }
 
 /// Default implementation of the public [BuiltSetMultimap] interface.
 class _BuiltSetMultimap<K, V> extends BuiltSetMultimap<K, V> {
+  // Precomputed.
+  final BuiltSet<V> _emptySet = BuiltSet<V>();
+
+  // Cached.
+  int? _hashCode;
+
+  @override
+  int get hashCode {
+    _hashCode ??= super.hashCode;
+    return _hashCode!;
+  }
+
+  Iterable<K>? _keys;
+
+  @override
+  Iterable<K> get keys {
+    _keys ??= super.keys;
+    return _keys!;
+  }
+
+  Iterable<V>? _values;
+  @override
+  Iterable<V> get values {
+    _values ??= super.values;
+    return _values!;
+  }
+
+  @override
+  BuiltSet<V>? operator [](Object? key) {
+    var result = _map[key];
+    return identical(result, null) ? _emptySet : result;
+  }
+
   _BuiltSetMultimap.withSafeMap(Map<K, BuiltSet<V>> map) : super._(map);
 
   _BuiltSetMultimap.copyAndCheck(Iterable keys, Function lookup)
@@ -179,3 +202,10 @@ class _BuiltSetMultimap<K, V> extends BuiltSetMultimap<K, V> {
 
   bool hasExactKeyAndValueTypes(Type key, Type value) => K == key && V == value;
 }
+
+class _ConstBuiltSetMultimap<K, V> extends BuiltSetMultimap<K, V> {
+  const _ConstBuiltSetMultimap.withSafeSet([Map<K, BuiltSet<V>> src = const {}])
+      : super._(src);
+
+  bool hasExactKeyAndValueTypes(Type key, Type value) => K == key && V == value;
+}
diff --git a/lib/src/set_multimap/set_multimap_builder.dart b/lib/src/set_multimap/set_multimap_builder.dart
index 2d7bf3e..4e42133 100644
--- a/lib/src/set_multimap/set_multimap_builder.dart
+++ b/lib/src/set_multimap/set_multimap_builder.dart
@@ -17,7 +17,7 @@ class SetMultimapBuilder<K, V> {
   late Map<K, BuiltSet<V>> _builtMap;
   // Instance that _builtMap belongs to. If present, _builtMap must not be
   // mutated.
-  _BuiltSetMultimap<K, V>? _builtMapOwner;
+  BuiltSetMultimap<K, V>? _builtMapOwner;
   // SetBuilders for keys that are being changed.
   late Map<K, SetBuilder<V>> _builderMap;
 
@@ -52,7 +52,7 @@ class SetMultimapBuilder<K, V> {
   /// Replaces all elements with elements from a [Map], [SetMultimap] or
   /// [BuiltSetMultimap].
   void replace(dynamic multimap) {
-    if (multimap is _BuiltSetMultimap<K, V>) {
+    if (multimap is BuiltSetMultimap<K, V>) {
       _setOwner(multimap);
     } else if (multimap is Map) {
       _setWithCopyAndCheck(multimap.keys, (k) => multimap[k]);
@@ -162,7 +162,7 @@ class SetMultimapBuilder<K, V> {
 
   SetMultimapBuilder._uninitialized();
 
-  void _setOwner(_BuiltSetMultimap<K, V> builtSetMultimap) {
+  void _setOwner(BuiltSetMultimap<K, V> builtSetMultimap) {
     _builtMapOwner = builtSetMultimap;
     _builtMap = builtSetMultimap._map;
     _builderMap = <K, SetBuilder<V>>{};