Rust (programming language)

From Wikipedia, the free encyclopedia
Jump to: navigation, search
Rust
Rust programming language black logo.svg
Paradigm multi-paradigm: compiled, concurrent, functional, imperative, object-oriented, structured
Designed by Originally Graydon Hoare, then Rust Project Developers
Developer Rust Project Developers
Appeared in 2012
1.0.0-alpha.2[1] / February 20, 2015; 35 days ago (2015-02-20)
static, strong, inferred, nominal, linear
Implementation language
Rust
OS Linux, Mac OS X, Windows, FreeBSD, Android, iOS (partial)[2]
License Apache License 2.0 or MIT License[3]
.rs, .rlib
Website rust-lang.org

Rust is a general purpose, multi-paradigm, compiled programming language developed by Mozilla Research.[11] It is designed to be a "safe, concurrent, practical language",[12][13] supporting pure-functional, concurrent-actor, 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[14] and announced it for the first time in 2010.[15] The same year, work shifted from the initial compiler (written in OCaml) to the self-hosted compiler written in Rust itself.[16] Known as rustc, it successfully compiled itself in 2011.[17] The self-hosted compiler uses LLVM as its backend.

The first numbered pre-alpha release of the Rust compiler occurred in January 2012.[18] Development moves quickly enough that using the stable releases is discouraged.[1]

Rust is developed entirely in the open and solicits feedback and contributions from the community. The design of the language has been refined through the experiences of writing the Servo[19] layout engine and the Rust compiler itself. Although its development is sponsored by Mozilla, it is a community project. A large portion of current commits are from community members.[20]

Design[edit]

The goal of Rust is to be a good language for the creation of large client and server programs that run over the Internet.[21] This has led to a feature set with an emphasis on safety, control of memory layout, and concurrency. Performance of safe code is expected to be slower than C++ if performance is the only consideration, but to be comparable to C++ code that manually takes precautions comparable to what the Rust language mandates.[22]

The syntax of Rust is similar to C and C++, with blocks of code delimited by braces, and control flow keywords such as if, else, while, and for. Not all C or C++ keywords are present, however, while others (such as the match keyword 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.[23][24] Data values can only be initialized through a fixed set of forms, all of which require their inputs to be already initialized.[25] 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 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.[26] 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++.

Syntax[edit]

The following code examples are valid as of Rust 1.0.0-alpha.2. Syntax and semantics may change before 1.0.0 final release.

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::scoped(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);       
        }));                                                                       
    }                                                                              
 
    // The `threads` `Vec` is destroyed here and scoped thread handles are         
    // destroyed after joining.                                                    
}

A demonstration of pattern matching, inspired by the ML family of languages:

fn main() {
    let array = ["Arrays", "are", "for", "values", "of", "the", "same", "type"];
    let tuple = ("Tuples", 'r', 4i32, 0xDEADBEEFu32);
 
    // `match` expressions are the typical way of employing pattern-matching,
    // and are somewhat analogous to the `switch` statement from C and C++.
    let uno = match array {
        // Below is an array pattern, which mirrors the syntax for array literals.
        // An underscore in a pattern will ignore a single element.
        // A double-dot `..` in a pattern will ignore multiple elements.
        [_, _, _, values, ..] => values
    };
 
    // Pattern-matching can also be employed when declaring variables.
    // This will declare two new variables in the current scope, `dos` and `tres`.
    let (_, dos, _, tres) = tuple;
 
    println!("{} {} {:x}!", uno, dos, tres);  // Prints "values r deadbeef!"
}

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 datastructure and implements methods upon it.
// Recursive datastructures 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 *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)                                               
        }                                                                          
    }                                                                              
}

An example of Rust's support for generics, traits, and type bounds.

use std::num::Int;
 
use GenericList::{Node, Empty};
 
fn main() {
    let i32_list = GenericList::new().prepend(3i32).prepend(2).prepend(1);
    println!("{:?}", i32_list); // Node(1, Node(2, Node(3, Empty)))
    println!("Sum of all values in the list: {}.", i32_list.sum());
    println!("Sum of all doubled values in the list: {}.", i32_list.multiply_by(2).sum());
 
    let str_list = GenericList::new().prepend("world").prepend("hello");
    println!("{:?}", str_list); // Node("hello", Node("world", Empty))
    // The two lines below will not compile since an `&str` is not an integer type
    //println!("Sum of all values in the list: {}.", str_list.sum());
    //println!("Sum of all doubled values in the list: {}.", str_list.multiply_by(2).sum());
}
 
