问题
Returning the current type questions are often asked on StackOverflow. Here is one such example. The usual answers seem to be either F-bounded polymorphism or typeclass pattern solution. Odersky suggests in Is F-bound polymorphism useful?
F-bounds do indeed add significant complexity. I would love to be able to get rid of them, and replace them with higher-kinded subtyping
whilst tpolecat (the author of linked post) suggests
A better strategy is to use a typeclass, which solves the problem neatly and leaves little room for worry. In fact it’s worth considering abandoning subtype polymorphism altogether in these situations.
where the following disadvantage is identified
F-bounded polymorphism parameterizes a type over its own subtypes, which is a weaker constraint than what the user usually wants, which is a way to say “my type”, which you can’t express precisely via subtyping. However typeclasses can express this idea directly, so that’s what I would teach beginners
My question is, in light of the above suggestions, can someone demonstrate a situation where F-bounded polymorphism is favorable, or should we point to typeclass solution as the canonical answer for solving the return-current-type problem?
F-bound polymorphism by type parameter
trait Semigroup[A <: Semigroup[A]] { this: A =>
def combine(that: A): A
}
final case class Foo(v: Int) extends Semigroup[Foo] {
override def combine(that: Foo): Foo = Foo(this.v + that.v)
}
final case class Bar(v: String) extends Semigroup[Bar] {
override def combine(that: Bar): Bar = Bar(this.v concat that.v)
}
def reduce[A <: Semigroup[A]](as: List[A]): A = as.reduce(_ combine _)
reduce(List(Foo(1), Foo(41))) // res0: Foo = Foo(42)
reduce(List(Bar("Sca"), Bar("la"))) // res1: Bar = Bar(Scala)
F-bounded polymorphism by type member
trait Semigroup {
type A <: Semigroup
def combine(that: A): A
}
final case class Foo(v: Int) extends Semigroup {
override type A = Foo
override def combine(that: Foo): Foo = Foo(this.v + that.v)
}
final case class Bar(v: String) extends Semigroup {
override type A = Bar
override def combine(that: Bar): Bar = Bar(this.v concat that.v)
}
def reduce[B <: Semigroup { type A = B }](as: List[B]) =
as.reduce(_ combine _)
reduce(List(Foo(1), Foo(41))) // res0: Foo = Foo(42)
reduce(List(Bar("Sca"), Bar("la"))) // res1: Bar = Bar(Scala)
Typeclass
trait Semigroup[A] {
def combine(x: A, y: A): A
}
final case class Foo(v: Int)
object Foo {
implicit final val FooSemigroup: Semigroup[Foo] =
new Semigroup[Foo] {
override def combine(x: Foo, y: Foo): Foo = Foo(x.v + y.v)
}
}
final case class Bar(v: String)
object Bar {
implicit final val BarSemigroup: Semigroup[Bar] =
new Semigroup[Bar] {
override def combine(x: Bar, y: Bar): Bar = Bar(x.v concat y.v)
}
}
def reduce[A](as: List[A])(implicit ev: Semigroup[A]): A = as.reduce(ev.combine)
reduce(List(Foo(1), Foo(41))) // res0: Foo = Foo(42)
reduce(List(Bar("Sca"), Bar("la"))) // res1: Bar = Bar(Scala)
回答1:
F-Bounded is a great example of what a type system is capable of express, even simpler ones, like the Java one. But, a typeclass would always be safer and better alternative.
What do we mean with safer? Simply, that we can not break the contract of returning exactly the same type. Which can be done for the two forms of F-Bounded polymorphism (quite easily).
F-bounded polymorphism by type member
This one is pretty easy to break, since we only need to lie about the type member.
trait Pet {
type P <: Pet
def name: String
def renamed(newName: String): P
}
final case class Dog(name: String) extends Pet {
override type P = Dog
override def renamed(newName: String): Dog = Dog(newName)
}
final case class Cat(name: String) extends Pet {
override type P = Dog // Here we break it.
override def renamed(newName: String): Dog = Dog(newName)
}
Cat("Luis").renamed(newName = "Mario")
// res: Dog = Dog("Mario")
F-bounded polymorphism by type parameter
This one is a little bit harder to break, since the this: A enforces that the extending class is the same. However, we only need to add an additional layer of inheritance.
trait Pet[P <: Pet[P]] { this: P =>
def name: String
def renamed(newName: String): P
}
class Dog(override val name: String) extends Pet[Dog] {
override def renamed(newName: String): Dog = new Dog(newName)
override def toString: String = s"Dog(${name})"
}
class Cat(name: String) extends Dog(name) // Here we break it.
new Cat("Luis").renamed(newName = "Mario")
// res: Dog = Dog(Mario)
Nevertheless, it is clear that the typeclass approach is more complex and has more boilerplate; Also, one can argue that to break F-Bounded, you have to do it intentionally. Thus, if you are OK with the problems of F-Bounded and do not like to deal with the complexity of a typeclass then it is still a valid solution.
Also, we should note that even the typeclass approach can be broken by using things like asInstanceOf or reflection.
BTW, it is worth mentioning that if instead of returning a modified copy, you want to modify the current object and return itself to allow chaining of calls (like a traditional Java builder), you can (should) use this.type.
trait Pet {
def name: String
def renamed(newName: String): this.type
}
final class Dog(private var _name: String) extends Pet {
override def name: String = _name
override def renamed(newName: String): this.type = {
this._name = newName
this
}
override def toString: String = s"Dog(${name})"
}
val d1 = Dog("Luis")
// d1: Dog = Dog(Luis)
val d2 = d1.renamed(newName = "Mario")
// d2: Dog = Dog(Mario)
d1 eq d2
// true
d1
// d1: Dog = Dog(Mario)
回答2:
I would suggest that typeclasses are indeed the superior pattern, and any F-bound polymorphic solution to a question of 'return the current type' has an equally good if not better typeclass parallel.
The F-bound polymorphic approach doesn't actually express the 'current type' concept very well, whereas a typeclass can. Typeclasses also make for generally good code under the principle that composition is better than inheritance. This answer offers similar logic, with reference to scala typeclasses in particular.
Note: I'm not an authority; it just seems that this is probably the right answer (as hinted in the question), and needs to be represented.
来源：https://stackoverflow.com/questions/59813323/advantages-of-f-bounded-polymorphism-over-typeclass-for-return-current-type-prob