"""Create reasoning_engine
Generated by Phi-Octopus Eden
2025-11-07 07:25:14.638094
"""

```python
from typing import List, Dict


class ReasoningEngine:
    """
    A simple reasoning engine designed to solve problems with limited reasoning sophistication.
    This implementation focuses on solving arithmetic expressions involving basic operations such as addition and subtraction.

    :param expression: The arithmetic expression as a string.
    """

    def __init__(self, expression: str):
        self.expression = expression
        self.operators = {'+': lambda x, y: x + y, '-': lambda x, y: x - y}

    def evaluate_expression(self) -> int:
        """
        Evaluates the arithmetic expression by parsing and applying the operators.
        :return: The result of the evaluated expression as an integer.
        """
        tokens = self._tokenize_expression()
        return self._evaluate(tokens)

    def _tokenize_expression(self) -> List[str]:
        """
        Splits the input string into tokens (numbers and operators).
        :return: A list of strings representing numbers and operators.
        """
        expression_list = []
        current_number = ''
        for char in self.expression:
            if char.isdigit():
                current_number += char
            else:
                if current_number:
                    expression_list.append(current_number)
                    current_number = ''
                expression_list.append(char)
        if current_number:  # Handle trailing number
            expression_list.append(current_number)
        return [token for token in expression_list if token]  # Remove empty strings

    def _evaluate(self, tokens: List[str]) -> int:
        """
        Recursively evaluates the arithmetic expression using operator precedence.
        :param tokens: A list of strings representing numbers and operators.
        :return: The result of the evaluated expression as an integer.
        """
        if len(tokens) == 1:
            return int(tokens[0])
        
        # Find first occurrence of '+' or '-', process it, then repeat
        for i in range(len(tokens)):
            if tokens[i] in self.operators.keys():
                left_operand = int(tokens[i-1])
                right_operand = int(tokens[i+1])
                result = self.operators[tokens[i]](left_operand, right_operand)
                # Replace the processed part with the result
                return self._evaluate([str(result)] + tokens[:i-1] + tokens[i+2:])

    def solve_expression(self) -> int:
        """
        Main method to solve the arithmetic expression.
        :return: The result of solving the arithmetic expression as an integer.
        """
        return self.evaluate_expression()


# Example usage
if __name__ == "__main__":
    engine = ReasoningEngine("5 + 3 - 2")
    print(f"Result: {engine.solve_expression()}")  # Output should be 6

    engine = ReasoningEngine("10 - 4 + 2")
    print(f"Result: {engine.solve_expression()}")  # Output should be 8
```

This `ReasoningEngine` class provides a basic capability to evaluate arithmetic expressions with limited reasoning. It tokenizes the input expression, processes it according to operator precedence, and evaluates the result. The example usage demonstrates how to use this engine to solve simple arithmetic problems.