🔧 ┗ 11. Scope 함수 — `apply`, `run`, `let`, `also`

BamgasiJM·2026년 9월 28일

목록 보기

11/17

지금까지 배운 문법들을 모두 활용하면, 코드를 더 깔끔하게 작성할 수 있습니다.

Scope 함수는 객체를 초기화하거나 체이닝할 때 매우 유용합니다.

문제: 객체 초기화가 복잡함

data class AppSettings(
    var width: Int = 0,
    var height: Int = 0,
    var frameRate: Int = 60,
    var debug: Boolean = false
)

val settings = AppSettings()
settings.width = 800
settings.height = 600
settings.frameRate = 60
settings.debug = true
// 변수 이름을 매번 반복해야 함

해결: Scope 함수로 간결하게

val settings = AppSettings().apply {
    width = 800
    height = 600
    frameRate = 60
    debug = true
    // this가 AppSettings이므로, 프로퍼티에 직접 접근
}

이 글에서는:

네 가지 Scope 함수의 차이
각각을 언제 사용할까
OPENRNDR에서의 실제 패턴

을 다루겠습니다.

Scope 함수란?

Scope 함수는 객체의 범위(scope) 안에서만 작동하는 함수들입니다.

네 가지가 있습니다:

apply — 객체를 수정하고 반환
also — 객체를 그대로 반환하며 부수효과 실행
let — 변환된 값 반환
run — 변환된 값 반환 (암묵적 리시버)

1. `apply` — 객체 설정 후 반환

apply는 객체를 설정하고 그 객체를 반환합니다.

data class AppSettings(var width: Int = 0, var height: Int = 0)

val settings = AppSettings().apply {
    width = 800
    height = 600
}
// settings는 설정이 끝난 같은 AppSettings 객체입니다.

apply 블록의 리시버는 생성한 객체이므로 this.width 대신 width로 접근합니다. 블록에서 무엇을 반환하든 apply의 결과는 원래 객체입니다.

예제 1: 간단한 초기화

data class Circle(
    var x: Double = 0.0,
    var y: Double = 0.0,
    var radius: Double = 10.0,
    var color: ColorRGBa = ColorRGBa.WHITE
)

// apply 없이
val circle1 = Circle()
circle1.x = 100.0
circle1.y = 200.0
circle1.radius = 50.0
circle1.color = ColorRGBa.RED

// apply로 (깔끔함)
val circle2 = Circle().apply {
    x = 100.0
    y = 200.0
    radius = 50.0
    color = ColorRGBa.RED
}

예제 2: 리스트 초기화

val numbers = mutableListOf<Int>().apply {
    add(1)
    add(2)
    add(3)
    add(4)
    add(5)
}

// 또는 한 줄로
val numbers = mutableListOf(1, 2, 3, 4, 5)  // 더 간단함

OPENRNDR에서의 apply

program {
    val drawer = this.drawer.apply {
        fill = ColorRGBa.WHITE
        stroke = ColorRGBa.BLACK
        strokeWeight = 2.0
    }
    
    extend {
        drawer.clear(ColorRGBa.BLACK)
        
        drawer.circle(400.0, 400.0, 100.0)
    }
}

2. `also` — 부수효과 실행 후 원본 반환

also는 객체를 그대로 반환하면서 부수효과를 실행합니다.

val result = mutableListOf(1, 2, 3)
    .also { list ->
        println("List created: $list")  // 부수효과
        // also 자체는 반환값을 바꾸지 않지만, list의 가변 내용은 수정할 수 있습니다.
    }
    // result는 원본 list와 같음

예제 1: 디버그 출력과 함께

val numbers = (1..10).toList()
    .also { println("Original: $it") }
    .filter { it % 2 == 0 }
    .also { println("Filtered: $it") }
    .map { it * 2 }
    .also { println("Mapped: $it") }

// 출력:
// Original: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
// Filtered: [2, 4, 6, 8, 10]
// Mapped: [4, 8, 12, 16, 20]

예제 2: 로깅과 함께 데이터 처리

data class Particle(
    var position: Vector2,
    var velocity: Vector2
)

