Go Programming Language

https://go.dev/ref/spec
Admin
Go is a general-purpose programming language designed for systems programming with strong typing,...
Tokens:42,334
Snippets:544
Trust Score:10
Update:1 month ago
Show doc for...
Tokens:
Raw
### Execute goroutines

Source: https://go.dev/ref/spec

Examples of starting concurrent goroutines.

```go
go Server()
go func(ch chan<- bool) { for { sleep(10); ch <- true }} (c)
```

--------------------------------

### Method Set Implementation Example

Source: https://go.dev/ref/spec

Example methods that satisfy the File interface requirements.

```go
func (p T) Read(p []byte) (n int, err error)
func (p T) Write(p []byte) (n int, err error)
func (p T) Close() error
```

--------------------------------

### Operator Precedence Examples

Source: https://go.dev/ref/spec

Examples illustrating how operators associate and bind in expressions.

```go
+x                         // x
42 + a - b                 // (42 + a) - b
23 + 3*x[i]                // 23 + (3 * x[i])
x <= f()                   // x <= f()
^a >> b                    // (^a) >> b
f() || g()                 // f() || g()
x == y+1 && <-chanInt > 0  // (x == (y+1)) && ((<-chanInt) > 0)
```

--------------------------------

### Pointer Type Examples

Source: https://go.dev/ref/spec

Examples of pointer type declarations.

```go
*Point
*[4]int
```

--------------------------------

### Example Identifiers

Source: https://go.dev/ref/spec

Valid examples of Go identifiers.

```text
a
_x9
ThisVariableIsExported
αβ
```

--------------------------------

### Representability Examples

Source: https://go.dev/ref/spec

Examples demonstrating constants that are representable by specific types.

```text
x                   T           x is representable by a value of T because

'a'                 byte        97 is in the set of byte values
97                  rune        rune is an alias for int32, and 97 is in the set of 32-bit integers
"foo"               string      "foo" is in the set of string values
1024                int16       1024 is in the set of 16-bit integers
42.0                byte        42 is in the set of unsigned 8-bit integers
1e10                uint64      10000000000 is in the set of unsigned 64-bit integers
2.718281828459045   float32     2.7182817 which is in the set of float32 values
-1e-1000            float64     -1e-1000 rounds to IEEE -0.0 which is further simplified to 0.0
0i                  int         0 is an integer value
(42 + 0i)           float32     42.0 (with zero imaginary part) is in the set of float32 values
```

--------------------------------

### Defer Statement Usage Examples

Source: https://go.dev/ref/spec

Examples demonstrating basic defer usage, deferred execution order in loops, and modification of named result parameters.

```Go
lock(l)
defer unlock(l)  // unlocking happens before surrounding function returns

// prints 3 2 1 0 before surrounding function returns
for i := 0; i <= 3; i++ {
	defer fmt.Print(i)
}

// f returns 42
func f() (result int) {
	defer func() {
		// result is accessed after it was set to 6 by the return statement
		result *= 7
	}()
	return 6
}
```

--------------------------------

### Alias Declaration Examples

Source: https://go.dev/ref/spec

Examples of creating type aliases for existing types.

```go
type (
	nodeList = []*Node  // nodeList and []*Node are identical types
	Polar    = polar    // Polar and polar denote identical types
)
```

--------------------------------

### Shift Expression Examples

Source: https://go.dev/ref/spec

Examples demonstrating how untyped constants behave in shift expressions across 64-bit and 32-bit architectures.

```go
var a [1024]byte
var s uint = 33

// The results of the following examples are given for 64-bit ints.
var i = 1<<s                   // 1 has type int
var j int32 = 1<<s             // 1 has type int32; j == 0
var k = uint64(1<<s)           // 1 has type uint64; k == 1<<33
var m int = 1.0<<s             // 1.0 has type int; m == 1<<33
var n = 1.0<<s == j            // 1.0 has type int32; n == true
var o = 1<<s == 2<<s           // 1 and 2 have type int; o == false
var p = 1<<s == 1<<33          // 1 has type int; p == true
var u = 1.0<<s                 // illegal: 1.0 has type float64, cannot shift
var u1 = 1.0<<s != 0           // illegal: 1.0 has type float64, cannot shift
var u2 = 1<<s != 1.0           // illegal: 1 has type float64, cannot shift
var v1 float32 = 1<<s          // illegal: 1 has type float32, cannot shift
var v2 = string(1<<s)          // illegal: 1 is converted to a string, cannot shift
var w int64 = 1.0<<33          // 1.0<<33 is a constant shift expression; w == 1<<33
var x = a[1.0<<s]              // panics: 1.0 has type int, but 1<<33 overflows array bounds
var b = make([]byte, 1.0<<s)   // 1.0 has type int; len(b) == 1<<33

// The results of the following examples are given for 32-bit ints,
// which means the shifts will overflow.
var mm int = 1.0<<s            // 1.0 has type int; mm == 0
var oo = 1<<s == 2<<s          // 1 and 2 have type int; oo == true
var pp = 1<<s == 1<<33         // illegal: 1 has type int, but 1<<33 overflows int
var xx = a[1.0<<s]             // 1.0 has type int; xx == a[0]
var bb = make([]byte, 1.0<<s)  // 1.0 has type int; len(bb) == 0
```

