Symmetry in using structures for conversion. What is best practice? - swift

Question

I've been playing with Swift and I encoded an obvious conversion structure:
struct MutableAngle {
var degrees : CGFloat
var radians : CGFloat {
return degrees * CGFloat(M_PI) / 180.0
}
init(inRadians : CGFloat) {
degrees = inRadians * 180.0 / CGFloat(M_PI)
}
init(inDegrees : CGFloat) {
degrees = inDegrees
}
}
Now this is fine but inelegant since it doesn't treat degrees and radians symmetrically although it does give mutability. This is really a structure which should be called Degrees and which can provide radians. For instance, I can write:
var angle : MutableAngle
angle.degrees = 45.0
but not
var angle : MutableAngle
angle.radians = 0.75
Here's a final version:
struct Angle {
let degrees : CGFloat
let radians : CGFloat
init(inRadians : CGFloat ) {
radians = inRadians
degrees = radians * CGFloat (180 / M_PI)
}
init(inDegrees : Float ) {
degrees = inDegrees
radians = degrees * CGFloat (M_PI / 180)
}
}
Use as follows:
var alpha = Angle(inDegrees: 45)
alpha.degrees // returns 45
alpha.radians // returns 0.7853982
// alpha.radians = 0.9 ... is now illegal with let constants
// must use constructor ... provided alpha was defined using 'var'
// i.e. the struct itself is mutable
alpha = Angle(inRadians: 0.9)
alpha.radians // returns 0.7853982
alpha.degrees // returns 45
Switching from var to let makes it mutable/immutable depending on how alpha is defined and I'm now obliged to use the constructors which is good. So its symmetric. It also has the merit that a calculation is not required every time I want to use the radians.

Answer 1

Two things here:
In Swift you don't need a separate mutable type for value types - that's handled by whoever is instantiating the type by using let or var.
Your radians computed property only has a getter - you can do what you want with both a setter and a getter.
My implementation:
struct Angle {
var degrees : CGFloat = 0
var radians : CGFloat {
get {
return degrees * CGFloat(M_PI) / 180.0
}
set {
degrees = newValue * 180.0 / CGFloat(M_PI)
}
}
init(inRadians : CGFloat) {
radians = inRadians
}
init(inDegrees : CGFloat) {
degrees = inDegrees
}
}
Useage:
// immutable
let angle = Angle(inDegrees: 180)
println(angle.radians)
// next line gives an error: can't assign to an immutable instance
angle.radians = angle.radians * 2
// mutable copy
var mutableAngle = angle
mutableAngle.degrees = 10
println(mutableAngle.radians)
// 0.1745...
mutableAngle.radians = CGFloat(M_PI)
println(mutableAngle.degrees)
// 180.0

Answer 2

A possible solution is to use enum with associated value:
enum MutableAngle {
case Radian(CGFloat)
case Degree(CGFloat)
init(radians:CGFloat) {
self = .Radian(radians)
}
init(degrees:CGFloat) {
self = .Degree(degrees)
}
var radians:CGFloat {
get {
switch self {
case .Radian(let val): return val
case .Degree(let val): return val * CGFloat(M_PI) / 180.0
}
}
set {
self = .Radian(newValue)
}
}
var degrees:CGFloat {
get {
switch self {
case .Degree(let val): return val
case .Radian(let val): return val * 180.0 / CGFloat(M_PI)
}
}
set {
self = .Degree(newValue)
}
}
}
var angle = MutableAngle(radians: 1)
angle.degrees // -> 57.2957795130823
angle.degrees = 180
angle.radians // -> 3.14159265358979