这个递归连接如何在 Rust 中工作

Question

So I wrote this recursive string join function in Rust which seems to work, but I'm a bit confused why it works.

fn join(separator: &str, strs: &[&str]) -> String {
    match strs.len() {
        l if l > 1    => return strs[0].to_string() + separator + &join(separator, &strs[1..]),
        l if l == 1   => return strs[0].to_string(),
        _             => return "".to_string(),
    }
}

So I have an array of 3 Strings that I would like to join and a String separator. The function takes in the reference to a str &str for its first argument and then a reference to an array of Strings &[&str] for the second argument.

let j1 = ["one", "two", "three"];
println!("{}", join(", ", &j1));

1. Why does the recursive join have to be defined as &join(separator, &strs[1..]) ?
2. why does &strs[1..] have to be dereferenced again?

Answer 1

1. std::ops::Add<&'_ str> is implemented for String (scroll to the very bottom of the page). std::ops::Add<String> is not. Hence, you can only add &'_ str s to String s, and only on the right hand side. You have to reference your call to join because that uses deref coercion to turn the String into a &str .

2. This one is a bit more convoluted to provide exact evidence for, but in simplest terms, slicing (using a range in the index position) a slice or array will produce a slice, IE, [T] . Since you can't pass around bare [T] s around, you need to take a reference to it.
   The more exact reason as to why is:

   • Index<i> is impl-ed for [T] where I: SliceIndex<[T]> .
   • The output is I 's output as a SliceIndex .
   • 1.. is a [std::ops::RangeFrom](https://doc.rust-lang.org/beta/std/ops/struct.RangeFrom.html) .
   • SliceIndex<[T]> is impl-ed for all [T] on RangeFrom<usize> .
   • The output is [T] and not &[T] .

---

Additionally, this isn't the most idiomatic way of writing this function:

pub fn join(separator: &str, strs: &[&str]) -> String {
    match strs {
        [last]               => last.to_string(),
        [current, rest @ ..] => current.to_string() + separator + &join(separator, &rest),
        []                   => "".to_string(),
    }
}

Pattern matching works on slices.

Answer 2

1. Why does the recursive join have to be defined as &join(separator, &strs[1..]) ?
   • The + operator is syntactic sugar for std::ops::Add .
   • String has only one Add implementation , impl<'_> Add<&'_ str> for String , which means you can do String + &str but not String + String .
   • Since join returns a String , you have to get a &str from the result with &join(...) in order to use the + operator.
2. Why does &strs[1..] have to be dereferenced again? (I'm assuming you mean, "why can't I just write strs[1..] ?")
   • The syntax strs[1..] means "the sequence of values contained by strs from index 1 to the end".
   • The length of this sequence, and therefore its size, is not known at compile time, and so it cannot be placed on the stack (which it must be in order to be used as an argument to a function).
   • Instead of placing the value on the stack, you take a reference to the value instead, which has a known size. (Rust compiles this reference as a "fat pointer" which consists of a pointer to the slice memory and a length value to keep track of the slice.)