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 error
let 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
unsafe
and may crash

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 = 0
let 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 = 0
let 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 -> Int
let g = A.g // Int -> Int
let 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

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

Tools : Compiler
» Swift compiler crashes - set of crash tests for
the compiler
Results: 1874 of 2024 tests crashed the compiler

Tools : Playgrounds
» Interactive scratchpad (a-la Scala's worksheet,
iPython notebook)
» Embed documentation generated from markdown
» Render charts and 3D

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. Non functional swift.

More Related Content

What's hot

Viewers also liked

Similar to Denis Lebedev. Non functional swift.

More from Alina Dolgikh

Recently uploaded

Denis Lebedev. Non functional swift.