     ref.forDefault({
       isEqual: -> console.log(@); throw "NOT IMPLEMENTED"
     })
-    # Number
+
+    # Pi
     ref.forType(comps.pi, {
       isEqual: (buildIsEqual(comps.pi))
     })


    # Exponentiation
    ref.forType(comps.exponentiation, {
      isEqual: (buildIsEqual(comps.exponentiation)),
      _simpleIsEqual: (other)->
        ref.refine(@base()).isEqual(other.base()) and
          ref.refine(@power()).isEqual(other.power())
      })


    # Expression
    ref.forType(comps.expression, {
      isExpressionEqual: (other)->
        logger.info("isExpressionEqual", @unrefined(), other)
        if @is_error == other.is_error && @is_open == other.is_open
          if _(@expression).size() == _(other.expression).size()
            contains_unequal =
              _.chain(@expression).map((element, i)->
                ref.refine(element).isEqual(other.nth(i))
              ).contains(false).value()
            !contains_unequal
          else
            false
        else
          false

      isEqual: (other)->
        if other instanceof comps.expression
          @isExpressionEqual(other)
    })



    # Multiplication

    })

    class ExpressionEquality
      initialize: ->
        @report_saved = false

      calculate: (@first, @second)->
        firstp = ref.refine @first
        @_equality_results = firstp.isEqual @second, @
        @

      isEqual: ->
        @_equality_results

      notEqualReport: (@a, @b, @not_eql_msg)->
        @report_saved = true

      saveFalseForReport: (value, a, b, msg)->
        if value
          true
        else
          @notEqualReport(a, b, msg) unless @report_saved
          false

    class_mixer ExpressionEquality

    ExpressionEquality.isEqual = (a,b)->
      ExpressionEquality.build().calculate(a,b).isEqual()

    ExpressionEquality.equalityCalculation = (a,b)->
      ec = ExpressionEquality.build()
      ec.calculate(a,b)
      ec

    return ExpressionEquality
