Scala 3 support

.github/workflows/checks.yml

@@ -63,10 +63,13 @@ jobs:
         with:
           jvm: temurin:1.11.0
 
-      - name: Compile all code with fatal warnings for Java 11, Scala 2.13
+      - name: Compile all code with fatal warnings for Java 11 and Scala 2.13
         # Run locally with: sbt 'clean ; +Test/compile ; +It/compile'
         run: sbt "; Test/compile"
 
+      - name: Compile all code with fatal warnings for Java 11 and Scala 3.3
+        run: sbt "++3.3; Test/compile"
+
   check-docs:
     name: Check Docs
     runs-on: ubuntu-22.04

build.sbt

@@ -18,9 +18,15 @@ lazy val core = project
     name := "akka-persistence-jdbc",
     libraryDependencies ++= Dependencies.Libraries,
     mimaReportSignatureProblems := true,
-    mimaPreviousArtifacts := Set(
-      organization.value %% name.value % previousStableVersion.value.getOrElse(
-        throw new Error("Unable to determine previous version for MiMa"))))
+    mimaPreviousArtifacts := {
+      if (scalaVersion.value.startsWith("3")) {
+        Set.empty
+      } else {
+        Set(
+          organization.value %% name.value % previousStableVersion.value.getOrElse(
+            throw new Error("Unable to determine previous version for MiMa")))
+      }
+    })
 
 lazy val integration = project
   .in(file("integration"))

core/src/main/mima-filters/5.4.0.backwards.excludes/issue-775-slick-3.50.excludes

@@ -0,0 +1,38 @@
+ProblemFilters.exclude[IncompatibleMethTypeProblem]("akka.persistence.jdbc.db.EagerSlickDatabase.apply")
+ProblemFilters.exclude[IncompatibleSignatureProblem]("akka.persistence.jdbc.db.EagerSlickDatabase.unapply")
+ProblemFilters.exclude[IncompatibleSignatureProblem]("akka.persistence.jdbc.db.EagerSlickDatabase.tupled")
+ProblemFilters.exclude[IncompatibleSignatureProblem]("akka.persistence.jdbc.db.EagerSlickDatabase.curried")
+ProblemFilters.exclude[IncompatibleResultTypeProblem]("akka.persistence.jdbc.db.EagerSlickDatabase.database")
+ProblemFilters.exclude[IncompatibleMethTypeProblem]("akka.persistence.jdbc.db.EagerSlickDatabase.copy")
+ProblemFilters.exclude[IncompatibleResultTypeProblem]("akka.persistence.jdbc.db.EagerSlickDatabase.copy$default$1")
+ProblemFilters.exclude[IncompatibleMethTypeProblem]("akka.persistence.jdbc.db.EagerSlickDatabase.this")
+
+ProblemFilters.exclude[IncompatibleResultTypeProblem]("akka.persistence.jdbc.db.LazySlickDatabase.database")
+
+ProblemFilters.exclude[IncompatibleResultTypeProblem]("akka.persistence.jdbc.db.SlickDatabase.forConfig")
+ProblemFilters.exclude[IncompatibleResultTypeProblem]("akka.persistence.jdbc.db.SlickDatabase.database")
+ProblemFilters.exclude[ReversedMissingMethodProblem]("akka.persistence.jdbc.db.SlickDatabase.database")
+
+ProblemFilters.exclude[IncompatibleResultTypeProblem]("akka.persistence.jdbc.journal.JdbcAsyncWriteJournal.db")
+ProblemFilters.exclude[IncompatibleResultTypeProblem]("akka.persistence.jdbc.journal.dao.DefaultJournalDao.db")
+ProblemFilters.exclude[IncompatibleMethTypeProblem]("akka.persistence.jdbc.journal.dao.DefaultJournalDao.this")
+ProblemFilters.exclude[IncompatibleResultTypeProblem]("akka.persistence.jdbc.journal.dao.legacy.BaseByteArrayJournalDao.db")
+ProblemFilters.exclude[ReversedMissingMethodProblem]("akka.persistence.jdbc.journal.dao.legacy.BaseByteArrayJournalDao.db")
+ProblemFilters.exclude[IncompatibleResultTypeProblem]("akka.persistence.jdbc.journal.dao.legacy.ByteArrayJournalDao.db")
+ProblemFilters.exclude[IncompatibleMethTypeProblem]("akka.persistence.jdbc.journal.dao.legacy.ByteArrayJournalDao.this")
+ProblemFilters.exclude[IncompatibleResultTypeProblem]("akka.persistence.jdbc.query.dao.DefaultReadJournalDao.db")
+ProblemFilters.exclude[IncompatibleMethTypeProblem]("akka.persistence.jdbc.query.dao.DefaultReadJournalDao.this")
+ProblemFilters.exclude[IncompatibleResultTypeProblem]("akka.persistence.jdbc.query.dao.legacy.BaseByteArrayReadJournalDao.db")
+ProblemFilters.exclude[ReversedMissingMethodProblem]("akka.persistence.jdbc.query.dao.legacy.BaseByteArrayReadJournalDao.db")
+ProblemFilters.exclude[IncompatibleResultTypeProblem]("akka.persistence.jdbc.query.dao.legacy.ByteArrayReadJournalDao.db")
+ProblemFilters.exclude[IncompatibleMethTypeProblem]("akka.persistence.jdbc.query.dao.legacy.ByteArrayReadJournalDao.this")
+ProblemFilters.exclude[IncompatibleResultTypeProblem]("akka.persistence.jdbc.query.dao.legacy.OracleReadJournalDao.db")
+ProblemFilters.exclude[ReversedMissingMethodProblem]("akka.persistence.jdbc.query.dao.legacy.OracleReadJournalDao.db")
+ProblemFilters.exclude[IncompatibleResultTypeProblem]("akka.persistence.jdbc.snapshot.JdbcSnapshotStore.db")
+ProblemFilters.exclude[IncompatibleMethTypeProblem]("akka.persistence.jdbc.snapshot.dao.DefaultSnapshotDao.this")
+ProblemFilters.exclude[IncompatibleMethTypeProblem]("akka.persistence.jdbc.snapshot.dao.legacy.ByteArraySnapshotDao.this")
+ProblemFilters.exclude[IncompatibleResultTypeProblem]("akka.persistence.jdbc.state.JdbcDurableStateStoreProvider.db")
+ProblemFilters.exclude[IncompatibleMethTypeProblem]("akka.persistence.jdbc.state.scaladsl.JdbcDurableStateStore.this")
+
+
+

