1use std::{any::Any, cell::RefCell, fmt::Debug, iter, mem::replace};23use jrsonnet_gcmodule::{Cc, Trace};4use jrsonnet_interner::{IBytes, IStr};5use jrsonnet_parser::LocExpr;67use super::ArrValue;8use crate::{9 error::ErrorKind::InfiniteRecursionDetected,10 evaluate,11 function::FuncVal,12 val::{StrValue, ThunkValue},13 Context, Error, Result, Thunk, Val,14};1516pub trait ArrayLike: Any + Trace + Debug {17 fn len(&self) -> usize;18 fn is_empty(&self) -> bool {19 self.len() == 020 }21 fn get(&self, index: usize) -> Result<Option<Val>>;22 fn get_lazy(&self, index: usize) -> Option<Thunk<Val>>;23 fn get_cheap(&self, index: usize) -> Option<Val>;2425 fn is_cheap(&self) -> bool;26}2728#[derive(Debug, Trace)]29pub struct SliceArray {30 pub(crate) inner: ArrValue,31 pub(crate) from: u32,32 pub(crate) to: u32,33 pub(crate) step: u32,34}3536impl SliceArray {37 fn iter(&self) -> impl Iterator<Item = Result<Val>> + '_ {38 self.inner39 .iter()40 .skip(self.from as usize)41 .take((self.to - self.from) as usize)42 .step_by(self.step as usize)43 }4445 fn iter_lazy(&self) -> impl Iterator<Item = Thunk<Val>> + '_ {46 self.inner47 .iter_lazy()48 .skip(self.from as usize)49 .take((self.to - self.from) as usize)50 .step_by(self.step as usize)51 }5253 fn iter_cheap(&self) -> Option<impl crate::arr::ArrayLikeIter<Val> + '_> {54 Some(55 self.inner56 .iter_cheap()?57 .skip(self.from as usize)58 .take((self.to - self.from) as usize)59 .step_by(self.step as usize),60 )61 }62}63impl ArrayLike for SliceArray {64 fn len(&self) -> usize {65 iter::repeat(())66 .take((self.to - self.from) as usize)67 .step_by(self.step as usize)68 .count()69 }7071 fn get(&self, index: usize) -> Result<Option<Val>> {72 self.iter().nth(index).transpose()73 }7475 fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {76 self.iter_lazy().nth(index)77 }7879 fn get_cheap(&self, index: usize) -> Option<Val> {80 self.iter_cheap()?.nth(index)81 }82 fn is_cheap(&self) -> bool {83 self.inner.is_cheap()84 }85}8687#[derive(Trace, Debug)]88pub struct CharArray(pub Vec<char>);89impl ArrayLike for CharArray {90 fn len(&self) -> usize {91 self.0.len()92 }9394 fn get(&self, index: usize) -> Result<Option<Val>> {95 Ok(self.get_cheap(index))96 }9798 fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {99 self.get_cheap(index).map(Thunk::evaluated)100 }101102 fn get_cheap(&self, index: usize) -> Option<Val> {103 self.0104 .get(index)105 .map(|v| Val::Str(StrValue::Flat(IStr::from(*v))))106 }107 fn is_cheap(&self) -> bool {108 true109 }110}111112#[derive(Trace, Debug)]113pub struct BytesArray(pub IBytes);114impl ArrayLike for BytesArray {115 fn len(&self) -> usize {116 self.0.len()117 }118119 fn get(&self, index: usize) -> Result<Option<Val>> {120 Ok(self.get_cheap(index))121 }122123 fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {124 self.get_cheap(index).map(Thunk::evaluated)125 }126127 fn get_cheap(&self, index: usize) -> Option<Val> {128 self.0.get(index).map(|v| Val::Num(f64::from(*v)))129 }130 fn is_cheap(&self) -> bool {131 true132 }133}134135#[derive(Debug, Trace, Clone)]136enum ArrayThunk<T: 'static + Trace> {137 Computed(Val),138 Errored(Error),139 Waiting(T),140 Pending,141}142143#[derive(Debug, Trace, Clone)]144pub struct ExprArray {145 ctx: Context,146 cached: Cc<RefCell<Vec<ArrayThunk<LocExpr>>>>,147}148impl ExprArray {149 pub fn new(ctx: Context, items: impl IntoIterator<Item = LocExpr>) -> Self {150 Self {151 ctx,152 cached: Cc::new(RefCell::new(153 items.into_iter().map(ArrayThunk::Waiting).collect(),154 )),155 }156 }157}158impl ArrayLike for ExprArray {159 fn len(&self) -> usize {160 self.cached.borrow().len()161 }162 fn get(&self, index: usize) -> Result<Option<Val>> {163 if index >= self.len() {164 return Ok(None);165 }166 match &self.cached.borrow()[index] {167 ArrayThunk::Computed(c) => return Ok(Some(c.clone())),168 ArrayThunk::Errored(e) => return Err(e.clone()),169 ArrayThunk::Pending => return Err(InfiniteRecursionDetected.into()),170 ArrayThunk::Waiting(..) => {}171 };172173 let ArrayThunk::Waiting(expr) =174 replace(&mut self.cached.borrow_mut()[index], ArrayThunk::Pending)175 else {176 unreachable!()177 };178179 let new_value = match evaluate(self.ctx.clone(), &expr) {180 Ok(v) => v,181 Err(e) => {182 self.cached.borrow_mut()[index] = ArrayThunk::Errored(e.clone());183 return Err(e);184 }185 };186 self.cached.borrow_mut()[index] = ArrayThunk::Computed(new_value.clone());187 Ok(Some(new_value))188 }189 fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {190 #[derive(Trace)]191 struct ArrayElement {192 arr_thunk: ExprArray,193 index: usize,194 }195196 impl ThunkValue for ArrayElement {197 type Output = Val;198199 fn get(self: Box<Self>) -> Result<Self::Output> {200 self.arr_thunk201 .get(self.index)202 .transpose()203 .expect("index checked")204 }205 }206207 if index >= self.len() {208 return None;209 }210 match &self.cached.borrow()[index] {211 ArrayThunk::Computed(c) => return Some(Thunk::evaluated(c.clone())),212 ArrayThunk::Errored(e) => return Some(Thunk::errored(e.clone())),213 ArrayThunk::Waiting(_) | ArrayThunk::Pending => {}214 };215216 Some(Thunk::new(ArrayElement {217 arr_thunk: self.clone(),218 index,219 }))220 }221 fn get_cheap(&self, _index: usize) -> Option<Val> {222 None223 }224 fn is_cheap(&self) -> bool {225 false226 }227}228229#[derive(Trace, Debug)]230pub struct ExtendedArray {231 pub a: ArrValue,232 pub b: ArrValue,233 split: usize,234 len: usize,235}236impl ExtendedArray {237 pub fn new(a: ArrValue, b: ArrValue) -> Self {238 let a_len = a.len();239 let b_len = b.len();240 Self {241 a,242 b,243 split: a_len,244 len: a_len.checked_add(b_len).expect("too large array value"),245 }246 }247}248249struct WithExactSize<I>(I, usize);250impl<I, T> Iterator for WithExactSize<I>251where252 I: Iterator<Item = T>,253{254 type Item = T;255256 fn next(&mut self) -> Option<Self::Item> {257 self.0.next()258 }259 fn nth(&mut self, n: usize) -> Option<Self::Item> {260 self.0.nth(n)261 }262 fn size_hint(&self) -> (usize, Option<usize>) {263 (self.1, Some(self.1))264 }265}266impl<I> DoubleEndedIterator for WithExactSize<I>267where268 I: DoubleEndedIterator,269{270 fn next_back(&mut self) -> Option<Self::Item> {271 self.0.next_back()272 }273 fn nth_back(&mut self, n: usize) -> Option<Self::Item> {274 self.0.nth_back(n)275 }276}277impl<I> ExactSizeIterator for WithExactSize<I>278where279 I: Iterator,280{281 fn len(&self) -> usize {282 self.1283 }284}285impl ArrayLike for ExtendedArray {286 fn get(&self, index: usize) -> Result<Option<Val>> {287 if self.split > index {288 self.a.get(index)289 } else {290 self.b.get(index - self.split)291 }292 }293 fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {294 if self.split > index {295 self.a.get_lazy(index)296 } else {297 self.b.get_lazy(index - self.split)298 }299 }300301 fn len(&self) -> usize {302 self.len303 }304305 fn get_cheap(&self, index: usize) -> Option<Val> {306 if self.split > index {307 self.a.get_cheap(index)308 } else {309 self.b.get_cheap(index - self.split)310 }311 }312 fn is_cheap(&self) -> bool {313 self.a.is_cheap() && self.b.is_cheap()314 }315}316317#[derive(Trace, Debug)]318pub struct LazyArray(pub Vec<Thunk<Val>>);319impl ArrayLike for LazyArray {320 fn len(&self) -> usize {321 self.0.len()322 }323 fn get(&self, index: usize) -> Result<Option<Val>> {324 let Some(v) = self.0.get(index) else {325 return Ok(None);326 };327 v.evaluate().map(Some)328 }329 fn get_cheap(&self, _index: usize) -> Option<Val> {330 None331 }332 fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {333 self.0.get(index).cloned()334 }335 fn is_cheap(&self) -> bool {336 false337 }338}339340#[derive(Trace, Debug)]341pub struct EagerArray(pub Vec<Val>);342impl ArrayLike for EagerArray {343 fn len(&self) -> usize {344 self.0.len()345 }346347 fn get(&self, index: usize) -> Result<Option<Val>> {348 Ok(self.0.get(index).cloned())349 }350351 fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {352 self.0.get(index).cloned().map(Thunk::evaluated)353 }354355 fn get_cheap(&self, index: usize) -> Option<Val> {356 self.0.get(index).cloned()357 }358 fn is_cheap(&self) -> bool {359 true360 }361}362363364#[derive(Debug, Trace, PartialEq, Eq)]365pub struct RangeArray {366 start: i32,367 end: i32,368}369impl RangeArray {370 pub fn empty() -> Self {371 Self::new_exclusive(0, 0)372 }373 pub fn new_exclusive(start: i32, end: i32) -> Self {374 end.checked_sub(1)375 .map_or_else(Self::empty, |end| Self { start, end })376 }377 pub fn new_inclusive(start: i32, end: i32) -> Self {378 Self { start, end }379 }380 fn range(&self) -> impl Iterator<Item = i32> + ExactSizeIterator + DoubleEndedIterator {381 WithExactSize(382 self.start..=self.end,383 (self.end as usize)384 .wrapping_sub(self.start as usize)385 .wrapping_add(1),386 )387 }388}389390impl ArrayLike for RangeArray {391 fn len(&self) -> usize {392 self.range().len()393 }394 fn is_empty(&self) -> bool {395 self.range().len() == 0396 }397398 fn get(&self, index: usize) -> Result<Option<Val>> {399 Ok(self.get_cheap(index))400 }401402 fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {403 self.get_cheap(index).map(Thunk::evaluated)404 }405406 fn get_cheap(&self, index: usize) -> Option<Val> {407 self.range().nth(index).map(|i| Val::Num(f64::from(i)))408 }409 fn is_cheap(&self) -> bool {410 true411 }412}413414#[derive(Debug, Trace)]415pub struct ReverseArray(pub ArrValue);416impl ArrayLike for ReverseArray {417 fn len(&self) -> usize {418 self.0.len()419 }420421 fn get(&self, index: usize) -> Result<Option<Val>> {422 self.0.get(self.0.len() - index - 1)423 }424425 fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {426 self.0.get_lazy(self.0.len() - index - 1)427 }428429 fn get_cheap(&self, index: usize) -> Option<Val> {430 self.0.get_cheap(self.0.len() - index - 1)431 }432 fn is_cheap(&self) -> bool {433 self.0.is_cheap()434 }435}436437#[derive(Trace, Debug, Clone)]438pub struct MappedArray {439 inner: ArrValue,440 cached: Cc<RefCell<Vec<ArrayThunk<()>>>>,441 mapper: FuncVal,442}443impl MappedArray {444 pub fn new(inner: ArrValue, mapper: FuncVal) -> Self {445 let len = inner.len();446 Self {447 inner,448 cached: Cc::new(RefCell::new(vec![ArrayThunk::Waiting(()); len])),449 mapper,450 }451 }452}453impl ArrayLike for MappedArray {454 fn len(&self) -> usize {455 self.cached.borrow().len()456 }457458 fn get(&self, index: usize) -> Result<Option<Val>> {459 if index >= self.len() {460 return Ok(None);461 }462 match &self.cached.borrow()[index] {463 ArrayThunk::Computed(c) => return Ok(Some(c.clone())),464 ArrayThunk::Errored(e) => return Err(e.clone()),465 ArrayThunk::Pending => return Err(InfiniteRecursionDetected.into()),466 ArrayThunk::Waiting(..) => {}467 };468469 let ArrayThunk::Waiting(_) =470 replace(&mut self.cached.borrow_mut()[index], ArrayThunk::Pending)471 else {472 unreachable!()473 };474475 let val = self476 .inner477 .get(index)478 .transpose()479 .expect("index checked")480 .and_then(|r| self.mapper.evaluate_simple(&(r,), false));481482 let new_value = match val {483 Ok(v) => v,484 Err(e) => {485 self.cached.borrow_mut()[index] = ArrayThunk::Errored(e.clone());486 return Err(e);487 }488 };489 self.cached.borrow_mut()[index] = ArrayThunk::Computed(new_value.clone());490 Ok(Some(new_value))491 }492 fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {493 #[derive(Trace)]494 struct ArrayElement {495 arr_thunk: MappedArray,496 index: usize,497 }498499 impl ThunkValue for ArrayElement {500 type Output = Val;501502 fn get(self: Box<Self>) -> Result<Self::Output> {503 self.arr_thunk504 .get(self.index)505 .transpose()506 .expect("index checked")507 }508 }509510 if index >= self.len() {511 return None;512 }513 match &self.cached.borrow()[index] {514 ArrayThunk::Computed(c) => return Some(Thunk::evaluated(c.clone())),515 ArrayThunk::Errored(e) => return Some(Thunk::errored(e.clone())),516 ArrayThunk::Waiting(_) | ArrayThunk::Pending => {}517 };518519 Some(Thunk::new(ArrayElement {520 arr_thunk: self.clone(),521 index,522 }))523 }524525 fn get_cheap(&self, _index: usize) -> Option<Val> {526 None527 }528 fn is_cheap(&self) -> bool {529 false530 }531}532533#[derive(Trace, Debug)]534pub struct RepeatedArray {535 data: ArrValue,536 repeats: usize,537 total_len: usize,538}539impl RepeatedArray {540 pub fn new(data: ArrValue, repeats: usize) -> Option<Self> {541 let total_len = data.len().checked_mul(repeats)?;542 Some(Self {543 data,544 repeats,545 total_len,546 })547 }548}549550impl ArrayLike for RepeatedArray {551 fn len(&self) -> usize {552 self.total_len553 }554555 fn get(&self, index: usize) -> Result<Option<Val>> {556 if index > self.total_len {557 return Ok(None);558 }559 self.data.get(index % self.data.len())560 }561562 fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {563 if index > self.total_len {564 return None;565 }566 self.data.get_lazy(index % self.data.len())567 }568569 fn get_cheap(&self, index: usize) -> Option<Val> {570 if index > self.total_len {571 return None;572 }573 self.data.get_cheap(index % self.data.len())574 }575 fn is_cheap(&self) -> bool {576 self.data.is_cheap()577 }578}