[스위프트(Swift) 프로그래밍] - Generic(제네릭)

🎯 제네릭(Generic) in Swift

🧑🏻‍💻 What - 제네릭이란?

• Swift는 어떤 변수나 상수, 혹은 함수(메소드)의 파라미터 등을 구현할 때 타입을 지정합니다. 타입을 명시함으로써 컴파일러에게 해당 값의 타입을 명확히 설명해주고, 코드를 읽는 개발자들의 입장에서 해당 값의 특성을 더 잘 이해할 수 있도록 도와줍니다. 물론 타입 추론 기능을 통해 타입 명시를 생략해줄 수 있지만 특정 타입이 확정되어야 하는 것은 마찬가지입니다.

  이런 상황에서 로직은 완전히 같은데 입력값의 타입만 다른 경우 어떻게 되어야 할까요? 일반적으로 오버로딩(over loading)으로 함수를 타입들에 맞게 정의할 수 있지만 그것 역시 무의미한 코드의 반복이 됩니다.

  Swift는 이러한 문제를 해결할 수 있는 Generic이라는 기능을 가지고 있습니다. 특정 타입을 미리 지정하는 것이 아니라 사용할 때 필요한 타입을 선언해주는 형태로 타입을 일반화 하여 선언한다고 할 수 있습니다.

  예시를 통해 살펴보겠습니다!

📚 Why - 제네릭이 필요한 이유

• 우선 두 Int값을 교환하는 메소드를 선언해보겠습니다.

  
  

  func swapTwoInts(_ a: inout Int, _ b: inout Int) {
      let temporaryA = a
      a = b
      b = temporaryA
  }

  
  

  inout이 이해가 어려우신 분들은 쉽게 생각해서 두 입력 파라미터 a, b를 교환해주는 메소드라고 생각하시면 됩니다!

  이 메소드를 잘 사용하고 있었는데 Int가 아닌 String을 교환해야할 메소드가 필요하면 어떻게 해야할까요?

  아래와 같이 함수를 또 정의합니다.

  
  

  func swapTwoStrings(_ a: inout String, _ b: inout String) {
      let temporaryA = a
      a = b
      b = temporaryA
  }

  
  

  로직이 완전히 같지만 파라미터를 위해 새로운 함수를 정의했습니다. 문제가 해결됬으니 또 코드를 작성하다가 이번에는 Double형의 교환이 필요합니다. 그럼 당연히 또 정의를 해야겠죠?

  
  

  func swapTwoDoubles(_ a: inout Double, _ b: inout Double) {
      let temporaryA = a
      a = b
      b = temporaryA
  }

  
  

  정상 작동 여부를 떠나서 이런 식의 구현은 무의미한 코드의 반복을 불러옵니다. N개의 타입을 사용한다면 같은 메소드를 N개 만들어야 하는 불편함이 있는 것이죠!

🛠 How - Generic 사용법

• 그럼 위의 예시를 한번에 선언할 방법을 살펴보겠습니다! 아래와 같이 메소드를 정의해줍니다.

  
  

  func swapTwoValues<T>(_ a: inout T, _ b: inout T) {
      let temporaryA = a
      a = b
      b = temporaryA
  }

  
  

  기존에 Int, String 등으로 선언되어 있었던 타입에 T라는 일반화된 타입을 넣어주고, 대신에 메소드 이름 옆에 <T>라는 마킹을 해주었습니다. T에 무엇이 들어가냐에 따라 위의 함수는 T로 표기된 타입에 사용하고 싶은 타입을 일괄적으로 선언해주는 것이죠!

  이제 위에 정의된 메소드로 값을 변경해보겠습니다.

  
  

  var someInt = 3
  var anotherInt = 107
  swapTwoValues(&someInt, &anotherInt)
  // someInt is now 107, and anotherInt is now 3
  
  var someString = "hello"
  var anotherString = "world"
  swapTwoValues(&someString, &anotherString)
  // someString is now "world", and anotherString is now "hello"

  
  

  특별히 타입을 명시할 필요 없이 입력된 값의 타입을 통해 자동적으로 T 에 각각 Int , String 을 할당하여 사용했습니다.

  이렇게 보면 낯설 수 있지만 사실 그동안 우리는 Generic 기능을 많이 사용하고 있었습니다.

  대표적인 것이 Array, Dictionary 입니다. 배열을 정의할 때 타입을 지정해서 어떤 타입의 배열인지 명시했었는데 이 개념이 바로 Generic입니다. 배열을 사용하는 예시로 Stack 구현을 살펴보겠습니다.

  
  

  struct Stack<Element>: Container {
      // original Stack<Element> implementation
      var items: [Element] = []
      mutating func push(_ item: Element) {
          items.append(item)
      }
      mutating func pop() -> Element {
          return items.removeLast()
      }
      // conformance to the Container protocol
      mutating func append(_ item: Element) {
          self.push(item)
      }
      var count: Int {
          return items.count
      }
      subscript(i: Int) -> Element {
          return items[i]
      }
  }

  
  

  위의 Stack의 경우 자료구조의 하나로 타입이 특정되면 안됩니다. 다시 말하면 Int 만 되는 스택은 효율성이 떨어지겠죠? 그래서 위와 같이 Generic으로 선언하여 사용합니다.

🧗 One more step - 한걸음 더

• Generic이 만능인 것 같지만 사실 생각해보면 큰 오류의 가능성을 내포하고 있기도 합니다.

  
  

  func newMultiply<T>(param1: T, param2: T) -> T {
      return param1 * param2 * 2
  }

  
  

  위의 메소드는 입력 받은 parameter를 곱하는 연산이 있기 때문에 당연히 곱하기 연산이 가능한 타입이 들어와야합니다. Int, Double, Float 등의 타입이 있을 수 있습니다. 이런 다양한 타입을 위해 Generic으로 선언이 된 것인데요, 만약에 이 Generic에 String이 들어오면 어떻게 될까요? 연산 자체가 성립하지 않게 됩니다.

  그래서 XCode는 위의 정의가 부정확하다는 메세지를 줍니다. 충분한 정보가 없다는 것이죠. 이럴 때 필요한 것이 제네릭한 타입을 구체화 해주는 것입니다.

  
  

  func newMultiply<T: BinaryInteger>(param1: T, param2: T) -> T {
      return param1 * param2 * 2
  }

  
  

  위와 같이 Generic 타입인 T를 단순히 선언해주는 것이 아니라 BinaryInteger 프로토콜을 따르게 해주면 오류가 해결됩니다. 이렇게 타입에 제약을 주는 것을 타입 제약(Type Constaints) 이라고 하며 이러한 제약은 클래스 타입 또는 프로토콜로만 설정 가능합니다. 특정 클래스를 상속받는 타입이어야하거나 특정 프로토콜을 채택한 타입이어야한다는 제약을 설정하는 것입니다.

  
  

• 제네릭 타입은 한개가 아니라 여러개 설정될 수 있습니다.

  func someMethod<T, U, V> (param1: T, param2: U, param3: V) { ... }

  처럼 쉼표(,)를 통해 여러개 선언할 수 있습니다.

Reference: https://docs.swift.org/swift-book/LanguageGuide/Generics.html