angle.swift

import UIKit

enum Angle {
    case Radians(Double)
    case Degrees(Double)
    
    var radians: Double {
        switch(self) {
        case let .Radians(scalar):
            return scalar
        case let .Degrees(scalar):
            return scalar / 180.0 * M_PI
        }
    }
    
    var degrees: Double {
        switch(self) {
        case let .Radians(scalar):
            return scalar * 180.0 / M_PI
        case let .Degrees(scalar):
            return scalar
        }
    }
}

sizeof(Angle)
sizeof(Double)

Angle.Radians(M_PI_2).degrees * 2

struct Circle {
    let radius: Double
    var circumference: Double {
        return 2 * M_PI * radius
    }
    func arcLength(theta: Angle) -> Double {
        return circumference * theta.radians / M_PI
    }
}

let circle = Circle(radius: 1)
let angle = Angle.Radians(M_PI_4)
circle.arcLength(angle)
circle.arcLength(.Degrees(45))

struct _Angle {
    let radians: Double
    var degrees: Double {
        return radians * 180.0 / M_PI
    }
    init(radians: Double) {
        self.radians = radians
    }
    init(degrees: Double) {
        radians = degrees / 180.0 * M_PI
    }
}

_Angle(radians: M_PI_4).degrees

sizeof(_Angle)
sizeof(Double)

func sin(angle: _Angle) -> Double {
    return sin(angle.radians)
}

sin(_Angle(degrees: 90))

// oh no I used to write ruby :(

postfix operator ° {}
postfix func °(degrees: Double) -> _Angle {
    return _Angle(degrees: degrees)
}

sin(90°)
sin(M_PI_4)

45°.radians