Use lambda in a JSON context

[tiawl]

Hi,

I tried to build this kind of struct to use lambdas with std.json.Value:

const std = @import("std");
const mustache = @import("mustache");

const Native = struct {
    values: std.json.Value,

    pub fn myAwesomeLambda(self: Native, context: mustache.LambdaContext) !void {
        // here I am doing awesome things with Native.values
    }
}

When I give my Native object as data to the renderAllocText function, it fails with this error:

src/rendering/context.zig:86:9: error: Unexpect context_source: json.dynamic.Value of type [json] and context_source == [native]

Which is undeniably correct.

However I am wondering if there are any tips to use lambdas in a JSON context ?
If not, do you plan something like this ?
If not, will you accept a PR implementing this feature ?
If yes, could you give me some tips to make it possible ? Something like how you see the implementation with more or less details. I will be happy to contribute to this awesome project.

Thank you.

[batiati]

Hello @tiawl, thanks for the kind words!

Currently, lambda isn't supported on JSON by design:

mustache-zig/src/rendering/contexts/json/context.zig

Lines 129 to 146 in 4913f1f

	pub inline fn expandLambda(
	self: Context,
	data_render: *DataRender,
	path: Element.Path,
	inner_text: []const u8,
	escape: Escape,
	delimiters: Delimiters,
	) (Allocator.Error || Writer.Error)!PathResolutionType(void) {
	_ = self;
	_ = data_render;
	_ = path;
	_ = inner_text;
	_ = escape;
	_ = delimiters;
	// Json objects cannot have declared lambdas
	return PathResolutionType(void).chain_broken;
	}

However, it might be a low-hanging fruit, I think most of the invoker code the from native context can be reused for JSON.

The most difficult part is to decide "how" we want that to work: Using JSON we need to declare the lambda elsewhere and communicate how the invoker will find the correct type.

In the past I considered adding support to "global lambdas", where the user could include general-purpose functions that could be shared between all objects (e.g. common string functions like len, upper, lower). It may be a good call for JSON as well.

What do you think would be the best solution?

[tiawl]

Hi,

Thanks for your answer and for considering this feature.

Here just some thinkings I had about this issue. When reading this message, please understand "native lambdas" as already implemented lambdas (in contrast with global lambdas that are not implemented):

• How the user will deal with these global lambdas ? With a function ?

  Something like this:

  pub fn myAwesomeLambda(context: mustache.LambdaContext) !void {
      // ...
  }
  
  test "mustache" {
      mustache.addGlobalLambda(myAwesomeLambda);
      // Use global lambdas in template and render it
  }

  Or like this ?

  pub const MyLambdaStruct = struct {
      pub fn myAwesomeLambda1(context: mustache.LambdaContext) !void {
          // ...
      }
  
      pub fn myAwesomeLambda2(context: mustache.LambdaContext) !void {
          // ...
      }
  };
  
  test "mustache" {
      mustache.addGlobalLambdas(myLambdaStruct);
      // Use global lambdas in template and render it
  }

• I am wondering if global lambdas will not bring some complexity:

  In a Native context, What will happen in the case where a global lambda has the same name than a native lambda ?

  1. Native lambdas will have an higher priority and are used in this case. I do not like this solution because it is not really intuitive.
  2. Send a compilation error: The user did not explicitly say which one use in its templates. I do not like this solution too because we are facing a dilemma:
     • if we do not provide a way to allow the user to make an explicit choice it could lead to frustration,
     • if we do, it brings more complexity.
  3. Only authorize global lambdas in a JSON context. I personally prefer this solution but Global is not the right word to describe these lambdas.

Maybe I do not think in the right direction because I do not know how internally things are implemented. In this case do not hesitate to tell me.

[batiati]

It would be something like this:

const MyGlobalLambdas = struct  {

  // Global lambda that can be applied over any rendered value, regardless of the type of context.
  pub fn lower(context: mustache.LambdaContext) !void { ... }

  // Global lambda that can be applied over values of type T, in this case json.Value.
  // It will only render if the context value can be used to call the lambda (that is, a value of T), 
  // otherwise it will be just be ignored like any invalid lambda.
  pub fn jsonStuff(value: std.json.Value, context: mustache.LambdaContext) !void { ... }

  // The same idea with a u32:
  pub fn intStuff(value: u32, context: mustache.LambdaContext) !void { ... }

  // The same idea with a struct.
  // In this case it behaves exactly like if we declared objectStuff inside MyObject.
  pub fn objectStuff(value: *const MyObject, context: mustache.LambdaContext) !void { ... }
};

test "mustache" {
// Global lambdas will be part of the comptime "options".
_ = mustache.renderWithOptions(template, .{ .global_lambdas = MyGlobalLambdas });
}

[tiawl]

That sounds good to me. How do you want to proceed ?

1. You are making the whole thing.
2. If you are busy with other stuff, I can make the PR:
   • I write tests & docs, then I submit you a first review
   • If you are OK with it, I start the implementation
   • When it is done, I wait for a second review and you merge.

[batiati]

Awesome, I'm super excited to have you as a contributor!

Let me know if I can help/unblock you somehow.

To be honest, it's been a while since I worked with this code, and I don't have a clear picture of what we need to do, but I'd suggest you start with a simple PoC on how to introduce the global lambdas for native contexts and resolve lambdas that are not declared in the context type. Then, I think we will have a much better understanding of what is needed to connect the JSON context to the same logic.