메타타입: 메타타타입타입의타입타타타입

[leeinae]

Metatype

쏘 심플. 타입의 타입이다.

우리가 쓰는 Int, String, Double 이런 값들은 이미 구현되어있는 struct, class 들을 가져다 쓰는거자나요

모든 언어에는 자료형이 존재하죠.. 이걸 좀 더 풀어서 말해보면 데이터 타입이라는건데

아까 말한 타입의 타입이다 → 데이터 타입의 타입이다 .. 라고 하면 뭔가 더 친절한 늑김

class Type, struct Type, protocol Type을 포함함.

우리가 ClassName.Type ← 이 값들이 바로 클래스나 인스턴스 들의 타입이 되는 값이라는 뜻.

class, struct, enum의 타입의 metatype은 .Type라고 불린다.

protocol의 타입은 .Protocol이 옴.

왜 타입의 타입이라고 말하느냐?

Int ← 이런 걸 타입이라고 부르지 (struct, enum, class .... )

Int.Type == Int의 타입임. 이런 타입값을 가지는 타입들을 메타ㅏ타타타ㅏ타입이라고 부르는 거임 ㅜㅜ!!!!!!!!!!!!!!

Swift에서 Type을 얻는 두 가지 방법

1. .self

   static metatype! 컴파일 타임에 결정되는 object의 타입!

2. type(of:)

   dynamic metatype! 런타임에 결정되는 object의 타입!

   인스턴스를 알고있을 때, 이 인스턴스가 어떤 타입인지 얻을 수 있는 메소드임.

   class SomeBaseClass {
       class func printClassName() {
           print("SomeBaseClass")
       }
   }
   
   class SomeSubClass: SomeBaseClass {
       override class func printClassName() {
           print("SomeSubClass")
       }
   }
   
   // 컴파일 시 someInstance의 타입은 SomeBaseClass
   let someInstance: SomeBaseClass = SomeSubClass()
   // 런타임 시의 타입은 SomeSubClass
   type(of: someInstance).printClassName()

   스위프트 기본 함수인 type(of:) 함수를 통해서 타입의 인스턴스와 함께 호출해 해당 인스턴스의 Dynamic Type (런타임에 동작하는)에 접근할 수 있음.

   여기서 type(of:)로 얻을 수 있는 리턴 타입은 SomeBaseClass.Type인건데

   값이라기보다 그냥 타입 그 자체임. 그래서 클래스 메소드인 printClassName을 호출할 수 있는 것임

자 그럼 .self

struct Rocket {}

// 여기서 Rocket.self vs Rocket.Type의 차이

.self는 자기 자신의 타입을 나타낼 수 있게 지정해주는 프로퍼티니까,

이렇게 정의했을 때, Rocket.self은 Rocket.Type 이라는 거임. 인스턴스 아님‼️

→ 타입의 .self는 해당 타입의 타입을 나타낸다고라 ..

글언아..

ClassName.self == Type이라는 뜻인데 이렇게 하면 왜 오류가 나는가

class Rocket {
	func make(type: SmallRocket.Type) {}
}

class SmallRocket {}

let rocket = Rocket()

rocket.make(type: SmallRocket.Type) /// complie error
rocket.make(type: SmallRocket.self) /// not error

Cannot convert value of type 'SmallRocket.Type.Type' to expected argument type 'SmallRocket.Type'

SmallRocket 타입의 타입은 SmallRocket 타입이 아니다..

이 현상은 마치 arr.append(Int) 와 비슷한 코드를 짠 효과임 :) ㅋㅋ

String은 타입이고, “string”은 instance value인 것처럼

정리해보면, SmallRocket.Type은 타입이고, SmallRocket.self는 metatype의 value라고 보면 됨.

print(Int.Type.self) // Int.Type
print(Int.self) // Int
print(Int.Type.self == Int.self) // false

큰 Self

자기 자신의 타입을 가르키는 용어로, 사용할 수 있는 곳이 제한적임.

클래스, 구조체 내에서 본인의 타입을 리턴하거나, 클래스 프로퍼티에 접근할 수 있는 용어!!

extension Rocket {
  static func makeRocket() -> Self {
    Rocket()
  }
}
------------------------------------
protocol Factory {
  func make() -> Self
}

extension Rocket: Factory {
  func make() -> Rocket {
    Rocket() // or Self.init()
  }
}

.self vs Self

.self - Metatype을 리턴하는 값, 본인의 metatype을 가지는 값을 나타낸다.

