# Learn Rust with Golang Example by David Jr. 2022/08/01 --- # TOC * Topics * Mutable, Reference and Mutable Reference * Trait, Struct, Implementation * Closure * Example - Anchor * Key Takeaways --- # Topics --- ## 1. Mutable, Reference and Mutable Reference Variable bindings are immutable by default, but this can be overridden using the mut modifier.  ----  ----  ----  ----  --- ## 2. Trait, Struct, Implementation ```go type geometry interface { area() float64 perim() float64 } type rect struct { width, height float64 } type circle struct { radius float64 } func (r rect) area() float64 { return r.width * r.height } func (r rect) perim() float64 { return 2*r.width + 2*r.height } func (c circle) area() float64 { return math.Pi * c.radius * c.radius } func (c circle) perim() float64 { return 2 * math.Pi * c.radius } func measure(g geometry) { fmt.Println(g) fmt.Println(g.area()) fmt.Println(g.perim()) } func main() { r := rect{width: 3, height: 4} c := circle{radius: 5} measure(r) measure(c) } ``` ---- ```rust use core::f64::consts::PI; use core::fmt::Debug; trait Geometry { fn area(&self) -> f64; fn perim(&self) -> f64; } #[derive(Debug)] struct Rect { width: f64, height: f64, } #[derive(Debug)] struct Circle { radius: f64, } impl Geometry for Rect { fn area(&self) -> f64 { self.width * self.height } fn perim(&self) -> f64 { 2.0 * self.height + 2.0 * self.width } } impl Geometry for Circle { fn area(&self) -> f64 { PI * self.radius * self.radius } fn perim(&self) -> f64 { 2.0 * PI * self.radius } } fn main() { fn measure<T>(g: &T) where T: Geometry + Debug { println!("{:?}", g); println!("{:?}", g.area()); println!("{:?}", g.perim()); } let r = Rect{width: 3.0, height: 4.0}; let c = Circle{radius: 5.0}; measure(&r); measure(&c); } ``` --- ## 3. Closure ```go func intSeq() func() int { i := 0 return func() int { i++ return i } } func main() { nextInt := intSeq() fmt.PrintLn(nextInt()) fmt.PrintLn(nextInt()) fmt.PrintLn(nextInt()) } 1 2 3 ``` ---- ```rust fn main() { fn int_seq() -> Box<dyn FnMut() -> i32> { let mut i = 0; Box::new(move || { i += 1; i }) } let mut next_int: Box<_> = int_seq(); assert_eq!([1,2,3], [next_int(), next_int(), next_int()]); ``` --- # Example <https://github.com/coral-xyz/anchor> --- # Key Takeaways * Mutable, Reference and Mutable Reference: vars are immutable by default * Trait, Struct, Implementation: Similar to Go's struct * Closure: Need a heap of pointers --- # Refs 1. [ref](https://rustwiki.org/en/rust-by-example/variable_bindings/mut.html)] 2. https://askeing.github.io/rust-book/mutability.html 3. https://segmentfault.com/a/1190000021901693 4. https://studygolang.com/articles/26944 5. https://studygolang.com/articles/26933