# 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.

The high-order bits that do not fit are silently discarded.
``````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