V (programming language)

Last updated

V
V Logo SVG.svg
The official V logo
Paradigms Multi-paradigm: functional, imperative, structured, concurrent
Designed by Alexander Medvednikov [1]
First appeared20 June 2019;5 years ago (2019-06-20) [2]
Stable release
0.4.9 [3]   OOjs UI icon edit-ltr-progressive.svg / December 22, 2024;20 days ago (December 22, 2024)
Typing discipline static, strong, inferred
Memory management optional (automatic or manual)
Implementation languageV
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, also known as vlang, is a statically typed, compiled programming language created by Alexander Medvednikov in early 2019. [4] It was inspired by the language Go, and other influences including Oberon, Swift, and Rust. [5] [6] [7] It is free and open-source software released under the MIT License, and currently in beta. [8]

Contents

The goals of V include ease of use, readability, and maintainability. [9] [10]

History

According to one of the developers, the new language was created as a result of frustration with existing languages being used for personal projects. [11] 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 in order to develop a desktop messaging client known as Volt. [6] Upon public release, the compiler was written in V, and could compile itself. [4] Key design goals behind the creation of V were being easy to learn and use, higher readability, fast compilation, increased safety, efficient development, cross-platform usability, improved C interoperability, better error handling, modern features, and more maintainable software. [12] [13] [10] [14]

V is released and developed through GitHub [15] [6] and maintained by developers and contributors from the community. [4]

Veasel is the official mascot of the V programming language Veasel.svg
Veasel is the official mascot of the V programming language

Features

Safety

V has policies to facilitate memory-safety, speed, and secure code. [7] [17] [18] The language has various default features for greater program safety. [7] [17] [6] [9] It employs bounds checking, to guard against out of bounds usage of variables. Option/result types are used, where the option type (?) can be represented by none (among possible choices) and the result type (!) can handle any returned errors. To ensure greater safety, the checking of errors are mandatory in V. By default, among the following are immutable: variables, structs, and function arguments. This includes string values are immutable, so elements can not be mutated. Other protections, which are the default for the language, are: no usage of undefined values, no shadowing of variables, no usage of null (unless code marked as unsafe), and no usage of global variables (unless enabled via flag).

Performance

V uses value types and string buffers to reduce memory allocations. [19] [20] [17] The language can be compiled to human-readable C [4] [21] and is considered to be as performant. [17]

Memory management

The language's 4 supported options for memory management are the following: [22] [6] [21]

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

Source code translators

V supports a source-to-source compiler (transpiler) and can translate C code into V. [23] [24] [10]

Working translators are also under development for Go, JavaScript, and WebAssembly. [25] [26]

Syntax

Hello world

The "Hello, World!" program in V: [17] 

fnmain(){println("Hello, World!")}

Variables

Variables are immutable by default and are defined using := and a value. Use the mut keyword to make them mutable. Mutable variables can be assigned to using =: [27] 

a:=1mutb:=2b=3

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

