How to avoid using a type projection in Scala

Question

I have a trait Location that I don't want to change. O can be a String or Seq[String]

trait Location {
  type O
  def value: O
}

Here is what I want to achieve :

private val stringLog = Log(new Location {
  type O = String
  def value = "base"
})

private val seqStringLog = Log(new Location {
  type O = Seq[String]
  def value = Seq("foo", "bar")
})

println(stringLog.getPath("2020"))
println(stringLog.getPath(List("2018", "2019")))

println(seqStringLog.getPath("2020"))
println(seqStringLog.getPath(List("2018", "2019")))

And the expected result : (in the first case, I have a single location and a single date, so the return type can be String instead of Seq[String])

base/2020
List(base/2018, base/2019)
List(foo/2020, bar/2020)
List(foo/2018, foo/2019, bar/2018, bar/2019)

My current solution uses a type projection. I've seen that it can be an anti pattern and it will be removed in dotty. Is there any cleaner/better solution ?

class Log[L <: Location](location: L)(implicit mapper: Mapper[L#O]) {
  def getPath(date: String): L#O =
    mapper.applyDate(location.value, date)

  def getPath(dates: Seq[String]): Seq[String] =
    mapper.applyDates(location.value, dates)
}

trait Mapper[A] {
  def applyDate(path: A, date: String): A
  def applyDates(path: A, dates: Seq[String]): Seq[String]
}

object Mapper {
  def build(path: String, date: String): String = s"$path/$date"

  implicit val stringMapper: Mapper[String] = new Mapper[String] {
    override def applyDate(path: String, date: String): String = build(path, date)
    override def applyDates(path: String, dates: Seq[String]): Seq[String] =
      dates.map(build(path, _))
  }
  implicit val seqStringMapper: Mapper[Seq[String]] = new Mapper[Seq[String]] {
    override def applyDate(path: Seq[String], date: String): Seq[String] =
      path.map(build(_, date))
    override def applyDates(path: Seq[String], dates: Seq[String]): Seq[String] =
      path.flatMap(p => dates.map(build(p, _)))
  }
}

mainly to avoid having 2 type parameters in Log : `Log[O, L <: Location[O]]`. I've tried both impl. and I find type member more elegant in this case. — Yann Moisan, Jul 08 '20 at 07:01
I have an answer with a type parameter that I deleted, but changes `Location`. I can undelete it if you want — user, Jul 08 '20 at 14:19

Dmytro Mitin · Answer 1 · 2020-07-08T09:09:13.427

Try refined type

case class Log[_O](location: Location { type O = _O })(implicit mapper: Mapper[_O]) {
  def getPath(date: String): _O =
    mapper.applyDate(location.value, date)

  def getPath(dates: Seq[String]): Seq[String] =
    mapper.applyDates(location.value, dates)
}

You can introduce Aux-type type Aux[_O] = Location { type O = _O } and write Location.Aux[_O].

In Dotty type classes and match types are two replacements for type projections

What does Dotty offer to replace type projections?

Dotty cannot infer result type of generic Scala function taking type parameter trait with abstract type

Luis Miguel Mejía Suárez · Answer 2 · 2020-07-08T14:11:08.110

This works for me:

final class Log[L <: Location](val location: L) {
  def getPath(date: String)
             (implicit mapper: Mapper[location.O]): location.O =
    mapper.applyDate(location.value, date)

  def getPath(dates: List[String])
             (implicit mapper: Mapper[location.O]): List[String] =
      mapper.applyDates(location.value, dates)
}

Which can be used as you want to.

BTW, I would recommend you to stay away from Seq and use a concrete collection like List. See this for more info.

Edit

Ensuring a Log instance can only be created if there is a mapper and keeping location encapsulated.

sealed trait Log[L <: Location] {
  protected type LL <: L
  protected val l: LL

  def getPath(date: String): l.O

  def getPath(dates: List[String]): List[String]
}

object Log {
  def apply[L <: Location](location: L)
                          (implicit mapper: Mapper[location.O]): Log[L] = new Log[L] {
    override protected final type LL = location.type                    
    override protected final val l: LL = location
    
    override def getPath(date: String): l.O =
      mapper.applyDate(l.value, date)

    override def getPath(dates: List[String]): List[String] =
        mapper.applyDates(l.value, dates)
  }
}

Thanks for pointing out issue with `Seq`. 2 drawbacks with your proposal : it's possible to instantiate a Log that has no Mapper instances. location is now public (that breaks a bit the encapsulation). — Yann Moisan, Jul 08 '20 at 07:16
@YannMoisan see the edited answer, btw this gets a quite complex because as I have said you before, it is not clear what is your real ultimate goal. For example, do you really need the dependent type? Do you really need to have the precise type `L`? A simple workaround would be just using the **Aux** pattern as Dmytro suggested. — Luis Miguel Mejía Suárez, Jul 08 '20 at 14:12

score 3 · Answer 3 · answered Jul 08 '20 at 00:10

I don't see any reason not to simply use a type parameter here.

trait Location[O] {
  def value: O
}

All you have to do is make Log accept O instead of a location. It's also more concise than having type members because you can simply do new Location[String]{} instead of new Location { type O = String }

class Log[O](location: Location[O])(implicit mapper: Mapper[O]) {
  def getPath(date: String): O =
    mapper.applyDate(location.value, date)
}

private val stringLog = new Log(new Location[String] {
  def value = "base"
})

private val seqStringLog = new Log(new Location[Seq[String]] {
  def value = Seq("foo", "bar")
})

In Scastie

How to avoid using a type projection in Scala

3 Answers3

Edit