A Modest Introduction to Swift

A Modest Introduction

To SwiftOpenWest 201615 July 2016

John SJ Anderson@genehack

Intro to Swift › OpenWest 20160715

Sorry!

These are my obligatory two "Swift" jokes, wanted to get those out of the way...

Hi I'm John

• VP Tech, Infinity Interactive • Ex-biologist • Linux • Perl tribe • Polyglot coder

• Just this guy, you know?

Polyglotism

Disclaimer

Swift?

So, what is Swift?

Introduced in 2014

Went Open Source at version 2.2

Version 3 just released

Version 3 just released("technology preview")

this talk is specifically about 2.2

Originally MacOS only

Now on Linux too.

Android in the works!

Android in the works!DONE!!

Windows too?

https://swiftforwindows.codeplex.com/

Originally targeted MacOS, iOS,

watchOS, and tvOS

With expanded platform support, offers potential "single-language stack" advantages a la Node

So what's it like, man?

First, a brief digression…

How many MacOS / iOS users do we have here?

How many MacOS / iOS developers do we have?

The dirty little secret of developing for Apple

From In The Beginning Was The Command Line

by Neal Stephenson

During the late 1980's and early 1990's I spent a lot of time programming Macintoshes, and eventually decided for fork over several hundred dollars for an Apple product called the Macintosh Programmer's Workshop, or MPW. MPW had competitors, but it was unquestionably the premier software development system for the Mac. It was what Apple's own engineers used to write Macintosh code. Given that MacOS was far more technologically advanced, at the time, than its competition, and that Linux did not even exist yet, and given that this was the actual program used by Apple's world-class team of creative engineers, I had high expectations. It arrived on a stack of floppy disks about a foot high, and so there was plenty of time for my excitement to build during the endless installation process. The first time I launched MPW, I was probably expecting some kind of touch-feely multimedia showcase. Instead it was austere, almost to the point of being intimidating.

Weird Pascal-based naming and calling

conventions

HANDLES?!?

ObjectiveC's "syntax"

Swift is the Mac of Apple programming languages

Swift Syntax

Comments//thisisacomment

Comments/*thisisamulti-linecomment*/

Comments/*thisisa/*_nested_multi-linecomment,*/whichiscool!*/

Comments///doccomment

Variablesvarfoo=1varbar:Intvarbaz="whee!"

Variables

letbar=1bar+=1//^^compiletimeerror!

Variables

letbar=1bar+=1//^^compiletimeerror!

Variablesletbar

//alsoacompiletimeerror

/*YoucanNOThaveanuninitializedanduntypedvariable.Youalsocan'tuseaninitializedvariable_atall_*/

Variablesletbar

//alsoacompiletimeerror

/*YoucanNOThaveanuninitializedanduntypedvariable.Youalsocan'tuseaninitializedvariable_atall_*/

How friggin' awesome is that?

Operators

Flow Controlletn=1

ifn>1{print("wegotabigNhere")}

Flow Controlletn=1

Flow Controlletarr=[1,2,3,4]varsum=0

foreleminarr{sum+=elem}

//sumnowis10

