DEV Community: Hercules Lemke Merscher

Tsonnet #45 - The devil in the details #1

Hercules Lemke Merscher — Sun, 19 Jul 2026 17:18:38 +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 removed every catch-all pattern match across the compiler, letting OCaml's exhaustiveness checker tell us exactly which variants were being silently ignored:

Hercules Lemke Merscher

Jul 18

Tsonnet #44 - The devil in the details #0

#jsonnet #tsonnet #compiler #ocaml

4 min read

The scope checker is on the operating table first. Let's go.

Scope-checking conditionals

The If variant was the most obvious omission — the scope checker had no arm for it. Before the catch-all removal, it was swallowed by | _ -> ok (). After the first cleanup pass in the previous post it was still sitting in a list of variants that were silently accepted:

(* For any other expression types, no special scope validation needed *)
| Unit | Null _ | Number _ | String _ | Bool _ | EvaluatedObject _
| RuntimeObject _ | ObjectPtr _ | FunctionDef _ | FunctionCall _ | Closure _
| If _ -> ok ()

That's wrong. An if can contain self or $ in its condition, then-branch, or else-branch. If that if is outside an object, the scope checker should catch it.

// samples/errors/conditional_self_out_of_scope.jsonnet
local value = if true then self.one else 1;
value

Before this fix, that passed without error. validate_if recursively walks all three branches:

diff --git a/lib/scope.ml b/lib/scope.ml
index 48dfa83..b4e36a3 100644
--- a/lib/scope.ml
+++ b/lib/scope.ml
@@ -51,10 +50,12 @@ let rec _validate expr context =
     _validate expr context
   | IndexedExpr (_, _, index_expr) ->
     _validate index_expr context
+  | If (_, cond_expr, then_expr, else_expr_opt) ->
+    validate_if cond_expr then_expr else_expr_opt context
   (* For any other expression types, no special scope validation needed *)
   | Unit | Null _ | Number _ | String _ | Bool _ | EvaluatedObject _
   | RuntimeObject _ | ObjectPtr _ | FunctionDef _ | FunctionCall _ | Closure _
-  | If _ -> ok ()
+    -> ok ()

and validate_if cond_expr then_expr else_expr_opt context =
  _validate cond_expr context >>= fun () ->
  _validate then_expr context >>= fun () ->
  (match else_expr_opt with
  | Some else_expr -> _validate else_expr context
  | None -> ok ()
  )

Now the earlier example correctly errors:

$ dune exec -- tsonnet samples/errors/conditional_self_out_of_scope.jsonnet
ERROR: samples/errors/conditional_self_out_of_scope.jsonnet:1:27 Can't use self outside of an object

1: local value = if true then self.one else 1;
   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[1]

The positive case — self inside an if inside an object — still works as expected:

// samples/conditionals/conditional_object_scope.jsonnet
{
  one: 1,
  two: if true then self.one + 1 else 0,
  three: if false then 0 else $.one + 2,
}

Scope-checking indexed object field access

The ObjectFieldAccess handler was already checking the scope reference — self, $, or ObjVarRef — against the context. But it was ignoring the chain of field expressions.

| ObjectFieldAccess (pos, scope, _) ->
  validate_object_field_access pos scope context

The chain (e.g. [self.one] in obj[self.one].two) was not being validated. A chain expression containing self or $ outside an object went undetected.

// samples/errors/object_field_access_index_self_out_of_scope.jsonnet
local obj = { one: 1 };
obj[self.one].two

// samples/errors/object_field_access_computed_self_out_of_scope.jsonnet
local obj = { one: 1 };
obj.[self.one].two

// samples/errors/object_field_access_index_toplevel_out_of_scope.jsonnet
local obj = { one: 1 };
obj[$.one].two

The fix threads the chain through to validate_expression_list:

-  | ObjectFieldAccess (pos, scope, _) ->
-    validate_object_field_access pos scope context
+  | ObjectFieldAccess (pos, scope, chain) ->
+    validate_object_field_access pos scope chain context

