git.delta.rocks / jrsonnet / refs/commits / a5471f26b10f

--- a/bindings/jsonnet/src/import.rs
+++ b/bindings/jsonnet/src/import.rs
@@ -49,8 +49,8 @@
 		};
 		// Release memory occipied by arguments passed
 		unsafe {
-			CString::from_raw(base);
-			CString::from_raw(rel);
+			let _ = CString::from_raw(base);
+			let _ = CString::from_raw(rel);
 		}
 		let result_raw = unsafe { CStr::from_ptr(result_ptr) };
 		let result_str = result_raw.to_str().unwrap();
@@ -64,7 +64,7 @@
 		let found_here_raw = unsafe { CStr::from_ptr(found_here) };
 		let found_here_buf = PathBuf::from(found_here_raw.to_str().unwrap());
 		unsafe {
-			CString::from_raw(found_here);
+			let _ = CString::from_raw(found_here);
 		}
 
 		let mut out = self.out.borrow_mut();

--- a/bindings/jsonnet/src/native.rs
+++ b/bindings/jsonnet/src/native.rs
@@ -3,10 +3,11 @@
 	error::{Error, LocError},
 	gc::TraceBox,
 	native::{NativeCallback, NativeCallbackHandler},
-	EvaluationState, Val,
+	EvaluationState, IStr, Val,
 };
 use jrsonnet_parser::{Param, ParamsDesc};
 use std::{
+	convert::TryFrom,
 	ffi::{c_void, CStr},
 	os::raw::{c_char, c_int},
 	path::Path,
@@ -45,7 +46,7 @@
 		if success == 1 {
 			Ok(v)
 		} else {
-			let e = v.try_cast_str("native error").expect("error msg");
+			let e = IStr::try_from(v).expect("error msg");
 			Err(Error::RuntimeError(e).into())
 		}
 	}

--- a/crates/jrsonnet-evaluator/Cargo.toml
+++ b/crates/jrsonnet-evaluator/Cargo.toml
@@ -23,6 +23,7 @@
 jrsonnet-parser = { path = "../jrsonnet-parser", version = "0.4.2" }
 jrsonnet-stdlib = { path = "../jrsonnet-stdlib", version = "0.4.2" }
 jrsonnet-types = { path = "../jrsonnet-types", version = "0.4.2" }
+jrsonnet-macros = { path = "../jrsonnet-macros", version = "0.4.2" }
 pathdiff = "0.2.0"
 
 md5 = "0.7.0"

5use gcmodule::Trace;5use gcmodule::Trace;
6use jrsonnet_interner::IStr;6use jrsonnet_interner::IStr;
7use jrsonnet_types::ValType;7use jrsonnet_types::ValType;
8use std::convert::TryFrom;
8use thiserror::Error;9use thiserror::Error;
910
10#[derive(Debug, Clone, Error, Trace)]11#[derive(Debug, Clone, Error, Trace)]
484	match code.convtype {485	match code.convtype {
485		ConvTypeV::String => tmp_out.push_str(&value.clone().to_string()?),486		ConvTypeV::String => tmp_out.push_str(&value.clone().to_string()?),
486		ConvTypeV::Decimal => {487		ConvTypeV::Decimal => {
487			let value = value.clone().try_cast_num("%d/%u/%i requires number")?;488			let value = f64::try_from(value.clone())?;
488			render_decimal(489			render_decimal(
489				&mut tmp_out,490				&mut tmp_out,
490				value as i64,491				value as i64,
495			);496			);
496		}497		}
497		ConvTypeV::Octal => {498		ConvTypeV::Octal => {
498			let value = value.clone().try_cast_num("%o requires number")?;499			let value = f64::try_from(value.clone())?;
499			render_octal(500			render_octal(
500				&mut tmp_out,501				&mut tmp_out,
501				value as i64,502				value as i64,
507			);508			);
508		}509		}
509		ConvTypeV::Hexadecimal => {510		ConvTypeV::Hexadecimal => {
510			let value = value.clone().try_cast_num("%x/%X requires number")?;511			let value = f64::try_from(value.clone())?;
511			render_hexadecimal(512			render_hexadecimal(
512				&mut tmp_out,513				&mut tmp_out,
513				value as i64,514				value as i64,
520			);521			);
521		}522		}
522		ConvTypeV::Scientific => {523		ConvTypeV::Scientific => {
523			let value = value.clone().try_cast_num("%e/%E requires number")?;524			let value = f64::try_from(value.clone())?;
524			render_float_sci(525			render_float_sci(
525				&mut tmp_out,526				&mut tmp_out,
526				value,527				value,
534			);535			);
535		}536		}
536		ConvTypeV::Float => {537		ConvTypeV::Float => {
537			let value = value.clone().try_cast_num("%e/%E requires number")?;538			let value = f64::try_from(value.clone())?;
538			render_float(539			render_float(
539				&mut tmp_out,540				&mut tmp_out,
540				value,541				value,
547			);548			);
548		}549		}
549		ConvTypeV::Shorter => {550		ConvTypeV::Shorter => {
550			let value = value.clone().try_cast_num("%g/%G requires number")?;551			let value = f64::try_from(value.clone())?;
551			let exponent = value.log10().floor();552			let exponent = value.log10().floor();
552			if exponent < -4.0 || exponent >= fpprec as f64 {553			if exponent < -4.0 || exponent >= fpprec as f64 {
553				render_float_sci(554				render_float_sci(
633						}634						}
634						let value = &values[0];635						let value = &values[0];
635						values = &values[1..];636						values = &values[1..];
636						value.clone().try_cast_num("field width")? as usize637						usize::try_from(value.clone())?
637					}638					}
638					Width::Fixed(n) => n,639					Width::Fixed(n) => n,
639				};640				};
644						}645						}
645						let value = &values[0];646						let value = &values[0];
646						values = &values[1..];647						values = &values[1..];
647						Some(value.clone().try_cast_num("field precision")? as usize)648						Some(usize::try_from(value.clone())?)
648					}649					}
649					Some(Width::Fixed(n)) => Some(n),650					Some(Width::Fixed(n)) => Some(n),
650					None => None,651					None => None,

--- a/crates/jrsonnet-evaluator/src/builtin/mod.rs
+++ b/crates/jrsonnet-evaluator/src/builtin/mod.rs
@@ -1,10 +1,12 @@
+use crate::typed::{Any, Either, Null, PositiveF64, VecVal, M1};
+use crate::{self as jrsonnet_evaluator, ObjValue};
 use crate::{
 	builtin::manifest::{manifest_yaml_ex, ManifestYamlOptions},
 	equals,
 	error::{Error::*, Result},
 	operator::evaluate_mod_op,
 	parse_args, primitive_equals, push_frame, throw, with_state, ArrValue, Context, FuncVal,
-	IndexableVal, LazyVal, Val,
+	IndexableVal, Val,
 };
 use format::{format_arr, format_obj};
 use gcmodule::Cc;
@@ -13,7 +15,12 @@
 use jrsonnet_types::ty;
 use serde::Deserialize;
 use serde_yaml::DeserializingQuirks;
-use std::{collections::HashMap, convert::TryFrom, path::PathBuf, rc::Rc};
+use std::{
+	collections::HashMap,
+	convert::{TryFrom, TryInto},
+	path::PathBuf,
+	rc::Rc,
+};
 
 pub mod stdlib;
 pub use stdlib::*;
@@ -24,15 +31,15 @@
 pub mod manifest;
 pub mod sort;
 
-pub fn std_format(str: IStr, vals: Val) -> Result<Val> {
+pub fn std_format(str: IStr, vals: Val) -> Result<String> {
 	push_frame(
 		&ExprLocation(Rc::from(PathBuf::from("std.jsonnet")), 0, 0),
 		|| format!("std.format of {}", str),
 		|| {
 			Ok(match vals {
-				Val::Arr(vals) => Val::Str(format_arr(&str, &vals.evaluated()?)?.into()),
-				Val::Obj(obj) => Val::Str(format_obj(&str, &obj)?.into()),
-				o => Val::Str(format_arr(&str, &[o])?.into()),
+				Val::Arr(vals) => format_arr(&str, &vals.evaluated()?)?,
+				Val::Obj(obj) => format_obj(&str, &obj)?,
+				o => format_arr(&str, &[o])?,
 			})
 		},
 	)
@@ -139,265 +146,177 @@
 	};
 }
 
