Coscup2021-rust-toturial

Variable
• Typescript
• Rust
const num = 123;
num = 456;
// Uncaught TypeError: Assignment to constant variable.
console.log(`The value of num is: ${num}`);
let num = 123;
num = 456;
// error[E0384]: cannot assign twice to immutable variable `num`
println!("The value of numMut is: {}", num);

Variable
• Typescript
• Rust
let mut numMut = 123;
numMut = 456;
println!("The value of numMut is: {}", numMut);
let numMut = 123;
numMut = 456;
console.log(`The value of numMut is: ${numMut}`);

• Typescript
• Rust
fn add(x: i32, y: i32) -> i32 {
x + y
}
add(1, 2); // 3
function add(x: number, y: number) {
return x + y;
}
add(1, 2); // 3
Function

Function
• Typescript
• Rust
function return_undefined(x: number, y: number): void {
const added = x + y;
}
return_undefined(1, 2); // undefined
fn return_unit(x: i32, y: i32) -> () {
let added = x + y;
}
return_unit(1, 2); // ()

Lambda expression
• Typescript
• Rust
let add2 = (x: number) => x + 2;
 
let add3 = (x: number) => { 
return x + 3; 
}
let add2 = |x| x + 2;
let add3 = |x: i32| -> i32 {
x + 3
};

Rust closure
• Typescript
• Rust
let a = 4;
 
let addA = x => x + a;
let a = 4;
let add_a = |x| x + a;

If else / Ternary
• Typescript
• Rust
let state: string = null;
if (condition) {
state = "a";
} else {
state = "b";
}
let state2 = condition ? "a" : "b";
let condition = true;
let state = if condition { "a" } else { "b" };

• Typescript
const options = {
cond1: false,
cond2: true,
propA: "a",
propB: "b"
};
let state = options.cond1 ? options.propA
: options.cond2
? doSomeThing(options.propB)
: doAnotherThing("c");
function doSomeThing(str: string) {
return "print: ".concat(str);
}
function doAnotherThing(str: string) {
}
Real World Case Study

• Typescript
const options = {
cond1: false,
cond2: true,
propA: "a",
propB: "b"
};
let state = options.cond1 ? options.propA
: options.cond2
? doSomeThing(options.propB)
: doAnotherThing("c");
function doSomeThing(str: string) {
}
function doAnotherThing(str: string) {
}
// print: b

• Rust
let options = Options {
cond1: false,
cond2: true,
propA: String::from("a"),
propB: String::from("b")
};
let state = if options.cond1 {
options.propA
} else if options.cond2 {
do_some_thing(&options.propB)
} else {
do_another_thing(&String::from(""))
};
println!("{:?}", state); // print: b

Object v.s Struct
• Typescript
interface User {
username: string;
email: string;
active: boolean;
sign_in_count: number;
}
const user1: User = {
username: 'someusername123',
email: 'someone@example.com',
active: true,
sign_in_count: 1,
};

Object v.s Struct
• Typescript
class User {
constructor(
public username: string,
public email: string,
public active: boolean,,
public sign_in_count: number,
) {}
}
const user = new User(
'someusername123',
'someone@example.com',
true,
1
);

Object v.s Struct
• Rust
struct User {
username: String,
email: String,
active: bool,
sign_in_count: u64,
}
let user1 = User {
email: String::from("someone@example.com"),
username: String::from("someusername123"),
active: true,
sign_in_count: 1,
};

Interface / Implement
• Typescript
interface IDuck {
name: string;
quack(): void;
walk(): void;
}
class Duck implements IDuck {
public name: string;
constructor(name: string) {
this.name = name;
}
quack() {
console.log(`${this.name} quacking!`);
}
walk() {
console.log(`${this.name} walking!`);
}
}

• Rust
trait DuckTrait {
fn quack(&self);
fn walk(&self);
}
struct Duck {
name: &'static str
}
impl Duck for DuckTrait {
fn quack(&self) {
println!("{} quacking!", self.name);
}
fn walk(&self) {
println!("{} walking!", self.name);
}
}