core/src/main/scala/akka/persistence/jdbc/journal/dao/JournalTables.scala

@@ -64,7 +64,7 @@ trait JournalTables {
         eventSerManifest,
         metaPayload,
         metaSerId,
-        metaSerManifest) <> (JournalAkkaSerializationRow.tupled, JournalAkkaSerializationRow.unapply)
+        metaSerManifest) <> ((JournalAkkaSerializationRow.apply _).tupled, JournalAkkaSerializationRow.unapply)
 
     val ordering: Rep[Long] = column[Long](journalTableCfg.columnNames.ordering, O.AutoInc)
     val persistenceId: Rep[String] =
@@ -91,17 +91,17 @@ trait JournalTables {
   lazy val JournalTable = new TableQuery(tag => new JournalEvents(tag))
 
   class EventTags(_tableTag: Tag) extends Table[TagRow](_tableTag, tagTableCfg.schemaName, tagTableCfg.tableName) {
-    override def * = (eventId, persistenceId, sequenceNumber, tag) <> (TagRow.tupled, TagRow.unapply)
+    override def * = (eventId, persistenceId, sequenceNumber, tag) <> ((TagRow.apply _).tupled, TagRow.unapply)
     // allow null value insert.
-    val eventId: Rep[Option[Long]] = column[Long](tagTableCfg.columnNames.eventId)
-    val persistenceId: Rep[Option[String]] = column[String](tagTableCfg.columnNames.persistenceId)
-    val sequenceNumber: Rep[Option[Long]] = column[Long](tagTableCfg.columnNames.sequenceNumber)
+    val eventId: Rep[Option[Long]] = column[Option[Long]](tagTableCfg.columnNames.eventId)
+    val persistenceId: Rep[Option[String]] = column[Option[String]](tagTableCfg.columnNames.persistenceId)
+    val sequenceNumber: Rep[Option[Long]] = column[Option[Long]](tagTableCfg.columnNames.sequenceNumber)
     val tag: Rep[String] = column[String](tagTableCfg.columnNames.tag)
 
     val pk = primaryKey(s"${tagTableCfg.tableName}_pk", (persistenceId, sequenceNumber, tag))
     val journalEvent =
       foreignKey(s"fk_${journalTableCfg.tableName}", (persistenceId, sequenceNumber), JournalTable)(e =>
-        (e.persistenceId, e.sequenceNumber))
+        (Rep.Some(e.persistenceId), Rep.Some(e.sequenceNumber)))
   }
 
   lazy val TagTable = new TableQuery(tag => new EventTags(tag))

