anchor.diff:          expressionStack.add(currentExpression);
           continue;
         }
  -      
  -      if(currentToken.type == TokenType.POW){
  +
  +      if(currentToken.type == TokenType.POW) {
           Expression rightOperand = expressionStack.last;
           expressionStack.removeLast();
           Expression leftOperand = expressionStack.last;
  
positive.code:        * stream until you find an operator with a priority lower or equal as the current tokens.
         * Then add the current Token to the operator buffer.
         */
        if(tempToken.type.priority < operatorBuffer.last.type.priority){
          while(operatorBuffer.length>0 && operatorBuffer.last.type.priority > tempToken.type.priority){
            outputStream.add(operatorBuffer.last);
            operatorBuffer.removeLast();
          }
          operatorBuffer.add(tempToken);
          continue;
        }else{
          operatorBuffer.add(tempToken);
          continue;
        }
      }
      /*
       * when the algorithm reached the end of the input stream, then we add the tokens in the 
       * operatorBuffer to the outputStream.
       */
      while(!operatorBuffer.isEmpty){
        outputStream.add(operatorBuffer.last);
        operatorBuffer.removeLast();
      }
  
      return outputStream;
    }
    
    /** 
     * This method invokes the createTokenStream methode to create an infix token stream and then invokes the shunting
     * yards method to transform this stream into an UPN token stream.
     * 
     * Returns  List<Token>.
     */
    createUPNStream(String inputString){
      List<Token> infixStream = createTokenStream(inputString);
      _tokenStream = shuntingYard(infixStream);
    }
  }
  
  class Token{
    //TODO
    var text;
    final TokenType type;
  
    bool operator==(Token token) => (token.text == this.text) && (token.type == this.type);
    
    Token(var this.text, TokenType this.type){
    }
  
    String toString(){
      return "( $type , $text )";
    }
  
  }
  
  class TokenType{
    static final TokenType VAR = const TokenType("VAR",10);
    static final TokenType VAL = const TokenType("VAL",10);
    //Braces
    static final TokenType LBRACE = const TokenType("LBRACE",-1);
    static final TokenType RBRACE = const TokenType("RBRACE",-1);
    //Simple Operators
    static final TokenType PLUS = const TokenType("PLUS",1);
    static final TokenType MINUS = const TokenType("MINUS",1);
    static final TokenType UNMINUS = const TokenType("UNMINUS",1);
    static final TokenType TIMES = const TokenType("TIMES",2);
    static final TokenType DIV = const TokenType("DIV",2);
    //Complex Operators
    static final TokenType POW = const TokenType("POW",3);
    static final TokenType SQRT = const TokenType("SQRT",3);
  
negative.code:       /* if the current Tokens type is MINUS and the last Token in the operator buffer is of type LBRACE
         * the current Token is an unary minus, so the tokentype has to be changed.
         */
        if(tempToken.type == TokenType.MINUS && operatorBuffer.last.type == TokenType.LBRACE) {
          Token newToken = new Token(tempToken.text, TokenType.UNMINUS);
          operatorBuffer.add(newToken);
          continue;
  