Lazy evaluation on import / string interpolation?

[suimong]

I'm using Nickel to implement a suite of python project templates, thinking a bunch of related cookiecutter templates with many shared configs (in pyproject.toml, mkdocs.yml, etc.) but also distinct features required by each template. While Nickel works perfectly with statically known data, I'm struggling to use it in a more dynamic way. Here is a simplified example of my use case:

This works fine and will output: "Adam's age is 20."

let vars = {name="Adam", age=20} in let result = "%{name}'s age is %{age}." in result

But this will raise an exception saying that name and age are unbound:

# template.ncl
{
    welcome_msg = "%{name}'s age is %{age}."
}

# config.ncl
let vars = {name="Adam", age=20} in let tmpl = import "template.ncl" in templ.welcome_msg

The reason for putting vars into a separate file is that in my use case vars is only known at runtime.

Looking through the repo, I found a similar use case in benches/mantis/ which is implemented by wrapping the templated string in a function. Illustrating using the above example:

# template.ncl
{
    welcome_msg = fun vars => "%{vars.name}'s age is %{vars.age}."
}

# config.ncl
let vars = {name="Adam", age=20} in let {welcome_msg} = import "template.ncl" in welcome_msg vars

Now config.ncl will again evaluate to Adam's age is 20..

However, this approach of wrapping every templated string in a function seems to have a few drawbacks:

1. It's rather cumbersome and unergonomic to write;
2. You lose the ability of merging with other configs, at least not in a straightforward way. One can of course wrap every subsequent merge operations in a function with the necessary variables passed in, but to my eye that somewhat defeats the purpose of using Nickel.

So what would be the best approach for this use case? Is there any Nickel feature that I missed? Perhaps an alternative pattern to write nickel configurations that's more ergonomic?

[vkleen]

The idiomatic Nickel way to do this is to use an incompletely defined record in template.ncl like so:

{
  name,
  age,
  welcome_msg = "%{name}'s age is %{std.string.from age}",
}

# config.ncl
let vars = { name = "Adam", age = 20 } in let tmpl = (import "template.ncl") & vars in templ.welcome_msg

This keeps the ability to override name and age and the possibility of merging more configuration snippets together. If you need to target a specific export format that doesn't tolerate extra fields, you can annotate them like so:

{
  name | not_exported,
  age | not_exported,
  welcome_msg = "%{name}'s age is %{std.string.from age}",
}

[suimong]

(Sorry I'm on a cellphone so formatting is terrible)

Thanks for the quick feedback! If I understand correctly it's like "declaring" name and age as private fields (using not_exported) within the same "scope" as the templated string thus %{name} and %{age} will find its corresponding values in the scope.

One more question, to extend this approach and apply vars to "config2.ncl" and "config3.ncl" all of which has similar templated string using variable "name" and "age", do I have to put "name" and "age" as partially defined fields in these two files as well? Is there a more concise or idiomatic way?

[vkleen]

Since Nickel is statically scoped, you will need to declare the fields that you expect the final configuration will have if you want to depend on them. But if, say, config2.ncl doesn't need to know about name but just about age, you could also write

# config1.ncl
{
  name,
  age,
  welcome_msg = "%{name}'s age is %{std.string.from age}",
}

# config2.ncl
{
  age,
  twice_the_age = 2 * age
}

# top.ncl
let vars = { name = "Adam", age = 20 } in
(import "config1.ncl") & (import "config2.ncl) & vars

[suimong]

Got it. Thanks again for the help!