implement some way to escape special characters in labels

[gdementen]

list of characters/patterns with special meaning:

• current: , ; : .. [ ] >> name[] name.i[] {} numbers
• whitespace could be considered a special character (because it is not kept as is) and we might want to make it "escapable"
• planned (for automatic patterns): * ?
• potential (for logic operators): | & !

we might want to reserve some or all other special characters just in case: # @ % / = + -
Or, we could define the precise list of characters a label can be made of which we can guarantee will not be interpreted.

[gdementen]

note that those characters are already partially supported because the full string is checked against the axis labels before evaluating the special characters. If we use an explicit group, though, this is not true (anymore).

[gdementen]

I thought quite a bit about this.

doubled characters

>>> "axis[[from::to,, a....b]] >>>> name"
'axis[[from::to,, a....b]] >>>> name'

• when you have several special characters, it makes for unreadable strings
• probably harder to implement than the other solutions

\ before char to escape

>>> r"axis\[from\:to\, a\.\.b\] \>\> name"
'axis\\[from\\:to\\, a\\.\\.b\\] \\>\\> name'

• yes, this is kinda standard, but I hate the fact that the display is not symmetric and that you need r-string or double the \
• to use a label with a real \ in it, we would need \\\\ 😭

@ before char to escape

>>> "axis@[from@:to@, a@.@.b@] @>@> name"
'axis@[from@:to@, a@.@.b@] @>@> name'

• visually awful too

` before char to escape

>>> "axis`[from`:to`, a`.`.b`] `>`> name"
'axis`[from`:to`, a`.`.b`] `>`> name'

• visually better but hard to type on some keyboards
• might be too small (if there is a single backtick, we could miss it)

starting marker on the whole string

>>> r"R/axis[from:to, a..b] >> name"
'R/axis[from:to, a..b] >> name'

• this is much nicer but quite limited (cannot use any of the string syntax in combination with this). E.g. "axis[R/from:to, a..b] >> name" is ambiguous

escaped part enclosed by two `

>>> "`axis[from:to, a..b] >> name`"
"`axis[from:to, a..b] >> name`"

• much better than escaping individual characters
• Pandas uses this for its query syntax (to escape column names which contain special characters)
• Combines well with "real" (unescaped) special characters

  >>> "axis[`axis[from:to, a..b] >> name`] >> `super >> new:name`"

• In the non-string syntax, it might be confusing that you can use quotes instead of backticks for the "leaf" parts (which are not parsed):

  >>> axis["`axis[from:to, a..b] >> name`"] >> "super >> new:name"
  axis["`axis[from:to, a..b] >> name`"] >> "super >> new:name"

• If we go with backticks, we will probably want to support no-op backticks for those cases.
• Given that it uses a single character for both start and stop, you cannot have nested escaped sequences, but I don't think there would be any use for that anyway.
• Pandas has a problem with some strings because they reuse Python parser. That's theoretically solvable though.
• Pandas has a problem with backticks inside escaped strings but I don't see why we could not (at least theoretically) make double backticks mean a single backtick. Might be hard in practice though.
• Do we want to support partially escaped strings? That might make the implementation more complicated, but would be much more powerful. Could come later if it's hard to implement.

  >>> from larray.core.group import _to_key
  >>> _to_key("axis[from`:to, a..b] >> name`] >> super` >> new:`name")
  axis[`from:to, a..b] >> name`] >> "super >> new:name"

literal function

>>> raw('axis[from:to, a..b] >> name')
raw('axis[from:to, a..b] >> name')
>>> 'axis[' + raw('from:to') + ', a..b)] >> name'

• I like the principle but raw is probably not a good name (because of python r-strings)
• could (need to think more about this) be hard to implement if we allow partial labels (i.e. if we implement __add__ on the returned object, this might be a pandora's box)
• other name candidates: esc(ape), lit(eral),

literal function + function-like string marker

>>> escape('axis[') + 'escape(from:to)' + escape(', a..b] >> name')

• this is my current favourite option in the long term

function-like string marker

>>> 'axis[literal(from:to), a0..a2] >> name'
axis['literal(from:to)', 'a0', 'a1', 'a2'] >> 'name'

• this is my current favourite option in the short term, the literal function could come as a later step
• my only remaining doubt is about the name of the "function"