Question

Why is this snippet not printing out: “You successfully implemented the function”

Details:

Why is the type of val actual seeming to be of type List[Either[List[Int], Int]], when I am even saying to the compiler explicitly that actual’s type should be of type List[Int]?

// Flatten a nested list structure

def flatten[T](list: List[Either[List[T], T]]): List[T] = list flatMap {
    // TODO: Implement
    case list: List[T]  => list
    case element: T     => List(element)
}

implicit def ElementToEitherLeft[T](obj: T) = Left(obj)
implicit def ElementToEitherRight[T](obj: T) = Right(obj)

val list: List[Either[List[Int], Int]] = List(List(1, 1), 2, List(3, 5))
val actual: List[Int] = flatten[Int](list)
val expected = List(1, 1, 2, 3, 5)
if (actual == expected)     print("You successfully implemented the function")
else                        print("Unfortunatly, that's not quite rigth yet")

Answer 1

When you compiled your flatten you should have seen a warning like this:

warning: there were 2 unchecked warnings; re-run with -unchecked for details

If you’d then compiled with with -unchecked, you’d have seen this:

<console>:9: warning: non variable type-argument T in type pattern List[T] is unchecked since it is eliminated by erasure
           case list: List[T]  => list
                      ^
<console>:10: warning: abstract type T in type pattern T is unchecked since it is eliminated by erasure
           case element: T     => List(element)

In short, flatMap isn’t going to unwrap your Either items for you, and what you’ve written only compiles because of some unpleasant facts about type erasure and pattern matching.

Fortunately there’s an easy fix:

 def flatten[T](list: List[Either[List[T], T]]): List[T] = list flatMap {
   case Left(list)  => list
   case Right(item) => item :: Nil
 }

Or, even better:

def flatten[T](list: List[Either[List[T], T]]): List[T] =
  list.flatMap(_.fold(identity, List(_)))

Either will work as you expect.