Generic에 대해 설명하시오.

[Do-hyun-Kim]

Generic에 대해 설명하시오.

• Generic 이란 Type에 유연하게 대처 할 수 있으며 범용적인 코드를 구현 할 수 있다.

• Generic을 사용하면 구현한 기능과 타입에 재사용에 용이하도록 구현 할 수 있으며, 코드의 중복을 줄 일 수 있다.

• Swift Standard Library에서는 Array, Dictionary, Set 등에서 사용을 하고 있다.

var numberOne: Double = 5.0
var numberTwo: Double = 10.0

swapToDoubles(&numberOne, &numberTwo)
print("numberOne value : \(numberOne) numberTwo value : \(numberTwo)")

var stringOne: String = "Jenny"
var stringTwo: String = "Hyun"
swapToStrings(&stringOne, &stringTwo)

print("stringOne value : \(stringOne) stringTwo value : \(stringTwo)")

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

swapTwoValues(&numberOne, &numberTwo)
print("genericOne value : \(numberOne) genericTwo value : \(numberTwo)")

Generic Function

Generic Functions

• 제너릭을 사용하고자 하는 메서드 이름 뒤에<T> 홀화살 괄호와 placeholder 제너릭을 위한 타입 매게변수를 써주어 제너릭을 사용할 것임을 명시해준다.

• 제너릭 함수는 실제 타입 Array, Set, String 등 Swift에서 제공되는 타입 대신 placeholder 를 사용한다.

  • ex) T, Element, U, Index

• placeholder 의 실제 타입은 함수가 호출 되는 순간에 결정된다.

• placeholder는 타입 매개변수로 쓰일 수도 있는데, 이 타입 매개변수는 함수를 호출할 때마다 실제 타입으로 치환된다.

• 하나의 타입 매개변수를 갖지 않고 여러 개의 타입 매개변수를 갖고 싶다면 홀화살괄호 기호 안쪽에 쉼표로 분리한 여러 개의 타입 매개변수를 지정해줄 수 있다.

  • ex) <T, U>, <Element, Index>

Generic Type Parameter

• 제너릭 타입의 함수 placeholder 타입은 Type Parameter의 한 예입니다.
• placeholder을 파라미터 타입으로 사용하거나 함수의 리턴 타입, 또는 함수 내에서 타입 annotation으로 사용할 수 있습니다.
• placeholder의 타입은 함수가 호출 될때 실제 타입(Int, Double, String) 등으로 대체 됩니다.

Generic Types

• 제너릭 타입은 class, struct , enum 타입에 선언하여 정의 할 수 있습니다.

• Generic은 함수 외에도 자신만의 제너릭 타입(Generic Types) 를 정의 할 수 있습니다.

  • ex) Array, Dictionary, Set

• 제너릭 타입의 instance 를 생성 할때는 <Type>을 명시하여 인스턴스를 생성합니다.

struct JennyStack<Element> {
    var items: [Element] = []

    mutating func push(_ item: Element) {
        items.append(item)
    }

    mutating func pop() -> Element {
        return items.removeLast()
    }

}

var myStack: JennyStack<Int> = JennyStack()
myStack.push(1)
print("append Item: \(myStack)")
// append Item: JennyStack<Int>(items: [1])

Extending a Generic Type

• Generic Type을 확장할 때, 익스텐션(extension) 의 정의의 일부로 타입 파라미터 리스트를 제공하지 않아도 된다.
• 원본 타입 정의에서 타입 파라미터 리스트를 익스텐션(extension) 의 내부에서 사용할 수 있고, 원본 타입 파라미터의 이름들은 원본 정의에서의 타입 파라미터를 참조하는데 사용됩니다.

extension JennyStack {
    var topItem: Element? {
        return items.isEmpty ? nil : items[items.count - 1]
    }
}

print("myStack Top Item: \(myStack.topItem)")

Generic Type Constraints

• Generic Type Constraints 는 타입 매개변수가 가져야 할 제약 사항을 지정할 수 있는 방법이다.
  • ex) 클래스를 상속 받는 경우, 특정 프로토콜을 준수 해야하는 경우
• Type Constraints는 클래스 타입 또는 프로토콜 타입으로만 제약을 줄 수 있다.
• Generic Type에 제약을 주고 싶으면 타입 매개변수 뒤에 콜론을 붙인 후 원하는 클래스 타입 또는 프로토콜을 명시하면 된다.
• 여러 제약을 추가하고 싶다면 콤마로 구분하는 것이 아닌 where절을 이용한다.

class SomeClass {
    var name: String
    var age: Int

    init(name: String, age: Int) {
        self.name = name
        self.age = age
    }
}

protocol SomeProtocol {
    var name: String { get }
    var age: Int { get }
}

func someFunction<T: SomeClass, U: SomeProtocol>(someT: T, someU: U) {
    // 함수 구현
}

TMI Generics

• Generic Function는 타입에 대한 메타데이터를 넘겨주는 방식이나 구체화(Specialization)과정을 거치며 구현이 이루어집니다.
• 타입에 대한 메타데이터를 넘기는 과정은 각 Generics 원소가 지원하는 함수의 목록을 함수 호출 시에 함께 넘겨주는 방식입니다.
• 연산의 구현이 런타임 시점에 결정되기 때문에 함수 호출(@inline)을 비롯한 컴파일러가 수행하는 다양한 최적화 기법의 혜택을 받을 수 없다는 단점이 있습니다.

TMI Generics Specialization

