Testing an array for emptiness in Scala

Question

The question isn't about how to test an array for emptiness (arr.length == 0 does this fine). Rather my question is, why does

scala> Array().isEmpty
res1: Boolean = true

work and

scala> val x = Array[String]()
x: Array[String] = Array()
scala> x.isEmpty
res2: Boolean = true

work, but

scala> val y = Array()
y: Array[Nothing] = Array()

scala> y.isEmpty
<console>:13: error: value isEmpty is not a member of Array[Nothing]
       y.isEmpty
         ^

does not?

See http://stackoverflow.com/questions/5843001/why-does-map-filter-not-work-with-an-array-of-nothing — slouc, Jan 31 '17 at 17:38
Seems as though `Array().isEmpty` works because `Array()` hasn't yet been inferred as empty, so it picks up `Predef.refArrayOps`. — Michael Zajac, Jan 31 '17 at 17:51

score 4 · Accepted Answer · edited May 23 '17 at 12:24

As @MichaelZajac points out, Nothing is a subtype of everything (its counterpart Any is a supertype of everything). In particular it's also a subtype of AnyRef. In fact there's an even more general genericArrayOps which has no type bound at all (e.g. Array[Any]().isEmpty works)! The implicit conversion allowing you to use isEmpty should kick in, but of course it doesn't, even though explicitly calling the conversion is fine.

The link @slouc gives is the answer, namely that the Scala compiler treats Nothing in a special way when doing implicit resolution because Nothing is the default lower bound for a type when doing type inference.

Now why exactly would it ever be desirable for Nothing not to be considered in implicit resolution? Well the tricky thing about Nothing again is that it's a subtype of everything. This means that if at any point Scala infers a type to be Nothing, every single implicit conversion would immediately become valid. This could hide a type error (you should never have an instance of Nothing, but when that Nothing becomes an Int... well who's to say?). (Note I would love for someone who actually hacks on the compiler to jump in and confirm/deny/elaborate on this)

Maxim · Answer 2 · 2017-02-01T09:09:50.780

3

EDIT: probably this answer is not correct. But I'm keepeing it here to show how did I try to investigate this issue. To me it looks like a bug in the compiler.

The answer is implicit conversion that exists for Array[T <: AnyRef] String is AnyRef, Nothing is not AnyRef.

How could you discover this yourself?

In IntelliJ you can see a grey underline under the isEmpty

This means that the method isEmpty is not a method of Array, but an implicit (a method on a class that has implicit conversion from Array).

Now, to discover the implicit conversion, just click ctrl+q

So when you follow it, you get to this line in the source code -

  implicit def refArrayOps[T <: AnyRef](xs: Array[T]): ArrayOps[T]    = new ArrayOps.ofRef[T](xs)

That explains that the implicit conversion is on an Array[T] when T extends AnyRef

So back to our case - String <: AnyRef, but this doesn't hold for Nothing

edited Feb 01 '17 at 09:09

answered Jan 31 '17 at 22:22

Maxim

7,268
1
32
44

Makes a lot of sense, thanks so much for the explanation! I'm not the biggest fan of IntelliJ, but that's a cool feature. – user4601931 Jan 31 '17 at 23:35
1

This reasoning here isn't true. `Nothing` _is absolutely_ a sub-type of `AnyRef`. Try: `refArrayOps[Nothing](Array()).isEmpty` -- it works just fine. The reason why the implicit doesn't kick-in for `y.isEmpty` is far more dubious than that. – Michael Zajac Feb 01 '17 at 00:36
1

@MichaelZajac What do you mean by "far more dubious"? – user4601931 Feb 01 '17 at 01:36

Testing an array for emptiness in Scala

2 Answers2