Abstract given seems useless

Abstract given were introduced in https://github.com/lampepfl/dotty/pull/10538 . But these seem useless, as one can always define an abstract field and use a given alias:

def ord: Ord[T]
given Ord[T] = ord

Would it be possible to drop this feature, as it forces us to add an uncanny with to givens even when no structural part is needed https://github.com/lampepfl/dotty-feature-requests/issues/156

[julienrf]

I find abstract givens useful, indeed. Abstract definitions are a common means of abstraction (abstract methods and abstract type members). We can observe that in Scala 2 abstract implicit definitions are used (e.g. in cats, endpoints4s, akka, and maybe at other places that I’m not aware of).

From a more fundamental perspective, there is a correspondence between parameters and abstract members. Both are means of abstractions, and you can refactor from one form to the other:

trait WithMembers {
  type A
  val foo: A
}

class WithParameters[A](val foo: A)

However, if we remove abstract givens, this will make it impossible to refactor this:

class Foo[A](using SemiGroup[A])

into that:

trait Foo {
  type A
  given SemiGroup[A]
}

You mentioned a workaround, which in my opinion is not only verbose, but very low-level and “mechanism-oriented” (as opposed to “intent-oriented”). I like how abstract givens removed half of the lines of this part of the compiler.

[julienrf]

That being said, if abstract givens are the only reason why we need the with connector, I agree that it’s an important drawback. Is it true that we could remove with if we didn’t support abstract givens?