/r/ Recent content in Rs on Tianyi as a Developer Hugo -- gohugo.io en-us Sat, 04 Apr 2020 00:00:00 +0000 /rust/constructors-of-rust-structs/ Sat, 04 Apr 2020 00:00:00 +0000 /rust/constructors-of-rust-structs/ The new() Method The new() method is nothing special but it’s idiomatically used to initialise a new instance of a struct with empty fields, for example: #[derive(Debug)] struct Car<'a> { brand: &'a str, model: &'a str, color: &'a str, } impl<'a> Car<'a> { fn new() -> Self { Car { brand: "", model: "", color: "", } } } fn main(){ println!("{:?}", Car::new()) } ## Car { brand: "", model: "", color: "" } Builder Methods For structs with many fields (some of which may be optional), it’s common to define a number of builder methods to construct them. /rust/closures-in-rust/ Thu, 02 Apr 2020 00:00:00 +0000 /rust/closures-in-rust/ Using Closures and Functions as Arguments fn apply<F>(f: F) where F: Fn() { f(); } fn apply_mut<F>(mut f: F) where F: FnMut() { f(); } fn apply_once<F>(f: F) where F: FnOnce() { f(); } fn main() { use std::mem; let mut greeting = "hello".to_owned(); let farewell = "goodbye"; // Capture 2 variables: `greeting` by value and // `farewell` by reference. let diary = || { println!("Fn: {}, {}", greeting, farewell); }; apply(diary); apply_mut(diary); apply_once(diary); // dyn Fn actually implements all Fn, FnMut and FnOnce // try &T, then &mut T, then T let diary_mut = || { greeting. /rust/oop-in-rust/ Wed, 01 Apr 2020 00:00:00 +0000 /rust/oop-in-rust/ Example: Post Using Enum enum PostState { Draft, PendingReview, Published, } struct Post { text: String, state: PostState, } impl Post { fn new() -> Self { Post { text: String::new(), state: PostState::Draft, } } fn add_text(&mut self, s: &str) { self.text.push_str(s) } fn request_review(&mut self) { self.state = PostState::PendingReview } fn approve(&mut self) { self.state = PostState::Published } fn content(&self) -> &str { if let PostState::Published = self.state { &self. /rust/polymorphism-in-rust-traits/ Wed, 01 Apr 2020 00:00:00 +0000 /rust/polymorphism-in-rust-traits/ The From and Into traits are good examples of polymorphism. If a trait uses a generic type T in its signature, such as in From: pub trait From<T>: Sized { fn from(_: T) -> Self; } then different ‘variants’ of the trait, where <T> is replaced with concrete types, can be implemented. Here is an example: struct Foo(i32); #[derive(Debug)] struct Bar(i32); impl From<i32> for Bar { fn from(n: i32) -> Self { Bar(n) } } impl<'a> From<&'a Foo> for Bar { fn from(foo: &Foo) -> Self { Bar(foo. /rust/borrowing-and-ownership-in-rust/ Tue, 31 Mar 2020 00:00:00 +0000 /rust/borrowing-and-ownership-in-rust/ Slice Slices fn main() { let mut x = [1, 2, 3, 4, 5]; let r = &mut x; if let Some((first, rest)) = r.split_first_mut() { *first = 100; rest[0] = 99; rest[1] = 98; } assert_eq!(x, [100, 99, 98, 4, 5]) } Deref Coersion in Functions fn main() { let v = 5; let r = &v; let r2 = &r; println!("{}, {}", is_five(r), is_five(r2)) } fn is_five(val: &i32) -> bool { *val == 5 } ## true, true Smart Pointers Deref Coersion From The Book: /rust/default-parameters-optional-arguments-in-rust/ Tue, 24 Mar 2020 00:00:00 +0000 /rust/default-parameters-optional-arguments-in-rust/ In Rust’s std docs, there is an example of using unwrap_or() to mimic a default parameter: use std::fmt; struct Vector2D { x: isize, y: isize, } impl fmt::Binary for Vector2D { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let magnitude = (self.x * self.x + self.y * self.y) as f64; let magnitude = magnitude.sqrt(); let decimals = f.precision().unwrap_or(3); let string = format!("{:.*}", decimals, magnitude); f.pad_integral(true, "", &string) } } fn main() { let myvector = Vector2D { x: 3, y: 4 }; println! /r/extending-knitr/ Mon, 23 Mar 2020 00:00:00 +0000 /r/extending-knitr/ Many R users use R Markdown to author documents, often containing R code, that can be seamlessly rendered into various output formats (usually PDF and HTML) with a single click or keyboard shortcut. Ordered R markdown documents can be converted into books and websites (for example the one you’re now reading!) with a few lines of command, thanks to Yihui’s bookdown and blogdown packages. /r/r-housekeeping/ Mon, 23 Mar 2020 00:00:00 +0000 /r/r-housekeeping/ This post is to remind myself of some not-so-common, but very useful operations in R. .Rprofile and .Renviron Options Setting PATH in .Renviron RStudio has a different PATH from bash’s, which can lead command not found when calling system() or system2(). You can set the PATH for RStudio in .Renviron file like this: PATH=/additional/path:${PATH} Note that curly braces are required. Package Management Installing Local Packages: First, open the R Project of the package in RStudio. /rust/rust-iterators/ Thu, 19 Mar 2020 00:00:00 +0000 /rust/rust-iterators/ Methods on Iterators next() Iterator Adaptors Iterator adaptors takes ownership of the iterator and returns another kind of iterator, which allows chaining. The commonly used adaptors are map(), filter(), The chain of iterators is lazy Aggregation Functions fn main() { use Direction::*; println!( "{:?}", dir_reduc(&[NORTH, SOUTH, EAST, WEST, NORTH, WEST]) ); } #[derive(PartialEq, Eq, Debug, Clone)] enum Direction { NORTH, SOUTH, EAST, WEST, } impl Direction { fn opposite(&self) -> Direction { match self { Direction::NORTH => Direction::SOUTH, Direction::SOUTH => Direction::NORTH, Direction::EAST => Direction::WEST, Direction::WEST => Direction::EAST, } } } fn dir_reduc(arr: &[Direction]) -> Vec<Direction> { let mut res: Vec<Direction> = vec!