Swiftでジェネリクスを使って型に依存しない関数を実装する方法

Swiftでジェネリクスを使うことで、特定の型に依存しない汎用的な関数やデータ構造を実装することが可能になります。これにより、同じロジックを異なる型に対して再利用でき、コードの冗長さを大幅に削減できます。ジェネリクスは、特にSwiftのような型安全性を重視する言語において、強力なツールです。本記事では、ジェネリクスの基本的な仕組みから実装方法、応用例までを網羅的に解説し、Swiftでのプログラミングの効率を向上させる方法を学びます。

Swiftにおけるジェネリクスの基本

ジェネリクスとは、関数やクラス、構造体、プロトコルなどに対して型を抽象化し、任意の型に対応できるようにする仕組みです。これにより、同じロジックを異なるデータ型に対して適用することが可能になり、コードの再利用性が向上します。

ジェネリクスの基本的な構文

Swiftでは、ジェネリック関数やジェネリック型を次のように定義します。

func swapValues<T>(_ a: inout T, _ b: inout T) {
    let temp = a
    a = b
    b = temp
}

この例では、Tという型パラメータが関数の引数に使用され、swapValuesは任意の型に対して動作することができます。Tは関数が呼び出される際に具体的な型として指定されます。

ジェネリクスを使うメリット

ジェネリクスを活用することで、次のようなメリットがあります。

• コードの再利用性向上：同じ関数やクラスをさまざまな型に対して使い回すことができます。
• 型安全性の保持：コンパイル時に型のチェックが行われるため、実行時エラーの可能性を減らします。
• 柔軟性の向上：ジェネリクスを使用することで、型に依存しない汎用的なプログラムを記述でき、コードの柔軟性が増します。

ジェネリクスの基本を理解することで、型に依存しない柔軟なコードを書けるようになります。次に、型安全性とジェネリクスの関係についてさらに深掘りしていきます。

型安全とジェネリクス

ジェネリクスを用いることで、Swiftでは型安全性を確保しながら、汎用的なコードを書くことができます。型安全とは、プログラム内で使用されるデータの型がコンパイル時に明確にチェックされ、誤った型の使用を防ぐことを意味します。ジェネリクスは、特定の型に依存しないコードを記述できるため、柔軟で再利用可能なコードを実現しつつ、型安全性を保つことができます。

ジェネリクスによる型安全の強化

ジェネリクスを使わない場合、型のキャストが必要になることがあります。キャストは型変換に失敗する可能性があり、実行時エラーを引き起こすリスクが高まります。しかし、ジェネリクスを使えば、型キャストを明示的に行わずに、異なる型に対しても安全にコードを適用することができます。

例として、型安全性を保ちながら汎用的な関数を実装する場合を考えてみましょう。

func compareValues<T: Comparable>(_ a: T, _ b: T) -> Bool {
    return a == b
}

この例では、TがComparableプロトコルに準拠していることを保証し、==演算子が使用可能であることが確認されます。これにより、compareValues関数は、数値や文字列など、Comparableを準拠したさまざまな型に対して安全に動作します。

型キャストの回避とパフォーマンスの向上

ジェネリクスを使用することで、Swiftは型チェックをコンパイル時に行います。これにより、動的な型キャストを避けることができ、実行時にパフォーマンスが向上します。キャストは実行時にコストがかかるため、ジェネリクスを使用することでこのオーバーヘッドを減らすことができるのです。

型安全性とパフォーマンスの両方を維持できるジェネリクスは、効率的で信頼性の高いコードを書くために不可欠なツールとなります。次に、ジェネリクスを使った具体的な関数の実装例を紹介します。

ジェネリクスを使った関数の実装例

ジェネリクスを使用することで、Swiftでは型に依存しない関数を簡単に実装できます。これにより、異なる型に対して同じロジックを適用するコードの再利用性が大幅に向上します。ここでは、具体的なジェネリック関数の実装例を紹介します。

リスト内の要素をシャッフルする関数

次の例では、配列の要素をランダムに並び替えるジェネリック関数を実装します。この関数は、要素の型に関係なく、配列の順序をシャッフルできるように設計されています。

func shuffleArray<T>(_ array: [T]) -> [T] {
    var shuffledArray = array
    for i in stride(from: array.count - 1, through: 1, by: -1) {
        let j = Int.random(in: 0...i)
        shuffledArray.swapAt(i, j)
    }
    return shuffledArray
}

