Types and Values

package main

import (
	"fmt"
	"math"
	"unsafe"
)

func main() {
	fmt.Println("[cols=\"1,1,3,1\",options=\"header\"]")
	fmt.Println("|===")
	fmt.Println("| Type | Size (bytes) | Values | Zero value")
	row := func(name string, size uintptr, values, zero string) {
		fmt.Printf("| `%s` | %d | %s | `%s`\n", name, size, values, zero)
	}
	row("bool", unsafe.Sizeof(true), "`false`, `true`", "false")
	row("int8", unsafe.Sizeof(int8(0)), fmt.Sprintf("%d to %d", math.MinInt8, math.MaxInt8), "0")
	row("int16", unsafe.Sizeof(int16(0)), fmt.Sprintf("%d to %d", math.MinInt16, math.MaxInt16), "0")
	row("int32 (rune)", unsafe.Sizeof(int32(0)), fmt.Sprintf("%d to %d", math.MinInt32, math.MaxInt32), "0")
	row("int64", unsafe.Sizeof(int64(0)), fmt.Sprintf("%d to %d", int64(math.MinInt64), int64(math.MaxInt64)), "0")
	row("int", unsafe.Sizeof(int(0)), fmt.Sprintf("%d to %d on this platform", math.MinInt, math.MaxInt), "0")
	row("uint8 (byte)", unsafe.Sizeof(uint8(0)), fmt.Sprintf("0 to %d", math.MaxUint8), "0")
	row("uint16", unsafe.Sizeof(uint16(0)), fmt.Sprintf("0 to %d", math.MaxUint16), "0")
	row("uint32", unsafe.Sizeof(uint32(0)), fmt.Sprintf("0 to %d", math.MaxUint32), "0")
	row("uint64", unsafe.Sizeof(uint64(0)), fmt.Sprintf("0 to %d", uint64(math.MaxUint64)), "0")
	row("uint", unsafe.Sizeof(uint(0)), fmt.Sprintf("0 to %d on this platform", uint(math.MaxUint)), "0")
	row("uintptr", unsafe.Sizeof(uintptr(0)), "an unsigned integer large enough to hold any pointer bit pattern", "0")
	row("float32", unsafe.Sizeof(float32(0)),
		fmt.Sprintf("about ±%.4g (smallest positive %.4g), 6 to 9 significant digits", math.MaxFloat32, math.SmallestNonzeroFloat32), "0")
	row("float64", unsafe.Sizeof(float64(0)),
		fmt.Sprintf("about ±%.4g (smallest positive %.4g), 15 to 17 significant digits", math.MaxFloat64, math.SmallestNonzeroFloat64), "0")
	row("complex64", unsafe.Sizeof(complex64(0)), "two `float32` parts", "(0+0i)")
	row("complex128", unsafe.Sizeof(complex128(0)), "two `float64` parts", "(0+0i)")
	row("string", unsafe.Sizeof(""), "an immutable sequence of bytes (the header is a pointer and a length)", `""`)
	var e error
	var a any
	row("error", unsafe.Sizeof(e), "any value with an `Error() string` method (an interface)", "nil")
	row("any", unsafe.Sizeof(a), "any value (an alias for the empty interface)", "nil")
	fmt.Println("|===")
}

package main

import (
	"fmt"
	"math"
	"math/bits"
	"runtime"
	"strconv"
)

func main() {
	fmt.Println(runtime.GOOS, runtime.GOARCH, strconv.IntSize, bits.UintSize)
	fmt.Println(math.MinInt8, math.MaxInt8, math.MaxUint8)
	fmt.Println(math.MinInt16, math.MaxInt16, math.MaxUint16)
	fmt.Println(math.MinInt32, math.MaxInt32, uint32(math.MaxUint32))
	fmt.Println(int64(math.MinInt64), int64(math.MaxInt64), uint64(math.MaxUint64))
	fmt.Println(math.MinInt, math.MaxInt, uint(math.MaxUint))
}