val particles = (0 until 100)
    .map { i ->
        Particle(
            position = Vector2(random(800.0), random(600.0)),
            velocity = Vector2(random(-2.0, 2.0), random(-2.0, 2.0))
        )
    }
    .also { particles ->
        println("Created ${particles.size} particles")
    }
    .filter { it.position.x > 100 }
    .also { filtered ->
        println("Filtered to ${filtered.size} particles")
    }

OPENRNDR에서의 also

program {
    val particles = mutableListOf<Particle>()
    
    extend {
        // 파티클 생성 및 로깅
        particles.add(
            Particle(mouse.position, Vector2(1.0, 0.0))
                .also { p ->
                    println("Particle created at ${p.position}")
                }
        )
    }
}

3. `let` — 변환 후 반환

let은 객체를 변환해서 새로운 값을 반환합니다.

val original = "Hello"
val transformed = original.let { str ->
    str.uppercase() + "!"
}
println(transformed)  // "HELLO!"

// original은 변경되지 않음
println(original)     // "Hello"

예제 1: Null 안전성과 함께

val name: String? = "Mina"

// let으로 null 체크
name?.let { n ->
    println("Hello, $n")
    // n은 String (null이 아님이 보장됨)
}

예제 2: 데이터 변환

val point = Vector2(100.0, 200.0)

val distance = point.let { p ->
    sqrt(p.x * p.x + p.y * p.y)
}

println(distance)  // 223.6...

// 또는 람다 축약
val distance2 = point.let { sqrt(it.x * it.x + it.y * it.y) }

예제 3: 체이닝

val result = mutableListOf(1, 2, 3)
    .let { list ->
        list.map { it * 2 }  // List<Int>로 변환
    }
    .let { doubled ->
        doubled.sum()  // Int로 변환
    }

println(result)  // 12

OPENRNDR에서의 let

program {
    var selectedPoint: Vector2? = null
    
    extend {
        drawer.clear(ColorRGBa.BLACK)
        
        // selectedPoint로 계산 수행
        selectedPoint?.let { point ->
            val distance = (point - mouse.position).length
            drawer.fill = if (distance < 100) ColorRGBa.RED else ColorRGBa.WHITE
            drawer.circle(point.x, point.y, 20.0)
        }
    }
}

4. `run` — 암묵적 리시버로 변환

run은 리시버를 암묵적으로 사용하면서 변환된 값을 반환합니다.

val result = "Hello".run {
    // this == "Hello"
    uppercase() + "!"
}
println(result)  // "HELLO!"

// let과 비슷하지만, 파라미터 대신 this 사용
// let: let { str -> str.uppercase() }
// run: run { uppercase() }

예제 1: 간단한 계산

val circle = Circle(100.0, 200.0, 50.0)

val area = circle.run {
    PI * radius * radius
}
println(area)  // 7853.98...

예제 2: 조건부 처리

val input: String? = "pattern"

val result = input?.run {
    if (this.isEmpty()) "Empty" else "Not empty: $this"
} ?: "Input is null"

println(result)

OPENRNDR에서의 run

program {
    data class Settings(var scale: Double = 1.0)

    val settings = Settings().run {
        scale = 2.0
        this  // 마지막 식이므로 Settings 객체 반환
    }
}

apply, also, let, run은 모두 블록을 실행한 뒤 결과를 반환합니다. 차이는 블록 안에서 객체를 어떤 이름으로 다루는지, 그리고 어떤 값을 반환하는지에 있습니다. 함수 종류에 따라 블록의 수신 객체가 달라집니다.

네 가지 Scope 함수 비교

함수	파라미터	리시버	반환값	용도
`apply`	없음	`this`	객체	초기화
`also`	`it`	없음	객체	부수효과
`let`	`it`	없음	변환값	변환
`run`	없음	`this`	변환값	계산

이 표는 확장 함수 형태인 객체.run { ... }를 기준으로 합니다. run { ... }처럼 객체 없이 부르는 표준 함수도 있으며, 그 형태에는 수신 객체가 없습니다.

선택 기준:

data class Settings(var width: Int = 0, var height: Int = 0)

