Share
Embed
Transcript
31 slides
-
String Interpolation in Scala 2.10 Anthony M. Sloane Programming Languages
Research Group Department of Computing Macquarie University [email protected] [email protected] @inkytonik February 13, 2013 -
Overview Scala strings: before and after Implementing your own string
interpolators Pattern matching Syntax checking Concrete object syntax -
Scala strings string literals "A string on one line" """A
long string with only Unicode escapes and possibly newlines in it""" constructing strings "The " + animal1 + " jumped over the " + animal2 "The %s jumped over the %s".format (animal1 , animal2) -
New in 2.10: inline expression insertion (s, raw) val answer
= 42 println (s"answer is $answer , dollar is $$") val animal1 = "fox" val animal2 = "dog" println (s"The $animal1 jumped over the $animal2") println (s"One plus one is ${1 + 1}") println (s"The inserted expressions are blocks ${ val x = "!" x * 3 }") answer is 42, dollar is $ The fox jumped over the dog One plus one is 2 The inserted expressions are blocks !!! -
New in 2.10: formatted insertion (f) val pi = 3.14159
println (f"pi ($pi) = $pi %1.3f") val msg = "G’day!" println (f"msg.length = ${msg.length }%5d") pi (3.14159) = 3.142 msg.length = 6 expressions are type-checked against their format specifier f"msg can’t be formatted as $msg %1.3f" -
How does it work? syntactic sugar id"text0${expr1}text1 ... ${exprn}textn" becomes
StringContext ("text0", "text1", ... , "textn").id ( expr1 , ... , exprn) e.g., the StringContext.s method returns esc ("text0") + (expr1) + esc ("text1") ... + (exprn) + esc ("textn") where esc performs escape sequence processing -
(Digression) Implicit conversions class MyInt (val i : Int) {
def sayhello = s"Hello there: $i" } implicit def ImplicitConversion (i : Int) : MyInt = new MyInt (i) println (42. sayhello) Hello there: 42 -
(Digression) New in 2.10: implicit classes implicit class MyInt (i
: Int) { def sayhello = s"Hello there: $i" } println (42. sayhello) Hello there: 42 -
Writing our own interpolator implicit class ReverseC (val sc :
StringContext ) { def rev (args : Any*) : String = { val orig = sc.s (args : _*) orig.reverse } } val msg = "Hello world!" println (rev"Backwards version of $msg") !dlrow olleH fo noisrev sdrawkcaB -
Constructing values that are not strings case class Count (num
: Int) implicit class SpaceCountC (val sc : StringContext ) { def nspaces (args : Any*) : Count = { val orig = sc.s (args : _*) Count (orig.count (_.isSpaceChar)) } } val msg1 = "Hello world!" val msg2 = s"a b $msg1 c d" println (nspaces"$msg1") println (nspaces"$msg2") Count (1) Count (5) -
Octal number literals implicit class OctalC (val sc : StringContext
) { def o () : Int = { val orig = sc.s () val OctalNum = "[0 -7]+".r orig match { case OctalNum () => Integer.parseInt (orig , 8) case _ => sys.error ("Can only contain 0-7 characters") } } } -
Run-time syntax checking println (o"177") println (o"49") 127 java.lang. RuntimeException
: Can only contain 0-7 characters at scala.sys.package$.error(package.scala :27) at Octal$OctalC .o(Octal.scala :11) at Octal$.main(Octal.scala :18) -
Compile-time checking using a macro import scala.language.experimental .macros import scala.reflect.macros.Context
implicit class OctalC (val sc : StringContext ) { def o () : Int = macro OctalImpl.oImpl } -
Macro implementation: access the prefix tree OctalMacros.OctalC ( scala. StringContext.apply
( "177")).o () def oImpl (c : Context) () : c.Expr[Int] = { import c.{ universe => u} import u._ val Apply (_, List ( Apply (_, List ( Literal (Constant (orig : String)))))) = c.prefix.tree -
Macro implementation: check, construct or complain val OctalNum = "[0
-7]+".r orig match { case OctalNum () => c.Expr[Int] ( Literal ( Constant ( Integer.parseInt (orig , 8)))) case _ => c.error (c.enclosingPosition , "Must only contain 0-7 characters") reify (0) } -
Use the macro-based interpolator object OctalWithMacro { import OctalMacros.OctalC def
main (args : Array[String ]) { println (o"177") } } 127 OctalWithMacro .scala :8: error: Must only contain 0-7 characters println (o"49") ^ -
The other side of the coin: pattern matching id"text0${pat1}text1 ...
${patn}textn" becomes StringContext ("text0", "text1", ... , "textn").id ( pat1 , ... , patn) id is an extractor object Combine construction and pattern matching together in a single object with both apply and unapply/unapplySeq methods -
(Digression) Extractor objects case class Foo (i : Int ,
s : String) e match { case Foo (p1 , p2) => ... } A call Foo.unapply (e) is made which either returns None if e is not matched, or Some ((v1, v2)) if it matches with two pieces v1 and v2. v1 and v2 are recursively matched against p1 and p2 -
A version of s that also pattern matches implicit class
MySC (val sc : StringContext ) { object mys { def apply (args : Any*) : String = sc.s (args : _*) def unapplySeq (s : String) : Option[Seq[String ]] = { val regexp = sc.parts.mkString ("(.+)").r regexp.unapplySeq (s) } } } -
Using interpolated pattern matching println (mys"One plus one is ${1
+ 1}") val msg = "The sky is blue" match { case mys"The $thing is $colour" => mys"A $colour thing is $thing" case _ => "no match" } println (msg) One plus one is 2 A blue thing is sky -
Concrete object syntax Extend these ideas to more complex languages
Use a proper parser to ensure that the interpolation is legal Use a macro to get compile-time checking Convenient for writing programs that manipulate other programs: compilers optimisers static analysis tools staged computation -
Expression construction examples println (exp"a + 1") val v :
Expression = IdnExp (IdnUse ("a")) println (exp"$v + $v") val w = exp"$v + 1" val x = StarExp (w, IntExp (2)) println (exp"${x.left} + 2 * $v") PlusExp(IdnExp(IdnUse(a)),IntExp (1)) PlusExp(IdnExp(IdnUse(a)),IdnExp(IdnUse(a))) PlusExp(PlusExp(IdnExp(IdnUse(a)),IntExp (1)),StarExp( IntExp (2),IdnExp(IdnUse(a)))) -
Statement construction examples println (stm"a = a + 1;") val
o : Expression = exp"1"; val v : Expression = exp"a"; val w : Statement = stm"a = $v + $o;" println (w) println (stm"while ($o) $w") VarAssign(IdnUse(a),PlusExp(IdnExp(IdnUse(a)),IntExp (1))) VarAssign(IdnUse(a),PlusExp(IdnExp(IdnUse(a)),IntExp (1))) While(IntExp (1),VarAssign(IdnUse(a),PlusExp(IdnExp( IdnUse(a)),IntExp (1)))) -
Syntax error examples val v : Expression = exp"a" MiniJavaWrong
.scala :8: error: expression expected println (exp"2 + ") ^ MiniJavaWrong .scala :9: error: statement expected println (stm"a := $v + 1") ^ MiniJavaWrong .scala :10: error: statement expected println (stm"while (1) $v") ^ -
Expression pattern matching examples val e = exp"1 + 2"
e match { case exp"1 + 2" => println ("match") case _ => println ("no match") } e match { case exp"$p" => println (s"p=$p") } e match { case exp"$l + $r" => println (s"l=$l r=$r") case _ => println ("no match") } match p=PlusExp(IntExp (1),IntExp (2)) l=IntExp (1) r=IntExp (2) -
Nested expression pattern matching (1) val e = exp"1 *
2 + a" e match { case exp"$l + $r" => println (s"l=$l r=$r") case _ => println ("no match") } e match { case exp"$ll * $lr + $r" => println (s"ll=$ll lr=$lr r=$r") case _ => println ("no match") } e match { case exp"$l * $r" => println (s"l=$l r=$r") case _ => println ("no match") } l=StarExp(IntExp (1),IntExp (2)) r=IdnExp(IdnUse(a)) ll=IntExp (1) lr=IntExp (2) r=IdnExp(IdnUse(a)) no match -
Nested expression pattern matching (2) def trymatch (x : Expression)
{ x match { case exp"${IntExp (l)} + ${IntExp (r)}" => println (s"l=$l r=$r") case _ => println ("no match") } } trymatch (exp"1 + 2") trymatch (exp"a + 2") l=1 r=2 no match -
Statement pattern matching examples val s = stm"a = a
+ 1;" s match { case stm"a = $e;" => println (s"e=$e") case _ => println ("no match") } s match { case stm"a = $e + 1;" => println (s"e=$e") case _ => println ("no match") } val t = stm"while (1) a = a + 1;" t match { case stm"while ($e) $s" => println (s"e=$e s=$s") case _ => println ("no match") } e=PlusExp(IdnExp(IdnUse(a)),IntExp (1)) e=IdnExp(IdnUse(a)) e=IntExp (1) s=VarAssign(IdnUse(a),PlusExp(IdnExp( IdnUse(a)),IntExp (1))) -
Concrete object syntax is a work in progress Still to
be packaged into an easily reusable unit Macro code yet to be fine-tuned More type signatures are needed than we would like Pattern matching relies on a feature of the nightly Scala distribution -
Further reading at http://docs.scala-lang.org String interpolation Overview: overviews/core/string-interpolation.html SIP 11:
sips/pending/string-interpolation.html Reflection: overviews/reflection/overview.html Macros: overviews/macros/overview.html