git.delta.rocks / jrsonnet / refs/commits / 432b17211316

1use crate::{2	create_error, Context, Error, FunctionDefault, FunctionRhs, LazyBinding, ObjValue, Result,3};4use closure::closure;5use jsonnet_parser::{Param, ParamsDesc};6use std::{7	cell::RefCell,8	collections::HashMap,9	fmt::{Debug, Display},10	rc::Rc,11};1213struct LazyValInternals {14	pub f: Option<Box<dyn Fn() -> Result<Val>>>,15	pub cached: RefCell<Option<Val>>,16}17#[derive(Clone)]18pub struct LazyVal(Rc<LazyValInternals>);19impl LazyVal {20	pub fn new(f: Box<dyn Fn() -> Result<Val>>) -> Self {21		LazyVal(Rc::new(LazyValInternals {22			f: Some(f),23			cached: RefCell::new(None),24		}))25	}26	pub fn new_resolved(val: Val) -> Self {27		LazyVal(Rc::new(LazyValInternals {28			f: None,29			cached: RefCell::new(Some(val)),30		}))31	}32	pub fn evaluate(&self) -> Result<Val> {33		{34			let cached = self.0.cached.borrow();35			if cached.is_some() {36				return Ok(cached.clone().unwrap());37			}38		}39		let result = (self.0.f.as_ref().unwrap())()?;40		self.0.cached.borrow_mut().replace(result.clone());41		Ok(result)42	}43}4445#[macro_export]46macro_rules! lazy_val {47	($f: expr) => {48		$crate::LazyVal::new(Box::new($f))49	};50}51#[macro_export]52macro_rules! resolved_lazy_val {53	($f: expr) => {54		$crate::LazyVal::new_resolved($f)55	};56}57impl Debug for LazyVal {58	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {59		if self.0.cached.borrow().is_some() {60			write!(f, "{:?}", self.0.cached.borrow().clone().unwrap())61		} else {62			write!(f, "Lazy")63		}64	}65}66impl PartialEq for LazyVal {67	fn eq(&self, other: &Self) -> bool {68		Rc::ptr_eq(&self.0, &other.0)69	}70}7172#[derive(Debug, PartialEq, Clone)]73pub struct FuncDesc {74	pub ctx: Context,75	pub params: ParamsDesc,76	pub eval_rhs: FunctionRhs,77	pub eval_default: FunctionDefault,78}79impl FuncDesc {80	// TODO: Check for unset variables81	pub fn evaluate(&self, args: Vec<(Option<String>, Val)>) -> Result<Val> {82		let mut new_bindings: HashMap<String, LazyBinding> = HashMap::new();83		let future_ctx = Context::new_future();8485		for Param(name, default) in self.params.with_defaults() {86			let default = default.unwrap();87			let eval_default = self.eval_default.clone();88			new_bindings.insert(89				name,90				LazyBinding::Bound(lazy_val!(91					closure!(clone future_ctx, clone eval_default, clone default, || (eval_default.clone()).092					(future_ctx.clone().unwrap(), default.clone()))93				)),94			);95		}96		for (name, val) in args.clone().into_iter().filter(|e| e.0.is_some()) {97			new_bindings.insert(98				name.as_ref().unwrap().clone(),99				LazyBinding::Bound(resolved_lazy_val!(val.clone())),100			);101		}102		for (i, param) in self.params.0.iter().enumerate() {103			if let Some((None, val)) = args.get(i) {104				new_bindings.insert(105					param.0.clone(),106					LazyBinding::Bound(resolved_lazy_val!(val.clone())),107				);108			}109		}110		let ctx = self111			.ctx112			.extend(new_bindings, None, None, None)?113			.into_future(future_ctx);114		self.eval_rhs.0(ctx)115	}116}117118#[derive(Debug)]119pub enum ValType {120	Bool,121	Null,122	Str,123	Num,124	Arr,125	Obj,126	Func,127}128impl ValType {129	pub fn name(&self) -> &'static str {130		use ValType::*;131		match self {132			Bool => "boolean",133			Null => "null",134			Str => "string",135			Num => "number",136			Arr => "array",137			Obj => "object",138			Func => "function",139		}140	}141}142impl Display for ValType {143	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {144		write!(f, "{}", self.name())145	}146}147148#[derive(Debug, PartialEq, Clone)]149pub enum Val {150	Bool(bool),151	Null,152	Str(String),153	Num(f64),154	Lazy(LazyVal),155	Arr(Vec<Val>),156	Obj(ObjValue),157	Func(FuncDesc),158159	// Library functions implemented in native160	Intristic(String, String),161}162impl Val {163	pub fn try_cast_bool(self, context: &'static str) -> Result<bool> {164		match self.unwrap_if_lazy()? {165			Val::Bool(v) => Ok(v),166			v => create_error(Error::TypeMismatch(167				context,168				vec![ValType::Bool],169				v.value_type()?,170			)),171		}172	}173	pub fn try_cast_str(self, context: &'static str) -> Result<String> {174		match self.unwrap_if_lazy()? {175			Val::Str(v) => Ok(v),176			v => create_error(Error::TypeMismatch(177				context,178				vec![ValType::Str],179				v.value_type()?,180			)),181		}182	}183	pub fn unwrap_if_lazy(self) -> Result<Self> {184		Ok(if let Val::Lazy(v) = self {185			v.evaluate()?.unwrap_if_lazy()?186		} else {187			self188		})189	}190	pub fn value_type(&self) -> Result<ValType> {191		Ok(match self {192			Val::Str(..) => ValType::Str,193			Val::Num(..) => ValType::Num,194			Val::Arr(..) => ValType::Arr,195			Val::Obj(..) => ValType::Obj,196			Val::Func(..) => ValType::Func,197			Val::Bool(_) => ValType::Bool,198			Val::Null => ValType::Null,199			Val::Intristic(_, _) => ValType::Func,200			Val::Lazy(_) => self.clone().unwrap_if_lazy()?.value_type()?,201		})202	}203}