Operators and Expressions

package main

import (
	"fmt"
	"math"
)

func main() {
	// Integer division truncates toward zero; the remainder takes the sign
	// of the dividend, so (a/b)*b + a%b == a always holds.
	for _, p := range [][2]int{{7, 2}, {-7, 2}, {7, -2}, {-7, -2}} {
		a, b := p[0], p[1]
		fmt.Printf("%2d / %2d = %2d   %2d %% %2d = %2d\n", a, b, a/b, a, b, a%b)
	}

	// Integer overflow wraps around silently at run time.
	var small int8 = math.MaxInt8
	small++
	var u uint8
	u--
	fmt.Println("int8 127+1 =", small, " uint8 0-1 =", u)

	// The one signed division that overflows: MinInt64 / -1 does not panic.
	m, minus1 := int64(math.MinInt64), int64(-1)
	fmt.Println("MinInt64 / -1 =", m/minus1, " MinInt64 % -1 =", m%minus1)

	// Floating point follows IEEE 754: no panic on division by zero.
	zero := 0.0
	fmt.Println(1/zero, -1/zero, zero/zero, zero/zero == zero/zero)

	// Complex numbers support + - * / and ==.
	c := complex(1, 2) * complex(3, -1)
	fmt.Println(c, real(c), imag(c))

	// Integer division by zero is a run-time panic.
	defer func() { fmt.Println("recovered:", recover()) }()
	d := 0
	fmt.Println(10 / d)
}

 7 /  2 =  3    7 %  2 =  1
-7 /  2 = -3   -7 %  2 = -1
 7 / -2 = -3    7 % -2 =  1
-7 / -2 =  3   -7 % -2 = -1
int8 127+1 = -128  uint8 0-1 = 255
MinInt64 / -1 = -9223372036854775808  MinInt64 % -1 = 0
+Inf -Inf NaN false
(5+5i) 5 5
recovered: runtime error: integer divide by zero

package main

import "fmt"

func main() {
	fmt.Println(10 / 0)
}

main.go:6:19: invalid operation: division by zero

package main

import (
	"fmt"
	"math"
)

func main() {
	var i int32 = math.MaxInt32 + 1
	var u uint = -1
	var b byte = 255 + 1
	fmt.Println(i, u, b, 5.5%2)
}

main.go:9:16: cannot use math.MaxInt32 + 1 (untyped int constant 2147483648) as int32 value in variable declaration (overflows)
main.go:10:15: cannot use -1 (untyped int constant) as uint value in variable declaration (overflows)
main.go:11:15: cannot use 255 + 1 (untyped int constant 256) as byte value in variable declaration (overflows)
main.go:12:23: invalid operation: operator % not defined on 5.5 (untyped float constant)

package main

import "fmt"

func main() {
	const a, b uint8 = 0b1100_1010, 0b1010_0110
	fmt.Printf("a      %08b\n", a)
	fmt.Printf("b      %08b\n", b)
	fmt.Printf("a & b  %08b  (AND)\n", a&b)
	fmt.Printf("a | b  %08b  (OR)\n", a|b)
	fmt.Printf("a ^ b  %08b  (XOR)\n", a^b)
	fmt.Printf("a &^ b %08b  (AND NOT, bit clear)\n", a&^b)
	fmt.Printf("^a     %08b  (unary ^ is bitwise NOT)\n", ^a)
	fmt.Printf("-5 as ^4: %d, ^0 = %d\n", ^4, ^0)

	// Shifts: left fills with zeros; right shift of a signed value copies the
	// sign bit (arithmetic shift); of an unsigned value it fills with zeros.
	var s int8 = -16
	var us uint8 = 240
	fmt.Println(s>>2, us>>2, s<<1, us<<1)

	// A shift count at or beyond the width gives 0 (or -1 for a negative signed value).
	var n uint = 70
	fmt.Println(uint64(1)<<n, int64(-8)>>n, int64(8)>>n)

	// Since Go 1.13 the shift count may be a signed integer.
	// A negative count panics at run time.
	k := 3
	fmt.Println(1<<k, 256>>k)
	defer func() { fmt.Println("recovered:", recover()) }()
	k = -1
	fmt.Println(1 << k)
}