Inside validate_object_field_access, after the scope check runs, the chain gets validated in sequence:

-  match scope with
-  | Self | TopLevel ->
-    if not context.in_object then
-      let with_error_msg = match scope with
-        | Self -> Error.Msg.self_out_of_scope
-        | TopLevel -> Error.Msg.no_toplevel_object
-        | ObjVarRef _ -> "" (* unreachable *)
-      in
-      Error.error_at pos with_error_msg
-    else ok ()
-  | ObjVarRef _ ->
-    (* Variable references are allowed anywhere *)
-    ok ()
+  let* () =
+    match scope with
+    | Self | TopLevel ->
+      if not context.in_object then
+        let with_error_msg = match scope with
+          | Self -> Error.Msg.self_out_of_scope
+          | TopLevel -> Error.Msg.no_toplevel_object
+          | ObjVarRef _ -> "" (* unreachable *)
+        in
+        Error.error_at pos with_error_msg
+      else ok ()
+    | ObjVarRef _ ->
+      (* Variable references are allowed anywhere *)
+      ok ()
+  in
+  validate_expression_list chain context

All three variations now produce the correct scope errors.

Scope-checking function definitions

FunctionDef was completely unvalidated. A function defined at the top level could reference self or $ in its body or parameter defaults without triggering any error. validate_function_def walks each parameter's optional default expression, then validates the body:

+  | FunctionDef (_, def) ->
+    validate_function_def def context
   (* For any other expression types, no special scope validation needed *)
   | Unit | Null _ | Number _ | String _ | Bool _ | EvaluatedObject _
-  | RuntimeObject _ | ObjectPtr _ | FunctionDef _ | FunctionCall _ | Closure _
+  | RuntimeObject _ | ObjectPtr _ | FunctionCall _ | Closure _
     -> ok ()

and validate_function_def def context =
  let* () = List.fold_left
    (fun acc (_, default_expr) ->
      acc >>= fun () ->
      match default_expr with
      | Some expr -> _validate expr context
      | None -> ok ()
    )
    (ok ())
    def.params
  in
  _validate def.body context

The four error samples:

// samples/errors/function_def_self_out_of_scope.jsonnet
local get_value() = self.value;
get_value()

// samples/errors/function_def_toplevel_out_of_scope.jsonnet
local get_value() = $.value;
get_value()

// samples/errors/function_def_default_self_out_of_scope.jsonnet
local get_value(value = self.value) = value;
get_value()

// samples/errors/function_def_default_toplevel_out_of_scope.jsonnet
local get_value(value = $.value) = value;
get_value()

All four now produce the correct scope errors.

Scope-checking function calls

FunctionCall was the next silent passer. A call like get_value(self.value) at the top level should fail:

// samples/errors/function_call_arg_self_out_of_scope.jsonnet
local get_value(value) = value;
get_value(self.value)

validate_function_call validates the callee expression and every argument, positional or named:

+  | FunctionCall (_, call) ->
+    validate_function_call call context
   (* Terminal variants *)
   | Null _ | Number _ | String _ | Bool _ -> ok ()

and validate_function_call call context =
  let* () = _validate call.callee context in
  List.fold_left
    (fun acc arg ->
      acc >>= fun () ->
      match arg with
      | Positional expr -> _validate expr context
      | Named (_, expr) -> _validate expr context
    )
    (ok ())
    call.args

Six error samples cover callee, positional args, and named args for both self and $:

// samples/errors/function_call_callee_self_out_of_scope.jsonnet
(self.get_value)()

// samples/errors/function_call_callee_toplevel_out_of_scope.jsonnet
($.get_value)()

// samples/errors/function_call_arg_self_out_of_scope.jsonnet
local get_value(value) = value;
get_value(self.value)

// samples/errors/function_call_arg_toplevel_out_of_scope.jsonnet
local get_value(value) = value;
get_value($.value)

// samples/errors/function_call_named_arg_self_out_of_scope.jsonnet
local get_value(value) = value;
get_value(value = self.value)

