enum Result<T, E: Error> {
    case success(T)
    case failure(E)

    func mapError<E2: Error>(_ f: (E) -> E2) -> Result<T, E2> {
        switch self {
        case .success(let value): return .success(value)
        case .failure(let error): return .failure(f(error))
        }
    }
}

protocol Store {
    associatedtype E: Error

    func fetch(_ completion: (Result<Void, E>) -> Void)
}

// specializing using a value type doesn't crash
enum EnumError: Error { case error }
struct StructError: Error {}

// only specializing using a reference type crashes
class ClassError: Error {}

final class MyStore: Store {
    typealias E = ClassError

    func fetch(_ completion: (Result<Void, ClassError>) -> Void) {
        completion(.failure(ClassError()))
    }
}

enum ServiceError: Error {
    case fetch(Error)
}

struct MyService<S: Store> {
    let store: S

    func fetch(_ completion: (Result<Void, ServiceError>) -> Void) {
        store.fetch { result in
            completion(result.mapError(ServiceError.fetch))
        }
    }

    func explicitFetch(_ completion: (Result<Void, ServiceError>) -> Void) {
        store.fetch { result in
            completion(result.mapError { ServiceError.fetch($0) })
        }
    }
}

// test

let store = MyStore()
let service = MyService(store: store)

// doesn't crash
// store.fetch { print($0) }

// crashes
service.fetch { print($0) }

// doesn't crash
// service.explicitFetch { print($0) }