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

--- a/Cargo.lock
+++ b/Cargo.lock
@@ -167,26 +167,34 @@
  "bincode",
  "closure",
  "indexmap",
+ "jrsonnet-interner",
  "jrsonnet-parser",
  "jrsonnet-stdlib",
+ "jrsonnet-types",
  "md5",
  "pathdiff",
  "rustc-hash",
  "serde",
  "serde_json",
- "structdump",
  "thiserror",
 ]
 
 [[package]]
+name = "jrsonnet-interner"
+version = "0.3.3"
+dependencies = [
+ "rustc-hash",
+ "serde",
+]
+
+[[package]]
 name = "jrsonnet-parser"
 version = "0.3.3"
 dependencies = [
+ "jrsonnet-interner",
  "jrsonnet-stdlib",
  "peg",
  "serde",
- "structdump",
- "structdump-derive",
  "unescape",
 ]
 
@@ -195,10 +203,18 @@
 version = "0.3.3"
 
 [[package]]
+name = "jrsonnet-types"
+version = "0.3.3"
+dependencies = [
+ "peg",
+]
+
+[[package]]
 name = "jsonnet"
 version = "0.3.3"
 dependencies = [
  "jrsonnet-evaluator",
+ "jrsonnet-interner",
  "jrsonnet-parser",
 ]
 
@@ -370,23 +386,6 @@
 version = "0.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623"
-
-[[package]]
-name = "structdump"
-version = "0.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2e16ec33a0342fdb67d13913b4ffae6527ebccfa04b5d7da174bdc7a31db29b8"
-
-[[package]]
-name = "structdump-derive"
-version = "0.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "06c337fdc077e02ccbfcc62af0090564a4af342975c3b7be09705efab90c1888"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
 
 [[package]]
 name = "syn"

--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,11 +1,13 @@
 [workspace]
 members = [
+	"crates/jrsonnet-interner",
 	"crates/jrsonnet-parser",
 	"crates/jrsonnet-evaluator",
 	"crates/jrsonnet-stdlib",
 	"crates/jrsonnet-cli",
+	"crates/jrsonnet-types",
 	"bindings/jsonnet",
-	"cmds/jrsonnet"
+	"cmds/jrsonnet",
 ]
 
 [profile.test]

--- a/bindings/jsonnet/Cargo.toml
+++ b/bindings/jsonnet/Cargo.toml
@@ -5,6 +5,7 @@
 edition = "2018"
 
 [dependencies]
+jrsonnet-interner = { path = "../../crates/jrsonnet-interner", version = "0.3.3" }
 jrsonnet-evaluator = { path = "../../crates/jrsonnet-evaluator", version = "0.3.3" }
 jrsonnet-parser = { path = "../../crates/jrsonnet-parser", version = "0.3.3" }
 

--- a/bindings/jsonnet/src/import.rs
+++ b/bindings/jsonnet/src/import.rs
@@ -4,6 +4,7 @@
 	error::{Error::*, Result},
 	throw, EvaluationState, ImportResolver,
 };
