Mathematica equivalent to Python long raw strings? handling escape characters in packages

Question

I'd like to write the following in plain text .m file in Mathematica, without having to double escape all the Latex commands:

s = ToString["\\documentclass[12pt,titlepage]{article}
\\begin{document}
It is known that $\\sin(0)=" <> ToString[Sin[0]] <> "$
\\end{document}"];

Is there a way to do the above?

reference: How do I make a string literal without having to escape backslashes?

Answer 1

I had another answer to this question (now located here) that used the global variable $PreRead to convert raw strings to InputForm prior to evaluation. Unfortunately, that method only works when evaluating the package file interactively, as you would a notebook file. It does not work when loading a package with Get, because $PreRead is not applied to the expressions that are read in from the package file before they are evaluated.

On the other hand, if we are just interested in using raw strings in package files that are to be read in, we can easily preprocess the package files to replace raw strings as they are being read.

One method (possibly not for the faint of heart) is to overload Get for designated package files. Suppose we want to implement the Python raw string syntax for any package file whose name ends with _raw.m. In your init.m file, place the following code:

Unprotect[Get];

Get[file_String] /; StringMatchQ[file, "*_raw.m"] && FileType[file] === File :=
  ToExpression@StringReplace[
    Import[file, "Text"], 
    "r\"\"\"" ~~ Shortest[str__] ~~ "\"\"\"" :> ToString@InputForm@str
]

Protect[Get];

Now make a test package file test_raw.m with contents

s = r"""\documentclass[12pt,titlepage]{article}
\begin{document}
It is known that $\sin(0)=""" <> ToString[Sin[0]] <> r"""$
\end{document}"""

Print[s]

Now, at the command line,

$ math -script test_raw.m

returns

\documentclass[12pt,titlepage]{article}
\begin{document}
It is known that $\sin(0)=0$
\end{document}

It also works when using Get["test_raw.m"] or << test_raw.m. The "context" form <<test_raw` doesn't work; to get it to work we'd have to sacrifice the underscore in the file name, which isn't allowed in a context specifier. Then we'd want to lengthen the designator suffix, maybe to rawstring.m, to reduce the chance of other package files accidentally matching the pattern.

Answer 2

If I'm not mistaken, an approach like this may work for you:

clean = {
   "\t" -> "\\t",
   "\b" -> "\\b",
   "\n" -> "\\n"};

StringReplace["\begin{5}", clean]

If too many exceptions appear it may be easier to set up something with FromCharacterCode.

---

Interesting, I found that InputForm auto-strings its argument, like a string version of Hold:

In[1]:= InputForm["\t"]

Out[1]//InputForm= "\t"

In[2]:= InputForm["\t"] // ToString // Characters

Out[2]= {"\"", "\\", "t", "\""}

So maybe just this will work for you:

r = StringTrim[ToString[InputForm[#]], "\""] &;

r@"\t"

That this works through the function seems to imply certain things about where escape sequences are processed.

Answer 3

There is no direct equivalent to Python's r. So from the comments it's clear that we have to cheat in order to get this formatting to work purely in a text file environment. One obvious way to do it is as follows:

toString[x_]:=StringReplace[x,""->"\\"];
s = toString["documentclass[12pt,titlepage]{article}                                               
begin{document}                                                                                    
It is known that $sin(0)=" <> ToString[Sin[0]] <> "$                                               
end{document}"];
Export["snippet.tex",s,"Text"]

Here, I simply decided to replace the special character \ in the $\LaTeX$ code ("special" because it has catcode 0 in $\TeX$ and at the same time is used in newlines etc., which makes it hard to isolate in a string replacement) by a less special character that is never used for anything else, either in normal text or in $\TeX$. In the example, I chose , but you could for example also choose > or <, if you use standard $\LaTeX$ (because then you'll type \leq etc. instead of these symbols; of course, that would then become <leq).

The point of this exercise is that the single replacement character (such as ) is reasonably easy to type (I have to press Shift-Option-k to get that symbol) and equally easy to recognize as the prefix of a $\LaTeX$ command, compared to the original \. But now we can easily use StringReplace to do the ugly replacement by \\ behind the scenes. If you do it this way, you can choose any replacement character that is not already assigned a meaning either as a letter or a special catcode allowed to appear in $\LaTeX$.