oh-my-oop 0.2.0

package/lessons/woowacourse-kotlin-blackjack/HamBeomJoon/137-2/353/213/250/352/263/204-/353/270/224/353/236/231/354/236/255.md

@@ -0,0 +1,459 @@
+# PR #137 — [블랙잭 2단계] 미플 미션
+
+- **Reviewee:** [@HamBeomJoon](https://github.com/HamBeomJoon)
+- **PR:** https://github.com/woowacourse/kotlin-blackjack/pull/137
+- **단계:** 2단계 (베팅 / 수익률 / 블랙잭 1.5배)
+- **리뷰어:** @lee-ji-hoon (지훈) — *신규 리뷰어*. 학생 자가 답변 + 커밋 SHA 첨부 풍부.
+- **라인 코멘트:** 21 스레드 / 42 코멘트 — *원시값 포장 + 도메인-뷰 분리 + ResultType enum 부가속성* 깊은 토론
+
+## 잘한 점 (설계 관점)
+
+- **`ResultType enum + profit: Double 부가속성`** — 지훈 권고: *"게임 결과에 따른 이익률을 게임 결과가 알고 있어도 되지 않을까? `enum class ResultType(val profit: Double) { WIN(1.0), TIE(0.0), LOSS(-1.0), BLACKJACK(1.5); }` 그렇게 되면 `calucateProfit` 함수도 조금 더 간결하게 표현이 됐을 것 같네요!"* 후속 반영 (커밋 `f1a40f9`). 학생 자가 답변: *"와..😲 enum class에 대해 좀 더 공부해보겠습니다!"*. PR #132·#90 와 같은 결의 *enum 부가 속성 응집*.
+- **`BetAmount @JvmInline value class` + `value` 멤버 명명 자가 반영** — 지훈 권고: *"저는 value class에서는 그냥 value라고 해두는 편입니다. `val amount = BetAmount(value = 10.0); amount.value`"* 후속 반영 (커밋 `0b30903`). *Kotlin value class 어휘 학습 모범*.
+- **`WinningMoney value class` + `BetAmount value class` 분리** — 지훈 권고 *"저희는 원시값을 가능한 다 포장을 해보는 연습을 해보기로 했습니다. 모르는 사람이 봤을 때 이 Double이 무엇을 의미하는지 알기가 어렵기도 하죠"* 후속 반영 (커밋 `8a673e0`). PR #49·#90·#132·#136 와 같은 결.
+- **`Profit(participant, winningMoney)` 결과 객체 응집** — `Profit` 클래스 도입으로 *Map<Player, WinningMoney>* 우회. *PR #132 (환노 2단계) 의 Map<X,X> 지양* 와 같은 결.
+- **`ResultCalculator.judgeState(dealer, player)` `when` 절 변환** — 지훈 권고 *"하나의 함수에서 많은 if문이 열리게 될 경우 가독성이 떨어지게 됩니다. 이렇게 한 번 바꿔볼까요?"* 후속 반영 (커밋 `2eac33b`). *if 분기 → when 패턴 매칭* Kotlin 어휘 정공.
+- **`Participant.cards = _cards.toList()` 방어적 복사 자가 학습** — 지훈 메타 질문 *"여기서 map으로 `it.copy` 를 한 대상이 `Card` 객체인데요! 이렇게 했을 때 어떤 이점이 있다고 판단을 해서 수정을 하신걸까요?"* + 학생 자가 학습 답변: *"`_cards.toList`와 `val cards: List<Card> get() = _cards.map { it.copy() }.toList()` 여러 테스트를 해보면서도 무슨 차이지..하고 차이를 못 느꼈지만 ... 좀 더 공부해보니 cards안에 있는 내부 객체 Card가 변하게 될 때 두 코드의 차이가 있는 것 같습니다. 현재는 Card의 shape, Number 둘다 val이어서 변할 일이 없기때문에, it.copy()를 하면 괜히 복사비용만 추가된다 생각해 _cards.toList()로 바꿨습니다"* (커밋 `13cf13a`). **불변 객체에 deepCopy 강박 자가 인식 + 후속 반영 모범**. PR #124 (모찌 1단계) 의 *Card.copy 강박* 와 *반대 방향 학습*.
+- **`BlackjackGame.startGame(wantsToDraw, onEndPlayerTurn, onEndDealerTurn, printAllHands)` 콜백 인터페이스 자가 학습** — 지훈 진단: *"`BlackjackGame` 이 View의 역할도 하고 있습니다. `println`을 호출하고 있기도 하고 간접적으로나마 print라는 lambda으로 인해서 간접적으로라도 알고 있는 느낌이기도 하죠. lambda 이름들을 이런 형태로 바꿔보면 어떨까요? `onEndDelaerTurn` 이런 형태로 지금 어떠한 행위가 끝났는지를 명시하고 그 행위를 사용하는 곳에서 무엇을 할지를 선택을 하는 것인데요."* 후속 반영 (커밋 `e90b497`). **콜백 = 행위 명시 (`onXX`) 표준 어휘 학습**. PR #132 (환노 2단계) 의 *고차함수 + 인터페이스* 와 같은 결.
+- **View 계산 로직 → GameManager 이전 자가 반영** — 지훈 진단 *"갑자기 View에서 계산하는 로직을 하고 있는데요! 딜러의 수익도 게임 결과를 합산할 때 처리하고 들어와야 하지 않을까요?"* 후속 반영 (커밋 `f8f3b9a`). PR #132·#90·#88·#41·#53 와 같은 결.
+- **`println` View 이전 자가 반영** — 지훈 진단 *"println을 직접 호출하는 것도 고민해볼만한 포인트입니다."* + 학생: *"println을 view로 이동시켰습니다."* (커밋 `4bff807`). **도메인 = println X 정공**. PR #58 와 같은 결.
+- **`mark` 자가 학습 표현 + 학생 자가 답변 풍부** — 지훈 권고 *"마음에 안 드는 이유를 이야기를 해줬으면 좋겠어요!"* + 학생 자가 답변 *"단순히 메서드 줄 수가 늘어나서 그랬던 것 같습니다. 상태를 먼저 판단하고 그뒤에 점수비교를 하도록 분리를 해봤습니다"* (커밋 `d1b51e8`). **메타 토론 + 자가 의도 명시 학습 모범**.
+- **`BetAmount value class + 확장 함수 → BetAmount Double 직접` 자가 학습** — 지훈 메타 질문: *"BetAmount 자체가 Int가 아닌 Double을 받는다고 생각했을 때 어색할까요?"* + 학생 자가 답변: *"BetAmount를 Double로 받도록 했는데, 결국 확장함수를 없애니 player.betAmount.amount로 코드길이는 그대로 유지 되는 것 같습니다😅"* + 지훈: *"네 코드 길이는 유지가 되지만 굳이 필요 없던 `toDouble()` 확장 함수는 사라졌으니 유의미하지 않았을까요!.."* (커밋 `970fcb9`). **YAGNI + 도메인 타입 직접 Double 자가 학습**.
+- **테스트 명세 정확성 자가 반영** — 지훈 진단 *"단순히 `딜러의 점수보다 크면 이긴다`라는 조건은 아닐 것 같아요! 이 테스트 함수명만 봤을 때는 아래와 같은 조건에서도 이긴다는 것 같아요 플레이어 : 24 / 딜러 : 19"* + 학생: *"구체적으로 명시해줬습니다!"* (커밋 `0e6ab44`). **테스트 명세 = 도메인 룰 정확** 학습.
+- **이익 vs 수익 어휘 자가 학습** — 지훈 메타 질문 + 학생 자가 답변: *"이익과 수익을 잘 모르고 사용한 것 같습니다."* + 추가 자가 질문: *"그러면 그냥 승리했을 때는 `승리했을때 수익은 배팅 금액의 0%이다`라고 작성을 해야 하나요??"* — 지훈 자가 인정: *"아니네요 😂 제가 잘못 오해했었네요"*. **상호 학습 = 학생/리뷰어 양방향**. PR #128·#135 와 같은 결의 *학생-리뷰어 양방향 학습*.
+- **`BlackjackGame` 통합 테스트 자가 추가** — 지훈 권고 *"게임의 전체 흐름이 정상적으로 진행되는지 통합 테스트를 작성하는 것이 좋습니다."* 후속 반영 (커밋 `24ca825`).
+
+## 못한 점 (설계 관점)
+
+### 1. `BlackjackGame.dealerDrawPhase` — *while 안에 print 콜백 + condition 이중 검사*
+
+```kotlin
+private fun dealerDrawPhase(printDealerHandStatus: (Boolean) -> Unit) {
+    val condition = dealer.isMoreCard()
+    if (!condition) {
+        printDealerHandStatus(false)
+    }
+
+    while (dealer.isMoreCard()) {
+        printDealerHandStatus(true)
+        gameManager.drawCard(dealer)
+    }
+}
+```
+
+→ **`isMoreCard()` 호출 + condition 변수 + while 다시 호출**. *condition 사용 한 번 + while 재호출*. *Kotlin 어휘 = `if (dealer.isMoreCard()) { while (...) } else { printDealerHandStatus(false) }` 또는 `while + 첫 iteration 출력 분리`*. *변수 1회 사용 + while 동일 메서드 호출* 가 *함수 호출 중복*.
+
+또한 `dealer.score < DEALER_MORE_CARD_MINIMUM (17)` 조건이 *17 미만이면 hit* — 정확. 다만 *Bust 도달 시 dealer.score = > 21* 도 *17 미만 아니므로 while 종료* — 정합.
+
+### 2. `Player.getInitialCard(): List<Card> = cards` — *Player 전체 카드 노출*
+
+```kotlin
+class Player(...) : Participant(name) {
+    override fun getInitialCard(): List<Card> = cards  // ⚠ 전체 카드
+}
+
+class Dealer(...) : Participant(name) {
+    override fun getInitialCard(): List<Card> = listOf(cards.first())  // 딜러 1장
+}
+```
+
+→ **`Player.getInitialCard` = *전체 cards 반환*** — *블랙잭 공개 룰 = 플레이어 2장 공개, 딜러 1장 공개*. *Player 가 *모든 카드* 반환* = *플레이어 손패 수 무관 모두 공개*. *초기 2장 공개* 의도면 `cards.take(2)`. *현재 cards = 초기 + 추가 hit 모두 포함* → *Player 의 모든 카드 공개*.
+
+학생 의도 = *Player 는 모든 카드 공개* + *Dealer 만 첫 1장*. *블랙잭 룰 정합* (플레이어 손패 전부 공개). 다만 *naming `getInitialCard` = 초기 카드* 어휘 — *Player 의 경우 전체 카드 반환*은 *naming 부정확*. PR #132 (환노) 의 *Player.getInitCard = cards.take(2)* 와 *다른 트레이드오프*.
+
+### 3. `ResultCalculator object` 정적 헬퍼 — *Tell-Don't-Ask 미달*
+
+```kotlin
+object ResultCalculator {
+    const val BLACKJACK_NUMBER = 21
+    ...
+    fun calculate(cards: List<Card>): Int { ... }
+    fun judgeScore(dealer: Dealer, player: Player): ResultType { ... }
+    private fun judgeState(dealer: Dealer, player: Player): ResultType? { ... }
+    ...
+}
+```
+
+지훈 (ResultCalculator.kt — 미해결): *"여기는 그래도 리뷰를 남겨보면, 블랙잭의 특성상 딜러의 점수를 플레이어가 비교를 해서 승패가 나눠지는데요. 그런 관점에서 봤을 때 `참가자 스스로가 다른 참가자의 점수를 비교해서 본인이 어떠한 상태인지 반환하는 게 객체지향적으로 그렇게 이상한 일일까? 본인의 점수를 이미 알고 있는데?` 이 부분을 고민해 봐도 좋을 것 같네요!"*
+
+→ **`ResultCalculator object` = 정적 헬퍼**. *Player.compareScores(dealer)* 같은 *Player 메시지* 가 *Tell-Don't-Ask 정공*. *PR #132·#136·#152·#108·#133·#49 의 *참가자 자기 비교 메서드** 와 같은 결의 *반대 트레이드오프*. 미플은 *Calculator 응집* 선택. **MCP 룰 후보 — `judge-as-static-helper`** 변형.
+
+### 4. `Participant.score: Int get() = ResultCalculator.calculate(cards)` — *매 호출 재계산*
+
+```kotlin
+val score: Int
+    get() = ResultCalculator.calculate(cards)
+```
+
+→ **`score` getter 가 매 호출 `calculate(cards)` 재계산**. *Hand 변경 안 되면 같은 score* — *캐싱 가능*. *PR #136 (밀러 2단계) 의 *Score.value get() = calculateTotalSum()* 와 같은 결*. *순수 함수면 by lazy 적용 가능 — Participant 의 cards 가 가변 (addCard)* 이라 *by lazy 불가*. *score 계산 비용 작음 + 매 호출 정확성 보장*. 미세 비효율.
+
+### 5. `Player.betAmount: BetAmount` + `Player.getInitialCard()` 책임 모호
+
+```kotlin
+class Player(name: String, val betAmount: BetAmount) : Participant(name) { ... }
+
+class Dealer(name: String = DEALER_NAME) : Participant(name) { ... }
+```
+
+→ **Player 만 betAmount 보유, Dealer 베팅 안 함**. PR #103·#85·#136 와 같은 결의 *Dealer ≠ Player*. **정공**.
+
+### 6. `Player.cards` 가 *외부 변경 불가능* — *방어적 복사 정공*
+
+```kotlin
+private val _cards: MutableList<Card> = mutableListOf()
+val cards get() = _cards.toList()
+```
+
+→ **`_cards.toList()` = immutable view**. *외부 변경 차단*. *PR #58 (수달) 의 _cards.toList* 와 같은 결 + *학생 자가 학습 (Card.copy 강박 회피)* 모범.
+
+### 7. `BlackjackGame.startGame` 의 *4 콜백 인자* — *고차함수 + 책임 분산*
+
+```kotlin
+fun startGame(
+    wantsToDraw: (Player) -> DrawChoice,
+    onEndPlayerTurn: (Player) -> Unit,
+    onEndDealerTurn: (Boolean) -> Unit,
+    printAllHands: () -> Unit,
+) {
+    gameManager.dealInitialCards()
+    printAllHands()
+    if (!dealer.isBlackjack()) {
+        players.forEach { playerDrawPhase(it, wantsToDraw, onEndPlayerTurn) }
+        dealerDrawPhase(onEndDealerTurn)
+    }
+}
+```
+
+→ **4 람다 인자 = 고차함수 패턴**. *Tell-Don't-Ask 정공 + 도메인 자기 진행*. 다만 *4 람다 = 호출자 부담 ↑*. PR #132 (환노 2단계) 의 *고차함수 시도 + 깊이 문제* 와 같은 결.
+
+지훈 진단 (BlackjackGame.kt — 미해결): *"지금은 `BlackjackGame` 이 View의 역할도 하고 있습니다. `println`을 호출하고 있기도 하고 간접적으로나마 print라는 lambda으로 인해서 간접적으로라도 알고 있는 느낌이기도 하죠. lambda 이름들을 이런 형태로 바꿔보면 어떨까요? `onEndDelaerTurn` 이런 형태로 지금 어떠한 행위가 끝났는지를 명시하고 그 행위를 사용하는 곳에서 무엇을 할지를 선택을 하는 것인데요."*
+
+→ **콜백 = 행위 명시 (`onXX`) 패턴**. *`printPlayerHands` (행위)* → *`onEndPlayerTurn` (행위 끝)* 변환. *호출자가 무엇을 할지 결정*. *Inversion of Control* 패턴.
+
+### 8. `BlackjackGame.calculateResults(): List<Profit> = gameManager.gameResult(gameManager.calculateResultMap())` — *Profit 합산 + 나중에 분리*
+
+```kotlin
+fun calculateResults(): List<Profit> = gameManager.gameResult(gameManager.calculateResultMap())
+```
+
+학생 자가 답변 (OutputView 토론): *"profitResults에는 GameManager.gameResult에서 만들어준 playerProfits + dealerProfit순서로 저장된 List<Profit>이 저장되어있습니다. 출력에서 딜러수익을 먼저 출력하고 플레이어들의 수익을 출력해야해서 이렇게 했습니다. 우선 지금의 출력순서를 위해 gameResult()를 dealerProfit + playerProfits 순서로 변경해서 forEach만 써서 돌아가게했습니다만, 수익출력 순서가 또 바뀌면 gameResult에서 리스트 순서를 바꿔줘야할 것 같아서 outputview에서 처리를 하는 것이 좋아보입니다!"*
+
+→ **`List<Profit> = 딜러 + 플레이어들 통합 리스트** — *순서 의존*. *Map<Participant, WinningMoney>* 또는 *별도 BlackjackResult(dealer: Profit, players: List<Profit>)* 객체가 *순서 의존 회피*. PR #132 (환노 2단계) 의 *BlackjackResult* / PR #49 (써니) 의 *ParticipantsProfitResult* 와 같은 결.
+
+### 9. `GameManager.dealInitialCards + dealInitialCardWithCount` — *두 메서드 책임 모호*
+
+```kotlin
+fun dealInitialCards() {
+    deck = Deck()           // ⚠ 매 호출 새 Deck (재할당)
+    dealInitialCardWithCount()
+}
+
+fun dealInitialCardWithCount() {
+    repeat(INITIAL_HAND_OUT_CARD_COUNT) {
+        dealer.addCard(deck.draw())
+        players.forEach { player -> player.addCard(deck.draw()) }
+    }
+}
+```
+
+→ **`dealInitialCards` 가 *Deck 재할당 + dealInitialCardWithCount 호출***. *Deck 재할당이 매 라운드 시작 시 = 새 카드 풀*. *var deck* — 가변. *PR #133 (시아 2단계) 의 BlackjackEngine.cardDeck 직접 생성* 과 같은 결.
+
+또한 두 메서드의 *책임 분리*가 *재할당 + 분배*. *dealInitialCardWithCount* 가 *internal*이지만 *public + Suffix `WithCount`* — *Kotlin 어휘 어색*.
+
+### 10. `BlackjackGame.startGame` 의 *Dealer 블랙잭 조기 종료* — *룰 정확성 신호*
+
+```kotlin
+gameManager.dealInitialCards()
+printAllHands()
+if (!dealer.isBlackjack()) {       // ⚠ 딜러 블랙잭 시 플레이어 턴 + 딜러 턴 모두 skip
+    players.forEach { playerDrawPhase(it, ...) }
+    dealerDrawPhase(...)
+}
+```
+
+→ **딜러 블랙잭 시 모든 진행 skip**. *카지노 룰 = 딜러 블랙잭 시 플레이어 블랙잭 만 무승부, 나머지 패배*. *플레이어 hit 기회 없음* 정확. 다만 *플레이어 자기 블랙잭 vs 딜러 블랙잭 = TIE 처리* 가 *ResultCalculator.judgeState 에서*. *룰 정확성*.
+
+PR #136 (밀러 2단계) 의 *Pair → Hand` 전략* 과 다른 트레이드오프.
+
+### 11. `ResultCalculator.calculate` 의 *`while (countAce-- > 0)` Ace 처리* — *Kotlin 어휘*
+
+```kotlin
+fun calculate(cards: List<Card>): Int {
+    var sumScore = calculateTotalScore(cards)
+    var countAce = countAce(cards)
+    while (countAce-- > 0) {
+        if (sumScore + ADJUST_ACE_NUMBER > BLACKJACK_NUMBER) {
+            break
+        }
+        sumScore += ADJUST_ACE_NUMBER
+    }
+    return sumScore
+}
+```
+
+→ **`countAce-- > 0`** = *Java/C 어휘*. *Kotlin = `repeat(countAce)` 또는 `for (i in 1..countAce)`* 가 *어휘 정공*. 다만 *break 활용 시 repeat 어색* — *while + countdown* 트레이드오프. PR #58·#93·#108 와 같은 결.
+
+또한 *`+= ADJUST_ACE_NUMBER` 안에 break* — *Ace 처리 패턴 정확*. *Ace 1 기본 + 가능한 만큼 +10*. PR #128·#114·#125·#108·#131·#136 와 같은 결의 *Ace 처리*.
+
+### 12. `Player(name, betAmount)` 생성 시점 = *베팅 + 이름* — *카드 미보유*
+
+```kotlin
+class Player(
+    name: String,
+    val betAmount: BetAmount,
+) : Participant(name) { ... }
+```
+
+→ **Player 생성 시점 = 이름 + 베팅 만**. *카드는 GameManager.dealInitialCards 에서 별도 분배*. *lotto empty-object-external-fill 변형* — *Player 생성 후 외부에서 카드 채움*. PR #132·#124·#108 와 같은 결.
+
+다만 *블랙잭 도메인 = 베팅 → 카드 분배 순서* 라 *2 단계 생성* 자연. *학생 PR 본문*: *베팅 + 이름 입력 후 분배*. **PR #103·#85·#88·#136 와 같은 결의 *플레이어 + 베팅 동시 입력 자가 반영***.
+
+### 13. `Profit class` — *data class 아님 = equals/copy 자동 X*
+
+```kotlin
+class Profit(val participant: Participant, val winningMoney: WinningMoney)
+```
+
+→ **`class` (data 아님)** — *equals/hashCode/copy/toString 자동 X*. *동등성 의미 명시 부재*. *데이터 보유 객체 = data class* 가 *Kotlin 어휘 표준*. PR #88 (채드 2단계) 의 *Revenue toString override* 와 같은 결의 *데이터 클래스 vs 일반 class*.
+
+### 14. `GameManager.DEALER_PROFIT_MULTIPLIER = -1.0` — 상수 활용
+
+```kotlin
+companion object {
+    const val INITIAL_HAND_OUT_CARD_COUNT = 2
+    const val DEALER_PROFIT_MULTIPLIER = -1.0
+}
+```
+
+→ **`DEALER_PROFIT_MULTIPLIER = -1.0` companion** — *딜러 수익 = 플레이어 합 × -1* 룰 명시 상수. *룰 명료성 정공*. PR #131·#132·#133·#49 와 같은 결.
+
+### 15. `GameManager.gameResult(result: Map<Player, ResultType>): List<Profit>` — *Profit List 통합 반환*
+
+```kotlin
+fun gameResult(result: Map<Player, ResultType>): List<Profit> {
+    val playerProfits = result.map { (player, resultType) ->
+        Profit(player, calculateProfit(resultType, player))
+    }
+    val dealerProfit = calculateDealerProfit(playerProfits)
+    return listOf(dealerProfit) + playerProfits
+}
+```
+
+→ **`listOf(dealerProfit) + playerProfits`** = *딜러 먼저 + 플레이어들*. *출력 순서 고정*. *호출자가 forEach 만 호출*. 다만 *호출자가 *딜러는 첫 번째* invariant 알아야*. PR #49·#132 의 *별도 dealer + players 객체* 보다 *비대칭*. 트레이드오프.
+
+### 16. `printAllHands: () -> Unit` 인자 없음 — *콜백 인자 부재 = 호출자 책임*
+
+```kotlin
+fun startGame(
+    ...
+    printAllHands: () -> Unit,
+) { ... }
+```
+
+지훈 (BlackjackGame.kt — 미해결, 보조 코멘트): *"그리고 printAllHands 에는 어떤 이유로 Dealer왜 List<Player> 를 넘기고 있는 상황일까요? ... 실제로는 사용이 안 되고 있는 것 같아서 어떤 의도였는지가 이해가 조금 안 되긴 하네요"*
+
+→ **`printAllHands: (Dealer, List<Player>) -> Unit` → `printAllHands: () -> Unit`** 변환 자가 반영. 다만 *호출자가 dealer + players 정보 알아야 출력 가능* — *호출자가 BlackjackGame 외부에서 dealer + players 보유* 가정. *Closure capture* 패턴.
+
+페로로 추가 진단 (구현 일치 안 됨): *"printAllHands 은 반영 안 된 것 같네요 ㅠㅠ.."*. **자가 반영 누락 신호**.
+
+### 17. `ResultType.LOSS` vs `LOSE` 어휘 — *영어 표준 어휘 모호*
+
+```kotlin
+enum class ResultType(val profit: Double) {
+    WIN(1.0), TIE(0.0), LOSS(-1.0), BLACKJACK(1.5),
+}
+```
+
+→ **`LOSS` = *손실 명사* vs `LOSE` = *동사***. *enum 멤버 = 명사형 표준*. *PR #131·#132·#136·#49 의 LOSE/LOSS* 와 *어휘 혼재*. *LOSS 정공* 이지만 *프로젝트 내 일관성*.
+
+### 18. `BetAmount.value: Double` 도입 (확장함수 제거) — 학생 자가 학습 모범
+
+학생 자가 답변 + 자가 의문: *"BetAmount를 Double로 받도록 했는데, 결국 확장함수를 없애니 player.betAmount.amount로 코드길이는 그대로 유지 되는 것 같습니다😅"* + 지훈 자가 답변: *"네 코드 길이는 유지가 되지만 굳이 필요 없던 `toDouble()` 확장 함수는 사라졌으니 유의미하지 않았을까요!.."*
+
+→ **YAGNI + 도메인 타입 직접 Double 자가 학습**. *불필요한 확장함수 = 인지 비용*. *value class Double 직접* 이 *간결*. 학습 모범.
+
+### 19. `Profit / WinningMoney / BetAmount` 세 도메인 객체 — *과도한 분리?*
+
+→ **3 value class = Profit (참가자 + 수익), WinningMoney (수익 금액), BetAmount (베팅 금액)**. *PR #49 (써니) 의 Profit + Money + EarningRate* 와 *비슷한 분리*. *책임 명료 + 인지 비용 트레이드오프*. *지훈 권고 = 원시값 최대한 포장* 후속 반영.
+
+### 20. `Dealer.isMoreCard()` naming — *Boolean 메서드 = is/has 어휘 정합*
+
+```kotlin
+fun isMoreCard() = score < DEALER_MORE_CARD_MINIMUM
+```
+
+→ **`isMoreCard()`** = *더 카드 받을 수 있는가*. *is + 명사* 형식 — *Kotlin Boolean 표준*. 다만 *`canDraw()` / `needsMore()` 가 더 명료*. PR #131·#132·#152·#136 의 *canDraw / canHit* 와 *비슷한 결*.
+
+### 21. `BetAmount value > 0` invariant — 정공
+
+```kotlin
+@JvmInline
+value class BetAmount(val value: Double) {
+    init {
+        require(value > 0) { ERROR_BET_AMOUNT_VALUE }
+    }
+    ...
+}
+```
+
+→ **`value > 0` 강제** — *베팅 = 최소 1원 (Double)*. *PR #131·#132 의 MIN = 0 허용* 와 *반대 트레이드오프*. *베팅 = 1원 이상 = 도메인 정합*. PR #136 (밀러) 의 *bettingAmount > 0* 와 같은 결.
+
+## 리뷰어 의견 요지
+
+- **원시값 최대한 포장** — *Double 의미 모름*. *WinningMoney / BetAmount / Profit value class 분리*.
+- **`ResultType enum + profit: Double` = 게임 결과가 이익률 알 수 있음** — *상수 응집*.
+- **`Map<X, X>` 회피 — Profit class 응집** — PR #132 와 같은 결.
+- **`it.copy()` 방어적 복사 = 불변 객체엔 복사 비용만 추가** — 학생 자가 학습 모범.
+- **`println` 도메인 X = View 책임** — *간접 lambda 도 View 결합*.
+- **콜백 = `onXX` 행위 명시** — *Inversion of Control + 의도 명료*.
+- **`when` 절 = if 다중 분기 가독성 ↑** — *Kotlin 패턴 매칭*.
+- **테스트 명세 = 도메인 룰 정확** — *플레이어 24 / 딜러 19 → WIN?* 함정.
+- **BlackjackGame 통합 테스트 = 흐름 검증** — *각 객체 단위 테스트 + 통합 흐름*.
+- **이익 vs 수익 어휘 혼란 → 학생/리뷰어 양방향 학습** — *지훈도 자가 인정*.
+- **확장함수 vs Double 직접 = YAGNI** — *불필요한 확장함수 제거*.
+- **`value class.value` 명명 = 어색하지 않은 표현** — *value 표준 어휘*.
+- **`Builder` 필수값 = 진입 함수 인자** — *Builder의 본질 = 선택적 속성*. *필수 = 인자 우선*.
+
+## 대표 인용
+
+**지훈 (원시값 포장, GameManager.kt):**
+> 저희는 원시값을 가능한 다 포장을 해보는 연습을 해보기로 했습니다.
+> 모르는 사람이 봤을 때 이 Double이 무엇을 의미하는지 알기가 어렵기도 하죠
+
+**지훈 (Tell-Don't-Ask, ResultCalculator.kt):**
+> 여기는 그래도 리뷰를 남겨보면, 블랙잭의 특성상 딜러의 점수를 플레이어가 비교를 해서 승패가 나눠지는데요. 그런 관점에서 봤을 때
+>
+> ```
+> 참가자 스스로가 다른 참가자의 점수를 비교해서 본인이 어떠한 상태인지 반환하는 게
+> 객체지향적으로 그렇게 이상한 일일까? 본인의 점수를 이미 알고 있는데?
+> ```
+>
+> 이 부분을 고민해 봐도 좋을 것 같네요!
+
+**지훈 (`onXX` 콜백 어휘, BlackjackGame.kt):**
+> 지금은 `BlackjackGame` 이 View의 역할도 하고 있습니다. `println`을 호출하고 있기도 하고 간접적으로나마 print라는 lambda으로 인해서 간접적으로라도 알고 있는 느낌이기도 하죠.
+>
+> lambda 이름들을 이런 형태로 바꿔보면 어떨까요?
+>
+> `onEndDelaerTurn` 이런 형태로 지금 어떠한 행위가 끝났는지를 명시하고 그 행위를 사용하는 곳에서 무엇을 할지를 선택을 하는 것인데요. 이런 형태가 된다면 더 좋았을 것 같네요.
+
+**지훈 (enum 부가속성, ResultType.kt):**
+> 음 ResultType의 동반 객체로 들어가게 되었군요.
+>
+> 그런데
+>
+> ```
+> 게임 결과에 따른 이익률을 게임 결과가 알고 있어도 되지 않을까?
+> ```
+>
+> 즉 그렇게 된다면 아래와 같이 구현이 됐을 것 같아요.
+>
+> ```kotlin
+> enum class ResultType(val profit: Double) {
+>     WIN(1.0),
+>     TIE(0.0),
+>     LOSS(-1.0),
+>     BLACKJACK(1.5) ;
+> }
+> ```
+>
+> 그렇게 되면 `calucateProfit` 함수도 조금 더 간결하게 표현이 됐을 것 같네요!
+
+**지훈 (when 절 변환, ResultCalculator.kt):**
+> 하나의 함수에서 많은 if문이 열리게 될 경우 가독성이 떨어지게 됩니다.
+> ...
+> 이렇게 한 번 바꿔볼까요?
+
+**지훈 (테스트 명세 정확, ResultCalculatorTest.kt):**
+> 단순히 `딜러의 점수보다 크면 이긴다`라는 조건은 아닐 것 같아요!
+>
+> 이 테스트 함수명만 봤을 때는 아래와 같은 조건에서도 이긴다는 것 같아요
+>
+> ```
+> 플레이어 : 24
+> 딜러 : 19
+> ```
+
+**지훈 (마음에 안 드는 이유 명시 권고, GameManager.kt):**
+> 마음에 안 드는 이유를 이야기를 해줬으면 좋겠어요!
+>
+> 단순히 마음에 안 들어서 어떻게 바꾸는 게 좋을까요? 라고 하면 어떤 부분을 인지했는지 제가 모르니 제 의견을 전부 말하는 수밖에 없다 보니 미플이 의견을 남겨주면 좋을 것 같네요.
+
+**지훈 (BetAmount value=Double 트레이드오프, GameManager.kt):**
+> 이 부분은 한 번 고민만 해보고 넘어가도 됩니다.
+>
+> `로또` 미션 때를 떠올려보면 LottoNumber들을 갖고 있는 객체를 아래와 같이 만들었을 거예요
+>
+> ```kotlin
+> data class LottoGame(val lottoNumber: List<LottoNumber>)
+> ```
+>
+> ```
+> 그러면 BetAmount 자체가 Int가 아닌 Double을 받는다고 생각했을 때 어색할까요?
+> ```
+
+**학생 자가 학습 (it.copy 방어적 복사 자가 인식, Participant.kt):**
+> `_cards.toList`와 `val cards: List<Card> get() = _cards.map { it.copy() }.toList()` 여러 테스트를 해보면서도 무슨 차이지..하고 차이를 못 느꼈지만 수업시간에 이런식으로 방어적 복사를 했다는 걸 배워서 그때 이걸 사용하라고 의도하신 것 같아서 사용했습니다.
+>
+> 좀 더 공부해보니 cards안에 있는 내부 객체 Card가 변하게 될 때 두 코드의 차이가 있는 것 같습니다.
+>
+> 현재는 Card의 shape, Number 둘다 val이어서 변할 일이 없기때문에, it.copy()를 하면 괜히 복사비용만 추가된다 생각해 _cards.toList()로 바꿨습니다
+
+**학생 자가 학습 (enum class 학습 의지, ResultType.kt):**
+> 와..😲 enum class에 대해 좀 더 공부해보겠습니다!
+
+**학생 자가 학습 (이익 vs 수익 어휘, GameManagerTest.kt:41):**
+> 이익과 수익을 잘 모르고 사용한 것 같습니다.
+> ...
+> + 그러면 그냥 승리했을 때는 `승리했을때 수익은 배팅 금액의 0%이다`라고 작성을 해야 하나요??
+
+**지훈 자가 인정 (어휘 혼란):**
+> 아니네요 😂 제가 잘못 오해했었네요
+>
+> 기존 150%와 100%(승리)가 맞는 말이었습니다!..
+>
+> 블랙잭은 1.5배니 150%가 맞았습니다!..
+>
+> > 최근에 주식을 공부하면서 이것저것 공부하다가 순간 저도 헷갈려서 잘못 말을 해버렸네요 🫠
+
+## 얻은 교훈
+
+1. ***원시값 최대한 포장 = Double 의미 모름***. *WinningMoney / BetAmount / Profit value class 분리* = *호출자가 *Double 이 무엇인지* 알 수 있음*. PR #131·#132·#136·#90·#49 와 같은 결.
+
+2. ***`ResultType enum + profit: Double` = 게임 결과가 이익률 응집***. *상수 = enum 멤버 부가속성*. *룰 변경 시 enum 한 곳 수정*. PR #132 (환노) 의 *GameResult earningRate* 와 같은 결.
+
+3. ***Tell-Don't-Ask = "본인의 점수를 이미 알고 있는데?" 메시지 정공***. *ResultCalculator object* 정적 헬퍼 → *Player.compareScores(dealer) 메시지* 가 정공. PR #132·#136·#152·#108·#133·#49 와 같은 결.
+
+4. ***`it.copy()` 방어적 복사 = 불변 객체엔 복사 비용만 추가***. *Card 불변 (val rank + val shape)* 이면 *`_cards.toList()` 만으로 충분*. *PR #124 (모찌 1단계) 의 Card.copy 강박* 진단 + *학생 자가 학습 모범*. **MCP 룰 후보 — `defensive-copy-on-immutable`** 변형.
+
+5. ***`onXX` 콜백 어휘 = Inversion of Control***. *람다 이름 = 행위 끝 알림*. *호출자가 무엇을 할지 결정*. *PR #132 (환노) 의 고차함수* 와 같은 결.
+
+6. ***`println` 도메인 X = View 책임***. *간접 lambda 도 도메인 → View 결합*. *println 명시적 사용 + 람다 인자 = 도메인이 print 의도 인지*. PR #58·#88·#132 와 같은 결.
+
+7. ***`when` 절 = if 다중 분기 가독성 ↑***. *Kotlin 패턴 매칭* + *exhaustive 검사 (enum)*. *if 4-5 단계 분기 → when 한 줄씩* 변환 정공.
+
+8. ***테스트 명세 = 도메인 룰 정확***. *`딜러 점수보다 크면 WIN`* 은 *Bust 케이스 미반영*. *`플레이어 24 / 딜러 19 → 잘못 WIN`*. *명세 구체화*. PR #93·#90·#136·#88 와 같은 결.
+
+9. ***학생 "마음에 안 드는 이유" 명시 = 학습 가시화 정공***. *지훈 권고 = 자기 의도 명시 → 리뷰 효율*. *학생/리뷰어 양방향 학습*. PR #128·#135·#108·#133·#136 와 같은 결의 *학생 자가 토론 풍부 패턴*.
+
+10. ***이익 vs 수익 어휘 혼란 = 학생/리뷰어 양방향 학습***. *지훈도 잘못 이해 → 자가 인정*. *상호 학습 + 인간적 모범*. *학생 의문 → reviewer 자가 검증 → 양방향 합의* 흐름.
+
+11. ***`BetAmount.value: Double` 직접 vs `toDouble()` 확장함수 = YAGNI***. *불필요한 확장함수 = 인지 비용*. *value class 의 도메인 타입 직접 사용* 정공. *학생 자가 학습 모범*.
+
+12. ***`value class` 멤버 명 = `value` 표준***. *지훈 권고*. *`BetAmount(value = 10.0); amount.value` vs `BetAmount(amount = 10.0); amount.amount` 의 어색함*. *Kotlin value class 표준 어휘*.
+
+13. ***Builder 필수값 = 진입 함수 인자***. *지훈 권고 = `Builder(name = name).build()`*. *Builder 의 본질 = 선택적 속성*. *필수 = 인자 우선*. PR #124·#128·#135 의 *DSL Builder 필수 속성 미강제* 와 같은 결.
+
+14. ***`Profit class` vs `data class` 트레이드오프***. *동등성 의미 명시* 시 *data class*. *데이터 보유 + equals/copy 자동* 표준. *non-data class = 명시적 의도 부재 신호*. PR #88·#136 와 같은 결.
+
+15. ***딜러 블랙잭 시 모든 진행 skip = 블랙잭 룰 정확성***. *플레이어 hit 기회 없음 + ResultCalculator 의 TIE/LOSS 분기 처리*. PR #136·#132·#108·#133 와 같은 결의 *블랙잭 룰 정확성*.
+
+16. ***학생 자가 답변에 커밋 SHA 첨부 일관성 (`a357234`, `b4763a1`, `e2840307`, `8a673e0`, `9f12c19`, `13cf13a`, `2eac33b`, `a0b52af`, `f1a40f9`, `0b30903` 등 다수) = 학습 가시화 모범***. PR #128·#135·#108·#133·#136·#124·#152 와 같은 결.
+
+17. ***`Player.getInitialCard() = cards` vs `Dealer.getInitialCard() = cards.first()` 비대칭 = 도메인 룰 표현***. *블랙잭 공개 룰 = 플레이어 모든 카드 공개, 딜러 1장*. *Player.getInitialCard naming 이 *초기* 가 아닌 *공개 카드* 의미* — *naming `getOpenedCards()` 가 명료*.
+
+18. ***Player(name, betAmount) + 카드 미보유 = lotto empty-object-external-fill 변형***. *생성 후 GameManager.dealInitialCards 에서 외부 채움*. PR #132·#124·#108 와 같은 결.
+
+19. ***신규 reviewer 지훈 = 깊은 메타 질문 + 자가 인정 + 학생 자가 토론 풍부 유도***. *PR #131·#136·#88 (두루)* / *PR #41·#53 (잭슨)* / *PR #93·#108·#133 (말리빈)* / *PR #124·#85·#103·#58·#49·#152 (페로로)* 외 **새 reviewer 스타일 분석** = *프로젝트 reviewer 다양성 명시*.
+
+20. ***BlackjackGame 통합 테스트 = 흐름 검증***. *각 객체 단위 테스트 + 통합 흐름 별도*. *지훈 예시 코드 + 학생 후속 반영* 모범.