def eval_expr(s):
    if not isinstance(s, str):
        raise ValueError("expression must be a string")

    pos = 0
    length = len(s)

    def skip_whitespace():
        nonlocal pos
        while pos < length and s[pos].isspace():
            pos += 1

    def parse_number():
        nonlocal pos
        start = pos
        has_digits = False
        has_decimal = False

        while pos < length and "0" <= s[pos] <= "9":
            pos += 1
            has_digits = True

        if pos < length and s[pos] == ".":
            has_decimal = True
            pos += 1
            while pos < length and "0" <= s[pos] <= "9":
                pos += 1
                has_digits = True

        if not has_digits:
            raise ValueError("invalid number")

        token = s[start:pos]
        try:
            return float(token) if has_decimal else int(token)
        except ValueError:
            raise ValueError("invalid number") from None

    def parse_primary():
        nonlocal pos
        skip_whitespace()

        if pos >= length:
            raise ValueError("expected operand")

        char = s[pos]

        if char == "(":
            pos += 1
            value = parse_expression()
            skip_whitespace()
            if pos >= length or s[pos] != ")":
                raise ValueError("mismatched parentheses")
            pos += 1
            return value

        if ("0" <= char <= "9") or (
            char == "." and pos + 1 < length and "0" <= s[pos + 1] <= "9"
        ):
            return parse_number()

        raise ValueError("expected number or parenthesized expression")

    def parse_unary():
        nonlocal pos
        skip_whitespace()

        if pos < length and s[pos] in "+-":
            operator = s[pos]
            pos += 1
            value = parse_unary()
            return value if operator == "+" else -value

        return parse_primary()

    def parse_term():
        nonlocal pos
        value = parse_unary()

        while True:
            skip_whitespace()
            if pos >= length or s[pos] not in "*/":
                return value

            operator = s[pos]
            pos += 1
            right = parse_unary()

            if operator == "*":
                value *= right
            else:
                if right == 0:
                    raise ValueError("division by zero")
                value /= right

    def parse_expression():
        nonlocal pos
        value = parse_term()

        while True:
            skip_whitespace()
            if pos >= length or s[pos] not in "+-":
                return value

            operator = s[pos]
            pos += 1
            right = parse_term()

            if operator == "+":
                value += right
            else:
                value -= right

    try:
        skip_whitespace()
        if pos >= length:
            raise ValueError("empty expression")

        result = parse_expression()
        skip_whitespace()

        if pos != length:
            raise ValueError("unexpected token")

        if isinstance(result, float) and result.is_integer():
            return int(result)
        return result
    except RecursionError:
        raise ValueError("expression is too deeply nested") from None