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

          expression.append(number_with_this_val)

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

    class_mixer(AppendNumber)

    class ExponentiateLast
      initialize: (@opts={})->
      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 = 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 = expression.last()

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

        power = if @opts.power then comps.number.build(value: @opts.power) else comps.blank.build()

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

    class_mixer(ExponentiateLast)


    class AppendMultiplication


    class_mixer(Negation)

    class OpenSubExpression
      action: (expression)->
        _ImplicitMultiplication.build().
          onNumeric(expression).
          append(comps.expression.build().open())

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


    class_mixer(OpenSubExpression)

    class _FinalOpenSubExpressionApplication
      initialize: (@expr)->
        @found = false

      findAndPerformAction: (expr)->
        subexp = @nextSubExpression(expr)
        if subexp
          subexp = @findAndPerformAction(subexp)
        if @found # the child element below me was updated
          @updateWithNewSubexp(expr, subexp)
        else if expr instanceof comps.expression and expr.isOpen()
