refactor: minor code cleanup / fixes

demo/bouncing_balls/bouncy_balls.dart

@@ -71,7 +71,7 @@ class BounceController {
 
   timeDigest() {
     var start = window.performance.now();
-    scope.$evalAsync(() {
+    scope.runAsync(() {
       digestTime = (window.performance.now() - start).round();
     }, outsideDigest: true);
   }
@@ -109,7 +109,7 @@ class BallPositionDirective {
 
   set position(BallModel model) {
     element.style.backgroundColor = model.color;
-    scope.$watch(() {
+    scope.watch(() {
       element.style.left = '${model.x + 10}px';
       element.style.top = '${model.y + 10}px';
     });

lib/change_detection/ast.dart

@@ -9,7 +9,12 @@ part of angular.watch_group;
 abstract class AST {
   static final String _CONTEXT = '#';
   final String expression;
-  AST(this.expression) { assert(expression!=null); }
+  AST(expression)
+      : expression = expression.startsWith('#.') ?
+          expression.substring(2) :
+          expression  {
+    assert(expression!=null);
+  }
   WatchRecord<_Handler> setupWatch(WatchGroup watchGroup);
   toString() => expression;
 }
@@ -21,8 +26,8 @@ abstract class AST {
  */
 class ContextReferenceAST extends AST {
   ContextReferenceAST(): super(AST._CONTEXT);
-  WatchRecord<_Handler> setupWatch(WatchGroup watchGroup)
-      => new _ConstantWatchRecord(watchGroup, expression, watchGroup.context);
+  WatchRecord<_Handler> setupWatch(WatchGroup watchGroup) =>
+      new _ConstantWatchRecord(watchGroup, expression, watchGroup.context);
 }
 
 /**
@@ -33,12 +38,14 @@ class ContextReferenceAST extends AST {
 class ConstantAST extends AST {
   final constant;
 
-  ConstantAST(dynamic constant):
-      super('$constant'),
-      constant = constant;
+  ConstantAST(constant, [String expression])
+      : constant = constant,
+        super(expression == null ?
+            constant is String ? '"$constant"' : '$constant' :
+            expression);
 
-  WatchRecord<_Handler> setupWatch(WatchGroup watchGroup)
-      => new _ConstantWatchRecord(watchGroup, expression, constant);
+  WatchRecord<_Handler> setupWatch(WatchGroup watchGroup) =>
+      new _ConstantWatchRecord(watchGroup, expression, constant);
 }
 
 /**
@@ -51,13 +58,12 @@ class FieldReadAST extends AST {
   final String name;
 
   FieldReadAST(lhs, name)
-      : super(lhs.expression == AST._CONTEXT ? name : '$lhs.$name'),
+      : super('$lhs.$name'),
         lhs = lhs,
         name = name;
 
   WatchRecord<_Handler> setupWatch(WatchGroup watchGroup) =>
-    watchGroup.addFieldWatch(lhs, name, expression);
-
+      watchGroup.addFieldWatch(lhs, name, expression);
 }
 
 /**
@@ -77,7 +83,7 @@ class PureFunctionAST extends AST {
         name = name;
 
   WatchRecord<_Handler> setupWatch(WatchGroup watchGroup) =>
-    watchGroup.addFunctionWatch(fn, argsAST, expression);
+      watchGroup.addFunctionWatch(fn, argsAST, expression);
 }
 
 /**
@@ -97,19 +103,18 @@ class MethodAST extends AST {
         argsAST = argsAST;
 
   WatchRecord<_Handler> setupWatch(WatchGroup watchGroup) =>
-    watchGroup.addMethodWatch(lhsAST, name, argsAST, expression);
+      watchGroup.addMethodWatch(lhsAST, name, argsAST, expression);
 }
 
 
 class CollectionAST extends AST {
   final AST valueAST;
-  CollectionAST(valueAST):
-      super('#collection($valueAST)'),
-      valueAST = valueAST;
+  CollectionAST(valueAST)
+      : super('#collection($valueAST)'),
+        valueAST = valueAST;
 
-  WatchRecord<_Handler> setupWatch(WatchGroup watchGroup) {
-    return watchGroup.addCollectionWatch(valueAST);
-  }
+  WatchRecord<_Handler> setupWatch(WatchGroup watchGroup) =>
+      watchGroup.addCollectionWatch(valueAST);
 }
 
 _argList(List<AST> items) => items.join(', ');
@@ -124,9 +129,9 @@ class _ConstantWatchRecord extends WatchRecord<_Handler> {
   final currentValue;
   final _Handler handler;
 
-  _ConstantWatchRecord(WatchGroup watchGroup, String expression, dynamic currentValue):
-      currentValue = currentValue,
-      handler = new _ConstantHandler(watchGroup, expression, currentValue);
+  _ConstantWatchRecord(WatchGroup watchGroup, String expression, currentValue)
+      : currentValue = currentValue,
+        handler = new _ConstantHandler(watchGroup, expression, currentValue);
 
   ChangeRecord<_Handler> check() => null;
   void remove() => null;

lib/change_detection/change_detection.dart

@@ -1,8 +1,10 @@
 library change_detection;
 
+typedef EvalExceptionHandler(error, stack);
+
 /**
  * An interface for [ChangeDetectorGroup] groups related watches together. It
- * guarentees that within the group all watches will be reported in the order in
+ * guarantees that within the group all watches will be reported in the order in
  * which they were registered. It also provides an efficient way of removing the
  * watch group.
  */
@@ -25,7 +27,6 @@ abstract class ChangeDetectorGroup<H> {
    */
   WatchRecord<H> watch(Object object, String field, H handler);
 
-
   /** Use to remove all watches in the group in an efficient manner. */
   void remove();
 
@@ -53,7 +54,7 @@ abstract class ChangeDetector<H> extends ChangeDetectorGroup<H> {
    * linked list of [ChangeRecord]s. The [ChangeRecord]s are to be returned in
    * the same order as they were registered.
    */
-  ChangeRecord<H> collectChanges();
+  ChangeRecord<H> collectChanges([EvalExceptionHandler exceptionHandler]);
 }
 
 abstract class Record<H> {
@@ -110,7 +111,64 @@ abstract class ChangeRecord<H> extends Record<H> {
 }
 
 /**
- * If [ChangeDetector] is watching a collection (an [Iterable]) then the
+ * If [ChangeDetector] is watching a an [Map] then the
+ * [currentValue] of [Record] will contain this object. The object contains a
+ * summary of changes to the map since the last execution. The changes
+ * are reported as a list of [MapKeyValue]s which contain the current
+ * and previous value in the list as well as the key.
+ */
+abstract class MapChangeRecord<K, V> {
+  /// The underlying iterable object
+  Map get map;
+
+  /// A list of [CollectionKeyValue]s which are in the iteration order. */
+  KeyValue<K, V> get mapHead;
+  /// A list of changed items.
+  ChangedKeyValue<K, V> get changesHead;
+  /// A list of new added items.
+  AddedKeyValue<K, V> get additionsHead;
+  /// A list of removed items
+  RemovedKeyValue<K, V> get removalsHead;
+
+  void forEachChange(void f(ChangedKeyValue<K, V> change));
+  void forEachAddition(void f(AddedKeyValue<K, V> addition));
+  void forEachRemoval(void f(RemovedKeyValue<K, V> removal));
+}
+
+/**
+ * Each item in map is wrapped in [MapKeyValue], which can track
+ * the [item]s [currentValue] and [previousValue] location.
+ */
+abstract class MapKeyValue<K, V> {
+  /// The item.
+  K get key;
+
+  /// Previous item location in the list or [null] if addition.
+  V get previousValue;
+
+  /// Current item location in the list or [null] if removal.
+  V get currentValue;
+}
+
+abstract class KeyValue<K, V> extends MapKeyValue<K, V> {
+  KeyValue<K, V> get nextKeyValue;
+}
+
+abstract class AddedKeyValue<K, V> extends MapKeyValue<K, V> {
+  AddedKeyValue<K, V> get nextAddedKeyValue;
+}
+
+abstract class RemovedKeyValue<K, V> extends MapKeyValue<K, V> {
+  RemovedKeyValue<K, V> get nextRemovedKeyValue;
+}
+
+abstract class ChangedKeyValue<K, V> extends MapKeyValue<K, V> {
+  ChangedKeyValue<K, V> get nextChangedKeyValue;
+}
+
+
+/**
+ * If [ChangeDetector] is watching a an [Iterable] then the
  * [currentValue] of [Record] will contain this object. The object contains a
  * summary of changes to the collection since the last execution. The changes
  * are reported as a list of [CollectionChangeItem]s which contain the current
@@ -128,18 +186,22 @@ abstract class CollectionChangeRecord<K, V> {
   MovedItem<K, V> get movesHead;
   /** A list of [RemovedItem]s. */
   RemovedItem<K, V> get removalsHead;
+
+  void forEachAddition(void f(AddedItem<K, V> addition));
+  void forEachMove(void f(MovedItem<K, V> move));
+  void forEachRemoval(void f(RemovedItem<K, V> removal));
 }
 
 /**
  * Each item in collection is wrapped in [CollectionChangeItem], which can track
  * the [item]s [currentKey] and [previousKey] location.
  */
-abstract class CollectionChangeItem<K, V> {
+abstract class CollectionChangeItem<K, V> { // TODO(misko): change <K,V> to <V> since K is int.
   /** Previous item location in the list or [null] if addition. */
-  K get previousKey;
+  K get previousKey; // TODO(misko): rename to previousIndex
 
   /** Current item location in the list or [null] if removal. */
-  K get currentKey;
+  K get currentKey; // TODO(misko): rename to CurrentIndex
 
   /** The item. */
   V get item;