anchor.diff:     * 
      * If the argument is not an expression, it will be wrapped in an appropriate
      * literal.
  -   *  - A (positive) number will be encapsulated in a [Number] Literal,
  -   *  - A string will be encapsulated in a [Variable] Literal.
  +   * 
  +   * * A (positive) number will be encapsulated in a [Number] Literal,
  +   * * A string will be encapsulated in a [Variable] Literal.
      */
     UnaryOperator(exp) {
       this.exp = _toExpression(exp);
  
positive.code:    */
    Minus(first, second): super(first, second);
    
    Expression derive(String toVar) => new Minus(first.derive(toVar), second.derive(toVar));
    String toString() => '(${first.toString()} - ${second.toString()})';
  }
  
  
negative.code:    */
    Divide(dividend, divisor): super(dividend, divisor);
    
    Expression derive(String toVar) => ((first.derive(toVar) * second)
                                      - (first * second.derive(toVar)))
                                      / (second * second);
    
    /**
     * Possible simplifications:
     * 
     * 1. -a / b = - (a / b)
     * 2. a * -b = - (a / b)
     * 3. -a / -b = a / b
     * 5. 0 / a = 0
     * 6. a / 1 = a
     * 
     * This method throws an error, if a divide by zero is encountered.
     */
    Expression simplify() {
      Expression firstOp = first.simplify();
      Expression secondOp = second.simplify();
      Expression tempResult;
      
      bool negative = false;
      
      if (firstOp is UnaryMinus) {
        firstOp = firstOp.exp;
        negative = !negative;
      }
      
      if (secondOp is UnaryMinus) {
        secondOp = secondOp.exp;
        negative = !negative;
      }
      
      if (_isNumber(firstOp, 0)) {
        return firstOp; // = 0
      }
      
      if (_isNumber(secondOp, 0)) {
        throw new ArgumentError('Divide by zero.');
      }
      
      if (_isNumber(secondOp, 1)) {
        tempResult = firstOp;
      } else {
        tempResult = new Divide(firstOp, secondOp);
      }
      
      return negative ? new UnaryMinus(tempResult) : tempResult;
      
      // TODO cancel down/out? - needs equals on literals!
    }
    
    String toString() => '(${first.toString()} / ${second.toString()})';
  }
  
  