Chapter 1 Getting Started with V

Quick Access

Below is an index of all code examples in this chapter. You can use these links to jump directly to any specific code example:

Code Comments

• Single Line Comments
• Multi Line Comments
• Programm Commented All Places

This chapter introduces the core design philosophies of V. You will learn how to set up your development environment, compile and run programs, and document your code using comments.

Under the Hood: The V Compilation Pipeline & Architecture

Understanding how V compiles and executes your code is fundamental to writing high-performance, idiomatic applications. Unlike languages that rely on virtual machines or heavy runtime interpreters, V is a native compiled language with a uniquely fast and transparent pipeline.

The 5 Stages of the V Compiler Pipeline

1. Single-Pass Parsing & AST Generation:

The V compiler reads source files in a single pass, constructing a streamlined Abstract Syntax Tree (AST). V deliberately omits complex macro expansion phases or runtime template interpretation, allowing AST construction to finish in milliseconds.

1. Static Type Checking & Safety Analysis:

The compiler enforces V's core safety invariants: immutability by default, absence of unhandled null values, no variable shadowing, and bounds checking on array accesses. Type checking and compile-time reflection are resolved entirely during this pass.

1. C99 Source Code Emission:

Rather than inventing an unoptimized intermediate machine-code generator, V transforms the AST directly into clean, human-readable C99 source code. This design grants V immediate compatibility with existing C libraries, debuggers (GDB, LLDB), and CPU architectures.

1. Native C Compiler Execution:

V invokes a backend C compiler to produce the final machine code:

• TCC (Tiny C Compiler): Used by default in development mode. TCC compiles C code in under 0.1 seconds, delivering near-instant v run feedback loops.
• Clang / GCC: Used when building release binaries (v -prod). Clang/GCC apply advanced optimization passes, Link-Time Optimization (LTO), and vectorization.

1. Direct Machine Code Generation (v -native):

In addition to C emission, V contains built-in native backends for x86_64, ARM64, and WebAssembly (wasm32). These backends emit raw machine code directly without invoking an external C compiler.

+----------------+      +-------------+      +-------------------+      +--------------------+      +---------------+
|   .v Source    | ---> | Single-Pass | ---> | Static Safety &   | ---> | C99 Emission or    | ---> | Native Binary |
|   Files        |      | Parser/AST  |      | Type Verification |      | Direct x64/ARM/Wasm|      | (< 1MB size)  |
+----------------+      +-------------+      +-------------------+      +--------------------+      +---------------+

Essential Compiler Flags Reference

| Flag | Purpose | Description |

| :--- | :--- | :--- |

| v run <file.v> | Rapid Development | Compiles in memory with TCC and executes immediately. |

| v -prod <file.v> | Production Release | Emits optimized C, applies -O3 / -flto, and strips debug symbols for minimal binary size. |

| v -g <file.v> | Debugging | Generates DWARF debug symbols for use with GDB / LLDB / VSCode debugger. |

| v -show-c-output <file.v> | Inspection | Prints or saves the generated C code so you can inspect compiler output directly. |

| v fmt -w <file.v> | Formatting | Formats the source code according to the official V style guide. |

| v -os <target> | Cross-Compilation | Cross-compiles for windows, linux, macos, or wasm32-wasi. |

Code Comments

Single Line Comments

Single Line Comments

Comments are non-executable lines of text in a program that explain what the code does. They are ignored by the compiler but are essential for human developers. This lesson on Single Line Comments demonstrates how to write and format comments in V.

module main

// greet function prints greetings to the console
pub fn greet() {
	println('Hello, Welcome to the Jungle!')
}

fn main() {
	greet()
}

Multi Line Comments

Multi Line Comments

In V, multi-line (or block) comments are enclosed between /* and */.

module main

/*
multiply is a function that accepts two integer arguments (x and y).
It performs multiplication and returns the integer product.

Note: Comments formatted like this (/* ... */) do not show in code hints
using v-analyzer or `v doc`. You must use `//` for each line to enable IDE hints.

/*
Note: In V, block comments can be nested.
This is a nested block comment. In standard C, nesting block comments
would cause a compile error, but V's compiler parses them correctly.
*/
This is the end of the outer block comment.
*/
fn multiply(x int, y int) int {
	return x * y
}

fn main() {
	println(multiply(4, 5))
}

Programm Commented All Places

Programm Commented All Places

Comments are non-executable lines of text in a program that explain what the code does. They are ignored by the compiler but are essential for human developers. This lesson on Programm Commented All Places demonstrates how to write and format comments in V.

module main

// Space3D A struct indicating the 3 dimensional coordinate system
struct Space3D {
mut:
	x int
	// x is an integer field that represents coordinate
	y int
	// y is an integer field that represents coordinate
	z int
	// z is an integer field that represents coordinate
}

/*
get_point is a function that returns a struct of Type Space3D with points x,y,z passed as input arguments to it
x is an input argument accepts values of type of int
y is an input argument accepts values of type of int
z is an input argument accepts values of type of int
get_point function returns a Struct result of type Space3D with its coordinates set as value passed as input arguments x, y and z
*/
fn get_point(x int, y int, z int) Space3D {
	return Space3D{
		x: x
		y: y
		z: z
	}
}

const origin = get_point(0, 0, 0)

// Defining origin as a constant
fn main() {
	// origin := Space3D {x: 0, y: 0, z:0}
	println(origin)
}

Chapter 2 Variables and Constants

Quick Access

Below is an index of all code examples in this chapter. You can use these links to jump directly to any specific code example:

Constants

• Define Single Constant
• Define Multiple Constants
• Define Constant Of Type Struct
• Define Constant Of Type Function
• Define Module Level Constants
• Cannot Define Constants Inside Functions
• Constants Module - Main (main.v)
• Constant Module Prefix - Helper (file1.v)

Variables

• Parallel Declaration Immutable Variables
• Parallel Declaration Mutable Variables
• Parallel Declaration Mut And Immutable Vars
• Augmented Assignment String
• Augmented Assignment Integer
• Declare Mutable Variable
• Cannot Update Mutable With Another Type
• Declare Immutable Variable
• Cannot Update Immutable Variables
• Declared And Assigned
• Declared And Not Assigned
• Unused Variables Will Be Warned
• Global Variables Not Allowed - Scope Demo
• Global Variables Not Allowed - File Scope Demo
• Variable Redeclaration
• Variable Scope For Same Variable Names
• Variable Shadowing Not Allowed

Variables are the basic storage units of any program. In this chapter, we explore how V handles variables with a safety-first mindset: variables are immutable by default, variable shadowing is forbidden, and constants are declared in module scopes. You will learn to manage program data safely and cleanly.

Under the Hood: Immutability, Memory Layout & Constant Inlining

V approaches variables and constants with a strict safety-first design philosophy. Understanding how memory is laid out and how the compiler optimizes bindings eliminates common debugging traps.

Memory Representation of Immutable vs Mutable Bindings

* Immutable Variables (x := 10):

When a variable is declared without mut, the V compiler registers it as an immutable binding. In the emitted C code, this translates to a const local variable allocated on the CPU stack. The compiler statically rejects any assignment or modification to this memory address.

* Mutable Variables (mut y := 10):

Declaring a variable with mut creates a standard mutable stack slot. Modifying y = 20 alters the value stored at that stack offset in-place without heap allocation.

* Type Rigidity:

Once a variable is declared, its type is permanently fixed. V prohibits changing the type of a mutable variable (e.g., assigning a string to an integer variable), preventing dynamic type confusion bugs.

Stack Frame:
+-------------------------------+-----------------------------------+
|  const int x = 10 (Immutable) |  int y = 20 (Mutable Stack Slot)  |
+-------------------------------+-----------------------------------+

Zero-Cost Compile-Time Constants

Constants declared in const (...) blocks possess unique runtime characteristics:

1. Compile-Time Folding: Scalar constants (integers, floats, string literals) are evaluated and folded during compilation. The compiler substitutes the literal value directly at the callsite.
2. Global Read-Only Data (.rodata): Complex constants (structs, arrays) are emitted as static read-only symbols placed in the .rodata binary section, incurring zero initialization runtime cost when your application boots.
3. Module Scoping: Constants are module-level and cannot be declared inside function bodies. This enforces clean separation between constant domain configuration and local procedural state.

Why Variable Shadowing is Strictly Prohibited

In many languages (such as JavaScript, Python, C++, and Rust), an inner block scope can redeclare a variable with the same name as an outer scope:

// FORBIDDEN IN V:
fn example() {
    count := 10
    if true {
        count := 20 // Compile Error: duplicate variable name `count`
    }
}

V treats variable shadowing as a compile-time error. Shadowing is one of the most frequent sources of subtle logic bugs in large codebases (where an engineer intends to update an outer variable but accidentally declares a new local variable). By disallowing shadowing, V guarantees that every identifier within a function refers unambiguously to a single declared memory location.

Constants

Define Single Constant

Define Single Constant

Constants in V are defined using the const block. Constants are values that are known at compile time and never change throughout the execution of the program. By convention, constant names are written in lowercase, unlike many other languages.

This example shows how to define and use a single constant.

const app_name = 'V on Wheels'

fn main() {
	println(app_name)
}

Define Multiple Constants

Define Multiple Constants

You can define multiple constants within a single const block. This keeps related constants grouped together and makes the code cleaner.

This example shows how to declare multiple constants (integers, strings, floats) together.

const app_name = 'V on Wheels'
const max_connections = 1000
const decimal_places = 2
const pi = 3.14

fn main() {
	println(app_name)
	println(max_connections)
	println(decimal_places)
	println(pi)
}

Define Constant Of Type Struct

Define Constant Of Type Struct

Variables and constants store state in V programs. This lesson on Define Constant Of Type Struct covers declaration rules, default values, scopes, or constant naming conventions.

module main

struct Space3D {
mut:
	x int
	y int
	z int
}

const origin = Space3D{
	x: 0
	y: 0
	z: 0
}

fn main() {
	println(origin)
}

Define Constant Of Type Function

Define Constant Of Type Function

Variables and constants store state in V programs. This lesson on Define Constant Of Type Function covers declaration rules, default values, scopes, or constant naming conventions.

module main

struct Space3D {
mut:
	x int
	y int
	z int
}

fn get_point(x int, y int, z int) Space3D {
	return Space3D{
		x: x
		y: y
		z: z
	}
}

const origin = get_point(0, 0, 0)

fn main() {
	println(origin)
}

Define Module Level Constants

Define Module Level Constants

Variables and constants store state in V programs. This lesson on Define Module Level Constants covers declaration rules, default values, scopes, or constant naming conventions.

module main

const app_name = 'V on Wheels'

fn main() {
	println(app_name)
}

Cannot Define Constants Inside Functions

Cannot Define Constants Inside Functions

Variables and constants store state in V programs. This lesson on Cannot Define Constants Inside Functions covers declaration rules, default values, scopes, or constant naming conventions.

module main

const app_name = 'V on Wheels'

fn main() {
        const greet = 'hi' // this is not top level constant definition, throws error.
        println(app_name)
}

Constants Module - Main (main.v)

Constants Module - Main

Variables and constants store state in V programs. This lesson on Main covers declaration rules, default values, scopes, or constant naming conventions.

module main

import mod1

fn main() {
	mod1.do_work()
}

Constant Module Prefix - Helper (file1.v)

Constant Module Prefix - Helper

Variables and constants store state in V programs. This lesson on File1 covers declaration rules, default values, scopes, or constant naming conventions.

module mod1

const greet_count = 5

pub fn do_work() {
	println(greet_count)
}

Variables

Parallel Declaration Immutable Variables

Parallel Declaration Immutable Variables

In V, you can declare and initialize multiple variables in a single line. This is known as parallel declaration. By default, variables in V are immutable (read-only). Once assigned a value, they cannot be changed.

This program demonstrates declaring two variables a and b at the same time and assigning them initial values. Any attempt to modify a or b later in the code will cause a compile-time error.

fn main() {
	first_name, last_name, age := 'Ada', 'Lovelace', 36
	println('${first_name} ${last_name} is ${age} years old')
	println('Next milestone: ${first_name} will speak at the conference')
}

Parallel Declaration Mutable Variables

Parallel Declaration Mutable Variables

If you want to modify parallelly declared variables later, you must explicitly mark them as mutable using the mut keyword. In V, mutability is always explicit to make code safer and easier to reason about.

Here, we declare two mutable variables a and b at the same time using mut. We then reassign their values using the standard assignment operator (=).

fn main() {
	mut greeting, mut recipient := 'Hi', 'world'
	println('${greeting}, ${recipient}!')

	greeting, recipient = 'Hello', 'Ada'
	println('${greeting}, ${recipient}!')
}

Parallel Declaration Mut And Immutable Vars

Parallel Declaration Mut And Immutable Vars

Variables and constants store state in V programs. This lesson on Parallel Declaration Mut And Immutable Vars covers declaration rules, default values, scopes, or constant naming conventions.

fn main() {
	mut message, count := 'Hello', 32
	println(message)
	message = 'Hi'
	println(message)
	println(count)
}

Augmented Assignment String

Augmented Assignment String

Variables and constants store state in V programs. This lesson on Augmented Assignment String covers declaration rules, default values, scopes, or constant naming conventions.

fn main() {
	mut greeting := 'Hi'
	println(greeting)

	greeting = greeting + ' there'
	println(greeting)

	greeting += ', how are you today?'
	println(greeting)
}

Augmented Assignment Integer

Augmented Assignment Integer

Variables and constants store state in V programs. This lesson on Augmented Assignment Integer covers declaration rules, default values, scopes, or constant naming conventions.

fn main() {
	mut score := 10
	println(score)

	score = score + 5
	println(score)

	score += 5
	println(score)
}

Declare Mutable Variable

Declare Mutable Variable

By default, all variables in V are immutable (their values cannot change). To declare a variable whose value can be modified later, you must prepend the mut keyword before the variable name.

This example shows how to declare a mutable variable, change its value, and print the results.

fn main() {
	mut counter := 0
	counter += 1
	println(counter)
}

Cannot Update Mutable With Another Type

Cannot Update Mutable With Another Type

Variables and constants store state in V programs. This lesson on Cannot Update Mutable With Another Type covers declaration rules, default values, scopes, or constant naming conventions.

fn main() {
	mut i := 10
	i = 100
	i = 'Apple' // throws error
}

Declare Immutable Variable

Declare Immutable Variable

In V, variables are immutable by default. This design choice prevents accidental state mutation bugs, making code easier to reason about and safer for concurrency. When you declare a variable using the declaration operator :=, you are creating a read-only variable. If you try to reassign this variable later, the compilation will fail. This approach is similar to declaring constants in other languages, but it operates at the local scope level.

This example demonstrates how to declare an immutable variable and print its value.

fn main() {
	// 'msg' is initialized as an immutable string variable using :=
	msg := 'Hello'
	println(msg)
}

Cannot Update Immutable Variables

Cannot Update Immutable Variables

