mirror of
https://github.com/chubin/cheat.sheets
synced 2024-11-15 06:12:59 +00:00
86 lines
2.3 KiB
Plaintext
86 lines
2.3 KiB
Plaintext
// Functions
|
||
// `i32` is the type for 32-bit signed integers
|
||
fn add2(x: i32, y: i32) -> i32 {
|
||
// Implicit return (no semicolon)
|
||
x + y
|
||
}
|
||
|
||
// Main function
|
||
fn main() {
|
||
|
||
// Numbers //
|
||
//
|
||
// Immutable bindings
|
||
let x: i32 = 1;
|
||
|
||
// Integer/float suffixes
|
||
let y: i32 = 13i32;
|
||
let f: f64 = 1.3f64;
|
||
|
||
// Type inference
|
||
// Most of the time, the Rust compiler can infer what type a variable is, so
|
||
// you don’t have to write an explicit type annotation.
|
||
// Throughout this tutorial, types are explicitly annotated in many places,
|
||
// but only for demonstrative purposes. Type inference can handle this for
|
||
// you most of the time.
|
||
let implicit_x = 1;
|
||
let implicit_f = 1.3;
|
||
|
||
// Arithmetic
|
||
let sum = x + y + 13;
|
||
|
||
// Mutable variable
|
||
let mut mutable = 1;
|
||
mutable = 4;
|
||
mutable += 2;
|
||
|
||
// Strings //
|
||
//
|
||
// String literals
|
||
let x: &str = "hello world!";
|
||
//
|
||
// Printing
|
||
println!("{} {}", f, x); // 1.3 hello world
|
||
//
|
||
// A `String` – a heap-allocated string
|
||
let s: String = "hello world".to_string();
|
||
//
|
||
// A string slice – an immutable view into another string
|
||
// This is basically an immutable pair of pointers to a string – it doesn’t
|
||
// actually contain the contents of a string, just a pointer to
|
||
// the begin and a pointer to the end of a string buffer,
|
||
// statically allocated or contained in another object (in this case, `s`)
|
||
let s_slice: &str = &s;
|
||
//
|
||
println!("{} {}", s, s_slice); // hello world hello world
|
||
|
||
// Vectors/arrays //
|
||
//
|
||
// A fixed-size array
|
||
let four_ints: [i32; 4] = [1, 2, 3, 4];
|
||
//
|
||
// A dynamic array (vector)
|
||
let mut vector: Vec<i32> = vec![1, 2, 3, 4];
|
||
vector.push(5);
|
||
//
|
||
// A slice – an immutable view into a vector or array
|
||
// This is much like a string slice, but for vectors
|
||
let slice: &[i32] = &vector;
|
||
//
|
||
// Use `{:?}` to print something debug-style
|
||
println!("{:?} {:?}", vector, slice); // [1, 2, 3, 4, 5] [1, 2, 3, 4, 5]
|
||
|
||
// Tuples //
|
||
//
|
||
// A tuple is a fixed-size set of values of possibly different types
|
||
let x: (i32, &str, f64) = (1, "hello", 3.4);
|
||
//
|
||
// Destructuring `let`
|
||
let (a, b, c) = x;
|
||
println!("{} {} {}", a, b, c); // 1 hello 3.4
|
||
//
|
||
// Indexing
|
||
println!("{}", x.1); // hello
|
||
|
||
}
|