• Specialization Generics를 이용해 maxInt(_: _: _:), maxDouble(_: _: _:), maxString(_: _: _:)함수를 max(_: _: _:) 함수 하나로 만들 었던 것의 정반대 작업을 컴파일러가 수행하는 것을 말합니다.
• Specialization 를 하면 컴파일 시점에 어떤 타입의 연산을 사용하는지 알 수 있기 때문에 최적화할 여지가 많아 집니다. 하지만 함수를 여러번 복사하고, 복사본이 여러번(@inline) 될 수 있기 때문에 바이너리 사이즈가 커집니다.
• Generic은 Specialization 를 통해 구체적인 타입(int, Double) 등을 가질 수 있으며, Heap 할당 , Reference Counting, Dynamic Method Dispatch 로 인한 성능 저하를 해결 할 수 있습니다.

📝 참고 사이트

• Swift 타입 시스템 탐험기
• 마법 같은 Swift 제네릭 이야기
• Generic에서 Method Dispatch
• Apple Document Site

[Hminchae]

제네릭 (Generics)

• 어떤 타입에도 유연하게 대응할 수 있는 코드를 구현
• 구현한 기능과 타입은 재사용하기 쉽고, 코드의 중복을 줄일 수 있음(추상적 표현)

제네릭 타입:
타입이름<타입 매개변수>

제네릭 메서드/함수:
메서드이름<타입 매개변수> (메서드 매개변수...) {...}

• 제네릭 타입으로 구현한 연결리스트

  
  struct LinkedList<T> {
  private var head: Node<T>?
  
  mutating func append(_ value: T) {
      let newNode = Node(value: value)
      if head == nil {
          head = newNode
          return
      }
  
      var current = head
      while current?.next != nil {
          current = current?.next
      }
      current?.next = newNode
  }
  
  mutating func insert(_ value: T, at index: Int) {
      let newNode = Node(value: value)
      if index == 0 {
          newNode.next = head
          head = newNode
          return
      }
  
      var current = head
      var i = 0
      var previous: Node<T>?
      while current?.next != nil && i < index {
          previous = current
          current = current?.next
          i += 1
      }
      previous?.next = newNode
      newNode.next = current
  }
  
  mutating func remove(at index: Int) -> T? {
      if index == 0 {
          let value = head?.value
          head = head?.next
          return value
      }
  
      var current = head
      var i = 0
      var previous: Node<T>?
      while current?.next != nil && i < index {
          previous = current
          current = current?.next
          i += 1
      }
      previous?.next = current?.next
      return current?.value
  }
  
  func nodeAt(_ index: Int) -> Node<T>? {
      var current = head
      var i = 0
      while current?.next != nil && i < index {
          current = current?.next
          i += 1
      }
      return current
  }

}

[vichye-1]

generic이란?

• 타입에 제한을 두지 않는 코드를 사용하고 싶을 때 사용한다.
• 똑같은 내용의 함수를 오버로딩 할 필요 없이 generic을 사용하여 코드 중복을 피하고 유연하게 코드를 짤 수 있다.
• generic을 이용하여 함수를 짤 수도 있고, 구조체, 클래스, 열거형 타입에서도 사용할 수 있다.

사용법

1. 제네릭 함수 (Generic Function)
   • <>를 이용해서 안에 타입처럼 사용할 이름(T)을 선언해주면, 그 뒤로 해당 이름(T)을 타입처럼 사용할 수 있다.
   • 타입 파라미터 이름을 선언할 때 가독성을 위해 T, V와 같은 단일 문자, 혹은 Upper Camel Case를 사용한다.
   • 타입 파라미터는 여러 개를 선언 할 수 있다 → , 사용
     • 예) func swapTwoValues<One, Two> {...}
   • 실제 함수를 호출할 때 Type Parameter인 T의 타입이 결정된다.

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

var someInt = 1
var anotherInt = 2
swapTwoValues(&someInt, &anotherInt)
print(someInt, anotherInt)
// 2 1

var someString = "Hi"
var anotherString = "Bye"
swapTwoValues(&someString, &anotherString)
print(someString, anotherString)
// Bye Hi

1. 제네릭 타입(Generic Type)
   • 구조체, 클래스, 열거형, 인스턴스 등에도 선언할 수 있다.

// 구조체에 선언한 예 (stack을 generic으로 만듦)
struct Stack<T> {
    let items: [T] = []

    mutating func push(_ item: T) {...}
    mutating func pop() -> T {...}
}

let array1: Array<Int> = .init()
let array2 = Array<Int>.init()
print(array1, array2)
// [] []

참고

• https://docs.swift.org/swift-book/documentation/the-swift-programming-language/generics/
• https://babbab2.tistory.com/136

[ronick-grammer]

Generic이란 (작성중)

• 제너릭이란 타입에 의존하지 않는 범용코드를 작성할 때 사용되는 기술이다.
• 제너릭을 사용하게 되면 중복되는 코드를 피할 수 있고, 코드를 유연하게 작성할 수 있도록 해준다.

• class, struct, enum 어디에도 사용될 수 있다.

struct Stack<T> {
    var items: [T] = []
    mutating func push(_ item: T) {
        items.append(item)
    }
    mutating func pop() -> T {
        return items.removeLast()
    }
}

Generic의 타입 추론

generic 정의 객체를 생성하거나 generic 메서드를 호출할 때 Swift 에서는 생성/호출 직전, generic 타입과 실제 데이터 타입을 바인딩(binding) 하게 된다.

타입 제약

• protocol 제약: 특정 프로토콜을 채택하는 타입만 generic으로 사용될 수 있다.

  struct SomeStruct<T: SomeProtocol> {
  ....
  }

• class 제약: 특정 클래스를 상속하는 클래스 타입만 generic으로 사용될 수 있다.

  struct SomeStruct<T: SomeClass> {
  ....
  }

📝 참고 사이트

• Generics
• Swift) 제네릭(Generic) 정복하기