• Typescript
• Rust
let duck = Duck { name: "Duck A" };
duck.quack(); //Duck A quacking!
duck.walk(); // Duck A walking!
let duck = new Duck("Duck A”);
duck.quack(); // Duck A quacking!
duck.walk(); // Duck A walking!

Collection and For Syntax
• Typescript
• Rust
let arr = [4, 5, 6];
for(let item of arr) {
console.log(`print: ${item}`);
}
let vec = vec![4,5,6];
for item in vec.iter() {
println!("print: {}", item);
}
// print: 4
// print: 5
// print: 6

Iterator
• Invoke next method
let mut iter = vec![4,5,6].iter();
println!("{:?}", iter.next()); // Some(4)
• Iterator Trait
trait Iterator {
type Item;
fn next(&mut self) -> Option<Self::Item>;
}

Typescript Array
• map 、 filter
let mapped: number[] = [1,2,3].map(x => x + 1); // [2,3,4]
let filtered: number[] = [1,2,3].filter(x => x > 2); // [3]

Typescript Array
• map 、 filter
• reduce、some、find、forEach…
let mapped: number[] = [1,2,3].map(x => x + 1); // [2,3,4]
let filtered: number[] = [1,2,3].filter(x => x > 2); // [3]
let hasBiggerThanOne = [1, 2, 3].some(x => x > 1); // true
let sum = [1, 2, 3].reduce((acc, curr) => acc + curr, 0); // 6
let finded = [1, 2, 4].find(x => x > 2); // 4
[1,2,3].forEach(x => console.log(x)); // undefined

Rust Vector
• map 、 filter
let mapped: Vec<i32> = vec![1,2,3].iter().map(|x| x + 1).collect(); // [2,3,4]
let filtered: Vec<i32> = vec![1,2,3].iter().filter(|&y| y > 2).collect(); // [3]

• map 、 filter
• any、fold、find、forEach…
let has_bigger_than_one = vec![1, 2, 3].iter().any(|x| x > 1); // true
let sum = vec![1,2,3].iter().fold(0, |acc, curr| acc + curr); // 6
let finded = vec![1, 2, 4].iter().find(|&x| x > 2); // Some(4)
let for_eached = vec![1,2,3].iter().for_each(|x| println!("{}", x)); // ()
let filtered: Vec<i32> = vec![1,2,3].iter().filter(|&y| y > 2).collect(); // [3]
Rust Vector

Step by step
let iter = vec![1,2,3].iter(); // Iter([1, 2, 3])

Step by step
let map_iter = vec![1,2,3].iter().map(|x| x + 1); // Map { iter: Iter([1, 2, 3]) }
Lazy Compute !

Step by step

Map Adapter
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
fn map<B, F>(self, f: F) -> Map<Self, F>
where
Self: Sized,
F: FnMut(Self::Item) -> B,
{
Map::new(self, f)
}
https://doc.rust-lang.org/src/core/iter/traits/iterator.rs.html#721-724

Map Adapter
#[stable(feature = "rust1", since = "1.0.0")]
impl<B, I: Iterator, F> Iterator for Map<I, F>
where
F: FnMut(I::Item) -> B,
{
type Item = B;
#[inline]
fn next(&mut self) -> Option<B> {
self.iter.next().map(&mut self.f)
}
#[inline]
fn size_hint(&self) -> (usize, Option<usize>) {
self.iter.size_hint()
}
...
}
https://doc.rust-lang.org/src/core/iter/adapters/map.rs.html#59-63

Consumer
#[inline]
#[stable(feature = "rust1", since = “1.0.0")]
...
fn collect<B: FromIterator<Self::Item>>(self) -> B
where
Self: Sized,
{
FromIterator::from_iter(self)
}
https://doc.rust-lang.org/src/core/iter/traits/collect.rs.html#92-114

Consumer
pub trait FromIterator<A>: Sized {
...
fn from_iter<T: IntoIterator<Item = A>>(iter: T) -> Self;
}
https://doc.rust-lang.org/beta/src/core/result.rs.html#1577-1627
#[inline]
#[stable(feature = "rust1", since = “1.0.0")]
...
fn collect<B: FromIterator<Self::Item>>(self) -> B
where
Self: Sized,
{
FromIterator::from_iter(self)
}

Custom Customer
https://doc.rust-lang.org/std/iter/trait.FromIterator.html
#[derive(Debug)]
struct MyCollection(Vec<i32>);
impl MyCollection {
fn new() -> MyCollection {
MyCollection(Vec::new())
}
fn add(&mut self, elem: i32) {
self.0.push(elem);
}
}

Custom Customer
https://doc.rust-lang.org/std/iter/trait.FromIterator.html
impl FromIterator<i32> for MyCollection {
fn from_iter<I: IntoIterator<Item=i32>>(iter: I) -> Self {
let mut c = MyCollection::new();
for i in iter {
c.add(i);
}
c
}
}

JS Array’s Limit
https://twitter.com/mgechev/status/1280523754615926784?s=20

JS library’s Solution
-—-Start——
iter_value: 1
iter_value: 2
—-Result—-
[2, 3]
import { append, compose, map, take, tap, transduce } from 'ramda';
let data = [1, 2, 3, 4, 5];
let transducer = compose(
tap(x => console.log(`iter_value: ${x}`)),
map(x => x + 1),
take(2)
);
let step = (acc, curr) => append(acc, curr);
let init_val = [];
let result = transduce(transducer, step, init_val)(data);
console.log(`---Result---`, result);

JS library’s Solution
import { append, compose, map, take, tap, transduce } from 'ramda';
let data = [1, 2, 3, 4, 5];
map(x => x + 1),
take(2)
);
let step = (acc, curr) => append(acc, curr);
let init_val = [];
let result = transduce(transducer, step, init_val)(data);
console.log(`---Result---`, result);
-—-Start——
iter_value: 1
iter_value: 2
—-Result—-
[2, 3]

