1234use std::{cell::RefCell, iter, mem::replace, rc::Rc};56use jrsonnet_gcmodule::{Cc, Trace};7use jrsonnet_interner::{IBytes, IStr};8use jrsonnet_parser::LocExpr;910use super::ArrValue;11use crate::{12 error::ErrorKind::InfiniteRecursionDetected,13 evaluate,14 function::FuncVal,15 val::{StrValue, ThunkValue},16 Context, Error, Result, Thunk, Val,17};1819pub 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;34 fn is_empty(&self) -> bool {35 self.len() == 036 }37 fn get(&self, index: usize) -> Result<Option<Val>>;38 fn get_lazy(&self, index: usize) -> Option<Thunk<Val>>;39 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<'_>>;4748 fn reverse(self) -> ArrValue {49 ArrValue::Reverse(Cc::new(ReverseArray(self.into())))50 }51}5253#[derive(Debug, Clone, Trace)]54pub struct SliceArray {55 pub(crate) inner: ArrValue,56 pub(crate) from: u32,57 pub(crate) to: u32,58 pub(crate) step: u32,59}6061impl SliceArray {62 #[cfg(not(feature = "nightly"))]63 fn iter(&self) -> impl Iterator<Item = Result<Val>> + '_ {64 self.inner65 .iter()66 .skip(self.from as usize)67 .take((self.to - self.from) as usize)68 .step_by(self.step as usize)69 }7071 #[cfg(not(feature = "nightly"))]72 fn iter_lazy(&self) -> impl Iterator<Item = Thunk<Val>> + '_ {73 self.inner74 .iter_lazy()75 .skip(self.from as usize)76 .take((self.to - self.from) as usize)77 .step_by(self.step as usize)78 }7980 #[cfg(not(feature = "nightly"))]81 fn iter_cheap(&self) -> Option<impl crate::arr::ArrayLikeIter<Val> + '_> {82 Some(83 self.inner84 .iter_cheap()?85 .skip(self.from as usize)86 .take((self.to - self.from) as usize)87 .step_by(self.step as usize),88 )89 }90}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 {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 {106 iter::repeat(())107 .take((self.to - self.from) as usize)108 .step_by(self.step as usize)109 .count()110 }111112 fn get(&self, index: usize) -> Result<Option<Val>> {113 self.iter().nth(index).transpose()114 }115116 fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {117 self.iter_lazy().nth(index)118 }119120 fn get_cheap(&self, index: usize) -> Option<Val> {121 self.iter_cheap()?.nth(index)122 }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}153impl From<SliceArray> for ArrValue {154 fn from(value: SliceArray) -> Self {155 Self::Slice(Cc::new(value))156 }157}158159#[derive(Trace, Debug, Clone)]160pub 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 {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 {176 self.0.len()177 }178179 fn get(&self, index: usize) -> Result<Option<Val>> {180 Ok(self.get_cheap(index))181 }182183 fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {184 self.get_cheap(index).map(Thunk::evaluated)185 }186187 fn get_cheap(&self, index: usize) -> Option<Val> {188 self.0189 .get(index)190 .map(|v| Val::Str(StrValue::Flat(IStr::from(*v))))191 }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}216impl From<CharArray> for ArrValue {217 fn from(value: CharArray) -> Self {218 ArrValue::Chars(value)219 }220}221222#[derive(Trace, Debug, Clone)]223pub 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 {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 {239 self.0.len()240 }241242 fn get(&self, index: usize) -> Result<Option<Val>> {243 Ok(self.get_cheap(index))244 }245246 fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {247 self.get_cheap(index).map(Thunk::evaluated)248 }249250 fn get_cheap(&self, index: usize) -> Option<Val> {251 self.0.get(index).map(|v| Val::Num(f64::from(*v)))252 }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}271impl From<BytesArray> for ArrValue {272 fn from(value: BytesArray) -> Self {273 ArrValue::Bytes(value)274 }275}276277#[derive(Debug, Trace, Clone)]278enum ArrayThunk<T: 'static + Trace> {279 Computed(Val),280 Errored(Error),281 Waiting(T),282 Pending,283}284285#[derive(Debug, Trace)]286pub struct ExprArrayInner {287 ctx: Context,288 cached: RefCell<Vec<ArrayThunk<LocExpr>>>,289}290#[derive(Debug, Trace, Clone)]291pub struct ExprArray(pub Cc<ExprArrayInner>);292impl ExprArray {293 pub fn new(ctx: Context, items: impl IntoIterator<Item = LocExpr>) -> Self {294 Self(Cc::new(ExprArrayInner {295 ctx,296 cached: RefCell::new(items.into_iter().map(ArrayThunk::Waiting).collect()),297 }))298 }299}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 {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 {315 self.0.cached.borrow().len()316 }317 fn get(&self, index: usize) -> Result<Option<Val>> {318 if index >= self.len() {319 return Ok(None);320 }321 match &self.0.cached.borrow()[index] {322 ArrayThunk::Computed(c) => return Ok(Some(c.clone())),323 ArrayThunk::Errored(e) => return Err(e.clone()),324 ArrayThunk::Pending => return Err(InfiniteRecursionDetected.into()),325 ArrayThunk::Waiting(..) => {}326 };327328 let ArrayThunk::Waiting(expr) = replace(&mut self.0.cached.borrow_mut()[index], ArrayThunk::Pending) else {329 unreachable!()330 };331332 let new_value = match evaluate(self.0.ctx.clone(), &expr) {333 Ok(v) => v,334 Err(e) => {335 self.0.cached.borrow_mut()[index] = ArrayThunk::Errored(e.clone());336 return Err(e);337 }338 };339 self.0.cached.borrow_mut()[index] = ArrayThunk::Computed(new_value.clone());340 Ok(Some(new_value))341 }342 fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {343 #[derive(Trace)]344 struct ArrayElement {345 arr_thunk: ExprArray,346 index: usize,347 }348349 impl ThunkValue for ArrayElement {350 type Output = Val;351352 fn get(self: Box<Self>) -> Result<Self::Output> {353 self.arr_thunk354 .get(self.index)355 .transpose()356 .expect("index checked")357 }358 }359360 if index >= self.len() {361 return None;362 }363 match &self.0.cached.borrow()[index] {364 ArrayThunk::Computed(c) => return Some(Thunk::evaluated(c.clone())),365 ArrayThunk::Errored(e) => return Some(Thunk::errored(e.clone())),366 ArrayThunk::Waiting(_) | ArrayThunk::Pending => {}367 };368369 Some(Thunk::new(ArrayElement {370 arr_thunk: self.clone(),371 index,372 }))373 }374 fn get_cheap(&self, _index: usize) -> Option<Val> {375 None376 }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}391impl From<ExprArray> for ArrValue {392 fn from(value: ExprArray) -> Self {393 Self::Expr(value)394 }395}396397#[derive(Trace, Debug, Clone)]398pub struct ExtendedArray {399 pub a: ArrValue,400 pub b: ArrValue,401 split: usize,402 len: usize,403}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 {413 pub fn new(a: ArrValue, b: ArrValue) -> Self {414 let a_len = a.len();415 let b_len = b.len();416 Self {417 a,418 b,419 split: a_len,420 len: a_len.checked_add(b_len).expect("too large array value"),421 }422 }423}424425struct WithExactSize<I>(I, usize);426impl<I, T> Iterator for WithExactSize<I>427where428 I: Iterator<Item = T>,429{430 type Item = T;431432 fn next(&mut self) -> Option<Self::Item> {433 self.0.next()434 }435 fn nth(&mut self, n: usize) -> Option<Self::Item> {436 self.0.nth(n)437 }438 fn size_hint(&self) -> (usize, Option<usize>) {439 (self.1, Some(self.1))440 }441}442impl<I> DoubleEndedIterator for WithExactSize<I>443where444 I: DoubleEndedIterator,445{446 fn next_back(&mut self) -> Option<Self::Item> {447 self.0.next_back()448 }449 fn nth_back(&mut self, n: usize) -> Option<Self::Item> {450 self.0.nth_back(n)451 }452}453impl<I> ExactSizeIterator for WithExactSize<I>454where455 I: Iterator,456{457 fn len(&self) -> usize {458 self.1459 }460}461impl 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>> {470 if self.split > index {471 self.a.get(index)472 } else {473 self.b.get(index - self.split)474 }475 }476 fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {477 if self.split > index {478 self.a.get_lazy(index)479 } else {480 self.b.get_lazy(index - self.split)481 }482 }483484 fn len(&self) -> usize {485 self.len486 }487488 fn get_cheap(&self, index: usize) -> Option<Val> {489 if self.split > index {490 self.a.get_cheap(index)491 } else {492 self.b.get_cheap(index - self.split)493 }494 }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}511impl From<ExtendedArray> for ArrValue {512 fn from(value: ExtendedArray) -> Self {513 Self::Extended(Cc::new(value))514 }515}516517#[derive(Trace, Debug, Clone)]518pub 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 {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 {536 self.0.len()537 }538 fn get(&self, index: usize) -> Result<Option<Val>> {539 let Some(v) = self.0.get(index) else {540 return Ok(None);541 };542 v.evaluate().map(Some)543 }544 fn get_cheap(&self, _index: usize) -> Option<Val> {545 None546 }547 fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {548 self.0.get(index).cloned()549 }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}563impl From<LazyArray> for ArrValue {564 fn from(value: LazyArray) -> Self {565 Self::Lazy(value)566 }567}568569#[derive(Trace, Debug, Clone)]570pub 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 {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 {588 self.0.len()589 }590591 fn get(&self, index: usize) -> Result<Option<Val>> {592 Ok(self.0.get(index).cloned())593 }594595 fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {596 self.0.get(index).cloned().map(Thunk::evaluated)597 }598599 fn get_cheap(&self, index: usize) -> Option<Val> {600 self.0.get(index).cloned()601 }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}618impl From<EagerArray> for ArrValue {619 fn from(value: EagerArray) -> Self {620 Self::Eager(value)621 }622}623624625#[derive(Debug, Trace, Clone, PartialEq, Eq)]626pub struct RangeArray {627 start: i32,628 end: i32,629}630impl RangeArray {631 pub fn empty() -> Self {632 Self::new_exclusive(0, 0)633 }634 pub fn new_exclusive(start: i32, end: i32) -> Self {635 end.checked_sub(1)636 .map_or_else(Self::empty, |end| Self { start, end })637 }638 pub fn new_inclusive(start: i32, end: i32) -> Self {639 Self { start, end }640 }641 fn range(&self) -> impl Iterator<Item = i32> + ExactSizeIterator + DoubleEndedIterator {642 WithExactSize(643 self.start..=self.end,644 (self.end as usize)645 .wrapping_sub(self.start as usize)646 .wrapping_add(1),647 )648 }649}650651#[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 {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 {668 self.range().len()669 }670 fn is_empty(&self) -> bool {671 self.range().len() == 0672 }673674 fn get(&self, index: usize) -> Result<Option<Val>> {675 Ok(self.get_cheap(index))676 }677678 fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {679 self.get_cheap(index).map(Thunk::evaluated)680 }681682 fn get_cheap(&self, index: usize) -> Option<Val> {683 self.range().nth(index).map(|i| Val::Num(f64::from(i)))684 }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}702impl From<RangeArray> for ArrValue {703 fn from(value: RangeArray) -> Self {704 Self::Range(value)705 }706}707708#[derive(Debug, Trace, Clone)]709pub struct ReverseArray(pub ArrValue);710impl 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 {721 self.0.len()722 }723724 fn get(&self, index: usize) -> Result<Option<Val>> {725 self.0.get(self.0.len() - index - 1)726 }727728 fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {729 self.0.get_lazy(self.0.len() - index - 1)730 }731732 fn get_cheap(&self, index: usize) -> Option<Val> {733 self.0.get_cheap(self.0.len() - index - 1)734 }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 {751 self.0752 }753}754impl From<ReverseArray> for ArrValue {755 fn from(value: ReverseArray) -> Self {756 Self::Reverse(Cc::new(value))757 }758}759760#[derive(Trace, Debug)]761pub struct MappedArrayInner {762 inner: ArrValue,763 cached: RefCell<Vec<ArrayThunk<()>>>,764 mapper: FuncVal,765}766#[derive(Trace, Debug, Clone)]767pub struct MappedArray(Cc<MappedArrayInner>);768impl MappedArray {769 pub fn new(inner: ArrValue, mapper: FuncVal) -> Self {770 let len = inner.len();771 Self(Cc::new(MappedArrayInner {772 inner,773 cached: RefCell::new(vec![ArrayThunk::Waiting(()); len]),774 mapper,775 }))776 }777}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 {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 {793 self.0.cached.borrow().len()794 }795796 fn get(&self, index: usize) -> Result<Option<Val>> {797 if index >= self.len() {798 return Ok(None);799 }800 match &self.0.cached.borrow()[index] {801 ArrayThunk::Computed(c) => return Ok(Some(c.clone())),802 ArrayThunk::Errored(e) => return Err(e.clone()),803 ArrayThunk::Pending => return Err(InfiniteRecursionDetected.into()),804 ArrayThunk::Waiting(..) => {}805 };806807 let ArrayThunk::Waiting(_) = replace(&mut self.0.cached.borrow_mut()[index], ArrayThunk::Pending) else {808 unreachable!()809 };810811 let val = self812 .0813 .inner814 .get(index)815 .transpose()816 .expect("index checked")817 .and_then(|r| self.0.mapper.evaluate_simple(&(r,), false));818819 let new_value = match val {820 Ok(v) => v,821 Err(e) => {822 self.0.cached.borrow_mut()[index] = ArrayThunk::Errored(e.clone());823 return Err(e);824 }825 };826 self.0.cached.borrow_mut()[index] = ArrayThunk::Computed(new_value.clone());827 Ok(Some(new_value))828 }829 fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {830 #[derive(Trace)]831 struct ArrayElement {832 arr_thunk: MappedArray,833 index: usize,834 }835836 impl ThunkValue for ArrayElement {837 type Output = Val;838839 fn get(self: Box<Self>) -> Result<Self::Output> {840 self.arr_thunk841 .get(self.index)842 .transpose()843 .expect("index checked")844 }845 }846847 if index >= self.len() {848 return None;849 }850 match &self.0.cached.borrow()[index] {851 ArrayThunk::Computed(c) => return Some(Thunk::evaluated(c.clone())),852 ArrayThunk::Errored(e) => return Some(Thunk::errored(e.clone())),853 ArrayThunk::Waiting(_) | ArrayThunk::Pending => {}854 };855856 Some(Thunk::new(ArrayElement {857 arr_thunk: self.clone(),858 index,859 }))860 }861862 fn get_cheap(&self, _index: usize) -> Option<Val> {863 None864 }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}881impl From<MappedArray> for ArrValue {882 fn from(value: MappedArray) -> Self {883 Self::Mapped(value)884 }885}886887#[derive(Trace, Debug)]888pub struct RepeatedArrayInner {889 data: ArrValue,890 repeats: usize,891 total_len: usize,892}893#[derive(Trace, Debug, Clone)]894pub struct RepeatedArray(Cc<RepeatedArrayInner>);895impl RepeatedArray {896 pub fn new(data: ArrValue, repeats: usize) -> Option<Self> {897 let total_len = data.len().checked_mul(repeats)?;898 Some(Self(Cc::new(RepeatedArrayInner {899 data,900 repeats,901 total_len,902 })))903 }904 pub fn is_cheap(&self) -> bool {905 self.0.data.is_cheap()906 }907}908909#[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 {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 {925 self.0.total_len926 }927928 fn get(&self, index: usize) -> Result<Option<Val>> {929 if index > self.0.total_len {930 return Ok(None);931 }932 self.0.data.get(index % self.0.data.len())933 }934935 fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {936 if index > self.0.total_len {937 return None;938 }939 self.0.data.get_lazy(index % self.0.data.len())940 }941942 fn get_cheap(&self, index: usize) -> Option<Val> {943 if index > self.0.total_len {944 return None;945 }946 self.0.data.get_cheap(index % self.0.data.len())947 }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}976impl From<RepeatedArray> for ArrValue {977 fn from(value: RepeatedArray) -> Self {978 Self::Repeated(value)979 }980}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}9991000macro_rules! pass {1001 ($t:ident.$m:ident($($ident:ident),*)) => {1002 match $t {1003 Self::Bytes(e) => e.$m($($ident)*),1004 Self::Chars(e) => e.$m($($ident)*),1005 Self::Expr(e) => e.$m($($ident)*),1006 Self::Lazy(e) => e.$m($($ident)*),1007 Self::Eager(e) => e.$m($($ident)*),1008 Self::Range(e) => e.$m($($ident)*),1009 Self::Slice(e) => e.$m($($ident)*),1010 Self::Extended(e) => e.$m($($ident)*),1011 Self::Reverse(e) => e.$m($($ident)*),1012 Self::Mapped(e) => e.$m($($ident)*),1013 Self::Repeated(e) => e.$m($($ident)*),1014 }1015 };1016}1017pub(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);