// A linked list like `IntList` above except that it can store any type.
// The `#[derive(Debug)]` has the compiler create a default implementation of the
// `Debug` trait that is used for debug printing (the `"{:?}"` format specifier).
#[derive(Debug)]
enum GenericList<T> {
    Node(T, Box<GenericList<T>>),
    Empty
}
 
// Methods that apply to `GenericList` with any `T`
impl<T> GenericList<T> {
    fn new() -> Box<GenericList<T>> {
        Box::new(Empty)
    }
 
    fn prepend(self, value: T) -> Box<GenericList<T>> {
        Box::new(Node(value, Box::new(self)))
    }
}
 
// Methods that only apply when `T` is an integer type
impl<T> GenericList<T> where T: Int {
    fn sum(&self) -> T {
        match *self {
            Node(value, ref next) => value + next.sum(),
            Empty => Int::zero()
        }
    }
 
    fn multiply_by(&self, n: T) -> Box<GenericList<T>> {
        match *self {
            Node(value, ref next) => Box::new(Node(value * n, next.multiply_by(n))),
            Empty => Box::new(Empty)
        }
    }
}

History[edit]

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.[27] Typestates were removed because in practice they found little use, though the same functionality can still be achieved with branding patterns.[28]

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 removed 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.

Releases
Version Date
1.0.0-alpha.2 2015-02-20
1.0.0-alpha 2015-01-09
0.12 2014-10-09
0.11 2014-07-02
0.10 2014-04-03
0.9 2014-01-09
0.8 2013-09-26
0.7 2013-07-03
0.6 2013-04-02
0.5 2012-12-20
0.4 2012-10-12
0.3 2012-07-12
0.2 2012-03-28
0.1 2012-01-20

See also[edit]