One of V's core safety features is immutability by default. If you declare a variable without the mut keyword and then try to reassign it a new value, the compiler will refuse to compile the program.

This example demonstrates what happens when you try to update an immutable variable (expect a compiler error).

fn main() {
	msg := 'Hello'
	msg = 'Good Day!' // throws error
}

Declared And Assigned

Declared And Assigned

Variables and constants store state in V programs. This lesson on Declared And Assigned covers declaration rules, default values, scopes, or constant naming conventions.

fn main() {
	mut i := 0
	// declared and assigned
	println(i)
}

Declared And Not Assigned

Declared And Not Assigned

V does not allow variables to be declared without an initial value. Unlike other languages that initialize variables to a default 'zero' value or null, V forces you to explicitly provide a value. This prevents uninitialized variable bugs.

This example illustrates that declaring a variable without an assignment is a compilation error.

fn main() {
	mut a // throws error
}

Unused Variables Will Be Warned

Unused Variables Will Be Warned

To keep codebases clean and efficient, the V compiler detects if you declare a variable but never use (consume) it. By default, V treats unused variables as a compilation warning/error, encouraging you to clean up dead code.

This example shows a declared variable that is never used.

fn main() {
	i := 'hello' // i is not used anywhere, so warns when run in dev mode and throws error when run in prod mode
	x := 3
	y := 2
	println(x + y)
}

Global Variables Not Allowed - Scope Demo

Global Variables Not Allowed - Scope Demo

V does not allow global variables by default. Global state is a major source of bugs, race conditions in multi-threaded applications, and poor code structure. By forbidding globals, V enforces clean, modular code passing state via arguments.

These examples demonstrate that declaring variables outside of the main function or modules is strictly prohibited.

module main

fn method1() {
	msg := 'Hello from Method1'
	println(msg)
}

fn main() {
	method1()
	println(msg) // Will throw error as msg declared and accessible only in method1
}

Global Variables Not Allowed - File Scope Demo

Global Variables Not Allowed - File Scope Demo

V does not allow global variables by default. Global state is a major source of bugs, race conditions in multi-threaded applications, and poor code structure. By forbidding globals, V enforces clean, modular code passing state via arguments.

These examples demonstrate that declaring variables outside of the main function or modules is strictly prohibited.

module main

fn method1() {
	if true {
		mut b := 10
		b++
	}
	println(b)
}

fn main() {
	method1()
}

Variable Redeclaration

Variable Redeclaration

Variables and constants store state in V programs. This lesson on Variable Redeclaration covers declaration rules, default values, scopes, or constant naming conventions.

module main

fn main() {
        x := 3
        y := 2
        println(x + y)
        x := 5 // re-definition of variable x is not allowed
}

Variable Scope For Same Variable Names

Variable Scope For Same Variable Names

In V, variables are strictly scoped to the function or block in which they are declared. This lexical scoping means that two different functions can declare variables with the exact same name (e.g., msg) without any collision or interference. The compiler guarantees that these variables occupy separate locations in memory and are completely isolated from one another. This allows developers to use common, context-appropriate names like temp, id, or msg locally inside individual functions without worrying about global or cross-functional namespace pollution.

This program illustrates how msg is declared separately in both method1 and method2, showing scope isolation in action.

module main

fn method1() {
	// 'msg' is local only to method1
	msg := 'Hello from Method1'
	println(msg)
}

fn method2() {
	// 'msg' is local only to method2; does not conflict with method1's 'msg'
	msg := 'Hello from Method2'
	println(msg)
}

fn main() {
	method1()
	method2()
}

Variable Shadowing Not Allowed

Variable Shadowing Not Allowed

Variable shadowing happens when a variable declared within an inner scope (like an if block, a loop, or a function body) has the same name as a variable in an outer scope. V strictly forbids variable shadowing at the compiler level. Prohibiting shadowing prevents a class of common bugs where a developer accidentally updates a local inner variable instead of the intended outer variable, or vice versa.

This example demonstrates how V rejects shadowed variable declarations.

module main

fn scope_demo() {
	// 'x' is declared in the function's main scope
	x := 10
	println(x)
	if true {
		// ERROR: Declaring another variable named 'x' in an inner block is forbidden.
		// To fix this, you must name the inner variable something else.
		x := 20 
		println(x)
	}
	println(x)
}

fn main() {
	scope_demo()
}

Chapter 3 Primitive Data Types

Quick Access

Below is an index of all code examples in this chapter. You can use these links to jump directly to any specific code example:

Primitive Types Demo

• Primitive Types Demo Code

Boolean Type

• Logical Operators
• Relational Operators
• Boolean Methods

Numeric Types

• Declaring Integers
• Hex Binary Octa Notation Of Declaring Integers
• Promoting Numeric Types
• Arithmetic Operators
• Bitwise Operators
• Shift Operators
• Shift Operator On Range Of Integers
• Integer Methods
• Float Methods
• U8 Methods
• Size Pointer Methods

Rune Type

• Declare Rune
• Rune Operations With Strings
• Rune Methods

String Type

• Declare String
• String Read Only Array Of Bytes
• Strings Immutable By Default
• Declaring Mutable Strings
• Cannot Mutate String Elements
• String Interpolation
• Escape Special Characters
• Declare Raw Strings
• String Concatenation Using Plus Sign
• String Concatenation Using Interpolation
• Extract Substring From String Literal
• Split String
• String To Runes Array
• Count Sub String Occurences
• Check String Contains Substring
• String Contains Is Case Sensitive
• Common String Methods

Primitive Types Demo

Primitive Types Demo Code

Primitive Types Demo Code

This comprehensive example demonstrates every primitive data type in V:

• Boolean: bool (representing true or false).
• String: string (representing an immutable array of bytes).
• Rune: rune (representing a single Unicode code point, alias for u32).
• Signed Integers: i8 (8-bit), i16 (16-bit), int (32-bit), i64 (64-bit).
• Unsigned Integers: u8 (8-bit), u16 (16-bit), u32 (32-bit), u64 (64-bit).
• Platform-dependent sizes: isize (signed size of a pointer), usize (unsigned size of a pointer).
• Floating Point Numbers: f32 (32-bit single-precision), f64 (64-bit double-precision).

For each type, the example initializes a value and prints its value, type (using typeof(var).name), and size in bytes (using sizeof(var)).

module main

fn main() {
	println('==================================================')
	println('        Vlang Primitive Data Types Demo           ')
	println('==================================================')

	// 1. Boolean Type
	b := true
	println('Boolean: val: ${b} | type: ${typeof(b).name} | size: ${sizeof(b)} byte')

	// 2. String Type
	s := 'Hello, V!'
	println('String:  val: "${s}" | type: ${typeof(s).name} | size: ${sizeof(s)} bytes')

	// 3. Rune Type (unicode character, represented as `r` prefix or backticks)
	r := `V`
	println('Rune:    val: ${r} (char: ${r.str()}) | type: ${typeof(r).name} | size: ${sizeof(r)} bytes')

	// 4. Signed Integers
	i_8 := i8(-128)
	i_16 := i16(-32768)
	i_32 := int(-2147483648)
	i_64 := i64(-9223372036854775808)
	println('i8:      val: ${i_8} | type: ${typeof(i_8).name} | size: ${sizeof(i_8)} byte')
	println('i16:     val: ${i_16} | type: ${typeof(i_16).name} | size: ${sizeof(i_16)} bytes')
	println('int:     val: ${i_32} | type: ${typeof(i_32).name} | size: ${sizeof(i_32)} bytes')
	println('i64:     val: ${i_64} | type: ${typeof(i_64).name} | size: ${sizeof(i_64)} bytes')

	// 5. Unsigned Integers
	u_8 := u8(255)
	u_16 := u16(65535)
	u_32 := u32(4294967295)
	u_64 := u64(18446744073709551615)
	println('u8:      val: ${u_8} | type: ${typeof(u_8).name} | size: ${sizeof(u_8)} byte')
	println('u16:     val: ${u_16} | type: ${typeof(u_16).name} | size: ${sizeof(u_16)} bytes')
	println('u32:     val: ${u_32} | type: ${typeof(u_32).name} | size: ${sizeof(u_32)} bytes')
	println('u64:     val: ${u_64} | type: ${typeof(u_64).name} | size: ${sizeof(u_64)} bytes')

	// 6. Platform-dependent Sizes
	isize_val := isize(-12345)
	usize_val := usize(12345)
	println('isize:   val: ${isize_val} | type: ${typeof(isize_val).name} | size: ${sizeof(isize_val)} bytes')
	println('usize:   val: ${usize_val} | type: ${typeof(usize_val).name} | size: ${sizeof(usize_val)} bytes')

	// 7. Floating Point Numbers
	f_32 := f32(3.14159)
	f_64 := f64(2.718281828459)
	println('f32:     val: ${f_32} | type: ${typeof(f_32).name} | size: ${sizeof(f_32)} bytes')
	println('f64:     val: ${f_64} | type: ${typeof(f_64).name} | size: ${sizeof(f_64)} bytes')

	println('==================================================')
}

V is a statically-typed language, meaning every variable has a fixed data type at compile time. In this chapter, you will learn about V's primitive types: booleans for logic, numeric types for numbers, runes for single characters, and strings for text. You will also learn about V's rich set of built-in methods on these types.

Under the Hood: Primitive Data Representation, Strings & UTF-8

Every primitive type in V is engineered for predictable memory footprint, binary compatibility with C, and strict safety.

Primitive Memory Map & Sizing

| V Type | C Equivalent | Size (Bytes) | Range / Purpose |

| :--- | :--- | :--- | :--- |

| bool | bool | 1 byte | true or false |

| i8 / u8 | int8_t / uint8_t | 1 byte | -128 to 127 / 0 to 255 (byte) |

| i16 / u16 | int16_t / uint16_t | 2 bytes | 16-bit signed / unsigned integers |

| int / i32 / u32 | int32_t / uint32_t | 4 bytes | Standard 32-bit integer |

| i64 / u64 | int64_t / uint64_t | 8 bytes | 64-bit signed / unsigned integers |

| f32 / f64 | float / double | 4 / 8 bytes | IEEE 754 floating-point numbers |

| rune | uint32_t | 4 bytes | Unicode code point (u32) |

| isize / usize | ptrdiff_t / size_t | 4 or 8 bytes | Pointer-sized integers |

The Memory Layout of a V `string`

In V, a string is a 16-byte structure on 64-bit systems. It is defined internally as:

struct string {
pub:
    str    &u8 // Pointer to raw UTF-8 byte array (null-terminated)
    len    int // Length of the string in bytes
    is_lit int // 1 if string literal (static .rodata), 0 if heap-allocated
}

Key architectural benefits of this design:

• Zero-Copy C Interoperability: Because the underlying str byte buffer is guaranteed to be null-terminated (), passing a V string to any C library function (printf, sqlite3_open, fopen) requires only s.str—with zero memory allocation or copying.
• Immutability & Safety: V strings are immutable. Slicing a string (s[0..5]) creates a new string header pointing to the same memory segment without deep copying.

Byte Indexing (`s[i]`) vs Unicode Runes (`s.runes()`)

Because V strings are UTF-8 encoded:

• s[i] accesses the raw byte (u8) at byte offset i in $O(1)$ constant time.
• ASCII characters occupy 1 byte, while international characters (e.g. ñ, 日, 🦀) occupy between 2 to 4 bytes.
• To iterate over human-readable characters, call s.runes(), which decodes UTF-8 bytes into 4-byte rune (u32) Unicode code points.

String Interpolation Internals

When you write:

greeting := 'Hello, ${name}! You have ${unread_count} new messages.'

The V compiler does not invoke a slow runtime formatting engine (like sprintf). Instead, it analyzes the template at compile time and emits optimized calls to strings.new_builder(estimated_size), appending each component directly into a pre-sized buffer.

Boolean Type

Logical Operators

Logical Operators

In V, primitive data types are the core building blocks of the language. This section details how to declare and use Logical Operators in a simple, straightforward manner. Beginners should pay close attention to how variables of this type are initialized and how built-in methods are called on them.

module main

fn main() {
	t := true
	f := false

	// Logical And using && operator
	and_tt := t && t
	and_tf := t && f
	and_ft := f && t
	and_ff := f && f

	println('Logical And using && operator')
	println('${t} && ${t} = ${and_tt}')
	println('${t} && ${f} = ${and_tf}')
	println('${f} && ${t} = ${and_ft}')
	println('${f} && ${f} = ${and_ff}')
	println('')

	// Logical OR using || operator
	or_tt := t || t
	or_tf := t || f
	or_ft := f || t
	or_ff := f || f

	println('Logical OR using || Operator')
	println('${t} || ${t} = ${or_tt}')
	println('${t} || ${f} = ${or_tf}')
	println('${f} || ${t} = ${or_ft}')
	println('${f} || ${f} = ${or_ff}')
	println('')

	// Logical not using ! Operator
	not_t := !t
	not_f := !f

	println('Logical not using ! Operator')
	println('!${t} = ${not_t}')
	println('!${f} = ${not_f}')
}

Relational Operators

Relational Operators

In V, primitive data types are the core building blocks of the language. This section details how to declare and use Relational Operators in a simple, straightforward manner. Beginners should pay close attention to how variables of this type are initialized and how built-in methods are called on them.

module main

struct Note {
	id        int
	detail    string
	completed bool
}

fn main() {
	mut n := Note{
		id:     1001
		detail: 'get groceries'
	}
	println(n.completed) // un-assigned bool field will be false by default

	// Comparing using Relational operator >
	if n.id > 1000 { // comparison of note id of integer type to another integer evaluates to a boolean
		println('The note id is greater than 1000')
	} else {
		println('The note id is less than 1000')
	}

	// Comparing using Relational operator ==
	if n.detail == 'get groceries' {
		println('The note details about groceries')
	}

	// Comparing using Relational operator !=
	if n.detail != 'get dairy products' {
		println('The note does not details about dairy products')
	}
}

Boolean Methods

Boolean Methods

Booleans in V are simple true or false values. V provides built-in methods on boolean types, such as str(), which converts the boolean value to its string representation ('true' or 'false').

This is useful for logging, printing, or interpolating booleans into strings.

module main

fn main() {
	t := true
	f := false

	// str() returns string representation ('true' or 'false')
	println(t.str()) // true
	println(f.str()) // false
}

Numeric Types

Declaring Integers

Declaring Integers

V has several built-in integer types, both signed and unsigned, of various sizes (e.g., i8, i16, i32, i64 for signed integers, and u8, u16, u32, u64 for unsigned integers). If you declare an integer using :=, V defaults to the standard 32-bit integer (int).

This example demonstrates how to declare different integer types.

module main

fn main() {
	x := 1
	println(typeof(x).name)
	// int

	i := 1_000
	j := 1000

	println(i == j) // true
}

Hex Binary Octa Notation Of Declaring Integers

Hex Binary Octa Notation Of Declaring Integers

