---
title: Operators
slug: reference/operators
docTags: 
createdAt: 2025-09-23T15:07:39.160Z
---

## Operators

### Int

### Equality

- `(int) == (int) = (bool)`: equality
- `(int) != (int) = (bool)`: inequality

### Arithmetic Operators

:::hint{type="warning"}
### Integer operators

When operating on two integers, the result will be an integer again, e.g. for division `10 / 100 = 0`. If your goal is to get a float as result, make sure one of the operands is a float.
:::

- `(int) + (int) = (int)`: sum
- `(int) - (int) = (int)`: difference
- `(int) * (int) = (int)`: product
- `(int) / (int) = (int)`: quotient
- `(int) % (int) = (int)`: remainder
- `(int) + (float) = (float)`: sum
- `(int) - (float) = (float)`: difference
- `(int) * (float) = (float)`: product
- `(int) / (float) = (float)`: quotient
- `(int) + (char) = (char)`: sum
- `(int) - (char) = (char)`: difference

### Bitwise Operators

- `(int) & (int) = (int)`: bitwise AND
- `(int) | (int) = (int)`: bitwise OR
- `(int) ^ (int) = (int)`: bitwise XOR
- `(int) &^ (int) = (int)`: bitclear (AND NOT)
- `(int) << (int) = (int)`: left shift
- `(int) >> (int) = (int)`: right shift

### Comparison Operators

- `(int) < (int) = (bool)`: less than
- `(int) > (int) = (bool)`: greater than
- `(int) <= (int) = (bool)`: less than or equal to
- `(int) >= (int) = (bool)`: greater than or equal to
- `(int) < (float) = (bool)`: less than
- `(int) > (float) = (bool)`: greater than
- `(int) <= (float) = (bool)`: less than or equal to
- `(int) >= (float) = (bool)`: greater than or equal to
- `(int) < (char) = (bool)`: less than
- `(int) > (char) = (bool)`: greater than
- `(int) <= (char) = (bool)`: less than or equal to
- `(int) >= (char) = (bool)`: greater than or equal to

### Float

### Equality

- `(float) == (float) = (bool)`: equality
- `(float) != (float) = (bool)`: inequality

### Arithmetic Operators

- `(float) + (float) = (float)`: sum
- `(float) - (float) = (float)`: difference
- `(float) * (float) = (float)`: product
- `(float) / (float) = (float)`: quotient
- `(float) + (int) = (float)`: sum
- `(float) - (int) = (float)`: difference
- `(float) * (int) = (float)`: product
- `(float) / (int) = (float)`: quotient

### Comparison Operators

- `(float) < (float) = (bool)`: less than
- `(float) > (float) = (bool)`: greater than
- `(float) <= (float) = (bool)`: less than or equal to
- `(float) >= (float) = (bool)`: greater than or equal to
- `(float) < (int) = (bool)`: less than
- `(float) > (int) = (bool)`: greater than
- `(float) <= (int) = (bool)`: less than or equal to
- `(float) >= (int) = (bool)`: greater than or equal to

### String

### Equality

- `(string) == (string) = (bool)`: equality
- `(string) != (string) = (bool)`: inequality

### Concatenation

- `(string) + (string) = (string)`: concatenation
- `(string) + (other types) = (string)`: concatenation (after string-converted)

### Comparison Operators

- `(string) < (string) = (bool)`: less than
- `(string) > (string) = (bool)`: greater than
- `(string) <= (string) = (bool)`: less than or equal to
- `(string) >= (string) = (bool)`: greater than or equal to

### Char

### Equality

- `(char) == (char) = (bool)`: equality
- `(char) != (char) = (bool)`: inequality

### Arithmetic Operators

- `(char) + (char) = (char)`: sum
- `(char) - (char) = (char)`: difference
- `(char) + (int) = (char)`: sum
- `(char) - (int) = (char)`: difference

### Comparison Operators

- `(char) < (char) = (bool)`: less than
- `(char) > (char) = (bool)`: greater than
- `(char) <= (char) = (bool)`: less than or equal to
- `(char) >= (char) = (bool)`: greater than or equal to
- `(char) < (int) = (bool)`: less than
- `(char) > (int) = (bool)`: greater than
- `(char) <= (int) = (bool)`: less than or equal to
- `(char) >= (int) = (bool)`: greater than or equal to

### Bool

### Equality

- `(bool) == (bool) = (bool)`: equality
- `(bool) != (bool) = (bool)`: inequality

### Bytes

### Equality

Test whether two byte array contain the same data. Uses [bytes.Equal](https://pkg.go.dev/bytes#Equal) internally.

- `(bytes) == (bytes) = (bool)`: equality
- `(bytes) != (bytes) = (bool)`: inequality

### Concatenation

- `(bytes) + (bytes) = (bytes)`: return the concatenated bytes

### Time

### Equality

Tests whether two times represent the same time instance. Uses [Time.Equal](https://pkg.go.dev/time#Time.Equal) internally.

- `(time) == (time) = (bool)`: equality
- `(time) != (time) = (bool)`: inequality

### Arithmetic Operators

- `(time) - (time) = (int)`: difference in nanoseconds (duration)
- `(time) + (int) = (time)`: time + duration (nanoseconds)
- `(time) - (int) = (time)`: time - duration (nanoseconds)

### Comparison Operators

- `(time) < (time) = (bool)`: less than
- `(time) > (time) = (bool)`: greater than
- `(time) <= (time) = (bool)`: less than or equal to
- `(time) >= (time) = (bool)`: greater than or equal to

### Array and ImmutableArray

### Equality

Tests whether two *(immutable)* arrays contain the same objects.

- `(array) == (array) = (bool)`: equality
- `(array) != (array) = (bool)`: inequality
- `(array) == (immutable-array) = (bool)`: equality
- `(array) != (immutable-array) = (bool)`: inequality
- `(immutable-array) == (immutable-array) = (bool)`: equality
- `(immutable-array) != (immutable-array) = (bool)`: inequality
- `(immutable-array) == (array) = (bool)`: equality
- `(immutable-array) != (array) = (bool)`: inequality

### Concatenation

- `(array) + (array)`: return a concatenated array
- `(immutable-array) + (immutable-array)`: return a concatenated array, which is mutable

Mixing the two is not allowed: `(array) + (immutable-array)` fails with `invalid operation`.

### Map and ImmutableMap

### Equality

Tests whether two *(immutable)* maps contain the same key-objects.

- `(map) == (map) = (bool)`: equality
- `(map) != (map) = (bool)`: inequality
- `(map) == (immutable-map) = (bool)`: equality
- `(map) != (immutable-map) = (bool)`: inequality
- `(immutable-map) == (immutable-map) = (bool)`: equality
- `(immutable-map) != (immutable-map) = (bool)`: inequality
- `(immutable-map) == (map) = (bool)`: equality
- `(immutable-map) != (map) = (bool)`: inequality