Did you miss yesterday’s Ask-me-anything session? You probably did. I had about 10-15 people there. But even with a small group, we had a *ton* of great questions! The Q&A session lasted about an hour, and covered topics such as book recommendations for going deeper into Go, what project to build to learn concurrency, and much more. Catch the replay on YouTube.

Let’s continue our discussion of constant expressions, with some more miscellaneous rules:

## Constant expressions

…

The divisor of a constant division or remainder operation must not be zero:

`3.14 / 0.0 // illegal: division by zero`

I don’t think this needs any explanation.

The values of

typedconstants must always be accurately representable by values of the constant type. The following constant expressions are illegal:`uint(-1) // -1 cannot be represented as a uint int(3.14) // 3.14 cannot be represented as an int int64(Huge) // 1267650600228229401496703205376 cannot be represented as an int64 Four * 300 // operand 300 cannot be represented as an int8 (type of Four) Four * 100 // product 400 cannot be represented as an int8 (type of Four)`

Recall that constants can be both *typed* and *untyped*:

```
const x = "foo" // Untyped string constant
const y = string("foo") // Typed string constant
type MyString string
const z = MyString("foo") // Typed string constant
```

So the above rule is just the natural and obvious application of Go’s representability rules, as they apply to conversion between typed and untyped constants.

The mask used by the unary bitwise complement operator

`^`

matches the rule for non-constants: the mask is all 1s for unsigned constants and -1 for signed and untyped constants.`^1 // untyped integer constant, equal to -2 uint8(^1) // illegal: same as uint8(-2), -2 cannot be represented as a uint8 ^uint8(1) // typed uint8 constant, same as 0xFF ^ uint8(1) = uint8(0xFE) int8(^1) // same as int8(-2) ^int8(1) // same as -1 ^ int8(1) = -2`

Nothing new to cover here. The same rules that apply to non-constants apply to constants, with regard to the `^`

operator.

And one final note before we move beyond this topic, just re-iterating what I said yesterday about the optional rounding of some constants:

Implementation restriction: A compiler may use rounding while computing untyped floating-point or complex constant expressions; see the implementation restriction in the section on constants. This rounding may cause a floating-point constant expression to be invalid in an integer context, even if it would be integral when calculated using infinite precision, and vice versa.

Quotes from *The Go Programming Language Specification* Language version go1.22 (Feb 6, 2024)