Alternative to extending implicit classes

[qwbarch]

In Scala 2, I could define an extension method using the following:

trait Foo[F[_]]
trait Bar[F[_]]

trait FooSyntax {
  implicit class FooOps[F[_]](foo: Foo[F]) extends Bar[F] {
    def helloWorld = ???
  }
}

object foo extends FooSyntax

I could then import foo to make use of helloWorld.

In Scala 3, I'm trying to change the same thing to an extension method.

extension [F[_]](foo: Foo[F])
  def helloWorld = ???

The problem is I can't extend the Bar trait like I could using an implicit class.
This also does not work:

trait FooSyntax[F[_]] extends Bar[F] {
  extension [(foo: Foo[F])
    def helloWorld = ???
}

object foo extends FooSyntax[F] // I don't have an F since objects don't have generics

How can I model this using Scala 3's extension methods?

[bishabosha]

So extension methods are made available whenever their containing object is available in implicit scope, so what you can do here is wrap the extension methods in some given object, e.g.

trait Foo[F[_]]
trait Bar[F[_]]

trait FooSyntax:
  given FooOps[F[_]]: Bar[F] with
    extension (foo: Foo[F])
      def helloWorld = "Hello, World!"

object foo extends FooSyntax

@main def Test =
  import foo.given // import givens from foo
  val fOpt = new Foo[Option] {}
  println(fOpt.helloWorld)

[qwbarch]

This is exactly what I was looking for, thank you!