Flow Controlforindexin1...10{#dosomething10times}

Flow Controlforindexin1..<10{#dosomething9times}

Flow ControlvarcountDown=5whilecountDown>0{countDown--}

Flow ControlvarcountUp=0repeat{countUp++}whilecountUp<5

Flow Controlletsample=2

switchsample{case0:print("Is0")

case2:print("Is2")

default://mandatorywhencasesnotexclusiveprint("Not0or2,isit.")}

case2:print("Is2")

No fallthru by default!

case2:print("Is2")

Flow Controlletsample="foo"

switchsample{case"foo":print("Isfoo")

case"bar":print("Isbar")

default://mandatorywhencasesnotexclusiveprint("Notfooorbar,isit.")}

Flow Controlletsample="foo"

switchsample{case"foo":print("Isfoo")

case"bar":print("Isbar")

default://mandatorywhencasesnotexclusiveprint("Notfooorbar,isit.")}

Flow Controlletsample=("foo",2)

switchsample{case("foo",2):print("Isfoo,2")

case("bar",_):print("Isbar")

default://mandatorywhencasesnotexclusiveprint("¯\_( )_/¯")}

switchsample{case("foo","bar"):print("Isfoo,bar")

case(letone,lettwo):print("Is\(one)and\(two)")

switchsample{case("foo","bar"):print("Isfoo,bar")

case(letone,lettwo):print("Is\(one)and\(two)")

StringsvarmyString="thisisastring"

ifmyString.isEmpty{//dosomething}

myString+="andthisisalongerstring"

Swift is very strongly typed.

Typingvarfoo=1//fooisanInt

varbar:Int//barisanuninit'dInt

varbaz=Int()

ifbazisInt{print("NiceIntyougotthere")}

varbaz=Int()

Castsvarfoo=1//fooisanInt

varbar=String(foo)//"1"

varmaybeBaz=stringishThingas?String//maybeBazisanoptionallytypedString

varforceBaz=stringishThingas!String

Optional Types//Whenavariablemaynothaveavaluevarbar:Int?

//testifbar!=nil{//hasavalue}

Optional Types//unwrapthevaluetouseifbar!=nil{bar!+=2}

//unwrappingnil-->runtimeexception!

if-letvarbar:Int?

ifletfoo=bar{//barhadavalue&//foonowhasthatunwrappedvalue}else{//barwasnil}

if-letvarbar:Int?

if-varvarbar:Int?

ifvarfoo=bar{//barhadavalue&//foonowhasthatunwrappedvalue&//fooismutablefoo++}else{//barwasnil}

if-varvarbar:Int?

Types of Values

Tupleslettuple=("foo",42)

letfirst=tuple.0//"foo"

letlabeledTuple=(one:"foo",two:42)

letsecond=labeledTuple.two//42

Arraysletnums=[1,2,3]

varstrs:[String]

//_can_mix&matchletmixed=[1,"foo"]

//butyouprobablyshouldn't

varstrs:[String]

DictionaryletcapitalCityStates=["Salem":"Oregon","SaltLakeCity":"Utah",]

//capitalCityStateshastype//[String:String]

DictionaryletcapitalCityStates=["Salem":"Oregon","SaltLakeCity":2,]

//capitalCityStateshastype//[String:NSObject]

SetsvarpetSet:Set=["cat","dog","fish","dog"]

petSet.count//returns3

Functions

FunctionsfuncobExample(){print("Hello,Salem!")}

//calllike:obExample()

FunctionsfuncobExample(who:String){print("Hello,\(who)!")}

//calllikeobExample("OpenWest")

FunctionsfuncobExample(who:String)->String{return"Hello,\(who)!"}

//calllikeletgreets=obExample("OpenWest")

//greets=="Hello,OpenWest"

FunctionsfuncobExample(who:String)->String{return"Hello,\(who)!"}

//calllikeletgreets=obExample("OpenWest")

//greets=="Hello,OpenWest"

FunctionsfuncobExample(who:String="Salem")->String{return"Hello,\(who)!"}

//calllikeletgreets=obExample("Oregon")//"Hello,Oregon!"

letgreets=obExample()//"Hello,Salem!"

FunctionsfuncobExample(what:String="Hello",who:String="Salem"){print"\(what),\(who)!"}

//calllikeobExample()//"Hello,Salem!"obExample("bye")//"bye,Salem!"obExample("bye",who:"Felicia")//"bye,felicia"obExample("bye","Salem")//COMPILEERRORobExample(what:"bye",who:"Salem")//COMPILEERRORobExample(who:"Salem",what:"bye")//COMPILEERROR

FunctionsfuncobExample(what:String="Hello",whothem:String="Salem"){print"\(what),\(them)!"}

//calllikeobExample("bye")//"bye,Salem!"obExample("bye",them:"Felicia")//"bye,Felicia!"

FunctionsfuncobExample(what:String="Hello",_who:String="Salem"){print"\(what),\(who)!"}

//calllikeobExample("bye")//"bye,Salem!"obExample("bye",who:"Felicia")//COMPILEERRORobExample("bye","Felicia")//"bye,Felicia!"

FunctionsfuncvariadiacExample(nums:Int...){//dosomethingwithnums//numsisArray[Int]}

Functions are first-class citizens

Closuresletnumbers=[2,1,56,32,120,13]

varsorted=numbers.sort({(n1:Int,n2:Int)->Boolinreturnn2>n1})

//sorted=[1,2,13,32,56,120]

This is already the func sig for sort!

//inferredparam&returntypesvarsorted=numbers.sort({n1,n2inreturnn2>n1})

//sorted=[1,2,13,32,56,120]

//inferredparam&returntypesvarsorted=numbers.sort({n1,n2inreturnn2>n1})

//sorted=[1,2,13,32,56,120]

//positionallynamedparametersvarsorted=numbers.sort({return$0>$1})

//sorted=[1,2,13,32,56,120]

//positionallynamedparametersvarsorted=numbers.sort({return$0>$1})

//sorted=[1,2,13,32,56,120]

//whenclosureislastparam,parensoptionalvarsorted=numbers.sort{$0>$1}

//sorted=[1,2,13,32,56,120]

//whenclosureislastparam,parensoptionalvarsorted=numbers.sort{$0>$1}

//sorted=[1,2,13,32,56,120]

OOP is also well supported

ClassesclassDog{

PropertiesclassDog{varname:Stringletnoise="WOOF!"}

just variable declarations inside the class

Class 'Dog' has no initializers

...because you're not allowed to have uninitialized properties.

PropertiesclassDog{varname:String?letnoise="WOOF!"}

you can fix that by making the property an optional type

PropertiesclassDog{varname:String?letnoise="WOOF!"}

you can fix that by making the property an optional type

InitializersclassDog{varname:Stringletnoise="WOOF"

init(name:String){self.name=name}}

or by providing an initializer that assigns a value to the property

DeinitializersclassDog{varname:Stringletnoise="WOOF"

init(name:String){self.name=name}

deinit(){//doanycleanuphere}}

DeinitializersclassDog{varname:Stringletnoise="WOOF"

deinit(){//doanycleanuphere}}

MethodsclassDog{varname:Stringletnoise="WOOF"

funcspeak()->String{returnself.noise}}

MethodsclassDog{varname:Stringletnoise="WOOF"

funcspeak()->String{returnself.noise}}

Using Objectsletsammy=Dog(name:"Sammy");

//sammyisDog

print(sammy.name)//prints"Sammy\n"

print(sammy.speak())//prints"WOOF!\n"

sammy.name="Buster"//worksb/cpropisvar

//sammyisDog

Computed PropertiesclassDog{varage:Int{get{returncurrentYear-self.birthYear}set{//thisishorrible,don'tdothisself.birthYear=currentYear-newValue}}}

Computed PropertiesclassDog{varage:Int{get{returncurrentYear-self.birthYear}set(age){//thisishorrible,don'tdothisself.birthYear=currentYear-age}}}

Computed PropertiesclassDog{varage:Int{willSet{//runsbeforepropertyvaluechanges}didSet{//runsafterpropertyvaluechanges}}}

Inheritance

InheritanceclassAnimal{

classDog:Animal{

InheritanceclassAnimal{

classDog:Animal{

InheritanceclassAnimal{letname:String

init(name:name){self.name=name}}

classDog:Animal{init(name:name){super.init(name:name)}}

InheritanceclassAnimal{letname:String

init(name:name){self.name=name}}

classDog:Animal{init(name:name){super.init(name:name)}}

OverridesclassAnimal{funcspeak(){...}}

classDog:Animal{overridefuncspeak(){...}}

OverridesclassAnimal{funcspeak(){...}}

classDog:Animal{overridefuncspeak(){...}}

Structs & Enumerations

StructsstructAnimal{varname:Stringvarnoise:String

init(name:String,makes:String){self.name=namenoise=makes}

funcspeak()->String{returnnoise}}

very much like classes -- support properties, initializers, methods, etc.

big difference: structs are pass-by-value; classes/objects are pass-by-reference

EnumerationsenumOpenSourceConfs{caseOpenWestcaseYAPC}

varconf=OpenSourceConfs.OpenWest//confistypeOpenSourceConfs

enums provide a constrained set of enumerated values

EnumerationsenumOpenSourceConfs:Int{caseOpenWest=1caseYAPC}

varconf=OpenSourceConfs.YAPC//confistypeOpenSourceConfs

conf.rawValue//2

EnumerationsenumOpenSourceConfs{caseOpenWestcaseYAPC

funcdescribe()->String{switchself{case.OpenWest:return"helloutah!"case.YAPCreturn"ithoughtperlwasdead"}}

varconf=OpenSourceConfs.OpenWestconf.describe()

EnumerationsenumOpenSourceConfs{caseOpenWestcaseYAPC(String)

funcdescribe()->String{switchself{case.OpenWest:return"helloutah!"case.YAPC(location)return"thisyearYAPCisin\(location)"}}

varyapc2016=OpenSourceConfs.YAPC("Orlando")yapc2016.describe()

varyapc2016=OpenSourceConfs.YAPC("Orlando")varyapc2015=OpenSourceConfs.YAPC("SaltLakeCity")

ProtocolsprotocolTalker{varnoise:String{get}functalk()->String}

ProtocolsprotocolTalker{varnoise:String{get}functalk()->Stringmutatingfuncmute()}

classDog:Talker{varnoise:Stringinit(noise:noise){self.noise=noise}functalk()->String{returnnoise}funcmute(){noise=""}}

ProtocolsprotocolTalker{...}

classDog:Talker{...}

classFish{...}

varsammy:Talker

sammy=Dog(noise:"WOOF!")

sammy=Fish()//compileerror

protocols can be used as types in variable declarations

classFish{...}

varsammy:Talker

classFish{...}

varsammy:Talker

classFish{...}

varsammy:Talker

ExtensionsextensionInt{funcsquared()->Int{returnself*self}}

letfoo=2

print(foo.squared())//4print(foo.squared().squared())//16

extensions can be used to extend built-in types to allow them to conform to protocols

letfoo=2

Exceptions & Error Handling

ExceptionsenumTalkErrors:ErrorType{caseTooShortcaseTooLongcaseTooBoring}

funcgiveATalk()throws->String{iftalk=="boring"{throwTalkErrors.TooBoring}return"talk!"}

Exceptionsdo{letthisTalk=trygiveATalk()print(thisTalk)}catch{print(error)}

Exceptionsdo{letthisTalk=trygiveATalk()print(thisTalk)}catchTalkErrors.TooLong{print("shutupalready")}catchlettalkErrorasTalkErrors{print("Talkerror:\(talkError).")}catch{print(error)}

Exceptions//silentlydiscardserrorletthisTalk=try?giveATalk()

//thisTalkisaString?

//thisTalkisString?

DeferfuncneedsMuchSetupAndTearDown()throws{//dothesetuphere,openfiles,etc.defer{//anddothecleanuphere,//rightnexttosetup}

//othercodehere.}

Workspaces

Ill-advisedlive

demotime!

Ill-advisedlive

demotime!

https://developer.apple.com/swift

This part is a lie.

THANKS!

questions?

A Modest Introduction to Swift

Internet

Transcript of A Modest Introduction to Swift