Types, Values and Constants

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.

It returns 6. Go's len on a string counts bytes, not characters, and the letter é takes two bytes in UTF-8 while each ASCII letter takes one. Counting characters means decoding the bytes instead.

Go sets every variable declared without an initializer to its type's zero value, so there is never uninitialised memory. That is 0 for numeric types, an empty string for string, false for bool, and nil for pointers, slices, maps, channels, functions and interfaces.

An untyped constant has a kind - integer, float, rune, string, boolean - but no type, and the compiler evaluates it exactly. With no type available from context it takes its default type: int, float64, rune, string or bool.

Because the loop hands back the byte offset where each character starts, not a sequential counter. The accented letter occupies bytes 1 and 2, so the next letter starts at 3. The second loop value is the decoded character.

You get a complete Server value with every field zeroed recursively: the int is 0, each field of the nested struct is its own zero value, all four array bytes are 0, and the map field is nil with nothing allocated for it.

They are aliases, not distinct types: byte is another name for uint8, rune another name for int32. Each pair is one type, so no conversion is ever needed and fmt's %T prints uint8 or int32.

Unsigned arithmetic wraps at zero, so subtracting a larger value gives a huge positive number instead of a negative one. Go returns int from len and cap so index arithmetic can go negative and be caught by an ordinary check.

No. A type definition copies the underlying type - here sync.Mutex's struct fields - but never the methods declared on the source type, so MyMutex starts with an empty method set. An alias or embedding keeps the methods.

A float32 carries a 24-bit significand, about seven decimal digits, against float64's 53 bits and about fifteen. Go never converts between the two implicitly, and the math package is float64-only, so float32 pays off only when memory or bandwidth dominates.

A constant zero divisor is rejected by the compiler. A divisor that is zero only at run time causes a panic carrying a runtime.Error with the message 'integer divide by zero', which a deferred recover in the same goroutine can catch.

Go strings are immutable, so s[0] = 'G' is a compile error. Build a new value: convert to []byte, or to []rune when the character is not ASCII, edit it, and convert back. Both conversions copy.

Every constant below the insertion point shifts up by one, so rows written under the old numbering now read back as a different status, and nothing fails to compile. Pin persisted values explicitly and only append.

Almost certainly a declaration became an alias: type Fahrenheit = Celsius. An alias makes the two names one identical type, so every unit mismatch type-checks. Look for the equals sign in the type declarations.

NaN is contagious and silent: any arithmetic touching it yields NaN, and every comparison against it is false, so a threshold check never fires. Instrument stage boundaries with math.IsNaN and log math.Float64bits, then fix the division that made it.

Go orders function calls, method calls, channel receives and the operands of && and || lexically left to right. The order of everything else, such as plain variable reads next to a call, is unspecified. Assignment evaluates all right-hand expressions and left-hand index operands first, then assigns left to right.

Slicing a Go string cuts bytes, not characters, so name[:20] can land inside a multi-byte UTF-8 sequence. The partial bytes left behind are still a legal Go string, and only the layer that decodes them shows a replacement character.

From the value alone you cannot: Go zeroes every field, so an omitted Timeout and one explicitly set to 0 are identical bits. Either define zero to mean 'use the default', or make the field a pointer, or accept option functions.

Leave an alias when you cannot change every importer in one commit: it keeps the old and new names identical, so migrated and unmigrated code interoperate. Otherwise move the type and delete the old name.

Inside a parenthesized const block, a line with no expression repeats the previous line's expression, with iota re-evaluated for it. A line declaring only the blank identifier still counts, so it consumes an iota value.

Go 1.24 lets a type alias declare its own type parameters, so type Set[T comparable] = map[T]struct{} finally compiles. Set[string] is identical to map[string]struct{}: no conversion, and still no method set of its own.

A float64 NaN is never equal to anything, itself included, so lookup and delete never match the entry. Each insert adds another one and len keeps growing; only clear or a fresh map removes them.

Go does not mask shift counts. Shifting a uint64 left by 64 or more yields 0, and shifting a negative signed value right far enough yields -1. A shift count that is negative at run time panics.

Because a bytes.Buffer's all-zero state is already a valid empty buffer: its internal byte slice is nil and writes append into a fresh one. sync.Mutex, sync.RWMutex, sync.WaitGroup, sync.Once, sync.Map, strings.Builder and http.Client are usable at zero too.

It gives 44. A Go conversion between integer types never fails: it keeps the low bits and discards the rest. In a parser a hostile large value silently becomes a small plausible one that passes validation.