a      11001010
b      10100110
a & b  10000010  (AND)
a | b  11101110  (OR)
a ^ b  01101100  (XOR)
a &^ b 01001000  (AND NOT, bit clear)
^a     00110101  (unary ^ is bitwise NOT)
-5 as ^4: -5, ^0 = -1
-4 60 -32 224
0 -1 0
8 32
recovered: runtime error: negative shift amount

package main

import "fmt"

func main() {
	var s uint = 33

	// An untyped constant in a non-constant shift takes the type it would
	// have if the shift were replaced by its left operand alone.
	var a int32 = 1 << s // 1 is an int32 here: 1<<33 overflows to 0
	var b int64 = 1 << s // 1 is an int64 here
	var c = 1 << s       // 1 is an int
	fmt.Println(a, b, c)
	fmt.Printf("%T %T %T\n", a, b, c)

	// In a constant shift the operands are exact; the result stays untyped.
	const big = 1 << 100
	fmt.Println(big >> 98)
}

0 8589934592 8589934592
int32 int64 int
4

package main

import "fmt"

func main() {
	var s uint = 3
	var f float64 = 1 << s
	fmt.Println(f)
	fmt.Println(1 << -1)
}

main.go:7:18: invalid operation: shifted operand 1 (type float64) must be integer
main.go:9:19: invalid operation: negative shift count -1 (untyped int constant)

package main

import (
	"fmt"
	"math"
	"strings"
)

type ISBN string

type Loan struct {
	Book   ISBN
	Member string
	Days   int
}

type Point [2]int

func main() {
	// Numbers, strings, booleans, pointers, channels, interfaces, structs of
	// comparable fields and arrays of comparable elements are comparable.
	l1 := Loan{"9780134190440", "ada", 14}
	l2 := Loan{"9780134190440", "ada", 14}
	fmt.Println("structs:", l1 == l2, l1 != Loan{})
	fmt.Println("arrays: ", Point{1, 2} == Point{1, 2}, [3]string{"a"} == [3]string{"a", "", ""})
	fmt.Println("pointers:", &l1 == &l1, &l1 == &l2)

	// Strings are ordered byte-wise; compare with < <= > >=.
	fmt.Println("strings:", "Go" < "Rust", "apple" < "Apple", "é" > "z", strings.Compare("a", "b"))

	// NaN is unordered: every comparison with it is false except !=.
	nan := math.NaN()
	fmt.Println("NaN:", nan == nan, nan < 1, nan > 1, nan != nan)

	// Interface values are equal when dynamic types and values are equal.
	var a, b any = 1, 1
	var c any = int64(1)
	var n1, n2 any
	fmt.Println("interfaces:", a == b, a == c, n1 == n2, a == nil)

	// Comparison of an interface with a concrete value converts the value.
	fmt.Println("mixed:", a == 1, a == int64(1), c == 1)

	// A map key or == on interface values holding uncomparable dynamic
	// types panics at run time.
	defer func() { fmt.Println("recovered:", recover()) }()
	var x, y any = []int{1}, []int{1}
	fmt.Println(x == y)
}

structs: true true
arrays:  true true
pointers: true false
strings: true false true -1
NaN: false false false true
interfaces: true false true false
mixed: true false false
recovered: runtime error: comparing uncomparable type []int

package main

import "fmt"

type Book struct {
	Title   string
	Authors []string
}

func main() {
	a, b := []int{1}, []int{1}
	fmt.Println(a == b)

	m1, m2 := map[string]int{}, map[string]int{}
	fmt.Println(m1 == m2)

	f := func() {}
	fmt.Println(f == f)

	b1, b2 := Book{}, Book{}
	fmt.Println(b1 == b2)

	set := map[Book]bool{}
	fmt.Println(set)
}

