#typealias

original source : https://www.programiz.com/swift-programming/typealias

A type alias allows you to provide a new name for an existing data type into your program. After a type alias is declared, the aliased name can be used instead of the existing type throughout the program.

Type alias do not create new types. They simply provide a new name to an existing type.

The main purpose of typealias is to make our code more readable, and clearer in context for human understanding.

How to create a typealias?

It is declared using the keyword typealias as:

typealias name = existing type

In Swift, you can use typealias for most types. They can be either:

Built-in types (for.eg: String, Int)

User-defined types (for.e.g: class, struct, enum)

Complex types (for e.g: closures)

Typealias for built-in types

You can use typealias for all built in data Types as String, Int, Float etc.

For example:

typealias StudentName = String

The above declaration allows StudentName to be used everywhere instead of String. So, if you want to create a constant of type string but represents more like student name. You can do as:

let name:StudentName = "Jack"

Without using typealias, you should declare constant of type string as:

let name:String = "Jack"

Above both examples creates a constant of type String. But declaring with typealias, our code becomes more readable.

Typealias for user defined types

There are many cases when you need to create your own data type. Suppose you want to create a Type that represents Student, you can create it using a class as:

class Student {

}

Now a group of students can be represented as an array as:

var students:Array<Student> = []

The above declaration can be made more readable by creating your own type for Array<Student> using typealias as:

typealias Students = Array<Student>

Now we can make our code more readable as:

var students:Students = []

Typealias for complex types

Lets analyze one more example. Suppose we have a method that takes a closure as an input parameter.

Don't worry if you do not know about closures. Just think of it as a special type of function. We have explained it detail in the article: Swift closures.

func someMethod(oncomp:(Int)->(String)){

}

The above example takes a closure as an input to someMethod. The closure takes an Int value and returns String.

You can see the use of (Int)->(String) makes less sense to the reader. You can use typealias to provide a new name for it:

typealias CompletionHandler = (Int)->(String)

Now you can rewrite the method as:

func someMethod(oncomp:CompletionHandler){

}

original source : https://schani.wordpress.com/2014/06/03/playing-with-swift/

이 예시에서 associatedtype을 위해 protocol 정의부분 안에서 사용되고 있는 typealias 는 deprecated 되었음을 인지할것

Playing with Swift

I really like what we’ve seen so far of Swift, Apple’s new programming language. For starters, I was happy to learn that references cannot be nil[1], and integer arithmetic is checked by default[2].

Let’s look at how Swift deals with sequences, and learn a little bit about generics on the way. Arrays, for example, are sequences, so you can iterate over them with a for loop:

for x in [1,2,3] {    println(x) }

Lots of other types are sequences, too, like strings, dictionaries and ranges. What makes them sequences is that they all implement the Sequence protocol:

protocol Sequence {    typealias GeneratorType : Generator    func generate() -> GeneratorType }

I’m not sure why Swift elects to do generic protocols via typealias instead of just having the protocol take type arguments, like C# does, which might look something like this:

protocol Sequence<T> {    func generate() -> Generator<T> }

Whatever the reason might be, we can see that a sequence can generate a Generator, which is defined as follows:

protocol Generator {    typealias Element    func next() -> Element? }

Generators have a next method which returns either the next element in the sequence, or nil, when the end has been reached. The for loop from above is probably mostly equivalent to

var gen = [1,2,3].generate() while let x = gen.next() {    println(x) }

The equivalent of Sequence and Generator in C# are IEnumerable and IEnumerator.

The map function takes a sequence and a function, returning a new sequence containing the results of applying the function to the elements of the given sequence. For example:

for x in map([1,2,3], {i in i*2}) {    println(x) }

produces

2 4 6

It’s important to realize that the sequence which map returns is not necessarily of the same type as the one it is passed:

println([1,2,3]) println(map([1,2,3], {i in i*2}))

prints

[1, 2, 3] VSs17MapCollectionView (has 2 children)

Also, sequences can generate their elements lazily:

var seq = map([1,2,3], { (i: Int) -> Int in    println("processing " + String(i))    return i*2    }) var gen = seq.generate() println(gen.next())

prints

processing 1 2

Let’s write a function that takes a sequence and returns an array containing all the sequence’s elements!

First we need to figure out the type of this function. It turns out that this doesn’t work:

func toArray (seq: Sequence) -> seq.GeneratorType.Element[]

The compiler complains that seq is an undeclared type. This doesn’t work, either:

func toArray (seq: Sequence) -> Sequence.GeneratorType.Element[]

Here the complaint is that Sequence.GeneratorType is ambiguous. That’s because we can’t tell the compiler that the two Sequence types are the same. Maybe we can use generics to solve the problem:

func toArray<S:Sequence> (seq: S) -> S.GeneratorType.Element[] {    var arr = S.GeneratorType.Element[]()    ...    return arr }

Swift is now happy with the type of the function, but unfortunately it doesn’t let us instantiate the array. Instead it thinks we’re trying to subscribe S.GeneratorType.Element, which isn’t possible, because it’s a type and not a value. As far as I can tell, the only way to get around this problem is to introduce a second generic argument, which we can force to the correct type via a where clause:

func toArray<S : Sequence,             T where T == S.GeneratorType.Element>        (seq : S) -> T[] {    var arr = T[]()    for x in seq {        arr.append(x)    }    return arr } println(toArray(map([1,2,3], {x in x*2})))

And there we have it:

original source: https://www.programiz.com/swift-programming/typealias

A type alias allows you to provide a new name for an existing type into your program. After a type alias is declared, the aliased name can be used instead of the existing type throughout the program.

Type alias do not create new types. They simply provide a new name to an existing type.

The main purpose of typealias is to make our code more readable, and clearer in context for human understanding.

How to create a typealias?

It is declared using the keyword typealias as:

typealias name = existing type

In Swift, you can use typealias for most types. They can be either:

Built-in types (for.eg: String, Int)

User-defined types (for.e.g: class, struct, enum)

Complex types (for e.g: closures)

Typealias for built-in types

You can use typealias for all built in data Types as String, Int, Float etc.

For example:

typealias StudentName = String

The above declaration allows StudentName to be used everywhere instead of String. So, if you want to create a constant of type string but represents more like student name. You can do as:

let name:StudentName = "Jack"

Without using typealias, you should declare constant of type string as:

let name:String = "Jack"

Above both examples creates a constant of type String. But declaring with typealias, our code becomes more readable.

Typealias for user defined types

There are many cases when you need to create your own data type. Suppose you want to create a Type that represents Student, you can create it using a class as:

class Student { }

Now a group of students can be represented as an array as:

var students:Array<Student> = []

The above declaration can be made more readable by creating your own type for Array<Student> using typealias as:

typealias Students = Array<Student>

Now we can make our code more readable as:

var students:Students = []

Typealias for complex types

Lets analyze one more example. Suppose we have a method that takes a closure as an input parameter.

Don't worry if you do not know about closures. Just think of it as a special type of function. We have explained it detail in the article: Swift closures.

func someMethod(oncomp:(Int)->(String)){ }

The above example takes a closure as an input to someMethod. The closure takes an Intvalue and returns String.

You can see the use of (Int)->(String) makes less sense to the reader. You can use typealias to provide a new name for it:

typealias CompletionHandler = (Int)->(String)

Now you can rewrite the method as:

func someMethod(oncomp:CompletionHandler){ }