git.delta.rocks / jrsonnet / refs/commits / 54c4db58ad3d

32	Reverse(Box<ReverseArray>),32	Reverse(Box<ReverseArray>),
33	/// Returned by `std.map` call33	/// Returned by `std.map` call
34	Mapped(MappedArray),34	Mapped(MappedArray),
35	/// Returned by `std.repeat` call
36	Repeated(RepeatedArray),
35}37}
3638
37impl ArrValue {39impl ArrValue {
51		Self::Eager(EagerArray(values))53		Self::Eager(EagerArray(values))
52	}54	}
55
56	pub fn repeated(data: ArrValue, repeats: usize) -> Option<Self> {
57		Some(Self::Repeated(RepeatedArray::new(data, repeats)?))
58	}
5359
54	pub fn bytes(bytes: IBytes) -> Self {60	pub fn bytes(bytes: IBytes) -> Self {
55		Self::Bytes(BytesArray(bytes))61		Self::Bytes(BytesArray(bytes))
76		// TODO: benchmark for an optimal value, currently just a arbitrary choice82		// TODO: benchmark for an optimal value, currently just a arbitrary choice
77		const ARR_EXTEND_THRESHOLD: usize = 100;83		const ARR_EXTEND_THRESHOLD: usize = 100;
7884
85		if a.is_empty() {
86			b
87		} else if b.is_empty() {
88			a
79		if a.len() + b.len() > ARR_EXTEND_THRESHOLD {89		} else if a.len() + b.len() > ARR_EXTEND_THRESHOLD {
80			Self::Extended(Cc::new(ExtendedArray::new(a, b)))90			Self::Extended(Cc::new(ExtendedArray::new(a, b)))
81		} else if let (Some(a), Some(b)) = (a.iter_cheap(), b.iter_cheap()) {91		} else if let (Some(a), Some(b)) = (a.iter_cheap(), b.iter_cheap()) {
82			let mut out = Vec::with_capacity(a.len() + b.len());92			let mut out = Vec::with_capacity(a.len() + b.len());
189			(ArrValue::Lazy(a), ArrValue::Lazy(b)) => Cc::ptr_eq(&a.0, &b.0),199			(ArrValue::Lazy(a), ArrValue::Lazy(b)) => Cc::ptr_eq(&a.0, &b.0),
190			(ArrValue::Expr(a), ArrValue::Expr(b)) => Cc::ptr_eq(&a.0, &b.0),200			(ArrValue::Expr(a), ArrValue::Expr(b)) => Cc::ptr_eq(&a.0, &b.0),
191			(ArrValue::Eager(a), ArrValue::Eager(b)) => Cc::ptr_eq(&a.0, &b.0),201			(ArrValue::Eager(a), ArrValue::Eager(b)) => Cc::ptr_eq(&a.0, &b.0),
192			(ArrValue::Extended(a), ArrValue::Extended(b)) => Cc::ptr_eq(&a, &b),202			(ArrValue::Extended(a), ArrValue::Extended(b)) => Cc::ptr_eq(a, b),
193			(ArrValue::Range(a), ArrValue::Range(b)) => a == b,203			(ArrValue::Range(a), ArrValue::Range(b)) => a == b,
194			(ArrValue::Slice(_), ArrValue::Slice(_)) => false,
195			(ArrValue::Reverse(_), ArrValue::Reverse(_)) => false,
196			_ => false,204			_ => false,
197		}205		}
198	}206	}
203			ArrValue::Extended(v) => v.a.is_cheap() && v.b.is_cheap(),211			ArrValue::Extended(v) => v.a.is_cheap() && v.b.is_cheap(),
204			ArrValue::Slice(r) => r.inner.is_cheap(),212			ArrValue::Slice(r) => r.inner.is_cheap(),
205			ArrValue::Reverse(i) => i.0.is_cheap(),213			ArrValue::Reverse(i) => i.0.is_cheap(),
214			ArrValue::Repeated(v) => v.is_cheap(),
206			ArrValue::Expr(_) | ArrValue::Lazy(_) | ArrValue::Mapped(_) => false,215			ArrValue::Expr(_) | ArrValue::Lazy(_) | ArrValue::Mapped(_) => false,
207		}216		}
208	}217	}

