Enum associated values

Question

I'm trying to understand Swift's Enum. I want to assign my enum case an associated value and have a computed value returned. Currently I'm using a method for returning the calculated number.

enum Calculation {
    case Number1(number: Int)
    case Number2(number: Int)

    func calculation() -> Int {
        switch self {
        case Number1(let number): return number + 1
        case Number2(let number): return number + 2
        }
    }
}

I was wondering if it could be done shorter like:

// This obviously doesn't work. Just an example as what I'm trying to achieve
enum Calculation: Int {
    case Number1(number: Int): return number + 1
    case Number2(number: Int): return number + 2
}

Answer 1

The question is whether you want to use a computed variable:

enum Calculation {
    case Number1(number: Int)
    case Number2(number: Int)

    var value:Int {
        switch self {
        case Number1(let number): return number + 1
        case Number2(let number): return number + 2
        }
    }

}

Or have the value stored as the associated value:

enum CalculationType {
    case Number1, Number2
}
enum Calculation {

    case Number1(number: Int)
    case Number2(number: Int)

    init (type:CalculationType, number:Int) {
        switch type {
        case .Number1:
            self = Calculation.Number1(number: number + 1)
        case .Number2:
            self = Calculation.Number2(number: number + 2)
        }

    }
}

Your question points towards the former but I'm not clear from your second piece of code whether you were expecting the latter or hoping that initialization would return a value, which can't happen (an init does not return a value). The closest thing would be to have a static function:

enum CalculationType {
    case Number1, Number2
}
enum Calculation {
    case Number1(number: Int)
    case Number2(number: Int)

    static func calc(type:CalculationType, number:Int) -> (Calculation, Int) {
        switch type {
        case .Number1:
            return (Calculation.Number1(number: number), number + 1)
        case .Number2:
            return  (Calculation.Number2(number: number), number + 2)
        }
    }

}

Calculation.calc(.Number1, number: 2)

Alternatively you could use a callback on the init:

enum CalculationType {
    case Number1, Number2
}
enum Calculation {

    case Number1(number: Int)
    case Number2(number: Int)

    init (type:CalculationType, number:Int, callback:(Int) -> Void) {
        switch type {
        case .Number1:
            self = Calculation.Number1(number: number)
            callback(number + 1)
        case .Number2:
            self = Calculation.Number2(number: number)
            callback(number + 2)
        }

    }

}


Calculation(type: .Number1, number: 10, callback: {n in print(n)})