Every-time using everytime shapeless.Generic that returns shapeless.Generic.Aux
I was wondering why the construction
type Aux[T, Repr0] = Generic[T] { type Repr = Repr0 }
is needed?
If you are impassioned and want to save a time: AUX pattern is wrapping abstract type member into generic parametrisation to solve compiler limitations.
While the Scala's abstract type members are preferred to generic parametrization sometimes there are the problems with making the code compilable.
Lets revisit Type level programming for Streams and start from the case when Aux pattern isn’t needed:
import cats.Show
implicit val requestFunc = new Function[Int, String] {
override def apply(in: Int): String = s"hello $in"
}
def process[Req, Resp](request: Req)(implicit func: Function[Req, Resp], s: Show[Resp]): String
= func(request).show
Our process function just applies the func to request and then using Show type class to represent the result value. Show and func are implicitly injected according to Req and Resp types.
Lets rewrite using abstract type member:
trait Request[Req] {
type Resp
def response: Resp
}
implicit def string2Sting = new Request[Int] {
type Resp = String
override def response: String = "Hello"
}
def process2[T](value: T)(implicit request: Request[T], m: Show[request.Resp]): String =
request.response.show
Method process2 isn’t compilable because we are trying parametrise Show with request.Response type:
error: illegal dependent method type: parameter may only be referenced in a subsequent parameter section
To fix this we introduce proxy type (Aux pattern).
type Aux[T2, B2] = Request[T2] {type B = B2}
And changing the method to:
def process3[Req, Resp](request: Req)(implicit aux: Aux[Req, Resp], m: Show[Resp]): String =
aux.response.show
As a result we create Aux type that wraps abstract type member into generic to overcome Scala's compiler limitation!
