Table of Contents

• Integers
• Numeric types
• Covert rune to int and vice versa
• Assignability
• Type Alias
• Conversions(Type casting)

Integers discussion

• int8, int16, int32, int64,
• uint8, uint16, uint32, uint64

Regardless of their size, int, uint, and uintptr are different types from their explicitly sized siblings. Thus int is not the same type as int32, even if the natural size of integers is 32 bits, and an explicit conversion is required to use an int value where an int32 is needed, and vice versa.

var u uint8 = 255
fmt.Println(u, u+1, u*u) // 255 0 1
var i int8 = 127
fmt.Println(i, i+1, i*i) // 127 -128 1

For this reason,

Although Go provides unsigned numbers and arithmetic, we tend to use the signed int form even for quantities that can’t be negative, such as the length of an array, though uint might seem a more obvious choice.

Unsigned numbers tend to be used only when their bitwise operators or peculiar arithmetic operators are required,

The conversion operation T(x), like int(x), converts the value x to type T if the conversion is allowed. Many integer-to-integer conversions do not entail any change in value; they just tell the compiler how to interpret a value. But a conversion that narrows a big integer into a smaller one, or a conversion from integer to floating-point or vice versa, may change the value or lose precision.

Numeric types reference

Architecture-independent

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

Implementation specific

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

Covert rune to int and vice versa howto

• As rune is internally an alias of int32, we can just convert one into another.

fmt.Printf("%d, %q", int('A'), rune(65))

65, 'A'

Assignability discussion

x is assignable to a variable of type T if

• x 's type is identical to T.
• x 's type V and T have identical underlying types and at least one of V or T is not a defined type.
• T is an interface type and x implements T.
• x is a bidirectional channel value, T is a channel type, x 's type V and T have identical element types, and at least one of V or T is not a defined type.
• x is the predeclared identifier nil and T is a pointer, function, slice, map, channel, or interface type.
• x is an untyped constant representable by a value of type T.

Type Alias discussion

From 1.9, Go started to support type aliases. Consider following:

type Name1 map[string]string
type Name2 map[string]string
type Alias = map[string]string

While type declaration creates a different type from an underlying type, type alias creates just a name for the original type.

• While a value of Name1 is assignable to map[string]string, is not to Name2.
• Alias is assignable to any of those types
• As a method receiver should be a defined type, a type alias of primitive types

Conversions(Type casting) discussion