Obtaining array element in Scala works only with explicit apply method

Question

Accessing collection elements in Scala is done by apply method. Having said that I tried to read numbers from standard input and get the second one as int in just one line.

  def main(args: Array[String]): Unit = {
    val number = StdIn.readLine().split(" ").map(_.toInt)(1)
  }

IntelliJ marks this 1 and show the error (the same is shown after the compilation attempt):

Error:(11, 60) type mismatch; found : Int(1) required: scala.collection.generic.CanBuildFrom[Array[String],Int,?] val number = StdIn.readLine().split(" ").map(_.toInt)(1)

Folding the expression in the parentheses dosn't help as well. However, when I split mapping input to int array and getting the element to other lines, everything works fine.

  def main(args: Array[String]): Unit = {
    val numbers = StdIn.readLine().split(" ").map(_.toInt)
    numbers(1)
  }

The explicit invocation of apply also does the job:

val number = StdIn.readLine().split(" ").map(_.toInt).apply(1)

Why does this weird behaviour happens? Obtaining element via array(5) is just a shortcut for array.apply(5), isn't it?

Community · Accepted Answer · 2017-05-23 11:53:35Z

3

As compiler already pointed out, map is defined with two arg lists. second one containing a single implicit param: implicit bf: CanBuildFrom[Repr, B, That]

For a vast majority of scenarios, the users don't worry about specifying the second arg. Specifically, in your case this is what the compiler "figures out":

StdIn.readLine().split(" ").map(_.toInt)(Array.canBuildFrom[Int])

So, if writing out apply is not desired then the following is the only choice:

StdIn.readLine().split(" ").map(_.toInt)(Array.canBuildFrom[Int])(1)

It's a bit counter-intuitive that adding a set of parentheses still doesn't quite do the trick:

( StdIn.readLine().split(" ").map(_.toInt) )(1)  //does not compile, same error

Perhaps it's best to demonstrate what's going with a simpler example. Consider the following function:

def add(x:Int)(y:Int) = x + y

The type of add(2) is Int => Int (since we haven't specified y). Note that adding a set of parentheses around it doesn't change the return type, i.e. (add(2)) still has a type Int => Int. Similarly, (Array("1").map(_.toInt))(1) still requires an instance of CanBuildFrom before using shorthand for apply.

Suggested reading about Scala collections:

and implicit scope:

Scala Specification <- as comprehensive as it gets
Where does Scala look for implicits?

edited May 23, 2017 at 11:53

CommunityBot

11 silver badge

answered Nov 11, 2016 at 18:19

Andrey

9,14010 gold badges62 silver badges83 bronze badges

Sign up to request clarification or add additional context in comments.

4 Comments

Joe Pallas Over a year ago

The thing that's mysterious (at least to me) is why does val number = (StdIn.readLine().split(" ").map(_.toInt))(1) not work? The search for the implicit parameter extends outside the parentheses as if they are not there. I can't find an explanation in the Scala spec.

Andrey Over a year ago

@JoePallas updated my answer, hopefully that clears up the confusion.

Joe Pallas Over a year ago

the updated answer opens a can of worms because I'm not sure we can talk about the type of add(2) without doing the explicit eta-expansion add(2) _. And it looks like that's where part of the confusion comes from: implicit resolution occurs before eta-expansion (stackoverflow.com/a/18635935/3851755). Interestingly, that leads to an alternative solution: (StdIn.readLine().split(" ").map(_.toInt) _)(1)

Andrey Over a year ago

@JoePallas sure, on its own add(2) is not a valid expression, e.g. val x = add(2) will not compile. however, i'm referring to add(2) as a smaller part of bigger expression. the point i'm trying to make is add(2)(3) is the same as (add(2))(3) is the same as ((add(2)))(3) and so on... the second arg list must be known before using shorthand for apply since the invocation of apply is done on the result of the expression. i.e. invoking apply using shorthand notation clashes with explicit specification of the second arg list...

Tim · Accepted Answer · 2016-11-11 18:20:37Z

1

You're getting a collision with an implicit argument to map. This is one of the cases apply needs to be invoked explicitly.

Here's some REPL that replicates the error:

scala> class Foo {
  def apply() { println("bar") }
}

scala> def makeFoo(): Foo = new Foo

scala> makeFoo()()
bar // got the println from the apply here

scala> def makeFooImplicit()(implicit x: Int): Foo = new Foo

scala> implicit val x = 5

scala> makeFooImplicit()()
  <console>:11: error: not enough arguments for method makeFooImplicit:(implicit x: Int)Foo.
  Unspecified value parameter x.
          makeFooImplicit()()

answered Nov 11, 2016 at 18:20

Tim

3,74515 silver badges25 bronze badges

3 Comments

Bartłomiej Szałach Over a year ago

So how to invoke makeFooImplicit?

Andrey Over a year ago

@BartłomiejSzałach both makeFooImplicit() and makeFooImplicit()(1) will return an instance of Foo. the former works because implicit val x = 5 is defined which effectively means makeFooImplicit()(5).

Tim Over a year ago

You could say val f = makeFooImplicit(); f() and get the printout.

Collectives™ on Stack Overflow

Obtaining array element in Scala works only with explicit apply method

2 Answers 2

4 Comments

3 Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

4 Comments

3 Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related