Let's see how we can pass an array as argument smoothly.
We are going to see an example when this syntax shine the most: nested Node creation.
Do you experience the pain of writing Node(List(Node(List(...
. Not pleasant huh ?!
But never again you will have to do this now that you know about *
!
Let's see how it works:
In a function, you can have TYPE*
to take all the last parameters given to the function and turn it into an array. If you place the argument of the method with TYPE*
not as last argument you will get an exception *-parameter must come last
.
After doing this, instead of doing foo(List(a,b,c))
you are able to do foo(a,b,c)
. And inside the body of the method you can use the parameter the same as before.
But now, let's say in some part of your code you do have a List
already but you have changed the method, you want to convert the List
into a *-parameter
.
The weird syntax to do this is: foo(list:_*)
. It means you are casting (changing the type) , with :
into _
which is a wildcard, so anything, in this case, the anything being the type A
of the list which should be the same as the input type of the method A*
, and finally *
.
If we look at the type only we are doing this:
list : _* List[A] : A*
If I didn't explain well, please feel free to reach out on the Discord server so we can improve the content of this article together.