Быстрый бросок из закрытия, вложенного в функцию

Когда вы определяете закрытие, которое выдает:

enum MyError: ErrorType {
    case Failed
}

let closure = {
    throw MyError.Failed
}

тогда тип этого замыкания — () throws -> (), и функция, которая принимает это замыкание в качестве параметра, должна иметь тот же тип параметра:

func myFunction(completion: () throws -> ()) {
}

В этой функции вы можете вызвать completion синхронное закрытие:

func myFunction(completion: () throws -> ()) throws {
    completion() 
}

и вам нужно добавить ключевое слово throws в сигнатуру функции или завершить вызов с помощью try!:

func myFunction(completion: () throws -> ()) {
    try! completion() 
}

или асинхронный:

func myFunction(completion: () throws -> ()) {
    dispatch_async(dispatch_get_main_queue(), { try! completion() })
}

В последнем случае вы не сможете поймать ошибку.

Итак, если completion замыкание в eventStore.requestAccessToEntityType методе и сам метод не имеет throws в своей сигнатуре или если completion вызывается асинхронно, то вы не можете throw из этого замыкания.

Я предлагаю вам следующую реализацию вашей функции, которая передает ошибку обратному вызову, а не выдает ее:

func insertEventToDefaultCalendar(event: EKEvent, completion: CalendarEventError? -> ()) {
    let eventStore = EKEventStore()
    switch EKEventStore.authorizationStatusForEntityType(.Event) {
    case .Authorized:
        do {
            try insertEvent(eventStore, event: event)
        } catch {
            completion(CalendarEventError.Failed)
        }

    case .Denied:
        completion(CalendarEventError.AccessDenied)

    case .NotDetermined:
        eventStore.requestAccessToEntityType(EKEntityType.Event, completion: { (granted, error) -> Void in
            if granted {
                //insertEvent(eventStore)
            } else {
                completion(CalendarEventError.AccessDenied)
            }
        })
    default:
    }
}

Поскольку генерация является синхронной, асинхронная функция, которая хочет генерировать генерацию, должна иметь внутреннее замыкание, которое генерирует генерацию, например:

func insertEventToDefaultCalendar(event :EKEvent, completion: (() throws -> Void) -> Void) {
    let eventStore = EKEventStore()
    switch EKEventStore.authorizationStatusForEntityType(.Event) {
    case .Authorized:
        do {
            try insertEvent(eventStore, event: event)
            completion { /*Success*/ }
        } catch {
            completion { throw CalendarEventError.Failed }
        }

        case .Denied:
            completion { throw CalendarEventError.AccessDenied }

        case .NotDetermined:
            eventStore.requestAccessToEntityType(EKEntityType.Event, completion: { (granted, error) -> Void in
                if granted {
                    let _ = try? self.insertEvent(eventStore, event: event)
                    completion { /*Success*/ }
                } else {
                    completion { throw CalendarEventError.AccessDenied }
                }
        })
        default:
            break
    }
}

Затем на сайте вызова вы используете его следующим образом:

   insertEventToDefaultCalendar(EKEvent()) { response in
        do {
            try response()
            // Success
        }
        catch {
            // Error
            print(error)
        }
    }

В данном случае это невозможно — этот обработчик завершения должен быть объявлен с throws (и метод с rethrows), а этот — нет.

Обратите внимание, что все эти броски — это просто разные обозначения для NSError ** в Objective-C (параметр ошибки inout). Обратный вызов Objective-C не имеет параметра inout, поэтому нет возможности передать ошибку.

Вам придется использовать другой метод для обработки ошибок.

В общем, NSError ** в Obj-C или throws в Swift плохо сочетаются с асинхронными методами, потому что обработка ошибок работает синхронно.

Вы не можете сделать функцию с throw, но вернуть closure со статусом или ошибкой! Если непонятно, могу дать код.

requestAccessToEntityType работает асинхронно. Когда обработчик завершения в конечном итоге запустит вашу функцию, уже возвращенную. Поэтому невозможно выдать ошибку из закрытия так, как вы предлагаете.

Вероятно, вам следует реорганизовать код, чтобы часть авторизации обрабатывалась отдельно от вставки события и вызывала insertEventToDefaultCalendar только тогда, когда вы знаете, что статус авторизации соответствует ожидаемому/требуемому.

Если вы действительно хотите обрабатывать все в одной функции, вы можете использовать семафор (или аналогичный метод), чтобы часть асинхронного кода вела себя синхронно по отношению к вашей функции.

func insertEventToDefaultCalendar(event :EKEvent) throws {
    var accessGranted: Bool = false

    let eventStore = EKEventStore()
    switch EKEventStore.authorizationStatusForEntityType(.Event) {
    case .Authorized:
        accessGranted = true

    case .Denied, .Restricted:
        accessGranted = false

    case .NotDetermined:
        let semaphore = dispatch_semaphore_create(0)
        eventStore.requestAccessToEntityType(EKEntityType.Event, completion: { (granted, error) -> Void in
            accessGranted = granted
            dispatch_semaphore_signal(semaphore)
        })
        dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER)
    }

    if accessGranted {
        do {
            try insertEvent(eventStore, event: event)
        } catch {
            throw CalendarEventError.Failed
        }
    }
    else {
        throw CalendarEventError.AccessDenied
    }
}