swift

some View이다 불투명 결과 유형 에 의해 도입으로 SE-0244 과 “반대”일반적인 자리 것으로 생각할 수 있습니다 엑스 코드 11. 스위프트 5.1에서 사용할 수는.

발신자가 만족하는 일반 일반 자리 표시 자와 달리 :

protocol P {}
struct S1 : P {}
struct S2 : P {}

func foo<T : P>(_ x: T) {}
foo(S1()) // Caller chooses T == S1.
foo(S2()) // Caller chooses T == S2.

불투명 한 결과 유형은 구현 에서 충족되는 암시 적 일반 자리 표시 자 이므로 다음과 같이 생각할 수 있습니다.

func bar() -> some P {
  return S1() // Implementation chooses S1 for the opaque result.
}

다음과 같이 보입니다 :

func bar() -> <Output : P> Output {
  return S1() // Implementation chooses Output == S1.
}

실제로이 기능의 최종 목표는보다 명확한 형식으로 리버스 제네릭을 허용하는 것 -> <T : Collection> T where T.Element == Int입니다. 예를 들어 제약 조건을 추가 할 수도 있습니다 . 자세한 내용은이 게시물을 참조하십시오 .

이것을 제거하는 가장 중요한 것은 함수 리턴 some P은 에 맞는 특정 단일 콘크리트 유형 의 값을 리턴하는 것 P입니다. 함수 내에서 다른 적합한 유형을 반환하려고하면 컴파일러 오류가 발생합니다.

// error: Function declares an opaque return type, but the return
// statements in its body do not have matching underlying types.
func bar(_ x: Int) -> some P {
  if x > 10 {
    return S1()
  } else {
    return S2()
  }
}

암시 적 일반 자리 표시자는 여러 유형으로 충족 될 수 없습니다.

이것은 반환하는 함수 대조적이다 P나타내는 데 사용될 수 있고, 둘 다 S1 및 S2그것의 임의 나타내므로 P따르는 값 :

func baz(_ x: Int) -> P {
  if x > 10 {
    return S1()
  } else {
    return S2()
  }
}

그렇다면 불투명 한 결과 유형 -> some P은 프로토콜 반환 유형보다 어떤 이점이 -> P있습니까?

1. PAT와 함께 불투명 한 결과 유형을 사용할 수 있습니다

프로토콜의 현재 주요 제한 사항은 PAT (관련 유형의 프로토콜)를 실제 유형으로 사용할 수 없다는 것입니다. 이는 향후 버전의 언어에서 해제 될 수있는 제한 사항이지만 불투명 한 결과 유형은 사실상 일반적인 자리 표시 자이므로 오늘날 PAT와 함께 사용할 수 있습니다.

즉, 다음과 같은 작업을 수행 할 수 있습니다.

func giveMeACollection() -> some Collection {
  return [1, 2, 3]
}

let collection = giveMeACollection()
print(collection.count) // 3

2. 불투명 한 결과 유형은 동일성

불투명 한 결과 유형으로 인해 단일 콘크리트 유형이 반환되므로 컴파일러는 동일한 함수에 대한 두 번의 호출이 동일한 유형의 두 값을 반환해야한다는 것을 알고 있습니다.

즉, 다음과 같은 작업을 수행 할 수 있습니다.

//   foo() -> <Output : Equatable> Output {
func foo() -> some Equatable {
  return 5 // The opaque result type is inferred to be Int.
}

let x = foo()
let y = foo()
print(x == y) // Legal both x and y have the return type of foo.

컴파일러가이를 알고 x있고 y구체적인 유형이 같기 때문에 이것은 합법적 입니다. 이것은 ==두 가지 유형의 매개 변수 가있는 중요한 요구 사항입니다 Self.

protocol Equatable {
  static func == (lhs: Self, rhs: Self) -> Bool
}

즉, 콘크리트 규격 유형과 동일한 유형의 두 값이 필요합니다. Equatable유형으로 사용 가능 하더라도 두 개의 임의의 Equatable일치 값을 서로 비교할 수 없습니다 .

func foo(_ x: Int) -> Equatable { // Assume this is legal.
  if x > 10 {
    return 0
  } else {
    return "hello world"
  }
}

let x = foo(20)
let y = foo(5)
print(x == y) // Illegal.

컴파일러는 두 개의 임의 Equatable값이 동일한 기본 콘크리트 유형을 가지고 있음을 증명할 수 없습니다 .

비슷한 방식으로, 또 다른 불투명 타입 반환 함수를 도입했다면 :

//   foo() -> <Output1 : Equatable> Output1 {
func foo() -> some Equatable {
  return 5 // The opaque result type is inferred to be Int.
}

//   bar() -> <Output2 : Equatable> Output2 {
func bar() -> some Equatable {
  return "" // The opaque result type is inferred to be String.
}

