V Programming language

V

The official V logo
Paradigms	Multi-paradigm: functional, imperative, structured
Designed by	Alexander Medvednikov
First appeared	25 June 2019 (2019-06-25)
Stable release	0.4.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

Search V Programming language on Amazon.

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.

History

The language came about because of frustration with existing programming languages that were being used for personal projects. Originally the new language was intended for personal use, but after it was mentioned publicly and gained interest, it was decided to make the language public. Initially, it had the same name as a product known as Volt. The V language was created in order to develop it, along with other software applications such as Ved (also called Vid). As the extension in use was already ".v", to not mess up the git history, it was decided to name it "V". Upon public release, the compiler was written in V, and could compile itself. Along with Alexander Medvednikov, the creator, its community has a large number of contributors who have helped with continually developing and adding to the compiler, language, and modules. Key design goals behind the creation of V: easier to learn and use, higher readability, fast compilation, increased safety, efficient development, cross-platform usability, improved C interop, better error handling, modern features, and more maintainable software.

Veasel is the official mascot of the V programming language, which is shown above.

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 or bypassed when performance is more important.
• C interop without any costs
• 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 an optional GC, as the default (which can be disabled). Autofree, when production ready, may become the default.

Autofree can be enabled with -autofree. It takes care of most objects; the compiler inserts necessary free calls automatically during compilation. The remaining 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)

V can translate entire C projects (via modules). For example, translating DOOM from C to V, which can take less than a second.

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 sanitized 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
	}
}

Other features

The Vinix Operating System is a demonstration of V's ability to make a usable OS that can run on real hardware, not just emulators or virtual machines. It targets modern 64-bit architectures, CPU features, and multi-core computing. Aims to have source-level compatibility with Linux, allowing the porting over of programs.

Further Reading

Books & Magazines

• Laboratory, Independent (June 20, 2020). The V Programming Language basic (in 日本語). ASIN B08BKJDRFR. Search this book on
• Rao, Navule (December 10, 2021). Getting Started with V Programming. Packt Publishing. ISBN 1839213434. Search this book on
• Lyons, Dakota "Kai" (April 13, 2022). Beginning with V Programming. Independently Published. ISBN 8801499963. Search this book on
• Chakraborty, Soubhik; Haldar, Subhomoy (December 6, 2023). Randomness Revisited using the V Programming Language. Nova Science Publishers. doi:10.52305/CVCN5241. ISBN 8891133280. Search this book on
• Tsoukalos, Mihalis (May 2022). "Discover the V language". Linux Format Magazine (288). ISSN 1470-4234.

Translated Documentation

• "V language learning notes". GitBook (in 中文).
• "V documentation". Qiita (in 日本語).

External links

• Official Vlang Website
• Official Vlang Twitter
• Official Vlang Discord
• Official Vlang YouTube

V Language Review (Videos)

• An introduction to V - the vlang (2022)
• Is V Lang Better Than Go And Rust? Let's Find Out (2023)
• V language - First Impression (2024)

References

This article "V Programming language" is from Wikipedia. The list of its authors can be seen in its historical and/or the page Edithistory:V Programming language. Articles copied from Draft Namespace on Wikipedia could be seen on the Draft Namespace of Wikipedia and not main one.

---