Swift: Money with Phantom Types 👻

Posted on March 30th, 2016

When I wrote about enums with no cases yesterday, both @mbrandonw and @jl_hfl pointed me to Phantom Types 👻!

@mbrandonw @NatashaTheRobot @cocoaphony @jesse_squires Yes. https://t.co/bOcxqVhtKi I got no case enums from @johannesweiss

— Joseph Lord (@jl_hfl) March 29, 2016

I’ve seen Phantom Types before, including in this objc.io article about Phantom Types and in conference talks, but while I like the idea of Phantom Types and think they’re cool and interesting, I haven’t actually used them ever in my own code. Mostly, because it’s not yet natural for me to see a problem and think “Ah, Phantom Types would be the perfect solution!”.

However, I would like to have Phantom Types more accessible for myself in the future and I really enjoyed the example that @johannesweiss gave in his talk The Type System is Your Friend, so I’m going to write his example out here to be more searchable / discoverable for myself and hopefully others!

The problem that @johannesweiss with Phantom Types is currency conversion 💸🤑💸!

While in the video, @johannesweiss goes straight into the Phantom Type solution, I wanted to first try a solution without the Phantom Types to see the before and after!

Without Phantom Types 😱

I would probably have a Money struct that includes both the amount and the currency of the amount:

struct Money {
    enum Currency {
        case GBP, EUR, USD
    }
    
    let amount: NSDecimalNumber
    let currency: Currency
}

struct Money {

enum Currency {

case GBP, EUR, USD

}

let amount: NSDecimalNumber

let currency: Currency

}

But let’s say I want to convert the money to a different currency – let’s say from GBP to EUR:

enum MoneyError: ErrorType {
    case WrongCurrency
}

func convertGBPtoEUR(gbp: Money) throws -> Money {
    if gbp.currency == .GBP {
        let forex = NSDecimalNumber(mantissa: 133263, exponent: -5, isNegative: false)
        let convertedAmount = gbp.amount.decimalNumberByMultiplyingBy(forex)
        return Money(amount: convertedAmount, currency: .EUR)
    } else {
        throw MoneyError.WrongCurrency
    }
}

// Usage
let fivePounds = Money(amount: 5, currency: .GBP)
let threeEuros = Money(amount: 3, currency: .EUR)

do {
    let conversionResult = try convertGBPtoEUR(fivePounds)
} catch {
     print("Error!!! Wrong Currency Conversion!!!")
}

do {
    // passing in the wrong currency is allowed here
    let badConversionResult = try convertGBPtoEUR(threeEuros)
} catch {
    print("Error!!! Wrong Currency Conversion!!!")
}

enum MoneyError: ErrorType {

case WrongCurrency

}

