Timothy SmithCOP 4020

Rust

Rust is a curly brace, block-structured expression language.

Visually resembles C but differs in syntactic and semantic details.

Design oriented toward “programming in the large”, mainly towards creating and maintaining different boundaries.

Helping to preserve system integrity, availability and concurrency.

Development: Graydon Hoare

Graydon worked on compilers/tools for other languages and decided to develop his own.

Created the Servo Parallel Browser Project, which is a prototype web browser engine.

Started Rust in 2006, Mozilla became interested in 2009 after a showcase from Graydon.

Bootstrap compiler released in 2010, then a self-hosted compiler released in 2011.

Grayson’s Focus for Rust

Type safety Memory Safety Concurrency Performance Friendlier syntax

Syntax and EBNF of grammar grammar : rule + ; rule : nonterminal ':' productionrule ';' ; productionrule : production [ '|' production ] * ; production : term * ; term : element repeats ; element : LITERAL | IDENTIFIER | '[' productionrule ']' ; repeats : [ '*' | '+' ] NUMBER ? | NUMBER ? | '?' ;

LITERAL is a single printable ASCII character, or an escaped hexadecimal ASCII code of the form \xQQ.

IDENTIFIER is a nonempty string of ASCII letters and underscores.

Continued: character and strings

char_lit : '\x27' char_body '\x27' ;

string_lit : '"' string_body * '"' ;

char_body : non_single_quote

| '\x5c' [ '\x27' | common_escape ] ;

string_body : non_double_quote

| '\x5c' [ '\x22' | common_escape ] ;

common_escape : '\x5c'

| 'n' | 'r' | 't'

| 'x' hex_digit 2

| 'u' hex_digit 4

| 'U' hex_digit 8 ;

hex_digit : 'a' | 'b' | 'c' | 'd' | 'e' | 'f'

| 'A' | 'B' | 'C' | 'D' | 'E' | 'F'

| dec_digit ;

dec_digit : '0' | nonzero_dec ;

nonzero_dec: '1' | '2' | '3' | '4'

| '5' | '6' | '7' | '8' | '9' ;

Example: let laptop: %str = “dell”;

Continued: Numbers num_lit : nonzero_dec [ dec_digit | '_' ] * num_suffix ?

| '0' [ [ dec_digit | '_' ] + num_suffix ?

| 'b' [ '1' | '0' | '_' ] + int_suffix ?

| 'x' [ hex_digit | '_' ] + int_suffix ? ] ;

num_suffix : int_suffix | float_suffix ;

int_suffix : 'u' int_suffix_size ?

| 'i' int_suffix_size ;

int_suffix_size : [ '8' | '1' '6' | '3' '2' | '6' '4' ] ;

float_suffix : [ exponent | '.' dec_lit exponent ? ] float_suffix_ty ? ;

float_suffix_ty : 'f' [ '3' '2' | '6' '4' ] ;

exponent : ['E' | 'e'] ['-' | '+' ] ? dec_lit ;

dec_lit : [ dec_digit | '_' ] + ;

A decimal literal starts with a decimal digit and continues with any mixture of decimal digits and underscores.

Examples: 123; 0xff00 //type determined by program context

// defaults to integer 123u; //type uint 123_u //type uint 0xff_u8 //type u8 0b1111_1111_1001_0000_i32 //type i32

Floats 123.0; //type float 3f; //type float 0.1f32 //type f32 12E+99_f64 //type f64

Syntax extensions for Rust fmt! : format data into a string

env! : look up an environment variable's value at compile time

stringify! : pretty-print the Rust expression given as an argument

proto! : dene a protocol for inter-task communication

include! : include the Rust expression in the given file

Include.str! : include the contents of the given file as a string

Include.bin! : include the contents of the given file as a binary blob

error!, warn!, info!, debug! : provide diagnostic information.

All expressions above give values except for proto!, which is an item, defining a new name.

Crates: items and modules A crate is a unit of compilation and linking, as well as versioning,

distribution, and runtime loading.

Contains a tree of nested module scopes. Top level of tree is anonymous and any item within a crate has a module path denoting its location within the crate’s tree.

Source files: example.rs

Crate files: example.rc