+use jrsonnet_interner::IStr;
 use std::{
 	any::Any,
 	cell::RefCell,
@@ -30,7 +31,7 @@
 	cb: JsonnetImportCallback,
 	ctx: *mut c_void,
 
-	out: RefCell<HashMap<PathBuf, Rc<str>>>,
+	out: RefCell<HashMap<PathBuf, IStr>>,
 }
 impl ImportResolver for CallbackImportResolver {
 	fn resolve_file(&self, from: &PathBuf, path: &PathBuf) -> Result<Rc<PathBuf>> {
@@ -75,7 +76,7 @@
 
 		Ok(Rc::new(found_here_buf))
 	}
-	fn load_file_contents(&self, resolved: &PathBuf) -> Result<Rc<str>> {
+	fn load_file_contents(&self, resolved: &PathBuf) -> Result<IStr> {
 		Ok(self.out.borrow().get(resolved).unwrap().clone())
 	}
 	unsafe fn as_any(&self) -> &dyn Any {
@@ -124,7 +125,7 @@
 			throw!(ImportFileNotFound(from.clone(), path.clone()))
 		}
 	}
-	fn load_file_contents(&self, id: &PathBuf) -> Result<Rc<str>> {
+	fn load_file_contents(&self, id: &PathBuf) -> Result<IStr> {
 		let mut file = File::open(id).map_err(|_e| ResolvedFileNotFound(id.clone()))?;
 		let mut out = String::new();
 		file.read_to_string(&mut out)

--- a/bindings/jsonnet/src/lib.rs
+++ b/bindings/jsonnet/src/lib.rs
@@ -8,6 +8,7 @@
 
 use import::NativeImportResolver;
 use jrsonnet_evaluator::{EvaluationState, ManifestFormat, Val};
+use jrsonnet_interner::IStr;
 use std::{
 	alloc::Layout,
 	ffi::{CStr, CString},
@@ -161,7 +162,7 @@
 	})
 }
 
-fn multi_to_raw(multi: Vec<(Rc<str>, Rc<str>)>) -> *const c_char {
+fn multi_to_raw(multi: Vec<(IStr, IStr)>) -> *const c_char {
 	let mut out = Vec::new();
 	for (i, (k, v)) in multi.iter().enumerate() {
 		if i != 0 {
@@ -237,7 +238,7 @@
 	})
 }
 
-fn stream_to_raw(multi: Vec<Rc<str>>) -> *const c_char {
+fn stream_to_raw(multi: Vec<IStr>) -> *const c_char {
 	let mut out = Vec::new();
 	for (i, v) in multi.iter().enumerate() {
 		if i != 0 {

--- a/bindings/jsonnet/src/native.rs
+++ b/bindings/jsonnet/src/native.rs
@@ -35,7 +35,7 @@
 
 	vm.add_native(
 		name,
-		Rc::new(NativeCallback::new(params, move |args| {
+		Rc::new(NativeCallback::new(params, move |_caller, args| {
 			let mut n_args = Vec::new();
 			for a in args {
 				n_args.push(Some(Box::new(a.clone())));

--- a/bindings/jsonnet/src/val_extract.rs
+++ b/bindings/jsonnet/src/val_extract.rs
@@ -9,7 +9,7 @@
 
 #[no_mangle]
 pub extern "C" fn jsonnet_json_extract_string(_vm: &EvaluationState, v: &Val) -> *mut c_char {
-	match v.unwrap_if_lazy().unwrap() {
+	match v {
 		Val::Str(s) => CString::new(&*s as &str).unwrap().into_raw(),
 		_ => std::ptr::null_mut(),
 	}
@@ -20,9 +20,9 @@
 	v: &Val,
 	out: &mut c_double,
 ) -> c_int {
-	match v.unwrap_if_lazy().unwrap() {
+	match v {
 		Val::Num(n) => {
-			*out = n;
+			*out = *n;
 			1
 		}
 		_ => 0,
@@ -30,7 +30,7 @@
 }
 #[no_mangle]
 pub extern "C" fn jsonnet_json_extract_bool(_vm: &EvaluationState, v: &Val) -> c_int {
-	match v.unwrap_if_lazy().unwrap() {
+	match v {
 		Val::Bool(false) => 0,
 		Val::Bool(true) => 1,
 		_ => 2,
@@ -38,7 +38,7 @@
 }
 #[no_mangle]
 pub extern "C" fn jsonnet_json_extract_null(_vm: &EvaluationState, v: &Val) -> c_int {
-	match v.unwrap_if_lazy().unwrap() {
+	match v {
 		Val::Null => 1,
 		_ => 0,
 	}

--- a/bindings/jsonnet/src/val_make.rs
+++ b/bindings/jsonnet/src/val_make.rs
@@ -1,6 +1,6 @@
 //! Create values in VM
 
-use jrsonnet_evaluator::{EvaluationState, ObjValue, Val};
+use jrsonnet_evaluator::{ArrValue, EvaluationState, ObjValue, Val};
 use std::{
 	ffi::CStr,
 	os::raw::{c_char, c_double, c_int},
@@ -38,7 +38,7 @@
 
 #[no_mangle]
 pub extern "C" fn jsonnet_json_make_array(_vm: &EvaluationState) -> *mut Val {
-	Box::into_raw(Box::new(Val::Arr(Rc::new(Vec::new()))))
+	Box::into_raw(Box::new(Val::Arr(ArrValue::Eager(Rc::new(Vec::new())))))
 }
 
 #[no_mangle]

--- a/bindings/jsonnet/src/val_modify.rs
+++ b/bindings/jsonnet/src/val_modify.rs
@@ -2,7 +2,9 @@
 //! Only tested with variables, which haven't altered by code before appearing here
 //! In jrsonnet every value is immutable, and this code is probally broken
 
-use jrsonnet_evaluator::{EvaluationState, LazyBinding, LazyVal, ObjMember, ObjValue, Val};
+use jrsonnet_evaluator::{
+	ArrValue, EvaluationState, LazyBinding, LazyVal, ObjMember, ObjValue, Val,
+};
 use jrsonnet_parser::Visibility;
 use std::{collections::HashMap, ffi::CStr, os::raw::c_char, rc::Rc};
 
@@ -12,14 +14,17 @@
 #[no_mangle]
 pub unsafe extern "C" fn jsonnet_json_array_append(
 	_vm: &EvaluationState,
-	arr: *mut Val,
+	arr: &mut Val,
 	val: &Val,
 ) {
-	match *Box::from_raw(arr) {
+	match arr {
 		Val::Arr(old) => {
-			let mut new = Rc::try_unwrap(old).expect("arr with no refs");
-			new.push(val.clone());
-			*arr = Val::Arr(Rc::new(new));
+			let mut new = Vec::new();
+			for item in old.iter_lazy() {
+				new.push(item);
+			}
+			new.push(LazyVal::new_resolved(val.clone()));
+			*arr = Val::Arr(ArrValue::Lazy(Rc::new(new)));
 		}
 		_ => panic!("should receive array"),
 	}

--- a/crates/jrsonnet-evaluator/Cargo.toml
+++ b/crates/jrsonnet-evaluator/Cargo.toml
@@ -12,8 +12,6 @@
 serialized-stdlib = ["serde", "bincode", "jrsonnet-parser/deserialize"]
 # Allow to convert Val into serde_json::Value and backwards
 serde-json = ["serde", "serde_json"]
-# Same as above, but with generated code instead of serde. Reduces memory usage, but increases binary size and compilation time
-codegenerated-stdlib = []
 # Replace some standard library functions with faster implementations (I.e manifestJsonEx)
 # Library works fine without this feature, but requires more memory and time for std function calls
 faster = []
@@ -24,8 +22,10 @@
 unstable = []
 
 [dependencies]
+jrsonnet-interner = { path = "../jrsonnet-interner" }
 jrsonnet-parser = { path = "../jrsonnet-parser", version = "0.3.3" }
 jrsonnet-stdlib = { path = "../jrsonnet-stdlib", version = "0.3.3" }
+jrsonnet-types = { path = "../jrsonnet-types", version = "0.3.3" }
 pathdiff = "0.2.0"
 
 closure = "0.3.0"
@@ -57,8 +57,7 @@
 optional = true
 
 [build-dependencies]
-jrsonnet-parser = { path = "../jrsonnet-parser", features = ["dump", "serialize", "deserialize"], version = "0.3.3" }
+jrsonnet-parser = { path = "../jrsonnet-parser", features = ["serialize", "deserialize"], version = "0.3.3" }
 jrsonnet-stdlib = { path = "../jrsonnet-stdlib", version = "0.3.3" }
-structdump = "0.1.2"
 serde = "1.0"
 bincode = "1.3.1"

--- a/crates/jrsonnet-evaluator/build.rs
+++ b/crates/jrsonnet-evaluator/build.rs
@@ -10,7 +10,6 @@
 	path::{Path, PathBuf},
 	rc::Rc,
 };
-use structdump::CodegenResult;
 
 fn main() {
 	let parsed = parse(
@@ -36,11 +35,12 @@
 									name: FieldName::Fixed(name),
 									..
 								})
-								if **name == *"join" || **name == *"manifestJsonEx" ||
-								**name == *"escapeStringJson" || **name == *"equals" ||
-								**name == *"base64" || **name == *"foldl" || **name == *"foldr" ||
-								**name == *"sortImpl" || **name == *"format" || **name == *"range" ||
-								**name == *"reverse" || **name == *"slice" || **name == *"mod"
+								if name == "join" || name == "manifestJsonEx" ||
+								name == "escapeStringJson" || name == "equals" ||
+								name == "base64" || name == "foldl" || name == "foldr" ||
+								name == "sortImpl" || name == "format" || name == "range" ||
+								name == "reverse" || name == "slice" || name == "mod" ||
+								name == "strReplace"
 							)
 						})
 						.collect(),
@@ -52,15 +52,6 @@
 	} else {
 		parsed
 	};
-	{
-		let mut codegen = CodegenResult::default();
-		let code = codegen.codegen(&parsed);
-
-		let out_dir = env::var("OUT_DIR").unwrap();
-		let dest_path = Path::new(&out_dir).join("stdlib.rs");
-		let mut f = File::create(&dest_path).unwrap();
-		f.write_all(&code.as_bytes()).unwrap();
-	}
 	{
 		let out_dir = env::var("OUT_DIR").unwrap();
 		let dest_path = Path::new(&out_dir).join("stdlib.bincode");

--- a/crates/jrsonnet-evaluator/src/builtin/format.rs
+++ b/crates/jrsonnet-evaluator/src/builtin/format.rs
@@ -1,7 +1,9 @@
 //! faster std.format impl
 #![allow(clippy::too_many_arguments)]
 
-use crate::{error::Error::*, throw, LocError, ObjValue, Result, Val, ValType};
+use crate::{error::Error::*, throw, LocError, ObjValue, Result, Val};
+use jrsonnet_interner::IStr;
+use jrsonnet_types::ValType;
 use thiserror::Error;
 
 #[derive(Debug, Clone, Error)]
@@ -19,7 +21,7 @@
 	#[error("mapping keys required")]
 	MappingKeysRequired,
 	#[error("no such format field: {0}")]
-	NoSuchFormatField(Rc<str>),
+	NoSuchFormatField(IStr),
 }
 
 impl From<FormatError> for LocError {
@@ -28,7 +30,6 @@
 	}
 }
 
-use std::rc::Rc;
 use FormatError::*;
 
 type ParseResult<'t, T> = std::result::Result<(T, &'t str), FormatError>;
@@ -573,7 +574,7 @@
 				);
 			}
 		}
-		ConvTypeV::Char => match value.clone().unwrap_if_lazy()? {
+		ConvTypeV::Char => match value.clone() {
 			Val::Num(n) => tmp_out.push(
 				std::char::from_u32(n as u32)
 					.ok_or_else(|| InvalidUnicodeCodepointGot(n as u32))?,
@@ -590,7 +591,7 @@
 				throw!(TypeMismatch(
 					"%c requires number/string",
 					vec![ValType::Num, ValType::Str],
-					value.value_type()?,
+					value.value_type(),
 				));
 			}
 		},
@@ -679,7 +680,7 @@
 			}
 			Element::Code(c) => {
 				// TODO: Operate on ref
-				let f: Rc<str> = c.mkey.into();
+				let f: IStr = c.mkey.into();
 				let width = match c.width {
 					Width::Star => {
 						throw!(CannotUseStarWidthWithObject);

--- a/crates/jrsonnet-evaluator/src/builtin/manifest.rs
+++ b/crates/jrsonnet-evaluator/src/builtin/manifest.rs
@@ -33,16 +33,16 @@
 ) -> Result<()> {
 	use std::fmt::Write;
 	let mtype = options.mtype;
-	match val.unwrap_if_lazy()? {
+	match val {
 		Val::Bool(v) => {
-			if v {
+			if *v {
 				buf.push_str("true");
 			} else {
 				buf.push_str("false");
 			}
 		}
 		Val::Null => buf.push_str("null"),
-		Val::Str(s) => buf.push_str(&escape_string_json(&s)),
+		Val::Str(s) => buf.push_str(&escape_string_json(s)),
 		Val::Num(n) => write!(buf, "{}", n).unwrap(),
 		Val::Arr(items) => {
 			buf.push('[');
@@ -63,7 +63,7 @@
 						}
 					}
 					buf.push_str(cur_padding);
-					manifest_json_ex_buf(item, buf, cur_padding, options)?;
+					manifest_json_ex_buf(&item?, buf, cur_padding, options)?;
 				}
 				cur_padding.truncate(old_len);
 
@@ -118,7 +118,6 @@
 			buf.push('}');
 		}
 		Val::Func(_) => throw!(RuntimeError("tried to manifest function".into())),
-		Val::Lazy(_) => unreachable!(),
 	};
 	Ok(())
 }

--- a/crates/jrsonnet-evaluator/src/builtin/mod.rs
+++ b/crates/jrsonnet-evaluator/src/builtin/mod.rs
@@ -1,28 +1,31 @@
 use crate::{
 	equals,
 	error::{Error::*, Result},
-	evaluate, parse_args, primitive_equals, push, throw, with_state, Context, FuncVal, Val,
-	ValType,
+	parse_args, primitive_equals, push, throw, with_state, ArrValue, Context, FuncVal, LazyVal,
+	Val,
 };
 use format::{format_arr, format_obj};
-use jrsonnet_parser::{ArgsDesc, ExprLocation};
-use manifest::{escape_string_json, manifest_json_ex, ManifestJsonOptions, ManifestType};
-use std::{path::PathBuf, rc::Rc};
+use jrsonnet_interner::IStr;
+use jrsonnet_parser::{ArgsDesc, BinaryOpType, ExprLocation};
+use jrsonnet_types::ty;
+use std::{collections::HashMap, path::PathBuf, rc::Rc};
 
 pub mod stdlib;
 pub use stdlib::*;
 
+use self::manifest::{escape_string_json, manifest_json_ex, ManifestJsonOptions, ManifestType};
+
 pub mod format;
 pub mod manifest;
 pub mod sort;
 
-fn std_format(str: Rc<str>, vals: Val) -> Result<Val> {
+fn std_format(str: IStr, vals: Val) -> Result<Val> {
 	push(
-		&Some(ExprLocation(Rc::from(PathBuf::from("std.jsonnet")), 0, 0)),
+		Some(&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)?.into()),
+				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()),
 			})
@@ -30,379 +33,566 @@
 	)
 }
 
-#[allow(clippy::cognitive_complexity)]
-pub fn call_builtin(
+type Builtin = fn(context: Context, loc: Option<&ExprLocation>, args: &ArgsDesc) -> Result<Val>;
+
+type BuiltinsType = HashMap<Box<str>, Builtin>;
+
+thread_local! {
+	static BUILTINS: BuiltinsType = {
+		[
+			("length".into(), builtin_length as Builtin),
+			("type".into(), builtin_type),
+			("makeArray".into(), builtin_make_array),
+			("codepoint".into(), builtin_codepoint),
+			("objectFieldsEx".into(), builtin_object_fields_ex),
+			("objectHasEx".into(), builtin_object_has_ex),
+			("slice".into(), builtin_slice),
+			("primitiveEquals".into(), builtin_primitive_equals),
+			("equals".into(), builtin_equals),
+			("modulo".into(), builtin_modulo),
+			("mod".into(), builtin_mod),
+			("floor".into(), builtin_floor),
+			("log".into(), builtin_log),
+			("pow".into(), builtin_pow),
+			("extVar".into(), builtin_ext_var),
+			("native".into(), builtin_native),
+			("filter".into(), builtin_filter),
+			("foldl".into(), builtin_foldl),
+			("foldr".into(), builtin_foldr),
+			("sortImpl".into(), builtin_sort_impl),
+			("format".into(), builtin_format),
+			("range".into(), builtin_range),
+			("char".into(), builtin_char),
+			("encodeUTF8".into(), builtin_encode_utf8),
+			("md5".into(), builtin_md5),
+			("base64".into(), builtin_base64),
+			("trace".into(), builtin_trace),
+			("join".into(), builtin_join),
+			("escapeStringJson".into(), builtin_escape_string_json),
+			("manifestJsonEx".into(), builtin_manifest_json_ex),
+			("reverse".into(), builtin_reverse),
+			("id".into(), builtin_id),
+			("strReplace".into(), builtin_str_replace),
+		].iter().cloned().collect()
+	};
+}
+
+fn builtin_length(context: Context, _loc: Option<&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!(),
+		})
+	})
+}
+
+fn builtin_type(context: Context, _loc: Option<&ExprLocation>, args: &ArgsDesc) -> Result<Val> {
+	parse_args!(context, "type", args, 1, [
+		0, x: ty!(any);
+	], {
+		Ok(Val::Str(x.value_type().name().into()))
+	})
+}
+
+fn builtin_make_array(
+	context: Context,
+	_loc: Option<&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::new(),
+				&[Val::Num(i as f64)]
+			)?))
+		}
+		Ok(Val::Arr(out.into()))
+	})
+}
+
+fn builtin_codepoint(
+	context: Context,
+	_loc: Option<&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))
+	})
+}
+
+fn builtin_object_fields_ex(
 	context: Context,
-	loc: &Option<ExprLocation>,
-	name: &str,
+	_loc: Option<&ExprLocation>,
 	args: &ArgsDesc,
 ) -> Result<Val> {
-	Ok(match name as &str {
-		// arr/string/function
-		"length" => parse_args!(context, "std.length", args, 1, [
-			0, x: [Val::Str|Val::Arr|Val::Obj], vec![ValType::Str, ValType::Arr, ValType::Obj];
-		], {
-			Ok(match x {
-				Val::Str(n) => Val::Num(n.chars().count() as f64),
-				Val::Arr(i) => Val::Num(i.len() as f64),
-				Val::Obj(o) => Val::Num(
-					o.fields_visibility()
-						.into_iter()
-						.filter(|(_k, v)| *v)
-						.count() as f64,
-				),
-				_ => unreachable!(),
-			})
-		})?,
-		// any
-		"type" => parse_args!(context, "std.type", args, 1, [
-			0, x, vec![];
-		], {
-			Ok(Val::Str(x.value_type()?.name().into()))
-		})?,
-		// length, idx=>any
-		"makeArray" => parse_args!(context, "std.makeArray", args, 2, [
-			0, sz: [Val::Num]!!Val::Num, vec![ValType::Num];
-			1, func: [Val::Func]!!Val::Func, vec![ValType::Func];
-		], {
-			if sz < 0.0 {
-				throw!(RuntimeError(format!("makeArray requires size >= 0, got {}", sz).into()));
-			}
-			let mut out = Vec::with_capacity(sz as usize);
-			for i in 0..sz as usize {
-				out.push(func.evaluate_values(
-					Context::new(),
-					&[Val::Num(i as f64)]
-				)?)
-			}
-			Ok(Val::Arr(Rc::new(out)))
-		})?,
-		// string
-		"codepoint" => parse_args!(context, "std.codepoint", args, 1, [
-			0, str: [Val::Str]!!Val::Str, vec![ValType::Str];
-		], {
-			assert!(
-				str.chars().count() == 1,
-				"std.codepoint should receive single char string"
-			);
-			Ok(Val::Num(str.chars().take(1).next().unwrap() as u32 as f64))
-		})?,
-		// object, includeHidden
-		"objectFieldsEx" => parse_args!(context, "std.objectFieldsEx",args, 2, [
-			0, obj: [Val::Obj]!!Val::Obj, vec![ValType::Obj];
-			1, inc_hidden: [Val::Bool]!!Val::Bool, vec![ValType::Bool];
-		], {
-			let mut out = obj.fields_visibility()
+	parse_args!(context, "objectFieldsEx", args, 2, [
+		0, obj: ty!(object) => Val::Obj;
+		1, inc_hidden: ty!(boolean) => Val::Bool;
+	], {
+		let mut out = obj.fields_visibility()
+			.into_iter()
+			.filter(|(_k, v)| *v || inc_hidden)
+			.map(|(k, _v)|k)
+			.collect::<Vec<_>>();
+		out.sort();
+		Ok(Val::Arr(out.into_iter().map(Val::Str).collect::<Vec<_>>().into()))
+	})
+}
+
+fn builtin_object_has_ex(
+	context: Context,
+	_loc: Option<&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.fields_visibility()
 				.into_iter()
 				.filter(|(_k, v)| *v || inc_hidden)
-				.map(|(k, _v)|k)
-				.collect::<Vec<_>>();
-			out.sort();
-			Ok(Val::Arr(Rc::new(out.into_iter().map(Val::Str).collect())))
-		})?,
-		// object, field, includeHidden
-		"objectHasEx" => parse_args!(context, "std.objectHasEx", args, 3, [
-			0, obj: [Val::Obj]!!Val::Obj, vec![ValType::Obj];
-			1, f: [Val::Str]!!Val::Str, vec![ValType::Str];
-			2, inc_hidden: [Val::Bool]!!Val::Bool, vec![ValType::Bool];
-		], {
-			Ok(Val::Bool(
-				obj.fields_visibility()
-					.into_iter()
-					.filter(|(_k, v)| *v || inc_hidden)
-					.any(|(k, _v)| *k == *f),
-			))
-		})?,
+				.any(|(k, _v)| *k == *f),
+		))
+	})
+}
 
