Introduce IterableMapEntryExtension for use with Map.entries.

pkgs/collection/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 1.19.1-wip
+- Add `IterableMapEntryExtension` for working on `Map` as a list of pairs, using
+  `Map.entries`.
+
 ## 1.19.1
 
 - Move to `dart-lang/core` monorepo.

pkgs/collection/lib/src/iterable_extensions.dart

@@ -914,6 +914,33 @@ extension IterableIterableExtension<T> on Iterable<Iterable<T>> {
       };
 }
 
+/// Extension on iterables of [MapEntry].
+///
+/// An [Iterable<MapEntry>] is obtained using [Map.entries], these extensions
+/// make it easy to work on a [Map] as a list of pairs.
+extension IterableMapEntryExtension<K, V> on Iterable<MapEntry<K, V>> {
+  /// Creates a new lazy [Iterable] with all elements whose [MapEntry.key]
+  /// satisfy the predicate [test].
+  Iterable<MapEntry<K, V>> whereKey(bool Function(K) test) =>
+      where((e) => test(e.key));
+
+  /// Creates a new lazy [Iterable] with all elements whose [MapEntry.value]
+  /// satisfy the predicate [test].
+  Iterable<MapEntry<K, V>> whereValue(bool Function(V) test) =>
+      where((e) => test(e.value));
+
+  /// Create an new lazy [Iterable] with [MapEntry.key] from all elements.
+  Iterable<K> get keys => map((e) => e.key);
+
+  /// Create an new lazy [Iterable] with [MapEntry.value] from all elements.
+  Iterable<V> get values => map((e) => e.value);
+
+  /// Create a [Map] from all elements.
+  ///
+  /// This is a short-hand for [Map.fromEntries].
+  Map<K, V> toMap() => Map.fromEntries(this);
+}
+
 /// Extensions that apply to iterables of [Comparable] elements.
 ///
 /// These operations can assume that the elements have a natural ordering,

pkgs/collection/pubspec.yaml

@@ -1,5 +1,5 @@
 name: collection
-version: 1.19.1
+version: 1.19.1-wip
 description: >-
   Collections and utilities functions and classes related to collections.
 repository: https://github.com/dart-lang/core/tree/main/pkgs/collection

pkgs/collection/test/extensions_test.dart

@@ -1122,6 +1122,87 @@ void main() {
         });
       });
     });
+    group('of MapEntry', () {
+      group('.whereKey', () {
+        test('empty', () {
+          expect(<String, int>{}.entries.whereKey(unreachable), isEmpty);
+        });
+        test('single', () {
+          expect({'a': 1}.entries.whereKey((k) => k == 'a').toMap(), {'a': 1});
+          expect({'a': 1}.entries.whereKey((k) => k == 'b').toMap(), isEmpty);
+        });
+        test('multiple', () {
+          expect(
+            {'a': 1, 'b': 2}.entries.whereKey((k) => k == 'a').toMap(),
+            {'a': 1},
+          );
+          expect(
+            {'a': 1, 'b': 2}.entries.whereKey((k) => k == 'b').toMap(),
+            {'b': 2},
+          );
+          expect(
+            {'a': 1, 'b': 2}.entries.whereKey((k) => k != 'c').toMap(),
+            {'a': 1, 'b': 2},
+          );
+        });
+      });
+      group('.whereValue', () {
+        test('empty', () {
+          expect(<String, int>{}.entries.whereValue(unreachable), isEmpty);
+        });
+        test('single', () {
+          expect({'a': 1}.entries.whereValue((v) => v == 1).toMap(), {'a': 1});
+          expect({'a': 1}.entries.whereValue((v) => v == 2).toMap(), isEmpty);
+        });
+        test('multiple', () {
+          expect(
+            {'a': 1, 'b': 2}.entries.whereValue((v) => v == 1).toMap(),
+            {'a': 1},
+          );
+          expect(
+            {'a': 1, 'b': 2}.entries.whereValue((v) => v == 2).toMap(),
+            {'b': 2},
+          );
+          expect(
+            {'a': 1, 'b': 2}.entries.whereValue((v) => v != 3).toMap(),
+            {'a': 1, 'b': 2},
+          );
+        });
+      });
+      group('.keys', () {
+        test('empty', () {
+          expect(<String, int>{}.entries.keys, isEmpty);
+        });
+        test('single', () {
+          expect({'a': 1}.entries.keys, ['a']);
+        });
+        test('multiple', () {
+          expect({'a': 1, 'b': 2}.entries.keys, ['a', 'b']);
+        });
+      });
+      group('.values', () {
+        test('empty', () {
+          expect(<String, int>{}.entries.values, isEmpty);
+        });
+        test('single', () {
+          expect({'a': 1}.entries.values, [1]);
+        });
+        test('multiple', () {
+          expect({'a': 1, 'b': 2}.entries.values, [1, 2]);
+        });
+      });
+      group('.toMap', () {
+        test('empty', () {
+          expect(<String, int>{}.entries.toMap(), <String, int>{});
+        });
+        test('single', () {
+          expect({'a': 1}.entries.toMap(), {'a': 1});
+        });
+        test('multiple', () {
+          expect({'a': 1, 'b': 2}.entries.toMap(), {'a': 1, 'b': 2});
+        });
+      });
+    });
     group('of comparable', () {
       group('.min', () {
         test('empty', () {