ProtocolExtensionをor演算子で制約したい

Question

前提・実現したいこと

ProtocolExtensionにおいて、どちらかのプロトコルに適合していれば有効になるようにしたいです。
素直に別々に書くしかないのでしょうか？

該当のソースコード

protocol SomeProtocol { }

//こちらはできる
extension SomeProtocol where Self: HogeProtocol & FugaProtocol { }

//こちらはエラーになる
extension SomeProtocol where Self: HogeProtocol || FugaProtocol { }

Answer 1

■ 結論から

論理的に無理が出てくるので、実現できないようになっていると思われます。

■ 現実問題として A or B だとコードが書けない

プロトコル拡張するということは、そこでメソッドなどの機能を実装したいと思うのですけれど、このとき今回の例であれば「Self が HogeProtocol と FugaProtocol のどちらになるかわからない」ということは「Self に HogeProtocol で規定された機能を持っていないかもしれないし、FugaProtocol で規定された機能を持っていないかもしれない」状況になります。

なので、例えば次のように各プロトコルに機能が規定されていたとします。

protocol SomeProtocol {
    func some()
}

protocol HogeProtocol {
    func hoge()
}

protocol FugaProtocol {
    func fuga()
}

こうした時に、実際に SomeProtocol に機能を拡張しようとすると、次のように「どちらかのプロトコルに該当していた場合」という制約に無理が出てくることが実感できると思います。

extension SomeProtocol where Self: HogeProtocol | FugaProtocol {
    func someWhereHogeOrFuga() {

        // 次のコードは `SomeProtocol` が持っている機能なので問題なし
        self.some()

        // 次のコードは `Self` が `FugaProtocol` だけに準拠していたとすると
        // `hoge` メソッドを持っていないため、呼び出しを保証できず、コンパイルを通すことができない。
        self.hoge()

        // かといって次のコードも `Self` が `HogeProtocol` だけに準拠していたとすると
        // `fuga` メソッドを持っていないため、呼び出しを保証できず、コンパイルを通すことができない。
        self.fuga()
    }
}

■ A と B、それぞれを想定したコードを書かざるを得ない

そのため、実質的にコードを書くことができない状況になります。そうして結局行き着くところとしては、必然的に次のようになってきます。

• HogeProtocol で提供する機能でコードを組み立てる時には where Self: HogeProtocol になる
• FugaProtocol で提供する機能でコードを組み立てる時には where Self: FugaProtocol になる
• HogeProtocol と FugaProtocol の機能が必要なら where Self: HogeProtocol & FugaProtocol

HogeProtocol または FugaProtocol という表現が必要になるときは、仮に HogeProtocol | FugaProtocol と書けたとしてもコードが立ち行かなくなって、結局のところは次のように HogeProtocol の場合と FugaProtocol の場合のそれぞれでコードを書いていくことになると思います。

extension SomeProtocol where Self: HogeProtocol {
    func someWhereHogeOrFuga() {

        // 次のコードは `SomeProtocol` が持っている機能なので問題なし
        self.some()

        // 次のコードは `Self` が `HogeProtocol` に準拠しているので
        // `hoge` メソッドを持っていて、コンパイルを通すことができる。
        self.hoge()
    }
}

extension SomeProtocol where Self: FugaProtocol {
    func someWhereHogeOrFuga() {

        // 次のコードは `SomeProtocol` が持っている機能なので問題なし
        self.some()

        // 次のコードは `Self` が `FugaProtocol` に準拠しているので
        // `fuga` メソッドを持っていて、コンパイルを通すことができる。
        self.fuga()
    }
}

このように、実装するときはそれぞれに対してコードを書いていく必要がありますけれど、使うときには HogeProtocol または FugaProtocol のどちらかに準拠していれば（当たり前ですけれど）someWhereHogeOrFuga メソッドを使えます。

struct A : SomeProtocol, HogeProtocol {
    
    func some() {}
    func hoge() {}
    
    func test() {

        // `HogeProtocol` に準拠しているだけでも
        // `someWhereHogeOrFuga` が使える。
        someWhereHogeOrFuga()
    }
}

struct B : SomeProtocol, FugaProtocol {
    
    func some() {}
    func fuga() {}
    
    func test() {

        // `FugaProtocol` に準拠しているだけでも
        // `someWhereHogeOrFuga` が使える。
        someWhereHogeOrFuga()
    }
}

■ A and B、両方を想定したコードを書かないといけない場合も

ただし、今のままだと HogeProtocol と FugaProtocol の両方に準拠している場合に where Self : HogeProtocol と where Self : FugaProtocol のどちらで実装した someWhereHogeOrFuga メソッドを使えばいいか判断できずに呼び出せないので、必要に応じて両方に準拠させた型で独自に実装するか、または次のようにあらかじめ where Self : HogeProtocol & FugaProtocol の場合として、両方に準拠していた場合の someWhereHogeOrFuga を規定しておくことで対応したりします。

extension SomeProtocol where Self: HogeProtocol & FugaProtocol {
    func someWhereHogeOrFuga() {

        // 次のコードは `SomeProtocol` が持っている機能なので問題なし
        self.some()

        // ここでは `Self` が `HogeProtocol` と `FugaProtocol` の両方に準拠しているので
        // それらの機能を使ってコードを組み立てることが可能です。
        if Bool.random() {
            self.hoge()
        }
        else {
            self.fuga()
        }
    }
}

struct C : SomeProtocol, HogeProtocol, FugaProtocol {
    
    func some() {}
    func hoge() {}
    func fuga() {}

    func test() {

        // `HogeProtocol` と `FugaProtocol` の両方に準拠している場合も
        // それを想定した `someWhereHogeOrFuga` を定義したことで、それを呼び出せるようになります。
        someWhereHogeOrFuga()
    }
}

■ 所感

こうして見ていって面白いのが、必然的に Self : HogeProtocol と Self : FugaProtocol と Self : HogeProtocol & FugaProtocol の３パターンで書くことになって、Self : HogeProtocol | FugaProtocol みたいな書き方は実質コードを書くことができず、結局のところその３つのパターンで補い合って書くことになる。

そんなところが見えてくると『素直に個別に書くしかない』ことが、自然なものとして素直に受け入れられるようになってくるかもしれません。

Comments

[Iwasho]

丁寧に解説していただきありがとうございました！

Answer 2

ワークアラウンドとして

protocol PiyoProtocol {
  // extensionに必要なプロパティ、メソッドを列挙
}

extension HogeProtocol: PiyoProtocol {}
extension FugaProtocol: PiyoProtocol {}

extension SomeProtocol where Self: PiyoProtocol {
  //
}

とする方法があります。

Comments

[Iwasho]

Extension of protocol 'XXXXProtocol' cannot have an inheritance clauseとエラーが表示されます。
プロトコルの拡張でプロトコルを適合できないそうなのですが...