difftreelog
refactor drop array iteration inlining
in: master
3 files changed
Cargo.tomldiffbeforeafterboth3package.repository = "https://github.com/CertainLach/jrsonnet"3package.repository = "https://github.com/CertainLach/jrsonnet"4members = ["crates/*", "bindings/jsonnet", "cmds/jrsonnet", "tests"]4members = ["crates/*", "bindings/jsonnet", "cmds/jrsonnet", "tests"]5default-members = ["cmds/jrsonnet"]5default-members = ["cmds/jrsonnet"]6resolver = "2"677[workspace.dependencies]8[workspace.dependencies]8jrsonnet-evaluator = { path = "./crates/jrsonnet-evaluator", version = "0.5.0-pre9" }9jrsonnet-evaluator = { path = "./crates/jrsonnet-evaluator", version = "0.5.0-pre9" }crates/jrsonnet-evaluator/src/arr/mod.rsdiffbeforeafterboth185 pass!(self.get_lazy(index))185 pass!(self.get_lazy(index))186 }186 }187187188 #[cfg(feature = "nightly")]189 pub fn iter(&self) -> UnknownArrayIter<'_> {190 pass_iter_call!(self.iter => UnknownArrayIter)191 }192 #[cfg(not(feature = "nightly"))]193 pub fn iter(&self) -> impl ArrayLikeIter<Result<Val>> + '_ {188 pub fn iter(&self) -> impl ArrayLikeIter<Result<Val>> + '_ {194 (0..self.len()).map(|i| self.get(i).transpose().expect("length checked"))189 (0..self.len()).map(|i| self.get(i).transpose().expect("length checked"))195 }190 }196191197 /// Iterate over elements, returning lazy values.192 /// Iterate over elements, returning lazy values.198 #[cfg(feature = "nightly")]199 pub fn iter_lazy(&self) -> UnknownArrayIterLazy<'_> {200 pass_iter_call!(self.iter_lazy => UnknownArrayIterLazy)201 }202 #[cfg(not(feature = "nightly"))]203 pub fn iter_lazy(&self) -> impl ArrayLikeIter<Thunk<Val>> + '_ {193 pub fn iter_lazy(&self) -> impl ArrayLikeIter<Thunk<Val>> + '_ {204 (0..self.len()).map(|i| self.get_lazy(i).expect("length checked"))194 (0..self.len()).map(|i| self.get_lazy(i).expect("length checked"))205 }195 }206196207 #[cfg(feature = "nightly")]208 pub fn iter_cheap(&self) -> Option<UnknownArrayIterCheap<'_>> {209 macro_rules! question {210 ($v:expr) => {211 $v?212 };213 }214 Some(pass_iter_call!(self.iter_cheap in question => UnknownArrayIterCheap))215 }216217 #[cfg(not(feature = "nightly"))]218 pub fn iter_cheap(&self) -> Option<impl ArrayLikeIter<Val> + '_> {197 pub fn iter_cheap(&self) -> Option<impl ArrayLikeIter<Val> + '_> {219 if self.is_cheap() {198 if self.is_cheap() {220 Some((0..self.len()).map(|i| self.get_cheap(i).expect("length and is_cheap checked")))199 Some((0..self.len()).map(|i| self.get_cheap(i).expect("length and is_cheap checked")))crates/jrsonnet-evaluator/src/arr/spec.rsdiffbeforeafterboth1//! Those implementations are a bit sketchy, as this is mostly performance experiments2//! of not yet finished nightly rust features34use std::{cell::RefCell, iter, mem::replace, rc::Rc};1use std::{cell::RefCell, iter, mem::replace, rc::Rc};5217};14};181519pub trait ArrayLike: Sized + Into<ArrValue> {16pub trait ArrayLike: Sized + Into<ArrValue> {20 #[cfg(feature = "nightly")]21 type Iter<'t>22 where23 Self: 't;24 #[cfg(feature = "nightly")]25 type IterLazy<'t>26 where27 Self: 't;28 #[cfg(feature = "nightly")]29 type IterCheap<'t>30 where31 Self: 't;3233 fn len(&self) -> usize;17 fn len(&self) -> usize;34 fn is_empty(&self) -> bool {18 fn is_empty(&self) -> bool {37 fn get(&self, index: usize) -> Result<Option<Val>>;21 fn get(&self, index: usize) -> Result<Option<Val>>;38 fn get_lazy(&self, index: usize) -> Option<Thunk<Val>>;22 fn get_lazy(&self, index: usize) -> Option<Thunk<Val>>;39 fn get_cheap(&self, index: usize) -> Option<Val>;23 fn get_cheap(&self, index: usize) -> Option<Val>;40 #[cfg(feature = "nightly")]41 #[allow(clippy::iter_not_returning_iterator)]42 fn iter(&self) -> Self::Iter<'_>;43 #[cfg(feature = "nightly")]44 fn iter_lazy(&self) -> Self::IterLazy<'_>;45 #[cfg(feature = "nightly")]46 fn iter_cheap(&self) -> Option<Self::IterCheap<'_>>;472448 fn reverse(self) -> ArrValue {25 fn reverse(self) -> ArrValue {49 ArrValue::Reverse(Cc::new(ReverseArray(self.into())))26 ArrValue::Reverse(Cc::new(ReverseArray(self.into())))59}36}603761impl SliceArray {38impl SliceArray {62 #[cfg(not(feature = "nightly"))]63 fn iter(&self) -> impl Iterator<Item = Result<Val>> + '_ {39 fn iter(&self) -> impl Iterator<Item = Result<Val>> + '_ {64 self.inner40 self.inner65 .iter()41 .iter()68 .step_by(self.step as usize)44 .step_by(self.step as usize)69 }45 }704671 #[cfg(not(feature = "nightly"))]72 fn iter_lazy(&self) -> impl Iterator<Item = Thunk<Val>> + '_ {47 fn iter_lazy(&self) -> impl Iterator<Item = Thunk<Val>> + '_ {73 self.inner48 self.inner74 .iter_lazy()49 .iter_lazy()77 .step_by(self.step as usize)52 .step_by(self.step as usize)78 }53 }795480 #[cfg(not(feature = "nightly"))]81 fn iter_cheap(&self) -> Option<impl crate::arr::ArrayLikeIter<Val> + '_> {55 fn iter_cheap(&self) -> Option<impl crate::arr::ArrayLikeIter<Val> + '_> {82 Some(56 Some(83 self.inner57 self.inner88 )62 )89 }63 }90}64}91#[cfg(feature = "nightly")]92type SliceArrayIter<'t> = impl DoubleEndedIterator<Item = Result<Val>> + ExactSizeIterator + 't;93#[cfg(feature = "nightly")]94type SliceArrayLazyIter<'t> = impl DoubleEndedIterator<Item = Thunk<Val>> + ExactSizeIterator + 't;95#[cfg(feature = "nightly")]96type SliceArrayCheapIter<'t> = impl DoubleEndedIterator<Item = Val> + ExactSizeIterator + 't;97impl ArrayLike for SliceArray {65impl ArrayLike for SliceArray {98 #[cfg(feature = "nightly")]99 type Iter<'t> = SliceArrayIter<'t>;100 #[cfg(feature = "nightly")]101 type IterLazy<'t> = SliceArrayLazyIter<'t>;102 #[cfg(feature = "nightly")]103 type IterCheap<'t> = SliceArrayCheapIter<'t>;104105 fn len(&self) -> usize {66 fn len(&self) -> usize {106 iter::repeat(())67 iter::repeat(())121 self.iter_cheap()?.nth(index)82 self.iter_cheap()?.nth(index)122 }83 }123124 #[cfg(feature = "nightly")]125 fn iter(&self) -> SliceArrayIter<'_> {126 self.inner127 .iter()128 .skip(self.from as usize)129 .take((self.to - self.from) as usize)130 .step_by(self.step as usize)131 }132133 #[cfg(feature = "nightly")]134 fn iter_lazy(&self) -> SliceArrayLazyIter<'_> {135 self.inner136 .iter_lazy()137 .skip(self.from as usize)138 .take((self.to - self.from) as usize)139 .step_by(self.step as usize)140 }141142 #[cfg(feature = "nightly")]143 fn iter_cheap(&self) -> Option<SliceArrayCheapIter<'_>> {144 Some(145 self.inner146 .iter_cheap()?147 .skip(self.from as usize)148 .take((self.to - self.from) as usize)149 .step_by(self.step as usize),150 )151 }152}84}153impl From<SliceArray> for ArrValue {85impl From<SliceArray> for ArrValue {154 fn from(value: SliceArray) -> Self {86 fn from(value: SliceArray) -> Self {15890159#[derive(Trace, Debug, Clone)]91#[derive(Trace, Debug, Clone)]160pub struct CharArray(pub Rc<Vec<char>>);92pub struct CharArray(pub Rc<Vec<char>>);161#[cfg(feature = "nightly")]162type CharArrayIter<'t> = impl DoubleEndedIterator<Item = Result<Val>> + ExactSizeIterator + 't;163#[cfg(feature = "nightly")]164type CharArrayLazyIter<'t> = impl DoubleEndedIterator<Item = Thunk<Val>> + ExactSizeIterator + 't;165#[cfg(feature = "nightly")]166type CharArrayCheapIter<'t> = impl DoubleEndedIterator<Item = Val> + ExactSizeIterator + 't;167impl ArrayLike for CharArray {93impl ArrayLike for CharArray {168 #[cfg(feature = "nightly")]169 type Iter<'t> = CharArrayIter<'t>;170 #[cfg(feature = "nightly")]171 type IterLazy<'t> = CharArrayLazyIter<'t>;172 #[cfg(feature = "nightly")]173 type IterCheap<'t> = CharArrayCheapIter<'t>;174175 fn len(&self) -> usize {94 fn len(&self) -> usize {176 self.0.len()95 self.0.len()190 .map(|v| Val::Str(StrValue::Flat(IStr::from(*v))))109 .map(|v| Val::Str(StrValue::Flat(IStr::from(*v))))191 }110 }192193 #[cfg(feature = "nightly")]194 fn iter(&self) -> CharArrayIter<'_> {195 self.0196 .iter()197 .map(|v| Ok(Val::Str(StrValue::Flat(IStr::from(*v)))))198 }199200 #[cfg(feature = "nightly")]201 fn iter_lazy(&self) -> CharArrayLazyIter<'_> {202 self.0203 .iter()204 .map(|v| Thunk::evaluated(Val::Str(StrValue::Flat(IStr::from(*v)))))205 }206207 #[cfg(feature = "nightly")]208 fn iter_cheap(&self) -> Option<CharArrayCheapIter<'_>> {209 Some(210 self.0211 .iter()212 .map(|v| Val::Str(StrValue::Flat(IStr::from(*v)))),213 )214 }215}111}216impl From<CharArray> for ArrValue {112impl From<CharArray> for ArrValue {217 fn from(value: CharArray) -> Self {113 fn from(value: CharArray) -> Self {221117222#[derive(Trace, Debug, Clone)]118#[derive(Trace, Debug, Clone)]223pub struct BytesArray(pub IBytes);119pub struct BytesArray(pub IBytes);224#[cfg(feature = "nightly")]225type BytesArrayIter<'t> = impl DoubleEndedIterator<Item = Result<Val>> + ExactSizeIterator + 't;226#[cfg(feature = "nightly")]227type BytesArrayLazyIter<'t> = impl DoubleEndedIterator<Item = Thunk<Val>> + ExactSizeIterator + 't;228#[cfg(feature = "nightly")]229type BytesArrayCheapIter<'t> = impl DoubleEndedIterator<Item = Val> + ExactSizeIterator + 't;230impl ArrayLike for BytesArray {120impl ArrayLike for BytesArray {231 #[cfg(feature = "nightly")]232 type Iter<'t> = BytesArrayIter<'t>;233 #[cfg(feature = "nightly")]234 type IterLazy<'t> = BytesArrayLazyIter<'t>;235 #[cfg(feature = "nightly")]236 type IterCheap<'t> = BytesArrayCheapIter<'t>;237238 fn len(&self) -> usize {121 fn len(&self) -> usize {239 self.0.len()122 self.0.len()251 self.0.get(index).map(|v| Val::Num(f64::from(*v)))134 self.0.get(index).map(|v| Val::Num(f64::from(*v)))252 }135 }253254 #[cfg(feature = "nightly")]255 fn iter(&self) -> BytesArrayIter<'_> {256 self.0.iter().map(|v| Ok(Val::Num(f64::from(*v))))257 }258259 #[cfg(feature = "nightly")]260 fn iter_lazy(&self) -> BytesArrayLazyIter<'_> {261 self.0262 .iter()263 .map(|v| Thunk::evaluated(Val::Num(f64::from(*v))))264 }265266 #[cfg(feature = "nightly")]267 fn iter_cheap(&self) -> Option<BytesArrayCheapIter<'_>> {268 Some(self.0.iter().map(|v| Val::Num(f64::from(*v))))269 }270}136}271impl From<BytesArray> for ArrValue {137impl From<BytesArray> for ArrValue {272 fn from(value: BytesArray) -> Self {138 fn from(value: BytesArray) -> Self {297 }))163 }))298 }164 }299}165}300#[cfg(feature = "nightly")]301type ExprArrayIter<'t> = impl DoubleEndedIterator<Item = Result<Val>> + ExactSizeIterator + 't;302#[cfg(feature = "nightly")]303type ExprArrayLazyIter<'t> = impl DoubleEndedIterator<Item = Thunk<Val>> + ExactSizeIterator + 't;304#[cfg(feature = "nightly")]305type ExprArrayCheapIter<'t> = iter::Empty<Val>;306impl ArrayLike for ExprArray {166impl ArrayLike for ExprArray {307 #[cfg(feature = "nightly")]308 type Iter<'t> = ExprArrayIter<'t>;309 #[cfg(feature = "nightly")]310 type IterLazy<'t> = ExprArrayLazyIter<'t>;311 #[cfg(feature = "nightly")]312 type IterCheap<'t> = ExprArrayCheapIter<'t>;313314 fn len(&self) -> usize {167 fn len(&self) -> usize {315 self.0.cached.borrow().len()168 self.0.cached.borrow().len()375 None228 None376 }229 }377378 #[cfg(feature = "nightly")]379 fn iter(&self) -> ExprArrayIter<'_> {380 (0..self.len()).map(|i| self.get(i).transpose().expect("index checked"))381 }382 #[cfg(feature = "nightly")]383 fn iter_lazy(&self) -> ExprArrayLazyIter<'_> {384 (0..self.len()).map(|i| self.get_lazy(i).expect("index checked"))385 }386 #[cfg(feature = "nightly")]387 fn iter_cheap(&self) -> Option<Self::IterCheap<'_>> {388 None389 }390}230}391impl From<ExprArray> for ArrValue {231impl From<ExprArray> for ArrValue {392 fn from(value: ExprArray) -> Self {232 fn from(value: ExprArray) -> Self {401 split: usize,241 split: usize,402 len: usize,242 len: usize,403}243}404#[cfg(feature = "nightly")]405406type ExtendedArrayIter<'t> = impl DoubleEndedIterator<Item = Result<Val>> + ExactSizeIterator + 't;407#[cfg(feature = "nightly")]408type ExtendedArrayLazyIter<'t> =409 impl DoubleEndedIterator<Item = Thunk<Val>> + ExactSizeIterator + 't;410#[cfg(feature = "nightly")]411type ExtendedArrayCheapIter<'t> = impl DoubleEndedIterator<Item = Val> + ExactSizeIterator + 't;412impl ExtendedArray {244impl ExtendedArray {413 pub fn new(a: ArrValue, b: ArrValue) -> Self {245 pub fn new(a: ArrValue, b: ArrValue) -> Self {414 let a_len = a.len();246 let a_len = a.len();459 }291 }460}292}461impl ArrayLike for ExtendedArray {293impl ArrayLike for ExtendedArray {462 #[cfg(feature = "nightly")]463 type Iter<'t> = ExtendedArrayIter<'t>;464 #[cfg(feature = "nightly")]465 type IterLazy<'t> = ExtendedArrayLazyIter<'t>;466 #[cfg(feature = "nightly")]467 type IterCheap<'t> = ExtendedArrayCheapIter<'t>;468469 fn get(&self, index: usize) -> Result<Option<Val>> {294 fn get(&self, index: usize) -> Result<Option<Val>> {470 if self.split > index {295 if self.split > index {493 }318 }494 }319 }495496 #[cfg(feature = "nightly")]497 fn iter(&self) -> ExtendedArrayIter<'_> {498 WithExactSize(self.a.iter().chain(self.b.iter()), self.len)499 }500 #[cfg(feature = "nightly")]501 fn iter_lazy(&self) -> ExtendedArrayLazyIter<'_> {502 WithExactSize(self.a.iter_lazy().chain(self.b.iter_lazy()), self.len)503 }504 #[cfg(feature = "nightly")]505 fn iter_cheap(&self) -> Option<ExtendedArrayCheapIter<'_>> {506 let a = self.a.iter_cheap()?;507 let b = self.b.iter_cheap()?;508 Some(WithExactSize(a.chain(b), self.len))509 }510}320}511impl From<ExtendedArray> for ArrValue {321impl From<ExtendedArray> for ArrValue {512 fn from(value: ExtendedArray) -> Self {322 fn from(value: ExtendedArray) -> Self {516326517#[derive(Trace, Debug, Clone)]327#[derive(Trace, Debug, Clone)]518pub struct LazyArray(pub Cc<Vec<Thunk<Val>>>);328pub struct LazyArray(pub Cc<Vec<Thunk<Val>>>);519#[cfg(feature = "nightly")]520type LazyArrayIter<'t> = impl DoubleEndedIterator<Item = Result<Val>> + ExactSizeIterator + 't;521#[cfg(feature = "nightly")]522type LazyArrayLazyIter<'t> = impl DoubleEndedIterator<Item = Thunk<Val>> + ExactSizeIterator + 't;523#[cfg(feature = "nightly")]524type LazyArrayCheapIter<'t> = iter::Empty<Val>;525impl ArrayLike for LazyArray {329impl ArrayLike for LazyArray {526 #[cfg(feature = "nightly")]527 type Iter<'t> = LazyArrayIter<'t>;528529 #[cfg(feature = "nightly")]530 type IterLazy<'t> = LazyArrayLazyIter<'t>;531532 #[cfg(feature = "nightly")]533 type IterCheap<'t> = LazyArrayCheapIter<'t>;534535 fn len(&self) -> usize {330 fn len(&self) -> usize {536 self.0.len()331 self.0.len()547 fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {342 fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {548 self.0.get(index).cloned()343 self.0.get(index).cloned()549 }344 }550 #[cfg(feature = "nightly")]551 fn iter(&self) -> LazyArrayIter<'_> {552 self.0.iter().map(Thunk::evaluate)553 }554 #[cfg(feature = "nightly")]555 fn iter_lazy(&self) -> LazyArrayLazyIter<'_> {556 self.0.iter().cloned()557 }558 #[cfg(feature = "nightly")]559 fn iter_cheap(&self) -> Option<LazyArrayCheapIter<'_>> {560 None561 }562}345}563impl From<LazyArray> for ArrValue {346impl From<LazyArray> for ArrValue {564 fn from(value: LazyArray) -> Self {347 fn from(value: LazyArray) -> Self {568351569#[derive(Trace, Debug, Clone)]352#[derive(Trace, Debug, Clone)]570pub struct EagerArray(pub Cc<Vec<Val>>);353pub struct EagerArray(pub Cc<Vec<Val>>);571#[cfg(feature = "nightly")]572type EagerArrayIter<'t> = impl DoubleEndedIterator<Item = Result<Val>> + ExactSizeIterator + 't;573#[cfg(feature = "nightly")]574type EagerArrayLazyIter<'t> = impl DoubleEndedIterator<Item = Thunk<Val>> + ExactSizeIterator + 't;575#[cfg(feature = "nightly")]576type EagerArrayCheapIter<'t> = impl DoubleEndedIterator<Item = Val> + ExactSizeIterator + 't;577impl ArrayLike for EagerArray {354impl ArrayLike for EagerArray {578 #[cfg(feature = "nightly")]579 type Iter<'t> = EagerArrayIter<'t>;580581 #[cfg(feature = "nightly")]582 type IterLazy<'t> = EagerArrayLazyIter<'t>;583584 #[cfg(feature = "nightly")]585 type IterCheap<'t> = EagerArrayCheapIter<'t>;586587 fn len(&self) -> usize {355 fn len(&self) -> usize {588 self.0.len()356 self.0.len()600 self.0.get(index).cloned()368 self.0.get(index).cloned()601 }369 }602603 #[cfg(feature = "nightly")]604 fn iter(&self) -> EagerArrayIter<'_> {605 self.0.iter().cloned().map(Ok)606 }607608 #[cfg(feature = "nightly")]609 fn iter_lazy(&self) -> EagerArrayLazyIter<'_> {610 self.0.iter().cloned().map(Thunk::evaluated)611 }612613 #[cfg(feature = "nightly")]614 fn iter_cheap(&self) -> Option<EagerArrayCheapIter<'_>> {615 Some(self.0.iter().cloned())616 }617}370}618impl From<EagerArray> for ArrValue {371impl From<EagerArray> for ArrValue {619 fn from(value: EagerArray) -> Self {372 fn from(value: EagerArray) -> Self {648 }401 }649}402}650403651#[cfg(feature = "nightly")]652type RangeArrayIter<'t> = impl DoubleEndedIterator<Item = Result<Val>> + ExactSizeIterator + 't;653#[cfg(feature = "nightly")]654type RangeArrayLazyIter<'t> = impl DoubleEndedIterator<Item = Thunk<Val>> + ExactSizeIterator + 't;655#[cfg(feature = "nightly")]656type RangeArrayCheapIter<'t> = impl DoubleEndedIterator<Item = Val> + ExactSizeIterator + 't;657impl ArrayLike for RangeArray {404impl ArrayLike for RangeArray {658 #[cfg(feature = "nightly")]659 type Iter<'t> = RangeArrayIter<'t>;660661 #[cfg(feature = "nightly")]662 type IterLazy<'t> = RangeArrayLazyIter<'t>;663664 #[cfg(feature = "nightly")]665 type IterCheap<'t> = RangeArrayCheapIter<'t>;666667 fn len(&self) -> usize {405 fn len(&self) -> usize {668 self.range().len()406 self.range().len()683 self.range().nth(index).map(|i| Val::Num(f64::from(i)))421 self.range().nth(index).map(|i| Val::Num(f64::from(i)))684 }422 }685686 #[cfg(feature = "nightly")]687 fn iter(&self) -> RangeArrayIter<'_> {688 self.range().map(|i| Ok(Val::Num(f64::from(i))))689 }690691 #[cfg(feature = "nightly")]692 fn iter_lazy(&self) -> RangeArrayLazyIter<'_> {693 self.range()694 .map(|i| Thunk::evaluated(Val::Num(f64::from(i))))695 }696697 #[cfg(feature = "nightly")]698 fn iter_cheap(&self) -> Option<RangeArrayCheapIter<'_>> {699 Some(self.range().map(|i| Val::Num(f64::from(i))))700 }701}423}702impl From<RangeArray> for ArrValue {424impl From<RangeArray> for ArrValue {703 fn from(value: RangeArray) -> Self {425 fn from(value: RangeArray) -> Self {708#[derive(Debug, Trace, Clone)]430#[derive(Debug, Trace, Clone)]709pub struct ReverseArray(pub ArrValue);431pub struct ReverseArray(pub ArrValue);710impl ArrayLike for ReverseArray {432impl ArrayLike for ReverseArray {711 #[cfg(feature = "nightly")]712 type Iter<'t> = iter::Rev<UnknownArrayIter<'t>>;713714 #[cfg(feature = "nightly")]715 type IterLazy<'t> = iter::Rev<UnknownArrayIterLazy<'t>>;716717 #[cfg(feature = "nightly")]718 type IterCheap<'t> = iter::Rev<UnknownArrayIterCheap<'t>>;719720 fn len(&self) -> usize {433 fn len(&self) -> usize {721 self.0.len()434 self.0.len()733 self.0.get_cheap(self.0.len() - index - 1)446 self.0.get_cheap(self.0.len() - index - 1)734 }447 }735736 #[cfg(feature = "nightly")]737 fn iter(&self) -> iter::Rev<UnknownArrayIter<'_>> {738 self.0.iter().rev()739 }740741 #[cfg(feature = "nightly")]742 fn iter_lazy(&self) -> iter::Rev<UnknownArrayIterLazy<'_>> {743 self.0.iter_lazy().rev()744 }745746 #[cfg(feature = "nightly")]747 fn iter_cheap(&self) -> Option<iter::Rev<UnknownArrayIterCheap<'_>>> {748 Some(self.0.iter_cheap()?.rev())749 }750 fn reverse(self) -> ArrValue {448 fn reverse(self) -> ArrValue {751 self.0449 self.0752 }450 }775 }))473 }))776 }474 }777}475}778#[cfg(feature = "nightly")]779type MappedArrayIter<'t> = impl DoubleEndedIterator<Item = Result<Val>> + ExactSizeIterator + 't;780#[cfg(feature = "nightly")]781type MappedArrayLazyIter<'t> = impl DoubleEndedIterator<Item = Thunk<Val>> + ExactSizeIterator + 't;782#[cfg(feature = "nightly")]783type MappedArrayCheapIter<'t> = iter::Empty<Val>;784impl ArrayLike for MappedArray {476impl ArrayLike for MappedArray {785 #[cfg(feature = "nightly")]786 type Iter<'t> = MappedArrayIter<'t>;787 #[cfg(feature = "nightly")]788 type IterLazy<'t> = MappedArrayLazyIter<'t>;789 #[cfg(feature = "nightly")]790 type IterCheap<'t> = MappedArrayCheapIter<'t>;791792 fn len(&self) -> usize {477 fn len(&self) -> usize {793 self.0.cached.borrow().len()478 self.0.cached.borrow().len()863 None548 None864 }549 }865866 #[cfg(feature = "nightly")]867 fn iter(&self) -> MappedArrayIter<'_> {868 (0..self.len()).map(|i| self.get(i).transpose().expect("length checked"))869 }870871 #[cfg(feature = "nightly")]872 fn iter_lazy(&self) -> MappedArrayLazyIter<'_> {873 (0..self.len()).map(|i| self.get_lazy(i).expect("length checked"))874 }875876 #[cfg(feature = "nightly")]877 fn iter_cheap(&self) -> Option<Self::IterCheap<'_>> {878 None879 }880}550}881impl From<MappedArray> for ArrValue {551impl From<MappedArray> for ArrValue {882 fn from(value: MappedArray) -> Self {552 fn from(value: MappedArray) -> Self {906 }576 }907}577}908578909#[cfg(feature = "nightly")]910type RepeatedArrayIter<'t> = impl DoubleEndedIterator<Item = Result<Val>> + ExactSizeIterator + 't;911#[cfg(feature = "nightly")]912type RepeatedArrayLazyIter<'t> =913 impl DoubleEndedIterator<Item = Thunk<Val>> + ExactSizeIterator + 't;914#[cfg(feature = "nightly")]915type RepeatedArrayCheapIter<'t> = impl DoubleEndedIterator<Item = Val> + ExactSizeIterator + 't;916impl ArrayLike for RepeatedArray {579impl ArrayLike for RepeatedArray {917 #[cfg(feature = "nightly")]918 type Iter<'t> = RepeatedArrayIter<'t>;919 #[cfg(feature = "nightly")]920 type IterLazy<'t> = RepeatedArrayLazyIter<'t>;921 #[cfg(feature = "nightly")]922 type IterCheap<'t> = RepeatedArrayCheapIter<'t>;923924 fn len(&self) -> usize {580 fn len(&self) -> usize {925 self.0.total_len581 self.0.total_len946 self.0.data.get_cheap(index % self.0.data.len())602 self.0.data.get_cheap(index % self.0.data.len())947 }603 }948949 #[cfg(feature = "nightly")]950 fn iter(&self) -> RepeatedArrayIter<'_> {951 (0..self.0.total_len)952 .map(|i| self.get(i))953 .map(Result::transpose)954 .map(Option::unwrap)955 }956957 #[cfg(feature = "nightly")]958 fn iter_lazy(&self) -> RepeatedArrayLazyIter<'_> {959 (0..self.0.total_len)960 .map(|i| self.get_lazy(i))961 .map(Option::unwrap)962 }963964 #[cfg(feature = "nightly")]965 fn iter_cheap(&self) -> Option<RepeatedArrayCheapIter<'_>> {966 if !self.0.data.is_cheap() {967 return None;968 }969 Some(970 (0..self.0.total_len)971 .map(|i| self.get_cheap(i))972 .map(Option::unwrap),973 )974 }975}604}976impl From<RepeatedArray> for ArrValue {605impl From<RepeatedArray> for ArrValue {977 fn from(value: RepeatedArray) -> Self {606 fn from(value: RepeatedArray) -> Self {978 Self::Repeated(value)607 Self::Repeated(value)979 }608 }980}609}981982#[cfg(feature = "nightly")]983macro_rules! impl_iter_enum {984 ($n:ident => $v:ident) => {985 pub enum $n<'t> {986 Bytes(<BytesArray as ArrayLike>::$v<'t>),987 Expr(<ExprArray as ArrayLike>::$v<'t>),988 Lazy(<LazyArray as ArrayLike>::$v<'t>),989 Eager(<EagerArray as ArrayLike>::$v<'t>),990 Range(<RangeArray as ArrayLike>::$v<'t>),991 Slice(Box<<SliceArray as ArrayLike>::$v<'t>>),992 Extended(Box<<ExtendedArray as ArrayLike>::$v<'t>>),993 Reverse(Box<<ReverseArray as ArrayLike>::$v<'t>>),994 Mapped(Box<<MappedArray as ArrayLike>::$v<'t>>),995 Repeated(Box<<RepeatedArray as ArrayLike>::$v<'t>>),996 }997 };998}9996101000macro_rules! pass {611macro_rules! pass {1001 ($t:ident.$m:ident($($ident:ident),*)) => {612 ($t:ident.$m:ident($($ident:ident),*)) => {1016}627}1017pub(super) use pass;628pub(super) use pass;10181019#[cfg(feature = "nightly")]1020macro_rules! pass_iter_call {1021 ($t:ident.$c:ident $(in $wrap:ident)? => $e:ident) => {1022 match $t {1023 ArrValue::Bytes(e) => $e::Bytes($($wrap!)?(e.$c())),1024 ArrValue::Lazy(e) => $e::Lazy($($wrap!)?(e.$c())),1025 ArrValue::Expr(e) => $e::Expr($($wrap!)?(e.$c())),1026 ArrValue::Eager(e) => $e::Eager($($wrap!)?(e.$c())),1027 ArrValue::Range(e) => $e::Range($($wrap!)?(e.$c())),1028 ArrValue::Slice(e) => $e::Slice(Box::new($($wrap!)?(e.$c()))),1029 ArrValue::Extended(e) => $e::Extended(Box::new($($wrap!)?(e.$c()))),1030 ArrValue::Reverse(e) => $e::Reverse(Box::new($($wrap!)?(e.$c()))),1031 ArrValue::Mapped(e) => $e::Mapped(Box::new($($wrap!)?(e.$c()))),1032 ArrValue::Repeated(e) => $e::Repeated(Box::new($($wrap!)?(e.$c()))),1033 }1034 };1035}1036#[cfg(feature = "nightly")]1037pub(super) use pass_iter_call;10381039#[cfg(feature = "nightly")]1040macro_rules! impl_iter {1041 ($t:ident => $out:ty) => {1042 impl Iterator for $t<'_> {1043 type Item = $out;10441045 fn next(&mut self) -> Option<Self::Item> {1046 pass!(self.next())1047 }1048 fn nth(&mut self, count: usize) -> Option<Self::Item> {1049 pass!(self.nth(count))1050 }1051 fn size_hint(&self) -> (usize, Option<usize>) {1052 pass!(self.size_hint())1053 }1054 }1055 impl DoubleEndedIterator for $t<'_> {1056 fn next_back(&mut self) -> Option<Self::Item> {1057 pass!(self.next_back())1058 }1059 fn nth_back(&mut self, count: usize) -> Option<Self::Item> {1060 pass!(self.nth_back(count))1061 }1062 }1063 impl ExactSizeIterator for $t<'_> {1064 fn len(&self) -> usize {1065 match self {1066 Self::Bytes(e) => e.len(),1067 Self::Expr(e) => e.len(),1068 Self::Lazy(e) => e.len(),1069 Self::Eager(e) => e.len(),1070 Self::Range(e) => e.len(),1071 Self::Slice(e) => e.len(),1072 Self::Extended(e) => {1073 e.size_hint().1.expect("overflow is checked in constructor")1074 }1075 Self::Reverse(e) => e.len(),1076 Self::Mapped(e) => e.len(),1077 Self::Repeated(e) => e.len(),1078 }1079 }1080 }1081 };1082}10831084#[cfg(feature = "nightly")]1085impl_iter_enum!(UnknownArrayIter => Iter);1086#[cfg(feature = "nightly")]1087impl_iter!(UnknownArrayIter => Result<Val>);1088#[cfg(feature = "nightly")]1089impl_iter_enum!(UnknownArrayIterLazy => IterLazy);1090#[cfg(feature = "nightly")]1091impl_iter!(UnknownArrayIterLazy => Thunk<Val>);1092#[cfg(feature = "nightly")]1093impl_iter_enum!(UnknownArrayIterCheap => IterCheap);1094#[cfg(feature = "nightly")]1095impl_iter!(UnknownArrayIterCheap => Val);1096629