Files
addr2line
adler
aho_corasick
arrayvec
atty
backtrace
backtrace
symbolize
bitflags
camino
cargo_metadata
cargo_nextest
cargo_platform
cfg_expr
cfg_if
chrono
format
naive
offset
sys
clap
build
app
arg
output
parse
util
clap_derive
derives
utils
color_eyre
config
crossbeam_channel
crossbeam_deque
crossbeam_epoch
crossbeam_utils
ctrlc
datatest_stable
debug_ignore
duct
either
enable_ansi_support
env_logger
filter
fmt
eyre
fixedbitset
gimli
read
guppy
graph
cargo
feature
petgraph_support
platform
guppy_workspace_hack
hashbrown
humantime
humantime_serde
indent_write
indenter
indexmap
is_ci
itertools
combinations.rscombinations_with_replacement.rsconcat_impl.rscons_tuples_impl.rsdiff.rsduplicates_impl.rseither_or_both.rsexactly_one_err.rsflatten_ok.rsformat.rsfree.rsgroup_map.rsgroupbylazy.rsgrouping_map.rsimpl_macros.rsintersperse.rsk_smallest.rskmerge_impl.rslazy_buffer.rslib.rsmerge_join.rsminmax.rsmultipeek_impl.rspad_tail.rspeek_nth.rspeeking_take_while.rspermutations.rspowerset.rsprocess_results_impl.rsput_back_n_impl.rsrciter_impl.rsrepeatn.rssize_hint.rssources.rstee.rstuple_impl.rsunique_impl.rsunziptuple.rswith_position.rszip_eq_impl.rszip_longest.rsziptuple.rs
itoa
lazy_static
lexical_core
atof
algorithm
atoi
float
ftoa
itoa
util
libc
unix
log
memchr
memchr
memmem
memoffset
miniz_oxide
nested
nextest_metadata
nextest_runner
nix
mount
net
sys
nom
bits
branch
bytes
character
combinator
multi
number
sequence
num_cpus
num_integer
num_traits
object
read
coff
elf
macho
pe
once_cell
os_pipe
os_str_bytes
owo_colors
pathdiff
petgraph
algo
graph_impl
visit
proc_macro2
proc_macro_error
proc_macro_error_attr
quick_junit
quick_xml
quote
rayon
collections
compile_fail
iter
chain.rschunks.rscloned.rscopied.rsempty.rsenumerate.rsextend.rsfilter.rsfilter_map.rsfind.rsflat_map.rsflat_map_iter.rsflatten.rsflatten_iter.rsfold.rsfor_each.rsfrom_par_iter.rsinspect.rsinterleave.rsinterleave_shortest.rsintersperse.rslen.rsmap.rsmap_with.rsmod.rsmultizip.rsnoop.rsonce.rspanic_fuse.rspar_bridge.rspositions.rsproduct.rsreduce.rsrepeat.rsrev.rsskip.rssplitter.rsstep_by.rssum.rstake.rstry_fold.rstry_reduce.rstry_reduce_with.rsunzip.rsupdate.rswhile_some.rszip.rszip_eq.rs
slice
rayon_core
compile_fail
join
scope
sleep
spawn
thread_pool
regex
regex_syntax
ast
hir
unicode_tables
rustc_demangle
ryu
same_file
scopeguard
semver
serde
de
private
ser
serde_derive
serde_json
shared_child
shellwords
smallvec
static_assertions
strip_ansi_escapes
strsim
structopt
structopt_derive
supports_color
syn
attr.rsawait.rsbigint.rsbuffer.rscustom_keyword.rscustom_punctuation.rsdata.rsderive.rsdiscouraged.rserror.rsexport.rsexpr.rsext.rsfile.rsgenerics.rsgroup.rsident.rsitem.rslib.rslifetime.rslit.rslookahead.rsmac.rsmacros.rsop.rsparse.rsparse_macro_input.rsparse_quote.rspat.rspath.rsprint.rspunctuated.rsreserved.rssealed.rsspan.rsspanned.rsstmt.rsthread.rstoken.rsty.rsverbatim.rswhitespace.rs
target_lexicon
target_spec
termcolor
textwrap
time
toml
twox_hash
unicode_xid
utf8parse
vte
vte_generate_state_changes
walkdir
>
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68
use crate::iter::plumbing::*;
use crate::iter::*;
/// Creates a parallel iterator that produces an element exactly once.
///
/// This admits no parallelism on its own, but it could be chained to existing
/// parallel iterators to extend their contents, or otherwise used for any code
/// that deals with generic parallel iterators.
///
/// # Examples
///
/// ```
/// use rayon::prelude::*;
/// use rayon::iter::once;
///
/// let pi = (0..1234).into_par_iter()
/// .chain(once(-1))
/// .chain(1234..10_000);
///
/// assert_eq!(pi.clone().count(), 10_001);
/// assert_eq!(pi.clone().filter(|&x| x < 0).count(), 1);
/// assert_eq!(pi.position_any(|x| x < 0), Some(1234));
/// ```
pub fn once<T: Send>(item: T) -> Once<T> {
Once { item }
}
/// Iterator adaptor for [the `once()` function](fn.once.html).
#[derive(Clone, Debug)]
pub struct Once<T: Send> {
item: T,
}
impl<T: Send> ParallelIterator for Once<T> {
type Item = T;
fn drive_unindexed<C>(self, consumer: C) -> C::Result
where
C: UnindexedConsumer<Self::Item>,
{
self.drive(consumer)
}
fn opt_len(&self) -> Option<usize> {
Some(1)
}
}
impl<T: Send> IndexedParallelIterator for Once<T> {
fn drive<C>(self, consumer: C) -> C::Result
where
C: Consumer<Self::Item>,
{
consumer.into_folder().consume(self.item).complete()
}
fn len(&self) -> usize {
1
}
fn with_producer<CB>(self, callback: CB) -> CB::Output
where
CB: ProducerCallback<Self::Item>,
{
// Let `OptionProducer` handle it.
Some(self.item).into_par_iter().with_producer(callback)
}
}