diff --git a/CHANGELOG.md b/CHANGELOG.md
index 08d659b..398c7c4 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,10 @@
+## 0.16.0
+
+* Refactored `MapChangeRecord`
+    * Added equality and hashCode checks
+    * Added `MapChangeRecord.apply` to apply a change record
+* Added `MapDiffer`, which implements `Differ` for a `Map`
+
 ## 0.15.0+2
 
 * Fix a bug in `ListDiffer` that caused a `RangeError`
diff --git a/lib/observable.dart b/lib/observable.dart
index 179a938..32a6560 100644
--- a/lib/observable.dart
+++ b/lib/observable.dart
@@ -4,8 +4,8 @@
 
 library observable;
 
-export 'src/differs.dart' show Differ, EqualityDiffer, ListDiffer;
-export 'src/records.dart' show ChangeRecord, ListChangeRecord;
+export 'src/differs.dart' show Differ, EqualityDiffer, ListDiffer, MapDiffer;
+export 'src/records.dart' show ChangeRecord, ListChangeRecord, MapChangeRecord;
 export 'src/observable.dart';
 export 'src/observable_list.dart';
 export 'src/observable_map.dart';
diff --git a/lib/src/differs.dart b/lib/src/differs.dart
index 41f8a89..8d155ed 100644
--- a/lib/src/differs.dart
+++ b/lib/src/differs.dart
@@ -10,14 +10,17 @@
 
 import 'records.dart';
 
+import 'internal.dart';
+
 part 'differs/list_differ.dart';
+part 'differs/map_differ.dart';
 
 /// Generic comparisons between two comparable objects.
 abstract class Differ<E> {
   /// Returns a list of change records between [e1] and [e2].
   ///
   /// A return value of an empty [ChangeRecord.NONE] means no changes found.
-  List<ChangeRecord> diff(E e1, E e2);
+  List<ChangeRecord> diff(E oldValue, E newValue);
 }
 
 /// Uses [Equality] to determine a simple [ChangeRecord.ANY] response.
@@ -29,7 +32,9 @@
   const EqualityDiffer.identity() : this._equality = const IdentityEquality();
 
   @override
-  List<ChangeRecord> diff(E e1, E e2) {
-    return _equality.equals(e1, e2) ? ChangeRecord.NONE : ChangeRecord.ANY;
+  List<ChangeRecord> diff(E oldValue, E newValue) {
+    return _equality.equals(oldValue, newValue)
+        ? ChangeRecord.NONE
+        : ChangeRecord.ANY;
   }
 }
diff --git a/lib/src/differs/map_differ.dart b/lib/src/differs/map_differ.dart
new file mode 100644
index 0000000..c6041a4
--- /dev/null
+++ b/lib/src/differs/map_differ.dart
@@ -0,0 +1,38 @@
+// Copyright (c) 2016, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+part of observable.src.differs;
+
+/// Determines differences between two maps, returning [MapChangeRecord]s.
+///
+/// While [MapChangeRecord] has more information and can be replayed they carry
+/// a more significant cost to calculate and create and should only be used when
+/// the details in the record will actually be used.
+///
+/// See also [EqualityDiffer] for a simpler comparison.
+class MapDiffer<K, V> implements Differ<Map<K, V>> {
+  const MapDiffer();
+
+  @override
+  List<MapChangeRecord<K, V>> diff(Map<K, V> oldValue, Map<K, V> newValue) {
+    if (identical(oldValue, newValue)) {
+      return ChangeRecord.NONE;
+    }
+    final changes = <MapChangeRecord<K, V>>[];
+    oldValue.forEach((oldK, oldV) {
+      final newV = newValue[oldK];
+      if (newV == null && !newValue.containsKey(oldK)) {
+        changes.add(new MapChangeRecord<K, V>.remove(oldK, oldV));
+      } else if (newV != oldV) {
+        changes.add(new MapChangeRecord<K, V>(oldK, oldV, newV));
+      }
+    });
+    newValue.forEach((newK, newV) {
+      if (!oldValue.containsKey(newK)) {
+        changes.add(new MapChangeRecord<K, V>.insert(newK, newV));
+      }
+    });
+    return freezeInDevMode(changes);
+  }
+}
diff --git a/lib/src/internal.dart b/lib/src/internal.dart
new file mode 100644
index 0000000..d0ae2e1
--- /dev/null
+++ b/lib/src/internal.dart
@@ -0,0 +1,12 @@
+// Copyright (c) 2016, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+List/*<E>*/ freezeInDevMode/*<E>*/(List/*<E>*/ list) {
+  if (list == null) return const [];
+  assert(() {
+    list = new List/*<E>*/ .unmodifiable(list);
+    return true;
+  });
+  return list;
+}
diff --git a/lib/src/observable.dart b/lib/src/observable.dart
index b76b13f..8a90e09 100644
--- a/lib/src/observable.dart
+++ b/lib/src/observable.dart
@@ -9,7 +9,6 @@
 
 import 'package:meta/meta.dart';
 
