The clean-rust from andreisilviudragnea

Use same name for Cargo package and directory in Cargo workspace

Use the same name for the Cargo package and directory in a Cargo workspace for easier understanding of the package structure

Clippy feature: Check for redundant async-await blocks

async (move) {
   future.await;
}

blocks are redundant

Suggest replacing if-let which only checks for pattern matching with matches! macro

Cargo clippy: replace .cloned() with .clone()

https://github.com/andreisilviudragnea/problems-rust/commit/e9e9bb5380048a8a23139b51d862da7ac8fe8e6d

Unnecessary reference in match target

https://github.com/andreisilviudragnea/problems-rust/commit/3f8473f0cc0f2f70f490c490a5fda728bba729ab

Closure captures in Rust book

Use rich enums instead of C-style enums

Rust enums are true ADTs, so use them instead of embedding C-style enums into structs

Investigate cargo nextest

Decouple non-determinism using trait bounds

Examples of non-determinism:

Randomness sources
Clocks

They can be extracted to a trait and injected using trait bounds and PhantomData on injected structs. This is the equivalent of implicit parameters in Scala.

Cargo clippy: replace Vec.into_iter().rev().collect() with [T].reverse()

https://github.com/andreisilviudragnea/problems-rust/commit/1f7bc7d2ca8595059114418e51cc29cc23e5dc06

Web frameworks

warp - 7.9k stars
Actix Web - 17.1k stars
Axum - 9.5k stars

Clippy style: prefer Result::map_err instead of match to reduce indentation

Document FuturesUnordered

Prefer static dispatch over dynamic dispatch

Static dispatch is both easier to understand and more efficient and should be preferred to dynamic dispatch as much as possible.

        let nodes = s[1..s.len() - 1]
            .split(',')
            .map(|str| match str {
                "null" => None,
                v => Some(v.parse::<i32>().unwrap()),
            })
            .map(|it| {
                it.map(|val| {
                    Rc::new(RefCell::new(TreeNode {
                        val,
                        left: None,
                        right: None,
                    }))
                })
            })
            .collect::<Vec<_>>();

        let nodes = s[1..s.len() - 1]
            .split(',')
            .map(|str| match str {
                "null" => None,
                v => Some(Rc::new(RefCell::new(TreeNode {
                    val: v.parse::<i32>().unwrap(),
                    left: None,
                    right: None,
                }))),
            })
            .collect::<Vec<_>>();

Use Cargo features for marking module and crate extraction

Cargo features are a fast way of marking code to be later decoupled into separate modules and crates

Clones can be removed by returning earlier value from function

For example, returning captures of a closure instead of a tuple of cloned capture groups.

Re-use business logic between async and non-async app

Use actix-web framework, which does not require Futures to be Send
Use maybe_async crate for automatic rewriting of async code to its non-async variant

Arcs without clone
Rcs without clone

Automatically remove unused items

    pub(crate) fn from_str(s: &str) -> Option<Rc<RefCell<TreeNode>>> {
        if s == "[]" {
            return None;
        }

        let nodes = s[1..s.len() - 1]
            .split(',')
            .map(|str| match str {
                "null" => None,
                v => Some(Rc::new(RefCell::new(TreeNode {
                    val: v.parse::<i32>().unwrap(),
                    left: None,
                    right: None,
                }))),
            })
            .collect::<Vec<_>>();

        let mut kids = nodes.iter().cloned().rev().collect::<Vec<_>>();

        let root = kids.pop().unwrap();

        for node in nodes.into_iter().flatten() {
            if let Some(val) = kids.pop() {
                node.borrow_mut().left = val;
            }
            if let Some(val) = kids.pop() {
                node.borrow_mut().right = val;
            }
        }

        root
    }

pub(crate) fn from_str(s: &str) -> Option<Rc<RefCell<TreeNode>>> {
    if s == "[]" {
        return None;
    }

    let nodes = s[1..s.len() - 1]
        .split(',')
        .map(|str| match str {
            "null" => None,
            v => Some(Rc::new(RefCell::new(TreeNode {
                val: v.parse::<i32>().unwrap(),
                left: None,
                right: None,
            }))),
        })
        .collect::<Vec<_>>();

    let mut kids = nodes.iter().cloned();

    let root = kids.next().unwrap();

    for node in nodes.iter().flatten() {
        if let Some(val) = kids.next() {
            node.borrow_mut().left = val;
        }
        if let Some(val) = kids.next() {
            node.borrow_mut().right = val;
        }
    }

    root
}

Cargo clippy: remove type arguments equal to defaults

Cargo clippy: Replace &Arc<T> with &T or Arc<T>

Replace &Arc with:

&T if there is no clone inside the method
Arc if there is a clone inside the method

Cargo clippy check for collect().iter() patterns

https://github.com/andreisilviudragnea/problems-rust/commit/a587070a62bdb5d94c32ec7fe0bad3c0805104e3
https://github.com/andreisilviudragnea/problems-rust/commit/bc425bb33048a9f99eca6cd12b05821fa5f804c5

        let nodes = s[1..s.len() - 1]
            .split(',')
            .map(|str| match str {
                "null" => None,
                v => Some(v.parse::<i32>().unwrap()),
            })
            .collect::<Vec<_>>() // THIS CAN
            .iter() // BE REMOVED
            .map(|it| {
                it.map(|val| {
                    Rc::new(RefCell::new(TreeNode {
                        val,
                        left: None,
                        right: None,
                    }))
                })
            })
            .collect::<Vec<_>>();

Do not remove .collect() calls if the collectors are used more than once.

First remove #derive[(Clone)] from as many types as possible. This usually results in many Arcs on which .clone is called instead.
Then check if those Arcs are really needed by looking if .clone() on those Arcs is really needed.

andreisilviudragnea / clean-rust Goto Github PK

clean-rust's People

Watchers

clean-rust's Issues

Recommend Projects

Recommend Topics

Recommend Org