One can express complex data structures and tree structures this way. If you know a little bit about how a compiler work

I can define a function fight which take an argument of type Soldier where Soldier is some interface with a list of methods. fight can then accept objects of type Pikeman or type Knight as long as both of them have all the methods defined in the Soldier interface. Here is an example of part of such an implementation in Go:

One of the things I really loved about Objective-C when coming from a C background was categories. A category allows you to add any number of methods to an existing class without subclassing it, and this can be done in separate libraries.

Most people will go on about how programming concurrency is awesome in Go. But for me, structural typing had the biggest appeal. What most of you are familiar with is what is called nominal typing. This is how typing works in C/C , Java, and C#.

Here is the problem: An object-graph made up of model objects should not have dependencies to GUI code. You don’t want to link a graphics library to a library containing non-GUI code.

Read more about this in Apple’s documentation. Going from Objective-C to Swift, I was amazed at how many sneaky little bugs I could catch from this. And especially compared to C , I love how this simplified a lot of functions. No longer did I have to write a reams of defensive code checking for null pointers.

A linked list consists of nodes, where each node can point to another node. It also has a cell to store data. But this can also be a pointer to another list. Hence we can have lists of lists, and these lists can also be lists of lists.

What this gives Go is a form of duck typing very similar to dynamic languages, but checked at compile time. Go does not have implementation inheritance, but you can define structs with methods and you can define interfaces.

Parsing a string '4' to an integer 4 could fail. In Swift, the Int function will return a value of type Int?, which means it could be an integer or a null. The type Int can only be an integer. Types such as Int? and String? cannot be used directly since they could be null. They must be unwrapped in some way. That is what the if let statement in Swift does.

For a more detailed explanation of how to implement the visitor pattern more elegantly in Swift, you can look at this more detailed explanation. It would work equally well in Objective-C.

It is an elegant solution that a C developer would have to solve with, say, a visitor pattern. Categories are no longer unique to Objective-C. You also have this feature available in Swift. Because Swift has more normal syntax, it can be useful to show an example of a Swift class extension which is similar to categories:

This is similar to, for instance, Python or Ruby. They don’t care what exactly the type of the inputs are, as long as the objects respond to the method calls made on them. Go lets you do that but in a type-safe manner. If the interface type and struct type didn’t match up, you would get a compilation error. For example, if I didn’t implement the damage method for Pikeman, I would get the following error:

How is this useful? Imagine you are storing an object-graph to disk representing some intricate user interface and you want to recreate it. You could traverse this object-graph and call, say, a method createUI to create a corresponding UI object for that object.

if let firstNumber = Int('4'), let secondNumber = Int('42'), firstNumber < secondNumber