--------------------------------

### Example Package Clause

Source: https://go.dev/ref/spec

A simple declaration of a package named math.

```go
package math
```

--------------------------------

### Function Type Examples

Source: https://go.dev/ref/spec

Various examples of function signatures, including variadic parameters and multiple return values.

```go
func()
func(x int) int
func(a, _ int, z float32) bool
func(a, b int, z float32) (bool)
func(prefix string, values ...int)
func(a, b int, z float64, opt ...interface{}) (success bool)
func(int, int, float64) (float64, *[]int)
func(n int) func(p *T)
```

--------------------------------

### Complex Number Manipulation Examples

Source: https://go.dev/ref/spec

Examples demonstrating the creation of complex numbers and extraction of their real and imaginary components.

```go
var a = complex(2, -2)             // complex128
const b = complex(1.0, -1.4)       // untyped complex constant 1 - 1.4i
x := float32(math.Cos(math.Pi/2))  // float32
var c64 = complex(5, -x)           // complex64
var s int = complex(1, 0)          // untyped complex constant 1 + 0i can be converted to int
_ = complex(1, 2<<s)               // illegal: 2 assumes floating-point type, cannot shift
var rl = real(c64)                 // float32
var im = imag(a)                   // float64
const c = imag(b)                  // untyped constant -1.4
_ = imag(3 << s)                   // illegal: 3 assumes complex type, cannot shift
```

--------------------------------

### Integer Literal Examples

Source: https://go.dev/ref/spec

Various valid and invalid integer literal examples.

```go
42
4_2
0600
0_600
0o600
0O600       // second character is capital letter 'O'
0xBadFace
0xBad_Face
0x_67_7a_2f_cc_40_c6
170141183460469231731687303715884105727
170_141183_460469_231731_687303_715884_105727

_42         // an identifier, not an integer literal
42_         // invalid: _ must separate successive digits
4__2        // invalid: only one _ at a time
0_xBadFace  // invalid: _ must separate successive digits
```

--------------------------------

### Map Type Examples

Source: https://go.dev/ref/spec

Examples of map declarations with various key and element types.

```go
map[string]int
map[*T]struct{ x, y float64 }
map[string]interface{}
```

--------------------------------

### Integer Division and Remainder Examples

Source: https://go.dev/ref/spec

Examples showing truncated division behavior for various integer inputs.

```text
 x     y     x / y     x % y
 5     3       1         2
-5     3      -1        -2
 5    -3      -1         2
-5    -3       1        -2
```

--------------------------------

### Basic Assignment Examples

Source: https://go.dev/ref/spec

Demonstrates standard variable assignment and parenthesized expressions.

```Go
x = 1
*p = f()
a[i] = 23
(k) = <-ch  // same as: k = <-ch
```

--------------------------------

### Generic instantiation examples

Source: https://go.dev/ref/spec

Illustrates the substitution of type arguments for type parameters and constraint satisfaction.

```go
type parameter list    type arguments    after substitution

[P any]                int               int satisfies any
[S ~[]E, E any]        []int, int        []int satisfies ~[]int, int satisfies any
[P io.Writer]          string            illegal: string doesn't satisfy io.Writer
[P comparable]         any               any satisfies (but does not implement) comparable
```

--------------------------------

### Pointer and uintptr conversion examples

Source: https://go.dev/ref/spec

Demonstrates converting between unsafe.Pointer and uintptr, and using type parameters with pointers.

```go
var f float64
bits = *(*uint64)(unsafe.Pointer(&f))

type ptr unsafe.Pointer
bits = *(*uint64)(ptr(&f))

func f[P ~*B, B any](p P) uintptr {
	return uintptr(unsafe.Pointer(p))
}

var p ptr = nil
```

--------------------------------

### Type Constraint Satisfaction Examples

Source: https://go.dev/ref/spec

Examples illustrating whether specific types satisfy given type constraints based on Go's type set rules.

```go
type argument      type constraint                // constraint satisfaction

int                interface{ ~int }              // satisfied: int implements interface{ ~int }
string             comparable                     // satisfied: string implements comparable (string is strictly comparable)
[]byte             comparable                     // not satisfied: slices are not comparable
any                interface{ comparable; int }   // not satisfied: any does not implement interface{ int }
any                comparable                     // satisfied: any is comparable and implements the basic interface any
struct{f any}      comparable                     // satisfied: struct{f any} is comparable and implements the basic interface any
any                interface{ comparable; m() }   // not satisfied: any does not implement the basic interface interface{ m() }
interface{ m() }   interface{ comparable; m() }   // satisfied: interface{ m() } is comparable and implements the basic interface interface{ m() }
```

--------------------------------

### Locker Interface Implementation

Source: https://go.dev/ref/spec

Example methods that satisfy the Locker interface.

```go
func (p T) Lock() { … }
func (p T) Unlock() { … }
```

--------------------------------

### Examples of make function usage

Source: https://go.dev/ref/spec