740}740}
741// impl MappedArray741// impl MappedArray
742
743#[derive(Trace, Debug)]
744pub struct RepeatedArrayInner {
745	data: ArrValue,
746	repeats: usize,
747	total_len: usize,
748}
749#[derive(Trace, Debug, Clone)]
750pub struct RepeatedArray(Cc<RepeatedArrayInner>);
751impl RepeatedArray {
752	pub fn new(data: ArrValue, repeats: usize) -> Option<Self> {
753		let total_len = data.len().checked_mul(repeats)?;
754		Some(Self(Cc::new(RepeatedArrayInner {
755			data,
756			repeats,
757			total_len,
758		})))
759	}
760	pub fn is_cheap(&self) -> bool {
761		self.0.data.is_cheap()
762	}
763}
764
765type RepeatedArrayIter<'t> = impl DoubleEndedIterator<Item = Result<Val>> + ExactSizeIterator + 't;
766type RepeatedArrayLazyIter<'t> =
767	impl DoubleEndedIterator<Item = Thunk<Val>> + ExactSizeIterator + 't;
768type RepeatedArrayCheapIter<'t> = impl DoubleEndedIterator<Item = Val> + ExactSizeIterator + 't;
769impl ArrayLike for RepeatedArray {
770	type Iter<'t> = RepeatedArrayIter<'t>;
771	type IterLazy<'t> = RepeatedArrayLazyIter<'t>;
772	type IterCheap<'t> = RepeatedArrayCheapIter<'t>;
773
774	fn len(&self) -> usize {
775		self.0.total_len
776	}
777
778	fn get(&self, index: usize) -> Result<Option<Val>> {
779		if index > self.0.total_len {
780			return Ok(None);
781		}
782		self.0.data.get(index % self.0.data.len())
783	}
784
785	fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {
786		if index > self.0.total_len {
787			return None;
788		}
789		self.0.data.get_lazy(index % self.0.data.len())
790	}
791
792	fn get_cheap(&self, index: usize) -> Option<Val> {
793		if index > self.0.total_len {
794			return None;
795		}
796		self.0.data.get_cheap(index % self.0.data.len())
797	}
798
799	fn evaluated(&self) -> Result<Vec<Val>> {
800		let mut data = self.0.data.evaluated()?;
801		let data_range = 0..data.len();
802		for _ in 1..self.0.repeats {
803			data.extend_from_within(data_range.clone());
804		}
805		Ok(data)
806	}
807
808	fn iter(&self) -> RepeatedArrayIter<'_> {
809		(0..self.0.total_len)
810			.map(|i| self.get(i))
811			.map(Result::transpose)
812			.map(Option::unwrap)
813	}
814
815	fn iter_lazy(&self) -> RepeatedArrayLazyIter<'_> {
816		(0..self.0.total_len)
817			.map(|i| self.get_lazy(i))
818			.map(Option::unwrap)
819	}
820
821	fn iter_cheap(&self) -> Option<RepeatedArrayCheapIter<'_>> {
822		if !self.0.data.is_cheap() {
823			return None;
824		}
825		Some(
826			(0..self.0.total_len)
827				.map(|i| self.get_cheap(i))
828				.map(Option::unwrap),
829		)
830	}
831}
742832
743macro_rules! impl_iter_enum {833macro_rules! impl_iter_enum {
744	($n:ident => $v:ident) => {834	($n:ident => $v:ident) => {
752			Extended(Box<<ExtendedArray as ArrayLike>::$v<'t>>),842			Extended(Box<<ExtendedArray as ArrayLike>::$v<'t>>),
753			Reverse(Box<<ReverseArray as ArrayLike>::$v<'t>>),843			Reverse(Box<<ReverseArray as ArrayLike>::$v<'t>>),
754			Mapped(Box<<MappedArray as ArrayLike>::$v<'t>>),844			Mapped(Box<<MappedArray as ArrayLike>::$v<'t>>),
845			Repeated(Box<<RepeatedArray as ArrayLike>::$v<'t>>),
755		}846		}
756	};847	};
757}848}
768			Self::Extended(e) => e.$m($($ident)*),859			Self::Extended(e) => e.$m($($ident)*),
769			Self::Reverse(e) => e.$m($($ident)*),860			Self::Reverse(e) => e.$m($($ident)*),
770			Self::Mapped(e) => e.$m($($ident)*),861			Self::Mapped(e) => e.$m($($ident)*),
862			Self::Repeated(e) => e.$m($($ident)*),
771		}863		}
772	};864	};
773}865}
785			ArrValue::Extended(e) => $e::Extended(Box::new($($wrap!)?(e.$c()))),877			ArrValue::Extended(e) => $e::Extended(Box::new($($wrap!)?(e.$c()))),
786			ArrValue::Reverse(e) => $e::Reverse(Box::new($($wrap!)?(e.$c()))),878			ArrValue::Reverse(e) => $e::Reverse(Box::new($($wrap!)?(e.$c()))),
787			ArrValue::Mapped(e) => $e::Mapped(Box::new($($wrap!)?(e.$c()))),879			ArrValue::Mapped(e) => $e::Mapped(Box::new($($wrap!)?(e.$c()))),
880			ArrValue::Repeated(e) => $e::Repeated(Box::new($($wrap!)?(e.$c()))),
788		}881		}
789	};882	};
790}883}
827					}920					}
828					Self::Reverse(e) => e.len(),921					Self::Reverse(e) => e.len(),
829					Self::Mapped(e) => e.len(),922					Self::Mapped(e) => e.len(),
923					Self::Repeated(e) => e.len(),
830				}924				}
831			}925			}
832		}926		}

