Denis Lebedev. Non functional swift.

Non-functional Swift

Denis Lebedev, 2014 1

Swift 101

» proprietary (Apple)


Swift 101


» LLVM-backed


Swift 101


» LLVM-backed

» multi-paradigm


Swift 101


» LLVM-backed

» multi-paradigm

» statically typed and mostly typesafe


“It's like Objective-C, but without C”Apple WWDC


“Swift is all about FP - it has map and filter”someone in the Internet


This talk is not about

» Cocoa & iOS

» filter / map

» ADT-based JSON parsers


It's about

» Standard library

» Simple yet powerful language concepts1

» Open source as a showcase of Swift possibilites

1 borrowed from other languages


Types classification

» Protocol: trait, type class




» Enum: sum type




» Enum: sum type

» Struct: product type




» Enum: sum type

» Struct: product type

» Class: close to struct, has inheritance



» Protocol: -

» Enum: value-type

» Struct: value-type

» Class: reference-type2

2 Swift has no GC and uses reference counting, developer is responsible for maintaining reference cycles


Standard library

» 1 class, ~160 structs & protocols

» no explicit root class


Standard library : Bool

» is a struct

» implements protocols to inherit behavior


Standard library

» Int, Bool, Array, ... are structs

» only Array and Dictionary for collections


Standard library

» heavily based on value types

» ascetic but extendable

» generic


Enum

» C-enum 'on steroids'

» good for pattern-matching


Enum

enum Types { case Str(String) case Num(Double)}

let a = Types.Num(1.0)


Pattern matching

» works with enum

switch a {case .Str(let val): println(val)case .Num(let val): println(val) // 1.0}


Pattern matching

» can match any type

switch str {case let x where x.hasPrefix("a"): println(str)default: println("did not match")}


Enum : limitations

enum Result<T, U> { case Success(T) case Error(U)}

// error: unimplemented IR generation // feature non-fixed multi-payload enum layout


Mutability

» let for immutable instances

» var as indicator of mutability

let i = 0; i++ // compilation errorlet a = [1, 2]; a.append(3) // compilation error


Mutability of structs

» mark methods changing inner state as mutating

» var if struct was mutated


Optional

» monad in Swift stdlib

» enum-based

» deeply-linked in the language


Optional

enum Optional<T> { case None case Some(T)

...

func map<U>(f: (T) -> U) -> U?}


Optional

var foo: Optional<Int> = .Some(3)

switch foo {case .Some(let f): println(f)case .None: break}


Optional : syntactic sygar

var foo: Int? = 3

if let f = foo { println(f) }


Optional : chaining

var amount: Amount

if let c = customer { if let a = account { amount = a.amount }}


Optional : chaining with syntactic sugar

let amount = customer?.account?.amount // Optional(Amount)


Optional : force unwrapping

let amount = customer!.account!.amount // Amount


Optional : force unwrapping

let amount = customer!.account!.amount // Amount

unsafeand may crashDenis Lebedev, 2014 34

Optional

» Plays nicely with Objective-C nil messaging

» '!' operator may cause runtime crashes

» '!' should be avoided in pure Swift


Type extensions

» Extend existing type


Type extensions

» Extend existing type

extension String { func isBar() -> Bool { return self == "bar" }}

"foo".isBar() // false


Type extensions

» Can implement protocols

class B { var a: Int = 0}

extension B: Printable { var description: String { return "\(a)" }}


Protocols

Task: implement generic stack

protocol Stackable { mutating func pop() -> Int? mutating func push(Int)}


Protocols : associated types

protocol Stackable { typealias Element

mutating func pop() -> Element? mutating func push(Element)}



struct Stack<T> { var storage: [T] = []}



extension Stack: Stackable { typealias Element = T

mutating func pop() -> Element? { return storage.count > 0 ? storage.removeLast() : nil }

mutating func push(e: Element) { storage.append(e) }}


Protocols : constraints

Task: overload push to take an array

mutating func push(s: [T]) { storage.extend(s) }


Protocols : constraints

Task: overload push to take any sequence

mutating func push <S: SequenceType where S.Generator.Element == T>(s: S) {

storage.extend(s) }


Protocols : recap

» powerfull abstraction instrument

» neat way of extending existing functionality


Lazy evaluation

» call-by-value model


Lazy evaluation


» lazy keyword is 'fake lazy' for lazy instantiation

class A { lazy var b = [1,2,3,4]}


Lazy evaluation


» lazy keyword is 'fake lazy' for lazy instantiation

» autoclosure arguments for real laziness


autoclosure

Task: implement || operator

func OR(lhs: Bool, rhs: Bool) -> Bool { if lhs { return true } return rhs}

let c = 0let b = OR(c == 0, 1/c == 1) // error: division by zero


autoclosure

Task: implement short-circuit || operator

func OR(lhs: @autoclosure () -> Bool, rhs: @autoclosure () -> Bool) -> Bool { if lhs() { return true } return rhs()}

let c = 0let b = OR(c == 0, 1/c == 1) // true


Functions & closures

» first-class sitizens

» function - special case of closure

» closure has memory-management rules


Currying

» functions can be written in curried form

» no standard functions for currying


Currying

func sum(a: Int)(b: Int) -> Int { return a + b}

let a = sum(3)(5) //error: missing argument label

let a = sum(3)(b: 5)


Currying & classes

class A { func f(i: Int) -> Int { return i } class func g(i: Int) -> Int { return i }}

let a_f = A.f // A -> Int -> Intlet g = A.g // Int -> Intlet f = A().f // Int -> Int


Open source

» swiftz - purely functional data structures, functions, etc.

» Concurrent - functional concurrency primitives

» ReactiveCocoa - functional reactive programming

» ExtSwift - collection extensions


https://github.com/typelift/swiftz

https://github.com/typelift/Concurrent

https://github.com/ReactiveCocoa/ReactiveCocoa

https://github.com/pNre/ExSwift

Tools : Compiler

» Compiler is unstable, affects Xcode IDE stability

» Sometimes compiler errors are non-informative


Tools : Compiler

» Swift compiler crashes - set of crash tests for the compiler


https://github.com/practicalswift/swift-compiler-crashes

Tools : Compiler

» Swift compiler crashes - set of crash tests for the compiler

Results: 1874 of 2024 tests crashed the compiler


https://github.com/practicalswift/swift-compiler-crashes

Tools : Playgrounds

» Interactive scratchpad (a-la Scala's worksheet, iPython notebook)

» Embed documentation generated from markdown

» Render charts and 3D


https://github.com/jas/playground

Interactive playground with doc


Rendering SceneKit objects


Conclusion on Swift

» Filled with functional concepts

» Someday will become mainstream in Cocoa world

» Language and tools are immature, it's like v0.9 but called 1.1


Thanks!Denis Lebedev, 2014 63

Denis Lebedev. Non functional swift.

Software

Transcript of Denis Lebedev. Non functional swift.