a:=1{a:=3// error: redefinition of a}a:=2// error: redefinition of a

Structs

Struct example: [12] 

structPoint{xintyint}mutp:=Point{x:10y:20}println(p.x)// Struct fields are accessed using a dot// Alternative literal syntax for structs with 3 fields or fewerp=Point{10,20}assertp.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: [12] 

structPoint{xintyint}p:=&Point{10,10}// References have the same syntax for accessing fieldsprintln(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: [9] [12] 

structUser{ageint}fn(uUser)is_registered()bool{returnu.age>16}user:=User{age:10}println(user.is_registered())// "false"user2:=User{age:20}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. [9] [7] [22] 

fndo_something(sstring)!string{ifs=="foo"{return"foo"}returnerror("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 tracebackprintln(a)println(b)

See also

Related Research Articles

In object-oriented (OO) and functional programming, an immutable object is an object whose state cannot be modified after it is created. This is in contrast to a mutable object, which can be modified after it is created. In some cases, an object is considered immutable even if some internally used attributes change, but the object's state appears unchanging from an external point of view. For example, an object that uses memoization to cache the results of expensive computations could still be considered an immutable object.

<span class="mw-page-title-main">D (programming language)</span> Multi-paradigm system programming language

D, also known as dlang, is a multi-paradigm system programming language created by Walter Bright at Digital Mars and released in 2001. Andrei Alexandrescu joined the design and development effort in 2007. Though it originated as a re-engineering of C++, D is now a very different language. As it has developed, it has drawn inspiration from other high-level programming languages. Notably, it has been influenced by Java, Python, Ruby, C#, and Eiffel.

<span class="mw-page-title-main">Foreach loop</span> Control flow statement for traversing items in a collection

In computer programming, foreach loop is a control flow statement for traversing items in a collection. foreach is usually used in place of a standard for loop statement. Unlike other for loop constructs, however, foreach loops usually maintain no explicit counter: they essentially say "do this to everything in this set", rather than "do this x times". This avoids potential off-by-one errors and makes code simpler to read. In object-oriented languages, an iterator, even if implicit, is often used as the means of traversal.

In computer programming, an entry point is the place in a program where the execution of a program begins, and where the program has access to command line arguments.

In some programming languages, const is a type qualifier that indicates that the data is read-only. While this can be used to declare constants, const in the C family of languages differs from similar constructs in other languages in that it is part of the type, and thus has complicated behavior when combined with pointers, references, composite data types, and type-checking. In other languages, the data is not in a single memory location, but copied at compile time for each use. Languages which use it include C, C++, D, JavaScript, Julia, and Rust.

<span class="mw-page-title-main">Scala (programming language)</span> General-purpose programming language

Scala is a strong statically typed high-level general-purpose programming language that supports both object-oriented programming and functional programming. Designed to be concise, many of Scala's design decisions are intended to address criticisms of Java.

this, self, and Me are keywords used in some computer programming languages to refer to the object, class, or other entity which the currently running code is a part of. The entity referred to thus depends on the execution context. Different programming languages use these keywords in slightly different ways. In languages where a keyword like "this" is mandatory, the keyword is the only way to access data and methods stored in the current object. Where optional, these keywords can disambiguate variables and functions with the same name.

The C and C++ programming languages are closely related but have many significant differences. C++ began as a fork of an early, pre-standardized C, and was designed to be mostly source-and-link compatible with C compilers of the time. Due to this, development tools for the two languages are often integrated into a single product, with the programmer able to specify C or C++ as their source language.

C++11 is a version of a joint technical standard, ISO/IEC 14882, by the International Organization for Standardization (ISO) and International Electrotechnical Commission (IEC), for the C++ programming language. C++11 replaced the prior version of the C++ standard, named C++03, and was later replaced by C++14. The name follows the tradition of naming language versions by the publication year of the specification, though it was formerly named C++0x because it was expected to be published before 2010.

This article describes the syntax of the C# programming language. The features described are compatible with .NET Framework and Mono.

In computer programming, variable shadowing occurs when a variable declared within a certain scope has the same name as a variable declared in an outer scope. At the level of identifiers, this is known as name masking. This outer variable is said to be shadowed by the inner variable, while the inner identifier is said to mask the outer identifier. This can lead to confusion, as it may be unclear which variable subsequent uses of the shadowed variable name refer to, which depends on the name resolution rules of the language.

In computer programming, a constant is a value that is not altered by the program during normal execution. When associated with an identifier, a constant is said to be "named," although the terms "constant" and "named constant" are often used interchangeably. This is contrasted with a variable, which is an identifier with a value that can be changed during normal execution. To simplify, constants' values remains, while the values of variables varies, hence both their names.

<span class="mw-page-title-main">Go (programming language)</span> Programming language

Go is a fast statically typed, compiled high-level general purpose programming language. It is known for its simplicity and efficiency. Its simplicity express through its basic syntax of the language itself and its large library that help the developer to have a small stack for its project. It was designed at Google in 2009 by Robert Griesemer, Rob Pike, and Ken Thompson. It is syntactically similar to C, but also has memory safety, garbage collection, structural typing, and CSP-style concurrency. It is often referred to as Golang to avoid ambiguity and because of its former domain name, golang.org, but its proper name is Go.

<span class="mw-page-title-main">Rust (programming language)</span> General-purpose programming language

Rust is a general-purpose programming language emphasizing performance, type safety, and concurrency. It enforces memory safety, meaning that all references point to valid memory. It does so without a traditional garbage collector; instead, memory safety errors and data races are prevented by the "borrow checker", which tracks the object lifetime of references at compile time.

Kotlin is a cross-platform, statically typed, general-purpose high-level programming language with type inference. Kotlin is designed to interoperate fully with Java, and the JVM version of Kotlin's standard library depends on the Java Class Library, but type inference allows its syntax to be more concise. Kotlin mainly targets the JVM, but also compiles to JavaScript or native code via LLVM. Language development costs are borne by JetBrains, while the Kotlin Foundation protects the Kotlin trademark.

Swift is a high-level general-purpose, multi-paradigm, compiled programming language created by Chris Lattner in 2010 for Apple Inc. and maintained by the open-source community. Swift compiles to machine code and uses an LLVM-based compiler. Swift was first released in June 2014 and the Swift toolchain has shipped in Xcode since Xcode version 6, released in September 2014.

<span class="mw-page-title-main">Nim (programming language)</span> Programming language

Nim is a general-purpose, multi-paradigm, statically typed, compiled high-level system programming language, designed and developed by a team around Andreas Rumpf. Nim is designed to be "efficient, expressive, and elegant", supporting metaprogramming, functional, message passing, procedural, and object-oriented programming styles by providing several features such as compile time code generation, algebraic data types, a foreign function interface (FFI) with C, C++, Objective-C, and JavaScript, and supporting compiling to those same languages as intermediate representations.

<span class="mw-page-title-main">Zig (programming language)</span> General-purpose programming language

Zig is an imperative, general-purpose, statically typed, compiled system programming language designed by Andrew Kelley. It is free and open-source software, released under an MIT License.

<span class="mw-page-title-main">Gleam (programming language)</span> Programming language

Gleam is a general-purpose, concurrent, functional high-level programming language that compiles to Erlang or JavaScript source code.

References

  1. ↑ "Creator of V". GitHub .
  2. ↑ "First public release". GitHub . 20 June 2019.
  3. ↑ "Release 0.4.9". 22 December 2024. Retrieved 26 December 2024.
  4. 1 2 3 4 Rao 2021.
  5. ↑ Lewkowicz, Jakub (25 June 2019). "SD Times news digest: V language now open sourced". SD Times. Retrieved 25 June 2019.
  6. 1 2 3 4 5 James, Ben (23 July 2019). "The V Programming Language: Vain Or Virtuous?". Hackaday. Retrieved 23 July 2019.
  7. 1 2 3 4 Umoren, Samuel. "Building a Web Server using Vlang". Section. Archived from the original on 13 March 2023. Retrieved 5 April 2021.
  8. ↑ "The V Programming Language". vlang.io. Retrieved 4 November 2023.
  9. 1 2 3 4 Knott, Simon (27 June 2019). "An introduction to V" . Retrieved 27 June 2019.
  10. 1 2 3 Nasufi, Erdet. "An introduction to V - the vlang". DebConf. Retrieved 24 July 2022.
  11. ↑ "How To Maintain And Iterate With V - SYNCS 2023 (Sydney Computing Society at the University of Sydney)". YouTube. Retrieved 18 October 2023.
  12. 1 2 3 4 Independent Laboratory 2020.
  13. ↑ Lyons 2022.
  14. ↑ "V language: simple like Go, small binary like Rust". TechRacho. Retrieved 3 March 2021.
  15. ↑ "GitHub Programming Languages (repository details)" – via OSS Insight.
  16. ↑ "V's official mascot". GitHub. Retrieved 8 November 2023.
  17. 1 2 3 4 5 Galuh, Rosa (8 August 2022). "A Brief Introduction to the V Language". MUO. Retrieved 8 August 2022.
  18. ↑ Abbas, Hazem (5 August 2024). "Introduction to V Language and Desktop App Development". medevel. Retrieved 3 January 2025.
  19. ↑ Rao 2021, p. 7.
  20. ↑ "The V programming language is now open source". Packt Hub. 24 June 2019. Retrieved 24 June 2019.
  21. 1 2 Chakraborty 2023.
  22. 1 2 Tsoukalos 2022.
  23. ↑ Choudhury, Ambika (9 February 2022). "Meet V, The New Statically Typed Programming Language Inspired By Go & Rust". Analytics India Magazine (AIM). Retrieved 7 July 2024.
  24. ↑ Schlothauer, Sarah. "The trendy five: Blazing hot GitHub repos in June 2019". JAXenter. Archived from the original on 17 February 2020. Retrieved 1 July 2019.
  25. ↑ "Convert Go to V with go2v". Zenn. 26 January 2023. Retrieved 26 January 2023.
  26. ↑ "The V WebAssembly Compiler Backend". l-m. 26 February 2023. Archived from the original on 8 July 2024.
  27. 1 2 Rao 2021, pp. 28–40.

Further reading

This page is based on this Wikipedia article
Text is available under the CC BY-SA 4.0 license; additional terms may apply.
Images, videos and audio are available under their respective licenses.