DEV Community: Hercules Lemke Merscher

Tsonnet #43 - Object fields, now with an opt-out clause

Hercules Lemke Merscher — Tue, 02 Jun 2026 08:55:10 +0000

Welcome to the Tsonnet series!

If you're not following along, check out how it all started in the first post of the series.

In the previous post, we got conditionals working:

Hercules Lemke Merscher

May 21

Tsonnet #42 - If then else (finally)

#tsonnet #jsonnet #compiler

7 min read

Turns out conditionals had one more trick to pull: deciding whether a field exists at all.

The target

I need to cover the Computed Field Names tutorial as the next step for Tsonnet:

// samples/tutorials/computed-fields.jsonnet
local Margarita(salted) = {
  ingredients: [
    { kind: 'Tequila Blanco', qty: 2 },
    { kind: 'Lime', qty: 1 },
    { kind: 'Cointreau', qty: 1 },
  ],
  [if salted then 'garnish']: 'Salt',
};
{
  Margarita: Margarita(true),
  'Margarita Unsalted': Margarita(false),
}

Let's target only the part we are interested in, adding new attributes to samples/conditionals/conditionals.jsonnet:

// samples/conditionals/conditionals.jsonnet
{
    // ... 

    [if true then 'conditional_attribute_then']: true,
    [if false then '...']: false,
    [if false then '...' else 'conditional_attribute_else']: false
}

There's one caveat though:

$ dune exec -- tsonnet samples/conditionals/conditionals.jsonnet
ERROR: samples/conditionals/conditionals.jsonnet:17:5 Parsing error. Invalid syntax:

17:     [if true then 'conditional_attribute_then']: true,
    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

$ dune exec -- tsonnet samples/tutorials/computed-fields.jsonnet
ERROR: samples/tutorials/computed-fields.jsonnet:7:3 Parsing error. Invalid syntax:

7:   [if salted then 'garnish']: 'Salt',
   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

There's no object's conditional attribute support yet.

Let's add new testing samples

We need to cover a few cases other than the three conditional attributes shown above.

Non string attributes:

// samples/conditionals/conditional_attr_not_string.jsonnet
{
  [if true then 42]: "value"
}

Cyclic references in conditional fields:

// samples/semantics/invalid_conditional_field_cyclic_key.jsonnet
{
    a: self.b,
    b: self.a,
    [if true then self.a else "x"]: "value",
}

Ignored cyclic reference field:

// samples/semantics/valid_conditional_field_access_cyclic.jsonnet
local obj = {
    a: 1,
    [if true then "b"]: self.c,
    c: self.b,
};
obj.a

A new object entry variant

diff --git a/lib/ast.ml b/lib/ast.ml
index 35f88a6..fdb5bbe 100644
--- a/lib/ast.ml
+++ b/lib/ast.ml
@@ -97,6 +97,7 @@ type expr =

 and object_entry =
   | ObjectField of string * expr
+  | ObjectConditionalField of expr * expr
   | ObjectExpr of expr
 and object_scope =
   | Self
@@ -236,6 +237,7 @@ let rec string_of_type = function

 and string_of_object_entry = function
   | ObjectField (field, expr) -> field ^ ": " ^ string_of_type expr
+  | ObjectConditionalField (field, expr) -> string_of_type field ^ ": " ^ string_of_type expr
   | ObjectExpr expr -> string_of_type expr

The parser needs only one more rule for obj_field -- pretty straightforward:

diff --git a/lib/parser.mly b/lib/parser.mly
index 40858f4..4e7775e 100644
--- a/lib/parser.mly
+++ b/lib/parser.mly
@@ -113,6 +113,7 @@ obj_field:
         Closure (with_pos $startpos $endpos, { params = params; body = body })
       )
     }
+  | LEFT_SQR_BRACKET; k = conditional; RIGHT_SQR_BRACKET; COLON; e = assignable_expr { ObjectConditionalField (k, e) }
   | e = single_var { ObjectExpr e }
   ;

The scope validation is also straightforward. First we check the field_expr, followed by the assignment expr:

diff --git a/lib/scope.ml b/lib/scope.ml
index df55eea..3f329fe 100644
--- a/lib/scope.ml
+++ b/lib/scope.ml
@@ -82,6 +82,7 @@ and validate_object_entries entries context =
       acc >>= fun _ ->
       match entry with
       | ObjectField (_, expr) -> _validate expr context
+      | ObjectConditionalField (field_expr, expr) -> _validate field_expr context >>= fun () -> _validate expr context
       | ObjectExpr expr -> _validate expr context
     )
     (ok ())

Type checking

The type checking phase is where most of the complexity for this feature lies. Let's break it down.

I had to carry the string with the Tstring type variant to be able to do certain checks:

diff --git a/lib/type.ml b/lib/type.ml
index 88e5b3a..ce61163 100644
--- a/lib/type.ml
+++ b/lib/type.ml
@@ -9,7 +9,7 @@ type tsonnet_type =
   | Tnull
   | Tbool
   | Tnumber
-  | Tstring
+  | Tstring of string
   | Tany
   | Tarray of tsonnet_type
   | Tobject of t_object_entry list
@@ -47,7 +47,7 @@ let rec to_string = function
   | Tnull -> "Null"
   | Tbool -> "Bool"
   | Tnumber -> "Number"
-  | Tstring -> "String"
+  | Tstring _ -> "String"
   | Tany -> "Any"
   | Tarray ty -> "Array of " ^ to_string ty
   | Tobject fields ->

let rec translate venv expr =
   match expr with
   | Unit -> ok (venv, Tunit)
   | Null _ -> ok (venv, Tnull)
   | Bool _ -> ok (venv, Tbool)
   | Number _ -> ok (venv, Tnumber)
-  | String _ -> ok (venv, Tstring)
+  | String (_, s) -> ok (venv, Tstring s)
   | Ident (pos, varname) -> translate_ident venv pos varname
   | Array (_pos, elems) -> translate_array venv elems
   | ParsedObject (pos, entries) -> translate_object venv pos entries

This, of course, led to many changes down the line. The semantics didn't change — I only had to fix the pattern-matching. Example:

@@ -466,7 +528,7 @@ and translate_object_field_access venv pos scope chain_exprs =
       | Number (pos, _) ->
         (* Handle numeric indexing of strings and arrays *)
         (match prev_ty with
-        | Tstring -> ok (venv, Tstring)
+        | Tstring _ as ty -> ok (venv, ty)
         | Tarray elem_ty -> ok (venv, elem_ty)
         | _ -> Error.error_at pos (Error.Msg.type_non_indexable_type (to_string prev_ty))
         )

I'm intentionally dropping the other cases like that to keep this post cleaner, and more to the point. The entire thing can be seen in the complete diff shared in the conclusion.

We'll need the semantic_type_equal function:

(* Semantic equality for types. *)
let semantic_type_equal ty_a ty_b =
  match ty_a, ty_b with
  (* Ignores representation details that do not affect type identity,
     such as the concrete value carried by Tstring.  *)
  | Tstring _, Tstring _ -> true
  (* Falls back to structural equality otherwise. *)
  | _ -> ty_a = ty_b

Everything other than Tstring can be compared structurally. Though this will likely need to be revisited soon.

When calling translate_object, we must pattern-match the new variant:

@@ -359,22 +381,49 @@ and translate_object venv pos entries =
         let* (venv', _) = translate venv expr in (ok venv')
       | ObjectField (attr, expr) ->
         ok (Env.add_obj_field attr (Lazy expr) obj_id venv)
+      | ObjectConditionalField (attr_expr, expr) ->
+        (match check_expr_for_cycles venv attr_expr [] with
+        | Ok () -> ()
+        | Error _ ->
+          let attr_pos = match attr_expr with If (p, _, _, _) -> p | _ -> pos in
+          Error.warn Error.Msg.type_cyclic_conditional_field_key attr_pos
+        );
+        (* It's past attr_expr, which means it has no cyclic refs.
+           Now we need to add the expr to the attr name it resolves to. *)
+        let* (_, ty) = translate venv attr_expr in
+        (match ty with
+        | Tstring attr -> ok (Env.add_obj_field attr (Lazy expr) obj_id venv)
+        | Tnull -> ok venv
+        | _ ->
+          let attr_pos = match attr_expr with If (p, _, _, _) -> p | _ -> pos in
+          Error.error_at attr_pos
+            (Error.Msg.invalid_conditional_field_key (to_string ty))
+        )
     )
     (ok venv)
     entries
   in

Since this field is a conditional, we must check the expr for cycles. After that, we can translate it, and extract the field name from Tstring to add the body expr to the environment. Nulls are ignored, just like Jsonnet.

The next step is the cyclic reference check for the attributes' body expr, and conditional fields are not different:

   (* Check for cyclical references among object fields
-    (warn, don't error when the reference is not part of
-    the evaluation tree)
-  *)
+    (warn, don't error when the reference is not part of the evaluation tree) *)
   List.iter
     (fun entry ->
       match entry with
       | ObjectField (attr, _) ->
         (match check_cyclic_refs venv (Env.uniq_field_ident obj_id attr) [] pos with
         | Ok () -> ()
-        | Error _ -> Error.warn (Error.Msg.type_cyclic_reference (Env.uniq_field_ident obj_id attr)) pos)
+        | Error _ -> Error.warn (Error.Msg.type_cyclic_reference (Env.uniq_field_ident obj_id attr)) pos
+        )
+      | ObjectConditionalField (attr_expr, _) ->
+        (* attr_expr must be translated first to discover its name, then we can check_cyclic_refs *)
+        (match translate venv attr_expr with
+        | Ok (_, Tstring attr) ->
+          (match check_cyclic_refs venv (Env.uniq_field_ident obj_id attr) [] pos with
+          | Ok () -> ()
+          | Error _ -> Error.warn (Error.Msg.type_cyclic_reference (Env.uniq_field_ident obj_id attr)) pos
+          )
+        | _ -> ()
+        )
       | _ -> ()
     )
     entries;

And the last step in translate_object is to translate each field:

