(Swift의 Closure, Java의 Stream/람다, JS의 async/await·const와 자연스럽게 이어지는 Kotlin의 문법과 철학)
1) Executive Summary (요약)
Kotlin의 핵심 철학: 간결함(boilerplate 제거)·안전성(null‐safety)·상호운용성(Java 100%)·현대적 비동기(coroutines)
기존 기술과의 연속성:
Java → Kotlin: final→val, 람다/Stream→람다·시퀀스, Optional/애너테이션→null‐safety 타입 시스템, record→data class, CompletableFuture→suspend/Flow
Swift → Kotlin: let(상수)↔val, 옵셔널 ? ↔ ?, guard/if let ↔ safe call/엘비스, struct↔data class, async/await↔suspend, extension↔extension function
JavaScript(Web) → Kotlin: const↔val, let↔var, Promise/async↔suspend/Flow, 함수형 체이닝↔scope 함수
적응 포인트:
null‐safety가 _언어 차원_에서 강제된다.
data class / sealed class / when 으로 _모델링과 패턴 매칭_이 간결해진다.
coroutines로 비동기 흐름을 단순 동기 코드처럼 표현한다.
확장 함수·스코프 함수로 DSL급 가독성을 얻는다.
2) TL;DR 치트시트 (개념 매핑)
2.1 상수·변수·불변성
개념
Kotlin
Java
Swift
JavaScript
불변 변수
val x = 1
final int x = 1;
let x = 1
const x = 1
가변 변수
var x = 1
int x = 1;
var x = 1
let x = 1
불변 컬렉션
listOf(1,2)
List.of(…)
let arr = [1,2](값 타입)
없음(관례)
2.2 함수/클로저/람다
개념
Kotlin
Java
Swift
JavaScript
람다
{ it * 2 }
x -> x*2
{ $0 * 2 }
x => x*2
고차함수
fun f(g:(Int)->Int)
Function<Integer,Integer>
func f(g:(Int)->Int)
(g)=>{}
클로저 캡처
캡처됨
캡처됨
캡처됨
캡처됨
2.3 Null·옵셔널
작업
Kotlin
Java
Swift
선언
String?
@Nullable String
String?
안전 호출
a?.len
a != null ? a.len() : null
a?.count
기본값
a ?: "default"
a != null ? a : "default"
a ?? "default"
2.4 데이터 모델
개념
Kotlin
Java
Swift
JS
데이터 홀더
data class
record(17+)
struct
POJO/객체 리터럴
패턴 매칭
when + sealed
switch(제한)
switch + enum(연관값)
switch(제한)
2.5 비동기/동시성
개념
Kotlin
Java
Swift
JS
비동기
coroutines (suspend)
CompletableFuture
async/await
async/await
스트림
Flow
Stream/Reactive
AsyncSequence
Observable(라이브러리)
3) Kotlin 언어 핵심: “기존 감각으로” 빠르게 이해하기
3.1 val/var와 타입 추론
val a = 10 // 불변 (Java final / Swift let / JS const)
var b = "text" // 가변 (Java 변수 / Swift var / JS let)
타입 추론이 기본. 필요 시 val n: Int = 10.
3.2 Null‐safety (Swift Optional 경험 그대로)
val s: String? = getName()
val len = s?.length ?: 0 // safe call + 엘비스 연산자
Java와 상호 운용 시 플랫폼 타입(String!) 주의: NPE 가능 → API 경계에 명시적 ?/!! 활용.
3.3 함수/람다/클로저
fun twice(f: (Int)->Int) = f(2)
val r = twice { it * 10 } // trailing lambda
클로저 캡처: 주변 val/var 사용 가능.
확장 함수: 기존 타입에 메서드 추가처럼 보이게.
fun String.padZ(n:Int) = this.padStart(n, '0')
"7".padZ(3) // "007"
Swift의 extension과 매우 유사.
3.4 컬렉션 & 함수형 유틸
val xs = listOf(1,2,3)
val ys = xs.map { it*2 }.filter { it>2 }
불변/가변 분리: listOf vs mutableListOf.
Java Stream과 유사하되, 람다·확장함수로 더 간결.
3.5 스코프 함수(let/run/apply/also/with)
val user = User().apply {
name = "Neo"
age = 42
}.also { println("created $it") }
val len = "abc".let { it.length } // 값 변환
JS 체이닝/Swift의 trailing closure 감각으로 빠르게 적응 가능.
3.6 data class & sealed class & when
data class User(val name:String, val age:Int)
// equals/hashCode/toString/copy 자동 생성
sealed class Shape {
data class Circle(val r:Double): Shape()
data class Rect(val w:Double, val h:Double): Shape()
}
fun area(s: Shape) = when(s) {
is Shape.Circle -> Math.PI * s.r * s.r
is Shape.Rect -> s.w * s.h
}
Swift enum with associated values + switch와 유사한 모델링.
3.7 제네릭 & 공변성(in/out)
interface Source<out T> { fun next(): T } // out: 생산만
interface Sink<in T> { fun push(x:T) } // in: 소비만
Java의 ? extends/? super를 _선언 지점_에서 표현.
3.8 예외/에러 모델
Kotlin은 checked exception이 없다.
Java API 호출 시 필요하면 @Throws(IOException::class)로 Swift 인터롭처럼 전달 가능.
Swift/JS의 Result/Either 스타일은 Result<T> 또는 sealed class로 모델링.
4) “제너레이터”에 해당하는 Kotlin의 해법: Sequence & Coroutines
Java에는 본격적인 _generator_가 없고 Iterator/Stream으로 유사 구현. Kotlin은 **sequence { yield(...) }**와 코루틴으로 generator 패턴을 자연스럽게 지원.
val seq = sequence {
var i = 0
while(true) yield(i++)
}
println(seq.take(5).toList()) // [0,1,2,3,4]
JS 제너레이터(function*)와 가장 유사한 개발 경험.
무한/대용량 스트림을 lazy하게 처리→ 메모리 효율↑.
5) 비동기/동시성: suspend vs Java/Swift/JS
시나리오
Java
Swift
JS
Kotlin
비동기 호출
CompletableFuture.supplyAsync()
async/await
async/await
suspend fun, withContext(Dispatchers.IO)
스트림성 데이터
Reactive Streams/RxJava
AsyncSequence
RxJS 등
Flow
suspend fun fetch(): Data =
withContext(Dispatchers.IO) {
http.get("/api").body()
}
// 병렬 합성
val a = async { fetchA() }
val b = async { fetchB() }
val both = a.await() to b.await()
Stream.map/filter ↔ 컬렉션 확장함수(map/filter) 또는 Sequence
CompletableFuture ↔ suspend/Flow
static util ↔ top-level function / companion object / extension
13) 부록 B: 미니 예제 (엔드투엔드)
// Domain
sealed class Payment {
data class Card(val last4:String): Payment()
data class Cash(val received:Int): Payment()
}
// Service
suspend fun pay(p: Payment): Receipt = when(p) {
is Payment.Card -> chargeCard(p.last4)
is Payment.Cash -> giveChange(p.received)
}
// Use
val paid = coroutineScope {
val a = async { pay(Payment.Card("1234")) }
val b = async { pay(Payment.Cash(10000)) }
listOf(a.await(), b.await())
}
모델링은 sealed + data, 분기는 when으로 명확.
비동기 합성은 async/await로 간결.
Java/Swift/JS 배경에서도 자연스럽게 읽히는 문법.
맺음말
Kotlin은 Java·Swift·JS의 장점을 “언어 레벨”에서 일관되게 통합합니다. 기존 프로그래머는 null‐safety·데이터 모델링·코루틴 세 축만 잡아도 생산성을 빠르게 체감합니다. 팀 차원에서는 _확장/스코프 함수_로 내부 DSL을 구축해 가독성과 유지보수성을 높이세요.