done propagating the execution context everywhere

2019-12-13 21:08:21 -06:00 · 2019-12-13 21:08:21 -06:00 · c0aa9734f3
parent 74afc821e7
commit c0aa9734f3
108 changed files with 188 additions and 175 deletions
--- a/app/Env.scala
+++ b/app/Env.scala
@ -81,7 +81,7 @@ final class Env(
    val rating: lila.rating.Env,
    val lilaCookie: lila.common.LilaCookie,
    val controllerComponents: ControllerComponents
-)(implicit val system: ActorSystem) {
+)(implicit val system: ActorSystem, val executionContext: ExecutionContext) {

  val isProd            = mode == Mode.Prod
  val isDev             = mode == Mode.Dev
--- a/app/controllers/Analyse.scala
+++ b/app/controllers/Analyse.scala
@ -14,7 +14,7 @@ final class Analyse(
    env: Env,
    gameC: => Game,
    roundC: => Round
-)(implicit ec: scala.concurrent.ExecutionContext)
+)
    extends LilaController(env) {

  def requestAnalysis(id: String) = Auth { implicit ctx => me =>
--- a/app/controllers/KeyPages.scala
+++ b/app/controllers/KeyPages.scala
@ -7,7 +7,7 @@ import lila.api.Context
 import lila.app._
 import views._

-final class KeyPages(env: Env) {
+final class KeyPages(env: Env)(implicit ec: scala.concurrent.ExecutionContext) {

  def home(status: Results.Status)(implicit ctx: Context): Fu[Result] =
    env
--- a/app/controllers/LilaController.scala
+++ b/app/controllers/LilaController.scala
@ -24,8 +24,8 @@ abstract private[controllers] class LilaController(val env: Env)
    with ResponseWriter {

  val controllerComponents = env.controllerComponents
-
-  implicit val executionContext = defaultExecutionContext
+  implicit val executionContext = env.executionContext
+  implicit val scheduler = env.scheduler

  implicit protected val LilaResultZero = Zero.instance[Result](Results.NotFound)

--- a/app/controllers/Prismic.scala
+++ b/app/controllers/Prismic.scala
@ -7,7 +7,7 @@ import lila.app._

 final class Prismic(
    env: Env
-)(implicit ws: play.api.libs.ws.WSClient) {
+)(implicit ec: scala.concurrent.ExecutionContext, ws: play.api.libs.ws.WSClient) {

  private val logger = lila.log("prismic")

--- a/app/controllers/UserAnalysis.scala
+++ b/app/controllers/UserAnalysis.scala
@ -174,7 +174,7 @@ final class UserAnalysis(
            forecasts => {
              val wait = 50 + (Forecast maxPlies forecasts min 10) * 50
              env.round.forecastApi.playAndSave(pov, uci, forecasts) >>
-                lila.common.Future.sleep(wait.millis)(env.scheduler) inject
+                lila.common.Future.sleep(wait.millis) inject
                Ok(Json.obj("reload" -> true))
            }
          )
--- a/app/http/ErrorHandler.scala
+++ b/app/http/ErrorHandler.scala
@ -18,7 +18,7 @@ final class ErrorHandler(
    router: => Option[Router],
    mainC: => controllers.Main,
    lobbyC: => controllers.Lobby
-) extends DefaultHttpErrorHandler(environment, config, sourceMapper, router) {
+)(implicit ec: scala.concurrent.ExecutionContext) extends DefaultHttpErrorHandler(environment, config, sourceMapper, router) {

  override def onProdServerError(req: RequestHeader, exception: UsefulException) =
    Future {
--- a/app/mashup/GameFilter.scala
+++ b/app/mashup/GameFilter.scala
@ -87,7 +87,7 @@ object GameFilterMenu {
      pag: lila.game.PaginatorBuilder,
      gameRepo: lila.game.GameRepo,
      bookmarkApi: lila.bookmark.BookmarkApi
-  ) {
+  )(implicit ec: scala.concurrent.ExecutionContext) {

    def apply(
        user: User,
--- a/app/mashup/Preload.scala
+++ b/app/mashup/Preload.scala
@ -29,7 +29,7 @@ final class Preload(
    roundProxy: lila.round.GameProxyRepo,
    simulIsFeaturable: Simul => Boolean,
    lastPostCache: lila.blog.LastPostCache
-) {
+)(implicit ec: scala.concurrent.ExecutionContext) {

  import Preload._

--- a/app/mashup/TeamInfo.scala
+++ b/app/mashup/TeamInfo.scala
@ -28,7 +28,7 @@ final class TeamInfoApi(
    teamCached: lila.team.Cached,
    tournamentRepo: TournamentRepo,
    requestRepo: RequestRepo
-) {
+)(implicit ec: scala.concurrent.ExecutionContext) {

  def apply(team: Team, me: Option[User]): Fu[TeamInfo] =
    for {
--- a/app/mashup/UserInfo.scala
+++ b/app/mashup/UserInfo.scala
@ -61,7 +61,7 @@ object UserInfo {
      relationApi: RelationApi,
      noteApi: lila.user.NoteApi,
      prefApi: lila.pref.PrefApi
-  ) {
+  )(implicit ec: scala.concurrent.ExecutionContext) {
    def apply(u: User, ctx: Context): Fu[Social] =
      ctx.userId.?? { relationApi.fetchRelation(_, u.id) } zip
        ctx.me.?? { me =>
@ -87,10 +87,10 @@ object UserInfo {
      bookmarkApi: BookmarkApi,
      gameCached: lila.game.Cached,
      crosstableApi: lila.game.CrosstableApi
-  ) {
+  )(implicit ec: scala.concurrent.ExecutionContext) {
    def apply(u: User, ctx: Context): Fu[NbGames] =
      (ctx.me.filter(u !=) ?? { me =>
-        crosstableApi.withMatchup(me.id, u.id) map some
+        crosstableApi.withMatchup(me.id, u.id) dmap some
      }) zip
        gameCached.nbPlaying(u.id) zip
        gameCached.nbImportedBy(u.id) zip
@ -121,11 +121,11 @@ object UserInfo {
      insightShare: lila.insight.Share,
      playTimeApi: lila.game.PlayTimeApi,
      playbanApi: lila.playban.PlaybanApi
-  ) {
+  )(implicit ec: scala.concurrent.ExecutionContext) {
    def apply(user: User, nbs: NbGames, ctx: Context): Fu[UserInfo] =
      (ctx.noBlind ?? ratingChartApi(user)) zip
        relationApi.countFollowers(user.id) zip
-        (ctx.me ?? Granter(_.UserSpy) ?? { relationApi.countBlockers(user.id) map (_.some) }) zip
+        (ctx.me ?? Granter(_.UserSpy) ?? { relationApi.countBlockers(user.id) dmap some }) zip
        postApi.nbByUser(user.id) zip
        studyRepo.countByOwner(user.id) zip
        trophyApi.findByUser(user) zip
--- a/modules/activity/src/main/ActivityReadApi.scala
+++ b/modules/activity/src/main/ActivityReadApi.scala
@ -15,7 +15,7 @@ final class ActivityReadApi(
    simulApi: lila.simul.SimulApi,
    studyApi: lila.study.StudyApi,
    tourLeaderApi: lila.tournament.LeaderboardApi
-) {
+)(implicit ec: scala.concurrent.ExecutionContext) {

  import BSONHandlers._
  import model._
--- a/modules/activity/src/main/ActivityWriteApi.scala
+++ b/modules/activity/src/main/ActivityWriteApi.scala
@ -8,7 +8,7 @@ import lila.user.User
 final class ActivityWriteApi(
    coll: Coll,
    studyApi: lila.study.StudyApi
-) {
+)(implicit ec: scala.concurrent.ExecutionContext) {

  import Activity._
  import BSONHandlers._
--- a/modules/activity/src/main/Env.scala
+++ b/modules/activity/src/main/Env.scala
@ -17,7 +17,7 @@ final class Env(
    tourLeaderApi: lila.tournament.LeaderboardApi,
    getTourName: lila.tournament.GetTourName,
    getTeamName: lila.team.GetTeamName
-)(implicit system: ActorSystem) {
+)(implicit ec: scala.concurrent.ExecutionContext, system: ActorSystem) {

  private lazy val coll = db(CollName("activity"))

--- a/modules/api/src/main/Cli.scala
+++ b/modules/api/src/main/Cli.scala
@ -19,11 +19,11 @@ final private[api] class Cli(
    coach: lila.coach.Env,
    evalCache: lila.evalCache.Env,
    plan: lila.plan.Env
-) extends lila.common.Cli {
+)(implicit ec: scala.concurrent.ExecutionContext) extends lila.common.Cli {

  private val logger = lila.log("cli")

-  def apply(args: List[String]): Fu[String] = run(args).map(_ + "\n") ~ {
+  def apply(args: List[String]): Fu[String] = run(args).dmap(_ + "\n") ~ {
    _.logFailure(logger, _ => args mkString " ") foreach { output =>
      logger.info("%s\n%s".format(args mkString " ", output))
    }
--- a/modules/api/src/main/Env.scala
+++ b/modules/api/src/main/Env.scala
@ -45,7 +45,7 @@ final class Env(
    lifecycle: ApplicationLifecycle,
    ws: WSClient,
    val mode: Mode
-)(implicit system: ActorSystem) {
+)(implicit ec: scala.concurrent.ExecutionContext, system: ActorSystem) {

  val config = ApiConfig loadFrom appConfig
  import config.apiToken
--- a/modules/api/src/main/EventStream.scala
+++ b/modules/api/src/main/EventStream.scala
@ -15,7 +15,7 @@ final class EventStream(
    challengeJsonView: lila.challenge.JsonView,
    challengeMaker: lila.challenge.ChallengeMaker,
    onlineBots: lila.bot.OnlineBots
-)(implicit system: ActorSystem) {
+)(implicit ec: scala.concurrent.ExecutionContext, system: ActorSystem) {

  private case object SetOnline

--- a/modules/api/src/main/GameApi.scala
+++ b/modules/api/src/main/GameApi.scala
@ -26,7 +26,7 @@ final private[api] class GameApi(
    gameCache: lila.game.Cached,
    analysisRepo: lila.analyse.AnalysisRepo,
    crosstableApi: CrosstableApi
-) {
+)(implicit ec: scala.concurrent.ExecutionContext) {

  import GameApi.WithFlags

--- a/modules/api/src/main/GameApiV2.scala
+++ b/modules/api/src/main/GameApiV2.scala
@ -24,7 +24,7 @@ final class GameApiV2(
    pairingRepo: lila.tournament.PairingRepo,
    analysisRepo: lila.analyse.AnalysisRepo,
    getLightUser: LightUser.Getter
-)(implicit system: akka.actor.ActorSystem) {
+)(implicit ec: scala.concurrent.ExecutionContext, system: akka.actor.ActorSystem) {

  import GameApiV2._

@ -35,7 +35,7 @@ final class GameApiV2(
        enrich(config.flags)(game) flatMap {
          case (game, initialFen, analysis) =>
            config.format match {
-              case Format.JSON => toJson(game, initialFen, analysis, config.flags) map Json.stringify
+              case Format.JSON => toJson(game, initialFen, analysis, config.flags) dmap Json.stringify
              case Format.PGN  => pgnDump.toPgnString(game, initialFen, analysis, config.flags)
            }
        }
@ -104,7 +104,7 @@ final class GameApiV2(

  private def enrich(flags: WithFlags)(game: Game) =
    gameRepo initialFen game flatMap { initialFen =>
-      (flags.evals ?? analysisRepo.byGame(game)) map { analysis =>
+      (flags.evals ?? analysisRepo.byGame(game)) dmap { analysis =>
        (game, initialFen, analysis)
      }
    }
@ -116,7 +116,7 @@ final class GameApiV2(

  private def jsonFormatter(flags: WithFlags) =
    (game: Game, initialFen: Option[FEN], analysis: Option[Analysis]) =>
-      toJson(game, initialFen, analysis, flags) map { json =>
+      toJson(game, initialFen, analysis, flags) dmap { json =>
        s"${Json.stringify(json)}\n"
      }

--- a/modules/api/src/main/InfluxEvent.scala
+++ b/modules/api/src/main/InfluxEvent.scala
@ -19,6 +19,8 @@ final private class InfluxEvent(
    event("lila_start", s"Lila starts: $seed")
  }

+  implicit def ec = context.dispatcher
+
  def receive = {
    case DeployPre  => event("lila_deploy_pre", "Lila will soon restart")
    case DeployPost => event("lila_deploy_post", "Lila restarts for deploy now")
--- a/modules/api/src/main/LobbyApi.scala
+++ b/modules/api/src/main/LobbyApi.scala
@ -14,7 +14,7 @@ final class LobbyApi(
    seekApi: SeekApi,
    pools: List[lila.pool.PoolConfig],
    gameProxyRepo: lila.round.GameProxyRepo
-) {
+)(implicit ec: scala.concurrent.ExecutionContext) {

  val poolsJson = Json toJson pools

--- a/modules/api/src/main/PgnDump.scala
+++ b/modules/api/src/main/PgnDump.scala
@ -11,7 +11,7 @@ final class PgnDump(
    annotator: Annotator,
    simulApi: lila.simul.SimulApi,
    getTournamentName: lila.tournament.GetTourName
-) {
+)(implicit ec: scala.concurrent.ExecutionContext) {

  def apply(game: Game, initialFen: Option[FEN], analysis: Option[Analysis], flags: WithFlags): Fu[Pgn] =
    dumper(game, initialFen, flags) flatMap { pgn =>
@ -48,7 +48,7 @@ final class PgnDump(
      toPgnString(game, initialFen, analysis, flags)

  def toPgnString(game: Game, initialFen: Option[FEN], analysis: Option[Analysis], flags: WithFlags) =
-    apply(game, initialFen, analysis, flags).map { pgn =>
+    apply(game, initialFen, analysis, flags) dmap { pgn =>
      // merge analysis & eval comments
      // 1. e4 { [%eval 0.17] } { [%clk 0:00:30] }
      // 1. e4 { [%eval 0.17] [%clk 0:00:30] }
--- a/modules/api/src/main/RoundApi.scala
+++ b/modules/api/src/main/RoundApi.scala
@ -23,7 +23,7 @@ final private[api] class RoundApi(
    gameRepo: lila.game.GameRepo,
    tourApi: lila.tournament.TournamentApi,
    simulApi: lila.simul.SimulApi
-) {
+)(implicit ec: scala.concurrent.ExecutionContext) {

  def player(pov: Pov, apiVersion: ApiVersion)(implicit ctx: Context): Fu[JsObject] =
    gameRepo
--- a/modules/api/src/main/UserApi.scala
+++ b/modules/api/src/main/UserApi.scala
@ -19,7 +19,7 @@ final private[api] class UserApi(
    onlineDoing: lila.relation.OnlineDoing,
    gameProxyRepo: lila.round.GameProxyRepo,
    net: NetConfig
-) {
+)(implicit ec: scala.concurrent.ExecutionContext) {

  def pagerJson(pag: Paginator[User]): JsObject =
    Json.obj("paginator" -> PaginatorJson(pag mapResults one))
@ -29,7 +29,7 @@ final private[api] class UserApi(
      Json.obj("url" -> makeUrl(s"@/${u.username}")) // for app BC

  def extended(username: String, as: Option[User]): Fu[Option[JsObject]] = userRepo named username flatMap {
-    _ ?? { extended(_, as) map some }
+    _ ?? { extended(_, as) dmap some }
  }

  def extended(u: User, as: Option[User]): Fu[JsObject] =
@ -40,7 +40,7 @@ final private[api] class UserApi(
        "closed"   -> true
      )
    } else {
-      gameProxyRepo.urgentGames(u).map(_.headOption) zip
+      gameProxyRepo.urgentGames(u).dmap(_.headOption) zip
        (as.filter(u !=) ?? { me =>
          crosstableApi.nbGames(me.id, u.id)
        }) zip
--- a/modules/api/src/main/UserGameApi.scala
+++ b/modules/api/src/main/UserGameApi.scala
@ -13,7 +13,7 @@ final class UserGameApi(
    bookmarkApi: lila.bookmark.BookmarkApi,
    lightUser: lila.user.LightUserApi,
    getTournamentName: lila.tournament.GetTourName
-) {
+)(implicit ec: scala.concurrent.ExecutionContext) {

  import lila.game.JsonView._
  import LightUser.lightUserWrites
--- a/modules/blog/src/main/BlogApi.scala
+++ b/modules/blog/src/main/BlogApi.scala
@ -12,7 +12,7 @@ final class BlogApi(
    asyncCache: lila.memo.AsyncCache.Builder,
    prismicUrl: String,
    collection: String
-)(implicit ws: WSClient) {
+)(implicit ec: scala.concurrent.ExecutionContext, ws: WSClient) {

  def recent(
      api: Api,
--- a/modules/blog/src/main/Env.scala
+++ b/modules/blog/src/main/Env.scala
@ -16,7 +16,7 @@ final class Env(
    appConfig: Configuration,
    asyncCache: lila.memo.AsyncCache.Builder,
    timelineApi: lila.timeline.EntryApi
-)(implicit system: akka.actor.ActorSystem, ws: play.api.libs.ws.WSClient) {
+)(implicit ec: scala.concurrent.ExecutionContext, system: akka.actor.ActorSystem, ws: play.api.libs.ws.WSClient) {

  private val config = appConfig.get[BlogConfig]("blog")(AutoConfig.loader)

--- a/modules/blog/src/main/LastPostCache.scala
+++ b/modules/blog/src/main/LastPostCache.scala
@ -9,7 +9,7 @@ final class LastPostCache(
    notifier: Notifier,
    ttl: FiniteDuration,
    collection: String
-)(implicit system: akka.actor.ActorSystem) {
+)(implicit ec: scala.concurrent.ExecutionContext, system: akka.actor.ActorSystem) {

  private val cache = new Syncache[Boolean, List[MiniPost]](
    name = "blog.lastPost",
--- a/modules/blog/src/main/Notifier.scala
+++ b/modules/blog/src/main/Notifier.scala
@ -8,7 +8,7 @@ import lila.timeline.EntryApi
 final private[blog] class Notifier(
    blogApi: BlogApi,
    timelineApi: EntryApi
-) {
+)(implicit ec: scala.concurrent.ExecutionContext) {

  def apply(id: String): Funit =
    blogApi.prismicApi flatMap { prismicApi =>
--- a/modules/bookmark/src/main/BookmarkApi.scala
+++ b/modules/bookmark/src/main/BookmarkApi.scala
@ -13,7 +13,7 @@ final class BookmarkApi(
    coll: Coll,
    gameRepo: GameRepo,
    paginator: PaginatorBuilder
-) {
+)(implicit ec: scala.concurrent.ExecutionContext) {

  private def exists(gameId: Game.ID, userId: User.ID): Fu[Boolean] =
    coll exists selectId(gameId, userId)
@ -51,7 +51,7 @@ final class BookmarkApi(
  def countByUser(user: User): Fu[Int] = coll.countSel(userIdQuery(user.id))

  def gamePaginatorByUser(user: User, page: Int) =
-    paginator.byUser(user, page) dmap2 { _.game }
+    paginator.byUser(user, page) dmap { _.map(_.game) }

  private def add(gameId: Game.ID, userId: User.ID, date: DateTime): Funit =
    coll.insert
--- a/modules/bookmark/src/main/Env.scala
+++ b/modules/bookmark/src/main/Env.scala
@ -20,7 +20,7 @@ final class Env(
    appConfig: Configuration,
    db: lila.db.Db,
    gameRepo: lila.game.GameRepo
-)(implicit system: ActorSystem) {
+)(implicit ec: scala.concurrent.ExecutionContext, system: ActorSystem) {

  private val config = appConfig.get[BookmarkConfig]("bookmark")(AutoConfig.loader)

--- a/modules/bookmark/src/main/PaginatorBuilder.scala
+++ b/modules/bookmark/src/main/PaginatorBuilder.scala
@ -9,7 +9,7 @@ final class PaginatorBuilder(
    coll: Coll,
    gameRepo: GameRepo,
    maxPerPage: lila.common.config.MaxPerPage
-) {
+)(implicit ec: scala.concurrent.ExecutionContext) {

  def byUser(user: User, page: Int): Fu[Paginator[Bookmark]] =
    paginator(new UserAdapter(user), page)
@ -31,8 +31,7 @@ final class PaginatorBuilder(
          .find(selector, $doc("g" -> true).some)
          .sort(sorting)
          .skip(offset)
-          .cursor[Bdoc]()
-          .gather[List](length) map { _ flatMap { _.string("g") } }
+          .list[Bdoc](length) dmap { _ flatMap { _ string "g" } }
        games <- gameRepo gamesFromSecondary gameIds
      } yield games map { g =>
        Bookmark(g, user)
--- a/modules/bot/src/main/BotJsonView.scala
+++ b/modules/bot/src/main/BotJsonView.scala
@ -10,7 +10,7 @@ final class BotJsonView(
    lightUserApi: lila.user.LightUserApi,
    gameRepo: GameRepo,
    rematches: lila.game.Rematches
-) {
+)(implicit ec: scala.concurrent.ExecutionContext) {

  def gameFull(game: Game): Fu[JsObject] = gameRepo.withInitialFen(game) flatMap gameFull

--- a/modules/bot/src/main/BotPlayer.scala
+++ b/modules/bot/src/main/BotPlayer.scala
@ -16,7 +16,7 @@ final class BotPlayer(
    chatApi: lila.chat.ChatApi,
    gameRepo: GameRepo,
    isOfferingRematch: lila.round.IsOfferingRematch
-)(implicit system: akka.actor.ActorSystem) {
+)(implicit ec: scala.concurrent.ExecutionContext, system: akka.actor.ActorSystem) {

  def apply(pov: Pov, me: User, uciStr: String, offeringDraw: Option[Boolean]): Funit =
    lila.common.Future.delay((pov.game.hasAi ?? 500) millis) {
--- a/modules/bot/src/main/Env.scala
+++ b/modules/bot/src/main/Env.scala
@ -9,7 +9,7 @@ final class Env(
    lightUserApi: lila.user.LightUserApi,
    rematches: lila.game.Rematches,
    isOfferingRematch: lila.round.IsOfferingRematch
-)(implicit system: akka.actor.ActorSystem) {
+)(implicit ec: scala.concurrent.ExecutionContext, system: akka.actor.ActorSystem) {

  private def scheduler = system.scheduler

--- a/modules/bot/src/main/GameStateStream.scala
+++ b/modules/bot/src/main/GameStateStream.scala
@ -15,7 +15,7 @@ import scala.concurrent.duration._

 final class GameStateStream(
    jsonView: BotJsonView
-)(implicit system: ActorSystem) {
+)(implicit ec: scala.concurrent.ExecutionContext, system: ActorSystem) {

  private case object SetOnline

@ -86,7 +86,7 @@ final class GameStateStream(
    }

    def pushState(g: Game) =
-      jsonView gameState Game.WithInitialFen(g, init.fen) map some flatMap queue.offer
+      jsonView gameState Game.WithInitialFen(g, init.fen) dmap some flatMap queue.offer

    def pushChatLine(username: String, text: String, player: Boolean) =
      queue offer jsonView.chatLine(username, text, player).some
--- a/modules/bot/src/main/OnlineBots.scala
+++ b/modules/bot/src/main/OnlineBots.scala
@ -8,7 +8,7 @@ import lila.memo.ExpireCallbackMemo

 final class OnlineBots(
    scheduler: akka.actor.Scheduler
-) {
+)(implicit ec: scala.concurrent.ExecutionContext) {

  private val cache = new ExpireCallbackMemo(
    10.seconds,
--- a/modules/challenge/src/main/ChallengeApi.scala
+++ b/modules/challenge/src/main/ChallengeApi.scala
@ -18,12 +18,12 @@ final class ChallengeApi(
    gameCache: lila.game.Cached,
    maxPlaying: Max,
    asyncCache: lila.memo.AsyncCache.Builder
-) {
+)(implicit ec: scala.concurrent.ExecutionContext) {

  import Challenge._

  def allFor(userId: User.ID): Fu[AllChallenges] =
-    createdByDestId(userId) zip createdByChallengerId(userId) map (AllChallenges.apply _).tupled
+    createdByDestId(userId) zip createdByChallengerId(userId) dmap (AllChallenges.apply _).tupled

  // returns boolean success
  def create(c: Challenge): Fu[Boolean] = isLimitedByMaxPlaying(c) flatMap {
@ -38,9 +38,9 @@ final class ChallengeApi(

  def byId = repo byId _

-  def activeByIdFor(id: Challenge.ID, dest: User) = repo.byIdFor(id, dest).map(_.filter(_.active))
+  def activeByIdFor(id: Challenge.ID, dest: User) = repo.byIdFor(id, dest).dmap(_.filter(_.active))

-  def onlineByIdFor(id: Challenge.ID, dest: User) = repo.byIdFor(id, dest).map(_.filter(_.online))
+  def onlineByIdFor(id: Challenge.ID, dest: User) = repo.byIdFor(id, dest).dmap(_.filter(_.online))

  val countInFor = asyncCache.clearable(
    name = "challenge.countInFor",
@ -94,10 +94,10 @@ final class ChallengeApi(
    else
      c.userIds
        .map { userId =>
-          gameCache.nbPlaying(userId) map (maxPlaying <=)
+          gameCache.nbPlaying(userId) dmap (maxPlaying <=)
        }
        .sequenceFu
-        .map(_ exists identity)
+        .dmap(_ exists identity)

  private[challenge] def sweep: Funit =
    repo.realTimeUnseenSince(DateTime.now minusSeconds 10, max = 50).flatMap { cs =>
--- a/modules/challenge/src/main/ChallengeGranter.scala
+++ b/modules/challenge/src/main/ChallengeGranter.scala
@ -43,7 +43,7 @@ final class ChallengeGranter(

  val ratingThreshold = 300

-  def apply(fromOption: Option[User], dest: User, perfType: Option[PerfType]): Fu[Option[ChallengeDenied]] =
+  def apply(fromOption: Option[User], dest: User, perfType: Option[PerfType])(implicit ec: scala.concurrent.ExecutionContext): Fu[Option[ChallengeDenied]] =
    fromOption
      .fold[Fu[Option[ChallengeDenied.Reason]]](fuccess(YouAreAnon.some)) { from =>
        relationApi.fetchRelation(dest, from) zip
--- a/modules/challenge/src/main/ChallengeMaker.scala
+++ b/modules/challenge/src/main/ChallengeMaker.scala
@ -7,7 +7,7 @@ import lila.user.User
 final class ChallengeMaker(
    userRepo: lila.user.UserRepo,
    gameRepo: lila.game.GameRepo
-) {
+)(implicit ec: scala.concurrent.ExecutionContext) {

  def makeRematchFor(gameId: Game.ID, dest: User): Fu[Option[Challenge]] =
    gameRepo game gameId flatMap {
@ -15,7 +15,7 @@ final class ChallengeMaker(
        game.opponentByUserId(dest.id).flatMap(_.userId) ?? userRepo.byId flatMap {
          _ ?? { challenger =>
            Pov(game, challenger) ?? { pov =>
-              makeRematch(pov, challenger, dest) map some
+              makeRematch(pov, challenger, dest) dmap some
            }
          }
        }
@ -26,7 +26,7 @@ final class ChallengeMaker(
    Pov.ofUserId(game, challenger.id) ?? { pov =>
      pov.opponent.userId ?? userRepo.byId flatMap {
        _ ?? { dest =>
-          makeRematch(pov, challenger, dest) map some
+          makeRematch(pov, challenger, dest) dmap some
        }
      }
    }
--- a/modules/challenge/src/main/ChallengeRepo.scala
+++ b/modules/challenge/src/main/ChallengeRepo.scala
@ -6,7 +6,7 @@ import org.joda.time.DateTime
 import lila.common.config.Max
 import lila.db.dsl._

-final private class ChallengeRepo(coll: Coll, maxPerUser: Max) {
+final private class ChallengeRepo(coll: Coll, maxPerUser: Max)(implicit ec: scala.concurrent.ExecutionContext) {

  import BSONHandlers._
  import Challenge._
--- a/modules/challenge/src/main/ChallengeSocket.scala
+++ b/modules/challenge/src/main/ChallengeSocket.scala
@ -8,7 +8,7 @@ import lila.socket.RemoteSocket.{ Protocol => P, _ }
 final private class ChallengeSocket(
    api: ChallengeApi,
    remoteSocketApi: lila.socket.RemoteSocket
-) {
+)(implicit ec: scala.concurrent.ExecutionContext) {

  import ChallengeSocket._

--- a/modules/challenge/src/main/Env.scala
+++ b/modules/challenge/src/main/Env.scala
@ -21,7 +21,7 @@ final class Env(
    prefApi: lila.pref.PrefApi,
    relationApi: lila.relation.RelationApi,
    remoteSocketApi: lila.socket.RemoteSocket
-)(implicit system: akka.actor.ActorSystem) {
+)(implicit ec: scala.concurrent.ExecutionContext, system: akka.actor.ActorSystem) {

  private lazy val maxPlaying = appConfig.get[Max]("setup.max_playing")

--- a/modules/challenge/src/main/Joiner.scala
+++ b/modules/challenge/src/main/Joiner.scala
@ -10,7 +10,7 @@ final private[challenge] class Joiner(
    gameRepo: lila.game.GameRepo,
    userRepo: lila.user.UserRepo,
    onStart: lila.round.OnStart
-) {
+)(implicit ec: scala.concurrent.ExecutionContext) {

  def apply(c: Challenge, destUser: Option[User]): Fu[Option[Pov]] =
    gameRepo exists c.id flatMap {
--- a/modules/coach/src/main/CoachApi.scala
+++ b/modules/coach/src/main/CoachApi.scala
@ -14,7 +14,7 @@ final class CoachApi(
    userRepo: UserRepo,
    photographer: Photographer,
    notifyApi: NotifyApi
-) {
+)(implicit ec: scala.concurrent.ExecutionContext) {

  import BsonHandlers._

@ -24,8 +24,8 @@ final class CoachApi(
    userRepo named username flatMap { _ ?? find }

  def find(user: User): Fu[Option[Coach.WithUser]] = Granter(_.Coach)(user) ?? {
-    byId(Coach.Id(user.id)) flatMap {
-      _ ?? withUser(user)
+    byId(Coach.Id(user.id)) dmap {
+      _ map withUser(user)
    }
  }

@ -67,7 +67,7 @@ final class CoachApi(
    coachColl.update.one(
      $id(User.normalize(username)),
      $set("approved" -> value)
-    ) map { result =>
+    ) dmap { result =>
      if (result.n > 0) "Done!"
      else "No such coach"
    }
--- a/modules/coach/src/main/CoachPager.scala
+++ b/modules/coach/src/main/CoachPager.scala
@ -10,7 +10,7 @@ import lila.user.{ User, UserRepo }
 final class CoachPager(
    userRepo: UserRepo,
    coll: Coll
-) {
+)(implicit ec: scala.concurrent.ExecutionContext) {

  val maxPerPage = lila.common.config.MaxPerPage(10)

--- a/modules/coach/src/main/Env.scala
+++ b/modules/coach/src/main/Env.scala
@ -20,7 +20,7 @@ final class Env(
    notifyApi: lila.notify.NotifyApi,
    db: lila.db.Db,
    imageRepo: lila.db.ImageRepo
-) {
+)(implicit ec: scala.concurrent.ExecutionContext) {

  private val config = appConfig.get[CoachConfig]("coach")(AutoConfig.loader)

--- a/modules/common/src/main/PackageObject.scala
+++ b/modules/common/src/main/PackageObject.scala
@ -1,6 +1,6 @@
 package lila

-import scalaz.{ ~>, Monoid }
+import scalaz.Monoid
 import scala.concurrent.ExecutionContext

 trait PackageObject extends Lilaisms {
--- a/modules/db/src/main/QueryBuilderExt.scala
+++ b/modules/db/src/main/QueryBuilderExt.scala
@ -34,5 +34,8 @@ trait QueryBuilderExt { self: dsl =>

    def list[A: b.pack.Reader](limit: Int, readPreference: ReadPreference): Fu[List[A]] =
      gather[A, List](limit, readPreference)
+
+    def vector[A: b.pack.Reader](limit: Int, readPreference: ReadPreference): Fu[Vector[A]] =
+      gather[A, Vector](limit, readPreference)
  }
 }
--- a/modules/event/src/main/Env.scala
+++ b/modules/event/src/main/Env.scala
@ -10,7 +10,7 @@ final class Env(
    appConfig: Configuration,
    db: lila.db.Db,
    asyncCache: lila.memo.AsyncCache.Builder
-) {
+)(implicit ec: scala.concurrent.ExecutionContext) {

  private lazy val eventColl = db(appConfig.get[CollName]("event.collection.event"))

--- a/modules/event/src/main/EventApi.scala
+++ b/modules/event/src/main/EventApi.scala
@ -9,7 +9,7 @@ import lila.db.dsl._
 final class EventApi(
    coll: Coll,
    asyncCache: lila.memo.AsyncCache.Builder
-) {
+)(implicit ec: scala.concurrent.ExecutionContext) {

  import BsonHandlers._

--- a/modules/forumSearch/src/main/Env.scala
+++ b/modules/forumSearch/src/main/Env.scala
@ -21,7 +21,7 @@ final class Env(
    makeClient: Index => ESClient,
    postApi: lila.forum.PostApi,
    postRepo: lila.forum.PostRepo
-)(implicit system: ActorSystem, mat: akka.stream.Materializer) {
+)(implicit ec: scala.concurrent.ExecutionContext, system: ActorSystem, mat: akka.stream.Materializer) {

  private val config = appConfig.get[ForumSearchConfig]("forumSearch")(AutoConfig.loader)

--- a/modules/forumSearch/src/main/ForumSearchApi.scala
+++ b/modules/forumSearch/src/main/ForumSearchApi.scala
@ -11,7 +11,7 @@ final class ForumSearchApi(
    client: ESClient,
    postApi: PostApi,
    postRepo: PostRepo
-)(implicit mat: akka.stream.Materializer)
+)(implicit ec: scala.concurrent.ExecutionContext, mat: akka.stream.Materializer)
    extends SearchReadApi[PostView, Query] {

  def search(query: Query, from: From, size: Size) =
@ -20,7 +20,7 @@ final class ForumSearchApi(
    }

  def count(query: Query) =
-    client.count(query) map (_.count)
+    client.count(query) dmap (_.count)

  def store(post: Post) = postApi liteView post flatMap {
    _ ?? { view =>
--- a/modules/insight/src/main/AggregationPipeline.scala
+++ b/modules/insight/src/main/AggregationPipeline.scala
@ -5,7 +5,7 @@ import reactivemongo.api.bson._
 import lila.db.dsl._
 import lila.user.User

-final private class AggregationPipeline(store: Storage) {
+final private class AggregationPipeline(store: Storage)(implicit ec: scala.concurrent.ExecutionContext) {

  def aggregate[X](question: Question[X], user: User): Fu[List[Bdoc]] = store.coll {
    _.aggregateList(
--- a/modules/insight/src/main/Env.scala
+++ b/modules/insight/src/main/Env.scala
@ -15,7 +15,7 @@ final class Env(
    prefApi: lila.pref.PrefApi,
    relationApi: lila.relation.RelationApi,
    mongo: lila.db.Env
-)(implicit system: akka.actor.ActorSystem) {
+)(implicit ec: scala.concurrent.ExecutionContext, system: akka.actor.ActorSystem) {

  private lazy val db = mongo.asyncDb(
    "insight",
--- a/modules/insight/src/main/Indexer.scala
+++ b/modules/insight/src/main/Indexer.scala
@ -16,7 +16,7 @@ final private class Indexer(
    povToEntry: PovToEntry,
    gameRepo: GameRepo,
    storage: Storage
-)(implicit mat: akka.stream.Materializer) {
+)(implicit ec: scala.concurrent.ExecutionContext, mat: akka.stream.Materializer) {

  private val workQueue = new WorkQueue(64)

--- a/modules/insight/src/main/InsightApi.scala
+++ b/modules/insight/src/main/InsightApi.scala
@ -11,7 +11,7 @@ final class InsightApi(
    userCacheApi: UserCacheApi,
    gameRepo: GameRepo,
    indexer: Indexer
-) {
+)(implicit ec: scala.concurrent.ExecutionContext) {

  import InsightApi._

--- a/modules/insight/src/main/PovToEntry.scala
+++ b/modules/insight/src/main/PovToEntry.scala
@ -9,7 +9,7 @@ import scalaz.NonEmptyList
 final private class PovToEntry(
    gameRepo: lila.game.GameRepo,
    analysisRepo: lila.analyse.AnalysisRepo
-) {
+)(implicit ec: scala.concurrent.ExecutionContext) {

  private type Ply = Int

--- a/modules/insight/src/main/Share.scala
+++ b/modules/insight/src/main/Share.scala
@ -7,9 +7,9 @@ import lila.user.User
 final class Share(
    prefApi: lila.pref.PrefApi,
    relationApi: lila.relation.RelationApi
-) {
+)(implicit ec: scala.concurrent.ExecutionContext) {

-  def getPrefId(insighted: User) = prefApi.getPrefById(insighted.id) map (_.insightShare)
+  def getPrefId(insighted: User) = prefApi.getPrefById(insighted.id) dmap (_.insightShare)

  def grant(insighted: User, to: Option[User]): Fu[Boolean] =
    if (to ?? Granter(_.SeeInsight)) fuTrue
--- a/modules/insight/src/main/Storage.scala
+++ b/modules/insight/src/main/Storage.scala
@ -7,7 +7,7 @@ import lila.db.AsyncColl
 import lila.rating.BSONHandlers.perfTypeIdHandler
 import lila.rating.PerfType

-final private class Storage(val coll: AsyncColl) {
+final private class Storage(val coll: AsyncColl)(implicit ec: scala.concurrent.ExecutionContext) {

  import Storage._
  import BSONHandlers._
--- a/modules/insight/src/main/UserCache.scala
+++ b/modules/insight/src/main/UserCache.scala
@ -16,7 +16,7 @@ case class UserCache(
  def id = _id
 }

-final private class UserCacheApi(coll: AsyncColl) {
+final private class UserCacheApi(coll: AsyncColl)(implicit ec: scala.concurrent.ExecutionContext) {

  implicit private val userCacheBSONHandler = Macros.handler[UserCache]

--- a/modules/irwin/src/main/Env.scala
+++ b/modules/irwin/src/main/Env.scala
@ -18,7 +18,7 @@ final class Env(
    analysisRepo: lila.analyse.AnalysisRepo,
    settingStore: lila.memo.SettingStore.Builder,
    db: lila.db.Db
-)(implicit system: ActorSystem) {
+)(implicit ec: scala.concurrent.ExecutionContext, system: ActorSystem) {

  private lazy val reportColl = db(CollName("irwin_report"))

--- a/modules/irwin/src/main/IrwinApi.scala
+++ b/modules/irwin/src/main/IrwinApi.scala
@ -22,7 +22,7 @@ final class IrwinApi(
    reportApi: lila.report.ReportApi,
    notifyApi: lila.notify.NotifyApi,
    mode: lila.memo.SettingStore[String]
-) {
+)(implicit ec: scala.concurrent.ExecutionContext) {

  val reportThreshold = 85
  val markThreshold   = 93
@ -30,7 +30,7 @@ final class IrwinApi(
  import BSONHandlers._

  def dashboard: Fu[IrwinDashboard] =
-    reportColl.ext.find($empty).sort($sort desc "date").list[IrwinReport](20) map IrwinDashboard.apply
+    reportColl.ext.find($empty).sort($sort desc "date").list[IrwinReport](20) dmap IrwinDashboard.apply

  object reports {

@ -46,7 +46,7 @@ final class IrwinApi(

    def withPovs(user: User): Fu[Option[IrwinReport.WithPovs]] = get(user) flatMap {
      _ ?? { report =>
-        gameRepo.gamesFromSecondary(report.games.map(_.gameId)) map { games =>
+        gameRepo.gamesFromSecondary(report.games.map(_.gameId)) dmap { games =>
          val povs = games.flatMap { g =>
            Pov(g, user) map { g.id -> _ }
          }.toMap
@ -56,7 +56,7 @@ final class IrwinApi(
    }

    private def getSuspect(suspectId: User.ID) =
-      userRepo byId suspectId orFail s"suspect $suspectId not found" map Suspect.apply
+      userRepo byId suspectId orFail s"suspect $suspectId not found" dmap Suspect.apply

    private def markOrReport(report: IrwinReport): Funit =
      if (report.activation >= markThreshold && mode.get() == "mark")
@ -64,7 +64,7 @@ final class IrwinApi(
          lila.mon.mod.irwin.mark.increment()
      else if (report.activation >= reportThreshold && mode.get() != "none") for {
        suspect <- getSuspect(report.suspectId.value)
-        irwin   <- userRepo byId "irwin" orFail s"Irwin user not found" map Mod.apply
+        irwin   <- userRepo byId "irwin" orFail s"Irwin user not found" dmap Mod.apply
        _ <- reportApi.create(
          Report.Candidate(
            reporter = Reporter(irwin.user),
--- a/modules/irwin/src/main/IrwinStream.scala
+++ b/modules/irwin/src/main/IrwinStream.scala
@ -24,7 +24,7 @@ final class IrwinStream {
        queue offer req
    }

-    queue.watchCompletion foreach { _ =>
+    queue.watchCompletion dforeach { _ =>
      Bus.unsubscribe(sub, classifier)
    }
  }
--- a/modules/learn/src/main/Env.scala
+++ b/modules/learn/src/main/Env.scala
@ -7,7 +7,7 @@ import lila.common.config._
 final class Env(
    appConfig: Configuration,
    db: lila.db.Db
-) {
+)(implicit ec: scala.concurrent.ExecutionContext) {
  lazy val api = new LearnApi(
    coll = db(appConfig.get[CollName]("learn.collection.progress"))
  )
--- a/modules/learn/src/main/LearnApi.scala
+++ b/modules/learn/src/main/LearnApi.scala
@ -3,12 +3,12 @@ package lila.learn
 import lila.db.dsl._
 import lila.user.User

-final class LearnApi(coll: Coll) {
+final class LearnApi(coll: Coll)(implicit ec: scala.concurrent.ExecutionContext) {

  import BSONHandlers._

  def get(user: User): Fu[LearnProgress] =
-    coll.one[LearnProgress]($id(user.id)) map { _ | LearnProgress.empty(LearnProgress.Id(user.id)) }
+    coll.one[LearnProgress]($id(user.id)) dmap { _ | LearnProgress.empty(LearnProgress.Id(user.id)) }

  private def save(p: LearnProgress): Funit =
    coll.update.one($id(p.id), p, upsert = true).void
--- a/modules/lobby/src/main/AbortListener.scala
+++ b/modules/lobby/src/main/AbortListener.scala
@ -6,7 +6,7 @@ final private class AbortListener(
    userRepo: lila.user.UserRepo,
    seekApi: SeekApi,
    lobbyTrouper: LobbyTrouper
-) {
+)(implicit ec: scala.concurrent.ExecutionContext) {

  def apply(pov: Pov): Funit =
    (pov.game.isCorrespondence ?? recreateSeek(pov)) >>-
--- a/modules/lobby/src/main/Biter.scala
+++ b/modules/lobby/src/main/Biter.scala
@ -10,7 +10,7 @@ import lila.user.User
 final private class Biter(
    userRepo: lila.user.UserRepo,
    gameRepo: lila.game.GameRepo
-)(implicit idGenerator: lila.game.IdGenerator) {
+)(implicit ec: scala.concurrent.ExecutionContext, idGenerator: lila.game.IdGenerator) {

  def apply(hook: Hook, sri: Sri, user: Option[LobbyUser]): Fu[JoinHook] =
    if (canJoin(hook, user)) join(hook, sri, user)
--- a/modules/lobby/src/main/Env.scala
+++ b/modules/lobby/src/main/Env.scala
@ -21,6 +21,7 @@ final class Env(
    remoteSocketApi: lila.socket.RemoteSocket
 )(
    implicit
+    ec: scala.concurrent.ExecutionContext,
    system: akka.actor.ActorSystem,
    idGenerator: lila.game.IdGenerator
 ) {
--- a/modules/lobby/src/main/LobbySocket.scala
+++ b/modules/lobby/src/main/LobbySocket.scala
@ -25,7 +25,7 @@ final class LobbySocket(
    relationApi: lila.relation.RelationApi,
    poolApi: PoolApi,
    system: akka.actor.ActorSystem
-) {
+)(implicit ec: scala.concurrent.ExecutionContext) {

  import LobbySocket._
  import Protocol._
--- a/modules/lobby/src/main/LobbyTrouper.scala
+++ b/modules/lobby/src/main/LobbyTrouper.scala
@ -21,7 +21,7 @@ final private class LobbyTrouper(
    playbanApi: lila.playban.PlaybanApi,
    poolApi: lila.pool.PoolApi,
    onStart: lila.round.OnStart
-) extends Trouper {
+)(implicit ec: scala.concurrent.ExecutionContext) extends Trouper {

  import LobbyTrouper._

@ -206,7 +206,9 @@ private object LobbyTrouper {
  def start(
      broomPeriod: FiniteDuration,
      resyncIdsPeriod: FiniteDuration
-  )(makeTrouper: () => LobbyTrouper)(implicit system: akka.actor.ActorSystem) = {
+  )(
+      makeTrouper: () => LobbyTrouper
+  )(implicit ec: scala.concurrent.ExecutionContext, system: akka.actor.ActorSystem) = {
    val trouper = makeTrouper()
    lila.common.Bus.subscribe(trouper, "lobbyTrouper")
    system.scheduler.scheduleWithFixedDelay(15 seconds, resyncIdsPeriod)(() => trouper ! actorApi.Resync)
--- a/modules/lobby/src/main/SeekApi.scala
+++ b/modules/lobby/src/main/SeekApi.scala
@ -12,7 +12,7 @@ final class SeekApi(
    biter: Biter,
    relationApi: lila.relation.RelationApi,
    asyncCache: lila.memo.AsyncCache.Builder
-) {
+)(implicit ec: scala.concurrent.ExecutionContext) {
  import config._

  sealed private trait CacheKey
--- a/modules/pool/src/main/GameStarter.scala
+++ b/modules/pool/src/main/GameStarter.scala
@ -10,7 +10,7 @@ final private class GameStarter(
    gameRepo: GameRepo,
    idGenerator: IdGenerator,
    onStart: Game.Id => Unit
-)(implicit mat: akka.stream.Materializer) {
+)(implicit ec: scala.concurrent.ExecutionContext, mat: akka.stream.Materializer) {

  import PoolApi._

--- a/modules/pool/src/main/HookThieve.scala
+++ b/modules/pool/src/main/HookThieve.scala
@ -4,7 +4,10 @@ import scala.concurrent.Promise

 import lila.common.Bus

-final private class HookThieve()(implicit system: akka.actor.ActorSystem) {
+final private class HookThieve()(
+    implicit ec: scala.concurrent.ExecutionContext,
+    system: akka.actor.ActorSystem
+) {

  import HookThieve._

--- a/modules/pool/src/main/PoolActor.scala
+++ b/modules/pool/src/main/PoolActor.scala
@ -21,6 +21,8 @@ final private class PoolActor(

  var nextWave: Cancellable = _

+  implicit def ec = context.dispatcher
+
  def scheduleWave() =
    nextWave = context.system.scheduler.scheduleOnce(
      config.wave.every + Random.nextInt(1000).millis,
--- a/modules/pool/src/main/PoolApi.scala
+++ b/modules/pool/src/main/PoolApi.scala
@ -26,11 +26,11 @@ final class PoolApi(
  }.toMap

  def join(poolId: PoolConfig.Id, joiner: Joiner) =
-    playbanApi.hasCurrentBan(joiner.userId) foreach {
+    playbanApi.hasCurrentBan(joiner.userId) dforeach {
      case false =>
        actors foreach {
          case (id, actor) if id == poolId =>
-            playbanApi.getRageSit(joiner.userId).foreach(actor ! Join(joiner, _))
+            playbanApi.getRageSit(joiner.userId).dforeach(actor ! Join(joiner, _))
          case (_, actor) => actor ! Leave(joiner.userId)
        }
      case _ =>
--- a/modules/practice/src/main/Env.scala
+++ b/modules/practice/src/main/Env.scala
@ -10,7 +10,7 @@ final class Env(
    studyApi: lila.study.StudyApi,
    asyncCache: lila.memo.AsyncCache.Builder,
    db: lila.db.Db
-) {
+)(implicit ec: scala.concurrent.ExecutionContext) {

  private lazy val coll = db(CollName("practice_progress"))

--- a/modules/practice/src/main/PracticeApi.scala
+++ b/modules/practice/src/main/PracticeApi.scala
@ -12,7 +12,7 @@ final class PracticeApi(
    configStore: lila.memo.ConfigStore[PracticeConfig],
    asyncCache: lila.memo.AsyncCache.Builder,
    studyApi: lila.study.StudyApi
-) {
+)(implicit ec: scala.concurrent.ExecutionContext) {

  import BSONHandlers._

@ -63,7 +63,7 @@ final class PracticeApi(
    } yield UserStudy(up, practiceStudy, publishedChapters, sc, section)

  object config {
-    def get  = configStore.get map (_ | PracticeConfig.empty)
+    def get  = configStore.get dmap (_ | PracticeConfig.empty)
    def set  = configStore.set _
    def form = configStore.makeForm
  }
@ -90,7 +90,7 @@ final class PracticeApi(
    import PracticeProgress.NbMoves

    def get(user: User): Fu[PracticeProgress] =
-      coll.one[PracticeProgress]($id(user.id)) map {
+      coll.one[PracticeProgress]($id(user.id)) dmap {
        _ | PracticeProgress.empty(PracticeProgress.Id(user.id))
      }

--- a/modules/push/src/main/DeviceApi.scala
+++ b/modules/push/src/main/DeviceApi.scala
@ -6,7 +6,7 @@ import reactivemongo.api.bson._
 import lila.db.dsl._
 import lila.user.User

-final private class DeviceApi(coll: Coll) {
+final private class DeviceApi(coll: Coll)(implicit ec: scala.concurrent.ExecutionContext) {

  implicit private val DeviceBSONHandler = Macros.handler[Device]

@ -25,7 +25,7 @@ final private class DeviceApi(coll: Coll) {
      .list[Device](max)

  private[push] def findLastOneByUserId(platform: String)(userId: String): Fu[Option[Device]] =
-    findLastManyByUserId(platform, 1)(userId) map (_.headOption)
+    findLastManyByUserId(platform, 1)(userId) dmap (_.headOption)

  def register(user: User, platform: String, deviceId: String) = {
    lila.mon.push.register.in(platform).increment()
--- a/modules/push/src/main/Env.scala
+++ b/modules/push/src/main/Env.scala
@ -28,7 +28,7 @@ final class Env(
    userRepo: lila.user.UserRepo,
    getLightUser: lila.common.LightUser.Getter,
    proxyRepo: lila.round.GameProxyRepo
-)(implicit system: ActorSystem) {
+)(implicit ec: scala.concurrent.ExecutionContext, system: ActorSystem) {

  private val config = appConfig.get[PushConfig]("push")(AutoConfig.loader)

--- a/modules/push/src/main/FirebasePush.scala
+++ b/modules/push/src/main/FirebasePush.scala
@ -15,7 +15,7 @@ final private class FirebasePush(
    deviceApi: DeviceApi,
    ws: WSClient,
    config: OneSignalPush.Config
-)(implicit system: akka.actor.ActorSystem) {
+)(implicit ec: scala.concurrent.ExecutionContext, system: akka.actor.ActorSystem) {

  private val workQueue = new WorkQueue(512)

--- a/modules/push/src/main/OneSignalPush.scala
+++ b/modules/push/src/main/OneSignalPush.scala
@ -8,7 +8,7 @@ final private class OneSignalPush(
    deviceApi: DeviceApi,
    ws: WSClient,
    config: OneSignalPush.Config
-) {
+)(implicit ec: scala.concurrent.ExecutionContext) {

  import config._

--- a/modules/push/src/main/PushApi.scala
+++ b/modules/push/src/main/PushApi.scala
@ -19,7 +19,7 @@ final private class PushApi(
    userRepo: lila.user.UserRepo,
    implicit val lightUser: LightUser.Getter,
    proxyRepo: lila.round.GameProxyRepo
-)(implicit system: ActorSystem) {
+)(implicit ec: scala.concurrent.ExecutionContext, system: ActorSystem) {

  def finish(game: Game): Funit =
    if (!game.isCorrespondence || game.hasAi) funit
@ -271,7 +271,7 @@ final private class PushApi(
  private def IfAway(pov: Pov)(f: => Funit): Funit =
    lila.common.Bus.ask[Boolean]("roundSocket") { p =>
      Tell(pov.gameId, IsOnGame(pov.color, p))
-    }(system) flatMap {
+    } flatMap {
      case true  => funit
      case false => f
    }
--- a/modules/push/src/main/WebPush.scala
+++ b/modules/push/src/main/WebPush.scala
@ -11,7 +11,7 @@ final private class WebPush(
    webSubscriptionApi: WebSubscriptionApi,
    config: WebPush.Config,
    ws: WSClient
-) {
+)(implicit ec: scala.concurrent.ExecutionContext) {

  def apply(userId: User.ID)(data: => PushApi.Data): Funit =
    webSubscriptionApi.getSubscriptions(5)(userId) flatMap { subscriptions =>
--- a/modules/push/src/main/WebSubscriptionApi.scala
+++ b/modules/push/src/main/WebSubscriptionApi.scala
@ -7,7 +7,7 @@ import reactivemongo.api.bson._
 import lila.db.dsl._
 import lila.user.User

-final class WebSubscriptionApi(coll: Coll) {
+final class WebSubscriptionApi(coll: Coll)(implicit ec: scala.concurrent.ExecutionContext) {

  def getSubscriptions(max: Int)(userId: User.ID): Fu[List[WebSubscription]] =
    coll.ext
--- a/modules/setup/src/main/AnonConfigRepo.scala
+++ b/modules/setup/src/main/AnonConfigRepo.scala
@ -5,7 +5,7 @@ import reactivemongo.api.bson._

 import lila.db.dsl._

-final private class AnonConfigRepo(coll: Coll) {
+final private class AnonConfigRepo(coll: Coll)(implicit ec: scala.concurrent.ExecutionContext) {

  def update(req: RequestHeader)(f: UserConfig => UserConfig): Funit =
    configOption(req) flatMap {
@ -29,7 +29,7 @@ final private class AnonConfigRepo(coll: Coll) {
        logger.warn("Can't load config", e)
        none[UserConfig]
      }
-    } map (_ | UserConfig.default(sid))
+    } dmap (_ | UserConfig.default(sid))

  private def configOption(req: RequestHeader): Fu[Option[UserConfig]] =
    sessionId(req).??(s => config(s) map (_.some))
@ -37,7 +37,7 @@ final private class AnonConfigRepo(coll: Coll) {
  def filter(req: RequestHeader): Fu[FilterConfig] =
    sessionId(req) ?? { sid =>
      coll.primitiveOne[FilterConfig]($id(sid), "filter")
-    } map (_ | FilterConfig.default)
+    } dmap (_ | FilterConfig.default)

  private def sessionId(req: RequestHeader): Option[String] =
    lila.common.HTTPRequest sid req
--- a/modules/setup/src/main/Env.scala
+++ b/modules/setup/src/main/Env.scala
@ -14,7 +14,7 @@ final class Env(
    fishnetPlayer: lila.fishnet.Player,
    onStart: lila.round.OnStart,
    gameCache: lila.game.Cached
-) {
+)(implicit ec: scala.concurrent.ExecutionContext) {

  private lazy val maxPlaying     = appConfig.get[Max]("setup.max_playing")
  private lazy val anonConfigRepo = new AnonConfigRepo(db(CollName("config")))
--- a/modules/setup/src/main/FormFactory.scala
+++ b/modules/setup/src/main/FormFactory.scala
@ -14,7 +14,7 @@ final class FormFactory(
  import Mappings._

  def filterFilled(implicit ctx: UserContext): Fu[(Form[FilterConfig], FilterConfig)] =
-    filterConfig map { f =>
+    filterConfig dmap { f =>
      filter.fill(f) -> f
    }

@ -27,10 +27,10 @@ final class FormFactory(
    )(FilterConfig.<<)(_.>>)
  )

-  def filterConfig(implicit ctx: UserContext): Fu[FilterConfig] = savedConfig map (_.filter)
+  def filterConfig(implicit ctx: UserContext): Fu[FilterConfig] = savedConfig dmap (_.filter)

  def aiFilled(fen: Option[FEN])(implicit ctx: UserContext): Fu[Form[AiConfig]] =
-    aiConfig map { config =>
+    aiConfig dmap { config =>
      ai fill fen.fold(config) { f =>
        config.copy(fen = f.some, variant = chess.variant.FromPosition)
      }
@ -51,10 +51,10 @@ final class FormFactory(
      .verifying("Can't play that time control from a position", _.timeControlFromPosition)
  )

-  def aiConfig(implicit ctx: UserContext): Fu[AiConfig] = savedConfig map (_.ai)
+  def aiConfig(implicit ctx: UserContext): Fu[AiConfig] = savedConfig dmap (_.ai)

  def friendFilled(fen: Option[FEN])(implicit ctx: UserContext): Fu[Form[FriendConfig]] =
-    friendConfig map { config =>
+    friendConfig dmap { config =>
      friend(ctx) fill fen.fold(config) { f =>
        config.copy(fen = f.some, variant = chess.variant.FromPosition)
      }
@ -75,10 +75,10 @@ final class FormFactory(
      .verifying("invalidFen", _.validFen)
  )

-  def friendConfig(implicit ctx: UserContext): Fu[FriendConfig] = savedConfig map (_.friend)
+  def friendConfig(implicit ctx: UserContext): Fu[FriendConfig] = savedConfig dmap (_.friend)

  def hookFilled(timeModeString: Option[String])(implicit ctx: UserContext): Fu[Form[HookConfig]] =
-    hookConfig map (_ withTimeModeString timeModeString) map hook(ctx).fill
+    hookConfig dmap (_ withTimeModeString timeModeString) dmap hook(ctx).fill

  def hook(ctx: UserContext) = Form(
    mapping(
@ -95,7 +95,7 @@ final class FormFactory(
      .verifying("Can't create rated unlimited in lobby", _.noRatedUnlimited)
  )

-  def hookConfig(implicit ctx: UserContext): Fu[HookConfig] = savedConfig map (_.hook)
+  def hookConfig(implicit ctx: UserContext): Fu[HookConfig] = savedConfig dmap (_.hook)

  lazy val api = Form(
    mapping(
--- a/modules/setup/src/main/Processor.scala
+++ b/modules/setup/src/main/Processor.scala
@ -14,7 +14,7 @@ final private[setup] class Processor(
    anonConfigRepo: AnonConfigRepo,
    userConfigRepo: UserConfigRepo,
    onStart: lila.round.OnStart
-) {
+)(implicit ec: scala.concurrent.ExecutionContext) {

  def filter(config: FilterConfig)(implicit ctx: UserContext): Funit =
    saveConfig(_ withFilter config)
@ -44,7 +44,7 @@ final private[setup] class Processor(
            Created(hook.id)
          }
        case Right(Some(seek)) =>
-          ctx.userId.??(gameCache.nbPlaying) map { nbPlaying =>
+          ctx.userId.??(gameCache.nbPlaying) dmap { nbPlaying =>
            if (maxPlaying <= nbPlaying) Refused
            else {
              Bus.publish(AddSeek(seek), "lobbyTrouper")
--- a/modules/setup/src/main/UserConfigRepo.scala
+++ b/modules/setup/src/main/UserConfigRepo.scala
@ -5,7 +5,7 @@ import reactivemongo.api.bson._
 import lila.db.dsl._
 import lila.user.User

-final private class UserConfigRepo(coll: Coll) {
+final private class UserConfigRepo(coll: Coll)(implicit ec: scala.concurrent.ExecutionContext) {

  def update(user: User)(f: UserConfig => UserConfig): Funit =
    config(user) flatMap { config =>
@ -24,8 +24,8 @@ final private class UserConfigRepo(coll: Coll) {
        logger.warn("Can't load config", e)
        none[UserConfig]
      }
-    } map (_ | UserConfig.default(user.id))
+    } dmap (_ | UserConfig.default(user.id))

  def filter(user: User): Fu[FilterConfig] =
-    coll.primitiveOne[FilterConfig]($id(user.id), "filter") map (_ | FilterConfig.default)
+    coll.primitiveOne[FilterConfig]($id(user.id), "filter") dmap (_ | FilterConfig.default)
 }
--- a/modules/streamer/src/main/Env.scala
+++ b/modules/streamer/src/main/Env.scala
@ -31,7 +31,7 @@ final class Env(
    timeline: lila.hub.actors.Timeline,
    db: lila.db.Db,
    imageRepo: lila.db.ImageRepo
-)(implicit system: ActorSystem) {
+)(implicit ec: scala.concurrent.ExecutionContext, system: ActorSystem) {

  implicit private val keywordLoader = strLoader(Stream.Keyword.apply)
  private val config                 = appConfig.get[StreamerConfig]("streamer")(AutoConfig.loader)
--- a/modules/streamer/src/main/LiveStream.scala
+++ b/modules/streamer/src/main/LiveStream.scala
@ -47,7 +47,7 @@ object LiveStreams {
 final class LiveStreamApi(
    asyncCache: lila.memo.AsyncCache.Builder,
    streamingActor: ActorRef
-) {
+)(implicit ec: scala.concurrent.ExecutionContext) {

  private val cache = asyncCache.single[LiveStreams](
    name = "streamer.liveStreams",
--- a/modules/streamer/src/main/StreamerApi.scala
+++ b/modules/streamer/src/main/StreamerApi.scala
@ -14,7 +14,7 @@ final class StreamerApi(
    asyncCache: lila.memo.AsyncCache.Builder,
    photographer: Photographer,
    notifyApi: lila.notify.NotifyApi
-) {
+)(implicit ec: scala.concurrent.ExecutionContext) {

  import BsonHandlers._

@ -27,8 +27,8 @@ final class StreamerApi(
    userRepo named username flatMap { _ ?? find }

  def find(user: User): Fu[Option[Streamer.WithUser]] =
-    byId(Streamer.Id(user.id)) flatMap {
-      _ ?? withUser(user)
+    byId(Streamer.Id(user.id)) dmap {
+      _ map { Streamer.WithUser(_, user) }
    }

  def findOrInit(user: User): Fu[Option[Streamer.WithUser]] =
@ -38,14 +38,14 @@ final class StreamerApi(
    }

  def withUser(s: Stream): Fu[Option[Streamer.WithUserAndStream]] =
-    userRepo named s.streamer.userId map {
+    userRepo named s.streamer.userId dmap {
      _ map { user =>
        Streamer.WithUserAndStream(s.streamer, user, s.some)
      }
    }

  def withUsers(live: LiveStreams): Fu[List[Streamer.WithUserAndStream]] =
-    live.streams.map(withUser).sequenceFu.map(_.flatten)
+    live.streams.map(withUser).sequenceFu.dmap(_.flatten)

  def allListedIds: Fu[Set[Streamer.Id]] = listedIdsCache.get

@ -62,11 +62,11 @@ final class StreamerApi(
    coll.ext
      .find($inIds(ids))
      .sort($doc("seenAt" -> -1))
-      .list[Bdoc](max) map {
+      .list[Bdoc](max) dmap {
      _ flatMap {
        _.getAsOpt[Streamer.Id]("_id")
      }
-    } map (_.toSet)
+    } dmap (_.toSet)

  def update(prev: Streamer, data: StreamerForm.UserData, asMod: Boolean): Fu[Streamer.ModChange] = {
    val streamer = data(prev, asMod)
@ -156,8 +156,6 @@ final class StreamerApi(
      )
  }

-  private def withUser(user: User)(streamer: Streamer) = Streamer.WithUser(streamer, user)
-
  private def selectListedApproved = $doc(
    "listed"           -> true,
    "approval.granted" -> true
--- a/modules/streamer/src/main/StreamerPager.scala
+++ b/modules/streamer/src/main/StreamerPager.scala
@ -11,7 +11,7 @@ final class StreamerPager(
    coll: Coll,
    userRepo: UserRepo,
    maxPerPage: lila.common.config.MaxPerPage
-) {
+)(implicit ec: scala.concurrent.ExecutionContext) {

  import BsonHandlers._

--- a/modules/streamer/src/main/Streaming.scala
+++ b/modules/streamer/src/main/Streaming.scala
@ -30,6 +30,8 @@ final private class Streaming(

  private var liveStreams = LiveStreams(Nil)

+  implicit def ec = context.dispatcher
+
  def receive = {

    case Streaming.Get => sender ! liveStreams
--- a/modules/studySearch/src/main/Env.scala
+++ b/modules/studySearch/src/main/Env.scala
@ -17,7 +17,7 @@ final class Env(
    chapterRepo: lila.study.ChapterRepo,
    pager: lila.study.StudyPager,
    makeClient: Index => ESClient
-)(implicit system: ActorSystem, mat: akka.stream.Materializer) {
+)(implicit ec: scala.concurrent.ExecutionContext, system: ActorSystem, mat: akka.stream.Materializer) {

  private val client = makeClient(Index("study"))

--- a/modules/studySearch/src/main/StudySearchApi.scala
+++ b/modules/studySearch/src/main/StudySearchApi.scala
@ -19,7 +19,7 @@ final class StudySearchApi(
    indexThrottler: ActorRef,
    studyRepo: StudyRepo,
    chapterRepo: ChapterRepo
-)(implicit system: ActorSystem, mat: akka.stream.Materializer)
+)(implicit ec: scala.concurrent.ExecutionContext, system: ActorSystem, mat: akka.stream.Materializer)
    extends SearchReadApi[Study, Query] {

  def search(query: Query, from: From, size: Size) =
@ -27,7 +27,7 @@ final class StudySearchApi(
      studyRepo byOrderedIds res.ids.map(Study.Id.apply)
    }

-  def count(query: Query) = client.count(query) map (_.count)
+  def count(query: Query) = client.count(query) dmap (_.count)

  def store(study: Study) = fuccess {
    indexThrottler ! LateMultiThrottler.work(
--- a/modules/teamSearch/src/main/Env.scala
+++ b/modules/teamSearch/src/main/Env.scala
@ -18,7 +18,7 @@ final class Env(
    appConfig: Configuration,
    makeClient: Index => ESClient,
    teamRepo: lila.team.TeamRepo
-)(implicit system: ActorSystem) {
+)(implicit ec: scala.concurrent.ExecutionContext, system: ActorSystem) {

  private val config = appConfig.get[TeamSearchConfig]("teamSearch")(AutoConfig.loader)

--- a/modules/teamSearch/src/main/TeamSearchApi.scala
+++ b/modules/teamSearch/src/main/TeamSearchApi.scala
@ -9,7 +9,7 @@ import lila.team.{ Team, TeamRepo }
 final class TeamSearchApi(
    client: ESClient,
    teamRepo: TeamRepo
-)(implicit mat: akka.stream.Materializer)
+)(implicit ec: scala.concurrent.ExecutionContext, mat: akka.stream.Materializer)
    extends SearchReadApi[Team, Query] {

  def search(query: Query, from: From, size: Size) =
@ -17,7 +17,7 @@ final class TeamSearchApi(
      teamRepo byOrderedIds res.ids
    }

-  def count(query: Query) = client.count(query) map (_.count)
+  def count(query: Query) = client.count(query) dmap (_.count)

  def store(team: Team) = client.store(Id(team.id), toDoc(team))

--- a/modules/timeline/src/main/EntryApi.scala
+++ b/modules/timeline/src/main/EntryApi.scala
@ -14,7 +14,7 @@ final class EntryApi(
    coll: Coll,
    userMax: Max,
    asyncCache: lila.memo.AsyncCache.Builder
-) {
+)(implicit ec: scala.concurrent.ExecutionContext) {

  import Entry._

@ -36,8 +36,7 @@ final class EntryApi(
        projection.some
      )
      .sort($sort desc "date")
-      .cursor[Entry](ReadPreference.secondaryPreferred)
-      .gather[Vector](max.value)
+      .vector[Entry](max.value, ReadPreference.secondaryPreferred)

  def findRecent(typ: String, since: DateTime, max: Max) =
    coll
@ -46,8 +45,7 @@ final class EntryApi(
        projection.some
      )
      .sort($sort desc "date")
-      .cursor[Entry](ReadPreference.secondaryPreferred)
-      .gather[Vector](max.value)
+      .vector[Entry](max.value, ReadPreference.secondaryPreferred)

  def channelUserIdRecentExists(channel: String, userId: User.ID): Fu[Boolean] =
    coll.countSel(
--- a/Show More
+++ b/Show More