Skip to content

Commit

Permalink
start writing chapter 4
Browse files Browse the repository at this point in the history
  • Loading branch information
@pranavj1001
pranavj1001 committed Sep 1, 2019
1 parent 620c566 commit a184128
Showing 1 changed file with 133 additions and 119 deletions.
252 changes: 133 additions & 119 deletions Rust/rust.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -101,140 +101,154 @@
// Rust provides access to a wide variety of primitives.

// !!!--- start uncommenting from line below ---!!!
use std::fmt;
use std::mem;

#[derive(Debug)]
struct Matrix(f32, f32, f32, f32);

impl fmt::Display for Matrix {
// `f` is a buffer, this method must write the formatted string into it
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "( {} {} ) \n( {} {} )", self.0, self.1, self.2, self.3)
}
}

fn transpose(matrix: Matrix) -> Matrix {
Matrix(matrix.0, matrix.2, matrix.1, matrix.3)
}

// This function borrows a slice
fn analyze_slice(slice: &[i32]) {
println!("first element of the slice: {}", slice[0]);
println!("the slice has {} elements", slice.len());
}

fn main() {
// Variables can be type annotated.
let logical: bool = true;

let a_float: f64 = 1.0; // Regular annotation
let an_integer = 5i32; // Suffix annotation

// Or a default will be used.
let default_float = 3.0; // `f64`
let default_integer = 7; // `i32`
// use std::fmt;
// use std::mem;

// #[derive(Debug)]
// struct Matrix(f32, f32, f32, f32);

// impl fmt::Display for Matrix {
// // `f` is a buffer, this method must write the formatted string into it
// fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
// write!(f, "( {} {} ) \n( {} {} )", self.0, self.1, self.2, self.3)
// }
// }

// fn transpose(matrix: Matrix) -> Matrix {
// Matrix(matrix.0, matrix.2, matrix.1, matrix.3)
// }

// // This function borrows a slice
// fn analyze_slice(slice: &[i32]) {
// println!("first element of the slice: {}", slice[0]);
// println!("the slice has {} elements", slice.len());
// }

// fn main() {
// // Variables can be type annotated.
// let logical: bool = true;

// let a_float: f64 = 1.0; // Regular annotation
// let an_integer = 5i32; // Suffix annotation

// // Or a default will be used.
// let default_float = 3.0; // `f64`
// let default_integer = 7; // `i32`

// A type can also be inferred from context
let mut inferred_type = 12; // Type i64 is inferred from another line
inferred_type = 4294967296i64;
// // A type can also be inferred from context
// let mut inferred_type = 12; // Type i64 is inferred from another line
// inferred_type = 4294967296i64;

// A mutable variable's value can be changed.
let mut mutable = 12; // Mutable `i32`
mutable = 21;
// // A mutable variable's value can be changed.
// let mut mutable = 12; // Mutable `i32`
// mutable = 21;

// Error! The type of a variable can't be changed.
//mutable = true;
// // Error! The type of a variable can't be changed.
// //mutable = true;

// Variables can be overwritten with shadowing.
let mutable = true;

// Integer addition
// We need to tell the compiler the type of the literals we use.
println!("1 + 2 = {}", 1u32 + 2);

// Integer subtraction
// We need to tell the compiler the type of the literals we use.
println!("1 - 2 = {}", 1i32 - 2);

// Short-circuiting boolean logic
println!("true AND false is {}", true && false);
println!("true OR false is {}", true || false);
println!("NOT true is {}", !true);

// Bitwise operations
println!("0011 AND 0101 is {:04b}", 0b0011u32 & 0b0101);
println!("0011 OR 0101 is {:04b}", 0b0011u32 | 0b0101);
println!("0011 XOR 0101 is {:04b}", 0b0011u32 ^ 0b0101);
println!("1 << 5 is {}", 1u32 << 5);
println!("0x80 >> 2 is 0x{:x}", 0x80u32 >> 2);

// Use underscores to improve readability!
println!("One million is written as {}", 1_000_000u32);

// A tuple with a bunch of different types
let long_tuple = (1u8, 2u16, 3u32, 4u64,
-1i8, -2i16, -3i32, -4i64,
0.1f32, 0.2f64,
'a', true);

// Values can be extracted from the tuple using tuple indexing
println!("long tuple first value: {}", long_tuple.0);
println!("long tuple second value: {}", long_tuple.1);

// Tuples can be tuple members
let tuple_of_tuples = ((1u8, 2u16, 2u32), (4u64, -1i8), -2i16);

// Tuples are printable
println!("tuple of tuples: {:?}", tuple_of_tuples);
// // Variables can be overwritten with shadowing.
// let mutable = true;

// // Integer addition
// // We need to tell the compiler the type of the literals we use.
// println!("1 + 2 = {}", 1u32 + 2);

// // Integer subtraction
// // We need to tell the compiler the type of the literals we use.
// println!("1 - 2 = {}", 1i32 - 2);

// // Short-circuiting boolean logic
// println!("true AND false is {}", true && false);
// println!("true OR false is {}", true || false);
// println!("NOT true is {}", !true);

// // Bitwise operations
// println!("0011 AND 0101 is {:04b}", 0b0011u32 & 0b0101);
// println!("0011 OR 0101 is {:04b}", 0b0011u32 | 0b0101);
// println!("0011 XOR 0101 is {:04b}", 0b0011u32 ^ 0b0101);
// println!("1 << 5 is {}", 1u32 << 5);
// println!("0x80 >> 2 is 0x{:x}", 0x80u32 >> 2);

// // Use underscores to improve readability!
// println!("One million is written as {}", 1_000_000u32);

// // A tuple with a bunch of different types
// let long_tuple = (1u8, 2u16, 3u32, 4u64,
// -1i8, -2i16, -3i32, -4i64,
// 0.1f32, 0.2f64,
// 'a', true);

// // Values can be extracted from the tuple using tuple indexing
// println!("long tuple first value: {}", long_tuple.0);
// println!("long tuple second value: {}", long_tuple.1);

// // Tuples can be tuple members
// let tuple_of_tuples = ((1u8, 2u16, 2u32), (4u64, -1i8), -2i16);

// // Tuples are printable
// println!("tuple of tuples: {:?}", tuple_of_tuples);

// But long Tuples cannot be printed
// let too_long_tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13);
// println!("too long tuple: {:?}", too_long_tuple);
// TODO ^ Uncomment the above 2 lines to see the compiler error
// // But long Tuples cannot be printed
// // let too_long_tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13);
// // println!("too long tuple: {:?}", too_long_tuple);
// // TODO ^ Uncomment the above 2 lines to see the compiler error

// To create one element tuples, the comma is required to tell them apart
// from a literal surrounded by parentheses
println!("one element tuple: {:?}", (5u32,));
println!("just an integer: {:?}", (5u32));
// // To create one element tuples, the comma is required to tell them apart
// // from a literal surrounded by parentheses
// println!("one element tuple: {:?}", (5u32,));
// println!("just an integer: {:?}", (5u32));

//tuples can be destructured to create bindings
let tuple = (1, "hello", 4.5, true);
// //tuples can be destructured to create bindings
// let tuple = (1, "hello", 4.5, true);

let (a, b, c, d) = tuple;
println!("{:?}, {:?}, {:?}, {:?}", a, b, c, d);
// let (a, b, c, d) = tuple;
// println!("{:?}, {:?}, {:?}, {:?}", a, b, c, d);

let matrix = Matrix(1.1, 1.2, 2.1, 2.2);
println!("{:?}", matrix);
println!("{}", matrix);
println!("{}", transpose(matrix));
// let matrix = Matrix(1.1, 1.2, 2.1, 2.2);
// println!("{:?}", matrix);
// println!("{}", matrix);
// println!("{}", transpose(matrix));

// Fixed-size array (type signature is superfluous)
let xs: [i32; 5] = [1, 2, 3, 4, 5];
// // Fixed-size array (type signature is superfluous)
// let xs: [i32; 5] = [1, 2, 3, 4, 5];

// All elements can be initialized to the same value
let ys: [i32; 500] = [0; 500];
// // All elements can be initialized to the same value
// let ys: [i32; 500] = [0; 500];

// Indexing starts at 0
println!("first element of the array: {}", xs[0]);
println!("second element of the array: {}", xs[1]);
// // Indexing starts at 0
// println!("first element of the array: {}", xs[0]);
// println!("second element of the array: {}", xs[1]);

// `len` returns the size of the array
println!("array size: {}", ys.len());
// // `len` returns the size of the array
// println!("array size: {}", ys.len());

// Arrays are stack allocated
println!("array occupies {} bytes", mem::size_of_val(&ys));
// // Arrays are stack allocated
// println!("array occupies {} bytes", mem::size_of_val(&ys));

// Arrays can be automatically borrowed as slices
println!("borrow the whole array as a slice");
analyze_slice(&xs);
// // Arrays can be automatically borrowed as slices
// println!("borrow the whole array as a slice");
// analyze_slice(&xs);

// Slices can point to a section of an array
println!("borrow a section of the array as a slice");
analyze_slice(&ys[1 .. 4]);
// // Slices can point to a section of an array
// println!("borrow a section of the array as a slice");
// analyze_slice(&ys[1 .. 4]);

// Out of bound indexing causes compile error
// println!("{}", xs[5]);
}
// // Out of bound indexing causes compile error
// // println!("{}", xs[5]);
// }
// !!!--- end uncommenting from line above ---!!!
// ------------------ Primitives end ------------------
// ------------------ Primitives end ------------------

// Chapter 4
// ------------------ Custom Types start ------------------
// Rust custom data types are formed mainly through the two keywords:

// struct: define a structure
// enum: define an enumeration
// Constants can also be created via the const and static keywords.

// !!!--- start uncommenting from line below ---!!!

// !!!--- end uncommenting from line above ---!!!

// ------------------ Custom Types end --------------------

0 comments on commit a184128

Please sign in to comment.