Successfully reported this slideshow.
Your SlideShare is downloading. ×

Swift Introduction

Ad
Ad
Ad
Ad
Ad
Ad
Ad
Ad
Ad
Ad
Ad
Upcoming SlideShare
Denis  Lebedev, Swift
Denis Lebedev, Swift
Loading in …3
×

Check these out next

1 of 54 Ad

More Related Content

Slideshows for you (20)

Viewers also liked (20)

Advertisement

Similar to Swift Introduction (20)

Recently uploaded (20)

Advertisement

Swift Introduction

  1. 1. SWIFT INTRODUCTION by Giuseppe Arici & Matteo Battaglio @ Codemotion Milan, 29/11/2014, v 1.1-S
  2. 2. A SWIFT INTRODUCTION TO THE NEW APPLE PROGRAMMING LANGUAGE
  3. 3. HELLO WORLD ▸ Giuseppe Arici & Matteo Battaglio ▸ iOS devs @ Tiltap / Superpartes ▸ #pragma mark co-founders ▸ Codemotion friends ▸  addicted
  4. 4. [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
  5. 5. HISTORY
  6. 6. LANGUAGE FATHER Chris Lattner
  7. 7. 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
  8. 8. 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
  9. 9. PRINCIPLES
  10. 10. SWIFT PROGRAMMING LANGUAGE imperative, functional, object oriented, multi-paradigm, static, strong typed, type safe, inferred, general purpose, compiled, fast, modern, elegant, clean, funny, happy, ❤️
  11. 11. SYNTAX
  12. 12. Immutable & Mutable Functions & Closures Tuples & Pattern Matching Data Types & Instances Protocols & Extensions Generics & Optionals
  13. 13. IMMUTABLE & MUTABLE
  14. 14. 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'
  15. 15. CONSTANTS & VARIABLES UNICODE CHARACTERS IN CONSTANT & VARIABLE NAMES let !!!! = 4 var """"" = 5 ! KILLER APPLICATION "
  16. 16. 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.
  17. 17. 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]
  18. 18. 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"]
  19. 19. FUNCTIONS & CLOSURES
  20. 20. 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, ...
  21. 21. 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)
  22. 22. 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.
  23. 23. 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
  24. 24. FUNCTIONS VS CLOSURES 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)
  25. 25. FUNCTIONS VS CLOSURES 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 } )
  26. 26. FUNCTIONS VS CLOSURES 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, >)
  27. 27. TUPLES & PATTERN MATCHING
  28. 28. 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
  29. 29. 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") }
  30. 30. DATA TYPES & INSTANCES
  31. 31. ENUMERATIONS, STRUCTURES & CLASSES COMMON CAPABILITIES ▸ Stored & Computed Properties ▸ Methods, Subscripts & Initializers ▸ Protocols & Extensions ▸ Access Control
  32. 32. 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() { /* ... */ } }
  33. 33. CLASSES Only ADDITIONAL CAPABILITIES: ▸ Inheritance ▸ Type casting ▸ Deinitializers ▸ Reference counting
  34. 34. 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
  35. 35. PROTOCOLS & EXTENSIONS
  36. 36. 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 }
  37. 37. 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 }
  38. 38. 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! !
  39. 39. GENERICS & OPTIONALS
  40. 40. 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) { let temporaryA = a; a = b; b = temporaryA } // Generic Function func swapTwoValues<T>(inout a: T, inout b: T) { let temporaryA = a; a = b; b = temporaryA } var someInt = 1, anotherInt = 2 swapTwoValues(&someInt, &anotherInt) // T == Int // someInt == 2, anotherInt == 1
  41. 41. 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 } }
  42. 42. 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
  43. 43. 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 !!!
  44. 44. 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?
  45. 45. 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)
  46. 46. TOOLS & PRACTICE
  47. 47. LET'S PLAY WITH SWIFT ▸ Swift in playground ▸ Swift distinctive features ! LET'S SEE IT IN ACTION!
  48. 48. FINAL THOUGHTS
  49. 49. SWIFT VS ... ? ▸ Swift vs Scala ▸ Swift vs Rust ▸ Swift vs C# Swift is Objective-C without the C
  50. 50. 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
  51. 51. 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
  52. 52. 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
  53. 53. Q&A
  54. 54. THANKS see you @ https://fb.com/groups/pragmamark @giuseppearici / giuseppe.arici@pragmamark.org @m4dbat / matteo.battaglio@pragmamark.org

×