Cutom string interpolation

[viperML]

Hi, I've been developing a linux package manager for my thesis, and I want to use a scripting language to declare the packages. The PM is written in rust, so rhai seems like a good fit.

My idea was to declare packages a a rust type, let's say:

struct Pkg {
  id: String // unique to each package
  // ...
}

So what I want to do, is use the Pkg in string interpolation.

let foo_build_script = ".....";
let foo = mkPkg(foo_build_script, ...);

let bar_build_script = `
  #!/bin/sh
  ls ${foo}
`;
let foo = mkPkg(bar_build_script, ...);

In this scenario, bar_build_script would be a string marked with metadata. The representation could be a map or a custom type.

// ==>
let bar_build_script = #{
 inner: "
    #!/bin/sh
    ls /path/to/foo
  `;
  dependencies: [ "foo_id" ]
}

I have already implemented this in Lua. What I do, is to return a custom type MetaText, which is just a struct { inner: String, dependencies: Vec<String> }. You can see an example here: https://github.com/viperML/miq/blob/11ee2f42a9b5a55b8c77cee34cc30c6f1a41b983/pkgs/bootstrap.lua#L28-L52

However this Lua implementation is very finnicky, as it relies on debug mode to inspect the surronding scope,.. and regex. So I thought maybe I can define some special syntax with rhai to get this kind of result.

[schungx]

You can easily define a custom syntax that would give you this.

If you define a custom syntax that starts with mkPkg, you can then return your filled-out object as the result.

[viperML]

To make things clear, I don't want it to be tied to mkPkg, as I would do transformations on these "MetaStrings" (the result of interpolating a pkg into a string) as part of some intermediate function.

[viperML]

And ideally I could monkey-patch the existing string interpolation mechanism (or use any other symbol instead of `` or ""), as having to wrap every string into a function call fn() is tedious. Basically to recreate nix's string interpolation: https://github.com/NixOS/nixpkgs/blob/a64b73e07d4aa65cfcbda29ecf78eaf9e72e44bd/pkgs/development/tools/rust/rust-analyzer/default.nix#L45-L47

[schungx]

So you want an interpreted string to actually call your supplied function?

[viperML]

To illustrate my point, I wrote a quick demo in TS:

https://www.typescriptlang.org/play

The interesting bit is the call to f:

const bar = {
  id: "foo-1234",
  script: f`
    #!/usr/bin/bash
    ls -la ${foo}
  `,
}
/* ==>
{
  "id": "foo-1234",
  "script": {
    "value": "\n    #!/usr/bin/bash\n    ls -la /nix/store/foo-1234\n  ",
    "deps": [
      "foo-1234"
    ]
  }
} 
*/

What I would like then, is to modify rhai so that this behaviour is the default for string interpolation:

let script = `
  #!/bin/sh
  ls ${foo}
`;

/* ==>
#{
 value: "
    #!/bin/sh
    ls function_result_on_foo
  `;
  deps: [ "function_result_on_foo" ]
}
*/

Possibly using different characters than ` and ${} - which clashes with bash's ${ENV_VARIABLE}

[schungx]

Would these custom interpolation formats need to be dynamic? Or compiled as Rust?

[viperML]

No need to be dynamic