Demonstrates valid and invalid ways to initialize slices, channels, and maps using make.

```go
s := make([]int, 10, 100)       // slice with len(s) == 10, cap(s) == 100
s := make([]int, 1e3)           // slice with len(s) == cap(s) == 1000
s := make([]int, 1<<63)         // illegal: len(s) is not representable by a value of type int
s := make([]int, 10, 0)         // illegal: len(s) > cap(s)
c := make(chan int, 10)         // channel with a buffer size of 10
m := make(map[string]int, 100)  // map with initial space for approximately 100 elements
```

--------------------------------

### Type Definition Examples

Source: https://go.dev/ref/spec

Examples of creating new, distinct types using type definitions.

```go
type (
	Point struct{ x, y float64 }  // Point and struct{ x, y float64 } are different types
	polar Point                   // polar and Point denote different types
)

type TreeNode struct {
	left, right *TreeNode
	value any
}

type Block interface {
	BlockSize() int
	Encrypt(src, dst []byte)
	Decrypt(src, dst []byte)
}
```

--------------------------------

### Assignment Operation Examples

Source: https://go.dev/ref/spec

Demonstrates compound assignment operators.

```Go
a[i] <<= 2
i &^= 1<<n
```

--------------------------------

### Array Type Examples

Source: https://go.dev/ref/spec

Examples of various array type declarations including multi-dimensional arrays.

```go
[32]byte
[2*N] struct { x, y int32 }
[1000]*float64
[3][5]int
[2][2][2]float64  // same as [2]([2]([2]float64))
```

--------------------------------

### Package variable initialization order

Source: https://go.dev/ref/spec

Example demonstrating how dependency analysis determines the initialization sequence of package-level variables.

```go
var (
	a = c + b  // == 9
	b = f()    // == 4
	c = f()    // == 5
	d = 3      // == 5 after initialization has finished
)

func f() int {
	d++
	return d
}
```

--------------------------------

### Function and Method Invocation

Source: https://go.dev/ref/spec

Examples of calling standard functions and methods on pointers.

```go
math.Atan2(x, y)  // function call
var pt *Point
pt.Scale(3.5)     // method call with receiver pt
```

--------------------------------

### Example of a labeled statement

Source: https://go.dev/ref/spec

A simple example of a labeled statement using a panic call.

```go
Error: log.Panic("error encountered")
```

--------------------------------

### Floating-point literal examples

Source: https://go.dev/ref/spec

Examples of valid and invalid floating-point literal syntax in Go.

```go
0.
72.40
072.40       // == 72.40
2.71828
1.e+0
6.67428e-11
1E6
.25
.12345E+5
1_5.         // == 15.0
0.15e+0_2    // == 15.0

0x1p-2       // == 0.25
0x2.p10      // == 2048.0
0x1.Fp+0     // == 1.9375
0X.8p-0      // == 0.5
0X_1FFFP-16  // == 0.1249847412109375
0x15e-2      // == 0x15e - 2 (integer subtraction)

0x.p1        // invalid: mantissa has no digits
1p-2         // invalid: p exponent requires hexadecimal mantissa
0x1.5e-2     // invalid: hexadecimal mantissa requires p exponent
1_.5         // invalid: _ must separate successive digits
1._5         // invalid: _ must separate successive digits
1.5_e1       // invalid: _ must separate successive digits
1.5e_1       // invalid: _ must separate successive digits
1.5e1_       // invalid: _ must separate successive digits
```

--------------------------------

### Type Assertion Examples

Source: https://go.dev/ref/spec

Examples demonstrating successful assertions, illegal assertions, and interface type assertions.

```go
var x interface{} = 7          // x has dynamic type int and value 7
i := x.(int)                   // i has type int and value 7

type I interface { m() }

func f(y I) {
	s := y.(string)        // illegal: string does not implement I (missing method m)
	r := y.(io.Reader)     // r has type io.Reader and the dynamic type of y must implement both I and io.Reader
	…
}
```

--------------------------------

### Rune Literal Examples

Source: https://go.dev/ref/spec

Examples of valid and illegal rune literal declarations.

```go
'a'
'ä'
'本'
'\t'
'\000'
'\007'
'\377'
'\x07'
'\xff'
'\u12e4'
'\U00101234'
'\''         // rune literal containing single quote character
'aa'         // illegal: too many characters
'\k'         // illegal: k is not recognized after a backslash
'\xa'        // illegal: too few hexadecimal digits
'\0'         // illegal: too few octal digits
'\400'       // illegal: octal value over 255
'\uDFFF'     // illegal: surrogate half
'\U00110000' // illegal: invalid Unicode code point
```

--------------------------------

### Constant Declaration Examples

Source: https://go.dev/ref/spec

Examples of typed and untyped constant declarations, including single and grouped declarations.

```go
const Pi float64 = 3.14159265358979323846
const zero = 0.0         // untyped floating-point constant
const (
	size int64 = 1024
	eof        = -1  // untyped integer constant
)
const a, b, c = 3, 4, "foo"  // a = 3, b = 4, c = "foo", untyped integer and string constants
const u, v float32 = 0, 3    // u = 0.0, v = 3.0
```

