What are all the instances of syntactic sugar in Scala?

What are all the instances of syntactic sugar in Scala?

They are hard to search for since most/all of them are purely symbols and are thus hard to search for without knowing the name of the concept.

TODO:

• Implicit conversions
• _ syntax for anonymous functions
• Other things I'm forgetting

Basics:

• a b is equivalent to a.b.

• a b c is equivalent to a.b(c), except when b ends in :. In that case, a b c is equivalent to c.b(a).

• a(b) is equivalent to a.apply(b) This is why the following definitions for an anonymous functions are identical:

  val square1 = (x: Int) => x*x
  val square2 = new Function1[Int,Int] {
      def apply(x: Int) = x*x
  }
  

  When calling square1(y), you are actually calling square1.apply(y) which square1 must have as specified by the Function1 trait (or Function2, etc...)

• a(b) = c is equivalent to a.update(b,c). Likewise, a(b,c) = d is equivalent to a.update(b,c,d) and so on.

• a.b = c is equivalent to a.b_=(c). When you create a val/var x in a Class/Object, Scala creates the methods x and x_= for you. You can define these yourself, but if you define y_= you must define y or it will not compile, for example:

  scala> val b = new Object{ def set_=(a: Int) = println(a) }
  b: java.lang.Object{def set_=(Int): Unit} = $anon$1@17e4cec
  
  scala> b.set = 5
  <console>:6: error: value set is not a member of java.lang.Object{def set_=(Int): Unit}
         b.set = 5
           ^
  
  scala> val c = new Object{ def set = 0 ; def set_=(a:Int) = println(a) }
  c: java.lang.Object{def set: Int; def set_=(Int): Unit} = $anon$1@95a253
  
  scala> c.set = 5
  5
  

• -a corresponds to a.unary_-. Likewise for +a,~a, and !a.

• a <operator>= b, where <operator> is some set of special characters, is equivalent to a = a <operator> b only if a doesn't have the <operator>= method, for example:

  class test(val x:Int) {
      def %%(y: Int) = new test(x*y)
  }
  
  var a = new test(10)
  a.x // 10
  a %%= 5 // Equivalent to a = a %% 5
  a.x // 50
  

Special Classes: Tuples and Symbols

As mentioned by Rahul G, tuples and symbols get a slightly special syntax.

• Symbols: the syntax 'x is short for Symbol("x")
• Tuples: (p1,p2,..,pn) is short for a case class Tuplen[T1,T2,..,Tn](p1,p2,..,pn)

For example, the following two are equivalent.

val tuple1 = ("Hello",1)
val tuple2 = Tuple2[String,Int]("Hello",1)

In addition to Jaxkson's answer:

• type F[A,B] can be used as A F B.

For example:

type ->[A,B] = (A,B)
def foo(f: String -> String)

• Using => type in a method definition makes the compiler wrap expressions inside the method call in a function thunk.

For example

def until(cond: => Boolean)(body: => Unit) = while(!cond) body

var a = 0
until (a > 5) {a += 1}

Extractors:

There are two methods used for extractors, unapply and unapplySeq. These are used in multiple variable assignments and pattern matching.

• The first use case is where unapply takes the object it is supposed to match and returns a Boolean based on whether or not it matches, for example,

    trait Gender
    trait Male extends Gender
    trait Female extends Gender
    object Male extends Male
    object Female extends Female
    class Person(val g: Gender, val age: Int)
  
    object Adult {
        def unapply(p: Person) = p.age >= 18
    }
  
    def check(p: Person) = p match {
        case Adult() => println("An Adult")
        case _ => println("A Child")
    }
  
    //Will print: An Adult since Adult.unapply returns true.
    check(new Person(Female, 18))
  
    //Will print: A Child as it falls through to the _ case.
    check(new Person(Male, 17))
  

Honestly, I don't really get the purpose of the above syntax since it can be done almost just as easily by just putting the code in the case statements. Of course if you have a better example, leave a comment below

• The general case where unapply takes some fixed-number of parameters and returns either an Option[T] for a single parameter or a Option[(p1,p2,...)] for multiple, i.e. a Tuple with the matched values, for example, continuing from the above code:

    object Person {
        def apply(g: Gender, age: Int) = new Person(g, age)
        def unapply(p: Person) = if(p.age < 0) None else Some((p.g, p.age))
    }
  
    //Using Person.apply as described in the Basics section
    val alice = Person(Female, 30)
    val bob = Person(Male, 25)
  
    //This calls Person.unapply(alice), which returns Some((Female, 30)).
    //alice_gender is assigned Female and alice_age 30.
    val Person(alice_gender, alice_age) = alice
  
    bob match {
        //Calls Person.unapply(bob), but sees that g is Male, so no match.
        case Person(Female, _) => println("Hello ma'am")
        //Calls Person.unapply(bob) and assigns age = bob.age, but it doesn't pass
        //the 'if' statement, so it doesn't match here either.
        case Person(Male, age) if age < 18 => println("Hey dude")
        //So bob falls through to here
        case _ => println("Hello Sir")
    }
  
    Person(Male,-1) match {
        //Person.unapply(Person.apply(Male,-1)) returns None because p.age < 0.
        //Therefore this case will not match.
        case Person(_, _) => println("Hello person")
        //Thus it falls through to here.
        case _ => println("Are you Human?")
    }
  

Note: Case classes do all those apply/unapply definitions for you (as well as other stuff) so use them whenver possible to save time and reduce code.

• unapplySeq. This works similarly to unapply as above, except it must return an Option of some kind of sequence.

As a quick example,

scala> List.unapplySeq(List(1,2,3))
res2: Some[List[Int]] = Some(List(1, 2, 3))

Anonymous functions:

_ + _ is short for (a, b) => a + b

Context bounds desugar into implicit parameters, e.g. consider a function that leverages the Monoid type class:

def suml[T: Monoid](xs: List[T]) = {
  val T = implicitly[Monoid[T]]
  xs.foldLeft(T.mzero)(T.mplus)
}

where the : Monoid part is a context bound, gets translated to:

def suml[T](xs: List[T])(implicit evidence$1: Monoid[T]]) = {
  ...
}

therefore the following compiles, too:

def suml[T: Monoid](xs: List[T]) = {
  val T = evidence$1
  ...
}