この関数では、Tという型パラメータを使用しており、どんな型の配列でもシャッフルできるようになっています。shuffleArrayは、数値の配列や文字列の配列など、さまざまな型に対して動作します。

スタック（Stack）データ構造のジェネリクス実装

次に、ジェネリクスを使ってスタック（LIFO: 後入れ先出し）のデータ構造を実装します。スタックは、データを後から追加し、追加した順序で取り出す動作を持つデータ構造です。

struct Stack<T> {
    private var elements: [T] = []

    mutating func push(_ element: T) {
        elements.append(element)
    }

    mutating func pop() -> T? {
        return elements.popLast()
    }

    func peek() -> T? {
        return elements.last
    }

    var isEmpty: Bool {
        return elements.isEmpty
    }
}

このStack構造体は、Tというジェネリック型を使っており、どんな型のデータでもスタックに追加して管理することができます。数値型のスタックや文字列型のスタックなど、さまざまな用途に対応できます。

関数の利用例

たとえば、次のようにInt型のスタックを作成して、値を追加・取り出すことができます。

var intStack = Stack<Int>()
intStack.push(10)
intStack.push(20)
print(intStack.pop()) // Optional(20)
print(intStack.peek()) // Optional(10)

このように、ジェネリクスを使うことで、型に依存しない汎用的な関数やデータ構造を作成し、再利用性と柔軟性を高めることができます。次は、複数の型パラメータを扱う方法について説明します。

複数の型パラメータを使用する関数

ジェネリクスでは、1つの型パラメータに限らず、複数の型パラメータを使用して関数やクラスを設計することもできます。これにより、異なる型同士を組み合わせた操作を汎用的に処理することが可能になります。ここでは、複数の型パラメータを使用した関数の実装例を紹介します。

複数の型パラメータを使用した関数の例

次の例は、2つの異なる型の値をスワップする関数です。この関数は、任意の2つの型を受け取り、それぞれの値を交換します。

func swapValues<T, U>(_ a: inout T, _ b: inout U) -> (U, T) {
    return (b, a)
}

この関数では、TとUという2つの型パラメータを使用しています。TとUは異なる型を表しており、aとbにそれぞれ別の型の値を渡すことができます。結果として、元の型の値が入れ替わります。

利用例として、次のように呼び出すことができます。

var x = 10
var y = "Swift"
let swapped = swapValues(&x, &y)
print(swapped) // ("Swift", 10)

このように、異なる型の値もジェネリクスを用いて汎用的に処理できることがわかります。

複数の型パラメータを使用する場面

複数の型パラメータを使うことが有効な場面として、次のようなケースが考えられます。

• キーと値のペア（辞書など）：キーと値が異なる型であるデータ構造の場合、それぞれをジェネリクスで定義することができます。
• 結果型の変換：ある型を別の型に変換する場合、入力と出力の型をジェネリクスとして指定できます。
• 異なる型同士の比較：異なる型のオブジェクトを比較や処理したい場合、複数の型パラメータを使うことで柔軟に対応できます。

次に、ジェネリクスとプロトコルを組み合わせることで、さらに強力で汎用性の高いコードを実装する方法を説明します。

ジェネリクスとプロトコルの組み合わせ

ジェネリクスとプロトコルを組み合わせることで、Swiftにおける柔軟で型安全なコードの設計が可能になります。プロトコルは、共通のインターフェースを定義するもので、クラス、構造体、列挙型がこのプロトコルに準拠することで、指定されたメソッドやプロパティを実装する必要があります。ジェネリクスにプロトコルを適用することで、型に依存しない関数やクラスをさらに汎用的にしながらも、型に要求される振る舞いを制限することができます。

ジェネリクスとプロトコルの基本的な組み合わせ方

ジェネリクスとプロトコルを組み合わせたコードの基本的な例を見てみましょう。以下のコードは、Comparableプロトコルに準拠した型に対して、最大値を返すジェネリック関数です。

func findMax<T: Comparable>(_ a: T, _ b: T) -> T {
    return a > b ? a : b
}

この関数では、TがComparableプロトコルに準拠していることを指定しています。この制約により、T型が>（大なり）演算子をサポートしていることが保証され、どんな型でもこの条件を満たす場合にのみ関数が動作します。