main.go:12:14: invalid operation: a == b (slice can only be compared to nil)
main.go:15:14: invalid operation: m1 == m2 (map can only be compared to nil)
main.go:18:14: invalid operation: f == f (func can only be compared to nil)
main.go:21:14: invalid operation: b1 == b2 (struct containing []string cannot be compared)
main.go:23:13: invalid map key type Book

package main

import "fmt"

type ISBN string

func main() {
	var i int = 1
	var f float64 = 1
	var n int64 = 1
	var isbn ISBN = "x"
	fmt.Println(i == f)
	fmt.Println(i == n)
	fmt.Println(isbn == "x", isbn == string("x"))
	var s string = "x"
	fmt.Println(isbn == s)
	fmt.Println(i == nil)
	fmt.Println(true < false)
}

main.go:12:19: invalid operation: i == f (mismatched types int and float64)
main.go:13:19: invalid operation: i == n (mismatched types int and int64)
main.go:14:35: invalid operation: isbn == string("x") (mismatched types ISBN and string)
main.go:16:22: invalid operation: isbn == s (mismatched types ISBN and string)
main.go:17:19: invalid operation: i == nil (mismatched types int and untyped nil)
main.go:18:14: invalid operation: true < false (operator < not defined on untyped bool)

package main

import "fmt"

func check(name string, v bool) bool {
	fmt.Println("  evaluated", name)
	return v
}

func main() {
	fmt.Println("false && ...:")
	_ = check("A", false) && check("B", true) // B is skipped

	fmt.Println("true || ...:")
	_ = check("C", true) || check("D", false) // D is skipped

	fmt.Println("mixed, && binds tighter than ||:")
	r := check("E", false) || check("F", true) && check("G", true)
	fmt.Println("result:", r)

	// Typical use: a guard before a dereference or an index.
	var names []string
	if len(names) > 0 && names[0] == "Ada" {
		fmt.Println("found")
	}
	fmt.Println(!true, !(1 > 2))
}

false && ...:
  evaluated A
true || ...:
  evaluated C
mixed, && binds tighter than ||:
  evaluated E
  evaluated F
  evaluated G
result: true
false true

package main

import "fmt"

type Book struct {
	ISBN  string
	Title string
}

func main() {
	b := Book{"9780134190440", "The Go Programming Language"}
	p := &b // address-of: p has type *Book
	p.Title = "TGPL"
	fmt.Println(b.Title, (*p).Title == p.Title)

	// A composite literal is the one non-variable operand &x accepts.
	q := &Book{ISBN: "1"}
	n := &[]int{1, 2}
	fmt.Println(q.ISBN, *n)

	// *p dereferences; *p = v stores through the pointer.
	x := 1
	px := &x
	*px += 41
	fmt.Println(x, *px)

	// new(expr) (Go 1.26) allocates a variable initialised with a value.
	ptr := new(int64(5))
	fmt.Println(*ptr)

	// Receive: <-ch is an expression; ch <- v is a statement.
	ch := make(chan int, 1)
	ch <- 7
	v, ok := <-ch
	fmt.Println(v, ok)
	close(ch)
	v, ok = <-ch
	fmt.Println(v, ok)

	// A nil pointer dereference panics at run time.
	defer func() { fmt.Println("recovered:", recover()) }()
	var np *Book
	fmt.Println(np.Title)
}

TGPL true
1 [1 2]
42 42
5
7 true
0 false
recovered: runtime error: invalid memory address or nil pointer dereference

package main

func f() int { return 1 }

func main() {
	m := map[string]int{"a": 1}
	_ = &m["a"]
	_ = &f()
	_ = &"literal"
	c := make(chan int)
	var r <-chan int = c
	r <- 1
	_ = *m
}

main.go:7:7: invalid operation: cannot take address of m["a"] (map index expression of type int)
main.go:8:7: invalid operation: cannot take address of f() (value of type int)
main.go:9:7: invalid operation: cannot take address of "literal" (untyped string constant)
main.go:12:2: invalid operation: cannot send to receive-only channel <-chan int r (variable of type <-chan int)
main.go:13:7: invalid operation: cannot indirect m (variable of type map[string]int)

package main

import "fmt"

func main() {
	i := 0
	j := i++
	fmt.Println(j)
}

