- Why we need generics? - Why Go doesn't have generics (yet)? - Walk through Golang Generics Draft Design! - Does Go1 has a type inference? - Parameterized types - Contracts vs Interfaces

1. Go generics
What is this fuss about?

3. Why we need generics?

4. Why we need generics?
● Reduce the programmers overhead
● Increase code maintenance
● Increase type safety
● Reduce number of errors
● Make code faster

5. Why we need generics?
● Generic Data Structures
● Generic Algorithms
● Higher-order functions
● ….

6. y:= make([]T, len(list))
for i, x := range list {
y[i] = fn(x)
}
seq.Map(list, fn)vs

7. parallel.Map(list, fn) vs seq.Map(list, fn)

8. Why Go doesn't have generics (yet)?

9. “Generics are a technical issue and are not a political one.
The Go team is not against generics per se, only against
doing things that are not well understood and/or don't work
well with Go.”
- Russ Cox
Source: https://news.ycombinator.com/item?id=9622417

10. Generics Draft Design!

11. “(...) the design can be fully backward
compatible with Go1.”
Source: https://go.googlesource.com/proposal/+/master/design/go2draft-contracts.md

12. “Among other languages
that support parametric polymorphism
this design is perhaps most similar to CLU or Ada.”
Source: https://go.googlesource.com/proposal/+/master/design/go2draft-contracts.md

13. Type parameters

14. func PrintTimes(s []interface{}, t int)

15. func PrintTimes(s []T, t int)

16. “In a language like Go, we expect
every identifier to be declared in some way.”
Source: https://go.googlesource.com/proposal/+/master/design/go2draft-contracts.md

17. func PrintTimes(s []T, t int)

18. func PrintTimes(s []T, t int)

19. func PrintTimes(s []T, t int)

20. func PrintTimes (s []T, t int)

21. func PrintTimes(type T)(s []T, t int)

22. PrintTimes(int)([]int{1, 2, 3}, 3)

23. PrintTimes(int)([]int{1, 2, 3}, 3)

24. PrintTimes(int)([]int{1, 2, 3}, 3)

25. PrintTimes ([]int{1, 2, 3}, 3)

26. PrintTimes ([]int{1, 2, 3}, 3)

27. “Type inference is a convenience feature.
Although we think it is an important feature, it does not add
any functionality to the design, only convenience in using it.”
Source: https://go.googlesource.com/proposal/+/master/design/go2draft-contracts.md

28. Does Go1 has a type inference?

29. var res *http.Response
var err error
res, err = http.Get("http://brainly.com/")

30. res, err := http.Get("http://brainly.com/")

31. How to declare more than one
type parameter?

32. func Print2(type T1, T2)(s1 []T1, s2 []T2)

33. Let’s look at map function

34. func Map(type T1, T2)(s []T1, f func(T1) T2) []T2 {
r := make([]T2, len(s))
for i, v := range s {
r[i] = f(v)
}
return r
}

35. func Map(type T1, T2)(s []T1, f func(T1) T2) []T2 {
r := make([]T2, len(s))
for i, v := range s {
r[i] = f(v)
}
return r
}

36. func Map(type T1, T2)(s []T1, f func(T1) T2) []T2 {
r := make([]T2, len(s))
for i, v := range s {
r[i] = f(v)
}
return r
}

37. s := []int{1, 2, 3}
slices.Map(s, func(i int) float64 {
return float64(i)
})

38. Parameterized types

39. type List struct {
next *List
val interface{}
}

40. type List(type T) struct {
next *List(T)
val T
}

41. func (l *List(T)) Val() T {
return l.val
}

42. l := list.List(int)
l.Append(1)
l.Tail().Val() == 1

43. Parameterized type aliases

44. type Ptr(type Target) = *Target

45. var i *int = &1 // Error!

46. j := 1
var i *int = &j // OK!

47. type Ptr(type Target) = *Target
var i *int = Ptr(int)(1)

48. type Ptr(type Target) = *Target
type PtrInt = Ptr(int)
var i *int = PtrInt(1)

49. Contracts

50. func PrintTimes(type T)(s []T, t int) {
for _, n := range s {
fmt.Print(n.String())
}
}

51. func PrintTimes(type T)(s []T, t int) {
for _, n := range s {
fmt.Print(n.String())
}
}

52. func PrintTimes(type T)(s []T, t int) {
for _, n := range s {
fmt.Print(n.Stringer())
}
}

53. PrintTimes(data, 3)
^^^^
Error: SomeStruct doesn’t have String() method,
Stringer() expected.

54. “(...) Go is designed to support programming at scale”
Source: https://go.googlesource.com/proposal/+/master/design/go2draft-contracts.md

55. contract stringer(x T) {
var s string = x.String()
}

56. func PrintTimes(type T stringer)(s []T, t int) {
for _, n := range s {
fmt.Print(n.Stringer())
}
}

57. func PrintTimes(type T stringer)(s []T, t int) {
^^^^^^^^^^
Error: PrintTimes does not follow contract
stringer. String() method call expected.

58. Contract vs Interface?

59. Source: https://twitter.com/rogpeppe/status/1036008488143646722

60. contract stringer(x T) {
var s string =
x.String()
}
type stringer interface {
String() string
}
vs

61. Source: https://gist.github.com/deanveloper/c495da6b9263b35f98b773e34bd41104
type Comparable interface {
operator[==]
operator[!=]
}

62. What contract can contract?

63. contract convert(t To, f From) {
To(f)
From(t)
f == f
}

64. contract strseq(x T) {
[]byte(x)
T([]byte{})
len(x)
}

65. contract G(n Node, e Edge) {
var _ []Edge = n.Edges()
var from, to Node = e.Nodes()
}

66. contract add1K(x T) {
x = 1000
x + x
}

67. contract iterable(x T) {
for T {}
}

68. Reflection

69. reflect.TypeOf(&List(int)).String()
=== "List(int)"

70. Efficiency

71. “do you want slow programmers, slow compilers and
bloated binaries, or slow execution times?”
- Russ Cox
Source: https://research.swtch.com/generic

72. “Only experience will show
what people expect in this area.”
Source: https://go.googlesource.com/proposal/+/master/design/go2draft-contracts.md

73. Omissions

74. Omissions
● No metaprogramming
● No covariance or contravariance.
● No operator methods (range, ==, m[k])
● No currying
● ...

75. What do you think about draft design?

76. vs

77. Thanks!
Gabriel Habryn
GitHub: github.com/widmogrod
Twitter: @widmogrod
Brainly Jobs: https://brainly.co/jobs.html

78. “(...) the type parameters are bounded not by a subtyping
relationship but by explicitly defined structural
constraints”
Source: https://go.googlesource.com/proposal/+/master/design/go2draft-contracts.md