// samples/errors/function_call_named_arg_toplevel_out_of_scope.jsonnet
local get_value(value) = value;
get_value(value = $.value)

Scope-checking closures (unified with function definitions)

Closure was the last variant sitting in the catch-all. It has the same structure as FunctionDef -- both have params with optional defaults and a body. Instead of duplicating the validation, I unified them:

-  | FunctionDef (_, def) ->
-    validate_function_def def context
+  | FunctionDef (_, {name = _; params; body})
+  | Closure (_, {params; body}) ->
+    validate_function_signature_and_body params body context

The old validate_function_def renamed to validate_function_signature_and_body and takes params and body directly:

-and validate_function_def def context =
+and validate_function_signature_and_body params body context =
   let* () = List.fold_left
     (fun acc (_, default_expr) ->
       acc >>= fun () ->
       match default_expr with
       | Some expr -> _validate expr context
       | None -> ok ()
     )
     (ok ())
-    def.params
+    params
   in
-  _validate def.body context
+  _validate body context

Four error samples cover body and defaults for both self and $:

// samples/errors/closure_self_out_of_scope.jsonnet
function() self.value

// samples/errors/closure_toplevel_out_of_scope.jsonnet
function() $.value

// samples/errors/closure_default_self_out_of_scope.jsonnet
function(value = self.value) value

// samples/errors/closure_default_toplevel_out_of_scope.jsonnet
function(value = $.value) value

Cleaning up the non-parser variants

The last diff separates the remaining no-ops into explicit groups with comments explaining why each group doesn't need validation:

-  (* For any other expression types, no special scope validation needed *)
-  | Unit | Null _ | Number _ | String _ | Bool _ | EvaluatedObject _
-  | RuntimeObject _ | ObjectPtr _ | FunctionCall _ | Closure _
-    -> ok ()
+  (* Terminal variants *)
+  | Null _ | Number _ | String _ | Bool _ -> ok ()
+  (* These variants are not produced by parsing source files.
+     Scope validation runs before type checking/interpreting,
+     so they only appear through internal or runtime, and have
+     no source-level scope to check. *)
+  | Unit | EvaluatedObject _ | RuntimeObject _ | ObjectPtr _ -> ok ()

Three groups: terminal literals that have no sub-expressions, internal/runtime-only variants that parsing never produces, and — after the closure unification — nothing left. The last catch-all is gone.

Testing

The cram tests cover both the positive case and every error case. The conditionals.t test confirms that self and $ inside a conditional within an object still works:

diff --git a/test/cram/conditionals.t b/test/cram/conditionals.t
@@ -18,3 +18,7 @@
   2:   [if true then 42]: "value"
      ^^^^^^^^^^^^^^^^^^^^^
   [1]
+
+
+  $ tsonnet ../../samples/conditionals/conditional_object_scope.jsonnet
+  { "one": 1, "three": 3, "two": 2 }

The errors.t file collects all the new scope error tests — conditionals, object field access, function definitions, function calls, and closures:

