Rust (programming language)

Some Rust users refer to themselves as Rustaceans (a pun on "crustacean") and use Ferris as their unofficial mascot.[27]

The language grew out of a personal project begun in 2006 by Mozilla employee Graydon Hoare,[16] who stated that the project was possibly named after the rust family of fungi.[28] Mozilla began sponsoring the project in 2009[16] and announced it in 2010.[29][30] The same year, work shifted from the initial compiler (written in OCaml) to the LLVM-based self-hosting compiler written in Rust.[31] Named rustc, it successfully compiled itself in 2011.[32]

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

Along with 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.[37] Typestates were removed because in practice they were little used,[38] though the same function can be achieved by leveraging Rust's move semantics.[39]

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, and version 0.3 added several 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, before the first stable release, Rust 1.0, the editor-in-chief of Dr Dobb's, Andrew Binstock, commented on Rust's chances of becoming a competitor to C++ and to the other up-and-coming languages D, Go, and Nim (then Nimrod). According to Binstock, while Rust was "widely viewed as a remarkably elegant language", adoption slowed because it repeatedly changed between versions.[40]

Rust has a foreign function interface (FFI) that can be called from e.g. C language, and can call C, while calling C++ has historically been problematic (from any language). Rust has a library, CXX, to allow calling to or from C++, and "CXX has zero or negligible overhead".[41]

In August 2020, Mozilla laid off 250 of its 1,000 employees worldwide as part of a corporate restructuring caused by the long-term impact of the COVID-19 pandemic.[42][43] Among those laid off were most of the Rust team,[44] while the Servo team was completely disbanded.[45] The event raised concerns about the future of Rust.[46]

In the following week, the Rust Core Team acknowledged the severe impact of the layoffs and announced that plans for a Rust foundation were underway. The first goal of the foundation would be taking ownership of all trademarks and domain names, and also take financial responsibility for their costs.[47]

On February 8, 2021 the formation of the Rust Foundation was officially announced by its five founding companies (AWS, Huawei, Google, Microsoft, and Mozilla).[48][49]

Here is a simple "Hello, World!" program written in Rust. The println! macro prints the message to standard output.

fn main() {
    println!("Hello, World!");
}

The concrete 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, although the specific syntax for defining functions is more similar to Pascal. Not all C or C++ keywords are implemented, however, and some Rust functions (such as the use of the keyword match for pattern matching) will be less familiar to those versed in these languages. Despite the superficial resemblance to C and C++, the syntax of Rust in a deeper sense is closer to that of the ML family of languages and the Haskell language. Nearly every part of a function body is an expression,[50] even control flow operators. For example, the ordinary if expression also takes the place of C's ternary conditional, an idiom used by ALGOL-60. As in Lisp, a function need not end with a return expression: in this case if the semicolon is omitted, the last expression in the function creates the return value, as seen in the following recursive implementation of the factorial function:

fn factorial(i: u64) -> u64 {
    match i {
        0 => 1,
        n => n * factorial(n-1)
    }
}

The following iterative implementation uses the ..= operator to create an inclusive range:

fn factorial(i: u64) -> u64 {
    (2..=i).product()
}

Rust is intended to be a language for highly concurrent and highly safe systems,[51] and programming in the large, that is, creating and maintaining boundaries that preserve large-system integrity.[52] 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++.[61][62]

Rust was the third-most-loved programming language in the 2015 Stack Overflow annual survey[63] and took first place for 2016–2020.[64]

Rust conferences include:

• RustConf: an annual conference in Portland, Oregon. Held annually since 2016 (except in 2020 because of the COVID-19 pandemic).[82]
• Rust Belt Rust: a #rustlang conference in the Rust Belt[83]
• RustFest: Europe's @rustlang conference[84]
• RustCon Asia
• Rust LATAM
• Oxidise Global [85]

• Comparison of programming languages

• Official website
• Rust-lang on GitHub