V (programming language)

V

The official V logo
Paradigms	Multi-paradigm: functional, imperative, structured
Designed by	Alexander Medvednikov
First appeared	22 June 2019 (2019-06-22)
Stable release	0.3.x
Typing discipline	Static, strong
Implementation language	V
Platform	Cross-platform
License	MIT
Filename extensions	.v, .vsh
Website	vlang.io
Influenced by
Go C Rust Oberon-2

V, or Vlang, is a general-purpose programming language designed by Alexander Medvednikov. It is mostly inspired by the Go programming language but was also influenced by C, Rust, and Oberon-2. The foremost goal of V is to be easy to use, and at the same time, to enforce a safe coding style through elimination of ambiguity. For example, variable shadowing is not allowed; declaring a variable with a name that is already used in a parent scope will cause a compilation error.

Features

Safety

• Bounds checking
• No undefined values
• No variable shadowing
• Immutable variables by default
• Immutable structs by default
• Option/Result and mandatory error checks
• Sum types
• Generics
• Immutable function args by default, mutable args have to be marked on call
• No null (allowed in unsafe code)
• No undefined behavior (wip, some overflowing can still result in UB)
• No global variables (can be enabled for low level apps like kernels via a flag)

Performance

• Fast like C (V's main backend compiles to human readable C), with equivalent code.

V does introduce some overhead for safety (such as array bounds checking, GC free), but these features can be disabled/bypassed when performance is more important.

• C interop
• Minimal amount of allocations
• Built-in serialization without runtime reflection
• Compiles to native binaries without any dependencies

Fast build

V is written in V and compiles in less than a second.

Flexible memory management

V avoids doing unnecessary allocations by using value types, string buffers, and promoting a simple abstraction-free code style.

Presently, allocations are handled by GC until V's autofree engine is production ready.

Autofree can be enabled with -autofree. It takes care of most objects (~90-100%): the compiler inserts necessary free calls automatically during compilation. Remaining small percentage of objects are freed via GC.

For developers willing to have more low level control, memory can be managed manually with -gc none.

Arena allocation is available via v -prealloc.

Source code translators (code transpilation)

C source code conversion: V (via module) can translate an entire C project into V code.

Working translators, under various stages of development, exist for Go, JavaScript, and WASM.

Syntax

Hello world

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

Structs

struct Point {
	x int
	y int
}

mut p := Point{
	x: 10
	y: 20
}
println(p.x) // Struct fields are accessed using a dot
// Alternative literal syntax for structs with 3 fields or fewer
p = Point{10, 20}
assert p.x == 10

Heap structs

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

struct Point {
	x int
	y int
}

p := &Point{10, 10}
// References have the same syntax for accessing fields
println(p.x)

Methods

V doesn't have classes, but you can define methods to types. A method is a function with a special receiver argument. The receiver appears in its own argument list between the fn keyword and the method name. Methods must be in the same module as the receiver type.

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

struct User {
	age int
}

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

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

Error handling

Optional types are for types which may represent none. Result types may represent an error returned from a function.

Option types are declared by prepending ? to the type name: ?Type. Result types use !: !Type.

link

fn do_something(s string) !string {
	if s == 'foo' {
		return 'foo'
	}
	return error('invalid string')
}

a := do_something('foo') or { 'default' } // a will be 'foo'
b := do_something('bar') or { 'default' } // b will be 'default'
c := do_something('bar') or { panic("{err}") } // exits with error 'invalid string' and a traceback

println(a)
println(b)

Vweb

import vweb

struct App {
    vweb.Context
}

fn main() {
	vweb.run(&App{}, 8080)
}

or

import vweb

struct App {
    vweb.Context
}

fn main() {
	vweb.run_at(new_app(), vweb.RunParams{
	    host: 'localhost'
	    port: 8099
	    family: .ip
	}) or { panic(err) }
}

ORM

V has a built-in ORM (object-relational mapping) which supports SQLite, MySQL and Postgres, but soon it will support MS SQL and Oracle.

V's ORM provides a number of benefits:

• One syntax for all SQL dialects. (Migrating between databases becomes much easier.)
• Queries are constructed using V's syntax. (There's no need to learn another syntax.)
• Safety. (All queries are automatically sanitised to prevent SQL injection.)
• Compile time checks. (This prevents typos which can only be caught during runtime.)
• Readability and simplicity. (You don't need to manually parse the results of a query and then manually construct objects from the parsed results.)

import pg

struct Member {
	id         string [default: 'gen_random_uuid()'; primary; sql_type: 'uuid']
	name       string
	created_at string [default: 'CURRENT_TIMESTAMP'; sql_type: 'TIMESTAMP']
}

fn main() {
	db := pg.connect(pg.Config{
		host: 'localhost'
		port: 5432
		user: 'user'
		password: 'password'
		dbname: 'dbname'
	}) or {
		println(err)
		return
	}

	defer {
		db.close()
	}

	sql db {
		create table Member
	}

	new_member := Member{
		name: 'John Doe'
	}

	sql db {
		insert new_member into Member
	}

	selected_member := sql db {
		select from Member where name == 'John Doe' limit 1
	}

	sql db {
		update Member set name = 'Hitalo' where id == selected_member.id
	}
}

Further Reading

• Laboratory, Independent (June 20, 2020) (in ja). The V Programming Language basic. 
• Rao, Navule Pavan Kumar (December 10, 2021) (in en). Getting Started with V Programming. Packt Publishing. ISBN 1839213434. 
• Lyons, Dakota "Kai" (April 13, 2022) (in en). Beginning with V Programming. Independently Published. ISBN 979-8801499963. 
• Tsoukalos, Mihalis (March 29, 2022) (in en). Discover the V language. Linux Format 288. 

External links

• Official website
• Official YouTube channel
• An introduction to V - the vlang