Strings & Interpolation

String is final and immutable, exactly as in Java. The methods of java.lang.String (length, charAt, indexOf, substring, toUpperCase, split, replace, matches…​) work unchanged. When a method is not found on String, the compiler looks for an implicit conversion and finds Predef.augmentString, which wraps the string in scala.collection.StringOps. StringOps is a value class, so the extra methods usually cost no allocation. It supplies the whole sequence API (take, drop, filter, map, reverse, foldLeft, exists, zip, sorted…​) treating the string as a sequence of Char, plus string-specific helpers (capitalize, stripPrefix, stripSuffix, stripMargin, toIntOption, toDoubleOption, *, linesIterator, format…​). When a method needs a real collection, the string is wrapped in a WrappedString instead (Predef.wrapString).

Source: Scala Collections Guide: Strings

Several details in the output matter in practice:

Concatenation with + converts the right-hand operand with toString, so "Hello" + 1 + 2 is Hello12, but 1 + 2 + "Hello" adds the numbers first. Adding a number on the left of a string with Int + String is deprecated since 2.13.0, and the compiler says so when -deprecation is on:

A literal delimited by three double quotes is a multiline string. It may span lines, may contain " characters without escaping, and does no escape processing: \n stays as two characters. Indentation inside the literal is kept, so the usual idiom is to start each continuation line with | and call stripMargin, which removes the whitespace and the first | of each line. stripMargin(c) uses another margin character.

Source: Scala 3 Book: String Interpolation

Note two things. First, a s"""...""" literal does process escapes, because the s interpolator does (next section), so \n became a real newline in the second example while the plain """a\nb""" kept the backslash. Second, a literal that starts with a newline produces an empty first element, as the List(, first, second) shows. The margin only applies to lines that begin (after whitespace) with the margin character; any other line is left untouched.

Prefixing a string literal with an identifier, id"...", makes the compiler call StringContext("...parts...").id(args*). The standard library defines three such methods on StringContext: s, f and raw. The s interpolator replaces $name with the toString of the value and ${expression} with the value of any expression, including blocks, conditionals and method calls. $name takes a plain identifier only; $t.name interpolates t and leaves .name as text, so use braces for member access.

Source: Scala 3 Book: The s interpolator (s strings)

Inside a single-quoted interpolated string the escape for a quote is the meta character $ itself. In Scala 2 there was no way to write a " inside s"..." (a backslash cannot work, because each interpolator decides how to treat backslashes, so the parser cannot know whether the " ends the literal); you had to switch to triple quotes. Scala 3 reads a dollar followed by a quote as an escaped quote, and a doubled dollar sign as an escaped dollar, in every interpolator, raw included (checked on 3.10.0: a raw literal containing a doubled dollar and 5 prints $5).

