Denis  Lebedev, Swift
Upcoming SlideShare
Loading in...5
×
 

Denis Lebedev, Swift

on

  • 18,812 views

 

Statistics

Views

Total Views
18,812
Slideshare-icon Views on SlideShare
395
Embed Views
18,417

Actions

Likes
2
Downloads
5
Comments
0

16 Embeds 18,417

http://habrahabr.ru 16409
http://m.habrahabr.ru 1548
http://tech.yandex.ru 317
https://tech.yandex.ru 77
http://feedly.com 29
http://savepearlharbor.com 14
http://gigamir.net 5
http://www.pvsm.ru 4
http://nbqwe4tbnbqwe4rooj2q.dresk.ru 3
http://translate.googleusercontent.com 3
http://security-corp.org 2
http://www.inoreader.com 2
http://devl547.noip.me 1
http://digg.com 1
http://nbqwe4tbnbqwe4rooj2q.biglu.ru 1
http://nbqwe4tbnbqwe4rooj2q.nblk.ru 1
More...

Accessibility

Categories

Upload Details

Uploaded via as Adobe PDF

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

    Denis  Lebedev, Swift Denis Lebedev, Swift Presentation Transcript

    • Swift Denis Lebedev, iOS @ Yandex
    • Agenda • Introduction • Objective-C bridging • Good-to-know features • “Where can I Swift?”
    • Swift Chris Lattner, Swift creator
    • Swift • Multi-paradigm • Static, inferred typing • Bridged with Objective-C • No pointers
    • –Someone at WWDC Keynote It’s like “Objective-C without C.”
    • Swift features • Namespacing* • Generic classes & functions • Named/default parameters • Functions are first class citizens • Optional types
    • Optionals • Used in situations where value may be absent • Alternative for obj-c nil passing • works with any type
    • Optionals - (NSInteger)indexOfObject:(id)object;
    • Optionals func indexOf(object: AnyObject) -> Int?
    • Optionals • Can be safely unwrapped (if/else) • Can be force unwrapped (runtime exception if value is missing)
    • Classes, structs, enumerations • Classes passed by reference, structs - by value • Using a struct has no runtime penalty • All scalars and even Bool are structs • Enumerations are extremely powerful
    • Enumerations enum Tree { case Empty case Leaf case Node }
    • Enumerations enum Tree { case Empty case Leaf(Int) case Node(Tree, Tree) }
    • Enumerations enum Tree<T> { case Empty case Leaf(T) case Node(Tree, Tree) }
    • Enumerations let tree: Tree<Int> = .Node(.Leaf(1), .Leaf(1))
    • Enumerations enum Tree<T> { case Empty case Leaf(T) case Node(Tree, Tree) func depth<T>(t: Tree<T>) -> Int { return 0 } }
    • Enumerations enum Tree<T> { case … func depth() -> Int { func _depth<T>(t: Tree<T>) -> Int { return 0 } return _depth(self) } }
    • Enumerations enum Tree<T> { case … func depth() -> Int { func _depth<T>(t: Tree<T>) -> Int { switch t { case .Empty: return 0 } return _depth(self) } }
    • Enumerations enum Tree<T> { case … func depth() -> Int { func _depth<T>(t: Tree<T>) -> Int { switch t { case .Empty: return 0 case .Leaf(let _): return 1 } return _depth(self) } }
    • Enumerations enum Tree<T> { case … func depth() -> Int { func _depth<T>(t: Tree<T>) -> Int { switch t { case .Empty: return 0 case .Leaf(let _): return 1 case .Node(let lhs, let rhs): return max(_depth(lhs), _depth(rhs)) } } return _depth(self) } }
    • Enumerations enum Tree<T> { case Empty case Leaf(T) case Node(Tree, Tree) func depth() -> Int { func _depth<T>(t: Tree<T>) -> Int { switch t { case .Empty: return 0 case .Leaf(let _): return 1 case .Node(let lhs, let rhs): return max(_depth(lhs), _depth(rhs)) } } return _depth(self) } }
    • Collections • Array, Dictionary, String (contains Char) • Collections are structs • Implicitly bridged to Cocoa collection types
    • Collections func filter<S : Sequence>(…) -> Bool) -> FilterSequenceView<S> func reverse<C : Collection …>(source: C) -> ReverseView<C> Some of operations are lazy evaluated
    • Collections func filter<S : Sequence>(…) -> Bool) -> FilterSequenceView<S> func reverse<C : Collection …>(source: C) -> ReverseView<C> Some of operations are lazy evaluated
    • Built-in immutability var b = 3 b += 1 let a = 3 a += 1 // error
    • Dictionary immutability let d = ["key0": 0] d["key"] = 3 //error d.updateValue(1, forKey: "key1") //error
    • Array immutability let c = [1, 2, 3] c[0] = 3 // success c.append(5) // fail
    • Array immutability let c = [1, 2, 3] c[0] = 3 // success c.append(5) // fail It’s a bug: https://devforums.apple.com/message/971330#971330
    • Extensions • extends any named type (struct, enum, class) • structures code
    • Extensions struct Foo { let value : Int } extension Foo : Printable { var description : String { get {return "Foo"} } } extension Foo : Equatable { } func ==(lhs: Foo, rhs: Foo) -> Bool { return lhs.value == rhs.value }
    • What Swift is missing • Preprocessor • Exceptions • Access control * • KVO, KVC • Compiler attributes (platforms, deprecations, etc.) • performSelector: is unavailable
    • Objective-C bridging • Call Obj-c from Swift • Call Swift from Objc with limitations • Call CoreFoundation types directly • C++ is not allowed (should be wrapped in Objc) • Subclassing Swift classes not allowed in Objc
    • Objective-C bridging • NSArray < - > Array • NSDictionary < - > Dictionary • NSNumber - > Int, Double, Float
    • Objective-C bridging @objc class Foo { init (bar: String) { /*...*/ } }
    • Objective-C bridging @objc(objc_Foo) class Foo { @objc(initWithBar:) init (bar: String) { /*...*/ } }
    • Objective-C bridging Foo *foo = [[Foo alloc] initWithBar:@"Bar"];
    • Objective-C bridging func convertPoint(point: CGPoint, toWindow window: UIWindow!) -> CGPoint - (CGPoint)convertPoint:(CGPoint)point toWindow:(UIWindow *)window
    • Objective-C bridging • All object types are mapped as implicitly unwrapped optionals (T!) • All ‘id’ types are mapped as ‘AnyObject’
    • Swift internals • Swift objects are Obj-c objects • Implicit root class ‘SwiftObject’ • Ivars type encoding is stored separately • Method’s vtable • Name mangling
    • Name mangling class Foo { func bar() -> Bool { return false } } _TFC9test3Foo3barfS0_FT_Sb Swift keeps function metadata encoded in function symbols
    • Performance • 10-100 x slower than C++ (-O0) • 10 x slower than C++ (-O3) • 1 x as C++ (-Ofast)*
    • Performance • Swift is still in beta • Unoptimized calls of retain/release in loops
    • Cross-platform code #if os(iOS) typealias View = UView #else typealias View = NSView #endif class MyControl : View { }
    • Pattern matching let point = (0, 1) if point.0 >= 0 && point.0 <= 1 && point.1 >= 0 && point.1 <= 1 { println("I") } ...
    • Pattern matching let point = (0, 1) switch point { case (0...1, 0...1): println("I") … }
    • Pattern matching let point = (0, 1) switch point { case (0, 0): println("Point is at the origin") case (0...1, 0...1): println("I") case (-1...0, 0...1): println("II") case (-1...0, -1...0): println("III") case(0...1, -1...0): println("IV") default: println(“I don’t know.") }
    • Function currying func add(a: Int)(b: Int) -> Int { return a + b } let foo = add(5)(b: 3) // 8 let add5 = add(5) // (Int) -> Int let bar = add5(b: 3) // 8
    • Auto closures • Wraps function argument in explicit closure func assert(condition:() -> Bool, message: String) { #if DEBUG if !condition() { println(message) } #endif } assert({5 % 2 == 0}, "5 isn't an even number.")
    • Auto closures Wraps function argument in explicit closure func assert(condition: @auto_closure () -> Bool, message: String) { #if DEBUG if !condition() { println(message) } #endif } assert(5 % 2 == 0, "5 isn't an even number.")
    • Implicit type conversion struct Box<T> { let _value : T init (_ value: T) { _value = value } } let boxedInt = Box(1) //Box<Int>
    • Implicit type conversion func foo(i: Int) {…} foo(boxedInt) //error: ’Box<Int>' is not convertible to 'Int'
    • Implicit type conversion extension Box { @conversion func __conversion() -> T { return value } } foo(boxedInt) //success
    • Implicit type conversion • allows any type to be ‘nil’ (which has NilType) • allows toll-free-bridging with Cocoa types
    • Reflection struct Foo { var str = "Apple" let int = 13 func foo() { } } reflect(Foo()).count // 2 reflect(Foo())[0].0 // "str" reflect(Foo())[0].1.summary // "Apple
    • Direct call of C functions @asmname - allows to provide a Swift interface for C functions @asmname("my_c_func") func my_c_func(UInt64, CMutablePointer<UInt64>) -> CInt;
    • Scripting and REPL • xcrun swift - launches REPL • xcrun -i ‘file.swift’ - executes script
    • Where can I swift? • BDD Testing framework: Quick • Reactive programming: RXSwift • Model mapping: Crust • Handy JSON processing: SwiftyJSON
    • Thx! @delebedev lebedzeu@yandex-team.ru
    • Credits • http://nondot.org/sabre/ • https://devforums.apple.com/thread/227288 • http://andelf.github.io/blog/2014/06/08/swift-implicit-type-cast/ • https://www.youtube.com/watch?v=Ii-02vhsdVk • http://www.eswick.com/2014/06/inside-swift/ • http://article.gmane.org/gmane.comp.compilers.clang.devel/37217 • http://stackoverflow.com/questions/24101718/swift-performance-sorting-arrays • http://www.splasmata.com/?p=2798 • https://github.com/rodionovd/SWRoute/wiki/Function-hooking-in-Swift