SE-0316 (second review): Global Actors

[Douglas_Gregor]

@anandabits

It seems pretty unlikely to me that there would be a computed property that does something more than a constant initialization could do while still consistently returning the same instance. On the other hand, I can easily imagine people violating the global actor contract unintentionally.

It seems pretty unlike to me that anyone will use anything other than static let here in the first place, so when we're talking about adding a special ad-hoc type-checking rule for a rare case that might be useful. Heck, you need it today if you want a generic global actor, because static variables aren't supported in generic types:

protocol DefaultInitializable {
  init()
}

@globalActor
struct GA<ActorType: Actor & DefaultInitializable> {
  static let shared = ActorType() // error: static stored properties not supported in generic types
}

Doug

[Joe_Groff]

Thanks everybody for your help in the review. The core team has decided to accept this proposal with modifications.

[xwu (Xiaodi Wu)]

I'm late to the review, seeing as it's already been accepted (congratulations!). I wonder if @Douglas_Gregor or another author could give a clarification that seems unanswered in the proposal text--

The proposal gives the following example:

protocol P {
  @MainActor func f()
}

struct X { }

extension X: P {
  func f() { } // implicitly @MainActor
}

What happens if I define two global actor-annotated protocols, P and Q (distinct global actors), and then write struct X: P, Q? Which is the implicit global actor then, and is there a warning?

In the same vein, but perhaps more likely to occur in real-world code, the proposal states:

A struct or class containing a wrapped instance property with a global actor-qualified wrappedValue infers actor isolation from that property wrapper:

@propertyWrapper
struct UIUpdating<Wrapped> {
  @MainActor var wrappedValue: Wrapped
}

struct CounterView { // infers @MainActor from use of @UIUpdating
  @UIUpdating var intValue: Int = 0
}

What if I define a struct with two members, one annotated with @UIUpdating and another annotated with a custom property wrapper called @BackgroundActorUpdating with a different global actor-qualified wrapped value? What is the inferred global actor for my struct, and is there a warning?