`repeat_and_join` function for strings and chars in rust

Warning: I am very new to Rust. At the moment I am not yet familiar with typical Rust habits. I am still transferring a lot of concepts from other languages I know, such as C#, C++ and Python. If you down-vote, please leave a comment so that I can learn from it.

Single responsibility

To me, the name repeat_and_join() implies a violation of the single responsibility principle. This method does 2 things. I would split that up into 2 methods, one for repeating and one for joining. Create one trait for each of them.

trait RepeatExt {
    fn times(&self, n: usize) -> Vec<String>;
}

trait JoinExt {
    fn join_with<S: Into<String>>(self, separator: S) -> String;
}

Use std::iter

The iter module helps you getting rid of manually coded loops.

Bringing it together

You can now write one repetition extension for each type (String, &str and char):

use std::iter;

impl RepeatExt for &str {
    fn times(&self, n: usize) -> Vec<String> {
        iter::repeat((*self).to_string()).take(n).collect()
    }
}

impl RepeatExt for String {
    fn times(&self, n: usize) -> Vec<String> {
        iter::repeat(self.clone()).take(n).collect()
    }
}

impl RepeatExt for char {
    fn times(&self, n: usize) -> Vec<String> {
        iter::repeat((*self).to_string()).take(n).collect()
    }
}

and the Join for just String:

impl JoinExt for Vec<String> {
    fn join_with<S: Into<String>>(self, separator: S) -> String {
        self.join(&separator.into())
    }
}

Testing

All 9 combinations work for me:

fn main() {
    println!("{}", "?".times(3).join_with(','));
    println!("{}", "?".times(3).join_with(","));
    println!("{}", "?".times(3).join_with(",".to_string()));
    
    println!("{}", '?'.times(3).join_with(','));
    println!("{}", '?'.times(3).join_with(","));
    println!("{}", '?'.times(3).join_with(",".to_string()));
    
    println!("{}", "?".to_string().times(3).join_with(','));
    println!("{}", "?".to_string().times(3).join_with(","));
    println!("{}", "?".to_string().times(3).join_with(",".to_string()));
}

Try it on the Rust playground

Evaluation

Is there a way to (i) make the caller API not have to use StringOrChar::X()

I removed that completely.

and (ii) reduce the repeated code?

Well, the 3 repetition methods are still similar, but a lot of duplication was removed using the iteration module. All in all, that's just 33 lines of code, compared to your original 96 lines.

Disclaimer: this answer focuses on performance.

Avoid creating a String for format!

The format! macro does not preserve any of its arguments, and therefore any allocation made just to format are gratuitous and best avoided.

Therefore, rather than formatting a String and pass it to format, it would be more idiomatic to create an object which implements Display.

The simplest approach is to stick to a single object, and ignore violations the Single Responsibility Principle.

On the playground:

struct RepeatJoin<R, J> {
    count: usize,
    repeated: R,
    joiner: J,
}

impl<R, J> RepeatJoin<R, J> {
    fn new(count: usize, repeated: R, joiner: J) -> Self {
        Self { count, repeated, joiner }
    }
}

impl<R, J> Display for RepeatJoin<R, J>
where
    R: Display,
    J: Display
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
        let Some(count) = self.count.checked_sub(1) else {
            return Ok(());
        };
    
        write!(f, "{}", self.repeated)?;

        for _ in 0..count {
            write!(f, "{}", self.joiner)?;
            write!(f, "{}", self.repeated)?;
        }

        Ok(())
    }
}

Which allows you to write your query as:

    format!(
        r#"SELECT * FROM my_entities WHERE id IN ({})"#,
        RepeatJoin::new(ids.len(), '?', ',')
    )

And for which a single String will be allocated, which the performance conscious may even pre-allocate by using write!(&mut my_string, ...) instead.

Single Responsibility Principle

While one can see the repetition and join as two distinct operations, in this specific case I would just outright ignore the criticism.

Joiners only make sense in the context of repetitions, anyway.

Still, the abstraction can be split if one wishes to.

struct JoinDisplay<I, J> {
    iterator: I,
    joiner: J,
}

impl<I, J> JoinDisplay<I, J> {
    fn new(iterator: I, joiner: J) -> Self {
        Self { iterator, joiner }
    }
}

impl<I, J> Display for JoinDisplay<I, J>
where
    I: Clone + Iterator<Item: Display>,
    J: Display
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
        let iterator = self.iterator.clone();

        for (i, e) in iterator.enumerate() {
            if i > 0 {
                write!(f, "{}", self.joiner)?;
            }

            write!(f, "{e}")?;
        }

        Ok(())
    }
}

Your extension trait can be replaced by using the standard library and the well-known itertools crate:

use itertools::Itertools;
use std::iter::repeat;

fn main() {
    let hello_world = repeat("hello").take(3).join(" world ");
    println!("{hello_world}");
    let question_marks = repeat('?').take(3).join(",");
    println!("{question_marks}");
}

https://play.rust-lang.org/?version=stable&mode=debug&edition=2024&gist=70c9b59cead5b7c6ba21ced88d2e89e6

No custom extension trait is needed.

The only downside is, that Itertools::join requires the separator to be a &str, so you cannot pass in a char directly, but given your use case, YAGNI.