1 of 22

Generics in Golang

1

Mohit Kumar

2 of 22

2

3 of 22

Let’s sort integers

3

4 of 22

Let’s sort floats

4

5 of 22

Let’s sort a custom float64 type

5

6 of 22

How did we solve this prior to Generics?

6

7 of 22

Reflection

7

8 of 22

Let’s talk about it!!

Introspect and Analyze program during run-time
Interface values
The empty interface
How do you use it?

8

If we treat the source code as code, it is possible to execute the source code on a CPU like we always do.

On the other hand, if we think of source code as data, we can inspect and update it like we do for normal program data. For example, you can list all the properties of a struct without knowing all of its properties.

Metaprogramming refers to a programming technique that treats the program as data. The metaprogramming techniques can inspect and process other programs, or the program itself, even during its execution.

Reflection is a sub part of meta-programming

Reflection adds a little hint of dynamicity to Go which is a statically typed language. Helps to gauge the underlying type and value of a variable. To better understand what it does and how it does it, we first need to understand what an empty interface{} is.

9 of 22

Reflection

Let’s create a SQL INSERT query generator

9

10 of 22

Reflection

But it should be a dynamic one

10

11 of 22

Then why do we need Generics?

11

12 of 22

Issues with Reflection

12

Clear is better than clever. Reflection is never clear. — Rob Pike
Awkward Programming Model
Does not provide compile time check. Dynamic is dangerous
Poor Performance

13 of 22

Generics

13

14 of 22

Generics💪

Way of writing code that is independent of the specific types being used.
Aims to write interoperable and adaptable code.

14

15 of 22

Let’s break it down

15

Type parameters for functions and types
Type sets defined by interfaces
Type Inference

16 of 22

Let’s see a real implementation

16

17 of 22

When to use generics?

17

Write code, don’t design types.
Functions that work on slices, maps, and channels of any element type and the code doesn’t make any assumption of the element type of the above
General purpose data structure
When a method looks the same for all the types

18 of 22

When not to use generics?

18

When just calling a method on the type argument.

19 of 22

When not to use generics?

19

When the implementation of a common method is different for each type.
When the implementation is different for each type and not all the types have to implement the operation

20 of 22

One Thumb Rule

20

Avoid boilerplate

Corollary, don’t use type parameters prematurely; wait until you are about to write boilerplate code

21 of 22

21

Questions?

22 of 22

References

22