Using a type definition to simplify a function signature

Clippy is giving the following warning:

warning: very complex type used. Consider factoring parts into `type` definitions
   --> src/regexp/mod.rs:845:56
    |
845 |     pub fn get_by_name<'b>(&'b self, name: &'b str) -> Vec<(&'b String, (usize, usize), (usize, usize))> {
    |                                                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#type_complexity
    = note: `#[warn(clippy::type_complexity)]` on by default

I agree with the warning. When I typed this code I didn't like it, but I can't seem to figure out where and how to put the type statement. I've looked in the book, followed the reference link clippy gave, and googled, and can't seem to find references to using type to simplify function signatures, or how to deal with the lifetime on the String parameter. Defining a new struct to hold the return value would work, but there isn't really any reason for such a structure besides simplifying the function definition.

Here's the code. You can see I fixed it by using the existing Report struct - it has a few extra fields that weren't in my design for the return, but the struct already exist, and it actually may be better to make the extra fields available. But thanks for the answer, it is something I should know whether or not it is used here.

pub struct Report {
    /// The string found matching the RE pattern
    pub found: String,
    /// The position in chars of the string. This cannot be used for slices, except for ASCII chars. To get a slice use **pos**
    pub pos: (usize, usize),
    /// The position in bytes of the string: that is, found[pos.0..pos.1] is a valid unicode substring containing the match
    pub bytes: (usize, usize),
    /// The name of the field: if None then the field should not be included in the Report tree, if Some("") it is included but
    /// unnamed, otherwise it is recorded with the given name
    pub name: Option<String>,
    /// Array of child Report structs, only non-empty for And and Or nodes. OrNodes will have only a single child node, AndNodes can have many.
    pub subreports: Vec<Report>,
}

impl Report {
    /// Constructor: creates a new report from a successful Path
    pub fn new(root: &crate::regexp::walk::Path, char_start: usize, byte_start: usize) -> Report {
        let (reports, _char_end)  = root.gather_reports(char_start, byte_start);
        reports[0].clone()
    }
    
    /// Pretty-prints a report with indentation to help make it easier to read
    pub fn display(&self, indent: isize) {
        let name_str = { if let Some(name) = &self.name { format!("<{}>", name) } else { "".to_string() }};
        println!("{}\"{}\" char position [{}, {}] byte position [{}, {}] {}",
                 pad(indent), self.found, self.pos.0, self.pos.1, self.bytes.0, self.bytes.1, name_str);
        self.subreports.iter().for_each(move |r| r.display(indent + 1));
    }

    /// Gets **Report** nodes representing matches for named Nodes. The return is a *Vec* because named matches can occur multiple
    /// times - for example, _\?\<name\>abc\)*_
    pub fn get_by_name<'b>(&'b self, name: &'b str) -> Vec<&Report> {
        let mut v = Vec::<&Report>::new();
        if let Some(n) = &self.name {
            if n == name { v.push(self); }
        }
        for r in &self.subreports {
            let mut x = r.get_by_name(name);
            v.append(&mut x);
        }
        v
    }

    /// Gets a hash of  **Report** nodes grouped by name. This just sets things up and calls **get_named_internal()** to do the work
    pub fn get_named(& self) -> HashMap<&str, Vec<&Report>> {
        let hash = HashMap::new();
        self.get_named_internal(hash)
    }

    /// internal function that does the work for **get_named()**
    fn get_named_internal<'b>(&'b self, mut hash: HashMap<&'b str, Vec<&'b Report>>) -> HashMap<&'b str, Vec<&Report>> {
        if let Some(name) = &self.name {
            if let Some(mut_v) = hash.get_mut(&name.as_str()) {
                mut_v.push(self);
            } else {
                hash.insert(name.as_str(), vec![self]);
            }
            for r in self.subreports.iter() {
                hash = r.get_named_internal(hash);
            }
        }
        hash
    }
}



</details>


# 答案1
**得分**: 5

有几种简化方法。 其中一种是将整个类型取一个别名（选择一个合适描述的名称而不是 `Foo`）：

```rust
type Foo<'a> = Vec<(&'a str, (usize, usize), (usize, usize))>;

然后你的返回类型是 Foo<'b>。

如果这个元组类型经常出现，你可以将其分离出来：

type Foo<'a> = (&'a str, (usize, usize), (usize, usize));

然后你将返回 Vec<Foo<'b>>。

很难在不看到你代码的其余部分的情况下提出替代方案。

我似乎无法弄清楚在何处以及如何放置类型声明

你可以将 type 声明放在任何可以放置其他类型声明的地方，比如 struct、enum 等。

type Foo<'a> = Vec<(&'a String, (usize, usize), (usize, usize))>;

type Foo<'a> = (&'a String, (usize, usize), (usize, usize));