item : mod_item | fn_item | type_item | struct_item | enum_item

| static_item | trait_item | impl_item | foreign_mod_item ;

mod_item : "mod" ident ( ';' | '{' mod '}' );

mod : [ view_item | item ] * ;

View_item specifies visibility to other crates, such as extern_mod and use_mod, which point to different paths.

Example: use core::float::sin

functions Example: fn add(x: int, y: int) -> int {

return x+ y;

}

Unsafe Functions: (must be prefixed with ‘unsafe’) Dereferencing a raw pointer Casting a raw pointer to a safe pointer type Calling an unsafe function Violate the memory-safety guarantee of Rust’s static

semantics.

Function Divergence fn my_error(s: &str) -> ! {

info!(s);

fail!();

}

- Never returns a value to the caller, every function must end with either a return or a diverging function. Example:

Fn f(i: int) -> int {

if I == 42 {

return 42;

}

else {

my_error!(“Bad Number!”)

}}

- Adding the ! Annotation to my_error informs Rust’s typechecker that, should the control ever enter my_error, no further type judgements about f need to hold.

Structs and Enums

Struct example: struct Point {x: int, y: int} let p = Point {x: 10, y: 11}; let px: int = p.x;

Enum example: enum Animal {

Dog,

Cat

}

Traits

Describes a set of method types. Trait Shape {

fn draw(&self, Surface);

fn bounding_box(&self) -> BoundingBox;

}

Defines a trait with two methods and example of using this trait would be calling something such as:

Value.bounding_box();

Statements and Expressions A statement is a component of a block, which is in turn a

component of an outer expression or function. Examples would be declaring variables and creating

structs. An expression in Rust must produce a value and have an

effect on; such as part of a condition statement. Examples would be literals, paths, tuple, structs, etc.

that produce a value somehow. Other types of expressions are Records, method calls,

fields, index, unary operator, and binary operator.

Arithmetic and bitwise operations are identical to C++ along with operator precendence.

Swap: x <-> a

Loops and If statements while i < 10 {

io::println("hello\n");

i = i + 1;

}

for_expr : "for" expr [ '|' ident_list '|' ] ? '{' block '}' ;

for v.each |e| {

println(v.e);

}

if_expr : "if" expr '{' block '}'

else_tail ? ;

else_tail : "else" [ if_expr

| '{' block '}' ] ;

If I < 10 {

io::println(“hello\n”);

}

Keywords Break Copy Do drop Else enum extern False fn for If Let loop Match mod mut Priv pub Ref return Self static struct True trait type Unsafe use while

Unique to Rust Infinite loops can be defined as just ‘loop’ and adding of

break/return statements. For variables, the addition of ‘mut’ must be added in

order to change the value of it later on. Also ‘let’ must be used when declaring variables.

Rust can almost always infer the types of local variables, but a type annotation is provided.

let stuff: int = 20;

Unique (continued) let price;

if item == "salad" {

price = 3.50;

} else if item == "muffin" {

price = 2.25;

} else {

price = 2.00;

}

To simplify this, you do not need to copy price over each time, since the expression syntax is simplified:

let price =

if item == “salad” {

3.50

} else if item == “muffin” {

2.25

} else {

2.00

};

Unique (syntax extensions) // %? will conveniently print any type Println(fmt!(“All the things: %?”, stuff)); Macros can be used to create other syntax extensions,

especially when yo uwant to abstract over compile-time syntax rather than run-time values. Such as turning:

match input_1 {

special_a(x) => { return x; }

_ => {}

}

Into just:

early_return!(input_1 special_a);

Match vs. Switch

match my_number {

0 => println("zero"),

1 | 2 => println("one or two"),

3..10 => println("three to ten"),

_ => println("something else")

Compiler Required packages to build from

source: g++ 4.4 or clang++ 3.x Python 2.6 or later Perl 5.0 or later Gnu make 3.81 Curl Then run configure, total time to

build the compiler on my machine: 2.5 hours

Examples:

Examples:

Sources:

http://web.mit.edu/rust-lang_v0.6/rust.pdf http://www.rust-lang.org/ http://static.rust-lang.org/doc/0.7/tutorial.html http://en.wikipedia.org/wiki/Rust_%28programming_language

%29