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.6 [3]   OOjs UI icon edit-ltr-progressive.svg / May 20, 2024;37 days ago (May 20, 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] 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't be mutated. Other protections, which are the default for the language, are: no usage of values that are undefined, 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. [18] [19] [17] The language can be compiled to human-readable C [4] and is considered to be as performant. [17]

Memory management

The language's 4 supported options for memory management are the following: [20] [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. [22] [23] [10]

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

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 =: [26] 

a:=1mutb:=2b=3

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

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] [20] 

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 drawing inspiration from other high-level programming languages, notably 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, which 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 the ISO/IEC 14882 standard for the C++ programming language. C++11 replaced the prior version of the C++ standard, called 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.

In computer programming, an anonymous function is a function definition that is not bound to an identifier. Anonymous functions are often arguments being passed to higher-order functions or used for constructing the result of a higher-order function that needs to return a function. If the function is only used once, or a limited number of times, an anonymous function may be syntactically lighter than using a named function. Anonymous functions are ubiquitous in functional programming languages and other languages with first-class functions, where they fulfil the same role for the function type as literals do for other data types.

In computing, compile-time function execution is the ability of a compiler, that would normally compile a function to machine code and execute it at run time, to execute the function at compile time. This is possible if the arguments to the function are known at compile time, and the function does not make any reference to or attempt to modify any global state.

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

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 statically typed, compiled high-level programming language designed at Google 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 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 multi-paradigm, general-purpose programming language that emphasizes performance, type safety, and concurrency. It enforces memory safety—meaning that all references point to valid memory—without a garbage collector. To simultaneously enforce memory safety and prevent data races, its "borrow checker" tracks the object lifetime of all references in a program during compilation.

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, as it is an LLVM-based compiler. Swift was first released in June 2014, and the Swift toolchain has shipped in Xcode since version 6, released in 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 systems 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> A general-purpose programming language, toolchain to build Zig/C/C++ code

Zig is an imperative, general-purpose, statically typed, compiled system programming language designed by Andrew Kelley. It is intended as a successor to the language C, with the intent of being even smaller and simpler to program in, while offering more function. It is free and open-source software, released under an MIT License.

Mojo is a programming language in the Python family that is currently under development. It is available both in browsers via Jupyter notebooks, and locally on Linux and macOS. Mojo aims to combine the usability of higher level programming languages, specifically Python, with the performance of lower level programming languages like C++, Rust, and Zig. The Mojo compiler is currently closed source with an open source standard library, although Modular, the company behind Mojo, has stated their intent to eventually open source the Mojo programming language itself as it matures.

References

  1. ↑ "Creator of V". GitHub .
  2. ↑ "First public release". GitHub . 20 June 2019.
  3. ↑ "Release 0.4.6". 20 May 2024. Retrieved 25 May 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. 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 rankings)" – via OSS.
  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. ↑ Rao 2021, p. 7.
  19. ↑ "The V programming language is now open source". Packt Hub. 24 June 2019. Retrieved 24 June 2019.
  20. 1 2 Tsoukalos 2022.
  21. ↑ Emy, Jade (29 August 2023). "The programming language V 0.4 Beta is available". developpez. Retrieved 29 August 2023.
  22. ↑ "Introducing the V Tutorial!". Replit. Retrieved 4 January 2021.
  23. ↑ 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.
  24. ↑ "Convert Go to V with go2v". Zenn. 26 January 2023. Retrieved 26 January 2023.
  25. ↑ "The V WebAssembly Compiler Backend". l-m. 26 February 2023. Retrieved 26 February 2023.
  26. 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.