How to use as config language for a program?

[tennox]

I developed another CLI tool, at some point wanted some config - and thought: why not use nickel for that?

But I skimmed through docs and tutorials, and it seems I would need to always export manually to e.g. JSON and then parse that?

Am I misunderstanding the concept or the scope of nickel? Or is it just not implemented yet?

[suimong]

Iirc Nickel provides Python and JS binding. So if your CLI is written in either of the two languages (or Rust) then you can directly parse the nickel file into the native data structure of that language.

[tennox]

I don't find any docs/package for that (JS), you have any idea?

[yannham]

I don't think there's good documentation right now for linking to JS, but we compile Nickel to WASM for the Nickel online playground.

If you have/can use Nix, the simplest is to run nix build .#wasm-repl at the root of the repository - this might be long but should produce in ./result a standard NPM package wrapping the Nickel REPL, which is relatively straightforward to use from JS. Although this is originally made for the REPL, you can always initialize a session, send one command, and be done with it if all you want to do is to evaluate one configuration.

If you don't use Nix or are on a platform that isn't supported by Nix, you can look at what we do in the flake.nix file to build the Wasm package. There's a bunch of things there, but with a bit of effort you should be able to do the build manually, using wasm-pack.

[jneem]

Maybe we could be publishing the npm package as part of the release process?

[jneem]

To expand on the case of rust specifically, nickel's RichTerm type implements serde's Deserializer trait, so if you annotate a rust struct with #[derive(serde::Deserialize)] then you can convert from the evaluated nickel straight to your rust struct. Just bear in mind that serde's error messages are not very user-friendly, so to get error messages you'll probably want to apply a contract on the nickel side that's strict enough to ensure that the serde conversion never fails.

[lcnbr]

Is it possible to auto generate this contract? Or to generate the associated rust type somehow with a macro?

[yannham]

I would say that this is probably straightforward to implement, as Rust struct and enums should have an obvious mapping to Nickel types/contracts, but it doesn't exist currently to the best of my knowledge.

[lcnbr]

which direction would be the simplest to implement? I would be interested in contributing if it isn't too complex.

[yannham]

Good question. From the top of my head, my intuition would be that deriving a Nickel contract from a Rust type is maybe the simplest conceptually. I think something like:

1. Introduce a trait (could be put in nickel_lang_core::typ for example) for Rust types that can be reified as a Nickel type

   pub trait ReifyAsNickelType {
       fn reify_as_nickel_type() -> Type;
   }

2. Write a procedural macro that derives this implementation for an arbitrary Rust type, ideally, so that you would just write:

   #[derive(ReifyAsNickelType)]
   struct Config {
       ....
   }

The generated implementation should build a Nickel contract that mimics the Rust type: if it's a struct, make a Nickel record with the same fields, and to each field attach a contract that corresponds to its Rust type. So for example, for struct A { foo: Foo, bar: Bar }, you want to build a contract like {foo | <Foo::reify_as_nickel_type()>, bar | <Bar::reify_as_nickel_type()>}. You'll find the builder library in nickel_lang_core::term::make::builder to be helpful there.

If it's an enum A { Foo(Foo), Bar(Bar) }, turns that into a Nickel enum type [|'Foo <Foo::reify_as_nickel_type()>, 'Bar <Bar::reify_as_nickel_type()> |]. I'm not sure what to do with variants with many arguments, like Binary(Left, Right), as Nickel enum can only have one argument. One possibility is to reject such enums in the macro. Another is to encode the tuple (Left, Right) as a record type {"0": Left, "1": Right}. Variants with anonymous struct as arguments are unproblematic: Foo {bar: Bar, baz: Baz} in Rust can be encoded as the variant 'Foo {bar | <Bar::reify_as_nickel_type()>, baz |<Baz::reify_as_nickel_type()>}.

We also want to provide instance for Rust base types: String, &str, i32/u32/i64/u64/etc..., bool, etc.

I think it's not going to be entirely trivial, writing the macros, generating some Nickel structures and so on, but the path is rather clear. We would gladly accept and help with such a PR!