Skip to Content
Author's profile photo Jerry Wang

Implicit parameter pass in Scala

Test code:

class Prefixer(val prefix: String){
  def addPrefix(s: String)(p: Prefixer) = p.prefix + s

Consumer code:

val myImplicitPrefixer = new Prefixer("***")
println(myImplicitPrefixer.addPrefix("abc")(myImplicitPrefixer))  // returns "***abc"

The implementation of Prefixer is combined to Java Byte code as below.

The argument list in Scala is converted into flat format (s: String)(p: Prefixer) as below:




The following two styles are actually equal:

def addPrefix(s: String, p: Prefixer) = p.prefix + s
def addPrefix(s: String) (p: Prefixer) = p.prefix + s

Now let’s make a little bit modification:

def addPrefix(s: String)(implicit p: Prefixer) = p.prefix + s

And consumer code:


Still ***abc is printed out. What’s the magic here?

When we debug into line 26, although in our application code, we only pass “abc” as parameter for method addPrefix.

The parameter p is filled with the reference myImplicitPrefixer marked with keyword implicit in line 25:


p actually points to the same reference of this:


This is the compiled byte code for method addPrefix, the implicit parameter p is already in the method’s signature.


And in the consumer code, the reference of Prefixer is automatically passed into addPrefix method:


One more point, the variable defined in class definition parameter will automatically become member of this class:



Assigned Tags

      Be the first to leave a comment
      You must be Logged on to comment or reply to a post.