利用例として、数値や文字列の比較が可能です。

let maxInt = findMax(10, 20)
let maxString = findMax("apple", "banana")
print(maxInt)       // 20
print(maxString)    // banana

このように、プロトコルを使用して型に対する制約を追加することで、ジェネリクスがさらに強力になります。

プロトコルとジェネリクスの応用: カスタムプロトコルの活用

カスタムプロトコルを定義して、ジェネリクスに適用することもできます。次の例では、Printableというプロトコルを定義し、オブジェクトがprintDescriptionメソッドを持つことを要求しています。

protocol Printable {
    func printDescription()
}

struct User: Printable {
    var name: String
    var age: Int

    func printDescription() {
        print("User: \(name), Age: \(age)")
    }
}

func printObject<T: Printable>(_ object: T) {
    object.printDescription()
}

この場合、User構造体がPrintableプロトコルに準拠しているため、printObject関数で任意のPrintable型オブジェクトを受け取り、そのprintDescriptionメソッドを呼び出すことができます。

利用例は次の通りです。

let user = User(name: "John", age: 30)
printObject(user) // User: John, Age: 30

プロトコルを使用した型の柔軟性

ジェネリクスとプロトコルを組み合わせることで、コードの柔軟性をさらに高めることができます。特定のプロトコルに準拠している型だけを受け付けることで、安全性を担保しながらも、より広い範囲の型に対応する汎用的なコードを実装できます。

この技術を活用することで、特定の振る舞いを持つ型に対してのみ操作を行うジェネリック関数を記述できるため、コードの再利用性と安全性が大幅に向上します。次に、ジェネリクスを用いた具体的な応用例を紹介します。

具体的な応用例

ジェネリクスは、特にSwiftのような型安全な言語において、非常に多くの場面で活用することができます。ここでは、実際にジェネリクスを使用してリストの並べ替えやフィルタリングを行う応用例を紹介します。これらの例を通じて、ジェネリクスの強力さと柔軟性を実感できるでしょう。

ジェネリクスを使ったリストの並べ替え

ジェネリクスとComparableプロトコルを組み合わせることで、任意の型に対して並べ替えを行う関数を実装できます。以下の関数は、ジェネリックな配列を受け取り、Comparableプロトコルに準拠している要素を昇順にソートします。

func sortArray<T: Comparable>(_ array: [T]) -> [T] {
    return array.sorted()
}

この関数は、任意の型であっても、Comparableに準拠していれば適用可能です。たとえば、整数や文字列を並べ替えることができます。

利用例:

let intArray = [3, 1, 4, 1, 5, 9]
let sortedIntArray = sortArray(intArray)
print(sortedIntArray) // [1, 1, 3, 4, 5, 9]

let stringArray = ["banana", "apple", "cherry"]
let sortedStringArray = sortArray(stringArray)
print(sortedStringArray) // ["apple", "banana", "cherry"]

このように、ジェネリクスとプロトコルを組み合わせることで、型に依存しない並べ替えが可能になります。

リストのフィルタリング

次に、ジェネリクスを使用して、任意の条件に基づいてリストをフィルタリングする方法を紹介します。以下の関数では、任意の型のリストを受け取り、条件を満たす要素のみを返します。この条件は、クロージャを使用して外部から指定します。

func filterArray<T>(_ array: [T], using condition: (T) -> Bool) -> [T] {
    return array.filter(condition)
}

このfilterArray関数は、どんな型でも適用でき、条件として渡されたクロージャに基づいて要素をフィルタリングします。

利用例:

let numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]
let evenNumbers = filterArray(numbers) { $0 % 2 == 0 }
print(evenNumbers) // [2, 4, 6, 8]

let names = ["John", "Jane", "Paul", "Jake"]
let filteredNames = filterArray(names) { $0.hasPrefix("J") }
print(filteredNames) // ["John", "Jane", "Jake"]

この例では、整数のリストから偶数のみを抽出したり、名前のリストから「J」で始まる名前だけを抽出しています。

ジェネリクスとクロージャの組み合わせによる柔軟性

ジェネリクスとクロージャを組み合わせることで、特定の条件に基づいた処理を柔軟に実装できます。型に依存せず、必要な条件を外部から渡すことができるため、コードの汎用性が高まり、再利用が容易になります。