darwin arm64 64 64
-128 127 255
-32768 32767 65535
-2147483648 2147483647 4294967295
-9223372036854775808 9223372036854775807 18446744073709551615
-9223372036854775808 9223372036854775807 18446744073709551615

package main

import "fmt"

func expensive() bool {
	fmt.Println("expensive called")
	return true
}

func main() {
	var ok bool // false
	loaned := true
	fmt.Println(ok, loaned, !loaned, ok || loaned, ok && loaned)
	fmt.Println(ok && expensive()) // && and || short-circuit: expensive is not called
	fmt.Println(loaned || expensive())
	fmt.Println(ok == false, loaned != ok)
	// bool has no numeric form; convert explicitly
	n := 0
	if loaned {
		n = 1
	}
	fmt.Println(n)
	type Flag bool
	var f Flag = true
	fmt.Printf("%v %T\n", f, f)
}

false true false true false
false
true
true true
1
true main.Flag

package main

import "fmt"

func main() {
	n := 1
	if n {
		fmt.Println("truthy")
	}
	for n {
	}
	var b bool = 1
	_ = b
}

# example.com/shelf/ref/err/non-bool
./main.go:7:5: non-boolean condition in if statement
./main.go:10:6: non-boolean condition in for statement
./main.go:12:15: cannot use 1 (untyped int constant) as bool value in variable declaration

package main

import (
	"fmt"
	"math"
)

func main() {
	a, b := 0.1, 0.2
	fmt.Println(a+b, a+b == 0.3, math.Abs(a+b-0.3) < 1e-9)
	fmt.Println(0.1+0.2 == 0.3) // constant arithmetic is exact: true

	var zero float64
	fmt.Println(1/zero, -1/zero, zero/zero) // +Inf, -Inf, NaN: no panic
	nan := math.NaN()
	fmt.Println(nan == nan, nan != nan, math.IsNaN(nan), nan < 1, nan > 1)

	negZero := math.Copysign(0, -1)
	fmt.Println(negZero, negZero == 0, math.Signbit(negZero))

	var f32 float32 = 16777216
	fmt.Println(f32+1 == f32) // float32 has a 24-bit significand

	// Money in floating point drifts; keep minor units in an integer.
	total := 0.0
	for range 10 {
		total += 0.10
	}
	fmt.Println(total, total == 1.0)
	cents := 0
	for range 10 {
		cents += 10
	}
	fmt.Printf("%d.%02d\n", cents/100, cents%100)
	huge := math.MaxFloat64
	fmt.Println(huge*10, -huge*10) // run-time overflow gives infinities
}

0.30000000000000004 false true
true
+Inf -Inf NaN
false true true false false
-0 true true
true
0.9999999999999999 false
1.00
+Inf -Inf

package main

import (
	"fmt"
	"math/cmplx"
)

func main() {
	var c complex128 = 3 + 4i
	d := complex(1, -2) // builtin complex(real, imag)
	fmt.Println(c, d, c*d, c+d)
	fmt.Println(real(c), imag(c), cmplx.Abs(c))
	var c64 complex64 = complex64(c)
	fmt.Printf("%T %T %v\n", c, c64, c == 3+4i)
	fmt.Printf("%.2f %v\n", cmplx.Sqrt(-1), cmplx.Exp(1i*3.141592653589793))
}

(3+4i) (1-2i) (11-2i) (4+2i)
3 4 5
complex128 complex64 true
(0.00+1.00i) (-1+1.2246467991473515e-16i)

package main

import "fmt"

func main() {
	title := "Les Misérables"
	fmt.Println(len(title), len([]rune(title))) // bytes versus code points
	fmt.Println(title[0], title[4:7], string(title[0]))
	var empty string
	fmt.Printf("%q %d %t\n", empty, len(empty), empty == "")
	fmt.Println("abc" < "abd", "Z" < "a", "é" > "z")
	greeting := "Hello, " + "shelf"
	greeting += "!"
	fmt.Println(greeting)
	for i, r := range "é!" {
		fmt.Println(i, r, string(r))
	}
}