main.go:7:8: syntax error: unexpected ++ at end of statement

package main

import "fmt"

func main() {
	i := 0
	++i
	fmt.Println(i)
}

main.go:7:2: syntax error: unexpected ++, expected }

package main

import "fmt"

func main() {
	// ++ and -- are statements, not expressions; only the postfix form exists.
	i := 0
	i++
	i += 10
	i <<= 2
	i %= 7
	fmt.Println(i)

	// Tuple assignment: all right-hand operands (and index/pointer operands
	// on the left) are evaluated first, then the assignments happen.
	a, b := 1, 2
	a, b = b, a
	fmt.Println(a, b)

	x, y := 0, 1
	for range 10 {
		x, y = y, x+y
	}
	fmt.Println("fib:", x)

	// The spec's example: the index i is evaluated before i is assigned.
	s := []int{10, 20, 30}
	j := 0
	j, s[j] = 1, 99
	fmt.Println(j, s)

	// Swap slice elements and a map entry.
	s[0], s[2] = s[2], s[0]
	m := map[string]int{"a": 1, "b": 2}
	m["a"], m["b"] = m["b"], m["a"]
	fmt.Println(s, m)

	// The blank identifier discards a value.
	_, err := fmt.Sscanf("7", "%d", &i)
	fmt.Println(i, err)

	// Compound assignment evaluates its left operand once.
	idx := 0
	next := func() int { idx++; return idx - 1 }
	t := []int{1, 1, 1}
	t[next()] += 5
	fmt.Println(t, idx)
}

2
2 1
fib: 55
1 [99 20 30]
[30 20 99] map[a:2 b:1]
7 <nil>
[6 1 1] 1

package main

import "fmt"

func main() {
	a, b := 1, 2
	a, b := 3, 4
	var c int
	c, d := 5
	if x = 3; x > 0 {
	}
	fmt.Println(a, b, c, d)
}

main.go:7:7: no new variables on left side of :=
main.go:9:10: assignment mismatch: 2 variables but 1 value
main.go:10:5: undefined: x

package main

import "fmt"

func main() {
	x, y := 6, 3
	p, q, r := true, false, false

	// Precedence 5: * / % << >> & &^     Precedence 4: + - | ^
	fmt.Println("1+2*3     =", 1+2*3)
	fmt.Println("(1+2)*3   =", (1+2)*3)
	fmt.Println("1+2<<3    =", 1+2<<3, "  // 1 + (2<<3): << binds like *")
	fmt.Println("1<<2+1    =", 1<<2+1, "  // (1<<2) + 1")
	fmt.Println("x&y+1     =", x&y+1, "  // (x&y) + 1")
	fmt.Println("x|y == 7  =", x|y == 7, " // | is level 4, == is level 3")
	fmt.Println("x&1 == 0  =", x&1 == 0, " // & is level 5: no parentheses needed, unlike C")
	fmt.Println("-x*y      =", -x*y, "  // unary operators bind tightest")
	fmt.Println("^x&y      =", ^x&y)
	fmt.Println("p||q&&r  =", p || q && r, "  // p || (q && r): && is level 2, || is level 1")
}

1+2*3     = 7
(1+2)*3   = 9
1+2<<3    = 17   // 1 + (2<<3): << binds like *
1<<2+1    = 5   // (1<<2) + 1
x&y+1     = 3   // (x&y) + 1
x|y == 7  = true  // | is level 4, == is level 3
x&1 == 0  = true  // & is level 5: no parentheses needed, unlike C
-x*y      = -18   // unary operators bind tightest
^x&y      = 1
p||q&&r  = true   // p || (q && r): && is level 2, || is level 1

package main

import (
	"fmt"
	"math"
)