V has several built-in integer types, both signed and unsigned, of various sizes (e.g., i8, i16, i32, i64 for signed integers, and u8, u16, u32, u64 for unsigned integers). If you declare an integer using :=, V defaults to the standard 32-bit integer (int).

This example demonstrates how to declare different integer types.

module main

fn demo() {
	h1 := 0x64 // hexadecimal starts with 0x
	b1 := 0b1100100 // binary starts with 0b
	o1 := 0o144 // Octal starts with 0o
	println('Value of var h1 with hexadecimal value : ${h1}')
	println('Data type of var h1 with hexadecimal value : ${typeof(h1).name}')
	println('Value of var b1 with binary value : ${b1}')
	println('Data type of var b1 with binary value : ${typeof(b1).name}')
	println('Value of var o1 with octal value : ${o1}')
	println('Data type of var o1 with octal value : ${typeof(o1).name}')
}

fn main() {
	demo()
}

Promoting Numeric Types

Promoting Numeric Types

V is very strict about types. It does not perform implicit type conversion (coercion) between different numeric types to prevent accidental precision loss or overflow bugs. If you want to perform arithmetic operations on different types, you must explicitly cast them.

This example shows how to cast (promote) smaller integer types to larger ones or to floats.

module main

fn demo() {
	ia := i8(2)
	ib := i16(2)
	ic := int(2)

	println('----type definitions----')
	println('variable ia is of type: ${typeof(ia).name}')
	println('variable ib is of type: ${typeof(ib).name}')
	println('variable ic is of type: ${typeof(ic).name}')
	println('')
	iaa := ia + ia // i8 with i8 results i8
	ibb := ib + ib // i16 with i16 results i16
	icc := ic + ic // int with int results int
	println('----mixing types----')
	println('variable iaa is of type: ${typeof(iaa).name}, after adding type ${typeof(ia).name} with itself')
	println('variable ibb is of type: ${typeof(ibb).name}, after adding type ${typeof(ib).name} with itself')
	println('variable icc is of type: ${typeof(icc).name}, after adding type ${typeof(ic).name} with itself')
	println('')
	iab := ia + ib // i8 with i16 results in i16
	ibc := ib - ic // i16 with i32 results in i32
	println('----type promotion----')
	println('variable iab is promoted to type: ${typeof(iab).name}, after adding type ${typeof(ia).name} with ${typeof(ib).name}')
	println('variable ibc is promoted to type: ${typeof(ibc).name}, after subtracting type ${typeof(ib).name} with ${typeof(ic).name}')

	iba := ib / ia // the division of i16 and i8 types
	println('Variable iba is promoted to the higher data type ${typeof(iba).name} which is carried from ib of type ${typeof(ib).name} divided from variable ia of type ${typeof(ia).name}')

	fa := f32(2)

	fa_iba := fa + iba // fa is type of f32 and iba is of type i32
	println('Variable fa_iba is promoted to the higher data type ${typeof(fa_iba).name} which is carried from fa of type ${typeof(fa).name} when added with variable iba of type ${typeof(iba).name}')
}

fn main() {
	demo()
}

Arithmetic Operators

Arithmetic Operators

In V, primitive data types are the core building blocks of the language. This section details how to declare and use Arithmetic Operators in a simple, straightforward manner. Beginners should pay close attention to how variables of this type are initialized and how built-in methods are called on them.

module main

fn main() {
	a := 10
	b := 2

	// add using +
	sum := a + b

	// subtract using -
	diff := b - a

	// product using *
	prod := a * b

	// / results in quotient
	quotient := a / b

	// % modulo results in remainder
	remainder := a % b

	println('Sum of ${a} and ${b} is ${sum}')
	println('Subtracting ${a} from ${b} is ${diff}')
	println('Product of ${a} and ${b} is ${prod}')
	println('Quotient when ${a} divided by ${b} is ${quotient}')
	println('Remainder when ${a} divided by ${b} is ${remainder}')
}

Bitwise Operators

Bitwise Operators

In V, primitive data types are the core building blocks of the language. This section details how to declare and use Bitwise Operators in a simple, straightforward manner. Beginners should pay close attention to how variables of this type are initialized and how built-in methods are called on them.

module main

fn main() {
	a := 0b00000110 // 6
	b := 0b00000010 // 2

	// bitwise AND operation of two binary nums using & operator
	b_and := a & b

	// bitwise OR operation of two binary nums using | operator
	b_or := a | b

	// bitwise XOR operation of two binary nums using ^ operator
	b_xor := a ^ b

	// bitwise NOT operation of an binary nums using ~ operator
	not_a := ~a // Not operation yields value which is equal to -(a+1) in its integer form
	println('Bitwise AND: ${a:08b} & ${b:08b} = ${b_and:08b}')
	println('Bitwise OR: ${a:08b} | ${b:08b} = ${b_or:08b}')
	println('Bitwise XOR: ${a:08b} ^ ${b:08b} = ${b_xor:08b}')
	println('Bitwise NOT: ~${a:b} = ${not_a:b}')
}

Shift Operators

Shift Operators

In V, primitive data types are the core building blocks of the language. This section details how to declare and use Shift Operators in a simple, straightforward manner. Beginners should pay close attention to how variables of this type are initialized and how built-in methods are called on them.

module main

fn main() {
	// declare 8 bit integer with value 3
	a := i8(3)

	// 8 bits equals to 1 byte
	println('a is ${sizeof(a)} byte(s)') // a is 1 byte(s)

	// declare 8-bit unsigned integer to shift by 1 position
	pos := u8(1)

	// Shift left the value 3 by 1 position
	a_left_shift := a << pos
	println('${a} << ${pos} = ${a_left_shift}')
}

Shift Operator On Range Of Integers

Shift Operator On Range Of Integers

In V, primitive data types are the core building blocks of the language. This section details how to declare and use Shift Operator On Range Of Integers in a simple, straightforward manner. Beginners should pay close attention to how variables of this type are initialized and how built-in methods are called on them.

module main

fn main() {
	val := i8(1)

	bits := sizeof(val) * 8

	println('Performing left shift using << Operator')

	for i in 0 .. bits {
		after_shift := val << i
		println('${val} << ${i} = ${after_shift} // type after shift operation: ${typeof(after_shift).name}')
	}
}

Integer Methods

Integer Methods

In V, primitive data types are the core building blocks of the language. This section details how to declare and use Integer Methods in a simple, straightforward manner. Beginners should pay close attention to how variables of this type are initialized and how built-in methods are called on them.

module main

fn main() {
	x := 42

	// str() returns string representation of the integer
	println(x.str()) // "42"

	// hex() returns hexadecimal representation without prefix
	println(x.hex()) // "2a"

	// hex2() returns hexadecimal representation with "0x" prefix
	println(x.hex2()) // "0x2a"

	// hex_full() returns hexadecimal representation with full width padding for the type (8 digits for 32-bit int)
	println(x.hex_full()) // "0000002a"
}

Float Methods

Float Methods

In V, primitive data types are the core building blocks of the language. This section details how to declare and use Float Methods in a simple, straightforward manner. Beginners should pay close attention to how variables of this type are initialized and how built-in methods are called on them.

module main

fn main() {
	f := 12345.6789

	// str() returns string representation of the float
	println(f.str()) // "12345.6789"

	// strg() returns string representation (often identical to str())
	println(f.strg()) // "12345.6789"

	// strlong() returns a full/long string representation of the float
	println(f.strlong()) // "12345.6789"

	// strsci(precision) returns scientific notation with specified precision/decimal places
	println(f.strsci(4)) // "1.2346e+04"

	// eq_epsilon(other) performs a comparison using machine epsilon (for near-equality)
	f2 := 12345.678900000001
	println(f.eq_epsilon(f2)) // true
}

U8 Methods

U8 Methods

In V, primitive data types are the core building blocks of the language. This section details how to declare and use U8 Methods in a simple, straightforward manner. Beginners should pay close attention to how variables of this type are initialized and how built-in methods are called on them.

module main

fn main() {
	b := u8(65) // ASCII code for 'A'

	// str() returns string representation of the numeric value
	println(b.str()) // "65"

	// ascii_str() returns string of length 1 containing the character
	println(b.ascii_str()) // "A"

	// hex() returns hexadecimal representation
	println(b.hex()) // "41"

	// hex_full() returns hexadecimal representation (same as hex() for u8)
	println(b.hex_full()) // "41"

	// is_alnum() checks if the character is alphanumeric
	println(b.is_alnum()) // true

	// is_bin_digit() checks if the character is a binary digit ('0' or '1')
	println(b.is_bin_digit()) // false

	// is_capital() checks if the character is an uppercase letter
	println(b.is_capital()) // true

	// is_digit() checks if the character is a decimal digit ('0'-'9')
	println(b.is_digit()) // false

	// is_hex_digit() checks if the character is a hexadecimal digit ('0'-'9', 'a'-'f', 'A'-'F')
	println(b.is_hex_digit()) // true

	// is_letter() checks if the character is an alphabetic letter
	println(b.is_letter()) // true

	// is_oct_digit() checks if the character is an octal digit ('0'-'7')
	println(b.is_oct_digit()) // false

	// is_space() checks if the character is a whitespace character
	println(b.is_space()) // false

	// repeat(count) repeats the character count times and returns a string
	println(b.repeat(3)) // "AAA"

	// str_escaped() returns an escaped string representation of the character
	println(b.str_escaped()) // "A"
}

Size Pointer Methods

Size Pointer Methods

In V, primitive data types are the core building blocks of the language. This section details how to declare and use Size Pointer Methods in a simple, straightforward manner. Beginners should pay close attention to how variables of this type are initialized and how built-in methods are called on them.

module main

fn main() {
	// isize and usize methods
	sz := isize(100)
	usz := usize(200)

	// str() returns string representation
	println(sz.str()) // "100"
	println(usz.str()) // "200"

	// voidptr methods
	x := 42
	p := voidptr(&x)

	// str() returns the memory address as string
	println(p.str().starts_with('0x')) // true

	// hex_full() returns full-width hex representation of address
	println(p.hex_full().len > 0) // true

	// vbytes(len) returns a byte array representation of the memory pointed to (must be called in unsafe block)
	unsafe {
		bytes := p.vbytes(int(sizeof(int)))
		println(bytes) // [42, 0, 0, 0]
	}
}

Rune Type

Declare Rune

Declare Rune

A rune in V represents a single Unicode code point. Runes are declared using backticks (e.g., \a\, \🔥\) and are represented internally as 32-bit unsigned integers (u32). This allows V to support multi-byte Unicode characters (like emojis or Chinese characters) as single character tokens.

This example shows how to declare and print runes.

fn main() {
	// A rune stores a single Unicode character.
	l := `a`
	println(typeof(l).name)
	// rune
}

Rune Operations With Strings

Rune Operations With Strings

Since strings in V are arrays of UTF-8 encoded bytes, you cannot directly check for a rune inside a string using string operations unless the rune is first converted to a string. V provides .str() on the rune type to easily convert a rune to a 1-character string, allowing you to use string methods like .count(), .contains(), etc.

This example shows how to count occurrences of a Unicode rune in a string.

fn main() {
	beverage := 'café'
	// 's' is a rune representing the Unicode character 'é'
	s := `é`
	// Since .count() expects a string argument, we convert the rune 's' using .str()
	println(beverage.count(s.str()))
	// Outputs: 1
}

Rune Methods

Rune Methods

Runes in V are not just raw numbers; they are full-fledged Unicode characters that support several built-in methods. You can convert their case, check their byte length (which can range from 1 to 4 bytes depending on the character, such as emojis), obtain their byte array representation, or convert them to hexadecimal code points.

This lesson demonstrates common helper methods on the rune type.

module main

fn main() {
	r := `A`

	// bytes() returns the byte representation (UTF-8 bytes) of the rune
	println(r.bytes()) // [65]

	// hex() returns the hexadecimal representation of the rune code point
	println(r.hex()) // "41"

	// length_in_bytes() returns the size of the rune in bytes (1 to 4)
	println(r.length_in_bytes()) // 1

	// repeat(count) returns a string with the rune repeated count times
	println(r.repeat(3)) // "AAA"

	// str() returns the string representation of the rune
	println(r.str()) // "A"

	// to_lower() returns the lowercase rune
	println(r.to_lower().str()) // "a"

	// to_upper() returns the uppercase rune
	println(r.to_upper().str()) // "A"

	// to_title() returns the titlecase rune
	println(r.to_title().str()) // "A"

	// Testing with a multi-byte UTF-8 rune (dog emoji 🐕)
	r2 := `🐕`
	println(r2.bytes()) // [240, 159, 144, 149]
	println(r2.hex()) // "1f415" (Unicode code point in hex)
	println(r2.length_in_bytes()) // 4
	println(r2.repeat(2)) // "🐕🐕"
	println(r2.str()) // "🐕"
}

String Type

Declare String

Declare String

In V, strings are representing read-only arrays of bytes, encoded natively in UTF-8. You can declare string variables using single quotes ('hello') or double quotes ("hello"), though single quotes are preferred in idiomatic V. The string type in V comes with built-in metadata, such as the .len field, which returns the total number of bytes in the string (not necessarily the number of Unicode characters/runes). You can inspect the runtime type of any variable using V's built-in typeof() function.

This example illustrates how to declare string variables, concatenate them, check string lengths, and query variable types at runtime.

module main

fn main() {
	// Strings can be declared using single quotes
	greeting := 'hello'
	name := 'Ada'
	
	// String concatenation using the '+' operator
	message := greeting + ', ' + name + '!'

	println(message)
	// Access the length (in bytes) of the string using the .len field
	println('Length: ${message.len}')
	// Inspect the variable type at runtime using typeof()
	println('Type: ${typeof(message).name}')
}

String Read Only Array Of Bytes

String Read Only Array Of Bytes

In V, strings are represented internally as read-only arrays of UTF-8 encoded bytes (u8). This means you can index into a string using bracket notation (str[index]) to extract the raw byte value at that position. The type returned from indexing a string is u8 (8-bit unsigned integer), not a string or rune.

This example shows how to read raw bytes from a string and prints the byte value and its type name.

fn main() {
	fruit := 'Orange'
	// Accessing the first byte of the string 'Orange'.
	// This returns the ASCII value of 'O' (which is 79), and its type is 'u8'.
	println(typeof(fruit[0]).name)
	// Outputs: u8
	
	println(fruit[0])
	// Outputs: 79
}

Strings Immutable By Default

Strings Immutable By Default

Strings in V are completely immutable. Once a string is created, its characters cannot be modified in place. Any operation that manipulates a string (such as replacing characters or converting to uppercase) returns a brand new string instead of modifying the original.

This example demonstrates that strings are read-only and cannot be changed.

fn main() {
	s := 'hello'
	// variable s is immutable
	s = 'Hello!'
	// this results in error
}

Declaring Mutable Strings

Declaring Mutable Strings

While strings are immutable, you can declare a mutable string variable using mut. This allows the variable to be reassigned to a new string value, or appended to using the += operator.

This example shows how to declare a mutable string and append text to it.

