Swift Пользовательская переменная Тип

Question

Для работы с комплексными числами, это то, как я делал это:

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... 

Теперь мне было интересно, есть ли способ определить пользовательский тип переменной, которая позволит Я напишу его как someComplex: Complex = 3i, например. Можно ли создать новый тип «с нуля»?

Answer 1

Вы можете использовать typealias:

typealias Name = String 

Теперь вы можете использовать Name всякий раз, когда вы могли бы использовать String:

func sayHello(to name: Name) { 
    print("Hello " + name) 
} 

Answer 2

Я немного неопределенными, если это то, что вы ищете , но на основе вашего комментария к другому ответу

«Спасибо, но то, что я имел в виду что-то вроде пользовательского типа, который будет принимать все поплавки и я, например»,

вы можете создать оболочку, которая содержит один общий значение, когда общий тип этого значения Тип ограниченный к некоторому протоколу, к которому вы, в свою очередь, расширяете типы, которые вы хотите обертывать, но тип. Например, ниже, позволяя типы Int, Float и String быть обернуты оберткой

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> 

Вы можете естественно написать общие функции, позволяющие аргументы для SomeWrapper<T> экземпляров, тип сдерживающих T таким же образом, как и в определении структуры выше

func foo<T: MyGenericTypes>(bar: SomeWrapper<T>) ->() { 
    print(bar.value) 
} 

foo(wrappedInt) // 4.2 
foo(wrappedFloat) // 42 
foo(wrappedString) // forty-two