```

    sealed class Response<T> {
        data class Success<T>(val value: T): Response<T>()
        data class Fail<T>(val errorMessage: String): Response<T>()
    }
    
    fun <T> fetch(onResponse: (Response<T>) -> Unit) {
        val value: T
    
        // 何かしら取得してvalueに入れる
    
        onResponse(Response.Success(value))
    }
    
```

というような処理を作ったのですが、`Response`の`T`について  
`Type Parameter "T" is never used`  
というwarningが表示されます  
（実際、`Response`の`T`は、その子クラスの`T`とは無関係なためその通りですが）。

タイプパラメータの変数自体は使わないもののクラスをジェネリクス型にはしたい場合、のうまい書き方はないでしょうか。

なお処理自体は問題なく動きます。
CC BY-SA 4.0
2018-11-15T04:44:37.730
50346
2019-06-29T08:52:20.623
2019-06-29T08:52:20.623
9008
30993
question
kotlin ジェネリクス
ジェネリクス型のクラスの定義で、タイプパラメータ名が不要なときのいい感じの書き方
恐らくそのままでは不便で、通常は何かしらの関数を定義するので、その問題は起きない気もします。

```

    sealed class Response<out T> {
    
        fun <A> map(f: (T) -> A): Response<A> {
            return when (this) {
                is Success -> Success(f(value))
                is Fail    -> this
            }
        }
    
        data class Success<T>(val value: T): Response<T>()
        data class Fail(val errorMessage: String): Response<Nothing>()
    }
    
    data class User(val name: String, val age: Int)
    
    fun fetch(onResponse: (Response<User>) -> Unit) {
        val result = Response.Success(mapOf("name" to "John", "age" to "42"))
    
        onResponse(
                result.map {
                    User(it.getValue("name"), it.getValue("age").toInt())
                }
        )
    }
    
```

ただし、本当に使用しない場合や[kotlin-either](https://github.com/adelnizamutdinov/kotlin-
either)のように関数を拡張関数として定義した場合は、型パラメータが未使用と判別されるため、`@Suppress("unused")`を使うのが良いかと思います。

[https://github.com/adelnizamutdinov/kotlin-
either/blob/master/src/main/kotlin/either/Either.kt](https://github.com/adelnizamutdinov/kotlin-
either/blob/26b6a29180eed6f762354444877dad2c3ed99171/src/main/kotlin/either/Either.kt)

>
```

>     @Suppress("unused")
>     sealed class Either<out L, out R>
>  
```

また、Kotlin
1.3から導入された`Result`型では、`Success`型を定義せず、`Result`と継承関係を持たない`Failure`ではない場合に成功(success)と判別するような実装になっています。

<https://github.com/JetBrains/kotlin/blob/1.3.0/libraries/stdlib/coroutines/src/kotlin/Result.kt>

>
```

>     @SinceKotlin("1.3")
>     public inline class Result<out T> @PublishedApi internal constructor(
>         @PublishedApi
>         internal val value: Any?
>     ) : Serializable {
>         // discovery
>  
>         /**
>          * Returns `true` if this instance represents successful outcome.
>          * In this case [isFailure] returns `false`.
>          */
>         public val isSuccess: Boolean get() = value !is Failure
>  
>         /**
>          * Returns `true` if this instance represents failed outcome.
>          * In this case [isSuccess] returns `false`.
>          */
>         public val isFailure: Boolean get() = value is Failure
>  
```

>
```

>         internal class Failure(
>             @JvmField
>             val exception: Throwable
>         ) : Serializable {
>             override fun equals(other: Any?): Boolean = other is Failure &&
> exception == other.exception
>             override fun hashCode(): Int = exception.hashCode()
>             override fun toString(): String = "Failure($exception)"
>         }
>  
```
CC BY-SA 4.0
2018-11-16T19:45:49.183
50385
2018-11-16T19:45:49.183
3068
50346
answer