fn main() {
	mut msg := 'Hello Friend!'
	msg = 'Hope you are doing good.'
	println(msg)
	// Hope you are doing good.
	msg = msg + ' There is a surprise for you.'
	println(msg)
	// Hope you are doing good. There is a surprise for you.
}

Cannot Mutate String Elements

Cannot Mutate String Elements

Although declaring a string variable with mut lets you reassign the variable to reference a completely different string, it does NOT let you mutate individual characters or bytes within the existing string (e.g. s[0] = \G\``). String data elements are strictly read-only arrays of bytes, and attempting to mutate them will fail compilation.

This program shows that element mutation is strictly forbidden.

fn main() {
	mut greet := 'good Day'

	// ERROR: Cannot assign directly to string indices.
	// Strings in V are read-only byte arrays and their contents cannot be mutated.
	greet[0] = 'G' 
}

String Interpolation

String Interpolation

String interpolation is a clean way to insert variables or expressions inside a string literal. In V, you do this by wrapping the variable or expression in ${variable} inside a single-quoted string.

This example demonstrates how to format strings with variable values.

fn main() {
	a := 'coding'
	b := 'fun'
	println('${a} is ${b}')
	println('${a} is ${b}')
}

Escape Special Characters

Escape Special Characters

V strings support standard escape characters (like \n for newlines, \t for tabs, and \\ for backslashes) to represent special characters inside a string literal.

This example shows how these escape sequences are rendered in the console.

module main

fn main() {
	// 1. Newline escape character (\n)
	println('Hello\nWorld!')

	// 2. Tab escape character (\t)
	println('Name:\tAlice\tAge:\t25')

	// 3. Backslash escape character (\\)
	println('File path: C:\\Program Files\\V')

	// 4. Escaping single quotes (\') in a single-quoted string
	println("It's my Daughter's birthday!")

	// 5. Escaping double quotes (\") in a double-quoted string
	println('She said, "V is fast!"')
}

Declare Raw Strings

Declare Raw Strings