--------------------------------

### Tuple Assignment Examples

Source: https://go.dev/ref/spec

Demonstrates assigning multiple values to multiple variables.

```Go
x, y = f()
```

```Go
one, two, three = '一', '二', '三'
```

--------------------------------

### String Literal Examples

Source: https://go.dev/ref/spec

Various examples demonstrating raw and interpreted string literals, including escape sequences and illegal characters.

```go
`abc`                // same as "abc"
`\n
\n`                  // same as "\\n\n\\n"
"\n"
"\""                 // same as `"`
"Hello, world!\n"
"日本語"
"\u65e5本\U00008a9e"
"\xff\u00FF"
"\uD800"             // illegal: surrogate half
"\U00110000"         // illegal: invalid Unicode code point
```

--------------------------------

### Basic array slicing

Source: https://go.dev/ref/spec

Example of slicing an array and verifying the resulting slice properties.

```go
a := [5]int{1, 2, 3, 4, 5}
s := a[1:4]
```

```go
s[0] == 2
s[1] == 3
s[2] == 4
```

--------------------------------

### Declare Type Parameters

Source: https://go.dev/ref/spec

Examples of valid type parameter list declarations.

```go
[P any]
[S interface{ ~[]byte|string }]
[S ~[]E, E any]
[P Constraint[int]]
[_ any]
```

--------------------------------

### For Loop Examples

Source: https://go.dev/ref/spec

Basic usage of for loops with a single condition and a full for-clause.

```go
for a < b {
	a *= 2
}
```

```go
for i := 0; i < 10; i++ {
	f(i)
}
```

--------------------------------

### Use select statements

Source: https://go.dev/ref/spec

Examples of channel communication using select, including blocking and default cases.

```go
var a []int
var c, c1, c2, c3, c4 chan int
var i1, i2 int
select {
case i1 = <-c1:
	print("received ", i1, " from c1\n")
case c2 <- i2:
	print("sent ", i2, " to c2\n")
case i3, ok := (<-c3):  // same as: i3, ok := <-c3
	if ok {
		print("received ", i3, " from c3\n")
	} else {
		print("c3 is closed\n")
	}
case a[f()] = <-c4:
	// same as:
	// case t := <-c4
	//	a[f()] = t
default:
	print("no communication\n")
}

for {  // send random sequence of bits to c
	select {
	case c <- 0:  // note: no statement, no fallthrough, no folding of cases
	case c <- 1:
	}
}

select {}  // block forever
```

--------------------------------

### Imaginary literal examples

Source: https://go.dev/ref/spec

Examples demonstrating the usage of imaginary literals, including backward-compatible integer-based literals.

```go
0i
0123i         // == 123i for backward-compatibility
0o123i        // == 0o123 * 1i == 83i
0xabci        // == 0xabc * 1i == 2748i
0.i
2.71828i
1.e+0i
6.67428e-11i
1E6i
.25i
.12345E+5i
0x1p-2i       // == 0x1p-2 * 1i == 0.25i
```

--------------------------------

### Examples of min and max functions

Source: https://go.dev/ref/spec

Shows usage of min and max with various ordered types and constants.

```go
var x, y int
m := min(x)                 // m == x
m := min(x, y)              // m is the smaller of x and y
m := max(x, y, 10)          // m is the larger of x and y but at least 10
c := max(1, 2.0, 10)        // c == 10.0 (floating-point kind)
f := max(0, float32(x))     // type of f is float32
var s []string
_ = min(s...)               // invalid: slice arguments are not permitted
t := max("", "foo", "bar")  // t == "foo" (string kind)
```

--------------------------------

### Use return statement

Source: https://go.dev/ref/spec

Example of a function returning without a value.

```go
func noResult() {
	return
}
```

--------------------------------

### Method Expression Example

Source: https://go.dev/ref/spec

Deriving a function from a method.

```go
T.Mv
```

--------------------------------

### Evaluate Comparable Interface Implementation

Source: https://go.dev/ref/spec

Examples showing which types implement the comparable interface.

```go
int                          // implements comparable (int is strictly comparable)
[]byte                       // does not implement comparable (slices cannot be compared)
interface{}                  // does not implement comparable (see above)
interface{ ~int | ~string }  // type parameter only: implements comparable (int, string types are strictly comparable)
interface{ comparable }      // type parameter only: implements comparable (comparable implements itself)
interface{ ~int | ~[]byte }  // type parameter only: does not implement comparable (slices are not comparable)
interface{ ~struct{ any } }  // type parameter only: does not implement comparable (field any is not strictly comparable)
```

--------------------------------

### Type Equation Example

Source: https://go.dev/ref/spec

A basic example of a type equation involving a bound type parameter P that is resolved through unification.

```text
	[10]struct{ elem P, list []P } ≡A [10]struct{ elem string; list []string }
```

--------------------------------

### Iterating with Range

Source: https://go.dev/ref/spec

Examples demonstrating range iteration over arrays, maps, channels, integers, and functions.

```go
var testdata *struct {
	a *[7]int
}
for i, _ := range testdata.a {
	// testdata.a is never evaluated; len(testdata.a) is constant
	// i ranges from 0 to 6
	f(i)
}