References[edit]

  1. ^ a b Rust Release Notes
  2. ^ "Doc building for ios". GitHub. Retrieved 4 January 2015. 
  3. ^ "COPYRIGHT". Rust compiler source repository. Retrieved 2012-12-17. 
  4. ^ a b c d e f g h i j k l m n o "The Rust Reference: Appendix: Influences". Retrieved March 25, 2015. Rust is not a particularly original language, with design elements coming from a wide range of sources. Some of these are listed below (including elements that have since been removed): SML, OCaml [...] C++ [...] ML Kit, Cyclone [...] Haskell [...] Newsqueak, Alef, Limbo [...] Erlang [...] Swift [...] Scheme [...] C# [...] Ruby [...] NIL, Hermes 
  5. ^ "Note Research: Type System". 2015-02-01. Retrieved 2015-03-25. Papers that have had more or less influence on Rust, or which one might want to consult for inspiration or to understand Rust's background. [...] Region based memory management in Cyclone [...] Safe memory management in Cyclone 
  6. ^ "RFC for `if let` expression". Retrieved December 4, 2014. The `if let` construct is based on the precedent set by Swift, which introduced its own `if let` statement. 
  7. ^ "Discussion - Patterns and Records". 2015-03-25. Retrieved 2015-03-25. Sources of Inspiration: [...] Rust 
  8. ^ "Command Optimizations?". 2014-06-26. Retrieved 2014-12-10. I just added the outline of a Result library that lets you use richer error messages. It's like Either except the names are more helpful. The names are inspired by Rust's Result library. 
  9. ^ "Uniqueness Types". 2014-08-22. Retrieved 2014-10-27. They are inspired by linear types, Uniqueness Types in the Clean programming language, and ownership types and borrowed pointers in the Rust programming language. 
  10. ^ Lattner, Chris (2014-06-03). "Chris Lattner's Homepage". Chris Lattner. Retrieved 2014-06-03. The Swift language is the product of tireless effort from a team of language experts, documentation gurus, compiler optimization ninjas, and an incredibly important internal dogfooding group who provided feedback to help refine and battle-test ideas. Of course, it also greatly benefited from the experiences hard-won by many other languages in the field, drawing ideas from Objective-C, Rust, Haskell, Ruby, Python, C#, CLU, and far too many others to list. 
  11. ^ Noel (2010-07-08). "The Rust Language". Lambda the Ultimate. Retrieved 2010-10-30. 
  12. ^ "The Rust Programming Language". Retrieved 2012-10-21. 
  13. ^ "Doc language FAQ". Retrieved 2012-10-21. 
  14. ^ "Project FAQ". 2010-09-14. Retrieved 2012-01-11. 
  15. ^ "Future Tense". 2011-04-29. Retrieved 2012-02-06. At Mozilla Summit 2010, we launched Rust, a new programming language motivated by safety and concurrency for parallel hardware, the “manycore” future which is upon us. 
  16. ^ Hoare, Graydon (2010-10-02). "Rust Progress". Retrieved 2010-10-30. 
  17. ^ Hoare, Graydon (2011-04-20). "[rust-dev] stage1/rustc builds". Retrieved 2011-04-20. After that last change fixing the logging scope context bug, looks like stage1/rustc builds. Just shy of midnight :) 
  18. ^ catamorphism (2012-01-20). "Mozilla and the Rust community release Rust 0.1 (a strongly-typed systems programming language with a focus on memory safety and concurrency)". Retrieved 2012-02-06. 
  19. ^ Peter Bright (2013-04-03). "Samsung teams up with Mozilla to build browser engine for multicore machines". Retrieved 2013-04-04. 
  20. ^ "Rust Contributors". 
  21. ^ Avram, Abel (2012-08-03). "Interview on Rust, a Systems Programming Language Developed by Mozilla". InfoQ. Retrieved 2013-08-17. GH: A lot of obvious good ideas, known and loved in other languages, haven't made it into widely used systems languages... There were a lot of good competitors in the late 1970s and early 1980s in that space, and I wanted to revive some of their ideas and give them another go, on the theory that circumstances have changed: the internet is highly concurrent and highly security-conscious, so the design-tradeoffs that always favor C and C++ (for example) have been shifting. 
  22. ^ Walton, Patrick (2010-12-05). "C++ Design Goals in the Context of Rust". Retrieved 2011-01-21. … It’s impossible to be “as fast as C” in all cases while remaining safe… C++ allows all sorts of low-level tricks, mostly involving circumventing the type system, that offer practically unlimited avenues for optimization. In practice, though, C++ programmers restrict themselves to a few tools for the vast majority of the code they write, including stack-allocated variables owned by one function and passed by alias, uniquely owned objects (often used with auto_ptr or the C++0x unique_ptr), and reference counting via shared_ptr or COM. One of the goals of Rust’s type system is to support these patterns exactly as C++ does, but to enforce their safe usage. In this way, the goal is to be competitive with the vast majority of idiomatic C++ in performance, while remaining memory-safe… 
  23. ^ Rosenblatt, Seth (2013-04-03). "Samsung joins Mozilla's quest for Rust". Retrieved 2013-04-05. [Brendan Eich] noted that every year browsers fall victim to hacking in the annual Pwn2Own contest at the CanSecWest conference. "There's no free memory reads" in Rust, he said, but there are in C++. Those problems "lead to a lot of browser vulnerabilities" and would be solved by Rust, which is a self-compiling language. 
  24. ^ Brown, Neil (2013-04-17). "A taste of Rust". Retrieved 2013-04-25. … Other more complex data structures could clearly be implemented to allow greater levels of sharing, while making sure the interface is composed only of owned and managed references, and thus is safe from unplanned concurrent access and from dangling pointer errors. 
  25. ^ "Doc language FAQ". 2010-09-14. Retrieved 2012-01-11. 
  26. ^ Walton, Patrick (2010-10-01). "Rust Features I: Type Inference". Retrieved 2011-01-21. 
  27. ^ Strom, Robert E.; Yemini, Shaula (1986). "Typestate: A Programming Language Concept for Enhancing Software Reliability". IEEE Transactions on Software Engineering. ISSN 0098-5589. Retrieved 2010-11-14. 
  28. ^ "Typestate Is Dead, Long Live Typestate!". 2012-12-26. Retrieved 2012-12-28. 

External links[edit]