-import 'observable_map.dart';
 import 'property_change_record.dart' show PropertyChangeRecord;
 import 'records.dart' show ChangeRecord;
 
diff --git a/lib/src/observable_map.dart b/lib/src/observable_map.dart
index c1e2c90..a99610c 100644
--- a/lib/src/observable_map.dart
+++ b/lib/src/observable_map.dart
@@ -8,7 +8,7 @@
 
 import 'observable.dart' show Observable;
 import 'property_change_record.dart' show PropertyChangeRecord;
-import 'records.dart' show ChangeRecord;
+import 'records.dart' show MapChangeRecord;
 import 'to_observable.dart';
 
 // TODO(jmesserly): this needs to be faster. We currently require multiple
@@ -17,47 +17,6 @@
 // LinkedHashMap, SplayTreeMap or HashMap. However it can use them for the
 // backing store.
 
-// TODO(jmesserly): should we summarize map changes like we do for list changes?
-class MapChangeRecord<K, V> extends ChangeRecord {
-  // TODO(jmesserly): we could store this more compactly if it matters, with
-  // subtypes for inserted and removed.
-
-  /// The map key that changed.
-  final K key;
-
-  /// The previous value associated with this key.
-  final V oldValue;
-
-  /// The new value associated with this key.
-  final V newValue;
-
-  /// True if this key was inserted.
-  final bool isInsert;
-
-  /// True if this key was removed.
-  final bool isRemove;
-
-  MapChangeRecord(this.key, this.oldValue, this.newValue)
-      : isInsert = false,
-        isRemove = false;
-
-  MapChangeRecord.insert(this.key, this.newValue)
-      : isInsert = true,
-        isRemove = false,
-        oldValue = null;
-
-  MapChangeRecord.remove(this.key, this.oldValue)
-      : isInsert = false,
-        isRemove = true,
-        newValue = null;
-
-  @override
-  String toString() {
-    var kind = isInsert ? 'insert' : isRemove ? 'remove' : 'set';
-    return '#<MapChangeRecord $kind $key from: $oldValue to: $newValue>';
-  }
-}
-
 /// Represents an observable map of model values. If any items are added,
 /// removed, or replaced, then observers that are listening to [changes]
 /// will be notified.
diff --git a/lib/src/records.dart b/lib/src/records.dart
index a04ae9e..07a9826 100644
--- a/lib/src/records.dart
+++ b/lib/src/records.dart
@@ -7,7 +7,10 @@
 import 'package:collection/collection.dart';
 import 'package:quiver/core.dart';
 
+import 'internal.dart';
+
 part 'records/list_change_record.dart';