これらの応用例により、ジェネリクスの実際の活用方法を理解できたでしょう。次は、ジェネリクスを使用したエラーハンドリングの方法について説明します。

ジェネリクスを用いたエラーハンドリング

Swiftのエラーハンドリングは強力であり、ジェネリクスと組み合わせることで、型に依存しない汎用的なエラーハンドリングが可能です。ジェネリクスを活用すると、さまざまな型のデータに対して共通のエラーハンドリングロジックを実装できるため、コードの再利用性が向上します。

ジェネリクスと`Result`型によるエラーハンドリング

Swiftでは、Result型を使ってジェネリクスを活用したエラーハンドリングが行えます。Result型は、SuccessとFailureの2つのケースを持つ列挙型で、成功時には成功結果を、失敗時にはエラー情報を保持します。

以下は、ジェネリクスを使用して、任意の処理結果を返す関数の例です。

enum DataError: Error {
    case noData
    case invalidData
}

func fetchData<T>(from source: String) -> Result<T, DataError> {
    if source.isEmpty {
        return .failure(.noData)
    }

    // ダミーデータの例として型キャストを試みます。
    if let data = source as? T {
        return .success(data)
    } else {
        return .failure(.invalidData)
    }
}

この関数は、データのソース（文字列）を引数に取り、ジェネリック型Tで指定された型のデータを返すか、エラーを返します。Result型によって、成功時と失敗時の処理が明確に分かれており、コンパイル時に型安全が保証されます。

関数の利用例

次に、このジェネリック関数を使ってデータを取得し、その結果を処理する例を見てみましょう。

let result: Result<Int, DataError> = fetchData(from: "123")

switch result {
case .success(let data):
    print("成功: \(data)")
case .failure(let error):
    switch error {
    case .noData:
        print("エラー: データがありません")
    case .invalidData:
        print("エラー: データが無効です")
    }
}

この例では、データが文字列として提供され、それがInt型に変換されるかどうかをチェックします。成功すれば変換されたデータが返され、失敗すれば適切なエラーが返されます。

ジェネリクスとカスタムエラー型の組み合わせ

さらに、独自のカスタムエラー型をジェネリクスと組み合わせることで、特定のエラーに対する詳細な処理が可能になります。カスタムエラー型を使えば、エラーの種類や原因をより細かく管理でき、エラーハンドリングの柔軟性が高まります。

例えば、ファイル読み込みやAPI呼び出しなど、さまざまな処理に対して共通のエラーハンドリングロジックを実装しつつ、処理ごとに異なるエラーを適切に扱うことができます。

enum NetworkError: Error {
    case timeout
    case noConnection
    case invalidResponse
}

func fetchFromNetwork<T>(url: String) -> Result<T, NetworkError> {
    // ダミーのエラーハンドリングを例示
    return .failure(.noConnection)
}

この例では、NetworkError型を使用して、ネットワーク関連のエラーハンドリングをジェネリクスで実装しています。返されるデータ型はTとしてジェネリックに定義されているため、様々な型のデータを安全に扱うことができます。

ジェネリクスを使ったエラーハンドリングの利点

• 汎用性: 型に依存しないため、どんなデータ型にも対応したエラーハンドリングが実装可能です。
• コードの再利用: 共通のエラーハンドリングロジックを様々な場面で再利用できます。
• 型安全性: コンパイル時に型が保証されるため、実行時のエラーを未然に防ぐことができます。

ジェネリクスを使ったエラーハンドリングにより、汎用性と型安全性を両立させた効果的なエラーマネジメントが実現できます。次に、ジェネリクスを活用したクラスと構造体の設計方法を説明します。

ジェネリクスを使用したクラスと構造体の設計

ジェネリクスは関数だけでなく、クラスや構造体にも適用できます。これにより、特定の型に依存しない柔軟で汎用的なデータ構造を設計することが可能です。ジェネリクスを用いることで、異なる型を扱うデータ構造を1つの設計でカバーでき、コードの再利用性が向上します。

ジェネリクスクラスの設計

ジェネリクスを使ったクラスの設計において、1つのクラスでさまざまな型を扱えるようになります。例えば、リストやスタックといったデータ構造は、任意の型に対応する必要があるため、ジェネリクスが非常に有効です。

