Kotlinで型による条件分岐をwhen文で実現する方法

fun describeNumber(number: Int): String {
    return when (number) {
        1 -> "One"
        2 -> "Two"
        in 3..10 -> "Between Three and Ten"
        else -> "Unknown"
    }
}

fun describe(obj: Any): String {
    return when (obj) {
        is String -> "This is a String with length ${obj.length}"
        is Int -> "This is an Integer with value $obj"
        is List<*> -> "This is a List with size ${obj.size}"
        else -> "Unknown type"
    }
}

fun handleInput(input: Any) {
    when (input) {
        is String -> println("String length: ${input.length}")
        is Int -> println("Incremented value: ${input + 1}")
        else -> println("Unsupported type")
    }
}

fun checkType(obj: Any): String {
    return when (obj) {
        is String, is StringBuilder -> "This is a String-like object"
        is Int -> "This is an Integer"
        else -> "Type not recognized"
    }
}

fun processResponse(response: Any): String {
    return when (response) {
        is String -> "Received a plain text: $response"
        is Map<*, *> -> "Received a JSON object with keys: ${response.keys}"
        is List<*> -> "Received a JSON array with size: ${response.size}"
        else -> "Unknown response type"
    }
}

sealed class UIEvent
data class ClickEvent(val x: Int, val y: Int): UIEvent()
data class InputEvent(val text: String): UIEvent()
object IdleEvent : UIEvent()

fun handleUIEvent(event: UIEvent) {
    when (event) {
        is ClickEvent -> println("Click at (${event.x}, ${event.y})")
        is InputEvent -> println("Input text: ${event.text}")
        is IdleEvent -> println("Idle state")
    }
}

sealed class Media
data class Image(val url: String): Media()
data class Video(val url: String, val duration: Int): Media()
object Unknown : Media()

fun renderMedia(media: Media) {
    when (media) {
        is Image -> println("Rendering image from URL: ${media.url}")
        is Video -> println("Rendering video from URL: ${media.url} with duration ${media.duration}s")
        is Unknown -> println("Cannot render unknown media type")
    }
}

sealed class Animal
data class Dog(val breed: String): Animal()
data class Cat(val color: String): Animal()
object Bird : Animal()

fun describeAnimal(animal: Animal): String {
    return when (animal) {
        is Dog -> "This is a ${animal.breed} dog."
        is Cat -> "This is a ${animal.color} cat."
        is Bird -> "This is a bird."
    }
}

sealed class Transaction
data class Deposit(val amount: Double): Transaction()
data class Withdrawal(val amount: Double): Transaction()
data class Transfer(val fromAccount: String, val toAccount: String, val amount: Double): Transaction()

fun handleTransaction(transaction: Transaction) {
    when (transaction) {
        is Deposit -> println("Deposited \$${transaction.amount}")
        is Withdrawal -> println("Withdrew \$${transaction.amount}")
        is Transfer -> println("Transferred \$${transaction.amount} from ${transaction.fromAccount} to ${transaction.toAccount}")
    }
}

sealed class PaymentMethod
object CreditCard : PaymentMethod()
object PayPal : PaymentMethod()
object BankTransfer : PaymentMethod()

fun processPayment(method: PaymentMethod) {
    when (method) {
        CreditCard -> println("Processing credit card payment.")
        PayPal -> println("Processing PayPal payment.")
        BankTransfer -> println("Processing bank transfer payment.")
    }
}

fun handleInput(input: Any) {
    when (input) {
        is String -> println("String length: ${input.length}") // スマートキャストにより`input`がStringとして扱える
        is Int -> println("Square: ${input * input}") // `input`がIntとして扱える
        else -> println("Unsupported type")
    }
}

fun processItem(item: Any) {
    when (item) {
        is String -> println("Uppercase: ${item.uppercase()}")
        is Int -> println("Incremented: ${item + 1}")
        is List<*> -> println("List size: ${item.size}")
        else -> println("Unknown type")
    }
}

fun evaluate(input: Any?) {
    when {
        input is String && input.isNotEmpty() -> println("Non-empty string: $input")
        input is Int && input > 0 -> println("Positive integer: $input")
        input == null -> println("Input is null")
        else -> println("Other type or condition not met")
    }
}

fun checkMutable(input: Any?) {
    if (input is String) {
        println("Input length: ${input.length}") // 有効
    }
    // ここでinputが変更されるとスマートキャストは無効
}

fun handleError(error: Any) {
    when (error) {
        is IllegalArgumentException -> println("Invalid argument: ${error.message}")
        is NullPointerException -> println("Null value encountered!")
        is IOException -> println("I/O error occurred: ${error.message}")
        else -> println("Unknown error: $error")
    }
}

fun processOperation() {
    try {
        // 例外をスローする可能性のあるコード
        throw IllegalArgumentException("Invalid parameter")
    } catch (e: Exception) {
        when (e) {
            is IllegalArgumentException -> println("Caught an IllegalArgumentException: ${e.message}")
            is NullPointerException -> println("Caught a NullPointerException")
            else -> println("Caught an unexpected exception: $e")
        }
    }
}

sealed class ApiResponse
data class Success(val data: String) : ApiResponse()
data class Error(val code: Int, val message: String) : ApiResponse()
object NetworkError : ApiResponse()

fun handleApiResponse(response: ApiResponse) {
    when (response) {
        is Success -> println("Data received: ${response.data}")
        is Error -> println("Error [Code ${response.code}]: ${response.message}")
        is NetworkError -> println("Network connection failed.")
    }
}

fun validateInput(input: Any?) {
    when {
        input == null -> println("Input is null!")
        input is String && input.isEmpty() -> println("Input is an empty string!")
        input is Int && input < 0 -> println("Input is a negative integer!")
        else -> println("Input is valid: $input")
    }
}

fun processWithRethrow(error: Exception) {
    when (error) {
        is IllegalArgumentException -> println("Handled IllegalArgumentException")
        else -> throw error // 再スロー
    }
}

fun processList(input: Any) {
    when (input) {
        is List<Int> -> println("List of Integers")
        is List<String> -> println("List of Strings") // 実行時にはこの区別ができません
        else -> println("Unknown type")
    }
}

fun checkVariable(input: Any?) {
    if (input is String) {
        println(input.length) // スマートキャスト有効
        // inputが変更されるとスマートキャストが無効
    }
}

sealed class Animal
class Dog : Animal()
class Cat : Animal()

fun describeAnimal(animal: Animal) {
    when (animal) {
        is Dog -> println("This is a dog")
        // Catのケースを忘れるとエラーになる可能性があります
    }
}

sealed class State
object Loading : State()
object Success : State()
object Error : State()

fun handleState(state: State) {
    when (state) {
        Loading -> println("Loading")
        Success -> println("Success")
        Error -> println("Error")
        // elseは不要
    }
}

sealed class Animal
class Dog(val breed: String) : Animal()
class Cat(val color: String) : Animal()
object Bird : Animal()

fun describeAnimal(animal: Animal): String {
    // ここにwhen文を使用した実装を書いてください
}

fun handleInput(input: Any): String {
    // ここにwhen文を使用した実装を書いてください
}

sealed class ApiResponse
data class Success(val data: String) : ApiResponse()
data class Error(val code: Int, val message: String) : ApiResponse()
object NetworkError : ApiResponse()

fun handleApiResponse(response: ApiResponse): String {
    // ここにwhen文を使用した実装を書いてください
}

fun evaluateInput(input: Any?) {
    when {
        // 条件に基づいた分岐処理を追加してください
    }
}