var a [10]string
for i, s := range a {
	// type of i is int
	// type of s is string
	// s == a[i]
	g(i, s)
}

var key string
var val interface{}  // element type of m is assignable to val
m := map[string]int{"mon":0, "tue":1, "wed":2, "thu":3, "fri":4, "sat":5, "sun":6}
for key, val = range m {
	h(key, val)
}
// key == last map key encountered in iteration
// val == map[key]

var ch chan Work = producer()
for w := range ch {
	doWork(w)
}

// empty a channel
for range ch {}

// call f(0), f(1), ... f(9)
for i := range 10 {
	// type of i is int (default type for untyped constant 10)
	f(i)
}

// invalid: 256 cannot be assigned to uint8
var u uint8
for u = range 256 {
}

// invalid: 1e3 is a floating-point constant
for range 1e3 {
}

// fibo generates the Fibonacci sequence
fibo := func(yield func(x int) bool) {
	f0, f1 := 0, 1
	for yield(f0) {
		f0, f1 = f1, f0+f1
	}
}
```

--------------------------------

### Basic Interface Definition

Source: https://go.dev/ref/spec

Example of a basic interface specifying methods for file operations.

```go
// A simple File interface.
interface {
	Read([]byte) (int, error)
	Write([]byte) (int, error)
	Close() error
}
```

--------------------------------

### Copy slice elements

Source: https://go.dev/ref/spec

Examples demonstrating how to copy elements between slices and from a string to a byte slice.

```go
var a = [...]int{0, 1, 2, 3, 4, 5, 6, 7}
var s = make([]int, 6)
var b = make([]byte, 5)
n1 := copy(s, a[0:])            // n1 == 6, s is []int{0, 1, 2, 3, 4, 5}
n2 := copy(s, s[2:])            // n2 == 4, s is []int{2, 3, 4, 5, 4, 5}
n3 := copy(b, "Hello, World!")  // n3 == 5, b is []byte("Hello")
```

--------------------------------

### Define Struct Types

Source: https://go.dev/ref/spec

Example struct declarations used for demonstrating literal initialization.

```go
type Object  struct { name, color string }
type Point3D struct { Object; x, y, z float64 }
type Line    struct { Object; p, q Point3D }
```

--------------------------------

### Basic Struct Declarations

Source: https://go.dev/ref/spec

Examples of empty structs and structs with multiple fields, including padding.

```go
// An empty struct.
struct {}

// A struct with 6 fields.
struct {
	x, y int
	u float32
	_ float32  // padding
	A *[]int
	F func()
}
```

--------------------------------

### Define array, slice, and map literals

Source: https://go.dev/ref/spec

Examples of initializing various collection types with specific values and indices.

```go
// list of prime numbers
primes := []int{2, 3, 5, 7, 9, 2147483647}

// vowels[ch] is true if ch is a vowel
vowels := [128]bool{'a': true, 'e': true, 'i': true, 'o': true, 'u': true, 'y': true}

// the array [10]float32{-1, 0, 0, 0, -0.1, -0.1, 0, 0, 0, -1}
filter := [10]float32{-1, 4: -0.1, -0.1, 9: -1}

// frequencies in Hz for equal-tempered scale (A4 = 440Hz)
noteFrequency := map[string]float32{
	"C0": 16.35, "D0": 18.35, "E0": 20.60, "F0": 21.83,
	"G0": 24.50, "A0": 27.50, "B0": 30.87,
}
```

--------------------------------

### Selector Expression Declarations

Source: https://go.dev/ref/spec

Example struct and method declarations used to demonstrate selector behavior.

```go
type T0 struct {
	x int
}

func (*T0) M0()

type T1 struct {
	y int
}

func (T1) M1()

type T2 struct {
	z int
	T1
	*T0
}

func (*T2) M2()

type Q *T2

var t T2     // with t.T0 != nil
var p *T2    // with p != nil and (*p).T0 != nil
var q Q = p
```

--------------------------------

### Method Call Addressability

Source: https://go.dev/ref/spec

Example of a method call on an addressable variable.

```go
var p Point
p.Scale(3.5)
```

--------------------------------

### Triggering panics

Source: https://go.dev/ref/spec

Examples of calling panic with different argument types.

```go
panic(42)
panic("unreachable")
panic(Error("cannot parse"))
```

--------------------------------

### Defined Type Method Sets

Source: https://go.dev/ref/spec

Examples showing how defined types interact with method sets.

```go
// A Mutex is a data type with two methods, Lock and Unlock.
type Mutex struct         { /* Mutex fields */ }
func (m *Mutex) Lock()    { /* Lock implementation */ }
func (m *Mutex) Unlock()  { /* Unlock implementation */ }

// NewMutex has the same composition as Mutex but its method set is empty.
type NewMutex Mutex

// The method set of PtrMutex's underlying type *Mutex remains unchanged,
// but the method set of PtrMutex is empty.
type PtrMutex *Mutex

