Introduction

It's similar to Go and is also influenced by Oberon, Rust, Swift.

V is a very simple language. Going through this documentation will take you about half an hour, and by the end of it you will learn pretty much the entire language.

Despite being simple, it gives a lot of power to the developer. Anything you can do in other languages, you can do in V.

Hello World

fn main() {
	println('hello world')
}

Functions are declared with fn. Return type goes after the function name. In this case main doesn't return anything, so the type is omitted.

Just like in C and all related languages, main is an entry point.

println is one of the few built-in functions. It prints the value to standard output.

fn main() declaration can be skipped in one file programs. This is useful when writing small programs, "scripts", or just learning the language. For brevity, fn main() will be skipped in this tutorial.

This means that a "hello world" program can be as simple as

println('hello world')

Comments

// This is a single line comment.

/* This is a multiline comment.
   /* It can be nested. */
*/

Functions

fn main() {
	println(add(77, 33))
	println(sub(100, 50))
}

fn add(x int, y int) int {
	return x + y
}

fn sub(x, y int) int {
	return x - y
}

Again, the type comes after the argument's name.

Just like in Go and C, functions cannot be overloaded. This simplifies the code and improves maintainability and readability.

Functions can be used before their declaration: add and sub are declared after main, but can still be called from main. This is true for all declarations in V and eliminates the need of header files or thinking about the order of files and declarations.

fn foo() (int, int) {
	return 2, 3
}

a, b := foo()
println(a) // 2
println(b) // 3

Functions can return multiple values.

Functions, like consts, and types, are private (not exported) by default. To allow other modules to use them, prepend pub. The same applies to consts and types.

pub fn public_function() {
}

fn private_function() {
}

Variables

name := 'Bob'
age := 20
large_number := i64(9999999999)
println(name)
println(age)
println(large_number)

Variables are declared and initialized with :=. This is the only way to declare variables in V. This means that variables always have an initial value.

The variable's type is inferred from the value on the right hand side. To force a different type, use type conversion: the expression T(v) converts the value v to the type T.

Unlike most other languages, V only allows defining variables in functions. Global (module level) variables are not allowed. There's no global state in V.

mut age := 20
println(age)
age = 21
println(age)

To change the value of the variable use =. In V, variables are immutable by default. To be able to change the value of the variable, you have to declare it with mut.

Try compiling the program above after removing mut from the first line.

Please note the difference between := and =
:= is used for declaring and initializing, = is used for assigning.

fn main() {
	age = 21
}

This code will not compile, because variable age is not declared. All variables need to be declared in V.

fn main() {
	age := 21
}

In development mode this code will result in an "unused variable" warning. In production mode (v -prod foo.v) it will not compile at all, like in Go.

fn main() {
	a := 10
	if true {
		a := 20
	}
}

Unlike most languages, variable shadowing is not allowed. Declaring a variable with a name that is already used in a parent scope will result in a compilation error.

Basic types

bool

string

i8    i16  int  i64      i128 (soon)
byte  u16  u32  u64      u128 (soon)

rune // represents a Unicode code point 

f32 f64

byteptr
voidptr

Strings

name := 'Bob'
println('Hello, $name!')  // `$` is used for string interpolation
println(name.len)

bobby := name + 'by' // + is used to concatenate strings
println(bobby) // "Bobby" 

println(bobby[1..3]) // "ob" 
mut s := 'hello '
s += 'world' // `+=` is used to append to a string
println(s) // "hello world" 

In V, a string is a read-only array of bytes. String data is encoded using UTF-8.

Strings are immutable.

Both single and double quotes can be used to denote strings. For consistency, vfmt converts double quotes to single quotes unless the string contains a single quote character.

Interpolation syntax is pretty simple. It also works with fields: 'age = $user.age'. If you need more complex expressions, use ${}: 'can register = ${user.age > 13}'.

All operators in V must have values of the same type on both sides. This code will not compile if age is an int:

println('age = ' + age)

println('age = ' + age.str())

println('age = $age')

