Introduction to Swift

IOS BOOTCAMP
7° EDITION
#pragma mark
@ WCAP Catania
06/06/2015, v 1.2-S

THANKS TO
Youthub Catania
Motorsquare

#PRAGMA MARK
Started by a group of friends in 2012
Aim: create a community of iOS developers
Non-profit org since Sept. 2013

#PRAGMA MARK
In 3 years:
Organized a dozen events in northern Italy
all over Italy! !
Created an active on-line community:
fb.com/groups/pragmamark
2 editions of the #Pragma Conference

#PRAGMA MARK
Next edition: Florence, 9-10 Oct 2015
www.pragmaconference.com

JUST FOR TODAY'S ATTENDEES
15% DISCOUNT CODE:
! PragmaLovesCatania "
(limited to 30 tickets, so be quick!)

LET'S GET THE
BOOTCAMP STARTED!

HELLO WORLD
▸ Matteo Battaglio
▸ iOS dev @ Codermine
▸ #pragma mark co-founder

SLIDES
http://bit.ly/swift-introduction

LANGUAGE BIRTH
I started work on the Swift Programming Language in July
of 2010. I implemented much of the basic language
structure, with only a few people knowing of its
existence. A few other (amazing) people started
contributing in earnest late in 2011, and it became a
major focus for the Apple Developer Tools group in July
2013.
— Chris Lattner

LANGUAGE INSPIRATION
The Swift Programming Language greatly benefited from
the experiences hard-won by many other languages in the
field, drawing ideas from Objective-C, Rust, Haskell, Ruby,
Python, C#, CLU, and far too many others to list.
— Chris Lattner

SWIFT PROGRAMMING LANGUAGE
imperative, functional, object oriented, multi-paradigm,
static, strong typed, type safe, inferred,
general purpose, compiled, fast,
modern, elegant, clean,
funny, happy,
❤

Immutable & Mutable
Functions & Closures
Tuples & Pattern Matching
Data Types & Instances
Protocols & Extensions
Generics & Optionals

CONSTANTS & VARIABLES
TYPE ANNOTATIONS & TYPE INFERENCE
let constant: Int = 1 // Type Annotations
let constant = 1 // Type Inference (as Int)
let constant = 1 // readonly, cannot be re-assigned
constant = 2 // ❌ ERROR !!!
var variable = 1 // readwrite, can be re-assigned
variable = 2 // OK
By convention you should prefer to use 'let' over 'var'

