The document discusses generics in Swift. It provides examples of using generics to write functions that can swap or operate on values of any type rather than being limited to a specific type. The document compares generics to using protocols, noting some key differences in how the return value is handled. It also discusses challenges with using generics with some frameworks like TableViews due to bugs, as well as examples of using generics for things like API requests, object mapping, and completion handlers. Overall it advocates that generics are fast, useful, flexible and practical despite some limitations.

1. Generics with Swift
by akira hirakawa
@akirahrkw

2. Do you Swift?

3. we use swift for
Burpple app

5. Generics with Swift

6. Do you use Generics?

7. example

8. swap two Int values
func swapTwoInts(inout a: Int, inout b: Int) {
let temporaryA = a
a = b
b = temporaryA
}

9. swap two Double values
func swapTwoDoubles(inout a: Double, inout b: Double) {
let temporaryA = a
a = b
b = temporaryA
}

10. swap two String values
func swapTwoStrings(inout a: String, inout b: String) {
let temporaryA = a
a = b
b = temporaryA
}

11. these are identical !!

12. more useful
more flexible?

13. generics !!

14. Generic function
func swapTwoValues<T>(inout a: T, inout b: T) {
let temporaryA = a
a = b
b = temporaryA
}

15. swap Int values
var someInt = 3
var anotherInt = 107
swapTwoValues(&someInt, &anotherInt)

16. swap String values
var someString = "hello"
var anotherString = "world"
swapTwoValues(&someString, &anotherString)

17. can not
var someInt = 3
var anotherString = "world"
swapTwoValues(&someInt, &anotherString)

18. useful
flexible

19. but

20. why not use
Protocol?

21. can

22. swap two Any values
func swapTwoValues(inout a: Any, inout b: Any) {
let temporaryA = a
a = b
b = temporaryA
}

23. var a = 1 as Any
var b = 2 as Any
swapTwoValues(&a, &b)

24. var a = “a” as Any
var b = “b” as Any
swapTwoValues(&a, &b)

25. but

26. var a = 1 as Any
var b = “a” as Any
swapTwoValues(&a, &b)

27. which is better?

28. what is the difference?

29. func executeProtocol(p: Printable) -> Printable {
}
func executeGenerics<T: Printable>(p: T) -> T {
}

30. almost same

31. func executProtocol(p: Printable) -> Printable {
p.description
return p
}
func executeGenerics<T: Printable>(p: T) -> T {
p.description
return p
}

32. no difference?

33. return value

34. func executProtocol(p: Printable) -> Printable {
return p
}
func executeGenerics<T: Printable>(p: T) -> T {
return p
}

35. -> Printable
you need to cast to use the return value
var movie: Movie = …
var p: Printable = executProtocol(movie)
(p as Movie).show()

36. -> T
you don’t need to cast to use the value
var movie: Movie = …
movie = executeGenerics(movie)
movie.show()

37. useful

38. different

39. performance?

40. case swap method:

41. case increment:

42. depends on
-O and swift version

43. fast
useful
flexible

44. in practice?

45. case DataSource:

46. but

47. case DataSource:

48. Generics doesn’t work on TableViewDeleate,
TableViewDataSource because of a bug
ds.respondsToSelector(“tableView:numberOfRo
wsInSection:”) is false
http://www.openradar.me/radar?
id=5829206453780480

49. case API Call:

50. Request<T>

51. Request<[User]>

52. Object Mapper

53. AnyObject -> T
var orm = { (json: AnyObject) -> User in
…
…
return user
}
var orm = { (json: AnyObject) -> Media in
…
…
return media
}

54. Completion Handler

55. T -> ()
var handler = { ( item:User) -> () in
…
…
}
var handler = { (item:Media) -> () in
…
…
}

56. fast
useful
flexible
practical

57. I like generics :)

58. thanks

59. bit.ly/tinyjson
bit.ly/code20150416

60. question?