+part 'records/map_change_record.dart';
 
 /// Result of a change to an observed object.
 class ChangeRecord {
diff --git a/lib/src/records/list_change_record.dart b/lib/src/records/list_change_record.dart
index aeb77d6..59867b2 100644
--- a/lib/src/records/list_change_record.dart
+++ b/lib/src/records/list_change_record.dart
@@ -4,15 +4,6 @@
 
 part of observable.src.records;
 
-List/*<E>*/ _freezeInDevMode/*<E>*/(List/*<E>*/ list) {
-  if (list == null) return const [];
-  assert(() {
-    list = new List/*<E>*/ .unmodifiable(list);
-    return true;
-  });
-  return list;
-}
-
 /// A [ChangeRecord] that denotes adding or removing nodes at [index].
 ///
 /// It should be assumed that elements are [removed] *before* being added.
@@ -50,7 +41,7 @@
 
   /// Records a `remove` operation at `object[index]` of [removed] elements.
   ListChangeRecord.remove(this.object, this.index, List<E> removed)
-      : this.removed = _freezeInDevMode/*<E>*/(removed),
+      : this.removed = freezeInDevMode/*<E>*/(removed),
         this.addedCount = 0 {
     _assertValidState();
   }
@@ -60,7 +51,7 @@
   /// If [addedCount] is not specified it defaults to `removed.length`.
   ListChangeRecord.replace(this.object, this.index, List<E> removed,
       [int addedCount])
-      : this.removed = _freezeInDevMode/*<E>*/(removed),
+      : this.removed = freezeInDevMode/*<E>*/(removed),
         this.addedCount = addedCount ?? removed.length {
     _assertValidState();
   }
diff --git a/lib/src/records/map_change_record.dart b/lib/src/records/map_change_record.dart
new file mode 100644
index 0000000..9150732
--- /dev/null
+++ b/lib/src/records/map_change_record.dart
@@ -0,0 +1,82 @@
+// Copyright (c) 2016, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+part of observable.src.records;
+
+/// A [ChangeRecord] that denotes adding, removing, or updating a map.
+class MapChangeRecord<K, V> implements ChangeRecord {
+  /// The map key that changed.
+  final K key;
+
+  /// The previous value associated with this key.
+  ///
+  /// Is always `null` if [isInsert].
+  final V oldValue;
+
+  /// The new value associated with this key.
+  ///
+  /// Is always `null` if [isRemove].
+  final V newValue;
+
+  /// True if this key was inserted.
+  final bool isInsert;
+
+  /// True if this key was removed.
+  final bool isRemove;
+
+  /// Create an update record of [key] from [oldValue] to [newValue].
+  const MapChangeRecord(this.key, this.oldValue, this.newValue)
+      : isInsert = false,
+        isRemove = false;
+
+  /// Create an insert record of [key] and [newValue].
+  const MapChangeRecord.insert(this.key, this.newValue)
+      : isInsert = true,
+        isRemove = false,
+        oldValue = null;
+
+  /// Create a remove record of [key] with a former [oldValue].
+  const MapChangeRecord.remove(this.key, this.oldValue)
+      : isInsert = false,
+        isRemove = true,
+        newValue = null;
+
+  /// Apply this change record to [map].
+  void apply(Map<K, V> map) {
+    if (isRemove) {
+      map.remove(key);
+    } else {
+      map[key] = newValue;
+    }
+  }
+
+  @override
+  bool operator ==(Object o) {
+    if (o is MapChangeRecord<K, V>) {
+      return key == o.key &&
+             oldValue == o.oldValue &&
+             newValue == o.newValue &&
+             isInsert == o.isInsert &&
+             isRemove == o.isRemove;
+    }
+    return false;
+  }
+
+  @override
+  int get hashCode {
+    return hashObjects([
+      key,
+      oldValue,
+      newValue,
+      isInsert,
+      isRemove,
+    ]);
+  }
+
+  @override
+  String toString() {
+    final kind = isInsert ? 'insert' : isRemove ? 'remove' : 'set';
+    return '#<MapChangeRecord $kind $key from $oldValue to $newValue';
+  }
+}
diff --git a/pubspec.yaml b/pubspec.yaml
index 7e3e9b1..a5451f0 100644
--- a/pubspec.yaml
+++ b/pubspec.yaml
@@ -1,5 +1,5 @@
 name: observable
-version: 0.15.0+2
+version: 0.16.0
 author: Dart Team <misc@dartlang.org>
 description: Support for marking objects as observable
 homepage: https://github.com/dart-lang/observable
diff --git a/test/map_differ_test.dart b/test/map_differ_test.dart
new file mode 100644
index 0000000..b6a11c8
--- /dev/null
+++ b/test/map_differ_test.dart
@@ -0,0 +1,115 @@
+import 'package:observable/observable.dart';
+import 'package:test/test.dart';
+
+main() {
+  group('$MapDiffer', () {
+    final diff = const MapDiffer<String, String>().diff;
+
+    test('should emit no changes for identical maps', () {
+      final map = new Map<String, String>.fromIterable(
+        new Iterable.generate(10, (i) => '$i'),
+      );
+      expect(diff(map, map), ChangeRecord.NONE);
+    });
+
+    test('should emit no changes for maps with identical content', () {
+      final map1 = new Map<String, String>.fromIterable(
+        new Iterable.generate(10, (i) => '$i'),
+      );
+      final map2 = new Map<String, String>.fromIterable(
+        new Iterable.generate(10, (i) => '$i'),
+      );
+      expect(diff(map1, map2), ChangeRecord.NONE);
+    });
+
+    test('should detect insertions', () {
+      expect(
+        diff({
+          'key-a': 'value-a',
+          'key-b': 'value-b',
+        }, {
+          'key-a': 'value-a',
+          'key-b': 'value-b',
+          'key-c': 'value-c',
+        }),
+        [
+          new MapChangeRecord.insert('key-c', 'value-c'),
+        ],
+      );
+    });
+
+    test('should detect removals', () {
+      expect(
+        diff({
+          'key-a': 'value-a',
+          'key-b': 'value-b',
+          'key-c': 'value-c',
+        }, {
+          'key-a': 'value-a',
+          'key-b': 'value-b',
+        }),
+        [
+          new MapChangeRecord.remove('key-c', 'value-c'),
+        ],
+      );
+    });
+
+    test('should detect updates', () {
+      expect(
+        diff({
+          'key-a': 'value-a',
+          'key-b': 'value-b-old',
+        }, {
+          'key-a': 'value-a',
+          'key-b': 'value-b-new',
+        }),
+        [
+          new MapChangeRecord('key-b', 'value-b-old', 'value-b-new'),
+        ],
+      );
+    });
+  });
+
+  group('$MapChangeRecord', () {
+    test('should reply an insertion', () {
+      final map1 = {
+        'key-a': 'value-a',
+        'key-b': 'value-b',
+      };
+      final map2 = {
+        'key-a': 'value-a',
+        'key-b': 'value-b',
+        'key-c': 'value-c',
+      };
+      new MapChangeRecord.insert('key-c', 'value-c').apply(map1);
+      expect(map1, map2);
+    });
+
+    test('should replay a removal', () {
+      final map1 = {
+        'key-a': 'value-a',
+        'key-b': 'value-b',
+        'key-c': 'value-c',
+      };
+      final map2 = {
+        'key-a': 'value-a',
+        'key-b': 'value-b',
+      };
+      new MapChangeRecord.remove('key-c', 'value-c').apply(map1);
+      expect(map1, map2);
+    });
+
+    test('should replay an update', () {
+      final map1 = {
+        'key-a': 'value-a',
+        'key-b': 'value-b-old',
+      };
+      final map2 = {
+        'key-a': 'value-a',
+        'key-b': 'value-b-new',
+      };
+      new MapChangeRecord('key-b', 'value-b-old', 'value-b-new').apply(map1);
+      expect(map1, map2);
+    });
+  });
+}