v0.3.1

- add `join` method

Author: daddinuz

Cargo.lock

@@ -2,7 +2,7 @@
 authors = ["Davide Di Carlo <[email protected]>"]
 description = "Extension traits for `String` and `&str` types."
 name = "string_more"
-version = "0.3.0"
+version = "0.3.1"
 edition = "2021"
 license = "MIT"
 keywords = ["String", "str", "extension", "in-place", "edit-distance"]

Cargo.toml

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2024 Davide Di Carlo
+Copyright (c) 2025 Davide Di Carlo
 
 Permission is hereby granted, free of charge, to any person
 obtaining a copy of this software and associated documentation

LICENSE

@@ -229,6 +229,13 @@ let s = "🦀";
 s.previous_char_boundary(2); // 0
 ```
 
+- **`join`**: Joins an iterator of items into a single `String`.
+
+```rust
+let result = ", ".join(["one", "two", "three"]);
+assert_eq!(result, "one, two, three");
+```
+
 ## Safety and Coverage
 
 This crate contains a small portion of unsafe code.

README.md

@@ -11,6 +11,7 @@
 //! - **Flexible and Efficient**: Designed to extend the standard string functionality without sacrificing performance.
 
 use std::collections::{BTreeMap, HashMap};
+use std::fmt::{Display, Write};
 use std::ops::Deref;
 
 mod sailed {
@@ -131,6 +132,14 @@ pub trait StrExt: sailed::Sailed {
     /// If index happens to be on a valid char boundary then index itself is returned.
     /// Note that both 0 and string's length are consedered valid char boundaries.
     fn previous_char_boundary(&self, index: usize) -> usize;
+
+    /// Joins an iterator of items into a single `String`, using `self` as the separator.
+    ///
+    /// Each item is formatted using the `Display` trait and concatenated with `self`
+    /// placed between consecutive items.
+    fn join<T: Display>(&self, iterable: impl IntoIterator<Item = T>) -> String
+    where
+        Self: Display;
 }
 
 /// The `StringExt` trait extends `String` with advanced in-place manipulation methods,
@@ -194,9 +203,9 @@ pub trait StringExt: StrExt {
     fn replace_in_place(&mut self, from: impl EncodeUtf8, to: impl EncodeUtf8);
 }
 
-impl<T> StrExt for T
+impl<S> StrExt for S
 where
-    T: sailed::Sailed + Deref<Target = str>,
+    S: sailed::Sailed + Deref<Target = str>,
 {
     fn fill_start(&self, fill: impl EncodeUtf8, times: usize) -> String {
         let mut buf = Default::default();
@@ -476,6 +485,22 @@ where
 
         index
     }
+
+    fn join<T: Display>(&self, iterable: impl IntoIterator<Item = T>) -> String
+    where
+        Self: Display,
+    {
+        let mut iter = iterable.into_iter();
+        let mut acc = String::new();
+
+        if let Some(value) = iter.next() {
+            write!(acc, "{value}").unwrap();
+            iter.try_for_each(|item| write!(acc, "{self}{item}"))
+                .unwrap();
+        }
+
+        acc
+    }
 }
 
 impl StringExt for String {
@@ -1380,4 +1405,34 @@ mod tests {
             assert_eq!(sut.longest_common_substring(other), expected);
         }
     }
+
+    #[test]
+    fn join_strings() {
+        let result = ", ".join(["one", "two", "three"]);
+        assert_eq!(result, "one, two, three");
+    }
+
+    #[test]
+    fn join_integers() {
+        let result = "-".join([1, 2, 3, 4]);
+        assert_eq!(result, "1-2-3-4");
+    }
+
+    #[test]
+    fn join_single_item() {
+        let result = "/".join(["only"]);
+        assert_eq!(result, "only");
+    }
+
+    #[test]
+    fn join_empty_iterator() {
+        let result = ";".join(std::iter::empty::<String>());
+        assert_eq!(result, "");
+    }
+
+    #[test]
+    fn join_non_ascii_strings() {
+        let result = "·".join(["Ā", "❤️", "Ȁ"]);
+        assert_eq!(result, "Ā·❤️·Ȁ");
+    }
 }