Speed up CompoundBindings

pkg/observe/lib/src/compound_binding.dart

 // Copyright (c) 2013, 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 observe;
 
 /** The callback used in the [CompoundBinding.combinator] field. */
 typedef Object CompoundBindingCombinator(Map objects);
 
 /**
@@ skipping 16 matching lines @@
  *     binding.bind('nameN', objN, pathN);
  */
 // TODO(jmesserly): rename to something that indicates it's a computed value?
 class CompoundBinding extends ChangeNotifierBase {
   CompoundBindingCombinator _combinator;
 
   // TODO(jmesserly): ideally these would be String keys, but sometimes we
   // use integers.
   Map<dynamic, StreamSubscription> _observers = new Map();
   Map _values = new Map();
-  bool _scheduled = false;
   Object _value;
 
+  /**
+   * True if [resolve] is scheduled. You can set this to true if you plan to
+   * call [resolve] manually, avoiding the need for scheduling an asynchronous
+   * resolve.
+   */
+  // TODO(jmesserly): I don't like having this public, is the optimization
+  // really needed? "runAsync" in Dart should be pretty cheap.
+  bool scheduled;
+
+  /**
+   * Creates a new CompoundBinding, optionally proving the [combinator] function
+   * for computing the value. You can also set [schedule] to true if you plan
+   * to invoke [resolve] manually after initial construction of the binding.
+   */
   CompoundBinding([CompoundBindingCombinator combinator]) {
     // TODO(jmesserly): this is a tweak to the original code, it seemed to me
     // that passing the combinator to the constructor should be equivalent to
     // setting it via the property.
     // I also added a null check to the combinator setter.
     this.combinator = combinator;
   }
 
   CompoundBindingCombinator get combinator => _combinator;
 
@@ skipping 29 matching lines @@
 
     binding.cancel();
     _values.remove(name);
     if (!suppressResolve) _scheduleResolve();
   }
 
   // TODO(rafaelw): Is this the right processing model?
   // TODO(rafaelw): Consider having a seperate ChangeSummary for
   // CompoundBindings so to excess dirtyChecks.
   void _scheduleResolve() {
-    if (_scheduled) return;
-    _scheduled = true;
+    if (scheduled) return;
+    scheduled = true;
     runAsync(resolve);
   }
 
   void resolve() {
     if (_observers.isEmpty) return;
-    _scheduled = false;
+    scheduled = false;
 
     if (_combinator == null) {
       throw new StateError(
           'CompoundBinding attempted to resolve without a combinator');
     }
 
     value = _combinator(_values);
   }
 
   /**
    * Closes the observer.
    *
    * This happens automatically if the [value] property is no longer observed,
    * but this can also be called explicitly.
    */
   void close() {
     for (var binding in _observers.values) {
       binding.cancel();
     }
     _observers.clear();
     _values.clear();
     value = null;
   }
 
   _unobserved() => close();
 }