1#[macro_use] mod macros;
5
6use super::{from_raw_parts, from_raw_parts_mut};
7use crate::hint::assert_unchecked;
8use crate::iter::{
9    FusedIterator, TrustedLen, TrustedRandomAccess, TrustedRandomAccessNoCoerce, UncheckedIterator,
10};
11use crate::marker::PhantomData;
12use crate::mem::{self, SizedTypeProperties};
13use crate::num::NonZero;
14use crate::ptr::{NonNull, without_provenance, without_provenance_mut};
15use crate::{cmp, fmt};
16
17#[stable(feature = "boxed_slice_into_iter", since = "1.80.0")]
18impl<T> !Iterator for [T] {}
19
20#[stable(feature = "rust1", since = "1.0.0")]
21impl<'a, T> IntoIterator for &'a [T] {
22    type Item = &'a T;
23    type IntoIter = Iter<'a, T>;
24
25    fn into_iter(self) -> Iter<'a, T> {
26        self.iter()
27    }
28}
29
30#[stable(feature = "rust1", since = "1.0.0")]
31impl<'a, T> IntoIterator for &'a mut [T] {
32    type Item = &'a mut T;
33    type IntoIter = IterMut<'a, T>;
34
35    fn into_iter(self) -> IterMut<'a, T> {
36        self.iter_mut()
37    }
38}
39
40#[stable(feature = "rust1", since = "1.0.0")]
67#[must_use = "iterators are lazy and do nothing unless consumed"]
68#[rustc_diagnostic_item = "SliceIter"]
69pub struct Iter<'a, T: 'a> {
70    ptr: NonNull<T>,
75    end_or_len: *const T,
79    _marker: PhantomData<&'a T>,
80}
81
82#[stable(feature = "core_impl_debug", since = "1.9.0")]
83impl<T: fmt::Debug> fmt::Debug for Iter<'_, T> {
84    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
85        f.debug_tuple("Iter").field(&self.as_slice()).finish()
86    }
87}
88
89#[stable(feature = "rust1", since = "1.0.0")]
90unsafe impl<T: Sync> Sync for Iter<'_, T> {}
91#[stable(feature = "rust1", since = "1.0.0")]
92unsafe impl<T: Sync> Send for Iter<'_, T> {}
93
94impl<'a, T> Iter<'a, T> {
95    #[inline]
96    pub(super) fn new(slice: &'a [T]) -> Self {
97        let len = slice.len();
98        let ptr: NonNull<T> = NonNull::from(slice).cast();
99        unsafe {
101            let end_or_len =
102                if T::IS_ZST { without_provenance(len) } else { ptr.as_ptr().add(len) };
103
104            Self { ptr, end_or_len, _marker: PhantomData }
105        }
106    }
107
108    #[must_use]
135    #[stable(feature = "iter_to_slice", since = "1.4.0")]
136    #[inline]
137    pub fn as_slice(&self) -> &'a [T] {
138        self.make_slice()
139    }
140}
141
142iterator! {struct Iter -> *const T, &'a T, const, {}, as_ref, {
143    fn is_sorted_by<F>(self, mut compare: F) -> bool
144    where
145        Self: Sized,
146        F: FnMut(&Self::Item, &Self::Item) -> bool,
147    {
148        self.as_slice().is_sorted_by(|a, b| compare(&a, &b))
149    }
150}}
151
152#[stable(feature = "rust1", since = "1.0.0")]
153impl<T> Clone for Iter<'_, T> {
154    #[inline]
155    fn clone(&self) -> Self {
156        Iter { ptr: self.ptr, end_or_len: self.end_or_len, _marker: self._marker }
157    }
158}
159
160#[stable(feature = "slice_iter_as_ref", since = "1.13.0")]
161impl<T> AsRef<[T]> for Iter<'_, T> {
162    #[inline]
163    fn as_ref(&self) -> &[T] {
164        self.as_slice()
165    }
166}
167
168#[stable(feature = "rust1", since = "1.0.0")]
193#[must_use = "iterators are lazy and do nothing unless consumed"]
194pub struct IterMut<'a, T: 'a> {
195    ptr: NonNull<T>,
200    end_or_len: *mut T,
204    _marker: PhantomData<&'a mut T>,
205}
206
207#[stable(feature = "core_impl_debug", since = "1.9.0")]
208impl<T: fmt::Debug> fmt::Debug for IterMut<'_, T> {
209    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
210        f.debug_tuple("IterMut").field(&self.make_slice()).finish()
211    }
212}
213
214#[stable(feature = "rust1", since = "1.0.0")]
215unsafe impl<T: Sync> Sync for IterMut<'_, T> {}
216#[stable(feature = "rust1", since = "1.0.0")]
217unsafe impl<T: Send> Send for IterMut<'_, T> {}
218
219impl<'a, T> IterMut<'a, T> {
220    #[inline]
221    pub(super) fn new(slice: &'a mut [T]) -> Self {
222        let len = slice.len();
223        let ptr: NonNull<T> = NonNull::from(slice).cast();
224        unsafe {
241            let end_or_len =
242                if T::IS_ZST { without_provenance_mut(len) } else { ptr.as_ptr().add(len) };
243
244            Self { ptr, end_or_len, _marker: PhantomData }
245        }
246    }
247
248    #[must_use = "`self` will be dropped if the result is not used"]
275    #[stable(feature = "iter_to_slice", since = "1.4.0")]
276    pub fn into_slice(self) -> &'a mut [T] {
277        unsafe { from_raw_parts_mut(self.ptr.as_ptr(), len!(self)) }
281    }
282
283    #[must_use]
311    #[stable(feature = "slice_iter_mut_as_slice", since = "1.53.0")]
312    #[inline]
313    pub fn as_slice(&self) -> &[T] {
314        self.make_slice()
315    }
316
317    #[must_use]
346    #[unstable(feature = "slice_iter_mut_as_mut_slice", issue = "93079")]
348    pub fn as_mut_slice(&mut self) -> &mut [T] {
349        unsafe { from_raw_parts_mut(self.ptr.as_ptr(), len!(self)) }
353    }
354}
355
356#[stable(feature = "slice_iter_mut_as_slice", since = "1.53.0")]
357impl<T> AsRef<[T]> for IterMut<'_, T> {
358    #[inline]
359    fn as_ref(&self) -> &[T] {
360        self.as_slice()
361    }
362}
363
364iterator! {struct IterMut -> *mut T, &'a mut T, mut, {mut}, as_mut, {}}
372
373#[doc(hidden)]
376pub(super) trait SplitIter: DoubleEndedIterator {
377    fn finish(&mut self) -> Option<Self::Item>;
380}
381
382#[stable(feature = "rust1", since = "1.0.0")]
400#[must_use = "iterators are lazy and do nothing unless consumed"]
401pub struct Split<'a, T: 'a, P>
402where
403    P: FnMut(&T) -> bool,
404{
405    pub(crate) v: &'a [T],
407    pred: P,
408    pub(crate) finished: bool,
410}
411
412impl<'a, T: 'a, P: FnMut(&T) -> bool> Split<'a, T, P> {
413    #[inline]
414    pub(super) fn new(slice: &'a [T], pred: P) -> Self {
415        Self { v: slice, pred, finished: false }
416    }
417    #[unstable(feature = "split_as_slice", issue = "96137")]
428    pub fn as_slice(&self) -> &'a [T] {
429        if self.finished { &[] } else { &self.v }
430    }
431}
432
433#[stable(feature = "core_impl_debug", since = "1.9.0")]
434impl<T: fmt::Debug, P> fmt::Debug for Split<'_, T, P>
435where
436    P: FnMut(&T) -> bool,
437{
438    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
439        f.debug_struct("Split").field("v", &self.v).field("finished", &self.finished).finish()
440    }
441}
442
443#[stable(feature = "rust1", since = "1.0.0")]
445impl<T, P> Clone for Split<'_, T, P>
446where
447    P: Clone + FnMut(&T) -> bool,
448{
449    fn clone(&self) -> Self {
450        Split { v: self.v, pred: self.pred.clone(), finished: self.finished }
451    }
452}
453
454#[stable(feature = "rust1", since = "1.0.0")]
455impl<'a, T, P> Iterator for Split<'a, T, P>
456where
457    P: FnMut(&T) -> bool,
458{
459    type Item = &'a [T];
460
461    #[inline]
462    fn next(&mut self) -> Option<&'a [T]> {
463        if self.finished {
464            return None;
465        }
466
467        match self.v.iter().position(|x| (self.pred)(x)) {
468            None => self.finish(),
469            Some(idx) => {
470                let (left, right) =
471                    unsafe { (self.v.get_unchecked(..idx), self.v.get_unchecked(idx + 1..)) };
474                let ret = Some(left);
475                self.v = right;
476                ret
477            }
478        }
479    }
480
481    #[inline]
482    fn size_hint(&self) -> (usize, Option<usize>) {
483        if self.finished {
484            (0, Some(0))
485        } else {
486            (1, Some(self.v.len() + 1))
489        }
490    }
491}
492
493#[stable(feature = "rust1", since = "1.0.0")]
494impl<'a, T, P> DoubleEndedIterator for Split<'a, T, P>
495where
496    P: FnMut(&T) -> bool,
497{
498    #[inline]
499    fn next_back(&mut self) -> Option<&'a [T]> {
500        if self.finished {
501            return None;
502        }
503
504        match self.v.iter().rposition(|x| (self.pred)(x)) {
505            None => self.finish(),
506            Some(idx) => {
507                let (left, right) =
508                    unsafe { (self.v.get_unchecked(..idx), self.v.get_unchecked(idx + 1..)) };
511                let ret = Some(right);
512                self.v = left;
513                ret
514            }
515        }
516    }
517}
518
519impl<'a, T, P> SplitIter for Split<'a, T, P>
520where
521    P: FnMut(&T) -> bool,
522{
523    #[inline]
524    fn finish(&mut self) -> Option<&'a [T]> {
525        if self.finished {
526            None
527        } else {
528            self.finished = true;
529            Some(self.v)
530        }
531    }
532}
533
534#[stable(feature = "fused", since = "1.26.0")]
535impl<T, P> FusedIterator for Split<'_, T, P> where P: FnMut(&T) -> bool {}
536
537#[stable(feature = "split_inclusive", since = "1.51.0")]
556#[must_use = "iterators are lazy and do nothing unless consumed"]
557pub struct SplitInclusive<'a, T: 'a, P>
558where
559    P: FnMut(&T) -> bool,
560{
561    v: &'a [T],
562    pred: P,
563    finished: bool,
564}
565
566impl<'a, T: 'a, P: FnMut(&T) -> bool> SplitInclusive<'a, T, P> {
567    #[inline]
568    pub(super) fn new(slice: &'a [T], pred: P) -> Self {
569        let finished = slice.is_empty();
570        Self { v: slice, pred, finished }
571    }
572}
573
574#[stable(feature = "split_inclusive", since = "1.51.0")]
575impl<T: fmt::Debug, P> fmt::Debug for SplitInclusive<'_, T, P>
576where
577    P: FnMut(&T) -> bool,
578{
579    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
580        f.debug_struct("SplitInclusive")
581            .field("v", &self.v)
582            .field("finished", &self.finished)
583            .finish()
584    }
585}
586
587#[stable(feature = "split_inclusive", since = "1.51.0")]
589impl<T, P> Clone for SplitInclusive<'_, T, P>
590where
591    P: Clone + FnMut(&T) -> bool,
592{
593    fn clone(&self) -> Self {
594        SplitInclusive { v: self.v, pred: self.pred.clone(), finished: self.finished }
595    }
596}
597
598#[stable(feature = "split_inclusive", since = "1.51.0")]
599impl<'a, T, P> Iterator for SplitInclusive<'a, T, P>
600where
601    P: FnMut(&T) -> bool,
602{
603    type Item = &'a [T];
604
605    #[inline]
606    fn next(&mut self) -> Option<&'a [T]> {
607        if self.finished {
608            return None;
609        }
610
611        let idx =
612            self.v.iter().position(|x| (self.pred)(x)).map(|idx| idx + 1).unwrap_or(self.v.len());
613        if idx == self.v.len() {
614            self.finished = true;
615        }
616        let ret = Some(&self.v[..idx]);
617        self.v = &self.v[idx..];
618        ret
619    }
620
621    #[inline]
622    fn size_hint(&self) -> (usize, Option<usize>) {
623        if self.finished {
624            (0, Some(0))
625        } else {
626            (1, Some(cmp::max(1, self.v.len())))
630        }
631    }
632}
633
634#[stable(feature = "split_inclusive", since = "1.51.0")]
635impl<'a, T, P> DoubleEndedIterator for SplitInclusive<'a, T, P>
636where
637    P: FnMut(&T) -> bool,
638{
639    #[inline]
640    fn next_back(&mut self) -> Option<&'a [T]> {
641        if self.finished {
642            return None;
643        }
644
645        let remainder = if self.v.is_empty() { &[] } else { &self.v[..(self.v.len() - 1)] };
649        let idx = remainder.iter().rposition(|x| (self.pred)(x)).map(|idx| idx + 1).unwrap_or(0);
650        if idx == 0 {
651            self.finished = true;
652        }
653        let ret = Some(&self.v[idx..]);
654        self.v = &self.v[..idx];
655        ret
656    }
657}
658
659#[stable(feature = "split_inclusive", since = "1.51.0")]
660impl<T, P> FusedIterator for SplitInclusive<'_, T, P> where P: FnMut(&T) -> bool {}
661
662#[stable(feature = "rust1", since = "1.0.0")]
677#[must_use = "iterators are lazy and do nothing unless consumed"]
678pub struct SplitMut<'a, T: 'a, P>
679where
680    P: FnMut(&T) -> bool,
681{
682    v: &'a mut [T],
683    pred: P,
684    finished: bool,
685}
686
687impl<'a, T: 'a, P: FnMut(&T) -> bool> SplitMut<'a, T, P> {
688    #[inline]
689    pub(super) fn new(slice: &'a mut [T], pred: P) -> Self {
690        Self { v: slice, pred, finished: false }
691    }
692}
693
694#[stable(feature = "core_impl_debug", since = "1.9.0")]
695impl<T: fmt::Debug, P> fmt::Debug for SplitMut<'_, T, P>
696where
697    P: FnMut(&T) -> bool,
698{
699    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
700        f.debug_struct("SplitMut").field("v", &self.v).field("finished", &self.finished).finish()
701    }
702}
703
704impl<'a, T, P> SplitIter for SplitMut<'a, T, P>
705where
706    P: FnMut(&T) -> bool,
707{
708    #[inline]
709    fn finish(&mut self) -> Option<&'a mut [T]> {
710        if self.finished {
711            None
712        } else {
713            self.finished = true;
714            Some(mem::take(&mut self.v))
715        }
716    }
717}
718
719#[stable(feature = "rust1", since = "1.0.0")]
720impl<'a, T, P> Iterator for SplitMut<'a, T, P>
721where
722    P: FnMut(&T) -> bool,
723{
724    type Item = &'a mut [T];
725
726    #[inline]
727    fn next(&mut self) -> Option<&'a mut [T]> {
728        if self.finished {
729            return None;
730        }
731
732        match self.v.iter().position(|x| (self.pred)(x)) {
733            None => self.finish(),
734            Some(idx) => {
735                let tmp = mem::take(&mut self.v);
736                let (head, tail) = tmp.split_at_mut(idx + 1);
740                self.v = tail;
741                Some(&mut head[..idx])
743            }
744        }
745    }
746
747    #[inline]
748    fn size_hint(&self) -> (usize, Option<usize>) {
749        if self.finished {
750            (0, Some(0))
751        } else {
752            (1, Some(self.v.len() + 1))
755        }
756    }
757}
758
759#[stable(feature = "rust1", since = "1.0.0")]
760impl<'a, T, P> DoubleEndedIterator for SplitMut<'a, T, P>
761where
762    P: FnMut(&T) -> bool,
763{
764    #[inline]
765    fn next_back(&mut self) -> Option<&'a mut [T]> {
766        if self.finished {
767            return None;
768        }
769
770        let idx_opt = {
771            let pred = &mut self.pred;
773            self.v.iter().rposition(|x| (*pred)(x))
774        };
775        match idx_opt {
776            None => self.finish(),
777            Some(idx) => {
778                let tmp = mem::take(&mut self.v);
779                let (head, tail) = tmp.split_at_mut(idx);
780                self.v = head;
781                Some(&mut tail[1..])
782            }
783        }
784    }
785}
786
787#[stable(feature = "fused", since = "1.26.0")]
788impl<T, P> FusedIterator for SplitMut<'_, T, P> where P: FnMut(&T) -> bool {}
789
790#[stable(feature = "split_inclusive", since = "1.51.0")]
806#[must_use = "iterators are lazy and do nothing unless consumed"]
807pub struct SplitInclusiveMut<'a, T: 'a, P>
808where
809    P: FnMut(&T) -> bool,
810{
811    v: &'a mut [T],
812    pred: P,
813    finished: bool,
814}
815
816impl<'a, T: 'a, P: FnMut(&T) -> bool> SplitInclusiveMut<'a, T, P> {
817    #[inline]
818    pub(super) fn new(slice: &'a mut [T], pred: P) -> Self {
819        let finished = slice.is_empty();
820        Self { v: slice, pred, finished }
821    }
822}
823
824#[stable(feature = "split_inclusive", since = "1.51.0")]
825impl<T: fmt::Debug, P> fmt::Debug for SplitInclusiveMut<'_, T, P>
826where
827    P: FnMut(&T) -> bool,
828{
829    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
830        f.debug_struct("SplitInclusiveMut")
831            .field("v", &self.v)
832            .field("finished", &self.finished)
833            .finish()
834    }
835}
836
837#[stable(feature = "split_inclusive", since = "1.51.0")]
838impl<'a, T, P> Iterator for SplitInclusiveMut<'a, T, P>
839where
840    P: FnMut(&T) -> bool,
841{
842    type Item = &'a mut [T];
843
844    #[inline]
845    fn next(&mut self) -> Option<&'a mut [T]> {
846        if self.finished {
847            return None;
848        }
849
850        let idx_opt = {
851            let pred = &mut self.pred;
853            self.v.iter().position(|x| (*pred)(x))
854        };
855        let idx = idx_opt.map(|idx| idx + 1).unwrap_or(self.v.len());
856        if idx == self.v.len() {
857            self.finished = true;
858        }
859        let tmp = mem::take(&mut self.v);
860        let (head, tail) = tmp.split_at_mut(idx);
861        self.v = tail;
862        Some(head)
863    }
864
865    #[inline]
866    fn size_hint(&self) -> (usize, Option<usize>) {
867        if self.finished {
868            (0, Some(0))
869        } else {
870            (1, Some(cmp::max(1, self.v.len())))
874        }
875    }
876}
877
878#[stable(feature = "split_inclusive", since = "1.51.0")]
879impl<'a, T, P> DoubleEndedIterator for SplitInclusiveMut<'a, T, P>
880where
881    P: FnMut(&T) -> bool,
882{
883    #[inline]
884    fn next_back(&mut self) -> Option<&'a mut [T]> {
885        if self.finished {
886            return None;
887        }
888
889        let idx_opt = if self.v.is_empty() {
890            None
891        } else {
892            let pred = &mut self.pred;
894
895            let remainder = &self.v[..(self.v.len() - 1)];
899            remainder.iter().rposition(|x| (*pred)(x))
900        };
901        let idx = idx_opt.map(|idx| idx + 1).unwrap_or(0);
902        if idx == 0 {
903            self.finished = true;
904        }
905        let tmp = mem::take(&mut self.v);
906        let (head, tail) = tmp.split_at_mut(idx);
907        self.v = head;
908        Some(tail)
909    }
910}
911
912#[stable(feature = "split_inclusive", since = "1.51.0")]
913impl<T, P> FusedIterator for SplitInclusiveMut<'_, T, P> where P: FnMut(&T) -> bool {}
914
915#[stable(feature = "slice_rsplit", since = "1.27.0")]
933#[must_use = "iterators are lazy and do nothing unless consumed"]
934pub struct RSplit<'a, T: 'a, P>
935where
936    P: FnMut(&T) -> bool,
937{
938    inner: Split<'a, T, P>,
939}
940
941impl<'a, T: 'a, P: FnMut(&T) -> bool> RSplit<'a, T, P> {
942    #[inline]
943    pub(super) fn new(slice: &'a [T], pred: P) -> Self {
944        Self { inner: Split::new(slice, pred) }
945    }
946}
947
948#[stable(feature = "slice_rsplit", since = "1.27.0")]
949impl<T: fmt::Debug, P> fmt::Debug for RSplit<'_, T, P>
950where
951    P: FnMut(&T) -> bool,
952{
953    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
954        f.debug_struct("RSplit")
955            .field("v", &self.inner.v)
956            .field("finished", &self.inner.finished)
957            .finish()
958    }
959}
960
961#[stable(feature = "slice_rsplit", since = "1.27.0")]
963impl<T, P> Clone for RSplit<'_, T, P>
964where
965    P: Clone + FnMut(&T) -> bool,
966{
967    fn clone(&self) -> Self {
968        RSplit { inner: self.inner.clone() }
969    }
970}
971
972#[stable(feature = "slice_rsplit", since = "1.27.0")]
973impl<'a, T, P> Iterator for RSplit<'a, T, P>
974where
975    P: FnMut(&T) -> bool,
976{
977    type Item = &'a [T];
978
979    #[inline]
980    fn next(&mut self) -> Option<&'a [T]> {
981        self.inner.next_back()
982    }
983
984    #[inline]
985    fn size_hint(&self) -> (usize, Option<usize>) {
986        self.inner.size_hint()
987    }
988}
989
990#[stable(feature = "slice_rsplit", since = "1.27.0")]
991impl<'a, T, P> DoubleEndedIterator for RSplit<'a, T, P>
992where
993    P: FnMut(&T) -> bool,
994{
995    #[inline]
996    fn next_back(&mut self) -> Option<&'a [T]> {
997        self.inner.next()
998    }
999}
1000
1001#[stable(feature = "slice_rsplit", since = "1.27.0")]
1002impl<'a, T, P> SplitIter for RSplit<'a, T, P>
1003where
1004    P: FnMut(&T) -> bool,
1005{
1006    #[inline]
1007    fn finish(&mut self) -> Option<&'a [T]> {
1008        self.inner.finish()
1009    }
1010}
1011
1012#[stable(feature = "slice_rsplit", since = "1.27.0")]
1013impl<T, P> FusedIterator for RSplit<'_, T, P> where P: FnMut(&T) -> bool {}
1014
1015#[stable(feature = "slice_rsplit", since = "1.27.0")]
1030#[must_use = "iterators are lazy and do nothing unless consumed"]
1031pub struct RSplitMut<'a, T: 'a, P>
1032where
1033    P: FnMut(&T) -> bool,
1034{
1035    inner: SplitMut<'a, T, P>,
1036}
1037
1038impl<'a, T: 'a, P: FnMut(&T) -> bool> RSplitMut<'a, T, P> {
1039    #[inline]
1040    pub(super) fn new(slice: &'a mut [T], pred: P) -> Self {
1041        Self { inner: SplitMut::new(slice, pred) }
1042    }
1043}
1044
1045#[stable(feature = "slice_rsplit", since = "1.27.0")]
1046impl<T: fmt::Debug, P> fmt::Debug for RSplitMut<'_, T, P>
1047where
1048    P: FnMut(&T) -> bool,
1049{
1050    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1051        f.debug_struct("RSplitMut")
1052            .field("v", &self.inner.v)
1053            .field("finished", &self.inner.finished)
1054            .finish()
1055    }
1056}
1057
1058#[stable(feature = "slice_rsplit", since = "1.27.0")]
1059impl<'a, T, P> SplitIter for RSplitMut<'a, T, P>
1060where
1061    P: FnMut(&T) -> bool,
1062{
1063    #[inline]
1064    fn finish(&mut self) -> Option<&'a mut [T]> {
1065        self.inner.finish()
1066    }
1067}
1068
1069#[stable(feature = "slice_rsplit", since = "1.27.0")]
1070impl<'a, T, P> Iterator for RSplitMut<'a, T, P>
1071where
1072    P: FnMut(&T) -> bool,
1073{
1074    type Item = &'a mut [T];
1075
1076    #[inline]
1077    fn next(&mut self) -> Option<&'a mut [T]> {
1078        self.inner.next_back()
1079    }
1080
1081    #[inline]
1082    fn size_hint(&self) -> (usize, Option<usize>) {
1083        self.inner.size_hint()
1084    }
1085}
1086
1087#[stable(feature = "slice_rsplit", since = "1.27.0")]
1088impl<'a, T, P> DoubleEndedIterator for RSplitMut<'a, T, P>
1089where
1090    P: FnMut(&T) -> bool,
1091{
1092    #[inline]
1093    fn next_back(&mut self) -> Option<&'a mut [T]> {
1094        self.inner.next()
1095    }
1096}
1097
1098#[stable(feature = "slice_rsplit", since = "1.27.0")]
1099impl<T, P> FusedIterator for RSplitMut<'_, T, P> where P: FnMut(&T) -> bool {}
1100
1101#[derive(Debug)]
1105struct GenericSplitN<I> {
1106    iter: I,
1107    count: usize,
1108}
1109
1110impl<T, I: SplitIter<Item = T>> Iterator for GenericSplitN<I> {
1111    type Item = T;
1112
1113    #[inline]
1114    fn next(&mut self) -> Option<T> {
1115        match self.count {
1116            0 => None,
1117            1 => {
1118                self.count -= 1;
1119                self.iter.finish()
1120            }
1121            _ => {
1122                self.count -= 1;
1123                self.iter.next()
1124            }
1125        }
1126    }
1127
1128    #[inline]
1129    fn size_hint(&self) -> (usize, Option<usize>) {
1130        let (lower, upper_opt) = self.iter.size_hint();
1131        (
1132            cmp::min(self.count, lower),
1133            Some(upper_opt.map_or(self.count, |upper| cmp::min(self.count, upper))),
1134        )
1135    }
1136}
1137
1138#[stable(feature = "rust1", since = "1.0.0")]
1156#[must_use = "iterators are lazy and do nothing unless consumed"]
1157pub struct SplitN<'a, T: 'a, P>
1158where
1159    P: FnMut(&T) -> bool,
1160{
1161    inner: GenericSplitN<Split<'a, T, P>>,
1162}
1163
1164impl<'a, T: 'a, P: FnMut(&T) -> bool> SplitN<'a, T, P> {
1165    #[inline]
1166    pub(super) fn new(s: Split<'a, T, P>, n: usize) -> Self {
1167        Self { inner: GenericSplitN { iter: s, count: n } }
1168    }
1169}
1170
1171#[stable(feature = "core_impl_debug", since = "1.9.0")]
1172impl<T: fmt::Debug, P> fmt::Debug for SplitN<'_, T, P>
1173where
1174    P: FnMut(&T) -> bool,
1175{
1176    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1177        f.debug_struct("SplitN").field("inner", &self.inner).finish()
1178    }
1179}
1180
1181#[stable(feature = "rust1", since = "1.0.0")]
1200#[must_use = "iterators are lazy and do nothing unless consumed"]
1201pub struct RSplitN<'a, T: 'a, P>
1202where
1203    P: FnMut(&T) -> bool,
1204{
1205    inner: GenericSplitN<RSplit<'a, T, P>>,
1206}
1207
1208impl<'a, T: 'a, P: FnMut(&T) -> bool> RSplitN<'a, T, P> {
1209    #[inline]
1210    pub(super) fn new(s: RSplit<'a, T, P>, n: usize) -> Self {
1211        Self { inner: GenericSplitN { iter: s, count: n } }
1212    }
1213}
1214
1215#[stable(feature = "core_impl_debug", since = "1.9.0")]
1216impl<T: fmt::Debug, P> fmt::Debug for RSplitN<'_, T, P>
1217where
1218    P: FnMut(&T) -> bool,
1219{
1220    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1221        f.debug_struct("RSplitN").field("inner", &self.inner).finish()
1222    }
1223}
1224
1225#[stable(feature = "rust1", since = "1.0.0")]
1240#[must_use = "iterators are lazy and do nothing unless consumed"]
1241pub struct SplitNMut<'a, T: 'a, P>
1242where
1243    P: FnMut(&T) -> bool,
1244{
1245    inner: GenericSplitN<SplitMut<'a, T, P>>,
1246}
1247
1248impl<'a, T: 'a, P: FnMut(&T) -> bool> SplitNMut<'a, T, P> {
1249    #[inline]
1250    pub(super) fn new(s: SplitMut<'a, T, P>, n: usize) -> Self {
1251        Self { inner: GenericSplitN { iter: s, count: n } }
1252    }
1253}
1254
1255#[stable(feature = "core_impl_debug", since = "1.9.0")]
1256impl<T: fmt::Debug, P> fmt::Debug for SplitNMut<'_, T, P>
1257where
1258    P: FnMut(&T) -> bool,
1259{
1260    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1261        f.debug_struct("SplitNMut").field("inner", &self.inner).finish()
1262    }
1263}
1264
1265#[stable(feature = "rust1", since = "1.0.0")]
1281#[must_use = "iterators are lazy and do nothing unless consumed"]
1282pub struct RSplitNMut<'a, T: 'a, P>
1283where
1284    P: FnMut(&T) -> bool,
1285{
1286    inner: GenericSplitN<RSplitMut<'a, T, P>>,
1287}
1288
1289impl<'a, T: 'a, P: FnMut(&T) -> bool> RSplitNMut<'a, T, P> {
1290    #[inline]
1291    pub(super) fn new(s: RSplitMut<'a, T, P>, n: usize) -> Self {
1292        Self { inner: GenericSplitN { iter: s, count: n } }
1293    }
1294}
1295
1296#[stable(feature = "core_impl_debug", since = "1.9.0")]
1297impl<T: fmt::Debug, P> fmt::Debug for RSplitNMut<'_, T, P>
1298where
1299    P: FnMut(&T) -> bool,
1300{
1301    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1302        f.debug_struct("RSplitNMut").field("inner", &self.inner).finish()
1303    }
1304}
1305
1306forward_iterator! { SplitN: T, &'a [T] }
1307forward_iterator! { RSplitN: T, &'a [T] }
1308forward_iterator! { SplitNMut: T, &'a mut [T] }
1309forward_iterator! { RSplitNMut: T, &'a mut [T] }
1310
1311#[derive(Debug)]
1329#[stable(feature = "rust1", since = "1.0.0")]
1330#[must_use = "iterators are lazy and do nothing unless consumed"]
1331pub struct Windows<'a, T: 'a> {
1332    v: &'a [T],
1333    size: NonZero<usize>,
1334}
1335
1336impl<'a, T: 'a> Windows<'a, T> {
1337    #[inline]
1338    pub(super) fn new(slice: &'a [T], size: NonZero<usize>) -> Self {
1339        Self { v: slice, size }
1340    }
1341}
1342
1343#[stable(feature = "rust1", since = "1.0.0")]
1345impl<T> Clone for Windows<'_, T> {
1346    fn clone(&self) -> Self {
1347        Windows { v: self.v, size: self.size }
1348    }
1349}
1350
1351#[stable(feature = "rust1", since = "1.0.0")]
1352impl<'a, T> Iterator for Windows<'a, T> {
1353    type Item = &'a [T];
1354
1355    #[inline]
1356    fn next(&mut self) -> Option<&'a [T]> {
1357        if self.size.get() > self.v.len() {
1358            None
1359        } else {
1360            let ret = Some(&self.v[..self.size.get()]);
1361            self.v = &self.v[1..];
1362            ret
1363        }
1364    }
1365
1366    #[inline]
1367    fn size_hint(&self) -> (usize, Option<usize>) {
1368        if self.size.get() > self.v.len() {
1369            (0, Some(0))
1370        } else {
1371            let size = self.v.len() - self.size.get() + 1;
1372            (size, Some(size))
1373        }
1374    }
1375
1376    #[inline]
1377    fn count(self) -> usize {
1378        self.len()
1379    }
1380
1381    #[inline]
1382    fn nth(&mut self, n: usize) -> Option<Self::Item> {
1383        let (end, overflow) = self.size.get().overflowing_add(n);
1384        if end > self.v.len() || overflow {
1385            self.v = &[];
1386            None
1387        } else {
1388            let nth = &self.v[n..end];
1389            self.v = &self.v[n + 1..];
1390            Some(nth)
1391        }
1392    }
1393
1394    #[inline]
1395    fn last(self) -> Option<Self::Item> {
1396        if self.size.get() > self.v.len() {
1397            None
1398        } else {
1399            let start = self.v.len() - self.size.get();
1400            Some(&self.v[start..])
1401        }
1402    }
1403
1404    unsafe fn __iterator_get_unchecked(&mut self, idx: usize) -> Self::Item {
1405        unsafe { from_raw_parts(self.v.as_ptr().add(idx), self.size.get()) }
1410    }
1411}
1412
1413#[stable(feature = "rust1", since = "1.0.0")]
1414impl<'a, T> DoubleEndedIterator for Windows<'a, T> {
1415    #[inline]
1416    fn next_back(&mut self) -> Option<&'a [T]> {
1417        if self.size.get() > self.v.len() {
1418            None
1419        } else {
1420            let ret = Some(&self.v[self.v.len() - self.size.get()..]);
1421            self.v = &self.v[..self.v.len() - 1];
1422            ret
1423        }
1424    }
1425
1426    #[inline]
1427    fn nth_back(&mut self, n: usize) -> Option<Self::Item> {
1428        let (end, overflow) = self.v.len().overflowing_sub(n);
1429        if end < self.size.get() || overflow {
1430            self.v = &[];
1431            None
1432        } else {
1433            let ret = &self.v[end - self.size.get()..end];
1434            self.v = &self.v[..end - 1];
1435            Some(ret)
1436        }
1437    }
1438}
1439
1440#[stable(feature = "rust1", since = "1.0.0")]
1441impl<T> ExactSizeIterator for Windows<'_, T> {}
1442
1443#[unstable(feature = "trusted_len", issue = "37572")]
1444unsafe impl<T> TrustedLen for Windows<'_, T> {}
1445
1446#[stable(feature = "fused", since = "1.26.0")]
1447impl<T> FusedIterator for Windows<'_, T> {}
1448
1449#[doc(hidden)]
1450#[unstable(feature = "trusted_random_access", issue = "none")]
1451unsafe impl<'a, T> TrustedRandomAccess for Windows<'a, T> {}
1452
1453#[doc(hidden)]
1454#[unstable(feature = "trusted_random_access", issue = "none")]
1455unsafe impl<'a, T> TrustedRandomAccessNoCoerce for Windows<'a, T> {
1456    const MAY_HAVE_SIDE_EFFECT: bool = false;
1457}
1458
1459#[derive(Debug)]
1481#[stable(feature = "rust1", since = "1.0.0")]
1482#[must_use = "iterators are lazy and do nothing unless consumed"]
1483pub struct Chunks<'a, T: 'a> {
1484    v: &'a [T],
1485    chunk_size: usize,
1486}
1487
1488impl<'a, T: 'a> Chunks<'a, T> {
1489    #[inline]
1490    pub(super) fn new(slice: &'a [T], size: usize) -> Self {
1491        Self { v: slice, chunk_size: size }
1492    }
1493}
1494
1495#[stable(feature = "rust1", since = "1.0.0")]
1497impl<T> Clone for Chunks<'_, T> {
1498    fn clone(&self) -> Self {
1499        Chunks { v: self.v, chunk_size: self.chunk_size }
1500    }
1501}
1502
1503#[stable(feature = "rust1", since = "1.0.0")]
1504impl<'a, T> Iterator for Chunks<'a, T> {
1505    type Item = &'a [T];
1506
1507    #[inline]
1508    fn next(&mut self) -> Option<&'a [T]> {
1509        if self.v.is_empty() {
1510            None
1511        } else {
1512            let chunksz = cmp::min(self.v.len(), self.chunk_size);
1513            let (fst, snd) = self.v.split_at(chunksz);
1514            self.v = snd;
1515            Some(fst)
1516        }
1517    }
1518
1519    #[inline]
1520    fn size_hint(&self) -> (usize, Option<usize>) {
1521        if self.v.is_empty() {
1522            (0, Some(0))
1523        } else {
1524            let n = self.v.len() / self.chunk_size;
1525            let rem = self.v.len() % self.chunk_size;
1526            let n = if rem > 0 { n + 1 } else { n };
1527            (n, Some(n))
1528        }
1529    }
1530
1531    #[inline]
1532    fn count(self) -> usize {
1533        self.len()
1534    }
1535
1536    #[inline]
1537    fn nth(&mut self, n: usize) -> Option<Self::Item> {
1538        let (start, overflow) = n.overflowing_mul(self.chunk_size);
1539        if start >= self.v.len() || overflow {
1540            self.v = &[];
1541            None
1542        } else {
1543            let end = match start.checked_add(self.chunk_size) {
1544                Some(sum) => cmp::min(self.v.len(), sum),
1545                None => self.v.len(),
1546            };
1547            let nth = &self.v[start..end];
1548            self.v = &self.v[end..];
1549            Some(nth)
1550        }
1551    }
1552
1553    #[inline]
1554    fn last(self) -> Option<Self::Item> {
1555        if self.v.is_empty() {
1556            None
1557        } else {
1558            let start = (self.v.len() - 1) / self.chunk_size * self.chunk_size;
1559            Some(&self.v[start..])
1560        }
1561    }
1562
1563    unsafe fn __iterator_get_unchecked(&mut self, idx: usize) -> Self::Item {
1564        let start = idx * self.chunk_size;
1565        unsafe {
1573            let len = cmp::min(self.v.len().unchecked_sub(start), self.chunk_size);
1574            from_raw_parts(self.v.as_ptr().add(start), len)
1575        }
1576    }
1577}
1578
1579#[stable(feature = "rust1", since = "1.0.0")]
1580impl<'a, T> DoubleEndedIterator for Chunks<'a, T> {
1581    #[inline]
1582    fn next_back(&mut self) -> Option<&'a [T]> {
1583        if self.v.is_empty() {
1584            None
1585        } else {
1586            let remainder = self.v.len() % self.chunk_size;
1587            let chunksz = if remainder != 0 { remainder } else { self.chunk_size };
1588            let (fst, snd) = unsafe { self.v.split_at_unchecked(self.v.len() - chunksz) };
1603            self.v = fst;
1604            Some(snd)
1605        }
1606    }
1607
1608    #[inline]
1609    fn nth_back(&mut self, n: usize) -> Option<Self::Item> {
1610        let len = self.len();
1611        if n >= len {
1612            self.v = &[];
1613            None
1614        } else {
1615            let start = (len - 1 - n) * self.chunk_size;
1616            let end = match start.checked_add(self.chunk_size) {
1617                Some(res) => cmp::min(self.v.len(), res),
1618                None => self.v.len(),
1619            };
1620            let nth_back = &self.v[start..end];
1621            self.v = &self.v[..start];
1622            Some(nth_back)
1623        }
1624    }
1625}
1626
1627#[stable(feature = "rust1", since = "1.0.0")]
1628impl<T> ExactSizeIterator for Chunks<'_, T> {}
1629
1630#[unstable(feature = "trusted_len", issue = "37572")]
1631unsafe impl<T> TrustedLen for Chunks<'_, T> {}
1632
1633#[stable(feature = "fused", since = "1.26.0")]
1634impl<T> FusedIterator for Chunks<'_, T> {}
1635
1636#[doc(hidden)]
1637#[unstable(feature = "trusted_random_access", issue = "none")]
1638unsafe impl<'a, T> TrustedRandomAccess for Chunks<'a, T> {}
1639
1640#[doc(hidden)]
1641#[unstable(feature = "trusted_random_access", issue = "none")]
1642unsafe impl<'a, T> TrustedRandomAccessNoCoerce for Chunks<'a, T> {
1643    const MAY_HAVE_SIDE_EFFECT: bool = false;
1644}
1645
1646#[derive(Debug)]
1664#[stable(feature = "rust1", since = "1.0.0")]
1665#[must_use = "iterators are lazy and do nothing unless consumed"]
1666pub struct ChunksMut<'a, T: 'a> {
1667    v: *mut [T],
1674    chunk_size: usize,
1675    _marker: PhantomData<&'a mut T>,
1676}
1677
1678impl<'a, T: 'a> ChunksMut<'a, T> {
1679    #[inline]
1680    pub(super) fn new(slice: &'a mut [T], size: usize) -> Self {
1681        Self { v: slice, chunk_size: size, _marker: PhantomData }
1682    }
1683}
1684
1685#[stable(feature = "rust1", since = "1.0.0")]
1686impl<'a, T> Iterator for ChunksMut<'a, T> {
1687    type Item = &'a mut [T];
1688
1689    #[inline]
1690    fn next(&mut self) -> Option<&'a mut [T]> {
1691        if self.v.is_empty() {
1692            None
1693        } else {
1694            let sz = cmp::min(self.v.len(), self.chunk_size);
1695            let (head, tail) = unsafe { self.v.split_at_mut(sz) };
1697            self.v = tail;
1698            Some(unsafe { &mut *head })
1700        }
1701    }
1702
1703    #[inline]
1704    fn size_hint(&self) -> (usize, Option<usize>) {
1705        if self.v.is_empty() {
1706            (0, Some(0))
1707        } else {
1708            let n = self.v.len() / self.chunk_size;
1709            let rem = self.v.len() % self.chunk_size;
1710            let n = if rem > 0 { n + 1 } else { n };
1711            (n, Some(n))
1712        }
1713    }
1714
1715    #[inline]
1716    fn count(self) -> usize {
1717        self.len()
1718    }
1719
1720    #[inline]
1721    fn nth(&mut self, n: usize) -> Option<&'a mut [T]> {
1722        let (start, overflow) = n.overflowing_mul(self.chunk_size);
1723        if start >= self.v.len() || overflow {
1724            self.v = &mut [];
1725            None
1726        } else {
1727            let end = match start.checked_add(self.chunk_size) {
1728                Some(sum) => cmp::min(self.v.len(), sum),
1729                None => self.v.len(),
1730            };
1731            let (head, tail) = unsafe { self.v.split_at_mut(end) };
1733            let (_, nth) = unsafe { head.split_at_mut(start) };
1735            self.v = tail;
1736            Some(unsafe { &mut *nth })
1738        }
1739    }
1740
1741    #[inline]
1742    fn last(self) -> Option<Self::Item> {
1743        if self.v.is_empty() {
1744            None
1745        } else {
1746            let start = (self.v.len() - 1) / self.chunk_size * self.chunk_size;
1747            Some(unsafe { &mut *self.v.get_unchecked_mut(start..) })
1749        }
1750    }
1751
1752    unsafe fn __iterator_get_unchecked(&mut self, idx: usize) -> Self::Item {
1753        let start = idx * self.chunk_size;
1754        unsafe {
1761            let len = cmp::min(self.v.len().unchecked_sub(start), self.chunk_size);
1762            from_raw_parts_mut(self.v.as_mut_ptr().add(start), len)
1763        }
1764    }
1765}
1766
1767#[stable(feature = "rust1", since = "1.0.0")]
1768impl<'a, T> DoubleEndedIterator for ChunksMut<'a, T> {
1769    #[inline]
1770    fn next_back(&mut self) -> Option<&'a mut [T]> {
1771        if self.v.is_empty() {
1772            None
1773        } else {
1774            let remainder = self.v.len() % self.chunk_size;
1775            let sz = if remainder != 0 { remainder } else { self.chunk_size };
1776            let len = self.v.len();
1777            let (head, tail) = unsafe { self.v.split_at_mut_unchecked(len - sz) };
1779            self.v = head;
1780            Some(unsafe { &mut *tail })
1782        }
1783    }
1784
1785    #[inline]
1786    fn nth_back(&mut self, n: usize) -> Option<Self::Item> {
1787        let len = self.len();
1788        if n >= len {
1789            self.v = &mut [];
1790            None
1791        } else {
1792            let start = (len - 1 - n) * self.chunk_size;
1793            let end = match start.checked_add(self.chunk_size) {
1794                Some(res) => cmp::min(self.v.len(), res),
1795                None => self.v.len(),
1796            };
1797            let (temp, _tail) = unsafe { self.v.split_at_mut(end) };
1799            let (head, nth_back) = unsafe { temp.split_at_mut(start) };
1801            self.v = head;
1802            Some(unsafe { &mut *nth_back })
1804        }
1805    }
1806}
1807
1808#[stable(feature = "rust1", since = "1.0.0")]
1809impl<T> ExactSizeIterator for ChunksMut<'_, T> {}
1810
1811#[unstable(feature = "trusted_len", issue = "37572")]
1812unsafe impl<T> TrustedLen for ChunksMut<'_, T> {}
1813
1814#[stable(feature = "fused", since = "1.26.0")]
1815impl<T> FusedIterator for ChunksMut<'_, T> {}
1816
1817#[doc(hidden)]
1818#[unstable(feature = "trusted_random_access", issue = "none")]
1819unsafe impl<'a, T> TrustedRandomAccess for ChunksMut<'a, T> {}
1820
1821#[doc(hidden)]
1822#[unstable(feature = "trusted_random_access", issue = "none")]
1823unsafe impl<'a, T> TrustedRandomAccessNoCoerce for ChunksMut<'a, T> {
1824    const MAY_HAVE_SIDE_EFFECT: bool = false;
1825}
1826
1827#[stable(feature = "rust1", since = "1.0.0")]
1828unsafe impl<T> Send for ChunksMut<'_, T> where T: Send {}
1829
1830#[stable(feature = "rust1", since = "1.0.0")]
1831unsafe impl<T> Sync for ChunksMut<'_, T> where T: Sync {}
1832
1833#[derive(Debug)]
1856#[stable(feature = "chunks_exact", since = "1.31.0")]
1857#[must_use = "iterators are lazy and do nothing unless consumed"]
1858pub struct ChunksExact<'a, T: 'a> {
1859    v: &'a [T],
1860    rem: &'a [T],
1861    chunk_size: usize,
1862}
1863
1864impl<'a, T> ChunksExact<'a, T> {
1865    #[inline]
1866    pub(super) fn new(slice: &'a [T], chunk_size: usize) -> Self {
1867        let rem = slice.len() % chunk_size;
1868        let fst_len = slice.len() - rem;
1869        let (fst, snd) = unsafe { slice.split_at_unchecked(fst_len) };
1871        Self { v: fst, rem: snd, chunk_size }
1872    }
1873
1874    #[must_use]
1892    #[stable(feature = "chunks_exact", since = "1.31.0")]
1893    pub fn remainder(&self) -> &'a [T] {
1894        self.rem
1895    }
1896}
1897
1898#[stable(feature = "chunks_exact", since = "1.31.0")]
1900impl<T> Clone for ChunksExact<'_, T> {
1901    fn clone(&self) -> Self {
1902        ChunksExact { v: self.v, rem: self.rem, chunk_size: self.chunk_size }
1903    }
1904}
1905
1906#[stable(feature = "chunks_exact", since = "1.31.0")]
1907impl<'a, T> Iterator for ChunksExact<'a, T> {
1908    type Item = &'a [T];
1909
1910    #[inline]
1911    fn next(&mut self) -> Option<&'a [T]> {
1912        if self.v.len() < self.chunk_size {
1913            None
1914        } else {
1915            let (fst, snd) = self.v.split_at(self.chunk_size);
1916            self.v = snd;
1917            Some(fst)
1918        }
1919    }
1920
1921    #[inline]
1922    fn size_hint(&self) -> (usize, Option<usize>) {
1923        let n = self.v.len() / self.chunk_size;
1924        (n, Some(n))
1925    }
1926
1927    #[inline]
1928    fn count(self) -> usize {
1929        self.len()
1930    }
1931
1932    #[inline]
1933    fn nth(&mut self, n: usize) -> Option<Self::Item> {
1934        let (start, overflow) = n.overflowing_mul(self.chunk_size);
1935        if start >= self.v.len() || overflow {
1936            self.v = &[];
1937            None
1938        } else {
1939            let (_, snd) = self.v.split_at(start);
1940            self.v = snd;
1941            self.next()
1942        }
1943    }
1944
1945    #[inline]
1946    fn last(mut self) -> Option<Self::Item> {
1947        self.next_back()
1948    }
1949
1950    unsafe fn __iterator_get_unchecked(&mut self, idx: usize) -> Self::Item {
1951        let start = idx * self.chunk_size;
1952        unsafe { from_raw_parts(self.v.as_ptr().add(start), self.chunk_size) }
1954    }
1955}
1956
1957#[stable(feature = "chunks_exact", since = "1.31.0")]
1958impl<'a, T> DoubleEndedIterator for ChunksExact<'a, T> {
1959    #[inline]
1960    fn next_back(&mut self) -> Option<&'a [T]> {
1961        if self.v.len() < self.chunk_size {
1962            None
1963        } else {
1964            let (fst, snd) = self.v.split_at(self.v.len() - self.chunk_size);
1965            self.v = fst;
1966            Some(snd)
1967        }
1968    }
1969
1970    #[inline]
1971    fn nth_back(&mut self, n: usize) -> Option<Self::Item> {
1972        let len = self.len();
1973        if n >= len {
1974            self.v = &[];
1975            None
1976        } else {
1977            let start = (len - 1 - n) * self.chunk_size;
1978            let end = start + self.chunk_size;
1979            let nth_back = &self.v[start..end];
1980            self.v = &self.v[..start];
1981            Some(nth_back)
1982        }
1983    }
1984}
1985
1986#[stable(feature = "chunks_exact", since = "1.31.0")]
1987impl<T> ExactSizeIterator for ChunksExact<'_, T> {
1988    fn is_empty(&self) -> bool {
1989        self.v.is_empty()
1990    }
1991}
1992
1993#[unstable(feature = "trusted_len", issue = "37572")]
1994unsafe impl<T> TrustedLen for ChunksExact<'_, T> {}
1995
1996#[stable(feature = "chunks_exact", since = "1.31.0")]
1997impl<T> FusedIterator for ChunksExact<'_, T> {}
1998
1999#[doc(hidden)]
2000#[unstable(feature = "trusted_random_access", issue = "none")]
2001unsafe impl<'a, T> TrustedRandomAccess for ChunksExact<'a, T> {}
2002
2003#[doc(hidden)]
2004#[unstable(feature = "trusted_random_access", issue = "none")]
2005unsafe impl<'a, T> TrustedRandomAccessNoCoerce for ChunksExact<'a, T> {
2006    const MAY_HAVE_SIDE_EFFECT: bool = false;
2007}
2008
2009#[derive(Debug)]
2029#[stable(feature = "chunks_exact", since = "1.31.0")]
2030#[must_use = "iterators are lazy and do nothing unless consumed"]
2031pub struct ChunksExactMut<'a, T: 'a> {
2032    v: *mut [T],
2039    rem: &'a mut [T], chunk_size: usize,
2041    _marker: PhantomData<&'a mut T>,
2042}
2043
2044impl<'a, T> ChunksExactMut<'a, T> {
2045    #[inline]
2046    pub(super) fn new(slice: &'a mut [T], chunk_size: usize) -> Self {
2047        let rem = slice.len() % chunk_size;
2048        let fst_len = slice.len() - rem;
2049        let (fst, snd) = unsafe { slice.split_at_mut_unchecked(fst_len) };
2051        Self { v: fst, rem: snd, chunk_size, _marker: PhantomData }
2052    }
2053
2054    #[must_use = "`self` will be dropped if the result is not used"]
2058    #[stable(feature = "chunks_exact", since = "1.31.0")]
2059    pub fn into_remainder(self) -> &'a mut [T] {
2060        self.rem
2061    }
2062}
2063
2064#[stable(feature = "chunks_exact", since = "1.31.0")]
2065impl<'a, T> Iterator for ChunksExactMut<'a, T> {
2066    type Item = &'a mut [T];
2067
2068    #[inline]
2069    fn next(&mut self) -> Option<&'a mut [T]> {
2070        if self.v.len() < self.chunk_size {
2071            None
2072        } else {
2073            let (head, tail) = unsafe { self.v.split_at_mut(self.chunk_size) };
2075            self.v = tail;
2076            Some(unsafe { &mut *head })
2078        }
2079    }
2080
2081    #[inline]
2082    fn size_hint(&self) -> (usize, Option<usize>) {
2083        let n = self.v.len() / self.chunk_size;
2084        (n, Some(n))
2085    }
2086
2087    #[inline]
2088    fn count(self) -> usize {
2089        self.len()
2090    }
2091
2092    #[inline]
2093    fn nth(&mut self, n: usize) -> Option<&'a mut [T]> {
2094        let (start, overflow) = n.overflowing_mul(self.chunk_size);
2095        if start >= self.v.len() || overflow {
2096            self.v = &mut [];
2097            None
2098        } else {
2099            let (_, snd) = unsafe { self.v.split_at_mut(start) };
2101            self.v = snd;
2102            self.next()
2103        }
2104    }
2105
2106    #[inline]
2107    fn last(mut self) -> Option<Self::Item> {
2108        self.next_back()
2109    }
2110
2111    unsafe fn __iterator_get_unchecked(&mut self, idx: usize) -> Self::Item {
2112        let start = idx * self.chunk_size;
2113        unsafe { from_raw_parts_mut(self.v.as_mut_ptr().add(start), self.chunk_size) }
2115    }
2116}
2117
2118#[stable(feature = "chunks_exact", since = "1.31.0")]
2119impl<'a, T> DoubleEndedIterator for ChunksExactMut<'a, T> {
2120    #[inline]
2121    fn next_back(&mut self) -> Option<&'a mut [T]> {
2122        if self.v.len() < self.chunk_size {
2123            None
2124        } else {
2125            let (head, tail) = unsafe { self.v.split_at_mut(self.v.len() - self.chunk_size) };
2127            self.v = head;
2128            Some(unsafe { &mut *tail })
2130        }
2131    }
2132
2133    #[inline]
2134    fn nth_back(&mut self, n: usize) -> Option<Self::Item> {
2135        let len = self.len();
2136        if n >= len {
2137            self.v = &mut [];
2138            None
2139        } else {
2140            let start = (len - 1 - n) * self.chunk_size;
2141            let end = start + self.chunk_size;
2142            let (temp, _tail) = unsafe { mem::replace(&mut self.v, &mut []).split_at_mut(end) };
2144            let (head, nth_back) = unsafe { temp.split_at_mut(start) };
2146            self.v = head;
2147            Some(unsafe { &mut *nth_back })
2149        }
2150    }
2151}
2152
2153#[stable(feature = "chunks_exact", since = "1.31.0")]
2154impl<T> ExactSizeIterator for ChunksExactMut<'_, T> {
2155    fn is_empty(&self) -> bool {
2156        self.v.is_empty()
2157    }
2158}
2159
2160#[unstable(feature = "trusted_len", issue = "37572")]
2161unsafe impl<T> TrustedLen for ChunksExactMut<'_, T> {}
2162
2163#[stable(feature = "chunks_exact", since = "1.31.0")]
2164impl<T> FusedIterator for ChunksExactMut<'_, T> {}
2165
2166#[doc(hidden)]
2167#[unstable(feature = "trusted_random_access", issue = "none")]
2168unsafe impl<'a, T> TrustedRandomAccess for ChunksExactMut<'a, T> {}
2169
2170#[doc(hidden)]
2171#[unstable(feature = "trusted_random_access", issue = "none")]
2172unsafe impl<'a, T> TrustedRandomAccessNoCoerce for ChunksExactMut<'a, T> {
2173    const MAY_HAVE_SIDE_EFFECT: bool = false;
2174}
2175
2176#[stable(feature = "chunks_exact", since = "1.31.0")]
2177unsafe impl<T> Send for ChunksExactMut<'_, T> where T: Send {}
2178
2179#[stable(feature = "chunks_exact", since = "1.31.0")]
2180unsafe impl<T> Sync for ChunksExactMut<'_, T> where T: Sync {}
2181
2182#[derive(Debug, Clone, Copy)]
2203#[unstable(feature = "array_windows", issue = "75027")]
2204#[must_use = "iterators are lazy and do nothing unless consumed"]
2205pub struct ArrayWindows<'a, T: 'a, const N: usize> {
2206    slice_head: *const T,
2207    num: usize,
2208    marker: PhantomData<&'a [T; N]>,
2209}
2210
2211impl<'a, T: 'a, const N: usize> ArrayWindows<'a, T, N> {
2212    #[inline]
2213    pub(super) fn new(slice: &'a [T]) -> Self {
2214        let num_windows = slice.len().saturating_sub(N - 1);
2215        Self { slice_head: slice.as_ptr(), num: num_windows, marker: PhantomData }
2216    }
2217}
2218
2219#[unstable(feature = "array_windows", issue = "75027")]
2220impl<'a, T, const N: usize> Iterator for ArrayWindows<'a, T, N> {
2221    type Item = &'a [T; N];
2222
2223    #[inline]
2224    fn next(&mut self) -> Option<Self::Item> {
2225        if self.num == 0 {
2226            return None;
2227        }
2228        let ret = unsafe { &*self.slice_head.cast::<[T; N]>() };
2231        self.slice_head = unsafe { self.slice_head.add(1) };
2234
2235        self.num -= 1;
2236        Some(ret)
2237    }
2238
2239    #[inline]
2240    fn size_hint(&self) -> (usize, Option<usize>) {
2241        (self.num, Some(self.num))
2242    }
2243
2244    #[inline]
2245    fn count(self) -> usize {
2246        self.num
2247    }
2248
2249    #[inline]
2250    fn nth(&mut self, n: usize) -> Option<Self::Item> {
2251        if self.num <= n {
2252            self.num = 0;
2253            return None;
2254        }
2255        let ret = unsafe { &*self.slice_head.add(n).cast::<[T; N]>() };
2258        self.slice_head = unsafe { self.slice_head.add(n + 1) };
2260
2261        self.num -= n + 1;
2262        Some(ret)
2263    }
2264
2265    #[inline]
2266    fn last(mut self) -> Option<Self::Item> {
2267        self.nth(self.num.checked_sub(1)?)
2268    }
2269}
2270
2271#[unstable(feature = "array_windows", issue = "75027")]
2272impl<'a, T, const N: usize> DoubleEndedIterator for ArrayWindows<'a, T, N> {
2273    #[inline]
2274    fn next_back(&mut self) -> Option<&'a [T; N]> {
2275        if self.num == 0 {
2276            return None;
2277        }
2278        let ret = unsafe { &*self.slice_head.add(self.num - 1).cast::<[T; N]>() };
2280        self.num -= 1;
2281        Some(ret)
2282    }
2283
2284    #[inline]
2285    fn nth_back(&mut self, n: usize) -> Option<&'a [T; N]> {
2286        if self.num <= n {
2287            self.num = 0;
2288            return None;
2289        }
2290        let ret = unsafe { &*self.slice_head.add(self.num - (n + 1)).cast::<[T; N]>() };
2292        self.num -= n + 1;
2293        Some(ret)
2294    }
2295}
2296
2297#[unstable(feature = "array_windows", issue = "75027")]
2298impl<T, const N: usize> ExactSizeIterator for ArrayWindows<'_, T, N> {
2299    fn is_empty(&self) -> bool {
2300        self.num == 0
2301    }
2302}
2303
2304#[derive(Debug)]
2329#[unstable(feature = "array_chunks", issue = "74985")]
2330#[must_use = "iterators are lazy and do nothing unless consumed"]
2331pub struct ArrayChunks<'a, T: 'a, const N: usize> {
2332    iter: Iter<'a, [T; N]>,
2333    rem: &'a [T],
2334}
2335
2336impl<'a, T, const N: usize> ArrayChunks<'a, T, N> {
2337    #[inline]
2338    pub(super) fn new(slice: &'a [T]) -> Self {
2339        let (array_slice, rem) = slice.as_chunks();
2340        Self { iter: array_slice.iter(), rem }
2341    }
2342
2343    #[must_use]
2347    #[unstable(feature = "array_chunks", issue = "74985")]
2348    pub fn remainder(&self) -> &'a [T] {
2349        self.rem
2350    }
2351}
2352
2353#[unstable(feature = "array_chunks", issue = "74985")]
2355impl<T, const N: usize> Clone for ArrayChunks<'_, T, N> {
2356    fn clone(&self) -> Self {
2357        ArrayChunks { iter: self.iter.clone(), rem: self.rem }
2358    }
2359}
2360
2361#[unstable(feature = "array_chunks", issue = "74985")]
2362impl<'a, T, const N: usize> Iterator for ArrayChunks<'a, T, N> {
2363    type Item = &'a [T; N];
2364
2365    #[inline]
2366    fn next(&mut self) -> Option<&'a [T; N]> {
2367        self.iter.next()
2368    }
2369
2370    #[inline]
2371    fn size_hint(&self) -> (usize, Option<usize>) {
2372        self.iter.size_hint()
2373    }
2374
2375    #[inline]
2376    fn count(self) -> usize {
2377        self.iter.count()
2378    }
2379
2380    #[inline]
2381    fn nth(&mut self, n: usize) -> Option<Self::Item> {
2382        self.iter.nth(n)
2383    }
2384
2385    #[inline]
2386    fn last(self) -> Option<Self::Item> {
2387        self.iter.last()
2388    }
2389
2390    unsafe fn __iterator_get_unchecked(&mut self, i: usize) -> &'a [T; N] {
2391        unsafe { self.iter.__iterator_get_unchecked(i) }
2394    }
2395}
2396
2397#[unstable(feature = "array_chunks", issue = "74985")]
2398impl<'a, T, const N: usize> DoubleEndedIterator for ArrayChunks<'a, T, N> {
2399    #[inline]
2400    fn next_back(&mut self) -> Option<&'a [T; N]> {
2401        self.iter.next_back()
2402    }
2403
2404    #[inline]
2405    fn nth_back(&mut self, n: usize) -> Option<Self::Item> {
2406        self.iter.nth_back(n)
2407    }
2408}
2409
2410#[unstable(feature = "array_chunks", issue = "74985")]
2411impl<T, const N: usize> ExactSizeIterator for ArrayChunks<'_, T, N> {
2412    fn is_empty(&self) -> bool {
2413        self.iter.is_empty()
2414    }
2415}
2416
2417#[unstable(feature = "trusted_len", issue = "37572")]
2418unsafe impl<T, const N: usize> TrustedLen for ArrayChunks<'_, T, N> {}
2419
2420#[unstable(feature = "array_chunks", issue = "74985")]
2421impl<T, const N: usize> FusedIterator for ArrayChunks<'_, T, N> {}
2422
2423#[doc(hidden)]
2424#[unstable(feature = "array_chunks", issue = "74985")]
2425unsafe impl<'a, T, const N: usize> TrustedRandomAccess for ArrayChunks<'a, T, N> {}
2426
2427#[doc(hidden)]
2428#[unstable(feature = "array_chunks", issue = "74985")]
2429unsafe impl<'a, T, const N: usize> TrustedRandomAccessNoCoerce for ArrayChunks<'a, T, N> {
2430    const MAY_HAVE_SIDE_EFFECT: bool = false;
2431}
2432
2433#[derive(Debug)]
2455#[unstable(feature = "array_chunks", issue = "74985")]
2456#[must_use = "iterators are lazy and do nothing unless consumed"]
2457pub struct ArrayChunksMut<'a, T: 'a, const N: usize> {
2458    iter: IterMut<'a, [T; N]>,
2459    rem: &'a mut [T],
2460}
2461
2462impl<'a, T, const N: usize> ArrayChunksMut<'a, T, N> {
2463    #[inline]
2464    pub(super) fn new(slice: &'a mut [T]) -> Self {
2465        let (array_slice, rem) = slice.as_chunks_mut();
2466        Self { iter: array_slice.iter_mut(), rem }
2467    }
2468
2469    #[must_use = "`self` will be dropped if the result is not used"]
2473    #[unstable(feature = "array_chunks", issue = "74985")]
2474    pub fn into_remainder(self) -> &'a mut [T] {
2475        self.rem
2476    }
2477}
2478
2479#[unstable(feature = "array_chunks", issue = "74985")]
2480impl<'a, T, const N: usize> Iterator for ArrayChunksMut<'a, T, N> {
2481    type Item = &'a mut [T; N];
2482
2483    #[inline]
2484    fn next(&mut self) -> Option<&'a mut [T; N]> {
2485        self.iter.next()
2486    }
2487
2488    #[inline]
2489    fn size_hint(&self) -> (usize, Option<usize>) {
2490        self.iter.size_hint()
2491    }
2492
2493    #[inline]
2494    fn count(self) -> usize {
2495        self.iter.count()
2496    }
2497
2498    #[inline]
2499    fn nth(&mut self, n: usize) -> Option<Self::Item> {
2500        self.iter.nth(n)
2501    }
2502
2503    #[inline]
2504    fn last(self) -> Option<Self::Item> {
2505        self.iter.last()
2506    }
2507
2508    unsafe fn __iterator_get_unchecked(&mut self, i: usize) -> &'a mut [T; N] {
2509        unsafe { self.iter.__iterator_get_unchecked(i) }
2512    }
2513}
2514
2515#[unstable(feature = "array_chunks", issue = "74985")]
2516impl<'a, T, const N: usize> DoubleEndedIterator for ArrayChunksMut<'a, T, N> {
2517    #[inline]
2518    fn next_back(&mut self) -> Option<&'a mut [T; N]> {
2519        self.iter.next_back()
2520    }
2521
2522    #[inline]
2523    fn nth_back(&mut self, n: usize) -> Option<Self::Item> {
2524        self.iter.nth_back(n)
2525    }
2526}
2527
2528#[unstable(feature = "array_chunks", issue = "74985")]
2529impl<T, const N: usize> ExactSizeIterator for ArrayChunksMut<'_, T, N> {
2530    fn is_empty(&self) -> bool {
2531        self.iter.is_empty()
2532    }
2533}
2534
2535#[unstable(feature = "trusted_len", issue = "37572")]
2536unsafe impl<T, const N: usize> TrustedLen for ArrayChunksMut<'_, T, N> {}
2537
2538#[unstable(feature = "array_chunks", issue = "74985")]
2539impl<T, const N: usize> FusedIterator for ArrayChunksMut<'_, T, N> {}
2540
2541#[doc(hidden)]
2542#[unstable(feature = "array_chunks", issue = "74985")]
2543unsafe impl<'a, T, const N: usize> TrustedRandomAccess for ArrayChunksMut<'a, T, N> {}
2544
2545#[doc(hidden)]
2546#[unstable(feature = "array_chunks", issue = "74985")]
2547unsafe impl<'a, T, const N: usize> TrustedRandomAccessNoCoerce for ArrayChunksMut<'a, T, N> {
2548    const MAY_HAVE_SIDE_EFFECT: bool = false;
2549}
2550
2551#[derive(Debug)]
2573#[stable(feature = "rchunks", since = "1.31.0")]
2574#[must_use = "iterators are lazy and do nothing unless consumed"]
2575pub struct RChunks<'a, T: 'a> {
2576    v: &'a [T],
2577    chunk_size: usize,
2578}
2579
2580impl<'a, T: 'a> RChunks<'a, T> {
2581    #[inline]
2582    pub(super) fn new(slice: &'a [T], size: usize) -> Self {
2583        Self { v: slice, chunk_size: size }
2584    }
2585}
2586
2587#[stable(feature = "rchunks", since = "1.31.0")]
2589impl<T> Clone for RChunks<'_, T> {
2590    fn clone(&self) -> Self {
2591        RChunks { v: self.v, chunk_size: self.chunk_size }
2592    }
2593}
2594
2595#[stable(feature = "rchunks", since = "1.31.0")]
2596impl<'a, T> Iterator for RChunks<'a, T> {
2597    type Item = &'a [T];
2598
2599    #[inline]
2600    fn next(&mut self) -> Option<&'a [T]> {
2601        if self.v.is_empty() {
2602            None
2603        } else {
2604            let len = self.v.len();
2605            let chunksz = cmp::min(len, self.chunk_size);
2606            let (fst, snd) = unsafe { self.v.split_at_unchecked(len - chunksz) };
2612            self.v = fst;
2613            Some(snd)
2614        }
2615    }
2616
2617    #[inline]
2618    fn size_hint(&self) -> (usize, Option<usize>) {
2619        if self.v.is_empty() {
2620            (0, Some(0))
2621        } else {
2622            let n = self.v.len() / self.chunk_size;
2623            let rem = self.v.len() % self.chunk_size;
2624            let n = if rem > 0 { n + 1 } else { n };
2625            (n, Some(n))
2626        }
2627    }
2628
2629    #[inline]
2630    fn count(self) -> usize {
2631        self.len()
2632    }
2633
2634    #[inline]
2635    fn nth(&mut self, n: usize) -> Option<Self::Item> {
2636        let (end, overflow) = n.overflowing_mul(self.chunk_size);
2637        if end >= self.v.len() || overflow {
2638            self.v = &[];
2639            None
2640        } else {
2641            let end = self.v.len() - end;
2643            let start = match end.checked_sub(self.chunk_size) {
2644                Some(sum) => sum,
2645                None => 0,
2646            };
2647            let nth = &self.v[start..end];
2648            self.v = &self.v[0..start];
2649            Some(nth)
2650        }
2651    }
2652
2653    #[inline]
2654    fn last(self) -> Option<Self::Item> {
2655        if self.v.is_empty() {
2656            None
2657        } else {
2658            let rem = self.v.len() % self.chunk_size;
2659            let end = if rem == 0 { self.chunk_size } else { rem };
2660            Some(&self.v[0..end])
2661        }
2662    }
2663
2664    unsafe fn __iterator_get_unchecked(&mut self, idx: usize) -> Self::Item {
2665        let end = self.v.len() - idx * self.chunk_size;
2666        let start = match end.checked_sub(self.chunk_size) {
2667            None => 0,
2668            Some(start) => start,
2669        };
2670        unsafe { from_raw_parts(self.v.as_ptr().add(start), end - start) }
2672    }
2673}
2674
2675#[stable(feature = "rchunks", since = "1.31.0")]
2676impl<'a, T> DoubleEndedIterator for RChunks<'a, T> {
2677    #[inline]
2678    fn next_back(&mut self) -> Option<&'a [T]> {
2679        if self.v.is_empty() {
2680            None
2681        } else {
2682            let remainder = self.v.len() % self.chunk_size;
2683            let chunksz = if remainder != 0 { remainder } else { self.chunk_size };
2684            let (fst, snd) = unsafe { self.v.split_at_unchecked(chunksz) };
2686            self.v = snd;
2687            Some(fst)
2688        }
2689    }
2690
2691    #[inline]
2692    fn nth_back(&mut self, n: usize) -> Option<Self::Item> {
2693        let len = self.len();
2694        if n >= len {
2695            self.v = &[];
2696            None
2697        } else {
2698            let offset_from_end = (len - 1 - n) * self.chunk_size;
2700            let end = self.v.len() - offset_from_end;
2701            let start = end.saturating_sub(self.chunk_size);
2702            let nth_back = &self.v[start..end];
2703            self.v = &self.v[end..];
2704            Some(nth_back)
2705        }
2706    }
2707}
2708
2709#[stable(feature = "rchunks", since = "1.31.0")]
2710impl<T> ExactSizeIterator for RChunks<'_, T> {}
2711
2712#[unstable(feature = "trusted_len", issue = "37572")]
2713unsafe impl<T> TrustedLen for RChunks<'_, T> {}
2714
2715#[stable(feature = "rchunks", since = "1.31.0")]
2716impl<T> FusedIterator for RChunks<'_, T> {}
2717
2718#[doc(hidden)]
2719#[unstable(feature = "trusted_random_access", issue = "none")]
2720unsafe impl<'a, T> TrustedRandomAccess for RChunks<'a, T> {}
2721
2722#[doc(hidden)]
2723#[unstable(feature = "trusted_random_access", issue = "none")]
2724unsafe impl<'a, T> TrustedRandomAccessNoCoerce for RChunks<'a, T> {
2725    const MAY_HAVE_SIDE_EFFECT: bool = false;
2726}
2727
2728#[derive(Debug)]
2746#[stable(feature = "rchunks", since = "1.31.0")]
2747#[must_use = "iterators are lazy and do nothing unless consumed"]
2748pub struct RChunksMut<'a, T: 'a> {
2749    v: *mut [T],
2756    chunk_size: usize,
2757    _marker: PhantomData<&'a mut T>,
2758}
2759
2760impl<'a, T: 'a> RChunksMut<'a, T> {
2761    #[inline]
2762    pub(super) fn new(slice: &'a mut [T], size: usize) -> Self {
2763        Self { v: slice, chunk_size: size, _marker: PhantomData }
2764    }
2765}
2766
2767#[stable(feature = "rchunks", since = "1.31.0")]
2768impl<'a, T> Iterator for RChunksMut<'a, T> {
2769    type Item = &'a mut [T];
2770
2771    #[inline]
2772    fn next(&mut self) -> Option<&'a mut [T]> {
2773        if self.v.is_empty() {
2774            None
2775        } else {
2776            let sz = cmp::min(self.v.len(), self.chunk_size);
2777            let len = self.v.len();
2778            let (head, tail) = unsafe { self.v.split_at_mut_unchecked(len - sz) };
2784            self.v = head;
2785            Some(unsafe { &mut *tail })
2787        }
2788    }
2789
2790    #[inline]
2791    fn size_hint(&self) -> (usize, Option<usize>) {
2792        if self.v.is_empty() {
2793            (0, Some(0))
2794        } else {
2795            let n = self.v.len() / self.chunk_size;
2796            let rem = self.v.len() % self.chunk_size;
2797            let n = if rem > 0 { n + 1 } else { n };
2798            (n, Some(n))
2799        }
2800    }
2801
2802    #[inline]
2803    fn count(self) -> usize {
2804        self.len()
2805    }
2806
2807    #[inline]
2808    fn nth(&mut self, n: usize) -> Option<&'a mut [T]> {
2809        let (end, overflow) = n.overflowing_mul(self.chunk_size);
2810        if end >= self.v.len() || overflow {
2811            self.v = &mut [];
2812            None
2813        } else {
2814            let end = self.v.len() - end;
2816            let start = match end.checked_sub(self.chunk_size) {
2817                Some(sum) => sum,
2818                None => 0,
2819            };
2820            let (head, tail) = unsafe { self.v.split_at_mut(start) };
2823            let (nth, _) = unsafe { tail.split_at_mut(end - start) };
2826            self.v = head;
2827            Some(unsafe { &mut *nth })
2829        }
2830    }
2831
2832    #[inline]
2833    fn last(self) -> Option<Self::Item> {
2834        if self.v.is_empty() {
2835            None
2836        } else {
2837            let rem = self.v.len() % self.chunk_size;
2838            let end = if rem == 0 { self.chunk_size } else { rem };
2839            Some(unsafe { &mut *self.v.get_unchecked_mut(0..end) })
2841        }
2842    }
2843
2844    unsafe fn __iterator_get_unchecked(&mut self, idx: usize) -> Self::Item {
2845        let end = self.v.len() - idx * self.chunk_size;
2846        let start = match end.checked_sub(self.chunk_size) {
2847            None => 0,
2848            Some(start) => start,
2849        };
2850        unsafe { from_raw_parts_mut(self.v.as_mut_ptr().add(start), end - start) }
2853    }
2854}
2855
2856#[stable(feature = "rchunks", since = "1.31.0")]
2857impl<'a, T> DoubleEndedIterator for RChunksMut<'a, T> {
2858    #[inline]
2859    fn next_back(&mut self) -> Option<&'a mut [T]> {
2860        if self.v.is_empty() {
2861            None
2862        } else {
2863            let remainder = self.v.len() % self.chunk_size;
2864            let sz = if remainder != 0 { remainder } else { self.chunk_size };
2865            let (head, tail) = unsafe { self.v.split_at_mut_unchecked(sz) };
2867            self.v = tail;
2868            Some(unsafe { &mut *head })
2870        }
2871    }
2872
2873    #[inline]
2874    fn nth_back(&mut self, n: usize) -> Option<Self::Item> {
2875        let len = self.len();
2876        if n >= len {
2877            self.v = &mut [];
2878            None
2879        } else {
2880            let offset_from_end = (len - 1 - n) * self.chunk_size;
2882            let end = self.v.len() - offset_from_end;
2883            let start = end.saturating_sub(self.chunk_size);
2884            let (tmp, tail) = unsafe { self.v.split_at_mut(end) };
2886            let (_, nth_back) = unsafe { tmp.split_at_mut(start) };
2888            self.v = tail;
2889            Some(unsafe { &mut *nth_back })
2891        }
2892    }
2893}
2894
2895#[stable(feature = "rchunks", since = "1.31.0")]
2896impl<T> ExactSizeIterator for RChunksMut<'_, T> {}
2897
2898#[unstable(feature = "trusted_len", issue = "37572")]
2899unsafe impl<T> TrustedLen for RChunksMut<'_, T> {}
2900
2901#[stable(feature = "rchunks", since = "1.31.0")]
2902impl<T> FusedIterator for RChunksMut<'_, T> {}
2903
2904#[doc(hidden)]
2905#[unstable(feature = "trusted_random_access", issue = "none")]
2906unsafe impl<'a, T> TrustedRandomAccess for RChunksMut<'a, T> {}
2907
2908#[doc(hidden)]
2909#[unstable(feature = "trusted_random_access", issue = "none")]
2910unsafe impl<'a, T> TrustedRandomAccessNoCoerce for RChunksMut<'a, T> {
2911    const MAY_HAVE_SIDE_EFFECT: bool = false;
2912}
2913
2914#[stable(feature = "rchunks", since = "1.31.0")]
2915unsafe impl<T> Send for RChunksMut<'_, T> where T: Send {}
2916
2917#[stable(feature = "rchunks", since = "1.31.0")]
2918unsafe impl<T> Sync for RChunksMut<'_, T> where T: Sync {}
2919
2920#[derive(Debug)]
2943#[stable(feature = "rchunks", since = "1.31.0")]
2944#[must_use = "iterators are lazy and do nothing unless consumed"]
2945pub struct RChunksExact<'a, T: 'a> {
2946    v: &'a [T],
2947    rem: &'a [T],
2948    chunk_size: usize,
2949}
2950
2951impl<'a, T> RChunksExact<'a, T> {
2952    #[inline]
2953    pub(super) fn new(slice: &'a [T], chunk_size: usize) -> Self {
2954        let rem = slice.len() % chunk_size;
2955        let (fst, snd) = unsafe { slice.split_at_unchecked(rem) };
2957        Self { v: snd, rem: fst, chunk_size }
2958    }
2959
2960    #[must_use]
2978    #[stable(feature = "rchunks", since = "1.31.0")]
2979    pub fn remainder(&self) -> &'a [T] {
2980        self.rem
2981    }
2982}
2983
2984#[stable(feature = "rchunks", since = "1.31.0")]
2986impl<'a, T> Clone for RChunksExact<'a, T> {
2987    fn clone(&self) -> RChunksExact<'a, T> {
2988        RChunksExact { v: self.v, rem: self.rem, chunk_size: self.chunk_size }
2989    }
2990}
2991
2992#[stable(feature = "rchunks", since = "1.31.0")]
2993impl<'a, T> Iterator for RChunksExact<'a, T> {
2994    type Item = &'a [T];
2995
2996    #[inline]
2997    fn next(&mut self) -> Option<&'a [T]> {
2998        if self.v.len() < self.chunk_size {
2999            None
3000        } else {
3001            let (fst, snd) = self.v.split_at(self.v.len() - self.chunk_size);
3002            self.v = fst;
3003            Some(snd)
3004        }
3005    }
3006
3007    #[inline]
3008    fn size_hint(&self) -> (usize, Option<usize>) {
3009        let n = self.v.len() / self.chunk_size;
3010        (n, Some(n))
3011    }
3012
3013    #[inline]
3014    fn count(self) -> usize {
3015        self.len()
3016    }
3017
3018    #[inline]
3019    fn nth(&mut self, n: usize) -> Option<Self::Item> {
3020        let (end, overflow) = n.overflowing_mul(self.chunk_size);
3021        if end >= self.v.len() || overflow {
3022            self.v = &[];
3023            None
3024        } else {
3025            let (fst, _) = self.v.split_at(self.v.len() - end);
3026            self.v = fst;
3027            self.next()
3028        }
3029    }
3030
3031    #[inline]
3032    fn last(mut self) -> Option<Self::Item> {
3033        self.next_back()
3034    }
3035
3036    unsafe fn __iterator_get_unchecked(&mut self, idx: usize) -> Self::Item {
3037        let end = self.v.len() - idx * self.chunk_size;
3038        let start = end - self.chunk_size;
3039        unsafe { from_raw_parts(self.v.as_ptr().add(start), self.chunk_size) }
3041    }
3042}
3043
3044#[stable(feature = "rchunks", since = "1.31.0")]
3045impl<'a, T> DoubleEndedIterator for RChunksExact<'a, T> {
3046    #[inline]
3047    fn next_back(&mut self) -> Option<&'a [T]> {
3048        if self.v.len() < self.chunk_size {
3049            None
3050        } else {
3051            let (fst, snd) = self.v.split_at(self.chunk_size);
3052            self.v = snd;
3053            Some(fst)
3054        }
3055    }
3056
3057    #[inline]
3058    fn nth_back(&mut self, n: usize) -> Option<Self::Item> {
3059        let len = self.len();
3060        if n >= len {
3061            self.v = &[];
3062            None
3063        } else {
3064            let offset = (len - n) * self.chunk_size;
3067            let start = self.v.len() - offset;
3068            let end = start + self.chunk_size;
3069            let nth_back = &self.v[start..end];
3070            self.v = &self.v[end..];
3071            Some(nth_back)
3072        }
3073    }
3074}
3075
3076#[stable(feature = "rchunks", since = "1.31.0")]
3077impl<'a, T> ExactSizeIterator for RChunksExact<'a, T> {
3078    fn is_empty(&self) -> bool {
3079        self.v.is_empty()
3080    }
3081}
3082
3083#[unstable(feature = "trusted_len", issue = "37572")]
3084unsafe impl<T> TrustedLen for RChunksExact<'_, T> {}
3085
3086#[stable(feature = "rchunks", since = "1.31.0")]
3087impl<T> FusedIterator for RChunksExact<'_, T> {}
3088
3089#[doc(hidden)]
3090#[unstable(feature = "trusted_random_access", issue = "none")]
3091unsafe impl<'a, T> TrustedRandomAccess for RChunksExact<'a, T> {}
3092
3093#[doc(hidden)]
3094#[unstable(feature = "trusted_random_access", issue = "none")]
3095unsafe impl<'a, T> TrustedRandomAccessNoCoerce for RChunksExact<'a, T> {
3096    const MAY_HAVE_SIDE_EFFECT: bool = false;
3097}
3098
3099#[derive(Debug)]
3119#[stable(feature = "rchunks", since = "1.31.0")]
3120#[must_use = "iterators are lazy and do nothing unless consumed"]
3121pub struct RChunksExactMut<'a, T: 'a> {
3122    v: *mut [T],
3129    rem: &'a mut [T],
3130    chunk_size: usize,
3131}
3132
3133impl<'a, T> RChunksExactMut<'a, T> {
3134    #[inline]
3135    pub(super) fn new(slice: &'a mut [T], chunk_size: usize) -> Self {
3136        let rem = slice.len() % chunk_size;
3137        let (fst, snd) = unsafe { slice.split_at_mut_unchecked(rem) };
3139        Self { v: snd, rem: fst, chunk_size }
3140    }
3141
3142    #[must_use = "`self` will be dropped if the result is not used"]
3146    #[stable(feature = "rchunks", since = "1.31.0")]
3147    pub fn into_remainder(self) -> &'a mut [T] {
3148        self.rem
3149    }
3150}
3151
3152#[stable(feature = "rchunks", since = "1.31.0")]
3153impl<'a, T> Iterator for RChunksExactMut<'a, T> {
3154    type Item = &'a mut [T];
3155
3156    #[inline]
3157    fn next(&mut self) -> Option<&'a mut [T]> {
3158        if self.v.len() < self.chunk_size {
3159            None
3160        } else {
3161            let len = self.v.len();
3162            let (head, tail) = unsafe { self.v.split_at_mut(len - self.chunk_size) };
3164            self.v = head;
3165            Some(unsafe { &mut *tail })
3167        }
3168    }
3169
3170    #[inline]
3171    fn size_hint(&self) -> (usize, Option<usize>) {
3172        let n = self.v.len() / self.chunk_size;
3173        (n, Some(n))
3174    }
3175
3176    #[inline]
3177    fn count(self) -> usize {
3178        self.len()
3179    }
3180
3181    #[inline]
3182    fn nth(&mut self, n: usize) -> Option<&'a mut [T]> {
3183        let (end, overflow) = n.overflowing_mul(self.chunk_size);
3184        if end >= self.v.len() || overflow {
3185            self.v = &mut [];
3186            None
3187        } else {
3188            let len = self.v.len();
3189            let (fst, _) = unsafe { self.v.split_at_mut(len - end) };
3191            self.v = fst;
3192            self.next()
3193        }
3194    }
3195
3196    #[inline]
3197    fn last(mut self) -> Option<Self::Item> {
3198        self.next_back()
3199    }
3200
3201    unsafe fn __iterator_get_unchecked(&mut self, idx: usize) -> Self::Item {
3202        let end = self.v.len() - idx * self.chunk_size;
3203        let start = end - self.chunk_size;
3204        unsafe { from_raw_parts_mut(self.v.as_mut_ptr().add(start), self.chunk_size) }
3206    }
3207}
3208
3209#[stable(feature = "rchunks", since = "1.31.0")]
3210impl<'a, T> DoubleEndedIterator for RChunksExactMut<'a, T> {
3211    #[inline]
3212    fn next_back(&mut self) -> Option<&'a mut [T]> {
3213        if self.v.len() < self.chunk_size {
3214            None
3215        } else {
3216            let (head, tail) = unsafe { self.v.split_at_mut(self.chunk_size) };
3218            self.v = tail;
3219            Some(unsafe { &mut *head })
3221        }
3222    }
3223
3224    #[inline]
3225    fn nth_back(&mut self, n: usize) -> Option<Self::Item> {
3226        let len = self.len();
3227        if n >= len {
3228            self.v = &mut [];
3229            None
3230        } else {
3231            let offset = (len - n) * self.chunk_size;
3234            let start = self.v.len() - offset;
3235            let end = start + self.chunk_size;
3236            let (tmp, tail) = unsafe { self.v.split_at_mut(end) };
3238            let (_, nth_back) = unsafe { tmp.split_at_mut(start) };
3240            self.v = tail;
3241            Some(unsafe { &mut *nth_back })
3243        }
3244    }
3245}
3246
3247#[stable(feature = "rchunks", since = "1.31.0")]
3248impl<T> ExactSizeIterator for RChunksExactMut<'_, T> {
3249    fn is_empty(&self) -> bool {
3250        self.v.is_empty()
3251    }
3252}
3253
3254#[unstable(feature = "trusted_len", issue = "37572")]
3255unsafe impl<T> TrustedLen for RChunksExactMut<'_, T> {}
3256
3257#[stable(feature = "rchunks", since = "1.31.0")]
3258impl<T> FusedIterator for RChunksExactMut<'_, T> {}
3259
3260#[doc(hidden)]
3261#[unstable(feature = "trusted_random_access", issue = "none")]
3262unsafe impl<'a, T> TrustedRandomAccess for RChunksExactMut<'a, T> {}
3263
3264#[doc(hidden)]
3265#[unstable(feature = "trusted_random_access", issue = "none")]
3266unsafe impl<'a, T> TrustedRandomAccessNoCoerce for RChunksExactMut<'a, T> {
3267    const MAY_HAVE_SIDE_EFFECT: bool = false;
3268}
3269
3270#[stable(feature = "rchunks", since = "1.31.0")]
3271unsafe impl<T> Send for RChunksExactMut<'_, T> where T: Send {}
3272
3273#[stable(feature = "rchunks", since = "1.31.0")]
3274unsafe impl<T> Sync for RChunksExactMut<'_, T> where T: Sync {}
3275
3276#[doc(hidden)]
3277#[unstable(feature = "trusted_random_access", issue = "none")]
3278unsafe impl<'a, T> TrustedRandomAccess for Iter<'a, T> {}
3279
3280#[doc(hidden)]
3281#[unstable(feature = "trusted_random_access", issue = "none")]
3282unsafe impl<'a, T> TrustedRandomAccessNoCoerce for Iter<'a, T> {
3283    const MAY_HAVE_SIDE_EFFECT: bool = false;
3284}
3285
3286#[doc(hidden)]
3287#[unstable(feature = "trusted_random_access", issue = "none")]
3288unsafe impl<'a, T> TrustedRandomAccess for IterMut<'a, T> {}
3289
3290#[doc(hidden)]
3291#[unstable(feature = "trusted_random_access", issue = "none")]
3292unsafe impl<'a, T> TrustedRandomAccessNoCoerce for IterMut<'a, T> {
3293    const MAY_HAVE_SIDE_EFFECT: bool = false;
3294}
3295
3296#[stable(feature = "slice_group_by", since = "1.77.0")]
3303#[must_use = "iterators are lazy and do nothing unless consumed"]
3304pub struct ChunkBy<'a, T: 'a, P> {
3305    slice: &'a [T],
3306    predicate: P,
3307}
3308
3309#[stable(feature = "slice_group_by", since = "1.77.0")]
3310impl<'a, T: 'a, P> ChunkBy<'a, T, P> {
3311    pub(super) fn new(slice: &'a [T], predicate: P) -> Self {
3312        ChunkBy { slice, predicate }
3313    }
3314}
3315
3316#[stable(feature = "slice_group_by", since = "1.77.0")]
3317impl<'a, T: 'a, P> Iterator for ChunkBy<'a, T, P>
3318where
3319    P: FnMut(&T, &T) -> bool,
3320{
3321    type Item = &'a [T];
3322
3323    #[inline]
3324    fn next(&mut self) -> Option<Self::Item> {
3325        if self.slice.is_empty() {
3326            None
3327        } else {
3328            let mut len = 1;
3329            let mut iter = self.slice.windows(2);
3330            while let Some([l, r]) = iter.next() {
3331                if (self.predicate)(l, r) { len += 1 } else { break }
3332            }
3333            let (head, tail) = self.slice.split_at(len);
3334            self.slice = tail;
3335            Some(head)
3336        }
3337    }
3338
3339    #[inline]
3340    fn size_hint(&self) -> (usize, Option<usize>) {
3341        if self.slice.is_empty() { (0, Some(0)) } else { (1, Some(self.slice.len())) }
3342    }
3343
3344    #[inline]
3345    fn last(mut self) -> Option<Self::Item> {
3346        self.next_back()
3347    }
3348}
3349
3350#[stable(feature = "slice_group_by", since = "1.77.0")]
3351impl<'a, T: 'a, P> DoubleEndedIterator for ChunkBy<'a, T, P>
3352where
3353    P: FnMut(&T, &T) -> bool,
3354{
3355    #[inline]
3356    fn next_back(&mut self) -> Option<Self::Item> {
3357        if self.slice.is_empty() {
3358            None
3359        } else {
3360            let mut len = 1;
3361            let mut iter = self.slice.windows(2);
3362            while let Some([l, r]) = iter.next_back() {
3363                if (self.predicate)(l, r) { len += 1 } else { break }
3364            }
3365            let (head, tail) = self.slice.split_at(self.slice.len() - len);
3366            self.slice = head;
3367            Some(tail)
3368        }
3369    }
3370}
3371
3372#[stable(feature = "slice_group_by", since = "1.77.0")]
3373impl<'a, T: 'a, P> FusedIterator for ChunkBy<'a, T, P> where P: FnMut(&T, &T) -> bool {}
3374
3375#[stable(feature = "slice_group_by", since = "1.77.0")]
3376impl<'a, T: 'a + fmt::Debug, P> fmt::Debug for ChunkBy<'a, T, P> {
3377    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3378        f.debug_struct("ChunkBy").field("slice", &self.slice).finish()
3379    }
3380}
3381
3382#[stable(feature = "slice_group_by", since = "1.77.0")]
3390#[must_use = "iterators are lazy and do nothing unless consumed"]
3391pub struct ChunkByMut<'a, T: 'a, P> {
3392    slice: &'a mut [T],
3393    predicate: P,
3394}
3395
3396#[stable(feature = "slice_group_by", since = "1.77.0")]
3397impl<'a, T: 'a, P> ChunkByMut<'a, T, P> {
3398    pub(super) fn new(slice: &'a mut [T], predicate: P) -> Self {
3399        ChunkByMut { slice, predicate }
3400    }
3401}
3402
3403#[stable(feature = "slice_group_by", since = "1.77.0")]
3404impl<'a, T: 'a, P> Iterator for ChunkByMut<'a, T, P>
3405where
3406    P: FnMut(&T, &T) -> bool,
3407{
3408    type Item = &'a mut [T];
3409
3410    #[inline]
3411    fn next(&mut self) -> Option<Self::Item> {
3412        if self.slice.is_empty() {
3413            None
3414        } else {
3415            let mut len = 1;
3416            let mut iter = self.slice.windows(2);
3417            while let Some([l, r]) = iter.next() {
3418                if (self.predicate)(l, r) { len += 1 } else { break }
3419            }
3420            let slice = mem::take(&mut self.slice);
3421            let (head, tail) = slice.split_at_mut(len);
3422            self.slice = tail;
3423            Some(head)
3424        }
3425    }
3426
3427    #[inline]
3428    fn size_hint(&self) -> (usize, Option<usize>) {
3429        if self.slice.is_empty() { (0, Some(0)) } else { (1, Some(self.slice.len())) }
3430    }
3431
3432    #[inline]
3433    fn last(mut self) -> Option<Self::Item> {
3434        self.next_back()
3435    }
3436}
3437
3438#[stable(feature = "slice_group_by", since = "1.77.0")]
3439impl<'a, T: 'a, P> DoubleEndedIterator for ChunkByMut<'a, T, P>
3440where
3441    P: FnMut(&T, &T) -> bool,
3442{
3443    #[inline]
3444    fn next_back(&mut self) -> Option<Self::Item> {
3445        if self.slice.is_empty() {
3446            None
3447        } else {
3448            let mut len = 1;
3449            let mut iter = self.slice.windows(2);
3450            while let Some([l, r]) = iter.next_back() {
3451                if (self.predicate)(l, r) { len += 1 } else { break }
3452            }
3453            let slice = mem::take(&mut self.slice);
3454            let (head, tail) = slice.split_at_mut(slice.len() - len);
3455            self.slice = head;
3456            Some(tail)
3457        }
3458    }
3459}
3460
3461#[stable(feature = "slice_group_by", since = "1.77.0")]
3462impl<'a, T: 'a, P> FusedIterator for ChunkByMut<'a, T, P> where P: FnMut(&T, &T) -> bool {}
3463
3464#[stable(feature = "slice_group_by", since = "1.77.0")]
3465impl<'a, T: 'a + fmt::Debug, P> fmt::Debug for ChunkByMut<'a, T, P> {
3466    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3467        f.debug_struct("ChunkByMut").field("slice", &self.slice).finish()
3468    }
3469}