-		// faster
-		"slice" => parse_args!(context, "slice", args, 4, [
-			0, indexable: [Val::Str | Val::Arr], vec![ValType::Str, ValType::Arr];
-			1, index, vec![ValType::Num, ValType::Null];
-			2, end, vec![ValType::Num, ValType::Null];
-			3, step, vec![ValType::Num, ValType::Null];
-		], {
-			let index = match index {
-				Val::Num(v) => v as usize,
-				Val::Null => 0,
-				_ => unreachable!(),
-			};
-			let end = match end {
-				Val::Num(v) => v as usize,
-				Val::Null => match &indexable {
-					Val::Str(s) => s.chars().count(),
-					Val::Arr(v) => v.len(),
-					_ => unreachable!()
-				},
+// faster
+fn builtin_slice(context: Context, _loc: Option<&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));
+	], {
+		let index = match index {
+			Val::Num(v) => v as usize,
+			Val::Null => 0,
+			_ => unreachable!(),
+		};
+		let end = match end {
+			Val::Num(v) => v as usize,
+			Val::Null => match &indexable {
+				Val::Str(s) => s.chars().count(),
+				Val::Arr(v) => v.len(),
 				_ => unreachable!()
-			};
-			let step = match step {
-				Val::Num(v) => v as usize,
-				Val::Null => 1,
-				_ => unreachable!()
-			};
-			match &indexable {
-				Val::Str(s) => {
-					Ok(Val::Str((s.chars().skip(index).take(end-index).step_by(step).collect::<String>()).into()))
-				}
-				Val::Arr(arr) => {
-					Ok(Val::Arr((arr.iter().skip(index).take(end-index).step_by(step).cloned().collect::<Vec<Val>>()).into()))
-				}
-				_ => unreachable!()
+			},
+			_ => unreachable!()
+		};
+		let step = match step {
+			Val::Num(v) => v as usize,
+			Val::Null => 1,
+			_ => unreachable!()
+		};
+		match &indexable {
+			Val::Str(s) => {
+				Ok(Val::Str((s.chars().skip(index).take(end-index).step_by(step).collect::<String>()).into()))
 			}
-		})?,
-		"primitiveEquals" => parse_args!(context, "std.primitiveEquals", args, 2, [
-			0, a, vec![];
-			1, b, vec![];
-		], {
-			Ok(Val::Bool(primitive_equals(&a, &b)?))
-		})?,
-		// faster
-		"equals" => parse_args!(context, "std.equals", args, 2, [
-			0, a, vec![];
-			1, b, vec![];
-		], {
-			Ok(Val::Bool(equals(&a, &b)?))
-		})?,
-		"mod" => parse_args!(context, "std.mod", args, 2, [
-			0, a: [Val::Num | Val::Str], vec![ValType::Num, ValType::Str];
-			1, b, vec![];
-		], {
-			match (a, b) {
-				(Val::Num(a), Val::Num(b)) => Ok(Val::Num(a % b)),
-				(Val::Str(str), vals) => std_format(str, vals),
-				(a, b) => throw!(BinaryOperatorDoesNotOperateOnValues(jrsonnet_parser::BinaryOpType::Mod, a.value_type()?, b.value_type()?))
+			Val::Arr(arr) => {
+				Ok(Val::Arr((arr.iter().skip(index).take(end-index).step_by(step).collect::<Result<Vec<Val>>>()?).into()))
 			}
-		})?,
-		"modulo" => parse_args!(context, "std.modulo", args, 2, [
-			0, a: [Val::Num]!!Val::Num, vec![ValType::Num];
-			1, b: [Val::Num]!!Val::Num, vec![ValType::Num];
-		], {
-			Ok(Val::Num(a % b))
-		})?,
-		"floor" => parse_args!(context, "std.floor", args, 1, [
-			0, x: [Val::Num]!!Val::Num, vec![ValType::Num];
-		], {
-			Ok(Val::Num(x.floor()))
-		})?,
-		"log" => parse_args!(context, "std.log", args, 2, [
-			0, n: [Val::Num]!!Val::Num, vec![ValType::Num];
-		], {
-			Ok(Val::Num(n.ln()))
-		})?,
-		"trace" => parse_args!(context, "std.trace", args, 2, [
-			0, str: [Val::Str]!!Val::Str, vec![ValType::Str];
-			1, rest, vec![];
-		], {
-			eprint!("TRACE:");
-			if let Some(loc) = loc {
-				with_state(|s|{
-					let locs = s.map_source_locations(&loc.0, &[loc.1]);
-					eprint!(" {}:{}", loc.0.file_name().unwrap().to_str().unwrap(), locs[0].line);
-				});
-			}
-			eprintln!(" {}", str);
-			Ok(rest)
-		})?,
-		"pow" => parse_args!(context, "std.modulo", args, 2, [
-			0, x: [Val::Num]!!Val::Num, vec![ValType::Num];
-			1, n: [Val::Num]!!Val::Num, vec![ValType::Num];
-		], {
-			Ok(Val::Num(x.powf(n)))
-		})?,
-		"extVar" => parse_args!(context, "std.extVar", args, 1, [
-			0, x: [Val::Str]!!Val::Str, vec![ValType::Str];
-		], {
-			Ok(with_state(|s| s.settings().ext_vars.get(&x).cloned()).ok_or(UndefinedExternalVariable(x))?)
-		})?,
-		"native" => parse_args!(context, "std.native", args, 1, [
-			0, x: [Val::Str]!!Val::Str, vec![ValType::Str];
-		], {
-			Ok(with_state(|s| s.settings().ext_natives.get(&x).cloned()).map(|v| Val::Func(Rc::new(FuncVal::NativeExt(x.clone(), v)))).ok_or(UndefinedExternalFunction(x))?)
-		})?,
-		"filter" => parse_args!(context, "std.filter", args, 2, [
-			0, func: [Val::Func]!!Val::Func, vec![ValType::Func];
-			1, arr: [Val::Arr]!!Val::Arr, vec![ValType::Arr];
-		], {
-			Ok(Val::Arr(Rc::new(
-				arr.iter()
-					.cloned()
-					.filter(|e| {
-						func
-							.evaluate_values(context.clone(), &[e.clone()])
-							.unwrap()
-							.try_cast_bool("filter predicate")
-							.unwrap()
-					})
-					.collect(),
-			)))
-		})?,
-		// faster
-		"foldl" => parse_args!(context, "std.foldl", args, 3, [
-			0, func: [Val::Func]!!Val::Func, vec![ValType::Func];
-			1, arr: [Val::Arr]!!Val::Arr, vec![ValType::Arr];
-			2, init, vec![];
-		], {
-			let mut acc = init;
-			for i in arr.iter().cloned() {
-				acc = func.evaluate_values(context.clone(), &[acc, i])?;
-			}
-			Ok(acc)
-		})?,
-		// faster
-		"foldr" => parse_args!(context, "std.foldr", args, 3, [
-			0, func: [Val::Func]!!Val::Func, vec![ValType::Func];
-			1, arr: [Val::Arr]!!Val::Arr, vec![ValType::Arr];
-			2, init, vec![];
-		], {
-			let mut acc = init;
-			for i in arr.iter().rev().cloned() {
-				acc = func.evaluate_values(context.clone(), &[acc, i])?;
-			}
-			Ok(acc)
-		})?,
-		// faster
-		#[allow(non_snake_case)]
-		"sortImpl" => parse_args!(context, "std.sort", args, 2, [
-			0, arr: [Val::Arr]!!Val::Arr, vec![ValType::Arr];
-			1, keyF: [Val::Func]!!Val::Func, vec![ValType::Func];
-		], {
-			if arr.len() <= 1 {
-				return Ok(Val::Arr(arr))
-			}
-			Ok(Val::Arr(sort::sort(context, arr, &keyF)?))
-		})?,
-		// faster
-		"format" => parse_args!(context, "std.format", args, 2, [
-			0, str: [Val::Str]!!Val::Str, vec![ValType::Str];
-			1, vals, vec![]
-		], {
-			std_format(str, vals)
-		})?,
-		// faster
-		"range" => parse_args!(context, "std.range", args, 2, [
-			0, from: [Val::Num]!!Val::Num, vec![ValType::Num];
-			1, to: [Val::Num]!!Val::Num, vec![ValType::Num];
-		], {
-			if to < from {
-				return Ok(Val::Arr(Rc::new(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(Val::Arr(Rc::new(out)))
-		})?,
-		"char" => parse_args!(context, "std.char", args, 1, [
-			0, n: [Val::Num]!!Val::Num, vec![ValType::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()))
-		})?,
-		"encodeUTF8" => parse_args!(context, "std.encodeUtf8", args, 1, [
-			0, str: [Val::Str]!!Val::Str, vec![ValType::Str];
-		], {
-			Ok(Val::Arr(Rc::new(str.bytes().map(|b| Val::Num(b as f64)).collect())))
-		})?,
-		"md5" => parse_args!(context, "std.md5", args, 1, [
-			0, str: [Val::Str]!!Val::Str, vec![ValType::Str];
-		], {
-			Ok(Val::Str(format!("{:x}", md5::compute(&str.as_bytes())).into()))
-		})?,
-		// faster
-		"base64" => parse_args!(context, "std.base64", args, 1, [
-			0, input: [Val::Str | Val::Arr], vec![ValType::Arr, ValType::Str];
-		], {
-			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.clone().try_cast_num("base64 array")? as u8)
-					}).collect::<Result<Vec<_>>>()?).into()
-				},
-				_ => unreachable!()
-			}))
-		})?,
-		// faster
-		"join" => parse_args!(context, "std.join", args, 2, [
-			0, sep: [Val::Str|Val::Arr], vec![ValType::Str, ValType::Arr];
-			1, arr: [Val::Arr]!!Val::Arr, vec![ValType::Arr];
-		], {
-			Ok(match sep {
-				Val::Arr(joiner_items) => {
-					let mut out = Vec::new();
+			_ => unreachable!()
+		}
+	})
+}
+
+// faster
+fn builtin_primitive_equals(
+	context: Context,
+	_loc: Option<&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)?))
+	})
+}
+
+// faster
+fn builtin_equals(context: Context, _loc: Option<&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)?))
+	})
+}
+
+fn builtin_modulo(context: Context, _loc: Option<&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))
+	})
+}
+
+fn builtin_mod(context: Context, _loc: Option<&ExprLocation>, args: &ArgsDesc) -> Result<Val> {
+	parse_args!(context, "mod", args, 2, [
+		0, a: ty!((number | string));
+		1, b: ty!(any);
+	], {
+		match (a, b) {
+			(Val::Num(a), Val::Num(b)) => Ok(Val::Num(a % b)),
+			(Val::Str(str), vals) => std_format(str, vals),
+			(a, b) => throw!(BinaryOperatorDoesNotOperateOnValues(BinaryOpType::Mod, a.value_type(), b.value_type()))
+		}
+	})
+}
+
+fn builtin_floor(context: Context, _loc: Option<&ExprLocation>, args: &ArgsDesc) -> Result<Val> {
+	parse_args!(context, "floor", args, 1, [
+		0, x: ty!(number) => Val::Num;
+	], {
+		Ok(Val::Num(x.floor()))
+	})
+}
+
+fn builtin_log(context: Context, _loc: Option<&ExprLocation>, args: &ArgsDesc) -> Result<Val> {
+	parse_args!(context, "log", args, 1, [
+		0, n: ty!(number) => Val::Num;
+	], {
+		Ok(Val::Num(n.ln()))
+	})
+}
+
+fn builtin_pow(context: Context, _loc: Option<&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)))
+	})
+}
+
+fn builtin_ext_var(context: Context, _loc: Option<&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))?)
+	})
+}
+
+fn builtin_native(context: Context, _loc: Option<&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(Rc::new(FuncVal::NativeExt(x.clone(), v)))).ok_or(UndefinedExternalFunction(x))?)
+	})
+}
+
+fn builtin_filter(context: Context, _loc: Option<&ExprLocation>, args: &ArgsDesc) -> Result<Val> {
+	parse_args!(context, "filter", args, 2, [
+		0, func: ty!(function) => Val::Func;
+		1, arr: ty!(array) => Val::Arr;
+	], {
+		let mut out = Vec::new();
+		for item in arr.iter() {
+			let item = item?;
+			if func
+						.evaluate_values(context.clone(), &[item.clone()])?
+						.try_cast_bool("filter predicate")? {
+							out.push(item);
+						}
+		}
+		Ok(Val::Arr(out.into()))
+	})
+}
+
+fn builtin_foldl(context: Context, _loc: Option<&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)
+	})
+}
+
+fn builtin_foldr(context: Context, _loc: Option<&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(), &[acc, i?])?;
+		}
+		Ok(acc)
+	})
+}
+
+#[allow(non_snake_case)]
+fn builtin_sort_impl(
+	context: Context,
+	_loc: Option<&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)?)))
+	})
+}
+
+// faster
+fn builtin_format(context: Context, _loc: Option<&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)
+	})
+}
+
+fn builtin_range(context: Context, _loc: Option<&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()))
+	})
+}
+
+fn builtin_char(context: Context, _loc: Option<&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()))
+	})
+}
 
