Optional value in StringTemplate

Question

I can use a string template like so:

st = StringTemplate["a is `a` and b is `b`"];
st @ <|"a" -> 1, "b" -> 2|>

which gives

"a is 1 and b is 2"

But I would like the parameter b to be optional, so that if I call

st @ <|"a" -> 1|>

I get simply

"a is 1"

Something like this is possible with <* *>: For the case where b must be numeric, I can use

StringTemplate["a is `a`<* If[NumericQ[#b],\" and b is \",\"\"]*>`b`"]

but is there a way to tell whether a template parameter is present or absent, rather than numeric or otherwise?

You can use KeyMemberQ[#,"b"] to check whether "b" is present in the parameters. But I'm not sure StringTemplate is really the best option for something like this... — Lukas Lang, May 16 '19 at 13:54
How general it should be? Are there more optional key:value pairs? Do you want the template to care about "a" "b" and potential others? — Kuba, May 17 '19 at 06:20
@Kuba Where I needed it, there was a single optional parameter, but the general case might be useful for others. — Stephen Powell, May 17 '19 at 07:29

score 6 · Accepted Answer · answered May 16 '19 at 14:46

6

You can use MissingQ instead of NumericQ:

template = StringTemplate["a is `a`<* If[!MissingQ[#b],\" and b is \",\"\"]*>`b`"];

Then:

template @ <|"a"->1|>
template @ <|"a"->1, "b"->2|>

"a is 1"

"a is 1 and b is 2"

answered May 16 '19 at 14:46

Carl Woll

130,679
6
243
355

Thanks. I think this is the most direct solution to the question as posed. I hadn't appreciated what is actually happening when the key "b" is missing from the association: #b gives Missing["SlotAbsent","b"] and then TextString applied to that gives an empty string, which is spliced in. – Stephen Powell May 17 '19 at 07:40
It looks like the TemplateExpression isn't being syntax-colored, both in Mathematica and in Markdown/Prettify. Just wondering aloud. – Roman May 17 '19 at 09:25

Kuba · Answer 2 · 2019-05-17T09:33:14.360

4

Sorry for not using templates:

StringRiffle[ KeyValueMap[List]@<|"a" -> 1, "b" -> 2|>, " and ", " is "]

edited May 17 '19 at 09:33

answered May 16 '19 at 14:33

Kuba

136,707
13
279
740

You inverted the levels of is and and. – Roman May 17 '19 at 09:30
@Roman O_o thanks :) – Kuba May 17 '19 at 09:33
I learn a lot by trying out your solutions. It's like studying a foreign language and learning from the native speakers. Thanks! – Roman May 17 '19 at 09:47
@Roman Thanks for kind words, I learned a lot this way as well. – Kuba May 17 '19 at 09:53

Kagaratsch · Answer 3 · 2019-05-16T14:20:51.857

st[sub_] := If[KeyMemberQ[sub, "b"], StringTemplate["a is `a` and b is `b`"], StringTemplate["a is `a`"]]@sub;
st[<|"a" -> 1|>]
st[<|"a" -> 1, "b" -> 2|>]

"a is 1"

"a is 1 and b is 2"

ALTERNATIVE:

Or you could make it more easily scalable for more different cases by defining:

strings = {{"a", "a is `a`"}, {"b", " and b is `b`"}};
compose[strings_, sub_] := Block[{st = ""},
  Do[If[KeyMemberQ[sub, element[[1]]], st = st <> element[[2]]];, {element, strings}];
  StringTemplate[st]@sub
]

the strings variable contains snippets to be added when first element is present. The function compose checks all cases and constructs the template

compose[strings, <|"a" -> 1|>]

"a is 1"

and

compose[strings, <|"a" -> 1, "b" -> 2|>]

"a is 1 and b is 2"

just add more entries to strings as you wish.

MelaGo · Answer 4 · 2019-05-17T00:25:24.827

1

An old-fashioned solution?

st2[l_] := 
 l[[1, 1]] <> " is " <> ToString[l[[1, 2]]] <> 
  Table[" and " <> l[[n, 1]] <> " is " <> ToString[l[[n, 2]]], {n, 2, Length[l]}]

st2[{{"a", 1}}]

"a is 1"

st2[{{"a", 1}, {"b", 2}}]

"a is 1 and b is 2"

st2[{{"a", 1}, {"b", 2}, {"w", 5}, {"x", 10}}]

"a is 1 and b is 2 and w is 5 and x is 10"

edited May 17 '19 at 00:25

answered May 17 '19 at 00:07

MelaGo

8,586
1
11
24

score 0 · Answer 5 · answered May 17 '19 at 08:14

Here's an implementation that uses a single StringTemplate and no (* *):

With[{st = 
   StringTemplate["a is `a` and b is `b`",
      InsertionFunction -> Replace[y : Except[_Missing] :> TextString[y]],
      CombinerFunction -> (StringJoin @@ BlockMap[Replace[{_, _Missing} -> Nothing], #, 2] &)]},
   {st[<|"a" -> 1, "b" -> 2|>], st[<|"a" -> 1|>]}
]

(* {"a is 1 and b is 2", "a is 1"} *)

The InsertionFunction makes sure that Missing["SlotAbsent",_] is not converted to "", and the CombinerFunction drops anything that is _Missing, and the preceding string.

Optional value in StringTemplate

5 Answers5