// The method set of *PrintableMutex contains the methods
// Lock and Unlock bound to its embedded field Mutex.
type PrintableMutex struct {
	Mutex
}

// MyBlock is an interface type that has the same method set as Block.
type MyBlock Block
```

--------------------------------

### Type Parameter Conversion

Source: https://go.dev/ref/spec

Example of converting a value to a type parameter P.

```go
func f[P ~float32|~float64]() {
	… P(1.1) …
}
```

--------------------------------

### Equivalent String Representations

Source: https://go.dev/ref/spec

Examples showing different ways to represent the same string value using various literal formats and encodings.

```go
"日本語"                                 // UTF-8 input text
`日本語`                                 // UTF-8 input text as a raw literal
"\u65e5\u672c\u8a9e"                    // the explicit Unicode code points
"\U000065e5\U0000672c\U00008a9e"        // the explicit Unicode code points
"\xe6\x97\xa5\xe6\x9c\xac\xe8\xaa\x9e"  // the explicit UTF-8 bytes
```

--------------------------------

### Variable Declaration Syntax

Source: https://go.dev/ref/spec

Formal grammar and standard usage examples for declaring variables in Go.

```ebnf
VarDecl = "var" ( VarSpec | "(" { VarSpec ";" } ")" ) .
VarSpec = IdentifierList ( Type [ "=" ExpressionList ] | "=" ExpressionList ) .
```

```go
var i int
var U, V, W float64
var k = 0
var x, y float32 = -1, -2
var (
	i       int
	u, v, s = 2.0, 3.0, "bar"
)
var re, im = complexSqrt(-1)
var _, found = entries[name]  // map lookup; only interested in "found"
```

--------------------------------

### Perform Conversions to and from String Types

Source: https://go.dev/ref/spec

Examples of converting strings to byte arrays and slices to string arrays, including cases that trigger panics.

```go
s0 := (*[0]byte)(s)      // s0 != nil
s1 := (*[1]byte)(s[1:])  // &s1[0] == &s[1]
s2 := (*[2]byte)(s)      // &s2[0] == &s[0]
s4 := (*[4]byte)(s)      // panics: len([4]byte) > len(s)

var t []string
t0 := [0]string(t)       // ok for nil slice t
t1 := (*[0]string)(t)    // t1 == nil
t2 := (*[1]string)(t)    // panics: len([1]string) > len(t)

u := make([]byte, 0)
u0 := (*[0]byte)(u)      // u0 != nil
```

--------------------------------

### Type Switch Example and Rewrite

Source: https://go.dev/ref/spec

Demonstrates a type switch compared to an equivalent series of if-else statements using type assertions.

```go
switch i := x.(type) {
case nil:
	printString("x is nil")                // type of i is type of x (interface{})
case int:
	printInt(i)                            // type of i is int
case float64:
	printFloat64(i)                        // type of i is float64
case func(int) float64:
	printFunction(i)                       // type of i is func(int) float64
case bool, string:
	printString("type is bool or string")  // type of i is type of x (interface{})
default:
	printString("don't know the type")     // type of i is type of x (interface{})
}
```

```go
v := x  // x is evaluated exactly once
if v == nil {
	i := v                                 // type of i is type of x (interface{})
	printString("x is nil")
} else if i, isInt := v.(int); isInt {
	printInt(i)                            // type of i is int
} else if i, isFloat64 := v.(float64); isFloat64 {
	printFloat64(i)                        // type of i is float64
} else if i, isFunc := v.(func(int) float64); isFunc {
	printFunction(i)                       // type of i is func(int) float64
} else {
	_, isBool := v.(bool)
	_, isString := v.(string)
	if isBool || isString {
		i := v                         // type of i is type of x (interface{})
		printString("type is bool or string")
	} else {
		i := v                         // type of i is type of x (interface{})
		printString("don't know the type")
	}
}
```

--------------------------------

### For Loop Output

Source: https://go.dev/ref/spec

Expected output for the loop variable scoping example in Go 1.22+.

```text
1
3
5
```

--------------------------------

### Non-Representability Examples

Source: https://go.dev/ref/spec

Examples demonstrating constants that are not representable by specific types.

```text
x                   T           x is not representable by a value of T because

0                   bool        0 is not in the set of boolean values
'a'                 string      'a' is a rune, it is not in the set of string values
1024                byte        1024 is not in the set of unsigned 8-bit integers
-1                  uint16      -1 is not in the set of unsigned 16-bit integers
1.1                 int         1.1 is not an integer value
42i                 float32     (0 + 42i) is not in the set of float32 values
1e1000              float64     1e1000 overflows to IEEE +Inf after rounding
```

--------------------------------

### Constant Length and Capacity Expressions

Source: https://go.dev/ref/spec

Examples showing when len and cap expressions are evaluated as constants.

```go
const (
	c1 = imag(2i)                    // imag(2i) = 2.0 is a constant
	c2 = len([10]float64{2})         // [10]float64{2} contains no function calls
	c3 = len([10]float64{c1})        // [10]float64{c1} contains no function calls
	c4 = len([10]float64{imag(2i)})  // imag(2i) is a constant and no function call is issued
	c5 = len([10]float64{imag(z)})   // invalid: imag(z) is a (non-constant) function call
)
var z complex128
```

--------------------------------

### Iterate with range loop

Source: https://go.dev/ref/spec

Example of using a range loop to iterate over a Fibonacci sequence.

```go
for x := range fibo {
	if x >= 1000 {
		break
	}
	fmt.Printf("%d ", x)
}
```

--------------------------------

### Define primary expressions syntax

Source: https://go.dev/ref/spec

Grammar rules and examples for primary expressions in Go.

```go
PrimaryExpr   = Operand |
                Conversion |
                MethodExpr |
                PrimaryExpr Selector |
                PrimaryExpr Index |
                PrimaryExpr Slice |
                PrimaryExpr TypeAssertion |
                PrimaryExpr Arguments .