-					let mut first = true;
-					for item in arr.iter().cloned() {
-						if let Val::Arr(items) = item.unwrap_if_lazy()? {
-							if !first {
-								out.reserve(joiner_items.len());
-								out.extend(joiner_items.iter().cloned());
+fn builtin_encode_utf8(
+	context: Context,
+	_loc: Option<&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()))
+	})
+}
+
+fn builtin_md5(context: Context, _loc: Option<&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()))
+	})
+}
+
+fn builtin_trace(context: Context, loc: Option<&ExprLocation>, args: &ArgsDesc) -> Result<Val> {
+	parse_args!(context, "trace", args, 2, [
+		0, str: ty!(string) => Val::Str;
+		1, rest: ty!(any);
+	], {
+		eprint!("TRACE:");
+		if let Some(loc) = loc {
+			with_state(|s|{
+				let locs = s.map_source_locations(&loc.0, &[loc.1]);
+				eprint!(" {}:{}", loc.0.file_name().unwrap().to_str().unwrap(), locs[0].line);
+			});
+		}
+		eprintln!(" {}", str);
+		Ok(rest)
+	})
+}
+
+fn builtin_base64(context: Context, _loc: Option<&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!()
+		}))
+	})
+}
+
+fn builtin_join(context: Context, _loc: Option<&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();
+
+				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());
-							out.extend(items.iter().cloned());
-						} 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(Rc::new(out))
-				},
-				Val::Str(sep) => {
-					let mut out = String::new();
+				Val::Arr(out.into())
+			},
+			Val::Str(sep) => {
+				let mut out = String::new();
 
-					let mut first = true;
-					for item in arr.iter().cloned() {
-						if let Val::Str(item) = item.unwrap_if_lazy()? {
-							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!()
-			})
-		})?,
-		// Faster
-		"escapeStringJson" => parse_args!(context, "std.escapeStringJson", args, 1, [
-			0, str_: [Val::Str]!!Val::Str, vec![ValType::Str];
-		], {
-			Ok(Val::Str(escape_string_json(&str_).into()))
-		})?,
-		// Faster
-		"manifestJsonEx" => parse_args!(context, "std.manifestJsonEx", args, 2, [
-			0, value, vec![];
-			1, indent: [Val::Str]!!Val::Str, vec![ValType::Str];
-		], {
-			Ok(Val::Str(manifest_json_ex(&value, &ManifestJsonOptions {
-				padding: &indent,
-				mtype: ManifestType::Std,
-			})?.into()))
-		})?,
-		// Faster
-		"reverse" => parse_args!(context, "std.reverse", args, 1, [
-			0, arr: [Val::Arr]!!Val::Arr, vec![ValType::Arr];
-		], {
-			let mut marr = arr;
-			Rc::make_mut(&mut marr).reverse();
-			Ok(Val::Arr(marr))
-		})?,
-		"id" => parse_args!(context, "std.id", args, 1, [
-			0, v, vec![];
-		], {
-			Ok(v)
-		})?,
-		name => throw!(IntrinsicNotFound(name.into())),
+				Val::Str(out.into())
+			},
+			_ => unreachable!()
+		})
+	})
+}
+
+// faster
+fn builtin_escape_string_json(
+	context: Context,
+	_loc: Option<&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()))
+	})
+}
+
+// faster
+fn builtin_manifest_json_ex(
+	context: Context,
+	_loc: Option<&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 {
+			padding: &indent,
+			mtype: ManifestType::Std,
+		})?.into()))
+	})
+}
+
+// faster
+fn builtin_reverse(context: Context, _loc: Option<&ExprLocation>, args: &ArgsDesc) -> Result<Val> {
+	parse_args!(context, "reverse", args, 1, [
+		0, value: ty!(array) => Val::Arr;
+	], {
+		Ok(Val::Arr(value.reversed()))
+	})
+}
+
+fn builtin_id(context: Context, _loc: Option<&ExprLocation>, args: &ArgsDesc) -> Result<Val> {
+	parse_args!(context, "id", args, 1, [
+		0, v: ty!(any);
+	], {
+		Ok(v)
+	})
+}
+
+// faster
+fn builtin_str_replace(
+	context: Context,
+	_loc: Option<&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;
+	], {
+		let mut out = String::new();
+		let mut last_idx = 0;
+		while let Some(idx) = (&str[last_idx..]).find(&from as &str) {
+			out.push_str(&str[last_idx..last_idx+idx]);
+			out.push_str(&to);
+			last_idx += idx + from.len();
+		}
+		if last_idx == 0 {
+			return Ok(Val::Str(str))
+		}
+		out.push_str(&str[last_idx..]);
+		Ok(Val::Str(out.into()))
 	})
 }
