Accepted answer

This is a bug in Scala:

escape does not work with string interpolation

but maybe you can use:

scala> import org.apache.commons.lang.StringEscapeUtils.escapeJava
import org.apache.commons.lang.StringEscapeUtils.escapeJava

scala> escapeJava("this is a string\nover two lines")
res1: java.lang.String = this is a string\nover two lines


Taking @Pascalius suggestion a few steps further. class StringImprovements extends and inherits AnyVal.

object StringUtil{
    implicit class StringImprovements(val s: String) extends AnyVal {
        def dqt = "\""+s+"\""    // double quote
        def sqt = s"'$s'"        // single quote

Scala only uses the StringImprovements class to create an intermediate object on which to call implicitly the two extension methods dqt & sqt. Nevertheless, we can eliminate the creation of this object and improve performance by making the class inherit from AnyVal. For Scala provides the value type specifically for such cases where the compiler will replace the object by just making the call to the method directly.

Here is a simple example using the above implicit class in an intermix where we use named variables (string & boolean) and a function in the interpolation string.

import StringUtil._
abstract class Animal {
   override def toString(): String = s"Animal:${getFullName().dqt}, CanFly:$canFly, Sound:${getSound.dqt}"


It's heavily used in my case, therefore I created this version:

object StringUtil{
    implicit class StringImprovements(s: String) {
        def quoted = "\""+s+"\""

val myStatement = s"INSERT INTO ${tableName.quoted} ..."


How about

s"This is ${"\"" + variable + "\""}" inserted in string with quotes


Starting Scala 2.13.6 escaped double quotes work as expected in string interpolations

Welcome to Scala 2.13.6 (OpenJDK 64-Bit Server VM, Java 15.0.2).
Type in expressions for evaluation. Or try :help.

scala> s"\"Hello\""
val res0: String = "Hello"

scala> s"$"Hello$""
val res1: String = "Hello"


As already mentioned, this is a known bug in Scala. A workaround is to use \042.


Simple way:-

val str="abc"
println(s"$str") //without double quotes
println(s"""\"$str\"""") // with double quotes


For your use case, they make it easy to achieve nice syntax.

scala> implicit class `string quoter`(val sc: StringContext) {
     | def q(args: Any*): String = "\"" + sc.s(args: _*) + "\""
     | }
defined class string$u0020quoter

scala> q"hello,${" "*8}world"
res0: String = "hello,        world"

scala> "hello, world"
res1: String = hello, world       // REPL doesn't add the quotes, sanity check

scala> " hello, world "
res2: String = " hello, world "   // unless the string is untrimmed

Squirrel the implicit away in a package object somewhere.

You can name the interpolator something besides q, of course.

Last week, someone asked on the ML for the ability to use backquoted identifiers. Right now you can do res3 but not res4:

scala> val `"` = "\""
": String = "

scala> s"${`"`}"
res3: String = "

scala> s"hello, so-called $`"`world$`"`"
res4: String = hello, so-called "world"

Another idea that just occurred to me was that the f-interpolator already does some work to massage your string. For instance, it has to handle "%n" intelligently. It could, at the same time, handle an additional escape "%q" which it would not pass through to the underlying formatter.

That would look like:

scala> f"%qhello, world%q"
<console>:9: error: conversions must follow a splice; use %% for literal %, %n for newline

That's worth an enhancement request.

Update: just noticed that octals aren't deprecated in interpolations yet:

scala> s"\42hello, world\42"
res12: String = "hello, world"


This fixed the problem for me, I tested this out and this is what I used.

   Inside this block you can put "as many" quotes as you "want" and even "${5 + 7}" interpolate inside the quotes 


An example:

scala> val username="admin"
> username: String = admin

scala> val pass="xyz"
> pass: String = xyz

scala> println(s"""{"username":"$username", "pass":"$pass"}""")
> {"username":"admin", "pass":"xyz"}


Another solution (also mentioned in the Scala tracker) is to use

case _ => s"${'"'}$value${'"'}"

Still ugly, but sometimes perhaps may be preferred over triple quotes.

It seems an escape sequence $" was suggested as a part of SIP-24 for 2.12:

case _ => s"$"$value$""

This SIP was never accepted, as it contained other more controversial suggestions. Currently there is an effort to get escape sequence $" implemented in 2.13 as Pre SIP/mini SIP $” escapes in interpolations.


You don't need to escape quotes in triple-quoted string, so s""""$value""""" will work. Admittedly, it doesn't look good either.

Related Query

More Query from same tag