V (programming language)

This article, V (programming language), has recently been created via the Articles for creation process. Please check to see if the reviewer has accidentally left this template after accepting the draft and take appropriate action as necessary. Reviewer tools: Inform author

This article, V (programming language), has recently been created via the Articles for creation process. Please check to see if the reviewer has accidentally left this template after accepting the draft and take appropriate action as necessary. Reviewer tools: Inform author

• Comment: As the previous comment said, this article should use more secondary sources, as primary sources are only suitable for small details that secondary sources do not cover. YouTube videos are not deem reliable as sources and should be removed as well. A portion of the content here seem to be taken from its own website, please make sure to rewrite or remove all contents marked red here. Tutwakhamoe (talk) 14:16, 13 July 2023 (UTC)

• Comment: There was a page deleted in 2008 with the same title, but referring to a different language, one more "academic". The second deletion discussion was on a page similar in content to what's in this draft, and the third being a much worse version. This version is much better because it includes four books, meaning it's likely suitable for a page. I would suggest though that the primary sources to GitHub and vlang.io be removed in favor of secondary sources. It's a promising draft. SWinxy (talk) 05:32, 31 May 2023 (UTC)

V

The official V logo
Paradigms	Multi-paradigm: functional, imperative, structured, concurrent
Designed by	Alexander Medvednikov[1]
First appeared	20 June 2019; 5 years ago (2019-06-20)[2]
Stable release	0.4.2[3] / September 30, 2023; 13 months ago (2023-09-30)
Typing discipline	static, strong, infered
Memory management	Tracing garbage collection
Implementation language	V
Platform	x86-64
OS	Linux, macOS, Windows, FreeBSD, OpenBSD, NetBSD, DragonflyBSD, Solaris
License	MIT
Filename extensions	.v, .vsh
Website	vlang.io
Influenced by
Go, Kotlin, Oberon, Python, Rust, Swift

V (/ˈviː/, as in the letter v), also known as vlang, is a statically typed compiled programming language created by Alexander Medvednikov in early 2019.^[4] It was mostly inspired by the Go programming language, but was also influenced by C, Rust, and Oberon-2.^[5][6][7] It is free and open-source software, in active development at GitHub^[8], and released under the MIT license.

The foremost goal of V is to be easy to use,^[9][10][11] and at the same time, to enforce a safe coding style through elimination of ambiguity. For example, variable shadowing is not allowed;^[12][13] declaring a variable with a name that is already used in a parent scope will cause a compilation error.

The new language was created as a result of frustration with existing languages being used for personal projects.^[14] Originally the language was intended for personal use, but after it was mentioned publicly and gained interest, it was decided to make it public. Initially, the name was the same as a product known as Volt.^[6] 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".^[11] Upon public release, the compiler was written in V, and could compile itself.^[15] Along with Alexander Medvednikov, the creator, its community has a large number of contributors from around the world^[16][15] 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.^{[11][17][18][19]}

• Usage of bounds checking
• Usage of Option/Result
• Mandatory checking of errors
• No usage of values that are undefined
• No shadowing of variables
• No usage of null (unless in unsafe code)
• No usage of global variables (unless enabled via flag)
• Variables are immutable by default
• Structs are immutable by default
• Function args are immutable by default
• Sum types can be used
• Generics can be used

• Fast like C (human-readable C compiled by backend)^{[20][21][22][23]}
  • Added features for safety, if desired, can be disabled or bypassed for greater performance
• C interop^{[24][25][26][27]}
• Allocations kept to minimal^[28]
• Serialization with no runtime reflection^[20]
• Native binaries compiled with no dependencies^[7][29]

V is written in itself and can compile within a second.^[30][15][23]

• Allocations handled by an optional GC, that is the default, which can be disabled
• Manual memory management (-gc none)
• Autofree (-autofree), handles most objects via free call insertion
  • Remaining percentage freed by GC
• Arena allocation with (-prealloc)

C source code conversion: V (via module) can translate an entire C project into V code.^[12][31][19]

Working translators (under various stages of development) exist for Go, JavaScript, and WASM.^[32][33]

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

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

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)

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 is_registered method has a receiver of type User named u. The convention is not to use receiver names like self or this, but preferably a short name.

struct User {
	age int
}

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

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

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)

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

V has a built-in ORM (object-relational mapping) which supports SQLite, MySQL and Postgres. Aims to also support MS SQL and Oracle.

V's ORM provides a number of benefits:

• One syntax for all SQL dialects
• Queries are constructed using V's syntax
• Safety (queries are sanitized to prevent SQL injection)
• Compile time checks (prevents typos which can only be caught during runtime)
• Readability and simplicity (need not manually parse results of a query or the 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
	}!
}

• The V Programming Language basic (in Japanese). Independent Laboratory. June 20, 2020. ASIN B08BKJDRFR.
• Rao, Navule Pavan Kumar (December 10, 2021). Getting Started with V Programming. Packt Publishing. ISBN 978-1839213434. OCLC 1290492862.{{cite book}}: CS1 maint: date and year (link)
• Lyons, Dakota "Kai" (April 13, 2022). Beginning with V Programming. Independently Published. ISBN 979-8801499963.{{cite book}}: CS1 maint: date and year (link)
• Tsoukalos, Mihalis (May 2022). "Discover the V language". Linux Format Magazine (288). ISSN 1470-4234.

• Official website

Category:Programming languages Category:Cross-platform free software Category:Cross-platform software Category:Free compilers and interpreters Category:Statically typed programming languages Category:Systems programming languages Category:Multi-paradigm programming languages Category:Procedural programming languages Category:Concurrent programming languages Category:Source-to-source compilers Category:Software using the MIT license Category:Programming languages created in 2019 Category:2019 software