+
+pub fn call_builtin(
+	context: Context,
+	loc: Option<&ExprLocation>,
+	name: &str,
+	args: &ArgsDesc,
+) -> Result<Val> {
+	if let Some(f) = BUILTINS.with(|builtins| builtins.get(name).copied()) {
+		return Ok(f(context, loc, args)?);
+	}
+	throw!(IntrinsicNotFound(name.into()))
+}

--- a/crates/jrsonnet-evaluator/src/builtin/sort.rs
+++ b/crates/jrsonnet-evaluator/src/builtin/sort.rs
@@ -46,7 +46,6 @@
 	let mut sort_type = SortKeyType::Unknown;
 	for i in values.iter_mut() {
 		let i = key_getter(i);
-		i.inplace_unwrap()?;
 		match (i, sort_type) {
 			(Val::Str(_), SortKeyType::Unknown) => sort_type = SortKeyType::String,
 			(Val::Num(_), SortKeyType::Unknown) => sort_type = SortKeyType::Number,

--- a/crates/jrsonnet-evaluator/src/ctx.rs
+++ b/crates/jrsonnet-evaluator/src/ctx.rs
@@ -2,6 +2,7 @@
 	error::Error::*, future_wrapper, map::LayeredHashMap, rc_fn_helper, resolved_lazy_val,
 	LazyBinding, LazyVal, ObjValue, Result, Val,
 };
+use jrsonnet_interner::IStr;
 use rustc_hash::FxHashMap;
 use std::hash::BuildHasherDefault;
 use std::{cell::RefCell, collections::HashMap, fmt::Debug, rc::Rc};
@@ -18,7 +19,7 @@
 	dollar: Option<ObjValue>,
 	this: Option<ObjValue>,
 	super_obj: Option<ObjValue>,
-	bindings: LayeredHashMap<Rc<str>, LazyVal>,
+	bindings: LayeredHashMap<LazyVal>,
 }
 impl Debug for ContextInternals {
 	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
@@ -57,7 +58,7 @@
 		}))
 	}
 