-fn builtin_length(context: Context, _loc: &ExprLocation, args: &ArgsDesc) -> Result<Val> {
-	parse_args!(context, "length", args, 1, [
-		0, x: ty!((string | object | array));
-	], {
-		Ok(match x {
-			Val::Str(n) => Val::Num(n.chars().count() as f64),
-			Val::Arr(a) => Val::Num(a.len() as f64),
-			Val::Obj(o) => Val::Num(
-				o.fields_visibility()
-					.into_iter()
-					.filter(|(_k, v)| *v)
-					.count() as f64,
-			),
-			_ => unreachable!(),
-		})
+#[jrsonnet_macros::builtin]
+fn builtin_length(x: Either<IStr, Either<VecVal, ObjValue>>) -> Result<usize> {
+	Ok(match x {
+		Either::Left(x) => x.len(),
+		Either::Right(Either::Left(x)) => x.0.len(),
+		Either::Right(Either::Right(x)) => x
+			.fields_visibility()
+			.into_iter()
+			.filter(|(_k, v)| *v)
+			.count(),
 	})
 }
 
-fn builtin_type(context: Context, _loc: &ExprLocation, args: &ArgsDesc) -> Result<Val> {
-	parse_args!(context, "type", args, 1, [
-		0, x: ty!(any);
-	], {
-		Ok(Val::Str(x.value_type().name().into()))
-	})
+#[jrsonnet_macros::builtin]
+fn builtin_type(x: Any) -> Result<IStr> {
+	Ok(x.0.value_type().name().into())
 }
 
-fn builtin_make_array(context: Context, _loc: &ExprLocation, args: &ArgsDesc) -> Result<Val> {
-	parse_args!(context, "makeArray", args, 2, [
-		0, sz: ty!(BoundedNumber<(Some(0.0)), (None)>) => Val::Num;
-		1, func: ty!(function) => Val::Func;
-	], {
-		let mut out = Vec::with_capacity(sz as usize);
-		for i in 0..sz as usize {
-			out.push(LazyVal::new_resolved(func.evaluate_values(
-				context.clone(),
-				&[Val::Num(i as f64)]
-			)?))
-		}
-		Ok(Val::Arr(out.into()))
-	})
+#[jrsonnet_macros::builtin]
+fn builtin_make_array(sz: usize, func: Cc<FuncVal>) -> Result<VecVal> {
+	let mut out = Vec::with_capacity(sz);
+	for i in 0..sz {
+		out.push(func.evaluate_values(&[Val::Num(i as f64)])?)
+	}
+	Ok(VecVal(out))
 }
 
-fn builtin_codepoint(context: Context, _loc: &ExprLocation, args: &ArgsDesc) -> Result<Val> {
-	parse_args!(context, "codepoint", args, 1, [
-		0, str: ty!(char) => Val::Str;
-	], {
-		Ok(Val::Num(str.chars().next().unwrap() as u32 as f64))
-	})
+#[jrsonnet_macros::builtin]
+const fn builtin_codepoint(str: char) -> Result<u32> {
+	Ok(str as u32)
 }
 
-fn builtin_object_fields_ex(context: Context, _loc: &ExprLocation, args: &ArgsDesc) -> Result<Val> {
-	parse_args!(context, "objectFieldsEx", args, 2, [
-		0, obj: ty!(object) => Val::Obj;
-		1, inc_hidden: ty!(boolean) => Val::Bool;
-	], {
-		let out = obj.fields_ex(inc_hidden);
-		Ok(Val::Arr(out.into_iter().map(Val::Str).collect::<Vec<_>>().into()))
-	})
+#[jrsonnet_macros::builtin]
+fn builtin_object_fields_ex(obj: ObjValue, inc_hidden: bool) -> Result<VecVal> {
+	let out = obj.fields_ex(inc_hidden);
+	Ok(VecVal(out.into_iter().map(Val::Str).collect::<Vec<_>>()))
 }
 
-fn builtin_object_has_ex(context: Context, _loc: &ExprLocation, args: &ArgsDesc) -> Result<Val> {
-	parse_args!(context, "objectHasEx", args, 3, [
-		0, obj: ty!(object) => Val::Obj;
-		1, f: ty!(string) => Val::Str;
-		2, inc_hidden: ty!(boolean) => Val::Bool;
-	], {
-		Ok(Val::Bool(obj.has_field_ex(f, inc_hidden)))
-	})
+#[jrsonnet_macros::builtin]
+fn builtin_object_has_ex(obj: ObjValue, f: IStr, inc_hidden: bool) -> Result<bool> {
+	Ok(obj.has_field_ex(f, inc_hidden))
 }
 
-fn builtin_parse_json(context: Context, _loc: &ExprLocation, args: &ArgsDesc) -> Result<Val> {
-	parse_args!(context, "parseJson", args, 1, [
-		0, s: ty!(string) => Val::Str;
-	], {
-		let value: serde_json::Value = serde_json::from_str(&s).map_err(|e| RuntimeError(format!("failed to parse json: {}", e).into()))?;
-		Ok(Val::try_from(&value)?)
-	})
+#[jrsonnet_macros::builtin]
+fn builtin_parse_json(s: IStr) -> Result<Any> {
+	let value: serde_json::Value = serde_json::from_str(&s)
+		.map_err(|e| RuntimeError(format!("failed to parse json: {}", e).into()))?;
+	Ok(Any(Val::try_from(&value)?))
 }
 
-fn builtin_parse_yaml(context: Context, _loc: &ExprLocation, args: &ArgsDesc) -> Result<Val> {
-	parse_args!(context, "parseYaml", args, 1, [
-		0, s: ty!(string) => Val::Str;
-	], {
-		let value = serde_yaml::Deserializer::from_str_with_quirks(&s, DeserializingQuirks { old_octals: true });
-		let mut out = vec![];
-		for item in value {
-			let value = serde_json::Value::deserialize(item)
-				.map_err(|e| RuntimeError(format!("failed to parse yaml: {}", e).into()))?;
-			let val = Val::try_from(&value)?;
-			out.push(val);
-		}
-		if out.is_empty() {
-			Ok(Val::Null)
-		} else if out.len() == 1 {
-			Ok(out.into_iter().next().unwrap())
-		} else {
-			Ok(Val::Arr(out.into()))
-		}
-	})
+#[jrsonnet_macros::builtin]
+fn builtin_parse_yaml(s: IStr) -> Result<Any> {
+	let value = serde_yaml::Deserializer::from_str_with_quirks(
+		&s,
+		DeserializingQuirks { old_octals: true },
+	);
+	let mut out = vec![];
+	for item in value {
+		let value = serde_json::Value::deserialize(item)
+			.map_err(|e| RuntimeError(format!("failed to parse yaml: {}", e).into()))?;
+		let val = Val::try_from(&value)?;
+		out.push(val);
+	}
+	Ok(Any(if out.is_empty() {
+		Val::Null
+	} else if out.len() == 1 {
+		out.into_iter().next().unwrap()
+	} else {
+		Val::Arr(out.into())
+	}))
 }
 
-fn builtin_slice(context: Context, _loc: &ExprLocation, args: &ArgsDesc) -> Result<Val> {
-	parse_args!(context, "slice", args, 4, [
-		0, indexable: ty!((string | array));
-		1, index: ty!((number | null));
-		2, end: ty!((number | null));
-		3, step: ty!((number | null));
-	], {
-		std_slice(
-			indexable.into_indexable()?,
-			index.try_cast_nullable_num("index")?.map(|v| v as usize),
-			end.try_cast_nullable_num("end")?.map(|v| v as usize),
-			step.try_cast_nullable_num("step")?.map(|v| v as usize),
-		)
-	})
+#[jrsonnet_macros::builtin]
+fn builtin_slice(
+	indexable: IndexableVal,
+	index: Either<usize, Null>,
+	end: Either<usize, Null>,
+	step: Either<usize, Null>,
+) -> Result<Any> {
+	std_slice(indexable, index.left(), end.left(), step.left()).map(Any)
 }
 
-fn builtin_substr(context: Context, _loc: &ExprLocation, args: &ArgsDesc) -> Result<Val> {
-	parse_args!(context, "substr", args, 3, [
-		0, str: ty!(string) => Val::Str;
-		1, from: ty!(BoundedNumber<(Some(0.0)), (None)>) => Val::Num;
-		2, len: ty!(BoundedNumber<(Some(0.0)), (None)>) => Val::Num;
-	], {
-		let out: String = str.chars().skip(from as usize).take(len as usize).collect();
-		Ok(Val::Str(out.into()))
-	})
+#[jrsonnet_macros::builtin]
+fn builtin_substr(str: IStr, from: usize, len: usize) -> Result<String> {
+	Ok(str.chars().skip(from as usize).take(len as usize).collect())
 }
 
-fn builtin_primitive_equals(context: Context, _loc: &ExprLocation, args: &ArgsDesc) -> Result<Val> {
-	parse_args!(context, "primitiveEquals", args, 2, [
-		0, a: ty!(any);
-		1, b: ty!(any);
-	], {
-		Ok(Val::Bool(primitive_equals(&a, &b)?))
-	})
+#[jrsonnet_macros::builtin]
+fn builtin_primitive_equals(a: Any, b: Any) -> Result<bool> {
+	primitive_equals(&a.0, &b.0)
 }
 
-fn builtin_equals(context: Context, _loc: &ExprLocation, args: &ArgsDesc) -> Result<Val> {
-	parse_args!(context, "equals", args, 2, [
-		0, a: ty!(any);
-		1, b: ty!(any);
-	], {
-		Ok(Val::Bool(equals(&a, &b)?))
-	})
+#[jrsonnet_macros::builtin]
+fn builtin_equals(a: Any, b: Any) -> Result<bool> {
+	equals(&a.0, &b.0)
 }
 
-fn builtin_modulo(context: Context, _loc: &ExprLocation, args: &ArgsDesc) -> Result<Val> {
-	parse_args!(context, "modulo", args, 2, [
-		0, a: ty!(number) => Val::Num;
-		1, b: ty!(number) => Val::Num;
-	], {
-		Ok(Val::Num(a % b))
-	})
+#[jrsonnet_macros::builtin]
+fn builtin_modulo(a: f64, b: f64) -> Result<f64> {
+	Ok(a % b)
 }
 
-fn builtin_mod(context: Context, _loc: &ExprLocation, args: &ArgsDesc) -> Result<Val> {
-	parse_args!(context, "mod", args, 2, [
-		0, a: ty!((number | string));
-		1, b: ty!(any);
-	], {
-		evaluate_mod_op(&a, &b)
-	})
+#[jrsonnet_macros::builtin]
+fn builtin_mod(a: Either<f64, IStr>, b: Any) -> Result<Any> {
+	Ok(Any(evaluate_mod_op(
+		&match a {
+			Either::Left(v) => Val::Num(v),
+			Either::Right(s) => Val::Str(s),
+		},
+		&b.0,
+	)?))
 }
 
-fn builtin_floor(context: Context, _loc: &ExprLocation, args: &ArgsDesc) -> Result<Val> {
-	parse_args!(context, "floor", args, 1, [
-		0, x: ty!(number) => Val::Num;
-	], {
-		Ok(Val::Num(x.floor()))
-	})
+#[jrsonnet_macros::builtin]
+fn builtin_floor(x: f64) -> Result<f64> {
+	Ok(x.floor())
 }
 
-fn builtin_ceil(context: Context, _loc: &ExprLocation, args: &ArgsDesc) -> Result<Val> {
-	parse_args!(context, "ceil", args, 1, [
-		0, x: ty!(number) => Val::Num;
-	], {
-		Ok(Val::Num(x.ceil()))
-	})
+#[jrsonnet_macros::builtin]
+fn builtin_ceil(x: f64) -> Result<f64> {
+	Ok(x.ceil())
 }
 
-fn builtin_log(context: Context, _loc: &ExprLocation, args: &ArgsDesc) -> Result<Val> {
-	parse_args!(context, "log", args, 1, [
-		0, n: ty!(number) => Val::Num;
-	], {
-		Ok(Val::Num(n.ln()))
-	})
+#[jrsonnet_macros::builtin]
+fn builtin_log(n: f64) -> Result<f64> {
+	Ok(n.ln())
 }
 
-fn builtin_pow(context: Context, _loc: &ExprLocation, args: &ArgsDesc) -> Result<Val> {
-	parse_args!(context, "pow", args, 2, [
-		0, x: ty!(number) => Val::Num;
-		1, n: ty!(number) => Val::Num;
-	], {
-		Ok(Val::Num(x.powf(n)))
-	})
+#[jrsonnet_macros::builtin]
+fn builtin_pow(x: f64, n: f64) -> Result<f64> {
+	Ok(x.powf(n))
 }
 
-fn builtin_sqrt(context: Context, _loc: &ExprLocation, args: &ArgsDesc) -> Result<Val> {
-	parse_args!(context, "sqrt", args, 1, [
-		0, x: ty!(BoundedNumber<(Some(0.0)), (None)>) => Val::Num;
-	], {
-		Ok(Val::Num(x.sqrt()))
-	})
+#[jrsonnet_macros::builtin]
+fn builtin_sqrt(x: PositiveF64) -> Result<f64> {
+	Ok(x.0.sqrt())
 }
 
-fn builtin_sin(context: Context, _loc: &ExprLocation, args: &ArgsDesc) -> Result<Val> {
-	parse_args!(context, "sin", args, 1, [
-		0, x: ty!(number) => Val::Num;
-	], {
-		Ok(Val::Num(x.sin()))
-	})
+#[jrsonnet_macros::builtin]
+fn builtin_sin(x: f64) -> Result<f64> {
+	Ok(x.sin())
 }
 
-fn builtin_cos(context: Context, _loc: &ExprLocation, args: &ArgsDesc) -> Result<Val> {
-	parse_args!(context, "cos", args, 1, [
-		0, x: ty!(number) => Val::Num;
-	], {
-		Ok(Val::Num(x.cos()))
-	})
+#[jrsonnet_macros::builtin]
+fn builtin_cos(x: f64) -> Result<f64> {
+	Ok(x.cos())
 }
 
-fn builtin_tan(context: Context, _loc: &ExprLocation, args: &ArgsDesc) -> Result<Val> {
-	parse_args!(context, "tan", args, 1, [
-		0, x: ty!(number) => Val::Num;
-	], {
-		Ok(Val::Num(x.tan()))
-	})
+#[jrsonnet_macros::builtin]
+fn builtin_tan(x: f64) -> Result<f64> {
+	Ok(x.tan())
 }
 
-fn builtin_asin(context: Context, _loc: &ExprLocation, args: &ArgsDesc) -> Result<Val> {
-	parse_args!(context, "asin", args, 1, [
-		0, x: ty!(number) => Val::Num;
-	], {
-		Ok(Val::Num(x.asin()))
-	})
+#[jrsonnet_macros::builtin]
+fn builtin_asin(x: f64) -> Result<f64> {
+	Ok(x.asin())
 }
 
-fn builtin_acos(context: Context, _loc: &ExprLocation, args: &ArgsDesc) -> Result<Val> {
-	parse_args!(context, "acos", args, 1, [
-		0, x: ty!(number) => Val::Num;
-	], {
-		Ok(Val::Num(x.acos()))
-	})
+#[jrsonnet_macros::builtin]
+fn builtin_acos(x: f64) -> Result<f64> {
+	Ok(x.acos())
 }
 
-fn builtin_atan(context: Context, _loc: &ExprLocation, args: &ArgsDesc) -> Result<Val> {
-	parse_args!(context, "atan", args, 1, [
-		0, x: ty!(number) => Val::Num;
-	], {
-		Ok(Val::Num(x.atan()))
-	})
+#[jrsonnet_macros::builtin]
+fn builtin_atan(x: f64) -> Result<f64> {
+	Ok(x.atan())
 }
 
-fn builtin_exp(context: Context, _loc: &ExprLocation, args: &ArgsDesc) -> Result<Val> {
-	parse_args!(context, "exp", args, 1, [
-		0, x: ty!(number) => Val::Num;
-	], {
-		Ok(Val::Num(x.exp()))
-	})
+#[jrsonnet_macros::builtin]
+fn builtin_exp(x: f64) -> Result<f64> {
+	Ok(x.exp())
 }
 
 fn frexp(s: f64) -> (f64, i16) {
@@ -411,198 +330,140 @@
 	}
 }
 
-fn builtin_mantissa(context: Context, _loc: &ExprLocation, args: &ArgsDesc) -> Result<Val> {
-	parse_args!(context, "mantissa", args, 1, [
-		0, x: ty!(number) => Val::Num;
-	], {
-		Ok(Val::Num(frexp(x).0))
-	})
+#[jrsonnet_macros::builtin]
+fn builtin_mantissa(x: f64) -> Result<f64> {
+	Ok(frexp(x).0)
 }
 
-fn builtin_exponent(context: Context, _loc: &ExprLocation, args: &ArgsDesc) -> Result<Val> {
-	parse_args!(context, "exponent", args, 1, [
-		0, x: ty!(number) => Val::Num;
-	], {
-		Ok(Val::Num(frexp(x).1.into()))
-	})
+#[jrsonnet_macros::builtin]
+fn builtin_exponent(x: f64) -> Result<i16> {
+	Ok(frexp(x).1)
 }
 
-fn builtin_ext_var(context: Context, _loc: &ExprLocation, args: &ArgsDesc) -> Result<Val> {
-	parse_args!(context, "extVar", args, 1, [
-		0, x: ty!(string) => Val::Str;
-	], {
-		Ok(with_state(|s| s.settings().ext_vars.get(&x).cloned()).ok_or(UndefinedExternalVariable(x))?)
-	})
+#[jrsonnet_macros::builtin]
+fn builtin_ext_var(x: IStr) -> Result<Any> {
+	Ok(Any(with_state(|s| s.settings().ext_vars.get(&x).cloned())
+		.ok_or(UndefinedExternalVariable(x))?))
 }
 
-fn builtin_native(context: Context, _loc: &ExprLocation, args: &ArgsDesc) -> Result<Val> {
-	parse_args!(context, "native", args, 1, [
-		0, x: ty!(string) => Val::Str;
-	], {
-		Ok(with_state(|s| s.settings().ext_natives.get(&x).cloned()).map(|v| Val::Func(Cc::new(FuncVal::NativeExt(x.clone(), v)))).ok_or(UndefinedExternalFunction(x))?)
-	})
+#[jrsonnet_macros::builtin]
+fn builtin_native(name: IStr) -> Result<Cc<FuncVal>> {
+	Ok(with_state(|s| s.settings().ext_natives.get(&name).cloned())
+		.map(|v| Cc::new(FuncVal::NativeExt(name.clone(), v)))
+		.ok_or(UndefinedExternalFunction(name))?)
 }
 
-fn builtin_filter(context: Context, _loc: &ExprLocation, args: &ArgsDesc) -> Result<Val> {
-	parse_args!(context, "filter", args, 2, [
-		0, func: ty!(function) => Val::Func;
-		1, arr: ty!(array) => Val::Arr;
-	], {
-		Ok(Val::Arr(arr.filter(|val| func
-			.evaluate_values(context.clone(), &[val.clone()])?
-			.try_cast_bool("filter predicate"))?))
-	})
+#[jrsonnet_macros::builtin]
+fn builtin_filter(func: Cc<FuncVal>, arr: ArrValue) -> Result<ArrValue> {
+	arr.filter(|val| bool::try_from(func.evaluate_values(&[val.clone()])?))
 }
 
-fn builtin_map(context: Context, _loc: &ExprLocation, args: &ArgsDesc) -> Result<Val> {
-	parse_args!(context, "map", args, 2, [
-		0, func: ty!(function) => Val::Func;
-		1, arr: ty!(array) => Val::Arr;
-	], {
-		Ok(Val::Arr(arr.map(|val| func
-			.evaluate_values(context.clone(), &[val]))?))
-	})
+#[jrsonnet_macros::builtin]
+fn builtin_map(func: Cc<FuncVal>, arr: ArrValue) -> Result<ArrValue> {
+	arr.map(|val| func.evaluate_values(&[val]))
 }
 
-fn builtin_flatmap(context: Context, _loc: &ExprLocation, args: &ArgsDesc) -> Result<Val> {
-	parse_args!(context, "flatMap", args, 2, [
-		0, func: ty!(function) => Val::Func;
-		1, arr: ty!((array | string));
-	], {
-		match arr {
-			Val::Str(s) => {
-				let mut out = String::new();
-				for c in s.chars() {
-					match func.evaluate_values(context.clone(), &[Val::Str(c.to_string().into())])? {
-						Val::Str(o) => out.push_str(&o),
-						_ => throw!(RuntimeError("in std.join all items should be strings".into())),
-					};
-				}
-				Ok(Val::Str(out.into()))
-			},
-			Val::Arr(a) => {
-				let mut out = Vec::new();
-				for el in a.iter() {
-					let el = el?;
-					match func.evaluate_values(context.clone(), &[el])? {
-						Val::Arr(o) => for oe in o.iter() {
+#[jrsonnet_macros::builtin]
+fn builtin_flatmap(func: Cc<FuncVal>, arr: IndexableVal) -> Result<IndexableVal> {
+	match arr {
+		IndexableVal::Str(s) => {
+			let mut out = String::new();
+			for c in s.chars() {
+				match func.evaluate_values(&[Val::Str(c.to_string().into())])? {
+					Val::Str(o) => out.push_str(&o),
+					_ => throw!(RuntimeError(
+						"in std.join all items should be strings".into()
+					)),
+				};
+			}
+			Ok(IndexableVal::Str(out.into()))
+		}
+		IndexableVal::Arr(a) => {
+			let mut out = Vec::new();
+			for el in a.iter() {
+				let el = el?;
+				match func.evaluate_values(&[el])? {
+					Val::Arr(o) => {
+						for oe in o.iter() {
 							out.push(oe?)
-						},
-						_ => throw!(RuntimeError("in std.join all items should be arrays".into())),
-					};
-				}
-				Ok(Val::Arr(out.into()))
-			},
-			_ => unreachable!(),
+						}
+					}
+					_ => throw!(RuntimeError(
+						"in std.join all items should be arrays".into()
+					)),
+				};
+			}
+			Ok(IndexableVal::Arr(out.into()))
 		}
-	})
+	}
 }
 
-fn builtin_foldl(context: Context, _loc: &ExprLocation, args: &ArgsDesc) -> Result<Val> {
-	parse_args!(context, "foldl", args, 3, [
-		0, func: ty!(function) => Val::Func;
-		1, arr: ty!(array) => Val::Arr;
-		2, init: ty!(any);
-	], {
-		let mut acc = init;
-		for i in arr.iter() {
-			acc = func.evaluate_values(context.clone(), &[acc, i?])?;
-		}
-		Ok(acc)
-	})
+#[jrsonnet_macros::builtin]
+fn builtin_foldl(func: Cc<FuncVal>, arr: ArrValue, init: Any) -> Result<Any> {
+	let mut acc = init.0;
+	for i in arr.iter() {
+		acc = func.evaluate_values(&[acc, i?])?;
+	}
+	Ok(Any(acc))
 }
 
-fn builtin_foldr(context: Context, _loc: &ExprLocation, args: &ArgsDesc) -> Result<Val> {
-	parse_args!(context, "foldr", args, 3, [
-		0, func: ty!(function) => Val::Func;
-		1, arr: ty!(array) => Val::Arr;
-		2, init: ty!(any);
-	], {
-		let mut acc = init;
-		for i in arr.iter().rev() {
-			acc = func.evaluate_values(context.clone(), &[i?, acc])?;
-		}
-		Ok(acc)
-	})
+#[jrsonnet_macros::builtin]
+fn builtin_foldr(func: Cc<FuncVal>, arr: ArrValue, init: Any) -> Result<Any> {
+	let mut acc = init.0;
+	for i in arr.iter().rev() {
+		acc = func.evaluate_values(&[i?, acc])?;
+	}
+	Ok(Any(acc))
 }
 
+#[jrsonnet_macros::builtin]
 #[allow(non_snake_case)]
-fn builtin_sort_impl(context: Context, _loc: &ExprLocation, args: &ArgsDesc) -> Result<Val> {
-	parse_args!(context, "sort", args, 2, [
-		0, arr: ty!(array) => Val::Arr;
-		1, keyF: ty!(function) => Val::Func;
-	], {
-		if arr.len() <= 1 {
-			return Ok(Val::Arr(arr))
-		}
-		Ok(Val::Arr(ArrValue::Eager(sort::sort(context, arr.evaluated()?, &keyF)?)))
-	})
+fn builtin_sort_impl(arr: ArrValue, keyF: Cc<FuncVal>) -> Result<ArrValue> {
+	if arr.len() <= 1 {
+		return Ok(arr);
+	}
+	Ok(ArrValue::Eager(sort::sort(arr.evaluated()?, &keyF)?))
 }
 
-fn builtin_format(context: Context, _loc: &ExprLocation, args: &ArgsDesc) -> Result<Val> {
-	parse_args!(context, "format", args, 2, [
-		0, str: ty!(string) => Val::Str;
-		1, vals: ty!(any)
-	], {
-		std_format(str, vals)
-	})
+#[jrsonnet_macros::builtin]
+fn builtin_format(str: IStr, vals: Any) -> Result<String> {
+	std_format(str, vals.0)
 }
 
-fn builtin_range(context: Context, _loc: &ExprLocation, args: &ArgsDesc) -> Result<Val> {
-	parse_args!(context, "range", args, 2, [
-		0, from: ty!(number) => Val::Num;
-		1, to: ty!(number) => Val::Num;
-	], {
-		if to < from {
-			return Ok(Val::Arr(ArrValue::new_eager()))
-		}
-		let mut out = Vec::with_capacity((1+to as usize-from as usize).max(0));
-		for i in from as usize..=to as usize {
-			out.push(Val::Num(i as f64));
-		}
-		Ok(Val::Arr(out.into()))
-	})
+#[jrsonnet_macros::builtin]
+fn builtin_range(from: i32, to: i32) -> Result<VecVal> {
+	if to < from {
+		return Ok(VecVal(Vec::new()));
+	}
+	let mut out = Vec::with_capacity((1 + to as usize - from as usize).max(0));
+	for i in from as usize..=to as usize {
+		out.push(Val::Num(i as f64));
+	}
+	Ok(VecVal(out))
 }
 
-fn builtin_char(context: Context, _loc: &ExprLocation, args: &ArgsDesc) -> Result<Val> {
-	parse_args!(context, "char", args, 1, [
-		0, n: ty!(number) => Val::Num;
-	], {
-		let mut out = String::new();
-		out.push(std::char::from_u32(n as u32).ok_or_else(||
-			InvalidUnicodeCodepointGot(n as u32)
-		)?);
-		Ok(Val::Str(out.into()))
-	})
+#[jrsonnet_macros::builtin]
+fn builtin_char(n: u32) -> Result<char> {
+	Ok(std::char::from_u32(n as u32).ok_or_else(|| InvalidUnicodeCodepointGot(n as u32))?)
 }
 
-fn builtin_encode_utf8(context: Context, _loc: &ExprLocation, args: &ArgsDesc) -> Result<Val> {
-	parse_args!(context, "encodeUTF8", args, 1, [
-		0, str: ty!(string) => Val::Str;
-	], {
-		Ok(Val::Arr((str.bytes().map(|b| Val::Num(b as f64)).collect::<Vec<Val>>()).into()))
-	})
+#[jrsonnet_macros::builtin]
+fn builtin_encode_utf8(str: IStr) -> Result<VecVal> {
+	Ok(VecVal(
+		str.bytes()
+			.map(|b| Val::Num(b as f64))
+			.collect::<Vec<Val>>(),
+	))
 }
 
-fn builtin_decode_utf8(context: Context, _loc: &ExprLocation, args: &ArgsDesc) -> Result<Val> {
-	parse_args!(context, "decodeUTF8", args, 1, [
-		0, arr: ty!((Array<ubyte>)) => Val::Arr;
-	], {
-		let data: Result<Vec<u8>> = arr.iter().map(|v| v.map(|v| match v{
-			Val::Num(n) => n as u8,
-			_ => unreachable!(),
-		})).collect();
-		let data = data?;
-		Ok(Val::Str(String::from_utf8(data).map_err(|_| RuntimeError("bad utf8".into()))?.into()))
-	})
+#[jrsonnet_macros::builtin]
+fn builtin_decode_utf8(arr: Vec<u8>) -> Result<String> {
+	Ok(String::from_utf8(arr).map_err(|_| RuntimeError("bad utf8".into()))?)
 }
 
-fn builtin_md5(context: Context, _loc: &ExprLocation, args: &ArgsDesc) -> Result<Val> {
-	parse_args!(context, "md5", args, 1, [
-		0, str: ty!(string) => Val::Str;
-	], {
-		Ok(Val::Str(format!("{:x}", md5::compute(&str.as_bytes())).into()))
-	})
+#[jrsonnet_macros::builtin]
+fn builtin_md5(str: IStr) -> Result<String> {
+	Ok(format!("{:x}", md5::compute(&str.as_bytes())))
 }
 
 fn builtin_trace(context: Context, loc: &ExprLocation, args: &ArgsDesc) -> Result<Val> {
@@ -620,251 +481,174 @@
 	})
 }
 
-fn builtin_base64(context: Context, _loc: &ExprLocation, args: &ArgsDesc) -> Result<Val> {
-	parse_args!(context, "base64", args, 1, [
-		0, input: ty!((string | (Array<number>)));
-	], {
-		Ok(Val::Str(match input {
-			Val::Str(s) => {
-				base64::encode(s.bytes().collect::<Vec<_>>()).into()
-			},
-			Val::Arr(a) => {
-				base64::encode(a.iter().map(|v| {
-					Ok(v?.unwrap_num()? as u8)
-				}).collect::<Result<Vec<_>>>()?).into()
-			},
-			_ => unreachable!()
-		}))
+#[jrsonnet_macros::builtin]
+fn builtin_base64(input: Either<Vec<u8>, IStr>) -> Result<String> {
+	Ok(match input {
+		Either::Left(a) => base64::encode(a),
+		Either::Right(l) => base64::encode(l.bytes().collect::<Vec<_>>()),
 	})
 }
 
-fn builtin_base64_decode_bytes(
-	context: Context,
-	_loc: &ExprLocation,
-	args: &ArgsDesc,
-) -> Result<Val> {
-	parse_args!(context, "base64DecodeBytes", args, 1, [
-		0, input: ty!(string) => Val::Str;
-	], {
-		Ok(Val::Arr(
-			base64::decode(&input.as_bytes())
-				.map_err(|_| RuntimeError("bad base64".into()))?
-				.iter()
-				.map(|v| Val::Num(*v as f64)).collect::<Vec<_>>().into()
-		))
-	})
+#[jrsonnet_macros::builtin]
+fn builtin_base64_decode_bytes(input: IStr) -> Result<Vec<u8>> {
+	Ok(base64::decode(&input.as_bytes()).map_err(|_| RuntimeError("bad base64".into()))?)
 }
 
-fn builtin_base64_decode(context: Context, _loc: &ExprLocation, args: &ArgsDesc) -> Result<Val> {
-	parse_args!(context, "base64Decode", args, 1, [
-		0, input: ty!(string) => Val::Str;
-	], {
-		Ok(Val::Str(
-			String::from_utf8(base64::decode(&input.as_bytes())
-				.map_err(|_| RuntimeError("bad base64".into()))?)
-				.map_err(|_| RuntimeError("bad utf8".into()))?.into()
-		))
-	})
+#[jrsonnet_macros::builtin]
+fn builtin_base64_decode(input: IStr) -> Result<String> {
+	let bytes = base64::decode(&input.as_bytes()).map_err(|_| RuntimeError("bad base64".into()))?;
+	Ok(String::from_utf8(bytes).map_err(|_| RuntimeError("bad utf8".into()))?)
 }
 
-fn builtin_join(context: Context, _loc: &ExprLocation, args: &ArgsDesc) -> Result<Val> {
-	parse_args!(context, "join", args, 2, [
-		0, sep: ty!((string | array));
-		1, arr: ty!(array) => Val::Arr;
-	], {
-		Ok(match sep {
-			Val::Arr(joiner_items) => {
-				let mut out = Vec::new();
+#[jrsonnet_macros::builtin]
+fn builtin_join(sep: IndexableVal, arr: ArrValue) -> Result<IndexableVal> {
+	Ok(match sep {
+		IndexableVal::Arr(joiner_items) => {
+			let mut out = Vec::new();
 
-				let mut first = true;
-				for item in arr.iter() {
-					let item = item?.clone();
-					if let Val::Arr(items) = item {
-						if !first {
-							out.reserve(joiner_items.len());
-							// TODO: extend
-							for item in joiner_items.iter() {
-								out.push(item?);
-							}
-						}
-						first = false;
-						out.reserve(items.len());
+			let mut first = true;
+			for item in arr.iter() {
+				let item = item?.clone();
+				if let Val::Arr(items) = item {
+					if !first {
+						out.reserve(joiner_items.len());
 						// TODO: extend
-						for item in items.iter() {
+						for item in joiner_items.iter() {
 							out.push(item?);
 						}
-					} else {
-						throw!(RuntimeError("in std.join all items should be arrays".into()));
 					}
+					first = false;
+					out.reserve(items.len());
+					// TODO: extend
+					for item in items.iter() {
+						out.push(item?);
+					}
+				} else {
+					throw!(RuntimeError(
+						"in std.join all items should be arrays".into()
+					));
 				}
+			}
 
-				Val::Arr(out.into())
-			},
-			Val::Str(sep) => {
-				let mut out = String::new();
+			IndexableVal::Arr(out.into())
+		}
+		IndexableVal::Str(sep) => {
+			let mut out = String::new();
 
-				let mut first = true;
-				for item in arr.iter() {
-					let item = item?.clone();
-					if let Val::Str(item) = item {
-						if !first {
-							out += &sep;
-						}
-						first = false;
-						out += &item;
-					} else {
-						throw!(RuntimeError("in std.join all items should be strings".into()));
+			let mut first = true;
+			for item in arr.iter() {
+				let item = item?.clone();
+				if let Val::Str(item) = item {
+					if !first {
+						out += &sep;
 					}
+					first = false;
+					out += &item;
+				} else {
+					throw!(RuntimeError(
+						"in std.join all items should be strings".into()
+					));
 				}
+			}
 
-				Val::Str(out.into())
-			},
-			_ => unreachable!()
-		})
+			IndexableVal::Str(out.into())
+		}
 	})
 }
 
-fn builtin_escape_string_json(
-	context: Context,
-	_loc: &ExprLocation,
-	args: &ArgsDesc,
-) -> Result<Val> {
-	parse_args!(context, "escapeStringJson", args, 1, [
-		0, str_: ty!(string) => Val::Str;
-	], {
-		Ok(Val::Str(escape_string_json(&str_).into()))
-	})
+#[jrsonnet_macros::builtin]
+fn builtin_escape_string_json(str_: IStr) -> Result<String> {
+	Ok(escape_string_json(&str_))
 }
 
-fn builtin_manifest_json_ex(context: Context, _loc: &ExprLocation, args: &ArgsDesc) -> Result<Val> {
-	parse_args!(context, "manifestJsonEx", args, 2, [
-		0, value: ty!(any);
-		1, indent: ty!(string) => Val::Str;
-	], {
-		Ok(Val::Str(manifest_json_ex(&value, &ManifestJsonOptions {
+#[jrsonnet_macros::builtin]
+fn builtin_manifest_json_ex(value: Any, indent: IStr) -> Result<String> {
+	manifest_json_ex(
+		&value.0,
+		&ManifestJsonOptions {
 			padding: &indent,
 			mtype: ManifestType::Std,
-		})?.into()))
-	})
+		},
+	)
 }
 
+#[jrsonnet_macros::builtin]
 fn builtin_manifest_yaml_doc(
-	context: Context,
-	_loc: &ExprLocation,
-	args: &ArgsDesc,
-) -> Result<Val> {
-	parse_args!(context, "manifestYamlDoc", args, 3, [
-		0, value: ty!(any);
-		1, indent_array_in_object: ty!(boolean) => Val::Bool;
-		2, quote_keys: ty!(boolean) => Val::Bool;
-	], {
-		Ok(Val::Str(manifest_yaml_ex(&value, &ManifestYamlOptions {
+	value: Any,
+	indent_array_in_object: bool,
+	quote_keys: bool,
+) -> Result<String> {
+	manifest_yaml_ex(
+		&value.0,
+		&ManifestYamlOptions {
 			padding: "  ",
 			arr_element_padding: if indent_array_in_object { "  " } else { "" },
 			quote_keys,
-		})?.into()))
-	})
+		},
+	)
 }
 
-fn builtin_reverse(context: Context, _loc: &ExprLocation, args: &ArgsDesc) -> Result<Val> {
-	parse_args!(context, "reverse", args, 1, [
-		0, value: ty!(array) => Val::Arr;
-	], {
-		Ok(Val::Arr(value.reversed()))
-	})
+#[jrsonnet_macros::builtin]
+fn builtin_reverse(value: ArrValue) -> Result<ArrValue> {
+	Ok(value.reversed())
 }
 
-fn builtin_id(context: Context, _loc: &ExprLocation, args: &ArgsDesc) -> Result<Val> {
-	parse_args!(context, "id", args, 1, [
-		0, v: ty!(any);
-	], {
-		Ok(v)
-	})
+#[jrsonnet_macros::builtin]
+const fn builtin_id(v: Any) -> Result<Any> {
+	Ok(v)
 }
 
-fn builtin_str_replace(context: Context, _loc: &ExprLocation, args: &ArgsDesc) -> Result<Val> {
-	parse_args!(context, "strReplace", args, 3, [
-		0, str: ty!(string) => Val::Str;
-		1, from: ty!(string) => Val::Str;
-		2, to: ty!(string) => Val::Str;
-	], {
-		Ok(Val::Str(str.replace(&from as &str, &to as &str).into()))
-	})
+#[jrsonnet_macros::builtin]
+fn builtin_str_replace(str: String, from: IStr, to: IStr) -> Result<String> {
+	Ok(str.replace(&from as &str, &to as &str))
 }
-
-fn builtin_splitlimit(context: Context, _loc: &ExprLocation, args: &ArgsDesc) -> Result<Val> {
-	parse_args!(context, "splitLimit", args, 3, [
-		0, str: ty!(string) => Val::Str;
-		1, c: ty!(char) => Val::Str;
-		2, maxsplits: ty!(number) => Val::Num;
-	], {
-		let maxsplits = maxsplits as isize;
-		let c = c.chars().next().unwrap();
 
-		let out: Vec<Val> = if maxsplits == -1 {
-			str.split(c).map(|s| Val::Str(s.into())).collect()
-		} else {
-			str.splitn(maxsplits as usize + 1, c).map(|s| Val::Str(s.into())).collect()
-		};
-
-		Ok(Val::Arr(out.into()))
-	})
+#[jrsonnet_macros::builtin]
+fn builtin_splitlimit(str: IStr, c: char, maxsplits: Either<usize, M1>) -> Result<VecVal> {
+	Ok(VecVal(match maxsplits {
+		Either::Left(n) => str.splitn(n + 1, c).map(|s| Val::Str(s.into())).collect(),
+		Either::Right(_) => str.split(c).map(|s| Val::Str(s.into())).collect(),
+	}))
 }
 
-fn builtin_ascii_upper(context: Context, _loc: &ExprLocation, args: &ArgsDesc) -> Result<Val> {
-	parse_args!(context, "asciiUpper", args, 1, [
-		0, str: ty!(string) => Val::Str;
-	], {
-		Ok(Val::Str(str.to_ascii_uppercase().into()))
-	})
+#[jrsonnet_macros::builtin]
+fn builtin_ascii_upper(str: IStr) -> Result<String> {
+	Ok(str.to_ascii_uppercase())
 }
 
-fn builtin_ascii_lower(context: Context, _loc: &ExprLocation, args: &ArgsDesc) -> Result<Val> {
-	parse_args!(context, "asciiLower", args, 1, [
-		0, str: ty!(string) => Val::Str;
-	], {
-		Ok(Val::Str(str.to_ascii_lowercase().into()))
-	})
+#[jrsonnet_macros::builtin]
+fn builtin_ascii_lower(str: IStr) -> Result<String> {
+	Ok(str.to_ascii_lowercase())
 }
 
-fn builtin_member(context: Context, _loc: &ExprLocation, args: &ArgsDesc) -> Result<Val> {
-	parse_args!(context, "member", args, 2, [
-		0, arr: ty!((array | string));
-		1, x: ty!(any);
-	], {
-		match arr {
-			Val::Str(s) => {
-				let x = x.try_cast_str("x should be string")?;
-				Ok(Val::Bool(!x.is_empty() && s.contains(&*x)))
-			}
-			Val::Arr(a) => {
-				for item in a.iter() {
-					let item = item?;
-					if equals(&item, &x)? {
-						return Ok(Val::Bool(true));
-					}
+#[jrsonnet_macros::builtin]
+fn builtin_member(arr: IndexableVal, x: Any) -> Result<bool> {
+	match arr {
+		IndexableVal::Str(s) => {
+			let x: IStr = IStr::try_from(x.0)?;
+			Ok(!x.is_empty() && s.contains(&*x))
+		}
+		IndexableVal::Arr(a) => {
+			for item in a.iter() {
+				let item = item?;
+				if equals(&item, &x.0)? {
+					return Ok(true);
 				}
-				Ok(Val::Bool(false))
 			}
-			_ => unreachable!(),
+			Ok(false)
 		}
-	})
+	}
 }
 
-fn builtin_count(context: Context, _loc: &ExprLocation, args: &ArgsDesc) -> Result<Val> {
-	parse_args!(context, "count", args, 2, [
-		0, arr: ty!(array) => Val::Arr;
-		1, x: ty!(any);
-	], {
-		let mut count = 0;
-		for item in arr.iter() {
-			let item = item?;
-			if equals(&item, &x)? {
-				count += 1;
-			}
+#[jrsonnet_macros::builtin]
+fn builtin_count(arr: Vec<Any>, v: Any) -> Result<usize> {
+	let mut count = 0;
+	for item in arr.iter() {
+		if equals(&item.0, &v.0)? {
+			count += 1;
 		}
-		Ok(Val::Num(count as f64))
-	})
+	}
+	Ok(count)
 }
 
 pub fn call_builtin(

--- a/crates/jrsonnet-evaluator/src/builtin/sort.rs
+++ b/crates/jrsonnet-evaluator/src/builtin/sort.rs
@@ -1,6 +1,6 @@
 use crate::{
 	error::{Error, LocError, Result},
-	throw, Context, FuncVal, Val,
+	throw, FuncVal, Val,
 };
 use gcmodule::{Cc, Trace};
 
@@ -59,7 +59,7 @@
 	Ok(sort_type)
 }
 
-pub fn sort(ctx: Context, values: Cc<Vec<Val>>, key_getter: &FuncVal) -> Result<Cc<Vec<Val>>> {
+pub fn sort(values: Cc<Vec<Val>>, key_getter: &FuncVal) -> Result<Cc<Vec<Val>>> {
 	if values.len() <= 1 {
 		return Ok(values);
 	}
@@ -81,10 +81,7 @@
 	} else {
 		let mut vk = Vec::with_capacity(values.len());
 		for value in values.iter() {
-			vk.push((
-				value.clone(),
-				key_getter.evaluate_values(ctx.clone(), &[value.clone()])?,
-			));
+			vk.push((value.clone(), key_getter.evaluate_values(&[value.clone()])?));
 		}
 		let sort_type = get_sort_type(&mut vk, |v| &mut v.1)?;
 		match sort_type {

--- a/crates/jrsonnet-evaluator/src/evaluate/mod.rs
+++ b/crates/jrsonnet-evaluator/src/evaluate/mod.rs
@@ -1,3 +1,5 @@
+use std::convert::TryFrom;
+
 use crate::{
 	builtin::std_slice,
 	error::Error::*,
@@ -189,14 +191,18 @@
 ) -> Result<Option<IStr>> {
 	Ok(match field_name {
 		jrsonnet_parser::FieldName::Fixed(n) => Some(n.clone()),
-		jrsonnet_parser::FieldName::Dyn(expr) => {
-			let value = evaluate(context, expr)?;
-			if matches!(value, Val::Null) {
-				None
-			} else {
-				Some(value.try_cast_str("dynamic field name")?)
-			}
-		}
+		jrsonnet_parser::FieldName::Dyn(expr) => push_frame(
+			&expr.1,
+			|| "evaluating field name".to_string(),
+			|| {
+				let value = evaluate(context, expr)?;
+				if matches!(value, Val::Null) {
+					Ok(None)
+				} else {
+					Ok(Some(IStr::try_from(value)?))
+				}
+			},
+		)?,
 	})
 }
 
@@ -208,7 +214,7 @@
 	match specs.get(0) {
 		None => callback(context)?,
 		Some(CompSpec::IfSpec(IfSpecData(cond))) => {
-			if evaluate(context.clone(), cond)?.try_cast_bool("if spec")? {
+			if bool::try_from(evaluate(context.clone(), cond)?)? {
 				evaluate_comp(context, &specs[1..], callback)?
 			}
 		}
@@ -459,10 +465,7 @@
 	let assertion_result = push_frame(
 		&value.1,
 		|| "assertion condition".to_owned(),
-		|| {
-			evaluate(context.clone(), value)?
-				.try_cast_bool("assertion condition should be of type `boolean`")
-		},
+		|| bool::try_from(evaluate(context.clone(), value)?),
 	)?;
 	if !assertion_result {
 		push_frame(
@@ -633,11 +636,7 @@
 		ErrorStmt(e) => push_frame(
 			loc,
 			|| "error statement".to_owned(),
-			|| {
-				throw!(RuntimeError(
-					evaluate(context, e)?.try_cast_str("error text should be of type `string`")?,
-				))
-			},
+			|| throw!(RuntimeError(IStr::try_from(evaluate(context, e)?)?,)),
 		)?,
 		IfElse {
 			cond,
@@ -647,7 +646,7 @@
 			if push_frame(
 				loc,
 				|| "if condition".to_owned(),
-				|| evaluate(context.clone(), &cond.0)?.try_cast_bool("in if condition"),
+				|| bool::try_from(evaluate(context.clone(), &cond.0)?),
 			)? {
 				evaluate(context, cond_then)?
 			} else {

--- a/crates/jrsonnet-evaluator/src/evaluate/operator.rs
+++ b/crates/jrsonnet-evaluator/src/evaluate/operator.rs
@@ -1,3 +1,5 @@
+use std::convert::TryInto;
+
 use crate::builtin::std_format;
 use crate::{equals, evaluate, Context, Val};
 use crate::{error::Error::*, throw, Result};
@@ -46,7 +48,7 @@
 	use Val::*;
 	match (a, b) {
 		(Num(a), Num(b)) => Ok(Num(a % b)),
-		(Str(str), vals) => std_format(str.clone(), vals.clone()),
+		(Str(str), vals) => std_format(str.clone(), vals.clone())?.try_into(),
 		(a, b) => throw!(BinaryOperatorDoesNotOperateOnValues(
 			BinaryOpType::Mod,
 			a.value_type(),

--- a/crates/jrsonnet-evaluator/src/function.rs
+++ b/crates/jrsonnet-evaluator/src/function.rs
@@ -141,6 +141,93 @@
 	}
 }
 
+#[derive(Clone, Copy)]
+pub struct BuiltinParam {
+	pub name: &'static str,
+	pub has_default: bool,
+}
+
+/// You shouldn't probally use this function, use jrsonnet_macros::builtin instead
+///
+/// ## Parameters
+/// * `ctx`: used for passed argument expressions' execution and for body execution (if `body_ctx` is not set)
+/// * `params`: function parameters' definition
+/// * `args`: passed function arguments
+/// * `tailstrict`: if set to `true` function arguments are eagerly executed, otherwise - lazily
+pub fn parse_builtin_call<'k>(
+	ctx: Context,
+	params: &'static [BuiltinParam],
+	args: &'k ArgsDesc,
+	tailstrict: bool,
+) -> Result<GcHashMap<&'k str, LazyVal>> {
+	let mut passed_args = GcHashMap::with_capacity(params.len());
+	if args.unnamed.len() > params.len() {
+		throw!(TooManyArgsFunctionHas(params.len()))
+	}
+
+	let mut filled_args = 0;
+
+	for (id, arg) in args.unnamed.iter().enumerate() {
+		let name = params[id].name;
+		passed_args.insert(
+			name,
+			if tailstrict {
+				LazyVal::new_resolved(evaluate(ctx.clone(), arg)?)
+			} else {
+				LazyVal::new(TraceBox(Box::new(EvaluateLazyVal {
+					context: ctx.clone(),
+					expr: arg.clone(),
+				})))
+			},
+		);
+		filled_args += 1;
+	}
+
+	for (name, value) in args.named.iter() {
+		// FIXME: O(n) for arg existence check
+		if !params.iter().any(|p| p.name == name as &str) {
+			throw!(UnknownFunctionParameter((name as &str).to_owned()));
+		}
+		if passed_args
+			.insert(
+				name,
+				if tailstrict {
+					LazyVal::new_resolved(evaluate(ctx.clone(), value)?)
+				} else {
+					LazyVal::new(TraceBox(Box::new(EvaluateLazyVal {
+						context: ctx.clone(),
+						expr: value.clone(),
+					})))
+				},
+			)
+			.is_some()
+		{
+			throw!(BindingParameterASecondTime(name.clone()));
+		}
+		filled_args += 1;
+	}
+
+	if filled_args < params.len() {
+		for param in params.iter().filter(|p| p.has_default) {
+			if passed_args.contains_key(&param.name) {
+				continue;
+			}
+			filled_args += 1;
+		}
+
+		// Some args still wasn't filled
+		if filled_args != params.len() {
+			for param in params.iter().skip(args.unnamed.len()) {
+				if !args.named.iter().any(|a| &a.0 as &str == param.name) {
+					throw!(FunctionParameterNotBoundInCall(param.name.into()));
+				}
+			}
+			unreachable!();
+		}
+	}
+	Ok(passed_args)
+}
+
 pub fn parse_function_call_map(
 	ctx: Context,
 	body_ctx: Option<Context>,
@@ -201,12 +288,7 @@
 	Ok(body_ctx.unwrap_or(ctx).extend(out, None, None, None))
 }
 
-pub fn place_args(
-	ctx: Context,
-	body_ctx: Option<Context>,
-	params: &ParamsDesc,
-	args: &[Val],
-) -> Result<Context> {
+pub fn place_args(body_ctx: Context, params: &ParamsDesc, args: &[Val]) -> Result<Context> {
 	let mut out = GcHashMap::with_capacity(params.len());
 	let mut positioned_args = vec![None; params.0.len()];
 	for (id, arg) in args.iter().enumerate() {
@@ -220,14 +302,14 @@
 		let val = if let Some(arg) = &positioned_args[id] {
 			(*arg).clone()
 		} else if let Some(default) = &p.1 {
-			evaluate(ctx.clone(), default)?
+			evaluate(body_ctx.clone(), default)?
 		} else {
 			throw!(FunctionParameterNotBoundInCall(p.0.clone()));
 		};
 		out.insert(p.0.clone(), LazyVal::new_resolved(val));
 	}
 
-	Ok(body_ctx.unwrap_or(ctx).extend(out, None, None, None))
+	Ok(body_ctx.extend(out, None, None, None))
 }
 
 #[macro_export]

--- a/crates/jrsonnet-evaluator/src/trace/mod.rs
+++ b/crates/jrsonnet-evaluator/src/trace/mod.rs
@@ -122,6 +122,7 @@
 			.map(|el| &el.location)
 			.map(|location| {
 				use std::fmt::Write;
+				#[allow(clippy::option_if_let_else)]
 				if let Some(location) = location {
 					let mut resolved_path = self.resolver.resolve(&location.0);
 					// TODO: Process all trace elements first

--- a/crates/jrsonnet-evaluator/src/val.rs
+++ b/crates/jrsonnet-evaluator/src/val.rs
@@ -170,10 +170,10 @@
 		}
 	}
 
-	pub fn evaluate_values(&self, call_ctx: Context, args: &[Val]) -> Result<Val> {
+	pub fn evaluate_values(&self, args: &[Val]) -> Result<Val> {
 		match self {
 			Self::Normal(func) => {
-				let ctx = place_args(call_ctx, Some(func.ctx.clone()), &func.params, args)?;
+				let ctx = place_args(func.ctx.clone(), &func.params, args)?;
 				evaluate(ctx, &func.body)
 			}
 			Self::Intrinsic(_) => todo!(),
@@ -363,14 +363,6 @@
 	Func(Cc<FuncVal>),
 }
 
-macro_rules! matches_unwrap {
-	($e: expr, $p: pat, $r: expr) => {
-		match $e {
-			$p => $r,
-			_ => panic!("no match"),
-		}
-	};
-}
 impl Val {
 	/// Creates `Val::Num` after checking for numeric overflow.
 	/// As numbers are `f64`, we can just check for their finity.
@@ -382,38 +374,6 @@
 		}
 	}
 
-	pub fn assert_type(&self, context: &'static str, val_type: ValType) -> Result<()> {
-		let this_type = self.value_type();
-		if this_type != val_type {
-			throw!(TypeMismatch(context, vec![val_type], this_type))
-		} else {
-			Ok(())
-		}
-	}
-	pub fn unwrap_num(self) -> Result<f64> {
-		Ok(matches_unwrap!(self, Self::Num(v), v))
-	}
-	pub fn unwrap_str(self) -> Result<IStr> {
-		Ok(matches_unwrap!(self, Self::Str(v), v))
-	}
-	pub fn unwrap_arr(self) -> Result<ArrValue> {
-		Ok(matches_unwrap!(self, Self::Arr(v), v))
-	}
-	pub fn unwrap_func(self) -> Result<Cc<FuncVal>> {
-		Ok(matches_unwrap!(self, Self::Func(v), v))
-	}
-	pub fn try_cast_bool(self, context: &'static str) -> Result<bool> {
-		self.assert_type(context, ValType::Bool)?;
-		Ok(matches_unwrap!(self, Self::Bool(v), v))
-	}
-	pub fn try_cast_str(self, context: &'static str) -> Result<IStr> {
-		self.assert_type(context, ValType::Str)?;
-		Ok(matches_unwrap!(self, Self::Str(v), v))
-	}
-	pub fn try_cast_num(self, context: &'static str) -> Result<f64> {
-		self.assert_type(context, ValType::Num)?;
-		self.unwrap_num()
-	}
 	pub fn try_cast_nullable_num(self, context: &'static str) -> Result<Option<f64>> {
 		Ok(match self {
 			Val::Null => None,

--- a/crates/jrsonnet-types/src/lib.rs
+++ b/crates/jrsonnet-types/src/lib.rs
@@ -42,14 +42,14 @@
 		$crate::ComplexValType::Simple($crate::ValType::Func)
 	};
 	(($($a:tt) |+)) => {{
-		static CONTENTS: &'static [$crate::ComplexValType] = &[
-			$(ty!($a)),+
+		static CONTENTS: &'static [&'static $crate::ComplexValType] = &[
+			$(&ty!($a)),+
 		];
 		$crate::ComplexValType::UnionRef(CONTENTS)
 	}};
 	(($($a:tt) &+)) => {{
-		static CONTENTS: &'static [$crate::ComplexValType] = &[
-			$(ty!($a)),+
+		static CONTENTS: &'static [&'static $crate::ComplexValType] = &[
+			$(&ty!($a)),+
 		];
 		$crate::ComplexValType::SumRef(CONTENTS)
 	}};
@@ -66,8 +66,8 @@
 	assert_eq!(
 		ty!((string | number)),
 		ComplexValType::UnionRef(&[
-			ComplexValType::Simple(ValType::Str),
-			ComplexValType::Simple(ValType::Num)
+			&ComplexValType::Simple(ValType::Str),
+			&ComplexValType::Simple(ValType::Num)
 		])
 	);
 	assert_eq!(
@@ -124,9 +124,9 @@
 	ArrayRef(&'static ComplexValType),
 	ObjectRef(&'static [(&'static str, ComplexValType)]),
 	Union(Vec<ComplexValType>),
-	UnionRef(&'static [ComplexValType]),
+	UnionRef(&'static [&'static ComplexValType]),
 	Sum(Vec<ComplexValType>),
-	SumRef(&'static [ComplexValType]),
+	SumRef(&'static [&'static ComplexValType]),
 }
 
 impl From<ValType> for ComplexValType {
@@ -135,12 +135,12 @@
 	}
 }
 
-fn write_union(
+fn write_union<'i>(
 	f: &mut std::fmt::Formatter<'_>,
 	is_union: bool,
-	union: &[ComplexValType],
+	union: impl Iterator<Item = &'i ComplexValType>,
 ) -> std::fmt::Result {
-	for (i, v) in union.iter().enumerate() {
+	for (i, v) in union.enumerate() {
 		let should_add_braces =
 			matches!(v, ComplexValType::UnionRef(_) | ComplexValType::Union(_) if !is_union);
 		if i != 0 {
@@ -190,10 +190,10 @@
 				}
 				write!(f, "}}")?;
 			}
-			ComplexValType::Union(v) => write_union(f, true, v)?,
-			ComplexValType::UnionRef(v) => write_union(f, true, v)?,
-			ComplexValType::Sum(v) => write_union(f, false, v)?,
-			ComplexValType::SumRef(v) => write_union(f, false, v)?,
+			ComplexValType::Union(v) => write_union(f, true, v.iter())?,
+			ComplexValType::UnionRef(v) => write_union(f, true, v.iter().map(|v| *v))?,
+			ComplexValType::Sum(v) => write_union(f, false, v.iter())?,
+			ComplexValType::SumRef(v) => write_union(f, false, v.iter().map(|v| *v))?,
 		};
 		Ok(())
 	}