Mutually recursive protocols seem to be beyond the Swift type system currently. Or am I missing something?

StateMachine.swift

//: Mutually recursive protocols?

protocol State {
    typealias EventType: Event // error: type may not reference itself as a requirement
    mutating func transitionWithEvent(event: EventType)
}

protocol Event {
    typealias StateType: State // error: type may not reference itself as a requirement
    var action: (StateMachine<StateType, Self>) -> () { get }
}

class StateMachine<S: State, E: Event> {
    // …¡
}

It seems, it is not possible (as of today). I stumbled about the same issue, and no matter how I turned it, there's no way to realise this protocol design with structs, classes and protocol extensions. IMHO, this is a sever limitation, and together with other limitations it makes it very difficult, yet impossible, to design a "more complex" architecture. And actually, it's quite easy to get something which cannot be realised, for example any design where there is a return type, whose concrete type is not known (e.g. a protocol with type alias), or a protocol with a type alias which references back to the first protocol. You see, your design is already too complex ;)

By the way, this another example which cannot be implemented:

public protocol ClientType {
    typealias Request: RequestType
    typealias Task: TaskType
    func request() -> Request
    func task(request: Request) -> Task
    func resume(task: Task)
}

public protocol RequestType {
    typealias Client
    typealias Task
    init(client: Client)
    var client: Client { get }
    func task() -> Task
}

public protocol TaskType {
    typealias Client
    typealias Request
    init(client: Client, request: Request)
    var client: Client { get }
    func resume()
}