V (programming Language)

V, also known as vlang, is a statically typed, compiled programming language created by Alexander Medvednikov in early 2019. It was inspired by the language Go, and other influences including Oberon, Swift, and Rust. It is free and open-source software released under the MIT License, and currently in beta.

The goals of V include ease of use, readability, and maintainability.

History

According to various sources, the new language was created as a result of frustration with existing languages being used for personal projects. The language was originally intended for personal use, but after it was mentioned publicly and gained interest, it was decided to make it public. V was initially created to develop a desktop messaging client named Volt. On public release, the compiler was written in V, and could compile itself. Key design goals in creating V were being easy to learn and use, higher readability, fast compiling, increased safety, efficient development, cross-platform usability, improved C interoperability, better error handling, modern features, and more maintainable software.

V is released and developed through GitHub, and maintained by developers and contributors internationally. It is among the languages that have been listed on the TIOBE index.

Features

Safety

V has policies to facilitate memory-safety, speed, and secure code, including various default features for greater program safety. It employs bounds checking, to guard against out of bounds use of variables. Option/result types are used, where the option data type () can be represented by (among possible choices) and the result type () can handle any returned errors. To ensure greater safety, error checking is mandatory. By default, the following are immutable: variables, structs, and function arguments. This includes string values are immutable, so elements cannot be mutated. Other protections, which are the default for the language, are: no use of undefined values, variable shadowing, null pointers (unless marked as unsafe), or global variables (unless enabled via flag).

Performance

V uses value types and string buffers to reduce memory allocations. The language can be compiled to human-readable C, and in terms of execution and compilation, it's considered to be as performant.

Memory management

V supports 4 memory management options:

# Use of an optional garbage collection (GC), that can be disabled, for handling allocations, and is the default.
# Manual memory management via disabling the GC (-gc none).
# Autofree, which handles most objects via free call insertion, and then the remaining percentage is freed by GC (-autofree).
# Arena allocation (-prealloc).

Source code translators

V supports a source-to-source compiler (transpiler) and can translate C code into V.

Working translators are also being developed for Go, JavaScript, and WebAssembly.

Syntax

Hello world

The "Hello, World!" program in V:

fn main()

Variables

Variables are immutable by default and are defined using and a value. Use the reserved word (keyword) to make them mutable. Mutable variables can be assigned to using :

a := 1
mut b := 2
b = 3

Redeclaring a variable, whether in an inner scope or in the same scope, is not allowed:

a := 1

a := 2 // error: redefinition of a

Structs

Struct example:

struct Point

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

10

Heap structs

Structs are allocated on the stack by default. To allocate a struct on the heap and get a reference to it, the prefix can be used:

struct Point

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

Methods

Methods in V are functions defined with a 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.

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. For example:

struct User

fn (u User) is_registered() bool

user := User
println(user.is_registered()) // "false"

user2 := User
println(user2.is_registered()) // "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.

fn do_something(s string) !string

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

println(a)
println(b)

See also

* Comparison of programming languages
* History of programming languages
* List of programming languages
* List of programming languages by type

References

Further reading

*
*
*
*
*
*

External links

*
* {{GitHub, vlang, Vlang

Documentation

Modules

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

Articles with example code