More OPA conformant semantics (#62)

Signed-off-by: Anand Krishnamoorthi <anakrish@microsoft.com>

src/builtins/aggregates.rs

@@ -21,7 +21,7 @@ pub fn register(m: &mut HashMap<&'static str, builtins::BuiltinFcn>) {
     m.insert("sum", (sum, 1));
 }
 
-fn count(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn count(span: &Span, params: &[Ref<Expr>], args: &[Value], _strict: bool) -> Result<Value> {
     ensure_args_count(span, "count", params, args, 1)?;
 
     Ok(Value::from(Number::from(match &args[0] {
@@ -38,7 +38,7 @@ fn count(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     })))
 }
 
-fn max(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn max(span: &Span, params: &[Ref<Expr>], args: &[Value], _strict: bool) -> Result<Value> {
     ensure_args_count(span, "max", params, args, 1)?;
 
     Ok(match &args[0] {
@@ -53,7 +53,7 @@ fn max(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     })
 }
 
-fn min(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn min(span: &Span, params: &[Ref<Expr>], args: &[Value], _strict: bool) -> Result<Value> {
     ensure_args_count(span, "min", params, args, 1)?;
 
     Ok(match &args[0] {
@@ -68,7 +68,7 @@ fn min(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     })
 }
 
-fn product(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn product(span: &Span, params: &[Ref<Expr>], args: &[Value], _strict: bool) -> Result<Value> {
     ensure_args_count(span, "product", params, args, 1)?;
 
     let mut v = Number::from(1_u64);
@@ -93,7 +93,7 @@ fn product(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     }))
 }
 
-fn sort(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn sort(span: &Span, params: &[Ref<Expr>], args: &[Value], _strict: bool) -> Result<Value> {
     ensure_args_count(span, "sort", params, args, 1)?;
     Ok(match &args[0] {
         Value::Array(a) => {
@@ -110,7 +110,7 @@ fn sort(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     })
 }
 
-fn sum(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn sum(span: &Span, params: &[Ref<Expr>], args: &[Value], _strict: bool) -> Result<Value> {
     ensure_args_count(span, "sum", params, args, 1)?;
 
     let mut v = Number::from(0_u64);

src/builtins/arrays.rs

@@ -18,7 +18,7 @@ pub fn register(m: &mut HashMap<&'static str, builtins::BuiltinFcn>) {
     m.insert("array.slice", (slice, 3));
 }
 
-fn concat(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn concat(span: &Span, params: &[Ref<Expr>], args: &[Value], _strict: bool) -> Result<Value> {
     let name = "array.concat";
     ensure_args_count(span, name, params, args, 2)?;
     let mut v1 = ensure_array(name, &params[0], args[0].clone())?;
@@ -28,7 +28,7 @@ fn concat(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     Ok(Value::Array(v1))
 }
 
-fn reverse(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn reverse(span: &Span, params: &[Ref<Expr>], args: &[Value], _strict: bool) -> Result<Value> {
     let name = "array.reverse";
     ensure_args_count(span, name, params, args, 1)?;
 
@@ -37,7 +37,7 @@ fn reverse(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     Ok(Value::Array(v1))
 }
 
-fn slice(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn slice(span: &Span, params: &[Ref<Expr>], args: &[Value], _strict: bool) -> Result<Value> {
     let name = "array.slice";
     ensure_args_count(span, name, params, args, 3)?;
 

src/builtins/bitwise.rs

@@ -21,7 +21,7 @@ pub fn register(m: &mut HashMap<&'static str, builtins::BuiltinFcn>) {
     m.insert("bits.xor", (xor, 2));
 }
 
-fn and(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn and(span: &Span, params: &[Ref<Expr>], args: &[Value], _strict: bool) -> Result<Value> {
     let name = "bits.and";
     ensure_args_count(span, name, params, args, 2)?;
 
@@ -34,7 +34,7 @@ fn and(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     })
 }
 
-fn lsh(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn lsh(span: &Span, params: &[Ref<Expr>], args: &[Value], _strict: bool) -> Result<Value> {
     let name = "bits.lsh";
     ensure_args_count(span, name, params, args, 2)?;
 
@@ -47,7 +47,7 @@ fn lsh(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     })
 }
 
-fn negate(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn negate(span: &Span, params: &[Ref<Expr>], args: &[Value], _strict: bool) -> Result<Value> {
     let name = "bits.negate";
     ensure_args_count(span, name, params, args, 1)?;
 
@@ -59,7 +59,7 @@ fn negate(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     })
 }
 
-fn or(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn or(span: &Span, params: &[Ref<Expr>], args: &[Value], _strict: bool) -> Result<Value> {
     let name = "bits.or";
     ensure_args_count(span, name, params, args, 2)?;
 
@@ -72,7 +72,7 @@ fn or(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     })
 }
 
-fn rsh(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn rsh(span: &Span, params: &[Ref<Expr>], args: &[Value], _strict: bool) -> Result<Value> {
     let name = "bits.rsh";
     ensure_args_count(span, name, params, args, 2)?;
 
@@ -85,7 +85,7 @@ fn rsh(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     })
 }
 
-fn xor(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn xor(span: &Span, params: &[Ref<Expr>], args: &[Value], _strict: bool) -> Result<Value> {
     let name = "bits.xor";
     ensure_args_count(span, name, params, args, 2)?;
 

src/builtins/conversions.rs

@@ -15,12 +15,13 @@ pub fn register(m: &mut HashMap<&'static str, builtins::BuiltinFcn>) {
     m.insert("to_number", (to_number, 1));
 }
 
-fn to_number(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn to_number(span: &Span, params: &[Ref<Expr>], args: &[Value], _strict: bool) -> Result<Value> {
     let name = "to_number";
     ensure_args_count(span, name, params, args, 1)?;
 
     let span = params[0].span();
     Ok(match &args[0] {
+        Value::Null => Value::from(0u64),
         Value::Bool(true) => Value::from(1u64),
         Value::Bool(false) => Value::from(0u64),
         Value::Number(_) => args[0].clone(),
@@ -34,7 +35,9 @@ fn to_number(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value>
             }
         },
         _ => {
-            bail!(span.error(format!("`{name}` expects bool/number/string argument.").as_str()));
+            bail!(
+                span.error(format!("`{name}` expects bool/number/string/null argument.").as_str())
+            );
         }
     })
 }

src/builtins/crypto.rs

@@ -28,7 +28,12 @@ pub fn register(m: &mut HashMap<&'static str, builtins::BuiltinFcn>) {
     m.insert("crypto.sha256", (crypto_sha256, 1));
 }
 
-fn hmac_equal_fixed_time(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn hmac_equal_fixed_time(
+    span: &Span,
+    params: &[Ref<Expr>],
+    args: &[Value],
+    _strict: bool,
+) -> Result<Value> {
     let name = "crypto.hmac.equal";
     ensure_args_count(span, name, params, args, 2)?;
 
@@ -41,7 +46,7 @@ fn hmac_equal_fixed_time(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> R
     )))
 }
 
-fn hmac_md5(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn hmac_md5(span: &Span, params: &[Ref<Expr>], args: &[Value], _strict: bool) -> Result<Value> {
     let name = "crypto.hmac.md5";
     ensure_args_count(span, name, params, args, 2)?;
 
@@ -57,7 +62,7 @@ fn hmac_md5(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value>
     Ok(Value::String(hex::encode(result.into_bytes()).into()))
 }
 
-fn hmac_sha1(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn hmac_sha1(span: &Span, params: &[Ref<Expr>], args: &[Value], _strict: bool) -> Result<Value> {
     let name = "crypto.hmac.sha1";
     ensure_args_count(span, name, params, args, 2)?;
 
@@ -73,7 +78,7 @@ fn hmac_sha1(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value>
     Ok(Value::String(hex::encode(result.into_bytes()).into()))
 }
 
-fn hmac_sha256(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn hmac_sha256(span: &Span, params: &[Ref<Expr>], args: &[Value], _strict: bool) -> Result<Value> {
     let name = "crypto.hmac.sha256";
     ensure_args_count(span, name, params, args, 2)?;
 
@@ -89,7 +94,7 @@ fn hmac_sha256(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Valu
     Ok(Value::String(hex::encode(result.into_bytes()).into()))
 }
 
-fn hmac_sha512(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn hmac_sha512(span: &Span, params: &[Ref<Expr>], args: &[Value], _strict: bool) -> Result<Value> {
     let name = "crypto.hmac.sha512";
     ensure_args_count(span, name, params, args, 2)?;
 
@@ -105,7 +110,7 @@ fn hmac_sha512(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Valu
     Ok(Value::String(hex::encode(result.into_bytes()).into()))
 }
 
-fn crypto_md5(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn crypto_md5(span: &Span, params: &[Ref<Expr>], args: &[Value], _strict: bool) -> Result<Value> {
     let name = "crypto.md5";
     ensure_args_count(span, name, params, args, 1)?;
 
@@ -119,7 +124,7 @@ fn crypto_md5(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value
     Ok(Value::String(hex::encode(result).into()))
 }
 
-fn crypto_sha1(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn crypto_sha1(span: &Span, params: &[Ref<Expr>], args: &[Value], _strict: bool) -> Result<Value> {
     let name = "crypto.sha1";
     ensure_args_count(span, name, params, args, 1)?;
 
@@ -133,7 +138,12 @@ fn crypto_sha1(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Valu
     Ok(Value::String(hex::encode(result).into()))
 }
 
-fn crypto_sha256(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn crypto_sha256(
+    span: &Span,
+    params: &[Ref<Expr>],
+    args: &[Value],
+    _strict: bool,
+) -> Result<Value> {
     let name = "crypto.sha256";
     ensure_args_count(span, name, params, args, 1)?;
 

src/builtins/debugging.rs

@@ -20,7 +20,7 @@ pub fn register(m: &mut HashMap<&'static str, builtins::BuiltinFcn>) {
 // Symbol analyzer must ensure that vars used by print are defined before
 // the print statement. Scheduler must ensure the above constraint.
 // Additionally interpreter must allow undefined inputs to print.
-fn print(span: &Span, _params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn print(span: &Span, _params: &[Ref<Expr>], args: &[Value], _strict: bool) -> Result<Value> {
     if args.len() > MAX_ARGS as usize {
         bail!(span.error("print supports up to 100 arguments"));
     }

src/builtins/deprecated.rs

@@ -19,7 +19,13 @@ lazy_static! {
 	let mut m : HashMap<&'static str, BuiltinFcn>  = HashMap::new();
 	
 	m.insert("all", (all, 1));
-	m.insert("any", (any, 1));	
+	m.insert("any", (any, 1));
+	m.insert("cast_array", (cast_array, 1));
+	m.insert("cast_boolean", (cast_boolean, 1));
+	m.insert("cast_null", (cast_null, 1));
+	m.insert("cast_object", (cast_object, 1));
+	m.insert("cast_set", (cast_set, 1));
+	m.insert("cast_string", (cast_string, 1));
 	m.insert("set_diff", (set_diff, 2));
 
 	#[cfg(feature = "crypto")]
@@ -28,7 +34,7 @@ lazy_static! {
     };
 }
 
-fn all(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn all(span: &Span, params: &[Ref<Expr>], args: &[Value], _strict: bool) -> Result<Value> {
     ensure_args_count(span, "all", params, args, 1)?;
 
     Ok(Value::Bool(match &args[0] {
@@ -41,7 +47,7 @@ fn all(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     }))
 }
 
-fn any(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn any(span: &Span, params: &[Ref<Expr>], args: &[Value], _strict: bool) -> Result<Value> {
     ensure_args_count(span, "any", params, args, 1)?;
 
     Ok(Value::Bool(match &args[0] {
@@ -54,10 +60,70 @@ fn any(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     }))
 }
 
-fn set_diff(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn set_diff(span: &Span, params: &[Ref<Expr>], args: &[Value], _strict: bool) -> Result<Value> {
     let name = "set_diff";
     ensure_args_count(span, name, params, args, 2)?;
     let s1 = ensure_set(name, &params[0], args[0].clone())?;
     let s2 = ensure_set(name, &params[1], args[1].clone())?;
     Ok(Value::from_set(s1.difference(&s2).cloned().collect()))
 }
+
+fn cast_array(span: &Span, params: &[Ref<Expr>], args: &[Value], strict: bool) -> Result<Value> {
+    let name = "cast_array";
+    ensure_args_count(span, name, params, args, 1)?;
+    match &args[0] {
+        Value::Array(_) => Ok(args[0].clone()),
+        _ if strict => bail!(params[0].span().error("array required")),
+        _ => Ok(Value::Undefined),
+    }
+}
+
+fn cast_boolean(span: &Span, params: &[Ref<Expr>], args: &[Value], strict: bool) -> Result<Value> {
+    let name = "cast_boolean";
+    ensure_args_count(span, name, params, args, 1)?;
+    match &args[0] {
+        Value::Bool(_) => Ok(args[0].clone()),
+        _ if strict => bail!(params[0].span().error("boolean required")),
+        _ => Ok(Value::Undefined),
+    }
+}
+
+fn cast_null(span: &Span, params: &[Ref<Expr>], args: &[Value], strict: bool) -> Result<Value> {
+    let name = "cast_null";
+    ensure_args_count(span, name, params, args, 1)?;
+    match &args[0] {
+        Value::Null => Ok(Value::Null),
+        _ if strict => bail!(params[0].span().error("null required")),
+        _ => Ok(Value::Undefined),
+    }
+}
+
+fn cast_object(span: &Span, params: &[Ref<Expr>], args: &[Value], strict: bool) -> Result<Value> {
+    let name = "cast_object";
+    ensure_args_count(span, name, params, args, 1)?;
+    match &args[0] {
+        Value::Object(_) => Ok(args[0].clone()),
+        _ if strict => bail!(params[0].span().error("object required")),
+        _ => Ok(Value::Undefined),
+    }
+}
+
+fn cast_set(span: &Span, params: &[Ref<Expr>], args: &[Value], strict: bool) -> Result<Value> {
+    let name = "cast_set";
+    ensure_args_count(span, name, params, args, 1)?;
+    match &args[0] {
+        Value::Set(_) => Ok(args[0].clone()),
+        _ if strict => bail!(params[0].span().error("set required")),
+        _ => Ok(Value::Undefined),
+    }
+}
+
+fn cast_string(span: &Span, params: &[Ref<Expr>], args: &[Value], strict: bool) -> Result<Value> {
+    let name = "cast_string";
+    ensure_args_count(span, name, params, args, 1)?;
+    match &args[0] {
+        Value::String(_) => Ok(args[0].clone()),
+        _ if strict => bail!(params[0].span().error("string required")),
+        _ => Ok(Value::Undefined),
+    }
+}

src/builtins/encoding.rs

@@ -26,7 +26,12 @@ pub fn register(m: &mut HashMap<&'static str, builtins::BuiltinFcn>) {
     }
 }
 
-fn base64_decode(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn base64_decode(
+    span: &Span,
+    params: &[Ref<Expr>],
+    args: &[Value],
+    _strict: bool,
+) -> Result<Value> {
     let name = "base64.decode";
     ensure_args_count(span, name, params, args, 1)?;
 
@@ -38,7 +43,12 @@ fn base64_decode(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Va
 }
 
 #[cfg(feature = "yaml")]
-fn yaml_is_valid(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn yaml_is_valid(
+    span: &Span,
+    params: &[Ref<Expr>],
+    args: &[Value],
+    _strict: bool,
+) -> Result<Value> {
     let name = "yaml.is_valid";
     ensure_args_count(span, name, params, args, 1)?;
 
@@ -47,7 +57,7 @@ fn yaml_is_valid(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Va
 }
 
 #[cfg(feature = "yaml")]
-fn yaml_marshal(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn yaml_marshal(span: &Span, params: &[Ref<Expr>], args: &[Value], _strict: bool) -> Result<Value> {
     let name = "yaml.marshal";
     ensure_args_count(span, name, params, args, 1)?;
     Ok(Value::String(
@@ -58,14 +68,24 @@ fn yaml_marshal(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Val
 }
 
 #[cfg(feature = "yaml")]
-fn yaml_unmarshal(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn yaml_unmarshal(
+    span: &Span,
+    params: &[Ref<Expr>],
+    args: &[Value],
+    _strict: bool,
+) -> Result<Value> {
     let name = "yaml.unmarshal";
     ensure_args_count(span, name, params, args, 1)?;
     let yaml_str = ensure_string(name, &params[0], &args[0])?;
     Value::from_yaml_str(&yaml_str).with_context(|| span.error("could not deserialize yaml."))
 }
 
-fn json_is_valid(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn json_is_valid(
+    span: &Span,
+    params: &[Ref<Expr>],
+    args: &[Value],
+    _strict: bool,
+) -> Result<Value> {
     let name = "json.is_valid";
     ensure_args_count(span, name, params, args, 1)?;
 
@@ -73,7 +93,7 @@ fn json_is_valid(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Va
     Ok(Value::Bool(Value::from_json_str(&json_str).is_ok()))
 }
 
-fn json_marshal(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn json_marshal(span: &Span, params: &[Ref<Expr>], args: &[Value], _strict: bool) -> Result<Value> {
     let name = "json.marshal";
     ensure_args_count(span, name, params, args, 1)?;
     Ok(Value::String(
@@ -83,7 +103,12 @@ fn json_marshal(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Val
     ))
 }
 
-fn json_unmarshal(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn json_unmarshal(
+    span: &Span,
+    params: &[Ref<Expr>],
+    args: &[Value],
+    _strict: bool,
+) -> Result<Value> {
     let name = "json.unmarshal";
     ensure_args_count(span, name, params, args, 1)?;
     let json_str = ensure_string(name, &params[0], &args[0])?;

src/builtins/glob.rs

@@ -55,7 +55,7 @@ fn make_glob<'a>(pattern: &'a str, span: &'a Span) -> Result<Glob<'a>> {
     Glob::new(pattern).or_else(|_| bail!(span.error("invalid glob")))
 }
 
-fn glob_match(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn glob_match(span: &Span, params: &[Ref<Expr>], args: &[Value], _strict: bool) -> Result<Value> {
     let name = "glob.match";
     ensure_args_count(span, name, params, args, 3)?;
 
@@ -101,7 +101,7 @@ fn glob_match(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value
     Ok(Value::Bool(glob.is_match(&value[..])))
 }
 
-fn quote_meta(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn quote_meta(span: &Span, params: &[Ref<Expr>], args: &[Value], _strict: bool) -> Result<Value> {
     let name = "glob.quote_meta";
     ensure_args_count(span, name, params, args, 1)?;
 

src/builtins/mod.rs

@@ -38,7 +38,7 @@ use std::collections::HashMap;
 use anyhow::Result;
 use lazy_static::lazy_static;
 
-pub type BuiltinFcn = (fn(&Span, &[Ref<Expr>], &[Value]) -> Result<Value>, u8);
+pub type BuiltinFcn = (fn(&Span, &[Ref<Expr>], &[Value], bool) -> Result<Value>, u8);
 
 #[cfg(feature = "deprecated")]
 pub use deprecated::DEPRECATED;

src/builtins/numbers.rs

@@ -48,28 +48,28 @@ pub fn arithmetic_operation(
     }))
 }
 
-fn abs(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn abs(span: &Span, params: &[Ref<Expr>], args: &[Value], _strict: bool) -> Result<Value> {
     ensure_args_count(span, "abs", params, args, 1)?;
     Ok(Value::from(
         ensure_numeric("abs", &params[0], &args[0])?.abs(),
     ))
 }
 
-fn ceil(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn ceil(span: &Span, params: &[Ref<Expr>], args: &[Value], _strict: bool) -> Result<Value> {
     ensure_args_count(span, "ceil", params, args, 1)?;
     Ok(Value::from(
         ensure_numeric("ceil", &params[0], &args[0])?.ceil(),
     ))
 }
 
-fn floor(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn floor(span: &Span, params: &[Ref<Expr>], args: &[Value], _strict: bool) -> Result<Value> {
     ensure_args_count(span, "floor", params, args, 1)?;
     Ok(Value::from(
         ensure_numeric("floor", &params[0], &args[0])?.floor(),
     ))
 }
 
-fn range(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn range(span: &Span, params: &[Ref<Expr>], args: &[Value], _strict: bool) -> Result<Value> {
     ensure_args_count(span, "numbers.range", params, args, 2)?;
     let v1 = ensure_numeric("numbers.range", &params[0], &args[0].clone())?;
     let v2 = ensure_numeric("numbers.range", &params[1], &args[1].clone())?;
@@ -96,14 +96,14 @@ fn range(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     Ok(Value::from_array(values))
 }
 
-fn round(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn round(span: &Span, params: &[Ref<Expr>], args: &[Value], _strict: bool) -> Result<Value> {
     ensure_args_count(span, "round", params, args, 1)?;
     Ok(Value::from(
         ensure_numeric("round", &params[0], &args[0])?.round(),
     ))
 }
 
-fn intn(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn intn(span: &Span, params: &[Ref<Expr>], args: &[Value], _strict: bool) -> Result<Value> {
     let fcn = "rand.intn";
     ensure_args_count(span, fcn, params, args, 2)?;
     let _ = ensure_string(fcn, &params[0], &args[0])?;

src/builtins/objects.rs

@@ -122,7 +122,7 @@ fn merge_filters(
     Ok(filters)
 }
 
-fn json_filter(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn json_filter(span: &Span, params: &[Ref<Expr>], args: &[Value], _strict: bool) -> Result<Value> {
     let name = "json.filter";
     ensure_args_count(span, name, params, args, 2)?;
     ensure_object(name, &params[0], args[0].clone())?;
@@ -136,7 +136,7 @@ fn json_filter(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Valu
     Ok(json_filter_impl(&args[0], &filters))
 }
 
-fn filter(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn filter(span: &Span, params: &[Ref<Expr>], args: &[Value], _strict: bool) -> Result<Value> {
     let name = "object.filter";
     ensure_args_count(span, name, params, args, 2)?;
     let mut obj = ensure_object(name, &params[0], args[0].clone())?;
@@ -154,7 +154,7 @@ fn filter(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     Ok(Value::Object(obj))
 }
 
-fn get(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn get(span: &Span, params: &[Ref<Expr>], args: &[Value], _strict: bool) -> Result<Value> {
     let name = "object.get";
     ensure_args_count(span, name, params, args, 3)?;
     let obj = ensure_object(name, &params[0], args[0].clone())?;
@@ -179,14 +179,14 @@ fn get(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     })
 }
 
-fn keys(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn keys(span: &Span, params: &[Ref<Expr>], args: &[Value], _strict: bool) -> Result<Value> {
     let name = "object.keys";
     ensure_args_count(span, name, params, args, 1)?;
     let obj = ensure_object(name, &params[0], args[0].clone())?;
     Ok(Value::from_set(obj.keys().cloned().collect()))
 }
 
-fn remove(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn remove(span: &Span, params: &[Ref<Expr>], args: &[Value], _strict: bool) -> Result<Value> {
     let name = "object.remove";
     ensure_args_count(span, name, params, args, 2)?;
     let mut obj = ensure_object(name, &params[0], args[0].clone())?;
@@ -225,7 +225,7 @@ fn is_subset(sup: &Value, sub: &Value) -> bool {
     }
 }
 
-fn subset(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn subset(span: &Span, params: &[Ref<Expr>], args: &[Value], _strict: bool) -> Result<Value> {
     let name = "object.subset";
     ensure_args_count(span, name, params, args, 2)?;
 

src/builtins/regex.rs

@@ -26,7 +26,12 @@ pub fn register(m: &mut HashMap<&'static str, builtins::BuiltinFcn>) {
     m.insert("regex.template_match", (regex_template_match, 4));
 }
 
-fn find_all_string_submatch_n(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn find_all_string_submatch_n(
+    span: &Span,
+    params: &[Ref<Expr>],
+    args: &[Value],
+    _strict: bool,
+) -> Result<Value> {
     let name = "regex.find_all_string_submatch_n";
     ensure_args_count(span, name, params, args, 3)?;
 
@@ -68,7 +73,7 @@ fn find_all_string_submatch_n(span: &Span, params: &[Ref<Expr>], args: &[Value])
     ))
 }
 
-fn find_n(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn find_n(span: &Span, params: &[Ref<Expr>], args: &[Value], _strict: bool) -> Result<Value> {
     let name = "regex.find_n";
     ensure_args_count(span, name, params, args, 3)?;
 
@@ -98,14 +103,19 @@ fn find_n(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     ))
 }
 
-fn is_valid(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn is_valid(span: &Span, params: &[Ref<Expr>], args: &[Value], _strict: bool) -> Result<Value> {
     let name = "regex.is_valid";
     ensure_args_count(span, name, params, args, 1)?;
     Ok(ensure_string(name, &params[0], &args[0])
         .map_or(Value::Bool(false), |p| Value::Bool(Regex::new(&p).is_ok())))
 }
 
-pub fn regex_match(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+pub fn regex_match(
+    span: &Span,
+    params: &[Ref<Expr>],
+    args: &[Value],
+    _strict: bool,
+) -> Result<Value> {
     let name = "regex.match";
     ensure_args_count(span, name, params, args, 2)?;
     let pattern = ensure_string(name, &params[0], &args[0])?;
@@ -116,7 +126,12 @@ pub fn regex_match(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<
     Ok(Value::Bool(pattern.is_match(&value)))
 }
 
-fn regex_replace(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn regex_replace(
+    span: &Span,
+    params: &[Ref<Expr>],
+    args: &[Value],
+    _strict: bool,
+) -> Result<Value> {
     let name = "regex.replace";
     ensure_args_count(span, name, params, args, 3)?;
 
@@ -135,7 +150,7 @@ fn regex_replace(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Va
     ))
 }
 
-fn regex_split(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn regex_split(span: &Span, params: &[Ref<Expr>], args: &[Value], _strict: bool) -> Result<Value> {
     let name = "regex.split";
     ensure_args_count(span, name, params, args, 2)?;
     let pattern = ensure_string(name, &params[0], &args[0])?;
@@ -151,7 +166,12 @@ fn regex_split(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Valu
     ))
 }
 
-fn regex_template_match(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn regex_template_match(
+    span: &Span,
+    params: &[Ref<Expr>],
+    args: &[Value],
+    _strict: bool,
+) -> Result<Value> {
     let name = "regex.template_match";
     ensure_args_count(span, name, params, args, 4)?;
     let template = ensure_string(name, &params[0], &args[0])?;

src/builtins/semver.rs

@@ -19,7 +19,7 @@ pub fn register(m: &mut HashMap<&'static str, builtins::BuiltinFcn>) {
     m.insert("semver.is_valid", (is_valid, 1));
 }
 
-fn compare(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn compare(span: &Span, params: &[Ref<Expr>], args: &[Value], _strict: bool) -> Result<Value> {
     let name = "semver.compare";
     ensure_args_count(span, name, params, args, 2)?;
 
@@ -35,7 +35,7 @@ fn compare(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     Ok(Value::from(result as i64))
 }
 
-fn is_valid(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn is_valid(span: &Span, params: &[Ref<Expr>], args: &[Value], _strict: bool) -> Result<Value> {
     let name = "semver.is_valid";
     ensure_args_count(span, name, params, args, 1)?;
     let v = ensure_string(name, &params[0], &args[0])?;

src/builtins/sets.rs

@@ -34,7 +34,12 @@ pub fn difference(expr1: &Expr, expr2: &Expr, v1: Value, v2: Value) -> Result<Va
     Ok(Value::from_set(s1.difference(&s2).cloned().collect()))
 }
 
-fn intersection_of_set_of_sets(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn intersection_of_set_of_sets(
+    span: &Span,
+    params: &[Ref<Expr>],
+    args: &[Value],
+    _strict: bool,
+) -> Result<Value> {
     let name = "intersection";
     ensure_args_count(span, name, params, args, 1)?;
     let set = ensure_set(name, &params[0], args[0].clone())?;
@@ -61,7 +66,12 @@ fn intersection_of_set_of_sets(span: &Span, params: &[Ref<Expr>], args: &[Value]
     Ok(Value::from_set(res))
 }
 
-fn union_of_set_of_sets(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn union_of_set_of_sets(
+    span: &Span,
+    params: &[Ref<Expr>],
+    args: &[Value],
+    _strict: bool,
+) -> Result<Value> {
     let name = "union";
     ensure_args_count(span, name, params, args, 1)?;
     let set = ensure_set(name, &params[0], args[0].clone())?;

src/builtins/strings.rs

@@ -42,7 +42,7 @@ pub fn register(m: &mut HashMap<&'static str, builtins::BuiltinFcn>) {
     m.insert("upper", (upper, 1));
 }
 
-fn concat(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn concat(span: &Span, params: &[Ref<Expr>], args: &[Value], _strict: bool) -> Result<Value> {
     let name = "concat";
     ensure_args_count(span, name, params, args, 2)?;
     let delimiter = ensure_string(name, &params[0], &args[0])?;
@@ -50,7 +50,7 @@ fn concat(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     Ok(Value::String(collection.join(&delimiter).into()))
 }
 
-fn contains(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn contains(span: &Span, params: &[Ref<Expr>], args: &[Value], _strict: bool) -> Result<Value> {
     let name = "contains";
     ensure_args_count(span, name, params, args, 2)?;
     let s1 = ensure_string(name, &params[0], &args[0])?;
@@ -58,7 +58,7 @@ fn contains(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value>
     Ok(Value::Bool(s1.contains(s2.as_ref())))
 }
 
-fn endswith(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn endswith(span: &Span, params: &[Ref<Expr>], args: &[Value], _strict: bool) -> Result<Value> {
     let name = "endswith";
     ensure_args_count(span, name, params, args, 2)?;
     let s1 = ensure_string(name, &params[0], &args[0])?;
@@ -76,7 +76,7 @@ fn format_number(n: &Number, base: u64) -> String {
     }
 }
 
-fn format_int(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn format_int(span: &Span, params: &[Ref<Expr>], args: &[Value], _strict: bool) -> Result<Value> {
     let name = "format_int";
     ensure_args_count(span, name, params, args, 2)?;
     let mut n = ensure_numeric(name, &params[0], &args[0])?;
@@ -97,7 +97,7 @@ fn format_int(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value
     ))
 }
 
-fn indexof(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn indexof(span: &Span, params: &[Ref<Expr>], args: &[Value], _strict: bool) -> Result<Value> {
     let name = "indexof";
     ensure_args_count(span, name, params, args, 2)?;
     let s1 = ensure_string(name, &params[0], &args[0])?;
@@ -109,7 +109,7 @@ fn indexof(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
 }
 
 #[allow(dead_code)]
-fn indexof_n(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn indexof_n(span: &Span, params: &[Ref<Expr>], args: &[Value], _strict: bool) -> Result<Value> {
     let name = "indexof_n";
     ensure_args_count(span, name, params, args, 2)?;
     let s1 = ensure_string(name, &params[0], &args[0])?;
@@ -128,14 +128,14 @@ fn indexof_n(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value>
     Ok(Value::from_array(positions))
 }
 
-fn lower(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn lower(span: &Span, params: &[Ref<Expr>], args: &[Value], _strict: bool) -> Result<Value> {
     let name = "lower";
     ensure_args_count(span, name, params, args, 1)?;
     let s = ensure_string(name, &params[0], &args[0])?;
     Ok(Value::String(s.to_lowercase().into()))
 }
 
-fn replace(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn replace(span: &Span, params: &[Ref<Expr>], args: &[Value], _strict: bool) -> Result<Value> {
     let name = "replace";
     ensure_args_count(span, name, params, args, 3)?;
     let s = ensure_string(name, &params[0], &args[0])?;
@@ -144,7 +144,7 @@ fn replace(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     Ok(Value::String(s.replace(old.as_ref(), new.as_ref()).into()))
 }
 
-fn split(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn split(span: &Span, params: &[Ref<Expr>], args: &[Value], _strict: bool) -> Result<Value> {
     let name = "replace";
     ensure_args_count(span, name, params, args, 2)?;
     let s = ensure_string(name, &params[0], &args[0])?;
@@ -157,7 +157,7 @@ fn split(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     ))
 }
 
-fn sprintf(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn sprintf(span: &Span, params: &[Ref<Expr>], args: &[Value], _strict: bool) -> Result<Value> {
     let name = "sprintf";
     ensure_args_count(span, name, params, args, 2)?;
     let fmt = ensure_string(name, &params[0], &args[0])?;
@@ -345,7 +345,12 @@ fn sprintf(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     Ok(Value::String(s.into()))
 }
 
-fn any_prefix_match(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn any_prefix_match(
+    span: &Span,
+    params: &[Ref<Expr>],
+    args: &[Value],
+    _strict: bool,
+) -> Result<Value> {
     let name = "strings.any_prefix_match";
     ensure_args_count(span, name, params, args, 2)?;
 
@@ -376,7 +381,12 @@ fn any_prefix_match(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result
     ))
 }
 
-fn any_suffix_match(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn any_suffix_match(
+    span: &Span,
+    params: &[Ref<Expr>],
+    args: &[Value],
+    _strict: bool,
+) -> Result<Value> {
     let name = "strings.any_suffix_match";
     ensure_args_count(span, name, params, args, 2)?;
 
@@ -407,7 +417,7 @@ fn any_suffix_match(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result
     ))
 }
 
-fn startswith(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn startswith(span: &Span, params: &[Ref<Expr>], args: &[Value], _strict: bool) -> Result<Value> {
     let name = "startswith";
     ensure_args_count(span, name, params, args, 2)?;
     let s1 = ensure_string(name, &params[0], &args[0])?;
@@ -415,7 +425,7 @@ fn startswith(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value
     Ok(Value::Bool(s1.starts_with(s2.as_ref())))
 }
 
-fn replace_n(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn replace_n(span: &Span, params: &[Ref<Expr>], args: &[Value], _strict: bool) -> Result<Value> {
     let name = "trim";
     ensure_args_count(span, name, params, args, 2)?;
     let obj = ensure_object(name, &params[0], args[0].clone())?;
@@ -438,14 +448,14 @@ fn replace_n(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value>
     Ok(Value::String(s.clone()))
 }
 
-fn reverse(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn reverse(span: &Span, params: &[Ref<Expr>], args: &[Value], _strict: bool) -> Result<Value> {
     let name = "reverse";
     ensure_args_count(span, name, params, args, 1)?;
     let s = ensure_string(name, &params[0], &args[0])?;
     Ok(Value::String(s.chars().rev().collect::<String>().into()))
 }
 
-fn substring(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn substring(span: &Span, params: &[Ref<Expr>], args: &[Value], _strict: bool) -> Result<Value> {
     let name = "substring";
     ensure_args_count(span, name, params, args, 3)?;
     let s = ensure_string(name, &params[0], &args[0])?;
@@ -470,7 +480,7 @@ fn substring(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value>
     }
 }
 
-fn trim(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn trim(span: &Span, params: &[Ref<Expr>], args: &[Value], _strict: bool) -> Result<Value> {
     let name = "trim";
     ensure_args_count(span, name, params, args, 2)?;
     let s1 = ensure_string(name, &params[0], &args[0])?;
@@ -478,7 +488,7 @@ fn trim(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
     Ok(Value::String(s1.trim_matches(|c| s2.contains(c)).into()))
 }
 
-fn trim_left(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn trim_left(span: &Span, params: &[Ref<Expr>], args: &[Value], _strict: bool) -> Result<Value> {
     let name = "trim_left";
     ensure_args_count(span, name, params, args, 2)?;
     let s1 = ensure_string(name, &params[0], &args[0])?;
@@ -488,7 +498,7 @@ fn trim_left(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value>
     ))
 }
 
-fn trim_prefix(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn trim_prefix(span: &Span, params: &[Ref<Expr>], args: &[Value], _strict: bool) -> Result<Value> {
     let name = "trim_prefix";
     ensure_args_count(span, name, params, args, 2)?;
     let s1 = ensure_string(name, &params[0], &args[0])?;
@@ -499,7 +509,7 @@ fn trim_prefix(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Valu
     }))
 }
 
-fn trim_right(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn trim_right(span: &Span, params: &[Ref<Expr>], args: &[Value], _strict: bool) -> Result<Value> {
     let name = "trim_right";
     ensure_args_count(span, name, params, args, 2)?;
     let s1 = ensure_string(name, &params[0], &args[0])?;
@@ -509,14 +519,14 @@ fn trim_right(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value
     ))
 }
 
-fn trim_space(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn trim_space(span: &Span, params: &[Ref<Expr>], args: &[Value], _strict: bool) -> Result<Value> {
     let name = "trim_space";
     ensure_args_count(span, name, params, args, 1)?;
     let s = ensure_string(name, &params[0], &args[0])?;
     Ok(Value::String(s.trim().into()))
 }
 
-fn trim_suffix(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn trim_suffix(span: &Span, params: &[Ref<Expr>], args: &[Value], _strict: bool) -> Result<Value> {
     let name = "trim_suffix";
     ensure_args_count(span, name, params, args, 2)?;
     let s1 = ensure_string(name, &params[0], &args[0])?;
@@ -527,7 +537,7 @@ fn trim_suffix(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Valu
     }))
 }
 
-fn upper(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn upper(span: &Span, params: &[Ref<Expr>], args: &[Value], _strict: bool) -> Result<Value> {
     let name = "upper";
     ensure_args_count(span, name, params, args, 1)?;
     let s = ensure_string(name, &params[0], &args[0])?;

src/builtins/time.rs

@@ -16,7 +16,7 @@ pub fn register(m: &mut HashMap<&'static str, builtins::BuiltinFcn>) {
     m.insert("time.now_ns", (now_ns, 0));
 }
 
-fn now_ns(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn now_ns(span: &Span, params: &[Ref<Expr>], args: &[Value], _strict: bool) -> Result<Value> {
     let name = "time.now_ns";
     ensure_args_count(span, name, params, args, 0)?;
 

src/builtins/tracing.rs

@@ -17,7 +17,7 @@ pub fn register(m: &mut HashMap<&'static str, builtins::BuiltinFcn>) {
 
 // Symbol analyzer must ensure that vars used by trace are defined before
 // the trace statement. Scheduler must ensure the above constraint.
-fn trace(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn trace(span: &Span, params: &[Ref<Expr>], args: &[Value], _strict: bool) -> Result<Value> {
     let name = "trace";
     ensure_args_count(span, name, params, args, 1)?;
     let msg = ensure_string(name, &params[0], &args[0])?;

src/builtins/types.rs

@@ -22,37 +22,37 @@ pub fn register(m: &mut HashMap<&'static str, builtins::BuiltinFcn>) {
     m.insert("type_name", (type_name, 1));
 }
 
-fn is_array(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn is_array(span: &Span, params: &[Ref<Expr>], args: &[Value], _strict: bool) -> Result<Value> {
     ensure_args_count(span, "is_array", params, args, 1)?;
     Ok(Value::Bool(matches!(&args[0], Value::Array(_))))
 }
 
-fn is_boolean(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn is_boolean(span: &Span, params: &[Ref<Expr>], args: &[Value], _strict: bool) -> Result<Value> {
     ensure_args_count(span, "is_boolean", params, args, 1)?;
     Ok(Value::Bool(matches!(&args[0], Value::Bool(_))))
 }
 
-fn is_null(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn is_null(span: &Span, params: &[Ref<Expr>], args: &[Value], _strict: bool) -> Result<Value> {
     ensure_args_count(span, "is_null", params, args, 1)?;
     Ok(Value::Bool(matches!(&args[0], Value::Null)))
 }
 
-fn is_number(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn is_number(span: &Span, params: &[Ref<Expr>], args: &[Value], _strict: bool) -> Result<Value> {
     ensure_args_count(span, "is_number", params, args, 1)?;
     Ok(Value::Bool(matches!(&args[0], Value::Number(_))))
 }
 
-fn is_object(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn is_object(span: &Span, params: &[Ref<Expr>], args: &[Value], _strict: bool) -> Result<Value> {
     ensure_args_count(span, "is_object", params, args, 1)?;
     Ok(Value::Bool(matches!(&args[0], Value::Object(_))))
 }
 
-fn is_set(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn is_set(span: &Span, params: &[Ref<Expr>], args: &[Value], _strict: bool) -> Result<Value> {
     ensure_args_count(span, "is_set", params, args, 1)?;
     Ok(Value::Bool(matches!(&args[0], Value::Set(_))))
 }
 
-fn is_string(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn is_string(span: &Span, params: &[Ref<Expr>], args: &[Value], _strict: bool) -> Result<Value> {
     ensure_args_count(span, "is_string", params, args, 1)?;
     Ok(Value::Bool(matches!(&args[0], Value::String(_))))
 }
@@ -70,7 +70,12 @@ pub fn get_type(value: &Value) -> &str {
     }
 }
 
-pub fn type_name(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+pub fn type_name(
+    span: &Span,
+    params: &[Ref<Expr>],
+    args: &[Value],
+    _strict: bool,
+) -> Result<Value> {
     ensure_args_count(span, "type_name", params, args, 1)?;
     Ok(Value::String(get_type(&args[0]).into()))
 }

src/builtins/units.rs

@@ -66,7 +66,7 @@ fn two_exp(suffix: &str) -> Option<i32> {
     })
 }
 
-fn parse(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn parse(span: &Span, params: &[Ref<Expr>], args: &[Value], _strict: bool) -> Result<Value> {
     let name = "units.parse";
     ensure_args_count(span, name, params, args, 1)?;
     let string = ensure_string(name, &params[0], &args[0])?;
@@ -143,7 +143,7 @@ fn tenb_exp(suffix: &str) -> Option<i32> {
     })
 }
 
-fn parse_bytes(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Value> {
+fn parse_bytes(span: &Span, params: &[Ref<Expr>], args: &[Value], strict: bool) -> Result<Value> {
     let name = "units.parse_bytes";
     ensure_args_count(span, name, params, args, 1)?;
     let string = ensure_string(name, &params[0], &args[0])?;
@@ -166,12 +166,15 @@ fn parse_bytes(span: &Span, params: &[Ref<Expr>], args: &[Value]) -> Result<Valu
         _ => (string, ""),
     };
 
-    let v: Value = if number_part.starts_with('.') {
+    let v: Value = match if number_part.starts_with('.') {
         serde_json::from_str(format!("0{number_part}").as_str())
     } else {
         serde_json::from_str(number_part)
-    }
-    .with_context(|| span.error("could not parse number"))?;
+    } {
+        Ok(v) => v,
+        Err(_) if strict => bail!(span.error("could not parse number")),
+        _ => return Ok(Value::Undefined),
+    };
 
     let mut n = match v {
         Value::Number(n) => n.clone(),