core/src/main/scala/akka/persistence/jdbc/journal/dao/legacy/ByteArrayJournalDao.scala

@@ -28,7 +28,8 @@ class ByteArrayJournalDao(
     serialization: Serialization)(implicit val ec: ExecutionContext, val mat: Materializer)
     extends BaseByteArrayJournalDao {
   val queries = new JournalQueries(profile, journalConfig.journalTableConfiguration)
-  val serializer = new ByteArrayJournalSerializer(serialization, journalConfig.pluginConfig.tagSeparator)
+  val serializer: ByteArrayJournalSerializer =
+    new ByteArrayJournalSerializer(serialization, journalConfig.pluginConfig.tagSeparator)
 }
 
 /**

core/src/main/scala/akka/persistence/jdbc/journal/dao/legacy/JournalTables.scala

@@ -19,7 +19,13 @@ trait JournalTables {
         _tableTag,
         _schemaName = journalTableCfg.schemaName,
         _tableName = journalTableCfg.tableName) {
-    def * = (ordering, deleted, persistenceId, sequenceNumber, message, tags) <> (JournalRow.tupled, JournalRow.unapply)
+    def * = (
+      ordering,
+      deleted,
+      persistenceId,
+      sequenceNumber,
+      message,
+      tags) <> ((JournalRow.apply _).tupled, JournalRow.unapply)
 
     val ordering: Rep[Long] = column[Long](journalTableCfg.columnNames.ordering, O.AutoInc)
     val persistenceId: Rep[String] =

core/src/main/scala/akka/persistence/jdbc/query/JdbcReadJournalProvider.scala

@@ -11,7 +11,8 @@ import com.typesafe.config.Config
 
 class JdbcReadJournalProvider(system: ExtendedActorSystem, config: Config, configPath: String)
     extends ReadJournalProvider {
-  override val scaladslReadJournal = new scaladsl.JdbcReadJournal(config, configPath)(system)
+  override def scaladslReadJournal(): scaladsl.JdbcReadJournal =
+    new scaladsl.JdbcReadJournal(config, configPath)(system)
 
-  override val javadslReadJournal = new javadsl.JdbcReadJournal(scaladslReadJournal)
+  override def javadslReadJournal(): javadsl.JdbcReadJournal = new javadsl.JdbcReadJournal(scaladslReadJournal())
 }

core/src/main/scala/akka/persistence/jdbc/query/JournalSequenceActor.scala

@@ -38,15 +38,15 @@ object JournalSequenceActor {
    * Efficient representation of missing elements using NumericRanges.
    * It can be seen as a collection of OrderingIds
    */
-  private case class MissingElements(elements: Seq[NumericRange[OrderingId]]) {
+  case class MissingElements(elements: Seq[NumericRange[OrderingId]]) {
     def addRange(from: OrderingId, until: OrderingId): MissingElements = {
       val newRange = from.until(until)
       MissingElements(elements :+ newRange)
     }
     def contains(id: OrderingId): Boolean = elements.exists(_.containsTyped(id))
     def isEmpty: Boolean = elements.forall(_.isEmpty)
   }
-  private object MissingElements {
+  object MissingElements {
     def empty: MissingElements = MissingElements(Vector.empty)
   }
 }

core/src/main/scala/akka/persistence/jdbc/query/dao/legacy/ByteArrayReadJournalDao.scala

@@ -112,7 +112,8 @@ trait OracleReadJournalDao extends ReadJournalDao {
     }
   }
 