Rust’s Solution
println!("---Start---");
let result: Vec<i32> = vec![1, 2, 3, 4, 5].iter()
.inspect(|x| println!("iter_value: {}", x))
.map(|x| x + 1)
.take(2)
.collect();
println!("---Result---");
println!("{:?}", result);
-—-Start——
iter_value: 1
iter_value: 2
—-Result—-
[2, 3]

Rust Version
println!("---Start---");
let result: Vec<i32> = vec![1, 2, 3, 4, 5].iter()
.inspect(|x| println!("iter_value: {}", x))
.map(|x| x + 1)
.take(2)
.collect();
println!("---Result---");
println!("{:?}", result);
-—-Start——
iter_value: 1
iter_value: 2
—-Result—-
[2, 3]

Zero Cost Iterator Abstraction
https://doc.rust-lang.org/book/ch13-04-performance.html

Think with set and function
map
Family Member’s
age
let toAge = |p| p.age
!
👶
#
$ 73
42
1
37

73
42
1
37
map
let afterOneYear= |age| age + 1
74
43
2
38

filter
let elders= |age| age > 40
74
43
2
38
74
43

1
2
4
3
A
4
5
7
6
B
8
9
11
10
C
f: A -> B g: B -> C
let add_three = |a| a + 3 let add_four= |a| a + 4

1
2
4
3
A
8
9
11
10
C
g ∘ f : A -> C
let add_seven= compose!(add_four, add_three);

• Delcarative: describes what you want, but
not how to achieve it.
• Divide and conquer: split big question to
multiple small questions.
Benefit of composition
• Think with data: focus on your goal.

Use macro for your
abstraction

Declarative Macro
let vector: Vec<i32> = vec![1, 2, 3];
#[macro_export]
macro_rules! vec {
( $( $x:expr ),* ) => {
{
let mut temp_vec = Vec::new();
$(
temp_vec.push($x);
)*
temp_vec
}
};
}

Procedural Macros
#[derive(Debug)]
struct Point {
x: i32,
y: i32,
}
let point = Point { x: 0, y: 0 };
println!(Debug Point: {:?}”, point);
// Debug: Point { x: 0, y: 0 }

Procedural Macros
https://doc.rust-lang.org/book/ch19-06-macros.html
use std::fmt;
struct Point {
x: i32,
y: i32,
}
impl fmt::Debug for Point {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::R
f.debug_struct("Point")
.field("x", &self.x)
.field("y", &self.y)
.finish()
}
}
#[derive(Debug)]
struct Point {
x: i32,
y: i32,
}
let point = Point { x: 0, y: 0 };
println!(Debug Point: {:?}”, point);
// Debug: Point { x: 0, y: 0 }

