how implicit keyword works in scala?

Question

I'm new in Scala but familiar with Java.

Please check this two methods

def jsonPar(name:String): ScallaopOption[Map[String, Map[String, String]]] : opt[Map[String, Map[String, String]]](name,required = true)(jsonMapper)
    
def jsonMapper : ValueConverter[Map[String, Map[String, String]]] = 
    scallop.singleArgConverter(json)

now there is opt method in ScallopConfBase class

def opt[A](name : scala.Predef.String, short : scala.Char, and so on upto 10 more params)(implicit conv : org.rogach.scallop.ValueConverter[A]) : org.rogach.scallop.ScallopopOption[A]

I'm stuck this code to understand, here are my concerns

1. opt needs to have 10 input params to execute, but in def jsonPar, only (name,required = true) is passed to opt, how ?

2. what's a importance of adding (implicit conv : org.rogach.scallop.ValueConverter[A]) : org.rogach.scallop.ScallopopOption[A] in opt method ?

3. what ScallaopOption[Map[String, Map[String, String]]] : opt[Map[String, Map[String, String]]](name,required = true)(jsonMapper) part is doing ?

can anyone share ? I'm trying to thing from java perspective, but still not able to understand.

Answer 1

Broadly, what implicit does is provide hints to the compiler to use when normal compilation fails.

For example, implicit conversions (which shouldn't generally be used) and implicit classes come into play when you try to call a method on an object whose type doesn't include that method. In that scenario, the compiler will, rather than reject the code immediately, search for an implicit conversion to a type which has that method and include a call to that conversion so that the method can be called. implicit classes work similarly (and use basically the same mechanism under the hood) as implicit conversions: if there's an implicit class available which can take that object as a constructor parameter, the compiler will effectively insert a new ImplicitClassName(originalObject).methodThatDoesntExistOnOriginalObject(...).

implicit parameters meanwhile rely on the idea of an implicit scope. If there's no explicitly provided argument for the implicit parameter, then the compiler will use an argument of that type from the implicit scope of the caller. Inside the method taking the implicit parameter, those parameters become part of the implicit scope so that that method can make calls using implicits.

The : ScallopOption[Map[String, Map[String, String]]] just means that the method returns a ScallopOption[Map[String, Map[String, String]]]. : ScallaopOption[Map[String, Map[String, String]]] : opt is not valid Scala; I suspect that the second : is an =.

You haven't provided the definition of opt, but it looks like it uses default parameters, so explicit parameters can be omitted in favor of the default values.