Swift-Keywords (typealias, associatedtype)

Typealiastypealias is used to redefine the name of a type that already exists, and by naming it, you can make the code clearer. The syntax used is also simple, as with the Typealias keyword, you can assign a new name to a type that already exists, as with a normal assignment statement. For example, when calculating the distance and position on the two-dimensional plane, we usually use double to denote the distance and use Cgpoint to represent the position:

[JavaScript]View PlainCopy

1. func distance (_ point: cgpoint, _  Anotherpoint: cgpoint)  -> double {  
2.     let  dx = double (anotherpoint.x - point.x)   
3.      let dy = double (ANOTHERPOINT.Y - POINT.Y)   
4.      return sqrt (dx * dx + dy * dy)   
5. }  
6.   
7. let origin  = cgpoint (x: 3, y: 0)   
8. let point = cgpoint (x:  4, y: 0)   
9.   
10. let d = distance ( Origin, point)   

Although there is no problem with the math and the final program running, there is always something wrong with reading and maintenance. Because we do not combine mathematical abstractions with practical problems, we also need to make an extra transition in the brain when reading code: Cgpoint represents a point, and this point is where we are in the defined coordinate system; A double is a number that represents the distance between two points. If we use Typealias, we can write this transformation directly in the code, thus reducing the burden of reading and maintenance:

[JavaScript]View PlainCopy

1. func distance (_ point: cgpoint, _  Anotherpoint: cgpoint)  -> double {  
2.     let  dx = distance (anotherpoint.x - point.x)   
3.      let dy = distance (ANOTHERPOINT.Y - POINT.Y)   
4.      return sqrt (dx * dx + dy * dy)   
5. }  
6.   
7. let origin  = location (x: 3, y: 0)   
8. let point = location (x:  4, y: 0)   
9.   
10. let d = distance ( Origin, point)   

The same code, with the help of Typealias, is much easier to read. There may not be a lot of experience with this simple example, but when you're faced with more complex practical problems, you can stop worrying and think about what's in your code, like the piles of int or string primitives, that represent something, so you can save a lot of brain cells. Note: During the development process, the use of Typealias is often used when compared to the use of the package

[JavaScript]View PlainCopy

1. Typealias Success = (_ data:string), Void
2. Typealias Failure = (_ error:string), Void
4. Func Request (_ Url:string, success:success, failure:failure) {
5. //Do request here ....
6. }

Typealias and generic typealias are single, meaning that you must specify that a particular type be assigned a new name by Typealias, and that the entire generic type cannot be renamed. The following names are not compiled:

[JavaScript]View PlainCopy

1. Class Person<t> {}
2. Typealias Woker = person
3. Typealias Worker = person<t>

But if we also introduce generics in aliases, we can do the corresponding [JavaScript]View PlainCopy

1. Class Person<t> {}
2. Typealias Woker = person
3. Typealias worker<t> = person<t>

When the certainty of a generic type is guaranteed, it is clear that aliases are also available:

[JavaScript]View PlainCopy

1. Class Person<t> {}
2. Typealias WorkID = String
3. Typealias Worker = person<workid>

Another usage scenario is when a type implements a combination of multiple protocols at the same time. We can use the & notation to connect several protocols, and then give them a new more contextual name to enhance the readability of the code:

[JavaScript]View PlainCopy

1. Protocol Cat {}
2. Protocol Dog {}
3. Typealias Pat = Cat & Dog

Associatedtype When an association type defines a protocol, it can sometimes be useful to declare one or more association types as part of the protocol definition. An association type provides a placeholder (or alias) for a type in the protocol, and the actual type it represents is not specified until the protocol is accepted. You can specify the association type by associatedtype the keyword. For example, the method of updating a cell with a protocol declaration:

[JavaScript]View PlainCopy

2. Model
4. struct Model {
6. Let Age:int
8. }
12. protocols, using association types
14. Protocol Tableviewcell {
16. Associatedtype T
18. Func Updatecell (_ Data:t)
20. }
24. Compliance with Tableviewcell
26. Class Mytableviewcell:uitableviewcell, Tableviewcell {
28. Typealias T = Model
30. Func Updatecell (_ Data:model) {
32. //do something ...
34. }
36. }

Swift-Keywords (typealias, associatedtype)