Dart 튜토리얼 8편: 상속·구성·확장(Mixins·Enums·Extension methods·Extension types)

Why#

NOTE

상속은 공통 동작을 재사용하기 좋지만, 계층이 깊어지면 구조 변경이 어려워집니다.
그래서 “타입 계층은 유지하면서 기능만 덧붙이는 방식”이 필요합니다.

1
class A {
2
  void log() => print('log');
3
}
4

5
class B {
6
  void log() => print('log'); // 중복
7
}

What#

NOTE

mixin은 여러 클래스에서 재사용할 멤버 묶음을 정의하는 방법입니다.
with¹¹를 사용해 클래스에 mixin을 적용합니다.
또한 on로 “어떤 타입에만 붙일 수 있는지”를 제한할 수 있습니다.

How#

TIP

mixin은 여러 클래스에서 재사용할 멤버 묶음을 정의하는 방법입니다.
with를 사용해 클래스에 mixin을 적용합니다.
또한 on로 “어떤 타입에만 붙일 수 있는지”를 제한할 수 있습니다.

1
mixin Musical {
2
  bool canPlayPiano = false;
3
  bool canCompose = false;
4
  bool canConduct = false;
5

6
  void entertainMe() {
7
    if (canPlayPiano) {
8
      print('Playing piano');
9
    } else if (canConduct) {
10
      print('Waving hands');
11
    } else {
12
      print('Humming to self');
13
    }
14
  }
15
}
16

17
class Musician with Musical {}

mixin은 상속이 아니기 때문에, “기능을 덧붙인다”는 느낌에 가깝습니다.
하지만 아무 클래스에나 붙이면 규칙이 흐려질 수 있습니다.
그래서 on로 제약을 걸어, 필요한 필드나 메서드가 있는 타입에만 섞도록 범위를 좁힙니다.

1
class Performer {
2
  void perform() => print('Performing');
3
}
4

5
mixin PerformerDuty on Performer {
6
  void callTime() => perform();
7
}
8

9
class Singer extends Performer with PerformerDuty {}

Watch out#

WARNING

mixin은 상속이 아니기 때문에, “기능을 덧붙인다”는 느낌에 가깝습니다.
하지만 아무 클래스에나 붙이면 규칙이 흐려질 수 있습니다.
그래서 on로 제약을 걸어, 필요한 필드나 메서드가 있는 타입에만 섞도록 범위를 좁힙니다.

결론: 공통 기능을 분리해 재사용하면서도, 적용 대상은 on로 제한해 설계를 흔들리지 않게 할 수 있습니다.

Why#

NOTE

상태를 문자열로 다루면 오타/누락이 생기기 쉽습니다.
그래서 가능한 값의 집합을 타입으로 고정하는 편이 안전합니다.

1
const status = 'approved';
2
// if (status == 'aproved') {} // 오타가 나도 컴파일 단계에서 잡히지 않는다.

What#

NOTE

enum은 가능한 값의 집합을 선언하는 방식입니다.
switch로 분기할 때 enum을 쓰면 가독성이 좋아집니다.
또한 각 열거 값에는 name 속성이 있어 문자열 이름을 얻을 수 있습니다.

How#

TIP

1
enum Color { red, green, blue }
2

3
void main() {
4
  final aColor = Color.blue;
5

6
  switch (aColor) {
7
    case Color.red:
8
      print('Red as roses!');
9
    case Color.green:
10
      print('Green as grass!');
11
    default:
12
      print(aColor);
13
  }
14

15
print(Color.blue.name);
16
}

Watch out#

WARNING

enum은 단순한 값 목록만이 아니라, 멤버를 가질 수 있는 타입이기도 합니다.
즉, 값의 집합을 선언하면서 해당 값에 대한 계산도 한 곳에 둘 수 있습니다.

결론: 문자열 비교 대신 타입으로 상태를 다루고, switch로 분기를 정리해 실수를 줄일 수 있습니다.

Why#

NOTE

기존 타입을 직접 수정할 수 없거나, 수정하고 싶지 않은 상황이 많습니다.
그래서 “타입은 그대로 두고, 필요한 멤버만 추가하는 방식”이 필요합니다.

