anchor.diff:    }
   
     EquationMember operator *(double m) {
  -    var terms = this.terms.fold(new List<Term>(), (list, term) => list
  +    var newTerms = terms.fold(new List<Term>(), (list, term) => list
         ..add(new Term(term.variable, term.coefficient * m)));
  -    return new Expression(terms, this.constant * m);
  +    return new Expression(newTerms, constant * m);
     }
   
     EquationMember operator /(double m) {
  -    var terms = this.terms.fold(new List<Term>(), (list, term) => list
  +    var newTerms = terms.fold(new List<Term>(), (list, term) => list
         ..add(new Term(term.variable, term.coefficient / m)));
  -    return new Expression(terms, this.constant / m);
  +    return new Expression(newTerms, constant / m);
     }
   }
  
positive.code:   Constraint _createConstraint(
        EquationMember /* rhs */ value, Relation relation) {
      if (value is ConstantMember) {
        return new Constraint(new Expression(
            new List.from(this.terms), this.constant - value.value), relation);
      }
  
      if (value is Variable) {
        var newTerms = new List<Term>.from(this.terms)
          ..add(new Term(value, -1.0));
        return new Constraint(new Expression(newTerms, this.constant), relation);
      }
  
      if (value is Term) {
        var newTerms = new List<Term>.from(this.terms)
          ..add(new Term(value.variable, -value.coefficient));
        return new Constraint(new Expression(newTerms, this.constant), relation);
      }
  
      if (value is Expression) {
        var newTerms = value.terms.fold(new List<Term>.from(this.terms),
            (list, t) => list..add(new Term(t.variable, -t.coefficient)));
        return new Constraint(
            new Expression(newTerms, this.constant - value.constant), relation);
      }
  
      assert(false);
  
negative.code: 
    Expression operator +(EquationMember m) {
      if (m is ConstantMember) {
        return new Expression(new List.from(terms), constant + m.value);
      }
  
      if (m is Variable) {
        return new Expression(
            new List.from(terms)..add(new Term(m, 1.0)), constant);
      }
  
      if (m is Term) {
        return new Expression(new List.from(terms)..add(m), constant);
      }
  
      if (m is Expression) {
        return new Expression(
            new List.from(terms)..addAll(m.terms), constant + m.constant);
      }
  
      assert(false);
  