A Few Interesting Things in Apple's Swift Programming Language

A Few Interesting
Things In Swift
Ara Hacopian
B’more on Rails
6/10/2014

Ara Hacopian
http://www.smartlogic.io
http://www.twitter.com/ahacop
http://www.github.com/ahacop
SmartLogic

Some Cool Stuff
● Type Inference
● Explicit Mutability
● Optionals
● Named Parameters
● Enumerations
● Exhaustive Switch
● Closures
● Generics

Type Inference
You can do this:
var x : Int = 0
var y : String = “foobar”
var z : Bool = true
Or, you can just do this:
var x = 0
var y = “foobar”
var z = true

Type Inference
var x = 1
x = “quux” ← COMPILER ERROR

Typed Collections
var mammals: String[] = [“dog”, “cat”]
var people = [“dan”, “eric”, “tom”]
var numbers = [1, 2, 3]
numbers.append(“ara”) ←COMPILER ERROR

Explicit Mutability
var x = 0
x = 1
x // x == 1
let y = 0
y = 1 ← COMPILER ERROR

Never Be Nil
var x : Int = 0
x = nil ← COMPILER ERROR

Optionals
Optionals handle the absence of a value.
Either:
1. there is some value, and it equals x
var foo : Int? = 41 // { Some 41 }
1. or, there is no value at all
var bar : Int? // nil

Optional Declaration
var intOptional : Int?
var stringOptional : String?
var boolOptional : Bool?

Optionals: Unwrapping
You can unwrap the value contained in the
optional by using the bang operator, like so:
var foo : Int? = 41
foo! == 41 // true
But if it’s nil, you will get a runtime error,
so don’t do that.

Optional Binding
var possibleNumber = "2"
if let actualNumber =
possibleNumber.toInt() {
println("(possibleNumber) has an integer
value of (actualNumber)")
} else {
println("(possibleNumber) could not be
converted to an integer")
}

Optional Chaining
class Person {
var name : String
var address : Address?
init(name:String, atAddress address:Address?=nil) {
self.name = name
self.address = address
}
}
class Address {
func sendLetter() {
println("Sent a letter!")
}
}
let ara = Person(name: "Ara")
let paul = Person(name: "Paul", atAddress:Address())
let people = [ara, paul]
for person in people {
person.address?.sendLetter()
}

External Param Names
func join(
string s1: String,
toString s2: String,
withJoiner joiner: String) -> String {
return s1 + joiner + s2
}
join(string: "hello", toString: "world",
withJoiner: ", ")

Enumerations
enum Compass {
case North, South, West, East
}
enum Status {
case OnTime, Delayed(Int, String)
}

Exhaustive Switch
In Swift, the compiler enforces that a switch statement contains a case
for every possible value for that type.
enum Status {
case OnTime, Delayed(Int, String)
}
let trainStatus = Status.Delayed(5, “banana on tracks”)
switch trainStatus {
case .OnTime:
println(“Train is on time!”)
case .Delayed(let minutes, let reason):
println(“Train delay: (minutes) minute(s), Reason: (reason)”)

Closures
Just like blocks in ObjC...but there’s a lot of optional syntax.
let names = ["Paul", "Ara", "Eric", "Tom", "Dan"]
func backwards(s1: String, s2: String) -> Bool {
return s1 > s2
}
1. sort(names, backwards)
2. sort(names, { (s1: String, s2: String) -> Bool in return s1 > s2
})
3. sort(names, { s1, s2 in return s1 > s2 } )
4. sort(names, { s1, s2 in s1 > s2 } )
5. sort(names, { $0 > $1 } )
6. sort(names, >)

Generics
struct IntStack {
var items = Int[]()
mutating func push(item: Int) {
items.append(item)
}
mutating func pop() -> Int {
return items.removeLast()
}
}

Generics
struct Stack<T> {
var items = T[]()
mutating func push(item: T) {
items.append(item)
}
mutating func pop() -> T {
return items.removeLast()
}
}

Questions?
http://www.smartlogic.io/
http://www.twitter.com/ahacop
http://www.github.com/ahacop

A Few Interesting Things in Apple's Swift Programming Language

More Related Content

What's hot

Viewers also liked

Similar to A Few Interesting Things in Apple's Swift Programming Language

More from SmartLogic

Recently uploaded

A Few Interesting Things in Apple's Swift Programming Language

Editor's Notes