-  implicit val getJournalRow = GetResult(r => JournalRow(r.<<, r.<<, r.<<, r.<<, r.nextBytes(), r.<<))
+  implicit val getJournalRow: GetResult[JournalRow] =
+    GetResult(r => JournalRow(r.<<, r.<<, r.<<, r.<<, r.nextBytes(), r.<<))
 
   abstract override def eventsByTag(
       tag: String,
@@ -155,5 +156,6 @@ class ByteArrayReadJournalDao(
     extends BaseByteArrayReadJournalDao
     with OracleReadJournalDao {
   val queries = new ReadJournalQueries(profile, readJournalConfig)
-  val serializer = new ByteArrayJournalSerializer(serialization, readJournalConfig.pluginConfig.tagSeparator)
+  val serializer: ByteArrayJournalSerializer =
+    new ByteArrayJournalSerializer(serialization, readJournalConfig.pluginConfig.tagSeparator)
 }

core/src/main/scala/akka/persistence/jdbc/snapshot/dao/SnapshotTables.scala

@@ -21,6 +21,7 @@ object SnapshotTables {
       metaSerId: Option[Int],
       metaSerManifest: Option[String],
       metaPayload: Option[Array[Byte]])
+
 }
 
 trait SnapshotTables {
@@ -43,7 +44,7 @@ trait SnapshotTables {
         snapshotPayload,
         metaSerId,
         metaSerManifest,
-        metaPayload) <> (SnapshotRow.tupled, SnapshotRow.unapply)
+        metaPayload) <> ((SnapshotRow.apply _).tupled, SnapshotRow.unapply)
 
     val persistenceId: Rep[String] =
       column[String](snapshotTableCfg.columnNames.persistenceId, O.Length(255, varying = true))

core/src/main/scala/akka/persistence/jdbc/snapshot/dao/legacy/SnapshotTables.scala

@@ -31,7 +31,7 @@ trait SnapshotTables {
         _tableTag,
         _schemaName = snapshotTableCfg.schemaName,
         _tableName = snapshotTableCfg.tableName) {
-    def * = (persistenceId, sequenceNumber, created, snapshot) <> (SnapshotRow.tupled, SnapshotRow.unapply)
+    def * = (persistenceId, sequenceNumber, created, snapshot) <> ((SnapshotRow.apply _).tupled, SnapshotRow.unapply)
 
     val persistenceId: Rep[String] =
       column[String](snapshotTableCfg.columnNames.persistenceId, O.Length(255, varying = true))

core/src/main/scala/akka/persistence/jdbc/state/DurableStateQueries.scala

@@ -42,7 +42,7 @@ import akka.persistence.jdbc.config.DurableStateTableConfiguration
     case _          => ???
   }
 
-  implicit val uuidSetter = SetParameter[Array[Byte]] { case (bytes, params) =>
+  implicit val uuidSetter: SetParameter[Array[Byte]] = SetParameter[Array[Byte]] { case (bytes, params) =>
     params.setBytes(bytes)
   }
 

core/src/main/scala/akka/persistence/jdbc/state/DurableStateTables.scala

@@ -41,7 +41,7 @@ import akka.persistence.jdbc.config.DurableStateTableConfiguration
 
     def * =
       (globalOffset, persistenceId, revision, statePayload, tag, stateSerId, stateSerManifest, stateTimestamp)
-        .<>(DurableStateRow.tupled, DurableStateRow.unapply)
+        .<>((DurableStateRow.apply _).tupled, DurableStateRow.unapply)
 
     val globalOffset: Rep[Long] = column[Long](durableStateTableCfg.columnNames.globalOffset, O.AutoInc)
     val persistenceId: Rep[String] =

core/src/main/scala/akka/persistence/jdbc/state/JdbcDurableStateStoreProvider.scala

@@ -33,10 +33,10 @@ class JdbcDurableStateStoreProvider[A](system: ExtendedActorSystem) extends Dura
   lazy val serialization = SerializationExtension(system)
   val profile: JdbcProfile = slickDb.profile
 
-  override val scaladslDurableStateStore: DurableStateStore[Any] =
+  override def scaladslDurableStateStore(): DurableStateStore[Any] =
     new scaladsl.JdbcDurableStateStore[Any](db, profile, durableStateConfig, serialization)(system)
 
-  override val javadslDurableStateStore: JDurableStateStore[AnyRef] =
+  override def javadslDurableStateStore(): JDurableStateStore[AnyRef] =
     new javadsl.JdbcDurableStateStore[AnyRef](
       profile,
       durableStateConfig,

core/src/main/scala/akka/persistence/jdbc/state/scaladsl/DurableStateSequenceActor.scala

@@ -46,7 +46,7 @@ import akka.annotation.InternalApi
    * Efficient representation of missing elements using NumericRanges.
    * It can be seen as a collection of GlobalOffset
    */
-  private case class MissingElements(elements: Seq[NumericRange[GlobalOffset]]) {
+  case class MissingElements(elements: Seq[NumericRange[GlobalOffset]]) {
     def addRange(from: GlobalOffset, until: GlobalOffset): MissingElements = {
       val newRange = from.until(until)
       MissingElements(elements :+ newRange)

core/src/main/scala/akka/persistence/jdbc/state/scaladsl/JdbcDurableStateStore.scala

@@ -211,20 +211,16 @@ class JdbcDurableStateStore[A](
   }
 
   private def updateDurableState(row: DurableStateTables.DurableStateRow) = {
-    import queries._
-
     for {
-      s <- getSequenceNextValueExpr()
-      u <- updateDbWithDurableState(row, s.head)
+      s <- queries.getSequenceNextValueExpr()
+      u <- queries.updateDbWithDurableState(row, s.head)
     } yield u
   }
 
   private def insertDurableState(row: DurableStateTables.DurableStateRow) = {
-    import queries._
-
     for {
-      s <- getSequenceNextValueExpr()
-      u <- insertDbWithDurableState(row, s.head)
+      s <- queries.getSequenceNextValueExpr()
+      u <- queries.insertDbWithDurableState(row, s.head)
     } yield u
   }
 

core/src/test/scala/akka/persistence/jdbc/SharedActorSystemTestSpec.scala

@@ -28,7 +28,7 @@ abstract class SharedActorSystemTestSpec(val config: Config) extends SimpleSpec
 
   implicit lazy val ec: ExecutionContext = system.dispatcher
   implicit val pc: PatienceConfig = PatienceConfig(timeout = 1.minute)
-  implicit val timeout = Timeout(1.minute)
+  implicit val timeout: Timeout = Timeout(1.minute)
 
   lazy val serialization = SerializationExtension(system)
 

core/src/test/scala/akka/persistence/jdbc/SingleActorSystemPerTestSpec.scala

@@ -26,7 +26,7 @@ abstract class SingleActorSystemPerTestSpec(val config: Config)
       conf.withValue(path, configValue)
     })
 
-  implicit val pc: PatienceConfig = PatienceConfig(timeout = 1.minute)
+  override implicit val patienceConfig: PatienceConfig = PatienceConfig(timeout = 1.minute)
   implicit val timeout: Timeout = Timeout(1.minute)
 
   val cfg = config.getConfig("jdbc-journal")

core/src/test/scala/akka/persistence/jdbc/journal/JdbcJournalPerfSpec.scala

@@ -18,6 +18,7 @@ import com.typesafe.config.{ Config, ConfigFactory }
 import org.scalatest.{ BeforeAndAfterAll, BeforeAndAfterEach }
 import org.scalatest.concurrent.ScalaFutures
 
+import scala.concurrent.ExecutionContext
 import scala.concurrent.duration._
 
 abstract class JdbcJournalPerfSpec(config: Config, schemaType: SchemaType)
@@ -29,7 +30,7 @@ abstract class JdbcJournalPerfSpec(config: Config, schemaType: SchemaType)
     with DropCreate {
   override protected def supportsRejectingNonSerializableObjects: CapabilityFlag = true
 
-  implicit lazy val ec = system.dispatcher
+  implicit lazy val ec: ExecutionContext = system.dispatcher
 
   implicit def pc: PatienceConfig = PatienceConfig(timeout = 10.minutes)
 

core/src/test/scala/akka/persistence/jdbc/journal/JdbcJournalSpec.scala

@@ -15,6 +15,7 @@ import com.typesafe.config.{ Config, ConfigFactory }
 import org.scalatest.{ BeforeAndAfterAll, BeforeAndAfterEach }
 import org.scalatest.concurrent.ScalaFutures
 
+import scala.concurrent.ExecutionContext
 import scala.concurrent.duration._
 
 abstract class JdbcJournalSpec(config: Config, schemaType: SchemaType)
@@ -28,7 +29,7 @@ abstract class JdbcJournalSpec(config: Config, schemaType: SchemaType)
 
   implicit val pc: PatienceConfig = PatienceConfig(timeout = 10.seconds)
 
-  implicit lazy val ec = system.dispatcher
+  implicit lazy val ec: ExecutionContext = system.dispatcher
 
   lazy val cfg = system.settings.config.getConfig("jdbc-journal")
 

core/src/test/scala/akka/persistence/jdbc/query/HardDeleteQueryTest.scala

@@ -12,7 +12,7 @@ import scala.concurrent.duration._
 import org.scalatest.matchers.should.Matchers
 
 abstract class HardDeleteQueryTest(config: String) extends QueryTestSpec(config) with Matchers {
-  implicit val askTimeout = 500.millis
+  implicit val askTimeout: FiniteDuration = 500.millis
 
   it should "not return deleted events when using CurrentEventsByTag" in withActorSystem { implicit system =>
     val journalOps = new ScalaJdbcReadJournalOperations(system)

core/src/test/scala/akka/persistence/jdbc/query/JournalDaoStreamMessagesMemoryTest.scala

@@ -43,7 +43,7 @@ abstract class JournalDaoStreamMessagesMemoryTest(configFile: String)
   val journalSequenceActorConfig = readJournalConfig.journalSequenceRetrievalConfiguration
   val journalTableCfg = journalConfig.journalTableConfiguration
 
-  implicit val askTimeout = 50.millis
+  implicit val askTimeout: FiniteDuration = 50.millis
 
   def generateId: Int = 0
 

core/src/test/scala/akka/persistence/jdbc/query/JournalSequenceActorTest.scala

@@ -33,7 +33,7 @@ abstract class JournalSequenceActorTest(configFile: String, isOracle: Boolean)
 
   import profile.api._
 
-  implicit val askTimeout = 50.millis
+  implicit val askTimeout: FiniteDuration = 50.millis
 
   def generateId: Int = 0
 
@@ -75,11 +75,12 @@ abstract class JournalSequenceActorTest(configFile: String, isOracle: Boolean)
 
           val startTime = System.currentTimeMillis()
           withJournalSequenceActor(db, maxTries = 100) { actor =>
-            val patienceConfig = PatienceConfig(10.seconds, Span(200, org.scalatest.time.Millis))
+            implicit val patienceConfig: PatienceConfig =
+              PatienceConfig(10.seconds, Span(200, org.scalatest.time.Millis))
             eventually {
               val currentMax = actor.ask(GetMaxOrderingId).mapTo[MaxOrderingId].futureValue.maxOrdering
               currentMax shouldBe elements
-            }(patienceConfig, implicitly, implicitly)
+            }
           }
           val timeTaken = System.currentTimeMillis() - startTime
           log.info(s"Recovered all events in $timeTaken ms")
@@ -109,11 +110,12 @@ abstract class JournalSequenceActorTest(configFile: String, isOracle: Boolean)
 
           withJournalSequenceActor(db, maxTries = 2) { actor =>
             // Should normally recover after `maxTries` seconds
-            val patienceConfig = PatienceConfig(10.seconds, Span(200, org.scalatest.time.Millis))
+            implicit val patienceConfig: PatienceConfig =
+              PatienceConfig(10.seconds, Span(200, org.scalatest.time.Millis))
             eventually {
               val currentMax = actor.ask(GetMaxOrderingId).mapTo[MaxOrderingId].futureValue.maxOrdering
               currentMax shouldBe lastElement
-            }(patienceConfig, implicitly, implicitly)
+            }
           }
         }
       }
@@ -145,11 +147,11 @@ abstract class JournalSequenceActorTest(configFile: String, isOracle: Boolean)
 
           withJournalSequenceActor(db, maxTries = 2) { actor =>
             // The actor should assume the max after 2 seconds
-            val patienceConfig = PatienceConfig(3.seconds)
+            implicit val patienceConfig: PatienceConfig = PatienceConfig(3.seconds)
             eventually {
               val currentMax = actor.ask(GetMaxOrderingId).mapTo[MaxOrderingId].futureValue.maxOrdering
               currentMax shouldBe highestValue
-            }(patienceConfig, implicitly, implicitly)
+            }
           }
         }
       }

core/src/test/scala/akka/persistence/jdbc/query/dao/TestProbeReadJournalDao.scala

@@ -27,7 +27,7 @@ object TestProbeReadJournalDao {
  */
 class TestProbeReadJournalDao(val probe: TestProbe) extends ReadJournalDao {
   // Since the testprobe is instrumented by the test, it should respond very fast
-  implicit val askTimeout = Timeout(100.millis)
+  implicit val askTimeout: Timeout = Timeout(100.millis)
 
   /**
    * Returns distinct stream of persistenceIds