diff --git a/test/cram/errors.t b/test/cram/errors.t
+  $ tsonnet ../../samples/errors/conditional_self_out_of_scope.jsonnet
+  ERROR: ...:1:27 Can't use self outside of an object
+
+  $ tsonnet ../../samples/errors/conditional_toplevel_out_of_scope.jsonnet
+  ERROR: ...:1:35 No top-level object found
+
+  $ tsonnet ../../samples/errors/object_field_access_index_self_out_of_scope.jsonnet
+  ERROR: ...:2:4 Can't use self outside of an object
+
+  $ tsonnet ../../samples/errors/object_field_access_computed_self_out_of_scope.jsonnet
+  ERROR: ...:2:5 Can't use self outside of an object
+
+  $ tsonnet ../../samples/errors/object_field_access_index_toplevel_out_of_scope.jsonnet
+  ERROR: ...:2:4 No top-level object found
+
+  $ tsonnet ../../samples/errors/function_def_self_out_of_scope.jsonnet
+  ERROR: ...:1:20 Can't use self outside of an object
+
+  $ tsonnet ../../samples/errors/function_def_toplevel_out_of_scope.jsonnet
+  ERROR: ...:1:20 No top-level object found
+
+  $ tsonnet ../../samples/errors/function_def_default_self_out_of_scope.jsonnet
+  ERROR: ...:1:24 Can't use self outside of an object
+
+  $ tsonnet ../../samples/errors/function_def_default_toplevel_out_of_scope.jsonnet
+  ERROR: ...:1:24 No top-level object found
+
+  $ tsonnet ../../samples/errors/function_call_callee_self_out_of_scope.jsonnet
+  ERROR: ...:1:1 Can't use self outside of an object
+
+  $ tsonnet ../../samples/errors/function_call_callee_toplevel_out_of_scope.jsonnet
+  ERROR: ...:1:1 No top-level object found
+
+  $ tsonnet ../../samples/errors/function_call_arg_self_out_of_scope.jsonnet
+  ERROR: ...:2:10 Can't use self outside of an object
+
+  $ tsonnet ../../samples/errors/function_call_arg_toplevel_out_of_scope.jsonnet
+  ERROR: ...:2:10 No top-level object found
+
+  $ tsonnet ../../samples/errors/function_call_named_arg_self_out_of_scope.jsonnet
+  ERROR: ...:2:18 Can't use self outside of an object
+
+  $ tsonnet ../../samples/errors/function_call_named_arg_toplevel_out_of_scope.jsonnet
+  ERROR: ...:2:18 No top-level object found
+
+  $ tsonnet ../../samples/errors/closure_self_out_of_scope.jsonnet
+  ERROR: ...:1:11 Can't use self outside of an object
+
+  $ tsonnet ../../samples/errors/closure_toplevel_out_of_scope.jsonnet
+  ERROR: ...:1:11 No top-level object found
+
+  $ tsonnet ../../samples/errors/closure_default_self_out_of_scope.jsonnet
+  ERROR: ...:1:17 Can't use self outside of an object
+
+  $ tsonnet ../../samples/errors/closure_default_toplevel_out_of_scope.jsonnet
+  ERROR: ...:1:17 No top-level object found

All 19 new tests pass, and every existing cram test still passes unchanged.

Conclusion

The scope checker is clean. Every expr variant that can appear during scope analysis now has explicit handling.

The type checker is next. It has at least as many loose ends as the scope checker did — probably more. Future me gets to sort them out.

The entire diff can be seen here.

Thanks for reading Bit Maybe Wise! Subscribe — and if you don't, the only thing out of scope is your inbox.

Photo by Matthew Ansley on Unsplash

Tsonnet #44 - The devil in the details #0

Hercules Lemke Merscher — Sat, 18 Jul 2026 14:50:12 +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 computed field names working:

Hercules Lemke Merscher

Jun 2

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

#tsonnet #jsonnet #compiler

12 min read

Turns out the catch-all patterns I'd been relying on were defeating the one thing that makes pattern-matching useful.

The problem

Compilers are amazing co-pilots when you're working with strongly typed languages. They catch invariants when we forget. But that only works if we enforce checking all pattern-matching cases, one by one. A catch-all | _ -> or | expr -> is the compiler equivalent of duct tape — it shuts it up, but it also hides every variant you forgot to handle.

So far, I'd been mistakenly ignoring new type variants in pattern-matching across lib/scope.ml, lib/type.ml, and lib/interpreter.ml because of catch-all cases. Every time a new expr variant was added, the compiler stayed quiet.

The fix: explicit exhaustiveness

The first thing to do is remove the catch-all cases and list every variant explicitly. This way, when a new variant gets added to the AST, OCaml will refuse to compile until every match is updated.

`lib/scope.ml` — `_validate`

