Struct joinery::join::Join

#[must_use]
pub struct Join<C, S> { /* fields omitted */ }

The primary data structure for representing a joined sequence.

It contains a collection and a separator, and represents the elements of the collection with the separator dividing each element. A collection is defined as any type for which &T: IntoIterator; that is, any time for which references to the type are iterable.

A Join is created with Joinable::join_with, Separator::separate, or JoinableIterator::join_with. Its main use is an implementation of Display, which writes out the elements of the underlying collection, separated by the separator. It also implements IntoIterator, using a JoinIter.

Examples

Writing via Display:

use joinery::Joinable;
use std::fmt::Write;

let content = [1, 2, 3, 4, 5, 6, 7, 8, 9];
let join = content.join_with(", ");

let mut buffer = String::new();
write!(buffer, "Numbers: {}", join);

assert_eq!(buffer, "Numbers: 1, 2, 3, 4, 5, 6, 7, 8, 9");

// Don't forget that `Display` gives to `ToString` for free!
assert_eq!(join.to_string(), "1, 2, 3, 4, 5, 6, 7, 8, 9")

Iterating via IntoIterator:

use joinery::{Separator, JoinItem};

let content = [0, 1, 2];
let join = ", ".separate(content);
let mut join_iter = join.into_iter();

assert_eq!(join_iter.next(), Some(JoinItem::Element(&0)));
assert_eq!(join_iter.next(), Some(JoinItem::Separator(&", ")));
assert_eq!(join_iter.next(), Some(JoinItem::Element(&1)));
assert_eq!(join_iter.next(), Some(JoinItem::Separator(&", ")));
assert_eq!(join_iter.next(), Some(JoinItem::Element(&2)));
assert_eq!(join_iter.next(), None);

Methods

impl<C, S> Join<C, S>

pub fn sep(&self) -> &S

Get a reference to the separator.

pub fn collection(&self) -> &C

Get a reference to the underlying collection.

pub fn collection_mut(&mut self) -> &mut C

Get a mutable reference to the underlying collection

pub fn into_collection(self) -> C

Consume the join, and return the underlying collection.

pub fn into_parts(self) -> (C, S)

Consume self and return underlying collection and separator.

Trait Implementations

impl<C, S: Display> Display for Join<C, S> where
    &'a C: IntoIterator,
    <&'a C as IntoIterator>::Item: Display<'a>, 

fn fmt(&self, f: &mut Formatter) -> Result

Format the joined collection, by writing out each element of the collection, separated by the separator.

impl<C: Debug, S: Debug> Debug for Join<C, S>

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<C: PartialEq, S: PartialEq> PartialEq<Join<C, S>> for Join<C, S>

fn eq(&self, other: &Join<C, S>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Join<C, S>) -> bool

This method tests for !=.

impl<C: Eq, S: Eq> Eq for Join<C, S>

impl<C: IntoIterator, S: Clone> IntoIterator for Join<C, S>

type IntoIter = JoinIter<C::IntoIter, S>

Which kind of iterator are we turning this into?

type Item = JoinItem<C::Item, S>

The type of the elements being iterated over.

fn into_iter(self) -> Self::IntoIter

Create a consuming iterator from a Join. This iterator consumes the elements of the underlying collection, and intersperses them with clones of the separator. See the JoinIter documentation for more details.

impl<'a, C, S> IntoIterator for &'a Join<C, S> where
    &'a C: IntoIterator, 

type IntoIter = JoinIter<<&'a C as IntoIterator>::IntoIter, &'a S>

Which kind of iterator are we turning this into?

type Item = JoinItem<<&'a C as IntoIterator>::Item, &'a S>

The type of the elements being iterated over.

fn into_iter(self) -> Self::IntoIter

Create a referential iterator over the join. This iterator iterates over references to the underlying collection, interspersed with references to the separator. See the JoinIter documentation for more details.

impl<C: Clone, S: Clone> Clone for Join<C, S>

fn clone(&self) -> Join<C, S>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.