15 14
76 Mis L
"" 0 true
true true true
Hello, shelf!
0 233 é
2 33 !

package main

func main() {
	s := "shelf"
	s[0] = 'S'
}

# example.com/shelf/ref/err/string-assign
./main.go:5:2: cannot assign to s[0] (neither addressable nor a map index expression)

package main

import "fmt"

func main() {
	// Integer literals (underscores and the 0b/0o prefixes arrived in Go 1.13).
	fmt.Println(42, 0b101010, 0o52, 052, 0x2A, 0x2a, 1_000_000, 0x_FF_FF)

	// Floating-point literals, including hexadecimal floats (mantissa, p, binary exponent).
	fmt.Println(1.5, .5, 5., 1e3, 1.5e-2, 0x1p-2, 0x1.8p1, 1_0.2_5)

	// Imaginary literals: the suffix i multiplies by the imaginary unit.
	fmt.Println(2i, 0b11i, 0o7i, 1.5e1i, 0x10i, 12i) // 012i is decimal 12i, for backward compatibility

	// Rune literals: a code point as an untyped rune constant.
	fmt.Println('a', '\n', '\x41', '\u00e9', '\U0001F4D6', '\101', '\'', '\\')
	fmt.Printf("%c %c %U %q\n", 'é', 0x1F4D6, 'é', '\t')

	// String literals: interpreted (escapes processed) and raw (backquotes).
	interpreted := "Dune\t(1965)\n\"Frank\" \u00e9 \xff"
	raw := `C:\shelf\books
line two with \n kept literally`
	fmt.Printf("%q\n%q\n", interpreted, raw)
	fmt.Println(len(interpreted), len(raw), len("é"), len("📖"))
}

42 42 42 42 42 42 1000000 65535
1.5 0.5 5 1000 0.015 0.25 3 10.25
(0+2i) (0+3i) (0+7i) (0+15i) (0+16i) (0+12i)
97 10 65 233 128214 65 39 92
é 📖 U+00E9 '\t'
"Dune\t(1965)\n\"Frank\" é \xff"
"C:\\shelf\\books\nline two with \\n kept literally"
24 46 2 4

package main

import "fmt"

func main() {
	fmt.Println(08)
	fmt.Println(1__0)
	fmt.Println(0x)
	fmt.Println('ab')
	fmt.Println(0b102)
}

# example.com/shelf/ref/err/bad-literals
./main.go:6:15: invalid digit '8' in octal literal
./main.go:7:16: '_' must separate successive digits
./main.go:8:16: hexadecimal literal has no digits
./main.go:9:14: more than one character in rune literal
./main.go:10:18: invalid digit '2' in binary literal

package main

import "fmt"

func main() {
	var a int32 = 1
	var b int64 = 2
	var c int = 3
	var x float64 = c
	fmt.Println(a+b, x)
	fmt.Println(a == c)
}

# example.com/shelf/ref/err/no-implicit
./main.go:9:18: cannot use c (variable of type int) as float64 value in variable declaration
./main.go:10:14: invalid operation: a + b (mismatched types int32 and int64)
./main.go:11:19: invalid operation: a == c (mismatched types int32 and int)

package main

import "fmt"

func main() {
	fmt.Println(int8(200))
	fmt.Println(uint(-1))
	fmt.Println(int(1.5))
	var f = 1.5
	fmt.Println(int(f), uint8(f))
}

# example.com/shelf/ref/err/const-conv
./main.go:6:19: constant 200 overflows int8
./main.go:7:19: constant -1 overflows uint
./main.go:8:18: cannot convert 1.5 (untyped float constant) to type int

package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Println(uint8(255), int8(-128), int(3.0), float32(0.1), float64(float32(0.1)))
	fmt.Println(float32(1e38), int64(math.MaxInt64), uint64(math.MaxUint64))
	var x float32 = 16777217 // rounded: float constants only need to round, not be exact
	fmt.Println(x)
	fmt.Println(complex64(1+2i), float64('a'), string(rune('a'+1)))
}