-	pub fn binding(&self, name: Rc<str>) -> Result<LazyVal> {
+	pub fn binding(&self, name: IStr) -> Result<LazyVal> {
 		Ok(self
 			.0
 			.bindings
@@ -72,7 +73,7 @@
 		ctx.unwrap()
 	}
 
-	pub fn with_var(self, name: Rc<str>, value: Val) -> Self {
+	pub fn with_var(self, name: IStr, value: Val) -> Self {
 		let mut new_bindings =
 			FxHashMap::with_capacity_and_hasher(1, BuildHasherDefault::default());
 		new_bindings.insert(name, resolved_lazy_val!(value));
@@ -81,7 +82,7 @@
 
 	pub fn extend(
 		self,
-		new_bindings: FxHashMap<Rc<str>, LazyVal>,
+		new_bindings: FxHashMap<IStr, LazyVal>,
 		new_dollar: Option<ObjValue>,
 		new_this: Option<ObjValue>,
 		new_super_obj: Option<ObjValue>,
@@ -123,7 +124,7 @@
 	}
 	pub fn extend_unbound(
 		self,
-		new_bindings: HashMap<Rc<str>, LazyBinding>,
+		new_bindings: HashMap<IStr, LazyBinding>,
 		new_dollar: Option<ObjValue>,
 		new_this: Option<ObjValue>,
 		new_super_obj: Option<ObjValue>,

--- a/crates/jrsonnet-evaluator/src/error.rs
+++ b/crates/jrsonnet-evaluator/src/error.rs
@@ -1,15 +1,17 @@
 use crate::{
 	builtin::{format::FormatError, sort::SortError},
-	ValType,
+	typed::TypeLocError,
 };
+use jrsonnet_interner::IStr;
 use jrsonnet_parser::{BinaryOpType, ExprLocation, UnaryOpType};
+use jrsonnet_types::ValType;
 use std::{path::PathBuf, rc::Rc};
 use thiserror::Error;
 
 #[derive(Error, Debug, Clone)]
 pub enum Error {
 	#[error("intrinsic not found: {0}")]
-	IntrinsicNotFound(Rc<str>),
+	IntrinsicNotFound(IStr),
 	#[error("argument reordering in intrisics not supported yet")]
 	IntrinsicArgumentReorderingIsNotSupportedYet,
 
@@ -32,36 +34,36 @@
 	ArrayBoundsError(usize, usize),
 
 	#[error("assert failed: {0}")]
-	AssertionFailed(Rc<str>),
+	AssertionFailed(IStr),
 
 	#[error("variable is not defined: {0}")]
-	VariableIsNotDefined(Rc<str>),
+	VariableIsNotDefined(IStr),
 	#[error("type mismatch: expected {}, got {2} {0}", .1.iter().map(|e| format!("{}", e)).collect::<Vec<_>>().join(", "))]
 	TypeMismatch(&'static str, Vec<ValType>, ValType),
 	#[error("no such field: {0}")]
-	NoSuchField(Rc<str>),
+	NoSuchField(IStr),
 
 	#[error("only functions can be called, got {0}")]
 	OnlyFunctionsCanBeCalledGot(ValType),
 	#[error("parameter {0} is not defined")]
 	UnknownFunctionParameter(String),
 	#[error("argument {0} is already bound")]
-	BindingParameterASecondTime(Rc<str>),
+	BindingParameterASecondTime(IStr),
 	#[error("too many args, function has {0}")]
 	TooManyArgsFunctionHas(usize),
 	#[error("founction argument is not passed: {0}")]
-	FunctionParameterNotBoundInCall(Rc<str>),
+	FunctionParameterNotBoundInCall(IStr),
 
 	#[error("external variable is not defined: {0}")]
-	UndefinedExternalVariable(Rc<str>),
+	UndefinedExternalVariable(IStr),
 	#[error("native is not defined: {0}")]
-	UndefinedExternalFunction(Rc<str>),
+	UndefinedExternalFunction(IStr),
 
 	#[error("field name should be string, got {0}")]
 	FieldMustBeStringGot(ValType),
 
 	#[error("attempted to index array with string {0}")]
-	AttemptedIndexAnArrayWithString(Rc<str>),
+	AttemptedIndexAnArrayWithString(IStr),
 	#[error("{0} index type should be {1}, got {2}")]
 	ValueIndexMustBeTypeGot(ValType, ValType, ValType),
 	#[error("cant index into {0}")]
@@ -85,12 +87,12 @@
 	)]
 	ImportSyntaxError {
 		path: Rc<PathBuf>,
-		source_code: Rc<str>,
+		source_code: IStr,
 		error: Box<jrsonnet_parser::ParseError>,
 	},
 
 	#[error("runtime error: {0}")]
-	RuntimeError(Rc<str>),
+	RuntimeError(IStr),
 	#[error("stack overflow, try to reduce recursion, or set --max-stack to bigger value")]
 	StackOverflow,
 	#[error("tried to index by fractional value")]
@@ -117,6 +119,8 @@
 
 	#[error("format error: {0}")]
 	Format(#[from] FormatError),
+	#[error("type error: {0}")]
+	TypeError(TypeLocError),
 	#[error("sort error: {0}")]
 	Sort(#[from] SortError),
 }
@@ -128,7 +132,7 @@
 
 #[derive(Clone, Debug)]
 pub struct StackTraceElement {
-	pub location: ExprLocation,
+	pub location: Option<ExprLocation>,
 	pub desc: String,
 }
 #[derive(Debug, Clone)]
@@ -144,6 +148,9 @@
 	pub const fn error(&self) -> &Error {
 		&(self.0).0
 	}
+	pub fn error_mut(&mut self) -> &mut Error {
+		&mut (self.0).0
+	}
 	pub const fn trace(&self) -> &StackTrace {
 		&(self.0).1
 	}

--- a/crates/jrsonnet-evaluator/src/evaluate.rs
+++ b/crates/jrsonnet-evaluator/src/evaluate.rs
@@ -1,18 +1,19 @@
 use crate::{
 	context_creator, error::Error::*, future_wrapper, lazy_val, push, throw, with_state, Context,
 	ContextCreator, FuncDesc, FuncVal, LazyBinding, LazyVal, ObjMember, ObjValue, Result, Val,
-	ValType,
 };
 use closure::closure;
+use jrsonnet_interner::IStr;
 use jrsonnet_parser::{
 	ArgsDesc, AssertStmt, BinaryOpType, BindSpec, CompSpec, Expr, ExprLocation, FieldMember,
 	ForSpecData, IfSpecData, LiteralType, LocExpr, Member, ObjBody, ParamsDesc, UnaryOpType,
 	Visibility,
 };
+use jrsonnet_types::ValType;
 use rustc_hash::FxHashMap;
 use std::{collections::HashMap, rc::Rc};
 
-pub fn evaluate_binding(b: &BindSpec, context_creator: ContextCreator) -> (Rc<str>, LazyBinding) {
+pub fn evaluate_binding(b: &BindSpec, context_creator: ContextCreator) -> (IStr, LazyBinding) {
 	let b = b.clone();
 	if let Some(params) = &b.params {
 		let params = params.clone();
@@ -45,7 +46,7 @@
 	}
 }
 
-pub fn evaluate_method(ctx: Context, name: Rc<str>, params: ParamsDesc, body: LocExpr) -> Val {
+pub fn evaluate_method(ctx: Context, name: IStr, params: ParamsDesc, body: LocExpr) -> Val {
 	Val::Func(Rc::new(FuncVal::Normal(FuncDesc {
 		name,
 		ctx,
@@ -57,12 +58,11 @@
 pub fn evaluate_field_name(
 	context: Context,
 	field_name: &jrsonnet_parser::FieldName,
-) -> Result<Option<Rc<str>>> {
+) -> Result<Option<IStr>> {
 	Ok(match field_name {
 		jrsonnet_parser::FieldName::Fixed(n) => Some(n.clone()),
 		jrsonnet_parser::FieldName::Dyn(expr) => {
-			let lazy = evaluate(context, expr)?;
-			let value = lazy.unwrap_if_lazy()?;
+			let value = evaluate(context, expr)?;
 			if matches!(value, Val::Null) {
 				None
 			} else {
@@ -74,11 +74,10 @@
 
 pub fn evaluate_unary_op(op: UnaryOpType, b: &Val) -> Result<Val> {
 	Ok(match (op, b) {
-		(o, Val::Lazy(l)) => evaluate_unary_op(o, &l.evaluate()?)?,
 		(UnaryOpType::Not, Val::Bool(v)) => Val::Bool(!v),
 		(UnaryOpType::Minus, Val::Num(n)) => Val::Num(-*n),
 		(UnaryOpType::BitNot, Val::Num(n)) => Val::Num(!(*n as i32) as f64),
-		(op, o) => throw!(UnaryOperatorDoesNotOperateOnType(op, o.value_type()?)),
+		(op, o) => throw!(UnaryOperatorDoesNotOperateOnType(op, o.value_type())),
 	})
 }
 
@@ -94,12 +93,17 @@
 		(o, Val::Str(s)) => Val::Str(format!("{}{}", o.clone().to_string()?, s).into()),
 
 		(Val::Obj(v1), Val::Obj(v2)) => Val::Obj(v2.with_super(v1.clone())),
-		(Val::Arr(a), Val::Arr(b)) => Val::Arr(Rc::new([&a[..], &b[..]].concat())),
+		(Val::Arr(a), Val::Arr(b)) => {
+			let mut out = Vec::with_capacity(a.len() + b.len());
+			out.extend(a.iter_lazy());
+			out.extend(b.iter_lazy());
+			Val::Arr(out.into())
+		}
 		(Val::Num(v1), Val::Num(v2)) => Val::new_checked_num(v1 + v2)?,
 		_ => throw!(BinaryOperatorDoesNotOperateOnValues(
 			BinaryOpType::Add,
-			a.value_type()?,
-			b.value_type()?,
+			a.value_type(),
+			b.value_type(),
 		)),
 	})
 }
@@ -110,15 +114,11 @@
 	op: BinaryOpType,
 	b: &LocExpr,
 ) -> Result<Val> {
-	Ok(
-		match (evaluate(context.clone(), a)?.unwrap_if_lazy()?, op, b) {
-			(Val::Bool(true), BinaryOpType::Or, _o) => Val::Bool(true),
-			(Val::Bool(false), BinaryOpType::And, _o) => Val::Bool(false),
-			(a, op, eb) => {
-				evaluate_binary_op_normal(&a, op, &evaluate(context, eb)?.unwrap_if_lazy()?)?
-			}
-		},
-	)
+	Ok(match (evaluate(context.clone(), a)?, op, b) {
+		(Val::Bool(true), BinaryOpType::Or, _o) => Val::Bool(true),
+		(Val::Bool(false), BinaryOpType::And, _o) => Val::Bool(false),
+		(a, op, eb) => evaluate_binary_op_normal(&a, op, &evaluate(context, eb)?)?,
+	})
 }
 
 pub fn evaluate_binary_op_normal(a: &Val, op: BinaryOpType, b: &Val) -> Result<Val> {
@@ -177,13 +177,13 @@
 
 		_ => throw!(BinaryOperatorDoesNotOperateOnValues(
 			op,
-			a.value_type()?,
-			b.value_type()?,
+			a.value_type(),
+			b.value_type(),
 		)),
 	})
 }
 
-future_wrapper!(HashMap<Rc<str>, LazyBinding>, FutureNewBindings);
+future_wrapper!(HashMap<IStr, LazyBinding>, FutureNewBindings);
 future_wrapper!(ObjValue, FutureObjValue);
 
 pub fn evaluate_comp<T>(
@@ -200,23 +200,20 @@
 				None
 			}
 		}
-		Some(CompSpec::ForSpec(ForSpecData(var, expr))) => {
-			match evaluate(context.clone(), expr)?.unwrap_if_lazy()? {
-				Val::Arr(list) => {
-					let mut out = Vec::new();
-					for item in list.iter() {
-						let item = item.unwrap_if_lazy()?;
-						out.push(evaluate_comp(
-							context.clone().with_var(var.clone(), item.clone()),
-							value,
-							&specs[1..],
-						)?);
-					}
-					Some(out.into_iter().flatten().flatten().collect())
+		Some(CompSpec::ForSpec(ForSpecData(var, expr))) => match evaluate(context.clone(), expr)? {
+			Val::Arr(list) => {
+				let mut out = Vec::new();
+				for item in list.iter() {
+					out.push(evaluate_comp(
+						context.clone().with_var(var.clone(), item?.clone()),
+						value,
+						&specs[1..],
+					)?);
 				}
-				_ => throw!(InComprehensionCanOnlyIterateOverArray),
+				Some(out.into_iter().flatten().flatten().collect())
 			}
-		}
+			_ => throw!(InComprehensionCanOnlyIterateOverArray),
+		},
 	})
 }
 
@@ -234,7 +231,7 @@
 		})
 	);
 	{
-		let mut bindings: HashMap<Rc<str>, LazyBinding> = HashMap::new();
+		let mut bindings: HashMap<IStr, LazyBinding> = HashMap::new();
 		for (n, b) in members
 			.iter()
 			.filter_map(|m| match m {
@@ -338,7 +335,7 @@
 							)?)
 						})
 					);
-					let mut bindings: HashMap<Rc<str>, LazyBinding> = HashMap::new();
+					let mut bindings: HashMap<IStr, LazyBinding> = HashMap::new();
 					for (n, b) in obj
 						.pre_locals
 						.iter()
@@ -375,7 +372,7 @@
 							},
 						);
 					}
-					v => throw!(FieldMustBeStringGot(v.value_type()?)),
+					v => throw!(FieldMustBeStringGot(v.value_type())),
 				}
 			}
 
