A taste of Swift 3.0 - Peano data type design

Peano.swift

import Foundation

public indirect enum Peano: ExpressibleByIntegerLiteral {
    case Succ(Peano),
         Zero

    public init(integerLiteral v: IntegerLiteralType) {
        if v == 0 {
            self = .Zero
        } else {
            self = .Succ(Peano(integerLiteral:v - 1))
        }
    }

    public func catamorphism<R>(_ s: (Peano) -> R, _ z: () -> R) -> R {
        switch self {
        case .Succ(let e):
            return s(e)
        case .Zero:
            return z()
        }
    }

    public func add(_ p: Peano) -> Peano {
        return catamorphism({ .Succ($0.add(p)) }, { p })
    }

    public func mult(_ p: Peano) -> Peano {
        return catamorphism({ p.add($0.mult(p)) }, { self })
    }

    public func isEven() -> Bool {
        return catamorphism({ $0.catamorphism({ $0.isEven() }, { false }) }, { true })
    }

    public func _conversion() -> Int {
        return catamorphism({ 1 + $0._conversion() }, { 0 })
    }
}

extension Int {
    public init(_ p:Peano) {
        self = p._conversion()
    }
}

// Main

let r = (100 as Peano).mult(100 as Peano)

if r.isEven() {
    print(String(Int(r)) + " is even!")
}