Part III

The code for this part is in the types folder under this github repo .


Go is a typed language. That means everything we create must have a type.

There are a few basic types.

Boolean Types

Represents set of boolean value. With predefined constant true and false

bool        true or false

Numeric Types

Integer and Floating point values. Following are architecture independent numeric types.

uint8       the set of all unsigned  8-bit integers (0 to 255)
uint16      the set of all unsigned 16-bit integers (0 to 65535)
uint32      the set of all unsigned 32-bit integers (0 to 4294967295)
uint64      the set of all unsigned 64-bit integers (0 to 18446744073709551615)

int8        the set of all signed  8-bit integers (-128 to 127)
int16       the set of all signed 16-bit integers (-32768 to 32767)
int32       the set of all signed 32-bit integers (-2147483648 to 2147483647)
int64       the set of all signed 64-bit integers (-9223372036854775808 to 9223372036854775807)

float32     the set of all IEEE-754 32-bit floating-point numbers
float64     the set of all IEEE-754 64-bit floating-point numbers

complex64   the set of all complex numbers with float32 real and imaginary parts
complex128  the set of all complex numbers with float64 real and imaginary parts

byte        alias for uint8
rune        alias for int32

These are architecture dependent. (Could be either 32 bit or 64 bit)

uint     either 32 or 64 bits
int      same size as uint
uintptr  an unsigned integer large enough to store the uninterpreted bits of a pointer value

String Types

String is a sequence of bytes.

Composite Types


Arrays are fixed length and fixed type.

var arr = [5]int{}


Contiguous segment of underlying array. Has fixed type. Length can be dynamically reallocated. (More on this on a later chapter)

var slice = []int{}


Key value store. Similar to dictionary in python or object in JavaScript. But it still has a fixed type.

var maps = map[int]int{}


Functions are also types.

var function = func() int {
	return 42

function has a type func() int


Custom type defined by user. Its a sequence of named elements with name and types. Struct can be empty too.

type empty struct{}
var x = empty{}


Channels are typed conduit between running go routines. We will hold off on talking about channels until we talk about go routines.


An interface type specifies a method set called its interface. If a any type has the method set of the interface, that type implements the interface. All types implement the empty interface interface{}. Interface does not have any type. Its always the underlying components type. A type can implement any number of interfaces. We will talk about interface in great details in a later post.

var y interface{} = x // y now has a type of empty since that is the type of x.

Type Alias and Type Definition

We already saw 2 examples of type aliases. byte and rune are type aliases of uint8 and uint32 respectively. This means every time we use byte we are basically using an uint8. We can also define our own type from another base type.

// type alias
type myFloat = float64
var aliasFloat myFloat = 5.0 // has type float64
// type definition
type myint int
var aliasInt myint = 1 // has type myint

Type alias is useful for moving types between packages for refactoring. Lets say we were using a struct type called coolstuff in a package. If we move the coolstuff to a different package, we would have to refactor all the places where coolstuff were being used. One way to mitigate issues during the refactor type is to create a type alias in the old package where coolstuff was.

type coolstuff = newpackage.Coolstuff

Type definition is used usually for creating enums. Or sometimes to extend existing types by attaching methods. For example:

func (m myint) double() myint {
	return m * 2

Type int does not have any methods. But with myint we can create a double() method on our type. We have yet to talk about method and method receiver. We will talk about it in depth.

Type Conversion

Basic numeric types can be converted with T() syntax. Where T is the type to be converted to.

var i int = 355        // type int
f := float64(i)        // type float64
by := byte(i)          // type byte (uint8)

Struct type can be converted to and from each other as long as they have identical field names and types in identical order.

type person struct {
	age  int
	name string

type student struct {
	age  int // try swapping these fields
	name string

p := person{age: 20, name: "john"}
std := student{age: 15, name: "paul"}

p2 := person(std)
s2 := student(p)

There is a way to type case any struct to any other struct using the unsafe package. This is rarely used. If you write code that uses unsafe package, you better have a solid reasoning for it.

On function calls type conversion is automatic if the parameter can be converted to the desired type it gets converted. int will be converted to float but not the other way around because float to int can loose precision.

For defined types, the conversion is uni directional. You can always use the underlying type in place of the defined type but not the other way around.

func definedTypeConversion(mi myint) {
	fmt.Printf("Type of mi=%T\n", mi)

func takesInt(i int) {
	fmt.Printf("Type of i=%d", i)

definedTypeConversion(5) // this get converted to myint type

takesInt(aliasInt) // this does not work


We have seen example of inference a few times already. Every time we use the := operator, we are inferring the type of the left hand operand.

x := 5 // type inferred to int
y := x // type inferred to int because of the type of x

Type inference also happens for numeric constants when passing to a function if the compiler does not detect a loss of precision or overflow.

Next Steps

This is Part 4 of this Go crash course series.

Part 5