@@ -382,16 +431,23 @@ and translate_object venv pos entries =
   (* Translate object fields lazily: warn on errors, skip invalid fields *)
   let entry_types = List.fold_left
     (fun entries' entry ->
-      match entry with
-      | ObjectField (attr, _) ->
-        (match Env.get_obj_field attr obj_id venv
-          ~succ:translate_lazy
-          ~err:(Error.error_at pos)
-        with
+      (* Resolve the field from the env to reuse memoized lazy translations
+        instead of retyping the field expression. *)
+      let get_field_type_from_env attr =
+        let obj_field = Env.get_obj_field attr obj_id venv ~succ:translate_lazy ~err:(Error.error_at pos) in
+        (match obj_field with
         | Ok (_, entry_ty) -> entries' @ [TobjectField (attr, entry_ty)]
-        | Error _ -> entries')
-      | _ ->
-        entries'
+        | Error _ -> entries'
+        )
+      in
+      match entry with
+      | ObjectField (attr, _) -> get_field_type_from_env attr
+      | ObjectConditionalField (attr_expr, _) ->
+        (match translate venv attr_expr with
+        | Ok (_, Tstring attr) -> get_field_type_from_env attr
+        | _ -> entries'
+        )
+      | _ -> entries'
     )
     []
     entries

The cycle check above requires new code to deal with ObjectConditionalField:

@@ -100,6 +109,7 @@ let rec collect_free_idents = function
   | ParsedObject (_, entries) ->
     List.concat_map (function
       | ObjectField (_, e) -> collect_free_idents e
+      | ObjectConditionalField (field, e) -> List.append (collect_free_idents field) (collect_free_idents e)
       | ObjectExpr e -> collect_free_idents e
     ) entries
   | ObjectFieldAccess (_, scope, exprs) ->
@@ -152,6 +162,7 @@ and check_expr_for_cycles venv expr seen =
   | BinOp (_, _, e1, e2) -> iter_for_cycles venv seen [e1; e2]
   | UnaryOp (_, _, e) -> check_expr_for_cycles venv e seen
   | Seq exprs -> iter_for_cycles venv seen exprs
+  | If (_, cond_expr, then_expr, else_expr_opt) -> check_conditional_for_cycles venv (cond_expr, then_expr, else_expr_opt) seen
   | _ -> ok ()
 and iter_for_cycles venv seen exprs =
   List.fold_left

Where we check each expr for cycles:

and check_conditional_for_cycles venv (cond_expr, then_expr, else_expr_opt) seen =
  let* () = check_expr_for_cycles venv cond_expr seen in
  let* () = check_expr_for_cycles venv then_expr seen in
  (match else_expr_opt with
  | Some else_expr -> check_expr_for_cycles venv else_expr seen
  | None -> ok ()
  )

@@ -163,6 +174,9 @@ and check_object_for_cycles venv entries seen =
     (fun ok entry -> ok >>= fun _ ->
       match entry with
       | ObjectField (field, expr) -> check_expr_for_cycles venv expr (field :: seen)
+      | ObjectConditionalField (field, expr) ->
+        check_expr_for_cycles venv field seen >>= fun () ->
+        check_expr_for_cycles venv expr seen
       | ObjectExpr expr -> check_expr_for_cycles venv expr seen
     )
     (ok ())

And to finish it off the type checking phase, we check if the two branch types are semantically equal:

@@ -714,13 +785,13 @@ and translate_conditional venv (pos, cond_expr, then_expr, else_expr_opt) =
     (match else_expr_opt with
     | Some else_expr ->
       let* (_, else_type) = translate venv else_expr in
-      if then_type = else_type
+      if semantic_type_equal then_type else_type
       then ok (venv, then_type)
-      else Error.error_at pos
-        (Error.Msg.type_conditional_branches_mismatch
-          ~then_type:(to_string then_type)
-          ~else_type:(to_string else_type)
-        )
+        else Error.error_at pos
+          (Error.Msg.type_conditional_branches_mismatch
+            ~then_type:(to_string then_type)
+            ~else_type:(to_string else_type)
+          )
     | None ->
       ok (venv, then_type)
     )

And with that, we also add more error keys to the error module:

diff --git a/lib/error.ml b/lib/error.ml
index b1ae567..422456a 100644
--- a/lib/error.ml
+++ b/lib/error.ml
@@ -14,6 +14,8 @@ module Msg = struct
   let invalid_binary_op = "Invalid binary operation"
   let invalid_unary_op = "Invalid unary operation"
   let must_be_object = "Must be an object"
+  let invalid_conditional_field_key ty =
+    Printf.sprintf "Conditional field key must be String or Null, got %s" ty

   (* Parser messages *)
   let parse_error = "Parsing error. Invalid syntax:"
@@ -21,6 +23,7 @@ module Msg = struct

   (* Type checker messages *)
   let type_cyclic_reference varname = "Cyclic reference found for " ^ varname
+  let type_cyclic_conditional_field_key = "Cyclic reference found in conditional field key"
   let type_unused_variable varname = "Unused variable " ^ varname
   let type_non_indexable_value ty = ty ^ " is a non indexable value"
   let type_expected_integer_index ty = "Expected Integer index, got " ^ ty
diff --git a/lib/error.mli b/lib/error.mli
index 28cd496..ec9d177 100644
--- a/lib/error.mli
+++ b/lib/error.mli
@@ -11,6 +11,7 @@ module Msg : sig
   val invalid_binary_op : string
   val invalid_unary_op : string
   val must_be_object : string
+  val invalid_conditional_field_key : string -> string

   (* Parser messages *)
   val parse_error : string
@@ -18,6 +19,7 @@ module Msg : sig

   (* Type checker messages *)
   val type_cyclic_reference : string -> string
+  val type_cyclic_conditional_field_key : string
   val type_unused_variable : string -> string
   val type_non_indexable_value : string -> string
   val type_expected_integer_index : string -> string

Evaluating

The evaluation part is straightforward, after the type checker did the heavy lifting:

diff --git a/lib/interpreter.ml b/lib/interpreter.ml
index 235b90e..40b9eea 100644
--- a/lib/interpreter.ml
+++ b/lib/interpreter.ml
@@ -137,16 +137,29 @@ and interpret_object env (pos, entries) =
   let* (obj_env, fields) = List.fold_left
     (fun result entry ->
       let* (env', fields) = result in
+      let add_field name expr obj_id env =
+        (* Object fields are kept lazy -- they will be evaluated only when accessed.
+           This prevents infinite loops from circular references. *)
+        let env' = Env.add_obj_field name expr obj_id env in
+        ok (env', ObjectFields.add name fields)
+      in
       match entry with
       | ObjectExpr expr ->
         (* ObjectExpr holds a single local. Interpreting
           it will add the expr to the environment *)
         let* (env', _) = interpret env' expr in ok (env', fields)
       | ObjectField (name, expr) ->
-        (* Object fields are kept lazy -- they will be evaluated only when accessed.
-           This prevents infinite loops from circular references. *)
-        let env' = Env.add_obj_field name expr obj_id env' in
-        ok (env', ObjectFields.add name fields)
+        add_field name expr obj_id env'
+      | ObjectConditionalField (field_expr, expr) ->
+        let* (_, ident) = interpret env field_expr in
+        (match ident with
+        | Null _ -> ok (env', fields) (* null attribute names are ignored *)
+        | String (_, name) -> add_field name expr obj_id env'
+        | _ ->
+          let field_pos = match field_expr with If (p, _, _, _) -> p | _ -> pos in
+          Error.error_at field_pos
+            (Error.Msg.invalid_conditional_field_key (string_of_type ident))
+        )
     )
     (ok (obj_env, ObjectFields.empty))
     entries

Moment of truth

Jsonnet does not allow referencing the own object in conditional fields:

$ jsonnet samples/semantics/invalid_conditional_field_cyclic_key.jsonnet
samples/semantics/invalid_conditional_field_cyclic_key.jsonnet:4:19-23 Can't use self outside of an object.

    [if true then self.a else "x"]: "value",

Tsonnet does, and will complain about the cyclic access:

$ dune exec -- tsonnet samples/semantics/invalid_conditional_field_cyclic_key.jsonnet
ERROR: samples/semantics/invalid_conditional_field_cyclic_key.jsonnet:3:7 Cyclic reference found for 1->a

3:     b: self.a,
   ^^^^^^^^^^^^^^

To be honest, I'm not certain which behavior is best to keep here. I believe allowing self references makes sense in a lazy language accessing references from its own scope. I will keep betting on this behavior until I hit a wall of unmanageable complexity. Until then, better checks for us!

In another scenario, Jsonnet goes on with the cyclic access:

$ jsonnet samples/semantics/invalid_conditional_field_cyclic_value.jsonnet
RUNTIME ERROR: max stack frames exceeded.
    samples/semantics/invalid_conditional_field_cyclic_value.jsonnet:3:25-31    object <anonymous>
    samples/semantics/invalid_conditional_field_cyclic_value.jsonnet:4:8-14 object <anonymous>
    samples/semantics/invalid_conditional_field_cyclic_value.jsonnet:3:25-31    object <anonymous>
    samples/semantics/invalid_conditional_field_cyclic_value.jsonnet:4:8-14 object <anonymous>
    samples/semantics/invalid_conditional_field_cyclic_value.jsonnet:3:25-31    object <anonymous>
    samples/semantics/invalid_conditional_field_cyclic_value.jsonnet:4:8-14 object <anonymous>
    samples/semantics/invalid_conditional_field_cyclic_value.jsonnet:3:25-31    object <anonymous>
    samples/semantics/invalid_conditional_field_cyclic_value.jsonnet:4:8-14 object <anonymous>
    samples/semantics/invalid_conditional_field_cyclic_value.jsonnet:3:25-31    object <anonymous>
    samples/semantics/invalid_conditional_field_cyclic_value.jsonnet:4:8-14 object <anonymous>
    ...
    samples/semantics/invalid_conditional_field_cyclic_value.jsonnet:4:8-14 object <anonymous>
    samples/semantics/invalid_conditional_field_cyclic_value.jsonnet:3:25-31    object <anonymous>
    samples/semantics/invalid_conditional_field_cyclic_value.jsonnet:4:8-14 object <anonymous>
    samples/semantics/invalid_conditional_field_cyclic_value.jsonnet:3:25-31    object <anonymous>
    samples/semantics/invalid_conditional_field_cyclic_value.jsonnet:4:8-14 object <anonymous>
    samples/semantics/invalid_conditional_field_cyclic_value.jsonnet:3:25-31    object <anonymous>
    samples/semantics/invalid_conditional_field_cyclic_value.jsonnet:4:8-14 object <anonymous>
    samples/semantics/invalid_conditional_field_cyclic_value.jsonnet:3:25-31    object <anonymous>
    Field "b"
    During manifestation

Tsonnet will report an error -- plus warnings:

dune exec -- tsonnet samples/semantics/invalid_conditional_field_cyclic_value.jsonnet
WARNING: samples/semantics/invalid_conditional_field_cyclic_value.jsonnet:1:0 Cyclic reference found for 1->b

1: {
   ^
2:     a: 1,
   ^^^^^^^^^
3:     [if true then "b"]: self.c,
   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
4:     c: self.b,
   ^^^^^^^^^^^^^^
---
WARNING: samples/semantics/invalid_conditional_field_cyclic_value.jsonnet:1:0 Cyclic reference found for 1->c

1: {
   ^
2:     a: 1,
   ^^^^^^^^^
3:     [if true then "b"]: self.c,
   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
4:     c: self.b,
   ^^^^^^^^^^^^^^
---
ERROR: samples/semantics/invalid_conditional_field_cyclic_value.jsonnet:3:29 Cyclic reference found for 1->c

3:     [if true then "b"]: self.c,
   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

For untouched object fields with cyclic references, Jsonnet ignores them, as expected of a lazy language:

$ jsonnet samples/semantics/valid_conditional_field_access_cyclic.jsonnet
1

But we can do better, and Tsonnet warns about the cyclic references, without erroring in this case because the code is semantically valid:

$ dune exec -- tsonnet samples/semantics/valid_conditional_field_access_cyclic.jsonnet
WARNING: samples/semantics/valid_conditional_field_access_cyclic.jsonnet:1:12 Cyclic reference found for 1->b

1: local obj = {
   ^^^^^^^^^^^^^
2:     a: 1,

3:     [if true then "b"]: self.c,
               ^^^^^^^^^^^^^^^^^^^
4:     c: self.b,
               ^^
---
WARNING: samples/semantics/valid_conditional_field_access_cyclic.jsonnet:1:12 Cyclic reference found for 1->c

1: local obj = {
   ^^^^^^^^^^^^^
2:     a: 1,

3:     [if true then "b"]: self.c,
               ^^^^^^^^^^^^^^^^^^^
4:     c: self.b,
               ^^
---
1

This is the kind of behavior that passes during development, but can be tightened to treat warnings as errors before pushing code to production. Eventually, I'll add a flag to the compiler to enforce that.

Here are the cram tests to capture all the content above:

diff --git a/test/cram/conditionals.t b/test/cram/conditionals.t
new file mode 100644
index 0000000..a12933d
--- /dev/null
+++ b/test/cram/conditionals.t
@@ -0,0 +1,20 @@
+  $ tsonnet ../../samples/conditionals/conditionals.jsonnet
+  {
+    "cond_else_expr": 15,
+    "cond_else_false": "else branch",
+    "cond_else_true": "then branch",
+    "cond_nested_chain": 42,
+    "cond_nested_object": { "result": "this one" },
+    "cond_null": null,
+    "cond_true": "if true works!",
+    "conditional_attribute_else": false,
+    "conditional_attribute_then": true
+  }
+
+
+  $ tsonnet ../../samples/conditionals/conditional_attr_not_string.jsonnet
+  ERROR: ../../samples/conditionals/conditional_attr_not_string.jsonnet:2:3 Conditional field key must be String or Null, got Number
+  
+  2:   [if true then 42]: "value"
+     ^^^^^^^^^^^^^^^^^^^^^
+  [1]
diff --git a/test/cram/semantics.t b/test/cram/semantics.t
index 14f5911..67bd204 100644
--- a/test/cram/semantics.t
+++ b/test/cram/semantics.t
@@ -332,3 +332,75 @@
      ^^^^^^^^^^^^^^^^^^^^^^^^^^
   [1]

+
+  $ tsonnet ../../samples/semantics/invalid_conditional_field_cyclic_value.jsonnet
+  WARNING: ../../samples/semantics/invalid_conditional_field_cyclic_value.jsonnet:1:0 Cyclic reference found for 1->b
+  
+  1: {
+     ^
+  2:     a: 1,
+     ^^^^^^^^^
+  3:     [if true then "b"]: self.c,
+     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  4:     c: self.b,
+     ^^^^^^^^^^^^^^
+  ---
+  WARNING: ../../samples/semantics/invalid_conditional_field_cyclic_value.jsonnet:1:0 Cyclic reference found for 1->c
+  
+  1: {
+     ^
+  2:     a: 1,
+     ^^^^^^^^^
+  3:     [if true then "b"]: self.c,
+     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  4:     c: self.b,
+     ^^^^^^^^^^^^^^
+  ---
+  ERROR: ../../samples/semantics/invalid_conditional_field_cyclic_value.jsonnet:3:29 Cyclic reference found for 1->c
+  
+  3:     [if true then "b"]: self.c,
+     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  [1]
+
+
+  $ tsonnet ../../samples/semantics/valid_conditional_field_access_cyclic.jsonnet
+  WARNING: ../../samples/semantics/valid_conditional_field_access_cyclic.jsonnet:1:12 Cyclic reference found for 1->b
+  
+  1: local obj = {
+     ^^^^^^^^^^^^^
+  2:     a: 1,
+                 
+  3:     [if true then "b"]: self.c,
+                 ^^^^^^^^^^^^^^^^^^^
+  4:     c: self.b,
+                 ^^
+  ---
+  WARNING: ../../samples/semantics/valid_conditional_field_access_cyclic.jsonnet:1:12 Cyclic reference found for 1->c
+  
+  1: local obj = {
+     ^^^^^^^^^^^^^
+  2:     a: 1,
+                 
+  3:     [if true then "b"]: self.c,
+                 ^^^^^^^^^^^^^^^^^^^
+  4:     c: self.b,
+                 ^^
+  ---
+  ERROR: ../../samples/semantics/valid_conditional_field_access_cyclic.jsonnet:4:7 Cyclic reference found for 1->b
+  
+  4:     c: self.b,
+     ^^^^^^^^^^^^^^
+  [1]
+
+
+  $ tsonnet ../../samples/semantics/invalid_conditional_field_cyclic_key.jsonnet
+  WARNING: ../../samples/semantics/invalid_conditional_field_cyclic_key.jsonnet:4:5 Cyclic reference found in conditional field key
+  
+  4:     [if true then self.a else "x"]: "value",
+     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  ---
+  ERROR: ../../samples/semantics/invalid_conditional_field_cyclic_key.jsonnet:3:7 Cyclic reference found for 1->a
+  
+  3:     b: self.a,
+     ^^^^^^^^^^^^^^
+  [1]
diff --git a/test/cram/tutorials.t b/test/cram/tutorials.t
index b3c1bc9..0ba664c 100644
--- a/test/cram/tutorials.t
+++ b/test/cram/tutorials.t
@@ -175,3 +175,22 @@
       "served": "Straight Up"
     }
   }
+
+  $ tsonnet ../../samples/tutorials/computed-fields.jsonnet
+  {
+    "Margarita": {
+      "garnish": "Salt",
+      "ingredients": [
+        { "kind": "Tequila Blanco", "qty": 2 },
+        { "kind": "Lime", "qty": 1 },
+        { "kind": "Cointreau", "qty": 1 }
+      ]
+    },
+    "Margarita Unsalted": {
+      "ingredients": [
+        { "kind": "Tequila Blanco", "qty": 2 },
+        { "kind": "Lime", "qty": 1 },
+        { "kind": "Cointreau", "qty": 1 }
+      ]
+    }
+  }

Conclusion

Computed field names done — and with them, the type checker took on most of the weight.

I'm still betting on letting self-references slide where Jsonnet won't, trading strictness for warnings I can promote to errors later. Future me gets to decide if that was wisdom or hubris.

The entire diff can be seen here.

Thanks for reading Bit Maybe Wise! Subscribe — and the condition for getting the next post is, conveniently, always true.

Photo by Jens Lelie on Unsplash

Tsonnet #42 - If then else (finally)

Hercules Lemke Merscher — Thu, 21 May 2026 09:39:04 +0000

Welcome to the Tsonnet series!

If you're not following along, check out how it all started in the first post of the series.

In the previous post, we fixed function calls with zero arguments:

Hercules Lemke Merscher

May 15

Tsonnet #41 - Call me maybe, but make it argless

#tsonnet #jsonnet #compiler

3 min read

Now conditionals are on the menu. Literally.

The target

This is the Jsonnet tutorial for conditionals:

// samples/tutorials/conditionals.jsonnet

local Mojito(virgin=false, large=false) = {
  // A local next to fields ends with ','.
  local factor = if large then 2 else 1,
  // The ingredients are split into 3 arrays,
  // the middle one is either length 1 or 0.
  ingredients: [
    {
      kind: 'Mint',
      action: 'muddle',
      qty: 6 * factor,
      unit: 'leaves',
    },
  ] + (
    if virgin then [] else [
      { kind: 'Banks', qty: 1.5 * factor },
    ]
  ) + [
    { kind: 'Lime', qty: 0.5 * factor },
    { kind: 'Simple Syrup', qty: 0.5 * factor },
    { kind: 'Soda', qty: 3 * factor },
  ],
  // Returns null if not large.
  garnish: if large then 'Lime wedge',
  served: 'Over crushed ice',
};

{
  Mojito: Mojito(),
  'Virgin Mojito': Mojito(virgin=true),
  'Large Mojito': Mojito(large=true),
}

We'll finish this post having this implemented.

A new variant

Let's add a new expr variant:

diff --git a/lib/ast.ml b/lib/ast.ml
index 1b5724b..35f88a6 100644
--- a/lib/ast.ml
+++ b/lib/ast.ml
@@ -93,6 +93,7 @@ type expr =
   | FunctionDef of position * function_def
   | FunctionCall of position * function_call
   | Closure of position * closure
+  | If of position * expr * expr * expr option

 and object_entry =
   | ObjectField of string * expr

The last field is an option because the else branch isn't always mandatory.

Three new keywords

Nothing complex here. Just some precedence rules to ensure the right evaluation order:

diff --git a/lib/lexer.mll b/lib/lexer.mll
index 4d65f55..3426d02 100644
--- a/lib/lexer.mll
+++ b/lib/lexer.mll
@@ -80,6 +80,9 @@ rule read =
   | "self" { SELF }
   | "$" { TOP_LEVEL_OBJ }
   | "in" { IN }
+  | "if" { IF }
+  | "then" { THEN }
+  | "else" { ELSE }
   | "function" { FUNCTION }
   | id { ID (Lexing.lexeme lexbuf) }
   | _ { raise (SyntaxError ("Unexpected char: " ^ Lexing.lexeme lexbuf)) }

diff --git a/lib/parser.mly b/lib/parser.mly
index 781ec5d..40858f4 100644
--- a/lib/parser.mly
+++ b/lib/parser.mly
@@ -21,6 +21,9 @@
 %token COLON
 %token DOT
 %token SELF TOP_LEVEL_OBJ
+%token IF THEN ELSE
+%nonassoc THEN
+%nonassoc ELSE
 %token PLUS MINUS MULTIPLY DIVIDE MODULO
 %nonassoc FUNCTION
 %left PLUS MINUS
@@ -61,6 +64,7 @@ assignable_expr:
   | op = unary_op; e = assignable_expr { UnaryOp (with_pos $startpos $endpos, op, e) }
   | e = indexed_expr { e }
   | e = obj_field_access { e }
+  | e = conditional { e }
   | e = funcall { e }
   | e = closure { e }
   ;
@@ -241,4 +245,17 @@ closure:
     }
     (* precedence here will transform "function(x) x * x" into "function(x) (x * x)" *)
     %prec FUNCTION
-  ;
+  ;
+
+conditional:
+  (* precedence here parses "if a then b + c" as "if a then (b + c)" *)
+  | IF; cond_expr = assignable_expr;
+    THEN; then_expr = assignable_expr;
+    ELSE; else_expr = assignable_expr
+    { If (with_pos $startpos $endpos, cond_expr, then_expr, Some else_expr) }
+    %prec ELSE
+  | IF; cond_expr = assignable_expr;
+    THEN; then_expr = assignable_expr
+    { If (with_pos $startpos $endpos, cond_expr, then_expr, None) }
+    %prec THEN
+  ;

Branch discipline

diff --git a/lib/type.ml b/lib/type.ml
index c537187..88e5b3a 100644
--- a/lib/type.ml
+++ b/lib/type.ml
@@ -211,6 +211,8 @@ let rec translate venv expr =
   | FunctionDef (pos, def) -> translate_function_def venv (pos, def)
   | FunctionCall (pos, call) -> translate_function_call venv (pos, call)
   | Closure (pos, closure) -> translate_closure venv (pos, closure)
+  | If (pos, cond_expr, then_expr, else_expr_opt) ->
+      translate_conditional venv (pos, cond_expr, then_expr, else_expr_opt)
   | expr' ->
     error (Error.Msg.type_invalid_expr (string_of_type expr'))

@@ -704,6 +706,30 @@ and translate_closure_call venv (pos, def_params, body, call_args) =
     let* (_, body_type) = translate body_venv body in
     ok (venv, body_type)

translate_conditional type checks the condition and both branches:

and translate_conditional venv (pos, cond_expr, then_expr, else_expr_opt) =
  let* (_, cond_ty) = translate venv cond_expr in
  match cond_ty with
  | Tbool ->
    let* (_, then_type) = translate venv then_expr in
    (match else_expr_opt with
    | Some else_expr ->
      let* (_, else_type) = translate venv else_expr in
      if then_type = else_type
      then ok (venv, then_type)
      else Error.error_at pos
        (Error.Msg.type_conditional_branches_mismatch
          ~then_type:(to_string then_type)
          ~else_type:(to_string else_type)
        )
    | None ->
      ok (venv, then_type)
    )
  | _ -> Error.error_at pos
    (Error.Msg.type_mismatch
      ~expected:(string_of_type (Bool (pos, true)))
      ~got:(string_of_type cond_expr)
    )

When the else branch is absent, the then branch is the return type of the entire expression. When both are present, they must match — otherwise we raise a type mismatch error.

This is a deliberate design choice. TypeScript would return a union type like string | number, which is flexible and plays well with dynamic languages, but it adds complexity. Most statically typed languages require both branches to be the same type when returning an expression — setting aside languages that treat conditional branches as statements, those are a different story.

And the new error message:

diff --git a/lib/error.ml b/lib/error.ml
index cefc8d1..b1ae567 100644
--- a/lib/error.ml
+++ b/lib/error.ml
@@ -30,6 +30,10 @@ module Msg = struct
   let type_invalid_lookup_key expr = "Invalid object lookup key: " ^ expr
   let type_mismatch ~expected ~got =
     Printf.sprintf "Expected type %s, got %s" expected got
+  let type_conditional_branches_mismatch ~then_type ~else_type =
+    Printf.sprintf
+      "Conditional branches have different types: then branch returns %s, else branch returns %s"
+      then_type else_type

   (* Interpreter messages *)
   let interp_division_by_zero = "Division by zero"
diff --git a/lib/error.mli b/lib/error.mli
index b3e7da6..28cd496 100644
--- a/lib/error.mli
+++ b/lib/error.mli
@@ -26,6 +26,7 @@ module Msg : sig
   val type_non_indexable_field : string -> string
   val type_invalid_lookup_key : string -> string
   val type_mismatch : expected:string -> got:string -> string
+  val type_conditional_branches_mismatch : then_type:string -> else_type:string -> string

   (* Interpreter messages *)
   val interp_division_by_zero : string

The boring part (by design)

The interpreter is the boring part. It just picks one branch or the other:

diff --git a/lib/interpreter.ml b/lib/interpreter.ml
index 37e367e..235b90e 100644
--- a/lib/interpreter.ml
+++ b/lib/interpreter.ml
@@ -29,6 +29,8 @@ let rec interpret env expr =
   | FunctionDef (pos, def) -> interpret_function_def env (pos, def)
   | FunctionCall (pos, call) -> interpret_function_call env (pos, call)
   | Closure _ -> ok (env, expr)
+  | If (pos, cond_expr, then_expr, else_expr_opt) ->
+      interpret_conditional env (pos, cond_expr, then_expr, else_expr_opt)

 and interpret_indexed_expr env (pos, varname, index_expr) =
   let* (env', index_expr') = interpret env index_expr in

and interpret_conditional env (pos, cond_expr, then_expr, else_expr_opt) =
  let* (_, cond) = interpret env cond_expr in
  match cond with
  | Bool (_, true) ->
    interpret env then_expr
  | Bool (_, false) ->
    (match else_expr_opt with
    | Some else_expr -> interpret env else_expr
    | None -> ok (env, Null pos)
    )
  | _ ->
    (* Unreachable: type checker ensures cond_expr is Bool *)
    Error.error_at pos "interpret_conditional: non-boolean condition (type checker should prevent this)"

The unreachable branch at the end is starting to bother me. The type checker already guarantees the condition is a Bool, so that match arm will never fire. I keep thinking about using phantom types to encode this statically and let the compiler enforce it, instead of leaving a comment that future me will pretend not to see. Something to revisit.

Tests

And it works:

$ dune exec -- tsonnet samples/tutorials/conditionals.jsonnet
{
  "Large Mojito": {
    "garnish": "Lime wedge",
    "ingredients": [
      { "action": "muddle", "kind": "Mint", "qty": 12, "unit": "leaves" },
      { "kind": "Banks", "qty": 3.0 },
      { "kind": "Lime", "qty": 1.0 },
      { "kind": "Simple Syrup", "qty": 1.0 },
      { "kind": "Soda", "qty": 6 }
    ],
    "served": "Over crushed ice"
  },
  "Mojito": {
    "garnish": null,
    "ingredients": [
      { "action": "muddle", "kind": "Mint", "qty": 6, "unit": "leaves" },
      { "kind": "Banks", "qty": 1.5 },
      { "kind": "Lime", "qty": 0.5 },
      { "kind": "Simple Syrup", "qty": 0.5 },
      { "kind": "Soda", "qty": 3 }
    ],
    "served": "Over crushed ice"
  },
  "Virgin Mojito": {
    "garnish": null,
    "ingredients": [
      { "action": "muddle", "kind": "Mint", "qty": 6, "unit": "leaves" },
      { "kind": "Lime", "qty": 0.5 },
      { "kind": "Simple Syrup", "qty": 0.5 },
      { "kind": "Soda", "qty": 3 }
    ],
    "served": "Over crushed ice"
  }
}

The cram tests will keep it honest:

diff --git a/samples/conditionals/conditionals.jsonnet b/samples/conditionals/conditionals.jsonnet
new file mode 100644
index 0000000..6b39918
--- /dev/null
+++ b/samples/conditionals/conditionals.jsonnet
@@ -0,0 +1,17 @@
+{
+    'cond_true': if true then 'if true works!',
+    'cond_null': if false then 'unreachable!',
+    'cond_else_true': if true then 'then branch' else 'else branch',
+    'cond_else_false': if false then 'then branch' else 'else branch',
+    'cond_else_expr': if true then 10 + 5 else 20 + 5,
+    'cond_nested_object': {
+        result: if false then 'not this' else 'this one'
+    },
+    'cond_nested_chain':
+        if true then
+            if false then 0
+            else
+                if true then 42
+                else 1
+        else 2
+}
diff --git a/samples/semantics/invalid_conditional_branches_type.jsonnet b/samples/semantics/invalid_conditional_branches_type.jsonnet
new file mode 100644
index 0000000..1ea1aef
--- /dev/null
+++ b/samples/semantics/invalid_conditional_branches_type.jsonnet
@@ -0,0 +1 @@
+if true then 1 else "oops"

diff --git a/test/cram/semantics.t b/test/cram/semantics.t
index 3f26924..14f5911 100644
--- a/test/cram/semantics.t
+++ b/test/cram/semantics.t
@@ -324,3 +324,11 @@
      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   [1]

+
+  $ tsonnet ../../samples/semantics/invalid_conditional_branches_type.jsonnet
+  ERROR: ../../samples/semantics/invalid_conditional_branches_type.jsonnet:1:0 Conditional branches have different types: then branch returns Number, else branch returns String
+  
+  1: if true then 1 else "oops"
+     ^^^^^^^^^^^^^^^^^^^^^^^^^^
+  [1]
+
diff --git a/test/cram/tutorials.t b/test/cram/tutorials.t
index 9990a7e..b3c1bc9 100644
--- a/test/cram/tutorials.t
+++ b/test/cram/tutorials.t
@@ -92,6 +92,42 @@
     }
   }
+  $ tsonnet ../../samples/tutorials/conditionals.jsonnet
+  {
+    "Large Mojito": {
+      "garnish": "Lime wedge",
+      "ingredients": [
+        { "action": "muddle", "kind": "Mint", "qty": 12, "unit": "leaves" },
+        { "kind": "Banks", "qty": 3.0 },
+        { "kind": "Lime", "qty": 1.0 },
+        { "kind": "Simple Syrup", "qty": 1.0 },
+        { "kind": "Soda", "qty": 6 }
+      ],
+      "served": "Over crushed ice"
+    },
+    "Mojito": {
+      "garnish": null,
+      "ingredients": [
+        { "action": "muddle", "kind": "Mint", "qty": 6, "unit": "leaves" },
+        { "kind": "Banks", "qty": 1.5 },
+        { "kind": "Lime", "qty": 0.5 },
+        { "kind": "Simple Syrup", "qty": 0.5 },
+        { "kind": "Soda", "qty": 3 }
+      ],
+      "served": "Over crushed ice"
+    },
+    "Virgin Mojito": {
+      "garnish": null,
+      "ingredients": [
+        { "action": "muddle", "kind": "Mint", "qty": 6, "unit": "leaves" },
+        { "kind": "Lime", "qty": 0.5 },
+        { "kind": "Simple Syrup", "qty": 0.5 },
+        { "kind": "Soda", "qty": 3 }
+      ],
+      "served": "Over crushed ice"
+    }
+  }
+
   $ tsonnet ../../samples/tutorials/arith.jsonnet
   {
     "concat_array": [ 1, 2, 3, 4 ],

Conclusion

Conditionals are in. Not a lot of ceremony for something this fundamental — which is usually the sign of a clean design paying off.

Next up: probably, for loops and comprehensions.

The entire diff is available here.

Thanks for reading Bit Maybe Wise! If conditionals finally work in Tsonnet, maybe you should conditionally subscribe — but make the condition true.

Photo by Marco Kaufmann on Unsplash

Tsonnet #41 - Call me maybe, but make it argless

Hercules Lemke Merscher — Fri, 15 May 2026 09:20:51 +0000

Welcome to the Tsonnet series!

If you're not following along, check out how it all started in the first post of the series.

In the previous post, we wrapped up function support with named parameters at call sites:

Hercules Lemke Merscher

Apr 23

Tsonnet #40 - Call me maybe, but make it typed, part 6

#tsonnet #jsonnet #compiler

8 min read

Oops, I forgot function calls without arguments.

Classic. I left them home alone.

What must be validated

Here's what we need to handle:

local greet() = 'hello';
local make_obj() = { x: 1, y: 2 };
local apply(f) = f();
local obj = { m(): 7 };

{
  greet: greet(),
  obj: make_obj(),
  inline: (function() 42)(),
  applied: apply(function() 'world'),
  method_call: obj.m(),
}

Parsing

The fix is very straightforward. The only change required is substituting separated_nonempty_list by separated_list:

diff --git a/lib/parser.mly b/lib/parser.mly
index 94f1a2f..781ec5d 100644
--- a/lib/parser.mly
+++ b/lib/parser.mly
@@ -102,7 +102,7 @@ obj_key:
 obj_field:
   | k = obj_key; COLON; e = assignable_expr { ObjectField (k, e) }
   | k = obj_key;
-    LEFT_PAREN; params = separated_nonempty_list(COMMA, fundef_param); RIGHT_PAREN;
+    LEFT_PAREN; params = separated_list(COMMA, fundef_param); RIGHT_PAREN;
     COLON; body = assignable_expr
     { ObjectField (
         k,
@@ -201,7 +201,7 @@ fundef_param:

 fundef:
   | fname = ID;
-    LEFT_PAREN; params = separated_nonempty_list(COMMA, fundef_param); RIGHT_PAREN;
+    LEFT_PAREN; params = separated_list(COMMA, fundef_param); RIGHT_PAREN;
     ASSIGN;
     body = fundef_body { { name = fname; params = params; body = body } }
   ;
@@ -218,7 +218,7 @@ funcall_arg:

 funcall:
   | fname = ID;
-    LEFT_PAREN; params = separated_nonempty_list(COMMA, funcall_arg); RIGHT_PAREN
+    LEFT_PAREN; params = separated_list(COMMA, funcall_arg); RIGHT_PAREN
     { FunctionCall
       (with_pos $startpos $endpos, {
         callee = Ident (with_pos $startpos(fname) $endpos(fname), fname);
@@ -226,16 +226,16 @@ funcall:
       })
     }
   | callee = scoped_expr;
-    LEFT_PAREN; params = separated_nonempty_list(COMMA, funcall_arg); RIGHT_PAREN
+    LEFT_PAREN; params = separated_list(COMMA, funcall_arg); RIGHT_PAREN
     { FunctionCall (with_pos $startpos $endpos, { callee = callee; args = params }) }
   | callee = obj_field_access;
-    LEFT_PAREN; params = separated_nonempty_list(COMMA, funcall_arg); RIGHT_PAREN
+    LEFT_PAREN; params = separated_list(COMMA, funcall_arg); RIGHT_PAREN
     { FunctionCall (with_pos $startpos $endpos, { callee = callee; args = params }) }
   ;

 closure:
   | FUNCTION;
-    LEFT_PAREN; params = separated_nonempty_list(COMMA, fundef_param); RIGHT_PAREN;
+    LEFT_PAREN; params = separated_list(COMMA, fundef_param); RIGHT_PAREN;
     body = assignable_expr {
       Closure (with_pos $startpos $endpos, { params = params; body = body })
     }

Every place we parse parameter or argument lists gets the same treatment: function definitions, object method definitions, function calls, and closures. Swap nonempty out, and zero-argument calls stop crashing the parser.

How could I forget this one? XD

Testing

A new sample and a cram test entry:

diff --git a/test/cram/functions.t b/test/cram/functions.t
index 89cfd27..44f7d44 100644
--- a/test/cram/functions.t
+++ b/test/cram/functions.t
@@ -15,3 +15,12 @@

   $ tsonnet ../../samples/functions/method.jsonnet
   4
+
+  $ tsonnet ../../samples/functions/no_args.jsonnet
+  {
+    "applied": "world",
+    "greet": "hello",
+    "inline": 42,
+    "method_call": 7,
+    "obj": { "x": 1, "y": 2 }
+  }

Zero arguments, zero drama.

Conclusion

Short one, but a necessary one. No-argument function calls were quietly broken, and the fix turned out to be a one-word change per grammar rule. Easy to overlook, easy to fix once you notice.

Next up: conditionals. The Jsonnet tutorial can't wait forever.

The entire diff can be seen here.

Thanks for reading Bit Maybe Wise! Left no-arg calls home alone. Subscribe so you don't miss when conditionals finally move in.

Photo from https://www.businessinsider.com/photos-show-inside-real-life-home-alone-house-chicago-illinois-2020-12

Tsonnet #40 - Call me maybe, but make it typed, part 6

Hercules Lemke Merscher — Thu, 23 Apr 2026 07:00:00 +0000

Welcome to the Tsonnet series!

If you're not following along, check out how it all started in the first post of the series.

In the previous post, we implemented methods:

Hercules Lemke Merscher

Apr 22

Tsonnet #39 - Call me maybe, but make it typed, part 5

#tsonnet #jsonnet #compiler

3 min read

After all this work implementing functions and methods, there's still one thing missing: function calls with named parameters. I implemented the definition, but not the call site when named parameters are present.

This is what I want to test

// samples/functions/named_params.jsonnet
local my_function(x, y=10) = x + y;
my_function(2, y=3)

A new argument in the room

This calls for a new type variant: call_arg.

diff --git a/lib/ast.ml b/lib/ast.ml
index 4b1102e..1b5724b 100644
--- a/lib/ast.ml
+++ b/lib/ast.ml
@@ -107,9 +107,12 @@ and function_def = {
   params: (string * expr option) list;
   body: expr;
 }
+and call_arg =
+  | Positional of expr
+  | Named of string * expr
 and function_call = {
   callee: expr;
-  args: expr list;
+  args: call_arg list;
 }
 and closure = {
   params: (string * expr option) list;

This way we can leverage the expressiveness of the OCaml type system to enforce a Positional or Named argument.

The parser needs a little tweaking:

diff --git a/lib/parser.mly b/lib/parser.mly
index 0c5601d..94f1a2f 100644
--- a/lib/parser.mly
+++ b/lib/parser.mly
@@ -211,9 +211,14 @@ fundef_body:
   | local_bindings = vars; SEMICOLON; body = fundef_body { Seq [local_bindings; body] }
   ;

+funcall_arg:
+  | name = ID; ASSIGN; e = assignable_expr { Named (name, e) }
+  | e = assignable_expr { Positional e }
+  ;
+
 funcall:
   | fname = ID;
-    LEFT_PAREN; params = separated_nonempty_list(COMMA, assignable_expr); RIGHT_PAREN
+    LEFT_PAREN; params = separated_nonempty_list(COMMA, funcall_arg); RIGHT_PAREN
     { FunctionCall
       (with_pos $startpos $endpos, {
         callee = Ident (with_pos $startpos(fname) $endpos(fname), fname);
@@ -221,10 +226,10 @@ funcall:
       })
     }
   | callee = scoped_expr;
-    LEFT_PAREN; params = separated_nonempty_list(COMMA, assignable_expr); RIGHT_PAREN
+    LEFT_PAREN; params = separated_nonempty_list(COMMA, funcall_arg); RIGHT_PAREN
     { FunctionCall (with_pos $startpos $endpos, { callee = callee; args = params }) }
   | callee = obj_field_access;
-    LEFT_PAREN; params = separated_nonempty_list(COMMA, assignable_expr); RIGHT_PAREN
+    LEFT_PAREN; params = separated_nonempty_list(COMMA, funcall_arg); RIGHT_PAREN
     { FunctionCall (with_pos $startpos $endpos, { callee = callee; args = params }) }
   ;

Teaching the typechecker to count on its fingers

With the addition of named parameters to function calls, they need to be translated by the type checker:

diff --git a/lib/type.ml b/lib/type.ml
index 4b438db..c537187 100644
--- a/lib/type.ml
+++ b/lib/type.ml
@@ -111,7 +111,10 @@ let rec collect_free_idents = function
   | IndexedExpr (_, name, e) -> name :: collect_free_idents e
   | Local (_, vars) -> List.concat_map (fun (_, e) -> collect_free_idents e) vars
   | FunctionCall (_, call) ->
-    collect_free_idents call.callee @ List.concat_map collect_free_idents call.args
+    collect_free_idents call.callee @ List.concat_map (function
+      | Positional e -> collect_free_idents e
+      | Named (_, e) -> collect_free_idents e
+    ) call.args
   | Closure (_, closure) -> collect_free_idents closure.body
   | _ -> []

@@ -551,27 +554,38 @@ and translate_function_call venv (pos, call) =
     )

 and translate_named_function_call venv (pos, name, args) =
+  let positional_args =
+    List.filter_map (function Positional e -> Some e | Named _ -> None) args
+  in
+  let named_args =
+    List.filter_map (function Named (n, e) -> Some (n, e) | Positional _ -> None) args
+  in
+  let num_positional = List.length positional_args in
   match Env.find_opt name venv with
   | Some (TfunctionDef { params = def_params;
-                         body = body_expr;
-                         return = return_type;
-                       }) ->
-    let num_call = List.length args in
+                          body = body_expr;
+                          return = return_type;
+                        }) ->
     let num_def = List.length def_params in
-    if num_call > num_def
+    let num_provided = num_positional + List.length named_args in
+    if num_provided > num_def
     then
       Error.error_at pos
-        (Error.Msg.wrong_number_of_params num_def num_call)
+        (Error.Msg.wrong_number_of_params num_def num_provided)
     else
       let* (venv', resolved_params) =
         List.fold_left
           (fun acc (index, (param_name, def_param_type)) ->
             let* (venv', params') = acc in
-            if index < num_call
-            then
-              let call_param = List.nth args index in
+            let call_expr_opt =
+              if index < num_positional
+              then Some (List.nth positional_args index)
+              else Option.map snd (List.find_opt (fun (n, _) -> n = param_name) named_args)
+            in
+            match call_expr_opt with
+            | Some call_param ->
               let* (venv'', call_param_type) = translate venv' call_param in
-              match def_param_type with
+              (match def_param_type with
               | Tunresolved ->
                 ok (venv'', params' @ [(param_name, call_param_type)])
               | expected ->
@@ -581,7 +595,8 @@ and translate_named_function_call venv (pos, name, args) =
                   (Error.Msg.type_mismatch
                     ~expected:(to_string expected)
                     ~got:(to_string call_param_type))
-            else
+              )
+            | None ->
               ok (venv', params' @ [(param_name, def_param_type)])
           )
           (ok (venv, []))
@@ -640,30 +655,43 @@ and translate_closure venv (_pos, closure) =
   in
   ok (venv, Tclosure { params = params_typed; body = closure.body })

-and translate_closure_call venv (pos, def_params, body, call_params) =
-  let num_call = List.length call_params in
+and translate_closure_call venv (pos, def_params, body, call_args) =
+  let positional_args =
+    List.filter_map (function Positional e -> Some e | Named _ -> None) call_args
+  in
+  let named_args =
+    List.filter_map (function Named (n, e) -> Some (n, e) | Positional _ -> None) call_args
+  in
+  let num_positional = List.length positional_args in
   let num_def = List.length def_params in
   let num_required =
     List.length (List.filter (fun (_, default) -> Option.is_none default) def_params)
   in
-  if num_call < num_required || num_call > num_def
-  then Error.error_at pos (Error.Msg.wrong_number_of_params num_def num_call)
+  let num_provided = num_positional + List.length named_args in
+  if num_provided < num_required || num_provided > num_def
+  then Error.error_at pos (Error.Msg.wrong_number_of_params num_def num_provided)
   else
     let* (venv', resolved_params) =
       List.fold_left
         (fun acc (index, (param_name, default)) ->
           let* (venv', params') = acc in
-          if index < num_call
-          then
-            let call_param = List.nth call_params index in
+          let call_expr_opt =
+            if index < num_positional
+            then Some (List.nth positional_args index)
+            else Option.map snd (List.find_opt (fun (n, _) -> n = param_name) named_args)
+          in
+          match call_expr_opt with
+          | Some call_param ->
             let* (venv'', call_param_type) = translate venv' call_param in
             ok (venv'', params' @ [(param_name, call_param_type)])
-          else
-            match default with
+          | None ->
+            (match default with
             | Some default_expr ->
               let* (venv'', default_type) = translate venv' default_expr in
               ok (venv'', params' @ [(param_name, default_type)])
-            | None -> Error.error_at pos (Error.Msg.wrong_number_of_params num_def num_call)
+            | None ->
+              Error.error_at pos (Error.Msg.wrong_number_of_params num_def num_provided)
+            )
         )
         (ok (venv, []))
         (List.mapi (fun i p -> (i, p)) def_params)

I feel like translate_named_function_call and translate_closure_call could be unified, similar to what I did with apply_function in the interpreter. They differ in subtle ways though, so I'll leave that for another day.

The interpreter changes are only following the new type variant addition:

diff --git a/lib/interpreter.ml b/lib/interpreter.ml
index 15f9932..37e367e 100644
--- a/lib/interpreter.ml
+++ b/lib/interpreter.ml
@@ -420,19 +420,26 @@ and interpret_function_def env (pos, def) =
   let env' = Env.add_local def.name (FunctionDef (pos, def)) env in
   ok (env', Unit)

-and apply_function env pos def_params body call_params =
-  let num_call = List.length call_params in
+and apply_function env pos def_params body call_args =
+  let positional_args =
+    List.filter_map (function Positional e -> Some e | Named _ -> None) call_args
+  in
+  let named_args =
+    List.filter_map (function Named (n, e) -> Some (n, e) | Positional _ -> None) call_args
+  in
+  let num_positional = List.length positional_args in
   let num_def = List.length def_params in
   let num_required =
     List.length (
       List.filter (fun (_, default) -> Option.is_none default) def_params
     )
   in
-  if num_call < num_required || num_call > num_def
+  let num_provided = num_positional + List.length named_args in
+  if num_provided < num_required || num_provided > num_def
   then
-    Error.error_at pos (Error.Msg.wrong_number_of_params num_def num_call)
+    Error.error_at pos (Error.Msg.wrong_number_of_params num_def num_provided)
   else
-    let* evaluated_call_params =
+    let* evaluated_positional =
       List.fold_left
         (fun acc param ->
           let* params = acc in
@@ -440,19 +447,32 @@ and apply_function env pos def_params body call_params =
           ok (params @ [v])
         )
         (ok [])
-        call_params
+        positional_args
+    in
+    let* evaluated_named =
+      List.fold_left
+        (fun acc (name, expr) ->
+          let* params = acc in
+          let* (_, v) = interpret env expr in
+          ok (params @ [(name, v)])
+        )
+        (ok [])
+        named_args
     in
     let* bindings =
       List.fold_left
         (fun acc (index, (param_name, default)) ->
           let* bindings = acc in
-          if index < num_call
+          if index < num_positional
           then
-            ok (bindings @ [(param_name, List.nth evaluated_call_params index)])
+            ok (bindings @ [(param_name, List.nth evaluated_positional index)])
           else
-            match default with
-            | Some default_expr -> ok (bindings @ [(param_name, default_expr)])
-            | None -> Error.error_at pos (Error.Msg.wrong_number_of_params num_def num_call)
+            match List.assoc_opt param_name evaluated_named with
+            | Some v -> ok (bindings @ [(param_name, v)])
+            | None ->
+              match default with
+              | Some default_expr -> ok (bindings @ [(param_name, default_expr)])
+              | None -> Error.error_at pos (Error.Msg.wrong_number_of_params num_def num_provided)
         )
         (ok [])
         (List.mapi (fun i p -> (i, p)) def_params)

Does it actually work? (Yes.)

diff --git a/samples/functions/named_params.jsonnet b/samples/functions/named_params.jsonnet
new file mode 100644
index 0000000..76406b1
--- /dev/null
+++ b/samples/functions/named_params.jsonnet
@@ -0,0 +1,2 @@
+local my_function(x, y=10) = x + y;
+my_function(2, y=3)
diff --git a/test/cram/functions.t b/test/cram/functions.t
index 9a9fe4d..89cfd27 100644
--- a/test/cram/functions.t
+++ b/test/cram/functions.t
@@ -10,5 +10,8 @@
   $ tsonnet ../../samples/functions/closure.jsonnet
   25

+  $ tsonnet ../../samples/functions/named_params.jsonnet
+  5
+
   $ tsonnet ../../samples/functions/method.jsonnet
   4

Putting it all together (with cocktails)

With that I can put a closure (pun intended) to the function tutorial.

// samples/tutorials/functions.jsonnet

// Define a local function.
// Default arguments are like Python:
local my_function(x, y=10) = x + y;

// Define a local multiline function.
local multiline_function(x) =
  // One can nest locals.
  local temp = x * 2;
  // Every local ends with a semi-colon.
  [temp, temp + 1];

local object = {
  // A method
  my_method(x): x * x,
};

{
  // Functions are first class citizens.
  call_inline_function:
    (function(x) x * x)(5),

  call_multiline_function: multiline_function(4),

  // Using the variable fetches the function,
  // the parens call the function.
  call: my_function(2),

  // Like Python, parameters can be named at
  // call time.
  named_params: my_function(x=2),
  // This allows changing their order
  named_params2: my_function(y=3, x=2),

  // object.my_method returns the function,
  // which is then called like any other.
  call_method1: object.my_method(3),

  // TODO
  // standard_lib:
  //   std.join(' ', std.split('foo/bar', '/')),
  // len: [
  //   std.length('hello'),
  //   std.length([1, 2, 3]),
  // ],
}

The standard library has to wait. We must implement other building blocks, such as conditionals, for loops, etc — the usual stuff we can't live without in a programming language.

// samples/tutorials/sours.jsonnet

// This function returns an object. Although
// the braces look like Java or C++ they do
// not mean a statement block, they are instead
// the value being returned.
local Sour(spirit, garnish='Lemon twist') = {
  ingredients: [
    { kind: spirit, qty: 2 },
    { kind: 'Egg white', qty: 1 },
    { kind: 'Lemon Juice', qty: 1 },
    { kind: 'Simple Syrup', qty: 1 },
  ],
  garnish: garnish,
  served: 'Straight Up',
};

{
  'Whiskey Sour': Sour('Bulleit Bourbon',
                       'Orange bitters'),
  'Pisco Sour': Sour('Machu Pisco',
                     'Angostura bitters'),
}

Have you tried Pisco Sour already? If you're into alcoholic drinks, give it a try. It has a tasty flavour.

Ta-da! Cram tests in place:

diff --git a/test/cram/tutorials.t b/test/cram/tutorials.t
index f3780c1..9990a7e 100644
--- a/test/cram/tutorials.t
+++ b/test/cram/tutorials.t
@@ -105,3 +105,37 @@
     "obj": { "a": 1, "b": 3, "c": 4 },
     "obj_member": true
   }
+
+  $ tsonnet ../../samples/tutorials/functions.jsonnet
+  {
+    "call": 12,
+    "call_inline_function": 25,
+    "call_method1": 9,
+    "call_multiline_function": [ 8, 9 ],
+    "named_params": 12,
+    "named_params2": 5
+  }
+
+  $ tsonnet ../../samples/tutorials/sours.jsonnet
+  {
+    "Pisco Sour": {
+      "garnish": "Angostura bitters",
+      "ingredients": [
+        { "kind": "Machu Pisco", "qty": 2 },
+        { "kind": "Egg white", "qty": 1 },
+        { "kind": "Lemon Juice", "qty": 1 },
+        { "kind": "Simple Syrup", "qty": 1 }
+      ],
+      "served": "Straight Up"
+    },
+    "Whiskey Sour": {
+      "garnish": "Orange bitters",
+      "ingredients": [
+        { "kind": "Bulleit Bourbon", "qty": 2 },
+        { "kind": "Egg white", "qty": 1 },
+        { "kind": "Lemon Juice", "qty": 1 },
+        { "kind": "Simple Syrup", "qty": 1 }
+      ],
+      "served": "Straight Up"
+    }
+  }

Conclusion

And that's a wrap on Tsonnet's function support (for now). Named parameters, default values, closures, methods — it's all there. The type checker knows how to count positional arguments, match them against names, and fill in defaults. Not bad for a type system that started life unable to tell a function from a hole in the ground.

This closes the chapter on functions in the Jsonnet tutorial too. We went from bare locals all the way to my_function(y=3, x=2) working correctly, with a Pisco Sour to show for it.

Here is the entire diff.

Thanks for reading Bit Maybe Wise! That's a closure on functions. Subscribe so you don't miss what comes next — conditionals, loops, and poor life choices.

Photo by Mike Meyers on Unsplash

Tsonnet #39 - Call me maybe, but make it typed, part 5

Hercules Lemke Merscher — Wed, 22 Apr 2026 07:00:00 +0000

Welcome to the Tsonnet series!

If you're not following along, check out how it all started in the first post of the series.

In the previous post, we refactored the AST to use named records, collapsed ClosureCall into FunctionCall, and cleaned up the grammar conflict that was keeping closures as second-class citizens:

Hercules Lemke Merscher

Apr 21

Tsonnet #38 - Call me maybe, but make it typed, part 4

#tsonnet #jsonnet #compiler

9 min read

Now that we support functions, just one more thing is missing on that front: methods!

The plan (such as it is)

// samples/functions/method.jsonnet
local object = {
  my_method(x): x * x,
};
object.my_method(2)

Sneaking methods past the grammar

After implementing functions and pausing for a moment to reflect on how I'd implement methods, I realised that methods can be easily represented as closures that bind to an object field. So I did it:

diff --git a/lib/parser.mly b/lib/parser.mly
index e7b7771..0c5601d 100644
--- a/lib/parser.mly
+++ b/lib/parser.mly
@@ -101,6 +101,14 @@ obj_key:

 obj_field:
   | k = obj_key; COLON; e = assignable_expr { ObjectField (k, e) }
+  | k = obj_key;
+    LEFT_PAREN; params = separated_nonempty_list(COMMA, fundef_param); RIGHT_PAREN;
+    COLON; body = assignable_expr
+    { ObjectField (
+        k,
+        Closure (with_pos $startpos $endpos, { params = params; body = body })
+      )
+    }
   | e = single_var { ObjectExpr e }
   ;

@@ -215,6 +223,9 @@ funcall:
   | callee = scoped_expr;
     LEFT_PAREN; params = separated_nonempty_list(COMMA, assignable_expr); RIGHT_PAREN
     { FunctionCall (with_pos $startpos $endpos, { callee = callee; args = params }) }
+  | callee = obj_field_access;
+    LEFT_PAREN; params = separated_nonempty_list(COMMA, assignable_expr); RIGHT_PAREN
+    { FunctionCall (with_pos $startpos $endpos, { callee = callee; args = params }) }
   ;

 closure:

This approach avoids adding one more abstraction, and maps precisely onto the semantics.

Turns out, scope bugs don't fix themselves

diff --git a/lib/type.ml b/lib/type.ml
index ad4f333..4b438db 100644
--- a/lib/type.ml
+++ b/lib/type.ml
@@ -102,7 +102,12 @@ let rec collect_free_idents = function
       | ObjectField (_, e) -> collect_free_idents e
       | ObjectExpr e -> collect_free_idents e
     ) entries
-  | ObjectFieldAccess (_, _, exprs) -> List.concat_map collect_free_idents exprs
+  | ObjectFieldAccess (_, scope, exprs) ->
+    let scope_idents = match scope with
+      | ObjVarRef name -> [name]
+      | Self | TopLevel -> []
+    in
+    scope_idents @ List.concat_map collect_free_idents exprs
   | IndexedExpr (_, name, e) -> name :: collect_free_idents e
   | Local (_, vars) -> List.concat_map (fun (_, e) -> collect_free_idents e) vars
   | FunctionCall (_, call) ->

Cram tests corrected:

diff --git a/test/cram/objects.t b/test/cram/objects.t
index 1a402df..11cc9d1 100644
--- a/test/cram/objects.t
+++ b/test/cram/objects.t
@@ -23,32 +23,10 @@
   { "a": 1, "b": 3, "c": 4 }

   $ tsonnet ../../samples/objects/untouched_field.jsonnet
-  WARNING: ../../samples/objects/untouched_field.jsonnet:1:0 Unused variable result
-  
-  1: local result = {
-     ^^^^^^^^^^^^^^^^
-  2:     a: 1,
-     ^^^^^^^^^
-  3:     b: 42,
-     ^^^^^^^^^^
-  ---
   42


   $ tsonnet ../../samples/objects/untouched_invalid_field.jsonnet
-  WARNING: ../../samples/objects/untouched_invalid_field.jsonnet:1:0 Unused variable result
-  
-  1: local result = {
-     ^^^^^^^^^^^^^^^^
-  2:     a: 1,
-     ^^^^^^^^^
-  3:     b: self.a,
-     ^^^^^^^^^^^^^^
-  4:     c: self.d,
-     ^^^^^^^^^^^^^^
-  5:     d: self.c
-     ^^^^^^^^^^^^^
-  ---
   WARNING: ../../samples/objects/untouched_invalid_field.jsonnet:1:15 Cyclic reference found for 1->c

   1: local result = {
diff --git a/test/cram/semantics.t b/test/cram/semantics.t
index c9a790e..3f26924 100644
--- a/test/cram/semantics.t
+++ b/test/cram/semantics.t
@@ -288,17 +288,6 @@


   $ tsonnet ../../samples/semantics/valid_object_access_non_cyclic_field.jsonnet
-  WARNING: ../../samples/semantics/valid_object_access_non_cyclic_field.jsonnet:1:0 Unused variable obj
-  
-  1: local obj = {
-     ^^^^^^^^^^^^^
-  2:     a: 1,
-     ^^^^^^^^^
-  3:     b: self.c,
-     ^^^^^^^^^^^^^^
-  4:     c: self.b,
-     ^^^^^^^^^^^^^^
-  ---
   WARNING: ../../samples/semantics/valid_object_access_non_cyclic_field.jsonnet:1:12 Cyclic reference found for 1->b

   1: local obj = {

Does it work?

Yes, it does:

$ dune exec -- tsonnet samples/functions/method.jsonnet
4

diff --git a/test/cram/functions.t b/test/cram/functions.t
index 5c77837..9a9fe4d 100644
--- a/test/cram/functions.t
+++ b/test/cram/functions.t
@@ -9,3 +9,6 @@

   $ tsonnet ../../samples/functions/closure.jsonnet
   25
+
+  $ tsonnet ../../samples/functions/method.jsonnet
+  4

Conclusion

Methods turned out to be less of a feature and more of a realisation: if you squint at them right, they're just closures sitting inside object fields, and the parser was already halfway there. Two small grammar rules and a scope bug fix later, object.my_method(2) just works. The scope fix was an interesting part — collect_free_idents was silently dropping the receiver when traversing ObjectFieldAccess, which meant variables used as method receivers could slip past the unused-variable analysis unnoticed. Worth catching.

Here is the entire diff.

Next up, time to wrap it up!

Thanks for reading Bit Maybe Wise! object.my_method(2) now returns 4. Your inbox could return something good too -- subscribe and square up.

Photo by Waldemar Brandt on Unsplash

Tsonnet #38 - Call me maybe, but make it typed, part 4

Hercules Lemke Merscher — Tue, 21 Apr 2026 07:00:00 +0000

Welcome to the Tsonnet series!

If you're not following along, check out how it all started in the first post of the series.

In the previous post, we implemented closures — both bound to locals and immediately invoked:

Hercules Lemke Merscher

Apr 19

Tsonnet #37 - Call me maybe, but make it typed, part 3

#tsonnet #jsonnet #compiler

8 min read

I was annoyed by the fact that function type variants were difficult to read, so went on an errand to make it simpler. We can do better!

Let's see how it turned out.

A makeover for the AST

diff --git a/lib/ast.ml b/lib/ast.ml
index e317b6e..4b1102e 100644
--- a/lib/ast.ml
+++ b/lib/ast.ml
@@ -90,10 +90,9 @@ type expr =
   | Local of position * (string * expr) list
   | Seq of expr list
   | IndexedExpr of position * string * expr
-  | FunctionDef of position * (string * (string * expr option) list * expr)
-  | FunctionCall of position * string * expr list
-  | Closure of position * ((string * expr option) list * expr)
-  | ClosureCall of position * (string * expr option) list * expr * expr list
+  | FunctionDef of position * function_def
+  | FunctionCall of position * function_call
+  | Closure of position * closure

 and object_entry =
   | ObjectField of string * expr

ClosureCall is gone. It's basically FunctionCall, so there's no need to have a duplicated type variant.

The type variants function_def, function_call, and closure are represented as records, which makes them much easier to reason about since we can have names to represent what they are holding:

@@ -102,6 +101,20 @@ and object_scope =
   | Self
   | TopLevel
   | ObjVarRef of string
+
+and function_def = {
+  name: string;
+  params: (string * expr option) list;
+  body: expr;
+}
+and function_call = {
+  callee: expr;
+  args: expr list;
+}
+and closure = {
+  params: (string * expr option) list;
+  body: expr;
+}
 [@@deriving show]

 let dummy_expr = Unit

With this AST change, it became easier to simplify the parsing rules:

diff --git a/lib/parser.mly b/lib/parser.mly
index 8b3821e..e7b7771 100644
--- a/lib/parser.mly
+++ b/lib/parser.mly
@@ -22,6 +22,7 @@
 %token DOT
 %token SELF TOP_LEVEL_OBJ
 %token PLUS MINUS MULTIPLY DIVIDE MODULO
+%nonassoc FUNCTION
 %left PLUS MINUS
 %left MULTIPLY DIVIDE MODULO
 %token <string> ID
@@ -43,13 +44,11 @@
 prog:
   | e = expr; EOF { e }
   | e = expr_seq; EOF { e }
-  | e = closure; EOF { e }
   ;

 expr:
   | e = assignable_expr { e }
   | e = vars { e }
-  | e = closure_call { e }
   ;

 expr_seq:
@@ -63,6 +62,7 @@ assignable_expr:
   | e = indexed_expr { e }
   | e = obj_field_access { e }
   | e = funcall { e }
+  | e = closure { e }
   ;

 indexed_expr:
@@ -175,7 +175,6 @@ obj_field_access:

 var:
   | varname = ID; ASSIGN; e = assignable_expr { (varname, e) }
-  | varname = ID; ASSIGN; e = closure { (varname, e) }
   ;

 vars:
@@ -196,7 +195,7 @@ fundef:
   | fname = ID;
     LEFT_PAREN; params = separated_nonempty_list(COMMA, fundef_param); RIGHT_PAREN;
     ASSIGN;
-    body = fundef_body { (fname, params, body) }
+    body = fundef_body { { name = fname; params = params; body = body } }
   ;

 fundef_body:
@@ -207,20 +206,23 @@ fundef_body:
 funcall:
   | fname = ID;
     LEFT_PAREN; params = separated_nonempty_list(COMMA, assignable_expr); RIGHT_PAREN
-    { FunctionCall (with_pos $startpos $endpos, fname, params) }
+    { FunctionCall
+      (with_pos $startpos $endpos, {
+        callee = Ident (with_pos $startpos(fname) $endpos(fname), fname);
+        args = params;
+      })
+    }
+  | callee = scoped_expr;
+    LEFT_PAREN; params = separated_nonempty_list(COMMA, assignable_expr); RIGHT_PAREN
+    { FunctionCall (with_pos $startpos $endpos, { callee = callee; args = params }) }
   ;

 closure:
   | FUNCTION;
     LEFT_PAREN; params = separated_nonempty_list(COMMA, fundef_param); RIGHT_PAREN;
-    body = assignable_expr { Closure (with_pos $startpos $endpos, (params, body)) }
-  ;
-
-closure_call:
-  | LEFT_PAREN; FUNCTION;
-    LEFT_PAREN; def_params = separated_nonempty_list(COMMA, fundef_param); RIGHT_PAREN;
-    body = assignable_expr;
-    RIGHT_PAREN;
-    LEFT_PAREN; call_params = separated_nonempty_list(COMMA, assignable_expr); RIGHT_PAREN;
-    { ClosureCall (with_pos $startpos $endpos, def_params, body, call_params) }
+    body = assignable_expr {
+      Closure (with_pos $startpos $endpos, { params = params; body = body })
+    }
+    (* precedence here will transform "function(x) x * x" into "function(x) (x * x)" *)
+    %prec FUNCTION
   ;

I could finally move closure out of prog and expr. It was never meant to be there. But part of the problem was not having FUNCTION flagged as non-associative.

The interpreter catches up

With ClosureCall gone and FunctionCall now carrying a callee: expr, the interpreter needed a bit more surgery -- resolving the callee before dispatching to apply_function:

diff --git a/lib/interpreter.ml b/lib/interpreter.ml
index 7412fb9..15f9932 100644
--- a/lib/interpreter.ml
+++ b/lib/interpreter.ml
@@ -27,9 +27,8 @@ let rec interpret env expr =
   | Seq exprs -> interpret_seq env exprs
   | IndexedExpr (pos, varname, index_expr) -> interpret_indexed_expr env (pos, varname, index_expr)
   | FunctionDef (pos, def) -> interpret_function_def env (pos, def)
-  | FunctionCall (pos, fname, params) -> interpret_function_call env (pos, fname, params)
+  | FunctionCall (pos, call) -> interpret_function_call env (pos, call)
   | Closure _ -> ok (env, expr)
-  | ClosureCall (pos, def_params, body, params) -> interpret_closure_call env (pos, def_params, body, params)

 and interpret_indexed_expr env (pos, varname, index_expr) =
   let* (env', index_expr') = interpret env index_expr in
@@ -417,8 +416,8 @@ and interpret_ident env pos varname =
     result
   end

-and interpret_function_def env (pos, (fname, params, body)) =
-  let env' = Env.add_local fname (FunctionDef (pos, (fname, params, body))) env in
+and interpret_function_def env (pos, def) =
+  let env' = Env.add_local def.name (FunctionDef (pos, def)) env in
   ok (env', Unit)

 and apply_function env pos def_params body call_params =
@@ -468,16 +467,23 @@ and apply_function env pos def_params body call_params =
     in
     ok (env, result)

-and interpret_function_call env (pos, fname, call_params) =
-  match Env.find_opt fname env with
-  | Some (Closure (pos, (def_params, body)))
-  | Some (FunctionDef (pos, (_, def_params, body))) ->
-    apply_function env pos def_params body call_params
+and interpret_function_call env (pos, call) =
+  let* (env', callee_val) =
+    match call.callee with
+    | Ident (pos, name) ->
+      (match Env.find_opt name env with
+      | Some expr -> ok (env, expr)
+      | None -> Error.error_at pos (Error.Msg.var_not_found name)
+      )
+    | _ -> interpret env call.callee
+  in
+  match callee_val with
+  | Closure (_, closure) ->
+    apply_function env' pos closure.params closure.body call.args
+  | FunctionDef (_, def) ->
+    apply_function env' pos def.params def.body call.args
   | _ ->
-    Error.error_at pos (Error.Msg.var_not_found fname)
-
-and interpret_closure_call env (pos, def_params, body, call_params) =
-  apply_function env pos def_params body call_params
+    Error.error_at pos (Error.Msg.var_not_found (string_of_type call.callee))

 let rec deep_eval expr =
   match expr with

The type checker gets the memo

The type checker can also be improved by using the new type variants as records:

diff --git a/lib/type.ml b/lib/type.ml
index ee912b3..ad4f333 100644
--- a/lib/type.ml
+++ b/lib/type.ml
@@ -17,10 +17,10 @@ type tsonnet_type =
   | TobjectPtr of Env.env_id * t_object_scope
   | Lazy of expr
   | Tunresolved
-  | TfunctionDef of (string * tsonnet_type) list (* params: name * type *) * expr (* body *) * tsonnet_type (* return *)
-  | TfunctionCall of tsonnet_type list * tsonnet_type
-  | Tclosure of (string * tsonnet_type) list * expr
-  | TclosureCall of tsonnet_type list * tsonnet_type
+  | TfunctionDef of t_function_def
+  | TfunctionCall of t_function_call
+  | Tclosure of t_closure
+
 and t_object_entry =
   | TobjectField of string * tsonnet_type
   | TobjectExpr of tsonnet_type
@@ -28,6 +28,20 @@ and t_object_scope =
   | TobjectSelf
   | TobjectTopLevel

+and t_function_def = {
+  params: (string * tsonnet_type) list;
+  body: expr;
+  return: tsonnet_type;
+}
+and t_function_call = {
+  params: tsonnet_type list;
+  return: tsonnet_type;
+}
+and t_closure = {
+  params: (string * tsonnet_type) list;
+  body: expr;
+}
+
 let rec to_string = function
   | Tunit -> "()"
   | Tnull -> "Null"
@@ -59,25 +73,21 @@ let rec to_string = function
       | TobjectTopLevel -> "$"
     in Printf.sprintf "%s (%d)" s id
   | Lazy ty -> string_of_type ty
-  | TfunctionDef (params, _, return) ->
+  | TfunctionDef {params; return; _} ->
     Printf.sprintf "function(%s) -> %s"
       (List.map (fun (name, ty) -> name ^ ": " ^ to_string ty) params
       |> String.concat ", "
       )
       (to_string return)
-  | TfunctionCall (params_type, return) ->
+  | TfunctionCall {params=params_type; return} ->
     Printf.sprintf "function(%s) -> %s"
       (List.map to_string params_type |> String.concat ", ")
       (to_string return)
-  | Tclosure (params, _) ->
+  | Tclosure {params; _} ->
     Printf.sprintf "function(%s)"
       (List.map (fun (name, ty) -> name ^ ": " ^ to_string ty) params
       |> String.concat ", "
       )
-  | TclosureCall (params_type, return) ->
-    Printf.sprintf "function(%s) -> %s"
-      (List.map to_string params_type |> String.concat ", ")
-      (to_string return)
   | Tunresolved -> "<unresolved>"

 let rec collect_free_idents = function
@@ -95,10 +105,9 @@ let rec collect_free_idents = function
   | ObjectFieldAccess (_, _, exprs) -> List.concat_map collect_free_idents exprs
   | IndexedExpr (_, name, e) -> name :: collect_free_idents e
   | Local (_, vars) -> List.concat_map (fun (_, e) -> collect_free_idents e) vars
-  | FunctionCall (_, name, args) -> name :: List.concat_map collect_free_idents args
-  | Closure (_, (_, body)) -> collect_free_idents body
-  | ClosureCall (_, _, body, args) ->
-    collect_free_idents body @ List.concat_map collect_free_idents args
+  | FunctionCall (_, call) ->
+    collect_free_idents call.callee @ List.concat_map collect_free_idents call.args
+  | Closure (_, closure) -> collect_free_idents closure.body
   | _ -> []

 let reachable_bindings bindings initial_idents =
@@ -192,10 +201,8 @@ let rec translate venv expr =
   | UnaryOp (pos, op, expr) -> translate_unary_op venv (pos, op, expr)
   | IndexedExpr (pos, varname, index_expr) -> translate_indexed_expr venv (pos, varname, index_expr)
   | FunctionDef (pos, def) -> translate_function_def venv (pos, def)
-  | FunctionCall (pos, fname, params) -> translate_function_call venv (pos, fname, params)
-  | Closure (pos, (params, body)) -> translate_closure venv (pos, params, body)
-  | ClosureCall (pos, def_params, body, call_params) ->
-    translate_closure_call venv (pos, def_params, body, call_params)
+  | FunctionCall (pos, call) -> translate_function_call venv (pos, call)
+  | Closure (pos, closure) -> translate_closure venv (pos, closure)
   | expr' ->
     error (Error.Msg.type_invalid_expr (string_of_type expr')) 
@@ -493,7 +500,7 @@ and translate_bin_op venv pos op e1 e2 =
   | _, Tany, _ | _, _, Tany -> ok (venv'', Tany)
   | _ -> Error.error_at pos Error.Msg.invalid_binary_op

-and translate_function_def venv (pos, (fun_name, params, body)) =
+and translate_function_def venv (pos, def) =
   (* For params with defaults, we can infer the type from the default expression;
      params without defaults remain Tunresolved until the first call *)
   let* params_typed = List.fold_left
@@ -507,36 +514,57 @@ and translate_function_def venv (pos, (fun_name, params, body)) =
         ok (params' @ [(name, Tunresolved)])
     )
     (ok [])
-    params
+    def.params
+  in
+  let fun_def = TfunctionDef
+    { params = params_typed;
+      body = def.body;
+      return = Tunresolved;
+    }
   in
-  let fun_def = TfunctionDef (params_typed, body, Tunresolved) in
   (* So, function declaration will have an unresolved type definition,
      that only later it will be translated: before function call translation!
      After first function call, concrete types are set and subsequent calls will
      type check against the initial type assignment(s). *)
-  let venv' = Env.add_local fun_name fun_def venv in
+  let venv' = Env.add_local def.name fun_def venv in
   ok (venv', fun_def)

-and translate_function_call venv (pos, fname, call_params) =
-  (* 1. retrieve TfunctionDef from venv *)
-  match Env.find_opt fname venv with
-  | Some (TfunctionDef (def_params, body_expr, return_type)) ->
-    (* check arity: allow fewer args if defaults exist *)
-    let num_call = List.length call_params in
+and translate_function_call venv (pos, call) =
+  match call.callee with
+  | Ident (_, name) ->
+    translate_named_function_call venv (pos, name, call.args)
+  | Closure (_, closure) ->
+    translate_closure_call venv (pos, closure.params, closure.body, call.args)
+  | _ ->
+    let* (venv', callee_ty) = translate venv call.callee in
+    (match callee_ty with
+    | Tclosure { params = closure_params; body = body_expr } ->
+      let def_params = List.map (fun (name, _ty) -> (name, None)) closure_params in
+      translate_closure_call venv' (pos, def_params, body_expr, call.args)
+    | _ ->
+      Error.error_at pos (Error.Msg.type_invalid_expr (string_of_type call.callee))
+    )
+
+and translate_named_function_call venv (pos, name, args) =
+  match Env.find_opt name venv with
+  | Some (TfunctionDef { params = def_params;
+                         body = body_expr;
+                         return = return_type;
+                       }) ->
+    let num_call = List.length args in
     let num_def = List.length def_params in
     if num_call > num_def
     then
       Error.error_at pos
         (Error.Msg.wrong_number_of_params num_def num_call)
     else
-      (* 2. type check each positional parameter passed in the function call *)
       let* (venv', resolved_params) =
         List.fold_left
           (fun acc (index, (param_name, def_param_type)) ->
             let* (venv', params') = acc in
             if index < num_call
             then
-              let call_param = List.nth call_params index in
+              let call_param = List.nth args index in
               let* (venv'', call_param_type) = translate venv' call_param in
               match def_param_type with
               | Tunresolved ->
@@ -549,26 +577,22 @@ and translate_function_call venv (pos, fname, call_params) =
                     ~expected:(to_string expected)
                     ~got:(to_string call_param_type))
             else
-              (* default arg — resolve type from the original AST default expression *)
               ok (venv', params' @ [(param_name, def_param_type)])
           )
           (ok (venv, []))
           (List.mapi (fun i p -> (i, p)) def_params)
       in
-      (* 3. type check return *)
       let body_venv = List.fold_left
         (fun env (name, ty) -> Env.add_local name ty env)
         venv'
         resolved_params
       in
-      (* translate the body with resolved param types in scope *)
       let* (_, body_type) = translate body_venv body_expr in
-      let* resolved_return = match return_type with
+      let* resolved_return =
+        match return_type with
         | Tunresolved ->
-          (* 3a. first call: infer return type from body *)
           ok body_type
         | expected ->
-          (* 3b. subsequent calls: check body type matches *)
           if body_type = expected
           then ok expected
           else Error.error_at pos
@@ -576,23 +600,26 @@ and translate_function_call venv (pos, fname, call_params) =
               ~expected:(to_string expected)
               ~got:(to_string body_type))
       in
-      (* 4. update env with the now-resolved function type *)
-      let resolved_fun = TfunctionDef (resolved_params, body_expr, resolved_return) in
-      let venv_with_resolved_fun = Env.add_local fname resolved_fun venv' in
+      let resolved_fun =
+        TfunctionDef {
+          params = resolved_params;
+          body = body_expr;
+          return = resolved_return;
+        }
+      in
+      let venv_with_resolved_fun = Env.add_local name resolved_fun venv' in
       ok (venv_with_resolved_fun, resolved_return)
   | Some (Lazy expr) ->
     let* (venv', resolved) = translate venv expr in
-    (* Re-dispatch with the resolved type *)
-    let venv'' = Env.add_local fname resolved venv' in
-    translate_function_call venv'' (pos, fname, call_params)
-  | Some (Tclosure (def_params, body_expr)) ->
-    translate_closure_call venv (pos, 
-      List.map (fun (name, _ty) -> (name, None)) def_params,
-      body_expr, call_params)
+    let venv'' = Env.add_local name resolved venv' in
+    translate_named_function_call venv'' (pos, name, args)
+  | Some (Tclosure { params = closure_params; body = body_expr }) ->
+    let def_params = List.map (fun (name, _ty) -> (name, None)) closure_params in
+    translate_closure_call venv (pos, def_params, body_expr, args)
   | _ ->
-    Error.error_at pos (Error.Msg.var_not_found fname)
+    Error.error_at pos (Error.Msg.var_not_found name)

-and translate_closure venv (_pos, params, body) =
+and translate_closure venv (_pos, closure) =
   let* params_typed = List.fold_left
     (fun acc (name, default) ->
       let* params' = acc in
@@ -604,11 +631,11 @@ and translate_closure venv (_pos, params, body) =
         ok (params' @ [(name, Tunresolved)])
     )
     (ok [])
-    params
+    closure.params
   in
-  ok (venv, Tclosure (params_typed, body))
+  ok (venv, Tclosure { params = params_typed; body = closure.body })

-and translate_closure_call venv (pos, def_params, body_expr, call_params) =
+and translate_closure_call venv (pos, def_params, body, call_params) =
   let num_call = List.length call_params in
   let num_def = List.length def_params in
   let num_required =
@@ -641,7 +668,7 @@ and translate_closure_call venv (pos, def_params, body_expr, call_params) =
       venv'
       resolved_params
     in
-    let* (_, body_type) = translate body_venv body_expr in
+    let* (_, body_type) = translate body_venv body in
     ok (venv, body_type)

 let check (config : Config.t) expr  =

Conclusion

Switching from tuples to named records across the AST, type checker, and interpreter was one of those refactors that feels almost mechanical — until it isn't. The real win was collapsing ClosureCall into FunctionCall and generalising the callee to an arbitrary expression. The grammar conflict that made closure a second-class citizen in the previous post? Gone. A bit of precedence annotation and a small restructuring of funcall was all it took.

Here is the entire diff.

Next up, methods!

Thanks for reading Bit Maybe Wise! Tuples are out, records are in. Your inbox deserves named fields too — subscribe and stop guessing what position two holds.

Photo by Quino Al on Unsplash

Tsonnet #37 - Call me maybe, but make it typed, part 3

Hercules Lemke Merscher — Sun, 19 Apr 2026 10:40:23 +0000

Welcome to the Tsonnet series!

If you're not following along, check out how it all started in the first post of the series.

In the previous post, we added default function arguments:

Hercules Lemke Merscher

Apr 17

Tsonnet #36 — Call me maybe, but make it typed, part 2

#tsonnet #jsonnet #compiler

5 min read

Now let's implement closures.

Captured and ready to be called

We should accept a closure that is going to be assigned to a local, and immediately called closures:

// samples/functions/closure.jsonnet

// binding closure
local id = function(x) x;
// immediately called closure
(function(x) id(x) * id(x))(5)

Parsing: teaching the grammar new tricks

We need two new AST variants:

diff --git a/lib/ast.ml b/lib/ast.ml
index f4c1472..e317b6e 100644
--- a/lib/ast.ml
+++ b/lib/ast.ml
@@ -92,6 +92,8 @@ type expr =
   | IndexedExpr of position * string * expr
   | FunctionDef of position * (string * (string * expr option) list * expr)
   | FunctionCall of position * string * expr list
+  | Closure of position * ((string * expr option) list * expr)
+  | ClosureCall of position * (string * expr option) list * expr * expr list

 and object_entry =
   | ObjectField of string * expr

Then we update the lexer to recognise the new keyword:

diff --git a/lib/lexer.mll b/lib/lexer.mll
index a4c3745..4d65f55 100644
--- a/lib/lexer.mll
+++ b/lib/lexer.mll
@@ -80,6 +80,7 @@ rule read =
   | "self" { SELF }
   | "$" { TOP_LEVEL_OBJ }
   | "in" { IN }
+  | "function" { FUNCTION }
   | id { ID (Lexing.lexeme lexbuf) }
   | _ { raise (SyntaxError ("Unexpected char: " ^ Lexing.lexeme lexbuf)) }
   | eof { EOF }

And the parser:

diff --git a/lib/parser.mly b/lib/parser.mly
index 290b280..8b3821e 100644
--- a/lib/parser.mly
+++ b/lib/parser.mly
@@ -13,6 +13,7 @@
 %token NULL
 %token <bool> BOOL
 %token <string> STRING
+%token FUNCTION
 %token LEFT_SQR_BRACKET RIGHT_SQR_BRACKET
 %token LEFT_PAREN RIGHT_PAREN
 %token COMMA
@@ -42,11 +43,13 @@
 prog:
   | e = expr; EOF { e }
   | e = expr_seq; EOF { e }
+  | e = closure; EOF { e }
   ;

 expr:
   | e = assignable_expr { e }
   | e = vars { e }
+  | e = closure_call { e }
   ;

I stumbled upon a shift-reduce issue trying to make closure part of the assignable_expr parsing rule — it would make more semantic sense there, but the grammar conflicts beat me. I'll come back to fix it later.

Here's the short version of why it's not feasible as-is: if closure lives in assignable_expr, then (function(x) x) becomes reachable via two paths simultaneously — as a parenthesised closure via scoped_expr, and as the first half of a closure_call. When the parser sees ( function(x) body . ) and hits ), it can't decide whether to reduce into scoped_expr or shift ) as part of closure_call — that would require two tokens of lookahead, which LR(1) doesn't have. The only clean fix would be generalising funcall to accept any expression as the callee, so (function(x) x)(5) parses naturally as "call this expression with these args" — but that's a bigger refactor touching the AST, type checker, and interpreter.

Here's how the new closure and closure_call rules are implemented for now:

@@ -171,7 +174,9 @@ obj_field_access:
   ;

 var:
-  varname = ID; ASSIGN; e = assignable_expr { (varname, e) };
+  | varname = ID; ASSIGN; e = assignable_expr { (varname, e) }
+  | varname = ID; ASSIGN; e = closure { (varname, e) }
+  ;

 vars:
   | LOCAL; vars = separated_nonempty_list(COMMA, var) { Local (with_pos $startpos $endpos, vars) }
@@ -203,4 +208,19 @@ funcall:
   | fname = ID;
     LEFT_PAREN; params = separated_nonempty_list(COMMA, assignable_expr); RIGHT_PAREN
     { FunctionCall (with_pos $startpos $endpos, fname, params) }
+  ;
+
+closure:
+  | FUNCTION;
+    LEFT_PAREN; params = separated_nonempty_list(COMMA, fundef_param); RIGHT_PAREN;
+    body = assignable_expr { Closure (with_pos $startpos $endpos, (params, body)) }
+  ;
+
+closure_call:
+  | LEFT_PAREN; FUNCTION;
+    LEFT_PAREN; def_params = separated_nonempty_list(COMMA, fundef_param); RIGHT_PAREN;
+    body = assignable_expr;
+    RIGHT_PAREN;
+    LEFT_PAREN; call_params = separated_nonempty_list(COMMA, assignable_expr); RIGHT_PAREN;
+    { ClosureCall (with_pos $startpos $endpos, def_params, body, call_params) }
   ;

Type checking: the elephant in the room

The new type variants mirror the ones in ast.ml:

diff --git a/lib/type.ml b/lib/type.ml
index 05bc187..ee912b3 100644
--- a/lib/type.ml
+++ b/lib/type.ml
@@ -19,6 +19,8 @@ type tsonnet_type =
   | Tunresolved
   | TfunctionDef of (string * tsonnet_type) list (* params: name * type *) * expr (* body *) * tsonnet_type (* return *)
   | TfunctionCall of tsonnet_type list * tsonnet_type
+  | Tclosure of (string * tsonnet_type) list * expr
+  | TclosureCall of tsonnet_type list * tsonnet_type
 and t_object_entry =
   | TobjectField of string * tsonnet_type
   | TobjectExpr of tsonnet_type

The collect_free_idents function needs updating for the new variants — I also noticed I'd forgotten FunctionCall here earlier (oops!):

@@ -84,6 +95,10 @@ let rec collect_free_idents = function
   | ObjectFieldAccess (_, _, exprs) -> List.concat_map collect_free_idents exprs
   | IndexedExpr (_, name, e) -> name :: collect_free_idents e
   | Local (_, vars) -> List.concat_map (fun (_, e) -> collect_free_idents e) vars
+  | FunctionCall (_, name, args) -> name :: List.concat_map collect_free_idents args
+  | Closure (_, (_, body)) -> collect_free_idents body
+  | ClosureCall (_, _, body, args) ->
+    collect_free_idents body @ List.concat_map collect_free_idents args
   | _ -> []

Then we pattern-match on the new AST nodes in translate:

@@ -178,6 +193,9 @@ let rec translate venv expr =
   | IndexedExpr (pos, varname, index_expr) -> translate_indexed_expr venv (pos, varname, index_expr)
   | FunctionDef (pos, def) -> translate_function_def venv (pos, def)
   | FunctionCall (pos, fname, params) -> translate_function_call venv (pos, fname, params)
+  | Closure (pos, (params, body)) -> translate_closure venv (pos, params, body)
+  | ClosureCall (pos, def_params, body, call_params) ->
+    translate_closure_call venv (pos, def_params, body, call_params)
   | expr' ->
     error (Error.Msg.type_invalid_expr (string_of_type expr'))

I also added a catch-all for Tany in binary operations — if either side is Tany, we let it through rather than erroring:

@@ -472,6 +490,7 @@ and translate_bin_op venv pos op e1 e2 =
   | LessThan, Tstring, Tstring -> ok (venv'', Tbool)
   | LessThanOrEqual, Tstring, Tstring -> ok (venv'', Tbool)
   | In, Tstring, (Tobject _ | Tany | TruntimeObject _ | TobjectPtr _) -> ok (venv'', Tbool)
+  | _, Tany, _ | _, _, Tany -> ok (venv'', Tany)
   | _ -> Error.error_at pos Error.Msg.invalid_binary_op

translate_function_call also needs to handle Tclosure — if a bound name resolves to a closure, we re-dispatch to translate_closure_call:

@@ -561,9 +580,70 @@ and translate_function_call venv (pos, fname, call_params) =
       let resolved_fun = TfunctionDef (resolved_params, body_expr, resolved_return) in
       let venv_with_resolved_fun = Env.add_local fname resolved_fun venv' in
       ok (venv_with_resolved_fun, resolved_return)
+  | Some (Lazy expr) ->
+    let* (venv', resolved) = translate venv expr in
+    (* Re-dispatch with the resolved type *)
+    let venv'' = Env.add_local fname resolved venv' in
+    translate_function_call venv'' (pos, fname, call_params)
+  | Some (Tclosure (def_params, body_expr)) ->
+    translate_closure_call venv (pos, 
+      List.map (fun (name, _ty) -> (name, None)) def_params,
+      body_expr, call_params)
   | _ ->
     Error.error_at pos (Error.Msg.var_not_found fname)

translate_closure is pretty similar to translate_function_def:

and translate_closure venv (_pos, params, body) =
  let* params_typed = List.fold_left
    (fun acc (name, default) ->
      let* params' = acc in
      match default with
      | Some default_expr ->
        let* (_, default_ty) = translate venv default_expr in
        ok (params' @ [(name, default_ty)])
      | None ->
        ok (params' @ [(name, Tunresolved)])
    )
    (ok [])
    params
  in
  ok (venv, Tclosure (params_typed, body))

And translate_closure_call is pretty similar to translate_function_call:

and translate_closure_call venv (pos, def_params, body_expr, call_params) =
  let num_call = List.length call_params in
  let num_def = List.length def_params in
  let num_required =
    List.length (List.filter (fun (_, default) -> Option.is_none default) def_params)
  in
  if num_call < num_required || num_call > num_def
  then Error.error_at pos (Error.Msg.wrong_number_of_params num_def num_call)
  else
    let* (venv', resolved_params) =
      List.fold_left
        (fun acc (index, (param_name, default)) ->
          let* (venv', params') = acc in
          if index < num_call
          then
            let call_param = List.nth call_params index in
            let* (venv'', call_param_type) = translate venv' call_param in
            ok (venv'', params' @ [(param_name, call_param_type)])
          else
            match default with
            | Some default_expr ->
              let* (venv'', default_type) = translate venv' default_expr in
              ok (venv'', params' @ [(param_name, default_type)])
            | None -> Error.error_at pos (Error.Msg.wrong_number_of_params num_def num_call)
        )
        (ok (venv, []))
        (List.mapi (fun i p -> (i, p)) def_params)
    in
    let body_venv = List.fold_left
      (fun env (name, ty) -> Env.add_local name ty env)
      venv'
      resolved_params
    in
    let* (_, body_type) = translate body_venv body_expr in
    ok (venv, body_type)

There's room for simplification here, but let's move on for now.

It's worth pausing on a behaviour difference between Tsonnet and standard Jsonnet. Given this sample:

// samples/semantics/invalid_function_call_type.jsonnet
local my_function(x) = x * 2;
my_function(3) && my_function("oops")

Jsonnet fails at runtime after evaluating the first call, because && expects a boolean and gets a number first:

$ jsonnet samples/semantics/invalid_function_call_type.jsonnet
RUNTIME ERROR: Unexpected type number, expected boolean
    samples/semantics/invalid_function_call_type.jsonnet:2:1-38 $
    During evaluation

Tsonnet instead type-checks the function calls before even getting to the &&, and catches the type mismatch earlier:

dune exec -- tsonnet samples/semantics/invalid_function_call_type.jsonnet
ERROR: samples/semantics/invalid_function_call_type.jsonnet:2:18 Expected type Number, got String

2: my_function(3) && my_function("oops")
   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

I think that's a more sensible error. Worth noting: I want to support polymorphic parameters and return types eventually, but for this prototype, this is enough.

Interpreting: where closures actually close over things

During interpretation, a closure definition is returned as-is — it just gets stored in the environment. The actual work happens at call time:

diff --git a/lib/interpreter.ml b/lib/interpreter.ml
index 6ad259e..7412fb9 100644
--- a/lib/interpreter.ml
+++ b/lib/interpreter.ml
@@ -28,6 +28,8 @@ let rec interpret env expr =
   | IndexedExpr (pos, varname, index_expr) -> interpret_indexed_expr env (pos, varname, index_expr)
   | FunctionDef (pos, def) -> interpret_function_def env (pos, def)
   | FunctionCall (pos, fname, params) -> interpret_function_call env (pos, fname, params)
+  | Closure _ -> ok (env, expr)
+  | ClosureCall (pos, def_params, body, params) -> interpret_closure_call env (pos, def_params, body, params)

The function application logic was straightforward to generalise into apply_function, which both interpret_function_call and interpret_closure_call now share:

and apply_function env pos def_params body call_params =
  let num_call = List.length call_params in
  let num_def = List.length def_params in
  let num_required =
    List.length (
      List.filter (fun (_, default) -> Option.is_none default) def_params
    )
  in
  if num_call < num_required || num_call > num_def
  then
    Error.error_at pos (Error.Msg.wrong_number_of_params num_def num_call)
  else
    let* evaluated_call_params =
      List.fold_left
        (fun acc param ->
          let* params = acc in
          let* (_, v) = interpret env param in
          ok (params @ [v])
        )
        (ok [])
        call_params
    in
    let* bindings =
      List.fold_left
        (fun acc (index, (param_name, default)) ->
          let* bindings = acc in
          if index < num_call
          then
            ok (bindings @ [(param_name, List.nth evaluated_call_params index)])
          else
            match default with
            | Some default_expr -> ok (bindings @ [(param_name, default_expr)])
            | None -> Error.error_at pos (Error.Msg.wrong_number_of_params num_def num_call)
        )
        (ok [])
        (List.mapi (fun i p -> (i, p)) def_params)
    in
    let env' = List.fold_left
      (fun env (k, v) -> Env.add_local k v env)
      env
      bindings
    in
    let* (_, result) = with_fresh_evaluating_bindings
      (fun () -> interpret env' body)
    in
    ok (env, result)

interpret_function_call and interpret_closure_call now just delegate to it:

 and interpret_function_call env (pos, fname, call_params) =
   match Env.find_opt fname env with
+  | Some (Closure (pos, (def_params, body)))
   | Some (FunctionDef (pos, (_, def_params, body))) ->
-    ...
+    apply_function env pos def_params body call_params
   | _ ->
     Error.error_at pos (Error.Msg.var_not_found fname)

+and interpret_closure_call env (pos, def_params, body, call_params) =
+  apply_function env pos def_params body call_params

I also used this opportunity to fix a leftover hard-coded error string I'd missed during an earlier refactoring:

diff --git a/lib/error.ml b/lib/error.ml
-  let type_wrong_number_of_params expected got =
-    Printf.sprintf "Expected %d argument(s), got %d" expected got
+  let wrong_number_of_params expected got =
+    Printf.sprintf "Expected %d argument(s), got %d" expected got

The rename also moves the message out of the type_-prefixed block, since both the type checker and the interpreter now share it.

Does it work? (Yes it does)

$ dune exec -- tsonnet samples/functions/closure.jsonnet
25

And the cram test:

diff --git a/test/cram/functions.t b/test/cram/functions.t
index fa29868..5c77837 100644
--- a/test/cram/functions.t
+++ b/test/cram/functions.t
@@ -6,3 +6,6 @@

   $ tsonnet ../../samples/functions/default_args.jsonnet
   12
+
+  $ tsonnet ../../samples/functions/closure.jsonnet
+  25

Conclusion

Closures are in. Binding them to locals, calling them immediately, passing them around — it all works. The type checker was the trickier part, requiring extra plumbing to re-dispatch when a bound name turns out to be a closure, but the interpreter side practically wrote itself once apply_function was factored out. The shift-reduce issue in the parser is still there, nagging at me from the grammar file — but that's a problem for future me, probably involving a refactor to let funcall accept any expression as callee.

Here is the entire diff.

Next up, I think this can be simplified, and I will do so.

Thanks for reading Bit Maybe Wise! Closures capture their environment. This newsletter captures compilers being built in the open. Subscribe before the environment gets GC'd.

Photo by The Now Time on Unsplash

Tsonnet #36 — Call me maybe, but make it typed, part 2

Hercules Lemke Merscher — Fri, 17 Apr 2026 07:00:00 +0000

Welcome to the Tsonnet series!

If you're not following along, check out how it all started in the first post of the series.

In the previous post, we added basic function support — positional parameters, multiline bodies, and type inference that resolves at call time:

Hercules Lemke Merscher

Apr 15

Tsonnet #35 — Call me maybe, but make it typed, part 1

#tsonnet #jsonnet #compiler

8 min read

Now let's make functions a little more forgiving. In this post, we'll implement default function arguments.

What's on the menu?

// samples/functions/default_args.jsonnet
local my_function(x, y=10) = x + y;
my_function(2)

The call passes only one argument. y falls back to its default value of 10, so the result is 12.

Teaching the parser about optionals

The parser needs a small adjustment to accept an optional default expression per parameter. Previously, each parameter was just an ID. Now it can optionally include = <expr>:

diff --git a/lib/parser.mly b/lib/parser.mly
index 102d202..290b280 100644
--- a/lib/parser.mly
+++ b/lib/parser.mly
@@ -182,9 +182,14 @@ single_var:
   | LOCAL; var_expr = var { Local (with_pos $startpos $endpos, [var_expr]) }
   ;

+fundef_param:
+  | name = ID { (name, None) }
+  | name = ID; ASSIGN; default = assignable_expr { (name, Some default) }
+  ;
+
 fundef:
   | fname = ID;
-    LEFT_PAREN; params = separated_nonempty_list(COMMA, ID); RIGHT_PAREN;
+    LEFT_PAREN; params = separated_nonempty_list(COMMA, fundef_param); RIGHT_PAREN;
     ASSIGN;
     body = fundef_body { (fname, params, body) }
   ;

And the AST type updates to carry the optional default alongside the parameter name:

diff --git a/lib/ast.ml b/lib/ast.ml
index 106f37c..f4c1472 100644
--- a/lib/ast.ml
+++ b/lib/ast.ml
@@ -90,7 +90,7 @@ type expr =
   | Local of position * (string * expr) list
   | Seq of expr list
   | IndexedExpr of position * string * expr
-  | FunctionDef of position * (string * string list * expr)
+  | FunctionDef of position * (string * (string * expr option) list * expr)
   | FunctionCall of position * string * expr list

 and object_entry =

Each parameter goes from a plain string to a string * expr option — None for required, Some expr for optional with a default.

Filling in the blanks

The arity check is a bit more involved now, since we have to distinguish between required and optional parameters:

diff --git a/lib/interpreter.ml b/lib/interpreter.ml
index d512c0f..6ad259e 100644
--- a/lib/interpreter.ml
+++ b/lib/interpreter.ml
@@ -422,16 +422,30 @@ and interpret_function_def env (pos, (fname, params, body)) =
 and interpret_function_call env (pos, fname, call_params) =
   match Env.find_opt fname env with
   | Some (FunctionDef (pos, (_, def_params, body))) ->
-    if List.compare_lengths call_params def_params <> 0
+    let num_call = List.length call_params in
+    let num_def = List.length def_params in
+    let num_required =
+      List.length (
+        List.filter (fun (_, default) -> Option.is_none default) def_params
+      )
+    in
+    if num_call < num_required || num_call > num_def
     then Error.error_at pos "wrong number of param(s)"
     else
-      let bindings =
-        List.mapi
-          (fun index value ->
-            let param_name = List.nth def_params index in
-            (param_name, value)
+      let* bindings =
+        List.fold_left
+          (fun acc (index, (param_name, default)) ->
+            let* bindings = acc in
+            if index < num_call
+            then
+              ok (bindings @ [(param_name, List.nth call_params index)])
+            else
+              match default with
+              | Some default_expr -> ok (bindings @ [(param_name, default_expr)])
+              | None -> Error.error_at pos "wrong number of param(s)"
           )
-          call_params
+          (ok [])
+          (List.mapi (fun i p -> (i, p)) def_params)
       in
       let env' = List.fold_left
         (fun env (k, v) -> Env.add_local k v env)

The key change: instead of checking for an exact match, we now compute both the total number of defined parameters (num_def) and the number of required ones (num_required). The call is valid if the number of supplied arguments falls anywhere in the range [num_required, num_def]. For arguments not supplied by the caller, we fall back to the default expression.

Knowing the type before the call

Default arguments give the type checker a nice bonus: when a parameter has a default value, we can infer its type right at declaration time instead of waiting for the first call.

diff --git a/lib/type.ml b/lib/type.ml
index bdbf357..05bc187 100644
--- a/lib/type.ml
+++ b/lib/type.ml
@@ -475,9 +475,21 @@ and translate_bin_op venv pos op e1 e2 =
   | _ -> Error.error_at pos Error.Msg.invalid_binary_op

 and translate_function_def venv (pos, (fun_name, params, body)) =
-  (* As of now, we don't know the input types at declaration *)
-  let params_typed = List.map (fun name -> (name, Tunresolved)) params in
-  (* We also don't know the result type *)
+  (* For params with defaults, we can infer the type from the default expression;
+     params without defaults remain Tunresolved until the first call *)
+  let* params_typed = List.fold_left
+    (fun acc (name, default) ->
+      let* params' = acc in
+      match default with
+      | Some default_expr ->
+        let* (_, default_ty) = translate venv default_expr in
+        ok (params' @ [(name, default_ty)])
+      | None ->
+        ok (params' @ [(name, Tunresolved)])
+    )
+    (ok [])
+    params
+  in
   let fun_def = TfunctionDef (params_typed, body, Tunresolved) in
   (* So, function declaration will have an unresolved type definition,
      that only later it will be translated: before function call translation!

Parameters without defaults stay Tunresolved and get resolved at the call site, same as before. Parameters with defaults get their type resolved immediately. In our example, y=10 means y is typed as Number from the moment the function is declared.

The arity check at the call site follows the same logic as the interpreter — allow fewer arguments than the total, as long as the mandatory ones are all there:

@@ -490,35 +502,39 @@ and translate_function_call venv (pos, fname, call_params) =
   (* 1. retrieve TfunctionDef from venv *)
   match Env.find_opt fname venv with
   | Some (TfunctionDef (def_params, body_expr, return_type)) ->
-    (* check arity *)
-    if List.compare_lengths call_params def_params <> 0
+    (* check arity: allow fewer args if defaults exist *)
+    let num_call = List.length call_params in
+    let num_def = List.length def_params in
+    if num_call > num_def
     then
       Error.error_at pos
-        (Error.Msg.type_wrong_number_of_params
-          (List.length def_params) (List.length call_params))
+        (Error.Msg.type_wrong_number_of_params num_def num_call)
     else
       (* 2. type check each positional parameter passed in the function call *)
       let* (venv', resolved_params) =
-        List.fold_left2
-          (fun acc call_param (param_name, def_param_type) ->
+        List.fold_left
+          (fun acc (index, (param_name, def_param_type)) ->
             let* (venv', params') = acc in
-            let* (venv'', call_param_type) = translate venv' call_param in
-            match def_param_type with
-            | Tunresolved ->
-              (* 2a. unresolved: accept and record the concrete type *)
-              ok (venv'', params' @ [(param_name, call_param_type)])
-            | expected ->
-              (* 2b. resolved: type check against the concrete type *)
-              if call_param_type = expected
-              then ok (venv'', params' @ [(param_name, expected)])
-              else Error.error_at pos
-                (Error.Msg.type_mismatch
-                  ~expected:(to_string expected)
-                  ~got:(to_string call_param_type))
+            if index < num_call
+            then
+              let call_param = List.nth call_params index in
+              let* (venv'', call_param_type) = translate venv' call_param in
+              match def_param_type with
+              | Tunresolved ->
+                ok (venv'', params' @ [(param_name, call_param_type)])
+              | expected ->
+                if call_param_type = expected
+                then ok (venv'', params' @ [(param_name, expected)])
+                else Error.error_at pos
+                  (Error.Msg.type_mismatch
+                    ~expected:(to_string expected)
+                    ~got:(to_string call_param_type))
+            else
+              (* default arg — resolve type from the original AST default expression *)
+              ok (venv', params' @ [(param_name, def_param_type)])
           )
           (ok (venv, []))
-          call_params
-          def_params
+          (List.mapi (fun i p -> (i, p)) def_params)
       in
       (* 3. type check return *)
       let body_venv = List.fold_left

When the caller omits an argument that has a default, we skip the type-checking step for that parameter and carry its already-resolved type forward. No extra work needed — the type was inferred when the function was declared.

The moment of truth

diff --git a/test/cram/functions.t b/test/cram/functions.t
index 0ad7e43..fa29868 100644
--- a/test/cram/functions.t
+++ b/test/cram/functions.t
@@ -3,3 +3,6 @@

   $ tsonnet ../../samples/functions/multiline.jsonnet
   [ 6, 7 ]
+
+  $ tsonnet ../../samples/functions/default_args.jsonnet
+  12

my_function(2) with y=10 gives 12. Working as expected.

Conclusion

Default arguments are in. With a surprisingly contained change across parser, AST, interpreter, and type checker, my_function(x, y=10) now works as you'd expect — and the type checker even gets to resolve y's type at declaration time rather than waiting for the first call.

Here is the entire diff.

Next up, functions get a serious upgrade: closures.

Thanks for reading Bit Maybe Wise! Default arguments are optional. Subscribing isn't — but I'd never force you. Subscribe

Photo by Compare Fibre on Unsplash

Tsonnet #35 — Call me maybe, but make it typed, part 1

Hercules Lemke Merscher — Wed, 15 Apr 2026 07:00:00 +0000

Welcome to the Tsonnet series!

If you're not following along, check out how it all started in the first post of the series.

In the previous post, we added warnings for unused variables and untouched bindings:

Hercules Lemke Merscher

Mar 15

Tsonnet #34 - Dabbling with untouched bindings

#tsonnet #jsonnet #compiler

14 min read

Now let's get to the most exciting feature in any programming language: functions!

What are we even working with here?

A simple inline function with a positional parameter:

// samples/functions/positional_params.jsonnet
local my_function(x) = x * 2;
my_function(3)

And a function with a multiline body:

// samples/functions/multiline.jsonnet
local simple_function(x, y) = x + y;

local multiline_function(x) =
  local temp = x * 2;
  [temp, temp + 1];

multiline_function(
  simple_function(1, 2)
)

Parsing (a.k.a. making sense of text)

We need two new AST variants -- one for function definition, one for function call:

diff --git a/lib/ast.ml b/lib/ast.ml
index ace6241..106f37c 100644
--- a/lib/ast.ml
+++ b/lib/ast.ml
@@ -90,6 +90,8 @@ type expr =
   | Local of position * (string * expr) list
   | Seq of expr list
   | IndexedExpr of position * string * expr
+  | FunctionDef of position * (string * string list * expr)
+  | FunctionCall of position * string * expr list

 and object_entry =
   | ObjectField of string * expr

And the parser rules to match:

diff --git a/lib/parser.mly b/lib/parser.mly
index 7adb1ee..102d202 100644
--- a/lib/parser.mly
+++ b/lib/parser.mly
@@ -59,6 +59,7 @@ assignable_expr:
   | op = unary_op; e = assignable_expr { UnaryOp (with_pos $startpos $endpos, op, e) }
   | e = indexed_expr { e }
   | e = obj_field_access { e }
+  | e = funcall { e }
   ;

 indexed_expr:
@@ -173,7 +174,28 @@ var:
   varname = ID; ASSIGN; e = assignable_expr { (varname, e) };

 vars:
-  LOCAL; vars = separated_nonempty_list(COMMA, var) { Local (with_pos $startpos $endpos, vars) };
+  | LOCAL; vars = separated_nonempty_list(COMMA, var) { Local (with_pos $startpos $endpos, vars) }
+  | LOCAL; def = fundef { FunctionDef (with_pos $startpos $endpos, def) }
+  ;

 single_var:
-  LOCAL; var_expr = var { Local (with_pos $startpos $endpos, [var_expr]) };
+  | LOCAL; var_expr = var { Local (with_pos $startpos $endpos, [var_expr]) }
+  ;
+
+fundef:
+  | fname = ID;
+    LEFT_PAREN; params = separated_nonempty_list(COMMA, ID); RIGHT_PAREN;
+    ASSIGN;
+    body = fundef_body { (fname, params, body) }
+  ;
+
+fundef_body:
+  | e = assignable_expr { e }
+  | local_bindings = vars; SEMICOLON; body = fundef_body { Seq [local_bindings; body] }
+  ;
+
+funcall:
+  | fname = ID;
+    LEFT_PAREN; params = separated_nonempty_list(COMMA, assignable_expr); RIGHT_PAREN
+    { FunctionCall (with_pos $startpos $endpos, fname, params) }
+  ;

fundef_body deserves a note: it lets us nest local bindings inside the function body, which is what makes multiline_function work. A function body is either a plain expression or a local binding followed by a semicolon and the rest of the body, recursively.

Interpreting: where things actually happen

While working on the interpreter, I noticed that evaluating_fields was a misleading name — interpret_ident handles not just object fields, but regular local bindings too. Renamed it to evaluating_bindings:

diff --git a/lib/interpreter.ml b/lib/interpreter.ml
index c8755bc..d512c0f 100644
--- a/lib/interpreter.ml
+++ b/lib/interpreter.ml
@@ -2,7 +2,14 @@ open Ast
 open Result
 open Syntax_sugar

-let evaluating_fields = ref ObjectFields.empty
+let evaluating_bindings = ref ObjectFields.empty

I also needed a helper to run a function in a fresh evaluation environment, then restore the previous state afterwards:

let with_fresh_evaluating_bindings fn =
  let saved_evaluating_bindings = !evaluating_bindings in
  evaluating_bindings := ObjectFields.empty;
  let result = fn () in
  evaluating_bindings := saved_evaluating_bindings;
  result

This matters for function calls: we don't want the caller's evaluation state leaking into the function body.

The new pattern-matching cases route to their respective handlers:

 (** [interpret expr] interprets and reduce the intermediate AST [expr] into a result AST. *)
 let rec interpret env expr =
@@ -19,6 +26,8 @@ let rec interpret env expr =
   | Local (_, vars) -> interpret_local env vars
   | Seq exprs -> interpret_seq env exprs
   | IndexedExpr (pos, varname, index_expr) -> interpret_indexed_expr env (pos, varname, index_expr)
+  | FunctionDef (pos, def) -> interpret_function_def env (pos, def)
+  | FunctionCall (pos, fname, params) -> interpret_function_call env (pos, fname, params)

 and interpret_indexed_expr env (pos, varname, index_expr) =
   let* (env', index_expr') = interpret env index_expr in

Function definition just registers the function in the environment:

and interpret_function_def env (pos, (fname, params, body)) =
  let env' = Env.add_local fname (FunctionDef (pos, (fname, params, body))) env in
  ok (env', Unit)

Function call is where things get interesting:

and interpret_function_call env (pos, fname, call_params) =
  match Env.find_opt fname env with
  | Some (FunctionDef (pos, (_, def_params, body))) ->
    if List.compare_lengths call_params def_params <> 0
    then Error.error_at pos "wrong number of param(s)"
    else
      let bindings =
        List.mapi
          (fun index value ->
            let param_name = List.nth def_params index in
            (param_name, value)
          )
          call_params
      in
      let env' = List.fold_left
        (fun env (k, v) -> Env.add_local k v env)
        env
        bindings
      in
      let* (_, result) = with_fresh_evaluating_bindings
        (fun () -> interpret env' body)
      in
      ok (env, result)
  | _ ->
    Error.error_at pos (Error.Msg.var_not_found fname)

Step by step:

Check that the number of arguments matches the definition. I could skip this in the interpreter and rely on the type checker alone, but I'm keeping it in both for now -- type checking can be bypassed during development for faster iteration.
Pair up each call argument with its corresponding parameter name.
Add those bindings to the environment.
Interpret the function body in that environment, being careful to return the caller's environment, not the one modified inside the body.

Making sure this isn’t completely illegal

We don't have type annotations yet, so the type checker needs to infer parameter types and the return type. Here's the motivating example -- the first call is fine, the second should error:

// samples/semantics/invalid_function_call_type.jsonnet
local my_function(x) = x * 2;
my_function(3) && my_function("oops")

We need three new type variants:

diff --git a/lib/type.ml b/lib/type.ml
index cad9ad1..bdbf357 100644
--- a/lib/type.ml
+++ b/lib/type.ml
@@ -16,6 +16,9 @@ type tsonnet_type =
   | TruntimeObject of Env.env_id * t_object_entry list
   | TobjectPtr of Env.env_id * t_object_scope
   | Lazy of expr
+  | Tunresolved
+  | TfunctionDef of (string * tsonnet_type) list (* params: name * type *) * expr (* body *) * tsonnet_type (* return *)
+  | TfunctionCall of tsonnet_type list * tsonnet_type
 and t_object_entry =
   | TobjectField of string * tsonnet_type
   | TobjectExpr of tsonnet_type

@@ -54,6 +57,17 @@ let rec to_string = function
       | TobjectTopLevel -> "$"
     in Printf.sprintf "%s (%d)" s id
   | Lazy ty -> string_of_type ty
+  | TfunctionDef (params, _, return) ->
+    Printf.sprintf "function(%s) -> %s"
+      (List.map (fun (name, ty) -> name ^ ": " ^ to_string ty) params
+      |> String.concat ", "
+      )
+      (to_string return)
+  | TfunctionCall (params_type, return) ->
+    Printf.sprintf "function(%s) -> %s"
+      (List.map to_string params_type |> String.concat ", ")
+      (to_string return)
+  | Tunresolved -> "<unresolved>"

 let rec collect_free_idents = function
   | Unit | Null _ | Number _ | String _ | Bool _ -> []

Tunresolved is the key one. At declaration time, we don't know what types the parameters will have -- that only becomes clear at the call site. So we use Tunresolved as a placeholder and fill it in later.

Two new error messages to go with it:

diff --git a/lib/error.ml b/lib/error.ml
index e287af9..e08c670 100644
--- a/lib/error.ml
+++ b/lib/error.ml
@@ -28,6 +28,10 @@ module Msg = struct
   let type_non_indexable_type ty = ty ^ " is a non-indexable type"
   let type_non_indexable_field field = field ^ " is a non-indexable value"
   let type_invalid_lookup_key expr = "Invalid object lookup key: " ^ expr
+  let type_wrong_number_of_params expected got =
+    Printf.sprintf "Expected %d argument(s), got %d" expected got
+  let type_mismatch ~expected ~got =
+    Printf.sprintf "Expected type %s, got %s" expected got

   (* Interpreter messages *)
   let interp_division_by_zero = "Division by zero"

The new cases in translate forward to specialised functions, same pattern as always:

@@ -162,6 +176,8 @@ let rec translate venv expr =
   | BinOp (pos, op, e1, e2) -> translate_bin_op venv pos op e1 e2
   | UnaryOp (pos, op, expr) -> translate_unary_op venv (pos, op, expr)
   | IndexedExpr (pos, varname, index_expr) -> translate_indexed_expr venv (pos, varname, index_expr)
+  | FunctionDef (pos, def) -> translate_function_def venv (pos, def)
+  | FunctionCall (pos, fname, params) -> translate_function_call venv (pos, fname, params)
   | expr' ->
     error (Error.Msg.type_invalid_expr (string_of_type expr'))

At declaration time, all types are Tunresolved:

and translate_function_def venv (pos, (fun_name, params, body)) =
  (* As of now, we don't know the input types at declaration *)
  let params_typed = List.map (fun name -> (name, Tunresolved)) params in
  (* We also don't know the result type *)
  let fun_def = TfunctionDef (params_typed, body, Tunresolved) in
  (* So, function declaration will have an unresolved type definition,
     that only later it will be translated: before function call translation!
     After first function call, concrete types are set and subsequent calls will
     type check against the initial type assignment(s). *)
  let venv' = Env.add_local fun_name fun_def venv in
  ok (venv', fun_def)

At call time, Tunresolved gets replaced with concrete types -- and subsequent calls are checked against those:

and translate_function_call venv (pos, fname, call_params) =
  (* 1. retrieve TfunctionDef from venv *)
  match Env.find_opt fname venv with
  | Some (TfunctionDef (def_params, body_expr, return_type)) ->
    (* check arity *)
    if List.compare_lengths call_params def_params <> 0
    then
      Error.error_at pos
        (Error.Msg.type_wrong_number_of_params
          (List.length def_params) (List.length call_params))
    else
      (* 2. type check each positional parameter passed in the function call *)
      let* (venv', resolved_params) =
        List.fold_left2
          (fun acc call_param (param_name, def_param_type) ->
            let* (venv', params') = acc in
            let* (venv'', call_param_type) = translate venv' call_param in
            match def_param_type with
            | Tunresolved ->
              (* 2a. unresolved: accept and record the concrete type *)
              ok (venv'', params' @ [(param_name, call_param_type)])
            | expected ->
              (* 2b. resolved: type check against the concrete type *)
              if call_param_type = expected
              then ok (venv'', params' @ [(param_name, expected)])
              else Error.error_at pos
                (Error.Msg.type_mismatch
                  ~expected:(to_string expected)
                  ~got:(to_string call_param_type))
          )
          (ok (venv, []))
          call_params
          def_params
      in
      (* 3. type check return *)
      let body_venv = List.fold_left
        (fun env (name, ty) -> Env.add_local name ty env)
        venv'
        resolved_params
      in
      (* translate the body with resolved param types in scope *)
      let* (_, body_type) = translate body_venv body_expr in
      let* resolved_return = match return_type with
        | Tunresolved ->
          (* 3a. first call: infer return type from body *)
          ok body_type
        | expected ->
          (* 3b. subsequent calls: check body type matches *)
          if body_type = expected
          then ok expected
          else Error.error_at pos
            (Error.Msg.type_mismatch
              ~expected:(to_string expected)
              ~got:(to_string body_type))
      in
      (* 4. update env with the now-resolved function type *)
      let resolved_fun = TfunctionDef (resolved_params, body_expr, resolved_return) in
      let venv_with_resolved_fun = Env.add_local fname resolved_fun venv' in
      ok (venv_with_resolved_fun, resolved_return)
  | _ ->
    Error.error_at pos (Error.Msg.var_not_found fname)

One limitation worth mentioning: the first call wins. If the first call passes a value with the wrong type for the intended use, the type checker won't catch it -- that's what type annotations are for. They're coming once Tsonnet reaches a reasonable level of Jsonnet compliance.

Proof that it (mostly) works

Ta-da!

$ dune exec -- tsonnet samples/functions/positional_params.jsonnet
6

$ dune exec -- tsonnet samples/functions/multiline.jsonnet
[ 6, 7 ]

$ dune exec -- tsonnet samples/semantics/invalid_function_call_type.jsonnet
ERROR: samples/semantics/invalid_function_call_type.jsonnet:2:18 Expected type Number, got String

2: my_function(3) && my_function("oops")
   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

The error could be more precise -- ideally it would point at the offending argument rather than the entire expression. That's a detail I'll get to later; not something that adds much right now.

The cram tests:

diff --git a/test/cram/functions.t b/test/cram/functions.t
new file mode 100644
index 0000000..0ad7e43
--- /dev/null
+++ b/test/cram/functions.t
@@ -0,0 +1,5 @@
+  $ tsonnet ../../samples/functions/positional_params.jsonnet
+  6
+
+  $ tsonnet ../../samples/functions/multiline.jsonnet
+  [ 6, 7 ]
diff --git a/test/cram/semantics.t b/test/cram/semantics.t
index de60a1b..c9a790e 100644
--- a/test/cram/semantics.t
+++ b/test/cram/semantics.t
@@ -289,3 +322,16 @@
                  ^^
   ---
   1
+
+  $ tsonnet ../../samples/semantics/invalid_function_call_type.jsonnet
+  ERROR: ../../samples/semantics/invalid_function_call_type.jsonnet:2:18 Expected type Number, got String
+  
+  2: my_function(3) && my_function("oops")
+     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  [1]
+

Conclusion

Basic functions are in: positional parameters, multiline bodies, arity checks, and type inference that resolves on the first call. Not bad for a first round.

Here is the entire diff.

Next up, we make function calls a little more forgiving — default arguments are coming.

Thanks for reading Bit Maybe Wise! First caller wins the type. Subscribe to lock in yours.

Photo by Annie Spratt on Unsplash

ABEND dump #26

Hercules Lemke Merscher — Wed, 08 Apr 2026 21:27:00 +0000

Welcome to the ABEND dump #26!

Don't know what is an “ABEND dump”?! I'm glad you asked.

You can check the previous ABEND dump here:

Hercules Lemke Merscher

Feb 28

ABEND dump #25

#abenddump

2 min read

Tech boss uses AI and ChatGPT to create cancer vaccine for his dying dog

This is WILD! This is what I want AI for, a truly relevant use case. I feel like there's so much potential for applications in medicine. What a time to be alive!

I know, I know. There's plenty of reasons to be wary about AI, but let's be positive for a moment, this is truly good and magical!

And speaking of which...

Explore Sid's Data

Sid Sijbrandij, former GitLab CEO, is fighting an osteosarcoma (a rare bone cancer). He's open-sourcing his experimental treatment data to help advancing cancer research.

Sid rocks!

The internet was weeks away from disaster and no one knew

How Pokémon Go is giving delivery robots an inch-perfect view of the world

"When the product is free, you are the product" -- in the AI era, this sentence never made more sense than now.

Systems Thinking is Brain Rot for Analysts

This got me thinking.

Building a Second Brain

I forgot to recommend this book in the previous issue.

Last year I got hooked into the Zettelkasten system to organize my thoughts in a digital world, but it was simply too complex to grasp, and what really made it work for me was following the PARA Method presented by Tiago Forte in Building a Second Brain book.

I may write more about it here, eventually.

There's a version of this book written in portuguese too, which was the one I read.

Thanks for reading the ABEND dump! AI curing cancer, robots delivering pizza, open-source treatment data -- what a time to be alive. Subscribe and we'll keep marveling at it together.

Tsonnet #34 - Dabbling with untouched bindings

Hercules Lemke Merscher — Sun, 15 Mar 2026 16:26:39 +0000

Welcome to the Tsonnet series!

If you're not following along, check out how it all started in the first post of the series.

In the previous post, we wrapped up the arithmetic tutorial:

Tsonnet #33 - The arithmetic tutorial must go on

Hercules Lemke Merscher ・ Mar 13

#tsonnet #jsonnet #compiler

This time, before proceeding to cover the next tutorial, I'm going to revisit one laziness aspect: the evaluation (or no-evaluation) of untouched bindings.

Warnings, not errors

Up until now, Tsonnet would hard-error on cyclic references regardless of whether the offending variable was ever touched. That's a bit heavy-handed. Jsonnet is lazily evaluated -- if a variable has a cycle but is never used, the program should still run. We should warn, not panic. For example:

// samples/variables/untouched_variable.jsonnet
local a = 1, b = 42;
b

Jsonnet behaves like this:

$ jsonnet samples/variables/untouched_variable.jsonnet
42

Jsonnet does nothing to alert the programmer that something is unused. Maybe that belongs to a linter, but the compiler not even warning is a bad experience, IMHO.

The same logic applies to unused variables: they're suspicious, but they shouldn't crash anything.

// samples/objects/untouched_field.jsonnet
local result = {
    a: 1,
    b: 42,
};
result.b

$ jsonnet samples/objects/untouched_field.jsonnet
42

Let's work through each of these in order.

Warn on cyclic refs for unused variables

The first thing we need is a way to tell which variables are actually reachable from the body of a local expression. For that, I added collect_free_idents and reachable_bindings to the type checker:

let rec collect_free_idents = function
  | Unit | Null _ | Number _ | String _ | Bool _ -> []
  | Ident (_, name) -> [name]
  | Array (_, exprs) -> List.concat_map collect_free_idents exprs
  | BinOp (_, _, e1, e2) -> collect_free_idents e1 @ collect_free_idents e2
  | UnaryOp (_, _, e) -> collect_free_idents e
  | Seq exprs -> List.concat_map collect_free_idents exprs
  | ParsedObject (_, entries) ->
    List.concat_map (function
      | ObjectField (_, e) -> collect_free_idents e
      | ObjectExpr e -> collect_free_idents e
    ) entries
  | ObjectFieldAccess (_, _, exprs) -> List.concat_map collect_free_idents exprs
  | IndexedExpr (_, name, e) -> name :: collect_free_idents e
  | Local (_, vars) -> List.concat_map (fun (_, e) -> collect_free_idents e) vars
  | _ -> []

let reachable_bindings bindings initial_idents =
  let rec go visited = function
    | [] -> visited
    | name :: rest ->
      if List.mem name visited
      then go visited rest
      else
        let new_idents =
          match List.assoc_opt name bindings with
          | Some expr -> collect_free_idents expr
          | None -> []
        in
        go (name :: visited) (new_idents @ rest)
  in
  go [] initial_idents

collect_free_idents walks an expression and collects every identifier referenced. reachable_bindings does a simple graph traversal starting from the identifiers used in the body, following variable references transitively. If a binding is never reachable from the body, it's unused.

I'm delegating part of what used to be Local-processing into the translate_seq function, where the logic actually runs, to keep things tidy:

diff --git a/lib/type.ml b/lib/type.ml
index fbe68b1..2f4bf41 100644
--- a/lib/type.ml
+++ b/lib/type.ml
@@ -154,23 +187,15 @@ let rec translate venv expr =
     )
   | ParsedObject (pos, entries) -> translate_object venv pos entries
   | ObjectFieldAccess (pos, scope, chain) -> translate_object_field_access venv pos scope chain
-  | Local (pos, vars) ->
+  | Local (_pos, vars) ->
     let venv' = List.fold_left
       (* Adds an expr to the env to be evaluated at a later point in time (when required) *)
       (fun venv (varname, var_expr) -> Env.add_local varname (Lazy var_expr) venv)
       venv
       vars
-    in
-    let* _ = List.fold_left
-      (fun ok' (varname, _) -> ok' >>= fun _ -> check_cyclic_refs venv' varname [] pos)
-      (ok ())
-      vars
     in ok (venv', Tunit)
   | Seq exprs ->
-    List.fold_left
-      (fun acc expr -> acc >>= fun (venv, _) -> translate venv expr)
-      (ok (venv, Tunit))
-      exprs
+    translate_seq venv exprs
   | BinOp (pos, op, e1, e2) ->
     translate_bin_op venv pos op e1 e2
   | UnaryOp (pos, op, expr) ->

and translate_seq venv exprs =
  let rec collect_locals = function
    | Local (pos, vars) :: rest ->
      let (all_vars, body) = collect_locals rest in
      (List.map (fun v -> (pos, v)) vars @ all_vars, body)
    | rest -> ([], rest)
  in
  let rec go venv = function
    | [] -> ok (venv, Tunit)
    | [expr] -> translate venv expr
    | (Local _ :: _) as exprs ->
      let (all_pos_vars, body) = collect_locals exprs in
      let all_vars = List.map snd all_pos_vars in
      let venv' = List.fold_left
        (fun venv (varname, var_expr) ->
          Env.add_local varname (Lazy var_expr) venv
        )
        venv
        all_vars
      in
      let body_idents = List.concat_map collect_free_idents body in
      let reachable = reachable_bindings all_vars body_idents in
      let* () = List.fold_left
        (fun acc (pos, (varname, _)) -> acc >>= fun () ->
          match check_cyclic_refs venv' varname [] pos with
          | Ok () -> ok ()
          | Error msg ->
            if List.mem varname reachable
            then error msg
            else (Error.warn (Error.Msg.type_cyclic_reference varname) pos; ok ())
        )
        (ok ())
        all_pos_vars
      in
      go venv' body
    | expr :: rest ->
      let* (venv', _) = translate venv expr in
      go venv' rest
  in
  go venv exprs

The key part: if a cyclic reference involves a variable that's reachable from the body, we still error. If it's unreachable, we just warn and move on. Here's what it looks like in practice:

$ dune exec -- tsonnet samples/variables/untouched_invalid_variable.jsonnet
Warning: .../untouched_invalid_variable.jsonnet:1:31 Cyclic reference found for c

1: local a = 1, b = a, c = d, d = c;
   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Warning: .../untouched_invalid_variable.jsonnet:1:24 Cyclic reference found for d

1: local a = 1, b = a, c = d, d = c;
   ^^^^^^^^^^^^^^^^^^^^^^^^^^
1

c and d have a cycle between them, but b is what the program actually evaluates. So we warn, and produce the result.

Warn on unused variables

With reachability analysis in place, unused variable warnings follow naturally. A variable is unused if it's not in the reachable set. Adding that to translate_seq:

diff --git a/lib/type.ml b/lib/type.ml
index 2f4bf41..0e7a680 100644
--- a/lib/type.ml
+++ b/lib/type.ml
@@ -247,6 +247,11 @@ and translate_seq venv exprs =
       (* Determine which vars are reachable from the body *)
       let body_idents = List.concat_map collect_free_idents body in
       let reachable = reachable_bindings all_vars body_idents in
+      (* Warn on unused variables *)
+      List.iter (fun (pos, (varname, _)) ->
+        if not (List.mem varname reachable)
+        then Error.warn (Error.Msg.type_unused_variable varname) pos
+      ) all_pos_vars;
       (* Check cycles: error for reachable, warn for unreachable *)
       let* () = List.fold_left
         (fun acc (pos, (varname, _)) -> acc >>= fun () ->
@@ -255,7 +260,7 @@ and translate_seq venv exprs =
           | Error msg ->
             if List.mem varname reachable
             then error msg
-            else (prerr_endline ("Warning: " ^ msg); ok ())
+            else (Error.warn (Error.Msg.type_cyclic_reference varname) pos; ok ())
         )
         (ok ())
         all_pos_vars

I also refactored the warning infrastructure a bit. Instead of calling prerr_endline inline, there's now a proper Error.warn function:

diff --git a/lib/error.ml b/lib/error.ml
index ac8ae48..508ae0c 100644
--- a/lib/error.ml
+++ b/lib/error.ml
@@ -21,6 +21,7 @@ module Msg = struct

   (* Type checker messages *)
   let type_cyclic_reference varname = "Cyclic reference found for " ^ varname
+  let type_unused_variable varname = "Unused variable " ^ varname
   let type_non_indexable_value ty = ty ^ " is a non indexable value"
   let type_expected_integer_index ty = "Expected Integer index, got " ^ ty
   let type_invalid_expr expr = "Invalid type " ^ expr
@@ -104,3 +105,8 @@ let trace (err: string) (pos: position) : (string, string) result =
     (fun content -> ok (Printf.sprintf "%s\n%s" (trace_file_position err pos) content))

 let error_at pos = fun msg -> trace msg pos >>= error
+
+let warn msg pos =
+  match trace msg pos with
+  | Ok formatted -> prerr_endline ("Warning: " ^ formatted)
+  | Error _ -> prerr_endline ("Warning: " ^ msg)
diff --git a/lib/error.mli b/lib/error.mli
index 0bdd708..c09b930 100644
--- a/lib/error.mli
+++ b/lib/error.mli
@@ -18,6 +18,7 @@ module Msg : sig

   (* Type checker messages *)
   val type_cyclic_reference : string -> string
+  val type_unused_variable : string -> string
   val type_non_indexable_value : string -> string
   val type_expected_integer_index : string -> string
   val type_invalid_expr : string -> string
@@ -37,3 +38,4 @@ end

 val trace : string -> Ast.position -> (string, string) result
 val error_at : Ast.position -> string -> ('a, string) result
+val warn : string -> Ast.position -> unit

Much cleaner. Let's see it in action:

$ dune exec -- tsonnet samples/variables/untouched_variable.jsonnet
Warning: .../untouched_variable.jsonnet:1:0 Unused variable a

1: local a = 1, b = 42;
   ^^^^^^^^^^^^^^^^^^^^
42

a is defined but never used. The program still returns 42.

Warn on untouched object fields

Variables were the easy part. Objects are more involved because we're dealing with two separate phases -- the type checker and the interpreter -- and both need to handle cyclic field references gracefully.

The approach is the same: if a cyclic object field is never accessed during evaluation, warn instead of error. The tricky bit is detecting "accessed during evaluation" correctly.

Both modules now track which fields are actively being evaluated using a mutable ObjectFields set:

(* In interpreter.ml *)
let evaluating_fields = ref ObjectFields.empty

(* In type.ml *)
let translating_fields = ref ObjectFields.empty

When we start evaluating a field, we add it to the set. When we're done (or on error), we remove it. If we try to evaluate a field already in the set -- cycle detected:

diff --git a/lib/interpreter.ml b/lib/interpreter.ml
index fe248b9..391c1e2 100644
--- a/lib/interpreter.ml
+++ b/lib/interpreter.ml
@@ -21,9 +23,17 @@ let rec interpret env expr =
   | ObjectPtr _ as obj_ptr -> ok (env, obj_ptr)
   | ObjectFieldAccess (pos, scope, chain) -> interpret_object_field_access env (pos, scope, chain)
   | Ident (pos, varname) ->
-    Env.find_var varname env
-      ~succ:(fun env' expr -> interpret env' expr)
-      ~err:(Error.error_at pos)
+    if ObjectFields.mem varname !evaluating_fields then
+      Error.error_at pos (Error.Msg.type_cyclic_reference varname)
+    else begin
+      evaluating_fields := ObjectFields.add varname !evaluating_fields;
+      let result = Env.find_var varname env
+        ~succ:(fun env' expr -> interpret env' expr)
+        ~err:(Error.error_at pos)
+      in
+      evaluating_fields := ObjectFields.remove varname !evaluating_fields;
+      result
+    end
   | BinOp (pos, op, e1, e2) -> interpret_bin_op env (pos, op, e1, e2)
   | UnaryOp (pos, op, expr) ->
     let* (env', expr') = interpret env expr in
@@ -201,9 +211,18 @@ and interpret_object_field_access env (pos, scope, chain_exprs) =
       match field_expr with
       | String (pos, field) | Ident (pos, field) ->
         let* (obj_id, field_env) = get_obj_id in
-        Env.get_obj_field field obj_id field_env
-          ~succ:(interpret)
-          ~err:(Error.error_at pos)
+        let key = Env.uniq_field_ident obj_id field in
+        if ObjectFields.mem key !evaluating_fields then
+          Error.error_at pos (Error.Msg.type_cyclic_reference key)
+        else begin
+          evaluating_fields := ObjectFields.add key !evaluating_fields;
+          let result = Env.get_obj_field field obj_id field_env
+            ~succ:(interpret)
+            ~err:(Error.error_at pos)
+          in
+          evaluating_fields := ObjectFields.remove key !evaluating_fields;
+          result
+        end
       | Number _ as index_expr ->
         (* Handle array/string indexing: prev_expr[number] *)
         Result.fold
@@ -223,19 +242,27 @@ and interpret_runtime_object env (pos, obj_env, fields) =
 and interpret_runtime_object_fields obj_env fields =
   match Env.Map.find_opt "self" obj_env with
   | Some (ObjectPtr (obj_id, _)) ->
-    let* field_list =
+    let field_list =
       ObjectFields.fold
         (fun field acc ->
-          let* evaluated_fields = acc in
           let key = Env.uniq_field_ident obj_id field in
-          match Env.Map.find_opt key obj_env with
-          | Some expr ->
-            let* (_, evaluated) = interpret obj_env expr in
-            ok ((field, evaluated) :: evaluated_fields)
-          | None -> acc
+          if ObjectFields.mem key !evaluating_fields then
+            acc (* Skip: cyclic reference detected *)
+          else
+            match Env.Map.find_opt key obj_env with
+            | Some expr ->
+              evaluating_fields := ObjectFields.add key !evaluating_fields;
+              let result =
+                match interpret obj_env expr with
+                | Ok (_, evaluated) -> (field, evaluated) :: acc
+                | Error _ -> acc
+              in
+              evaluating_fields := ObjectFields.remove key !evaluating_fields;
+              result
+            | None -> acc
         )
         fields
-        (ok [])
+        []
     in ok (List.rev field_list)
   | _ -> ok []

For object fields that are never accessed, the type checker now warns instead of erroring. translate_object was changed to iterate over entries and emit warnings rather than propagate errors:

diff --git a/lib/type.ml b/lib/type.ml
index 0e7a680..8b41545 100644
--- a/lib/type.ml
+++ b/lib/type.ml
@@ -152,13 +154,21 @@ let rec translate venv expr =
   | Number _ -> ok (venv, Tnumber)
   | String _ -> ok (venv, Tstring)
   | Ident (pos, varname) ->
-    Env.find_var varname venv
-      ~succ:(fun venv ty ->
-        match ty with
-        | Lazy expr -> translate venv expr
-        | _ -> ok (venv, ty)
-      )
-      ~err:(Error.error_at pos)
+    if ObjectFields.mem varname !translating_fields then
+      Error.error_at pos (Error.Msg.type_cyclic_reference varname)
+    else begin
+      translating_fields := ObjectFields.add varname !translating_fields;
+      let result = Env.find_var varname venv
+        ~succ:(fun venv ty ->
+          match ty with
+          | Lazy expr -> translate venv expr
+          | _ -> ok (venv, ty)
+        )
+        ~err:(Error.error_at pos)
+      in
+      translating_fields := ObjectFields.remove varname !translating_fields;
+      result
+    end
   | Array (_pos, elems) ->
     (* As of now, we compare each element and if all have the same type,
       it is an array of this type, otherwise it will be an array of any.
@@ -298,32 +308,36 @@ and translate_object venv pos entries =
     entries
   in

-  (* Check for cyclical references among object fields *)
-  let* () = List.fold_left
-      (fun ok' entry -> ok' >>= fun _ ->
-        match entry with
-        | ObjectField (attr, _) ->
-          check_cyclic_refs venv (Env.uniq_field_ident obj_id attr) [] pos
-        | _ -> ok'
-      )
-      (ok ())
-      entries
-  in
+  (* Check for cyclical references among object fields
+    (warn, don't error when the reference is not part of
+    the evaluation tree)
+  *)
+  List.iter
+    (fun entry ->
+      match entry with
+      | ObjectField (attr, _) ->
+        (match check_cyclic_refs venv (Env.uniq_field_ident obj_id attr) [] pos with
+        | Ok () -> ()
+        | Error _ -> Error.warn (Error.Msg.type_cyclic_reference (Env.uniq_field_ident obj_id attr)) pos)
+      | _ -> ()
+    )
+    entries;

-  (* Then translate object fields *)
-  let* entry_types = List.fold_left
-    (fun result entry ->
-      let* entries' = result in
+  (* Translate object fields lazily: warn on errors, skip invalid fields *)
+  let entry_types = List.fold_left
+    (fun entries' entry ->
       match entry with
       | ObjectField (attr, _) ->
-        let* (_, entry_ty) = Env.get_obj_field attr obj_id venv
+        (match Env.get_obj_field attr obj_id venv
           ~succ:translate_lazy
           ~err:(Error.error_at pos)
-        in ok (entries' @ [TobjectField (attr, entry_ty)])
+        with
+        | Ok (_, entry_ty) -> entries' @ [TobjectField (attr, entry_ty)]
+        | Error _ -> entries')
       | _ ->
-        result
+        entries'
     )
-    (ok [])
+    []
     entries
   in
   (* Remove self and $ from the environment to prevent leaking *)
@@ -372,9 +386,18 @@ and translate_object_field_access venv pos scope chain_exprs =
       match field_expr with
       | String (_, field) | Ident (_, field) ->
         let* obj_id = get_obj_id in
-        Env.get_obj_field field obj_id venv
-          ~succ:translate_lazy
-          ~err:(Error.error_at pos)
+        let key = Env.uniq_field_ident obj_id field in
+        if ObjectFields.mem key !translating_fields then
+          Error.error_at pos (Error.Msg.type_cyclic_reference key)
+        else begin
+          translating_fields := ObjectFields.add key !translating_fields;
+          let result = Env.get_obj_field field obj_id venv
+            ~succ:translate_lazy
+            ~err:(Error.error_at pos)
+          in
+          translating_fields := ObjectFields.remove key !translating_fields;
+          result
+        end
       | Number (pos, _) ->
         (* Handle numeric indexing of strings and arrays *)
         (match prev_ty with
@@ -429,4 +452,5 @@ let check (config : Config.t) expr  =
   else
     let* _ = translate Env.empty expr in
     Env.Id.reset ();
+    translating_fields := ObjectFields.empty;
     ok expr

Here's a sample that demonstrates the distinction. When we only access result.b, the cyclic c/d pair just produces warnings:

// samples/objects/untouched_invalid_field.jsonnet
local result = {
    a: 1,
    b: self.a,
    c: self.d,
    d: self.c
};
result.b

$ dune exec -- tsonnet samples/objects/untouched_invalid_field.jsonnet
Warning: .../untouched_invalid_field.jsonnet:1:0 Unused variable result

...

Warning: .../untouched_invalid_field.jsonnet:1:15 Cyclic reference found for 1->c

...

Warning: .../untouched_invalid_field.jsonnet:1:15 Cyclic reference found for 1->d

...
1

Meanwhile, if a cyclic field is actually accessed at runtime, it still errors hard:

// samples/semantics/invalid_object_with_cyclic_field.jsonnet
{
    a: 1,
    b: self.c,
    c: self.b,
}

$ dune exec -- tsonnet samples/semantics/invalid_object_with_cyclic_field.jsonnet
Warning: .../invalid_object_with_cyclic_field.jsonnet:1:0 Cyclic reference found for 1->b
...
.../invalid_object_with_cyclic_field.jsonnet:3:12 Cyclic reference found for 1->c
...
[1]

The type checker warns (because it doesn't know at type-check time which fields will be accessed), but the interpreter finds the cycle at runtime and errors properly.

Warn on cyclic refs for untouched object fields

The previous changes got the type checker side right, but the interpreter was still getting it wrong. When rendering an object, interpret_runtime_object_fields was folding into a plain list and silently skipping any field that errored -- including cyclic ones. So if you did access a cyclic field at runtime, you'd get an empty result instead of an error. Not great.

The fix is straightforward: go back to a monadic fold and let errors propagate normally. The cycle detection in interpret_object_field_access already handles the "is this field in a cycle?" question via evaluating_fields -- interpret_runtime_object_fields doesn't need to second-guess it.

diff --git a/lib/interpreter.ml b/lib/interpreter.ml
index 391c1e2..60f8a72 100644
--- a/lib/interpreter.ml
+++ b/lib/interpreter.ml
@@ -242,27 +242,19 @@ and interpret_runtime_object env (pos, obj_env, fields) =
 and interpret_runtime_object_fields obj_env fields =
   match Env.Map.find_opt "self" obj_env with
   | Some (ObjectPtr (obj_id, _)) ->
-    let field_list =
+    let* field_list =
       ObjectFields.fold
         (fun field acc ->
+          let* evaluated_fields = acc in
           let key = Env.uniq_field_ident obj_id field in
-          if ObjectFields.mem key !evaluating_fields then
-            acc (* Skip: cyclic reference detected *)
-          else
-            match Env.Map.find_opt key obj_env with
-            | Some expr ->
-              evaluating_fields := ObjectFields.add key !evaluating_fields;
-              let result =
-                match interpret obj_env expr with
-                | Ok (_, evaluated) -> (field, evaluated) :: acc
-                | Error _ -> acc
-              in
-              evaluating_fields := ObjectFields.remove key !evaluating_fields;
-              result
-            | None -> acc
+          match Env.Map.find_opt key obj_env with
+          | Some expr ->
+            let* (_, evaluated) = interpret obj_env expr in
+            ok ((field, evaluated) :: evaluated_fields)
+          | None -> acc
         )
         fields
-        []
+        (ok [])
     in ok (List.rev field_list)
   | _ -> ok []

There's also a small fix in the type checker's translate_object_field_access. When chaining into a TruntimeObject, the field lookup was using the outer venv -- meaning self and $ weren't in scope. The fix builds a proper field_venv before looking up the field, the same way the interpreter does it:

diff --git a/lib/type.ml b/lib/type.ml
index 8b41545..200f533 100644
--- a/lib/type.ml
+++ b/lib/type.ml
@@ -376,22 +376,31 @@ and translate_object_field_access venv pos scope chain_exprs =
     (fun acc field_expr ->
       let* (venv, prev_ty) = acc in

-      let get_obj_id =
+      let get_obj_id_and_env =
         match prev_ty with
-        | TobjectPtr (obj_id, _) -> ok obj_id
-        | TruntimeObject (obj_id, _) -> ok obj_id
+        | TobjectPtr (obj_id, _) -> ok (obj_id, venv)
+        | TruntimeObject (obj_id, _) ->
+          (* TODO: we haven't included the environment in TruntimeObject yet.
+             It must be done such as Ast.RuntimeObject *)
+          let field_venv =
+            Env.add_local "self" (TobjectPtr (obj_id, TobjectSelf)) venv
+          in
+          let field_venv =
+            Env.add_local_when_not_present "$" (TobjectPtr (obj_id, TobjectTopLevel)) field_venv |> fst
+          in
+          ok (obj_id, field_venv)
         | _ -> Error.error_at pos Error.Msg.must_be_object
       in

       match field_expr with
       | String (_, field) | Ident (_, field) ->
-        let* obj_id = get_obj_id in
+        let* (obj_id, field_venv) = get_obj_id_and_env in
         let key = Env.uniq_field_ident obj_id field in
         if ObjectFields.mem key !translating_fields then
           Error.error_at pos (Error.Msg.type_cyclic_reference key)
         else begin
           translating_fields := ObjectFields.add key !translating_fields;
-          let result = Env.get_obj_field field obj_id venv
+          let result = Env.get_obj_field field obj_id field_venv
             ~succ:translate_lazy
             ~err:(Error.error_at pos)
           in

I sprinkled a TODO here because I don't want to do this refactoring now. XD

Everything is captured in the cram tests:

diff --git a/samples/semantics/valid_object_with_cyclic_field.jsonnet b/samples/semantics/invalid_object_with_cyclic_field.jsonnet
similarity index 100%
rename from samples/semantics/valid_object_with_cyclic_field.jsonnet
rename to samples/semantics/invalid_object_with_cyclic_field.jsonnet
diff --git a/test/cram/objects.t b/test/cram/objects.t
index b200032..e7ae092 100644
--- a/test/cram/objects.t
+++ b/test/cram/objects.t
@@ -24,7 +24,7 @@

   $ tsonnet ../../samples/objects/untouched_field.jsonnet
   Warning: ../../samples/objects/untouched_field.jsonnet:1:0 Unused variable result
-  
+
   1: local result = {
      ^^^^^^^^^^^^^^^^
   2:     a: 1,
@@ -32,3 +32,39 @@
   3:     b: 42,
      ^^^^^^^^^^
   42
+
+
+  $ tsonnet ../../samples/objects/untouched_invalid_field.jsonnet
+  Warning: ../../samples/objects/untouched_invalid_field.jsonnet:1:0 Unused variable result
+
+  1: local result = {
+     ^^^^^^^^^^^^^^^^
+  2:     a: 1,
+     ^^^^^^^^^
+  3:     b: self.a,
+     ^^^^^^^^^^^^^^
+  4:     c: self.d,
+     ^^^^^^^^^^^^^^
+  5:     d: self.c
+     ^^^^^^^^^^^^^
+  Warning: ../../samples/objects/untouched_invalid_field.jsonnet:1:15 Cyclic reference found for 1->c
+
+  1: local result = {
+     ^^^^^^^^^^^^^^^^
+  2:     a: 1,
+
+  3:     b: self.a,
+
+  4:     c: self.d,
+
+  Warning: ../../samples/objects/untouched_invalid_field.jsonnet:1:15 Cyclic reference found for 1->d
+
+  1: local result = {
+     ^^^^^^^^^^^^^^^^
+  2:     a: 1,
+
+  3:     b: self.a,
+
+  4:     c: self.d,
+
+  1
diff --git a/test/cram/semantics.t b/test/cram/semantics.t
index 4513915..c98851d 100644
--- a/test/cram/semantics.t
+++ b/test/cram/semantics.t
@@ -52,7 +52,11 @@
      ^^^^^^^^^^^^^^^^
   4:     local c = b,
      ^^^^^^^^^^^^^^^^
-  {}
+  ../../samples/semantics/invalid_binding_cycle_object_locals.jsonnet:4:14 Cyclic reference found for b
+  
+  4:     local c = b,
+     ^^^^^^^^^^^^^^^^
+  [1]

   $ tsonnet ../../samples/semantics/invalid_binding_cycle_binop.jsonnet
   ../../samples/semantics/invalid_binding_cycle_binop.jsonnet:2:10 Cyclic reference found for a
@@ -92,7 +96,11 @@
      ^^^^^^^^^^^^^^
   3:     b: self.a,
      ^^^^^^^^^^^^^^
-  {}
+  ../../samples/semantics/invalid_binding_cycle_object_fields.jsonnet:2:12 Cyclic reference found for 1->b
+  
+  2:     a: self.b,
+     ^^^^^^^^^^^^^^
+  [1]

   $ tsonnet ../../samples/semantics/invalid_binding_cycle_object_nested_field.jsonnet
   Warning: ../../samples/semantics/invalid_binding_cycle_object_nested_field.jsonnet:1:0 Cyclic reference found for 1->a
@@ -135,7 +143,11 @@
               ^^^^^^^^^
   4:     },

-  { "a": {} }
+  ../../samples/semantics/invalid_binding_cycle_object_nested_field.jsonnet:3:17 Cyclic reference found for 1->b
+  
+  3:         value: $.b
+     ^^^^^^^^^^^^^^^^^^
+  [1]

   $ tsonnet ../../samples/semantics/invalid_binding_cycle_outer_object_fields.jsonnet
   Warning: ../../samples/semantics/invalid_binding_cycle_outer_object_fields.jsonnet:1:0 Cyclic reference found for 1->a
@@ -154,7 +166,11 @@
      ^^^^^^^^^^^
   3:     b: $.a,
      ^^^^^^^^^^^
-  {}
+  ../../samples/semantics/invalid_binding_cycle_outer_object_fields.jsonnet:2:9 Cyclic reference found for 1->b
+  
+  2:     a: $.b,
+     ^^^^^^^^^^^
+  [1]

   $ tsonnet ../../samples/semantics/invalid_binding_cycle_object_field_and_local.jsonnet
   Warning: ../../samples/semantics/invalid_binding_cycle_object_field_and_local.jsonnet:1:0 Cyclic reference found for 1->b
@@ -165,7 +181,11 @@
      ^^^^^^^^^^^^^^^^^^^^^
   3:     b: a,
      ^^^^^^^^^
-  {}
+  ../../samples/semantics/invalid_binding_cycle_object_field_and_local.jsonnet:3:7 Cyclic reference found for a
+  
+  3:     b: a,
+     ^^^^^^^^^
+  [1]

   $ tsonnet ../../samples/semantics/invalid_binding_cycle_indexed_field.jsonnet
   Warning: ../../samples/semantics/invalid_binding_cycle_indexed_field.jsonnet:1:0 Cyclic reference found for 1->arr
@@ -184,10 +204,14 @@
      ^^^^^^^^^^^^^^^^^^^^^^
   3:     first: self.arr[0]
      ^^^^^^^^^^^^^^^^^^^^^^
-  {}
+  ../../samples/semantics/invalid_binding_cycle_indexed_field.jsonnet:2:15 Cyclic reference found for 1->first
+  
+  2:     arr: [self.first],
+     ^^^^^^^^^^^^^^^^^^^^^^
+  [1]

-  $ tsonnet ../../samples/semantics/valid_object_with_cyclic_field.jsonnet
-  Warning: ../../samples/semantics/valid_object_with_cyclic_field.jsonnet:1:0 Cyclic reference found for 1->b
+  $ tsonnet ../../samples/semantics/invalid_object_with_cyclic_field.jsonnet
+  Warning: ../../samples/semantics/invalid_object_with_cyclic_field.jsonnet:1:0 Cyclic reference found for 1->b

   1: {
      ^
@@ -197,7 +221,7 @@
      ^^^^^^^^^^^^^^
   4:     c: self.b,
      ^^^^^^^^^^^^^^
-  Warning: ../../samples/semantics/valid_object_with_cyclic_field.jsonnet:1:0 Cyclic reference found for 1->c
+  Warning: ../../samples/semantics/invalid_object_with_cyclic_field.jsonnet:1:0 Cyclic reference found for 1->c

   1: {
      ^
@@ -207,7 +231,11 @@
      ^^^^^^^^^^^^^^
   4:     c: self.b,
      ^^^^^^^^^^^^^^
-  { "a": 1 }
+  ../../samples/semantics/invalid_object_with_cyclic_field.jsonnet:3:12 Cyclic reference found for 1->c
+  
+  3:     b: self.c,
+     ^^^^^^^^^^^^^^
+  [1]

   $ tsonnet ../../samples/semantics/valid_object_access_non_cyclic_field.jsonnet
   Warning: ../../samples/semantics/valid_object_access_non_cyclic_field.jsonnet:1:0 Unused variable obj

One thing I noticed while working through the test cases: the sample that used to be called valid_object_with_cyclic_field.jsonnet is not actually valid -- it errors when the cyclic fields are accessed. Renamed it to invalid_object_with_cyclic_field.jsonnet. These things happen when you're naming files before you've implemented the feature that would tell you whether they're valid or not.

Conclusion

The reachability analysis for variables and the evaluating_fields tracking for objects both push in the same direction -- lean on lazy evaluation instead of fighting it. This is the nature of Jsonnet, and Tsonnet should embrace it.

You can check the entire diff here.

I think, after that, we can start playing with much more fun things: functions!

Thanks for reading Bit Maybe Wise! If you too believe a cycle you never touch shouldn't ruin your day, subscribe and let's keep being reasonably lenient together.

Photo by Sebastian Unrau on Unsplash

Tsonnet #33 - The arithmetic tutorial must go on

Hercules Lemke Merscher — Fri, 13 Mar 2026 10:04:57 +0000

Welcome to the Tsonnet series!

If you're not following along, check out how it all started in the first post of the series.

In the previous post, we added a full set of binary operators:

Hercules Lemke Merscher

Mar 5

Tsonnet #32 - != done, but getting there

#tsonnet #jsonnet #compiler

11 min read

We were almost done with the arithmetic tutorial. Two pieces were still missing: object merging, and division by zero error handling. Let's wrap those up.

Merging objects

The + operator is overloaded to act as an operator to merge two objects.

This sample file:

// samples/objects/merge.jsonnet
{ a: 1, b: 2 } + { b: 3, c: 4 }

Results in:

{ "a": 1, "b": 3, "c": 4 }

The right-hand side overrides the left-hand side fields.

The cram test looks like this:

diff --git a/test/cram/objects.t b/test/cram/objects.t
index 9c12260..bfb25bd 100644
--- a/test/cram/objects.t
+++ b/test/cram/objects.t
@@ -18,3 +18,6 @@

   $ tsonnet ../../samples/objects/toplevel_field_lookup_chain.jsonnet
   { "answer": { "value": 42 }, "answer_to_the_ultimate_question": 42 }
+
+  $ tsonnet ../../samples/objects/merge.jsonnet
+  { "a": 1, "b": 3, "c": 4 }

I'm adding a helper function in the Ast module to merge two lists of fields:

module Object = struct
  let merge_fields fields1 fields2 =
    (* fields2 comes after and has preference over fields1 *)
    let updated = List.map
      (fun (k, v) ->
        match List.assoc_opt k fields2 with
        | Some v' -> (k, v')
        | None -> (k, v)
      )
      fields1
    in
    (* (k,v) in fields2 not present in fields1 *)
    let new_fields = List.filter
      (fun (k, _) -> not (List.mem_assoc k fields1))
      fields2
    in
    (* then we merge *)
    updated @ new_fields
end

The type checker only needs to include the overloaded operation:

diff --git a/lib/type.ml b/lib/type.ml
index d553f5c..fbe68b1 100644
--- a/lib/type.ml
+++ b/lib/type.ml
@@ -321,6 +321,8 @@ and translate_bin_op venv pos op e1 e2 =
   | Add, _, Tstring | Add, Tstring, _ -> ok (venv'', Tstring)
   | Add, Tnumber, Tnumber -> ok (venv'', Tnumber)
   | Add, (Tarray _), (Tarray _) -> ok (venv'', Tarray Tany)
+  | Add, (Tobject _ | TruntimeObject _ | TobjectPtr _), (Tobject _ | TruntimeObject _ | TobjectPtr _) ->
+    ok (venv'', Tany)
   | Subtract, Tnumber, Tnumber -> ok (venv'', Tnumber)
   | Multiply, Tnumber, Tnumber -> ok (venv'', Tnumber)
   | Divide, Tnumber, Tnumber -> ok (venv'', Tnumber)

The interpreter implements the new interpret_object_merge_op function to deal with that, and we pattern-match in the interpret_bin_op function to add it:

diff --git a/lib/interpreter.ml b/lib/interpreter.ml
index ddc8041..24f0595 100644
--- a/lib/interpreter.ml
+++ b/lib/interpreter.ml
@@ -66,6 +66,19 @@ and interpret_array_concat_op env e1 e2 =
   | _ ->
     error Error.Msg.interp_invalid_concat

+and interpret_object_merge_op env pos e1 e2 =
+  let eval_object = function
+    | EvaluatedObject _ as obj -> ok (env, obj)
+    | RuntimeObject _ as obj -> interpret env obj
+    | _ -> error Error.Msg.invalid_binary_op
+  in
+  let* (_, e1') = eval_object e1 in
+  let* (_, e2') = eval_object e2 in
+  match e1', e2' with
+  | EvaluatedObject (_, fields1), EvaluatedObject (_, fields2) ->
+    ok (env, EvaluatedObject (pos, Object.merge_fields fields1 fields2))
+  | _ -> error Error.Msg.invalid_binary_op
+
 and interpret_array env (pos, exprs) =
   let* (env', evaluated_exprs) = List.fold_left
     (fun result expr ->
@@ -234,6 +247,8 @@ and interpret_bin_op env (pos, op, e1, e2) =
    | Add, (Array _ as v1), (Array _ as v2)  ->
      interpret_array_concat_op env2 v1 v2
+   | Add, (EvaluatedObject _ | RuntimeObject _ as v1), (EvaluatedObject _ | RuntimeObject _ as v2) ->
+     interpret_object_merge_op env2 pos v1 v2
    | In, (String _ | Ident _ as field), (EvaluatedObject _ | RuntimeObject (_, _, _) as obj) ->
      interpret_in_op env2 pos field obj
    | _, v1, v2 ->

Done!

dune exec -- tsonnet samples/objects/merge.jsonnet
{ "a": 1, "b": 3, "c": 4 }

Division by zero

Next we should deal with the division by zero error.

Here's how Jsonnet handles it:

$ jsonnet samples/errors/divide_by_zero.jsonnet
RUNTIME ERROR: Division by zero.
    samples/errors/divide_by_zero.jsonnet:1:1-6 $
    During evaluation

And here are the sample files and how I want it to look in Tsonnet:

diff --git a/samples/errors/divide_by_zero.jsonnet b/samples/errors/divide_by_zero.jsonnet
new file mode 100644
index 0000000..59a5d52
--- /dev/null
+++ b/samples/errors/divide_by_zero.jsonnet
@@ -0,0 +1 @@
+5 / 0
diff --git a/samples/errors/divide_by_zero_float.jsonnet b/samples/errors/divide_by_zero_float.jsonnet
new file mode 100644
index 0000000..20f3764
--- /dev/null
+++ b/samples/errors/divide_by_zero_float.jsonnet
@@ -0,0 +1 @@
+5 / 0.0
diff --git a/samples/errors/modulo_by_zero.jsonnet b/samples/errors/modulo_by_zero.jsonnet
new file mode 100644
index 0000000..be4046b
--- /dev/null
+++ b/samples/errors/modulo_by_zero.jsonnet
@@ -0,0 +1 @@
+5 % 0
diff --git a/samples/errors/modulo_by_zero_float.jsonnet b/samples/errors/modulo_by_zero_float.jsonnet
new file mode 100644
index 0000000..8f666b8
--- /dev/null
+++ b/samples/errors/modulo_by_zero_float.jsonnet
@@ -0,0 +1 @@
+5 % 0.0
diff --git a/test/cram/errors.t b/test/cram/errors.t
index 7c117b8..dfcac7e 100644
--- a/test/cram/errors.t
+++ b/test/cram/errors.t
@@ -93,9 +105,43 @@
   $ tsonnet ../../samples/errors/object_outer_most_ref_out_of_scope.jsonnet
   ../../samples/errors/object_outer_most_ref_out_of_scope.jsonnet:2:13 No top-level object found

   2: local _two = $.one + 1;
      ^^^^^^^^^^^^^^^^^^^^^^^
   [1]
+
+
+  $ tsonnet ../../samples/errors/divide_by_zero.jsonnet
+  ../../samples/errors/divide_by_zero.jsonnet:1:0 Division by zero
+  
+  1: 5 / 0
+     ^^^^^
+  [1]
+
+
+  $ tsonnet ../../samples/errors/divide_by_zero_float.jsonnet
+  ../../samples/errors/divide_by_zero_float.jsonnet:1:0 Division by zero
+  
+  1: 5 / 0.0
+     ^^^^^^^
+  [1]
+
+
+  $ tsonnet ../../samples/errors/modulo_by_zero.jsonnet
+  ../../samples/errors/modulo_by_zero.jsonnet:1:0 Division by zero
+  
+  1: 5 % 0
+     ^^^^^
+  [1]
+
+
+  $ tsonnet ../../samples/errors/modulo_by_zero_float.jsonnet
+  ../../samples/errors/modulo_by_zero_float.jsonnet:1:0 Division by zero
+  
+  1: 5 % 0.0
+     ^^^^^^^
+  [1]
+

Not a huge difference from the reference implementation, but I like seeing the faulty operation highlighted in the source — much easier to spot and fix.

Let's add the error message:

diff --git a/lib/error.ml b/lib/error.ml
index 8c6b53f..ac8ae48 100644
--- a/lib/error.ml
+++ b/lib/error.ml
@@ -29,6 +29,7 @@ module Msg = struct
   let type_invalid_lookup_key expr = "Invalid object lookup key: " ^ expr

   (* Interpreter messages *)
+  let interp_division_by_zero = "Division by zero"
   let interp_invalid_concat = "Invalid concatenation operation"
   let interp_invalid_lookup = "Invalid object lookup"
   let interp_cannot_interpret expr = Printf.sprintf "Expression %s cannot be interpreted" expr
diff --git a/lib/error.mli b/lib/error.mli
index 58d7e8e..0bdd708 100644
--- a/lib/error.mli
+++ b/lib/error.mli
@@ -26,6 +26,7 @@ module Msg : sig
   val type_invalid_lookup_key : string -> string

   (* Interpreter messages *)
+  val interp_division_by_zero : string
   val interp_invalid_concat : string
   val interp_invalid_lookup : string
   val interp_cannot_interpret : string -> string

The interpret_arith_op function only needs to pattern-match on Int and Float zero before the division — pretty simple. Have I mentioned how much I enjoy pattern matching?

diff --git a/lib/interpreter.ml b/lib/interpreter.ml
index 24f0595..fe248b9 100644
--- a/lib/interpreter.ml
+++ b/lib/interpreter.ml
@@ -280,6 +280,8 @@ and interpret_arith_op env (pos, bin_op, n1, n2) =
     ok (env, Number (pos, Float ((float_of_int a) *. b)))
   | Multiply, Number (_, Float a), Number (_, Float b) ->
     ok (env, Number (pos, Float (a *. b)))
+  | Divide, _, Number (_, n) when n = Int 0 || n = Float 0.0 ->
+    Error.error_at pos Error.Msg.interp_division_by_zero
   | Divide, Number (_, Int a), Number (_, Int b) ->
     ok (env, Number (pos, Float ((float_of_int a) /. (float_of_int b))))
   | Divide, Number (_, Float a), Number (_, Int b) ->
@@ -288,6 +290,8 @@ and interpret_arith_op env (pos, bin_op, n1, n2) =
     ok (env, Number (pos, Float ((float_of_int a) /. b)))
   | Divide, Number (_, Float a), Number (_, Float b) ->
     ok (env, Number (pos, Float (a /. b)))
+  | Modulo, _, Number (_, n) when n = Int 0 || n = Float 0.0 ->
+    Error.error_at pos Error.Msg.interp_division_by_zero
   | Modulo, Number (_, Int a), Number (_, Int b) ->
     ok (env, Number (pos, Int (a mod b)))
   | Modulo, Number (_, Float a), Number (_, Int b) ->

The guard clauses (when n = Int 0 || n = Float 0.0) catch both integer and float zero before the division cases get a chance to run.

Completing the tutorial

With those two additions in place, samples/tutorials/arith.jsonnet is now fully supported -- minus the string formatting bits I'm deliberately setting aside for later. Here's the file with those commented out:

{
  concat_array: [1, 2, 3] + [4],
  concat_string: '123' + 4,
  equality1: 1 == '1',
  equality2: [{}, { x: 3 - 1 }]
             == [{}, { x: 2 }],
  ex1: 1 + 2 * 3 / (4 + 5),
  // Bitwise operations first cast to int.
  ex2: self.ex1 | 3,
  // Modulo operator.
  ex3: self.ex1 % 2,
  // Boolean logic
  ex4: (4 > 3) && (1 <= 3) || false,
  // Mixing objects together
  obj: { a: 1, b: 2 } + { b: 3, c: 4 },
  // Test if a field is in an object
  obj_member: 'foo' in { foo: 1 },
//   // String formatting
//   str1: 'The value of self.ex2 is '
//         + self.ex2 + '.',
//   str2: 'The value of self.ex2 is %g.'
//         % self.ex2,
//   str3: 'ex1=%0.2f, ex2=%0.2f'
//         % [self.ex1, self.ex2],
//   // By passing self, we allow ex1 and ex2 to
//   // be extracted internally.
//   str4: 'ex1=%(ex1)0.2f, ex2=%(ex2)0.2f'
//         % self,
//   // Do textual templating of entire files:
//   str5: |||
//     ex1=%(ex1)0.2f
//     ex2=%(ex2)0.2f
//   ||| % self,
}

Running it:

dune exec -- tsonnet samples/tutorials/arith.jsonnet
{
  "concat_array": [ 1, 2, 3, 4 ],
  "concat_string": "1234",
  "equality1": false,
  "equality2": true,
  "ex1": 1.6666666666666665,
  "ex2": 3,
  "ex3": 1.6666666666666665,
  "ex4": true,
  "obj": { "a": 1, "b": 3, "c": 4 },
  "obj_member": true
}

String formatting is next on the list -- but there are more interesting features to tackle first, so I'm parking it for now.

Conclusion

Two small additions -- object merging and division by zero -- and the arithmetic tutorial is effectively done. The pattern-matching guard clauses made the zero-division check almost embarrassingly straightforward, and the merge_fields helper slotted in without touching anything else.

You can check the entire diff here.

If you, too, believe dividing by zero should be an error and not a NaN, subscribe and let's keep each other honest.

Photo by Lance Grandahl on Unsplash