次に、ジェネリクスを使用したスタックのクラス実装を見てみましょう。

class Stack<T> {
    private var elements: [T] = []

    func push(_ element: T) {
        elements.append(element)
    }

    func pop() -> T? {
        return elements.popLast()
    }

    func peek() -> T? {
        return elements.last
    }

    var isEmpty: Bool {
        return elements.isEmpty
    }
}

このStackクラスは、ジェネリック型Tを利用しており、任意の型の要素を格納できます。整数や文字列など、あらゆる型に対して同じロジックを適用でき、柔軟に使用することができます。

利用例:

let intStack = Stack<Int>()
intStack.push(10)
intStack.push(20)
print(intStack.pop()) // Optional(20)

let stringStack = Stack<String>()
stringStack.push("Swift")
stringStack.push("Generics")
print(stringStack.pop()) // Optional("Generics")

この例では、整数型のスタックと文字列型のスタックをそれぞれ作成していますが、Stackクラスは型に依存せずに動作しています。

ジェネリクスを使用した構造体の設計

クラスと同様に、構造体でもジェネリクスを活用できます。次に、Pairという2つの異なる型の値を持つジェネリック構造体を設計してみましょう。

struct Pair<T, U> {
    let first: T
    let second: U

    func describe() {
        print("First: \(first), Second: \(second)")
    }
}

このPair構造体は、2つの異なる型TとUを持つことができ、それぞれの値に対して操作を行えます。

利用例:

let intStringPair = Pair(first: 42, second: "Swift")
intStringPair.describe() // First: 42, Second: Swift

let doubleBoolPair = Pair(first: 3.14, second: true)
doubleBoolPair.describe() // First: 3.14, Second: true

このように、Pair構造体は異なる型のデータを持つことができ、ジェネリクスによって柔軟に使用できます。

ジェネリクスを使用する利点

• 汎用性: クラスや構造体が任意の型に対応するため、再利用性が高まります。
• コードの整理: 型ごとに別のクラスや構造体を定義する必要がなく、コードがシンプルになります。
• 型安全性: ジェネリクスを使用することで、コンパイル時に型がチェックされ、実行時エラーのリスクが減少します。

ジェネリクスを使うことで、クラスや構造体が持つデータに柔軟に対応でき、コードの効率性と安全性が向上します。次に、ジェネリクスがパフォーマンスに与える影響について解説します。

パフォーマンスへの影響

ジェネリクスは、Swiftにおいてコードの再利用性や柔軟性を向上させるだけでなく、パフォーマンスにも良い影響を与えることがあります。ここでは、ジェネリクスのパフォーマンスへの影響について詳しく説明します。

コンパイル時の型チェック

Swiftでは、ジェネリクスを使用することで、コンパイル時に型チェックが行われます。これにより、型安全性が保証され、実行時に型に関連するエラーを未然に防ぐことができます。コンパイル時にエラーを捕捉できるため、開発プロセスが効率化され、デバッグにかかる時間も短縮されます。

インライン化によるパフォーマンス向上

Swiftコンパイラは、ジェネリック関数やメソッドをインライン化することができます。インライン化とは、関数の呼び出しを関数の本体に置き換えることを指します。これにより、関数呼び出しのオーバーヘッドが削減され、実行時のパフォーマンスが向上します。

例えば、以下のようなジェネリック関数があります。

func add<T: Numeric>(_ a: T, _ b: T) -> T {
    return a + b
}

この関数がインライン化されると、呼び出し時にオーバーヘッドが発生せず、より効率的に動作します。

型の特定化による最適化

ジェネリクスを使用する際、コンパイラは具体的な型が提供されるたびに新しいバージョンの関数やメソッドを生成します。このプロセスを「型の特定化」と呼びます。型の特定化により、最適化が可能になり、特定の型に対してより効率的な実装を生成することができます。

たとえば、Int型やDouble型を使用する場合、コンパイラはそれぞれに最適化された関数を生成し、パフォーマンスを向上させます。

メモリ管理の効率性

ジェネリクスを使用することで、メモリ管理の効率性も向上します。具体的には、異なる型のデータを扱うために別々のクラスや構造体を作成する必要がなくなります。これにより、メモリのオーバーヘッドが削減され、効率的にリソースを使用できます。

