Swift Custom Variable Type - swift

Question

For working with complex numbers, this is how I've been doing it:
import Foundation
class Complex {
var real: Float
var imaginary: Float
init(re: Float, im: Float) {
self.imaginary = im
self.real = re
}
func abs() -> Float {
return sqrtf(powf(self.real, 2) + powf(self.imaginary, 2))
}
func string() -> String {
if (ceilf(self.real) == self.real) && (ceilf(self.imaginary) == self.imaginary){
return "\(Int(self.real))+\(Int(self.imaginary))i"
}
return "\(self.real)+\(self.imaginary)i"
}
func arg() -> Float {
return atan2f(self.imaginary, self.real)
}
}
var someComplex = Complex(re: 2, im: 3)
var someComplexString = someComplex.string() //"2+3i"
var someComplexAbsolute = someComplex.abs() // 3.60...
var someComplexArgument = someComplex.arg() //0.98...
Now I was wondering, if there was any way to define a custom type of variable that would let me write it as someComplex: Complex = 3i for example. Is it possible to create a new type "from the ground up"?

Answer 1

I'm slightly uncertain if this is what you're looking for, but based on your comment to the other answer
"Thanks, but what I meant was something like a custom type that would accept all floats and i for example",
you could create a wrapper that holds a single generic value, where the generic type of this value is type constrained to some protocol, to which you in turn extend the types you wish to be wrappable but the type. E.g., below allowing types Int, Float and String to be wrapped by the wrapper
protocol MyGenericTypes { }
extension Int: MyGenericTypes { }
extension Float: MyGenericTypes { }
extension String: MyGenericTypes { }
struct SomeWrapper<T: MyGenericTypes> {
var value: T
init(_ value: T) {
self.value = value
}
}
let myInt = 42
let myFloat: Float = 4.2
let myString = "forty-two"
let wrappedInt = SomeWrapper(myInt) // T inferred as "Int"
let wrappedFloat = SomeWrapper(myFloat) // T inferred as "Float"
let wrappedString = SomeWrapper(myString) // T ingerred as "String"
print(wrappedInt.dynamicType) // SomeWrapper<Int>
print(wrappedFloat.dynamicType) // SomeWrapper<Float>
print(wrappedString.dynamicType) // SomeWrapper<String>
You can naturally write generic functions allowing arguments for SomeWrapper<T> instances, type constraining T in the same fashion as in the struct definition above
func foo<T: MyGenericTypes>(bar: SomeWrapper<T>) -> () {
print(bar.value)
}
foo(wrappedInt) // 4.2
foo(wrappedFloat) // 42
foo(wrappedString) // forty-two