Aux pattern in 5 minutes

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!