```v fn foo() (int, int) { return 2, 3 } a, b := foo() println(a) // 2 println(b) // 3 ``` Functions can return multiple values.
```v pub fn public_function() { } fn private_function() { } ``` Like constants and types, functions are private (not exported) by default. To allow other modules to use them, prepend `pub`. The same applies to constants and types. ## Variables ```v 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.
```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. Note the (important) difference between `:=` and `=` `:=` is used for declaring and initializing, `=` is used for assigning.
```v fn main() { age = 21 } ``` This code will not compile, because the variable `age` is not declared. All variables need to be declared in V.
```v fn main() { age := 21 } ``` In development mode the compiler will warn you that you haven't used the variable (you'll get an "unused variable" warning). In production mode (enabled by passing the `-prod` flag to v – `v -prod foo.v`) it will not compile at all (like in Go).
```v 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 cause a compilation error. ## Primitive types ```v bool string i8 i16 int i64 i128 (soon) byte u16 u32 u64 u128 (soon) rune // represents a Unicode code point f32 f64 any_int, any_float // internal intermediate types of number literals byteptr // these two are mostly used for C interop voidptr any // similar to C's void* and Go's interface{} ``` Please note that unlike C and Go, `int` is always a 32 bit integer. There is an exceptions to the rule that all operators in V must have values of the same type on both sides. A small primitive type on one side can be automatically promoted if it fits completely into the data range of the type on the other side, i.e. when the promotion does not result in any data loss. These are the allowed possibilities: ``` i8 → i16 → int → i64 ↘ ↘ f32 → f64 ↗ ↗ byte → u16 → u32 → u64 ⬎ ↘ ↘ ↘ ptr i8 → i16 → int → i64 ⬏ ``` An `int` value for example can be automatically promoted to `f64` or `i64` but not to `f32` or `u32`. (`f32` would mean precission loss for large values and `u32` would mean loss of the sign for negative values). ## Strings ```v 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}'`. Format specifiers similar to those in C's `printf()` are also supported. `f`, `g`, `x`, etc. are optional and specify the output format. The compiler takes care of the storage size, so there is no `hd` or `llu`. ```v println('x = ${x:12.3f}') println('${item:-20} ${n:20d}') ``` All operators in V must have values of the same type on both sides. This code will not compile if `age` is not a string (for example if `age` were an `int`): ```v println('age = ' + age) ``` We have to either convert `age` to a `string`: ```v println('age = ' + age.str()) ``` or use string interpolation (preferred): ```v println('age = $age') ``` To denote character literals, use ` ```v a := `a` assert 'aloha!'[0] == `a` ``` For raw strings, prepend `r`. Raw strings are not escaped: ```v s := r'hello\nworld' println(s) // "hello\nworld" ``` ## Imports ```v import os fn main() { name := os.input('Enter your name:') println('Hello, $name!') } ``` Modules can be imported using keyword `import`. When using types, functions, and constants from other modules, the full path must be specified. In the example above, `name := input()` wouldn't work. That means that it's always clear from which module a function is called. ## Arrays ```v 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 // Declare an empty array: users := []User{} // We can also preallocate a certain amount of elements. ids := []int{ len: 50, init: 0 } // This creates an array with 50 zeros ``` The type of an array is determined by the first element: `[1, 2, 3]` is an array of ints (`[]int`). `['a', 'b']` is an array of strings (`[]string`). V arrays are homogenous (all elements must have the same type). This means that code like `[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. 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 the `.filter()` and `.map()` methods: ```v 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'] ``` `it` is a builtin variable which refers to element currently being processed in filter/map methods. ## Maps ```v 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') // Short syntax numbers := { 'one': 1, 'two': 2 } ``` ## If ```v 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: ```v num := 777 s := if num % 2 == 0 { 'even' } else { 'odd' } println(s) // "odd" ``` ## In operator `in` allows to check whether an array or a map contains an element. ```v nums := [1, 2, 3] println(1 in nums) // true m := {'one': 1, 'two': 2} println('one' in m) // true ``` It's also useful for writing clearer and more compact boolean expressions: ```v if parser.token == .plus || parser.token == .minus || parser.token == .div || parser.token == .mult { ... } if parser.token in [.plus, .minus, .div, .mult] { ... } ``` V optimizes such expressions, so both `if` statements above produce the same machine code and no arrays are created. ## For loop V has only one looping construct: `for`. ```v 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: ```v mut numbers := [1, 2, 3, 4, 5] for i, num in numbers { println(num) numbers[i] = 0 } ``` ```v 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. ```v mut num := 0 for { num++ if num >= 10 { break } } println(num) // "10" ``` The condition can be omitted, resulting in an infinite loop. ```v 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 ```v os := 'windows' print('V is running on ') match os { 'darwin' { println('macOS.') } 'linux' { println('Linux.') } else { println(os) } } number := 2 s := match number { 1 { 'one' } 2 { 'two' } else { '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. ```v 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 ```v 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: ```v // 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 allow subclassing, but it supports embedded structs: ```v // 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) ```
```v struct Foo { n int // n is 0 by default s string // s is '' by default a []int // a is `[]int{}` by default pos int = -1 // custom default value } ``` All struct fields are zeroed by default during the creation of the struct. Array and map fields are allocated. It's also possible to define custom default values. ## Short struct initialization syntax There are no default function argument values or named arguments, for that the short struct initialization syntax can be used instead: ```v struct ButtonConfig { text string is_disabled bool width int = 70 height int = 20 } fn new_button(c ButtonConfig) &Button { return &Button{ width: c.width height: c.height text: c.text } } button := new_button(text:'Click me', width:100) // the height is unset, so it's 20, the default value ``` As you can see, we can use ``` new_button(text:'Click me', width:100) ``` instead of ``` new_button(ButtonConfig{text:'Click me', width:100}) ``` This only works with functions that have a single struct argument. ## 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: ```v 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: ```v 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. The `len` field is public, but immutable: ```v fn main() { str := 'hello' len := str.len // OK str.len++ // Compilation error } ``` This means that defining public readonly fields is very easy in V, no need in getters/setters or properties. ## Methods ```v 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 V functions are pure by default, meaning that their return values are a function of their arguments only, and their evaluation has no side effects. 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 purely functional language however. It is possible to modify function arguments by using the keyword `mut`: ```v struct User { mut: is_registered bool } fn (mut u 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: ```v fn multiply_by_2(mut arr []int) { for i in 0..arr.len { 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 the modification of arguments with primative types such as integers. Only more complex types such as arrays and maps may be modified. Use `user.register()` or `user = register(user)` instead of `register(mut user)`. V makes it easy to return a modified version of an object: ```v fn register(u User) User { return { u | is_registered: true } } user = register(user) ``` ## Anonymous & high order functions ```v 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" // Anonymous functions can be declared inside other functions: double_fn := fn(n int) int { return n + n } println(run(5, double_fn)) // "10" // Functions can be passed around without assigning them to variables: res := run(5, fn(n int) int { return n + n }) } ``` ## References ```v fn (foo Foo) bar_method() { ... } fn bar_function(foo Foo) { ... } ``` If a function argument is immutable (like `foo` in the examples above) V can pass it either value or reference. The compiler will determine this by itself, and the developer doesn't need to think about it. You no longer need to remember whether you should pass the struct by value or by reference. You can ensure that the struct is always passed by reference by adding `&`: ```v fn (foo &Foo) bar() { println(foo.abc) } ``` `foo` is still immutable and can't be changed. For that, `(mut foo Foo)` has to be used. In general, V's references are similar to Go pointers and C++ references. For example, a tree structure definition would look like this: ```v struct Node