Recursive enumerations in Swift - Mini Project: Build & Apply

Recursive Enumerations in Swift

📖 Scenario: Imagine you are building a simple calculator that can handle addition and multiplication of numbers. You want to represent these calculations using a special kind of data structure called a recursive enumeration. This will help you understand how to model complex data that can contain itself.

🎯 Goal: Build a recursive enumeration in Swift to represent simple math expressions with numbers, addition, and multiplication. Then, write code to calculate the result of these expressions.

📋 What You'll Learn

Create a recursive enumeration called Expression with cases for number, addition, and multiplication.

Add a constant called expr that represents the expression (5 + 3) * 2 using the Expression enum.

Write a function called evaluate that takes an Expression and returns the calculated Int result.

Print the result of evaluating expr.

💡 Why This Matters

🌍 Real World

Recursive enumerations help model data that can contain itself, like math expressions, file systems, or nested menus.

💼 Career

Understanding recursive enums is useful for Swift developers working on compilers, interpreters, or complex data modeling in apps.

1

Create the recursive enumeration

Create a recursive enumeration called Expression with three cases: number(Int), addition(Expression, Expression), and multiplication(Expression, Expression).

Swift

# Your code here

Need a hint?

Use the indirect keyword before enum to allow recursive cases.

2

Create an expression instance

Create a constant called expr that represents the expression (5 + 3) * 2 using the Expression enum cases.

Swift

indirect enum Expression {
    case number(Int)
    case addition(Expression, Expression)
    case multiplication(Expression, Expression)
}

# Your code here

Need a hint?

Use nested enum cases to build the expression (5 + 3) * 2.

3

Write the evaluation function

Write a function called evaluate that takes an Expression parameter and returns an Int. Use a switch statement to handle each case and recursively calculate the result.

Swift

indirect enum Expression {
    case number(Int)
    case addition(Expression, Expression)
    case multiplication(Expression, Expression)
}

let expr = Expression.multiplication(
    .addition(.number(5), .number(3)),
    .number(2)
)

// Write the evaluate function below
# Your code here

Need a hint?

Use recursion by calling evaluate inside the addition and multiplication cases.

4

Print the evaluation result

Write a print statement to display the result of calling evaluate on expr.

Swift

indirect enum Expression {
    case number(Int)
    case addition(Expression, Expression)
    case multiplication(Expression, Expression)
}

let expr = Expression.multiplication(
    .addition(.number(5), .number(3)),
    .number(2)
)

func evaluate(_ expression: Expression) -> Int {
    switch expression {
    case .number(let value):
        return value
    case .addition(let left, let right):
        return evaluate(left) + evaluate(right)
    case .multiplication(let left, let right):
        return evaluate(left) * evaluate(right)
    }
}

// Print the result of evaluating expr
# Your code here

Need a hint?

The expression (5 + 3) * 2 equals 16.