case class StringContext(parts: String*) extends Product with Serializable
This class provides the basic mechanism to do String Interpolation. String Interpolation allows users to embed variable references directly in *processed* string literals. Here's an example:
val name = "James" println(s"Hello, $name") // Hello, James
Any processed string literal is rewritten as an instantiation and method call against this class. For example:
s"Hello, $name"
is rewritten to be:
StringContext("Hello, ", "").s(name)
By default, this class provides the raw
, s
and f
methods as
available interpolators.
To provide your own string interpolator, create an implicit class
which adds a method to StringContext
. Here's an example:
implicit class JsonHelper(private val sc: StringContext) extends AnyVal { def json(args: Any*): JSONObject = ... } val x: JSONObject = json"{ a: $a }"
Here the JsonHelper
extension class implicitly adds the json
method to
StringContext
which can be used for json
string literals.
- parts
The parts that make up the interpolated string, without the expressions that get inserted by interpolation.
- Source
- StringContext.scala
- Alphabetic
- By Inheritance
- StringContext
- Serializable
- Product
- Equals
- AnyRef
- Any
- by any2stringadd
- by StringFormat
- by Ensuring
- by ArrowAssoc
- Hide All
- Show All
- Public
- Protected
Instance Constructors
Value Members
- macro def f[A >: Any](args: A*): String
The formatted string interpolator.
The formatted string interpolator.
It inserts its arguments between corresponding parts of the string context. It also treats standard escape sequences as defined in the Scala specification. Finally, if an interpolated expression is followed by a
parts
string that starts with a formatting specifier, the expression is formatted according to that specifier. All specifiers allowed in Java format strings are handled, and in the same way they are treated in Java.For example:
val height = 1.9d val name = "James" println(f"$name%s is $height%2.2f meters tall") // James is 1.90 meters tall
- Exceptions thrown
IllegalArgumentException
if the number ofparts
in the enclosingStringContext
does not exceed the number of argumentsarg
by exactly 1.if a
parts
string contains a backslash (\
) character that does not start a valid escape sequence. Note: Thef
method works by assembling a format string from all theparts
strings and usingjava.lang.String.format
to format all arguments with that format string. The format string is obtained by concatenating allparts
strings, and performing two transformations:- Let a _formatting position_ be a start of any
parts
string except the first one. If a formatting position does not refer to a%
character (which is assumed to start a format specifier), then the string format specifier%s
is inserted. 2. Any%
characters not in formatting positions must begin one of the conversions%%
(the literal percent) or%n
(the platform-specific line separator).
- Let a _formatting position_ be a start of any
- val parts: String*
- def productElementNames: Iterator[String]
An iterator over the names of all the elements of this product.
An iterator over the names of all the elements of this product.
- Definition Classes
- Product
- macro def raw(args: Any*): String
The raw string interpolator.
The raw string interpolator.
It inserts its arguments between corresponding parts of the string context. As opposed to the simple string interpolator
s
, this one does not treat standard escape sequences as defined in the Scala specification.For example, the raw processed string
raw"a\nb"
is equal to the scala string"a\\nb"
.Note: Even when using the raw interpolator, Scala will process Unicode escapes. Unicode processing in the raw interpolator is deprecated as of scala 2.13.2 and will be removed in the future For example:
scala> raw"\u005cu0023" res0: String = #
- Exceptions thrown
IllegalArgumentException
if the number ofparts
in the enclosingStringContext
does not exceed the number of argumentsarg
by exactly 1.- Note
The Scala compiler may replace a call to this method with an equivalent, but more efficient, use of a StringBuilder.
- macro def s(args: Any*): String
The simple string interpolator.
The simple string interpolator.
It inserts its arguments between corresponding parts of the string context. It also treats standard escape sequences as defined in the Scala specification. Here's an example of usage:
val name = "James" println(s"Hello, $name") // Hello, James
In this example, the expression $name is replaced with the
toString
of the variablename
. Thes
interpolator can take thetoString
of any arbitrary expression within a${}
block, for example:println(s"1 + 1 = ${1 + 1}")
will print the string
1 + 1 = 2
.- Exceptions thrown
IllegalArgumentException
if the number ofparts
in the enclosingStringContext
does not exceed the number of argumentsarg
by exactly 1.StringContext.InvalidEscapeException
if aparts
string contains a backslash (\
) character that does not start a valid escape sequence.- Note
The Scala compiler may replace a call to this method with an equivalent, but more efficient, use of a StringBuilder.
- object s
Deprecated Value Members
- def checkLengths(args: collection.Seq[Any]): Unit
- Annotations
- @deprecated
- Deprecated
(Since version 2.13.0) use same-named method on StringContext companion object
- def standardInterpolator(process: (String) => String, args: Seq[Any]): String
- Annotations
- @deprecated
- Deprecated
(Since version 2.13.0) Use the static method StringContext.standardInterpolator instead of the instance method
This is the documentation for the Scala standard library.
Package structure
The scala package contains core types like
Int
,Float
,Array
orOption
which are accessible in all Scala compilation units without explicit qualification or imports.Notable packages include:
scala.collection
and its sub-packages contain Scala's collections frameworkscala.collection.immutable
- Immutable, sequential data-structures such asVector
,List
,Range
,HashMap
orHashSet
scala.collection.mutable
- Mutable, sequential data-structures such asArrayBuffer
,StringBuilder
,HashMap
orHashSet
scala.collection.concurrent
- Mutable, concurrent data-structures such asTrieMap
scala.concurrent
- Primitives for concurrent programming such asFutures
andPromises
scala.io
- Input and output operationsscala.math
- Basic math functions and additional numeric types likeBigInt
andBigDecimal
scala.sys
- Interaction with other processes and the operating systemscala.util.matching
- Regular expressionsOther packages exist. See the complete list on the right.
Additional parts of the standard library are shipped as separate libraries. These include:
scala.reflect
- Scala's reflection API (scala-reflect.jar)scala.xml
- XML parsing, manipulation, and serialization (scala-xml.jar)scala.collection.parallel
- Parallel collections (scala-parallel-collections.jar)scala.util.parsing
- Parser combinators (scala-parser-combinators.jar)scala.swing
- A convenient wrapper around Java's GUI framework called Swing (scala-swing.jar)Automatic imports
Identifiers in the scala package and the
scala.Predef
object are always in scope by default.Some of these identifiers are type aliases provided as shortcuts to commonly used classes. For example,
List
is an alias forscala.collection.immutable.List
.Other aliases refer to classes provided by the underlying platform. For example, on the JVM,
String
is an alias forjava.lang.String
.