Rust Compiler Flow
https://doc.rust-lang.org/beta/src/core/result.rs.html#1577-1627

Use Case: Variadic Function
map(x => x + 1),
take(2)
);

map(x => x + 1),
take(2)
);
function compose(f, g) {
return x => f(g(x));
};

map(x => x + 1),
take(2)
);
function compose(f, g) {
return x => f(g(x));
};
function compose(f, g, h) {
return x => f(g(h(x)));
};

function compose(…fns) {
return (arg) => fns.reduceRight((acc, fn) => fn(acc), args);
}
let newFunction = compose(
map(x => x + 1),
take(2),
tap(x => console.log(`taked_value: ${x}`)),
);

macro_rules! compose {
($($fns:expr),+) => {
move |arg| compose!(@inner arg, $($fns),+)
};
(@inner $x:expr, $f:expr, $($fns: expr),+) => {
$f(compose!(@inner $x, $($fns),+))
};
(@inner $x:expr, $f:expr) => {
$f($x)
};
}
$($fns:expr),*: repeat functions
*: zero or more repetitions
+: one or more repetitions
$f:expr: matched function expression

macro_rules! compose {
($($fns:expr),+) => {
move |arg| compose!(@inner arg, $($fns),+)
};
(@inner $x:expr, $f:expr, $($fns: expr),+) => {
$f(compose!(@inner $x, $($fns),+))
};
(@inner $x:expr, $f:expr) => {
$f($x)
};
}
fn main() {
let f1 = |x: i32| x + 1;
let f2 = |y: i32| y + 2;
let f3 = |z: i32| z + 3;
let f4 = compose!(f3, f2, f1);
println!("{:?}", f4(4))
}

Reuse composed function
fn f1(x: i32) -> i32 { x + 1 }
fn f2(y: i32) -> i32 { y + 2 }
fn f3(z: i32) -> i32 { z + 3 }
pub fn f4(input: i32) -> i32 {
compose!(f3, f2, f1)(input)
}

Reuse composed function
pub fn precededc<I, O1, O2, E: ParseError<I>, F, G>(
input: I,
first: F,
second: G,
) -> IResult<I, O2, E>
where
F: Fn(I) -> IResult<I, O1, E>,
G: Fn(I) -> IResult<I, O2, E>,
{
preceded(first, second)(input)
}

Trace the expansion of macros
#![feature(trace_macros)]
...
fn main() {
let f1 = |x: i32| x + 1;
let f2 = |y: i32| y + 2;
let f3 = |z: i32| z + 3;
trace_macros!(true);
trace_macros!(false);
println!("{:?}", f4(4))
}

Trace the expansion of macros
#![feature(trace_macros)]
...
fn main() {
let f1 = |x: i32| x + 1;
let f2 = |y: i32| y + 2;
let f3 = |z: i32| z + 3;
trace_macros!(true);
trace_macros!(false);
println!("{:?}", f4(4))
}
note: trace_macro
--> src/main.rs:18:14
|
18 | let f4 = compose!(f3, f2, f1);
| ^^^^^^^^^^^^^^^^^^^^
|
= note: expanding `compose! { f3, f2, f1 }`
= note: to `move | arg | compose! (@inner arg, f3, f2, f1)`
= note: expanding `compose! { @inner arg, f3, f2, f1 }`
= note: to `f3 (compose! (@inner arg, f2, f1))`
= note: expanding `compose! { @inner arg, f2, f1 }`
= note: to `f2 (compose! (@inner arg, f1))`
= note: expanding `compose! { @inner arg, f1 }`
= note: to `f1 (arg)`

Inspect Expanded Macro
rustup run nightly cargo rustc -- -Z unstable-options --pretty=expanded

Inspect Expanded Macro
rustup run nightly cargo rustc -- -Z unstable-options --pretty=expanded
fn main() {
let f1 = |x: i32| x + 1;
let f2 = |y: i32| y + 2;
let f3 = |z: i32| z + 3;
();
let f4 = move |arg| f3(f2(f1(arg)));
();
{
...
}
}

Coscup2021-rust-toturial

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (20)

Similar a Coscup2021-rust-toturial

Similar a Coscup2021-rust-toturial (20)

Último

Último (20)

Coscup2021-rust-toturial