"Idiomatic code should not use extra whitespace in the middle of a line to provide alignment."
http://aturon.github.io/style/whitespace.html
I realize the linked page still needs an RFC, but the docs should be written in accordance with the guidelines nevertheless.
same type. By default, arrays are immutable.
```{rust}
-let a = [1, 2, 3]; // a: [i32; 3]
+let a = [1, 2, 3]; // a: [i32; 3]
let mut m = [1, 2, 3]; // mut m: [i32; 3]
```
nums.push(4);
-println!("The length of nums is now {}", nums.len()); // Prints 4
+println!("The length of nums is now {}", nums.len()); // Prints 4
```
Vectors have many more useful methods.
```{rust}
let a = [0, 1, 2, 3, 4];
-let middle = &a[1..4]; // A slice of a: just the elements 1, 2, and 3
+let middle = &a[1..4]; // A slice of a: just the elements 1, 2, and 3
for e in middle.iter() {
- println!("{}", e); // Prints 1, 2, 3
+ println!("{}", e); // Prints 1, 2, 3
}
```
```rust
let mut x = (1, 2); // x: (i32, i32)
-let y = (2, 3); // y: (i32, i32)
+let y = (2, 3); // y: (i32, i32)
x = y;
```
```{rust}
# struct Color(i32, i32, i32);
# struct Point(i32, i32, i32);
-let black = Color(0, 0, 0);
+let black = Color(0, 0, 0);
let origin = Point(0, 0, 0);
```
fn descriptive_probability(event: Event) -> &'static str {
match probability(&event) {
- 1.00 => "certain",
- 0.00 => "impossible",
+ 1.00 => "certain",
+ 0.00 => "impossible",
0.00 ... 0.25 => "very unlikely",
0.25 ... 0.50 => "unlikely",
0.50 ... 0.75 => "likely",
- 0.75 ... 1.00 => "very likely",
+ 0.75 ... 1.00 => "very likely",
}
}
fn descriptive_probability(event: Event) -> &'static str {
match probability(&event) {
- 1.00 => "certain",
- 0.00 => "impossible",
+ 1.00 => "certain",
+ 0.00 => "impossible",
0.00 ... 0.25 => "very unlikely",
0.25 ... 0.50 => "unlikely",
0.50 ... 0.75 => "likely",
- 0.75 ... 1.00 => "very likely",
+ 0.75 ... 1.00 => "very likely",
_ => unreachable!()
}
}
println!("You guessed: {}", input);
match cmp(input, secret_number) {
- Ordering::Less => println!("Too small!"),
+ Ordering::Less => println!("Too small!"),
Ordering::Greater => println!("Too big!"),
- Ordering::Equal => println!("You win!"),
+ Ordering::Equal => println!("You win!"),
}
}
println!("You guessed: {}", input);
match cmp(input, secret_number) {
- Ordering::Less => println!("Too small!"),
+ Ordering::Less => println!("Too small!"),
Ordering::Greater => println!("Too big!"),
- Ordering::Equal => println!("You win!"),
+ Ordering::Equal => println!("You win!"),
}
}
tell `random()` what to generate. In a similar fashion, both of these work:
```{rust,ignore}
-let input_num = "5".parse::<u32>(); // input_num: Option<u32>
-let input_num: Option<u32> = "5".parse(); // input_num: Option<u32>
+let input_num = "5".parse::<u32>(); // input_num: Option<u32>
+let input_num: Option<u32> = "5".parse(); // input_num: Option<u32>
```
Anyway, with us now converting our input to a number, our code looks like this:
println!("You guessed: {}", input_num);
match cmp(input_num, secret_number) {
- Ordering::Less => println!("Too small!"),
+ Ordering::Less => println!("Too small!"),
Ordering::Greater => println!("Too big!"),
- Ordering::Equal => println!("You win!"),
+ Ordering::Equal => println!("You win!"),
}
}
let num = match input_num {
Some(num) => num,
- None => {
+ None => {
println!("Please input a number!");
return;
}
println!("You guessed: {}", num);
match cmp(num, secret_number) {
- Ordering::Less => println!("Too small!"),
+ Ordering::Less => println!("Too small!"),
Ordering::Greater => println!("Too big!"),
- Ordering::Equal => println!("You win!"),
+ Ordering::Equal => println!("You win!"),
}
}
let num = match input_num {
Some(num) => num,
- None => {
+ None => {
println!("Please input a number!");
return;
}
println!("You guessed: {}", num);
match cmp(num, secret_number) {
- Ordering::Less => println!("Too small!"),
+ Ordering::Less => println!("Too small!"),
Ordering::Greater => println!("Too big!"),
- Ordering::Equal => println!("You win!"),
+ Ordering::Equal => println!("You win!"),
}
}
let num = match input_num {
Some(num) => num,
- None => {
+ None => {
println!("Please input a number!");
return;
}
println!("You guessed: {}", num);
match cmp(num, secret_number) {
- Ordering::Less => println!("Too small!"),
+ Ordering::Less => println!("Too small!"),
Ordering::Greater => println!("Too big!"),
- Ordering::Equal => println!("You win!"),
+ Ordering::Equal => println!("You win!"),
}
}
}
let num = match input_num {
Some(num) => num,
- None => {
+ None => {
println!("Please input a number!");
return;
}
println!("You guessed: {}", num);
match cmp(num, secret_number) {
- Ordering::Less => println!("Too small!"),
+ Ordering::Less => println!("Too small!"),
Ordering::Greater => println!("Too big!"),
- Ordering::Equal => {
+ Ordering::Equal => {
println!("You win!");
return;
},
let num = match input_num {
Some(num) => num,
- None => {
+ None => {
println!("Please input a number!");
continue;
}
println!("You guessed: {}", num);
match cmp(num, secret_number) {
- Ordering::Less => println!("Too small!"),
+ Ordering::Less => println!("Too small!"),
Ordering::Greater => println!("Too big!"),
- Ordering::Equal => {
+ Ordering::Equal => {
println!("You win!");
return;
},
let num = match input_num {
Some(num) => num,
- None => {
+ None => {
println!("Please input a number!");
continue;
}
println!("You guessed: {}", num);
match cmp(num, secret_number) {
- Ordering::Less => println!("Too small!"),
+ Ordering::Less => println!("Too small!"),
Ordering::Greater => println!("Too big!"),
- Ordering::Equal => {
+ Ordering::Equal => {
println!("You win!");
return;
},
match greater_than_forty_two {
Some(_) => println!("We got some numbers!"),
- None => println!("No numbers found :("),
+ None => println!("No numbers found :("),
}
```
this:
```{rust}
-let mut x = 5; // mut x: u32
+let mut x = 5; // mut x: u32
let mut done = false; // mut done: bool
while !done {
let y = 10;
match cmp(x, y) {
- Ordering::Less => println!("less"),
+ Ordering::Less => println!("less"),
Ordering::Greater => println!("greater"),
- Ordering::Equal => println!("equal"),
+ Ordering::Equal => println!("equal"),
}
}
```
match x {
OptionalInt::Value(n) => println!("x is {}", n),
- OptionalInt::Missing => println!("x is missing!"),
+ OptionalInt::Missing => println!("x is missing!"),
}
match y {
OptionalInt::Value(n) => println!("y is {}", n),
- OptionalInt::Missing => println!("y is missing!"),
+ OptionalInt::Missing => println!("y is missing!"),
}
}
```
let y = 10;
println!("{}", match cmp(x, y) {
- Ordering::Less => "less",
+ Ordering::Less => "less",
Ordering::Greater => "greater",
- Ordering::Equal => "equal",
+ Ordering::Equal => "equal",
});
}
```
what the elided lifetimes are expand to:
```{rust,ignore}
-fn print(s: &str); // elided
-fn print<'a>(s: &'a str); // expanded
+fn print(s: &str); // elided
+fn print<'a>(s: &'a str); // expanded
-fn debug(lvl: u32, s: &str); // elided
-fn debug<'a>(lvl: u32, s: &'a str); // expanded
+fn debug(lvl: u32, s: &str); // elided
+fn debug<'a>(lvl: u32, s: &'a str); // expanded
// In the preceeding example, `lvl` doesn't need a lifetime because it's not a
// reference (`&`). Only things relating to references (such as a `struct`
// which contains a reference) need lifetimes.
-fn substr(s: &str, until: u32) -> &str; // elided
-fn substr<'a>(s: &'a str, until: u32) -> &'a str; // expanded
+fn substr(s: &str, until: u32) -> &str; // elided
+fn substr<'a>(s: &'a str, until: u32) -> &'a str; // expanded
-fn get_str() -> &str; // ILLEGAL, no inputs
+fn get_str() -> &str; // ILLEGAL, no inputs
-fn frob(s: &str, t: &str) -> &str; // ILLEGAL, two inputs
+fn frob(s: &str, t: &str) -> &str; // ILLEGAL, two inputs
-fn get_mut(&mut self) -> &mut T; // elided
-fn get_mut<'a>(&'a mut self) -> &'a mut T; // expanded
+fn get_mut(&mut self) -> &mut T; // elided
+fn get_mut<'a>(&'a mut self) -> &'a mut T; // expanded
-fn args<T:ToCStr>(&mut self, args: &[T]) -> &mut Command // elided
+fn args<T:ToCStr>(&mut self, args: &[T]) -> &mut Command // elided
fn args<'a, 'b, T:ToCStr>(&'a mut self, args: &'b [T]) -> &'a mut Command // expanded
-fn new(buf: &mut [u8]) -> BufWriter; // elided
-fn new<'a>(buf: &'a mut [u8]) -> BufWriter<'a> // expanded
+fn new(buf: &mut [u8]) -> BufWriter; // elided
+fn new<'a>(buf: &'a mut [u8]) -> BufWriter<'a> // expanded
```
# Related Resources
match x {
OptionalInt::Value(..) => println!("Got an int!"),
- OptionalInt::Missing => println!("No such luck."),
+ OptionalInt::Missing => println!("No such luck."),
}
```
match x {
OptionalInt::Value(i) if i > 5 => println!("Got an int bigger than five!"),
OptionalInt::Value(..) => println!("Got an int!"),
- OptionalInt::Missing => println!("No such luck."),
+ OptionalInt::Missing => println!("No such luck."),
}
```
let ref_x = &5;
let box_x = Box::new(5);
-let rc_x = Rc::new(5);
+let rc_x = Rc::new(5);
succ(ref_x);
succ(&*box_x);
match x {
OptionalInt::Value(n) => println!("x is {}", n),
- OptionalInt::Missing => println!("x is missing!"),
+ OptionalInt::Missing => println!("x is missing!"),
}
match y {
OptionalInt::Value(n) => println!("y is {}", n),
- OptionalInt::Missing => println!("y is missing!"),
+ OptionalInt::Missing => println!("y is missing!"),
}
}
```
fn main() {
println!("Type something!");
- // here, we'll show the types at each step
+ // here, we'll show the types at each step
- let input = io::stdin() // std::io::stdio::StdinReader
- .read_line() // IoResult<String>
- .ok() // Option<String>
+ let input = io::stdin() // std::io::stdio::StdinReader
+ .read_line() // IoResult<String>
+ .ok() // Option<String>
.expect("Failed to read line"); // String
println!("{}", input);
#[lang = "panic_fmt"]
extern fn panic_fmt(args: &core::fmt::Arguments,
- file: &str,
- line: u32) -> ! {
+ file: &str,
+ line: u32) -> ! {
loop {}
}