[−]Trait astral::thirdparty::rayon::prelude::ParallelString

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

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

    fn par_char_indices(&self) -> CharIndices { ... }

    fn par_bytes(&self) -> Bytes { ... }

    fn par_encode_utf16(&self) -> EncodeUtf16 { ... }

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

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

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

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

    fn par_matches<P>(&self, pattern: P) -> Matches<P>
    where
        P: Pattern,
    { ... }

    fn par_match_indices<P>(&self, pattern: P) -> MatchIndices<P>
    where
        P: Pattern,
    { ... }
}

Parallel extensions for strings.

Required methods

fn as_parallel_string(&self) -> &str

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

Loading content...

Provided methods

fn par_chars(&self) -> Chars

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);

fn par_char_indices(&self) -> CharIndices

Returns a parallel iterator over the characters of a string, with their positions.

Examples

use rayon::prelude::*;
let min = "hello".par_char_indices().min_by_key(|&(_i, c)| c as i32);
assert_eq!(Some((1, 'e')), min);

fn par_bytes(&self) -> Bytes

Returns a parallel iterator over the bytes of a string.

Note that multi-byte sequences (for code points greater than U+007F) are produced as separate items, but will not be split across threads. If you would prefer an indexed iterator without that guarantee, consider string.as_bytes().par_iter().cloned() instead.

Examples

use rayon::prelude::*;
let max = "hello".par_bytes().max();
assert_eq!(Some(b'o'), max);

fn par_encode_utf16(&self) -> EncodeUtf16

Returns a parallel iterator over a string encoded as UTF-16.

Note that surrogate pairs (for code points greater than U+FFFF) are produced as separate items, but will not be split across threads.

Examples

use rayon::prelude::*;

let max = "hello".par_encode_utf16().max();
assert_eq!(Some(b'o' as u16), max);

let text = "Zażółć gęślą jaźń";
let utf8_len = text.len();
let utf16_len = text.par_encode_utf16().count();
assert!(utf16_len <= utf8_len);

fn par_split<P>(&self, separator: P) -> Split<P> where
    P: Pattern, 

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);

fn par_split_terminator<P>(&self, terminator: P) -> SplitTerminator<P> where
    P: Pattern, 

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);

fn par_lines(&self) -> Lines

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);

fn par_split_whitespace(&self) -> SplitWhitespace

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);

fn par_matches<P>(&self, pattern: P) -> Matches<P> where
    P: Pattern, 

Returns a parallel iterator over substrings that match a given character or predicate, similar to str::matches.

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_matches(char::is_numeric)
   .map(|s| s.parse::<i32>().expect("digit"))
   .sum();
assert_eq!(10, total);

fn par_match_indices<P>(&self, pattern: P) -> MatchIndices<P> where
    P: Pattern, 

Returns a parallel iterator over substrings that match a given character or predicate, with their positions, similar to str::match_indices.

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 digits: Vec<_> = "1, 2, buckle, 3, 4, door"
   .par_match_indices(char::is_numeric)
   .collect();
assert_eq!(digits, vec![(0, "1"), (3, "2"), (14, "3"), (17, "4")]);
Loading content...

Implementations on Foreign Types

impl ParallelString for str[src]

fn par_chars(&self) -> Chars[src]

fn par_char_indices(&self) -> CharIndices[src]

fn par_bytes(&self) -> Bytes[src]

fn par_encode_utf16(&self) -> EncodeUtf16[src]

fn par_split<P>(&self, separator: P) -> Split<P> where
    P: Pattern, [src]

fn par_split_terminator<P>(&self, terminator: P) -> SplitTerminator<P> where
    P: Pattern, [src]

fn par_lines(&self) -> Lines[src]

fn par_split_whitespace(&self) -> SplitWhitespace[src]

fn par_matches<P>(&self, pattern: P) -> Matches<P> where
    P: Pattern, [src]

fn par_match_indices<P>(&self, pattern: P) -> MatchIndices<P> where
    P: Pattern, [src]

Loading content...

Implementors

Loading content...