[Xcode/Swift] Swift ⇄ Kotlin 脳内スイッチ・チートシート②

// Swift
let count: Int = 3          // 型注釈
var name = "Alice"          // 型推論 (String)
var scores: [Int] = []      // 空配列は注釈入れておくと安心

// Kotlin
val count: Int = 3          // 型注釈
var name = "Alice"          // 型推論 (String)
var scores: MutableList<Int> = mutableListOf()

// Swift
func greet(to person: String = "Guest", times: Int = 1) {
    for _ in 0..<times { print("Hi, \(person)") }
}

greet(to: "Alice", times: 2)   // ラベル必須
greet(times: 3)                // person はデフォルト
greet(to: "Bob")               // times はデフォルト

func sum(_ numbers: Int...) -> Int { numbers.reduce(0, +) }
sum(1, 2, 3) // 6

// Kotlin
fun greet(person: String = "Guest", times: Int = 1) {
    repeat(times) { println("Hi, $person") }
}

greet(person = "Alice", times = 2)  // 名前付き
greet(times = 3)                    // person はデフォルト
greet("Bob")                        // 位置引数でもOK

fun sum(vararg numbers: Int): Int = numbers.sum()
sum(1, 2, 3) // 6

// Swift (Struct：init 自動生成)
struct User {
    var name: String
    var age: Int = 0
}
let user1 = User(name: "Alice")        // age はデフォルト 0
let user2 = User(name: "Bob", age: 20) // もう一つのパターン

// Swift（class：init 必要）
class Person {
    let name: String

    init(name: String) {
        self.name = name
    }
}

// Kotlin（data class：copy 付き）
data class User(
    val name: String,
    val age: Int = 0
)
val user1 = User("Alice")
val user2 = User("Bob", 20)
val user3 = user2.copy(age = 21)   // 一部だけ差し替えて新インスタンス

// Swift
struct Rect {
    var width: Double
    var height: Double
    var area: Double { width * height } // 計算プロパティ

    lazy var cache = [String: Any]()    // 初アクセスで生成

    var name: String = "rect" {
        willSet { print("will set to \(newValue)") } // 呼ばれるタイミング: 値がセットされる直前
        didSet  { print("did set from \(oldValue)") } // 呼ばれるタイミング: 値がセットされた直後
    }
}

// Kotlin
class Rect(
    var width: Double,
    var height: Double
) {
    val area: Double
        get() = width * height          // 計算プロパティ

    val cache: MutableMap<String, Any> by lazy { mutableMapOf() }

    var name: String = "rect"
        set(value) {
            println("will set to $value")
            field = value               // バックフィールド必須
            println("did set from $field")
        }
}

// Swift
public class A {}     // 他モジュールから見えるが継承は不可
open class B {}       // 他モジュールからの継承OK
internal struct C {}  // 同一モジュールのみ
private func f() {}

// Kotlin
open class A          // open で継承許可（デフォは final）
internal class B      // 同一モジュールのみ
private fun f() {}

// Swift：最大値（Comparable 制約）
func maxOf<T: Comparable>(_ a: T, _ b: T) -> T { a > b ? a : b }

// Swift：複数制約
func encodeJSON<T>(_ v: T) -> Data where T: Encodable { try! JSONEncoder().encode(v) }

// Kotlin：Comparable 制約
fun <T : Comparable<T>> maxOf(a: T, b: T): T = if (a > b) a else b

// Kotlin：複数制約
fun <T> encodeJson(v: T): String where T : Any = /* 省略 */

// Kotlin：reified（型でフィルタ）
inline fun <reified T> List<*>.only(): List<T> =
    this.filterIsInstance<T>()

val xs: List<Any> = listOf(1, "a", 2)
val ints = xs.only<Int>()  // [1, 2]

// Swift
struct Point: Equatable, Hashable, Comparable {
    let x: Int, y: Int
    static func < (lhs: Point, rhs: Point) -> Bool {
        (lhs.x, lhs.y) < (rhs.x, rhs.y)
    }
}

let a = Point(x: 1, y: 2)
let b = Point(x: 1, y: 2)
print(a == b) // true

// Kotlin
data class Point(val x: Int, val y: Int): Comparable<Point> {
    override fun compareTo(other: Point): Int =
        compareValuesBy(this, other, Point::x, Point::y)
}

val a = Point(1, 2)
val b = Point(1, 2)
println(a == b)  // true（構造）
println(a === b) // false（参照）

// Swift
struct Counter { var value = 0 }
var c1 = Counter()
var c2 = c1        // コピー
c2.value = 10
print(c1.value)    // 0（影響しない）

// Kotlin：copy で不変運用
data class Counter(val value: Int = 0)
val c1 = Counter()
val c2 = c1.copy(value = 10)
println(c1.value)  // 0（影響しない）

// Swift：関連値付き enum
enum AuthState {
    case signedOut
    case signingIn(progress: Double)
    case signedIn(userID: String)
}

func render(_ s: AuthState) {
    switch s {
    case .signedOut:
        print("Sign in")
    case .signingIn(let p):
        print("Loading \(p)")
    case .signedIn(let id):
        print("Welcome \(id)")
    }
    // すべて列挙しないとコンパイルエラー（網羅性）
}

// Kotlin：sealed interface + data class
sealed interface AuthState {
    data object SignedOut: AuthState
    data class SigningIn(val progress: Double): AuthState
    data class SignedIn(val userId: String): AuthState
}

fun render(s: AuthState) = when (s) {
    AuthState.SignedOut -> println("Sign in")
    is AuthState.SigningIn -> println("Loading ${s.progress}")
    is AuthState.SignedIn  -> println("Welcome ${s.userId}")
    // else 不要（sealed の網羅性）
}

// Swift：guard で早期 return
func load(userID: String?) -> String {
    guard let userID else { return "guest" }
    return "user: \(userID)"
}
// Swift: チェーンとデフォルト
let length = user?.name?.count ?? 0

// Kotlin：Elvis で変換
fun load(userId: String?): String =
    "user: " + (userId ?: return "guest")
// Kotlin: チェーンとデフォルト
val length = user?.name?.length ?: 0

// Swift
let any: Any = "Hello"
if let s = any as? String {
    print(s.count)
}
// let n = any as! Int  // 危険：クラッシュ

// Kotlin
val any: Any = "Hello"
val s = any as? String
println(s?.length)
// val n = any as Int   // 危険：ClassCastException