`typealias` is used to rename an existing type. By doing this, we can change our code and make it more readable, and clearer in context. The using of `typealias` is as simple as a normal assignment. A new name could be assigned to an old type with an equality sign. Take an example, when handling some concepts in a 2D plane, by default we may use `Double` as the type of distance, and `CGPoint` referring the position:

``````func distanceBetweenPoint(point: CGPoint, toPoint: CGPoint) -> Double {
let dx = Double(toPoint.x - point.x)
let dy = Double(toPoint.y - point.y)
return sqrt(dx * dx + dy * dy)
}

let origin: CGPoint = CGPoint(x: 0, y: 0)
let point: CGPoint = CGPoint(x: 1, y: 1)

let distance: Double =  distanceBetweenPoint(origin, point)
``````

It is fine in both mathematics and programming, but not so well in human understanding. The type of `Double` or `CGPoint` is only an abstract in mathematics. When reading this code, we have to convert them again in our brains: `CGPoint` represents a point, and it is a position in the coordinate system we defined, while `Double` is a number and means the distance between two positions.

So, why not use the words `Position` and `Distance` directly?

If we turn to use `typealias`, we can write down these conversions in the code. So it becomes easier for us to read and maintain it:

``````typealias Location = CGPoint
typealias Distance = Double

func distanceBetweenPoint(location: Location,
toLocation: Location) -> Distance {
let dx = Distance(location.x - toLocation.x)
let dy = Distance(location.y - toLocation.y)
return sqrt(dx * dx + dy * dy)
}

let origin: Location = Location(x: 0, y: 0)
let point: Location = Location(x: 1, y: 1)

let distance: Distance =  distanceBetweenPoint(origin, point)
``````

The two versions do the same thing, but with the help of `typealias`, we get some cleaner and more readable code.

There is nothing difficult for routine types. While it turns to generic, things get complicated soon. First of all, `typealias` is unique. You can only set a specified type to a `typealias`. Any attempt at setting a generic typealias will fail. For example, this code produces an error in compiling:

### This is wrong code

``````class Person<T> {}
typealias Worker = Person
typealias Worker = Person<T>
typealias Worker<T> = Person<T>
``````

Once the generic type is determined, we can use `typealias` to rename it:

``````class Person<T> {}

typealias WorkId = String
typealias Worker = Person<WorkId>
``````

Conceptually, there are no generic protocols in Swift. But by using typealias we can declare a required alias for another type. A good example is `GeneratorType` or `SequenceType` in Swift. In these two protocols, Swift defines a typealias for the users of this protocol to implement:

``````protocol GeneratorType {
typealias Element
mutating func next() -> Self.Element?
}

protocol SequenceType {
typealias Generator : GeneratorType
func generate() -> Self.Generator
}
``````

When we write a type conforming to this kind of protocol, except for implementing the methods, we have to specify a type for it. In fact, it is an abstract for a protocol.