The following is a function, f(a:Int, b:Int). We can call this function using the named parameter syntax: f(a = 5, b=10). If we swap the parameters but leave the correct names, the method will still be correct.

It is possible to combine positional and named function calls—the first few arguments can be positional.

For example:

def f(x:Int, y:Int) = x*2 + y
f(x=1,y=2) // 4
f(y=1,x=2) // 5

When specifying a function, we can set default parameters. Then, later, when we call this function, we can omit parameters and the compiler will substitute defaults:

def f(x:Int, y:Int=2) = x*2 + y
f(1) // 4

It is possible to create a comfortable API with the help of the combination of named and default arguments. For example, for case classes with N components, the compiler generates a copy method with N arguments; all of them have defaults:

case class Person(firstName: String, lastName: String)
val p1 = Person("Jon","Bull")
val p2 = p1.copy(firstName = "Iyan")

Now, let's transform code in the Or and Otherwise combinators to use the copy method instead of the Processed constructor.

The full code looks like this:

case class Or(frs: ChatbotMode, snd: ChatbotMode) extends ChatbotMode{
override def process(message: String, 
           effects: EffectsProvider): LineStepResult = {
   frs.process(message, effects) match {
   case processed@Processed(answer,nextMode,endOfDialog) =>
   processed.copy(nextMode = Or(nextMode,snd))
   case Failed => snd.process(message,effects) match {
   case processed@Processed(answer,nextMode,endOfDialog) =>
   processed.copy(nextMode=Or(nextMode,frs))
   case Failed => Failed
   }
   }
   }
   }
}

Currying is a term used for describing the transformation of a function with multiple arguments into a function with one argument. We will describe this process in detail in the next chapter.

It is vital for syntax that we can use multiple argument lists:

def f1(x:Int,y:Int) = x + y 
def f2(x:Int)(y:Int) = x + y

Here, f2 is in its curried form. It has the same semantics as f1, but can be called with a different syntax. This is useful when you need visually separate arguments.

The following table shows the various magic methods: