Rust (programming language)

Rust

Paradigm	Multi-paradigm: compiled, concurrent, functional, imperative, structured
Designed by	Originally Graydon Hoare, then Rust Project Developers
Developer	Rust Project Developers
First appeared	2010
Stable release	1.8 / April 14, 2016 (2016-04-14)
Typing discipline	static, strong, inferred, nominal, linear
Implementation language	Rust
OS	Linux, OS X, Windows, FreeBSD, Android, iOS (partial)
License	Apache License 2.0 or MIT License
Filename extensions	.rs, .rlib
Website	www.rust-lang.org
Influenced by
Ada, Alef, C#, C++, Cyclone, Erlang, Haskell, Hermes, Limbo, Newsqueak, NIL, OCaml, Ruby, Scheme, Standard ML, Swift
Influenced
C# 7, Elm, Idris, Swift

Rust is a general-purpose, multi-paradigm, compiled programming language sponsored by Mozilla Research. It is designed to be a "safe, concurrent, practical language", supporting pure-functional, imperative-procedural, and object-oriented styles.

The language grew out of a personal project by Mozilla employee Graydon Hoare. 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.

Although its development is sponsored by Mozilla, it is an open community project. The design of the language has been refined through the experiences of writing the Servo web browser layout engine and the Rust compiler. A large portion of current commits are from community members.

Rust won the first place for Most Loved Programming Language of 2016 in the Stack Overflow Developer Survey. The language is believed to take its name from the rust family of fungi.

Design

The goal of Rust is to be a good language for creating highly concurrent and highly safe systems. 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++.

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 present, however, while some Rust keywords (such as 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++.

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. A system of pointer lifetimes and freezing allows the compiler to prevent many types of errors that are possible to write in C++, even when using its smart pointers.

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.

Rust does not use an automated garbage collection system like those used by Go, Java or .NET.

Rust features type inference, for variables declared with the let keyword. Such variables do not require a value to be initially assigned in order 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, in order to prevent the diamond inheritance problem of C++.

History

In addition to conventional static typing, prior to 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 once 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 NIL programming language. 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. The first "stable" version of the Rust, version 1.0.0, was released in May 2015.

Rust was the third most loved programming language in the 2015 Stack Overflow annual survey, and jumped to the first place in 2016 Stack Overflow annual survey

Projects using Rust

Magic Pocket - Dropbox's file storage system that powers their Diskotech petabyte storage machines.

Servo - Mozilla's new parallel rendering engine developed in collaboration with Samsung.

OpenDNS - Uses Rust in two of its components.

Redox OS - a microkernel operating system being developed in Rust.

Examples

Hello world:

fn main() {
    println!("hello, world");
}

Three versions of the factorial function, in recursive, iterative, and iterator styles:

// 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.
fn recursive_factorial(n: u32) -> u32 {
    if n <= 1 {
        1
    } else {
        n * recursive_factorial(n - 1)
    }
}

fn iterative_factorial(n: u32) -> u32 {
    // Variables are declared with `let`.
    // The `mut` keyword allows these variables to be mutated.
    let mut i = 1u32;
    let mut result = 1u32;
    while i <= n {
        result *= i;
        i += 1;
    }
    return result; // An explicit return, in contrast to the prior function.
}

fn iterator_factorial(n: u32) -> u32 {
    // Iterators have a variety of methods for transformations.
    // |accum, x| defines an anonymous function.
    // Optimizations like inline expansion reduce the range and fold
    // to have performance similar to iterative_factorial.
    (1..n + 1).fold(1, |accum, x| accum * x)
}

fn main() {
    println!("Recursive result: {}", recursive_factorial(10));
    println!("Iterative result: {}", iterative_factorial(10));
    println!("Iterator result: {}", iterator_factorial(10));
}

A simple demonstration of Rust's concurrency capabilities:

use std::thread;

// This function creates ten threads that all execute concurrently.
// To verify this, run the program several times and observe the irregular
// order in which each thread's output is printed.
fn main() {
    // This string is immutable, so it can safely be accessed from multiple threads.
    let greeting = "Hello";

    let mut threads = Vec::new();
    // `for` loops work with any type that implements the `Iterator` trait.
    for num in 0..10 {
        threads.push(thread::spawn(move || {
            // `println!` is a macro that statically typechecks a format string.
            // Macros are structural (as in Scheme) rather than textual (as in C).
            println!("{} from thread number {}", greeting, num);
        }));
    }

    // Join each thread so that they all finish before program exit.
    for thread in threads {
        thread.join().unwrap();
    }
}

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

use IntList::{Node, Empty};

// This program defines a recursive data structure and implements methods upon it.
// Recursive data structures require a layer of indirection, which is provided here
// by a unique pointer, constructed via the `Box::new` constructor. These are
// analogous to the C++ library type `std::unique_ptr`, though with more static
// safety guarantees.
fn main() {
    let list = IntList::new().prepend(3).prepend(2).prepend(1);
    println!("Sum of all values in the list: {}.", list.sum());
    println!("Sum of all doubled values in the list: {}.", list.multiply_by(2).sum());
}

// `enum` defines a tagged union that may be one of several different kinds of values at runtime.
// The type here will either contain no value, or a value and a pointer to another `IntList`.
enum IntList {
    Node(i32, Box<IntList>),
    Empty
}

// An `impl` block allows methods to be defined on a type.
impl IntList {
    fn new() -> Box<IntList> {
        Box::new(Empty)
    }

    fn prepend(self, value: i32) -> Box<IntList> {
        Box::new(Node(value, Box::new(self)))
    }

    fn sum(&self) -> i32 {
        // `match` expressions are the typical way of employing pattern-matching,
        // and are somewhat analogous to the `switch` statement from C and C++.
        match *self {
            Node(value, ref next) => value + next.sum(),
            Empty => 0
        }
    }

    fn multiply_by(&self, n: i32) -> Box<IntList> {
        match *self {
            Node(value, ref next) => Box::new(Node(value * n, next.multiply_by(n))),
            Empty => Box::new(Empty)
        }
    }
}

See also

• Comparison of programming languages
• Servo (layout engine)
• Swift (programming language)

External links

• Official website
• The Rust-dev Archives – electronic mailing list
• Primary source code repository and bug tracker
• Rust Rosetta – implementations of common algorithms and solutions
• Rust by Example – web book