           expression.append(new_last)
 
       invoke: (expression)->
-        _FinalOpenSubExpressionApplcation.build((expr)=> @onFinalExpression(expr)).
-          invokeOrDefault(expression)
+        _FinalOpenSubExpressionApplication.build(expression).
+          invokeOrDefault((expr)=> @onFinalExpression(expr))
 
     class_mixer(AppendDecimal)
 

        _OverrideIfOperatorOrAppend.build(expression).with comps.multiplication.build()

      invoke: (expression)->
        _FinalOpenSubExpressionApplcation.build((expr)=> @appendAction(expr)).
          invokeOrDefault(expression)

    class_mixer(AppendMultiplication)


    class AppendDivision
      invoke: (expression)->
        _FinalOpenSubExpressionApplcation.build((expr)=>
          _OverrideIfOperatorOrAppend.build(expr).with comps.division.build()).
          invokeOrDefault(expression)
    class_mixer(AppendDivision)


    class AppendAddition
      invoke: (expression)->
        _FinalOpenSubExpressionApplcation.build(
          (expression)->
            _OverrideIfOperatorOrAppend.build(expression).with comps.addition.build()
          ).invokeOrDefault(expression)

    class_mixer(AppendAddition)


    class AppendSubtraction
      invoke: (expression)->
        _FinalOpenSubExpressionApplcation.build(
          (expression)->
            _OverrideIfOperatorOrAppend.build(expression).with comps.subtraction.build()
          ).invokeOrDefault(expression)

    class_mixer(AppendSubtraction)


          expression.append(number_with_this_val)

      invoke: (expression)->
        _FinalOpenSubExpressionApplication.build(expression).
          invokeOrDefault((expr)=> @onFinalExpression(expr))

    class_mixer(AppendNumber)

    class ExponentiateLast
      initialize: (@opts={})->

      baseExpression: (base)->
        comps.expression.build(expression: [base])

      powerExpression: ()->
        power = if @opts.power
          comps.expression.build expression: [
            comps.number.build(value: @opts.power)
          ]
        else
          comps.expression.build expression: []

        if @opts.power_closed
          power
        else
          power.open()

      invoke: (expression)->
        last = expression.last()

        # in the first case, our base case comes
        # from the contents of a previous part of the expression
        if it = last.preceedingSubexpression()
          base = @baseExpression(it)

        # if the previous element is an operator but has no sub-expression,
        # then we are dropping the operator and use the number prior to the operator
        else if last.isOperator()
          expression = expression.withoutLast() #remove useless operator
          base = @baseExpression(expression.last())

        # otherwise, our base is just the number before
        else
          base = @baseExpression(expression.last())


        power = @powerExpression()



        expression.replaceLast(
          comps.exponentiation.build(base: base, power: power))

    class_mixer(ExponentiateLast)

    class SquareLast


    class AppendMultiplication
