Rust (programming language)

Goal

The goal of Rust is to be a language suited to creating highly concurrent and highly safe systems, and "programming in the large", that is, creating and maintaining boundaries that preserve large-system integrity. This has led to a feature set with an emphasis on safety, control of memory layout, and concurrency. Performance of idiomatic Rust is comparable to the performance of idiomatic C++.

Syntax

The syntax of Rust is similar to C and C++, with blocks of code delimited by curly brackets, and control flow keywords such as if, else, while, and for. Not all C or C++ keywords are implemented, however, while some Rust functionality (such as keyword match for multi-directional branching, similar to switch in other languages) will be less familiar to programmers coming from these languages. Despite the syntactic resemblance, Rust is semantically very different from C and C++.

Memory safety

The system is designed to be memory safe, and it does not permit null pointers or dangling pointers. Data values can only be initialized through a fixed set of forms, all of which require their inputs to be already initialized. The system introduces additional syntax to manage lifetimes, and the compiler reasons about these through its borrow checker.

Polymorphism

The type system supports a mechanism similar to type classes, called 'traits', inspired directly by the Haskell language. This is a facility for ad-hoc polymorphism, achieved by adding constraints to type variable declarations. Other features from Haskell, such as higher-kinded polymorphism, are not yet supported.

Memory management

Rust does not use an automated garbage collection system like those used by Go, Java or .NET Framework, but instead Resource Acquisition Is Initialization (RAII), as in C++.

Miscellaneous

Rust features type inference, for variables declared with the let keyword. Such variables do not require a value to be initially assigned to determine their type. A compile time error results if any branch of code fails to assign a value to the variable. Functions can be given generic parameters, but they must be explicitly bounded by traits. There is no way to leave off type signatures while still making use of methods and operators on the parameters.

The object system within Rust is based around implementations, traits and structured types. Implementations fulfill a role similar to that of classes within other languages, and are defined with the impl keyword. Inheritance and polymorphism are provided by traits; they allow methods to be defined and mixed in to implementations. Structured types are used to define fields. Implementations and traits cannot define fields themselves, and only traits can provide inheritance, to prevent the diamond problem of multiple inheritance, as in C++.

This program prints the string "Hello, world!" to standard output and exits.

History

The language grew out of a personal project started in 2006 by Mozilla employee Graydon Hoare, who stated that the project was possibly named after the rust family of fungi. Mozilla began sponsoring the project in 2009 and announced it in 2010. The same year, work shifted from the initial compiler (written in OCaml) to the self-hosting compiler written in Rust. Known as rustc, it successfully compiled itself in 2011. rustc uses LLVM as its back end.

The first numbered pre-alpha release of the Rust compiler occurred in January 2012. Rust 1.0, the first stable release, was released on May 15, 2015. Following 1.0, stable point releases are delivered every six weeks, while features are developed in nightly Rust and then tested with alpha and beta releases that last six weeks.

In addition to conventional static typing, before version 0.4, Rust also supported typestates. The typestate system modeled assertions before and after program statements, through use of a special check statement. Discrepancies could be discovered at compile time, rather than when a program was running, as might be the case with assertions in C or C++ code. The typestate concept was not unique to Rust, as it was first introduced in the language NIL. Typestates were removed because in practice they found little use, though the same functionality can still be achieved with branding patterns.

The style of the object system changed considerably within versions 0.2, 0.3 and 0.4 of Rust. Version 0.2 introduced classes for the first time, with version 0.3 adding a number of features including destructors and polymorphism through the use of interfaces. In Rust 0.4, traits were added as a means to provide inheritance; interfaces were unified with traits and removed as a separate feature. Classes were also removed, replaced by a combination of implementations and structured types.

Starting in Rust 0.9 and ending in Rust 0.11, Rust had two built-in pointer types, ~ and @, simplifying the core memory model. It reimplemented those pointer types in the standard library as Box and (the now removed) Gc.

In January 2014, the editor-in-chief of Dr Dobb's, Andrew Binstock, commented on Rust's chances to become a competitor to C++, as well as to the other upcoming languages D, Go and Nim (then Nimrod): according to Binstock, while Rust was "widely viewed as a remarkably elegant language", adoption of it stayed behind because the language kept changing between versions.

Rust was the third most loved programming language in the 2015 Stack Overflow annual survey, and took first place in 2016 and 2017.

Projects using Rust

Projects developed in Rust include:

Web browser oriented:

Build tool oriented:

Other projects:

Factorial

This is a factorial function, implemented recursively. The branches in this function exhibit Rust's optional implicit return values, which can be utilized where a more "functional" style is preferred. Unlike C++ and related languages, Rust's if construct is an expression rather than a statement, and thus has a return value of its own.

This can be written with the most idiomatic match pattern, coming from the functional languages. The first line of the match block evaluates the block to 1 if n is 0 or 1, and the _ match all the remaining cases, like default in the switch from C.

And here's an iterative implementation:

This implementation uses an iterator instead.

Concurrency

A demonstration of Rust's concurrency capabilities:

Miscellaneous

A demonstration of Rust's built-in unique smart pointers, along with tagged unions and methods.