### Recursive enumeration in Swift : Explanation with example :

We know that a function is called recursive if the function itself is called from it. Similar to recursive function, in swift we have recursive enumeration. If any *case* in the enumeration contains one or more *associated value* as another instance of the Enumeration itself. For example, let’s take a look at the below example :

```
enum RecursiveEnum {
indirect case firstCase(RecursiveEnum)
}
```

It is an recursive enumeration. Because, the case *firstCase* has associated value as same type of *RecursiveEnum*. One thing we should note that the keyword *indirect* should be used before the name of each *case* that will behave recursively. We can also use the *indirect* keyword before the name of the enum like below :

```
indirect enum RecursiveEnum {
case firstCase(RecursiveEnum)
}
```

This is better than the previous version because we don’t need to write *indirect* before each *case* statement.To understand more on recursive enum, let me explain you with an example :

### Recursive Enum example :

Let’s consider the below enum :

```
indirect enum Calculator{
case number(Int)
case add(Calculator, Calculator)
case subtract(Calculator, Calculator)
case multiply(Calculator, Calculator)
case divide(Calculator, Calculator)
}
```

- The name of the enum is
*Calculator* - It has four different cases .
- The case
*add, subtract, multiply*and*divide*are of recursive type i.e. they will accept only values of type*Calculator*.

Now, to solve any expressions, we can write one function like below :

```
func calculate(_ exp: Calculator) -> Int{
switch(exp){
case let .number(value):
return value
case let .add(first,second):
return calculate(first) + calculate(second)
case let .subtract(first , second):
return calculate(first) - calculate(second)
case let .multiply(first , second):
return calculate(first) * calculate(second)
case let .divide(first, second):
return calculate(first)/calculate(second)
}
}
```

This function will take one variable of type *Calculator* and find out the result recursively. For example, let’s take a look at the below example expressions :

```
let one = Calculator.number(1)
let two = Calculator.number(2)
print(calculate(Calculator.add(one,two)))
print(calculate(Calculator.subtract(one,two)))
print(calculate(Calculator.multiply(one,two)))
print(calculate(Calculator.divide(two,one)))
```

It will print :

```
3
-1
2
2
```

Similarly, to solve one more complex problem like *( 2 + 3) * (5 - 2)*, we can use the below expression :

```
let two = Calculator.number(1)
let three = Calculator.number(2)
let five = Calculator.number(5)
let addition = Calculator.add(two,three)
let subtraction = Calculator.subtract(five,two)
print(calculate(Calculator.multiply(addition,subtraction)))
```

It will print *12*.