代码之家  ›  专栏  ›  技术社区  ›  Tony Lin

为什么守卫会破坏类型推断?

  •  2
  • Tony Lin  · 技术社区  · 8 年前

    我遇到了一个类似title描述的问题:guard语句由于某种原因中断了类型推断。我创造了一个 Playground 要四处玩玩的项目。

    以下是一些用于设置的样板代码:

    import Foundation
    
    struct Model: Decodable {
        var i: String
    }
    
    let jsonString = """
    {
        "i": "yes"
    }
    """
    
    let jsonData = jsonString.data(using: .utf8)
    let theModel = try JSONDecoder().decode(Model.self, from: jsonData!)
    
    struct Response<T> {
        var decodedData: T?
    }
    
    enum Result<Value> {
        case success(Value)
        case failure
    }
    
    struct Client {
        static let shared = Client()
        private init() {}
    
        func execute<T: Decodable>(completion: (Response<T>) -> ()) {
            let decodedData = try! JSONDecoder().decode(T.self, from: jsonData!)
            completion(Response(decodedData: decodedData))
        }
    }
    

    问题是:

    struct ServicesA {
        func loadSomething(completion: (Result<Model>) -> ()) {
            Client.shared.execute { result in      // error: generic parameter 'T' could not be inferred
                guard let decodedData = result.decodedData else { return }
                completion(Result.success(decodedData))
            }
        }
    }
    
    struct ServicesB {
        func loadSomething(completion: (Result<Model>) -> ()) {
            Client.shared.execute { result in
                completion(Result.success(result.decodedData!))
            }
        }
    }
    

    ServicesA 中断,而 ServicesB 编译。

    如你所见,唯一的区别是 guard let decodedData = result.decodedData else { return } . 它打破了类型推断,因此 Client.shared.execute 函数抱怨 T 无法推断。

    我想知道为什么会发生这种情况,以及处理这一问题的最适当方式是什么。

    4 回复  |  直到 8 年前
        1
  •  4
  •   Aamir    8 年前

    单行闭包编译不同于多行

    长答案:让我们暂时忘记单行闭包。当我们编写接受泛型作为参数类型的泛型函数,然后调用此函数时,编译器需要在调用时知道所需的函数类型,即它的参数类型。现在考虑一下这个论点是一个终结。同样,编译器需要知道调用时闭包(函数签名)的类型。这些信息应该在闭包的签名(即参数和返回类型)中提供,编译器不必担心闭包的主体。因此,服务A的行为完全符合编译器的预期,即闭包签名没有给出任何类型的线索。

    现在是单线闭合。swift编译器只对单行闭包进行内置类型推断优化。当您编写单行闭包时,编译器首先启动它的类型推断,并试图从它唯一的一行正文中找出闭包,包括它的返回类型等。这种类型推断适用于单行闭包(带或不带泛型上下文)。 这种类型推断是服务B工作的原因

    所以我将把这个问题重新表述为“为什么类型推断对单行闭包有效?”因为这是swift只为单行闭包提供的额外功能。一旦转到多行闭包(它不是特定于guard语句的闭包,如果您也放置print(hello world),就会发生同样的情况),这种类型推断就不再可用。尽管可能有其他类型推断检查可用于多行闭包。

    你能做的就是在闭包签名中提供类型信息 即(结果:响应<模型>)

        2
  •  3
  •   Avi    8 年前

    编译器只在闭包中有一个语句时推断闭包返回类型。

    let x = {
        return 1
    }()
    
                    // x == Int(1)
    
    let y = {       // error: unable to infer complex closure return type; add explicit type to disambiguate
        print("hi")
        return 2
    }()
    

    https://forums.swift.org/t/problems-with-closure-type-inference/11859/2

        3
  •  0
  •   Prashant Tukadiya    8 年前

    你需要输入cast result 具有 结果<模型> 所以编译器可以知道 T

    struct ServicesA {
        func loadSomething(completion:(Result<Model>) -> ()) {
            Client.shared.execute { (result:Response<Model>) in
                guard let data = result.decodedData else {return}
                completion(Result.success(data))
            }
        }
    }
    
        4
  •  0
  •   Vicente Garcia    8 年前

    问题是你在引用 data 变量,但编译器不知道这是什么类型(因为它是泛型)。试试这个:

    struct ServicesA {
        func loadSomething<T:Model>(completion:(Result<T>) -> ()) {
            Client.shared.execute { result:Response<T> in
                guard let decodedData = result.decodedData else { return }
                completion(Result.success(decodedData))
            }
        }
    }
    
    推荐文章