SYMBOL INDEX (3282 symbols across 173 files) FILE: ci/alt-core/build.rs function main (line 1) | fn main() {} FILE: ci/highlander/src/main.rs function main (line 1) | fn main() {} FILE: rayon-core/build.rs function main (line 4) | fn main() { FILE: rayon-core/src/broadcast/mod.rs function broadcast (line 19) | pub fn broadcast(op: OP) -> Vec function spawn_broadcast (line 36) | pub fn spawn_broadcast(op: OP) type BroadcastContext (line 45) | pub struct BroadcastContext<'a> { function with (line 53) | pub(super) fn with(f: impl FnOnce(BroadcastContext<'_>) -> R) -> R { function index (line 64) | pub fn index(&self) -> usize { function num_threads (line 76) | pub fn num_threads(&self) -> usize { function fmt (line 82) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { function broadcast_in (line 97) | pub(super) unsafe fn broadcast_in(op: OP, registry: &Arc(op: OP, registry: &Arc { type Job (line 20) | pub(super) trait Job { method execute (line 24) | unsafe fn execute(this: *const ()); method execute (line 116) | unsafe fn execute(this: *const ()) { method execute (line 167) | unsafe fn execute(this: *const ()) { method execute (line 210) | unsafe fn execute(this: *const ()) { method execute (line 259) | unsafe fn execute(this: *const ()) { type JobRef (line 33) | pub(super) struct JobRef { method new (line 44) | pub(super) unsafe fn new(data: *const T) -> JobRef method id (line 58) | pub(super) fn id(&self) -> impl Eq { method execute (line 63) | pub(super) unsafe fn execute(self) { type StackJob (line 72) | pub(super) struct StackJob function new (line 89) | pub(super) fn new(func: F, latch: L) -> StackJob { function as_job_ref (line 97) | pub(super) unsafe fn as_job_ref(&self) -> JobRef { function run_inline (line 101) | pub(super) unsafe fn run_inline(self, stolen: bool) -> R { function into_result (line 105) | pub(super) unsafe fn into_result(self) -> R { type HeapJob (line 132) | pub(super) struct HeapJob function new (line 143) | pub(super) fn new(job: BODY) -> Box { function into_job_ref (line 150) | pub(super) unsafe fn into_job_ref(self: Box) -> JobRef { function into_static_job_ref (line 155) | pub(super) fn into_static_job_ref(self: Box) -> JobRef type ArcJob (line 175) | pub(super) struct ArcJob function new (line 186) | pub(super) fn new(job: BODY) -> Arc { function as_job_ref (line 193) | pub(super) unsafe fn as_job_ref(this: &Arc) -> JobRef { function as_static_job_ref (line 198) | pub(super) fn as_static_job_ref(this: &Arc) -> JobRef function call (line 217) | fn call(func: impl FnOnce(bool) -> T) -> Self { function into_return_value (line 228) | pub(super) fn into_return_value(self) -> T { type JobFifo (line 238) | pub(super) struct JobFifo { method new (line 243) | pub(super) fn new() -> Self { method push (line 249) | pub(super) unsafe fn push(&self, job_ref: JobRef) -> JobRef { FILE: rayon-core/src/join/mod.rs function join (line 93) | pub fn join(oper_a: A, oper_b: B) -> (RA, RB) function join_context (line 115) | pub fn join_context(oper_a: A, oper_b: B) -> (RA, RB) function join_recover_from_panic (line 179) | unsafe fn join_recover_from_panic( FILE: rayon-core/src/join/test.rs function quick_sort (line 9) | fn quick_sort(v: &mut [T]) { function partition (line 19) | fn partition(v: &mut [T]) -> usize { function seeded_rng (line 32) | fn seeded_rng() -> XorShiftRng { function sort (line 39) | fn sort() { function sort_in_pool (line 50) | fn sort_in_pool() { function panic_propagate_a (line 63) | fn panic_propagate_a() { function panic_propagate_b (line 69) | fn panic_propagate_b() { function panic_propagate_both (line 75) | fn panic_propagate_both() { function panic_b_still_executes (line 81) | fn panic_b_still_executes() { function join_context_both (line 91) | fn join_context_both() { function join_context_neither (line 100) | fn join_context_neither() { function join_context_second (line 111) | fn join_context_second() { function join_counter_overflow (line 135) | fn join_counter_overflow() { FILE: rayon-core/src/latch.rs type Latch (line 35) | pub(super) trait Latch { method set (line 50) | unsafe fn set(this: *const Self); method set (line 196) | unsafe fn set(this: *const Self) { method set (line 262) | unsafe fn set(this: *const Self) { method set (line 405) | unsafe fn set(this: *const Self) { method set (line 454) | unsafe fn set(this: *const Self) { type AsCoreLatch (line 53) | pub(super) trait AsCoreLatch { method as_core_latch (line 54) | fn as_core_latch(&self) -> &CoreLatch; method as_core_latch (line 140) | fn as_core_latch(&self) -> &CoreLatch { method as_core_latch (line 189) | fn as_core_latch(&self) -> &CoreLatch { method as_core_latch (line 310) | fn as_core_latch(&self) -> &CoreLatch { constant UNSET (line 58) | const UNSET: usize = 0; constant SLEEPY (line 62) | const SLEEPY: usize = 1; constant SLEEPING (line 66) | const SLEEPING: usize = 2; constant SET (line 69) | const SET: usize = 3; type CoreLatch (line 75) | pub(super) struct CoreLatch { method new (line 81) | fn new() -> Self { method get_sleepy (line 91) | pub(super) fn get_sleepy(&self) -> bool { method fall_asleep (line 101) | pub(super) fn fall_asleep(&self) -> bool { method wake_up (line 111) | pub(super) fn wake_up(&self) { method set (line 126) | unsafe fn set(this: *const Self) -> bool { method probe (line 133) | pub(super) fn probe(&self) -> bool { type SpinLatch (line 148) | pub(super) struct SpinLatch<'r> { function new (line 161) | pub(super) fn new(thread: &'r WorkerThread) -> SpinLatch<'r> { function cross (line 174) | pub(super) fn cross(thread: &'r WorkerThread) -> SpinLatch<'r> { function probe (line 182) | pub(super) fn probe(&self) -> bool { type LockLatch (line 228) | pub(super) struct LockLatch { method new (line 235) | pub(super) const fn new() -> LockLatch { method wait_and_reset (line 243) | pub(super) fn wait_and_reset(&self) { method wait (line 252) | pub(super) fn wait(&self) { type OnceLatch (line 282) | pub(super) struct OnceLatch { method new (line 288) | pub(super) fn new() -> OnceLatch { method set_and_tickle_one (line 297) | pub(super) unsafe fn set_and_tickle_one( type CountLatch (line 321) | pub(super) struct CountLatch { method new (line 360) | pub(super) fn new(owner: Option<&WorkerThread>) -> Self { method with_count (line 364) | pub(super) fn with_count(count: usize, owner: Option<&WorkerThread>) -... method increment (line 381) | pub(super) fn increment(&self) { method wait (line 386) | pub(super) fn wait(&self, owner: Option<&WorkerThread>) { type CountLatchKind (line 326) | enum CountLatchKind { method fmt (line 347) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { type LatchRef (line 427) | pub(super) struct LatchRef<'a, L> { function new (line 433) | pub(super) fn new(inner: &L) -> LatchRef<'_, L> { type Target (line 444) | type Target = L; method deref (line 446) | fn deref(&self) -> &L { FILE: rayon-core/src/lib.rs function max_num_threads (line 113) | pub fn max_num_threads() -> usize { function current_num_threads (line 136) | pub fn current_num_threads() -> usize { type ThreadPoolBuildError (line 142) | pub struct ThreadPoolBuildError { method new (line 741) | fn new(kind: ErrorKind) -> ThreadPoolBuildError { method is_unsupported (line 745) | fn is_unsupported(&self) -> bool { method fmt (line 775) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { type ErrorKind (line 147) | enum ErrorKind { type ThreadPoolBuilder (line 170) | pub struct ThreadPoolBuilder { method new (line 244) | pub fn new() -> Self { method build_scoped (line 322) | pub fn build_scoped(self, wrapper: W, with_pool: F) -> Result... type Configuration (line 207) | pub struct Configuration { method new (line 669) | pub fn new() -> Configuration { method build (line 676) | pub fn build(self) -> Result> { method thread_name (line 681) | pub fn thread_name(mut self, closure: F) -> Self method num_threads (line 690) | pub fn num_threads(mut self, num_threads: usize) -> Configuration { method panic_handler (line 696) | pub fn panic_handler(mut self, panic_handler: H) -> Configuration method stack_size (line 705) | pub fn stack_size(mut self, stack_size: usize) -> Self { method breadth_first (line 711) | pub fn breadth_first(mut self) -> Self { method start_handler (line 717) | pub fn start_handler(mut self, start_handler: H) -> Configuration method exit_handler (line 726) | pub fn exit_handler(mut self, exit_handler: H) -> Configuration method into_builder (line 735) | fn into_builder(self) -> ThreadPoolBuilder { method fmt (line 833) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { type PanicHandler (line 213) | type PanicHandler = dyn Fn(Box) + Send + Sync; type StartHandler (line 218) | type StartHandler = dyn Fn(usize) + Send + Sync; type ExitHandler (line 223) | type ExitHandler = dyn Fn(usize) + Send + Sync; method default (line 227) | fn default() -> Self { function build (line 256) | pub fn build(self) -> Result { function build_global (line 277) | pub fn build_global(self) -> Result<(), ThreadPoolBuildError> { function spawn_handler (line 433) | pub fn spawn_handler(self, spawn: F) -> ThreadPoolBuilder &mut S { function get_num_threads (line 458) | fn get_num_threads(&self) -> usize { function get_thread_name (line 489) | fn get_thread_name(&mut self, index: usize) -> Option { function thread_name (line 496) | pub fn thread_name(mut self, closure: F) -> Self function num_threads (line 529) | pub fn num_threads(mut self, num_threads: usize) -> Self { function use_current_thread (line 547) | pub fn use_current_thread(mut self) -> Self { function take_panic_handler (line 553) | fn take_panic_handler(&mut self) -> Option> { function panic_handler (line 571) | pub fn panic_handler(mut self, panic_handler: H) -> Self function get_stack_size (line 580) | fn get_stack_size(&self) -> Option { function stack_size (line 585) | pub fn stack_size(mut self, stack_size: usize) -> Self { function breadth_first (line 618) | pub fn breadth_first(mut self) -> Self { function get_breadth_first (line 623) | fn get_breadth_first(&self) -> bool { function take_start_handler (line 628) | fn take_start_handler(&mut self) -> Option> { function start_handler (line 638) | pub fn start_handler(mut self, start_handler: H) -> Self function take_exit_handler (line 647) | fn take_exit_handler(&mut self) -> Option> { function exit_handler (line 657) | pub fn exit_handler(mut self, exit_handler: H) -> Self constant GLOBAL_POOL_ALREADY_INITIALIZED (line 750) | const GLOBAL_POOL_ALREADY_INITIALIZED: &str = constant CURRENT_THREAD_ALREADY_IN_POOL (line 753) | const CURRENT_THREAD_ALREADY_IN_POOL: &str = method description (line 758) | fn description(&self) -> &str { method source (line 766) | fn source(&self) -> Option<&(dyn Error + 'static)> { function initialize (line 787) | pub fn initialize(config: Configuration) -> Result<(), Box> { function fmt (line 792) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { type FnContext (line 840) | pub struct FnContext { method new (line 849) | fn new(migrated: bool) -> Self { method migrated (line 861) | pub fn migrated(&self) -> bool { FILE: rayon-core/src/private.rs type PrivateMarker (line 9) | pub struct PrivateMarker; FILE: rayon-core/src/registry.rs type ThreadBuilder (line 22) | pub struct ThreadBuilder { method index (line 33) | pub fn index(&self) -> usize { method name (line 38) | pub fn name(&self) -> Option<&str> { method stack_size (line 43) | pub fn stack_size(&self) -> Option { method run (line 49) | pub fn run(self) { method fmt (line 55) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { type ThreadSpawn (line 69) | pub trait ThreadSpawn { method spawn (line 74) | fn spawn(&mut self, thread: ThreadBuilder) -> io::Result<()>; method spawn (line 87) | fn spawn(&mut self, thread: ThreadBuilder) -> io::Result<()> { method spawn (line 123) | fn spawn(&mut self, thread: ThreadBuilder) -> io::Result<()> { type DefaultSpawn (line 82) | pub struct DefaultSpawn; type CustomSpawn (line 105) | pub struct CustomSpawn(F); function new (line 111) | pub(super) fn new(spawn: F) -> Self { type Registry (line 128) | pub(super) struct Registry { method new (line 239) | pub(super) fn new( method current (line 324) | pub(super) fn current() -> Arc { method current_num_threads (line 339) | pub(super) fn current_num_threads() -> usize { method current_thread (line 351) | pub(super) fn current_thread(&self) -> Option<&WorkerThread> { method id (line 363) | pub(super) fn id(&self) -> RegistryId { method num_threads (line 371) | pub(super) fn num_threads(&self) -> usize { method catch_unwind (line 375) | pub(super) fn catch_unwind(&self, f: impl FnOnce()) { method wait_until_primed (line 390) | pub(super) fn wait_until_primed(&self) { method wait_until_stopped (line 399) | pub(super) fn wait_until_stopped(&self) { method inject_or_push (line 414) | pub(super) fn inject_or_push(&self, job_ref: JobRef) { method inject (line 428) | pub(super) fn inject(&self, injected_job: JobRef) { method has_injected_job (line 446) | fn has_injected_job(&self) -> bool { method pop_injected_job (line 450) | fn pop_injected_job(&self) -> Option { method inject_broadcast (line 465) | pub(super) fn inject_broadcast(&self, injected_jobs: impl ExactSizeIte... method in_worker (line 496) | pub(super) fn in_worker(&self, op: OP) -> R method in_worker_cold (line 517) | unsafe fn in_worker_cold(&self, op: OP) -> R method in_worker_cross (line 543) | unsafe fn in_worker_cross(&self, current_thread: &WorkerThread,... method increment_terminate_count (line 585) | pub(super) fn increment_terminate_count(&self) { method terminate (line 594) | pub(super) fn terminate(&self) { method notify_worker_latch_is_set (line 603) | pub(super) fn notify_worker_latch_is_set(&self, target_worker_index: u... function global_registry (line 162) | pub(super) fn global_registry() -> &'static Arc { function init_global_registry (line 176) | pub(super) fn init_global_registry( function set_global_registry (line 187) | fn set_global_registry(registry: F) -> Result<&'static Arc,... function default_global_registry (line 209) | fn default_global_registry() -> Result, ThreadPoolBuildErr... type Terminator (line 230) | struct Terminator<'a>(&'a Arc); method drop (line 233) | fn drop(&mut self) { type RegistryId (line 609) | pub(super) struct RegistryId { type ThreadInfo (line 613) | struct ThreadInfo { method new (line 634) | fn new(stealer: Stealer) -> ThreadInfo { type WorkerThread (line 647) | pub(super) struct WorkerThread { method from (line 675) | fn from(thread: ThreadBuilder) -> Self { method current (line 702) | pub(super) fn current() -> *const WorkerThread { method set_current (line 708) | unsafe fn set_current(thread: *const WorkerThread) { method registry (line 717) | pub(super) fn registry(&self) -> &Arc { method index (line 723) | pub(super) fn index(&self) -> usize { method push (line 728) | pub(super) unsafe fn push(&self, job: JobRef) { method push_fifo (line 735) | pub(super) unsafe fn push_fifo(&self, job: JobRef) { method local_deque_is_empty (line 740) | pub(super) fn local_deque_is_empty(&self) -> bool { method take_local_job (line 749) | pub(super) fn take_local_job(&self) -> Option { method has_injected_job (line 765) | fn has_injected_job(&self) -> bool { method wait_until (line 772) | pub(super) unsafe fn wait_until(&self, latch:... method wait_until_cold (line 780) | unsafe fn wait_until_cold(&self, latch: &CoreLatch) { method wait_until_out_of_work (line 819) | unsafe fn wait_until_out_of_work(&self) { method find_work (line 833) | fn find_work(&self) -> Option { method yield_now (line 844) | pub(super) fn yield_now(&self) -> Yield { method yield_local (line 854) | pub(super) fn yield_local(&self) -> Yield { method execute (line 865) | pub(super) unsafe fn execute(&self, job: JobRef) { method steal (line 873) | fn steal(&self) -> Option { method drop (line 688) | fn drop(&mut self) { function main_loop (line 910) | unsafe fn main_loop(thread: ThreadBuilder) { function in_worker (line 946) | pub(super) fn in_worker(op: OP) -> R type XorShift64Star (line 968) | struct XorShift64Star { method new (line 973) | fn new() -> Self { method next (line 988) | fn next(&self) -> u64 { method next_usize (line 999) | fn next_usize(&self, n: usize) -> usize { FILE: rayon-core/src/scope/mod.rs type Scope (line 24) | pub struct Scope<'scope> { type ScopeFifo (line 31) | pub struct ScopeFifo<'scope> { type ScopeBase (line 36) | struct ScopeBase<'scope> { function scope (line 277) | pub fn scope<'scope, OP, R>(op: OP) -> R function scope_fifo (line 366) | pub fn scope_fifo<'scope, OP, R>(op: OP) -> R function in_place_scope (line 398) | pub fn in_place_scope<'scope, OP, R>(op: OP) -> R function do_in_place_scope (line 405) | pub(crate) fn do_in_place_scope<'scope, OP, R>(registry: Option<&Arc(op: OP) -> R function do_in_place_scope_fifo (line 456) | pub(crate) fn do_in_place_scope_fifo<'scope, OP, R>(registry: Option<&Ar... function new (line 466) | fn new(owner: Option<&WorkerThread>, registry: Option<&Arc>) -... function spawn (line 523) | pub fn spawn(&self, body: BODY) function spawn_broadcast (line 545) | pub fn spawn_broadcast(&self, body: BODY) function new (line 562) | fn new(owner: Option<&WorkerThread>, registry: Option<&Arc>) -... function spawn_fifo (line 582) | pub fn spawn_fifo(&self, body: BODY) function spawn_broadcast (line 610) | pub fn spawn_broadcast(&self, body: BODY) function new (line 628) | fn new(owner: Option<&WorkerThread>, registry: Option<&Arc>) -... function heap_job_ref (line 642) | fn heap_job_ref(&self, job: Box>) -> JobRef function inject_broadcast (line 652) | fn inject_broadcast(&self, job: Arc>) function complete (line 667) | fn complete(&self, owner: Option<&WorkerThread>, func: FUNC) -> R function execute_job (line 679) | unsafe fn execute_job(this: *const Self, func: FUNC) function execute_job_closure (line 689) | unsafe fn execute_job_closure(this: *const Self, func: FUNC) ->... function job_panicked (line 704) | fn job_panicked(&self, err: Box) { function maybe_propagate_panic (line 723) | fn maybe_propagate_panic(&self) { function fmt (line 736) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { function fmt (line 746) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { type ScopePtr (line 760) | struct ScopePtr(*const T); function as_ref (line 770) | unsafe fn as_ref(&self) -> &T { FILE: rayon-core/src/scope/test.rs function scope_empty (line 12) | fn scope_empty() { function scope_result (line 17) | fn scope_result() { function scope_two (line 23) | fn scope_two() { function scope_divide_and_conquer (line 39) | fn scope_divide_and_conquer() { function divide_and_conquer (line 51) | fn divide_and_conquer<'scope>(scope: &Scope<'scope>, counter: &'scope At... function divide_and_conquer_seq (line 61) | fn divide_and_conquer_seq(counter: &AtomicUsize, size: usize) { type Tree (line 71) | struct Tree { function iter (line 77) | fn iter(&self) -> vec::IntoIter<&T> { function update (line 84) | fn update(&mut self, op: OP) function update_in_scope (line 92) | fn update_in_scope<'scope, OP>(&'scope mut self, op: &'scope OP, scope: ... function random_tree (line 110) | fn random_tree(depth: usize) -> Tree { function random_tree1 (line 118) | fn random_tree1(depth: usize, rng: &mut XorShiftRng) -> Tree { function update_tree (line 134) | fn update_tree() { function linear_stack_growth (line 151) | fn linear_stack_growth() { function the_final_countdown (line 171) | fn the_final_countdown<'scope>( function panic_propagate_scope (line 192) | fn panic_propagate_scope() { function panic_propagate_spawn (line 198) | fn panic_propagate_spawn() { function panic_propagate_nested_spawn (line 204) | fn panic_propagate_nested_spawn() { function panic_propagate_nested_scope_spawn (line 210) | fn panic_propagate_nested_scope_spawn() { function panic_propagate_still_execute_1 (line 216) | fn panic_propagate_still_execute_1() { function panic_propagate_still_execute_2 (line 232) | fn panic_propagate_still_execute_2() { function panic_propagate_still_execute_3 (line 248) | fn panic_propagate_still_execute_3() { function panic_propagate_still_execute_4 (line 264) | fn panic_propagate_still_execute_4() { function lifo_order (line 303) | fn lifo_order() { function fifo_order (line 312) | fn fifo_order() { function nested_lifo_order (line 347) | fn nested_lifo_order() { function nested_fifo_order (line 356) | fn nested_fifo_order() { function nested_lifo_fifo_order (line 365) | fn nested_lifo_fifo_order() { function nested_fifo_lifo_order (line 377) | fn nested_fifo_lifo_order() { function mixed_lifo_order (line 420) | fn mixed_lifo_order() { function mixed_fifo_order (line 430) | fn mixed_fifo_order() { function mixed_lifo_fifo_order (line 438) | fn mixed_lifo_fifo_order() { function mixed_fifo_lifo_order (line 448) | fn mixed_fifo_lifo_order() { function static_scope (line 455) | fn static_scope() { function static_scope_fifo (line 477) | fn static_scope_fifo() { function mixed_lifetime_scope (line 499) | fn mixed_lifetime_scope() { function mixed_lifetime_scope_fifo (line 517) | fn mixed_lifetime_scope_fifo() { function scope_spawn_broadcast (line 535) | fn scope_spawn_broadcast() { function scope_fifo_spawn_broadcast (line 547) | fn scope_fifo_spawn_broadcast() { function scope_spawn_broadcast_nested (line 559) | fn scope_spawn_broadcast_nested() { function scope_spawn_broadcast_barrier (line 574) | fn scope_spawn_broadcast_barrier() { function scope_spawn_broadcast_panic_one (line 587) | fn scope_spawn_broadcast_panic_one() { function scope_spawn_broadcast_panic_many (line 606) | fn scope_spawn_broadcast_panic_many() { FILE: rayon-core/src/sleep/counters.rs type AtomicCounters (line 3) | pub(super) struct AtomicCounters { method new (line 91) | pub(super) fn new() -> AtomicCounters { method load (line 101) | pub(super) fn load(&self, ordering: Ordering) -> Counters { method try_exchange (line 106) | fn try_exchange(&self, old_value: Counters, new_value: Counters, order... method add_inactive_thread (line 120) | pub(super) fn add_inactive_thread(&self) { method increment_jobs_event_counter_if (line 128) | pub(super) fn increment_jobs_event_counter_if( method sub_inactive_thread (line 151) | pub(super) fn sub_inactive_thread(&self) -> usize { method sub_sleeping_thread (line 176) | pub(super) fn sub_sleeping_thread(&self) { method try_add_sleeping_thread (line 192) | pub(super) fn try_add_sleeping_thread(&self, old_value: Counters) -> b... type Counters (line 19) | pub(super) struct Counters { method new (line 221) | fn new(word: usize) -> Counters { method increment_jobs_counter (line 226) | fn increment_jobs_counter(self) -> Counters { method jobs_counter (line 235) | pub(super) fn jobs_counter(self) -> JobsEventCounter { method inactive_threads (line 242) | pub(super) fn inactive_threads(self) -> usize { method awake_but_idle_threads (line 247) | pub(super) fn awake_but_idle_threads(self) -> usize { method sleeping_threads (line 258) | pub(super) fn sleeping_threads(self) -> usize { method fmt (line 264) | fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { type JobsEventCounter (line 27) | pub(super) struct JobsEventCounter(usize); constant DUMMY (line 30) | pub(super) const DUMMY: JobsEventCounter = JobsEventCounter(usize::MAX); method as_usize (line 33) | pub(super) fn as_usize(self) -> usize { method is_sleepy (line 42) | pub(super) fn is_sleepy(self) -> bool { method is_active (line 50) | pub(super) fn is_active(self) -> bool { constant THREADS_BITS (line 57) | const THREADS_BITS: usize = 16; constant THREADS_BITS (line 60) | const THREADS_BITS: usize = 8; constant SLEEPING_SHIFT (line 65) | const SLEEPING_SHIFT: usize = 0 * THREADS_BITS; constant INACTIVE_SHIFT (line 70) | const INACTIVE_SHIFT: usize = 1 * THREADS_BITS; constant JEC_SHIFT (line 74) | const JEC_SHIFT: usize = 2 * THREADS_BITS; constant THREADS_MAX (line 77) | pub(crate) const THREADS_MAX: usize = (1 << THREADS_BITS) - 1; constant ONE_SLEEPING (line 80) | const ONE_SLEEPING: usize = 1; constant ONE_INACTIVE (line 84) | const ONE_INACTIVE: usize = 1 << INACTIVE_SHIFT; constant ONE_JEC (line 87) | const ONE_JEC: usize = 1 << JEC_SHIFT; function select_thread (line 210) | fn select_thread(word: usize, shift: usize) -> usize { function select_jec (line 215) | fn select_jec(word: usize) -> usize { FILE: rayon-core/src/sleep/mod.rs type Sleep (line 21) | pub(super) struct Sleep { method new (line 60) | pub(super) fn new(n_threads: usize) -> Sleep { method start_looking (line 69) | pub(super) fn start_looking(&self, worker_index: usize) -> IdleState { method work_found (line 80) | pub(super) fn work_found(&self) { method no_work_found (line 88) | pub(super) fn no_work_found( method announce_sleepy (line 111) | fn announce_sleepy(&self) -> JobsEventCounter { method sleep (line 118) | fn sleep( method notify_worker_latch_is_set (line 200) | pub(super) fn notify_worker_latch_is_set(&self, target_worker_index: u... method new_injected_jobs (line 214) | pub(super) fn new_injected_jobs(&self, num_jobs: u32, queue_was_empty:... method new_internal_jobs (line 236) | pub(super) fn new_internal_jobs(&self, num_jobs: u32, queue_was_empty:... method new_jobs (line 242) | fn new_jobs(&self, num_jobs: u32, queue_was_empty: bool) { method wake_any_threads (line 275) | fn wake_any_threads(&self, mut num_to_wake: u32) { method wake_specific_thread (line 288) | fn wake_specific_thread(&self, index: usize) -> bool { type IdleState (line 34) | pub(super) struct IdleState { method wake_fully (line 315) | fn wake_fully(&mut self) { method wake_partly (line 320) | fn wake_partly(&mut self) { type WorkerSleepState (line 48) | struct WorkerSleepState { constant ROUNDS_UNTIL_SLEEPY (line 56) | const ROUNDS_UNTIL_SLEEPY: u32 = 32; constant ROUNDS_UNTIL_SLEEPING (line 57) | const ROUNDS_UNTIL_SLEEPING: u32 = ROUNDS_UNTIL_SLEEPY + 1; FILE: rayon-core/src/spawn/mod.rs function spawn (line 58) | pub fn spawn(func: F) function spawn_in (line 69) | pub(super) unsafe fn spawn_in(func: F, registry: &Arc) function spawn_job (line 84) | unsafe fn spawn_job(func: F, registry: &Arc) -> JobRef function spawn_fifo (line 130) | pub fn spawn_fifo(func: F) function spawn_fifo_in (line 141) | pub(super) unsafe fn spawn_fifo_in(func: F, registry: &Arc) FILE: rayon-core/src/spawn/test.rs function spawn_then_join_in_worker (line 11) | fn spawn_then_join_in_worker() { function spawn_then_join_outside_worker (line 21) | fn spawn_then_join_outside_worker() { function panic_fwd (line 29) | fn panic_fwd() { function termination_while_things_are_executing (line 61) | fn termination_while_things_are_executing() { function custom_panic_handler_and_spawn (line 88) | fn custom_panic_handler_and_spawn() { function custom_panic_handler_and_nested_spawn (line 116) | fn custom_panic_handler_and_nested_spawn() { function lifo_order (line 175) | fn lifo_order() { function fifo_order (line 184) | fn fifo_order() { function lifo_fifo_order (line 193) | fn lifo_fifo_order() { function fifo_lifo_order (line 205) | fn fifo_lifo_order() { function mixed_lifo_fifo_order (line 243) | fn mixed_lifo_fifo_order() { function mixed_fifo_lifo_order (line 251) | fn mixed_fifo_lifo_order() { FILE: rayon-core/src/test.rs function worker_thread_index (line 9) | fn worker_thread_index() { function start_callback_called (line 19) | fn start_callback_called() { function exit_callback_called (line 46) | fn exit_callback_called() { function handler_panics_handled_correctly (line 76) | fn handler_panics_handled_correctly() { function check_config_build (line 127) | fn check_config_build() { function _send_sync (line 133) | fn _send_sync() {} function check_error_send_sync (line 136) | fn check_error_send_sync() { function configuration (line 143) | fn configuration() { function default_pool (line 164) | fn default_pool() { function cleared_current_thread (line 173) | fn cleared_current_thread() -> Result<(), ThreadPoolBuildError> { FILE: rayon-core/src/thread_pool/mod.rs type ThreadPool (line 46) | pub struct ThreadPool { method new (line 54) | pub fn new(configuration: crate::Configuration) -> Result( method install (line 137) | pub fn install(&self, op: OP) -> R method broadcast (line 187) | pub fn broadcast(&self, op: OP) -> Vec method current_num_threads (line 207) | pub fn current_num_threads(&self) -> usize { method current_thread_index (line 232) | pub fn current_thread_index(&self) -> Option { method current_thread_has_pending_tasks (line 259) | pub fn current_thread_has_pending_tasks(&self) -> Option { method join (line 267) | pub fn join(&self, oper_a: A, oper_b: B) -> (RA, RB) method scope (line 283) | pub fn scope<'scope, OP, R>(&self, op: OP) -> R method scope_fifo (line 298) | pub fn scope_fifo<'scope, OP, R>(&self, op: OP) -> R method in_place_scope (line 311) | pub fn in_place_scope<'scope, OP, R>(&self, op: OP) -> R method in_place_scope_fifo (line 323) | pub fn in_place_scope_fifo<'scope, OP, R>(&self, op: OP) -> R method spawn (line 338) | pub fn spawn(&self, op: OP) method spawn_fifo (line 354) | pub fn spawn_fifo(&self, op: OP) method spawn_broadcast (line 366) | pub fn spawn_broadcast(&self, op: OP) method yield_now (line 381) | pub fn yield_now(&self) -> Option { method yield_local (line 393) | pub fn yield_local(&self) -> Option { method fmt (line 406) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { method drop (line 400) | fn drop(&mut self) { function current_thread_index (line 438) | pub fn current_thread_index() -> Option { function current_thread_has_pending_tasks (line 452) | pub fn current_thread_has_pending_tasks() -> Option { function yield_now (line 471) | pub fn yield_now() -> Option { function yield_local (line 488) | pub fn yield_local() -> Option { type Yield (line 497) | pub enum Yield { FILE: rayon-core/src/thread_pool/test.rs function panic_propagate (line 11) | fn panic_propagate() { function workers_stop (line 20) | fn workers_stop() { function join_a_lot (line 40) | fn join_a_lot(n: usize) { function sleeper_stop (line 48) | fn sleeper_stop() { function count_handler (line 68) | fn count_handler() -> (Arc, impl Fn(usize)) { function wait_for_counter (line 76) | fn wait_for_counter(mut counter: Arc) -> usize { function failed_thread_stack (line 95) | fn failed_thread_stack() { function panic_thread_name (line 122) | fn panic_thread_name() { function self_install (line 147) | fn self_install() { function mutual_install (line 156) | fn mutual_install() { function mutual_install_sleepy (line 176) | fn mutual_install_sleepy() { function check_thread_pool_new (line 205) | fn check_thread_pool_new() { function scope_lifo_order (line 231) | fn scope_lifo_order() { function scope_fifo_order (line 239) | fn scope_fifo_order() { function spawn_lifo_order (line 264) | fn spawn_lifo_order() { function spawn_fifo_order (line 272) | fn spawn_fifo_order() { function nested_scopes (line 280) | fn nested_scopes() { function nested_fifo_scopes (line 317) | fn nested_fifo_scopes() { function in_place_scope_no_deadlock (line 354) | fn in_place_scope_no_deadlock() { function in_place_scope_fifo_no_deadlock (line 370) | fn in_place_scope_fifo_no_deadlock() { function yield_now_to_spawn (line 385) | fn yield_now_to_spawn() { function yield_local_to_spawn (line 403) | fn yield_local_to_spawn() { FILE: rayon-core/src/unwind.rs function halt_unwinding (line 13) | pub(super) fn halt_unwinding(func: F) -> thread::Result function resume_unwinding (line 20) | pub(super) fn resume_unwinding(payload: Box) -> ! { type AbortIfPanic (line 24) | pub(super) struct AbortIfPanic; method drop (line 27) | fn drop(&mut self) { FILE: rayon-core/tests/double_init_fail.rs function double_init_fail (line 6) | fn double_init_fail() { FILE: rayon-core/tests/init_zero_threads.rs function init_zero_threads (line 5) | fn init_zero_threads() { FILE: rayon-core/tests/scope_join.rs function pseudo_join (line 2) | fn pseudo_join(f: F, g: G) function quick_sort (line 13) | fn quick_sort(v: &mut [T]) { function partition (line 23) | fn partition(v: &mut [T]) -> usize { function is_sorted (line 36) | fn is_sorted(v: &[T]) -> bool { function scope_join (line 41) | fn scope_join() { FILE: rayon-core/tests/scoped_threadpool.rs type Local (line 5) | struct Local(i32); function missing_scoped_tls (line 11) | fn missing_scoped_tls() { function spawn_scoped_tls_threadpool (line 26) | fn spawn_scoped_tls_threadpool() { function build_scoped_tls_threadpool (line 69) | fn build_scoped_tls_threadpool() { FILE: rayon-core/tests/simple_panic.rs function simple_panic (line 5) | fn simple_panic() { FILE: rayon-core/tests/stack_overflow_crash.rs function force_stack_overflow (line 9) | fn force_stack_overflow(depth: u32) { function disable_core (line 18) | fn disable_core() { function overflow_code (line 31) | fn overflow_code() -> Option { function overflow_code (line 36) | fn overflow_code() -> Option { function stack_overflow_crash (line 44) | fn stack_overflow_crash() { function run_ignored (line 64) | fn run_ignored(test: &str) -> ExitStatus { function run_with_small_stack (line 77) | fn run_with_small_stack() { function run_with_large_stack (line 83) | fn run_with_large_stack() { function run_with_stack (line 87) | fn run_with_stack(stack_size_in_mb: usize) { FILE: rayon-core/tests/use_current_thread.rs function use_current_thread_basic (line 7) | fn use_current_thread_basic() { FILE: rayon-demo/examples/cpu_monitor.rs constant USAGE (line 5) | const USAGE: &str = " type Args (line 26) | pub struct Args { function main (line 31) | fn main() { function wait_for_user (line 48) | fn wait_for_user() { function task (line 53) | fn task(args: &Args) { function tasks_ended (line 67) | fn tasks_ended(args: &Args) { function task_stall_root (line 72) | fn task_stall_root(args: &Args) { function task_stall_scope (line 76) | fn task_stall_scope(args: &Args) { FILE: rayon-demo/src/cpu_time/mod.rs function get_cpu_time (line 14) | pub fn get_cpu_time() -> Option { function get_cpu_duration (line 18) | pub fn get_cpu_duration(start: Option, stop: Option) -> Option... type CpuMeasure (line 23) | pub struct CpuMeasure { function measure_cpu (line 31) | pub fn measure_cpu(op: impl FnOnce()) -> CpuMeasure { function print_time (line 47) | pub fn print_time(m: CpuMeasure) { FILE: rayon-demo/src/cpu_time/unix.rs function get_cpu_time (line 4) | pub fn get_cpu_time() -> Option { FILE: rayon-demo/src/cpu_time/win.rs function get_cpu_time (line 4) | pub fn get_cpu_time() -> Option { FILE: rayon-demo/src/factorial/mod.rs constant N (line 7) | const N: u32 = 9999; function factorial (line 10) | fn factorial(n: u32) -> BigUint { function factorial_iterator (line 16) | fn factorial_iterator(b: &mut test::Bencher) { function factorial_par_iter (line 23) | fn factorial_par_iter(b: &mut test::Bencher) { function factorial_fold_with (line 38) | fn factorial_fold_with(b: &mut test::Bencher) { function factorial_fold_chunks_with (line 54) | fn factorial_fold_chunks_with(b: &mut test::Bencher) { function factorial_recursion (line 69) | fn factorial_recursion(b: &mut test::Bencher) { function factorial_join (line 84) | fn factorial_join(b: &mut test::Bencher) { FILE: rayon-demo/src/fibonacci/mod.rs constant N (line 16) | const N: u32 = 32; constant FN (line 17) | const FN: u32 = 2_178_309; function fib_iterative (line 19) | fn fib_iterative(n: u32) -> u32 { function fib_recursive (line 30) | fn fib_recursive(n: u32) -> u32 { function fibonacci_recursive (line 40) | fn fibonacci_recursive(b: &mut test::Bencher) { function fibonacci_join_1_2 (line 47) | fn fibonacci_join_1_2(b: &mut test::Bencher) { function fibonacci_join_2_1 (line 63) | fn fibonacci_join_2_1(b: &mut test::Bencher) { function fibonacci_split_recursive (line 78) | fn fibonacci_split_recursive(b: &mut test::Bencher) { function fibonacci_split_iterative (line 98) | fn fibonacci_split_iterative(b: &mut test::Bencher) { function fibonacci_iterative (line 119) | fn fibonacci_iterative(b: &mut test::Bencher) { FILE: rayon-demo/src/join_microbench.rs function increment_all (line 7) | fn increment_all(b: &mut Bencher) { function increment_all_min (line 15) | fn increment_all_min(b: &mut Bencher) { function increment_all_serialized (line 26) | fn increment_all_serialized(b: &mut Bencher) { function increment_all_max (line 37) | fn increment_all_max(b: &mut Bencher) { function increment_all_atomized (line 48) | fn increment_all_atomized(b: &mut Bencher) { function join_recursively (line 59) | fn join_recursively(b: &mut Bencher) { FILE: rayon-demo/src/life/bench.rs function generations (line 4) | fn generations(b: &mut ::test::Bencher) { function par_iter_generations (line 9) | fn par_iter_generations(b: &mut ::test::Bencher) { function par_bridge_generations (line 14) | fn par_bridge_generations(b: &mut ::test::Bencher) { FILE: rayon-demo/src/life/mod.rs constant USAGE (line 1) | const USAGE: &str = " type Args (line 33) | pub struct Args { type Board (line 43) | pub struct Board { method new (line 52) | pub fn new(rows: usize, cols: usize) -> Board { method new_with_custom_rules (line 59) | fn new_with_custom_rules( method len (line 76) | fn len(&self) -> usize { method next_board (line 80) | fn next_board(&self, new_board: Vec) -> Board { method random (line 92) | pub fn random(&self) -> Board { method next_generation (line 101) | pub fn next_generation(&self) -> Board { method parallel_next_generation (line 109) | pub fn parallel_next_generation(&self) -> Board { method par_bridge_next_generation (line 118) | pub fn par_bridge_next_generation(&self) -> Board { method cell_live (line 127) | fn cell_live(&self, x: usize, y: usize) -> bool { method living_neighbors (line 131) | fn living_neighbors(&self, x: usize, y: usize) -> usize { method successor_cell (line 147) | fn successor_cell(&self, cell: usize) -> bool { method successor (line 151) | fn successor(&self, x: usize, y: usize) -> bool { function test_life (line 162) | fn test_life() { function generations (line 174) | fn generations(board: Board, gens: usize) { function parallel_generations (line 181) | fn parallel_generations(board: Board, gens: usize) { function par_bridge_generations (line 188) | fn par_bridge_generations(board: Board, gens: usize) { function delay (line 195) | fn delay(last_start: Instant, min_interval: Duration) -> Instant { function generations_limited (line 206) | fn generations_limited(board: Board, gens: usize, min_interval: Duration) { function parallel_generations_limited (line 215) | fn parallel_generations_limited(board: Board, gens: usize, min_interval:... function par_bridge_generations_limited (line 224) | fn par_bridge_generations_limited(board: Board, gens: usize, min_interva... function measure (line 233) | fn measure(f: fn(Board, usize) -> (), args: &Args) -> Duration { type CpuResult (line 243) | struct CpuResult { function measure_cpu (line 248) | fn measure_cpu(f: fn(Board, usize, Duration) -> (), args: &Args) -> CpuR... function main (line 264) | pub fn main(args: &[String]) { FILE: rayon-demo/src/main.rs constant USAGE (line 42) | const USAGE: &str = " function usage (line 68) | fn usage() -> ! { function main (line 73) | fn main() { function seeded_rng (line 94) | fn seeded_rng() -> rand_xorshift::XorShiftRng { FILE: rayon-demo/src/map_collect.rs function collect (line 11) | pub fn collect(pi: PI) -> HashMap function mutex (line 21) | pub fn mutex(pi: PI) -> HashMap function mutex_vec (line 36) | pub fn mutex_vec(pi: PI) -> HashMap function linked_list_collect (line 55) | pub fn linked_list_collect(pi: PI) -> HashMap function linked_list_collect_vec (line 66) | pub fn linked_list_collect_vec(pi: PI) -> HashMap function linked_list_collect_vec_sized (line 85) | pub fn linked_list_collect_vec_sized(pi: PI) -> HashMap function linked_list_map_reduce_vec_sized (line 107) | pub fn linked_list_map_reduce_vec_sized(pi: PI) -> HashMap function vec_vec_sized (line 137) | pub fn vec_vec_sized(pi: PI) -> HashMap function fold (line 163) | pub fn fold(pi: PI) -> HashMap function fold_vec (line 185) | pub fn fold_vec(pi: PI) -> HashMap constant N (line 294) | const N: u32 = 256 * 1024; function generate (line 296) | fn generate() -> impl ParallelIterator { function check (line 300) | fn check(hm: &HashMap) { constant N (line 317) | const N: u32 = 256 * 1024; function generate (line 319) | fn generate() -> impl ParallelIterator { function check (line 323) | fn check(hm: &HashMap) { FILE: rayon-demo/src/matmul/bench.rs constant ROW_SIZE (line 1) | const ROW_SIZE: usize = 256; function bench_matmul_strassen (line 4) | fn bench_matmul_strassen(b: &mut test::Bencher) { FILE: rayon-demo/src/matmul/mod.rs constant USAGE (line 1) | const USAGE: &str = " type Args (line 14) | pub struct Args { function seq_matmul (line 27) | pub fn seq_matmul(a: &[f32], b: &[f32], dest: &mut [f32]) { type SplayedBitsCounter (line 49) | struct SplayedBitsCounter { method new (line 55) | fn new(max: usize) -> Self { type Item (line 61) | type Item = usize; method next (line 63) | fn next(&mut self) -> Option { function test_splayed_counter (line 79) | fn test_splayed_counter() { function seq_matmulz (line 90) | pub fn seq_matmulz(a: &[f32], b: &[f32], dest: &mut [f32]) { constant MULT_CHUNK (line 120) | const MULT_CHUNK: usize = 1 * 1024; constant LINEAR_CHUNK (line 121) | const LINEAR_CHUNK: usize = 64 * 1024; function quarter_chunks (line 123) | fn quarter_chunks(v: &[f32]) -> (&[f32], &[f32], &[f32], &[f32]) { function quarter_chunks_mut (line 132) | fn quarter_chunks_mut(v: &mut [f32]) -> (&mut [f32], &mut [f32], &mut [f... function join4 (line 141) | fn join4(f1: F1, f2: F2, f3: F3, f4: F4)... function join8 (line 157) | fn join8( function matmulz (line 193) | pub fn matmulz(a: &[f32], b: &[f32], dest: &mut [f32]) { function matmul_strassen (line 224) | pub fn matmul_strassen(a: &[f32], b: &[f32], dest: &mut [f32]) { function raw_buffer (line 256) | fn raw_buffer(n: usize) -> Vec { function strassen_add2_mul (line 261) | fn strassen_add2_mul(a1: &[f32], a2: &[f32], b1: &[f32], b2: &[f32]) -> ... function strassen_sub_add_mul (line 268) | fn strassen_sub_add_mul(a1: &[f32], a2: &[f32], b1: &[f32], b2: &[f32]) ... function strassen_add_mul (line 275) | fn strassen_add_mul(a1: &[f32], a2: &[f32], b: &[f32]) -> Vec { function strassen_sub_mul (line 282) | fn strassen_sub_mul(b1: &[f32], b2: &[f32], a: &[f32]) -> Vec { function strassen_sum_sub (line 289) | fn strassen_sum_sub(a: &[f32], b: &[f32], c: &[f32], s: &[f32], dest: &m... function strassen_sum (line 296) | fn strassen_sum(a: &[f32], b: &[f32], dest: &mut [f32]) { function rtmp_sum (line 301) | fn rtmp_sum(a: &[f32], b: &[f32]) -> Vec { function rtmp_sub (line 308) | fn rtmp_sub(a: &[f32], b: &[f32]) -> Vec { function rmatsum (line 316) | fn rmatsum(src: &[f32], dest: &mut [f32]) { function rmatsub (line 322) | fn rmatsub(src: &[f32], dest: &mut [f32]) { function rcopy (line 328) | fn rcopy(src: &[f32], dest: &mut [f32]) { function test_matmul (line 341) | fn test_matmul() { function timed_matmul (line 375) | fn timed_matmul(size: usize, f: F... function main (line 400) | pub fn main(args: &[String]) { FILE: rayon-demo/src/mergesort/bench.rs constant BENCH_SIZE (line 3) | const BENCH_SIZE: usize = 250_000_000 / 512; function bench_harness (line 5) | fn bench_harness(mut f: F, b: &mut test::Bencher) { function merge_sort_par_bench (line 16) | fn merge_sort_par_bench(b: &mut test::Bencher) { function merge_sort_seq_bench (line 21) | fn merge_sort_seq_bench(b: &mut test::Bencher) { FILE: rayon-demo/src/mergesort/mod.rs constant USAGE (line 4) | const USAGE: &str = " type Args (line 22) | pub struct Args { function merge_sort (line 33) | pub fn merge_sort(v: &mut [T]) { constant SORT_CHUNK (line 44) | const SORT_CHUNK: usize = 32 * 1024; constant MERGE_CHUNK (line 45) | const MERGE_CHUNK: usize = 64 * 1024; function as_uninit_slice (line 47) | fn as_uninit_slice(slice: &[T]) -> &[MaybeUninit] { function as_uninit_slice_mut (line 53) | fn as_uninit_slice_mut(slice: &mut [T]) -> &mut [MaybeUninit] { function slice_assume_init_mut (line 59) | unsafe fn slice_assume_init_mut(slice: &mut [MaybeUninit]) -> &mut... function rsort (line 65) | fn rsort(src: &mut [T], buf: &mut [MaybeUninit]) { function rsort_into (line 82) | fn rsort_into<'dest, T: Ord + Send + Copy>( function rmerge (line 105) | fn rmerge(a: &mut [T], b: &mut [T], dest: &mut [Ma... function seq_merge (line 129) | fn seq_merge(a: &[T], b: &[T], dest: &mut [MaybeUninit... function test_merge_sort (line 157) | fn test_merge_sort() { function seq_merge_sort (line 171) | pub fn seq_merge_sort(v: &mut [T]) { function seq_sort (line 182) | fn seq_sort(src: &mut [T], buf: &mut [MaybeUninit]) { function seq_sort_into (line 199) | fn seq_sort_into<'dest, T: Ord + Copy>( function is_sorted (line 217) | pub fn is_sorted(v: &mut [T]) -> bool { function default_vec (line 237) | fn default_vec(n: usize) -> Vec { function timed_sort (line 242) | fn timed_sort(n: usize, f: F, name: &str) -> u64 { function main (line 257) | pub fn main(args: &[String]) { FILE: rayon-demo/src/nbody/bench.rs constant BENCH_BODIES (line 4) | const BENCH_BODIES: usize = 1000; constant BENCH_TICKS (line 6) | const BENCH_TICKS: usize = 10; function nbody_bench (line 8) | fn nbody_bench(b: &mut test::Bencher, mut tick: TICK) function nbody_seq (line 22) | fn nbody_seq(b: &mut ::test::Bencher) { function nbody_par_iter (line 29) | fn nbody_par_iter(b: &mut ::test::Bencher) { function nbody_par_bridge (line 36) | fn nbody_par_bridge(b: &mut ::test::Bencher) { function nbody_parreduce (line 43) | fn nbody_parreduce(b: &mut ::test::Bencher) { FILE: rayon-demo/src/nbody/mod.rs constant USAGE (line 12) | const USAGE: &str = " type ExecutionMode (line 47) | pub enum ExecutionMode { type Args (line 54) | pub struct Args { function main (line 62) | pub fn main(args: &[String]) { function run_benchmarks (line 79) | fn run_benchmarks(mode: Option, bodies: usize, ticks: usi... FILE: rayon-demo/src/nbody/nbody.rs constant INITIAL_VELOCITY (line 37) | const INITIAL_VELOCITY: f64 = 8.0; type NBodyBenchmark (line 39) | pub struct NBodyBenchmark { method new (line 52) | pub fn new(num_bodies: usize, rng: &mut R) -> NBodyBenchmark { method tick_par (line 92) | pub fn tick_par(&mut self) -> &[Body] { method tick_par_bridge (line 118) | pub fn tick_par_bridge(&mut self) -> &[Body] { method tick_par_reduce (line 144) | pub fn tick_par_reduce(&mut self) -> &[Body] { method tick_seq (line 169) | pub fn tick_seq(&mut self) -> &[Body] { type Body (line 45) | pub struct Body { function next_velocity (line 193) | fn next_velocity(time: usize, prev: &Body, bodies: &[Body]) -> (Vector3<... function next_velocity_par (line 332) | fn next_velocity_par(time: usize, prev: &Body, bodies: &[Body]) -> (Vect... FILE: rayon-demo/src/nbody/visualize.rs type Vertex (line 19) | struct Vertex { function icosahedron (line 25) | fn icosahedron() -> ([Vertex; 12], Vec) { type Instance (line 77) | struct Instance { type State (line 84) | struct State { method resumed (line 96) | fn resumed(&mut self, _event_loop: &ActiveEventLoop) {} method window_event (line 98) | fn window_event( method about_to_wait (line 166) | fn about_to_wait(&mut self, _event_loop: &ActiveEventLoop) { function visualize_benchmarks (line 187) | pub fn visualize_benchmarks(num_bodies: usize, mode: ExecutionMode) { FILE: rayon-demo/src/noop/mod.rs constant USAGE (line 1) | const USAGE: &str = " type Args (line 15) | pub struct Args { function main (line 20) | pub fn main(args: &[String]) { FILE: rayon-demo/src/pythagoras/mod.rs function par_euclid (line 17) | fn par_euclid(map_m: FM, map_n: FN) -> u32 function par_euclid_weightless (line 35) | fn par_euclid_weightless() -> u32 { function euclid (line 49) | fn euclid() -> u32 { function euclid_serial (line 62) | fn euclid_serial(b: &mut test::Bencher) { function euclid_faux_serial (line 69) | fn euclid_faux_serial(b: &mut test::Bencher) { function euclid_parallel_weightless (line 77) | fn euclid_parallel_weightless(b: &mut test::Bencher) { function euclid_parallel_one (line 84) | fn euclid_parallel_one(b: &mut test::Bencher) { function euclid_parallel_outer (line 91) | fn euclid_parallel_outer(b: &mut test::Bencher) { function euclid_parallel_full (line 99) | fn euclid_parallel_full(b: &mut test::Bencher) { FILE: rayon-demo/src/quicksort/bench.rs constant BENCH_SIZE (line 5) | const BENCH_SIZE: usize = 250_000_000 / 512; function bench_harness (line 7) | fn bench_harness(mut f: F, b: &mut test::Bencher) { function quick_sort_par_bench (line 18) | fn quick_sort_par_bench(b: &mut test::Bencher) { function quick_sort_seq_bench (line 23) | fn quick_sort_seq_bench(b: &mut test::Bencher) { function quick_sort_splitter (line 28) | fn quick_sort_splitter(b: &mut test::Bencher) { FILE: rayon-demo/src/quicksort/mod.rs constant USAGE (line 3) | const USAGE: &str = " type Args (line 19) | pub struct Args { type Joiner (line 30) | pub trait Joiner { method is_parallel (line 31) | fn is_parallel() -> bool; method join (line 32) | fn join(oper_a: A, oper_b: B) -> (R_A, R_B) method is_parallel (line 43) | fn is_parallel() -> bool { method join (line 47) | fn join(oper_a: A, oper_b: B) -> (R_A, R_B) method is_parallel (line 61) | fn is_parallel() -> bool { method join (line 65) | fn join(oper_a: A, oper_b: B) -> (R_A, R_B) type Parallel (line 40) | pub struct Parallel; type Sequential (line 58) | struct Sequential; function quick_sort (line 78) | pub fn quick_sort(v: &mut [T]) { function partition (line 92) | fn partition(v: &mut [T]) -> usize { function is_sorted (line 105) | pub fn is_sorted(v: &[T]) -> bool { function default_vec (line 109) | fn default_vec(n: usize) -> Vec { function timed_sort (line 114) | fn timed_sort(n: usize, f: F, name: &str) -> u64 { function main (line 129) | pub fn main(args: &[String]) { FILE: rayon-demo/src/sieve/bench.rs constant MAGNITUDE (line 3) | const MAGNITUDE: usize = 7; function sieve_bench (line 5) | fn sieve_bench(b: &mut test::Bencher, mut tick: TICK) function sieve_serial (line 16) | fn sieve_serial(b: &mut ::test::Bencher) { function sieve_chunks (line 21) | fn sieve_chunks(b: &mut ::test::Bencher) { function sieve_parallel (line 26) | fn sieve_parallel(b: &mut ::test::Bencher) { FILE: rayon-demo/src/sieve/mod.rs constant USAGE (line 1) | const USAGE: &str = " type Args (line 35) | pub struct Args { constant CHUNK_SIZE (line 46) | const CHUNK_SIZE: usize = 100_000; constant NUM_PRIMES (line 50) | const NUM_PRIMES: &[usize] = &[ function max (line 76) | fn max(magnitude: usize) -> usize { function sieve_serial (line 81) | fn sieve_serial(max: usize) -> Vec { function sieve_chunks (line 98) | fn sieve_chunks(max: usize) -> Vec { function sieve_parallel (line 117) | fn sieve_parallel(max: usize) -> Vec { function update_chunk (line 139) | fn update_chunk(low: &[bool], chunk: &mut [bool], base: usize) { function clear_stride (line 163) | fn clear_stride(slice: &mut [bool], from: usize, stride: usize) { function measure (line 170) | fn measure(f: fn(usize) -> Vec) -> Duration { function main (line 184) | pub fn main(args: &[String]) { FILE: rayon-demo/src/sort.rs function gen_ascending (line 8) | fn gen_ascending(len: usize) -> Vec { function gen_descending (line 12) | fn gen_descending(len: usize) -> Vec { function gen_random (line 16) | fn gen_random(len: usize) -> Vec { function gen_mostly_ascending (line 21) | fn gen_mostly_ascending(len: usize) -> Vec { function gen_mostly_descending (line 33) | fn gen_mostly_descending(len: usize) -> Vec { function gen_strings (line 45) | fn gen_strings(len: usize) -> Vec { function gen_big_random (line 62) | fn gen_big_random(len: usize) -> Vec<[u64; 16]> { type MergeSort (line 212) | trait MergeSort { method demo_merge_sort (line 213) | fn demo_merge_sort(&mut self); method demo_merge_sort (line 217) | fn demo_merge_sort(&mut self) { type QuickSort (line 256) | trait QuickSort { method demo_quick_sort (line 257) | fn demo_quick_sort(&mut self); method demo_quick_sort (line 261) | fn demo_quick_sort(&mut self) { FILE: rayon-demo/src/str_split.rs constant WHITESPACE (line 18) | const WHITESPACE: &[char] = &['\r', '\n', ' ', '\t']; function get_string_count (line 20) | fn get_string_count() -> (&'static str, usize) { function parallel_space_char (line 25) | fn parallel_space_char(b: &mut Bencher) { function parallel_space_chars (line 31) | fn parallel_space_chars(b: &mut Bencher) { function parallel_space_fn (line 37) | fn parallel_space_fn(b: &mut Bencher) { function serial_space_char (line 43) | fn serial_space_char(b: &mut Bencher) { function serial_space_chars (line 49) | fn serial_space_chars(b: &mut Bencher) { function serial_space_fn (line 56) | fn serial_space_fn(b: &mut Bencher) { function serial_space_str (line 62) | fn serial_space_str(b: &mut Bencher) { FILE: rayon-demo/src/tree.rs constant SIZE (line 4) | const SIZE: u64 = 100_000; constant VAL (line 5) | const VAL: u64 = SIZE * (SIZE - 1) / 2; function tree_prefix_collect (line 8) | fn tree_prefix_collect(b: &mut ::test::Bencher) { function tree_postfix_collect (line 28) | fn tree_postfix_collect(b: &mut ::test::Bencher) { function tree_prefix_sum (line 48) | fn tree_prefix_sum(b: &mut ::test::Bencher) { function tree_postfix_sum (line 65) | fn tree_postfix_sum(b: &mut ::test::Bencher) { FILE: rayon-demo/src/tsp/bench.rs function run_dir (line 7) | fn run_dir( function dj10 (line 40) | fn dj10(b: &mut test::Bencher) { FILE: rayon-demo/src/tsp/graph.rs type Graph (line 6) | pub struct Graph { method new (line 16) | pub fn new(num_nodes: usize) -> Graph { method num_nodes (line 25) | pub fn num_nodes(&self) -> usize { method all_nodes (line 29) | pub fn all_nodes(&self) -> impl Iterator { method node_set (line 33) | pub fn node_set(&self) -> NodeSet { method edge_index (line 39) | fn edge_index(&self, source: Node, target: Node) -> usize { method set_weight (line 43) | pub fn set_weight(&mut self, source: Node, target: Node, w: Weight) { method edge_weight (line 49) | pub fn edge_weight(&self, source: Node, target: Node) -> Option { method edges (line 58) | pub fn edges(&self, source: Node) -> impl Iterator + '_ { type Node (line 70) | pub struct Node { method new (line 75) | pub fn new(index: usize) -> Node { method index (line 79) | pub fn index(self) -> usize { type Edge (line 85) | pub struct Edge { type NodeSet (line 92) | pub struct NodeSet { method contains (line 97) | pub fn contains(&self, node: Node) -> bool { method with (line 101) | pub fn with(&self, node: Node) -> NodeSet { method insert (line 107) | pub fn insert(&mut self, node: Node) { method remove (line 111) | pub fn remove(&mut self, node: Node) { FILE: rayon-demo/src/tsp/mod.rs constant USAGE (line 26) | const USAGE: &str = " type Args (line 47) | pub struct Args { function main (line 54) | pub fn main(args: &[String]) { function run_solver (line 68) | fn run_solver(datafile: &Path, seq_threshold: usize, from: usize) -> Res... function parse_solver (line 107) | fn parse_solver(datafile: &Path) -> Result> { FILE: rayon-demo/src/tsp/parser.rs function parse_tsp_data (line 32) | pub fn parse_tsp_data(text: &str) -> Result { type Data (line 141) | pub struct Data<'text> { function new (line 148) | pub fn new(data: &'text str) -> Data<'text> { function advance (line 158) | pub fn advance(&mut self) { type Header (line 164) | pub struct Header<'text> { function parse_tsp_header (line 170) | pub fn parse_tsp_header<'text>(data: &mut Data<'text>) -> Option) -> Option<()> { function parse_coord (line 194) | pub fn parse_coord(data: &mut Data<'_>) -> Option<(Node, f64, f64)> { function parse_blank (line 220) | pub fn parse_blank(data: &mut Data<'_>) -> Option<()> { FILE: rayon-demo/src/tsp/solver.rs type SolverCx (line 11) | pub struct SolverCx<'s> { type TourId (line 23) | pub struct TourId { function new (line 28) | pub fn new(graph: &'s Graph, seq_threshold: usize) -> Self { function search_from (line 39) | pub fn search_from(&mut self, node: Node) { function seq_threshold (line 61) | pub fn seq_threshold(&self) -> usize { function tour_id (line 65) | pub fn tour_id(&self) -> TourId { function graph (line 70) | pub fn graph(&self) -> &'s Graph { function enqueue (line 74) | pub fn enqueue(&self, tour_element: Arc) { function dequeue (line 79) | pub fn dequeue(&self) -> Option> { function min_tour_weight (line 84) | pub fn min_tour_weight(&self) -> Weight { function add_complete_tour (line 91) | pub fn add_complete_tour(&self, tour: &[Node], weight: Weight) { function into_result (line 103) | pub fn into_result(self) -> (Option>, Weight) { FILE: rayon-demo/src/tsp/step.rs function step (line 9) | pub fn step<'s>(scope: &Scope<'s>, solver: &'s SolverCx<'s>) { function split_tour (line 20) | fn split_tour<'s>(scope: &Scope<'s>, solver: &'s SolverCx<'s>, element: ... function compute_lower_bound (line 60) | fn compute_lower_bound( function solve_tour_seq (line 100) | fn solve_tour_seq(solver: &SolverCx<'_>, element: Arc) { function enumerate_sequentially (line 129) | fn enumerate_sequentially( function complete_tour (line 175) | fn complete_tour(solver: &SolverCx<'_>, path: &mut Vec, weight: We... FILE: rayon-demo/src/tsp/tour.rs type TourPrefix (line 9) | pub struct TourPrefix { method to_cmp_elements (line 35) | fn to_cmp_elements(&self) -> (Priority, TourId) { method visited (line 39) | pub fn visited(&self, node: Node) -> bool { method eq (line 45) | fn eq(&self, other: &Self) -> bool { method partial_cmp (line 53) | fn partial_cmp(&self, other: &Self) -> Option { method cmp (line 59) | fn cmp(&self, other: &Self) -> Ordering { FILE: rayon-demo/src/tsp/weight.rs type Weight (line 4) | pub struct Weight { method new (line 14) | pub fn new(w: usize) -> Weight { method zero (line 18) | pub fn zero() -> Weight { method max (line 22) | pub fn max() -> Weight { method to_usize (line 26) | pub fn to_usize(self) -> usize { method is_max (line 30) | pub fn is_max(self) -> bool { method to_priority (line 36) | pub fn to_priority(self) -> Priority { type Priority (line 9) | pub struct Priority { type Output (line 44) | type Output = Weight; method add (line 46) | fn add(self, rhs: Weight) -> Weight { method add_assign (line 52) | fn add_assign(&mut self, rhs: Weight) { type Output (line 58) | type Output = Weight; method sub (line 60) | fn sub(self, rhs: Weight) -> Weight { method sub_assign (line 66) | fn sub_assign(&mut self, rhs: Weight) { FILE: rayon-demo/src/vec_collect.rs function collect (line 8) | pub fn collect(pi: PI) -> Vec function linked_list_collect_vec (line 17) | pub fn linked_list_collect_vec(pi: PI) -> Vec function linked_list_collect_vec_sized (line 35) | pub fn linked_list_collect_vec_sized(pi: PI) -> Vec function linked_list_map_reduce_vec_sized (line 56) | pub fn linked_list_map_reduce_vec_sized(pi: PI) -> Vec function vec_vec_sized (line 85) | pub fn vec_vec_sized(pi: PI) -> Vec function fold (line 110) | pub fn fold(pi: PI) -> Vec constant N (line 182) | const N: u32 = 4 * 1024 * 1024; function generate (line 184) | fn generate() -> impl IndexedParallelIterator { function check (line 188) | fn check(v: &[u32]) { function with_collect_into_vec (line 193) | fn with_collect_into_vec(b: &mut ::test::Bencher) { function with_collect_into_vec_reused (line 204) | fn with_collect_into_vec_reused(b: &mut ::test::Bencher) { constant N (line 218) | const N: u32 = 4 * 1024 * 1024; function generate (line 220) | fn generate() -> impl ParallelIterator { function check (line 224) | fn check(v: &[u32]) { FILE: src/array.rs type Item (line 15) | type Item = &'data T; type Iter (line 16) | type Iter = Iter<'data, T>; method into_par_iter (line 18) | fn into_par_iter(self) -> Self::Iter { type Item (line 24) | type Item = &'data mut T; type Iter (line 25) | type Iter = IterMut<'data, T>; method into_par_iter (line 27) | fn into_par_iter(self) -> Self::Iter { type Item (line 33) | type Item = T; type Iter (line 34) | type Iter = IntoIter; method into_par_iter (line 36) | fn into_par_iter(self) -> Self::Iter { type IntoIter (line 43) | pub struct IntoIter { type Item (line 48) | type Item = T; method drive_unindexed (line 50) | fn drive_unindexed(self, consumer: C) -> C::Result method opt_len (line 57) | fn opt_len(&self) -> Option { method drive (line 63) | fn drive(self, consumer: C) -> C::Result method len (line 70) | fn len(&self) -> usize { method with_producer (line 74) | fn with_producer(self, callback: CB) -> CB::Output FILE: src/collections/binary_heap.rs type IntoIter (line 15) | pub struct IntoIter { type Item (line 20) | type Item = T; type Iter (line 21) | type Iter = IntoIter; method into_par_iter (line 23) | fn into_par_iter(self) -> Self::Iter { type Iter (line 37) | pub struct Iter<'a, T> { method clone (line 42) | fn clone(&self) -> Self { type Item (line 50) | type Item = &'a T; type Iter (line 51) | type Iter = Iter<'a, T>; method into_par_iter (line 53) | fn into_par_iter(self) -> Self::Iter { type Drain (line 70) | pub struct Drain<'a, T> { type Iter (line 77) | type Iter = Drain<'a, T>; type Item (line 78) | type Item = T; method par_drain (line 80) | fn par_drain(self) -> Self::Iter { type Item (line 86) | type Item = T; method drive_unindexed (line 88) | fn drive_unindexed(self, consumer: C) -> C::Result method opt_len (line 95) | fn opt_len(&self) -> Option { method drive (line 101) | fn drive(self, consumer: C) -> C::Result method len (line 108) | fn len(&self) -> usize { method with_producer (line 112) | fn with_producer(self, callback: CB) -> CB::Output method drop (line 123) | fn drop(&mut self) { FILE: src/collections/btree_map.rs type IntoIter (line 14) | pub struct IntoIter { type Iter (line 30) | pub struct Iter<'a, K, V> { method clone (line 35) | fn clone(&self) -> Self { type IterMut (line 54) | pub struct IterMut<'a, K, V> { FILE: src/collections/btree_set.rs type IntoIter (line 14) | pub struct IntoIter { type Iter (line 30) | pub struct Iter<'a, T> { method clone (line 35) | fn clone(&self) -> Self { FILE: src/collections/hash_map.rs type IntoIter (line 15) | pub struct IntoIter { type Iter (line 31) | pub struct Iter<'a, K, V> { method clone (line 36) | fn clone(&self) -> Self { type IterMut (line 55) | pub struct IterMut<'a, K, V> { type Drain (line 72) | pub struct Drain<'a, K, V> { type Iter (line 78) | type Iter = Drain<'a, K, V>; type Item (line 79) | type Item = (K, V); method par_drain (line 81) | fn par_drain(self) -> Self::Iter { FILE: src/collections/hash_set.rs type IntoIter (line 15) | pub struct IntoIter { type Iter (line 31) | pub struct Iter<'a, T> { method clone (line 36) | fn clone(&self) -> Self { type Drain (line 58) | pub struct Drain<'a, T> { type Iter (line 64) | type Iter = Drain<'a, T>; type Item (line 65) | type Item = T; method par_drain (line 67) | fn par_drain(self) -> Self::Iter { FILE: src/collections/linked_list.rs type IntoIter (line 14) | pub struct IntoIter { type Iter (line 30) | pub struct Iter<'a, T> { method clone (line 35) | fn clone(&self) -> Self { type IterMut (line 54) | pub struct IterMut<'a, T> { FILE: src/collections/mod.rs type DrainGuard (line 46) | pub(super) struct DrainGuard<'a, T, C: From>> { function new (line 56) | pub(super) fn new(collection: &'a mut C) -> Self { method drop (line 66) | fn drop(&mut self) { type Iter (line 77) | type Iter = crate::vec::Drain<'a, T>; type Item (line 78) | type Item = T; function par_drain (line 80) | fn par_drain>(self, range: R) -> Self::Iter { FILE: src/collections/vec_deque.rs type IntoIter (line 17) | pub struct IntoIter { type Item (line 22) | type Item = T; type Iter (line 23) | type Iter = IntoIter; method into_par_iter (line 25) | fn into_par_iter(self) -> Self::Iter { type Iter (line 39) | pub struct Iter<'a, T> { method clone (line 44) | fn clone(&self) -> Self { type Item (line 52) | type Item = &'a T; type Iter (line 53) | type Iter = Iter<'a, T>; method into_par_iter (line 55) | fn into_par_iter(self) -> Self::Iter { type IterMut (line 70) | pub struct IterMut<'a, T> { type Item (line 75) | type Item = &'a mut T; type Iter (line 76) | type Iter = IterMut<'a, T>; method into_par_iter (line 78) | fn into_par_iter(self) -> Self::Iter { type Drain (line 94) | pub struct Drain<'a, T> { type Iter (line 101) | type Iter = Drain<'a, T>; type Item (line 102) | type Item = T; function par_drain (line 104) | fn par_drain>(self, range: R) -> Self::Iter { type Item (line 114) | type Item = T; method drive_unindexed (line 116) | fn drive_unindexed(self, consumer: C) -> C::Result method opt_len (line 123) | fn opt_len(&self) -> Option { method drive (line 129) | fn drive(self, consumer: C) -> C::Result method len (line 136) | fn len(&self) -> usize { method with_producer (line 140) | fn with_producer(self, callback: CB) -> CB::Output method drop (line 152) | fn drop(&mut self) { FILE: src/delegate.rs function unindexed_example (line 64) | fn unindexed_example() { function indexed_example (line 89) | fn indexed_example() { FILE: src/iter/blocks.rs type BlocksCallback (line 4) | struct BlocksCallback { type Output (line 15) | type Output = C::Result; function callback (line 17) | fn callback>(mut self, mut producer: P) -> Self::O... type ExponentialBlocks (line 59) | pub struct ExponentialBlocks { function new (line 64) | pub(super) fn new(base: I) -> Self { type Item (line 73) | type Item = I::Item; method drive_unindexed (line 75) | fn drive_unindexed(self, consumer: C) -> C::Result function exponential_size (line 89) | fn exponential_size(size: &usize) -> Option { type UniformBlocks (line 101) | pub struct UniformBlocks { function new (line 107) | pub(super) fn new(base: I, block_size: usize) -> Self { type Item (line 116) | type Item = I::Item; method drive_unindexed (line 118) | fn drive_unindexed(self, consumer: C) -> C::Result FILE: src/iter/chain.rs type Chain (line 12) | pub struct Chain { function new (line 19) | pub(super) fn new(a: A, b: B) -> Self { type Item (line 29) | type Item = A::Item; method drive_unindexed (line 31) | fn drive_unindexed(self, consumer: C) -> C::Result method opt_len (line 52) | fn opt_len(&self) -> Option { method drive (line 62) | fn drive(self, consumer: C) -> C::Result method len (line 72) | fn len(&self) -> usize { method with_producer (line 76) | fn with_producer(self, callback: CB) -> CB::Output type ChainProducer (line 138) | struct ChainProducer function new (line 153) | fn new(a_len: usize, a: A, b: B) -> Self { type Item (line 163) | type Item = A::Item; type IntoIter (line 164) | type IntoIter = ChainSeq; method into_iter (line 166) | fn into_iter(self) -> Self::IntoIter { method min_len (line 170) | fn min_len(&self) -> usize { method max_len (line 174) | fn max_len(&self) -> usize { method split_at (line 178) | fn split_at(self, index: usize) -> (Self, Self) { method fold_with (line 197) | fn fold_with(self, mut folder: F) -> F type ChainSeq (line 213) | struct ChainSeq { function new (line 218) | fn new(a: A, b: B) -> ChainSeq type Item (line 232) | type Item = A::Item; method next (line 234) | fn next(&mut self) -> Option { method size_hint (line 238) | fn size_hint(&self) -> (usize, Option) { method next_back (line 255) | fn next_back(&mut self) -> Option { FILE: src/iter/chunks.rs type Chunks (line 11) | pub struct Chunks { function new (line 18) | pub(super) fn new(i: I, size: usize) -> Self { type Item (line 27) | type Item = Vec; method drive_unindexed (line 29) | fn drive_unindexed(self, consumer: C) -> C::Result method opt_len (line 36) | fn opt_len(&self) -> Option { method drive (line 45) | fn drive(self, consumer: C) -> C::Result method len (line 52) | fn len(&self) -> usize { method with_producer (line 56) | fn with_producer(self, callback: CB) -> CB::Output type ChunkProducer (line 90) | pub(super) struct ChunkProducer { function new (line 98) | pub(super) fn new(chunk_size: usize, len: usize, base: P, map: F) -> Self { type Item (line 113) | type Item = T; type IntoIter (line 114) | type IntoIter = std::iter::Map, F>; method into_iter (line 116) | fn into_iter(self) -> Self::IntoIter { method split_at (line 125) | fn split_at(self, index: usize) -> (Self, Self) { method min_len (line 144) | fn min_len(&self) -> usize { method max_len (line 148) | fn max_len(&self) -> usize { type ChunkSeq (line 153) | pub(super) struct ChunkSeq
{ type Item (line 163) | type Item = P::IntoIter; method next (line 165) | fn next(&mut self) -> Option { method size_hint (line 179) | fn size_hint(&self) -> (usize, Option) { method len (line 190) | fn len(&self) -> usize { method next_back (line 199) | fn next_back(&mut self) -> Option { FILE: src/iter/cloned.rs type Cloned (line 13) | pub struct Cloned { function new (line 19) | pub(super) fn new(base: I) -> Self { type Item (line 29) | type Item = T; method drive_unindexed (line 31) | fn drive_unindexed(self, consumer: C) -> C::Result method opt_len (line 39) | fn opt_len(&self) -> Option { method drive (line 49) | fn drive(self, consumer: C) -> C::Result method len (line 57) | fn len(&self) -> usize { method with_producer (line 61) | fn with_producer(self, callback: CB) -> CB::Output type ClonedProducer (line 91) | struct ClonedProducer
{ type Item (line 100) | type Item = T; type IntoIter (line 101) | type IntoIter = iter::Cloned; method into_iter (line 103) | fn into_iter(self) -> Self::IntoIter { method min_len (line 107) | fn min_len(&self) -> usize { method max_len (line 111) | fn max_len(&self) -> usize { method split_at (line 115) | fn split_at(self, index: usize) -> (Self, Self) { method fold_with (line 123) | fn fold_with(self, folder: F) -> F type ClonedConsumer (line 134) | struct ClonedConsumer { function new (line 139) | fn new(base: C) -> Self { type Folder (line 149) | type Folder = ClonedFolder; type Reducer (line 150) | type Reducer = C::Reducer; type Result (line 151) | type Result = C::Result; function split_at (line 153) | fn split_at(self, index: usize) -> (Self, Self, Self::Reducer) { function into_folder (line 162) | fn into_folder(self) -> Self::Folder { function full (line 168) | fn full(&self) -> bool { function split_off_left (line 178) | fn split_off_left(&self) -> Self { function to_reducer (line 182) | fn to_reducer(&self) -> Self::Reducer { type ClonedFolder (line 187) | struct ClonedFolder { type Result (line 196) | type Result = F::Result; function consume (line 198) | fn consume(self, item: &'a T) -> Self { function consume_iter (line 204) | fn consume_iter(mut self, iter: I) -> Self function complete (line 212) | fn complete(self) -> F::Result { function full (line 216) | fn full(&self) -> bool { FILE: src/iter/collect/consumer.rs type CollectConsumer (line 6) | pub(super) struct CollectConsumer<'c, T: Send> { function appender (line 15) | pub(super) fn appender(vec: &mut Vec, len: usize) -> CollectConsumer<... function new (line 29) | unsafe fn new(start: *mut T, len: usize) -> Self { type CollectResult (line 43) | pub(super) struct CollectResult<'c, T> { function len (line 60) | pub(super) fn len(&self) -> usize { function release_ownership (line 65) | pub(super) fn release_ownership(mut self) -> usize { method drop (line 73) | fn drop(&mut self) { type Folder (line 86) | type Folder = CollectResult<'c, T>; type Reducer (line 87) | type Reducer = CollectReducer; type Result (line 88) | type Result = CollectResult<'c, T>; function split_at (line 90) | fn split_at(self, index: usize) -> (Self, Self, CollectReducer) { function into_folder (line 105) | fn into_folder(self) -> Self::Folder { function full (line 116) | fn full(&self) -> bool { type Result (line 122) | type Result = Self; function consume (line 124) | fn consume(mut self, item: T) -> Self { function complete (line 141) | fn complete(self) -> Self::Result { function full (line 147) | fn full(&self) -> bool { function split_off_left (line 155) | fn split_off_left(&self) -> Self { function to_reducer (line 158) | fn to_reducer(&self) -> Self::Reducer { type CollectReducer (line 165) | pub(super) struct CollectReducer; method reduce (line 168) | fn reduce( FILE: src/iter/collect/mod.rs function collect_into_vec (line 13) | pub(super) fn collect_into_vec(pi: I, v: &mut Vec) function special_extend (line 34) | pub(super) fn special_extend(pi: I, len: usize, v: &mut Vec) function unzip_into_vecs (line 45) | pub(super) fn unzip_into_vecs(pi: I, left: &mut Vec, right: ... function collect_with_consumer (line 75) | fn collect_with_consumer(vec: &mut Vec, len: usize, scope_fn: F) FILE: src/iter/collect/test.rs function produce_too_many_items (line 21) | fn produce_too_many_items() { function produce_fewer_items (line 36) | fn produce_fewer_items() { function left_produces_items_with_no_complete (line 49) | fn left_produces_items_with_no_complete() { function right_produces_items_with_no_complete (line 65) | fn right_produces_items_with_no_complete() { function produces_items_with_no_complete (line 80) | fn produces_items_with_no_complete() { function left_produces_too_many_items (line 100) | fn left_produces_too_many_items() { function right_produces_too_many_items (line 117) | fn right_produces_too_many_items() { function left_produces_fewer_items (line 134) | fn left_produces_fewer_items() { function only_left_result (line 153) | fn only_left_result() { function only_right_result (line 171) | fn only_right_result() { function reducer_does_not_preserve_order (line 188) | fn reducer_does_not_preserve_order() { function right_produces_fewer_items (line 207) | fn right_produces_fewer_items() { function left_panics (line 226) | fn left_panics() { function right_panics (line 252) | fn right_panics() { function left_produces_fewer_items_drops (line 278) | fn left_produces_fewer_items_drops() { type DropCounter (line 304) | struct DropCounter { method created (line 312) | fn created(&self) -> usize { method dropped (line 316) | fn dropped(&self) -> usize { method element (line 320) | fn element(&self) -> Element<'_> { method assert_drop_count (line 325) | fn assert_drop_count(&self) { type Element (line 309) | struct Element<'a>(&'a AtomicUsize); method drop (line 337) | fn drop(&mut self) { function assert_is_panic_with_message (line 343) | fn assert_is_panic_with_message(result: &ThreadResult, expected: &... FILE: src/iter/copied.rs type Copied (line 13) | pub struct Copied { function new (line 19) | pub(super) fn new(base: I) -> Self { type Item (line 29) | type Item = T; method drive_unindexed (line 31) | fn drive_unindexed(self, consumer: C) -> C::Result method opt_len (line 39) | fn opt_len(&self) -> Option { method drive (line 49) | fn drive(self, consumer: C) -> C::Result method len (line 57) | fn len(&self) -> usize { method with_producer (line 61) | fn with_producer(self, callback: CB) -> CB::Output type CopiedProducer (line 91) | struct CopiedProducer
{ type Item (line 100) | type Item = T; type IntoIter (line 101) | type IntoIter = iter::Copied; method into_iter (line 103) | fn into_iter(self) -> Self::IntoIter { method min_len (line 107) | fn min_len(&self) -> usize { method max_len (line 111) | fn max_len(&self) -> usize { method split_at (line 115) | fn split_at(self, index: usize) -> (Self, Self) { method fold_with (line 123) | fn fold_with(self, folder: F) -> F type CopiedConsumer (line 134) | struct CopiedConsumer { function new (line 139) | fn new(base: C) -> Self { type Folder (line 149) | type Folder = CopiedFolder; type Reducer (line 150) | type Reducer = C::Reducer; type Result (line 151) | type Result = C::Result; function split_at (line 153) | fn split_at(self, index: usize) -> (Self, Self, Self::Reducer) { function into_folder (line 162) | fn into_folder(self) -> Self::Folder { function full (line 168) | fn full(&self) -> bool { function split_off_left (line 178) | fn split_off_left(&self) -> Self { function to_reducer (line 182) | fn to_reducer(&self) -> Self::Reducer { type CopiedFolder (line 187) | struct CopiedFolder { type Result (line 196) | type Result = F::Result; function consume (line 198) | fn consume(self, &item: &'a T) -> Self { function consume_iter (line 204) | fn consume_iter(mut self, iter: I) -> Self function complete (line 212) | fn complete(self) -> F::Result { function full (line 216) | fn full(&self) -> bool { FILE: src/iter/empty.rs function empty (line 24) | pub fn empty() -> Empty { type Empty (line 33) | pub struct Empty { method clone (line 38) | fn clone(&self) -> Self { function fmt (line 46) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { type Item (line 52) | type Item = T; method drive_unindexed (line 54) | fn drive_unindexed(self, consumer: C) -> C::Result method opt_len (line 61) | fn opt_len(&self) -> Option { method drive (line 67) | fn drive(self, consumer: C) -> C::Result method len (line 74) | fn len(&self) -> usize { method with_producer (line 78) | fn with_producer(self, callback: CB) -> CB::Output type EmptyProducer (line 87) | struct EmptyProducer(PhantomData); type Item (line 90) | type Item = T; type IntoIter (line 91) | type IntoIter = std::iter::Empty; method into_iter (line 93) | fn into_iter(self) -> Self::IntoIter { method split_at (line 97) | fn split_at(self, index: usize) -> (Self, Self) { method fold_with (line 102) | fn fold_with(self, folder: F) -> F FILE: src/iter/enumerate.rs type Enumerate (line 12) | pub struct Enumerate { function new (line 18) | pub(super) fn new(base: I) -> Self { type Item (line 27) | type Item = (usize, I::Item); method drive_unindexed (line 29) | fn drive_unindexed(self, consumer: C) -> C::Result method opt_len (line 36) | fn opt_len(&self) -> Option { method drive (line 45) | fn drive>(self, consumer: C) -> C::Result { method len (line 49) | fn len(&self) -> usize { method with_producer (line 53) | fn with_producer(self, callback: CB) -> CB::Output type EnumerateProducer (line 82) | struct EnumerateProducer
{ type Item (line 91) | type Item = (usize, P::Item); type IntoIter (line 92) | type IntoIter = iter::Zip, P::IntoIter>; method into_iter (line 94) | fn into_iter(self) -> Self::IntoIter { method min_len (line 108) | fn min_len(&self) -> usize { method max_len (line 111) | fn max_len(&self) -> usize { method split_at (line 115) | fn split_at(self, index: usize) -> (Self, Self) { FILE: src/iter/extend.rs function len (line 42) | fn len(vecs: &Either, LinkedList>>) -> usize { function string_len (line 50) | fn string_len>(vecs: &Either, LinkedList>>) ... function osstring_len (line 59) | fn osstring_len>(vecs: &Either, LinkedList... function fast_collect (line 67) | pub(super) fn fast_collect(pi: I) -> Either, LinkedList; type Reducer (line 92) | type Reducer = ListReducer; type Result (line 93) | type Result = LinkedList>; method split_at (line 95) | fn split_at(self, _index: usize) -> (Self, Self, Self::Reducer) { method into_folder (line 99) | fn into_folder(self) -> Self::Folder { method full (line 103) | fn full(&self) -> bool { method split_off_left (line 109) | fn split_off_left(&self) -> Self { method to_reducer (line 113) | fn to_reducer(&self) -> Self::Reducer { type ListVecFolder (line 86) | struct ListVecFolder { type Result (line 119) | type Result = LinkedList>; function consume (line 121) | fn consume(mut self, item: T) -> Self { function consume_iter (line 126) | fn consume_iter(mut self, iter: I) -> Self function complete (line 134) | fn complete(self) -> Self::Result { function full (line 142) | fn full(&self) -> bool { function par_extend (line 152) | fn par_extend(&mut self, par_iter: I) function par_extend (line 165) | fn par_extend(&mut self, par_iter: I) function par_extend (line 179) | fn par_extend(&mut self, par_iter: I) function par_extend (line 193) | fn par_extend(&mut self, par_iter: I) function par_extend (line 206) | fn par_extend(&mut self, par_iter: I) function par_extend (line 219) | fn par_extend(&mut self, par_iter: I) function par_extend (line 234) | fn par_extend(&mut self, par_iter: I) function par_extend (line 250) | fn par_extend(&mut self, par_iter: I) function par_extend (line 264) | fn par_extend(&mut self, par_iter: I) function par_extend (line 278) | fn par_extend(&mut self, par_iter: I) function par_extend (line 291) | fn par_extend(&mut self, par_iter: I) function par_extend (line 305) | fn par_extend(&mut self, par_iter: I) type ListConsumer (line 313) | struct ListConsumer; type Folder (line 322) | type Folder = ListFolder; type Reducer (line 323) | type Reducer = ListReducer; type Result (line 324) | type Result = LinkedList; method split_at (line 326) | fn split_at(self, _index: usize) -> (Self, Self, Self::Reducer) { method into_folder (line 330) | fn into_folder(self) -> Self::Folder { method full (line 336) | fn full(&self) -> bool { method split_off_left (line 342) | fn split_off_left(&self) -> Self { method to_reducer (line 346) | fn to_reducer(&self) -> Self::Reducer { type ListFolder (line 315) | struct ListFolder { type ListReducer (line 319) | struct ListReducer; method reduce (line 377) | fn reduce(self, mut left: LinkedList, mut right: LinkedList) -> ... type Result (line 352) | type Result = LinkedList; function consume (line 354) | fn consume(mut self, item: T) -> Self { function consume_iter (line 359) | fn consume_iter(mut self, iter: I) -> Self function complete (line 367) | fn complete(self) -> Self::Result { function full (line 371) | fn full(&self) -> bool { method par_extend (line 385) | fn par_extend(&mut self, par_iter: I) method par_extend (line 395) | fn par_extend(&mut self, par_iter: I) method par_extend (line 405) | fn par_extend(&mut self, par_iter: I) method par_extend (line 415) | fn par_extend(&mut self, par_iter: I) method par_extend (line 429) | fn par_extend(&mut self, par_iter: I) type ListStringConsumer (line 437) | struct ListStringConsumer; type Folder (line 444) | type Folder = ListStringFolder; type Reducer (line 445) | type Reducer = ListReducer; type Result (line 446) | type Result = LinkedList; method split_at (line 448) | fn split_at(self, _index: usize) -> (Self, Self, Self::Reducer) { method into_folder (line 452) | fn into_folder(self) -> Self::Folder { method full (line 458) | fn full(&self) -> bool { method split_off_left (line 464) | fn split_off_left(&self) -> Self { method to_reducer (line 468) | fn to_reducer(&self) -> Self::Reducer { type ListStringFolder (line 439) | struct ListStringFolder { type Result (line 474) | type Result = LinkedList; method consume (line 476) | fn consume(mut self, item: char) -> Self { method consume_iter (line 481) | fn consume_iter(mut self, iter: I) -> Self method complete (line 489) | fn complete(self) -> Self::Result { method full (line 497) | fn full(&self) -> bool { method par_extend (line 504) | fn par_extend(&mut self, par_iter: I) method par_extend (line 514) | fn par_extend(&mut self, par_iter: I) method par_extend (line 524) | fn par_extend(&mut self, par_iter: I) method par_extend (line 534) | fn par_extend(&mut self, par_iter: I) function par_extend (line 547) | fn par_extend(&mut self, par_iter: I) function par_extend (line 560) | fn par_extend(&mut self, par_iter: I) function par_extend (line 573) | fn par_extend(&mut self, par_iter: I) function par_extend (line 603) | fn par_extend(&mut self, par_iter: I) function par_extend (line 613) | fn par_extend(&mut self, par_iter: I) FILE: src/iter/filter.rs type Filter (line 12) | pub struct Filter { method fmt (line 18) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { function new (line 25) | pub(super) fn new(base: I, filter_op: P) -> Self { type Item (line 35) | type Item = I::Item; method drive_unindexed (line 37) | fn drive_unindexed(self, consumer: C) -> C::Result type FilterConsumer (line 49) | struct FilterConsumer<'p, C, P> { function new (line 55) | fn new(base: C, filter_op: &'p P) -> Self { type Folder (line 65) | type Folder = FilterFolder<'p, C::Folder, P>; type Reducer (line 66) | type Reducer = C::Reducer; type Result (line 67) | type Result = C::Result; function split_at (line 69) | fn split_at(self, index: usize) -> (Self, Self, C::Reducer) { function into_folder (line 78) | fn into_folder(self) -> Self::Folder { function full (line 85) | fn full(&self) -> bool { function split_off_left (line 95) | fn split_off_left(&self) -> Self { function to_reducer (line 99) | fn to_reducer(&self) -> Self::Reducer { type FilterFolder (line 104) | struct FilterFolder<'p, C, P> { type Result (line 114) | type Result = C::Result; function consume (line 116) | fn consume(self, item: T) -> Self { function complete (line 130) | fn complete(self) -> Self::Result { function full (line 134) | fn full(&self) -> bool { FILE: src/iter/filter_map.rs type FilterMap (line 12) | pub struct FilterMap { method fmt (line 18) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { function new (line 27) | pub(super) fn new(base: I, filter_op: P) -> Self { type Item (line 38) | type Item = R; method drive_unindexed (line 40) | fn drive_unindexed(self, consumer: C) -> C::Result type FilterMapConsumer (line 52) | struct FilterMapConsumer<'p, C, P> { function new (line 58) | fn new(base: C, filter_op: &'p P) -> Self { type Folder (line 68) | type Folder = FilterMapFolder<'p, C::Folder, P>; type Reducer (line 69) | type Reducer = C::Reducer; type Result (line 70) | type Result = C::Result; function split_at (line 72) | fn split_at(self, index: usize) -> (Self, Self, Self::Reducer) { function into_folder (line 81) | fn into_folder(self) -> Self::Folder { function full (line 89) | fn full(&self) -> bool { function split_off_left (line 99) | fn split_off_left(&self) -> Self { function to_reducer (line 103) | fn to_reducer(&self) -> Self::Reducer { type FilterMapFolder (line 108) | struct FilterMapFolder<'p, C, P> { type Result (line 118) | type Result = C::Result; function consume (line 120) | fn consume(self, item: T) -> Self { function complete (line 134) | fn complete(self) -> C::Result { function full (line 138) | fn full(&self) -> bool { FILE: src/iter/find.rs function find (line 5) | pub(super) fn find(pi: I, find_op: P) -> Option type FindConsumer (line 15) | struct FindConsumer<'p, P> { function new (line 21) | fn new(find_op: &'p P, found: &'p AtomicBool) -> Self { type Folder (line 31) | type Folder = FindFolder<'p, T, P>; type Reducer (line 32) | type Reducer = FindReducer; type Result (line 33) | type Result = Option; function split_at (line 35) | fn split_at(self, _index: usize) -> (Self, Self, Self::Reducer) { function into_folder (line 39) | fn into_folder(self) -> Self::Folder { function full (line 47) | fn full(&self) -> bool { function split_off_left (line 57) | fn split_off_left(&self) -> Self { function to_reducer (line 61) | fn to_reducer(&self) -> Self::Reducer { type FindFolder (line 66) | struct FindFolder<'p, T, P> { type Result (line 76) | type Result = Option; function consume (line 78) | fn consume(mut self, item: T) -> Self { function consume_iter (line 86) | fn consume_iter(mut self, iter: I) -> Self function complete (line 105) | fn complete(self) -> Self::Result { function full (line 109) | fn full(&self) -> bool { type FindReducer (line 114) | struct FindReducer; method reduce (line 117) | fn reduce(self, left: Option, right: Option) -> Option { FILE: src/iter/find_first_last/mod.rs type MatchPosition (line 27) | enum MatchPosition { function better_position (line 34) | fn better_position(pos1: usize, pos2: usize, mp: MatchPosition) -> bool { function find_first (line 41) | pub(super) fn find_first(pi: I, find_op: P) -> Option function find_last (line 51) | pub(super) fn find_last(pi: I, find_op: P) -> Option type FindConsumer (line 61) | struct FindConsumer<'p, P> { function new (line 70) | fn new(find_op: &'p P, match_position: MatchPosition, best_found: &'p At... function current_index (line 80) | fn current_index(&self) -> usize { type Folder (line 93) | type Folder = FindFolder<'p, T, P>; type Reducer (line 94) | type Reducer = FindReducer; type Result (line 95) | type Result = Option; function split_at (line 97) | fn split_at(self, _index: usize) -> (Self, Self, Self::Reducer) { function into_folder (line 108) | fn into_folder(self) -> Self::Folder { function full (line 118) | fn full(&self) -> bool { function split_off_left (line 134) | fn split_off_left(&self) -> Self { function to_reducer (line 159) | fn to_reducer(&self) -> Self::Reducer { type FindFolder (line 166) | struct FindFolder<'p, T, P> { type Result (line 175) | type Result = Option; function consume (line 177) | fn consume(mut self, item: T) -> Self { function complete (line 200) | fn complete(self) -> Self::Result { function full (line 204) | fn full(&self) -> bool { type FindReducer (line 219) | struct FindReducer { method reduce (line 224) | fn reduce(self, left: Option, right: Option) -> Option { FILE: src/iter/find_first_last/test.rs function same_range_first_consumers_return_correct_answer (line 4) | fn same_range_first_consumers_return_correct_answer() { function same_range_last_consumers_return_correct_answer (line 38) | fn same_range_last_consumers_return_correct_answer() { function find_first_folder_does_not_clobber_first_found (line 76) | fn find_first_folder_does_not_clobber_first_found() { function find_last_folder_yields_last_match (line 91) | fn find_last_folder_yields_last_match() { FILE: src/iter/flat_map.rs type FlatMap (line 12) | pub struct FlatMap { method fmt (line 18) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { function new (line 25) | pub(super) fn new(base: I, map_op: F) -> Self { type Item (line 36) | type Item = PI::Item; method drive_unindexed (line 38) | fn drive_unindexed(self, consumer: C) -> C::Result type FlatMapConsumer (line 50) | struct FlatMapConsumer<'f, C, F> { function new (line 56) | fn new(base: C, map_op: &'f F) -> Self { type Folder (line 67) | type Folder = FlatMapFolder<'f, C, F, C::Result>; type Reducer (line 68) | type Reducer = C::Reducer; type Result (line 69) | type Result = C::Result; function split_at (line 71) | fn split_at(self, index: usize) -> (Self, Self, C::Reducer) { function into_folder (line 80) | fn into_folder(self) -> Self::Folder { function full (line 88) | fn full(&self) -> bool { function split_off_left (line 99) | fn split_off_left(&self) -> Self { function to_reducer (line 103) | fn to_reducer(&self) -> Self::Reducer { type FlatMapFolder (line 108) | struct FlatMapFolder<'f, C, F, R> { type Result (line 120) | type Result = C::Result; function consume (line 122) | fn consume(self, item: T) -> Self { function complete (line 143) | fn complete(self) -> Self::Result { function full (line 150) | fn full(&self) -> bool { FILE: src/iter/flat_map_iter.rs type FlatMapIter (line 12) | pub struct FlatMapIter { method fmt (line 18) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { function new (line 27) | pub(super) fn new(base: I, map_op: F) -> Self { type Item (line 38) | type Item = SI::Item; method drive_unindexed (line 40) | fn drive_unindexed(self, consumer: C) -> C::Result type FlatMapIterConsumer (line 52) | struct FlatMapIterConsumer<'f, C, F> { function new (line 58) | fn new(base: C, map_op: &'f F) -> Self { type Folder (line 69) | type Folder = FlatMapIterFolder<'f, C::Folder, F>; type Reducer (line 70) | type Reducer = C::Reducer; type Result (line 71) | type Result = C::Result; function split_at (line 73) | fn split_at(self, index: usize) -> (Self, Self, C::Reducer) { function into_folder (line 82) | fn into_folder(self) -> Self::Folder { function full (line 89) | fn full(&self) -> bool { function split_off_left (line 100) | fn split_off_left(&self) -> Self { function to_reducer (line 104) | fn to_reducer(&self) -> Self::Reducer { type FlatMapIterFolder (line 109) | struct FlatMapIterFolder<'f, C, F> { type Result (line 120) | type Result = C::Result; function consume (line 122) | fn consume(self, item: T) -> Self { function consume_iter (line 128) | fn consume_iter(self, iter: I) -> Self function complete (line 138) | fn complete(self) -> Self::Result { function full (line 142) | fn full(&self) -> bool { FILE: src/iter/flatten.rs type Flatten (line 10) | pub struct Flatten { function new (line 16) | pub(super) fn new(base: I) -> Self { type Item (line 25) | type Item = ::Item; method drive_unindexed (line 27) | fn drive_unindexed(self, consumer: C) -> C::Result type FlattenConsumer (line 39) | struct FlattenConsumer { function new (line 44) | fn new(base: C) -> Self { type Folder (line 54) | type Folder = FlattenFolder; type Reducer (line 55) | type Reducer = C::Reducer; type Result (line 56) | type Result = C::Result; function split_at (line 58) | fn split_at(self, index: usize) -> (Self, Self, C::Reducer) { function into_folder (line 67) | fn into_folder(self) -> Self::Folder { function full (line 74) | fn full(&self) -> bool { function split_off_left (line 84) | fn split_off_left(&self) -> Self { function to_reducer (line 88) | fn to_reducer(&self) -> Self::Reducer { type FlattenFolder (line 93) | struct FlattenFolder { type Result (line 103) | type Result = C::Result; function consume (line 105) | fn consume(self, item: T) -> Self { function complete (line 124) | fn complete(self) -> Self::Result { function full (line 131) | fn full(&self) -> bool { FILE: src/iter/flatten_iter.rs type FlattenIter (line 10) | pub struct FlattenIter { function new (line 16) | pub(super) fn new(base: I) -> Self { type Item (line 25) | type Item = ::Item; method drive_unindexed (line 27) | fn drive_unindexed(self, consumer: C) -> C::Result type FlattenIterConsumer (line 39) | struct FlattenIterConsumer { function new (line 44) | fn new(base: C) -> Self { type Folder (line 54) | type Folder = FlattenIterFolder; type Reducer (line 55) | type Reducer = C::Reducer; type Result (line 56) | type Result = C::Result; function split_at (line 58) | fn split_at(self, index: usize) -> (Self, Self, C::Reducer) { function into_folder (line 67) | fn into_folder(self) -> Self::Folder { function full (line 73) | fn full(&self) -> bool { function split_off_left (line 83) | fn split_off_left(&self) -> Self { function to_reducer (line 87) | fn to_reducer(&self) -> Self::Reducer { type FlattenIterFolder (line 92) | struct FlattenIterFolder { type Result (line 101) | type Result = C::Result; function consume (line 103) | fn consume(self, item: T) -> Self { function consume_iter (line 108) | fn consume_iter(self, iter: I) -> Self function complete (line 117) | fn complete(self) -> Self::Result { function full (line 121) | fn full(&self) -> bool { FILE: src/iter/fold.rs function new (line 7) | pub(super) fn new(base: I, identity: ID, fold_op: F) -> Self { type Fold (line 22) | pub struct Fold { method fmt (line 29) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { type Item (line 41) | type Item = U; method drive_unindexed (line 43) | fn drive_unindexed(self, consumer: C) -> C::Result type FoldConsumer (line 56) | struct FoldConsumer<'c, C, ID, F> { type Folder (line 69) | type Folder = FoldFolder<'r, C::Folder, U, F>; type Reducer (line 70) | type Reducer = C::Reducer; type Result (line 71) | type Result = C::Result; function split_at (line 73) | fn split_at(self, index: usize) -> (Self, Self, Self::Reducer) { function into_folder (line 85) | fn into_folder(self) -> Self::Folder { function full (line 93) | fn full(&self) -> bool { function split_off_left (line 105) | fn split_off_left(&self) -> Self { function to_reducer (line 112) | fn to_reducer(&self) -> Self::Reducer { type FoldFolder (line 117) | struct FoldFolder<'r, C, ID, F> { type Result (line 128) | type Result = C::Result; function consume (line 130) | fn consume(self, item: T) -> Self { function consume_iter (line 139) | fn consume_iter(self, iter: I) -> Self function complete (line 164) | fn complete(self) -> C::Result { function full (line 168) | fn full(&self) -> bool { function new (line 176) | pub(super) fn new(base: I, item: U, fold_op: F) -> Self { type FoldWith (line 191) | pub struct FoldWith { method fmt (line 198) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { type Item (line 212) | type Item = U; method drive_unindexed (line 214) | fn drive_unindexed(self, consumer: C) -> C::Result type FoldWithConsumer (line 227) | struct FoldWithConsumer<'c, C, U, F> { type Folder (line 239) | type Folder = FoldFolder<'r, C::Folder, U, F>; type Reducer (line 240) | type Reducer = C::Reducer; type Result (line 241) | type Result = C::Result; function split_at (line 243) | fn split_at(self, index: usize) -> (Self, Self, Self::Reducer) { function into_folder (line 259) | fn into_folder(self) -> Self::Folder { function full (line 267) | fn full(&self) -> bool { function split_off_left (line 278) | fn split_off_left(&self) -> Self { function to_reducer (line 286) | fn to_reducer(&self) -> Self::Reducer { FILE: src/iter/fold_chunks.rs type FoldChunks (line 15) | pub struct FoldChunks { method fmt (line 23) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { function new (line 33) | pub(super) fn new(base: I, chunk_size: usize, identity: ID, fold_op: F) ... type Item (line 50) | type Item = U; method drive_unindexed (line 52) | fn drive_unindexed(self, consumer: C) -> C::Result method opt_len (line 59) | fn opt_len(&self) -> Option { method len (line 71) | fn len(&self) -> usize { method drive (line 75) | fn drive(self, consumer: C) -> C::Result method with_producer (line 82) | fn with_producer(self, callback: CB) -> CB::Output function check_fold_chunks (line 131) | fn check_fold_chunks() { function id (line 146) | fn id() -> i32 { function sum (line 149) | fn sum(x: T, y: U) -> T function check_fold_chunks_zero_size (line 158) | fn check_fold_chunks_zero_size() { function check_fold_chunks_even_size (line 166) | fn check_fold_chunks_even_size() { function check_fold_chunks_empty (line 177) | fn check_fold_chunks_empty() { function check_fold_chunks_len (line 189) | fn check_fold_chunks_len() { function check_fold_chunks_uneven (line 198) | fn check_fold_chunks_uneven() { FILE: src/iter/fold_chunks_with.rs type FoldChunksWith (line 15) | pub struct FoldChunksWith { method fmt (line 23) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { function new (line 34) | pub(super) fn new(base: I, chunk_size: usize, item: U, fold_op: F) -> Se... type Item (line 50) | type Item = U; method drive_unindexed (line 52) | fn drive_unindexed(self, consumer: C) -> C::Result method opt_len (line 59) | fn opt_len(&self) -> Option { method len (line 70) | fn len(&self) -> usize { method drive (line 74) | fn drive(self, consumer: C) -> C::Result method with_producer (line 81) | fn with_producer(self, callback: CB) -> CB::Output function check_fold_chunks_with (line 130) | fn check_fold_chunks_with() { function sum (line 145) | fn sum(x: T, y: U) -> T function check_fold_chunks_zero_size (line 154) | fn check_fold_chunks_zero_size() { function check_fold_chunks_even_size (line 162) | fn check_fold_chunks_even_size() { function check_fold_chunks_with_empty (line 173) | fn check_fold_chunks_with_empty() { function check_fold_chunks_len (line 185) | fn check_fold_chunks_len() { function check_fold_chunks_uneven (line 194) | fn check_fold_chunks_uneven() { FILE: src/iter/for_each.rs function for_each (line 5) | pub(super) fn for_each(pi: I, op: &F) type ForEachConsumer (line 15) | struct ForEachConsumer<'f, F> { type Folder (line 23) | type Folder = ForEachConsumer<'f, F>; type Reducer (line 24) | type Reducer = NoopReducer; type Result (line 25) | type Result = (); function split_at (line 27) | fn split_at(self, _index: usize) -> (Self, Self, NoopReducer) { function into_folder (line 31) | fn into_folder(self) -> Self { function full (line 35) | fn full(&self) -> bool { type Result (line 44) | type Result = (); function consume (line 46) | fn consume(self, item: T) -> Self { function consume_iter (line 51) | fn consume_iter(self, iter: I) -> Self function complete (line 59) | fn complete(self) {} function full (line 61) | fn full(&self) -> bool { function split_off_left (line 70) | fn split_off_left(&self) -> Self { function to_reducer (line 74) | fn to_reducer(&self) -> NoopReducer { FILE: src/iter/from_par_iter.rs function collect_extended (line 14) | fn collect_extended(par_iter: I) -> C function from_par_iter (line 29) | fn from_par_iter(par_iter: I) -> Self function from_par_iter (line 42) | fn from_par_iter(par_iter: I) -> Self function from_par_iter (line 55) | fn from_par_iter(par_iter: I) -> Self function from_par_iter (line 68) | fn from_par_iter(par_iter: I) -> Self function from_par_iter (line 81) | fn from_par_iter(par_iter: I) -> Self function from_par_iter (line 95) | fn from_par_iter(par_iter: I) -> Self function from_par_iter (line 109) | fn from_par_iter(par_iter: I) -> Self function from_par_iter (line 127) | fn from_par_iter(par_iter: I) -> Self function from_par_iter (line 144) | fn from_par_iter(par_iter: I) -> Self function from_par_iter (line 158) | fn from_par_iter(par_iter: I) -> Self function from_par_iter (line 171) | fn from_par_iter(par_iter: I) -> Self method from_par_iter (line 212) | fn from_par_iter(par_iter: I) -> Self method from_par_iter (line 222) | fn from_par_iter(par_iter: I) -> Self method from_par_iter (line 232) | fn from_par_iter(par_iter: I) -> Self function from_par_iter (line 250) | fn from_par_iter(par_iter: I) -> Self function from_par_iter (line 274) | fn from_par_iter(par_iter: I) -> Self FILE: src/iter/inspect.rs type Inspect (line 15) | pub struct Inspect { method fmt (line 21) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { function new (line 28) | pub(super) fn new(base: I, inspect_op: F) -> Self { type Item (line 38) | type Item = I::Item; method drive_unindexed (line 40) | fn drive_unindexed(self, consumer: C) -> C::Result method opt_len (line 48) | fn opt_len(&self) -> Option { method drive (line 58) | fn drive(self, consumer: C) -> C::Result method len (line 66) | fn len(&self) -> usize { method with_producer (line 70) | fn with_producer(self, callback: CB) -> CB::Output type InspectProducer (line 107) | struct InspectProducer<'f, P, F> { type Item (line 117) | type Item = P::Item; type IntoIter (line 118) | type IntoIter = iter::Inspect; method into_iter (line 120) | fn into_iter(self) -> Self::IntoIter { method min_len (line 124) | fn min_len(&self) -> usize { method max_len (line 128) | fn max_len(&self) -> usize { method split_at (line 132) | fn split_at(self, index: usize) -> (Self, Self) { method fold_with (line 146) | fn fold_with(self, folder: G) -> G type InspectConsumer (line 161) | struct InspectConsumer<'f, C, F> { function new (line 167) | fn new(base: C, inspect_op: &'f F) -> Self { type Folder (line 177) | type Folder = InspectFolder<'f, C::Folder, F>; type Reducer (line 178) | type Reducer = C::Reducer; type Result (line 179) | type Result = C::Result; function split_at (line 181) | fn split_at(self, index: usize) -> (Self, Self, Self::Reducer) { function into_folder (line 190) | fn into_folder(self) -> Self::Folder { function full (line 197) | fn full(&self) -> bool { function split_off_left (line 207) | fn split_off_left(&self) -> Self { function to_reducer (line 211) | fn to_reducer(&self) -> Self::Reducer { type InspectFolder (line 216) | struct InspectFolder<'f, C, F> { type Result (line 226) | type Result = C::Result; function consume (line 228) | fn consume(self, item: T) -> Self { function consume_iter (line 236) | fn consume_iter(mut self, iter: I) -> Self function complete (line 246) | fn complete(self) -> C::Result { function full (line 250) | fn full(&self) -> bool { FILE: src/iter/interleave.rs type Interleave (line 12) | pub struct Interleave { function new (line 19) | pub(super) fn new(i: I, j: J) -> Self { type Item (line 29) | type Item = I::Item; method drive_unindexed (line 31) | fn drive_unindexed(self, consumer: C) -> C::Result method opt_len (line 38) | fn opt_len(&self) -> Option { method drive (line 48) | fn drive(self, consumer: C) -> C::Result method len (line 55) | fn len(&self) -> usize { method with_producer (line 59) | fn with_producer(self, callback: CB) -> CB::Output type InterleaveProducer (line 133) | struct InterleaveProducer function new (line 150) | fn new(i: I, j: J, i_len: usize, j_len: usize, i_next: bool) -> Interlea... type Item (line 166) | type Item = I::Item; type IntoIter (line 167) | type IntoIter = InterleaveSeq; method into_iter (line 169) | fn into_iter(self) -> Self::IntoIter { method min_len (line 177) | fn min_len(&self) -> usize { method max_len (line 181) | fn max_len(&self) -> usize { method split_at (line 197) | fn split_at(self, index: usize) -> (Self, Self) { type InterleaveSeq (line 243) | struct InterleaveSeq { type Item (line 262) | type Item = I::Item; method next (line 265) | fn next(&mut self) -> Option { method size_hint (line 280) | fn size_hint(&self) -> (usize, Option) { method next_back (line 302) | fn next_back(&mut self) -> Option { method len (line 323) | fn len(&self) -> usize { FILE: src/iter/interleave_shortest.rs type InterleaveShortest (line 14) | pub struct InterleaveShortest { function new (line 24) | pub(super) fn new(i: I, j: J) -> Self { type Item (line 44) | type Item = I::Item; method drive_unindexed (line 46) | fn drive_unindexed(self, consumer: C) -> C::Result method opt_len (line 53) | fn opt_len(&self) -> Option { method drive (line 63) | fn drive(self, consumer: C) -> C::Result method len (line 70) | fn len(&self) -> usize { method with_producer (line 74) | fn with_producer(self, callback: CB) -> CB::Output FILE: src/iter/intersperse.rs type Intersperse (line 13) | pub struct Intersperse function new (line 26) | pub(super) fn new(base: I, item: I::Item) -> Self { type Item (line 35) | type Item = I::Item; method drive_unindexed (line 37) | fn drive_unindexed(self, consumer: C) -> C::Result method opt_len (line 45) | fn opt_len(&self) -> Option { method drive (line 57) | fn drive(self, consumer: C) -> C::Result method len (line 65) | fn len(&self) -> usize { method with_producer (line 74) | fn with_producer(self, callback: CB) -> CB::Output type IntersperseProducer (line 109) | struct IntersperseProducer
function new (line 123) | fn new(base: P, item: P::Item, len: usize) -> Self { type Item (line 137) | type Item = P::Item; type IntoIter (line 138) | type IntoIter = IntersperseIter; method into_iter (line 140) | fn into_iter(self) -> Self::IntoIter { method min_len (line 152) | fn min_len(&self) -> usize { method max_len (line 155) | fn max_len(&self) -> usize { method split_at (line 159) | fn split_at(self, index: usize) -> (Self, Self) { method fold_with (line 188) | fn fold_with(self, folder: F) -> F type IntersperseIter (line 201) | struct IntersperseIter type Item (line 215) | type Item = I::Item; method next (line 217) | fn next(&mut self) -> Option { method size_hint (line 233) | fn size_hint(&self) -> (usize, Option) { method next_back (line 243) | fn next_back(&mut self) -> Option { method len (line 264) | fn len(&self) -> usize { type IntersperseConsumer (line 270) | struct IntersperseConsumer { function new (line 280) | fn new(base: C, item: T) -> Self { type Folder (line 294) | type Folder = IntersperseFolder; type Reducer (line 295) | type Reducer = C::Reducer; type Result (line 296) | type Result = C::Result; function split_at (line 298) | fn split_at(mut self, index: usize) -> (Self, Self, Self::Reducer) { function into_folder (line 313) | fn into_folder(self) -> Self::Folder { function full (line 321) | fn full(&self) -> bool { function split_off_left (line 331) | fn split_off_left(&self) -> Self { function to_reducer (line 341) | fn to_reducer(&self) -> Self::Reducer { type IntersperseFolder (line 346) | struct IntersperseFolder { type Result (line 357) | type Result = C::Result; function consume (line 359) | fn consume(mut self, item: T) -> Self { function consume_iter (line 372) | fn consume_iter(self, iter: I) -> Self function complete (line 394) | fn complete(self) -> C::Result { function full (line 398) | fn full(&self) -> bool { FILE: src/iter/len.rs type MinLen (line 10) | pub struct MinLen { function new (line 17) | pub(super) fn new(base: I, min: usize) -> Self { type Item (line 26) | type Item = I::Item; method drive_unindexed (line 28) | fn drive_unindexed(self, consumer: C) -> C::Result method opt_len (line 35) | fn opt_len(&self) -> Option { method drive (line 44) | fn drive>(self, consumer: C) -> C::Result { method len (line 48) | fn len(&self) -> usize { method with_producer (line 52) | fn with_producer(self, callback: CB) -> CB::Output type MinLenProducer (line 88) | struct MinLenProducer
{ type Item (line 97) | type Item = P::Item; type IntoIter (line 98) | type IntoIter = P::IntoIter; method into_iter (line 100) | fn into_iter(self) -> Self::IntoIter { method min_len (line 104) | fn min_len(&self) -> usize { method max_len (line 108) | fn max_len(&self) -> usize { method split_at (line 112) | fn split_at(self, index: usize) -> (Self, Self) { method fold_with (line 126) | fn fold_with(self, folder: F) -> F type MaxLen (line 140) | pub struct MaxLen { function new (line 147) | pub(super) fn new(base: I, max: usize) -> Self { type Item (line 156) | type Item = I::Item; method drive_unindexed (line 158) | fn drive_unindexed(self, consumer: C) -> C::Result method opt_len (line 165) | fn opt_len(&self) -> Option { method drive (line 174) | fn drive>(self, consumer: C) -> C::Result { method len (line 178) | fn len(&self) -> usize { method with_producer (line 182) | fn with_producer(self, callback: CB) -> CB::Output type MaxLenProducer (line 218) | struct MaxLenProducer
{ type Item (line 227) | type Item = P::Item; type IntoIter (line 228) | type IntoIter = P::IntoIter; method into_iter (line 230) | fn into_iter(self) -> Self::IntoIter { method min_len (line 234) | fn min_len(&self) -> usize { method max_len (line 238) | fn max_len(&self) -> usize { method split_at (line 242) | fn split_at(self, index: usize) -> (Self, Self) { method fold_with (line 256) | fn fold_with(self, folder: F) -> F FILE: src/iter/map.rs type Map (line 14) | pub struct Map { method fmt (line 20) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { function new (line 27) | pub(super) fn new(base: I, map_op: F) -> Self { type Item (line 38) | type Item = F::Output; method drive_unindexed (line 40) | fn drive_unindexed(self, consumer: C) -> C::Result method opt_len (line 48) | fn opt_len(&self) -> Option { method drive (line 59) | fn drive(self, consumer: C) -> C::Result method len (line 67) | fn len(&self) -> usize { method with_producer (line 71) | fn with_producer(self, callback: CB) -> CB::Output type MapProducer (line 109) | struct MapProducer<'f, P, F> { type Item (line 120) | type Item = F::Output; type IntoIter (line 121) | type IntoIter = iter::Map; method into_iter (line 123) | fn into_iter(self) -> Self::IntoIter { method min_len (line 127) | fn min_len(&self) -> usize { method max_len (line 130) | fn max_len(&self) -> usize { method split_at (line 134) | fn split_at(self, index: usize) -> (Self, Self) { method fold_with (line 148) | fn fold_with(self, folder: G) -> G type MapConsumer (line 163) | struct MapConsumer<'f, C, F> { function new (line 169) | fn new(base: C, map_op: &'f F) -> Self { type Folder (line 180) | type Folder = MapFolder<'f, C::Folder, F>; type Reducer (line 181) | type Reducer = C::Reducer; type Result (line 182) | type Result = C::Result; function split_at (line 184) | fn split_at(self, index: usize) -> (Self, Self, Self::Reducer) { function into_folder (line 193) | fn into_folder(self) -> Self::Folder { function full (line 200) | fn full(&self) -> bool { function split_off_left (line 211) | fn split_off_left(&self) -> Self { function to_reducer (line 215) | fn to_reducer(&self) -> Self::Reducer { type MapFolder (line 220) | struct MapFolder<'f, C, F> { type Result (line 230) | type Result = C::Result; function consume (line 232) | fn consume(self, item: T) -> Self { function consume_iter (line 240) | fn consume_iter(mut self, iter: I) -> Self function complete (line 248) | fn complete(self) -> C::Result { function full (line 252) | fn full(&self) -> bool { FILE: src/iter/map_with.rs type MapWith (line 13) | pub struct MapWith { method fmt (line 20) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { function new (line 30) | pub(super) fn new(base: I, item: T, map_op: F) -> Self { type Item (line 42) | type Item = R; method drive_unindexed (line 44) | fn drive_unindexed(self, consumer: C) -> C::Result method opt_len (line 52) | fn opt_len(&self) -> Option { method drive (line 64) | fn drive(self, consumer: C) -> C::Result method len (line 72) | fn len(&self) -> usize { method with_producer (line 76) | fn with_producer(self, callback: CB) -> CB::Output type MapWithProducer (line 118) | struct MapWithProducer<'f, P, U, F> { type Item (line 131) | type Item = R; type IntoIter (line 132) | type IntoIter = MapWithIter<'f, P::IntoIter, U, F>; method into_iter (line 134) | fn into_iter(self) -> Self::IntoIter { method min_len (line 142) | fn min_len(&self) -> usize { method max_len (line 145) | fn max_len(&self) -> usize { method split_at (line 149) | fn split_at(self, index: usize) -> (Self, Self) { method fold_with (line 165) | fn fold_with(self, folder: G) -> G type MapWithIter (line 178) | struct MapWithIter<'f, I, U, F> { type Item (line 190) | type Item = R; method next (line 192) | fn next(&mut self) -> Option { method size_hint (line 197) | fn size_hint(&self) -> (usize, Option) { method next_back (line 208) | fn next_back(&mut self) -> Option { type MapWithConsumer (line 225) | struct MapWithConsumer<'f, C, U, F> { function new (line 232) | fn new(base: C, item: U, map_op: &'f F) -> Self { type Folder (line 244) | type Folder = MapWithFolder<'f, C::Folder, U, F>; type Reducer (line 245) | type Reducer = C::Reducer; type Result (line 246) | type Result = C::Result; function split_at (line 248) | fn split_at(self, index: usize) -> (Self, Self, Self::Reducer) { function into_folder (line 257) | fn into_folder(self) -> Self::Folder { function full (line 265) | fn full(&self) -> bool { function split_off_left (line 277) | fn split_off_left(&self) -> Self { function to_reducer (line 281) | fn to_reducer(&self) -> Self::Reducer { type MapWithFolder (line 286) | struct MapWithFolder<'f, C, U, F> { type Result (line 297) | type Result = C::Result; function consume (line 299) | fn consume(mut self, item: T) -> Self { function consume_iter (line 305) | fn consume_iter(mut self, iter: I) -> Self function complete (line 323) | fn complete(self) -> C::Result { function full (line 327) | fn full(&self) -> bool { type MapInit (line 341) | pub struct MapInit { method fmt (line 348) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { function new (line 355) | pub(super) fn new(base: I, init: INIT, map_op: F) -> Self { type Item (line 367) | type Item = R; method drive_unindexed (line 369) | fn drive_unindexed(self, consumer: C) -> C::Result method opt_len (line 377) | fn opt_len(&self) -> Option { method drive (line 389) | fn drive(self, consumer: C) -> C::Result method len (line 397) | fn len(&self) -> usize { method with_producer (line 401) | fn with_producer(self, callback: CB) -> CB::Output type MapInitProducer (line 443) | struct MapInitProducer<'f, P, INIT, F> { type Item (line 456) | type Item = R; type IntoIter (line 457) | type IntoIter = MapWithIter<'f, P::IntoIter, U, F>; method into_iter (line 459) | fn into_iter(self) -> Self::IntoIter { method min_len (line 467) | fn min_len(&self) -> usize { method max_len (line 470) | fn max_len(&self) -> usize { method split_at (line 474) | fn split_at(self, index: usize) -> (Self, Self) { method fold_with (line 490) | fn fold_with(self, folder: G) -> G type MapInitConsumer (line 506) | struct MapInitConsumer<'f, C, INIT, F> { function new (line 513) | fn new(base: C, init: &'f INIT, map_op: &'f F) -> Self { type Folder (line 525) | type Folder = MapWithFolder<'f, C::Folder, U, F>; type Reducer (line 526) | type Reducer = C::Reducer; type Result (line 527) | type Result = C::Result; function split_at (line 529) | fn split_at(self, index: usize) -> (Self, Self, Self::Reducer) { function into_folder (line 538) | fn into_folder(self) -> Self::Folder { function full (line 546) | fn full(&self) -> bool { function split_off_left (line 558) | fn split_off_left(&self) -> Self { function to_reducer (line 562) | fn to_reducer(&self) -> Self::Reducer { FILE: src/iter/mod.rs type IntoParallelIterator (line 220) | pub trait IntoParallelIterator { method into_par_iter (line 249) | fn into_par_iter(self) -> Self::Iter; type Iter (line 2425) | type Iter = T; type Item (line 2426) | type Item = T::Item; method into_par_iter (line 2428) | fn into_par_iter(self) -> T { type IntoParallelRefIterator (line 262) | pub trait IntoParallelRefIterator<'data> { method par_iter (line 285) | fn par_iter(&'data self) -> Self::Iter; type Iter (line 292) | type Iter = <&'data I as IntoParallelIterator>::Iter; type Item (line 293) | type Item = <&'data I as IntoParallelIterator>::Item; method par_iter (line 295) | fn par_iter(&'data self) -> Self::Iter { type IntoParallelRefMutIterator (line 310) | pub trait IntoParallelRefMutIterator<'data> { method par_iter_mut (line 329) | fn par_iter_mut(&'data mut self) -> Self::Iter; type Iter (line 336) | type Iter = <&'data mut I as IntoParallelIterator>::Iter; type Item (line 337) | type Item = <&'data mut I as IntoParallelIterator>::Item; method par_iter_mut (line 339) | fn par_iter_mut(&'data mut self) -> Self::Iter { type ParallelIterator (line 357) | pub trait ParallelIterator: Sized + Send { method for_each (line 374) | fn for_each(self, op: OP) method for_each_with (line 404) | fn for_each_with(self, init: T, op: OP) method for_each_init (line 438) | fn for_each_init(self, init: INIT, op: OP) method try_for_each (line 466) | fn try_for_each(self, op: OP) -> R method try_for_each_with (line 505) | fn try_for_each_with(self, init: T, op: OP) -> R method try_for_each_init (line 547) | fn try_for_each_init(self, init: INIT, op: OP) -> R method count (line 571) | fn count(self) -> usize { method map (line 593) | fn map(self, map_op: F) -> Map method map_with (line 630) | fn map_with(self, init: T, map_op: F) -> MapWith method map_init (line 667) | fn map_init(self, init: INIT, map_op: F) -> MapInit(self) -> Cloned method copied (line 726) | fn copied<'a, T>(self) -> Copied method inspect (line 763) | fn inspect(self, inspect_op: OP) -> Inspect method update (line 783) | fn update(self, update_op: F) -> Update method filter (line 804) | fn filter
(self, filter_op: P) -> Filter method filter_map (line 829) | fn filter_map(self, filter_op: P) -> FilterMap method flat_map (line 855) | fn flat_map(self, map_op: F) -> FlatMap method flat_map_iter (line 901) | fn flat_map_iter(self, map_op: F) -> FlatMapIter method flatten (line 923) | fn flatten(self) -> Flatten method flatten_iter (line 946) | fn flatten_iter(self) -> FlattenIter method reduce (line 983) | fn reduce(self, identity: ID, op: OP) -> Self::Item method reduce_with (line 1017) | fn reduce_with(self, op: OP) -> Option method try_reduce (line 1071) | fn try_reduce(self, identity: ID, op: OP) -> Self::Item method try_reduce_with (line 1115) | fn try_reduce_with(self, op: OP) -> Option method fold (line 1256) | fn fold(self, identity: ID, fold_op: F) -> Fold method fold_with (line 1284) | fn fold_with(self, init: T, fold_op: F) -> FoldWith method try_fold (line 1317) | fn try_fold(self, identity: ID, fold_op: F) -> TryFold(self, init: T, fold_op: F) -> TryFoldWith(self) -> S method product (line 1410) | fn product
(self) -> P method min (line 1440) | fn min(self) -> Option method min_by (line 1464) | fn min_by(self, f: F) -> Option method min_by_key (line 1495) | fn min_by_key(self, f: F) -> Option method max (line 1538) | fn max(self) -> Option method max_by (line 1562) | fn max_by(self, f: F) -> Option method max_by_key (line 1593) | fn max_by_key(self, f: F) -> Option method chain (line 1629) | fn chain(self, chain: C) -> Chain method find_any (line 1659) | fn find_any
(self, predicate: P) -> Option method find_first (line 1692) | fn find_first
(self, predicate: P) -> Option method find_last (line 1721) | fn find_last
(self, predicate: P) -> Option method find_map_any (line 1751) | fn find_map_any(self, predicate: P) -> Option method find_map_first (line 1785) | fn find_map_first(self, predicate: P) -> Option method find_map_last (line 1819) | fn find_map_last(self, predicate: P) -> Option method find (line 1833) | fn find
(self, predicate: P) -> Option method any (line 1857) | fn any
(self, predicate: P) -> bool method all (line 1879) | fn all
(self, predicate: P) -> bool method while_some (line 1913) | fn while_some(self) -> WhileSome method panic_fuse (line 1951) | fn panic_fuse(self) -> PanicFuse { method collect (line 2054) | fn collect(self) -> C method unzip (line 2095) | fn unzip(self) -> (FromA, FromB) method partition (line 2125) | fn partition(self, predicate: P) -> (A, B) method partition_map (line 2177) | fn partition_map(self, predicate: P) -> (A, B) method intersperse (line 2200) | fn intersperse(self, element: Self::Item) -> Intersperse method take_any (line 2228) | fn take_any(self, n: usize) -> TakeAny { method skip_any (line 2253) | fn skip_any(self, n: usize) -> SkipAny { method take_any_while (line 2303) | fn take_any_while
(self, predicate: P) -> TakeAnyWhile method skip_any_while (line 2337) | fn skip_any_while
(self, predicate: P) -> SkipAnyWhile method collect_vec_list (line 2376) | fn collect_vec_list(self) -> LinkedList> { method drive_unindexed (line 2401) | fn drive_unindexed(self, consumer: C) -> C::Result method opt_len (line 2419) | fn opt_len(&self) -> Option { type IndexedParallelIterator (line 2440) | pub trait IndexedParallelIterator: ParallelIterator { method by_exponential_blocks (line 2474) | fn by_exponential_blocks(self) -> ExponentialBlocks { method by_uniform_blocks (line 2500) | fn by_uniform_blocks(self, block_size: usize) -> UniformBlocks { method collect_into_vec (line 2523) | fn collect_into_vec(self, target: &mut Vec) { method unzip_into_vecs (line 2548) | fn unzip_into_vecs(self, left: &mut Vec, right: &mut Vec) method zip (line 2575) | fn zip(self, zip_op: Z) -> Zip method zip_eq (line 2602) | fn zip_eq(self, zip_op: Z) -> ZipEq method interleave (line 2629) | fn interleave(self, other: I) -> Interleave method interleave_shortest (line 2647) | fn interleave_shortest(self, other: I) -> InterleaveShortest Chunks { method fold_chunks (line 2713) | fn fold_chunks( method fold_chunks_with (line 2751) | fn fold_chunks_with( method cmp (line 2779) | fn cmp(self, other: I) -> Ordering method partial_cmp (line 2817) | fn partial_cmp(self, other: I) -> Option method eq (line 2842) | fn eq(self, other: I) -> bool method ne (line 2858) | fn ne(self, other: I) -> bool method lt (line 2868) | fn lt(self, other: I) -> bool method le (line 2878) | fn le(self, other: I) -> bool method gt (line 2889) | fn gt(self, other: I) -> bool method ge (line 2899) | fn ge(self, other: I) -> bool method enumerate (line 2923) | fn enumerate(self) -> Enumerate { method step_by (line 2942) | fn step_by(self, step: usize) -> StepBy { method skip (line 2960) | fn skip(self, n: usize) -> Skip { method take (line 2978) | fn take(self, n: usize) -> Take { method position_any (line 3000) | fn position_any
(self, predicate: P) -> Option method position_first (line 3037) | fn position_first
(self, predicate: P) -> Option method position_last (line 3074) | fn position_last
(self, predicate: P) -> Option method position (line 3092) | fn position
(self, predicate: P) -> Option method positions (line 3117) | fn positions
(self, predicate: P) -> Positions method rev (line 3139) | fn rev(self) -> Rev { method with_min_len (line 3165) | fn with_min_len(self, min: usize) -> MinLen { method with_max_len (line 3193) | fn with_max_len(self, max: usize) -> MaxLen { method len (line 3211) | fn len(&self) -> usize; method drive (line 3227) | fn drive>(self, consumer: C) -> C::Result; method with_producer (line 3244) | fn with_producer>(self, callback: CB)... type FromParallelIterator (line 3281) | pub trait FromParallelIterator method from_par_iter (line 3301) | fn from_par_iter(par_iter: I) -> Self type ParallelExtend (line 3334) | pub trait ParallelExtend method par_extend (line 3351) | fn par_extend(&mut self, par_iter: I) type ParallelDrainFull (line 3361) | pub trait ParallelDrainFull { method par_drain (line 3394) | fn par_drain(self) -> Self::Iter; type ParallelDrainRange (line 3401) | pub trait ParallelDrainRange { method par_drain (line 3467) | fn par_drain>(self, range: R) -> Self::Iter; type Try (line 3480) | pub trait Try { method from_output (line 3486) | fn from_output(output: Self::Output) -> Self; method from_residual (line 3488) | fn from_residual(residual: Self::Residual) -> Self; method branch (line 3490) | fn branch(self) -> ControlFlow; type Output (line 3496) | type Output = C; type Residual (line 3497) | type Residual = ControlFlow; method from_output (line 3499) | fn from_output(output: Self::Output) -> Self { method from_residual (line 3503) | fn from_residual(residual: Self::Residual) -> Self { method branch (line 3511) | fn branch(self) -> ControlFlow { type Output (line 3522) | type Output = T; type Residual (line 3523) | type Residual = Option; method from_output (line 3525) | fn from_output(output: Self::Output) -> Self { method from_residual (line 3529) | fn from_residual(residual: Self::Residual) -> Self { method branch (line 3537) | fn branch(self) -> ControlFlow { type Output (line 3548) | type Output = T; type Residual (line 3549) | type Residual = Result; method from_output (line 3551) | fn from_output(output: Self::Output) -> Self { method from_residual (line 3555) | fn from_residual(residual: Self::Residual) -> Self { method branch (line 3563) | fn branch(self) -> ControlFlow { type Output (line 3574) | type Output = Poll; type Residual (line 3575) | type Residual = Result; method from_output (line 3577) | fn from_output(output: Self::Output) -> Self { method from_residual (line 3581) | fn from_residual(residual: Self::Residual) -> Self { method branch (line 3589) | fn branch(self) -> ControlFlow { type Output (line 3601) | type Output = Poll>; type Residual (line 3602) | type Residual = Result; method from_output (line 3604) | fn from_output(output: Self::Output) -> Self { method from_residual (line 3611) | fn from_residual(residual: Self::Residual) -> Self { method branch (line 3619) | fn branch(self) -> ControlFlow { FILE: src/iter/multizip.rs type MultiZip (line 79) | pub struct MultiZip { FILE: src/iter/noop.rs type NoopConsumer (line 3) | pub(super) struct NoopConsumer; type Folder (line 6) | type Folder = NoopConsumer; type Reducer (line 7) | type Reducer = NoopReducer; type Result (line 8) | type Result = (); method split_at (line 10) | fn split_at(self, _index: usize) -> (Self, Self, NoopReducer) { method into_folder (line 14) | fn into_folder(self) -> Self { method full (line 18) | fn full(&self) -> bool { type Result (line 24) | type Result = (); method consume (line 26) | fn consume(self, _item: T) -> Self { method consume_iter (line 30) | fn consume_iter(self, iter: I) -> Self method complete (line 38) | fn complete(self) {} method full (line 40) | fn full(&self) -> bool { method split_off_left (line 46) | fn split_off_left(&self) -> Self { method to_reducer (line 50) | fn to_reducer(&self) -> NoopReducer { type NoopReducer (line 55) | pub(super) struct NoopReducer; method reduce (line 58) | fn reduce(self, _left: (), _right: ()) {} FILE: src/iter/once.rs function once (line 24) | pub fn once(item: T) -> Once { type Once (line 32) | pub struct Once { type Item (line 37) | type Item = T; method drive_unindexed (line 39) | fn drive_unindexed(self, consumer: C) -> C::Result method opt_len (line 46) | fn opt_len(&self) -> Option { method drive (line 52) | fn drive(self, consumer: C) -> C::Result method len (line 59) | fn len(&self) -> usize { method with_producer (line 63) | fn with_producer(self, callback: CB) -> CB::Output FILE: src/iter/panic_fuse.rs type PanicFuse (line 14) | pub struct PanicFuse { type Fuse (line 20) | struct Fuse<'a>(&'a AtomicBool); method drop (line 24) | fn drop(&mut self) { function panicked (line 33) | fn panicked(&self) -> bool { function new (line 40) | pub(super) fn new(base: I) -> PanicFuse { type Item (line 49) | type Item = I::Item; method drive_unindexed (line 51) | fn drive_unindexed(self, consumer: C) -> C::Result method opt_len (line 63) | fn opt_len(&self) -> Option { method drive (line 72) | fn drive(self, consumer: C) -> C::Result method len (line 84) | fn len(&self) -> usize { method with_producer (line 88) | fn with_producer(self, callback: CB) -> CB::Output type PanicFuseProducer (line 122) | struct PanicFuseProducer<'a, P> { type Item (line 131) | type Item = P::Item; type IntoIter (line 132) | type IntoIter = PanicFuseIter<'a, P::IntoIter>; method into_iter (line 134) | fn into_iter(self) -> Self::IntoIter { method min_len (line 141) | fn min_len(&self) -> usize { method max_len (line 144) | fn max_len(&self) -> usize { method split_at (line 148) | fn split_at(self, index: usize) -> (Self, Self) { method fold_with (line 162) | fn fold_with(self, folder: G) -> G type PanicFuseIter (line 174) | struct PanicFuseIter<'a, I> { type Item (line 183) | type Item = I::Item; method next (line 185) | fn next(&mut self) -> Option { method size_hint (line 193) | fn size_hint(&self) -> (usize, Option) { method next_back (line 202) | fn next_back(&mut self) -> Option { method len (line 215) | fn len(&self) -> usize { type PanicFuseConsumer (line 223) | struct PanicFuseConsumer<'a, C> { type Folder (line 232) | type Folder = PanicFuseFolder<'a, C::Folder>; type Reducer (line 233) | type Reducer = PanicFuseReducer<'a, C::Reducer>; type Result (line 234) | type Result = C::Result; function split_at (line 236) | fn split_at(self, index: usize) -> (Self, Self, Self::Reducer) { function into_folder (line 254) | fn into_folder(self) -> Self::Folder { function full (line 261) | fn full(&self) -> bool { function split_off_left (line 270) | fn split_off_left(&self) -> Self { function to_reducer (line 277) | fn to_reducer(&self) -> Self::Reducer { type PanicFuseFolder (line 285) | struct PanicFuseFolder<'a, C> { type Result (line 294) | type Result = C::Result; function consume (line 296) | fn consume(mut self, item: T) -> Self { function consume_iter (line 301) | fn consume_iter(mut self, iter: I) -> Self function complete (line 317) | fn complete(self) -> C::Result { function full (line 321) | fn full(&self) -> bool { type PanicFuseReducer (line 326) | struct PanicFuseReducer<'a, C> { function reduce (line 335) | fn reduce(self, left: T, right: T) -> T { FILE: src/iter/par_bridge.rs type ParallelBridge (line 53) | pub trait ParallelBridge: Sized { method par_bridge (line 55) | fn par_bridge(self) -> IterBridge; method par_bridge (line 62) | fn par_bridge(self) -> IterBridge { type IterBridge (line 72) | pub struct IterBridge { type Item (line 80) | type Item = Iter::Item; method drive_unindexed (line 82) | fn drive_unindexed(self, consumer: C) -> C::Result type IterParallelProducer (line 100) | struct IterParallelProducer<'a, Iter> { type Item (line 107) | type Item = Iter::Item; method split (line 109) | fn split(self) -> (Self, Option) { method fold_with (line 117) | fn fold_with(self, mut folder: F) -> F FILE: src/iter/plumbing/mod.rs type ProducerCallback (line 17) | pub trait ProducerCallback { method callback (line 27) | fn callback
(self, producer: P) -> Self::Output type Producer (line 56) | pub trait Producer: Send + Sized { method into_iter (line 66) | fn into_iter(self) -> Self::IntoIter; method min_len (line 78) | fn min_len(&self) -> usize { method max_len (line 91) | fn max_len(&self) -> usize { method split_at (line 97) | fn split_at(self, index: usize) -> (Self, Self); method fold_with (line 103) | fn fold_with(self, folder: F) -> F type Consumer (line 123) | pub trait Consumer: Send + Sized { method split_at (line 137) | fn split_at(self, index: usize) -> (Self, Self, Self::Reducer); method into_folder (line 141) | fn into_folder(self) -> Self::Folder; method full (line 145) | fn full(&self) -> bool; type Folder (line 154) | pub trait Folder: Sized { method consume (line 159) | fn consume(self, item: Item) -> Self; method consume_iter (line 169) | fn consume_iter(mut self, iter: I) -> Self method complete (line 183) | fn complete(self) -> Self::Result; method full (line 187) | fn full(&self) -> bool; type Reducer (line 197) | pub trait Reducer { method reduce (line 200) | fn reduce(self, left: Result, right: Result) -> Result; type UnindexedConsumer (line 208) | pub trait UnindexedConsumer: Consumer { method split_off_left (line 216) | fn split_off_left(&self) -> Self; method to_reducer (line 220) | fn to_reducer(&self) -> Self::Reducer; type UnindexedProducer (line 231) | pub trait UnindexedProducer: Send + Sized { method split (line 236) | fn split(self) -> (Self, Option); method fold_with (line 240) | fn fold_with(self, folder: F) -> F type Splitter (line 251) | struct Splitter { method new (line 260) | fn new() -> Splitter { method try_split (line 267) | fn try_split(&mut self, stolen: bool) -> bool { type LengthSplitter (line 289) | struct LengthSplitter { method new (line 308) | fn new(min: usize, max: usize, len: usize) -> LengthSplitter { method try_split (line 329) | fn try_split(&mut self, len: usize, stolen: bool) -> bool { function bridge (line 346) | pub fn bridge(par_iter: I, consumer: C) -> C::Result function bridge_producer_consumer (line 385) | pub fn bridge_producer_consumer(len: usize, producer: P, consumer:... function bridge_unindexed (line 438) | pub fn bridge_unindexed(producer: P, consumer: C) -> C::Result function bridge_unindexed_producer_consumer (line 447) | fn bridge_unindexed_producer_consumer( FILE: src/iter/positions.rs type Positions (line 14) | pub struct Positions { method fmt (line 20) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { function new (line 29) | pub(super) fn new(base: I, predicate: P) -> Self { type Item (line 39) | type Item = usize; method drive_unindexed (line 41) | fn drive_unindexed(self, consumer: C) -> C::Result type PositionsConsumer (line 53) | struct PositionsConsumer<'p, C, P> { function new (line 60) | fn new(base: C, predicate: &'p P, offset: usize) -> Self { type Folder (line 74) | type Folder = PositionsFolder<'p, C::Folder, P>; type Reducer (line 75) | type Reducer = C::Reducer; type Result (line 76) | type Result = C::Result; function split_at (line 78) | fn split_at(self, index: usize) -> (Self, Self, C::Reducer) { function into_folder (line 87) | fn into_folder(self) -> Self::Folder { function full (line 95) | fn full(&self) -> bool { type PositionsFolder (line 100) | struct PositionsFolder<'p, F, P> { type Result (line 111) | type Result = F::Result; function consume (line 113) | fn consume(mut self, item: T) -> Self { function complete (line 126) | fn complete(self) -> Self::Result { function full (line 130) | fn full(&self) -> bool { FILE: src/iter/product.rs function product (line 7) | pub(super) fn product(pi: PI) -> P function mul (line 15) | fn mul(left: T, right: T) -> T { type ProductConsumer (line 19) | struct ProductConsumer { function new (line 26) | fn new() -> ProductConsumer
{ type Folder (line 37) | type Folder = ProductFolder
; type Reducer (line 38) | type Reducer = Self; type Result (line 39) | type Result = P; function split_at (line 41) | fn split_at(self, _index: usize) -> (Self, Self, Self) { function into_folder (line 49) | fn into_folder(self) -> Self::Folder { function full (line 55) | fn full(&self) -> bool { function split_off_left (line 64) | fn split_off_left(&self) -> Self { function to_reducer (line 68) | fn to_reducer(&self) -> Self::Reducer { function reduce (line 77) | fn reduce(self, left: P, right: P) -> P { type ProductFolder (line 82) | struct ProductFolder
{ type Result (line 90) | type Result = P; function consume (line 92) | fn consume(self, item: T) -> Self { function consume_iter (line 98) | fn consume_iter(self, iter: I) -> Self function complete (line 107) | fn complete(self) -> P { function full (line 111) | fn full(&self) -> bool { FILE: src/iter/reduce.rs function reduce (line 4) | pub(super) fn reduce(pi: PI, identity: ID, reduce_op: R) -> T type ReduceConsumer (line 18) | struct ReduceConsumer<'r, R, ID> { method clone (line 26) | fn clone(&self) -> Self { type Folder (line 37) | type Folder = ReduceFolder<'r, R, T>; type Reducer (line 38) | type Reducer = Self; type Result (line 39) | type Result = T; function split_at (line 41) | fn split_at(self, _index: usize) -> (Self, Self, Self) { function into_folder (line 45) | fn into_folder(self) -> Self::Folder { function full (line 52) | fn full(&self) -> bool { function split_off_left (line 63) | fn split_off_left(&self) -> Self { function to_reducer (line 67) | fn to_reducer(&self) -> Self::Reducer { function reduce (line 76) | fn reduce(self, left: T, right: T) -> T { type ReduceFolder (line 81) | struct ReduceFolder<'r, R, T> { type Result (line 90) | type Result = T; function consume (line 92) | fn consume(self, item: T) -> Self { function consume_iter (line 99) | fn consume_iter(self, iter: I) -> Self function complete (line 109) | fn complete(self) -> T { function full (line 113) | fn full(&self) -> bool { FILE: src/iter/repeat.rs type Repeat (line 10) | pub struct Repeat { function repeat (line 30) | pub fn repeat(element: T) -> Repeat { function take (line 45) | pub fn take(self, n: usize) -> RepeatN { function zip (line 53) | pub fn zip(self, zip_op: Z) -> Zip, Z::Iter> type Item (line 67) | type Item = T; method drive_unindexed (line 69) | fn drive_unindexed(self, consumer: C) -> C::Result type RepeatProducer (line 81) | struct RepeatProducer { type Item (line 86) | type Item = T; method split (line 88) | fn split(self) -> (Self, Option) { method fold_with (line 99) | fn fold_with(self, folder: F) -> F type RepeatN (line 111) | pub struct RepeatN { function repeat_n (line 126) | pub fn repeat_n(element: T, n: usize) -> RepeatN { function repeatn (line 139) | pub fn repeatn(element: T, n: usize) -> RepeatN { function fmt (line 144) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { type Item (line 160) | type Item = T; method drive_unindexed (line 162) | fn drive_unindexed(self, consumer: C) -> C::Result method opt_len (line 169) | fn opt_len(&self) -> Option { method drive (line 178) | fn drive(self, consumer: C) -> C::Result method with_producer (line 185) | fn with_producer(self, callback: CB) -> CB::Output method len (line 192) | fn len(&self) -> usize { type RepeatNProducer (line 199) | enum RepeatNProducer { type Item (line 205) | type Item = T; type IntoIter (line 206) | type IntoIter = Self; method into_iter (line 208) | fn into_iter(self) -> Self::IntoIter { method split_at (line 214) | fn split_at(self, index: usize) -> (Self, Self) { type Item (line 237) | type Item = T; method next (line 240) | fn next(&mut self) -> Option { method nth (line 257) | fn nth(&mut self, n: usize) -> Option { method size_hint (line 269) | fn size_hint(&self) -> (usize, Option) { method next_back (line 277) | fn next_back(&mut self) -> Option { method nth_back (line 282) | fn nth_back(&mut self, n: usize) -> Option { method len (line 289) | fn len(&self) -> usize { FILE: src/iter/rev.rs type Rev (line 11) | pub struct Rev { function new (line 17) | pub(super) fn new(base: I) -> Self { type Item (line 26) | type Item = I::Item; method drive_unindexed (line 28) | fn drive_unindexed(self, consumer: C) -> C::Result method opt_len (line 35) | fn opt_len(&self) -> Option { method drive (line 44) | fn drive>(self, consumer: C) -> C::Result { method len (line 48) | fn len(&self) -> usize { method with_producer (line 52) | fn with_producer(self, callback: CB) -> CB::Output type RevProducer (line 83) | struct RevProducer
{ type Item (line 92) | type Item = P::Item; type IntoIter (line 93) | type IntoIter = iter::Rev; method into_iter (line 95) | fn into_iter(self) -> Self::IntoIter { method min_len (line 99) | fn min_len(&self) -> usize { method max_len (line 102) | fn max_len(&self) -> usize { method split_at (line 106) | fn split_at(self, index: usize) -> (Self, Self) { FILE: src/iter/skip.rs type Skip (line 11) | pub struct Skip { function new (line 21) | pub(super) fn new(base: I, n: usize) -> Self { type Item (line 31) | type Item = I::Item; method drive_unindexed (line 33) | fn drive_unindexed(self, consumer: C) -> C::Result method opt_len (line 40) | fn opt_len(&self) -> Option { method len (line 49) | fn len(&self) -> usize { method drive (line 53) | fn drive>(self, consumer: C) -> C::Result { method with_producer (line 57) | fn with_producer(self, callback: CB) -> CB::Output FILE: src/iter/skip_any.rs type SkipAny (line 11) | pub struct SkipAny { function new (line 18) | pub(super) fn new(base: I, count: usize) -> Self { type Item (line 27) | type Item = I::Item; method drive_unindexed (line 29) | fn drive_unindexed(self, consumer: C) -> C::Result type SkipAnyConsumer (line 44) | struct SkipAnyConsumer<'f, C> { type Folder (line 54) | type Folder = SkipAnyFolder<'f, C::Folder>; type Reducer (line 55) | type Reducer = C::Reducer; type Result (line 56) | type Result = C::Result; function split_at (line 58) | fn split_at(self, index: usize) -> (Self, Self, Self::Reducer) { function into_folder (line 70) | fn into_folder(self) -> Self::Folder { function full (line 77) | fn full(&self) -> bool { function split_off_left (line 87) | fn split_off_left(&self) -> Self { function to_reducer (line 94) | fn to_reducer(&self) -> Self::Reducer { type SkipAnyFolder (line 99) | struct SkipAnyFolder<'f, C> { function checked_decrement (line 104) | fn checked_decrement(u: &AtomicUsize) -> bool { type Result (line 113) | type Result = C::Result; function consume (line 115) | fn consume(mut self, item: T) -> Self { function consume_iter (line 122) | fn consume_iter(mut self, iter: I) -> Self function complete (line 133) | fn complete(self) -> C::Result { function full (line 137) | fn full(&self) -> bool { FILE: src/iter/skip_any_while.rs type SkipAnyWhile (line 13) | pub struct SkipAnyWhile { function fmt (line 19) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { function new (line 28) | pub(super) fn new(base: I, predicate: P) -> Self { type Item (line 38) | type Item = I::Item; method drive_unindexed (line 40) | fn drive_unindexed(self, consumer: C) -> C::Result type SkipAnyWhileConsumer (line 56) | struct SkipAnyWhileConsumer<'p, C, P> { type Folder (line 67) | type Folder = SkipAnyWhileFolder<'p, C::Folder, P>; type Reducer (line 68) | type Reducer = C::Reducer; type Result (line 69) | type Result = C::Result; function split_at (line 71) | fn split_at(self, index: usize) -> (Self, Self, Self::Reducer) { function into_folder (line 83) | fn into_folder(self) -> Self::Folder { function full (line 91) | fn full(&self) -> bool { function split_off_left (line 101) | fn split_off_left(&self) -> Self { function to_reducer (line 108) | fn to_reducer(&self) -> Self::Reducer { type SkipAnyWhileFolder (line 113) | struct SkipAnyWhileFolder<'p, C, P> { function skip (line 119) | fn skip(item: &T, skipping: &AtomicBool, predicate: &impl Fn(&T) -> b... type Result (line 135) | type Result = C::Result; function consume (line 137) | fn consume(mut self, item: T) -> Self { function consume_iter (line 144) | fn consume_iter(mut self, iter: I) -> Self function complete (line 155) | fn complete(self) -> C::Result { function full (line 159) | fn full(&self) -> bool { FILE: src/iter/splitter.rs function split (line 106) | pub fn split(data: D, splitter: S) -> Split type Split (line 117) | pub struct Split { method fmt (line 123) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { type Item (line 133) | type Item = D; method drive_unindexed (line 135) | fn drive_unindexed(self, consumer: C) -> C::Result type SplitProducer (line 147) | struct SplitProducer<'a, D, S> { type Item (line 157) | type Item = D; method split (line 159) | fn split(mut self) -> (Self, Option) { method fold_with (line 166) | fn fold_with(self, folder: F) -> F FILE: src/iter/step_by.rs type StepBy (line 11) | pub struct StepBy { function new (line 18) | pub(super) fn new(base: I, step: usize) -> Self { type Item (line 27) | type Item = I::Item; method drive_unindexed (line 29) | fn drive_unindexed(self, consumer: C) -> C::Result method opt_len (line 36) | fn opt_len(&self) -> Option { method drive (line 45) | fn drive>(self, consumer: C) -> C::Result { method len (line 49) | fn len(&self) -> usize { method with_producer (line 53) | fn with_producer(self, callback: CB) -> CB::Output type StepByProducer (line 93) | struct StepByProducer
{ type Item (line 103) | type Item = P::Item; type IntoIter (line 104) | type IntoIter = iter::StepBy; method into_iter (line 106) | fn into_iter(self) -> Self::IntoIter { method split_at (line 110) | fn split_at(self, index: usize) -> (Self, Self) { method min_len (line 128) | fn min_len(&self) -> usize { method max_len (line 132) | fn max_len(&self) -> usize { FILE: src/iter/sum.rs function sum (line 7) | pub(super) fn sum(pi: PI) -> S function add (line 15) | fn add(left: T, right: T) -> T { type SumConsumer (line 19) | struct SumConsumer { function new (line 26) | fn new() -> SumConsumer { type Folder (line 37) | type Folder = SumFolder; type Reducer (line 38) | type Reducer = Self; type Result (line 39) | type Result = S; function split_at (line 41) | fn split_at(self, _index: usize) -> (Self, Self, Self) { function into_folder (line 45) | fn into_folder(self) -> Self::Folder { function full (line 51) | fn full(&self) -> bool { function split_off_left (line 60) | fn split_off_left(&self) -> Self { function to_reducer (line 64) | fn to_reducer(&self) -> Self::Reducer { function reduce (line 73) | fn reduce(self, left: S, right: S) -> S { type SumFolder (line 78) | struct SumFolder { type Result (line 86) | type Result = S; function consume (line 88) | fn consume(self, item: T) -> Self { function consume_iter (line 94) | fn consume_iter(self, iter: I) -> Self function complete (line 103) | fn complete(self) -> S { function full (line 107) | fn full(&self) -> bool { FILE: src/iter/take.rs type Take (line 10) | pub struct Take { function new (line 20) | pub(super) fn new(base: I, n: usize) -> Self { type Item (line 30) | type Item = I::Item; method drive_unindexed (line 32) | fn drive_unindexed(self, consumer: C) -> C::Result method opt_len (line 39) | fn opt_len(&self) -> Option { method len (line 48) | fn len(&self) -> usize { method drive (line 52) | fn drive>(self, consumer: C) -> C::Result { method with_producer (line 56) | fn with_producer(self, callback: CB) -> CB::Output FILE: src/iter/take_any.rs type TakeAny (line 11) | pub struct TakeAny { function new (line 18) | pub(super) fn new(base: I, count: usize) -> Self { type Item (line 27) | type Item = I::Item; method drive_unindexed (line 29) | fn drive_unindexed(self, consumer: C) -> C::Result type TakeAnyConsumer (line 44) | struct TakeAnyConsumer<'f, C> { type Folder (line 54) | type Folder = TakeAnyFolder<'f, C::Folder>; type Reducer (line 55) | type Reducer = C::Reducer; type Result (line 56) | type Result = C::Result; function split_at (line 58) | fn split_at(self, index: usize) -> (Self, Self, Self::Reducer) { function into_folder (line 70) | fn into_folder(self) -> Self::Folder { function full (line 77) | fn full(&self) -> bool { function split_off_left (line 87) | fn split_off_left(&self) -> Self { function to_reducer (line 94) | fn to_reducer(&self) -> Self::Reducer { type TakeAnyFolder (line 99) | struct TakeAnyFolder<'f, C> { function checked_decrement (line 104) | fn checked_decrement(u: &AtomicUsize) -> bool { type Result (line 113) | type Result = C::Result; function consume (line 115) | fn consume(mut self, item: T) -> Self { function consume_iter (line 122) | fn consume_iter(mut self, iter: I) -> Self function complete (line 133) | fn complete(self) -> C::Result { function full (line 137) | fn full(&self) -> bool { FILE: src/iter/take_any_while.rs type TakeAnyWhile (line 13) | pub struct TakeAnyWhile { function fmt (line 19) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { function new (line 28) | pub(super) fn new(base: I, predicate: P) -> Self { type Item (line 38) | type Item = I::Item; method drive_unindexed (line 40) | fn drive_unindexed(self, consumer: C) -> C::Result type TakeAnyWhileConsumer (line 56) | struct TakeAnyWhileConsumer<'p, C, P> { type Folder (line 67) | type Folder = TakeAnyWhileFolder<'p, C::Folder, P>; type Reducer (line 68) | type Reducer = C::Reducer; type Result (line 69) | type Result = C::Result; function split_at (line 71) | fn split_at(self, index: usize) -> (Self, Self, Self::Reducer) { function into_folder (line 83) | fn into_folder(self) -> Self::Folder { function full (line 91) | fn full(&self) -> bool { function split_off_left (line 101) | fn split_off_left(&self) -> Self { function to_reducer (line 108) | fn to_reducer(&self) -> Self::Reducer { type TakeAnyWhileFolder (line 113) | struct TakeAnyWhileFolder<'p, C, P> { function take (line 119) | fn take(item: &T, taking: &AtomicBool, predicate: &impl Fn(&T) -> boo... type Result (line 135) | type Result = C::Result; function consume (line 137) | fn consume(mut self, item: T) -> Self { function consume_iter (line 144) | fn consume_iter(mut self, iter: I) -> Self function complete (line 155) | fn complete(self) -> C::Result { function full (line 159) | fn full(&self) -> bool { FILE: src/iter/test.rs function is_indexed (line 16) | fn is_indexed(_: T) {} function seeded_rng (line 18) | fn seeded_rng() -> XorShiftRng { function execute (line 25) | fn execute() { function execute_cloned (line 34) | fn execute_cloned() { function execute_range (line 43) | fn execute_range() { function execute_unindexed_range (line 52) | fn execute_unindexed_range() { function execute_pseudo_indexed_range (line 60) | fn execute_pseudo_indexed_range() { function check_map_indexed (line 73) | fn check_map_indexed() { function map_sum (line 79) | fn map_sum() { function map_reduce (line 87) | fn map_reduce() { function map_reduce_with (line 95) | fn map_reduce_with() { function fold_map_reduce (line 103) | fn fold_map_reduce() { function fold_is_full (line 166) | fn fold_is_full() { function check_step_by (line 180) | fn check_step_by() { function check_step_by_unaligned (line 188) | fn check_step_by_unaligned() { function check_step_by_rev (line 196) | fn check_step_by_rev() { function check_enumerate (line 204) | fn check_enumerate() { function check_enumerate_rev (line 216) | fn check_enumerate_rev() { function check_indices_after_enumerate_split (line 229) | fn check_indices_after_enumerate_split() { function check_increment (line 254) | fn check_increment() { function check_skip (line 263) | fn check_skip() { function check_take (line 293) | fn check_take() { function check_inspect (line 313) | fn check_inspect() { function check_move (line 328) | fn check_move() { function check_drops (line 340) | fn check_drops() { function check_slice_indexed (line 378) | fn check_slice_indexed() { function check_slice_mut_indexed (line 384) | fn check_slice_mut_indexed() { function check_vec_indexed (line 390) | fn check_vec_indexed() { function check_range_indexed (line 396) | fn check_range_indexed() { function check_cmp_direct (line 401) | fn check_cmp_direct() { function check_cmp_to_seq (line 411) | fn check_cmp_to_seq() { function check_cmp_rng_to_seq (line 419) | fn check_cmp_rng_to_seq() { function check_cmp_lt_direct (line 433) | fn check_cmp_lt_direct() { function check_cmp_lt_to_seq (line 443) | fn check_cmp_lt_to_seq() { function check_cmp_gt_direct (line 451) | fn check_cmp_gt_direct() { function check_cmp_gt_to_seq (line 461) | fn check_cmp_gt_to_seq() { function check_cmp_short_circuit (line 470) | fn check_cmp_short_circuit() { function check_partial_cmp_short_circuit (line 500) | fn check_partial_cmp_short_circuit() { function check_partial_cmp_nan_short_circuit (line 530) | fn check_partial_cmp_nan_short_circuit() { function check_partial_cmp_direct (line 559) | fn check_partial_cmp_direct() { function check_partial_cmp_to_seq (line 569) | fn check_partial_cmp_to_seq() { function check_partial_cmp_rng_to_seq (line 576) | fn check_partial_cmp_rng_to_seq() { function check_partial_cmp_lt_direct (line 590) | fn check_partial_cmp_lt_direct() { function check_partial_cmp_lt_to_seq (line 600) | fn check_partial_cmp_lt_to_seq() { function check_partial_cmp_gt_direct (line 607) | fn check_partial_cmp_gt_direct() { function check_partial_cmp_gt_to_seq (line 617) | fn check_partial_cmp_gt_to_seq() { function check_partial_cmp_none_direct (line 624) | fn check_partial_cmp_none_direct() { function check_partial_cmp_none_to_seq (line 634) | fn check_partial_cmp_none_to_seq() { function check_partial_cmp_late_nan_direct (line 645) | fn check_partial_cmp_late_nan_direct() { function check_partial_cmp_late_nan_to_seq (line 655) | fn check_partial_cmp_late_nan_to_seq() { function check_cmp_lengths (line 666) | fn check_cmp_lengths() { function check_eq_direct (line 676) | fn check_eq_direct() { function check_eq_to_seq (line 686) | fn check_eq_to_seq() { function check_ne_direct (line 694) | fn check_ne_direct() { function check_ne_to_seq (line 704) | fn check_ne_to_seq() { function check_ne_lengths (line 712) | fn check_ne_lengths() { function check_lt_direct (line 722) | fn check_lt_direct() { function check_lt_to_seq (line 728) | fn check_lt_to_seq() { function check_le_equal_direct (line 736) | fn check_le_equal_direct() { function check_le_equal_to_seq (line 741) | fn check_le_equal_to_seq() { function check_le_less_direct (line 749) | fn check_le_less_direct() { function check_le_less_to_seq (line 754) | fn check_le_less_to_seq() { function check_gt_direct (line 762) | fn check_gt_direct() { function check_gt_to_seq (line 767) | fn check_gt_to_seq() { function check_ge_equal_direct (line 775) | fn check_ge_equal_direct() { function check_ge_equal_to_seq (line 780) | fn check_ge_equal_to_seq() { function check_ge_greater_direct (line 788) | fn check_ge_greater_direct() { function check_ge_greater_to_seq (line 793) | fn check_ge_greater_to_seq() { function check_zip (line 801) | fn check_zip() { function check_zip_into_par_iter (line 811) | fn check_zip_into_par_iter() { function check_zip_into_mut_par_iter (line 823) | fn check_zip_into_mut_par_iter() { function check_zip_range (line 833) | fn check_zip_range() { function check_zip_eq (line 844) | fn check_zip_eq() { function check_zip_eq_into_par_iter (line 854) | fn check_zip_eq_into_par_iter() { function check_zip_eq_into_mut_par_iter (line 866) | fn check_zip_eq_into_mut_par_iter() { function check_zip_eq_range (line 876) | fn check_zip_eq_range() { function check_sum_filtered_ints (line 887) | fn check_sum_filtered_ints() { function check_sum_filtermap_ints (line 895) | fn check_sum_filtermap_ints() { function check_flat_map_nested_ranges (line 909) | fn check_flat_map_nested_ranges() { function check_empty_flat_map_sum (line 927) | fn check_empty_flat_map_sum() { function check_flatten_vec (line 941) | fn check_flatten_vec() { function check_flatten_vec_empty (line 954) | fn check_flatten_vec_empty() { function check_slice_split (line 962) | fn check_slice_split() { function check_slice_split_inclusive (line 985) | fn check_slice_split_inclusive() { function check_slice_split_mut (line 1004) | fn check_slice_split_mut() { function check_slice_split_inclusive_mut (line 1022) | fn check_slice_split_inclusive_mut() { function check_chunks (line 1042) | fn check_chunks() { function check_chunks_mut (line 1056) | fn check_chunks_mut() { function check_windows (line 1073) | fn check_windows() { function check_options (line 1101) | fn check_options() { function check_results (line 1115) | fn check_results() { function check_binary_heap (line 1134) | fn check_binary_heap() { function check_btree_map (line 1144) | fn check_btree_map() { function check_btree_set (line 1158) | fn check_btree_set() { function check_hash_map (line 1168) | fn check_hash_map() { function check_hash_set (line 1182) | fn check_hash_set() { function check_linked_list (line 1192) | fn check_linked_list() { function check_vec_deque (line 1205) | fn check_vec_deque() { function check_chain (line 1222) | fn check_chain() { function check_count (line 1278) | fn check_count() { function find_any (line 1288) | fn find_any() { function find_first_or_last (line 1313) | fn find_first_or_last() { function find_map_first_or_last_or_any (line 1352) | fn find_map_first_or_last_or_any() { function check_find_not_present (line 1396) | fn check_find_not_present() { function check_find_is_present (line 1407) | fn check_find_is_present() { function check_while_some (line 1419) | fn check_while_some() { function par_iter_collect_option (line 1441) | fn par_iter_collect_option() { function par_iter_collect_result (line 1454) | fn par_iter_collect_result() { function par_iter_collect (line 1473) | fn par_iter_collect() { function par_iter_collect_vecdeque (line 1481) | fn par_iter_collect_vecdeque() { function par_iter_collect_binaryheap (line 1489) | fn par_iter_collect_binaryheap() { function par_iter_collect_hashmap (line 1501) | fn par_iter_collect_hashmap() { function par_iter_collect_hashset (line 1509) | fn par_iter_collect_hashset() { function par_iter_collect_btreemap (line 1516) | fn par_iter_collect_btreemap() { function par_iter_collect_btreeset (line 1524) | fn par_iter_collect_btreeset() { function par_iter_collect_linked_list (line 1531) | fn par_iter_collect_linked_list() { function par_iter_collect_linked_list_flat_map_filter (line 1539) | fn par_iter_collect_linked_list_flat_map_filter() { function par_iter_collect_cows (line 1553) | fn par_iter_collect_cows() { function par_iter_unindexed_flat_map (line 1594) | fn par_iter_unindexed_flat_map() { function min_max (line 1601) | fn min_max() { function min_max_by (line 1612) | fn min_max_by() { function min_max_by_key (line 1631) | fn min_max_by_key() { function check_rev (line 1650) | fn check_rev() { function scope_mix (line 1658) | fn scope_mix() { function divide_and_conquer (line 1673) | fn divide_and_conquer<'scope>(scope: &Scope<'scope>, counter: &'scope At... function check_split (line 1684) | fn check_split() { function check_lengths (line 1703) | fn check_lengths() { function check_map_with (line 1733) | fn check_map_with() { function check_fold_with (line 1747) | fn check_fold_with() { function check_for_each_with (line 1764) | fn check_for_each_with() { function check_extend_items (line 1777) | fn check_extend_items() { function check_extend_heap (line 1811) | fn check_extend_heap() { function check_extend_pairs (line 1831) | fn check_extend_pairs() { function check_unzip_into_vecs (line 1863) | fn check_unzip_into_vecs() { function check_unzip (line 1878) | fn check_unzip() { function check_partition (line 1908) | fn check_partition() { function check_partition_map (line 1916) | fn check_partition_map() { function check_either (line 1930) | fn check_either() { function check_either_extend (line 1950) | fn check_either_extend() { function check_interleave_eq (line 1967) | fn check_interleave_eq() { function check_interleave_uneven (line 1985) | fn check_interleave_uneven() { function check_interleave_shortest (line 2040) | fn check_interleave_shortest() { function check_chunks_zero_size (line 2088) | fn check_chunks_zero_size() { function check_chunks_even_size (line 2093) | fn check_chunks_even_size() { function check_chunks_empty (line 2101) | fn check_chunks_empty() { function check_chunks_len (line 2111) | fn check_chunks_len() { function check_chunks_uneven (line 2120) | fn check_chunks_uneven() { function check_repeat_unbounded (line 2149) | fn check_repeat_unbounded() { function check_repeat_find_any (line 2159) | fn check_repeat_find_any() { function check_repeat_take (line 2165) | fn check_repeat_take() { function check_repeat_zip (line 2171) | fn check_repeat_zip() { function check_repeat_n_zip_left (line 2181) | fn check_repeat_n_zip_left() { function check_repeat_n_zip_right (line 2191) | fn check_repeat_n_zip_right() { function count_repeat_n_clones (line 2201) | fn count_repeat_n_clones() { function check_empty (line 2265) | fn check_empty() { function check_once (line 2280) | fn check_once() { function check_update (line 2295) | fn check_update() { function walk_tree_prefix (line 2303) | fn walk_tree_prefix() { function walk_tree_postfix (line 2318) | fn walk_tree_postfix() { function walk_flat_tree_prefix (line 2333) | fn walk_flat_tree_prefix() { function walk_flat_tree_postfix (line 2340) | fn walk_flat_tree_postfix() { function walk_tree_prefix_degree5 (line 2347) | fn walk_tree_prefix_degree5() { function walk_tree_postfix_degree5 (line 2363) | fn walk_tree_postfix_degree5() { function blocks (line 2379) | fn blocks() { FILE: src/iter/try_fold.rs function new (line 10) | pub(super) fn new(base: I, identity: ID, fold_op: F) -> Self { type TryFold (line 26) | pub struct TryFold { method fmt (line 34) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { type Item (line 46) | type Item = U; method drive_unindexed (line 48) | fn drive_unindexed(self, consumer: C) -> C::Result type TryFoldConsumer (line 62) | struct TryFoldConsumer<'c, U, C, ID, F> { type Folder (line 76) | type Folder = TryFoldFolder<'r, C::Folder, U, F>; type Reducer (line 77) | type Reducer = C::Reducer; type Result (line 78) | type Result = C::Result; function split_at (line 80) | fn split_at(self, index: usize) -> (Self, Self, Self::Reducer) { function into_folder (line 92) | fn into_folder(self) -> Self::Folder { function full (line 100) | fn full(&self) -> bool { function split_off_left (line 112) | fn split_off_left(&self) -> Self { function to_reducer (line 119) | fn to_reducer(&self) -> Self::Reducer { type TryFoldFolder (line 124) | struct TryFoldFolder<'r, C, U: Try, F> { type Result (line 136) | type Result = C::Result; function consume (line 138) | fn consume(mut self, item: T) -> Self { function complete (line 146) | fn complete(self) -> C::Result { function full (line 154) | fn full(&self) -> bool { function new (line 165) | pub(super) fn new(base: I, item: U::Output, fold_op: F) -> Self { type TryFoldWith (line 180) | pub struct TryFoldWith { method fmt (line 191) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { type Item (line 205) | type Item = U; method drive_unindexed (line 207) | fn drive_unindexed(self, consumer: C) -> C::Result type TryFoldWithConsumer (line 220) | struct TryFoldWithConsumer<'c, C, U: Try, F> { type Folder (line 232) | type Folder = TryFoldFolder<'r, C::Folder, U, F>; type Reducer (line 233) | type Reducer = C::Reducer; type Result (line 234) | type Result = C::Result; function split_at (line 236) | fn split_at(self, index: usize) -> (Self, Self, Self::Reducer) { function into_folder (line 252) | fn into_folder(self) -> Self::Folder { function full (line 260) | fn full(&self) -> bool { function split_off_left (line 271) | fn split_off_left(&self) -> Self { function to_reducer (line 279) | fn to_reducer(&self) -> Self::Reducer { FILE: src/iter/try_reduce.rs function try_reduce (line 8) | pub(super) fn try_reduce(pi: PI, identity: ID, reduce_op: ... type TryReduceConsumer (line 24) | struct TryReduceConsumer<'r, R, ID> { method clone (line 33) | fn clone(&self) -> Self { type Folder (line 44) | type Folder = TryReduceFolder<'r, R, T>; type Reducer (line 45) | type Reducer = Self; type Result (line 46) | type Result = T; function split_at (line 48) | fn split_at(self, _index: usize) -> (Self, Self, Self) { function into_folder (line 52) | fn into_folder(self) -> Self::Folder { function full (line 60) | fn full(&self) -> bool { function split_off_left (line 71) | fn split_off_left(&self) -> Self { function to_reducer (line 75) | fn to_reducer(&self) -> Self::Reducer { function reduce (line 85) | fn reduce(self, left: T, right: T) -> T { type TryReduceFolder (line 93) | struct TryReduceFolder<'r, R, T: Try> { type Result (line 104) | type Result = T; function consume (line 106) | fn consume(mut self, item: T) -> Self { function complete (line 118) | fn complete(self) -> T { function full (line 125) | fn full(&self) -> bool { FILE: src/iter/try_reduce_with.rs function try_reduce_with (line 8) | pub(super) fn try_reduce_with(pi: PI, reduce_op: R) -> Option type TryReduceWithConsumer (line 22) | struct TryReduceWithConsumer<'r, R> { method clone (line 30) | fn clone(&self) -> Self { type Folder (line 40) | type Folder = TryReduceWithFolder<'r, R, T>; type Reducer (line 41) | type Reducer = Self; type Result (line 42) | type Result = Option; function split_at (line 44) | fn split_at(self, _index: usize) -> (Self, Self, Self) { function into_folder (line 48) | fn into_folder(self) -> Self::Folder { function full (line 56) | fn full(&self) -> bool { function split_off_left (line 66) | fn split_off_left(&self) -> Self { function to_reducer (line 70) | fn to_reducer(&self) -> Self::Reducer { function reduce (line 80) | fn reduce(self, left: Option, right: Option) -> Option { type TryReduceWithFolder (line 92) | struct TryReduceWithFolder<'r, R, T: Try> { type Result (line 103) | type Result = Option; function consume (line 105) | fn consume(mut self, item: T) -> Self { function complete (line 118) | fn complete(self) -> Option { function full (line 126) | fn full(&self) -> bool { FILE: src/iter/unzip.rs type UnzipOp (line 7) | trait UnzipOp: Sync + Send { method consume (line 15) | fn consume(&self, item: T, left: FA, right: FB) -> (FA, FB) method indexable (line 23) | fn indexable() -> bool { function execute (line 29) | fn execute(pi: I, op: OP) -> (FromA, FromB) function execute_into (line 43) | fn execute_into(a: &mut FromA, b: &mut FromB, pi: I... function unzip (line 61) | pub(super) fn unzip(pi: I) -> (FromA, FromB) function unzip_indexed (line 75) | pub(super) fn unzip_indexed(pi: I, left: CA, right: CB)... type Unzip (line 92) | struct Unzip; type Left (line 95) | type Left = A; type Right (line 96) | type Right = B; method consume (line 98) | fn consume(&self, item: (A, B), left: FA, right: FB) -> (FA, FB) method indexable (line 106) | fn indexable() -> bool { function partition (line 115) | pub(super) fn partition(pi: I, predicate: P) -> (A, B) type Partition (line 126) | struct Partition
{ type Left (line 135) | type Left = T; type Right (line 136) | type Right = T; function consume (line 138) | fn consume(&self, item: T, left: FA, right: FB) -> (FA, FB) function partition_map (line 155) | pub(super) fn partition_map(pi: I, predicate: P) -> (A... type PartitionMap (line 168) | struct PartitionMap
{ type Left (line 178) | type Left = L; type Right (line 179) | type Right = R; function consume (line 181) | fn consume(&self, item: T, left: FA, right: FB) -> (FA, FB) type UnzipA (line 194) | struct UnzipA<'b, I, OP, FromB> { type Item (line 206) | type Item = OP::Left; method drive_unindexed (line 208) | fn drive_unindexed(self, consumer: C) -> C::Result method opt_len (line 229) | fn opt_len(&self) -> Option { type UnzipB (line 239) | struct UnzipB<'r, I, OP, CA> type Item (line 257) | type Item = OP::Right; method drive_unindexed (line 259) | fn drive_unindexed(self, consumer: C) -> C::Result method opt_len (line 275) | fn opt_len(&self) -> Option { type UnzipConsumer (line 285) | struct UnzipConsumer<'a, OP, CA, CB> { type Folder (line 297) | type Folder = UnzipFolder<'a, OP, CA::Folder, CB::Folder>; type Reducer (line 298) | type Reducer = UnzipReducer; type Result (line 299) | type Result = (CA::Result, CB::Result); function split_at (line 301) | fn split_at(self, index: usize) -> (Self, Self, Self::Reducer) { function into_folder (line 323) | fn into_folder(self) -> Self::Folder { function full (line 331) | fn full(&self) -> bool { function split_off_left (line 343) | fn split_off_left(&self) -> Self { function to_reducer (line 351) | fn to_reducer(&self) -> Self::Reducer { type UnzipFolder (line 360) | struct UnzipFolder<'a, OP, FA, FB> { type Result (line 372) | type Result = (FA::Result, FB::Result); function consume (line 374) | fn consume(self, item: T) -> Self { function complete (line 383) | fn complete(self) -> Self::Result { function full (line 387) | fn full(&self) -> bool { type UnzipReducer (line 394) | struct UnzipReducer { function reduce (line 404) | fn reduce(self, left: (A, B), right: (A, B)) -> (A, B) { function par_extend (line 419) | fn par_extend(&mut self, pi: I) function par_extend (line 434) | fn par_extend(&mut self, pi: I) type UnEither (line 443) | struct UnEither; type Left (line 450) | type Left = L; type Right (line 451) | type Right = R; method consume (line 453) | fn consume(&self, item: Either, left: FL, right: FR) -> ... function from_par_iter (line 472) | fn from_par_iter(pi: I) -> Self function from_par_iter (line 488) | fn from_par_iter(pi: I) -> Self type Collector (line 502) | struct Collector { method default (line 507) | fn default() -> Self { function par_extend (line 517) | fn par_extend(&mut self, pi: I) FILE: src/iter/update.rs type Update (line 14) | pub struct Update { method fmt (line 20) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { function new (line 27) | pub(super) fn new(base: I, update_op: F) -> Self { type Item (line 37) | type Item = I::Item; method drive_unindexed (line 39) | fn drive_unindexed(self, consumer: C) -> C::Result method opt_len (line 47) | fn opt_len(&self) -> Option { method drive (line 57) | fn drive(self, consumer: C) -> C::Result method len (line 65) | fn len(&self) -> usize { method with_producer (line 69) | fn with_producer(self, callback: CB) -> CB::Output type UpdateProducer (line 106) | struct UpdateProducer<'f, P, F> { type Item (line 116) | type Item = P::Item; type IntoIter (line 117) | type IntoIter = UpdateSeq; method into_iter (line 119) | fn into_iter(self) -> Self::IntoIter { method min_len (line 126) | fn min_len(&self) -> usize { method max_len (line 129) | fn max_len(&self) -> usize { method split_at (line 133) | fn split_at(self, index: usize) -> (Self, Self) { method fold_with (line 147) | fn fold_with(self, folder: G) -> G type UpdateConsumer (line 162) | struct UpdateConsumer<'f, C, F> { function new (line 168) | fn new(base: C, update_op: &'f F) -> Self { type Folder (line 178) | type Folder = UpdateFolder<'f, C::Folder, F>; type Reducer (line 179) | type Reducer = C::Reducer; type Result (line 180) | type Result = C::Result; function split_at (line 182) | fn split_at(self, index: usize) -> (Self, Self, Self::Reducer) { function into_folder (line 191) | fn into_folder(self) -> Self::Folder { function full (line 198) | fn full(&self) -> bool { function split_off_left (line 208) | fn split_off_left(&self) -> Self { function to_reducer (line 212) | fn to_reducer(&self) -> Self::Reducer { type UpdateFolder (line 217) | struct UpdateFolder<'f, C, F> { function apply (line 222) | fn apply(update_op: impl Fn(&mut T)) -> impl Fn(T) -> T { type Result (line 234) | type Result = C::Result; function consume (line 236) | fn consume(self, mut item: T) -> Self { function consume_iter (line 245) | fn consume_iter(mut self, iter: I) -> Self function complete (line 256) | fn complete(self) -> C::Result { function full (line 260) | fn full(&self) -> bool { type UpdateSeq (line 268) | struct UpdateSeq { type Item (line 278) | type Item = I::Item; method next (line 280) | fn next(&mut self) -> Option { method size_hint (line 286) | fn size_hint(&self) -> (usize, Option) { method fold (line 290) | fn fold(self, init: Acc, g: G) -> Acc method collect (line 298) | fn collect(self) -> C method next_back (line 318) | fn next_back(&mut self) -> Option { FILE: src/iter/walk_tree.rs type WalkTreePrefixProducer (line 6) | struct WalkTreePrefixProducer<'b, S, B> { type Item (line 18) | type Item = S; method split (line 20) | fn split(mut self) -> (Self, Option) { method fold_with (line 51) | fn fold_with(mut self, mut folder: F) -> F type WalkTreePrefix (line 76) | pub struct WalkTreePrefix { type Item (line 87) | type Item = S; method drive_unindexed (line 89) | fn drive_unindexed(self, consumer: C) -> C::Result function walk_tree_prefix (line 204) | pub fn walk_tree_prefix(root: S, children_of: B) -> WalkTreePre... type WalkTreePostfixProducer (line 219) | struct WalkTreePostfixProducer<'b, S, B> { type Item (line 231) | type Item = S; method split (line 233) | fn split(mut self) -> (Self, Option) { method fold_with (line 267) | fn fold_with(self, mut folder: F) -> F function consume_rec_postfix (line 283) | fn consume_rec_postfix(children_of: &B, s: S, mut folder: F)... type WalkTreePostfix (line 302) | pub struct WalkTreePostfix { type Item (line 313) | type Item = S; method drive_unindexed (line 315) | fn drive_unindexed(self, consumer: C) -> C::Result function split_vec (line 331) | fn split_vec(v: &mut Vec) -> Option> { function walk_tree_postfix (line 444) | pub fn walk_tree_postfix(root: S, children_of: B) -> WalkTreePo... type WalkTree (line 459) | pub struct WalkTree(WalkTreePostfix); function walk_tree (line 497) | pub fn walk_tree(root: S, children_of: B) -> WalkTree type Item (line 516) | type Item = S; method drive_unindexed (line 518) | fn drive_unindexed(self, consumer: C) -> C::Result FILE: src/iter/while_some.rs type WhileSome (line 13) | pub struct WhileSome { function new (line 19) | pub(super) fn new(base: I) -> Self { type Item (line 29) | type Item = T; method drive_unindexed (line 31) | fn drive_unindexed(self, consumer: C) -> C::Result type WhileSomeConsumer (line 47) | struct WhileSomeConsumer<'f, C> { type Folder (line 57) | type Folder = WhileSomeFolder<'f, C::Folder>; type Reducer (line 58) | type Reducer = C::Reducer; type Result (line 59) | type Result = C::Result; function split_at (line 61) | fn split_at(self, index: usize) -> (Self, Self, Self::Reducer) { function into_folder (line 73) | fn into_folder(self) -> Self::Folder { function full (line 80) | fn full(&self) -> bool { function split_off_left (line 90) | fn split_off_left(&self) -> Self { function to_reducer (line 97) | fn to_reducer(&self) -> Self::Reducer { type WhileSomeFolder (line 102) | struct WhileSomeFolder<'f, C> { type Result (line 111) | type Result = C::Result; function consume (line 113) | fn consume(mut self, item: Option) -> Self { function consume_iter (line 121) | fn consume_iter(mut self, iter: I) -> Self function complete (line 143) | fn complete(self) -> C::Result { function full (line 147) | fn full(&self) -> bool { FILE: src/iter/zip.rs type Zip (line 12) | pub struct Zip { function new (line 19) | pub(super) fn new(a: A, b: B) -> Self { type Item (line 29) | type Item = (A::Item, B::Item); method drive_unindexed (line 31) | fn drive_unindexed(self, consumer: C) -> C::Result method opt_len (line 38) | fn opt_len(&self) -> Option { method drive (line 48) | fn drive(self, consumer: C) -> C::Result method len (line 55) | fn len(&self) -> usize { method with_producer (line 59) | fn with_producer(self, callback: CB) -> CB::Output type ZipProducer (line 118) | struct ZipProducer { type Item (line 124) | type Item = (A::Item, B::Item); type IntoIter (line 125) | type IntoIter = iter::Zip; method into_iter (line 127) | fn into_iter(self) -> Self::IntoIter { method min_len (line 131) | fn min_len(&self) -> usize { method max_len (line 135) | fn max_len(&self) -> usize { method split_at (line 139) | fn split_at(self, index: usize) -> (Self, Self) { FILE: src/iter/zip_eq.rs type ZipEq (line 13) | pub struct ZipEq { function new (line 19) | pub(super) fn new(a: A, b: B) -> Self { type Item (line 31) | type Item = (A::Item, B::Item); method drive_unindexed (line 33) | fn drive_unindexed(self, consumer: C) -> C::Result method opt_len (line 40) | fn opt_len(&self) -> Option { method drive (line 50) | fn drive(self, consumer: C) -> C::Result method len (line 57) | fn len(&self) -> usize { method with_producer (line 61) | fn with_producer(self, callback: CB) -> CB::Output FILE: src/lib.rs type SendPtr (line 133) | struct SendPtr(*mut T); function get (line 143) | fn get(self) -> *mut T { method clone (line 150) | fn clone(&self) -> Self { FILE: src/math.rs function simplify_range (line 4) | pub(super) fn simplify_range(range: impl RangeBounds, len: usize)... FILE: src/option.rs type IntoIter (line 20) | pub struct IntoIter { type Item (line 25) | type Item = T; type Iter (line 26) | type Iter = IntoIter; method into_par_iter (line 28) | fn into_par_iter(self) -> Self::Iter { type Item (line 34) | type Item = T; method drive_unindexed (line 36) | fn drive_unindexed(self, consumer: C) -> C::Result method opt_len (line 43) | fn opt_len(&self) -> Option { method drive (line 49) | fn drive(self, consumer: C) -> C::Result method len (line 60) | fn len(&self) -> usize { method with_producer (line 67) | fn with_producer(self, callback: CB) -> CB::Output type Iter (line 83) | pub struct Iter<'a, T> { method clone (line 88) | fn clone(&self) -> Self { type Item (line 96) | type Item = &'a T; type Iter (line 97) | type Iter = Iter<'a, T>; method into_par_iter (line 99) | fn into_par_iter(self) -> Self::Iter { type IterMut (line 119) | pub struct IterMut<'a, T> { type Item (line 124) | type Item = &'a mut T; type Iter (line 125) | type Iter = IterMut<'a, T>; method into_par_iter (line 127) | fn into_par_iter(self) -> Self::Iter { type OptionProducer (line 140) | struct OptionProducer { type Item (line 145) | type Item = T; type IntoIter (line 146) | type IntoIter = std::option::IntoIter; method into_iter (line 148) | fn into_iter(self) -> Self::IntoIter { method split_at (line 152) | fn split_at(self, index: usize) -> (Self, Self) { function from_par_iter (line 172) | fn from_par_iter(par_iter: I) -> Self FILE: src/par_either.rs type Item (line 11) | type Item = L::Item; method drive_unindexed (line 13) | fn drive_unindexed(self, consumer: C) -> C::Result method opt_len (line 23) | fn opt_len(&self) -> Option { method drive (line 33) | fn drive(self, consumer: C) -> C::Result method len (line 43) | fn len(&self) -> usize { method with_producer (line 47) | fn with_producer(self, callback: CB) -> CB::Output function par_extend (line 65) | fn par_extend(&mut self, par_iter: I) FILE: src/private.rs type PrivateMarker (line 9) | pub struct PrivateMarker; FILE: src/range.rs type Iter (line 45) | pub struct Iter { type Item (line 54) | type Item = as ParallelIterator>::Item; type Iter (line 55) | type Iter = Iter; method into_par_iter (line 57) | fn into_par_iter(self) -> Self::Iter { type IterProducer (line 62) | struct IterProducer { type Item (line 70) | type Item = as Iterator>::Item; type IntoIter (line 71) | type IntoIter = Range; method into_iter (line 73) | fn into_iter(self) -> Self::IntoIter { type RangeInteger (line 89) | pub trait RangeInteger: Sized + Send { method drive_unindexed (line 92) | fn drive_unindexed(iter: Iter, consumer: C) -> C::Result method opt_len (line 96) | fn opt_len(iter: &Iter) -> Option; type IndexedRangeInteger (line 100) | pub trait IndexedRangeInteger: RangeInteger { method drive (line 103) | fn drive(iter: Iter, consumer: C) -> C::Result method len (line 107) | fn len(iter: &Iter) -> usize; method with_producer (line 109) | fn with_producer(iter: Iter, callback: CB) -> CB::Output type Item (line 117) | type Item = T; method drive_unindexed (line 119) | fn drive_unindexed(self, consumer: C) -> C::Result method opt_len (line 127) | fn opt_len(&self) -> Option { method drive (line 133) | fn drive(self, consumer: C) -> C::Result method len (line 141) | fn len(&self) -> usize { method with_producer (line 145) | fn with_producer(self, callback: CB) -> CB::Output type UnindexedRangeLen (line 212) | trait UnindexedRangeLen { method unindexed_len (line 213) | fn unindexed_len(&self) -> L; type Item (line 321) | type Item = char; method drive_unindexed (line 323) | fn drive_unindexed(self, consumer: C) -> C::Result method opt_len (line 330) | fn opt_len(&self) -> Option { method drive (line 337) | fn drive(self, consumer: C) -> C::Result method len (line 344) | fn len(&self) -> usize { method with_producer (line 359) | fn with_producer(self, callback: CB) -> CB::Output function check_range_split_at_overflow (line 368) | fn check_range_split_at_overflow() { function test_i128_len_doesnt_overflow (line 378) | fn test_i128_len_doesnt_overflow() { function test_u64_opt_len (line 396) | fn test_u64_opt_len() { function test_u128_opt_len (line 414) | fn test_u128_opt_len() { function test_usize_i64_overflow (line 428) | fn test_usize_i64_overflow() { function test_issue_833 (line 440) | fn test_issue_833() { FILE: src/range_inclusive.rs type Iter (line 45) | pub struct Iter { function bounds (line 59) | fn bounds(&self) -> Option<(T, T)> { type Item (line 78) | type Item = as ParallelIterator>::Item; type Iter (line 79) | type Iter = Iter; method into_par_iter (line 81) | fn into_par_iter(self) -> Self::Iter { type RangeInteger (line 97) | pub trait RangeInteger: Sized + Send { method drive_unindexed (line 100) | fn drive_unindexed(iter: Iter, consumer: C) -> C::Result method opt_len (line 104) | fn opt_len(iter: &Iter) -> Option; type IndexedRangeInteger (line 108) | pub trait IndexedRangeInteger: RangeInteger { method drive (line 111) | fn drive(iter: Iter, consumer: C) -> C::Result method len (line 115) | fn len(iter: &Iter) -> usize; method with_producer (line 117) | fn with_producer(iter: Iter, callback: CB) -> CB::Output type Item (line 125) | type Item = T; method drive_unindexed (line 127) | fn drive_unindexed(self, consumer: C) -> C::Result method opt_len (line 135) | fn opt_len(&self) -> Option { method drive (line 141) | fn drive(self, consumer: C) -> C::Result method len (line 149) | fn len(&self) -> usize { method with_producer (line 153) | fn with_producer(self, callback: CB) -> CB::Output type Item (line 265) | type Item = char; method drive_unindexed (line 267) | fn drive_unindexed(self, consumer: C) -> C::Result method opt_len (line 274) | fn opt_len(&self) -> Option { method drive (line 282) | fn drive(self, consumer: C) -> C::Result method len (line 289) | fn len(&self) -> usize { method with_producer (line 304) | fn with_producer(self, callback: CB) -> CB::Output function test_u32_opt_len (line 314) | fn test_u32_opt_len() { function test_u64_opt_len (line 327) | fn test_u64_opt_len() { function test_u128_opt_len (line 338) | fn test_u128_opt_len() { function test_usize_i64_overflow (line 352) | fn test_usize_i64_overflow() { function test_issue_833 (line 364) | fn test_issue_833() { FILE: src/result.rs type IntoIter (line 16) | pub struct IntoIter { type Item (line 21) | type Item = T; type Iter (line 22) | type Iter = IntoIter; method into_par_iter (line 24) | fn into_par_iter(self) -> Self::Iter { type Iter (line 38) | pub struct Iter<'a, T> { method clone (line 43) | fn clone(&self) -> Self { type Item (line 51) | type Item = &'a T; type Iter (line 52) | type Iter = Iter<'a, T>; method into_par_iter (line 54) | fn into_par_iter(self) -> Self::Iter { type IterMut (line 68) | pub struct IterMut<'a, T> { type Item (line 73) | type Item = &'a mut T; type Iter (line 74) | type Iter = IterMut<'a, T>; method into_par_iter (line 76) | fn into_par_iter(self) -> Self::Iter { function from_par_iter (line 99) | fn from_par_iter(par_iter: I) -> Self FILE: src/slice/chunk_by.rs type ChunkBySlice (line 6) | trait ChunkBySlice: AsRef<[T]> + Default + Send { method split (line 7) | fn split(self, index: usize) -> (Self, Self); method chunk_by (line 8) | fn chunk_by(self, pred: &impl Fn(&T, &T) -> bool) -> impl Iterator bool, start: usize, end: usiz... method rfind (line 17) | fn rfind(&self, pred: &impl Fn(&T, &T) -> bool, end: usize) -> Option<... function split (line 26) | fn split(self, index: usize) -> (Self, Self) { function chunk_by (line 30) | fn chunk_by(self, pred: &impl Fn(&T, &T) -> bool) -> impl Iterator (Self, Self) { function chunk_by (line 40) | fn chunk_by(self, pred: &impl Fn(&T, &T) -> bool) -> impl Iterator { type Item (line 58) | type Item = Slice; method split (line 60) | fn split(self) -> (Self, Option) { method fold_with (line 104) | fn fold_with(self, mut folder: F) -> F type ChunkBy (line 142) | pub struct ChunkBy<'data, T, P> { method clone (line 148) | fn clone(&self) -> Self { function fmt (line 157) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { function new (line 165) | pub(super) fn new(slice: &'data [T], pred: P) -> Self { type Item (line 175) | type Item = &'data [T]; method drive_unindexed (line 177) | fn drive_unindexed(self, consumer: C) -> C::Result type ChunkByMut (line 199) | pub struct ChunkByMut<'data, T, P> { function fmt (line 205) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { function new (line 213) | pub(super) fn new(slice: &'data mut [T], pred: P) -> Self { type Item (line 223) | type Item = &'data mut [T]; method drive_unindexed (line 225) | fn drive_unindexed(self, consumer: C) -> C::Result FILE: src/slice/chunks.rs type Chunks (line 6) | pub struct Chunks<'data, T> { function new (line 12) | pub(super) fn new(chunk_size: usize, slice: &'data [T]) -> Self { method clone (line 18) | fn clone(&self) -> Self { type Item (line 24) | type Item = &'data [T]; method drive_unindexed (line 26) | fn drive_unindexed(self, consumer: C) -> C::Result method opt_len (line 33) | fn opt_len(&self) -> Option { method drive (line 39) | fn drive(self, consumer: C) -> C::Result method len (line 46) | fn len(&self) -> usize { method with_producer (line 50) | fn with_producer(self, callback: CB) -> CB::Output type ChunksProducer (line 61) | struct ChunksProducer<'data, T: Sync> { type Item (line 67) | type Item = &'data [T]; type IntoIter (line 68) | type IntoIter = ::std::slice::Chunks<'data, T>; method into_iter (line 70) | fn into_iter(self) -> Self::IntoIter { method split_at (line 74) | fn split_at(self, index: usize) -> (Self, Self) { type ChunksExact (line 92) | pub struct ChunksExact<'data, T> { function new (line 99) | pub(super) fn new(chunk_size: usize, slice: &'data [T]) -> Self { function remainder (line 113) | pub fn remainder(&self) -> &'data [T] { method clone (line 119) | fn clone(&self) -> Self { type Item (line 125) | type Item = &'data [T]; method drive_unindexed (line 127) | fn drive_unindexed(self, consumer: C) -> C::Result method opt_len (line 134) | fn opt_len(&self) -> Option { method drive (line 140) | fn drive(self, consumer: C) -> C::Result method len (line 147) | fn len(&self) -> usize { method with_producer (line 151) | fn with_producer(self, callback: CB) -> CB::Output type ChunksExactProducer (line 162) | struct ChunksExactProducer<'data, T: Sync> { type Item (line 168) | type Item = &'data [T]; type IntoIter (line 169) | type IntoIter = ::std::slice::ChunksExact<'data, T>; method into_iter (line 171) | fn into_iter(self) -> Self::IntoIter { method split_at (line 175) | fn split_at(self, index: usize) -> (Self, Self) { type ChunksMut (line 193) | pub struct ChunksMut<'data, T> { function new (line 199) | pub(super) fn new(chunk_size: usize, slice: &'data mut [T]) -> Self { type Item (line 205) | type Item = &'data mut [T]; method drive_unindexed (line 207) | fn drive_unindexed(self, consumer: C) -> C::Result method opt_len (line 214) | fn opt_len(&self) -> Option { method drive (line 220) | fn drive(self, consumer: C) -> C::Result method len (line 227) | fn len(&self) -> usize { method with_producer (line 231) | fn with_producer(self, callback: CB) -> CB::Output type ChunksMutProducer (line 242) | struct ChunksMutProducer<'data, T: Send> { type Item (line 248) | type Item = &'data mut [T]; type IntoIter (line 249) | type IntoIter = ::std::slice::ChunksMut<'data, T>; method into_iter (line 251) | fn into_iter(self) -> Self::IntoIter { method split_at (line 255) | fn split_at(self, index: usize) -> (Self, Self) { type ChunksExactMut (line 273) | pub struct ChunksExactMut<'data, T> { function new (line 280) | pub(super) fn new(chunk_size: usize, slice: &'data mut [T]) -> Self { function into_remainder (line 300) | pub fn into_remainder(self) -> &'data mut [T] { function remainder (line 310) | pub fn remainder(&mut self) -> &mut [T] { function take_remainder (line 317) | pub fn take_remainder(&mut self) -> &'data mut [T] { type Item (line 323) | type Item = &'data mut [T]; method drive_unindexed (line 325) | fn drive_unindexed(self, consumer: C) -> C::Result method opt_len (line 332) | fn opt_len(&self) -> Option { method drive (line 338) | fn drive(self, consumer: C) -> C::Result method len (line 345) | fn len(&self) -> usize { method with_producer (line 349) | fn with_producer(self, callback: CB) -> CB::Output type ChunksExactMutProducer (line 360) | struct ChunksExactMutProducer<'data, T: Send> { type Item (line 366) | type Item = &'data mut [T]; type IntoIter (line 367) | type IntoIter = ::std::slice::ChunksExactMut<'data, T>; method into_iter (line 369) | fn into_iter(self) -> Self::IntoIter { method split_at (line 373) | fn split_at(self, index: usize) -> (Self, Self) { FILE: src/slice/mod.rs type ParallelSlice (line 29) | pub trait ParallelSlice { method as_parallel_slice (line 32) | fn as_parallel_slice(&self) -> &[T]; method par_split (line 47) | fn par_split
~~(&self, separator: P) -> Split<'_, T, P> method par_split_inclusive (line 70) | fn par_split_inclusive~~
(&self, separator: P) -> SplitInclusive<'_, T... method par_windows (line 90) | fn par_windows(&self, window_size: usize) -> Windows<'_, T> { method par_chunks (line 112) | fn par_chunks(&self, chunk_size: usize) -> Chunks<'_, T> { method par_chunks_exact (line 132) | fn par_chunks_exact(&self, chunk_size: usize) -> ChunksExact<'_, T> { method par_rchunks (line 152) | fn par_rchunks(&self, chunk_size: usize) -> RChunks<'_, T> { method par_rchunks_exact (line 172) | fn par_rchunks_exact(&self, chunk_size: usize) -> RChunksExact<'_, T> { method par_chunk_by (line 193) | fn par_chunk_by(&self, pred: F) -> ChunkBy<'_, T, F> function as_parallel_slice (line 203) | fn as_parallel_slice(&self) -> &[T] { type ParallelSliceMut (line 209) | pub trait ParallelSliceMut { method as_parallel_slice_mut (line 212) | fn as_parallel_slice_mut(&mut self) -> &mut [T]; method par_split_mut (line 226) | fn par_split_mut
~~(&mut self, separator: P) -> SplitMut<'_, T, P> method par_split_inclusive_mut (line 248) | fn par_split_inclusive_mut~~
(&mut self, separator: P) -> SplitInclusi... method par_chunks_mut (line 275) | fn par_chunks_mut(&mut self, chunk_size: usize) -> ChunksMut<'_, T> { method par_chunks_exact_mut (line 297) | fn par_chunks_exact_mut(&mut self, chunk_size: usize) -> ChunksExactMu... method par_rchunks_mut (line 319) | fn par_rchunks_mut(&mut self, chunk_size: usize) -> RChunksMut<'_, T> { method par_rchunks_exact_mut (line 341) | fn par_rchunks_exact_mut(&mut self, chunk_size: usize) -> RChunksExact... method par_sort (line 379) | fn par_sort(&mut self) method par_sort_by (line 440) | fn par_sort_by(&mut self, compare: F) method par_sort_by_key (line 487) | fn par_sort_by_key(&mut self, f: F) method par_sort_by_cached_key (line 535) | fn par_sort_by_cached_key(&mut self, f: F) method par_sort_unstable (line 618) | fn par_sort_unstable(&mut self) method par_sort_unstable_by (line 679) | fn par_sort_unstable_by(&mut self, compare: F) method par_sort_unstable_by_key (line 723) | fn par_sort_unstable_by_key(&mut self, f: F) method par_chunk_by_mut (line 748) | fn par_chunk_by_mut(&mut self, pred: F) -> ChunkByMut<'_, T, F> function as_parallel_slice_mut (line 758) | fn as_parallel_slice_mut(&mut self) -> &mut [T] { type Item (line 764) | type Item = &'data T; type Iter (line 765) | type Iter = Iter<'data, T>; method into_par_iter (line 767) | fn into_par_iter(self) -> Self::Iter { type Item (line 773) | type Item = &'data T; type Iter (line 774) | type Iter = Iter<'data, T>; method into_par_iter (line 776) | fn into_par_iter(self) -> Self::Iter { type Item (line 782) | type Item = &'data mut T; type Iter (line 783) | type Iter = IterMut<'data, T>; method into_par_iter (line 785) | fn into_par_iter(self) -> Self::Iter { type Item (line 791) | type Item = &'data mut T; type Iter (line 792) | type Iter = IterMut<'data, T>; method into_par_iter (line 794) | fn into_par_iter(self) -> Self::Iter { type Iter (line 801) | pub struct Iter<'data, T> { method clone (line 806) | fn clone(&self) -> Self { type Item (line 812) | type Item = &'data T; method drive_unindexed (line 814) | fn drive_unindexed(self, consumer: C) -> C::Result method opt_len (line 821) | fn opt_len(&self) -> Option { method drive (line 827) | fn drive(self, consumer: C) -> C::Result method len (line 834) | fn len(&self) -> usize { method with_producer (line 838) | fn with_producer(self, callback: CB) -> CB::Output type IterProducer (line 846) | struct IterProducer<'data, T: Sync> { type Item (line 851) | type Item = &'data T; type IntoIter (line 852) | type IntoIter = ::std::slice::Iter<'data, T>; method into_iter (line 854) | fn into_iter(self) -> Self::IntoIter { method split_at (line 858) | fn split_at(self, index: usize) -> (Self, Self) { type Windows (line 866) | pub struct Windows<'data, T> { method clone (line 872) | fn clone(&self) -> Self { type Item (line 878) | type Item = &'data [T]; method drive_unindexed (line 880) | fn drive_unindexed(self, consumer: C) -> C::Result method opt_len (line 887) | fn opt_len(&self) -> Option { method drive (line 893) | fn drive(self, consumer: C) -> C::Result method len (line 900) | fn len(&self) -> usize { method with_producer (line 905) | fn with_producer(self, callback: CB) -> CB::Output type WindowsProducer (line 916) | struct WindowsProducer<'data, T: Sync> { type Item (line 922) | type Item = &'data [T]; type IntoIter (line 923) | type IntoIter = ::std::slice::Windows<'data, T>; method into_iter (line 925) | fn into_iter(self) -> Self::IntoIter { method split_at (line 929) | fn split_at(self, index: usize) -> (Self, Self) { type IterMut (line 948) | pub struct IterMut<'data, T> { type Item (line 953) | type Item = &'data mut T; method drive_unindexed (line 955) | fn drive_unindexed(self, consumer: C) -> C::Result method opt_len (line 962) | fn opt_len(&self) -> Option { method drive (line 968) | fn drive(self, consumer: C) -> C::Result method len (line 975) | fn len(&self) -> usize { method with_producer (line 979) | fn with_producer(self, callback: CB) -> CB::Output type IterMutProducer (line 987) | struct IterMutProducer<'data, T: Send> { type Item (line 992) | type Item = &'data mut T; type IntoIter (line 993) | type IntoIter = ::std::slice::IterMut<'data, T>; method into_iter (line 995) | fn into_iter(self) -> Self::IntoIter { method split_at (line 999) | fn split_at(self, index: usize) -> (Self, Self) { type Split (line 1009) | pub struct Split<'data, T, P> { method clone (line 1015) | fn clone(&self) -> Self { method fmt (line 1024) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { type Item (line 1034) | type Item = &'data [T]; method drive_unindexed (line 1036) | fn drive_unindexed(self, consumer: C) -> C::Result type SplitInclusive (line 1047) | pub struct SplitInclusive<'data, T, P> { method clone (line 1053) | fn clone(&self) -> Self { method fmt (line 1062) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { type Item (line 1074) | type Item = &'data [T]; method drive_unindexed (line 1076) | fn drive_unindexed(self, consumer: C) -> C::Result function length (line 1090) | fn length(&self) -> usize { function midpoint (line 1094) | fn midpoint(&self, end: usize) -> usize { function find (line 1098) | fn find(&self, separator: &P, start: usize, end: usize) -> Option { function rfind (line 1102) | fn rfind(&self, separator: &P, end: usize) -> Option { function split_once (line 1106) | fn split_once(self, index: usize) -> (Self, Self) { function fold_splits (line 1116) | fn fold_splits(self, separator: &P, folder: F, skip... type SplitMut (line 1135) | pub struct SplitMut<'data, T, P> { method fmt (line 1141) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { type Item (line 1153) | type Item = &'data mut [T]; method drive_unindexed (line 1155) | fn drive_unindexed(self, consumer: C) -> C::Result type SplitInclusiveMut (line 1166) | pub struct SplitInclusiveMut<'data, T, P> { method fmt (line 1172) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { type Item (line 1184) | type Item = &'data mut [T]; method drive_unindexed (line 1186) | fn drive_unindexed(self, consumer: C) -> C::Result function length (line 1200) | fn length(&self) -> usize { function midpoint (line 1204) | fn midpoint(&self, end: usize) -> usize { function find (line 1208) | fn find(&self, separator: &P, start: usize, end: usize) -> Option { function rfind (line 1212) | fn rfind(&self, separator: &P, end: usize) -> Option { function split_once (line 1216) | fn split_once(self, index: usize) -> (Self, Self) { function fold_splits (line 1226) | fn fold_splits(self, separator: &P, folder: F, skip... FILE: src/slice/rchunks.rs type RChunks (line 6) | pub struct RChunks<'data, T> { function new (line 12) | pub(super) fn new(chunk_size: usize, slice: &'data [T]) -> Self { method clone (line 18) | fn clone(&self) -> Self { type Item (line 24) | type Item = &'data [T]; method drive_unindexed (line 26) | fn drive_unindexed(self, consumer: C) -> C::Result method opt_len (line 33) | fn opt_len(&self) -> Option { method drive (line 39) | fn drive(self, consumer: C) -> C::Result method len (line 46) | fn len(&self) -> usize { method with_producer (line 50) | fn with_producer(self, callback: CB) -> CB::Output type RChunksProducer (line 61) | struct RChunksProducer<'data, T: Sync> { type Item (line 67) | type Item = &'data [T]; type IntoIter (line 68) | type IntoIter = ::std::slice::RChunks<'data, T>; method into_iter (line 70) | fn into_iter(self) -> Self::IntoIter { method split_at (line 74) | fn split_at(self, index: usize) -> (Self, Self) { type RChunksExact (line 92) | pub struct RChunksExact<'data, T> { function new (line 99) | pub(super) fn new(chunk_size: usize, slice: &'data [T]) -> Self { function remainder (line 112) | pub fn remainder(&self) -> &'data [T] { method clone (line 118) | fn clone(&self) -> Self { type Item (line 124) | type Item = &'data [T]; method drive_unindexed (line 126) | fn drive_unindexed(self, consumer: C) -> C::Result method opt_len (line 133) | fn opt_len(&self) -> Option { method drive (line 139) | fn drive(self, consumer: C) -> C::Result method len (line 146) | fn len(&self) -> usize { method with_producer (line 150) | fn with_producer(self, callback: CB) -> CB::Output type RChunksExactProducer (line 161) | struct RChunksExactProducer<'data, T: Sync> { type Item (line 167) | type Item = &'data [T]; type IntoIter (line 168) | type IntoIter = ::std::slice::RChunksExact<'data, T>; method into_iter (line 170) | fn into_iter(self) -> Self::IntoIter { method split_at (line 174) | fn split_at(self, index: usize) -> (Self, Self) { type RChunksMut (line 192) | pub struct RChunksMut<'data, T> { function new (line 198) | pub(super) fn new(chunk_size: usize, slice: &'data mut [T]) -> Self { type Item (line 204) | type Item = &'data mut [T]; method drive_unindexed (line 206) | fn drive_unindexed(self, consumer: C) -> C::Result method opt_len (line 213) | fn opt_len(&self) -> Option { method drive (line 219) | fn drive(self, consumer: C) -> C::Result method len (line 226) | fn len(&self) -> usize { method with_producer (line 230) | fn with_producer(self, callback: CB) -> CB::Output type RChunksMutProducer (line 241) | struct RChunksMutProducer<'data, T: Send> { type Item (line 247) | type Item = &'data mut [T]; type IntoIter (line 248) | type IntoIter = ::std::slice::RChunksMut<'data, T>; method into_iter (line 250) | fn into_iter(self) -> Self::IntoIter { method split_at (line 254) | fn split_at(self, index: usize) -> (Self, Self) { type RChunksExactMut (line 272) | pub struct RChunksExactMut<'data, T: Send> { function new (line 279) | pub(super) fn new(chunk_size: usize, slice: &'data mut [T]) -> Self { function into_remainder (line 298) | pub fn into_remainder(self) -> &'data mut [T] { function remainder (line 308) | pub fn remainder(&mut self) -> &mut [T] { function take_remainder (line 315) | pub fn take_remainder(&mut self) -> &'data mut [T] { type Item (line 321) | type Item = &'data mut [T]; method drive_unindexed (line 323) | fn drive_unindexed(self, consumer: C) -> C::Result method opt_len (line 330) | fn opt_len(&self) -> Option { method drive (line 336) | fn drive(self, consumer: C) -> C::Result method len (line 343) | fn len(&self) -> usize { method with_producer (line 347) | fn with_producer(self, callback: CB) -> CB::Output type RChunksExactMutProducer (line 358) | struct RChunksExactMutProducer<'data, T: Send> { type Item (line 364) | type Item = &'data mut [T]; type IntoIter (line 365) | type IntoIter = ::std::slice::RChunksExactMut<'data, T>; method into_iter (line 367) | fn into_iter(self) -> Self::IntoIter { method split_at (line 371) | fn split_at(self, index: usize) -> (Self, Self) { FILE: src/slice/sort.rs type InsertionHole (line 27) | struct InsertionHole { method drop (line 33) | fn drop(&mut self) { function insert_tail (line 45) | unsafe fn insert_tail(v: &mut [T], is_less: &F) function insert_head (line 101) | unsafe fn insert_head(v: &mut [T], is_less: &F) function insertion_sort_shift_left (line 164) | fn insertion_sort_shift_left(v: &mut [T], offset: usize, is_less: &F) function insertion_sort_shift_right (line 189) | fn insertion_sort_shift_right(v: &mut [T], offset: usize, is_less:... function partial_insertion_sort (line 214) | fn partial_insertion_sort(v: &mut [T], is_less: &F) -> bool function heapsort (line 264) | fn heapsort(v: &mut [T], is_less: F) function partition_in_blocks (line 317) | fn partition_in_blocks(v: &mut [T], pivot: &T, is_less: &F) -> usize function partition (line 575) | fn partition(v: &mut [T], pivot: usize, is_less: &F) -> (usize, bool) function partition_equal (line 636) | fn partition_equal(v: &mut [T], pivot: usize, is_less: &F) -> usize function break_patterns (line 704) | fn break_patterns(v: &mut [T]) { function choose_pivot (line 753) | fn choose_pivot(v: &mut [T], is_less: &F) -> (usize, bool) function recurse (line 829) | fn recurse<'a, T, F>(mut v: &'a mut [T], is_less: &F, mut pred: Option<&... function par_quicksort (line 933) | pub(super) fn par_quicksort(v: &mut [T], is_less: F) function merge (line 956) | unsafe fn merge(v: &mut [T], mid: usize, buf: *mut T, is_less: &F) type MergeHole (line 1055) | struct MergeHole { method drop (line 1062) | fn drop(&mut self) { type MergeSortResult (line 1074) | enum MergeSortResult { function merge_sort (line 1100) | unsafe fn merge_sort(v: &mut [T], buf_ptr: *mut T, is_less: &Cm... type TimSortRun (line 1202) | struct TimSortRun { function provide_sorted_batch (line 1209) | fn provide_sorted_batch(v: &mut [T], start: usize, mut end: usize,... function find_streak (line 1240) | fn find_streak(v: &[T], is_less: &F) -> (usize, bool) function split_for_merge (line 1283) | fn split_for_merge(left: &[T], right: &[T], is_less: &F) -> (usize... function par_merge (line 1333) | unsafe fn par_merge(left: &mut [T], right: &mut [T], dest: *mut T,... function merge_recurse (line 1435) | unsafe fn merge_recurse( function par_mergesort (line 1510) | pub(super) fn par_mergesort(v: &mut [T], is_less: F) function test_heapsort (line 1618) | fn test_heapsort() { function test_split_for_merge (line 1652) | fn test_split_for_merge() { FILE: src/slice/test.rs function test_par_sort_stability (line 96) | fn test_par_sort_stability() { function test_par_chunks_exact_remainder (line 130) | fn test_par_chunks_exact_remainder() { function test_par_chunks_exact_mut_remainder (line 138) | fn test_par_chunks_exact_mut_remainder() { function test_par_rchunks_exact_remainder (line 152) | fn test_par_rchunks_exact_remainder() { function test_par_rchunks_exact_mut_remainder (line 160) | fn test_par_rchunks_exact_mut_remainder() { function slice_chunk_by (line 174) | fn slice_chunk_by() { function slice_chunk_by_mut (line 195) | fn slice_chunk_by_mut() { FILE: src/split_producer.rs type SplitProducer (line 8) | pub(super) struct SplitProducer<'p, P, V, const INCL: bool = false> { type SplitInclusiveProducer (line 16) | pub(super) type SplitInclusiveProducer<'p, P, V> = SplitProducer<'p, P, ... type Fissile (line 19) | pub(super) trait Fissile
: Sized { method length (line 20) | fn length(&self) -> usize; method midpoint (line 21) | fn midpoint(&self, end: usize) -> usize; method find (line 22) | fn find(&self, separator: &P, start: usize, end: usize) -> Option; method rfind (line 23) | fn rfind(&self, separator: &P, end: usize) -> Option; method split_once (line 24) | fn split_once(self, index: usize) -> (Self, Self); method fold_splits (line 25) | fn fold_splits(self, separator: &P, folder: F, sk... function new (line 35) | pub(super) fn new(data: V, separator: &'p P) -> Self { function new_incl (line 48) | pub(super) fn new_incl(data: V, separator: &'p P) -> Self { function fold_with (line 63) | pub(super) fn fold_with(self, folder: F, skip_last: bool) -> F type Item (line 102) | type Item = V; method split (line 104) | fn split(self) -> (Self, Option) { method fold_with (line 146) | fn fold_with(self, folder: F) -> F FILE: src/str.rs function is_char_boundary (line 22) | fn is_char_boundary(b: u8) -> bool { function find_char_midpoint (line 29) | fn find_char_midpoint(chars: &str) -> usize { function split (line 49) | fn split(chars: &str) -> Option<(&str, &str)> { type ParallelString (line 59) | pub trait ParallelString { method as_parallel_string (line 62) | fn as_parallel_string(&self) -> &str; method par_chars (line 73) | fn par_chars(&self) -> Chars<'_> { method par_char_indices (line 88) | fn par_char_indices(&self) -> CharIndices<'_> { method par_bytes (line 108) | fn par_bytes(&self) -> Bytes<'_> { method par_encode_utf16 (line 132) | fn par_encode_utf16(&self) -> EncodeUtf16<'_> { method par_split (line 155) | fn par_split(&self, separator: P) -> Split<'_, P> { method par_split_inclusive (line 176) | fn par_split_inclusive(&self, separator: P) -> SplitInclus... method par_split_terminator (line 198) | fn par_split_terminator(&self, terminator: P) -> SplitTerm... method par_lines (line 217) | fn par_lines(&self) -> Lines<'_> { method par_split_whitespace (line 256) | fn par_split_whitespace(&self) -> SplitWhitespace<'_> { method par_split_ascii_whitespace (line 293) | fn par_split_ascii_whitespace(&self) -> SplitAsciiWhitespace<'_> { method par_matches (line 314) | fn par_matches(&self, pattern: P) -> Matches<'_, P> { method par_match_indices (line 337) | fn par_match_indices(&self, pattern: P) -> MatchIndices<'_... method as_parallel_string (line 347) | fn as_parallel_string(&self) -> &str { type Pattern (line 365) | pub trait Pattern: Sized + Sync + Send { method find_in (line 367) | fn find_in(&self, haystack: &str) -> Option; method rfind_in (line 368) | fn rfind_in(&self, haystack: &str) -> Option; method is_suffix_of (line 369) | fn is_suffix_of(&self, haystack: &str) -> bool; method fold_splits (line 370) | fn fold_splits<'ch, F>(&self, haystack: &'ch str, folder: F, skip_last... method fold_inclusive_splits (line 373) | fn fold_inclusive_splits<'ch, F>(&self, haystack: &'ch str, folder: F)... method fold_matches (line 376) | fn fold_matches<'ch, F>(&self, haystack: &'ch str, folder: F) -> F method fold_match_indices (line 379) | fn fold_match_indices<'ch, F>(&self, haystack: &'ch str, folder: F, ba... function offset (line 387) | fn offset(base: usize) -> impl Fn((usize, T)) -> (usize, T) { type Chars (line 468) | pub struct Chars<'ch> { type CharsProducer (line 472) | struct CharsProducer<'ch> { type Item (line 477) | type Item = char; method drive_unindexed (line 479) | fn drive_unindexed(self, consumer: C) -> C::Result type Item (line 488) | type Item = char; method split (line 490) | fn split(self) -> (Self, Option) { method fold_with (line 500) | fn fold_with(self, folder: F) -> F type CharIndices (line 512) | pub struct CharIndices<'ch> { type CharIndicesProducer (line 516) | struct CharIndicesProducer<'ch> { type Item (line 522) | type Item = (usize, char); method drive_unindexed (line 524) | fn drive_unindexed(self, consumer: C) -> C::Result type Item (line 537) | type Item = (usize, char); method split (line 539) | fn split(self) -> (Self, Option) { method fold_with (line 555) | fn fold_with(self, folder: F) -> F type Bytes (line 568) | pub struct Bytes<'ch> { type BytesProducer (line 572) | struct BytesProducer<'ch> { type Item (line 577) | type Item = u8; method drive_unindexed (line 579) | fn drive_unindexed(self, consumer: C) -> C::Result type Item (line 588) | type Item = u8; method split (line 590) | fn split(self) -> (Self, Option) { method fold_with (line 600) | fn fold_with(self, folder: F) -> F type EncodeUtf16 (line 612) | pub struct EncodeUtf16<'ch> { type EncodeUtf16Producer (line 616) | struct EncodeUtf16Producer<'ch> { type Item (line 621) | type Item = u16; method drive_unindexed (line 623) | fn drive_unindexed(self, consumer: C) -> C::Result type Item (line 632) | type Item = u16; method split (line 634) | fn split(self) -> (Self, Option) { method fold_with (line 644) | fn fold_with(self, folder: F) -> F type Split (line 656) | pub struct Split<'ch, P: Pattern> { function new (line 662) | fn new(chars: &'ch str, separator: P) -> Self { type Item (line 668) | type Item = &'ch str; method drive_unindexed (line 670) | fn drive_unindexed(self, consumer: C) -> C::Result function length (line 681) | fn length(&self) -> usize { function midpoint (line 685) | fn midpoint(&self, end: usize) -> usize { function find (line 690) | fn find(&self, separator: &P, start: usize, end: usize) -> Option { function rfind (line 694) | fn rfind(&self, separator: &P, end: usize) -> Option { function split_once (line 698) | fn split_once(self, index: usize) -> (Self, Self) { function fold_splits (line 711) | fn fold_splits(self, separator: &P, folder: F, skip... type SplitInclusive (line 728) | pub struct SplitInclusive<'ch, P: Pattern> { function new (line 734) | fn new(chars: &'ch str, separator: P) -> Self { type Item (line 740) | type Item = &'ch str; method drive_unindexed (line 742) | fn drive_unindexed(self, consumer: C) -> C::Result type SplitTerminator (line 755) | pub struct SplitTerminator<'ch, P: Pattern> { type SplitTerminatorProducer (line 760) | struct SplitTerminatorProducer<'ch, 'sep, P: Pattern> { function new (line 766) | fn new(chars: &'ch str, terminator: P) -> Self { function new (line 772) | fn new(chars: &'ch str, terminator: &'sep P) -> Self { type Item (line 781) | type Item = &'ch str; method drive_unindexed (line 783) | fn drive_unindexed(self, consumer: C) -> C::Result type Item (line 793) | type Item = &'ch str; method split (line 795) | fn split(mut self) -> (Self, Option) { method fold_with (line 809) | fn fold_with(self, folder: F) -> F type Lines (line 821) | pub struct Lines<'ch>(&'ch str); function no_carriage_return (line 824) | fn no_carriage_return(line: &str) -> &str { type Item (line 829) | type Item = &'ch str; method drive_unindexed (line 831) | fn drive_unindexed(self, consumer: C) -> C::Result type SplitWhitespace (line 846) | pub struct SplitWhitespace<'ch>(&'ch str); function not_empty (line 849) | fn not_empty(s: &&str) -> bool { type Item (line 854) | type Item = &'ch str; method drive_unindexed (line 856) | fn drive_unindexed(self, consumer: C) -> C::Result type SplitAsciiWhitespace (line 871) | pub struct SplitAsciiWhitespace<'ch>(&'ch str); function is_ascii_whitespace (line 874) | fn is_ascii_whitespace(c: char) -> bool { type Item (line 879) | type Item = &'ch str; method drive_unindexed (line 881) | fn drive_unindexed(self, consumer: C) -> C::Result type Matches (line 896) | pub struct Matches<'ch, P: Pattern> { type MatchesProducer (line 901) | struct MatchesProducer<'ch, 'pat, P: Pattern> { type Item (line 907) | type Item = &'ch str; method drive_unindexed (line 909) | fn drive_unindexed(self, consumer: C) -> C::Result type Item (line 922) | type Item = &'ch str; method split (line 924) | fn split(self) -> (Self, Option) { method fold_with (line 940) | fn fold_with(self, folder: F) -> F type MatchIndices (line 952) | pub struct MatchIndices<'ch, P: Pattern> { type MatchIndicesProducer (line 957) | struct MatchIndicesProducer<'ch, 'pat, P: Pattern> { type Item (line 964) | type Item = (usize, &'ch str); method drive_unindexed (line 966) | fn drive_unindexed(self, consumer: C) -> C::Result type Item (line 980) | type Item = (usize, &'ch str); method split (line 982) | fn split(self) -> (Self, Option) { method fold_with (line 999) | fn fold_with(self, folder: F) -> F FILE: src/string.rs type Iter (line 11) | type Iter = Drain<'a>; type Item (line 12) | type Item = char; function par_drain (line 14) | fn par_drain>(self, range: R) -> Self::Iter { type Drain (line 25) | pub struct Drain<'a> { type Item (line 31) | type Item = char; method drive_unindexed (line 33) | fn drive_unindexed(self, consumer: C) -> C::Result method drop (line 44) | fn drop(&mut self) { FILE: src/vec.rs type Item (line 19) | type Item = &'data T; type Iter (line 20) | type Iter = Iter<'data, T>; method into_par_iter (line 22) | fn into_par_iter(self) -> Self::Iter { type Item (line 28) | type Item = &'data mut T; type Iter (line 29) | type Iter = IterMut<'data, T>; method into_par_iter (line 31) | fn into_par_iter(self) -> Self::Iter { type IntoIter (line 38) | pub struct IntoIter { type Item (line 43) | type Item = T; type Iter (line 44) | type Iter = IntoIter; method into_par_iter (line 46) | fn into_par_iter(self) -> Self::Iter { type Item (line 52) | type Item = T; type Iter (line 53) | type Iter = IntoIter; method into_par_iter (line 55) | fn into_par_iter(self) -> Self::Iter { type Item (line 61) | type Item = T; method drive_unindexed (line 63) | fn drive_unindexed(self, consumer: C) -> C::Result method opt_len (line 70) | fn opt_len(&self) -> Option { method drive (line 76) | fn drive(self, consumer: C) -> C::Result method len (line 83) | fn len(&self) -> usize { method with_producer (line 87) | fn with_producer(mut self, callback: CB) -> CB::Output type Iter (line 97) | type Iter = Drain<'data, T>; type Item (line 98) | type Item = T; function par_drain (line 100) | fn par_drain>(self, range: R) -> Self::Iter { type Drain (line 111) | pub struct Drain<'data, T: Send> { type Item (line 118) | type Item = T; method drive_unindexed (line 120) | fn drive_unindexed(self, consumer: C) -> C::Result method opt_len (line 127) | fn opt_len(&self) -> Option { method drive (line 133) | fn drive(self, consumer: C) -> C::Result method len (line 140) | fn len(&self) -> usize { method with_producer (line 144) | fn with_producer(self, callback: CB) -> CB::Output method drop (line 162) | fn drop(&mut self) { type DrainProducer (line 188) | pub(crate) struct DrainProducer<'data, T: Send> { function new (line 196) | pub(crate) unsafe fn new(slice: &mut [T]) -> DrainProducer<'_, T> { function from_vec (line 204) | unsafe fn from_vec(vec: &mut Vec, len: usize) -> DrainProducer<'_, T> { type Item (line 216) | type Item = T; type IntoIter (line 217) | type IntoIter = SliceDrain<'data, T>; method into_iter (line 219) | fn into_iter(mut self) -> Self::IntoIter { method split_at (line 227) | fn split_at(mut self, index: usize) -> (Self, Self) { method drop (line 236) | fn drop(&mut self) { type SliceDrain (line 246) | pub(crate) struct SliceDrain<'data, T> { type Item (line 251) | type Item = T; method next (line 253) | fn next(&mut self) -> Option { method size_hint (line 260) | fn size_hint(&self) -> (usize, Option) { method count (line 264) | fn count(self) -> usize { method next_back (line 270) | fn next_back(&mut self) -> Option { method len (line 279) | fn len(&self) -> usize { method drop (line 287) | fn drop(&mut self) { FILE: tests/chars.rs function half_open_correctness (line 4) | fn half_open_correctness() { function closed_correctness (line 22) | fn closed_correctness() { FILE: tests/clones.rs function check (line 4) | fn check(iter: I) function check_count (line 13) | fn check_count(iter: I) function clone_binary_heap (line 21) | fn clone_binary_heap() { function clone_btree_map (line 29) | fn clone_btree_map() { function clone_btree_set (line 36) | fn clone_btree_set() { function clone_hash_map (line 43) | fn clone_hash_map() { function clone_hash_set (line 50) | fn clone_hash_set() { function clone_linked_list (line 57) | fn clone_linked_list() { function clone_vec_deque (line 65) | fn clone_vec_deque() { function clone_option (line 73) | fn clone_option() { function clone_result (line 80) | fn clone_result() { function clone_range (line 87) | fn clone_range() { function clone_range_inclusive (line 92) | fn clone_range_inclusive() { function clone_str (line 97) | fn clone_str() { function clone_vec (line 109) | fn clone_vec() { function clone_array (line 124) | fn clone_array() { function clone_adaptors (line 130) | fn clone_adaptors() { function clone_counted_adaptors (line 179) | fn clone_counted_adaptors() { function clone_empty (line 186) | fn clone_empty() { function clone_once (line 191) | fn clone_once() { function clone_repeat (line 196) | fn clone_repeat() { function clone_splitter (line 203) | fn clone_splitter() { function clone_multizip (line 208) | fn clone_multizip() { FILE: tests/collect.rs function collect_drop_on_unwind (line 10) | fn collect_drop_on_unwind() { function collect_drop_on_unwind_zst (line 66) | fn collect_drop_on_unwind_zst() { FILE: tests/cross-pool.rs function cross_pool_busy (line 6) | fn cross_pool_busy() { FILE: tests/debug.rs function check (line 4) | fn check(iter: I) function debug_binary_heap (line 12) | fn debug_binary_heap() { function debug_btree_map (line 21) | fn debug_btree_map() { function debug_btree_set (line 30) | fn debug_btree_set() { function debug_hash_map (line 38) | fn debug_hash_map() { function debug_hash_set (line 48) | fn debug_hash_set() { function debug_linked_list (line 57) | fn debug_linked_list() { function debug_vec_deque (line 66) | fn debug_vec_deque() { function debug_option (line 76) | fn debug_option() { function debug_result (line 84) | fn debug_result() { function debug_range (line 92) | fn debug_range() { function debug_range_inclusive (line 97) | fn debug_range_inclusive() { function debug_str (line 102) | fn debug_str() { function debug_string (line 114) | fn debug_string() { function debug_vec (line 120) | fn debug_vec() { function debug_array (line 144) | fn debug_array() { function debug_adaptors (line 150) | fn debug_adaptors() { function debug_empty (line 197) | fn debug_empty() { function debug_once (line 202) | fn debug_once() { function debug_repeat (line 207) | fn debug_repeat() { function debug_splitter (line 214) | fn debug_splitter() { function debug_multizip (line 219) | fn debug_multizip() { FILE: tests/drain_vec.rs function drain_vec_yielded (line 4) | fn drain_vec_yielded() { function drain_vec_dropped (line 14) | fn drain_vec_dropped() { function drain_vec_empty_range_yielded (line 24) | fn drain_vec_empty_range_yielded() { function drain_vec_empty_range_dropped (line 34) | fn drain_vec_empty_range_dropped() { FILE: tests/intersperse.rs function check_intersperse (line 4) | fn check_intersperse() { function check_intersperse_again (line 13) | fn check_intersperse_again() { function check_intersperse_unindexed (line 31) | fn check_intersperse_unindexed() { function check_intersperse_producer (line 40) | fn check_intersperse_producer() { function check_intersperse_rev (line 51) | fn check_intersperse_rev() { FILE: tests/issue671-unzip.rs function type_length_limit (line 6) | fn type_length_limit() { FILE: tests/issue671.rs function type_length_limit (line 6) | fn type_length_limit() { FILE: tests/iter_panic.rs constant ITER (line 7) | const ITER: Range = 0..0x1_0000; constant PANIC (line 8) | const PANIC: i32 = 0xC000; function check (line 10) | fn check(&i: &i32) { function iter_panic (line 18) | fn iter_panic() { function iter_panic_fuse (line 24) | fn iter_panic_fuse() { FILE: tests/named-threads.rs function named_threads (line 8) | fn named_threads() { FILE: tests/octillion.rs constant OCTILLION (line 3) | const OCTILLION: u128 = 1_000_000_000_000_000_000_000_000_000; function octillion (line 6) | fn octillion() -> rayon::range::Iter { function octillion_inclusive (line 11) | fn octillion_inclusive() -> rayon::range_inclusive::Iter { function octillion_flat (line 16) | fn octillion_flat() -> impl ParallelIterator { function find_first_octillion (line 41) | fn find_first_octillion() { function find_first_octillion_inclusive (line 48) | fn find_first_octillion_inclusive() { function find_first_octillion_flat (line 55) | fn find_first_octillion_flat() { function two_threads (line 60) | fn two_threads R, R: Send>(f: F) -> R { function find_last_octillion (line 79) | fn find_last_octillion() { function find_last_octillion_inclusive (line 96) | fn find_last_octillion_inclusive() { function find_last_octillion_flat (line 110) | fn find_last_octillion_flat() { function find_any_octillion (line 117) | fn find_any_octillion() { function find_any_octillion_flat (line 124) | fn find_any_octillion_flat() { function filter_find_any_octillion (line 131) | fn filter_find_any_octillion() { function filter_find_any_octillion_flat (line 142) | fn filter_find_any_octillion_flat() { function fold_find_any_octillion_flat (line 153) | fn fold_find_any_octillion_flat() { FILE: tests/par_bridge_recursion.rs constant N (line 4) | const N: usize = 100_000; function par_bridge_recursion (line 8) | fn par_bridge_recursion() { FILE: tests/producer_split_at.rs function check (line 6) | fn check(expected: &[I::Item], mut f: F) function map_triples (line 17) | fn map_triples(end: usize, mut f: F) type Split (line 31) | struct Split { method forward (line 39) | fn forward(iter: I, i: usize, j: usize, k: usize, expected: &[I::It... method reverse (line 52) | fn reverse(iter: I, i: usize, j: usize, k: usize, expected: &[I::It... type Output (line 67) | type Output = Vec; method callback (line 69) | fn callback
(self, producer: P) -> Self::Output function check_len (line 99) | fn check_len(iter: &I, len: usize) { function array (line 107) | fn array() { function empty (line 113) | fn empty() { function once (line 118) | fn once() { function option (line 123) | fn option() { function range (line 128) | fn range() { function range_inclusive (line 134) | fn range_inclusive() { function repeat_n (line 140) | fn repeat_n() { function slice_iter (line 146) | fn slice_iter() { function slice_iter_mut (line 153) | fn slice_iter_mut() { function slice_chunks (line 165) | fn slice_chunks() { function slice_chunks_exact (line 174) | fn slice_chunks_exact() { function slice_chunks_mut (line 183) | fn slice_chunks_mut() { function slice_chunks_exact_mut (line 196) | fn slice_chunks_exact_mut() { function slice_rchunks (line 209) | fn slice_rchunks() { function slice_rchunks_exact (line 218) | fn slice_rchunks_exact() { function slice_rchunks_mut (line 227) | fn slice_rchunks_mut() { function slice_rchunks_exact_mut (line 240) | fn slice_rchunks_exact_mut() { function slice_windows (line 253) | fn slice_windows() { function vec (line 260) | fn vec() { function chain (line 268) | fn chain() { function cloned (line 274) | fn cloned() { function copied (line 280) | fn copied() { function enumerate (line 286) | fn enumerate() { function step_by (line 292) | fn step_by() { function step_by_unaligned (line 298) | fn step_by_unaligned() { function inspect (line 304) | fn inspect() { function update (line 310) | fn update() { function interleave (line 316) | fn interleave() { function intersperse (line 326) | fn intersperse() { function chunks (line 332) | fn chunks() { function map (line 339) | fn map() { function map_with (line 345) | fn map_with() { function map_init (line 351) | fn map_init() { function panic_fuse (line 357) | fn panic_fuse() { function rev (line 363) | fn rev() { function with_max_len (line 369) | fn with_max_len() { function with_min_len (line 375) | fn with_min_len() { function zip (line 381) | fn zip() { FILE: tests/sort-panic-safe.rs constant LEN (line 11) | const LEN: usize = 20_000; type DropCounter (line 18) | struct DropCounter { method eq (line 25) | fn eq(&self, other: &Self) -> bool { method partial_cmp (line 32) | fn partial_cmp(&self, other: &Self) -> Option { method cmp (line 41) | fn cmp(&self, other: &Self) -> Ordering { method drop (line 47) | fn drop(&mut self) { function sort_panic_safe (line 122) | fn sort_panic_safe() { FILE: tests/str.rs function seeded_rng (line 6) | fn seeded_rng() -> XorShiftRng { function execute_strings (line 13) | pub fn execute_strings() { function execute_strings_split (line 45) | pub fn execute_strings_split() {