Selector      = "." identifier .
Index         = "[" Expression [ "," ] "]" .
Slice         = "[" [ Expression ] ":" [ Expression ] "]" |
                "[" [ Expression ] ":" Expression ":" Expression "]" .
TypeAssertion = "." "(" Type ")" .
Arguments     = "(" [ ( ExpressionList | Type [ "," ExpressionList ] ) [ "..." ] [ "," ] ] ")" .
```

```go
x
2
(s + ".txt")
f(3.1415, true)
Point{1, 2}
m["foo"]
s[i : j + 1]
obj.color
f.p[i].x()
```

--------------------------------

### Use Simplified Type Constraints

Source: https://go.dev/ref/spec

Examples of omitting the interface keyword in type parameter lists for convenience.

```go
[T []P]                      // = [T interface{[]P}]
[T ~int]                     // = [T interface{~int}]
[T int|string]               // = [T interface{int|string}]
type Constraint ~int         // illegal: ~int is not in a type parameter list
```

--------------------------------

### Full slice expression usage

Source: https://go.dev/ref/spec

Example of using a full slice expression to set both length and capacity.

```go
a := [5]int{1, 2, 3, 4, 5}
t := a[1:3:5]
```

```go
t[0] == 2
t[1] == 3
```

--------------------------------

### Implement Function with Return Statement

Source: https://go.dev/ref/spec

Example of a function that requires a terminating return statement.

```go
func IndexRune(s string, r rune) int {
	for i, c := range s {
		if c == r {
			return i
		}
	}
	// invalid: missing return statement
}
```

--------------------------------

### Initialize Channels

Source: https://go.dev/ref/spec

Creating a buffered channel using the make function.

```go
make(chan int, 100)
```

--------------------------------

### Defining Underlying Types

Source: https://go.dev/ref/spec

Examples of type aliases and defined types to illustrate how underlying types are resolved.

```go
type (
	A1 = string
	A2 = A1
)

type (
	B1 string
	B2 B1
	B3 []B1
	B4 B3
)

func f[P any](x P) { … }
```

--------------------------------

### Initialize Struct Literals

Source: https://go.dev/ref/spec

Demonstrates struct initialization using zero values, positional arguments, and key-value pairs.

```go
origin := Point3D{}                                       // zero value for Point3D
line1 := Line{Object{}, origin, Point3D{y: -4, z: 12.3}}  // zero value for line1.q.x
line2 := Line{name: "diagonal", q: Point3D{1, 1, 1}}      // zero value for line2.Object.color, line2.p
```

--------------------------------

### For Loop Syntax Equivalents

Source: https://go.dev/ref/spec

Demonstrates shorthand syntax for for loops with missing condition or init/post statements.

```go
for cond { S() }    is the same as    for ; cond ; { S() }
for      { S() }    is the same as    for true     { S() }
```

--------------------------------

### Parenthesized Conversion Ambiguity Resolution

Source: https://go.dev/ref/spec

Examples showing how to use parentheses to clarify conversions involving pointers, channels, or function types.

```go
*Point(p)        // same as *(Point(p))
(*Point)(p)      // p is converted to *Point
<-chan int(c)    // same as <-(chan int(c))
(<-chan int)(c)  // c is converted to <-chan int
func()(x)        // function signature func() x
(func())(x)      // x is converted to func()
(func() int)(x)  // x is converted to func() int
func() int(x)    // x is converted to func() int (unambiguous)
```

--------------------------------

### Short Variable Declaration Usage

Source: https://go.dev/ref/spec

Examples of short variable declarations and their behavior with multiple return values.

```go
i, j := 0, 10
f := func() int { return 7 }
ch := make(chan int)
r, w, _ := os.Pipe()  // os.Pipe() returns a connected pair of Files and an error, if any
_, y, _ := coord(p)   // coord() returns three values; only interested in y coordinate
```

--------------------------------

### Hidden dependency initialization

Source: https://go.dev/ref/spec

Example showing that dependencies hidden within method calls or interfaces are not detected by the compiler's initialization analysis.

```go
var x = I(T{}).ab()   // x has an undetected, hidden dependency on a and b
var _ = sideEffect()  // unrelated to x, a, or b
var a = b
var b = 42

