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;4 years ago (2019-06-20) [2]
Stable release
0.4.4 [3]   OOjs UI icon edit-ltr-progressive.svg / January 9, 2024;55 days ago (January 9, 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 interop, 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] Among these default safety features are: [7] [17] [6] [9] 1) Usage of bounds checking. 2) Usage of Option/Result. 3) Mandatory checking of errors. 4) Variables are immutable by default. 5) Structs are immutable by default. 6) Function args are immutable by default. 7) No usage of values that are undefined. 8) No shadowing of variables. 9) No usage of null (unless in code marked as unsafe). 10) No usage of global variables (unless enabled via flag).

Performance

V uses value types and string buffers to reduce memory allocations. [18] [19] [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('invalidstring')}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 compiler construction, name mangling is a technique used to solve various problems caused by the need to resolve unique names for programming entities in many modern programming languages.

<span class="mw-page-title-main">Java syntax</span> Set of rules defining correctly structured program

The syntax of Java is the set of rules defining how a Java program is written and interpreted.

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 mathematics and in computer programming, a variadic function is a function of indefinite arity, i.e., one which accepts a variable number of arguments. Support for variadic functions differs widely among programming languages.

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.

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.

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

<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. Rust was influenced by ideas from functional programming, including immutability, higher-order functions, and algebraic data types. It is popular for systems programming.

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 developed by Apple Inc. and 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 to be a successor to the C programming language, with the goals of being even smaller and simpler to program in while also offering modern features, new optimizations and a variety of safety mechanisms while not as demanding of runtime safety as seen in other languages. It is distinct from languages like Go, Rust and Carbon, which have similar goals but also target the C++ space.

Mojo is a proprietary programming language that is currently under development. It is available both in browsers via Jupyter notebooks, and locally on both Linux and macOS. Mojo combines the usability of Python with its syntax with the high performance of low level languages like C.

References

  1. ↑ "Creator of V". GitHub .
  2. ↑ "First public release". GitHub . 20 June 2019.
  3. ↑ "Release 0.4.4". 9 January 2024. Retrieved 9 January 2024.
  4. 1 2 3 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 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.