---
# System prepended metadata

title: Learn Rust with Golang Example
tags: [' Talk', Templates]

---

---
title: Learn Rust with Golang Example
tags: Templates, Talk
description: View the slide with "Slide Mode".
---

# 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.

![](https://i.imgur.com/uzbNdBc.png)

----

![](https://i.imgur.com/mFfiD9G.png)

----

![](https://i.imgur.com/8rgGfTZ.png)

----

![](https://i.imgur.com/dGPAKOh.png)

----

![](https://i.imgur.com/26TKU0I.png)


---

## 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