Swift Introduction

SWIFT INTRODUCTION
by Giuseppe Arici & Matteo Battaglio
@ Codemotion Milan, 29/11/2014, v 1.1-S

A SWIFT INTRODUCTION
TO THE NEW APPLE PROGRAMMING LANGUAGE

HELLO WORLD
▸ Giuseppe Arici & Matteo Battaglio
▸ iOS devs @ Tiltap / Superpartes
▸ #pragma mark co-founders
▸ Codemotion friends
▸  addicted

[This] Short Presentation @ SlideShare
http://slideshare.net/giuseppearici/swift-introduction
Long Presentation @ SlideShare
http://slideshare.net/giuseppearici/swift-programminglanguage
Sample Code @ GitHub
https://github.com/madbat/swift-fun-playgrounds

LANGUAGE FATHER
Chris Lattner

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 = "Codemotion"
// 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)

LET'S PLAY WITH SWIFT
▸ Swift in playground
▸ Swift distinctive features
!
LET'S SEE IT IN ACTION!

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.1 IN XCODE 6.1 ]
▸ Compiler attributes and Preprocessor
▸ Class Variables, Exceptions, KVO, KVC and Reflection6
HTTPS://GITHUB.COM/KSM/SWIFTINFLUX
6 Though it’s not documented in the Swift Standard Library — and is subject to change — Swift has a reflection API:
let mirror = reflect(instance) // see Reflectable Protocol

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

THANKS see you @ https://fb.com/groups/pragmamark
@giuseppearici / giuseppe.arici@pragmamark.org
@m4dbat / matteo.battaglio@pragmamark.org

Swift Introduction

More Related Content

What's hot

Viewers also liked

Similar to Swift Introduction

Recently uploaded

Swift Introduction