What is the purpose of {} in the returning type of a function?

Question

In the following function declaration:

def f(x: Int): Int {} = x + 1

what is the purpose of {}?

The result of the method invocation is the same with or without the curly braces.

Answer 1

It's just an empty refinement. In Scala any type can have a refinement, that constrains the definitions of members (e.g., types, vals, defs) of the original type.

For example:

trait Base { type T }

type BaseInt = Base { type T = Int }

Those members don't have to be defined in any base type, the refined type can itself define new members. And there are no restrictions on the type being refined, it is allowed to refine AnyVal or any of its subtypes. So the following code is perfectly legal:

type A = Int { type C = Boolean; val a: String }

According to the Scala specification:

If no refinement is given, the empty refinement is implicitly added, i.e. T1 with … with Tn is a shorthand for T1 with … with Tn {}.

So in your code Int {} is the same as Int.

---

Also, according to the specification, two types are considered equal if their refinements match exactly. So the following code results in a compile-time error:

scala> type A = Int { type C = Boolean; val a: String }
defined type alias A

scala> val a: A = 10 
<console>:12: error: type mismatch;
 found   : Int(10)
 required: A
    (which expands to)  Int{type C = Boolean; val a: String}
       val a: A = 10
                  ^

But as those refinements don't exist at runtime due to erasure, all casts are perfectly legal, if you don't use the members from refinements:

scala> val a: A = 10.asInstanceOf[A] 
a: A = 10

This feature can be used to implement tagged types, that are the same and represented by some primitive type at runtime, but can be distinguished at compile time.