13	parse::{parse_default_function_call, parse_function_call},13	parse::{parse_default_function_call, parse_function_call},
14};14};
15use crate::{evaluate, gc::TraceBox, typed::Any, Context, ContextBuilder, Result, Val};15use crate::{
16	evaluate, evaluate_trivial, gc::TraceBox, typed::Any, Context, ContextBuilder, Result, Val,
17};
1618
17pub mod arglike;19pub mod arglike;
81		parse_function_call(call_ctx, self.ctx.clone(), &self.params, args, tailstrict)83		parse_function_call(call_ctx, self.ctx.clone(), &self.params, args, tailstrict)
82	}84	}
85
86	pub fn evaluate_trivial(&self) -> Option<Val> {
87		evaluate_trivial(&self.body)
88	}
83}89}
8490
85/// Represents a Jsonnet function value, including plain functions and user-provided builtins.91/// Represents a Jsonnet function value, including plain functions and user-provided builtins.
202		Self::Id208		Self::Id
203	}209	}
210
211	pub fn evaluate_trivial(&self) -> Option<Val> {
212		match self {
213			FuncVal::Normal(n) => n.evaluate_trivial(),
214			_ => None,
215		}
216	}
204}217}
205218

1use jrsonnet_evaluator::{1use jrsonnet_evaluator::{
2	error::Result,2	error::{ErrorKind::RuntimeError, Result},
3	function::{builtin, FuncVal},3	function::{builtin, FuncVal},
4	throw,4	throw,
5	typed::{Any, BoundedUsize, Either2, NativeFn, Typed, VecVal},5	typed::{Any, BoundedI32, BoundedUsize, Either2, NativeFn, Typed},
6	val::{equals, ArrValue, IndexableVal},6	val::{equals, ArrValue, IndexableVal, StrValue},
7	Either, IStr, Val,7	Either, IStr, Val,
8};8};
9use jrsonnet_gcmodule::Cc;9use jrsonnet_gcmodule::Cc;
1010
11#[builtin]11#[builtin]
12pub fn builtin_make_array(sz: usize, func: NativeFn<((f64,), Any)>) -> Result<VecVal> {12pub fn builtin_make_array(sz: BoundedI32<0, { i32::MAX }>, func: FuncVal) -> Result<ArrValue> {
13	if *sz == 0 {
14		return Ok(ArrValue::empty());
15	}
16	if let Some(trivial) = func.evaluate_trivial() {
13	let mut out = Vec::with_capacity(sz);17		let mut out = Vec::with_capacity(*sz as usize);
14	for i in 0..sz {18		for _ in 0..*sz {
15		out.push(func(i as f64)?.0);19			out.push(trivial.clone())
16	}20		}
17	Ok(VecVal(Cc::new(out)))21		Ok(ArrValue::eager(Cc::new(out)))
22	} else {
23		Ok(ArrValue::range_exclusive(0, *sz).map(func))
24	}
18}25}
26
27#[builtin]
28pub fn builtin_repeat(what: Either![IStr, ArrValue], count: usize) -> Result<Any> {
29	Ok(Any(match what {
30		Either2::A(s) => Val::Str(StrValue::Flat(s.repeat(count).into())),
31		Either2::B(arr) => Val::Arr(
32			ArrValue::repeated(arr, count)
33				.ok_or_else(|| RuntimeError("repeated length overflow".into()))?,
34		),
35	}))
36}
1937
20#[builtin]38#[builtin]
21pub fn builtin_slice(39pub fn builtin_slice(

63		("isFunction", builtin_is_function::INST),63		("isFunction", builtin_is_function::INST),
64		// Arrays64		// Arrays
65		("makeArray", builtin_make_array::INST),65		("makeArray", builtin_make_array::INST),
66		("repeat", builtin_repeat::INST),
66		("slice", builtin_slice::INST),67		("slice", builtin_slice::INST),
67		("map", builtin_map::INST),68		("map", builtin_map::INST),
68		("flatMap", builtin_flatmap::INST),69		("flatMap", builtin_flatmap::INST),

2727
28  split(str, c):: std.splitLimit(str, c, -1),28  split(str, c):: std.splitLimit(str, c, -1),
2929
30  repeat(what, count)::
31    local joiner =
32      if std.isString(what) then ''
33      else if std.isArray(what) then []
34      else error 'std.repeat first argument must be an array or a string';
35    std.join(joiner, std.makeArray(count, function(i) what)),
36
37  mapWithIndex(func, arr)::30  mapWithIndex(func, arr)::
38    if !std.isFunction(func) then31    if !std.isFunction(func) then
39      error ('std.mapWithIndex first param must be function, got ' + std.type(func))32      error ('std.mapWithIndex first param must be function, got ' + std.type(func))