Int.self: Int.Type

Self - 자기 자신의 타입을 가리키는 키워드, 사용할 수 있는 곳이 제한적임

Protocol

struct, class와는 다르게 프로토콜의 메타타입은 .Protocol 이라는 키워드로 얻어야함.

• protocol .Type을 할 경우: 해당 프로토콜을 따르는 클래스/구조체의 메타타입을 말함
• protocol .Protocol을 할 경우: 진짜 프로토콜의 진짜 메타타입을 말함

protocol NetworkInterface {}

final class UserNetwork: NetworkInterface {
	func fetchUserName() {}
}

let protocolType: NetworkInterface.**Type** = NetworkInterface.self // #1
let conformType: NetworkInterface.**Type** = UserNetwork.self // #2

#1

Cannot convert value of type 'NetworkInterface.Protocol' to specified type 'NetworkInterface.Type’

이봐라. NetworkInterface.Protocol의 값은 .Type의 값이 될 수 없다고 하잔니

그럼 어떻게 고치면 에러를 없앨 수 있을지?

let protocolType: NetworkInterface.**Protocol** = NetworkInterface.self

#2

NetworkInterface.Type → 해당 프로토콜을 준수하는 클래스의 타입을 명시하는 것이 되어버림

---

Self, self, Self.Type에 대한 .. 번역

목표: self, Self, Self.Type이 뭔지 알자, 또 이 각각은 언제 사용하는지 알자.

self

self는 일반적으로 현재 scope에 있는 object에 대한 참조가 필요할 때 사용된다.

예를 들어 struct 내에 있는 인스턴스 메소드에 대해 self를 사용한다면, self는 해당 구조체의 instance가 될 것임

struct Rocket {
  func launch() {
    print("Launching \(self) in 10 seconds")
  }
}

let rocket = Rocket()
rocket.launch() // Launching Rocket() in 10 seconds

하지만 클래스 인스턴스의 클래스 메소드, 구조체 인스턴스의 static 메소드에서 self를 호출하면 어떻게 될까?

이 경우에 self는 인스턴스가 없고, self가 현재 type에 대한 값 자체이기 때문에 인스턴스에 대한 참조가 될 수 없다.

class Dog {
  class func bark() {
    print("\(self) is going to woof!")
  }
}

Dog.bark() // Dog is going to woof!

struct Cat {
  static func meow() {
    print("\(self) is going to meow!")
  }
}

Cat.meow() // Cat is going to meow!

왤까? static메소드와 클래스 메소드 둘 다 인스턴스가 아닌 type itself로 존재하기 때문임

Meta-types

하지만 모든 값(자료형)은 self를 포함한 type이라는 값을 가져야 함. static, class 메소드가 type에 존재하므로, 이 경우에는 self 자체에 Self.Type의 타입이 있다.

예를 들어 Dog.Type은 모든 Dog의 type value를 가지는 거임

다른 유형을 보유하는 유형은 메타 타입으로 불림

쉽게말해서, meta-type Dog.Type은 Dog type의 값을 가질 뿐 아니라, 모든 하위 클래스도 포함할 수 있는것임.

class Labrador: Dog {
  override class func bark() -> Dog.Type {
    return self
  }
}

let labrador: Dog.Type = Labrador.bark()
print(labrador) // Labrador

또한 변수의 어딘가에 저장하거나, 함수 파라미터로 전달할 경우 type 자체를 값으로 사용할 수 있음

Type.self 처럼 사용해서 말임!

let dogType: Dog.Type = Labrador.self

func saySomething(dog: Dog.Type) {
  print("Woof")
}

saySomething(dog: dogType) // Woof

Self

이것은 항상 현재 context에서의 type을 참조한다. 현재 타입을 편하게 지칭할 수 있는 방법이라고 생각하면 돼!!!!!!!!!!

팩토리 패턴을 만들거나, protocol 메소드에서 concrete type을 반환할 때 유용함

외? 팩토리 패턴에서 타입 의존적이지 않은 코드를 만들 수 있다는 뜻임

extension Rocket {
  static func makeRocket() -> Self {
    Rocket()
  }
}

protocol Factory {
  func make() -> Self
}

extension Rocket: Factory {
  func make() -> Rocket {
    Rocket()
  }
}

해당 글은 해당 아티클을 보고 번역함 난 한국사람이니까 번역 틀리면 머 어쩌라궁