type I interface      { ab() []int }
type T struct{}
func (T) ab() []int   { return []int{a, b} }
```

--------------------------------

### Identify Parsing Ambiguities

Source: https://go.dev/ref/spec

Examples of type parameter lists that may be misinterpreted as array type declarations.

```go
type T[P *C] …
type T[P (C)] …
type T[P *C|Q] …
…
```

--------------------------------

### Comparison Operator Usage

Source: https://go.dev/ref/spec

Examples showing how comparison results are assigned to variables of different boolean types.

```go
const c = 3 < 4            // c is the untyped boolean constant true

type MyBool bool
var x, y int
var (
	// The result of a comparison is an untyped boolean.
	// The usual assignment rules apply.
	b3        = x == y // b3 has type bool
	b4 bool   = x == y // b4 has type bool
	b5 MyBool = x == y // b5 has type MyBool
)
```

--------------------------------

### Legacy For Loop Output

Source: https://go.dev/ref/spec

Expected output for the loop variable scoping example in versions prior to Go 1.22.

```text
6
6
6
```

--------------------------------

### Illegal Type Definition Examples

Source: https://go.dev/ref/spec

Examples of illegal type definitions involving type parameters.

```go
type T[P any] P    // illegal: P is a type parameter

func f[P any]() {
	type L P   // illegal: P is a type parameter declared by the enclosing function
}
```

--------------------------------

### Struct Tags

Source: https://go.dev/ref/spec

Examples of using string literals as tags for struct fields, including protocol buffer conventions.

```go
struct {
	x, y float64 ""  // an empty tag string is like an absent tag
	name string  "any string is permitted as a tag"
	_    [4]byte "ceci n'est pas un champ de structure"
}

// A struct corresponding to a TimeStamp protocol buffer.
// The tag strings define the protocol buffer field numbers;
// they follow the convention outlined by the reflect package.
struct {
	microsec  uint64 `protobuf:"1"`
	serverIP6 uint64 `protobuf:"2"`
}
```

--------------------------------

### Initialize Maps

Source: https://go.dev/ref/spec

Creating maps using the make function with optional capacity.

```go
make(map[string]int)
make(map[string]int, 100)
```

--------------------------------

### Constant Type Conversions

Source: https://go.dev/ref/spec

Examples of converting constant values to specific types, noting illegal conversions and non-constant cases.

```go
uint(iota)               // iota value of type uint
float32(2.718281828)     // 2.718281828 of type float32
complex128(1)            // 1.0 + 0.0i of type complex128
float32(0.49999999)      // 0.5 of type float32
float64(-1e-1000)        // 0.0 of type float64
string('x')              // "x" of type string
string(0x266c)           // "♬" of type string
myString("foo" + "bar")  // "foobar" of type myString
string([]byte{'a'})      // not a constant: []byte{'a'} is not a constant
(*int)(nil)              // not a constant: nil is not a constant, *int is not a boolean, numeric, or string type
int(1.2)                 // illegal: 1.2 cannot be represented as an int
string(65.0)             // illegal: 65.0 is not an integer constant
```

--------------------------------

### Illegal Alias Declaration Examples

Source: https://go.dev/ref/spec

Examples of illegal alias declarations involving type parameters.

```go
type A[P any] = P   // illegal: P is a type parameter declared in the declaration of A

func f[P any]() {
	type A = P  // ok: T is a type parameter declared by the enclosing function
}
```

--------------------------------

### Define Array Literals

Source: https://go.dev/ref/spec

Examples of array initialization with fixed lengths and inferred lengths using the ellipsis operator.

```go
buffer := [10]string{}             // len(buffer) == 10
intSet := [6]int{1, 2, 3, 5}       // len(intSet) == 6
days := [...]string{"Sat", "Sun"}  // len(days) == 2
```

--------------------------------

### Equivalent Slice Initialization

Source: https://go.dev/ref/spec

Shows two equivalent ways to initialize a slice of a specific length and capacity.

```go
make([]int, 50, 100)
new([100]int)[0:50]
```

--------------------------------

### For Loop Variable Scoping

Source: https://go.dev/ref/spec

Example showing how variables are scoped in for loops, noting the behavior change introduced in Go 1.22.

```go
var prints []func()
for i := 0; i < 5; i++ {
	prints = append(prints, func() { println(i) })
	i++
}
for _, p := range prints {
	p()
}
```

--------------------------------

### Switch Statement Syntax and Usage

Source: https://go.dev/ref/spec

Defines the grammar for switch statements and provides examples of expression switches with various configurations.

```ebnf
SwitchStmt = ExprSwitchStmt | TypeSwitchStmt .
```

```ebnf
ExprSwitchStmt = "switch" [ SimpleStmt ";" ] [ Expression ] "{" { ExprCaseClause } "}" .
ExprCaseClause = ExprSwitchCase ":" StatementList .
ExprSwitchCase = "case" ExpressionList | "default" .
```

```go
switch tag {
default: s3()
case 0, 1, 2, 3: s1()
case 4, 5, 6, 7: s2()
}

switch x := f(); {  // missing switch expression means "true"
case x < 0: return -x
default: return x
}

switch {
case x < y: f1()
case x < z: f2()
case x == 4: f3()
}
```
Tokens:
Raw