Source

Also Read:Swift 3.1: Swift Package Manager – Part 2

Introduction

Language Improvements

1. Failable Numeric Conversion Initializers

1. class Student {
2.  let name: String
3.  let grade: Int
4.  
5.  init?(json: [String: Any]) {
6.    guard let name = json[“name”] as? String,
7.          let gradeString = json[“grade”] as? String,
8.          let gradeDouble = Double(gradeString),
9.          let grade = Int(exactly: gradeDouble)  // <– 3.1 feature here
10.    else {
11.        return nil
12.    }
13.    self.name = name
14.    self.grade = grade
15.  }
16. }
18. func makeStudents(with data: Data) -> [Student] {
19.  guard let json = try? JSONSerialization.jsonObject(with: data, options: .allowFragments),
20.        let jsonArray = json as? [[String: Any]] else {
21.    return []
22.  }
23.  return jsonArray.flatMap(Student.init)
24. }

1. let rawStudents = “[{\”name\”:\”Ray\”, \”grade\”:\”5.0\”}, {\”name\”:\”Matt\”, \”grade\”:\”6\”},
2.                    {\”name\”:\”Chris\”, \”grade\”:\”6.33\”}, {\”name\”:\”Cosmin\”, \”grade\”:\”7\”},
3.                    {\”name\”:\”Steven\”, \”grade\”:\”7.5\”}]”
4. let data = rawStudents.data(using: .utf8)!
5. let students = makeStudents(with: data)
6. dump(students) // [(name: “Ray”, grade: 5), (name: “Matt”, grade: 6), (name: “Cosmin”, grade: 7)]

let grade = Int(exactly: gradeDouble)

Also Read:Kotlin- The Next-Gen Android App Development Language

2. New Sequence Functions

1. let fibonacci = sequence(state: (0, 1)) {
2.  (state: inout (Int, Int)) -> Int? in
3.  defer {state = (state.1, state.0 + state.1)}
4.  return state.0
5. }

1. // Swift 3.0
2. for number in fibonacci.prefix(10) {
3.  print(number)  // 0 1 1 2 3 5 8 13 21 34
4. }

1. // Swift 3.1
2. let interval = fibonacci.prefix(while: {$0 < 1000}).drop(while: {$0 < 100})
3. for element in interval {
4.  print(element) // 144 233 377 610 987
5. }

3. Concrete Constrained Extensions

1. // Swift 3.0
2. extension String {
3.  var isBlank: Bool {
4.    return trimmingCharacters(in: .whitespaces).isEmpty
5.  }
6. }
8. let abc = ” “
9. let def = “x”
11. abc.isBlank // true
12. def.isBlank // false

1. // Swift 3.0
2. protocol StringProvider {
3.  var string: String {get}
4. }
6. extension String: StringProvider {
7.  var string: String {
8.    return self
9.  }
10. }
12. extension Optional where Wrapped: StringProvider {
13.  var isBlank: Bool {
14.    return self?.string.isBlank ?? true
15.  }
16. }
18. let foo: String? = nil
19. let bar: String? = ”  “
20. let baz: String? = “x”
22. foo.isBlank // true
23. bar.isBlank // true
24. baz.isBlank // false

1. // Swift 3.1
2. extension Optional where Wrapped == String {
3.  var isBlank: Bool {
4.    return self?.isBlank ?? true
5.  }
6. }

4. Nested Generics

1. class Team<T> {
2.  enum TeamType {
3.    case swift
4.    case iOS
5.    case macOS
6.  }
7.  
8.  class BlogPost<T> {
9.    enum BlogPostType {
10.      case tutorial
11.      case article
12.    }
13.    
14.    let title: T
15.    let type: BlogPostType
16.    let category: TeamType
17.    let publishDate: Date
18.    
19.    init(title: T, type: BlogPostType, category: TeamType, publishDate: Date) {
20.      self.title = title
21.      self.type = type
22.      self.category = category
23.      self.publishDate = publishDate
24.    }
25.  }
26.  
27.  let type: TeamType
28.  let author: T
29.  let teamLead: T
30.  let blogPost: BlogPost<T>
31.  
32.  init(type: TeamType, author: T, teamLead: T, blogPost: BlogPost<T>) {
33.    self.type = type
34.    self.author = author
35.    self.teamLead = teamLead
36.    self.blogPost = blogPost
37.  }
38. }

1. Team(type: .swift, author: “Cosmin Pupăză”, teamLead: “Ray Fix”,
2.     blogPost: Team.BlogPost(title: “Pattern Matching”, type: .tutorial,
3.     category: .swift, publishDate: Date()))
5. Team(type: .swift, author: “Cosmin Pupăză”, teamLead: “Ray Fix”,
6.     blogPost: Team.BlogPost(title: “What’s New in Swift 3.1?”, type: .article,
7.     category: .swift, publishDate: Date()))

1. class Team<T> {
2.  // original code
3.  
4.  class BlogPost {
5.    // original code
6.  }  
7.  
8.  // original code
9.  let blogPost: BlogPost
10.  
11.  init(type: TeamType, author: T, teamLead: T, blogPost: BlogPost) {
12.    // original code   
13.  }
14. }

5. Convert Non-Escaping Closures to Escaping Ones

1. func perform(_ f: () -> Void, simultaneouslyWith g: () -> Void,
2.             on queue: DispatchQueue) {
3.  withoutActuallyEscaping(f) { escapableF in     // 1
4.    withoutActuallyEscaping(g) { escapableG in
5.      queue.async(execute: escapableF)           // 2
6.      queue.async(execute: escapableG)     
7.      queue.sync(flags: .barrier) {}             // 3
8.    }                                            // 4
9.  }
10. }

1. f and g come in as non-escaping and are converted to escapableF and escapableG.
2. async(execute:) calls require escaping closures. Fortunately, you have those because of the previous step.
3. By running sync(flags: .barrier), you ensure that the async(execute:) methods are completely done and the closures won’t be called later on.
4. Scope limits the use of escapableF and escapableG.