How can I conform a Swift actor to a protocol while preserving isolation?

Question

Let's say we have the following goals:

1. We want to use actors.
2. We want to use dependency injection and resolve actors through DI.
3. We want to hide our actors behind protocols so we can vary the implementation.
4. We want to preserve actor isolation, otherwise there's no point in using actors.

So the specific question is: How can we conform a Swift actor to a protocol while preserving isolation?

protocol Zippity {
  func foo()
}

actor Zappity: Zippity {
  func foo() {} // Doesn't compile
}

I can make it compile with …

actor Zappity: Zippity {
  nonisolated func foo() {}
}

… but that seems to defeat the purpose. I also tried declaring the interface method async but that also didn't compile.

I can think of several reasonable workarounds, including composition, nonisolated async methods that call isolated methods, etc. but wanted to see if there's something I'm missing.

Answer 1

OK, I've discovered the answer, and it's pretty straightforward:

protocol Zippity: Actor {
  func foo()
}

actor Zappity: Zippity {
  func foo() // This is a properly isolated method
}

It seems that declaring conformity to the Actor protocol enables the compiler magic.

Answer 2

Actors are only able to be thread safe by making all their functions implicitly async. It does some magic behind the curtains, to make sure it’s being called in the right thread.

To fix this you can either inherit from Actor on the protocol

protocol Foo: Actor {
func bar()
}

Or mark the functions async

protocol Foo {
func bar() async
}