The square() Function in the extension below uses the Self keyword to allow having different return type that conforms to the same Numeric protocol.

extension Numeric {
    func squared() -> Self {
        self * self
    }
}

So, if we are looking to return different types that conforms to the same Numeric protocol, why we don't use Opaque return type instead like this?``

extension Numeric {
  func square() -> some Numeric {
    return self * self
  }
}

PS: I experimented in Xcode and the code works fine with opaque return type also.

You could do it that way, but what would be the point? Opaque return types are used to hide the return type from the caller because the specific return type ultimately doesn't matter at the call site.

But here you know what type squared is returning because you call it on a specific variable. You are always returning the same type it was called on. If you call squared on a Double, you'll get a Double back; if you call it on an Int, you'll get an Int back; etc.

The square() Function in the extension below uses the Self keyword to allow having different return type that conforms to the same Numeric protocol.

No, it returns the same type it was called on, not a different type. If squared is called on a Double, then Self is Double; if it's called on an Int, then Self is Int, etc. Using Self indicates "I'm returning the same type that the method was called on", whereas some Numeric indicates "I'm returning some kind of thing that conforms to Numeric, but you don't need to know exactly what it is". It just so happens that in this specific case some Numeric ends up being the same as Self, which is why it works.