> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Go Addition
The `+` operator in Go is an overloaded operator that functions as a binary arithmetic operator for numeric addition, a binary operator for string concatenation, and a unary operator for numeric identity. Due to Go's strict type system, binary operations require both operands to resolve to the identical type; Go does not perform implicit type coercion.
```go theme={"dark"}
// Unary syntax
+operand
// Binary syntax
operand1 + operand2
```
## Binary Numeric Addition
When applied to numeric types (integers, floating-point numbers, and complex numbers), the `+` operator computes the mathematical sum of the two operands.
* **Type Strictness:** Both operands must be of the exact same type (e.g., `int32` + `int32`). Attempting to add an `int32` to an `int64` results in a compile-time type mismatch error. Explicit type conversion is required to align the operand types prior to evaluation.
* **Integer Overflow:** Go handles integer overflow silently. If the sum of two integers exceeds the maximum representable value for their bit-width, the result wraps around according to two's complement arithmetic (for signed integers) or standard modulo arithmetic (for unsigned integers). It does not trigger a runtime panic.
* **Floating-Point and Complex:** Addition follows IEEE-754 standards, including the handling of infinities and `NaN` (Not a Number) values.
```go theme={"dark"}
var a int8 = 127
var b int8 = 1
var c int8 = a + b // c is -128 (silent overflow)
var x float32 = 1.5
var y float64 = 2.0
// var z = x + y // Compilation error: mismatched types
var z = float64(x) + y // Valid explicit conversion
```
## Binary String Concatenation
When applied to operands of type `string`, the `+` operator performs byte-wise concatenation.
* **Immutability:** Because strings in Go are immutable, the `+` operator allocates a new backing array in memory and copies the byte sequences of the left operand followed by the right operand into this new array.
* **Type Strictness:** Both operands must be strings. Go will not implicitly convert a numeric or boolean type to a string during concatenation.
```go theme={"dark"}
str1 := "foo"
str2 := "bar"
result := str1 + str2 // Yields a new string "foobar"
```
## Unary Identity
When used as a prefix to a single numeric operand, `+` acts as the unary identity operator. It yields the unmodified value of the operand. It cannot be applied to strings or booleans.
```go theme={"dark"}
var a int = 5
var b int = +a // b is 5
```
## Untyped Constants
If the operands are untyped constants, the `+` operator is evaluated at compile-time rather than runtime. Go's compiler performs constant arithmetic with arbitrary precision (at least 256 bits). The result of adding two untyped constants is a new untyped constant, which only assumes a concrete type when assigned to a variable or used in a typed context.
```go theme={"dark"}
const a = 1e100
const b = 2e100
const c = a + b // Evaluated at compile-time, no overflow
```
Tired of Poor Go Skills? Fix That With Deep Grasping!
Learn More
