Kotlinでの型パラメータを活用したジェネリックプログラミング完全ガイド

fun <T> printList(items: List<T>) {
    for (item in items) {
        println(item)
    }
}

class Box<T>(var content: T) {
    fun getContent(): T {
        return content
    }
}

val intBox = Box(123)        // TはInt型
val stringBox = Box("Hello") // TはString型
println(intBox.getContent()) // 出力: 123
println(stringBox.getContent()) // 出力: Hello

fun <T> getFirstItem(items: List<T>): T {
    return items.first()
}

val numbers = listOf(1, 2, 3)
val words = listOf("Kotlin", "Java", "C++")

println(getFirstItem(numbers)) // 出力: 1
println(getFirstItem(words))   // 出力: Kotlin

val box = Box(42) // 型推論によりBox<Int>が作成される

fun <T : Number> sum(a: T, b: T): Double {
    return a.toDouble() + b.toDouble()
}

println(sum(3, 4))         // 出力: 7.0
println(sum(2.5, 3.5))     // 出力: 6.0
// println(sum("Hello", "World")) // コンパイルエラー

fun <T> copyIfGreater(list: List<T>, threshold: T): List<T> 
    where T : Comparable<T>, T : Any {
    return list.filter { it > threshold }
}

class Container<T : CharSequence>(val content: T) {
    fun printContent() {
        println("Content: ${content.length} characters")
    }
}

val stringContainer = Container("Kotlin")
stringContainer.printContent() // 出力: Content: 6 characters

// val intContainer = Container(123) // コンパイルエラー

interface Producer<out T> {
    fun produce(): T
}

open class Animal
class Dog : Animal()

val dogProducer: Producer<Dog> = object : Producer<Dog> {
    override fun produce(): Dog = Dog()
}
val animalProducer: Producer<Animal> = dogProducer // 共変性により代入可能

interface Consumer<in T> {
    fun consume(item: T)
}

val animalConsumer: Consumer<Animal> = object : Consumer<Animal> {
    override fun consume(item: Animal) {
        println("Consumed an animal")
    }
}
val dogConsumer: Consumer<Dog> = animalConsumer // 反変性により代入可能

// 共変性（out）の例
fun printAnimals(producer: Producer<Animal>) {
    println(producer.produce())
}

// 反変性（in）の例
fun addAnimal(consumer: Consumer<Animal>, animal: Animal) {
    consumer.consume(animal)
}

val listOfInts: List<Int> = listOf(1, 2, 3)
val listOfNullableInts: List<Int?> = listOf(1, null, 3)

fun <T> printItem(item: T?) {
    item?.let {
        println("Item: $it")
    } ?: println("Item is null")
}

printItem(42)     // 出力: Item: 42
printItem(null)   // 出力: Item is null

fun <T : Any> processItem(item: T) {
    println("Processing: $item")
}

// processItem(null) // コンパイルエラー
processItem("Kotlin") // 出力: Processing: Kotlin

fun <T> filterNonNullItems(items: List<T?>): List<T> {
    return items.filterNotNull()
}

val mixedList = listOf(1, null, 2, null, 3)
val nonNullList = filterNonNullItems(mixedList)
println(nonNullList) // 出力: [1, 2, 3]

fun <T> filterItems(items: List<T>, predicate: (T) -> Boolean): List<T> {
    return items.filter(predicate)
}

// 使用例
val numbers = listOf(1, 2, 3, 4, 5)
val evenNumbers = filterItems(numbers) { it % 2 == 0 }
println(evenNumbers) // 出力: [2, 4]

val words = listOf("Kotlin", "Java", "Swift")
val longWords = filterItems(words) { it.length > 4 }
println(longWords) // 出力: [Kotlin, Swift]

class DynamicList<T> {
    private val items = mutableListOf<T>()

    fun addItem(item: T) {
        items.add(item)
    }

    fun removeItem(item: T) {
        items.remove(item)
    }

    fun getItems(): List<T> {
        return items
    }
}

// 使用例
val intList = DynamicList<Int>()
intList.addItem(1)
intList.addItem(2)
intList.removeItem(1)
println(intList.getItems()) // 出力: [2]

val stringList = DynamicList<String>()
stringList.addItem("Hello")
stringList.addItem("World")
println(stringList.getItems()) // 出力: [Hello, World]

fun <T, R> mapItems(items: List<T>, transform: (T) -> R): List<R> {
    return items.map(transform)
}

// 使用例
val numbers = listOf(1, 2, 3)
val squaredNumbers = mapItems(numbers) { it * it }
println(squaredNumbers) // 出力: [1, 4, 9]

val strings = listOf("apple", "banana", "cherry")
val lengths = mapItems(strings) { it.length }
println(lengths) // 出力: [5, 6, 6]

fun <T> printList(items: List<T>) {
    println(items)
}

// コンパイル後、実質的には以下のようなコードになる
fun printList(items: List<Object>) {
    println(items)
}

   fun <T> checkType(item: T) {
       if (item is List<T>) { // コンパイルエラー: 型情報が消去されているためチェック不可
           println("This is a list of type T")
       }
   }

   val list = listOf(1, 2, 3) as List<String> // 実行時にClassCastExceptionが発生

inline fun <reified T> isInstance(item: Any): Boolean {
    return item is T
}

println(isInstance<String>("Hello")) // 出力: true
println(isInstance<Int>("Hello"))    // 出力: false

fun <T> printListIfTypeMatches(items: List<*>, clazz: Class<T>) {
    if (clazz.isInstance(items.firstOrNull())) {
        println("List contains elements of type ${clazz.simpleName}")
    }
}

printListIfTypeMatches(listOf(1, 2, 3), Int::class.java) // 出力: List contains elements of type Integer

fun <T : Number> sumNumbers(items: List<T>): Double {
    return items.sumOf { it.toDouble() }
}

val numbers = listOf(1, 2, 3)
println(sumNumbers(numbers)) // 出力: 6.0

fun <T : Comparable<T>> findMax(items: List<T>): T? {
    return if (items.isEmpty()) null else items.maxOrNull()
}

// テスト
val numbers = listOf(1, 2, 3, 4, 5)
println(findMax(numbers)) // 出力: 5

val words = listOf("Kotlin", "Java", "Swift")
println(findMax(words)) // 出力: Swift

fun <T, R> transformList(items: List<T>, transformer: (T) -> R): List<R> {
    return items.map(transformer)
}

// テスト
val numbers = listOf(1, 2, 3)
val squaredNumbers = transformList(numbers) { it * it }
println(squaredNumbers) // 出力: [1, 4, 9]

val words = listOf("apple", "banana")
val lengths = transformList(words) { it.length }
println(lengths) // 出力: [5, 6]

fun <T> findFirstMatch(items: List<T>, predicate: (T) -> Boolean): T? {
    return items.firstOrNull(predicate)
}

// テスト
val numbers = listOf(10, 20, 30, 40)
val result = findFirstMatch(numbers) { it > 25 }
println(result) // 出力: 30

val names = listOf("Alice", "Bob", "Charlie")
val match = findFirstMatch(names) { it.startsWith("B") }
println(match) // 出力: Bob