// apply: 객체 설정 후 같은 객체를 반환
val settings = Settings().apply {
    width = 800
    height = 600
}

// also: 값을 유지하면서 로그 출력
val numbers = listOf(1, 2, 3).also { println("Created: $it") }

// let: nullable 값이 있을 때만 변환
val name: String? = "Mina"
val length = name?.let { it.length }

// run: 리시버를 사용해 계산값 반환
val radius = 50.0
val area = radius.run { PI * this * this }

실전 예제 1: 게임 객체 초기화

data class GameCharacter(
    var name: String = "",
    var health: Int = 100,
    var mana: Int = 50,
    var position: Vector2 = Vector2(0.0, 0.0),
    var level: Int = 1
) {
    fun takeDamage(amount: Int) {
        health -= amount
    }
}

// apply로 초기화
val hero = GameCharacter().apply {
    name = "Hero"
    health = 200
    mana = 150
    position = Vector2(400.0, 400.0)
    level = 5
}

// also로 검증
val validHero = hero.also {
    require(it.health > 0) { "Health must be positive" }
    println("Hero initialized: ${it.name} at level ${it.level}")
}

실전 예제 2: 데이터 파이프라인

data class DataPoint(
    val x: Double,
    val y: Double,
    val value: Double
)

val results = (0 until 1000)
    .map { i ->
        DataPoint(
            x = i.toDouble(),
            y = random(100.0),
            value = sin(i.toDouble() / 100)
        )
    }
    .also { data ->
        println("Generated ${data.size} data points")
    }
    .filter { it.value > 0 }
    .also { data ->
        println("Filtered to ${data.size} positive values")
    }
    .sortedByDescending { it.value }
    .also { data ->
        println("Top value: ${data.firstOrNull()?.value}")
    }
    .take(10)
    .also { data ->
        println("Took top 10: ${data.size} items")
    }

실전 예제 3: Null 안전성과 체이닝

program {
    var cachedResult: List<Vector2>? = null
    
    extend {
        drawer.clear(ColorRGBa.BLACK)
        
        // 캐시된 결과 또는 새로 계산
        val points = cachedResult?.let { cached ->
            println("Using cached result")
            cached
        } ?: run {
            println("Computing new result")
            (0 until 20).map { i ->
                Vector2(i * 40.0, 300.0 + 100.0 * sin(i.toDouble()))
            }
        }.also { points ->
            cachedResult = points  // 캐시 저장
        }
        
        // 포인트 그리기
        drawer.fill = ColorRGBa.WHITE
        points.forEach { circle(it.x, it.y, 5.0) }
    }
}

실전 예제 4: Builder 패턴

data class DrawingContext(
    var strokeColor: ColorRGBa = ColorRGBa.BLACK,
    var fillColor: ColorRGBa = ColorRGBa.WHITE,
    var strokeWeight: Double = 1.0,
    var fontSize: Int = 12
)

fun createContext(init: DrawingContext.() -> Unit): DrawingContext {
    return DrawingContext().apply(init)
}

program {
    val darkContext = createContext {
        strokeColor = ColorRGBa.WHITE
        fillColor = ColorRGBa.BLACK
        strokeWeight = 2.0
    }
    
    val lightContext = createContext {
        strokeColor = ColorRGBa.BLACK
        fillColor = ColorRGBa.WHITE
        strokeWeight = 1.0
    }
    
    extend {
        drawer.clear(ColorRGBa.BLACK)
        
        drawer.fill = darkContext.fillColor
        drawer.stroke = darkContext.strokeColor
        drawer.strokeWeight = darkContext.strokeWeight
        
        drawer.circle(200.0, 400.0, 50.0)
    }
}

실전 예제 5: 복잡한 설정 체이닝