例えば、ジェネリックなスタックを使う場合、異なる型のスタックを別々に実装する必要がなく、同じメモリ領域を利用することで効率的に動作します。

パフォーマンスへの留意点

ただし、ジェネリクスを使用する際にはいくつかの注意点もあります。

• コンパイル時間の増加: ジェネリクスは型の特定化により、コンパイラが生成するコードが増えるため、コンパイル時間が長くなる可能性があります。
• 特定のケースにおけるパフォーマンス低下: ジェネリック型が非常に多くの型に適用される場合、特定のケースでパフォーマンスが低下する可能性があります。

これらの点を理解しつつ、適切にジェネリクスを活用することで、Swiftプログラムのパフォーマンスを最適化できます。次に、ジェネリクスを使用した演習問題を提供し、理解を深めるための機会を設けます。

演習問題: ジェネリクスを使った関数を実装してみよう

ここでは、ジェネリクスを利用したプログラミングスキルを磨くための演習問題をいくつか提供します。これらの問題に取り組むことで、ジェネリクスの理解を深め、実際のコーディングに役立てることができます。

問題1: 汎用的な最大値を返す関数を実装せよ

以下の要件に従って、任意の型の配列から最大値を返すジェネリック関数 findMax を実装してください。この関数は、Comparableプロトコルに準拠する型に対してのみ動作する必要があります。

要件:

• 引数として配列を受け取り、その中の最大値を返す。
• 配列が空の場合は、nilを返す。

ヒント:

• if array.isEmpty を使って配列の空チェックを行う。

問題2: 2つの値を交換する関数を実装せよ

以下の要件に従って、2つの異なる型の値を受け取り、交換した結果を返すジェネリック関数 swap を実装してください。

要件:

• 2つの引数を受け取り、それらの値を交換したタプルを返す。
• 値の型は異なることを考慮する。

ヒント:

• タプルを返すためには、(U, T) という形で戻り値を定義する。

問題3: 汎用的なフィルタリング関数を実装せよ

以下の要件に従って、配列をフィルタリングするジェネリック関数 filterArray を実装してください。この関数は、条件を満たす要素のみを含む新しい配列を返す必要があります。

要件:

• 配列と条件を引数として受け取り、条件を満たす要素を含む新しい配列を返す。
• 条件はクロージャで指定できるようにする。

ヒント:

• array.filter(condition) を使うと便利です。

問題4: 汎用的なスタックの実装を行え

以下の要件に従って、任意の型を格納できるジェネリックなスタッククラス GenericStack を実装してください。

要件:

• プッシュ、ポップ、ピークのメソッドを実装する。
• スタックが空であるかどうかを判断するためのプロパティを持つ。

ヒント:

• elementsという配列を内部に持つ。

これらの演習問題に取り組むことで、ジェネリクスを利用したプログラミングの理解を深め、実践的なスキルを身につけることができます。次は、ジェネリクスの全体を振り返るまとめを行います。

まとめ

本記事では、Swiftにおけるジェネリクスの基本概念から、具体的な実装例、応用方法までを幅広く解説しました。ジェネリクスを活用することで、型に依存しない柔軟で再利用可能なコードを記述できることが理解できたかと思います。

主要なポイント

• 型安全性の確保: ジェネリクスは、型に依存しない汎用的な関数やデータ構造を提供しつつ、コンパイル時に型安全性を保証します。
• 再利用性の向上: 同じロジックを異なる型に適用できるため、コードの再利用性が大幅に向上します。
• パフォーマンスの最適化: ジェネリクスは、コンパイル時の型チェックやインライン化によって、実行時パフォーマンスを向上させることができます。

実践的な応用

具体的な応用例として、リストの並べ替えやフィルタリング、エラーハンドリング、汎用的なデータ構造（スタックやペア）などが挙げられました。これらの実装を通じて、ジェネリクスが実際のプログラミングにおいてどのように役立つかを理解できたでしょう。

次のステップ

これからは、提供した演習問題に取り組むことで、ジェネリクスの実践的なスキルをさらに深めることが重要です。また、実際のプロジェクトにおいても、ジェネリクスを積極的に活用し、型安全で再利用可能なコードの作成に挑戦してみてください。

ジェネリクスの理解を深めることで、Swiftでのプログラミングがより楽しく、効果的になることでしょう。