7mind/izumi

Hi, I am new to distage and was following the documentation and example application to build a small POC based on cats effect's Sync type class, but I am hitting a wall using TagK in my PluginDef. Maybe someone can point me towards a solution here.

[error] App.scala:20:13: could not find implicit value for evidence parameter of type distage.TagK[F]
[error]     include(rideRelationCapacities)
[error]             ^
[error] App.scala:26:9: parameter value evidence$2 in method rideRelationCapacities is never used
[error]     def rideRelationCapacities[F[_]: TagK: Async]: ModuleDef = new ModuleDef {
[error]         ^
[error] two errors found
[error] (ride-relation-projection / Compile / compileIncremental) Compilation failed

This is the PluginDef:

  object AppPlugin extends PluginDef {
    include(roleModule)
    include(rideRelationCapacities)

    def roleModule: RoleModuleDef = new RoleModuleDef {
      makeRole[RideRelationCapacityService]
    }

    def rideRelationCapacities[F[_]: TagK: Async]: ModuleDef = new ModuleDef {
      make[RideRelationCapacities[F]]
        .fromResource[RideRelationCapacities.Dummy[F]]
        .tagged(Repo.Dummy)
    }
  }

And for completeness the Dummy repository implementation:

trait RideRelationCapacities[F[_]] {
  def add(rideRelationCapacities: NonEmptySeq[RideRelationCapacity]): F[Unit]
  def get(rideId: UUID): F[Option[NonEmptySeq[RideRelationCapacity]]]
  def rel(rideId: UUID, fromId: UUID, toId: UUID): F[Option[RideRelationCapacity]]
}

object RideRelationCapacities {
  final class Dummy[F[_]: Sync]
      extends Lifecycle.LiftF[F, RideRelationCapacities[F]](for {
        state <- Sync[F].pure(Map.empty[(UUID, UUID, UUID), Int])
      } yield {
        new RideRelationCapacities[F] {
          type Item = ((UUID, UUID, UUID), Int)

          private var s = state
          private def tupled(i: Item): RideRelationCapacity = RideRelationCapacity(i._1._1, i._1._2, i._1._3, i._2)

          override def add(rideRelationCapacities: NonEmptySeq[RideRelationCapacity]): F[Unit] =
            rideRelationCapacities.traverse_(rc =>
              Sync[F].delay {
                s = s.updated((rc.rideId, rc.from, rc.to), rc.capacity)
              },
            )

          override def get(rideId: UUID): F[Option[NonEmptySeq[RideRelationCapacity]]] =
            Sync[F].pure {
              val filtered = s.filter(_._1._1 === rideId)
              if (filtered.isEmpty) None else Some(NonEmptySeq.fromSeqUnsafe(s.map(tupled).toSeq))
            }

          override def rel(rideId: UUID, fromId: UUID, toId: UUID): F[Option[RideRelationCapacity]] =
            Sync[F].pure(
              s.find(rc => rc._1._1 == rideId && rc._1._2 == fromId && rc._1._3 == toId)
                .map(tupled),
            )
        }
      })
}