diff --git a/lib/scope.ml b/lib/scope.ml
index 3f329fe..48dfa83 100644
--- a/lib/scope.ml
+++ b/lib/scope.ml
@@ -31,7 +31,6 @@ let add_locals_to_context locals context = {

 let rec _validate expr context =
   match expr with
-  | Unit | Null _ | Number _ | String _ | Bool _ -> ok ()
   | Ident (pos, varname) ->
     (* Identifier validation - the heart of scope checking *)
     validate_ident pos varname context
@@ -52,9 +51,10 @@ let rec _validate expr context =
     _validate expr context
   | IndexedExpr (_, _, index_expr) ->
     _validate index_expr context
-  | _ ->
-    (* For any other expression types, no special scope validation needed *)
-    ok ()
+  (* For any other expression types, no special scope validation needed *)
+  | Unit | Null _ | Number _ | String _ | Bool _ | EvaluatedObject _
+  | RuntimeObject _ | ObjectPtr _ | FunctionDef _ | FunctionCall _ | Closure _
+  | If _ -> ok ()

`lib/type.ml` — three matches

The type checker had the most catch-all cases. Three separate matches needed the treatment:

diff --git a/lib/type.ml b/lib/type.ml
index 79fa6aa..28c8909 100644
--- a/lib/type.ml
+++ b/lib/type.ml
@@ -100,7 +100,6 @@ let rec to_string = function
   | Tunresolved -> "<unresolved>"

 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
@@ -126,7 +125,9 @@ let rec collect_free_idents = function
       | Named (_, e) -> collect_free_idents e
     ) call.args
   | Closure (_, closure) -> collect_free_idents closure.body
-  | _ -> []
+  | Unit | Null _ | Number _ | String _ | Bool _ | EvaluatedObject _
+  | RuntimeObject _ | ObjectPtr _ | FunctionDef _
+  | If _ -> []

@@ -154,7 +155,6 @@ let rec check_cyclic_refs venv varname seen pos =
     | _ -> ok ()
 and check_expr_for_cycles venv expr seen =
   match expr with
-  | Unit | Null _ | Number _ | String _ | Bool _ -> ok ()
   | Array (_, exprs) -> iter_for_cycles venv seen exprs
   | ParsedObject (_, entries) -> check_object_for_cycles venv entries seen
   | ObjectFieldAccess (pos, scope, exprs) -> check_object_field_chain_for_cycles venv (pos, scope, exprs) seen
@@ -163,7 +163,10 @@ and check_expr_for_cycles venv expr seen =
   | 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 ()
+  | Unit | Null _ | Number _ | String _ | Bool _ | EvaluatedObject _
+  | RuntimeObject _ | ObjectPtr _ | FunctionDef _ | FunctionCall _ | Closure _
+  | Local _ | IndexedExpr _ -> ok ()

@@ -235,7 +238,7 @@ let rec translate venv expr =
   | 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' ->
