Trait rustc_rayon::str::ParallelString[−][src]

pub trait ParallelString {
    fn as_parallel_string(&self) -> &str;

    fn par_chars(&self) -> Chars { ... }

    fn par_split<P: Pattern>(&self, separator: P) -> Split<P> { ... }

    fn par_split_terminator<P: Pattern>(
        &self, 
        terminator: P
    ) -> SplitTerminator<P> { ... }

    fn par_lines(&self) -> Lines { ... }

    fn par_split_whitespace(&self) -> SplitWhitespace { ... }
}

Parallel extensions for strings.

Required Methods

Returns a plain string slice, which is used to implement the rest of the parallel methods.

Provided Methods

Returns a parallel iterator over the characters of a string.

Examples

use rayon::prelude::*;
let max = "hello".par_chars().max_by_key(|c| *c as i32);
assert_eq!(Some('o'), max);

Returns a parallel iterator over substrings separated by a given character or predicate, similar to str::split.

Note: the Pattern trait is private, for use only by Rayon itself. It is implemented for char and any F: Fn(char) -> bool + Sync + Send.

Examples

use rayon::prelude::*;
let total = "1, 2, buckle, 3, 4, door"
   .par_split(',')
   .filter_map(|s| s.trim().parse::<i32>().ok())
   .sum();
assert_eq!(10, total);

Returns a parallel iterator over substrings terminated by a given character or predicate, similar to str::split_terminator. It's equivalent to par_split, except it doesn't produce an empty substring after a trailing terminator.

Note: the Pattern trait is private, for use only by Rayon itself. It is implemented for char and any F: Fn(char) -> bool + Sync + Send.

Examples

use rayon::prelude::*;
let parts: Vec<_> = "((1 + 3) * 2)"
    .par_split_terminator(|c| c == '(' || c == ')')
    .collect();
assert_eq!(vec!["", "", "1 + 3", " * 2"], parts);

Returns a parallel iterator over the lines of a string, ending with an optional carriage return and with a newline (\r\n or just \n). The final line ending is optional, and line endings are not included in the output strings.

Examples

use rayon::prelude::*;
let lengths: Vec<_> = "hello world\nfizbuzz"
    .par_lines()
    .map(|l| l.len())
    .collect();
assert_eq!(vec![11, 7], lengths);

Returns a parallel iterator over the sub-slices of a string that are separated by any amount of whitespace.

As with str::split_whitespace, 'whitespace' is defined according to the terms of the Unicode Derived Core Property White_Space.

Examples

use rayon::prelude::*;
let longest = "which is the longest word?"
    .par_split_whitespace()
    .max_by_key(|word| word.len());
assert_eq!(Some("longest"), longest);

Implementations on Foreign Types

impl ParallelString for str
[src]

Implementors