@@ -388,11 +385,10 @@
 	context: Context,
 	value: &LocExpr,
 	args: &ArgsDesc,
-	loc: &Option<ExprLocation>,
+	loc: Option<&ExprLocation>,
 	tailstrict: bool,
 ) -> Result<Val> {
-	let lazy = evaluate(context.clone(), value)?;
-	let value = lazy.unwrap_if_lazy()?;
+	let value = evaluate(context.clone(), value)?;
 	Ok(match value {
 		Val::Func(f) => {
 			let body = || f.evaluate(context, loc, args, tailstrict);
@@ -402,11 +398,11 @@
 				push(loc, || format!("function <{}> call", f.name()), body)?
 			}
 		}
-		v => throw!(OnlyFunctionsCanBeCalledGot(v.value_type()?)),
+		v => throw!(OnlyFunctionsCanBeCalledGot(v.value_type())),
 	})
 }
 
-pub fn evaluate_named(context: Context, lexpr: &LocExpr, name: Rc<str>) -> Result<Val> {
+pub fn evaluate_named(context: Context, lexpr: &LocExpr, name: IStr) -> Result<Val> {
 	use Expr::*;
 	let LocExpr(expr, _loc) = lexpr;
 	Ok(match &**expr {
@@ -434,9 +430,9 @@
 		BinaryOp(v1, o, v2) => evaluate_binary_op_special(context, v1, *o, v2)?,
 		UnaryOp(o, v) => evaluate_unary_op(*o, &evaluate(context, v)?)?,
 		Var(name) => push(
-			loc,
+			loc.as_ref(),
 			|| format!("variable <{}>", name),
-			|| Ok(Val::Lazy(context.binding(name.clone())?).unwrap_if_lazy()?),
+			|| Ok(context.binding(name.clone())?.evaluate()?),
 		)?,
 		Index(LocExpr(v, _), index) if matches!(&**v, Expr::Literal(LiteralType::Super)) => {
 			let name = evaluate(context.clone(), index)?.try_cast_str("object index")?;
@@ -444,22 +440,19 @@
 				.super_obj()
 				.clone()
 				.expect("no super found")
-				.get_raw(name, &context.this().clone().expect("no this found"))?
+				.get_raw(name, Some(&context.this().clone().expect("no this found")))?
 				.expect("value not found")
 		}
 		Index(value, index) => {
-			match (
-				evaluate(context.clone(), value)?.unwrap_if_lazy()?,
-				evaluate(context, index)?,
-			) {
+			match (evaluate(context.clone(), value)?, evaluate(context, index)?) {
 				(Val::Obj(v), Val::Str(s)) => {
 					let sn = s.clone();
 					push(
-						loc,
+						loc.as_ref(),
 						|| format!("field <{}> access", sn),
 						|| {
 							if let Some(v) = v.get(s.clone())? {
-								Ok(v.unwrap_if_lazy()?)
+								Ok(v)
 							} else if v.get("__intrinsic_namespace__".into())?.is_some() {
 								Ok(Val::Func(Rc::new(FuncVal::Intrinsic(s))))
 							} else {
@@ -471,23 +464,21 @@
 				(Val::Obj(_), n) => throw!(ValueIndexMustBeTypeGot(
 					ValType::Obj,
 					ValType::Str,
-					n.value_type()?,
+					n.value_type(),
 				)),
 
 				(Val::Arr(v), Val::Num(n)) => {
 					if n.fract() > f64::EPSILON {
 						throw!(FractionalIndex)
 					}
-					v.get(n as usize)
+					v.get(n as usize)?
 						.ok_or_else(|| ArrayBoundsError(n as usize, v.len()))?
-						.clone()
-						.unwrap_if_lazy()?
 				}
 				(Val::Arr(_), Val::Str(n)) => throw!(AttemptedIndexAnArrayWithString(n)),
 				(Val::Arr(_), n) => throw!(ValueIndexMustBeTypeGot(
 					ValType::Arr,
 					ValType::Num,
-					n.value_type()?,
+					n.value_type(),
 				)),
 
 				(Val::Str(s), Val::Num(n)) => Val::Str(
@@ -500,14 +491,14 @@
 				(Val::Str(_), n) => throw!(ValueIndexMustBeTypeGot(
 					ValType::Str,
 					ValType::Num,
-					n.value_type()?,
+					n.value_type(),
 				)),
 
-				(v, _) => throw!(CantIndexInto(v.value_type()?)),
+				(v, _) => throw!(CantIndexInto(v.value_type())),
 			}
 		}
 		LocalExpr(bindings, returned) => {
-			let mut new_bindings: HashMap<Rc<str>, LazyBinding> = HashMap::new();
+			let mut new_bindings: HashMap<IStr, LazyBinding> = HashMap::new();
 			let future_context = Context::new_future();
 
 			let context_creator = context_creator!(
@@ -529,31 +520,35 @@
 		Arr(items) => {
 			let mut out = Vec::with_capacity(items.len());
 			for item in items {
-				out.push(Val::Lazy(lazy_val!(
+				out.push(LazyVal::new(Box::new(
 					closure!(clone context, clone item, || {
 						evaluate(context.clone(), &item)
-					})
+					}),
 				)));
 			}
-			Val::Arr(Rc::new(out))
+			Val::Arr(out.into())
 		}
 		ArrComp(expr, comp_specs) => Val::Arr(
 			// First comp_spec should be for_spec, so no "None" possible here
-			Rc::new(evaluate_comp(context, &|ctx| evaluate(ctx, expr), comp_specs)?.unwrap()),
+			evaluate_comp(context, &|ctx| evaluate(ctx, expr), comp_specs)?
+				.unwrap()
+				.into(),
 		),
 		Obj(body) => Val::Obj(evaluate_object(context, body)?),
 		ObjExtend(s, t) => evaluate_add_op(
 			&evaluate(context.clone(), s)?,
 			&Val::Obj(evaluate_object(context, t)?),
 		)?,
-		Apply(value, args, tailstrict) => evaluate_apply(context, value, args, loc, *tailstrict)?,
+		Apply(value, args, tailstrict) => {
+			evaluate_apply(context, value, args, loc.as_ref(), *tailstrict)?
+		}
 		Function(params, body) => {
 			evaluate_method(context, "anonymous".into(), params.clone(), body.clone())
 		}
 		Intrinsic(name) => Val::Func(Rc::new(FuncVal::Intrinsic(name.clone()))),
 		AssertExpr(AssertStmt(value, msg), returned) => {
 			let assertion_result = push(
-				&value.1,
+				value.1.as_ref(),
 				|| "assertion condition".to_owned(),
 				|| {
 					evaluate(context.clone(), value)?
@@ -562,14 +557,22 @@
 			)?;
 			if assertion_result {
 				evaluate(context, returned)?
-			} else if let Some(msg) = msg {
-				throw!(AssertionFailed(evaluate(context, msg)?.to_string()?));
 			} else {
-				throw!(AssertionFailed(Val::Null.to_string()?));
+				push(
+					value.1.as_ref(),
+					|| "assertion failure".to_owned(),
+					|| {
+						if let Some(msg) = msg {
+							throw!(AssertionFailed(evaluate(context, msg)?.to_string()?));
+						} else {
+							throw!(AssertionFailed(Val::Null.to_string()?));
+						}
+					},
+				)?
 			}
 		}
 		ErrorStmt(e) => push(
-			loc,
+			loc.as_ref(),
 			|| "error statement".to_owned(),
 			|| {
 				throw!(RuntimeError(
@@ -583,7 +586,7 @@
 			cond_else,
 		} => {
 			if push(
-				loc,
+				loc.as_ref(),
 				|| "if condition".to_owned(),
 				|| evaluate(context.clone(), &cond.0)?.try_cast_bool("in if condition"),
 			)? {
@@ -603,7 +606,7 @@
 			let import_location = Rc::make_mut(&mut tmp);
 			import_location.pop();
 			push(
-				loc,
+				loc.as_ref(),
 				|| format!("import {:?}", path),
 				|| with_state(|s| s.import_file(import_location, path)),
 			)?

--- a/crates/jrsonnet-evaluator/src/function.rs
+++ b/crates/jrsonnet-evaluator/src/function.rs
@@ -1,8 +1,9 @@
 use crate::{error::Error::*, evaluate, lazy_val, resolved_lazy_val, throw, Context, Result, Val};
 use closure::closure;
+use jrsonnet_interner::IStr;
 use jrsonnet_parser::{ArgsDesc, ParamsDesc};
 use rustc_hash::FxHashMap;
-use std::{collections::HashMap, hash::BuildHasherDefault, rc::Rc};
+use std::{collections::HashMap, hash::BuildHasherDefault};
 
 const NO_DEFAULT_CONTEXT: &str =
 	"no default context set for call with defined default parameter value";
@@ -66,7 +67,7 @@
 	ctx: Context,
 	body_ctx: Option<Context>,
 	params: &ParamsDesc,
-	args: &HashMap<Rc<str>, Val>,
+	args: &HashMap<IStr, Val>,
 	tailstrict: bool,
 ) -> Result<Context> {
 	let mut out = FxHashMap::with_capacity_and_hasher(params.len(), BuildHasherDefault::default());
@@ -143,9 +144,10 @@
 #[macro_export]
 macro_rules! parse_args {
 	($ctx: expr, $fn_name: expr, $args: expr, $total_args: expr, [
-		$($id: expr, $name: ident $(: [$($p: path)|+] $(!! $a: path)?)?, $nt: expr);+ $(;)?
+		$($id: expr, $name: ident: $ty: expr $(=>$match: path)?);+ $(;)?
 	], $handler:block) => {{
-		use crate::{throw, error::Error::*};
+		use $crate::{error::Error::*, throw, evaluate, push_stack_frame, typed::CheckType};
+
 		let args = $args;
 		if args.len() > $total_args {
 			throw!(TooManyArgsFunctionHas($total_args));
@@ -160,47 +162,19 @@
 					throw!(IntrinsicArgumentReorderingIsNotSupportedYet);
 				}
 			}
-			let $name = evaluate($ctx.clone(), &$name.1)?;
+			let $name = push_stack_frame(None, || format!("evaluating argument"), || {
+				let value = evaluate($ctx.clone(), &$name.1)?;
+				$ty.check(&value)?;
+				Ok(value)
+			})?;
 			$(
-				match $name {
-					$($p(_))|+ => {},
-					_ => throw!(TypeMismatch(
-						concat!($fn_name, " ", stringify!($id), "nd (", stringify!($name), ") argument"),
-						$nt, $name.value_type()?
-					)),
+				let $name = if let $match(v) = $name {
+					v
+				} else {
+					unreachable!();
 				};
-				$(
-					let $name = match $name {
-						$a(v) => v,
-						_ =>throw!(TypeMismatch(concat!($fn_name, " ", stringify!($id), "nd (", stringify!($name), ") argument"), $nt, $name.value_type()?)),
-					};
-				)*
-			)*
+			)?
 		)+
 		($handler as crate::Result<_>)
 	}};
-}
-
-#[test]
-fn test() -> Result<()> {
-	use crate::val::ValType;
-	use jrsonnet_parser::*;
-	let state = crate::EvaluationState::default();
-	let evaluator = state.with_stdlib();
-	let ctx = evaluator.create_default_context()?;
-	evaluator.run_in_state(|| {
-		parse_args!(ctx, "test", ArgsDesc(vec![
-			Arg(None, el!(Expr::Num(2.0))),
-			Arg(Some("b".into()), el!(Expr::Num(1.0))),
-		]), 2, [
-			0, a: [Val::Num]!!Val::Num, vec![ValType::Num];
-			1, b: [Val::Num]!!Val::Num, vec![ValType::Num];
-		], {
-			assert!((a - 2.0).abs() <= f64::EPSILON);
-			assert!((b - 1.0).abs() <= f64::EPSILON);
-			Ok(())
-		})
-		.unwrap();
-		Ok(())
-	})
 }

--- a/crates/jrsonnet-evaluator/src/import.rs
+++ b/crates/jrsonnet-evaluator/src/import.rs
@@ -3,6 +3,7 @@
 	throw,
 };
 use fs::File;
+use jrsonnet_interner::IStr;
 use std::fs;
 use std::io::Read;
 use std::{any::Any, cell::RefCell, collections::HashMap, path::PathBuf, rc::Rc};
@@ -15,7 +16,7 @@
 	fn resolve_file(&self, from: &PathBuf, path: &PathBuf) -> Result<Rc<PathBuf>>;
 
 	/// Reads file from filesystem, should be used only with path received from `resolve_file`
-	fn load_file_contents(&self, resolved: &PathBuf) -> Result<Rc<str>>;
+	fn load_file_contents(&self, resolved: &PathBuf) -> Result<IStr>;
 
 	/// # Safety
 	///
@@ -32,7 +33,7 @@
 		throw!(ImportNotSupported(from.clone(), path.clone()))
 	}
 
-	fn load_file_contents(&self, _resolved: &PathBuf) -> Result<Rc<str>> {
+	fn load_file_contents(&self, _resolved: &PathBuf) -> Result<IStr> {
 		// Can be only caused by library direct consumer, not by supplied jsonnet
 		panic!("dummy resolver can't load any file")
 	}
@@ -72,7 +73,7 @@
 			throw!(ImportFileNotFound(from.clone(), path.clone()))
 		}
 	}
-	fn load_file_contents(&self, id: &PathBuf) -> Result<Rc<str>> {
+	fn load_file_contents(&self, id: &PathBuf) -> Result<IStr> {
 		let mut file = File::open(id).map_err(|_e| ResolvedFileNotFound(id.clone()))?;
 		let mut out = String::new();
 		file.read_to_string(&mut out)
@@ -89,7 +90,7 @@
 /// Caches results of the underlying resolver
 pub struct CachingImportResolver {
 	resolution_cache: RefCell<HashMap<ResolutionData, Result<Rc<PathBuf>>>>,
-	loading_cache: RefCell<HashMap<PathBuf, Result<Rc<str>>>>,
+	loading_cache: RefCell<HashMap<PathBuf, Result<IStr>>>,
 	inner: Box<dyn ImportResolver>,
 }
 impl ImportResolver for CachingImportResolver {
@@ -101,7 +102,7 @@
 			.clone()
 	}
 
-	fn load_file_contents(&self, resolved: &PathBuf) -> Result<Rc<str>> {
+	fn load_file_contents(&self, resolved: &PathBuf) -> Result<IStr> {
 		self.loading_cache
 			.borrow_mut()
 			.entry(resolved.clone())

--- a/crates/jrsonnet-evaluator/src/integrations/serde.rs
+++ b/crates/jrsonnet-evaluator/src/integrations/serde.rs
@@ -22,11 +22,10 @@
 			} else {
 				Number::from_f64(*n).expect("to json number")
 			}),
-			Val::Lazy(v) => (&v.evaluate()?).try_into()?,
 			Val::Arr(a) => {
 				let mut out = Vec::with_capacity(a.len());
 				for item in a.iter() {
-					out.push(item.try_into()?);
+					out.push((&item?).try_into()?);
 				}
 				Self::Array(out)
 			}
@@ -55,9 +54,9 @@
 			Value::Array(a) => {
 				let mut out = Vec::with_capacity(a.len());
 				for v in a {
-					out.push(v.into());
+					out.push(LazyVal::new_resolved(v.into()));
 				}
-				Self::Arr(Rc::new(out))
+				Self::Arr(out.into())
 			}
 			Value::Object(o) => {
 				let mut entries = HashMap::with_capacity(o.len());