Core Language and Type System

Go integers wrap around silently: an int8 holding 127 becomes -128 when incremented, and a uint8 holding 0 becomes 255 when decremented. There is no panic and no promotion to a wider type. Only constant overflow is caught at compile time.

iota is a built-in counter usable only in const declarations: it is 0 on the first line of a const block and increases by one on each following line. Every new const block resets it to 0.

type Celsius float64 declares a new, distinct type that shares float64's representation but has its own method set. type Celsius = float64 is an alias: Celsius and float64 are two names for one identical type.

The compiler evaluates constant expressions itself and rejects a constant division by zero outright. Float64 variables divide at run time under IEEE 754, so a nonzero value over zero gives positive or negative infinity, and zero over zero gives NaN.

Go truncates integer division toward zero, so -7/2 is -3, and the remainder takes the sign of the dividend, so -7%2 is -1. The identity x == (x/y)*y + x%y always holds.

An array's length is part of its type, and assigning or passing one copies every element. A slice is a resizable view onto a backing array, carrying a length and a capacity; copying a slice shares that array.

Assignment copies a struct field by field. Number, string, bool and array fields become independent, but a slice, map or pointer field copies only the reference, so both structs still read and write the same underlying data.

A keyed struct literal names each field and may omit fields, so order does not matter. A positional literal must supply every field in declaration order, so reordering fields silently changes what each value means.

Use the two-value comma-ok form: v, ok := m[key]. ok is true only when the key is present. A one-value lookup returns the value type's zero value for a missing key, so 0, an empty string or false cannot tell you which happened.

Pass a pointer. A function parameter of type Player receives a copy, so writes to it die with the call. Declare the parameter as *Player, call it with &pl, and write p.HP = 40 — Go dereferences the selector for you.

Writing a type inside a struct with no field name embeds it. The embedded type's fields and methods are promoted: you can use them directly on the outer value. The field itself is still named after its type.

No. Embedding is composition, not subtyping: a struct that embeds StateRecord is its own distinct type and is never assignable to StateRecord. You pass the embedded value explicitly, as n.StateRecord.

Go's method set of T contains only methods declared with receiver T; methods declared with receiver *T belong to *T's method set alone. Interface satisfaction is checked against the method set, so only the pointer satisfies the interface.

A method value is the function value you get by writing runner.Warmup with no call parentheses. Go evaluates and saves the receiver at that moment, so calling f() later runs Warmup on that saved receiver and takes no receiver argument.

A value receiver gets a copy of the value, so anything the method writes to it is discarded when the method returns. A pointer receiver gets the address of the caller's value, so its writes are visible afterwards.

The one-result form v := x.(T) panics if the interface value x does not hold a T. The comma-ok form v, ok := x.(T) never panics: on a miss it yields T's zero value and sets ok to false.

An interface method call is indirect: the target comes from the interface value's method table at run time, so the compiler cannot inline it or optimise across it. The lost inlining usually costs far more than the extra jump.

Embedding folds the other interfaces' method sets into the new one, so io.ReadWriteCloser requires exactly Read, Write and Close and declares nothing extra. Any type with all three methods satisfies it automatically, with no declaration of intent.

A Go type satisfies an interface just by having every method the interface lists, with matching names and signatures. Nothing is declared anywhere: the compiler checks the match at the point where the value is assigned to the interface.

A Go interface value holds two halves: a dynamic type and a value of that type. It is nil only when both halves are empty. An interface that has been given a type is non-nil even if the value stored is a nil pointer.

A constraint is an interface that bounds a type parameter, defining which types may be used as the type argument. The any constraint admits every type, so the body may only assign, pass and store such values, not compare or add them.

Go infers a generic function's type arguments from the ordinary arguments you pass at the call site. A type parameter that appears only in the result is not determined by any argument, so you must write it explicitly, as in Zeroint.

Returning any gives the caller a value with no static type, so every call site must type-assert and can panic at run time. A type parameter returns the caller's own type instead, so the compiler checks the use.

The brackets declare a type parameter list. T is a placeholder for a type, constrained by any, so one Reverse serves every element type. T is in scope for the rest of the signature and the whole body.

Use comparable when the code needs equality: it is the predeclared constraint for types supporting == and !=, which is what a map key or set element requires. Use cmp.Ordered when the code needs ordering with <, >: integers, floats and strings.

A Go function literal captures the variable itself, not a snapshot of its value. Assignments made after the literal is created are visible when it runs, and assignments made inside it are visible to the enclosing code.

Go's for has three non-range forms: three-clause (init; condition; post), condition-only, and infinite (for with no clauses at all). The condition-only form is Go's while loop - the language has no while and no do-while keyword.

defer postpones a function call until the surrounding function finishes, not until the enclosing block ends. Several deferred calls run in reverse registration order, last registered first, and they run on every return path.

A Go call returning two values needs two targets: port, ok := parsePort(s). Write the blank identifier _ for any result you do not want. Binding one variable to it is a compile error.

In Go a case body ends the switch automatically — there is no implicit fall-through and no break is needed. The fallthrough keyword, written as the last statement of a case, forces control into the next case's body.

Go makes an unused import a hard compile error rather than a warning: dead imports slow builds, grow the dependency graph and mislead readers. Delete the line, or make it deliberate with a blank import, an underscore before the path.

Go runs a package's init() functions automatically at startup: after that package's package-level variables are assigned and after every package it imports is fully initialized, but before main() begins. You cannot call init() yourself.

A package whose import path contains an internal element can be imported only by code inside the tree rooted at that internal/ directory's parent. Any other import fails at build time with 'use of internal package ... not allowed'.

It declares a new variable that lives only until that block's closing brace. The outer variable of the same name is hidden, not assigned, so whatever the inner block writes is lost when the block ends.

The case of its first letter. A name beginning with an upper-case letter is exported and can be used by importing packages; a name beginning with a lower-case letter is usable only inside the package that declares it.

An untyped string constant is assignable to any type whose underlying type is string, so the literal works. But UserID and string are two distinct named types, so moving a value between them needs an explicit conversion: string(id).

Booleans, numbers, strings, pointers, channels, interfaces, and structs or arrays built entirely from comparable parts support ==. Slices, maps and functions do not: the compiler rejects ==, and the only equality they allow is a comparison against nil.

Six kinds of type can be nil: pointers, slices, maps, channels, functions and interfaces. nil is the zero value of each, not one shared value, so every kind has its own representation and its own rules about what you may safely do.

A bidirectional channel may be assigned to a receive-only or send-only variable, because that only removes capability. The reverse would invent capability the value never had, so it is neither assignable nor convertible. Direction is part of the static type.

Two interface values are equal only when both hold nothing at all, or when their dynamic types are identical and their dynamic values are equal. An any holding int(1) never equals an any holding int64(1).