Number.swift

//
//  Number.swift
//  
//  This allows the use of the Type Number in Generics
//  Allow operations between optional numbers.
//
//  Created by Ruben Paz
//

import Foundation

protocol Number {
    func +(lhs: Self, rhs: Self) -> Self
    func -(lhs: Self, rhs: Self) -> Self
    func *(lhs: Self, rhs: Self) -> Self
    func /(lhs: Self, rhs: Self) -> Self
    func %(lhs: Self, rhs: Self) -> Self
    init(_ v: Int)
    
}

extension Double : Number {}
extension Float  : Number {}
extension Int    : Number {}
extension Int8   : Number {}
extension Int16  : Number {}
extension Int32  : Number {}
extension Int64  : Number {}
extension UInt   : Number {}
extension UInt8  : Number {}
extension UInt16 : Number {}
extension UInt32 : Number {}
extension UInt64 : Number {}

func optionalOperation <T: Number>(n1:Optional<T>, n2:Optional<T>, operation: (T, T) -> T) -> Optional<T> {
    if n1 != nil && n2 != nil {
        return operation(n1!, n2!)
    }
    else {
        return nil
    }
}

func - <T: Number>(n1:Optional<T>, n2:Optional<T>) -> Optional<T> {
    return optionalOperation(n1, n2, {$0 - $1})
}

func + <T: Number>(n1:Optional<T>, n2:Optional<T>) -> Optional<T> {
    return optionalOperation(n1, n2, {$0 + $1})
}

func * <T: Number>(n1:Optional<T>, n2:Optional<T>) -> Optional<T> {
    return optionalOperation(n1, n2, {$0 * $1})
}

func / <T: Number>(n1:Optional<T>, n2:Optional<T>) -> Optional<T> {
    return optionalOperation(n1, n2, {$0 / $1})
}

func % <T: Number>(n1:Optional<T>, n2:Optional<T>) -> Optional<T> {
    return optionalOperation(n1, n2, {$0 % $1})
}