255 -128 3 0.1 0.10000000149011612
1e+38 9223372036854775807 18446744073709551615
1.6777216e+07
(1+2i) 97 b

package main

import (
	"fmt"
	"sync"
	"time"
)

type Author struct{ Name string }

type Book struct {
	Title   string
	Authors []Author
	Year    int
	Rating  *float64
	Tags    map[string]bool
}

func main() {
	var (
		b   bool
		i   int
		f   float64
		c   complex128
		s   string
		p   *int
		sl  []int
		m   map[string]int
		ch  chan int
		fn  func()
		e   error
		a   any
		arr [3]bool
		bk  Book
		mu  sync.Mutex
		t   time.Time
		d   time.Duration
	)
	fmt.Printf("%#v %#v %#v %#v %#v\n", b, i, f, c, s)
	fmt.Printf("%#v %#v %#v %#v\n", p, sl, m, ch)
	fmt.Printf("%v %v %v %#v\n", fn == nil, e, a, arr)
	fmt.Printf("%#v\n", bk)
	fmt.Println(t.IsZero(), d, mu.TryLock()) // a zero Mutex is an unlocked mutex
	fmt.Println(len(sl), cap(sl), len(m), m["missing"], sl == nil)
	sl = append(sl, 1) // append works on a nil slice
	fmt.Println(sl)
}

false 0 0 (0+0i) ""
(*int)(nil) []int(nil) map[string]int(nil) (chan int)(nil)
true <nil> <nil> [3]bool{false, false, false}
main.Book{Title:"", Authors:[]main.Author(nil), Year:0, Rating:(*float64)(nil), Tags:map[string]bool(nil)}
true 0s true
0 0 0 0 true
[1]

package main

import "fmt"

type ISBN string                        // defined type: a new, distinct type
type Barcode = ISBN                     // alias: another name for the same type
type Octets = []byte                    // alias of an unnamed type
type Set[T comparable] = map[T]struct{} // generic alias (Go 1.24)

func (i ISBN) Valid() bool { return len(i) == 13 }

type Celsius float64
type Fahrenheit float64

func main() {
	var b byte = 'x'
	var r rune = 'é'
	fmt.Printf("%T %T\n", b, r) // byte and rune are aliases of uint8 and int32

	var i ISBN = "9780441172719" // an untyped constant converts implicitly
	var bc Barcode = i           // identical types: no conversion
	fmt.Printf("%T %T %v\n", i, bc, bc.Valid())

	s := string(i) // explicit conversion: same underlying type
	j := ISBN(s)
	fmt.Println(s == string(j))

	var o Octets = []byte("hi")
	fmt.Printf("%T\n", o)

	seen := Set[string]{"a": {}}
	fmt.Printf("%T %d\n", seen, len(seen))

	c := Celsius(100)
	f := Fahrenheit(c*9/5 + 32)
	fmt.Println(c, f)
}

uint8 int32
main.ISBN main.ISBN true
true
[]uint8
map[string]struct {} 1
100 212

package main

import "fmt"

type ISBN string
type Celsius float64
type Fahrenheit float64

func main() {
	s := "9780441172719"
	var i ISBN = s
	var c Celsius = 20
	var f Fahrenheit = 68
	fmt.Println(i, c+f)
}

# example.com/shelf/ref/err/defined-mismatch
./main.go:11:15: cannot use s (variable of type string) as ISBN value in variable declaration
./main.go:14:17: invalid operation: c + f (mismatched types Celsius and Fahrenheit)

package main

func (b byte) IsDigit() bool { return b >= '0' && b <= '9' }

func main() {}

# example.com/shelf/ref/err/methods-on-builtin
./main.go:3:9: cannot define new methods on non-local type byte

package main

import "fmt"

type Point struct{ X, Y int }
type Pair struct{ X, Y int }
type Alias = Point

