Provide an `enclose` builtin function for wrapping prefix and suffix

[yuan-y-chang]

Feature request

It would be useful to have an enclose string function that prepends a prefix
and appends a suffix to every whitespace-separated string in its argument.

The function could be defined as:

enclose(prefix, suffix, s) := prepend(prefix, append(suffix, s))

For example:

enclose('systemd/', '.service', 'foo bar baz')
# → 'systemd/foo.service systemd/bar.service systemd/baz.service'

This would be a convenient shorthand for the common pattern:

prepend(prefix, append(suffix, s))

It would complement the existing prepend() and append() functions while
making it clearer that each item is being enclosed by a prefix and suffix.

The function name may be: enclose, warp, surround, etc.

[casey]

Thanks for the issue! This seems useful, but, as you note, there's already a workaround:

prepend(prefix, append(suffix, s))

And with user defined functions, you can define it yourself with:

enclose(prefix, suffix, s) := prepend(prefix, append(suffix, s))

Since just doesn't have object.method() syntax, the three-argument function form would be ambiguous as to what is the prefix and what's the suffix, and I'm not sure how it would handle lists, where each argument can be a different length.

I'll leave this issue open for comment, in case anyone has some suggestions or feels strongly about it one way or another.

[laniakea64]

prepend() and append() feel like relics from before user-defined functions were a thing. Even back then they were already convenience functions that could be implemented by a justfile. User-defined functions cover the readability and simplicity rationale for adding prepend() and append() that was brought up back then. So if those functions were being suggested now, there would be little to no reason to add them as builtins, and concerns about leaving room for improvement while keeping backwards compatibility would take priority.

Likewise for other similar type of functions.

It seems the only reason to consider adding the proposed enclose() function in today's just would be if it's a super-common need for many users and many justfiles?

[acuteaangle]

I encountered this issue today as well.
In my case, this was for an experimental hobby project, so I felt comfortable trying out just’s currently-unstable lists feature (docs) as a solution.

Without set lists, the syntax for applying both a prefix and a suffix to a set of strings looks like this:

items := "one two three four"
enclosed := prepend("prefix_", append("_suffix", items))

which evaluates to:

items    := "one two three four"
enclosed := "prefix_one_suffix prefix_two_suffix prefix_three_suffix prefix_four_suffix"

With set lists, the following is possible instead:

set unstable
set lists
items := ["one", "two", "three", "four"]
enclosed := "prefix_" + items + "_suffix"

which evaluates as:

items    := ["one", "two", "three", "four"]
enclosed := ["prefix_one_suffix", "prefix_two_suffix", "prefix_three_suffix", "prefix_four_suffix"]

---

If lists end up being stabilized with this functionality, then I don’t think an enclose() function is necessary as a builtin.

[casey]

Ah yeah, I forgot that lists pretty much subsumed the functionality of prepend and append. I think given that, and the fact that we have user-defined functions, that a dedicated enclose() function probably isn't worth it. Thanks for the feedback everyone!