1
// String에 parseInt 같은 메서드가 있으면 편하지만, String을 직접 수정할 수는 없다.

What#

NOTE

extension method는 기존 타입을 수정하지 않고 새 멤버를 추가하는 방법입니다.
확장 선언에서 on¹²으로 대상 타입을 지정합니다.
그리고 확장 안에서 getter¹³, operator¹⁴, 일반 메서드를 모두 정의할 수 있다고 보여줍니다.

How#

TIP

1
extension NumberParsing on String {
2
  int parseInt() => int.parse(this);
3
}
4

5
void main() {
6
  print('42'.parseInt());
7
}

제네릭을 함께 쓰면, 호출한 쪽의 정적 타입에 따라 타입 매개변수가 묶입니다.

1
extension MyFancyList<T> on List<T> {
2
  int get doubleLength => length * 2;
3
  List<T> operator -() => reversed.toList();
4
  List<List<T>> split(int at) => [sublist(0, at), sublist(at)];
5
}

Watch out#

WARNING

extension method는 “해당 이름의 멤버가 없을 때” 주로 효과가 드러납니다.
기존 타입에 같은 이름의 멤버가 이미 있다면, 어느 쪽이 선택되는지(우선순위)가 코드 맥락에 따라 달라질 수 있습니다.

결론: 기존 타입을 감싸는 래퍼 클래스를 만들지 않고도, 프로젝트에 필요한 편의 API를 추가할 수 있습니다.

Why#

NOTE

값의 “의미”는 다르지만, 내부 표현은 같은 경우가 있습니다.
예를 들어 int로 관리하되 “이 값은 그냥 숫자가 아니라 특정 규칙을 가진 값”이라고 표현하고 싶을 수 있습니다.

1
// 같은 int라도 의미가 다른 값이 섞이면 실수가 생길 수 있다.
2
int userId = 1;
3
int productId = 2;

What#

NOTE

extension type는 기존 값을 기반으로 “새 타입처럼” 보이게 만드는 선언입니다.
핵심 메시지는 두 가지입니다.
첫째, extension type은 compile time¹⁵에 의미가 있지만, 컴파일 과정에서 erasure¹⁶될 수 있습니다.
둘째, extension type은 run time¹⁷에 별도의 wrapper object¹⁸를 만들지 않을 “선택지”를 제공한다고 설명합니다.
일반 wrapper class¹⁹가 더 안전할 수 있지만, extension type은 wrapper object를 피할 수 있어 일부 상황에서 성능에 이점이 있을 수 있습니다.

입문자 관점에서는 이렇게 이해하면 됩니다.
extension type은 “새 객체를 하나 더 만드는 것”이 아니라, “이 값은 이런 규칙으로만 쓰겠다”를 타입으로 표현하는 도구입니다.
그래서 representation type과 “어떤 멤버가 보이는지” 규칙을 먼저 잡아야 합니다.

How#

TIP

아래는 “가장 작은 형태 → 멤버 노출 규칙 → 생성자/검증 오해 포인트” 순서로 따라가는 구성입니다.

4-1) 가장 작은 형태: representation type부터 정하기#

extension type E(int i)처럼, 괄호 안에 representation type을 둡니다.

1
extension type E(int i) {
2
  // 허용할 연산(멤버) 집합을 정의한다.
3
}

이때 중요한 점은, extension type에서 “보이게 할 멤버”를 내가 선택한다는 것입니다.
즉, representation type이 가진 멤버가 자동으로 전부 노출되는 방식이 아닙니다.

4-2) “정의한 멤버만” 쓸 수 있다: NumberE 예시로 감 잡기#

int를 기반으로 NumberE를 만들고, operator·getter·메서드를 직접 정의할 수 있습니다.

1
extension type NumberE(int value) {
2
  // 연산자:
3
  NumberE operator +(NumberE other) => NumberE(value + other.value);
4

5
  // getter:
6
  NumberE get next => NumberE(value + 1);
7

8
  // 메서드:
9
  bool isValid() => !value.isNegative;
10
}