program {
    val particles = mutableListOf<Particle>()
    
    val config = object {
        var particleCount = 100
        var minVelocity = -2.0
        var maxVelocity = 2.0
        var particleSize = 5.0
    }.apply {
        particleCount = 150  // 설정 조정
        particleSize = 8.0
    }
    
    extend {
        drawer.clear(ColorRGBa.BLACK)
        
        // 파티클 추가
        repeat(3) {
            particles.add(
                Particle(
                    position = mouse.position,
                    velocity = Vector2(
                        random(config.minVelocity, config.maxVelocity),
                        random(config.minVelocity, config.maxVelocity)
                    ),
                    radius = config.particleSize
                ).also { p ->
                    println("Particle added with radius: ${p.radius}")
                }
            )
        }
        
        // 파티클 업데이트 및 렌더링
        particles
            .also { list ->
                println("Updating ${list.size} particles")
            }
            .forEach { p ->
                p.update()
                p.draw(drawer)
            }
        
        particles.removeIf { !it.isAlive }
    }
}

Scope 함수의 체이닝

여러 Scope 함수를 연결할 수 있습니다.

val result = mutableListOf(1, 2, 3)
    .apply {
        add(4)
        add(5)
    }
    .also { list ->
        println("List: $list")
    }
    .map { it * 2 }
    .let { doubled ->
        doubled.sum()
    }

println(result)  // 30

실전 예제 6: 게임 상태 관리

data class Enemy(var position: Vector2, var health: Int)

object GameManager {
    var score = 0
    var level = 1
    var enemies = mutableListOf<Enemy>()
    
    fun updateScore(points: Int) {
        score = (score + points).also { newScore ->
            println("Score updated to $newScore")
        }
        level = score / 1000 + 1
    }
    
    fun createEnemies(count: Int) {
        enemies = (0 until count)
            .map { i ->
                Enemy(
                    position = Vector2(random(800.0), random(600.0)),
                    health = 10 * level
                )
            }
            .toMutableList()
            .also { list ->
                println("Created ${list.size} enemies for level $level")
            }
    }
}

program {
    extend {
        drawer.clear(ColorRGBa.BLACK)
        
        // 게임 관리자 상태 표시
        drawer.fill = ColorRGBa.WHITE
        drawer.text("Score: ${GameManager.score}", 20.0, 30.0)
        drawer.text("Level: ${GameManager.level}", 20.0, 60.0)
        drawer.text("Enemies: ${GameManager.enemies.size}", 20.0, 90.0)
    }
}

Scope 함수의 장점

장점	설명
간결성	반복되는 변수 이름 제거
가독성	의도가 명확함
표현	객체 설정과 값 변환을 블록으로 구분
유효범위	별도의 변수 오염 없음
표현력	함수형 스타일로 우아함

실전 팁: 언제 어떤 함수를 쓸까?

data class Settings(
    var debug: Boolean = false,
    var maxConnections: Int = 0
)

// 초기화: apply
val config = Settings().apply {
    debug = true
    maxConnections = 100
}.also { settings ->
    println("Config: $settings")
}

// 검증과 기록: also
val list = listOf(1, 2, 3).also {
    require(it.isNotEmpty())
    println("List created")
}

// nullable 값 변환: let
val data: String? = "42"
val transformed = data?.let { it.toInt() }

// 계산: run
val radius = 50.0
val area = radius.run { PI * this * this }

다음 단계

지금까지 배운 코틀린의 핵심 문법들:
1. 프로그램 구조
2. 람다와 리시버
3. val/var
4. 범위와 반복
5. 컬렉션
6. Extension 함수
7. when 조건 분기
8. Null 안전성
9. 클래스와 데이터 클래스
10. Object와 싱글턴
11. Scope 함수 ✅

각 문법은 작은 예제에서 끝나지 않습니다. 입자 시스템이나 격자 패턴처럼 실제 상태와 그리기 규칙을 함께 다루는 코드에 적용하면, 어떤 부분을 고정하고 어떤 값을 갱신할지 판단하는 데 도움이 됩니다.

연습 문제

1. 기본 apply

data class Shape(
    var x: Double = 0.0,
    var y: Double = 0.0,
    var size: Double = 10.0
)

val shape = Shape().apply {
    x = 100.0
    y = 200.0
    size = 50.0
}

println(shape)  // Shape(x=100.0, y=200.0, size=50.0)

2. also로 디버깅