CONSTANTS & VARIABLES
UNICODE CHARACTERS IN CONSTANT & VARIABLE NAMES
let !!!! = 4
var """"" = 5
! KILLER APPLICATION "

VALUE & REFERENCE TYPES
ENUMERATIONS & STRUCTURES VS CLASSES
▸ Enumerations & Structures are passed by Value
▸ Classes are passed by Reference
ENUMERATIONS & STRUCTURES ARE ALWAYS COPIED WHEN THEY ARE PASSED
AROUND IN THE CODE, AND DO NOT USE REFERENCE COUNTING.

STRUCTURES
MANY SWIFT LIBRARY'S BASE TYPES ARE STRUCTURES
// String
let string = "Swift"
// Character
let character: Character = "c"
// Array
let array = ["A", "B"]
// Dictionary
let dictionary = ["First" : 1, "Second" : 2]

STRUCTURES
CONSTANT & VARIABLE ARRAYS
let constantArray = ["A"]
var variableArray = ["A"]
constantArray = ["X"] // ❌ ERROR !!!
constantArray[0] = "Y" // ❌ ERROR !!!
constantArray.append("B"); // ❌ ERROR !!!
constantArray.removeAtIndex(0) // ❌ ERROR !!!
variableArray = ["X"] // ["X"]
variableArray[0] = "A" // ["A"]
variableArray.append("B"); // ["A", "B"]
variableArray.removeAtIndex(0) // ["B"]

FUNCTIONS
FIRST-CLASS FUNCTION
▸ assign a function to variable
▸ pass function as argument to another function
▸ return a function from a function
▸ functional programming patterns: map, filter, ...

FUNCTIONS
DECLARATION & CALL
// declaration
func foo(parameter1: Type1, parameter1: Type2) -> ReturnType {
/* function body */
}
// call
foo(argument1, argument2)
// external and local parameter names
func bar(externalParameterName localParameterName: Type) {
/* body use localParameterName */
}
// call must use externalParameterName label
bar(externalParameterName: argument)

CLOSURES
MEANING & SYNTAX
// Closures are blocks of functionality that can be passed around
{ (parameter1: Type1, parameter2: Type2) -> ReturnType in
/ * ... */
}
// Closures can capture and store references to any constants and
// variables from the context in which they are defined.

FUNCTIONS VS CLOSURES
▸ Global functions:
NAMED CLOSURES / DO NOT CAPTURE ANY VALUES
▸ Nested functions:
NAMED CLOSURES / CAPTURE VALUES FROM ENCLOSING FUNCTION
▸ Closure expressions:
UNNAMED CLOSURES / CAPTURE VALUES FROM THEIR CONTEXT

SORTING WITHOUT CLOSURES
// define a function which takes an array and a sorting algorithm
func sorted(array: [Int], algorithm: (Int, Int) -> Bool) -> [Int] {
/* apply the sorting algorithm to the array */
}
// define an array
let array = [1, 2, 3]
// define a sorting algorithm funtion
func backwards(i1: Int, i2: Int) {
return i1 > i2
}
// call sorted
var reversed = sorted(array, backwards)

SORTING WITH CLOSURES 1/2
// Fully declared closure
reversed = sorted(array, { (i1: Int, i2: Int) -> Bool in return i1 > i2 } )
// Infer closure type
reversed = sorted(array, { (i1, i2) in return i1 > i2 } )
// Implicit returns
reversed = sorted(array, { (i1, i2) in i1 > i2 } )

SORTING WITH CLOSURES 2/2
// Shorthand argument names
reversed = sorted(array, { $0 > $1 } )
// Trailing closure: outside of () only if it's function’s final argument
reversed = sorted(array) { $0 > $1 }
// Operator functions
reversed = sorted(array, >)

TUPLES
LIGHTWEIGHT CONTAINERS FOR MULTIPLE VALUES
let complex = (1.0, -2.0) // Compound Type: (Double, Double)
let (real, imag) = complex // Decompose
let (real, _) = complex // Underscores ignore value
// Access by index
let real = complex.0
let imag = complex.1
// Name elements
let complex = (real: 1.0, imag: -2.0)
let real = complex.real

PATTERN MATCHING
let point = (42, 42)
switch point { // break by default
case (0, 0):
println("match a specific tuple")
case (_, 0):
println("ignore undescore value")
case (let x, 1):
println("bind a value to x")
case let (x, y) where x == y:
println("bind values which satify the where clause")
default:
println("must be exhaustive")
}

ENUMERATIONS, STRUCTURES & CLASSES
COMMON CAPABILITIES
▸ Stored & Computed Properties
▸ Methods, Subscripts & Initializers
▸ Protocols & Extensions
▸ Access Control

ENUMERATIONS, STRUCTURES & CLASSES
public class Vehicle {
// stored instance property
private let name: String
// computed instance property
public var formattedName: String { return "vehicle: (name)" }
// type property
class var maxSpeed : Int { return 299_792_458 }
// initializer
init (name: String) { self.name = name }
// instance method
internal func move() { /* ... */ }
}

CLASSES Only
ADDITIONAL CAPABILITIES:
▸ Inheritance
▸ Type casting
▸ Deinitializers
▸ Reference counting

CLASSES Only
public class Car: Vehicle { // inheritance
// override
public override var formattedName: String { return "car: (name)" }
// designated initializer
override init(name: String) { super.init(name: name);}
// convenience initializer
convenience init() { self.init(name: "Car") }
// deinitializer
deinit { /* clean up */ }
}
let vehicle = Car(name: "Supercar")
let car = vehicle as Car // Type Casting

PROTOCOLS
// Available for Enumerations, Structures & Classes
protocol SomeProtocol { // define a set of requirements
var instanceProperty: Type { get set } // require instance properties
class var typeProperty: Type { get set } // require type properties
func someMethod() // require instance methods
class func someTypeMethod() // require type methods
init() // require initializers
}

EXTENSIONS
// Available for Enumerations, Structures & Classes
extension SomeType: SomeProtocol { // add protocol conformance
var stored = 1 // ❌ ERROR !!! // CANNOT add store properties !
var computed: String { /* ... */ } // add computed properties
func method() { /* ... */ } // add methods
subscript(i: Int) -> String { /* ... */ } // add subscripts
init(parameter: Type) { /* ... */ } // add initializers
enum SomeEnum { /* ... */ } // add nested types
}

EXTENSIONS
EXTENSIONS CAN EXTEND ALSO SWIFT LIBRARY TYPES
extension Int {
func times(task: () -> ()) {
for i in 0 ..< self {
task()
}
}
}
3.times({ println("Developer! ") })
// Developer! Developer! Developer! !

GENERICS
// Specific Functions
func swapTwoStrings(inout a: String, inout b: String) {
let temporaryA = a; a = b; b = temporaryA
}
func swapTwoDoubles(inout a: Double, inout b: Double) {
}
// Generic Function
func swapTwoValues<T>(inout a: T, inout b: T) {
}
var someInt = 1, anotherInt = 2
swapTwoValues(&someInt, &anotherInt) // T == Int
// someInt == 2, anotherInt == 1

GENERICS
WHERE CLAUSES ON TYPE CONSTRAINTS
protocol Container { typealias ItemType /* ... */ }
func allItemsMatch<
C1: Container, C2: Container
where C1.ItemType == C2.ItemType, C1.ItemType: Equatable>
(container1: C1, container2: C2) -> Bool {
if container1.count != container2.count { return false }
for i in 0..<container1.count {
if container1[i] != container2[i] {
return false
}
}
return true // all items match
}
}

OPTIONALS
AN OPTIONAL VALUE EITHER CONTAINS A VALUE OR NIL
var optionalInt: Int? = 42
optionalInt = nil // to indicate that the value is missing
var optionalDouble: Double? // automatically sets to nil
// Check if nil
optionalDouble == nil
optionalDouble != nil

OPTIONALS
// Force unwrap
let optionalInt: Int? = 42
let definitelyInt = optionalInt! // throws runtime error if nil
// Optional binding
if let definitelyInt = optionalInt {
// runs if optionalInt is not nil and sets definitelyInt: Int
}
// Implicitly Unwrapped Optionals
var assumedInt: Int! // set to nil
assumedInt = 42
var implicitInt: Int = assumedInt // do not need an exclamation mark
assumedInt = nil
implicitInt = assumedInt // ❌ RUNTIME ERROR !!!

OPTIONALS
class Car {
var model: String
init(model: String) { self.model = model }
func jump() -> String? {
if model == "Supercar" { return "!⚡" }
else { return nil } }
}
// Return type of chaining is always optional
var car1: Car? = nil; car1?.model // nil: String?
var car2: Car? = Car(model: "Supercar"); car2?.model // "Supercar": String?
// Chain on optional return value
car1?.jump()?.hasPrefix("!") // type Bool?

OPTIONALS
A GENERIC ENUMERATION WITH ASSOCIATED VALUE
enum Optional<T> : Reflectable, NilLiteralConvertible {
case None
case Some(T)
/* ... */
}
var maybeInt1: Int? = nil
var maybeInt2: Optional<Int> = .None
maybeInt1 = 42
maybeInt2 = .Some(42)

SWIFT VS ... ?
▸ Swift vs Scala
▸ Swift vs Rust
▸ Swift vs C#
Swift is Objective-C without the C

OPEN SOURCE SWIFT ?
Guys, feel free to make up your own dragons if you want,
but your speculation is just that: speculation. We literally
have not even discussed this yet, because we have a ton
of work to do [...] You can imagine that many of us want it
to be open source and part of llvm, but the discussion
hasn't happened yet, and won't for some time.
— Chris Lattner @ llvmdev

WHAT SWIFT IS MISSING?
[ SWIFT 1.2 IN XCODE 6.3 ]
▸ Compiler attributes and Preprocessor
▸ Exceptions, KVO, KVC and proper Reflection
HTTPS://GITHUB.COM/KSM/SWIFTINFLUX

SWIFT IN PRODUCTION?
▸ Companies are doing it
▸ Freelances are doing it
▸ Many of us are doing it
▸ But be careful if you do it!
A few apps that were built using Swift @ apple.com

WWDC
next week (8-12 June)
Great expectations for Swift...

THANKSYou can find me on the Internet!
twitter ! @m4dbat
github ! madbat
" matteo.battaglio@pragmamark.org

Introduction to Swift

Related slideshows

More Related Content

What's hot

What's hot (20)

Viewers also liked

Viewers also liked (13)

Similar to Introduction to Swift

Similar to Introduction to Swift (20)

Recently uploaded

Recently uploaded (20)

Introduction to Swift