Observations

    Stream.of<String>().forAll {   it.isEmpty() } shouldBe true
    Stream.of<String>().forAll {  !it.isEmpty() } shouldBe true

Welcome to Scala 2.12.8 (Java HotSpot(TM) 64-Bit Server VM, Java 1.8.0_92).
Type in expressions for evaluation. Or try :help.

scala> def f(x: Int) = 10 + x -> "ok"
f: (x: Int)(Int, String)

scala> f(10)
res0: (Int, String) = (20,ok)

scala> def g(x: Int) = 20 + x → "oops"
:11: error: overloaded method value + with alternatives:
  (x: Double)Double 
  (x: Float)Float 
  (x: Long)Long 
  (x: Int)Int 
  (x: Char)Int 
  (x: Short)Int 
  (x: Byte)Int 
  (x: String)String
 cannot be applied to ((Int, String))
       def g(x: Int) = 20 + x → "oops"
                          ^

object model {
  type MovieId = Long
  type UserId  = Long
  case class View(userId: UserId, movieId: MovieId)
}
import model._

object Solution extends App {
  def diverseMovies(views: Seq[View], numMovie: Int): Set[MovieId] = {
    def choose(except: Set[UserId] = Set.empty): MovieId = {
      views.collect { case view if !except(view.userId) => view }.
            groupBy(_.movieId).mapValues(_.size).maxBy(_._2)._1
    }
    
    def viewersOf(movie: MovieId) =
      views.filter(_.movieId equals movie).map(_.userId).toSet
    
    val result: (List[MovieId], Set[UserId]) =
      ((List.empty[MovieId], Set.empty[UserId])/:(1 to numMovie)) ({
        case ((movies: List[MovieId], ignoredUsers: Set[MovieId]), _) => {
          val movie = choose(ignoredUsers)
          (movie::movies, ignoredUsers ++ viewersOf(movie))
        }
      })
    result._1.toSet
      
  }
}