             return nil
         }
     }
-
+    
+    private func parseIntoTokens(from string: String) -> [Token] {
+        var stack = [Token]()
+        var numberString = ""
+        
+        for (index, character) in string.unicodeScalars.enumerated() {
+            if character.isDigit() || character.isDot() {
+                numberString += "\(character)"
+            } else if character.isOperator() {
+                if let number = Double(numberString) {
+                    stack.append(Token(operand: number))
+                    numberString = ""
+                }
+    
+                stack.append(Token(operatorType: OperatorType(rawValue: "\(character)")!))
+            } else if character.isParanthesis() {
+                if let number = Double(numberString) {
+                    stack.append(Token(operand: number))
+                    numberString = ""
+                }
+                
+                stack.append(Token(tokenType: character == "(" ? .openBracket : .closeBracket))
+            }
+            
+            if index == string.unicodeScalars.count - 1 {
+                if let number = Double(numberString) {
+                    stack.append(Token(operand: number))
+                    numberString = ""
+                }
+            }
+        }
+        
+        return stack
+    }
+    
     private func parseIntoNumbersAndOperators(from string: String) -> ([Double], [OperatorType]) {
         var numbers: [Double] = []
         var operators: [OperatorType] = []

        let expressionBuilder = InfixExpressionBuilder()

        let (numbers, _) = parseIntoNumbersAndOperators(from: expression)
        
        var numbersIndex = 0
        
        for (index, char) in expression.unicodeScalars.enumerated() {
            print("Char: \(char)")
            
            if char.isOperator() {
                if let number = numbers[safe: numbersIndex] {
                    _ = expressionBuilder.addOperand(operand: number)
                    numbersIndex += 1
                }
                _ = expressionBuilder.addOperator(operatorType: OperatorType(rawValue: "\(char)")!)
            }
            if char.isParanthesis() {
                if char == "(" {
                    expressionBuilder.addOpenBracket()
                    expressionBuilder.addOperand(operand: numbers[numbersIndex])
                } else {
                    expressionBuilder.addOperand(operand: numbers[numbersIndex])
                    expressionBuilder.addCloseBracket()
                }
                numbersIndex += 1
            }
            if index == expression.unicodeScalars.count - 1 {
                if let number = numbers[safe: numbersIndex] {
                    _ = expressionBuilder.addOperand(operand: number)
                }
            }
        }
        
        print("Expression: \(expressionBuilder.build())")
        let (RPN, tokens) = reversePolishNotation(expression: expressionBuilder.build())

        var stack = Stack<Token>()

        var tokenCounter = 0
        
        for token in tokens {
            if token.isOperand { stack.push(token) }
            else {