func main() {
	// min and max (Go 1.21) work on any ordered type, including strings.
	fmt.Println(min(3, 1, 2), max(2.5, 1), min("pear", "apple"))

	// If any argument is NaN the result is NaN; -0.0 is less than +0.0.
	fmt.Println(min(1.0, math.NaN()), max(math.Copysign(0, -1), 0))

	// Constant arguments give a constant result.
	const lim = min(10, 20, 5)
	var buf [lim]byte
	fmt.Println(len(buf))

	// clear (Go 1.21) empties a map or zeroes a slice's elements.
	m := map[string]int{"a": 1}
	s := []int{1, 2, 3}
	clear(m)
	clear(s[1:])
	fmt.Println(m, len(m), s)
}

1 2.5 apple
NaN 0
5
map[] 0 [1 0 0]

package main

import "fmt"

func trace(name string, v int) int {
	fmt.Print(name, " ")
	return v
}

func sum(args ...int) int {
	t := 0
	for _, a := range args {
		t += a
	}
	return t
}

func main() {
	// Function calls, method calls, receive operations and binary logical
	// operations are evaluated in lexical left-to-right order.
	r := trace("a", 1) + trace("b", 2)*trace("c", 3)
	fmt.Println("=", r)

	fmt.Print("args: ")
	fmt.Println("=", sum(trace("x", 1), trace("y", 2), trace("z", 3)))

	// The order of evaluation of a plain variable against a function call is
	// NOT specified. The spec says this may print either [1 2] or [2 2].
	a := 1
	f := func() int { a++; return a }
	x := []int{a, f()}
	fmt.Println("unspecified:", x)

	// Map index order relative to calls is unspecified too, but each
	// operand is evaluated exactly once.
	m := map[string]int{}
	m["k"] += trace("rhs", 5)
	fmt.Println(m)
}

a b c = 7
args: x y z = 6
unspecified: [2 2]
rhs map[k:5]

package main

import (
	"fmt"
	"strings"
	"testing"
)

var words = strings.Fields(strings.Repeat("shelf ", 100))

func plus() string {
	s := ""
	for _, w := range words {
		s += w + " "
	}
	return s
}

func builder() string {
	var sb strings.Builder
	sb.Grow(len(words) * 6)
	for _, w := range words {
		sb.WriteString(w)
		sb.WriteByte(' ')
	}
	return sb.String()
}

func join() string { return strings.Join(words, " ") }

func main() {
	const greeting = "Hello, " + "shelf" // constant expression: folded at compile time
	fmt.Println(greeting, len(greeting))

	fmt.Println(plus() == builder()+"", len(plus()))
	fmt.Println("allocs with +=:      ", testing.AllocsPerRun(20, func() { _ = plus() }))
	fmt.Println("allocs with Builder: ", testing.AllocsPerRun(20, func() { _ = builder() }))
	fmt.Println("allocs with Join:    ", testing.AllocsPerRun(20, func() { _ = join() }))
}

Hello, shelf 12
true 600
allocs with +=:       100
allocs with Builder:  1
allocs with Join:     1

package main

import (
	"fmt"
	"time"
)

func main() {
	n := 3
	fmt.Println(n * time.Second)
}

main.go:10:14: invalid operation: n * time.Second (mismatched types int and time.Duration)

package main

import (
	"fmt"
	"time"
)

func main() {
	n := 3
	// No operator overloading: Duration is an int64 and arithmetic is the
	// ordinary integer kind, so the operand types must match exactly.
	d := time.Duration(n) * time.Second
	fmt.Println(d, 2*time.Second, d+500*time.Millisecond, d/2)
	fmt.Println(d > time.Second, time.Duration(1.5*float64(time.Second)))
}

3s 2s 3.5s 1.5s
true 1.5s

package main

import "fmt"

func main() {
	var b byte = 1
	x := 3
	x = x
	fmt.Println(b<<8, x == 1 || x == 1)
	if x&1 == 0 || x&1 == 0 {
		fmt.Println("even")
	}
	var f func()
	fmt.Println(f == nil, fmt.Sprint)
}

main.go:8:2: self-assignment of x
main.go:9:20: redundant or: x == 1 || x == 1
main.go:10:5: redundant or: x&1 == 0 || x&1 == 0
main.go:14:2: fmt.Println arg fmt.Sprint is a func value, not called
main.go:9:14: b (8 bits) too small for shift of 8