1use std::{2 cell::RefCell,3 iter::{self, Rev},4 mem::replace,5};67use jrsonnet_gcmodule::{Cc, Trace};8use jrsonnet_interner::IBytes;9use jrsonnet_parser::LocExpr;1011use super::ArrValue;12use crate::{13 error::ErrorKind::InfiniteRecursionDetected, evaluate, function::FuncVal, tb, typed::Any,14 val::ThunkValue, Context, Error, Result, Thunk, Val,15};1617pub trait ArrayLike {18 type Iter<'t>19 where20 Self: 't;21 type IterLazy<'t>22 where23 Self: 't;24 type IterCheap<'t>25 where26 Self: 't;2728 fn len(&self) -> usize;29 fn is_empty(&self) -> bool {30 self.len() == 031 }32 fn get(&self, index: usize) -> Result<Option<Val>>;33 fn get_lazy(&self, index: usize) -> Option<Thunk<Val>>;34 fn get_cheap(&self, index: usize) -> Option<Val>;35 fn evaluated(&self) -> Result<Vec<Val>>;36 #[allow(clippy::iter_not_returning_iterator)]37 fn iter(&self) -> Self::Iter<'_>;38 fn iter_lazy(&self) -> Self::IterLazy<'_>;39 fn iter_cheap(&self) -> Option<Self::IterCheap<'_>>;40}4142#[derive(Debug, Clone, Trace)]43pub struct SliceArray {44 pub(crate) inner: ArrValue,45 pub(crate) from: u32,46 pub(crate) to: u32,47 pub(crate) step: u32,48}49type SliceArrayIter<'t> = impl DoubleEndedIterator<Item = Result<Val>> + ExactSizeIterator + 't;50type SliceArrayLazyIter<'t> = impl DoubleEndedIterator<Item = Thunk<Val>> + ExactSizeIterator + 't;51type SliceArrayCheapIter<'t> = impl DoubleEndedIterator<Item = Val> + ExactSizeIterator + 't;52impl ArrayLike for SliceArray {53 type Iter<'t> = SliceArrayIter<'t>;5455 type IterLazy<'t> = SliceArrayLazyIter<'t>;5657 type IterCheap<'t> = SliceArrayCheapIter<'t>;5859 fn len(&self) -> usize {60 iter::repeat(())61 .take((self.to - self.from) as usize)62 .step_by(self.step as usize)63 .count()64 }6566 fn get(&self, index: usize) -> Result<Option<Val>> {67 self.iter().nth(index).transpose()68 }6970 fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {71 self.iter_lazy().nth(index)72 }7374 fn get_cheap(&self, index: usize) -> Option<Val> {75 self.iter_cheap()?.nth(index)76 }7778 fn evaluated(&self) -> Result<Vec<Val>> {79 self.iter().collect()80 }8182 fn iter(&self) -> SliceArrayIter<'_> {83 self.inner84 .iter()85 .skip(self.from as usize)86 .take((self.to - self.from) as usize)87 .step_by(self.step as usize)88 }8990 fn iter_lazy(&self) -> SliceArrayLazyIter<'_> {91 self.inner92 .iter_lazy()93 .skip(self.from as usize)94 .take((self.to - self.from) as usize)95 .step_by(self.step as usize)96 }9798 fn iter_cheap(&self) -> Option<SliceArrayCheapIter<'_>> {99 Some(100 self.inner101 .iter_cheap()?102 .skip(self.from as usize)103 .take((self.to - self.from) as usize)104 .step_by(self.step as usize),105 )106 }107}108109#[derive(Trace, Debug, Clone)]110pub struct BytesArray(pub IBytes);111type BytesArrayIter<'t> = impl DoubleEndedIterator<Item = Result<Val>> + ExactSizeIterator + 't;112type BytesArrayLazyIter<'t> = impl DoubleEndedIterator<Item = Thunk<Val>> + ExactSizeIterator + 't;113type BytesArrayCheapIter<'t> = impl DoubleEndedIterator<Item = Val> + ExactSizeIterator + 't;114impl ArrayLike for BytesArray {115 type Iter<'t> = BytesArrayIter<'t>;116117 type IterLazy<'t> = BytesArrayLazyIter<'t>;118119 type IterCheap<'t> = BytesArrayCheapIter<'t>;120121 fn len(&self) -> usize {122 self.0.len()123 }124125 fn get(&self, index: usize) -> Result<Option<Val>> {126 Ok(self.get_cheap(index))127 }128129 fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {130 self.get_cheap(index).map(Thunk::evaluated)131 }132133 fn get_cheap(&self, index: usize) -> Option<Val> {134 self.0.get(index).map(|v| Val::Num(f64::from(*v)))135 }136137 fn evaluated(&self) -> Result<Vec<Val>> {138 self.iter().collect()139 }140141 fn iter(&self) -> BytesArrayIter<'_> {142 self.0.iter().map(|v| Ok(Val::Num(f64::from(*v))))143 }144145 fn iter_lazy(&self) -> BytesArrayLazyIter<'_> {146 self.0147 .iter()148 .map(|v| Thunk::evaluated(Val::Num(f64::from(*v))))149 }150151 fn iter_cheap(&self) -> Option<BytesArrayCheapIter<'_>> {152 Some(self.0.iter().map(|v| Val::Num(f64::from(*v))))153 }154}155156#[derive(Debug, Trace, Clone)]157enum ArrayThunk<T: 'static + Trace> {158 Computed(Val),159 Errored(Error),160 Waiting(T),161 Pending,162}163164#[derive(Debug, Trace)]165pub struct ExprArrayInner {166 ctx: Context,167 cached: RefCell<Vec<ArrayThunk<LocExpr>>>,168}169#[derive(Debug, Trace, Clone)]170pub struct ExprArray(pub Cc<ExprArrayInner>);171type ExprArrayIter<'t> = impl DoubleEndedIterator<Item = Result<Val>> + ExactSizeIterator + 't;172type ExprArrayLazyIter<'t> = impl DoubleEndedIterator<Item = Thunk<Val>> + ExactSizeIterator + 't;173type ExprArrayCheapIter<'t> = iter::Empty<Val>;174impl ExprArray {175 pub fn new(ctx: Context, items: impl IntoIterator<Item = LocExpr>) -> Self {176 Self(Cc::new(ExprArrayInner {177 ctx,178 cached: RefCell::new(items.into_iter().map(ArrayThunk::Waiting).collect()),179 }))180 }181}182impl ArrayLike for ExprArray {183 type Iter<'t> = ExprArrayIter<'t>;184185 type IterLazy<'t> = ExprArrayLazyIter<'t>;186187 type IterCheap<'t> = ExprArrayCheapIter<'t>;188189 fn len(&self) -> usize {190 self.0.cached.borrow().len()191 }192 fn get(&self, index: usize) -> Result<Option<Val>> {193 if index >= self.len() {194 return Ok(None);195 }196 match &self.0.cached.borrow()[index] {197 ArrayThunk::Computed(c) => return Ok(Some(c.clone())),198 ArrayThunk::Errored(e) => return Err(e.clone()),199 ArrayThunk::Pending => return Err(InfiniteRecursionDetected.into()),200 ArrayThunk::Waiting(..) => {}201 };202203 let ArrayThunk::Waiting(expr) = replace(&mut self.0.cached.borrow_mut()[index], ArrayThunk::Pending) else {204 unreachable!()205 };206207 let new_value = match evaluate(self.0.ctx.clone(), &expr) {208 Ok(v) => v,209 Err(e) => {210 self.0.cached.borrow_mut()[index] = ArrayThunk::Errored(e.clone());211 return Err(e);212 }213 };214 self.0.cached.borrow_mut()[index] = ArrayThunk::Computed(new_value.clone());215 Ok(Some(new_value))216 }217 fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {218 #[derive(Trace)]219 struct ArrayElement {220 arr_thunk: ExprArray,221 index: usize,222 }223224 impl ThunkValue for ArrayElement {225 type Output = Val;226227 fn get(self: Box<Self>) -> Result<Self::Output> {228 self.arr_thunk229 .get(self.index)230 .transpose()231 .expect("index checked")232 }233 }234235 if index >= self.len() {236 return None;237 }238 match &self.0.cached.borrow()[index] {239 ArrayThunk::Computed(c) => return Some(Thunk::evaluated(c.clone())),240 ArrayThunk::Errored(e) => return Some(Thunk::errored(e.clone())),241 ArrayThunk::Waiting(_) | ArrayThunk::Pending => {}242 };243244 Some(Thunk::new(tb!(ArrayElement {245 arr_thunk: self.clone(),246 index,247 })))248 }249 fn get_cheap(&self, _index: usize) -> Option<Val> {250 None251 }252253 fn iter(&self) -> ExprArrayIter<'_> {254 (0..self.len()).map(|i| self.get(i).transpose().expect("index checked"))255 }256 fn iter_lazy(&self) -> ExprArrayLazyIter<'_> {257 (0..self.len()).map(|i| self.get_lazy(i).expect("index checked"))258 }259 fn iter_cheap(&self) -> Option<ExprArrayCheapIter<'_>> {260 None261 }262263 fn evaluated(&self) -> Result<Vec<Val>> {264 self.iter().collect()265 }266}267268#[derive(Trace, Debug, Clone)]269pub struct ExtendedArray {270 pub a: ArrValue,271 pub b: ArrValue,272 split: usize,273 len: usize,274}275type ExtendedArrayIter<'t> = impl DoubleEndedIterator<Item = Result<Val>> + 't;276type ExtendedArrayLazyIter<'t> = impl DoubleEndedIterator<Item = Thunk<Val>> + 't;277type ExtendedArrayCheapIter<'t> = impl DoubleEndedIterator<Item = Val> + 't;278impl ExtendedArray {279 pub fn new(a: ArrValue, b: ArrValue) -> Self {280 let a_len = a.len();281 let b_len = b.len();282 Self {283 a,284 b,285 split: a_len,286 len: a_len.checked_add(b_len).expect("too large array value"),287 }288 }289}290impl ArrayLike for ExtendedArray {291 type Iter<'t> = ExtendedArrayIter<'t>;292293 type IterLazy<'t> = ExtendedArrayLazyIter<'t>;294295 type IterCheap<'t> = ExtendedArrayCheapIter<'t>;296297 fn get(&self, index: usize) -> Result<Option<Val>> {298 if self.split > index {299 self.a.get(index)300 } else {301 self.b.get(index - self.split)302 }303 }304 fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {305 if self.split > index {306 self.a.get_lazy(index)307 } else {308 self.b.get_lazy(index - self.split)309 }310 }311312 fn len(&self) -> usize {313 self.len314 }315316 fn get_cheap(&self, index: usize) -> Option<Val> {317 if self.split > index {318 self.a.get_cheap(index)319 } else {320 self.b.get_cheap(index - self.split)321 }322 }323324 fn evaluated(&self) -> Result<Vec<Val>> {325 let mut out = self.a.evaluated()?;326 out.extend(self.b.evaluated()?.into_iter());327 Ok(out)328 }329330 fn iter(&self) -> ExtendedArrayIter<'_> {331 self.a.iter().chain(self.b.iter())332 }333 fn iter_lazy(&self) -> ExtendedArrayLazyIter<'_> {334 self.a.iter_lazy().chain(self.b.iter_lazy())335 }336 fn iter_cheap(&self) -> Option<ExtendedArrayCheapIter<'_>> {337 let a = self.a.iter_cheap()?;338 let b = self.b.iter_cheap()?;339 Some(a.chain(b))340 }341}342343#[derive(Trace, Debug, Clone)]344pub struct LazyArray(pub Cc<Vec<Thunk<Val>>>);345type LazyArrayIter<'t> = impl DoubleEndedIterator<Item = Result<Val>> + ExactSizeIterator + 't;346type LazyArrayLazyIter<'t> = impl DoubleEndedIterator<Item = Thunk<Val>> + ExactSizeIterator + 't;347type LazyArrayCheapIter<'t> = iter::Empty<Val>;348impl ArrayLike for LazyArray {349 type Iter<'t> = LazyArrayIter<'t>;350351 type IterLazy<'t> = LazyArrayLazyIter<'t>;352353 type IterCheap<'t> = LazyArrayCheapIter<'t>;354355 fn len(&self) -> usize {356 self.0.len()357 }358 fn get(&self, index: usize) -> Result<Option<Val>> {359 let Some(v) = self.0.get(index) else {360 return Ok(None);361 };362 v.evaluate().map(Some)363 }364 fn get_cheap(&self, _index: usize) -> Option<Val> {365 None366 }367 fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {368 self.0.get(index).cloned()369 }370 fn evaluated(&self) -> Result<Vec<Val>> {371 let mut out = Vec::with_capacity(self.len());372 for i in self.0.iter() {373 out.push(i.evaluate()?);374 }375 Ok(out)376 }377 fn iter(&self) -> LazyArrayIter<'_> {378 self.0.iter().map(Thunk::evaluate)379 }380 fn iter_lazy(&self) -> LazyArrayLazyIter<'_> {381 self.0.iter().cloned()382 }383 fn iter_cheap(&self) -> Option<LazyArrayCheapIter<'_>> {384 None385 }386}387388#[derive(Trace, Debug, Clone)]389pub struct EagerArray(pub Cc<Vec<Val>>);390type EagerArrayIter<'t> = impl DoubleEndedIterator<Item = Result<Val>> + ExactSizeIterator + 't;391type EagerArrayLazyIter<'t> = impl DoubleEndedIterator<Item = Thunk<Val>> + ExactSizeIterator + 't;392type EagerArrayCheapIter<'t> = impl DoubleEndedIterator<Item = Val> + ExactSizeIterator + 't;393impl ArrayLike for EagerArray {394 type Iter<'t> = EagerArrayIter<'t>;395396 type IterLazy<'t> = EagerArrayLazyIter<'t>;397398 type IterCheap<'t> = EagerArrayCheapIter<'t>;399400 fn len(&self) -> usize {401 self.0.len()402 }403404 fn get(&self, index: usize) -> Result<Option<Val>> {405 Ok(self.0.get(index).cloned())406 }407408 fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {409 self.0.get(index).cloned().map(Thunk::evaluated)410 }411412 fn get_cheap(&self, index: usize) -> Option<Val> {413 self.0.get(index).cloned()414 }415416 fn evaluated(&self) -> Result<Vec<Val>> {417 Ok((*self.0).clone())418 }419420 fn iter(&self) -> EagerArrayIter<'_> {421 self.0.iter().cloned().map(Ok)422 }423424 fn iter_lazy(&self) -> EagerArrayLazyIter<'_> {425 self.0.iter().cloned().map(Thunk::evaluated)426 }427428 fn iter_cheap(&self) -> Option<EagerArrayCheapIter<'_>> {429 Some(self.0.iter().cloned())430 }431}432433434#[derive(Debug, Trace, Clone, PartialEq, Eq)]435pub struct RangeArray {436 start: i32,437 end: i32,438}439struct RangeIter {440 start: i32,441 end: i32,442}443impl RangeIter {444 fn finished(&self) -> bool {445 self.end < self.start446 }447 fn finish(&mut self) {448 self.start = 0;449 self.end = -1;450 }451}452impl Iterator for RangeIter {453 type Item = i32;454455 fn next(&mut self) -> Option<Self::Item> {456 if self.finished() {457 return None;458 }459 let v = self.start;460 if v == self.end {461 self.finish();462 } else {463 self.start = v + 1;464 }465 Some(v)466 }467 fn nth(&mut self, n: usize) -> Option<Self::Item> {468 let v = (self.start as usize) + n;469 if v > self.end as usize {470 self.finish();471 None472 } else {473 self.start = v as i32;474 self.next()475 }476 }477 fn size_hint(&self) -> (usize, Option<usize>) {478 let len = self.len();479 (len, Some(len))480 }481}482impl DoubleEndedIterator for RangeIter {483 fn next_back(&mut self) -> Option<Self::Item> {484 if self.finished() {485 return None;486 }487 let v = self.end;488 if v == self.start {489 self.finish();490 } else {491 self.end = v - 1;492 }493 Some(v)494 }495 fn nth_back(&mut self, n: usize) -> Option<Self::Item> {496 let v = (self.end as usize) - n;497 if v < self.start as usize {498 self.finish();499 None500 } else {501 self.end = v as i32;502 self.next_back()503 }504 }505}506impl ExactSizeIterator for RangeIter {507 fn len(&self) -> usize {508 if self.finished() {509 0510 } else {511 (self.end as isize - self.start as isize + 1) as usize512 }513 }514}515impl RangeArray {516 pub fn empty() -> Self {517 Self::new_exclusive(0, 0)518 }519 pub fn new_exclusive(start: i32, end: i32) -> Self {520 end.checked_sub(1)521 .map_or_else(Self::empty, |end| Self { start, end })522 }523 pub fn new_inclusive(start: i32, end: i32) -> Self {524 Self { start, end }525 }526 fn range(&self) -> RangeIter {527 RangeIter {528 start: self.start,529 end: self.end,530 }531 }532}533534type RangeArrayIter<'t> = impl DoubleEndedIterator<Item = Result<Val>> + ExactSizeIterator + 't;535type RangeArrayLazyIter<'t> = impl DoubleEndedIterator<Item = Thunk<Val>> + ExactSizeIterator + 't;536type RangeArrayCheapIter<'t> = impl DoubleEndedIterator<Item = Val> + ExactSizeIterator + 't;537impl ArrayLike for RangeArray {538 type Iter<'t> = RangeArrayIter<'t>;539540 type IterLazy<'t> = RangeArrayLazyIter<'t>;541542 type IterCheap<'t> = RangeArrayCheapIter<'t>;543544 fn len(&self) -> usize {545 self.range().len()546 }547 fn is_empty(&self) -> bool {548 self.range().finished()549 }550551 fn get(&self, index: usize) -> Result<Option<Val>> {552 Ok(self.get_cheap(index))553 }554555 fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {556 self.get_cheap(index).map(Thunk::evaluated)557 }558559 fn get_cheap(&self, index: usize) -> Option<Val> {560 self.range().nth(index).map(|i| Val::Num(f64::from(i)))561 }562563 fn evaluated(&self) -> Result<Vec<Val>> {564 Ok(self.range().map(|i| Val::Num(f64::from(i))).collect())565 }566567 fn iter(&self) -> RangeArrayIter<'_> {568 self.range().map(|i| Ok(Val::Num(f64::from(i))))569 }570571 fn iter_lazy(&self) -> RangeArrayLazyIter<'_> {572 self.range()573 .map(|i| Thunk::evaluated(Val::Num(f64::from(i))))574 }575576 fn iter_cheap(&self) -> Option<RangeArrayCheapIter<'_>> {577 Some(self.range().map(|i| Val::Num(f64::from(i))))578 }579}580581#[derive(Debug, Trace, Clone)]582pub struct ReverseArray(pub ArrValue);583impl ArrayLike for ReverseArray {584 type Iter<'t> = Rev<UnknownArrayIter<'t>>;585586 type IterLazy<'t> = Rev<UnknownArrayIterLazy<'t>>;587588 type IterCheap<'t> = Rev<UnknownArrayIterCheap<'t>>;589590 fn len(&self) -> usize {591 self.0.len()592 }593594 fn get(&self, index: usize) -> Result<Option<Val>> {595 self.0.get(self.0.len() - index - 1)596 }597598 fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {599 self.0.get_lazy(self.0.len() - index - 1)600 }601602 fn get_cheap(&self, index: usize) -> Option<Val> {603 self.0.get_cheap(self.0.len() - index - 1)604 }605606 fn evaluated(&self) -> Result<Vec<Val>> {607 let mut v = self.0.evaluated()?;608 v.reverse();609 Ok(v)610 }611612 fn iter(&self) -> Rev<UnknownArrayIter<'_>> {613 self.0.iter().rev()614 }615616 fn iter_lazy(&self) -> Rev<UnknownArrayIterLazy<'_>> {617 self.0.iter_lazy().rev()618 }619620 fn iter_cheap(&self) -> Option<Rev<UnknownArrayIterCheap<'_>>> {621 Some(self.0.iter_cheap()?.rev())622 }623}624625#[derive(Trace, Debug)]626pub struct MappedArrayInner {627 inner: ArrValue,628 cached: RefCell<Vec<ArrayThunk<()>>>,629 mapper: FuncVal,630}631#[derive(Trace, Debug, Clone)]632pub struct MappedArray(Cc<MappedArrayInner>);633impl MappedArray {634 pub fn new(inner: ArrValue, mapper: FuncVal) -> Self {635 let len = inner.len();636 Self(Cc::new(MappedArrayInner {637 inner,638 cached: RefCell::new(vec![ArrayThunk::Waiting(()); len]),639 mapper,640 }))641 }642}643type MappedArrayIter<'t> = impl DoubleEndedIterator<Item = Result<Val>> + ExactSizeIterator + 't;644type MappedArrayLazyIter<'t> = impl DoubleEndedIterator<Item = Thunk<Val>> + ExactSizeIterator + 't;645type MappedArrayCheapIter<'t> = iter::Empty<Val>;646impl ArrayLike for MappedArray {647 type Iter<'t> = MappedArrayIter<'t>;648 type IterLazy<'t> = MappedArrayLazyIter<'t>;649 type IterCheap<'t> = MappedArrayCheapIter<'t>;650651 fn len(&self) -> usize {652 self.0.cached.borrow().len()653 }654655 fn get(&self, index: usize) -> Result<Option<Val>> {656 if index >= self.len() {657 return Ok(None);658 }659 match &self.0.cached.borrow()[index] {660 ArrayThunk::Computed(c) => return Ok(Some(c.clone())),661 ArrayThunk::Errored(e) => return Err(e.clone()),662 ArrayThunk::Pending => return Err(InfiniteRecursionDetected.into()),663 ArrayThunk::Waiting(..) => {}664 };665666 let ArrayThunk::Waiting(_) = replace(&mut self.0.cached.borrow_mut()[index], ArrayThunk::Pending) else {667 unreachable!()668 };669670 let val = self671 .0672 .inner673 .get(index)674 .transpose()675 .expect("index checked")676 .and_then(|r| self.0.mapper.evaluate_simple(&(Any(r),)));677678 let new_value = match val {679 Ok(v) => v,680 Err(e) => {681 self.0.cached.borrow_mut()[index] = ArrayThunk::Errored(e.clone());682 return Err(e);683 }684 };685 self.0.cached.borrow_mut()[index] = ArrayThunk::Computed(new_value.clone());686 Ok(Some(new_value))687 }688 fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {689 #[derive(Trace)]690 struct ArrayElement {691 arr_thunk: MappedArray,692 index: usize,693 }694695 impl ThunkValue for ArrayElement {696 type Output = Val;697698 fn get(self: Box<Self>) -> Result<Self::Output> {699 self.arr_thunk700 .get(self.index)701 .transpose()702 .expect("index checked")703 }704 }705706 if index >= self.len() {707 return None;708 }709 match &self.0.cached.borrow()[index] {710 ArrayThunk::Computed(c) => return Some(Thunk::evaluated(c.clone())),711 ArrayThunk::Errored(e) => return Some(Thunk::errored(e.clone())),712 ArrayThunk::Waiting(_) | ArrayThunk::Pending => {}713 };714715 Some(Thunk::new(tb!(ArrayElement {716 arr_thunk: self.clone(),717 index,718 })))719 }720721 fn get_cheap(&self, _index: usize) -> Option<Val> {722 None723 }724725 fn evaluated(&self) -> Result<Vec<Val>> {726 self.iter().collect()727 }728729 fn iter(&self) -> MappedArrayIter<'_> {730 (0..self.len()).map(|i| self.get(i).transpose().expect("length checked"))731 }732733 fn iter_lazy(&self) -> MappedArrayLazyIter<'_> {734 (0..self.len()).map(|i| self.get_lazy(i).expect("length checked"))735 }736737 fn iter_cheap(&self) -> Option<Self::IterCheap<'_>> {738 None739 }740}741742743#[derive(Trace, Debug)]744pub struct RepeatedArrayInner {745 data: ArrValue,746 repeats: usize,747 total_len: usize,748}749#[derive(Trace, Debug, Clone)]750pub struct RepeatedArray(Cc<RepeatedArrayInner>);751impl RepeatedArray {752 pub fn new(data: ArrValue, repeats: usize) -> Option<Self> {753 let total_len = data.len().checked_mul(repeats)?;754 Some(Self(Cc::new(RepeatedArrayInner {755 data,756 repeats,757 total_len,758 })))759 }760 pub fn is_cheap(&self) -> bool {761 self.0.data.is_cheap()762 }763}764765type RepeatedArrayIter<'t> = impl DoubleEndedIterator<Item = Result<Val>> + ExactSizeIterator + 't;766type RepeatedArrayLazyIter<'t> =767 impl DoubleEndedIterator<Item = Thunk<Val>> + ExactSizeIterator + 't;768type RepeatedArrayCheapIter<'t> = impl DoubleEndedIterator<Item = Val> + ExactSizeIterator + 't;769impl ArrayLike for RepeatedArray {770 type Iter<'t> = RepeatedArrayIter<'t>;771 type IterLazy<'t> = RepeatedArrayLazyIter<'t>;772 type IterCheap<'t> = RepeatedArrayCheapIter<'t>;773774 fn len(&self) -> usize {775 self.0.total_len776 }777778 fn get(&self, index: usize) -> Result<Option<Val>> {779 if index > self.0.total_len {780 return Ok(None);781 }782 self.0.data.get(index % self.0.data.len())783 }784785 fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {786 if index > self.0.total_len {787 return None;788 }789 self.0.data.get_lazy(index % self.0.data.len())790 }791792 fn get_cheap(&self, index: usize) -> Option<Val> {793 if index > self.0.total_len {794 return None;795 }796 self.0.data.get_cheap(index % self.0.data.len())797 }798799 fn evaluated(&self) -> Result<Vec<Val>> {800 let mut data = self.0.data.evaluated()?;801 let data_range = 0..data.len();802 for _ in 1..self.0.repeats {803 data.extend_from_within(data_range.clone());804 }805 Ok(data)806 }807808 fn iter(&self) -> RepeatedArrayIter<'_> {809 (0..self.0.total_len)810 .map(|i| self.get(i))811 .map(Result::transpose)812 .map(Option::unwrap)813 }814815 fn iter_lazy(&self) -> RepeatedArrayLazyIter<'_> {816 (0..self.0.total_len)817 .map(|i| self.get_lazy(i))818 .map(Option::unwrap)819 }820821 fn iter_cheap(&self) -> Option<RepeatedArrayCheapIter<'_>> {822 if !self.0.data.is_cheap() {823 return None;824 }825 Some(826 (0..self.0.total_len)827 .map(|i| self.get_cheap(i))828 .map(Option::unwrap),829 )830 }831}832833macro_rules! impl_iter_enum {834 ($n:ident => $v:ident) => {835 pub enum $n<'t> {836 Bytes(<BytesArray as ArrayLike>::$v<'t>),837 Expr(<ExprArray as ArrayLike>::$v<'t>),838 Lazy(<LazyArray as ArrayLike>::$v<'t>),839 Eager(<EagerArray as ArrayLike>::$v<'t>),840 Range(<RangeArray as ArrayLike>::$v<'t>),841 Slice(Box<<SliceArray as ArrayLike>::$v<'t>>),842 Extended(Box<<ExtendedArray as ArrayLike>::$v<'t>>),843 Reverse(Box<<ReverseArray as ArrayLike>::$v<'t>>),844 Mapped(Box<<MappedArray as ArrayLike>::$v<'t>>),845 Repeated(Box<<RepeatedArray as ArrayLike>::$v<'t>>),846 }847 };848}849850macro_rules! pass {851 ($t:ident.$m:ident($($ident:ident),*)) => {852 match $t {853 Self::Bytes(e) => e.$m($($ident)*),854 Self::Expr(e) => e.$m($($ident)*),855 Self::Lazy(e) => e.$m($($ident)*),856 Self::Eager(e) => e.$m($($ident)*),857 Self::Range(e) => e.$m($($ident)*),858 Self::Slice(e) => e.$m($($ident)*),859 Self::Extended(e) => e.$m($($ident)*),860 Self::Reverse(e) => e.$m($($ident)*),861 Self::Mapped(e) => e.$m($($ident)*),862 Self::Repeated(e) => e.$m($($ident)*),863 }864 };865}866pub(super) use pass;867868macro_rules! pass_iter_call {869 ($t:ident.$c:ident $(in $wrap:ident)? => $e:ident) => {870 match $t {871 ArrValue::Bytes(e) => $e::Bytes($($wrap!)?(e.$c())),872 ArrValue::Lazy(e) => $e::Lazy($($wrap!)?(e.$c())),873 ArrValue::Expr(e) => $e::Expr($($wrap!)?(e.$c())),874 ArrValue::Eager(e) => $e::Eager($($wrap!)?(e.$c())),875 ArrValue::Range(e) => $e::Range($($wrap!)?(e.$c())),876 ArrValue::Slice(e) => $e::Slice(Box::new($($wrap!)?(e.$c()))),877 ArrValue::Extended(e) => $e::Extended(Box::new($($wrap!)?(e.$c()))),878 ArrValue::Reverse(e) => $e::Reverse(Box::new($($wrap!)?(e.$c()))),879 ArrValue::Mapped(e) => $e::Mapped(Box::new($($wrap!)?(e.$c()))),880 ArrValue::Repeated(e) => $e::Repeated(Box::new($($wrap!)?(e.$c()))),881 }882 };883}884pub(super) use pass_iter_call;885886macro_rules! impl_iter {887 ($t:ident => $out:ty) => {888 impl Iterator for $t<'_> {889 type Item = $out;890891 fn next(&mut self) -> Option<Self::Item> {892 pass!(self.next())893 }894 fn nth(&mut self, count: usize) -> Option<Self::Item> {895 pass!(self.nth(count))896 }897 fn size_hint(&self) -> (usize, Option<usize>) {898 pass!(self.size_hint())899 }900 }901 impl DoubleEndedIterator for $t<'_> {902 fn next_back(&mut self) -> Option<Self::Item> {903 pass!(self.next_back())904 }905 fn nth_back(&mut self, count: usize) -> Option<Self::Item> {906 pass!(self.nth_back(count))907 }908 }909 impl ExactSizeIterator for $t<'_> {910 fn len(&self) -> usize {911 match self {912 Self::Bytes(e) => e.len(),913 Self::Expr(e) => e.len(),914 Self::Lazy(e) => e.len(),915 Self::Eager(e) => e.len(),916 Self::Range(e) => e.len(),917 Self::Slice(e) => e.len(),918 Self::Extended(e) => {919 e.size_hint().1.expect("overflow is checked in constructor")920 }921 Self::Reverse(e) => e.len(),922 Self::Mapped(e) => e.len(),923 Self::Repeated(e) => e.len(),924 }925 }926 }927 };928}929930impl_iter_enum!(UnknownArrayIter => Iter);931impl_iter_enum!(UnknownArrayIterLazy => IterLazy);932impl_iter_enum!(UnknownArrayIterCheap => IterCheap);933impl_iter!(UnknownArrayIter => Result<Val>);934impl_iter!(UnknownArrayIterLazy => Thunk<Val>);935impl_iter!(UnknownArrayIterCheap => Val);