Go generics. what is this fuzz about?

Go generics
What is this fuss about?

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

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

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

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

Why Go doesn't have generics (yet)?

“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

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

“Among other languages
that support parametric polymorphism
this design is perhaps most similar to CLU or Ada.”

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

“In a language like Go, we expect
every identifier to be declared in some way.”

func PrintTimes (s []T, t int)

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

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

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

“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.”

Does Go1 has a type inference?

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

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

How to declare more than one
type parameter?

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

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
}

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

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

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

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

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

type Ptr(type Target) = *Target

var i *int = Ptr(int)(1)

type PtrInt = Ptr(int)
var i *int = PtrInt(1)

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

func PrintTimes(type T)(s []T, t int) {
fmt.Print(n.Stringer())
}
}

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

“(...) Go is designed to support programming at scale”

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

func PrintTimes(type T stringer)(s []T, t int) {
fmt.Print(n.Stringer())
}
}

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

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

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

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

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

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

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

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

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

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

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

“Only experience will show
what people expect in this area.”

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

What do you think about draft design?

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

“(...) the type parameters are bounded not by a subtyping
relationship but by explicitly defined structural
constraints”

Go generics. what is this fuzz about?

More Related Content

What's hot (19)

Similar to Go generics. what is this fuzz about? (20)

More from Gabriel Habryn (6)

Recently uploaded (20)

Go generics. what is this fuzz about?

Editor's Notes