Observations

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
      
  }
}

• Filtered colimits considered harmful
• Free monads don't always exist
• Free monads make code unrefactorable
• Trampolining makes code untraceable and untestable
• Kleisli is not a functor, it's a category, for a given monad
• Type level programming makes code unmanageable (and unreadable)
• Implicit transformations make code non-typesafe
• cats.IO makes code unrefactorable

  val topos = new CategoryOfDiagrams(cat)
  import topos._
  val points = Ω.points

  val desc = s"Testing ${cat.name} distributivity laws"
  println(desc)
  
  for { pt1 ← points } {
    println(s"  at ${pt1.tag}")
    val p = predicateFor(pt1)

    for { pt2 ← points } {
      val q = predicateFor(pt2)
      val pAndQ = p ∧ q
      val pOrQ = p ∨ q

      for { pt3 ← points } {
        val r = predicateFor(pt3)
        // distributivity of conjunction over disjunction
        (p ∧ (q ∨ r)) === (pAndQ ∨ (p ∧ r))
        // distributivity of disjunction over conjunction
        (p ∨ (q ∧ r)) === (pOrQ ∧ (p ∨ r))
      }
    }
  }

  ok
}

      applyTo | "a" | "b"  | "c" | "d"  | "e" |
      at("a") | "a" | "ab" | ""  | ""   | ""  |
      at("b") | ""  | "b"  | ""  | ""   | ""  |
      at("c") | ""  | "cb" | "c" | "cd" | ""  |
      at("d") | ""  | ""   | ""  | "d"  | ""  |
      at("e") | ""  | ""   | ""  | "ed" | "e" 

      val at = (obj: topos.site.Obj) => topos.representable(obj)

      val at = (obj: topos.site.Obj) => topos.representable(obj)
      
      case class table(data: List[String] = Nil) {
        def |(x: String): table = table(x::data)
        def |(d: Diagrams.Diagram) = check(d, data, data)
      }

      case class check(d: Diagram, data: List[String], fullList: List[String]) {
        def |(x: String): check = {
            d(data.head) === x.split(",").toSet
            check(d, data.tail, fullList)
        }
        def |(d: Diagram): check = check(d, fullList, fullList)
      }

      val applyTo = new table