To denote character literals, use `

a := `a`
assert 'aloha!'[0] == `a`

For raw strings, prepend r. Raw strings are not escaped:

s := r'hello\nworld'
println(s) // "hello\nworld"

Arrays

mut nums := [1, 2, 3]
println(nums) // "[1, 2, 3]"
println(nums[1]) // "2"

nums << 4
println(nums) // "[1, 2, 3, 4]"

nums << [5, 6, 7]
println(nums) // "[1, 2, 3, 4, 5, 6, 7]"

mut names := ['John']
names << 'Peter'
names << 'Sam'
// names << 10  <-- This will not compile. `names` is an array of strings.
println(names.len) // "3"
println('Alex' in names) // "false"

names = [] // The array is now empty

// We can also preallocate a certain amount of elements.
ids := [0].repeat(50) // This creates an array with 50 zeros

Array type is determined by the first element: [1, 2, 3] is an array of ints
([]int).
['a', 'b'] is an array of strings ([]string).

All elements must have the same type. [1, 'a'] will not compile.

<< is an operator that appends a value to the end of the array. It can also append an entire array.

.len field returns the length of the array. Note, that it's a read-only field, and it can't be modified by the user. All exported fields are read-only by default in V.

val in array returns true if the array contains val.

All arrays can be easily printed with println(arr) and converted to a string with s := arr.str().

Arrays can be efficiently filtered and mapped with .filter() and .map() methods:

nums := [1, 2, 3, 4, 5, 6]
even := nums.filter(it % 2 == 0)
println(even) // [2, 4, 6]

words := ['hello', 'world']
upper := words.map(it.to_upper())
println(upper) // ['HELLO', 'WORLD']

Maps

mut m := map[string]int // Only maps with string keys are allowed for now 
m['one'] = 1
m['two'] = 2
println(m['one']) // "1" 
println(m['bad_key']) // "0" 
println('bad_key' in m) // Use `in` to detect whether such key exists
m.delete('two')

numbers := {
	'one': 1,
	'two': 2,
}

If

a := 10
b := 20
if a < b {
	println('$a < $b')
} else if a > b {
	println('$a > $b')
} else {
	println('$a == $b')
}

if statements are pretty straightforward and similar to most other languages.

Unlike other C-like languages, there are no parentheses surrounding the condition, and the braces are always required.

if can be used as an expression:

num := 777
s := if num % 2 == 0 {
	'even'
}
else {
	'odd'
}
println(s) // "odd"

In operator

nums := [1, 2, 3]
println(1 in nums) // true

m := {'one': 1, 'two': 2}
println('one' in m) // true

if parser.token == .plus || parser.token == .minus ||
	parser.token == .div || parser.token == .mult {
	...
}

if parser.token in [.plus, .minus, .div, .mult] {
	...
}

For loop

numbers := [1, 2, 3, 4, 5]
for num in numbers {
	println(num)
}
names := ['Sam', 'Peter']
for i, name in names {
	println('$i) $name')  // Output: 0) Sam
}                             //         1) Peter

The for value in loop is used for going through elements of an array. If an index is required, an alternative form for index, value in can be used.

Note, that the value is read-only. If you need to modify the array while looping, you have to use indexing:

mut numbers := [1, 2, 3, 4, 5]
for i, num in numbers {
	println(num)
	numbers[i] = 0
}

mut sum := 0
mut i := 0
for i <= 100 {
	sum += i
	i++
}
println(sum) // "5050"

This form of the loop is similar to while loops in other languages.

The loop will stop iterating once the boolean condition evaluates to false.

Again, there are no parentheses surrounding the condition, and the braces are always required.

mut num := 0
for {
	num++
	if num >= 10 {
		break
	}
}
println(num) // "10"

The condition can be omitted, this results in an infinite loop.

for i := 0; i < 10; i++ {
	// Don't print 6
	if i == 6 {
		continue
	}
	println(i)
}

Finally, there's the traditional C style for loop. It's safer than the `while` form because with the latter it's easy to forget to update the counter and get stuck in an infinite loop.

Here i doesn't need to be declared with mut since it's always going to be mutable by definition.

Match

os := 'windows'
print('V is running on ')
match os {
	'darwin' { println('macOS.') }
	'linux'  { println('Linux.') }
	else     { println(os) }
}

s := match number {
	1    { 'one' }
	2    { 'two' }
	else { 
		println('this works too')
		'many' 
	}
}

A match statement is a shorter way to write a sequence of if - else statements. When a matching branch is found, the following statement block will be run, and the final expression will be returned. The else branch will be evaluated when no other branches match.

enum Color {
	red
	blue
	green
}

fn is_red_or_blue(c Color) bool {
	return match c {
		.red { true }
		.blue { true }
		else { false }
	}
}

A match statement can also be used to branch on the variants of an enum by using the shorthand .variant_here syntax.

Structs

struct Point {
	x int
	y int
}

p := Point{
	x: 10
	y: 20
}
println(p.x) // Struct fields are accessed using a dot

Structs are allocated on the stack. To allocate a struct on the heap and get a reference to it, use the & prefix:

 // Alternative initialization syntax for structs with 3 fields or fewer
p := &Point;{10, 10}
// References have the same syntax for accessing fields 
println(p.x)

The type of p is &Point;. It's a reference to Point. References are similar to Go pointers and C++ references.

V doesn't have subclassing, but it supports embedded structs:

// TODO: this will be implemented later
struct Button {
	Widget
	title string
}

button := new_button('Click me')
button.set_pos(x, y)

// Without embedding we'd have to do
button.widget.set_pos(x,y)

Structs can have default values:

struct Foo {
  a int
  b int = 10
}

foo := Foo{}
assert foo.a == 0
assert foo.b == 10

Access modifiers

Struct fields are private and immutable by default (making structs immutable as well). Their access modifiers can be changed with pub and mut. In total, there are 5 possible options:

struct Foo {
	a int     // private immutable (default)
mut:
	b int     // private mutable
	c int     // (you can list multiple fields with the same access modifier) 
pub:
	d int     // public immmutable (readonly)
pub mut:
	e int     // public, but mutable only in parent module 
__global:
	f int 	  // public and mutable both inside and outside parent module 
}                 // (not recommended to use, that's why the 'global' keyword 
                  // starts with __)

For example, here's the string type defined in the builtin module:

struct string {
	str byteptr
pub:
	len int
}

It's easy to see from this definition that string is an immutable type.

The byte pointer with the string data is not accessible outside builtin at all. len field is public, but not mutable:

fn main() {
	str := 'hello'
	len := str.len // OK 
	str.len++      // Compilation error 
}

Methods

struct User {
	age int
}

fn (u User) can_register() bool {
	return u.age > 16
}

user := User{age: 10}
println(user.can_register()) // "false" 

user2 := User{age: 20}
println(user2.can_register()) // "true" 

V doesn't have classes. But you can define methods on types.

A method is a function with a special receiver argument.

The receiver appears in its own argument list between the fn keyword and the method name.

In this example, the can_register method has a receiver of type User named u. The convention is not to use receiver names like self or this, but a short, preferably one letter long, name.

Pure functions by default

This is achieved by lack of global variables and all function arguments being immutable by default, even when references are passed.

V is not a pure functional language however. It is possible to modify function arguments by using the same keyword mut:

struct User {
mut:
	is_registered bool
}

fn (u mut User) register() {
	u.is_registered = true
}

mut user := User{}
println(user.is_registered) // "false" 
user.register()
println(user.is_registered) // "true" 

In this example, the receiver (which is simply the first argument) is marked as mutable, so register() can change the user object. The same works with non-receiver arguments:

fn multiply_by_2(arr mut []int) {
	for i := 0; i < arr.len; i++ {
		arr[i] *= 2
	}
}

mut nums := [1, 2, 3]
multiply_by_2(mut nums)
println(nums) // "[2, 4, 6]"

Note, that you have to add mut before nums when calling this function. This makes it clear that the function being called will modify the value.

It is preferable to return values instead of modifying arguments. Modifying arguments should only be done in performance-critical parts of your application to reduce allocations and copying.

For this reason V doesn't allow to modify primitive args like integers, only complex types like arrays and maps.

Use user.register() or user = register(user) instead of register(mut user).

V makes it easy to return a modified version of an object:

fn register(u User) User {
	return { u | is_registered: true }
}

user = register(user)

High order functions

fn sqr(n int) int {
        return n * n
}

fn run(value int, op fn(int) int) int {
        return op(value)
}

fn main()  {
        println(run(5, sqr)) // "25"
}

References

fn (foo Foo) bar_method() {
	...
}

fn bar_function(foo Foo) {
	...
}

You no longer need to remember whether you should pass the struct by value or by reference.

There's a way to ensure that the struct is always passed by reference by adding &:

fn (foo &Foo;) bar() {
	println(foo.abc)
}

foo is still immutable and can't be changed. For that, (foo mut Foo) has to be used.

In general, V references are similar to Go pointers and C++ references. For example, a tree structure definition would look like this:

struct Node<T> {
	val   T
	left  &Node;
	right &Node;
}

Constants

const (
	pi    = 3.14
	world = '世界'
)

println(pi)
println(world)

Constants are declared with const. They can only be defined at the module level (outside of functions).

Constant values can never be changed.

V constants are more flexible than in most languages. You can assign more complex values:

struct Color {
        r int
        g int
        b int
}

fn (c Color) str() string { return '{$c.r, $c.g, $c.b}' }

fn rgb(r, g, b int) Color { return Color{r: r, g: g, b: b} }

const (
        numbers = [1, 2, 3]

        red  = Color{r: 255, g: 0, b: 0}
        blue = rgb(0, 0, 255)
)

println(numbers)
println(red)
println(blue)

Global variables are not allowed, so this can be really useful.

When naming constants, snake_case must be used. Many people prefer all caps consts: TOP_CITIES. This wouldn't work well in V, because consts are a lot more powerful than in other languages. They can represent complex structures, and this is used quite often since there are no globals:

println('Top cities: $TOP_CITIES.filter(.usa)')
vs
println('Top cities: $top_cities.filter(.usa)')

println

println is a simple yet powerful builtin function. It can print anything: strings, numbers, arrays, maps, structs.

println(1) // "1"
println('hi') // "hi"
println([1,2,3]) // "[1, 2, 3]"
println(User{name:'Bob', age:20}) // "User{name:'Bob', age:20}"

If you don't want to print a newline, use print() instead.

Modules

cd ~/code/modules
mkdir mymodule
vim mymodule/mymodule.v

// mymodule.v
module mymodule

// To export a function we have to use `pub`
pub fn say_hi() {
	println('hello from mymodule!')
}

Build it with v build module ~/code/modules/mymodule.

That's it, you can now use it in your code:

module main

import mymodule

fn main() {
	mymodule.say_hi()
}

Note that you have to specify the module every time you call an external function. This may seem verbose at first, but it makes code much more readable and easier to understand, since it's always clear which function from which module is being called. Especially in large code bases.

Module names should be short, under 10 characters. Circular imports are not allowed.

You can create modules anywhere.

All modules are compiled statically into a single executable.

If you want to write a module that will automatically call some setup/initialization code when imported (perhaps you want to call some C library functions), write a module init function inside the module:

fn init() {
	// your setup code here ...
}

The init function cannot be public. It will be called automatically.

Interfaces

struct Dog {}
struct Cat {}

fn (d Dog) speak() string {
	return 'woof'
}

fn (c Cat) speak() string {
	return 'meow' 
}

interface Speaker {
	speak() string
}

fn perform(s Speaker) {
	println(s.speak())
}

dog := Dog{}
cat := Cat{}
perform(dog) // "woof" 
perform(cat) // "meow" 

A type implements an interface by implementing its methods. There is no explicit declaration of intent, no "implements" keyword.

Enums

enum Color {
	red green blue
}

fn main() {
	mut color := Color.red
	// V knows that `color` is a `Color`. No need to use `color = Color.green` here.
	color = .green
	println(color) // "1"  TODO: print "green"? 
	if color == .green {
		println("it's green")
	}
}

Sum types

type Expr = BinaryExpr | UnaryExpr | IfExpr 

struct BinaryExpr{ ... }
struct UnaryExpr{ ... }
struct IfExpr{ ... }

struct CallExpr {
	args []Expr
	...
}

fn (p mut Parser) expr(precedence int) ast.Expr {
	match p.tok {
		.key_if { return IfExpr{} }
		...
		else    { return BinaryExpr{} }
	}
}

fn gen(expr Expr) {
	match expr {
		.key_if { gen_if(it) }
		...
	}
}

fn gen_if(expr IfExpr) {
	...
}

Option/Result types & error handling

struct User {
	id int
	name string
}

struct Repo {
	users []User
}

fn new_repo() Repo {
	return Repo {
		users: [User{1, 'Andrew'}, User {2, 'Bob'}, User {10, 'Charles'}]
	}
}

fn (r Repo) find_user_by_id(id int) ?User {
	for user in r.users {
		if user.id == id {
			// V automatically wraps this into an option type 
			return user
		}
	}
	return error('User $id not found')
}

fn main() {
	repo := new_repo()
	user := repo.find_user_by_id(10) or { // Option types must be handled by `or` blocks 
		return  // `or` block must end with `return`, `break`, or `continue` 
	}
	println(user.id) // "10" 
	println(user.name) // "Charles"
}

V combines Option and Result into one type, so you don't need to decide which one to use.

The amount of work required to "upgrade" a function to an optional function is minimal: you have to add a ? to the return type and return an error when something goes wrong.

If you don't need to return an error, you can simply return none.

This is the primary way of handling errors in V. They are still values, like in Go, but the advantage is that errors can't be unhandled, and handling them is a lot less verbose.

err is defined inside an or block and is set to the string message passed to the error() function. err is empty if none was returned.

user := repo.find_user_by_id(7) or {
	println(err) // "User 7 not found"
	return
}

You can also propagate errors:

resp := http.get(url)?
println(resp.body)

Basically the code above is a shorter version of

resp := http.get(url) or {
	panic(err)
}
println(resp.body)

V does not have a way to force unwrap an optional (like Rust's unwrap() or Swift's !). You have to use or { panic(err) } instead.

Generics

struct Repo<T> {
	db DB
}

fn new_repo<T>(db DB) Repo<T> {
	return Repo<T>{db: db}
}

// This is a generic function. V will generate it for every type it's used with.
fn (r Repo<T>) find_by_id(id int) ?T {
	table_name := T.name // in this example getting the name of the type gives us the table name
	return r.db.query_one<T>('select * from $table_name where id = ?', id)
}

db := new_db()
users_repo := new_repo<User>(db)
posts_repo := new_repo<Post>(db)
user := users_repo.find_by_id(1)?
post := posts_repo.find_by_id(1)?

Concurrency

Decoding JSON

import json

struct User {
	name string
	age  int

	// Use the `skip` attribute to skip certain fields
	foo Foo [skip]  

	// If the field name is different in JSON, it can be specified
	last_name string [json:lastName]  
}

data := '{ "name": "Frodo", "lastName": "Baggins", "age": 25 }'
user := json.decode(User, data) or {
	eprintln('Failed to decode json')
	return
}
println(user.name)
println(user.last_name)
println(user.age)

JSON is very popular nowadays, that's why JSON support is built in.

The first argument of the json.decode function is the type to decode to. The second argument is the JSON string.

V generates code for JSON encoding and decoding. No runtime reflection is used. This results in much better performance.

Testing

// hello.v
fn hello() string {
	return 'Hello world'
}

// hello_test.v
fn test_hello() {
    assert hello() == 'Hello world'
}

To run the tests do v hello_test.v. To test an entire module, do v test mymodule.

assert keyword can be used outside of tests as well.

Memory management

fn draw_text(s string, x, y int) {
	...
}

fn draw_scene() {
	...
	draw_text('hello $name1', 10, 10)
	draw_text('hello $name2', 100, 10)
	draw_text(strings.repeat('X', 10000), 10, 50)
	...
}

In fact, the first two calls won't result in any allocations at all. These two strings are small, V will use a preallocated buffer for them.

fn test() []int {
	number := 7 // stack variable
	user := User{} // struct allocated on stack
	numbers := [1, 2, 3] // array allocated on heap, will be freed as the function exits
	println(number)
	println(user)
	println(numbers)
	numbers2 := [4, 5, 6] // array that's being returned, won't be freed here
	return numbers2
}

Defer

fn read_log() {
	f := os.open('log.txt')
	defer { f.close() }
	...
	if !ok {
		// defer statement will be called here, the file will be closed
		return
	}
	...
	// defer statement will be called here, the file will be closed
}

ORM

V has a built-in ORM that supports Postgres, and will soon support MySQL and SQLite.

The benefits of V ORM:

struct Customer { // struct name has to be the same as the table name for now
	id int // an integer id must be the first field
	name string
	nr_orders int
	country string
}

db := pg.connect(db_name, db_user)

// select count(*) from Customer
nr_customers := db.select count from Customer
println('number of all customers: $nr_customers')

// V syntax can be used to build queries
// db.select returns an array
uk_customers := db.select from Customer where country == 'uk' && nr_orders > 0
println(uk_customers.len)
for customer in uk_customers {
	println('$customer.id - $customer.name')
}

// by adding `limit 1` we tell V that there will be only one object
customer := db.select from Customer where id == 1 limit 1
println('$customer.id - $customer.name')

// insert a new customer
new_customer := Customer{name: 'Bob', nr_orders: 10}
db.insert(new_customer)

v fmt file.v

// clearall clears all bits in the array
fn clearall() {
}

#flag -lsqlite3
#include "sqlite3.h"

struct C.sqlite3
struct C.sqlite3_stmt

fn C.sqlite3_column_int(stmt C.sqlite3_stmt, n int) int

fn main() {
        path := 'users.db'
        db := &C.sqlite3;{!} // a temporary hack meaning `sqlite3* db = 0`
        C.sqlite3_open(path.str, &db;)
        query := 'select count(*) from users'
        stmt := &C.sqlite3;_stmt{!}
        C.sqlite3_prepare_v2(db, query.str, - 1, &stmt;, 0)
        C.sqlite3_step(stmt)
        nr_users := C.sqlite3_column_int(stmt, 0)
        C.sqlite3_finalize(stmt)
        println(nr_users)
}

#flag linux -lsdl2
#flag linux -Ivig
#flag linux -DCIMGUI_DEFINE_ENUMS_AND_STRUCTS=1
#flag linux -DIMGUI_DISABLE_OBSOLETE_FUNCTIONS=1
#flag linux -DIMGUI_IMPL_API=

$if windows {
	println('Windows')
}
$if linux {
	println('Linux')
}
$if mac {
	println('macOS')
}

$if debug {
	println('debugging')
}

// TODO: not implemented yet
fn decode<T>(data string) T {
        mut result := T{}
        for field in T.fields {
                if field.typ == 'string' {
                        result.$field = get_string(data, field.name)
                } else if field.typ == 'int' {
                        result.$field = get_int(data, field.name)
                }
        }
        return result
}

// generates to:
fn decode_User(data string) User {
        mut result := User{}
        result.name = get_string(data, 'name')
        result.age = get_int(data, 'age')
        return result
}

struct Vec {
	x int
	y int
}

fn (a Vec) str() string {
	return '{$a.x, $a.y}'
}

fn (a Vec) + (b Vec) Vec {
	return Vec {
		a.x + b.x,
		a.y + b.y
	}
}

fn (a Vec) - (b Vec) Vec {
	return Vec {
		a.x - b.x,
		a.y - b.y
	}
}

fn main() {
	a := Vec{2, 3}
	b := Vec{4, 5}
	println(a + b) // "{6, 8}" 
	println(a - b) // "{-2, -2}" 
}

fn main() {
	a := 10
	asm x64 {
		mov eax, [a]
		add eax, 10
		mov [a], eax
	}
}

#include <vector>
#include <string>
#include <iostream>

int main() {
        std::vector<std::string> s;
        s.push_back("V is ");
        s.push_back("awesome");
        std::cout << s.size() << std::endl;
        return 0;
}

fn main {
        mut s := []
	s << 'V is '
	s << 'awesome'
	println(s.len)
}

module main

import time
import os

[live]
fn print_message() {
	println('Hello! Modify this message while the program is running.')
}

fn main() {
	for {
		print_message()
		time.sleep_ms(500)
	}
}

v -os windows .

v -os linux .

rm('build/*')
// Same as: 
for file in ls('build/') {
	rm(file)
}

mv('*.v', 'build/')
// Same as: 
for file in ls('.') {
	if file.ends_with('.v') {
		mv(file, 'build/')
	}
}

break
const
continue
defer
else
enum
fn
for
go
goto
if
import
in
interface
match
module
mut
none
or
pub
return
struct
type

+    sum                    integers, floats, strings
-    difference             integers, floats
*    product                integers, floats
/    quotient               integers, floats
%    remainder              integers

&    bitwise AND            integers
|    bitwise OR             integers
^    bitwise XOR            integers

<<   left shift             integer << unsigned integer
>>   right shift            integer >> unsigned integer


Precedence    Operator
    5             *  /  %  <<  >>  &
    4             +  -  |  ^
    3             ==  !=  <  <=  >  >=
    2             &&
    1             ||


Assignment Operators
+=   -=   *=   /=   %=
&=   |=   ^=
>>=  <<=