아래처럼, “extension type의 정적 타입(static type²⁰)“에서 무엇이 가능한지/불가능한지를 확인할 수 있습니다.

1
void testE() {
2
  var num1 = NumberE(1);
3
  int num2 = NumberE(2); // 오류: 'NumberE'를 'int'에 할당할 수 없다.
4

5
  num1.isValid(); // 가능: extension type이 정의한 멤버 호출.
6
  num1.isNegative(); // 오류: 'NumberE'는 'int'의 'isNegative' 멤버를 정의하지 않는다.
7

8
  var sum1 = num1 + num1; // 가능: 'NumberE'가 '+'를 정의한다.
9
  var diff1 = num1 - num1; // 오류: 'NumberE'는 'int'의 '-' 멤버를 정의하지 않는다.
10
  var diff2 = num1.value - 2; // 가능: representation type의 값(value)에 참조로 접근할 수 있다.
11
  var sum2 = num1 + 2; // 오류: 매개변수 타입 'NumberE'에 'int'를 넣을 수 없다.
12

13
  List<NumberE> numbers = [
14
    NumberE(1),
15
    num1.next, // 가능: 'next' getter는 'NumberE'를 반환한다.
16
    1, // 오류: 'int' 요소를 'NumberE' 리스트에 넣을 수 없다.
17
  ];
18
}

이 예시는 Step 4의 목표(“새 타입처럼 보이게”)를 가장 직관적으로 보여줍니다.
int를 그대로 쓰면 가능한 연산이 너무 많습니다.
반면 NumberE처럼 만들면, 타입이 허용하지 않는 사용은 컴파일 단계에서 막힙니다.

4-3) 타입만 바뀌었다고 생성자가 자동 실행되지는 않는다#

static type의 변화가 곧 생성자 호출을 의미하는 것은 아닙니다.
검증 같은 작업을 “생성자에서 반드시” 수행하고 싶다면, NumberE(i)처럼 명시적으로 생성자를 호출해야 한다고 안내합니다.

아래는 int를 representation type으로 삼아 “ID처럼 써야 하는 값”에 허용할 연산만 남기는 패턴입니다.
operator를 필요한 만큼만 노출해, 잘못된 연산을 컴파일 단계에서 막을 수 있습니다.

1
extension type IdNumber(int id) {
2
  // 'int' 타입의 '<' 연산자를 감싼다.
3
  operator <(IdNumber other) => id < other.id;
4
  // 예를 들어 '+' 연산자는 선언하지 않는다.
5
  // ID에는 더하기가 의미 없기 때문이다.
6
}
7

8
void main() {
9
  // extension type로 규칙을 강제하지 않으면,
10
  // 'int'는 ID를 위험한 연산에 노출한다.
11
  int myUnsafeId = 42424242;
12
  myUnsafeId = myUnsafeId + 10; // 동작하지만, ID에는 허용되면 안 되는 연산이다.
13

14
  var safeId = IdNumber(42424242);
15
  safeId + 10; // 컴파일 오류: '+' 연산자가 없다.
16
  myUnsafeId = safeId; // 컴파일 오류: 타입이 맞지 않는다.
17
  myUnsafeId = safeId as int; // 가능: representation type으로 런타임 캐스팅.
18
  safeId < IdNumber(42424241); // 가능: 감싼 '<' 연산자를 사용한다.
19
}

Watch out#

WARNING

extension type은 compile time에 의미가 있지만, erasure될 수 있습니다.
즉, 실행 중에는 “별도 객체로 감싼 타입”처럼 동작한다고 기대하면 오해가 생길 수 있습니다.

또한 static type이 바뀐다고 해서 생성자가 자동으로 실행되는 것이 아닙니다.
검증/정규화가 필요하다면, 생성자 호출을 코드에서 명시해야 합니다.

1
extension type IdNumber(int id) {}
2

3
void main() {
4
  final id = IdNumber(1);
5
  // 여기에서 별도 검증 로직이 자동으로 실행되지는 않는다.
6
}

결론: 코드에서는 새 타입처럼 다루면서도, wrapper object를 만들지 않는 선택지로 일부 상황에서는 비용을 줄일 수 있습니다.