let x = foo()
let y = bar()
print(x == y) // Illegal, the return type of foo != return type of bar.

모두 있지만 있기 때문에 예를 들어 불법이됩니다 foo및 bar반환 some Equatable, 자신의 일반적인 자리를 “반대” Output1와 Output2다른 유형에 의해 만족 될 수있다.

3. 불투명 한 결과 유형은 일반 자리 표시 자로 구성됩니다.

일반 프로토콜 유형 값과 달리 불투명 한 결과 유형은 일반 일반 자리 표시 자와 함께 잘 구성됩니다.

protocol P {
  var i: Int { get }
}
struct S : P {
  var i: Int
}

func makeP() -> some P { // Opaque result type inferred to be S.
  return S(i: .random(in: 0 ..< 10))
}

func bar<T : P>(_ x: T, _ y: T) -> T {
  return x.i < y.i ? x : y
}

let p1 = makeP()
let p2 = makeP()
print(bar(p1, p2)) // Legal, T is inferred to be the return type of makeP.

예를 들어, 두 값이 서로 다른 기본 콘크리트 유형을 가질 수 있기 makeP때문에 방금 반환 된 경우 작동하지 않습니다 .PP

struct T : P {
  var i: Int
}

func makeP() -> P {
  if .random() { // 50:50 chance of picking each branch.
    return S(i: 0)
  } else {
    return T(i: 1)
  }
}

let p1 = makeP()
let p2 = makeP()
print(bar(p1, p2)) // Illegal.

콘크리트 유형에 불투명 한 결과 유형을 사용하는 이유는 무엇입니까?

이 시점에서 자신에게 생각할 수도 있습니다. 코드를 다음과 같이 작성하십시오.

func makeP() -> S {
  return S(i: 0)
}

음, 불투명 한 결과 유형을 사용하면에서 S제공하는 인터페이스 만 노출 하여 유형 을 구현 세부 사항으로 만들 수 P있으므로 함수에 의존하는 코드를 중단하지 않고 콘크리트 유형을 나중에 줄 아래로 유연하게 변경할 수 있습니다.

예를 들어 다음을 교체 할 수 있습니다.

func makeP() -> some P {
  return S(i: 0)
}

와:

func makeP() -> some P {
  return T(i: 1)
}

호출하는 코드를 깨지 않고 makeP().

참조 불투명 유형 섹션 언어 가이드 및 신속한 진화 제안 이 기능에 대한 자세한 정보를.

답변

protocol Animal {
    func isSibling(_ animal: Self) -> Bool
}

class Dog: Animal {
    func isSibling(_ animal: Dog) -> Bool {
        return true // doesn't really matter implementation of this
    }
}

func animalFromAnimalFamily() -> Animal {
    return myDog // myDog is just some random variable of type `Dog`
}

let animal1: Animal = animalFromAnimalFamily()
let animal2: Animal = animalFromAnimalFamily()

animal1.isSibling(animal2) // error

func animalFromAnimalFamily() -> some Animal {
    return myDog
}

let animal1 = animalFromAnimalFamily()
let animal2 = animalFromAnimalFamily()

animal1.isSibling(animal2)

struct ContentView: View {
    var body: Text {
        Text("Hello World")
    }
}

public protocol View : _View {

    /// The type of view representing the body of this view.
    ///
    /// When you create a custom view, Swift infers this type from your
    /// implementation of the required `body` property.
    associatedtype Body : View

    /// Declares the content and behavior of this view.
    var body: Self.Body { get }
}

struct ContentView: View {
    var body: VStack {
        VStack {
            Text("Hello World")
            Image(systemName: "video.fill")
        }
    }
}

VStack<TupleView<(Text, Image)>>

VStack<TupleView<(Text, Text, Image)>>    

VStack<TupleView<(Text, _ModifiedContent<Spacer, _FrameLayout>, Image)>>

@available(iOS 13.0, *)
func makeACollection() -> some Collection {
    ...
}

@available(iOS 13.0, OSX 10.15, tvOS 13.0, watchOS 6.0, *)
public protocol View {

    /// The type of view representing the body of this view.
    ///
    /// When you create a custom view, Swift infers this type from your
    /// implementation of the required `body` property.
    associatedtype Body : View

    /// Declares the content and behavior of this view.
    var body: Self.Body { get }
}

protocol ProtocolWithAssociatedType {
    associatedtype SomeType
}

struct First: ProtocolWithAssociatedType {
    typealias SomeType = Int
}

struct Second: ProtocolWithAssociatedType {
    typealias SomeType = String
}

func create() -> ProtocolWithAssociatedType {
    return First()
}

func create() -> some ProtocolWithAssociatedType {
    return First()
}

func create() -> some ProtocolWithAssociatedType {
    if (1...2).randomElement() == 1 {
        return First()
    } else {
        return Second()
    }
}