Kotlin: Kotlinの基本構文

// BAD: mutable shared state
var orderCount = 0  // Race condition!

// GOOD: immutable + functional pipeline
val processedOrders = orders
    .filter { it.status == "CONFIRMED" }
    .also { println("Processed ${it.size} orders") }

// val: read-only (immutable reference) - PREFERRED
val orderId = "ORD-001"         // Type inferred as String
val total: Double = 299.99      // Explicit type

// var: mutable (reassignable) - USE SPARINGLY
var status = "PENDING"          // Can be reassigned
status = "CONFIRMED"            // OK

// val does NOT mean the object is immutable
val items = mutableListOf<Order>()  // Reference is val, list is mutable
items.add(Order("ORD-002", 150.0, "NEW"))  // OK - modifying the list
// items = mutableListOf()  // ERROR - cannot reassign val

val orderId = "ORD-001"
val total = 299.99

// Simple variable reference
println("Order: $orderId")

// Expression in template
println("Total: \$$total USD")
println("Tax: \$${total * 0.08} USD")

// Arbitrary expression with ${}
val items = listOf("Widget", "Gadget")
println("Item count: ${items.size}, First: ${items[0]}")

val receipt = """
    |Order ID: ORD-001
    |Total: $299.99 USD
    |Status: CONFIRMED
""".trimMargin()

// Alternative: trimIndent
val json = """
    {
      "order_id": "ORD-001",
      "total": 299.99
    }
""".trimIndent()

// when as expression (must be exhaustive)
val status = "CONFIRMED"
val label = when (status) {
    "PENDING" -> "Waiting for payment"
    "CONFIRMED" -> "Payment received"
    "SHIPPED" -> "In transit"
    "CANCELLED" -> "Order cancelled"
    else -> "Unknown status"
}

// Multiple values
when (status) {
    "PENDING", "NEW" -> processNewOrder()
    in listOf("CONFIRMED", "PAID") -> shipOrder()
    else -> handleOther()
}

// Range matching
val quantity = 150
when (quantity) {
    in 1..10 -> println("Small order")
    in 11..100 -> println("Medium order")
    in 101..1_000 -> println("Large order")
    else -> println("Bulk order")
}

// Type matching
fun describe(obj: Any): String = when (obj) {
    is String -> "String of length ${obj.length}"
    is Int -> "Integer: $obj"
    is List<*> -> "List with ${obj.size} elements"
    else -> "Unknown type"
}

// Closed range: includes both ends
for (i in 1..5) print("$i ")  // 1 2 3 4 5

// Half-open range: excludes end
for (i in 1 until 5) print("$i ")  // 1 2 3 4

// Step
for (i in 1..10 step 2) print("$i ")  // 1 3 5 7 9

// DownTo
for (i in 5 downTo 1) print("$i ")  // 5 4 3 2 1

// Char range
for (c in 'A'..'E') print("$c ")  // A B C D E

val orders = listOf(
    Order("ORD-001", 299.99),
    Order("ORD-002", 1_500.00),
    Order("ORD-003", 45.50)
)

// Iterate with index
for ((index, order) in orders.withIndex()) {
    println("[$index] ${order.id}: \$${order.total} USD")
}

// Iterate map
val statusMap = mapOf("ORD-001" to "SHIPPED", "ORD-002" to "PENDING")
for ((id, status) in statusMap) {
    println("$id -> $status")
}

// Block body
fun calculateTax(total: Double): Double {
    return total * 0.08
}

// Expression body (more concise)
fun calculateTax(total: Double): Double = total * 0.08

// Type inference with expression body
fun calculateTax(total: Double) = total * 0.08

// 1. Semicolons are optional
val x = 1  // No semicolon needed

// 2. Trailing lambda convention
orders.filter { it.total > 1_000 }  // lambda outside parens

// 3. It keyword for single-parameter lambda
orders.map { it.id }  // 'it' = implicit parameter

// 4. String template over concatenation
val msg = "Order $orderId confirmed"  // Not "Order " + orderId + " confirmed"

// 5. Expression body for simple functions
fun isHighValue(order: Order) = order.total > 10_000

// ============================================
// OrderProcessor - Order Routing Engine
// Feature: Route orders based on status and value
// ============================================

data class Order(val id: String, val total: Double, val status: String)

fun routeOrder(order: Order): String = when {
    order.status == "CANCELLED" -> "REFUND_QUEUE"
    order.total > 10_000 -> "VIP_PIPELINE"
    order.total > 1_000 -> "PRIORITY_PIPELINE"
    order.status == "CONFIRMED" -> "STANDARD_PIPELINE"
    order.status in listOf("PENDING", "NEW") -> "WAITING_QUEUE"
    else -> "MANUAL_REVIEW"
}

fun processBatch(orders: List<Order>) {
    for ((index, order) in orders.withIndex()) {
        val pipeline = routeOrder(order)
        val priority = when (pipeline) {
            "VIP_PIPELINE" -> "CRITICAL"
            "PRIORITY_PIPELINE" -> "HIGH"
            "STANDARD_PIPELINE" -> "NORMAL"
            else -> "LOW"
        }
        println("[${index + 1}] ${order.id} -> $pipeline (Priority: $priority)")
    }
}

fun main() {
    val orders = listOf(
        Order("ORD-001", 299.99, "CONFIRMED"),
        Order("ORD-002", 15_000.00, "CONFIRMED"),
        Order("ORD-003", 2_500.00, "PENDING"),
        Order("ORD-004", 45.50, "CANCELLED"),
        Order("ORD-005", 750.00, "NEW")
    )

    println("=== Order Routing Report ===")
    processBatch(orders)

    // Summary with functional pipeline
    val pipelineCounts = orders
        .map { routeOrder(it) }
        .groupingBy { it }
        .eachCount()

    println("\n=== Pipeline Distribution ===")
    for ((pipeline, count) in pipelineCounts) {
        println("  $pipeline: $count orders")
    }
}

=== Order Routing Report ===
[1] ORD-001 -> STANDARD_PIPELINE (Priority: NORMAL)
[2] ORD-002 -> VIP_PIPELINE (Priority: CRITICAL)
[3] ORD-003 -> PRIORITY_PIPELINE (Priority: HIGH)
[4] ORD-004 -> REFUND_QUEUE (Priority: LOW)
[5] ORD-005 -> WAITING_QUEUE (Priority: LOW)

=== Pipeline Distribution ===
  STANDARD_PIPELINE: 1 orders
  VIP_PIPELINE: 1 orders
  PRIORITY_PIPELINE: 1 orders
  REFUND_QUEUE: 1 orders
  WAITING_QUEUE: 1 orders

val name = "Alice"  // immutable
var age = 30        // mutable
age = 31            // OK
// name = "Bob"     // compile error

Compiles; reassigning name fails

val score = 85
val grade = when {
    score >= 90 -> "A"
    score >= 80 -> "B"
    else -> "C"
}
println(grade)

B

for (i in 1..3) println(i)
for (s in listOf("a", "b")) println(s)

1
2
3
a
b