If you want to write a string literal where escape sequences (like \n) are treated as literal text instead of special commands, you can declare a raw string by prefixing the string literal with r (e.g., r\'hello\nworld\').

This is extremely useful when writing regular expressions or file paths.

module main

fn main() {
	i := r'hi \how are you/?'
	println(i)
}

String Concatenation Using Plus Sign

String Concatenation Using Plus Sign

In V, joining strings together is performed using the + operator. Since strings are immutable byte arrays, each concatenation creates a brand-new string in memory and copies the contents of both source strings. While the + operator is extremely convenient and clear for joining a few strings, doing this in loops or performance-critical code paths is discouraged because it leads to excessive memory allocations. For high-performance string building, V offers the strings.Builder module.

This example illustrates the direct concatenation of two string variables.

module main

fn main() {
	a := 'con'
	b := 'cat'
	// Concatenate a and b, creating a new string 'concat' in memory
	println(a + b)
	// concat
}

String Concatenation Using Interpolation

String Concatenation Using Interpolation

In V, primitive data types are the core building blocks of the language. This section details how to declare and use String Concatenation Using Interpolation in a simple, straightforward manner. Beginners should pay close attention to how variables of this type are initialized and how built-in methods are called on them.

module main

fn main() {
	i := 1
	j := 'man army'
	println('${i} ${j}')
}

Extract Substring From String Literal

Extract Substring From String Literal

V provides two main techniques to extract substrings from a string literal or variable:

1. The .substr(start, end) Method: Takes the starting index (inclusive) and ending index (exclusive) as parameters.
2. Range Slicing Syntax [start..end]: A clean and idiomatic syntax (similar to Go and Rust) where you specify range offsets. If the starting index is omitted (e.g. [..end]), it defaults to 0. If the ending index is omitted (e.g. [start..]), it defaults to the length of the string.

Both techniques are demonstrated in the example below.

module main

fn main() {
	a := 'Camel'

	// Method 1: Using the substr(start, end) method
	// Extracts characters from index 0 up to (but not including) index 3
	b := a.substr(0, 3)
	println(b) // Output: Cam

	// Method 2: Using idiomatic range slicing syntax [start..end] (similar to Go/Rust)
	// Slices from index 1 up to (but not including) index 4
	c := a[1..4]
	println(c) // Output: ame

	// Method 3: Slicing from start to index [..end]
	// If the start index is omitted, it defaults to 0
	d := a[..3]
	println(d) // Output: Cam

	// Method 4: Slicing from index to end [start..]
	// If the end index is omitted, it defaults to the string length
	e := a[2..]
	println(e) // Output: mel
}

Split String

Split String

In V, primitive data types are the core building blocks of the language. This section details how to declare and use Split String in a simple, straightforward manner. Beginners should pay close attention to how variables of this type are initialized and how built-in methods are called on them.

module main

fn main() {
	sp := 'The tiny tiger tied the tie tighter to its tail'
	res := sp.split(' ')
	// split by space as delimiter
	println(typeof(res).name)
	// []string
	println(res)
	// ['The', 'tiny', 'tiger', 'tied', 'the', 'tie', 'tighter', 'to', 'its', 'tail']
}

String To Runes Array

String To Runes Array

In V, primitive data types are the core building blocks of the language. This section details how to declare and use String To Runes Array in a simple, straightforward manner. Beginners should pay close attention to how variables of this type are initialized and how built-in methods are called on them.

module main

fn main() {
	doge_moon := '🐕+🚀=🌑'
	doge_moon_runes := doge_moon.runes()
	println(doge_moon_runes)
	println(typeof(doge_moon_runes).name) // []rune
}

Count Sub String Occurences

Count Sub String Occurences

In V, primitive data types are the core building blocks of the language. This section details how to declare and use Count Sub String Occurences in a simple, straightforward manner. Beginners should pay close attention to how variables of this type are initialized and how built-in methods are called on them.

module main

fn main() {
	sp := 'The tiny tiger tied the tie tighter to its tail'
	println(sp.count('t'))
	// 10
	println(sp.count('T'))
	// 1
	println(sp.count('tie'))
	// 2
	println(sp.count('-'))
	// 0
}

Check String Contains Substring

Check String Contains Substring

In V, primitive data types are the core building blocks of the language. This section details how to declare and use Check String Contains Substring in a simple, straightforward manner. Beginners should pay close attention to how variables of this type are initialized and how built-in methods are called on them.

module main

fn main() {
	hs := 'monday'

	if hs.contains('mon') {
		println('${hs} contains mon')
	} else {
		println('${hs} does not contains mon')
	}
}

String Contains Is Case Sensitive

String Contains Is Case Sensitive

In V, primitive data types are the core building blocks of the language. This section details how to declare and use String Contains Is Case Sensitive in a simple, straightforward manner. Beginners should pay close attention to how variables of this type are initialized and how built-in methods are called on them.

module main

fn main() {
	hs := 'Monday'

	if hs.contains('mon') {
		println('${hs} contains mon')
	} else {
		println('${hs} does not contains mon')
	}
}

Common String Methods

Common String Methods

In V, primitive data types are the core building blocks of the language. This section details how to declare and use Common String Methods in a simple, straightforward manner. Beginners should pay close attention to how variables of this type are initialized and how built-in methods are called on them.

module main

fn main() {
	s := '  Hello, V!  '

	// to_lower() returns the lowercase version of the string
	println(s.to_lower()) // "  hello, v!  "

	// to_upper() returns the uppercase version of the string
	println(s.to_upper()) // "  HELLO, V!  "

	// trim_space() trims leading and trailing whitespaces
	println(s.trim_space()) // "Hello, V!"

	// trim(cutset) trims leading and trailing characters that match any character in the cutset
	println(s.trim(' ')) // "Hello, V!"

	// replace(old, new) replaces all occurrences of old with new
	println(s.replace('V', 'World')) // "  Hello, World!  "

	// replace_once(old, new) replaces the first occurrence of old with new
	println(s.replace_once('l', 'x')) // "  Hexlo, V!  "

	// index(sub) returns the start index of the first occurrence of sub as an optional ?int
	idx := s.index('Hello') or { -1 }
	println(idx) // 2

	// last_index(sub) returns the start index of the last occurrence of sub as an optional ?int
	last_idx := s.last_index('l') or { -1 }
	println(last_idx) // 5

	// starts_with(prefix) checks if the string starts with the prefix
	println(s.starts_with('  ')) // true

	// ends_with(suffix) checks if the string ends with the suffix
	println(s.ends_with('!')) // false (ends with spaces)

	// is_pure_ascii() checks if all characters in the string are pure ASCII
	println(s.is_pure_ascii()) // true

	// split_into_lines() splits a string into an array of lines
	multiline := 'line 1\nline 2'
	println(multiline.split_into_lines()) // ["line 1", "line 2"]

	// split_by_space() splits a string by space as delimiter
	println(s.split_by_space()) // ["Hello,", "V!"]
}

Chapter 4 Control Flow

Quick Access

Below is an index of all code examples in this chapter. You can use these links to jump directly to any specific code example:

Control Flow Extras

• Chaining Else If
• If With Goto
• Cascade Match Conditions
• Match As Switch Case
• Match Pattern Matching
• Match With Enum
• Match With Enum And Else
• Bare For
• Break For
• Continue For
• For C Style
• For On Array Without Index
• For On Arrays
• For On Maps
• For On Maps Ignore Key
• For On Range
• For With Continue Break And Labels
• Reverse For

Control flow determines the execution path of your code. In this chapter, we cover conditionals (if-else), pattern matching (match), and the versatile for loop. V simplifies control flow by using fewer keywords, making code highly readable.

Under the Hood: Control Flow Optimization, Jump Tables & Defer Stack

V provides clean, expressive control flow constructs that compile down to highly optimized machine code instructions.

`if` as an Expression

In V, if-else blocks can be used as expressions that evaluate to a value:

status := if score >= 50 { 'Pass' } else { 'Fail' }

Under the hood, the V compiler transforms this into a C ternary operator (score >= 50 ? "Pass" : "Fail") or a direct conditional assignment on the stack. There is zero runtime overhead, no temporary object creation, and the compiler statically verifies that all branches return identical types.

`match` Compilation & Jump Tables

V's match statement replaces complex switch or cascading if-else chains:

* Exhaustiveness Guarantee: When matching on an enum or boolean, the compiler verifies that every single variant is handled. If a new enum variant is added in the future, the compiler will refuse to build until all match statements handle it.

* $O(1)$ Jump Table Optimization: When matching on contiguous integers or enums, the C backend compiles the match block into a hardware jump table. Dispatching to the target branch executes in $O(1)$ constant time regardless of how many branches exist.

* No Fallthrough: Unlike C/C++, V match branches do not fall through to the next case. Each branch is strictly isolated, completely eliminating the need for break statements.

The `defer` LIFO Execution Stack

The defer statement schedules a cleanup expression to execute right before the enclosing function exits:

fn process_file(path string) ! {
    mut file := os.open(path)!
    defer { file.close() } // Guaranteed to execute whenever process_file returns

    // Perform operations...
}

Under the hood:

1. The compiler maintains a Last-In, First-Out (LIFO) stack of deferred expressions recorded within the function scope.
2. At every possible exit point (including early return, panic, or error propagation !), the compiler automatically injects the deferred cleanup code in reverse order.
3. This is achieved with zero runtime stack unwinding penalty—the injected calls are compiled directly into the function's epilogue.

Control Flow Extras

Chaining Else If

Chaining Else If

When your program must choose between multiple mutually exclusive paths, you can chain multiple else if blocks together. V evaluates these conditions sequentially from top to bottom. As soon as one condition evaluates to true, the corresponding block of code is executed, and all remaining branches (including any final fallback else block) are skipped entirely. Like single if statements, parentheses are not required around the condition expressions in V.

This example defines a helper function that takes a weekday string and prints a corresponding breakfast menu using a chained conditional statement.

module main

// This helper chooses a meal plan based on the weekday.
fn breakfast_menu(day string) {
	// Cascading conditional checks
	if day == 'Monday' {
		println('Bread, Jam, Half boiled Egg')
	} else if day == 'Tuesday' {
		println('Bread, Jam, Juice')
	} else if day == 'Wednesday' {
		println('Milk, Bread, Fruit Bowl')
	} else if day == 'Thursday' {
		println('Bread, Jam, Juice')
	} else if day == 'Friday' {
		println('Cereals, Bread, Jam, Half boiled Egg')
	} else if day == 'Saturday' {
		println('Milk, Bread, Fruit Bowl')
	} else if day == 'Sunday' {
		println('Cereals, Bread, Jam, Half boiled Egg')
	} else {
		// Fallback block executed if no prior conditions match
		println('invalid input')
	}
}

fn main() {
	// Call the helper with a sample weekday.
	breakfast_menu('Saturday')
}

If With Goto

If With Goto

Control flow structures allow your program to decide which path of execution to take. This example demonstrates the usage of If With Goto in V, showing how to control execution paths cleanly and safely.

module main

import os

fn main() {
	improper_input_age:
	println('Invalid input. Please provide value greater than 0.')

	next_person:
	inp := os.input('Enter your age:')

	if inp != 'stop' {
		age := inp.int()

		if age >= 13 {
			println('You are allowed to watch this movie')
		} else if age > 0 && age < 13 {
			println('Parental Guidance is required to watch this movie')
		} else if age <= 0 {
			unsafe {
				goto improper_input_age
			}
		}
		unsafe {
			goto next_person
		}
	}
}

Cascade Match Conditions

Cascade Match Conditions

Control flow structures allow your program to decide which path of execution to take. This example demonstrates the usage of Cascade Match Conditions in V, showing how to control execution paths cleanly and safely.

module main

fn breakfast_menu(day string) string {
	return match day {
		'Monday' {
			'Bread, Jam, Half boiled Egg'
		}
		'Tuesday', 'Thursday' {
			'Bread, Jam, Juice'
		}
		'Wednesday' {
			'Milk, Bread, Fruit Bowl'
		}
		'Friday', 'Sunday' {
			'Cereals, Bread, Jam, Half boiled Egg'
		}
		'Saturday' {
			'Milk, Bread, Fruit Bowl'
		}
		else {
			'invalid input'
		}
	}
}

fn main() {
	friday_menu := breakfast_menu('Friday')
	println(friday_menu)

	sunday_menu := breakfast_menu('Sunday')
	println(sunday_menu)

	tuesday_menu := breakfast_menu('Tuesday')
	println(tuesday_menu)

	thursday_menu := breakfast_menu('Thursday')
	println(thursday_menu)
}

Match As Switch Case

Match As Switch Case

In V, there is no switch statement. Instead, the match keyword is used for branching on values. The match statement is highly readable and type-safe. Each branch is evaluated in order, and unlike in C/Java/Javascript, there is no "fall-through" behavior—the matching block executes and the statement completes immediately. This eliminates bugs caused by forgetting break statements. V also enforces that a match must cover all possible cases or provide an else block.

This example shows how to use match on string values.

module main

fn breakfast_menu(day string) {
	// A match block branches on the value of 'day'.
	// In V, match is an expression and can also return values.
	match day {
		'Monday' { println('Bread, Jam, Half boiled Egg') }
		'Tuesday' { println('Bread, Jam, Juice') }
		'Wednesday' { println('Milk, Bread, Fruit Bowl') }
		'Thursday' { println('Bread, Jam, Juice') }
		'Friday' { println('Cereals, Bread, Jam, Half boiled Egg') }
		'Saturday' { println('Milk, Bread, Fruit Bowl') }
		'Sunday' { println('Cereals, Bread, Jam, Half boiled Egg') }
		else { println('invalid input') } // Exhaustive match requirement handled by 'else'
	}
}

fn main() {
	breakfast_menu('Sunday')
}

Match Pattern Matching

Match Pattern Matching

Control flow structures allow your program to decide which path of execution to take. This example demonstrates the usage of Match Pattern Matching in V, showing how to control execution paths cleanly and safely.

module main

fn main() {
	age := 18
	res := match age {
		0...18 { 'Person with age ${age} classified as a Child' }
		19...120 { 'Person with age ${age} classified as an Adult' }
		else { '${age} is must be in the range 0 to 120' }
	}
	println(res)
}

Match With Enum

Match With Enum

One of V's strongest safety guarantees is exhaustive enum matching. When you match on an enum value, V requires you to handle every single enum member. If you miss one, the compiler will refuse to compile the program. This ensures that when new items are added to an enum in the future, the compiler will automatically guide you to update all match expressions across your codebase. Additionally, V supports shorthand syntax where you can write .member_name instead of EnumName.member_name inside the match arms.

This example illustrates matching over an enum to return a string menu item.

module main

// Define a Days-of-the-week enum
enum Day {
	sunday
	monday
	tuesday
	wednesday
	thursday
	friday
	saturday
}

fn breakfast_menu(day Day) string {
	// The match statement returns the value of the matching block.
	// Notice we use the shorthand dot syntax (.monday) since 'day' is known to be of type 'Day'.
	return match day {
		.monday {
			'Bread, Jam, Half boiled Egg'
		}
		.tuesday, .thursday {
			'Bread, Jam, Juice' // Grouping multiple enum members using comma
		}
		.wednesday {
			'Milk, Bread, Fruit Bowl'
		}
		.friday, .sunday {
			'Cereals, Bread, Jam, Half boiled Egg'
		}
		.saturday {
			'Milk, Bread, Fruit Bowl'
		}
	} // No else block is needed because all enum members are exhaustively handled.
}

fn main() {
	friday_menu := breakfast_menu(Day.friday)
	println(friday_menu)

	sunday_menu := breakfast_menu(Day.sunday)
	println(sunday_menu)

	tuesday_menu := breakfast_menu(Day.tuesday)
	println(tuesday_menu)

	thursday_menu := breakfast_menu(Day.thursday)
	println(thursday_menu)
}

Match With Enum And Else

Match With Enum And Else

Control flow structures allow your program to decide which path of execution to take. This example demonstrates the usage of Match With Enum And Else in V, showing how to control execution paths cleanly and safely.

module main

enum Day {
	sunday
	monday
	tuesday
	wednesday
	thursday
	friday
	saturday
}

fn weekend_breakfast_menu(day Day) string {
	return match day {
		.sunday {
			'Cereals, Bread, Jam, Half boiled Egg'
		}
		.saturday {
			'Milk, Bread, Fruit Bowl'
		}
		else {
			'Sorry, we are closed on weekdays!'
		}
	}
}

fn main() {
	sunday_menu := weekend_breakfast_menu(Day.sunday)
	println(sunday_menu)

	tuesday_menu := weekend_breakfast_menu(Day.tuesday)
	println(tuesday_menu)
}

Bare For

Bare For

V simplifies iteration by only offering a single keyword for loops: for. There is no while keyword in V. A "bare" for (a loop declaration without any conditions or loop ranges) represents an infinite loop, which behaves exactly like while true in other languages. To exit a bare for loop, you must use a break statement inside the loop body, or exit the function using return.

This example shows how to declare a bare infinite loop.

module main

fn main() {
	mut count := 1
	// Bare for starts an infinite loop.
	// WARNING: Running this without a break condition will loop forever.
	for {
		println('Hi ${count} times')
		count += 1
		
		// To break out, a developer would normally add:
		if count > 5 {
			break
		}
	}
}

Break For

Break For

Control flow structures allow your program to decide which path of execution to take. This example demonstrates the usage of Break For in V, showing how to control execution paths cleanly and safely.

module main

import os

fn main() {
	mut count := 0
	input := os.input('Enter number of times to Greet:')
	limit := input.int()
	for {
		if count >= limit {
			break
		}
		println('Hi')
		count += 1
	}
	println('Greeted Hi ${count} times')
}

Continue For

Continue For

Control flow structures allow your program to decide which path of execution to take. This example demonstrates the usage of Continue For in V, showing how to control execution paths cleanly and safely.

module main

fn main() {
	for i in 0 .. 10 {
		if i % 2 == 0 { // skips printing number that is a multiple of 2
			continue
		}
		println(i)
	}
}

For C Style

For C Style

Control flow structures allow your program to decide which path of execution to take. This example demonstrates the usage of For C Style in V, showing how to control execution paths cleanly and safely.

module main

fn main() {
	sample := [3, 4, 23, 12, 4, 1, 45, 12, 42, 17, 92, 38]
	for i := 0; i < sample.len; i += 3 {
		println(sample[i])
	}
}

For On Array Without Index

For On Array Without Index

Control flow structures allow your program to decide which path of execution to take. This example demonstrates the usage of For On Array Without Index in V, showing how to control execution paths cleanly and safely.

module main

fn main() {
	col := [1, 2, 3, 4, 5, 6, 7]
	for val in col {
		if val % 2 == 0 {
			println('${val} is Even')
		} else {
			println('${val} is Odd')
		}
	}
}

For On Arrays

For On Arrays

Iterating over arrays is a very common requirement. In V, you can iterate over both the index and value of each element using the for index, value in array syntax. During each iteration, the index variable (e.g., idx) contains the zero-based array index, and the element variable (e.g., ele) contains a read-only copy of the item. Both variables are scoped exclusively to the body of the loop and cannot be mutated. If you only need the element values and not their indices, V allows you to omit the index variable (e.g. for value in array).

This example declares a list of fruits and iterates over them, printing each fruit alongside its corresponding index.

module main

fn main() {
	fruits := ['apple', 'banana', 'coconut']
	
	// Loop over the indices (idx) and elements (ele) of the fruits array
	for idx, ele in fruits {
		println('idx: ${idx} \t fruit: ${ele}')
	}
}

For On Maps

For On Maps

V makes iterating over key-value collections (maps) straightforward. By using the syntax for key, value in map, you can access both the key and the value of each entry directly during each iteration. Like arrays, the iteration variables (key and value) are local to the loop scope and are immutable. Note that iteration order over maps is not guaranteed to be stable or sorted, matching standard hash map behavior in other systems languages.

This example demonstrates how to declare a map and iterate over its key-value pairs.

module main

fn main() {
	// Initialize a map with string keys and integer values
	lottery := {
		'First':       1000
		'Second':      700
		'Consolation': 200
	}

	// Loop over keys (k) and values (v) in the 'lottery' map.
	for k, v in lottery {
		println('${k} prize lottery amount: ${v}')
	}
}

For On Maps Ignore Key

For On Maps Ignore Key

Control flow structures allow your program to decide which path of execution to take. This example demonstrates the usage of For On Maps Ignore Key in V, showing how to control execution paths cleanly and safely.

module main

fn main() {
	basket := {
		'apples':  10
		'bananas': 12
	}

	mut total := 0
	for _, v in basket {
		total += v
	}
	println('Total number of fruits: ${total}')
}

For On Range

For On Range

Control flow structures allow your program to decide which path of execution to take. This example demonstrates the usage of For On Range in V, showing how to control execution paths cleanly and safely.

module main

fn main() {
	for val in 0 .. 4 {
		println(val)
	}
}

For With Continue Break And Labels

For With Continue Break And Labels

Control flow structures allow your program to decide which path of execution to take. This example demonstrates the usage of For With Continue Break And Labels in V, showing how to control execution paths cleanly and safely.

module main

import os

fn main() {
	input := os.input('Enter the number of multiplication tables to print:')
	limit := input.int()
	if limit <= 0 {
		return
	}
	first_loop: for i := 1; i <= 10; i++ {
		println('Printing multiplication table for ${i}')
		for j := 1; j <= 10; j++ {
			mul := i * j
			println('${i} * ${j} = ${mul}')
			if mul >= limit * 10 {
				break first_loop
			}
		}
		println('*********')
	}
}

Reverse For

Reverse For

Control flow structures allow your program to decide which path of execution to take. This example demonstrates the usage of Reverse For in V, showing how to control execution paths cleanly and safely.

module main

fn main() {
	subjects := ['zoology', 'chemistry', 'physics', 'algebra']

	for i := subjects.len - 1; i >= 0; i-- {
		println(subjects[i])
	}
}

Chapter 5 Collections: Arrays and Maps

Quick Access

Below is an index of all code examples in this chapter. You can use these links to jump directly to any specific code example:

Arrays

• Declare And Initialize
• Declare Empty Array
• Declare Array With Len
• Declare Array With Init And Len
• Declare Array With Cap
• Working With Array Properties
• Access Array Elements Using Index
• Access Array Elements Using Slices
• In Operator With Array
• Append Array
• Define Fixed Size Array
• Update Fixed Size Array Elements
• Determining Type Of Fixed Array
• Slicing Fixed Size Array Results In Ordinary Array
• Declaring Multi Dimensional Arrays
• Updating Multi Dimensional Array Indices
• Reassigning Multi Dimensional Arrays
• Clone Array
• Copy Array
• Sort Integer Array
• Sort String Array
• Sort Struct Array
• Filter Array
• Filter With Anonymous Funcs On Array
• Map Array Items
• Map Using Anonymous Funcs On Array
• Array Methods

Maps

• Explicit Map Initialization
• Short Syntax Initialization Of Map
• Count Key Value Pairs In Map
• Value Given Key Of Map
• Value Given Non Existent Key Of Map
• Handling Missing Keys In Map
• Update Value Given A Key In Map
• Delete Key Value Pair From Map
• Map Methods

Collections allow you to group multiple data items together. V provides two primary built-in collection types: arrays (ordered lists of elements) and maps (key-value dictionaries). This chapter covers creating, accessing, and manipulating these collections using modern functional patterns like map and filter.

Under the Hood: Dynamic Arrays, Slicing & Hash Table Mechanics

Arrays and maps form the backbone of data manipulation in V. Both are built for cache efficiency, fast iteration, and predictable memory growth.

Dynamic Array Architecture

Dynamic arrays in V are managed by a compact 24-byte control structure:

struct Array {
    data         voidptr // Pointer to continuous heap-allocated memory block
    offset       int     // Slicing offset
    len          int     // Number of active elements currently in array
    cap          int     // Total capacity allocated in memory
    element_size int     // Size in bytes of each element (e.g., 4 for int)
}

Array Header: [ data* | offset: 0 | len: 3 | cap: 4 | element_size: 4 ]
                      |
                      v
Heap Buffer:   [ 10 ][ 20 ][ 30 ][ <unallocated> ]

Amortized 2x Capacity Growth Strategy

When you append an item to an array using the << operator:

1. If len < cap, the element is written directly to data[len] and len is incremented ($O(1)$ operation).
2. If len == cap, V allocates a new memory block with double the previous capacity (cap * 2), copies the existing elements with memcpy, frees the old buffer, and inserts the new item.
3. Pre-Allocation Best Practice: When the final count of items is known in advance, initialize the array with []int{cap: count} to allocate the exact memory buffer once, eliminating intermediate reallocation copies.

Slice Semantics: Shared Memory vs `.clone()`

When you create a slice using range syntax sub := arr[1..3]:

* The slice sub points directly to the memory buffer of the parent array arr.

* Creating a slice is an $O(1)$ operation with zero memory allocation.

* Caution: Modifying an element inside a mutable slice mutates the underlying data in the original array. If you need an isolated, independent copy, call arr[1..3].clone().

Map Architecture & The Wyhash Algorithm

V's built-in map[Key]Value is an open-addressing hash table:

* Hashing Engine: Uses Wyhash, one of the fastest hashing algorithms in existence, producing uniform hash distributions and high resilience against hash collision attacks.

* Cache Locality: Keys and values are stored in dense contiguous memory buckets, maximizing CPU L1/L2 cache hit rates during lookups.

* Lookup Cost: Key retrieval, insertion, and deletion operate in $O(1)$ average time complexity.

* Zero-Value Returns: Querying a missing key (m['absent']) returns the default zero-value of the value type (e.g. 0, "", false), or you can use key in m to check for explicit presence.

Arrays

Declare And Initialize

Declare And Initialize

An array is a collection of elements of the same type. In V, arrays are declared using square brackets. They are index-based, dynamically sized, and provide built-in methods like map(), filter(), and sort() for functional-style manipulation.

These examples show how to initialize, append, clone, copy, and manipulate arrays.

fn main() {
	mut sports := ['cricket', 'hockey', 'football']
	println(sports)
}

Declare Empty Array

Declare Empty Array

An array is a collection of elements of the same type. In V, arrays are declared using square brackets. They are index-based, dynamically sized, and provide built-in methods like map(), filter(), and sort() for functional-style manipulation.

These examples show how to initialize, append, clone, copy, and manipulate arrays.

fn main() {
	mut animals := []string{}
	println(animals)
	// prints empty array: []
	animals << 'Chimpanzee'
	animals << 'Dog'
	println(animals)
	// ['Chimpanzee', 'Dog']
}

Declare Array With Len

Declare Array With Len

An array is a collection of elements of the same type. In V, arrays are declared using square brackets. They are index-based, dynamically sized, and provide built-in methods like map(), filter(), and sort() for functional-style manipulation.

These examples show how to initialize, append, clone, copy, and manipulate arrays.

fn main() {
	mut i := []int{len: 3}
	println(i)
}

Declare Array With Init And Len

Declare Array With Init And Len

An array is a collection of elements of the same type. In V, arrays are declared using square brackets. They are index-based, dynamically sized, and provide built-in methods like map(), filter(), and sort() for functional-style manipulation.

These examples show how to initialize, append, clone, copy, and manipulate arrays.

fn main() {
	mut j := []int{len: 3, init: 1}
	println(j)
}

Declare Array With Cap

Declare Array With Cap

An array is a collection of elements of the same type. In V, arrays are declared using square brackets. They are index-based, dynamically sized, and provide built-in methods like map(), filter(), and sort() for functional-style manipulation.

These examples show how to initialize, append, clone, copy, and manipulate arrays.

fn main() {
	mut k := []int{cap: 2}
	println(k)
}

Working With Array Properties

Working With Array Properties

An array is a collection of elements of the same type. In V, arrays are declared using square brackets. They are index-based, dynamically sized, and provide built-in methods like map(), filter(), and sort() for functional-style manipulation.

These examples show how to initialize, append, clone, copy, and manipulate arrays.

fn main() {
	mut sports := ['cricket', 'hockey', 'football']
	println(sports.len)
	// Length of sports array
	println(sports.cap)
	// Capacity of sports array
	println('----Deleting football----')
	sports.delete(2)
	// deleting football
	println('Length of sports array: ${sports.len}')
	println('Capacity of sports array: ${sports.cap}')

	println('----Adding volleyball and baseball----')

	sports << ['volleyball', 'baseball']
	println(sports)
	println('Length of sports array: ${sports.len}')
	println('Capacity of sports array: ${sports.cap}')
}

Access Array Elements Using Index

Access Array Elements Using Index

An array is a collection of elements of the same type. In V, arrays are declared using square brackets. They are index-based, dynamically sized, and provide built-in methods like map(), filter(), and sort() for functional-style manipulation.

These examples show how to initialize, append, clone, copy, and manipulate arrays.

fn main() {
	mut sports := ['cricket', 'hockey', 'football']
	s := sports[1]
	println(s) // hockey
}

Access Array Elements Using Slices

Access Array Elements Using Slices

An array is a collection of elements of the same type. In V, you can retrieve a subset of elements by slicing the array. Slicing uses the [start..end] syntax, which creates a new array containing elements from the start index up to (but not including) the end index.

Positive Slicing

Positive indices represent offsets from the beginning of the array (starting at 0). For example, sports[1..3] returns a slice from index 1 to 2.

Negative Slicing

V does not support negative indices natively in slices (e.g., sports[-2..] will cause a compiler error). To achieve the effect of negative slicing (indexing from the end of the array), you calculate the start and/or end index using the array's .len property:

• Excluding the last element: sports[..sports.len - 1] (equivalent to Python's sports[..-1])
• Range from the end: sports[sports.len - 3 .. sports.len - 1] (equivalent to Python's sports[-3..-1])
• Last N elements: sports[sports.len - 2 ..] (equivalent to Python's sports[-2..])

Slices are References

fn main() {
	mut sports := ['cricket', 'hockey', 'football', 'basketball', 'tennis']

	// Positive slicing: from index 1 to 3 (excluding index 3)
	println(sports[1..3]) // ['hockey', 'football']

	// V does not support negative indices natively in slices (e.g., sports[-2..] will not compile).
	// To achieve "negative slicing" (indexing from the end of the array), use the `.len` property:

	// Slice up to the last element (excluding it): Python's sports[..-1]
	println(sports[..sports.len - 1]) // ['cricket', 'hockey', 'football', 'basketball']

	// Slice from 3rd to last up to 1st to last (excluding it): Python's sports[-3..-1]
	println(sports[sports.len - 3..sports.len - 1]) // ['football', 'basketball']

	// Slice the last two elements: Python's sports[-2..]
	println(sports[sports.len - 2..]) // ['basketball', 'tennis']

	// --- REFERENCE VS VALUE BEHAVIOR ---
	// In V, slices are reference views of the original array.
	// If you modify an element of a slice, it affects the original array.
	// Note: To prevent unsafe behavior, assigning a slice to a variable requires an `unsafe` block
	// if you want it by-reference, or an explicit `.clone()` to get a copy by-value.

	// 1. Modifying by reference (using unsafe)
	mut original := [10, 20, 30, 40, 50]
	mut ref_slice := unsafe { original[1..4] }
	ref_slice[0] = 99
	println(original) // [10, 99, 30, 40, 50] (Original is modified!)

	// 2. Modifying by value (using .clone())
	mut original_two := [10, 20, 30, 40, 50]
	mut val_slice := original_two[1..4].clone()
	val_slice[0] = 99
	println(original_two) // [10, 20, 30, 40, 50] (Original remains unchanged!)
}

In Operator With Array

In Operator With Array

An array is a collection of elements of the same type. In V, arrays are declared using square brackets. They are index-based, dynamically sized, and provide built-in methods like map(), filter(), and sort() for functional-style manipulation.

These examples show how to initialize, append, clone, copy, and manipulate arrays.

fn main() {
	odd := [1, 3, 5, 7]

	println(3 in odd)
	// prints: true
	println(8 !in odd)
	// prints: true
}

Append Array

Append Array

An array is a collection of elements of the same type. In V, arrays are declared using square brackets. They are index-based, dynamically sized, and provide built-in methods like map(), filter(), and sort() for functional-style manipulation.

These examples show how to initialize, append, clone, copy, and manipulate arrays.

fn main() {
	mut even := [2, 4, 6]
	even << 8
	println(even)
	// prints [2, 4, 6, 8]
	even << [10, 12, 14]
	println(even)
	// prints: [2, 4, 6, 8, 10, 12, 14]
}

Define Fixed Size Array

Define Fixed Size Array

An array is a collection of elements of the same type. In V, arrays are declared using square brackets. They are index-based, dynamically sized, and provide built-in methods like map(), filter(), and sort() for functional-style manipulation.

These examples show how to initialize, append, clone, copy, and manipulate arrays.

fn main() {
	mut fix := [4]int{}
	println(fix)
	// [0, 0, 0, 0]
}

Update Fixed Size Array Elements

Update Fixed Size Array Elements

An array is a collection of elements of the same type. In V, arrays are declared using square brackets. They are index-based, dynamically sized, and provide built-in methods like map(), filter(), and sort() for functional-style manipulation.

These examples show how to initialize, append, clone, copy, and manipulate arrays.

fn main() {
	mut fix := [4]int{}
	fix[1] = 33
	println(fix)
	//[0, 33, 0, 0]
}

Determining Type Of Fixed Array

Determining Type Of Fixed Array

An array is a collection of elements of the same type. In V, arrays are declared using square brackets. They are index-based, dynamically sized, and provide built-in methods like map(), filter(), and sort() for functional-style manipulation.

These examples show how to initialize, append, clone, copy, and manipulate arrays.

fn main() {
	mut fix := [4]int{}
	println(typeof(fix).name) // [4]int
}

Slicing Fixed Size Array Results In Ordinary Array

Slicing Fixed Size Array Results In Ordinary Array

An array is a collection of elements of the same type. In V, arrays are declared using square brackets. They are index-based, dynamically sized, and provide built-in methods like map(), filter(), and sort() for functional-style manipulation.

These examples show how to initialize, append, clone, copy, and manipulate arrays.

fn main() {
	mut fix := [4]int{}
	fix[1] = 33
	s := fix[1..]
	println(s)
	// [33, 0, 0]
	println(typeof(s).name) // prints: []int
}

Declaring Multi Dimensional Arrays

Declaring Multi Dimensional Arrays

An array is a collection of elements of the same type. In V, arrays are declared using square brackets. They are index-based, dynamically sized, and provide built-in methods like map(), filter(), and sort() for functional-style manipulation.

These examples show how to initialize, append, clone, copy, and manipulate arrays.

fn main() {
	mut coordinates_2d := [][]int{len: 4, init: []int{len: 2}}
	println(typeof(coordinates_2d).name)
	// [][]int
	println(coordinates_2d)
	// [[0, 0], [0, 0], [0, 0], [0, 0]]
}

Updating Multi Dimensional Array Indices

Updating Multi Dimensional Array Indices

An array is a collection of elements of the same type. In V, arrays are declared using square brackets. They are index-based, dynamically sized, and provide built-in methods like map(), filter(), and sort() for functional-style manipulation.

These examples show how to initialize, append, clone, copy, and manipulate arrays.

fn main() {
	mut coordinates_2d := [][]int{len: 4, init: []int{len: 2}}
	println(coordinates_2d.len)

	point_1 := [0, 0]
	point_2 := [0, 1]
	point_3 := [1, 0]
	point_4 := [1, 1]

	coordinates_2d[0] = point_1
	coordinates_2d[1] = point_2
	coordinates_2d[2] = point_3
	coordinates_2d[3] = point_4
	println(coordinates_2d)
}

Reassigning Multi Dimensional Arrays

Reassigning Multi Dimensional Arrays

An array is a collection of elements of the same type. In V, arrays are declared using square brackets. They are index-based, dynamically sized, and provide built-in methods like map(), filter(), and sort() for functional-style manipulation.

These examples show how to initialize, append, clone, copy, and manipulate arrays.

fn main() {
	mut coordinates_2d := [][]int{len: 4, init: []int{len: 2}}
	println(coordinates_2d.len)
	coordinates_2d = [
		[0, 0],
		[0, 1],
		[1, 0],
		[1, 1],
	]
	println(coordinates_2d)
}

Clone Array

Clone Array

An array is a collection of elements of the same type. In V, arrays are declared using square brackets. They are index-based, dynamically sized, and provide built-in methods like map(), filter(), and sort() for functional-style manipulation.

These examples show how to initialize, append, clone, copy, and manipulate arrays.

fn main() {
	r := [1, 2, 3, 4]
	mut u := r.clone()
	// copies the array r to u
	println(u)
}

Copy Array

Copy Array

An array is a collection of elements of the same type. In V, arrays are declared using square brackets. They are index-based, dynamically sized, and provide built-in methods like map(), filter(), and sort() for functional-style manipulation.

These examples show how to initialize, append, clone, copy, and manipulate arrays.

fn main() {
	r := [1, 2, 3, 4]
	s := unsafe { r }
	println(s)
	unsafe {
		r.free()
	}
}

Sort Integer Array

Sort Integer Array

An array is a collection of elements of the same type. In V, arrays are declared using square brackets. They are index-based, dynamically sized, and provide built-in methods like map(), filter(), and sort() for functional-style manipulation.

These examples show how to initialize, append, clone, copy, and manipulate arrays.

fn main() {
	mut i := [3, 2, 8, 1]
	i.sort()
	// ascending order
	println(i)
	i.sort(a > b)
	// descending order
	println(i)
}

Sort String Array

Sort String Array

An array is a collection of elements of the same type. In V, arrays are declared using square brackets. They are index-based, dynamically sized, and provide built-in methods like map(), filter(), and sort() for functional-style manipulation.

These examples show how to initialize, append, clone, copy, and manipulate arrays.

fn main() {
	mut fruits := ['Apples', 'avocado', 'banana', 'Orange']

	fruits.sort()
	// ascending order
	println(fruits)
	fruits.sort(a > b)
	// reverse order
	println(fruits)
}

Sort Struct Array

Sort Struct Array

An array is a collection of elements of the same type. In V, arrays are declared using square brackets. They are index-based, dynamically sized, and provide built-in methods like map(), filter(), and sort() for functional-style manipulation.

These examples show how to initialize, append, clone, copy, and manipulate arrays.

module main

struct Student {
	id    int
	name  string
	class int
}

fn main() {
	// Declare an empty array
	mut students := []Student{}

	// Create students
	st1 := Student{
		id:    1
		name:  'Ram'
		class: 9
	}
	st2 := Student{
		id:    2
		name:  'Katy'
		class: 3
	}
	st3 := Student{
		id:    3
		name:  'Tom'
		class: 6
	}

	// Append all the students to the array
	students << [st1, st2, st3]
	println(students)

	// Reverse Sort students by id
	students.sort(a.id > b.id)

	println('Students sorted in reverse order of id:')
	println(students)

	// Sort students by class in ascending order
	students.sort(a.class < b.class)

	println('Students sorted in ascending order of class:')
	println(students)

	// Sort students by name in reverse order
	students.sort(a.name > b.name)

	println('Students sorted in reverse order of name:')
	println(students)
}

Filter Array

Filter Array

An array is a collection of elements of the same type. In V, arrays are declared using square brackets. They are index-based, dynamically sized, and provide built-in methods like map(), filter(), and sort() for functional-style manipulation.

These examples show how to initialize, append, clone, copy, and manipulate arrays.

fn main() {
	f := [1, 2, 3, 4, 5, 6, 7, 8, 9]
	multiples_of_3 := f.filter(it % 3 == 0)
	println(multiples_of_3)
	// [3, 6, 9]
}

Filter With Anonymous Funcs On Array

Filter With Anonymous Funcs On Array

An array is a collection of elements of the same type. In V, arrays are declared using square brackets. They are index-based, dynamically sized, and provide built-in methods like map(), filter(), and sort() for functional-style manipulation.

These examples show how to initialize, append, clone, copy, and manipulate arrays.

fn main() {
	fruits := ['apple', 'mango', 'water melon', 'musk melon']

	fruits_starting_m := fruits.filter(fn (f string) bool {
		return f.starts_with('m')
	})

	println(fruits_starting_m)
}

Map Array Items

Map Array Items

An array is a collection of elements of the same type. In V, arrays are declared using square brackets. They are index-based, dynamically sized, and provide built-in methods like map(), filter(), and sort() for functional-style manipulation.

These examples show how to initialize, append, clone, copy, and manipulate arrays.

fn main() {
	visitor := ['Tom', 'Ram', 'Rao']
	res := visitor.map('Mr. ' + it)
	println(res)
}

Map Using Anonymous Funcs On Array

Map Using Anonymous Funcs On Array

An array is a collection of elements of the same type. In V, arrays are declared using square brackets. They are index-based, dynamically sized, and provide built-in methods like map(), filter(), and sort() for functional-style manipulation.

These examples show how to initialize, append, clone, copy, and manipulate arrays.

fn main() {
	colors := ['red', 'blue', 'green', 'white', 'black']

	colors_with_letter_e := colors.map(fn (c string) int {
		if c.contains('e') { return 1 } else { return 0 }
	})

	println(colors_with_letter_e)
}

Array Methods

Array Methods

An array is a collection of elements of the same type. In V, arrays are declared using square brackets. They are index-based, dynamically sized, and provide built-in methods like map(), filter(), and sort() for functional-style manipulation.

These examples show how to initialize, append, clone, copy, and manipulate arrays.

module main

// A custom comparison function for sorting.
// It accepts references to elements (e.g. &int) and returns -1, 1, or 0.
fn compare_ints(a &int, b &int) int {
	val_a := *a
	val_b := *b
	if val_a < val_b {
		return -1
	}
	if val_a > val_b {
		return 1
	}
	return 0
}

fn main() {
	println('--- Array Built-in Methods ---')

	// 1. ensure_cap(required)
	// Ensures that the array has at least the specified capacity.
	mut a := [10, 20, 30]
	a.ensure_cap(10)
	println('ensure_cap: cap is ${a.cap >= 10}') // true

	// 2. repeat(count)
	// Repeats the array count times and returns a new array.
	rep := a.repeat(2)
	println('repeat: ${rep}') // [10, 20, 30, 10, 20, 30]

	// 3. repeat_to_depth(count, depth) (unsafe)
	// Recursively repeats a multi-dimensional array count times to the specified depth.
	grid := [[1, 2], [3, 4]]
	unsafe {
		rep_grid := grid.repeat_to_depth(2, 1)
		// Cast the raw array struct back to typed [][]int
		typed_grid := *(&[][]int(&rep_grid))
		println('repeat_to_depth: ${typed_grid}') // [[1, 2], [3, 4], [1, 2], [3, 4]]
		rep_grid.free()
	}
	// 4. insert(index, val)
	// Inserts a new element at the specified index.
	a.insert(1, 15)
	println('insert: ${a}') // [10, 15, 20, 30]

	// 5. prepend(val)
	// Prepends a new element at the beginning of the array.
	a.prepend(5)
	println('prepend: ${a}') // [5, 10, 15, 20, 30]

	// 6. delete(index)
	// Deletes the element at the specified index.
	a.delete(1) // Deletes index 1 (which is 10)
	println('delete: ${a}') // [5, 15, 20, 30]

	// 7. delete_many(index, size)
	// Deletes size elements starting from the specified index.
	a.delete_many(1, 2) // Deletes 2 elements starting at index 1
	println('delete_many: ${a}') // [5, 30]

	// 8. clear()
	// Sets the array length to 0, retaining capacity.
	mut a_clear := [1, 2, 3]
	a_clear.clear()
	println('clear: len is ${a_clear.len}') // 0

	// 9. reset() (unsafe)
	// Sets all elements of the array to 0 / empty values without altering len or cap.
	mut a_reset := [1, 2, 3]
	unsafe {
		a_reset.reset()
	}
	println('reset: ${a_reset}') // [0, 0, 0]
	unsafe {
		a_reset.free()
	}

	// 10. trim(index)
	// Truncates the array length to index.
	mut a_trim := [1, 2, 3, 4]
	a_trim.trim(2)
	println('trim: ${a_trim}') // [1, 2]

	// 11. drop(num)
	// Drops the first num elements in-place.
	mut a_drop := [1, 2, 3, 4]
	a_drop.drop(2)
	println('drop: ${a_drop}') // [3, 4]

	// 12. first()
	// Returns the first element of the array.
	println('first: ${a_drop.first()}') // 3

	// 13. last()
	// Returns the last element of the array.
	println('last: ${a_drop.last()}') // 4

	// 14. pop_left()
	// Removes and returns the first element of the array.
	mut a_pop := [1, 2, 3]
	first_val := a_pop.pop_left()
	println('pop_left: value = ${first_val}, array = ${a_pop}') // 1, [2, 3]

	// 15. pop()
	// Removes and returns the last element of the array.
	last_val := a_pop.pop()
	println('pop: value = ${last_val}, array = ${a_pop}') // 3, [2]

	// 16. delete_last()
	// Deletes the last element of the array.
	mut a_del_last := [1, 2, 3]
	a_del_last.delete_last()
	println('delete_last: ${a_del_last}') // [1, 2]

	// 17. clone()
	// Returns a deep copy of the array.
	a_clone := a_del_last.clone()
	println('clone: ${a_clone}') // [1, 2]

	// 18. clone_to_depth(depth) (unsafe)
	// Recursively clones a multi-dimensional array up to the specified depth.
	grid2 := [[1, 2], [3, 4]]
	unsafe {
		grid_clone := grid2.clone_to_depth(1)
		typed_clone := *(&[][]int(&grid_clone))
		println('clone_to_depth: ${typed_clone}') // [[1, 2], [3, 4]]
		grid_clone.free()
	}
	// 19. push_many(val, size) (unsafe)
	// Appends size elements starting from a raw pointer val to the array.
	mut a_push := [1, 2]
	vals := [3, 4]
	unsafe {
		a_push.push_many(vals.data, 2)
	}
	println('push_many: ${a_push}') // [1, 2, 3, 4]
	unsafe {
		a_push.free()
		vals.free()
	}
	// 20. reverse()
	// Returns a new reversed copy of the array.
	a_rev := [1, 2, 3]
	println('reverse: ${a_rev.reverse()}') // [3, 2, 1]

	// 21. reverse_in_place()
	// Reverses the array elements in-place.
	mut a_rev_ip := [1, 2, 3]
	a_rev_ip.reverse_in_place()
	println('reverse_in_place: ${a_rev_ip}') // [3, 2, 1]

	// 22. free() (unsafe)
	// Deallocates the array's buffer.
	mut a_free := [1, 2, 3]
	unsafe {
		a_free.free()
	}
	println('free: array freed')

	// 23. filter(it)
	// Filters elements that satisfy a predicate using compiler-defined `it` expression.
	a_filt := [1, 2, 3, 4]
	filtered := a_filt.filter(it % 2 == 0)
	println('filter: ${filtered}') // [2, 4]

	// 24. any(it)
	// Checks if any element satisfies the predicate.
	println('any: ${a_filt.any(it > 3)}') // true

	// 25. count(it)
	// Counts how many elements satisfy the predicate.
	println('count: ${a_filt.count(it % 2 == 0)}') // 2

	// 26. all(it)
	// Checks if all elements satisfy the predicate.
	println('all: ${a_filt.all(it > 0)}') // true

	// 27. map(it)
	// Maps elements to a new array using a transformation expression.
	mapped := a_filt.map(it * 10)
	println('map: ${mapped}') // [10, 20, 30, 40]

	// 28. sort() & sort(custom)
	// Sorts elements in-place. Uses optional boolean expression for custom order (uses magic vars a and b).
	mut a_sort := [3, 1, 4, 2]
	a_sort.sort()
	println('sort (default ascending): ${a_sort}') // [1, 2, 3, 4]
	a_sort.sort(a > b)
	println('sort (custom descending): ${a_sort}') // [4, 3, 2, 1]

	// 29. sorted() & sorted(custom)
	// Returns a sorted copy of the array. Uses optional boolean expression for custom order (uses magic vars a and b).
	a_sorted := [3, 1, 4, 2]
	println('sorted (default): ${a_sorted.sorted()}') // [1, 2, 3, 4]
	println('sorted (custom): ${a_sorted.sorted(a > b)}') // [4, 3, 2, 1]

	// 30. sort_with_compare(callback)
	// Sorts the array in-place using a custom comparison function.
	mut a_compare := [3, 1, 4, 2]
	a_compare.sort_with_compare(compare_ints)
	println('sort_with_compare: ${a_compare}') // [1, 2, 3, 4]

	// 31. sorted_with_compare(callback)
	// Returns a sorted copy of the array using a custom comparison function.
	a_sorted_comp := [3, 1, 4, 2]
	println('sorted_with_compare: ${a_sorted_comp.sorted_with_compare(compare_ints)}') // [1, 2, 3, 4]

	// 32. contains(value)
	// Checks if the array contains value.
	println('contains: ${a_filt.contains(3)}') // true

	// 33. index(value)
	// Returns the index of the first occurrence of value, or -1 if not found.
	println('index: ${a_filt.index(3)}') // 2

	// 34. last_index(value)
	// Returns the index of the last occurrence of value, or -1 if not found.
	a_dup := [1, 2, 3, 2]
	println('last_index: ${a_dup.last_index(2)}') // 3

	// 35. grow_cap(amount)
	// Increases the array capacity by the specified amount.
	mut a_grow := [1, 2]
	a_grow.grow_cap(10)
	println('grow_cap: cap is ${a_grow.cap >= 12}') // true

	// 36. grow_len(amount) (unsafe)
	// Increases the array length by the specified amount.
	unsafe {
		a_grow.grow_len(3)
	}
	println('grow_len: ${a_grow}') // [1, 2, 0, 0, 0]
	unsafe {
		a_grow.free()
	}

	// 37. pointers() (unsafe)
	// Returns an array of void pointers (pointers()) pointing to each element.
	a_ptrs := [10, 20]
	unsafe {
		ptrs := a_ptrs.pointers()
		println('pointers (first element): ${*(&int(ptrs[0]))}') // 10
		ptrs.free()
		a_ptrs.free()
	}
}

Array Update Syntax

Array Update Syntax

V lets you initialise an array by spreading an existing array (using ellipsis spread syntax ...), optionally followed by additional elements.

module main

fn main() {
	println('=== Array Update Syntax ===')

	base := [1, 2]
	a := [...base, 3, 4]

	println('base: ${base}') // [1, 2]
	println('a: ${a}')       // [1, 2, 3, 4]

	assert base == [1, 2]
	assert a == [1, 2, 3, 4]
}

Maps

Explicit Map Initialization

Explicit Map Initialization

A map is an unordered collection of key-value pairs, also known as a dictionary or associative array. In V, map keys must be strings or integer types, and values can be of any type. Maps are declared using curly braces with colon separators.

These examples cover how to initialize maps, look up keys, add or delete entries, and check if a key exists.

fn main() {
	mut books := map[string]int{}
	books['V on Wheels'] = 320
	books['Go for Dummies'] = 279

	println(books)
}

Short Syntax Initialization Of Map

Short Syntax Initialization Of Map

A map is an unordered collection of key-value pairs, also known as a dictionary or associative array. In V, map keys must be strings or integer types, and values can be of any type. Maps are declared using curly braces with colon separators.

These examples cover how to initialize maps, look up keys, add or delete entries, and check if a key exists.

fn main() {
	mut student_1 := {
		'english':     90
		'mathematics': 96
		'physics':     83
		'chemistry':   89
	}
	println(student_1)
}

Count Key Value Pairs In Map

Count Key Value Pairs In Map

A map is an unordered collection of key-value pairs, also known as a dictionary or associative array. In V, map keys must be strings or integer types, and values can be of any type. Maps are declared using curly braces with colon separators.

These examples cover how to initialize maps, look up keys, add or delete entries, and check if a key exists.

fn main() {
	mut student_1 := {
		'english':     90
		'mathematics': 96
		'physics':     83
		'chemistry':   89
	}
	cnt := student_1.len
	println('There are ${cnt} key-value pairs in student_1 map')
}

Value Given Key Of Map

Value Given Key Of Map

A map is an unordered collection of key-value pairs, also known as a dictionary or associative array. In V, map keys must be strings or integer types, and values can be of any type. Maps are declared using curly braces with colon separators.

These examples cover how to initialize maps, look up keys, add or delete entries, and check if a key exists.

fn main() {
	mut student_1 := {
		'english':     90
		'mathematics': 96
		'physics':     83
		'chemistry':   89
	}

	println(student_1['physics']) // 83
}

Value Given Non Existent Key Of Map

Value Given Non Existent Key Of Map

A map is an unordered collection of key-value pairs, also known as a dictionary or associative array. In V, map keys must be strings or integer types, and values can be of any type. Maps are declared using curly braces with colon separators.

These examples cover how to initialize maps, look up keys, add or delete entries, and check if a key exists.

fn main() {
	mut student_1 := {
		'english':     90
		'mathematics': 96
		'physics':     83
		'chemistry':   89
	}

	println(student_1['geography']) // 0
}

Handling Missing Keys In Map

Handling Missing Keys In Map

A map is an unordered collection of key-value pairs, also known as a dictionary or associative array. In V, map keys must be strings or integer types, and values can be of any type. Maps are declared using curly braces with colon separators.

These examples cover how to initialize maps, look up keys, add or delete entries, and check if a key exists.

fn main() {
	mut student_1 := {
		'english':     90
		'mathematics': 96
		'physics':     83
		'chemistry':   89
	}

	sub := 'geography'
	res := student_1[sub] or { panic('marks for subject ${sub} not yet updated') } // throws error
}

Update Value Given A Key In Map

Update Value Given A Key In Map

A map is an unordered collection of key-value pairs, also known as a dictionary or associative array. In V, map keys must be strings or integer types, and values can be of any type. Maps are declared using curly braces with colon separators.

These examples cover how to initialize maps, look up keys, add or delete entries, and check if a key exists.

fn main() {
	mut student_1 := {
		'english':     90
		'mathematics': 96
		'physics':     83
		'chemistry':   89
	}
	student_1['english'] = 93
	println(student_1)
}

Delete Key Value Pair From Map

Delete Key Value Pair From Map

A map is an unordered collection of key-value pairs, also known as a dictionary or associative array. In V, map keys must be strings or integer types, and values can be of any type. Maps are declared using curly braces with colon separators.

These examples cover how to initialize maps, look up keys, add or delete entries, and check if a key exists.

fn main() {
	mut student_1 := {
		'english':     90
		'mathematics': 96
		'physics':     83
		'chemistry':   89
	}

	println('Key-Value pairs before deleting a key: ${student_1.len}')
	student_1.delete('physics')
	println('Key-Value pairs after deleting a key ${student_1.len}')
}

Map Methods

Map Methods

A map is an unordered collection of key-value pairs, also known as a dictionary or associative array. In V, map keys must be strings or integer types, and values can be of any type. Maps are declared using curly braces with colon separators.

These examples cover how to initialize maps, look up keys, add or delete entries, and check if a key exists.

module main

fn main() {
	println('--- Map Built-in Methods ---')

	mut m := {
		'one': 1
		'two': 2
	}
	println('initial map: ${m}') // {"one": 1, "two": 2}

	// 1. keys()
	// Returns an array containing all keys in the map.
	println('keys: ${m.keys()}') // ["one", "two"]

	// 2. values()
	// Returns an array containing all values in the map.
	println('values: ${m.values()}') // [1, 2]

	// 3. clone()
	// Returns a deep copy of the map.
	mut m_clone := m.clone()
	println('clone: ${m_clone}') // {"one": 1, "two": 2}

	// 4. delete(key)
	// Removes a key-value pair from the map by key.
	m.delete('one')
	println('delete: ${m}') // {"two": 2}

	// 5. reserve(capacity)
	// Pre-allocates space for at least capacity elements in the map.
	m.reserve(10)
	println('reserve: reserved capacity successfully')

	// 6. clear()
	// Removes all key-value pairs from the map without deallocating data.
	m.clear()
	println('clear: len is ${m.len}') // 0

	// 7. move()
	// Moves the map contents to a new map variable and clears the original map to empty.
	mut m_move := {
		'three': 3
		'four':  4
	}
	moved := m_move.move()
	println('move (new map): ${moved}') // {"three": 3, "four": 4}
	println('move (original map): ${m_move}') // {}

	// 8. free() (unsafe)
	// Deallocates the map memory.
	mut m_free := {
		'temp': 100
	}
	unsafe {
		m_free.free()
	}
	println('free: map freed successfully')
}

Import Maps Helpers

Import Maps Helpers

The maps module provides higher-level helpers for filtering, transforming, inverting, merging, and converting between maps and arrays. These helpers are useful when you want to work with map data in a functional style without manually writing the loops yourself.

module main

import maps

fn main() {
	println('--- Import Maps Module Helpers ---')

	// Start with a simple map of fruit counts.
	m1 := {
		'apple':  1
		'banana': 2
		'cherry': 3
	}

	// filter() keeps only the entries that satisfy the callback condition.
	filtered := maps.filter(m1, fn (k string, v int) bool {
		return v > 1
	})
	println('filter(): ${filtered}')

	// to_array() builds a new array by transforming each entry.
	keys_upper := maps.to_array(m1, fn (k string, v int) string {
		return k.to_upper()
	})
	println('to_array(): ${keys_upper}')

	// invert() swaps each key/value pair so the values become the keys.
	inverted := maps.invert(m1)
	println('invert(): ${inverted}')

	// from_array() creates a map from a list of strings.
	fruits := ['apple', 'banana', 'cherry']
	map_from_arr := maps.from_array(fruits)
	println('from_array(): ${map_from_arr}')

	// merge() combines two maps and lets the second map override duplicates.
	m2 := {
		'banana': 20
		'date':   4
	}
	merged := maps.merge(m1, m2)
	println('merge(): ${merged}')

	// merge_in_place() mutates the first map directly.
	mut mut_map := {
		'a': 1
	}
	maps.merge_in_place(mut mut_map, {
		'b': 2
		'c': 3
	})
	println('merge_in_place(): ${mut_map}')

	// flat_map() can expand each entry into multiple output values.
	flat_items := maps.flat_map[string, int, string](m1, fn (k string, v int) []string {
		return [k, v.str()]
	})
	println('flat_map(): ${flat_items}')

	// to_map() transforms each entry into a new key/value pair.
	transformed := maps.to_map[string, int, string, int](m1, fn (k string, v int) (string, int) {
		return k.to_upper(), v * 10
	})
	println('to_map(): ${transformed}')
}

Map Update Syntax

Map Update Syntax

Similar to structs, V lets you initialise a new map with updates applied on top of an existing map using the spread syntax .... This is functionally equivalent to cloning the map and updating it, except that it avoids declaring a mutable intermediate variable and allows inlining elements.

module main

fn main() {
	println('=== Map Update Syntax ===')

	base_map := {
		'a': 4
		'b': 5
	}

	// Create a new map by updating elements of base_map
	foo := {
		...base_map
		'b': 88
		'c': 99
	}

	println('base_map: ${base_map}') // {'a': 4, 'b': 5}
	println('foo: ${foo}')           // {'a': 4, 'b': 88, 'c': 99}
	
	assert base_map['b'] == 5
	assert foo['a'] == 4
	assert foo['b'] == 88
	assert foo['c'] == 99
}

Chapter 6 Functions

Quick Access

Below is an index of all code examples in this chapter. You can use these links to jump directly to any specific code example:

Advanced Function Features

• Function Returns Value Example 1
• Function Returns Value Example 2
• Funtions Without Return Type
• Function With Input Arguments
• Function Return Multiple Values
• Ignore Function Return Value
• Function Calls Other Function
• Example 1
• Example 2
• Error Script Functions
• Script Functions
• Functions Module Variables - Main (main.v)
• Mymod
• Functions With Optional Return Types Example 1
• Function With Optional Return Type Example 2
• Mod1
• Public Function Demo1
• Public Function Demo2
• Public Function Demo3
• Function With Defer Block
• Functions As Elements Of Array Or Map

Function Extras

• Hello
• Basic Functions
• Anonymous Functions
• Functions As Input Arguments
• Functions That Return Other Functions
• Lambda Expressions
• Closures

Functions let you turn repeated or complex logic into small, named building blocks. A useful mental model is: define the task, give it inputs if needed, do the work, and return a useful result. This chapter starts with simple functions and then introduces multiple returns, optional results, higher-order functions, and cleanup with defer.

Under the Hood: Calling Conventions, Multiple Returns & Closures

Functions in V are designed for clarity, zero runtime overhead, and seamless integration with native C calling conventions.

Multiple Return Values Without Heap Allocation

In many languages, returning multiple values requires allocating a tuple or object on the heap. In V:

fn divide(a int, b int) (int, int) {
    return a / b, a % b
}

Under the hood, the compiler creates an anonymous C struct on the caller's stack frame:

typedef struct { int arg0; int arg1; } MultiReturn_int_int;

The return values are written directly into this stack structure or returned via CPU registers, resulting in zero heap allocation and optimal performance.

Parameter Passing Conventions

* Pass-by-Value (Default): Primitive types (int, f64, bool) and small structs are passed by value (copied onto the stack or passed directly in CPU registers).

* Pass-by-Reference (mut): When a parameter is declared with mut (e.g. fn update(mut user User)), V passes a pointer to the caller's instance (User*), allowing in-place modifications.

* Immutable Parameters: Function parameters are immutable by default. You cannot reassign or modify a parameter unless explicitly marked mut.

Closures & Environment Capture

When an anonymous function references variables from its enclosing scope:

multiplier := 3
triple := fn [multiplier] (x int) int {
    return x * multiplier
}

The V compiler generates a hidden environment closure struct that captures the referenced variable (multiplier), ensuring safe access across scope boundaries.

Function Attributes

| Attribute | Purpose | Description |

| :--- | :--- | :--- |

| @[inline] | Performance | Instructs the backend C compiler to inline the function body directly at callsites, eliminating function call overhead in performance-critical loops. |

| @[params] | Clean API Design | Enables the struct options pattern, allowing callers to pass named arguments or omit optional parameters cleanly. |

| @[deprecated: 'Use new_fn()'] | Maintainability | Emits a compiler warning whenever the marked function is called. |

Advanced Function Features

Function Returns Value Example 1

Function Returns Value Example 1

A simple function is a small helper that turns inputs into a useful result. The basic pattern is: define the function, pass in values, do some work, and return the answer. In this example, add takes two integers and returns their sum.

fn add(a int, b int) int {
	return a + b
}

fn main() {
	println(add(2, 3))
}

Function Returns Value Example 2

Function Returns Value Example 2

A function does not need to print anything itself. It can build a value and hand it back to the caller. Here, say_hello returns a greeting string, and main decides how to display it.

fn say_hello() string {
	return 'Hello!'
}

fn main() {
	// call the method
	res := say_hello()
	println(res)
	// prints: Hello!
}

Functions Without Return Type

Functions Without Return Type

Some functions are used for actions rather than calculations. They may print output, write files, or update state. In that case, you can leave out the return type and focus on the side effect.

fn console_greeter() {
	println('Hello!')
}

fn main() {
	console_greeter()
	// prints: Hello!
}

Function With Input Arguments

Function With Input Arguments

Functions become much more useful when they accept inputs. This example uses two numbers as arguments and returns their sum, showing the classic input → process → output flow.

fn add(a int, b int) int {
	return a + b
}

fn main() {
	res := add(2, 4)
	println(res)
	// prints: 6
}

Function Return Multiple Values

Function Return Multiple Values

In V, functions are not limited to returning a single value. A function can return a tuple containing two or more values when they logically belong together. A very common pattern in systems programming is returning both the main result of an operation and a secondary value (such as status flags, byte counts, or errors). Returning multiple values is clean, avoids wrapping results in temporary struct containers, and is assigned using parallel declaration at the call site.

This example shows how a function computes a string greeting and returns both the greeting string and its length as an integer.

// The return types are declared within parentheses: (string, int)
fn greet_and_message_length(name string) (string, int) {
	mut greeting := 'Hello, ' + name + '!'
	// Multiple values are returned as a comma-separated list
	return greeting, greeting.len
}

fn main() {
	// Receive multiple return values using parallel assignment
	i, j := greet_and_message_length('Navule')
	println(i) // Prints: Hello, Navule!
	println(j) // Prints the length: 14
}

Ignore Function Return Value

Ignore Function Return Value

Sometimes you only care about one returned value. V lets you ignore the rest with _, which keeps the code readable when you are only interested in part of the result.

fn greet_and_message_length(name string) (string, int) {
	mut greeting := 'Hello, ' + name + '!'
	return greeting, greeting.len
}

fn main() {
	i, _ := greet_and_message_length('Navule')
	println(i)
}

Function Calls Other Function

Function Calls Other Function

Functions can call other functions to split a bigger problem into smaller steps. This makes the code easier to understand and easier to reuse later.

fn greet(p string) string {
	return 'Hello, ${p}!'
}

fn welcome(p string) string {
	msg := 'Nice to meet you!'
	mut g := greet(p)
	g = g + ' ${msg}'
	return g
}

fn main() {
	res := welcome('Visitor')
	println(res)
}

Example 1

Example 1

V functions support several advanced features:

• Multiple Return Values: A function can return more than one value (often a result and an error).
• Blank Identifier (_): Used to discard unwanted return values.
• Defer: Schedules a block of code to run right before the function exits, which is excellent for resource cleanup.
• Anonymous Functions & Closures: Functions defined inline that can capture variables from their outer scope.

These examples illustrate these powerful concepts.

fn increment_array_items(arr []int, inc int) []int {
	mut tmp := arr.clone()
	for mut i in tmp {
		i += inc
	}
	return tmp
}

fn main() {
	a := [5, 6]

	res := increment_array_items(a, 100)

	println('a: ${a}')
	println('res: ${res}')
}

Example 2

Example 2

V functions support several advanced features:

• Multiple Return Values: A function can return more than one value (often a result and an error).
• Blank Identifier (_): Used to discard unwanted return values.
• Defer: Schedules a block of code to run right before the function exits, which is excellent for resource cleanup.
• Anonymous Functions & Closures: Functions defined inline that can capture variables from their outer scope.

These examples illustrate these powerful concepts.

fn increment_array_items(mut arr []int, inc int) {
	for mut i in arr {
		i += inc
	}
}

fn main() {
	mut a := [5, 6]
	increment_array_items(mut a, 100)
	// Must specify mut keyword when sending value to mut arg of a function
	println('a: ${a}')
}

Error Script Functions

Error Script Functions

V functions support several advanced features:

• Multiple Return Values: A function can return more than one value (often a result and an error).
• Blank Identifier (_): Used to discard unwanted return values.
• Defer: Schedules a block of code to run right before the function exits, which is excellent for resource cleanup.
• Anonymous Functions & Closures: Functions defined inline that can capture variables from their outer scope.

These examples illustrate these powerful concepts.

#!/usr/local/bin/v run

cnt := 2

for i in 0 .. cnt {
	log('iteration ${i}')
}

fn log(msg string) {
	println(msg)
}

Script Functions

Script Functions

V functions support several advanced features:

• Multiple Return Values: A function can return more than one value (often a result and an error).
• Blank Identifier (_): Used to discard unwanted return values.
• Defer: Schedules a block of code to run right before the function exits, which is excellent for resource cleanup.
• Anonymous Functions & Closures: Functions defined inline that can capture variables from their outer scope.

These examples illustrate these powerful concepts.

#!/usr/local/bin/v run

fn log(msg string) {
	println(msg)
}

cnt := 2

for i in 0 .. cnt {
	log('iteration ${i}')
}

Functions Module Variables - Main (main.v)

Functions Module Variables - Main

V functions support several advanced features:

• Multiple Return Values: A function can return more than one value (often a result and an error).
• Blank Identifier (_): Used to discard unwanted return values.
• Defer: Schedules a block of code to run right before the function exits, which is excellent for resource cleanup.
• Anonymous Functions & Closures: Functions defined inline that can capture variables from their outer scope.

These examples illustrate these powerful concepts.

// file: main.v
module main

import mymod

fn main() {
	mymod.msg := 'global variable demo'
	println(mymod.msg)
}

Mymod

Mymod

V functions support several advanced features:

• Multiple Return Values: A function can return more than one value (often a result and an error).
• Blank Identifier (_): Used to discard unwanted return values.
• Defer: Schedules a block of code to run right before the function exits, which is excellent for resource cleanup.
• Anonymous Functions & Closures: Functions defined inline that can capture variables from their outer scope.

These examples illustrate these powerful concepts.

// file: mymod/mymod.v
module mymod

__global (
	msg string
)

Functions With Optional Return Types Example 1

Functions With Optional Return Types Example 1

V functions support several advanced features:

• Multiple Return Values: A function can return more than one value (often a result and an error).
• Blank Identifier (_): Used to discard unwanted return values.
• Defer: Schedules a block of code to run right before the function exits, which is excellent for resource cleanup.
• Anonymous Functions & Closures: Functions defined inline that can capture variables from their outer scope.

These examples illustrate these powerful concepts.

module main

fn is_teen(age int) ?string {
	if age < 0 {
		return none
	} else if age >= 13 && age <= 19 {
		return 'teenager'
	} else {
		return 'not teenager'
	}
}

fn main() {
	x := is_teen(-3) or { 'invalid age provided' }
	println(x)
}

Function With Optional Return Type Example 2

Function With Optional Return Type Example 2

V functions support several advanced features:

• Multiple Return Values: A function can return more than one value (often a result and an error).
• Blank Identifier (_): Used to discard unwanted return values.
• Defer: Schedules a block of code to run right before the function exits, which is excellent for resource cleanup.
• Anonymous Functions & Closures: Functions defined inline that can capture variables from their outer scope.

These examples illustrate these powerful concepts.

module main

fn is_teen(age int) !string {
	if age < 0 {
		return error('invalid age provided')
	} else if age >= 13 && age <= 19 {
		return 'teenager'
	} else {
		return 'not teenager'
	}
}

fn main() {
	x := is_teen(-3) or { err.msg() }
	println(x)
}

Mod1

Mod1

V functions support several advanced features:

• Multiple Return Values: A function can return more than one value (often a result and an error).
• Blank Identifier (_): Used to discard unwanted return values.
• Defer: Schedules a block of code to run right before the function exits, which is excellent for resource cleanup.
• Anonymous Functions & Closures: Functions defined inline that can capture variables from their outer scope.

These examples illustrate these powerful concepts.

// file: mod1/mod1.v
module mod1

fn greet1() string {
	return 'Hello from greet1'
}

pub fn greet2() string {
	return 'Hello from greet2'
}

pub fn greet_and_wish() string {
	wish := 'Have a nice day!'
	return greet1() + ', ' + wish
}

Public Function Demo1

Public Function Demo1

V functions support several advanced features:

• Multiple Return Values: A function can return more than one value (often a result and an error).
• Blank Identifier (_): Used to discard unwanted return values.
• Defer: Schedules a block of code to run right before the function exits, which is excellent for resource cleanup.
• Anonymous Functions & Closures: Functions defined inline that can capture variables from their outer scope.

These examples illustrate these powerful concepts.

// file: public_function_demo1.v
import mod1

fn main() {
	g := mod1.greet1()
	println(g)
}

Public Function Demo2

Public Function Demo2

V functions support several advanced features:

• Multiple Return Values: A function can return more than one value (often a result and an error).
• Blank Identifier (_): Used to discard unwanted return values.
• Defer: Schedules a block of code to run right before the function exits, which is excellent for resource cleanup.
• Anonymous Functions & Closures: Functions defined inline that can capture variables from their outer scope.

These examples illustrate these powerful concepts.

// file: public_function_demo2.v
import mod1

fn main() {
	g := mod1.greet2()
	println(g)
}

Public Function Demo3

Public Function Demo3

V functions support several advanced features:

• Multiple Return Values: A function can return more than one value (often a result and an error).
• Blank Identifier (_): Used to discard unwanted return values.
• Defer: Schedules a block of code to run right before the function exits, which is excellent for resource cleanup.
• Anonymous Functions & Closures: Functions defined inline that can capture variables from their outer scope.

These examples illustrate these powerful concepts.