+  | EvaluatedObject _ | RuntimeObject _ | ObjectPtr _ as expr' ->
     error (Error.Msg.type_invalid_expr (string_of_type expr'))

`lib/interpreter.ml` — `deep_eval`

diff --git a/lib/interpreter.ml b/lib/interpreter.ml
index 40b9eea..1751554 100644
--- a/lib/interpreter.ml
+++ b/lib/interpreter.ml
@@ -562,7 +562,9 @@ let rec deep_eval expr =
   | RuntimeObject _ ->
     let* (_, evaluated) = interpret Env.empty expr in
     deep_eval evaluated
-  | expr ->
+  | Ident _ | ParsedObject _ | ObjectPtr _ | ObjectFieldAccess _
+  | BinOp _ | UnaryOp _ | IndexedExpr _ | Local _ | Seq _
+  | FunctionDef _ | FunctionCall _ | Closure _ | If _ as expr ->
     let* (_, evaluated) = interpret Env.empty expr in
     deep_eval evaluated

Every catch-all is gone. Now when I add a new variant to the expr type, the compiler will tell me exactly which function needs a new arm — silently swallowing it is no longer an option.

Does it change anything? (No)

This improves nothing in the runtime behaviour. Every explicit list above matches exactly what the catch-all was doing. But now the compiler can do its job — if I forget to update a match when adding a new variant, the build breaks.

The existing cram tests pass without changes. No output changed — as expected, since the semantics are identical.

What's next

This post was just the tip of the iceberg — removing the catch-all exposed the loose ends, but now I actually need to deal with them. In the next one, I'll start with the scope check, where there are variants in _validate that are silently passing through when they probably shouldn't. But first, I needed to see them.

The diff is small — the habit it breaks is the point.

The entire diff can be seen here.

Thanks for reading Bit Maybe Wise! Your inbox deserves exhaustive coverage — subscribe and never miss a variant.

Photo by Volodymyr Hryshchenko on Unsplash

ABEND dump #27

Hercules Lemke Merscher — Thu, 02 Jul 2026 21:31:59 +0000

Welcome to the ABEND dump #27!

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

You can check the previous ABEND dump here:

Hercules Lemke Merscher

Apr 8

ABEND dump #26

#abenddump

2 min read

I haven't been reading that much lately, unfortunately. Or, I did read, but if I don't remember, it's not worth mentioning.

So, here goes just a tiny bit of content that stood out for the past 3 months.

TypeScript, C# and Turbo Pascal with Anders Hejlsberg

Here's an interview with Anders Hejlsberg. This guy is a legend! Always inspiring to watch his talks and interviews.

Trust Factory

As always, Kent Beck makes me think, and yes, I agree with his statement here.

Physical disc production ending in January 2028 for new games releasing on PlayStation consoles

After Sony announced they aren't going to release physical discs for games, Xbox followed.

It's a sad time for games preservation. I wish there was at least a way to keep them as physical copies, to play offline in the future, but I doubt most studios would offer this option.

I don't like this direction where everything is turning into a subscription.

MIT students turned a building into a giant playable game of Tetris

This was sitting here for a while, and just now I managed to find it to share.

How cool is that?! :D

Thanks for reading the ABEND dump! No discs, no problem -- as long as MIT keeps turning buildings into Tetris boards, the future's still fun. Subscribe and let's see what they turn into a giant Pac-Man next.

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

DEV Community: Hercules Lemke Merscher

Tsonnet #45 - The devil in the details #1

Scope-checking conditionals

Scope-checking indexed object field access

Scope-checking function definitions

Scope-checking function calls

Scope-checking closures (unified with function definitions)

Cleaning up the non-parser variants

Testing

Conclusion

Tsonnet #44 - The devil in the details #0

The problem

The fix: explicit exhaustiveness

lib/scope.ml — _validate

lib/type.ml — three matches

lib/interpreter.ml — deep_eval

Does it change anything? (No)

What's next

ABEND dump #27

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

The target

Let's add new testing samples

A new object entry variant

Type checking

Evaluating

Moment of truth

Conclusion

Tsonnet #42 - If then else (finally)

The target

A new variant

Three new keywords

Branch discipline

The boring part (by design)

Tests

Conclusion

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

What must be validated

Parsing

Testing

Conclusion

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

This is what I want to test

A new argument in the room

Teaching the typechecker to count on its fingers

Does it actually work? (Yes.)

Putting it all together (with cocktails)

Conclusion

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

The plan (such as it is)

Sneaking methods past the grammar

Turns out, scope bugs don't fix themselves

Does it work?

Conclusion

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

A makeover for the AST

The interpreter catches up

The type checker gets the memo

Conclusion

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

Captured and ready to be called

Parsing: teaching the grammar new tricks

Type checking: the elephant in the room

Interpreting: where closures actually close over things

Does it work? (Yes it does)

Conclusion

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

What's on the menu?

Teaching the parser about optionals

Filling in the blanks

Knowing the type before the call

The moment of truth

Conclusion

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

What are we even working with here?

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

Interpreting: where things actually happen

Making sure this isn’t completely illegal

Proof that it (mostly) works

Conclusion

`lib/scope.ml` — `_validate`

`lib/type.ml` — three matches

`lib/interpreter.ml` — `deep_eval`