val numbers = (1..10).toList()
    .also { println("Original: $it") }
    .filter { it % 2 == 0 }
    .also { println("Filtered: $it") }

// 출력:
// Original: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
// Filtered: [2, 4, 6, 8, 10]

3. let으로 null 처리

program {
    var selected: Vector2? = Vector2(100.0, 120.0)

    extend {
        drawer.clear(ColorRGBa.BLACK)
        selected?.let { pos ->
            drawer.fill = ColorRGBa.CYAN
            drawer.circle(pos.x, pos.y, 20.0)
        }
        // selected = null로 바꾸면 원은 그려지지 않습니다.
    }
}

4. run으로 계산

data class Circle(val radius: Double)

val circle = Circle(50.0)

val area = circle.run {
    PI * radius * radius
}

println(area)  // 7853.981633974483

5. OPENRNDR 종합 예제

마우스를 누르면 현재 위치에 입자를 최대 다섯 개 추가합니다. apply로 설정을 만들고, also로 생성 시점을 기록하며, let으로 마지막 선택 위치를 표시합니다. 누르고 있는 동안 같은 입력을 반복 처리하지 않도록 프레임 사이의 버튼 상태를 비교합니다.

data class Particle(
    var position: Vector2,
    var velocity: Vector2,
    val radius: Double,
    val lifespan: Double,
    var age: Double = 0.0
) {
    val isAlive: Boolean get() = age < lifespan

    fun update() {
        position += velocity
        age += 1.0
    }

    fun draw(drawer: Drawer) {
        val alpha = (1.0 - age / lifespan).coerceIn(0.0, 1.0)
        drawer.fill = ColorRGBa(1.0, 1.0, 1.0, alpha)
        drawer.circle(position.x, position.y, radius)
    }
}

program {
    data class Config(var particleLimit: Int = 100, var particleSize: Double = 5.0)

    val config = Config().apply {
        particleLimit = 200
        particleSize = 8.0
    }
    val particles = mutableListOf<Particle>()
    var selectedPosition: Vector2? = null
    var wasMouseDown = false

    extend {
        drawer.clear(ColorRGBa.BLACK)
        val mouseDown = mouse.buttonDown
        if (mouseDown && !wasMouseDown) {
            selectedPosition = mouse.position
            val remaining = (config.particleLimit - particles.size).coerceAtLeast(0)
            repeat(minOf(5, remaining)) {
                particles.add(
                    Particle(
                        position = mouse.position,
                        velocity = Vector2(random(-2.0, 2.0), random(-2.0, 2.0)),
                        radius = config.particleSize,
                        lifespan = 60.0
                    ).also { particle ->
                        println("Particle created at ${particle.position}")
                    }
                )
            }
        }
        wasMouseDown = mouseDown

        particles.forEach { it.update() }
        particles.removeIf { !it.isAlive }
        particles.forEach { it.draw(drawer) }

        selectedPosition?.let { position ->
            drawer.stroke = ColorRGBa.YELLOW
            drawer.circle(position.x, position.y, 14.0)
        }
    }
}

한 번 누를 때마다 입자 다섯 개가 추가되고, 전체 개수는 200개를 넘지 않습니다. 생성 로그는 마우스를 누르기 시작한 순간에만 출력됩니다. selectedPosition이 아직 정해지지 않았다면 let 블록은 실행되지 않으며, 한 번이라도 누른 뒤에는 마지막 누른 위치에 노란 원이 표시됩니다.

마지막 조언

Scope 함수는 리시버와 반환값을 기준으로 구분하면 선택이 단순해집니다.

기억할 기준:

초기화 → apply
부수효과 → also
변환 → let
계산 → run

이 네 가지를 기억하면 됩니다.

이 문서까지 0~11번에서 다룬 Kotlin 문법을 살펴봤습니다. 다음 단계에서는 이 문법을 작은 OPENRNDR 작품에 적용하며 필요한 라이브러리 기능을 익히면 됩니다.

BamgasiJM

Coding Art with Blender / Three.js / p5.js / GLSL Shader / Processing / nannou

이전 포스트

🔧 ┠ 10. Object와 싱글턴 — 전역 상태 관리

다음 포스트