func convertGBPtoEUR(gbp: Money) throws -> Money {

if gbp.currency == .GBP {

let forex = NSDecimalNumber(mantissa: 133263, exponent: -5, isNegative: false)

let convertedAmount = gbp.amount.decimalNumberByMultiplyingBy(forex)

return Money(amount: convertedAmount, currency: .EUR)

} else {

throw MoneyError.WrongCurrency

}

// Usage

let fivePounds = Money(amount: 5, currency: .GBP)

let threeEuros = Money(amount: 3, currency: .EUR)

do {

let conversionResult = try convertGBPtoEUR(fivePounds)

} catch {

print("Error!!! Wrong Currency Conversion!!!")

}

do {

// passing in the wrong currency is allowed here

let badConversionResult = try convertGBPtoEUR(threeEuros)

} catch {

print("Error!!! Wrong Currency Conversion!!!")

}

We can immediately see the problem. I have to check to make sure that the money passed into my function is of the correct currency. And if it’s not, I have to trhow an Error. Which cascades down and now the function that calls this function has to handle an error case!

With Phantom Types 👻

Phantom Types are Types that don’t have any functionality. According to @johannesweiss:

A phantom type is a parameterized type whose type parameters do not all appear in its definition. I have what you could call a useless type parameter C. This is the Currency, and it is not even used in the actual properties of the struct. To fill Money, I created an empty protocol, Currency, so that I may mark any type as a currency.

Like this:

protocol Currency { }

enum GBP: Currency { }
enum EUR: Currency { }
enum USD: Currency { }

struct Money<C: Currency> {
    let amount: NSDecimalNumber
}

protocol Currency { }

enum GBP: Currency { }

enum EUR: Currency { }

enum USD: Currency { }

struct Money<C: Currency> {

let amount: NSDecimalNumber

}

Now the GBP -> EUR conversion function looks like this!

// the method signature is super nice now!
// inputing Money in GBP, return Money in EUR!
func convertGBPtoEUR(gbp: Money<GBP>) -> Money<EUR> {
    let forex = NSDecimalNumber(mantissa: 133263, exponent: -5, isNegative: false)
    let convertedAmount = gbp.amount.decimalNumberByMultiplyingBy(forex)
    return Money(amount: convertedAmount)
}

// Usage
let fivePounds = Money<GBP>(amount: 5)
let threeEuros = Money<EUR>(amount: 3)

let convertedMoney = convertGBPtoEUR(fivePounds) // success!
let badMoney = convertGBPtoEUR(threeEuros) // compiler error!

// the method signature is super nice now!

// inputing Money in GBP, return Money in EUR!

func convertGBPtoEUR(gbp: Money<GBP>) -> Money<EUR> {

let forex = NSDecimalNumber(mantissa: 133263, exponent: -5, isNegative: false)

let convertedAmount = gbp.amount.decimalNumberByMultiplyingBy(forex)

return Money(amount: convertedAmount)

}

// Usage

let fivePounds = Money<GBP>(amount: 5)

let threeEuros = Money<EUR>(amount: 3)

let convertedMoney = convertGBPtoEUR(fivePounds) // success!

let badMoney = convertGBPtoEUR(threeEuros) // compiler error!

Notice that we no longer need to manually check for correct currency type or return any errors. The compiler does the work for us!

Update

The point of this blog post is to illustrate the basics of using Phantom Types. However, as @oisdk points out, you can go further and use Phantom Types to automatically pick the correct conversion:

@NatashaTheRobot @johannesweiss @jl_hfl You can also use phantom types to automatically pick the correct conversion https://t.co/2JfZquS4E9

— oisdk (@oisdk) March 30, 2016

@davedelong further optimized the solution to this:

import Foundation

protocol Currency {
    static var code: String { get }
    static var factor: NSDecimalNumber { get }
}
enum GBP: Currency {
    static let code = "GBP"
    static let factor: NSDecimalNumber = 1.44
}
enum EUR: Currency {
    static let code = "EUR"
    static let factor: NSDecimalNumber = 1.13
}
enum USD: Currency {
    static let code = "USD"
    static let factor: NSDecimalNumber = 1.0
}

struct Money<Cur: Currency>: CustomStringConvertible, FloatLiteralConvertible, IntegerLiteralConvertible {
    let amount: NSDecimalNumber
    
    var description: String {
        let f = NSNumberFormatter()
        f.numberStyle = .CurrencyStyle
        f.currencyCode = Cur.code
        return f.stringFromNumber(self.amount)!
    }
    
    init(floatLiteral value: Double) {
        self.amount = NSDecimalNumber(double: value)
    }
    
    init(integerLiteral value: Int) {
        self.amount = NSDecimalNumber(integer: value)
    }
    
    init(_ amount: NSDecimalNumber) {
        self.amount = amount
    }
    
    func convertTo<C: Currency>() -> Money<C> {
        let baseAmount = amount.decimalNumberByMultiplyingBy(Cur.factor)
        let convertedAmount = baseAmount.decimalNumberByDividingBy(C.factor)
        return Money<C>(convertedAmount)
    }
}

extension Money {
    var gbp: Money<GBP> { return convertTo() }
    var eur: Money<EUR> { return convertTo() }
    var usd: Money<USD> { return convertTo() }
}

// Usage
let fivePound: Money<GBP> = 5 // £5
let threeEuro: Money<EUR> = 3 // €3

print(fivePound.eur) // €6.35
print(threeEuro.gbp) // £2.37

import Foundation

protocol Currency {

static var code: String { get }

static var factor: NSDecimalNumber { get }

}

enum GBP: Currency {

static let code = "GBP"

static let factor: NSDecimalNumber = 1.44

}

enum EUR: Currency {

static let code = "EUR"

static let factor: NSDecimalNumber = 1.13

}

enum USD: Currency {

static let code = "USD"

static let factor: NSDecimalNumber = 1.0

}

struct Money<Cur: Currency>: CustomStringConvertible, FloatLiteralConvertible, IntegerLiteralConvertible {

let amount: NSDecimalNumber

var description: String {

let f = NSNumberFormatter()

f.numberStyle = .CurrencyStyle

f.currencyCode = Cur.code

return f.stringFromNumber(self.amount)!

}

init(floatLiteral value: Double) {

self.amount = NSDecimalNumber(double: value)

}

init(integerLiteral value: Int) {

self.amount = NSDecimalNumber(integer: value)

}

init(_ amount: NSDecimalNumber) {

self.amount = amount

}

func convertTo<C: Currency>() -> Money<C> {

let baseAmount = amount.decimalNumberByMultiplyingBy(Cur.factor)

let convertedAmount = baseAmount.decimalNumberByDividingBy(C.factor)

return Money<C>(convertedAmount)

}

extension Money {

var gbp: Money<GBP> { return convertTo() }

var eur: Money<EUR> { return convertTo() }

var usd: Money<USD> { return convertTo() }

}

// Usage

let fivePound: Money<GBP> = 5 // £5

let threeEuro: Money<EUR> = 3 // €3

print(fivePound.eur) // €6.35

print(threeEuro.gbp) // £2.37

Abdullah

great post! I have question, in convertGBPtoEUR func what dose this – & g t mean?
- Abdullah
  
  oh… html entity for “>”
  - NatashaTheRobot
    
    Yeah sorry, sometimes the HTML gets messed up. Fixed it!
    - Stuart Kent
      
      Are the generic types being swallowed here, or am I missing something else?
      - Apokrupto
        
        I think it’s an editing issue, the code as it is compiles, even badMoney in the example. All the generics have been removed accidentally
      - NatashaTheRobot
        
        Yeah – sorry. Things got messed up somehow. Updated!
      - Stuart Kent
        
        No problem, and thanks for the article!
Hugh Berney

nice article.

However I think you may have a typo in the following paragraph:

// the method signature is super nice now! // inputing Money in GBP, return Money in EUR! func convertGBPtoEUR(gbp: Money) -> Money { let forex = NSDecimalNumber(mantissa: 133263, exponent: -5, isNegative: false) let convertedAmount = gbp.amount.decimalNumberByMultiplyingBy(forex) return Money(amount: convertedAmount) }
// Usage let fivePounds = Money(amount: 5) let threeEuros = Money(amount: 3) let convertedMoney = convertGBPtoEUR(fivePounds) // success! let badMoney = convertGBPtoEUR(threeEuros) // compiler error!

Shouldn’t it be:
// the method signature is super nice now! // inputing Money in GBP, return Money in EUR! func convertGBPtoEUR(gbp: GBP) -> EUR { let forex = NSDecimalNumber(mantissa: 133263, exponent: -5, isNegative: false) let convertedAmount = gbp.amount.decimalNumberByMultiplyingBy(forex) return EUR(amount: convertedAmount) }
// Usage let fivePounds = GBP(amount: 5) let threeEuros = EUR(amount: 3) let convertedMoney = convertGBPtoEUR(fivePounds) // success! let badMoney = convertGBPtoEUR(threeEuros) // compiler error!

You’re still using the type Money and not the fantom type EUR && GBP ?

++
- NatashaTheRobot
  
  Hmmm.. must have gotten messed up somehow with the HTML / Update. Fixed it!
  - Hugh Berney
    
    👍👍👍
nferocious76

so this phantom type thing is like a wild card right?
- hamsternik
  
  It’s more convenient to look up phantom types as like a marker interface pattern which works with genercis