Exploit path dependent types and get generic companion type to work

Author: hamnis

core/shared/src/main/scala/org/typelevel/log4cats/LoggerFactory.scala

@@ -22,36 +22,10 @@ import scala.annotation.implicitNotFound
 Implicit not found for LoggerFactory[${F}].
 Information can be found here: https://log4cats.github.io/logging-capability.html
 """)
-trait LoggerFactory[F[_]] extends LoggerFactoryGen[F, SelfAwareStructuredLogger[F]]
-object LoggerFactory extends LoggerFactoryCompanion {
-  def apply[F[_]: LoggerFactory]: LoggerFactory[F] = implicitly
+trait LoggerFactory[F[_]] extends LoggerFactoryGen[F] {
+  type LoggerType = SelfAwareStructuredLogger[F]
 }
 
-private[log4cats] trait LoggerFactoryCompanion {
-  def getLogger[F[_]](implicit
-      lf: LoggerFactory[F],
-      name: LoggerName
-  ): SelfAwareStructuredLogger[F] =
-    lf.getLogger
-  def getLoggerFromName[F[_]](name: String)(implicit
-      lf: LoggerFactory[F]
-  ): SelfAwareStructuredLogger[F] =
-    lf.getLoggerFromName(name)
-
-  def getLoggerFromClass[F[_]](clazz: Class[_])(implicit
-      lf: LoggerFactory[F]
-  ): SelfAwareStructuredLogger[F] =
-    lf.getLoggerFromClass(clazz)
-
-  def create[F[_]](implicit
-      lf: LoggerFactory[F],
-      name: LoggerName
-  ): F[SelfAwareStructuredLogger[F]] =
-    lf.create
-  def fromName[F[_]](name: String)(implicit lf: LoggerFactory[F]): F[SelfAwareStructuredLogger[F]] =
-    lf.fromName(name)
-  def fromClass[F[_]](clazz: Class[_])(implicit
-      lf: LoggerFactory[F]
-  ): F[SelfAwareStructuredLogger[F]] =
-    lf.fromClass(clazz)
-}
+object LoggerFactory extends LoggerFactoryGenCompanion {
+  def apply[F[_]: LoggerFactory]: LoggerFactory[F] = implicitly
+}

core/shared/src/main/scala/org/typelevel/log4cats/LoggerFactoryGen.scala

@@ -16,11 +16,27 @@
 
 package org.typelevel.log4cats
 
-trait LoggerFactoryGen[F[_], LoggerType] {
+trait LoggerFactoryGen[F[_]] {
+  type LoggerType <: Logger[F]
   def getLogger(implicit name: LoggerName): LoggerType = getLoggerFromName(name.value)
   def getLoggerFromClass(clazz: Class[_]): LoggerType = getLoggerFromName(clazz.getName)
   def create(implicit name: LoggerName): F[LoggerType] = fromName(name.value)
   def fromClass(clazz: Class[_]): F[LoggerType] = fromName(clazz.getName)
   def getLoggerFromName(name: String): LoggerType
   def fromName(name: String): F[LoggerType]
 }
+
+private[log4cats] trait LoggerFactoryGenCompanion {
+  def getLogger[F[_]](implicit lf: LoggerFactoryGen[F], name: LoggerName): lf.LoggerType =
+    lf.getLogger
+  def getLoggerFromName[F[_]](name: String)(implicit lf: LoggerFactoryGen[F]): lf.LoggerType =
+    lf.getLoggerFromName(name)
+  def getLoggerFromClass[F[_]](clazz: Class[_])(implicit lf: LoggerFactoryGen[F]): lf.LoggerType =
+    lf.getLoggerFromClass(clazz)
+  def create[F[_]](implicit lf: LoggerFactoryGen[F], name: LoggerName): F[lf.LoggerType] =
+    lf.create
+  def fromName[F[_]](name: String)(implicit lf: LoggerFactoryGen[F]): F[lf.LoggerType] =
+    lf.fromName(name)
+  def fromClass[F[_]](clazz: Class[_])(implicit lf: LoggerFactoryGen[F]): F[lf.LoggerType] =
+    lf.fromClass(clazz)
+}

slf4j/src/main/scala/org/typelevel/log4cats/slf4j/Slf4jFactory.scala

@@ -25,7 +25,7 @@ trait Slf4jFactory[F[_]] extends LoggerFactory[F] {
   def fromSlf4j(logger: JLogger): F[SelfAwareStructuredLogger[F]]
 }
 
-object Slf4jFactory extends LoggerFactoryCompanion {
+object Slf4jFactory extends LoggerFactoryGenCompanion {
   def apply[F[_]: Slf4jFactory]: Slf4jFactory[F] = implicitly
 
   def getLoggerFromSlf4j[F[_]](logger: JLogger)(implicit