func main() {
	var p Point = Point{1, 2}
	var q Pair = Pair(p) // convertible: identical underlying struct types
	var al Alias = p     // identical: Alias is Point
	fmt.Printf("%T %T %T\n", p, q, al)

	var s1 []int
	var s2 []int
	fmt.Println(fmt.Sprintf("%T", s1) == fmt.Sprintf("%T", s2)) // []int is one type everywhere

	// Anonymous struct types are identical when fields, tags and order match.
	x := struct{ X, Y int }{1, 2}
	p = x // assignable: identical underlying types and x's type is unnamed
	fmt.Println(p)
	fn1 := func(a int, b string) error { return nil }
	var fn2 func(int, string) error = fn1 // parameter names do not matter
	fmt.Printf("%T %v\n", fn2, fn2 != nil)
}

main.Point main.Pair main.Point
true
{1 2}
func(int, string) error true

package main

import (
	"fmt"
	"io"
	"strings"
)

type IDs []int
type Meters float64

func main() {
	// 1. identical types
	var a int = 1
	var b int = a
	// 2. identical underlying types, and at least one of them is not a named type
	var ids IDs = []int{1, 2, 3}
	var raw []int = ids
	// 3. a value that implements an interface
	var r io.Reader = strings.NewReader("x")
	// 4. a bidirectional channel to a directional channel type
	ch := make(chan int, 1)
	var send chan<- int = ch
	// 5. nil to pointer, function, slice, map, channel and interface types
	var p *int = nil
	var m map[string]int = nil
	// 6. an untyped constant representable in the target type
	var d Meters = 3 // untyped 3 becomes Meters
	var u uint8 = 'x'

	send <- 1
	fmt.Println(b, raw, r != nil, <-ch, p, m, d, u)
	fmt.Printf("%T %T\n", ids, raw)
}

1 [1 2 3] true 1 <nil> map[] 3 120
main.IDs []int

package main

type IDs []int
type Handles []int

type Shelf interface{ Len() int }

func main() {
	var a IDs = IDs{1}
	var b Handles = a
	var s Shelf = a
	ch := make(<-chan int)
	var back chan int = ch
	_, _, _ = b, s, back
}

# example.com/shelf/ref/err/assign-fail
./main.go:10:18: cannot use a (variable of slice type IDs) as Handles value in variable declaration
./main.go:11:16: cannot use a (variable of slice type IDs) as Shelf value in variable declaration: IDs does not implement Shelf (missing method Len)
./main.go:13:22: cannot use ch (variable of type <-chan int) as chan int value in variable declaration

package main

func main() {
	x := nil
	var n int = nil
	_, _ = x, n
}

# example.com/shelf/ref/err/nil-untyped
./main.go:4:7: use of untyped nil in assignment
./main.go:5:14: cannot use nil as int value in variable declaration

package main

import (
	"fmt"
	"unsafe"
)

type Loose struct {
	Active bool  // 1 byte, then 7 bytes of padding
	ID     int64 // 8
	Copies int8  // 1, then 7 bytes of tail padding
}

type Tight struct {
	ID     int64 // 8
	Active bool  // 1
	Copies int8  // 1, then 6 bytes of tail padding
}

func main() {
	var l Loose
	var t Tight
	fmt.Println(unsafe.Sizeof(l), unsafe.Alignof(l), unsafe.Sizeof(t), unsafe.Alignof(t))
	fmt.Println(unsafe.Offsetof(l.Active), unsafe.Offsetof(l.ID), unsafe.Offsetof(l.Copies))
	fmt.Println(unsafe.Offsetof(t.ID), unsafe.Offsetof(t.Active), unsafe.Offsetof(t.Copies))
	fmt.Println(unsafe.Sizeof(struct{}{}), unsafe.Sizeof([0]int{}), unsafe.Sizeof([3]int16{}))
	fmt.Println(unsafe.Alignof(int8(0)), unsafe.Alignof(int32(0)), unsafe.Alignof(int64(0)), unsafe.Alignof(""), unsafe.Alignof(complex128(0)))
	const size = unsafe.Sizeof(l) // a compile-time constant of type uintptr
	var buf [size]byte
	fmt.Println(len(buf))
}

24 8 16 8
0 8 16
0 8 9
0 0 6
1 4 8 8 8
24