difftreelog
feat make std.map accept strings
in: master
5 files changed
crates/jrsonnet-evaluator/src/arr/mod.rsdiffbeforeafterboth--- a/crates/jrsonnet-evaluator/src/arr/mod.rs
+++ b/crates/jrsonnet-evaluator/src/arr/mod.rs
@@ -1,3 +1,5 @@
+use std::rc::Rc;
+
use jrsonnet_gcmodule::{Cc, Trace};
use jrsonnet_interner::IBytes;
use jrsonnet_parser::LocExpr;
@@ -14,6 +16,8 @@
pub enum ArrValue {
/// Layout optimized byte array.
Bytes(BytesArray),
+ /// Layout optimized char array.
+ Chars(CharArray),
/// Every element is lazy evaluated.
Lazy(LazyArray),
/// Every element is defined somewhere in source code
@@ -66,6 +70,9 @@
pub fn bytes(bytes: IBytes) -> Self {
Self::Bytes(BytesArray(bytes))
}
+ pub fn chars(chars: impl Iterator<Item = char>) -> Self {
+ Self::Chars(CharArray(Rc::new(chars.collect())))
+ }
#[must_use]
pub fn map(self, mapper: FuncVal) -> Self {
@@ -237,7 +244,9 @@
/// Is this vec supports `.get_cheap()?`
pub fn is_cheap(&self) -> bool {
match self {
- ArrValue::Eager(_) | ArrValue::Range(..) | ArrValue::Bytes(_) => true,
+ ArrValue::Eager(_) | ArrValue::Range(..) | ArrValue::Bytes(_) | ArrValue::Chars(_) => {
+ true
+ }
ArrValue::Extended(v) => v.a.is_cheap() && v.b.is_cheap(),
ArrValue::Slice(r) => r.inner.is_cheap(),
ArrValue::Reverse(i) => i.0.is_cheap(),
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};56use jrsonnet_gcmodule::{Cc, Trace};7use jrsonnet_interner::IBytes;8use jrsonnet_parser::LocExpr;910use super::ArrValue;11use crate::{12 error::ErrorKind::InfiniteRecursionDetected, evaluate, function::FuncVal, val::ThunkValue,13 Context, Error, Result, Thunk, Val,14};1516pub trait ArrayLike: Sized + Into<ArrValue> {17 #[cfg(feature = "nightly")]18 type Iter<'t>19 where20 Self: 't;21 #[cfg(feature = "nightly")]22 type IterLazy<'t>23 where24 Self: 't;25 #[cfg(feature = "nightly")]26 type IterCheap<'t>27 where28 Self: 't;2930 fn len(&self) -> usize;31 fn is_empty(&self) -> bool {32 self.len() == 033 }34 fn get(&self, index: usize) -> Result<Option<Val>>;35 fn get_lazy(&self, index: usize) -> Option<Thunk<Val>>;36 fn get_cheap(&self, index: usize) -> Option<Val>;37 #[cfg(feature = "nightly")]38 #[allow(clippy::iter_not_returning_iterator)]39 fn iter(&self) -> Self::Iter<'_>;40 #[cfg(feature = "nightly")]41 fn iter_lazy(&self) -> Self::IterLazy<'_>;42 #[cfg(feature = "nightly")]43 fn iter_cheap(&self) -> Option<Self::IterCheap<'_>>;4445 fn reverse(self) -> ArrValue {46 ArrValue::Reverse(Cc::new(ReverseArray(self.into())))47 }48}4950#[derive(Debug, Clone, Trace)]51pub struct SliceArray {52 pub(crate) inner: ArrValue,53 pub(crate) from: u32,54 pub(crate) to: u32,55 pub(crate) step: u32,56}5758impl SliceArray {59 #[cfg(not(feature = "nightly"))]60 fn iter(&self) -> impl Iterator<Item = Result<Val>> + '_ {61 self.inner62 .iter()63 .skip(self.from as usize)64 .take((self.to - self.from) as usize)65 .step_by(self.step as usize)66 }6768 #[cfg(not(feature = "nightly"))]69 fn iter_lazy(&self) -> impl Iterator<Item = Thunk<Val>> + '_ {70 self.inner71 .iter_lazy()72 .skip(self.from as usize)73 .take((self.to - self.from) as usize)74 .step_by(self.step as usize)75 }7677 #[cfg(not(feature = "nightly"))]78 fn iter_cheap(&self) -> Option<impl crate::arr::ArrayLikeIter<Val> + '_> {79 Some(80 self.inner81 .iter_cheap()?82 .skip(self.from as usize)83 .take((self.to - self.from) as usize)84 .step_by(self.step as usize),85 )86 }87}88#[cfg(feature = "nightly")]89type SliceArrayIter<'t> = impl DoubleEndedIterator<Item = Result<Val>> + ExactSizeIterator + 't;90#[cfg(feature = "nightly")]91type SliceArrayLazyIter<'t> = impl DoubleEndedIterator<Item = Thunk<Val>> + ExactSizeIterator + 't;92#[cfg(feature = "nightly")]93type SliceArrayCheapIter<'t> = impl DoubleEndedIterator<Item = Val> + ExactSizeIterator + 't;94impl ArrayLike for SliceArray {95 #[cfg(feature = "nightly")]96 type Iter<'t> = SliceArrayIter<'t>;97 #[cfg(feature = "nightly")]98 type IterLazy<'t> = SliceArrayLazyIter<'t>;99 #[cfg(feature = "nightly")]100 type IterCheap<'t> = SliceArrayCheapIter<'t>;101102 fn len(&self) -> usize {103 iter::repeat(())104 .take((self.to - self.from) as usize)105 .step_by(self.step as usize)106 .count()107 }108109 fn get(&self, index: usize) -> Result<Option<Val>> {110 self.iter().nth(index).transpose()111 }112113 fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {114 self.iter_lazy().nth(index)115 }116117 fn get_cheap(&self, index: usize) -> Option<Val> {118 self.iter_cheap()?.nth(index)119 }120121 #[cfg(feature = "nightly")]122 fn iter(&self) -> SliceArrayIter<'_> {123 self.inner124 .iter()125 .skip(self.from as usize)126 .take((self.to - self.from) as usize)127 .step_by(self.step as usize)128 }129130 #[cfg(feature = "nightly")]131 fn iter_lazy(&self) -> SliceArrayLazyIter<'_> {132 self.inner133 .iter_lazy()134 .skip(self.from as usize)135 .take((self.to - self.from) as usize)136 .step_by(self.step as usize)137 }138139 #[cfg(feature = "nightly")]140 fn iter_cheap(&self) -> Option<SliceArrayCheapIter<'_>> {141 Some(142 self.inner143 .iter_cheap()?144 .skip(self.from as usize)145 .take((self.to - self.from) as usize)146 .step_by(self.step as usize),147 )148 }149}150impl From<SliceArray> for ArrValue {151 fn from(value: SliceArray) -> Self {152 Self::Slice(Cc::new(value))153 }154}155156#[derive(Trace, Debug, Clone)]157pub struct BytesArray(pub IBytes);158#[cfg(feature = "nightly")]159type BytesArrayIter<'t> = impl DoubleEndedIterator<Item = Result<Val>> + ExactSizeIterator + 't;160#[cfg(feature = "nightly")]161type BytesArrayLazyIter<'t> = impl DoubleEndedIterator<Item = Thunk<Val>> + ExactSizeIterator + 't;162#[cfg(feature = "nightly")]163type BytesArrayCheapIter<'t> = impl DoubleEndedIterator<Item = Val> + ExactSizeIterator + 't;164impl ArrayLike for BytesArray {165 #[cfg(feature = "nightly")]166 type Iter<'t> = BytesArrayIter<'t>;167 #[cfg(feature = "nightly")]168 type IterLazy<'t> = BytesArrayLazyIter<'t>;169 #[cfg(feature = "nightly")]170 type IterCheap<'t> = BytesArrayCheapIter<'t>;171172 fn len(&self) -> usize {173 self.0.len()174 }175176 fn get(&self, index: usize) -> Result<Option<Val>> {177 Ok(self.get_cheap(index))178 }179180 fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {181 self.get_cheap(index).map(Thunk::evaluated)182 }183184 fn get_cheap(&self, index: usize) -> Option<Val> {185 self.0.get(index).map(|v| Val::Num(f64::from(*v)))186 }187188 #[cfg(feature = "nightly")]189 fn iter(&self) -> BytesArrayIter<'_> {190 self.0.iter().map(|v| Ok(Val::Num(f64::from(*v))))191 }192193 #[cfg(feature = "nightly")]194 fn iter_lazy(&self) -> BytesArrayLazyIter<'_> {195 self.0196 .iter()197 .map(|v| Thunk::evaluated(Val::Num(f64::from(*v))))198 }199200 #[cfg(feature = "nightly")]201 fn iter_cheap(&self) -> Option<BytesArrayCheapIter<'_>> {202 Some(self.0.iter().map(|v| Val::Num(f64::from(*v))))203 }204}205impl From<BytesArray> for ArrValue {206 fn from(value: BytesArray) -> Self {207 ArrValue::Bytes(value)208 }209}210211#[derive(Debug, Trace, Clone)]212enum ArrayThunk<T: 'static + Trace> {213 Computed(Val),214 Errored(Error),215 Waiting(T),216 Pending,217}218219#[derive(Debug, Trace)]220pub struct ExprArrayInner {221 ctx: Context,222 cached: RefCell<Vec<ArrayThunk<LocExpr>>>,223}224#[derive(Debug, Trace, Clone)]225pub struct ExprArray(pub Cc<ExprArrayInner>);226impl ExprArray {227 pub fn new(ctx: Context, items: impl IntoIterator<Item = LocExpr>) -> Self {228 Self(Cc::new(ExprArrayInner {229 ctx,230 cached: RefCell::new(items.into_iter().map(ArrayThunk::Waiting).collect()),231 }))232 }233}234#[cfg(feature = "nightly")]235type ExprArrayIter<'t> = impl DoubleEndedIterator<Item = Result<Val>> + ExactSizeIterator + 't;236#[cfg(feature = "nightly")]237type ExprArrayLazyIter<'t> = impl DoubleEndedIterator<Item = Thunk<Val>> + ExactSizeIterator + 't;238#[cfg(feature = "nightly")]239type ExprArrayCheapIter<'t> = iter::Empty<Val>;240impl ArrayLike for ExprArray {241 #[cfg(feature = "nightly")]242 type Iter<'t> = ExprArrayIter<'t>;243 #[cfg(feature = "nightly")]244 type IterLazy<'t> = ExprArrayLazyIter<'t>;245 #[cfg(feature = "nightly")]246 type IterCheap<'t> = ExprArrayCheapIter<'t>;247248 fn len(&self) -> usize {249 self.0.cached.borrow().len()250 }251 fn get(&self, index: usize) -> Result<Option<Val>> {252 if index >= self.len() {253 return Ok(None);254 }255 match &self.0.cached.borrow()[index] {256 ArrayThunk::Computed(c) => return Ok(Some(c.clone())),257 ArrayThunk::Errored(e) => return Err(e.clone()),258 ArrayThunk::Pending => return Err(InfiniteRecursionDetected.into()),259 ArrayThunk::Waiting(..) => {}260 };261262 let ArrayThunk::Waiting(expr) = replace(&mut self.0.cached.borrow_mut()[index], ArrayThunk::Pending) else {263 unreachable!()264 };265266 let new_value = match evaluate(self.0.ctx.clone(), &expr) {267 Ok(v) => v,268 Err(e) => {269 self.0.cached.borrow_mut()[index] = ArrayThunk::Errored(e.clone());270 return Err(e);271 }272 };273 self.0.cached.borrow_mut()[index] = ArrayThunk::Computed(new_value.clone());274 Ok(Some(new_value))275 }276 fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {277 #[derive(Trace)]278 struct ArrayElement {279 arr_thunk: ExprArray,280 index: usize,281 }282283 impl ThunkValue for ArrayElement {284 type Output = Val;285286 fn get(self: Box<Self>) -> Result<Self::Output> {287 self.arr_thunk288 .get(self.index)289 .transpose()290 .expect("index checked")291 }292 }293294 if index >= self.len() {295 return None;296 }297 match &self.0.cached.borrow()[index] {298 ArrayThunk::Computed(c) => return Some(Thunk::evaluated(c.clone())),299 ArrayThunk::Errored(e) => return Some(Thunk::errored(e.clone())),300 ArrayThunk::Waiting(_) | ArrayThunk::Pending => {}301 };302303 Some(Thunk::new(ArrayElement {304 arr_thunk: self.clone(),305 index,306 }))307 }308 fn get_cheap(&self, _index: usize) -> Option<Val> {309 None310 }311312 #[cfg(feature = "nightly")]313 fn iter(&self) -> ExprArrayIter<'_> {314 (0..self.len()).map(|i| self.get(i).transpose().expect("index checked"))315 }316 #[cfg(feature = "nightly")]317 fn iter_lazy(&self) -> ExprArrayLazyIter<'_> {318 (0..self.len()).map(|i| self.get_lazy(i).expect("index checked"))319 }320 #[cfg(feature = "nightly")]321 fn iter_cheap(&self) -> Option<Self::IterCheap<'_>> {322 None323 }324}325impl From<ExprArray> for ArrValue {326 fn from(value: ExprArray) -> Self {327 Self::Expr(value)328 }329}330331#[derive(Trace, Debug, Clone)]332pub struct ExtendedArray {333 pub a: ArrValue,334 pub b: ArrValue,335 split: usize,336 len: usize,337}338#[cfg(feature = "nightly")]339340type ExtendedArrayIter<'t> = impl DoubleEndedIterator<Item = Result<Val>> + ExactSizeIterator + 't;341#[cfg(feature = "nightly")]342type ExtendedArrayLazyIter<'t> =343 impl DoubleEndedIterator<Item = Thunk<Val>> + ExactSizeIterator + 't;344#[cfg(feature = "nightly")]345type ExtendedArrayCheapIter<'t> = impl DoubleEndedIterator<Item = Val> + ExactSizeIterator + 't;346impl ExtendedArray {347 pub fn new(a: ArrValue, b: ArrValue) -> Self {348 let a_len = a.len();349 let b_len = b.len();350 Self {351 a,352 b,353 split: a_len,354 len: a_len.checked_add(b_len).expect("too large array value"),355 }356 }357}358359struct WithExactSize<I>(I, usize);360impl<I, T> Iterator for WithExactSize<I>361where362 I: Iterator<Item = T>,363{364 type Item = T;365366 fn next(&mut self) -> Option<Self::Item> {367 self.0.next()368 }369 fn nth(&mut self, n: usize) -> Option<Self::Item> {370 self.0.nth(n)371 }372 fn size_hint(&self) -> (usize, Option<usize>) {373 (self.1, Some(self.1))374 }375}376impl<I> DoubleEndedIterator for WithExactSize<I>377where378 I: DoubleEndedIterator,379{380 fn next_back(&mut self) -> Option<Self::Item> {381 self.0.next_back()382 }383 fn nth_back(&mut self, n: usize) -> Option<Self::Item> {384 self.0.nth_back(n)385 }386}387impl<I> ExactSizeIterator for WithExactSize<I>388where389 I: Iterator,390{391 fn len(&self) -> usize {392 self.1393 }394}395impl ArrayLike for ExtendedArray {396 #[cfg(feature = "nightly")]397 type Iter<'t> = ExtendedArrayIter<'t>;398 #[cfg(feature = "nightly")]399 type IterLazy<'t> = ExtendedArrayLazyIter<'t>;400 #[cfg(feature = "nightly")]401 type IterCheap<'t> = ExtendedArrayCheapIter<'t>;402403 fn get(&self, index: usize) -> Result<Option<Val>> {404 if self.split > index {405 self.a.get(index)406 } else {407 self.b.get(index - self.split)408 }409 }410 fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {411 if self.split > index {412 self.a.get_lazy(index)413 } else {414 self.b.get_lazy(index - self.split)415 }416 }417418 fn len(&self) -> usize {419 self.len420 }421422 fn get_cheap(&self, index: usize) -> Option<Val> {423 if self.split > index {424 self.a.get_cheap(index)425 } else {426 self.b.get_cheap(index - self.split)427 }428 }429430 #[cfg(feature = "nightly")]431 fn iter(&self) -> ExtendedArrayIter<'_> {432 WithExactSize(self.a.iter().chain(self.b.iter()), self.len)433 }434 #[cfg(feature = "nightly")]435 fn iter_lazy(&self) -> ExtendedArrayLazyIter<'_> {436 WithExactSize(self.a.iter_lazy().chain(self.b.iter_lazy()), self.len)437 }438 #[cfg(feature = "nightly")]439 fn iter_cheap(&self) -> Option<ExtendedArrayCheapIter<'_>> {440 let a = self.a.iter_cheap()?;441 let b = self.b.iter_cheap()?;442 Some(WithExactSize(a.chain(b), self.len))443 }444}445impl From<ExtendedArray> for ArrValue {446 fn from(value: ExtendedArray) -> Self {447 Self::Extended(Cc::new(value))448 }449}450451#[derive(Trace, Debug, Clone)]452pub struct LazyArray(pub Cc<Vec<Thunk<Val>>>);453#[cfg(feature = "nightly")]454type LazyArrayIter<'t> = impl DoubleEndedIterator<Item = Result<Val>> + ExactSizeIterator + 't;455#[cfg(feature = "nightly")]456type LazyArrayLazyIter<'t> = impl DoubleEndedIterator<Item = Thunk<Val>> + ExactSizeIterator + 't;457#[cfg(feature = "nightly")]458type LazyArrayCheapIter<'t> = iter::Empty<Val>;459impl ArrayLike for LazyArray {460 #[cfg(feature = "nightly")]461 type Iter<'t> = LazyArrayIter<'t>;462463 #[cfg(feature = "nightly")]464 type IterLazy<'t> = LazyArrayLazyIter<'t>;465466 #[cfg(feature = "nightly")]467 type IterCheap<'t> = LazyArrayCheapIter<'t>;468469 fn len(&self) -> usize {470 self.0.len()471 }472 fn get(&self, index: usize) -> Result<Option<Val>> {473 let Some(v) = self.0.get(index) else {474 return Ok(None);475 };476 v.evaluate().map(Some)477 }478 fn get_cheap(&self, _index: usize) -> Option<Val> {479 None480 }481 fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {482 self.0.get(index).cloned()483 }484 #[cfg(feature = "nightly")]485 fn iter(&self) -> LazyArrayIter<'_> {486 self.0.iter().map(Thunk::evaluate)487 }488 #[cfg(feature = "nightly")]489 fn iter_lazy(&self) -> LazyArrayLazyIter<'_> {490 self.0.iter().cloned()491 }492 #[cfg(feature = "nightly")]493 fn iter_cheap(&self) -> Option<LazyArrayCheapIter<'_>> {494 None495 }496}497impl From<LazyArray> for ArrValue {498 fn from(value: LazyArray) -> Self {499 Self::Lazy(value)500 }501}502503#[derive(Trace, Debug, Clone)]504pub struct EagerArray(pub Cc<Vec<Val>>);505#[cfg(feature = "nightly")]506type EagerArrayIter<'t> = impl DoubleEndedIterator<Item = Result<Val>> + ExactSizeIterator + 't;507#[cfg(feature = "nightly")]508type EagerArrayLazyIter<'t> = impl DoubleEndedIterator<Item = Thunk<Val>> + ExactSizeIterator + 't;509#[cfg(feature = "nightly")]510type EagerArrayCheapIter<'t> = impl DoubleEndedIterator<Item = Val> + ExactSizeIterator + 't;511impl ArrayLike for EagerArray {512 #[cfg(feature = "nightly")]513 type Iter<'t> = EagerArrayIter<'t>;514515 #[cfg(feature = "nightly")]516 type IterLazy<'t> = EagerArrayLazyIter<'t>;517518 #[cfg(feature = "nightly")]519 type IterCheap<'t> = EagerArrayCheapIter<'t>;520521 fn len(&self) -> usize {522 self.0.len()523 }524525 fn get(&self, index: usize) -> Result<Option<Val>> {526 Ok(self.0.get(index).cloned())527 }528529 fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {530 self.0.get(index).cloned().map(Thunk::evaluated)531 }532533 fn get_cheap(&self, index: usize) -> Option<Val> {534 self.0.get(index).cloned()535 }536537 #[cfg(feature = "nightly")]538 fn iter(&self) -> EagerArrayIter<'_> {539 self.0.iter().cloned().map(Ok)540 }541542 #[cfg(feature = "nightly")]543 fn iter_lazy(&self) -> EagerArrayLazyIter<'_> {544 self.0.iter().cloned().map(Thunk::evaluated)545 }546547 #[cfg(feature = "nightly")]548 fn iter_cheap(&self) -> Option<EagerArrayCheapIter<'_>> {549 Some(self.0.iter().cloned())550 }551}552impl From<EagerArray> for ArrValue {553 fn from(value: EagerArray) -> Self {554 Self::Eager(value)555 }556}557558/// Inclusive range type559#[derive(Debug, Trace, Clone, PartialEq, Eq)]560pub struct RangeArray {561 start: i32,562 end: i32,563}564impl RangeArray {565 pub fn empty() -> Self {566 Self::new_exclusive(0, 0)567 }568 pub fn new_exclusive(start: i32, end: i32) -> Self {569 end.checked_sub(1)570 .map_or_else(Self::empty, |end| Self { start, end })571 }572 pub fn new_inclusive(start: i32, end: i32) -> Self {573 Self { start, end }574 }575 fn range(&self) -> impl Iterator<Item = i32> + ExactSizeIterator + DoubleEndedIterator {576 WithExactSize(577 self.start..=self.end,578 (self.end as usize)579 .wrapping_sub(self.start as usize)580 .wrapping_add(1),581 )582 }583}584585#[cfg(feature = "nightly")]586type RangeArrayIter<'t> = impl DoubleEndedIterator<Item = Result<Val>> + ExactSizeIterator + 't;587#[cfg(feature = "nightly")]588type RangeArrayLazyIter<'t> = impl DoubleEndedIterator<Item = Thunk<Val>> + ExactSizeIterator + 't;589#[cfg(feature = "nightly")]590type RangeArrayCheapIter<'t> = impl DoubleEndedIterator<Item = Val> + ExactSizeIterator + 't;591impl ArrayLike for RangeArray {592 #[cfg(feature = "nightly")]593 type Iter<'t> = RangeArrayIter<'t>;594595 #[cfg(feature = "nightly")]596 type IterLazy<'t> = RangeArrayLazyIter<'t>;597598 #[cfg(feature = "nightly")]599 type IterCheap<'t> = RangeArrayCheapIter<'t>;600601 fn len(&self) -> usize {602 self.range().len()603 }604 fn is_empty(&self) -> bool {605 self.range().len() == 0606 }607608 fn get(&self, index: usize) -> Result<Option<Val>> {609 Ok(self.get_cheap(index))610 }611612 fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {613 self.get_cheap(index).map(Thunk::evaluated)614 }615616 fn get_cheap(&self, index: usize) -> Option<Val> {617 self.range().nth(index).map(|i| Val::Num(f64::from(i)))618 }619620 #[cfg(feature = "nightly")]621 fn iter(&self) -> RangeArrayIter<'_> {622 self.range().map(|i| Ok(Val::Num(f64::from(i))))623 }624625 #[cfg(feature = "nightly")]626 fn iter_lazy(&self) -> RangeArrayLazyIter<'_> {627 self.range()628 .map(|i| Thunk::evaluated(Val::Num(f64::from(i))))629 }630631 #[cfg(feature = "nightly")]632 fn iter_cheap(&self) -> Option<RangeArrayCheapIter<'_>> {633 Some(self.range().map(|i| Val::Num(f64::from(i))))634 }635}636impl From<RangeArray> for ArrValue {637 fn from(value: RangeArray) -> Self {638 Self::Range(value)639 }640}641642#[derive(Debug, Trace, Clone)]643pub struct ReverseArray(pub ArrValue);644impl ArrayLike for ReverseArray {645 #[cfg(feature = "nightly")]646 type Iter<'t> = iter::Rev<UnknownArrayIter<'t>>;647648 #[cfg(feature = "nightly")]649 type IterLazy<'t> = iter::Rev<UnknownArrayIterLazy<'t>>;650651 #[cfg(feature = "nightly")]652 type IterCheap<'t> = iter::Rev<UnknownArrayIterCheap<'t>>;653654 fn len(&self) -> usize {655 self.0.len()656 }657658 fn get(&self, index: usize) -> Result<Option<Val>> {659 self.0.get(self.0.len() - index - 1)660 }661662 fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {663 self.0.get_lazy(self.0.len() - index - 1)664 }665666 fn get_cheap(&self, index: usize) -> Option<Val> {667 self.0.get_cheap(self.0.len() - index - 1)668 }669670 #[cfg(feature = "nightly")]671 fn iter(&self) -> iter::Rev<UnknownArrayIter<'_>> {672 self.0.iter().rev()673 }674675 #[cfg(feature = "nightly")]676 fn iter_lazy(&self) -> iter::Rev<UnknownArrayIterLazy<'_>> {677 self.0.iter_lazy().rev()678 }679680 #[cfg(feature = "nightly")]681 fn iter_cheap(&self) -> Option<iter::Rev<UnknownArrayIterCheap<'_>>> {682 Some(self.0.iter_cheap()?.rev())683 }684 fn reverse(self) -> ArrValue {685 self.0686 }687}688impl From<ReverseArray> for ArrValue {689 fn from(value: ReverseArray) -> Self {690 Self::Reverse(Cc::new(value))691 }692}693694#[derive(Trace, Debug)]695pub struct MappedArrayInner {696 inner: ArrValue,697 cached: RefCell<Vec<ArrayThunk<()>>>,698 mapper: FuncVal,699}700#[derive(Trace, Debug, Clone)]701pub struct MappedArray(Cc<MappedArrayInner>);702impl MappedArray {703 pub fn new(inner: ArrValue, mapper: FuncVal) -> Self {704 let len = inner.len();705 Self(Cc::new(MappedArrayInner {706 inner,707 cached: RefCell::new(vec![ArrayThunk::Waiting(()); len]),708 mapper,709 }))710 }711}712#[cfg(feature = "nightly")]713type MappedArrayIter<'t> = impl DoubleEndedIterator<Item = Result<Val>> + ExactSizeIterator + 't;714#[cfg(feature = "nightly")]715type MappedArrayLazyIter<'t> = impl DoubleEndedIterator<Item = Thunk<Val>> + ExactSizeIterator + 't;716#[cfg(feature = "nightly")]717type MappedArrayCheapIter<'t> = iter::Empty<Val>;718impl ArrayLike for MappedArray {719 #[cfg(feature = "nightly")]720 type Iter<'t> = MappedArrayIter<'t>;721 #[cfg(feature = "nightly")]722 type IterLazy<'t> = MappedArrayLazyIter<'t>;723 #[cfg(feature = "nightly")]724 type IterCheap<'t> = MappedArrayCheapIter<'t>;725726 fn len(&self) -> usize {727 self.0.cached.borrow().len()728 }729730 fn get(&self, index: usize) -> Result<Option<Val>> {731 if index >= self.len() {732 return Ok(None);733 }734 match &self.0.cached.borrow()[index] {735 ArrayThunk::Computed(c) => return Ok(Some(c.clone())),736 ArrayThunk::Errored(e) => return Err(e.clone()),737 ArrayThunk::Pending => return Err(InfiniteRecursionDetected.into()),738 ArrayThunk::Waiting(..) => {}739 };740741 let ArrayThunk::Waiting(_) = replace(&mut self.0.cached.borrow_mut()[index], ArrayThunk::Pending) else {742 unreachable!()743 };744745 let val = self746 .0747 .inner748 .get(index)749 .transpose()750 .expect("index checked")751 .and_then(|r| self.0.mapper.evaluate_simple(&(r,), false));752753 let new_value = match val {754 Ok(v) => v,755 Err(e) => {756 self.0.cached.borrow_mut()[index] = ArrayThunk::Errored(e.clone());757 return Err(e);758 }759 };760 self.0.cached.borrow_mut()[index] = ArrayThunk::Computed(new_value.clone());761 Ok(Some(new_value))762 }763 fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {764 #[derive(Trace)]765 struct ArrayElement {766 arr_thunk: MappedArray,767 index: usize,768 }769770 impl ThunkValue for ArrayElement {771 type Output = Val;772773 fn get(self: Box<Self>) -> Result<Self::Output> {774 self.arr_thunk775 .get(self.index)776 .transpose()777 .expect("index checked")778 }779 }780781 if index >= self.len() {782 return None;783 }784 match &self.0.cached.borrow()[index] {785 ArrayThunk::Computed(c) => return Some(Thunk::evaluated(c.clone())),786 ArrayThunk::Errored(e) => return Some(Thunk::errored(e.clone())),787 ArrayThunk::Waiting(_) | ArrayThunk::Pending => {}788 };789790 Some(Thunk::new(ArrayElement {791 arr_thunk: self.clone(),792 index,793 }))794 }795796 fn get_cheap(&self, _index: usize) -> Option<Val> {797 None798 }799800 #[cfg(feature = "nightly")]801 fn iter(&self) -> MappedArrayIter<'_> {802 (0..self.len()).map(|i| self.get(i).transpose().expect("length checked"))803 }804805 #[cfg(feature = "nightly")]806 fn iter_lazy(&self) -> MappedArrayLazyIter<'_> {807 (0..self.len()).map(|i| self.get_lazy(i).expect("length checked"))808 }809810 #[cfg(feature = "nightly")]811 fn iter_cheap(&self) -> Option<Self::IterCheap<'_>> {812 None813 }814}815impl From<MappedArray> for ArrValue {816 fn from(value: MappedArray) -> Self {817 Self::Mapped(value)818 }819}820821#[derive(Trace, Debug)]822pub struct RepeatedArrayInner {823 data: ArrValue,824 repeats: usize,825 total_len: usize,826}827#[derive(Trace, Debug, Clone)]828pub struct RepeatedArray(Cc<RepeatedArrayInner>);829impl RepeatedArray {830 pub fn new(data: ArrValue, repeats: usize) -> Option<Self> {831 let total_len = data.len().checked_mul(repeats)?;832 Some(Self(Cc::new(RepeatedArrayInner {833 data,834 repeats,835 total_len,836 })))837 }838 pub fn is_cheap(&self) -> bool {839 self.0.data.is_cheap()840 }841}842843#[cfg(feature = "nightly")]844type RepeatedArrayIter<'t> = impl DoubleEndedIterator<Item = Result<Val>> + ExactSizeIterator + 't;845#[cfg(feature = "nightly")]846type RepeatedArrayLazyIter<'t> =847 impl DoubleEndedIterator<Item = Thunk<Val>> + ExactSizeIterator + 't;848#[cfg(feature = "nightly")]849type RepeatedArrayCheapIter<'t> = impl DoubleEndedIterator<Item = Val> + ExactSizeIterator + 't;850impl ArrayLike for RepeatedArray {851 #[cfg(feature = "nightly")]852 type Iter<'t> = RepeatedArrayIter<'t>;853 #[cfg(feature = "nightly")]854 type IterLazy<'t> = RepeatedArrayLazyIter<'t>;855 #[cfg(feature = "nightly")]856 type IterCheap<'t> = RepeatedArrayCheapIter<'t>;857858 fn len(&self) -> usize {859 self.0.total_len860 }861862 fn get(&self, index: usize) -> Result<Option<Val>> {863 if index > self.0.total_len {864 return Ok(None);865 }866 self.0.data.get(index % self.0.data.len())867 }868869 fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {870 if index > self.0.total_len {871 return None;872 }873 self.0.data.get_lazy(index % self.0.data.len())874 }875876 fn get_cheap(&self, index: usize) -> Option<Val> {877 if index > self.0.total_len {878 return None;879 }880 self.0.data.get_cheap(index % self.0.data.len())881 }882883 #[cfg(feature = "nightly")]884 fn iter(&self) -> RepeatedArrayIter<'_> {885 (0..self.0.total_len)886 .map(|i| self.get(i))887 .map(Result::transpose)888 .map(Option::unwrap)889 }890891 #[cfg(feature = "nightly")]892 fn iter_lazy(&self) -> RepeatedArrayLazyIter<'_> {893 (0..self.0.total_len)894 .map(|i| self.get_lazy(i))895 .map(Option::unwrap)896 }897898 #[cfg(feature = "nightly")]899 fn iter_cheap(&self) -> Option<RepeatedArrayCheapIter<'_>> {900 if !self.0.data.is_cheap() {901 return None;902 }903 Some(904 (0..self.0.total_len)905 .map(|i| self.get_cheap(i))906 .map(Option::unwrap),907 )908 }909}910impl From<RepeatedArray> for ArrValue {911 fn from(value: RepeatedArray) -> Self {912 Self::Repeated(value)913 }914}915916#[cfg(feature = "nightly")]917macro_rules! impl_iter_enum {918 ($n:ident => $v:ident) => {919 pub enum $n<'t> {920 Bytes(<BytesArray as ArrayLike>::$v<'t>),921 Expr(<ExprArray as ArrayLike>::$v<'t>),922 Lazy(<LazyArray as ArrayLike>::$v<'t>),923 Eager(<EagerArray as ArrayLike>::$v<'t>),924 Range(<RangeArray as ArrayLike>::$v<'t>),925 Slice(Box<<SliceArray as ArrayLike>::$v<'t>>),926 Extended(Box<<ExtendedArray as ArrayLike>::$v<'t>>),927 Reverse(Box<<ReverseArray as ArrayLike>::$v<'t>>),928 Mapped(Box<<MappedArray as ArrayLike>::$v<'t>>),929 Repeated(Box<<RepeatedArray as ArrayLike>::$v<'t>>),930 }931 };932}933934macro_rules! pass {935 ($t:ident.$m:ident($($ident:ident),*)) => {936 match $t {937 Self::Bytes(e) => e.$m($($ident)*),938 Self::Expr(e) => e.$m($($ident)*),939 Self::Lazy(e) => e.$m($($ident)*),940 Self::Eager(e) => e.$m($($ident)*),941 Self::Range(e) => e.$m($($ident)*),942 Self::Slice(e) => e.$m($($ident)*),943 Self::Extended(e) => e.$m($($ident)*),944 Self::Reverse(e) => e.$m($($ident)*),945 Self::Mapped(e) => e.$m($($ident)*),946 Self::Repeated(e) => e.$m($($ident)*),947 }948 };949}950pub(super) use pass;951952#[cfg(feature = "nightly")]953macro_rules! pass_iter_call {954 ($t:ident.$c:ident $(in $wrap:ident)? => $e:ident) => {955 match $t {956 ArrValue::Bytes(e) => $e::Bytes($($wrap!)?(e.$c())),957 ArrValue::Lazy(e) => $e::Lazy($($wrap!)?(e.$c())),958 ArrValue::Expr(e) => $e::Expr($($wrap!)?(e.$c())),959 ArrValue::Eager(e) => $e::Eager($($wrap!)?(e.$c())),960 ArrValue::Range(e) => $e::Range($($wrap!)?(e.$c())),961 ArrValue::Slice(e) => $e::Slice(Box::new($($wrap!)?(e.$c()))),962 ArrValue::Extended(e) => $e::Extended(Box::new($($wrap!)?(e.$c()))),963 ArrValue::Reverse(e) => $e::Reverse(Box::new($($wrap!)?(e.$c()))),964 ArrValue::Mapped(e) => $e::Mapped(Box::new($($wrap!)?(e.$c()))),965 ArrValue::Repeated(e) => $e::Repeated(Box::new($($wrap!)?(e.$c()))),966 }967 };968}969#[cfg(feature = "nightly")]970pub(super) use pass_iter_call;971972#[cfg(feature = "nightly")]973macro_rules! impl_iter {974 ($t:ident => $out:ty) => {975 impl Iterator for $t<'_> {976 type Item = $out;977978 fn next(&mut self) -> Option<Self::Item> {979 pass!(self.next())980 }981 fn nth(&mut self, count: usize) -> Option<Self::Item> {982 pass!(self.nth(count))983 }984 fn size_hint(&self) -> (usize, Option<usize>) {985 pass!(self.size_hint())986 }987 }988 impl DoubleEndedIterator for $t<'_> {989 fn next_back(&mut self) -> Option<Self::Item> {990 pass!(self.next_back())991 }992 fn nth_back(&mut self, count: usize) -> Option<Self::Item> {993 pass!(self.nth_back(count))994 }995 }996 impl ExactSizeIterator for $t<'_> {997 fn len(&self) -> usize {998 match self {999 Self::Bytes(e) => e.len(),1000 Self::Expr(e) => e.len(),1001 Self::Lazy(e) => e.len(),1002 Self::Eager(e) => e.len(),1003 Self::Range(e) => e.len(),1004 Self::Slice(e) => e.len(),1005 Self::Extended(e) => {1006 e.size_hint().1.expect("overflow is checked in constructor")1007 }1008 Self::Reverse(e) => e.len(),1009 Self::Mapped(e) => e.len(),1010 Self::Repeated(e) => e.len(),1011 }1012 }1013 }1014 };1015}10161017#[cfg(feature = "nightly")]1018impl_iter_enum!(UnknownArrayIter => Iter);1019#[cfg(feature = "nightly")]1020impl_iter!(UnknownArrayIter => Result<Val>);1021#[cfg(feature = "nightly")]1022impl_iter_enum!(UnknownArrayIterLazy => IterLazy);1023#[cfg(feature = "nightly")]1024impl_iter!(UnknownArrayIterLazy => Thunk<Val>);1025#[cfg(feature = "nightly")]1026impl_iter_enum!(UnknownArrayIterCheap => IterCheap);1027#[cfg(feature = "nightly")]1028impl_iter!(UnknownArrayIterCheap => Val);1//! 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};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}623624/// Inclusive range type625#[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);crates/jrsonnet-evaluator/src/val.rsdiffbeforeafterboth--- a/crates/jrsonnet-evaluator/src/val.rs
+++ b/crates/jrsonnet-evaluator/src/val.rs
@@ -149,6 +149,12 @@
Arr(ArrValue),
}
impl IndexableVal {
+ pub fn to_array(self) -> ArrValue {
+ match self {
+ IndexableVal::Str(s) => ArrValue::chars(s.chars()),
+ IndexableVal::Arr(arr) => arr,
+ }
+ }
/// Slice the value.
///
/// # Implementation
crates/jrsonnet-interner/src/lib.rsdiffbeforeafterboth--- a/crates/jrsonnet-interner/src/lib.rs
+++ b/crates/jrsonnet-interner/src/lib.rs
@@ -205,6 +205,12 @@
s.as_str().into()
}
}
+impl From<char> for IStr {
+ fn from(value: char) -> Self {
+ let mut buf = [0; 5];
+ Self::from(&*value.encode_utf8(&mut buf))
+ }
+}
impl From<&[u8]> for IBytes {
fn from(v: &[u8]) -> Self {
intern_bytes(v)
crates/jrsonnet-stdlib/src/arrays.rsdiffbeforeafterboth--- a/crates/jrsonnet-stdlib/src/arrays.rs
+++ b/crates/jrsonnet-stdlib/src/arrays.rs
@@ -45,8 +45,9 @@
}
#[builtin]
-pub fn builtin_map(func: FuncVal, arr: ArrValue) -> Result<ArrValue> {
- Ok(arr.map(func))
+pub fn builtin_map(func: FuncVal, arr: IndexableVal) -> ArrValue {
+ let arr = arr.to_array();
+ arr.map(func)
}
#[builtin]