Like any other literal, an interpolated string can use triple quotes, so s"""Quote: "${t.name}" ok""" works with no escapes. Because s applies the standard escape processing (\n, \t, \", \\, \u0041), the s interpolator is the right default. ${...} can contain any expression but must be closed on the same literal; an unbalanced brace fails to compile with unclosed string literal and '}' expected, but eof found.

f"..." is a type-checked printf. Each $value may be followed immediately by a java.util.Formatter format specifier (%d, %5.2f, %-20s, %05d, %x, %,d…​). Without a specifier the format defaults to %s. A % that is not attached to an interpolated value must be doubled (%%) and %n is a newline. Unlike String.format, the compiler checks that the argument type fits the conversion, so mistakes are compile errors rather than runtime `IllegalFormatException`s:

Source: Scala 3 Book: The f interpolator (f strings)

The most common surprise is locale. f (like String.format) formats numbers with the JVM’s default locale. The earlier output 12,50 km came from a machine whose default locale is es_ES, which uses a decimal comma. Programs whose output is parsed by other programs, or compared in tests, should pin the locale:

Source: Scala 3 Book: The f interpolator (f strings)

"...".format(args*) and formatLocal(locale, args*) are the StringOps equivalents when the format string is not a literal. Use the interpolator when the format is a literal (you get checking), and format when it comes from data.

raw"..." performs the same substitutions as s but leaves backslash sequences exactly as written. It suits Windows paths and regular expressions, which otherwise need doubled backslashes. In the example above raw"C:\trails\new $grade" prints the backslashes, while the ordinary literal "C:\trails\new" turned \t into a tab and \n into a newline.

Source: Scala 3 Book: The raw interpolator

A triple-quoted literal is also unescaped, so """C:\trails\new""" and raw"""...""" are equivalent when you need no substitution. To put a literal " in a single-quoted raw literal use $".

Scala 3.10 adds the Java-style \s escape: it means one space (U+0020). String literals accept it, including in interpolators; raw keeps the two characters. Its purpose is to make trailing spaces visible and safe, for example in fixed-width records, where an editor that trims whitespace would silently shorten a line. It is a 3.10 feature and is not available on the 3.9 LTS or earlier lines.

Source: Scala 3.10 release notes: \s space escape

Other escapes are unchanged: \b \t \n \f \r \" \' \\, octal escapes are not supported ("\0" fails with octal escape literals are unsupported: use \u0000 instead), and Unicode escapes \uXXXX are processed by the compiler. A backslash followed by any other character, including a \ at the end of a line (Java’s text-block line continuation does not exist in Scala), is a compile error (invalid escape character).

Any identifier can be an interpolator. id"a${x}b${y}c" is compiled to StringContext("a", "b", "c").id(x, y), and StringContext.parts holds the literal fragments. In Scala 3 the idiomatic way to add one is an extension method on StringContext (Scala 2 used an implicit class). The method can return any type, so interpolators work as typed constructors; a val d = km"12.5" can build an opaque Km, a regular expression or a SQL statement.

Interpolators can also appear in patterns: id"a$x-$y" in a pattern is compiled to a call of StringContext(...).id.unapplySeq(scrutinee). The standard s interpolator already works that way, which is useful for parsing simple text without a regular expression:

Source: Scala 3 Book: Custom interpolators

Points to remember about patterns:

Adding .runtimeChecked (as in the example) tells the compiler that a MatchError is acceptable; otherwise write a match with a fallback case. A custom pattern interpolator needs a class with unapplySeq/unapply, because the pattern hut"Hut:$name" desugars to StringContext("Hut:", "").hut.unapplySeq(...), which is why hut returns an object rather than a value.

When the literal can be validated at compile time, an inline or macro-based implementation turns mistakes into compile errors; see Inline. Third-party libraries such as Scalameta (quasiquotes), Doobie (sql) and sttp (uri) are built on this mechanism.

Dedented string literals implement SIP-72 as an experimental feature of Scala 3.10. They add a ''' multiline literal that strips indentation in the language, so you no longer need stripMargin. The opening ''' must be followed by a newline and the closing one must be preceded by a newline and whitespace. The compiler removes the first newline, the last newline with the whitespace before the closing delimiter, and the common indentation up to the column of the closing delimiter. Lines may not be indented less than the closing delimiter. s'''...''' and f'''...''' work the same way. Because the feature is experimental, it has to be switched on, either with the import language.experimental.dedentedStringLiterals or with the compiler option -language:experimental.dedentedStringLiterals; it is not part of the 3.9 LTS and may change or be removed. Do not use it in library code.

Source: Scala 3 Reference: Dedented String Literals

Without the flag ''' is not a string at all; the compiler reads it as empty character literals and reports errors such as empty character literal (use '\'' for single quote) and unclosed character literal.

Scala 2.13 differs from Scala 3 only in details: $" is not accepted (use triple quotes), the .runtimeChecked guidance for refutable pattern bindings does not exist, and custom interpolators are written with implicit class wrappers. The cross-building implications are in Scala 2 & Scala 3 Compatibility.

Older Scala books describe string interpolation as a Scala 2.10 feature and show implicit class wrappers for custom interpolators; in Scala 3 prefer an extension on StringContext as above. They also predate $", \s and dedented strings, the .runtimeChecked guidance for refutable pattern bindings, and the 2.13 collection overhaul (StringOps is a value class built on the new collections, and the JDK 11 String.lines now shadows the old Scala lines). Check any listing from a book against the official pages below, which track the current release.