blocks|key|4281342|text|问题是您引用的是data变量，但是编译器不知道这是什么类型(因为它是泛型)。试试这个：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4281343|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))
++++++++}
++++}
}|code-block|syntax|javascript|4281344|entityMap^0|8|4|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

Problem is you are referencing <code>data</code> variable but the compiler doesn't know what type is this (because it is a Generic). Try this:

<pre><code>struct ServicesA {
 func loadSomething&lt;T:Model&gt;(completion:(Result&lt;T&gt;) -&gt; ()) {
 Client.shared.execute { result:Response&lt;T&gt; in
 guard let decodedData = result.decodedData else { return }
 completion(Result.success(decodedData))
 }
 }
}
</code></pre>

blocks|key|4281391|text|当闭包中只有一条语句时，编译器才会推断闭包返回类型。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4281392|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
}()|code-block|syntax|javascript|4281393|https://forums.swift.org/t/problems-with-closure-type-inference/11859/2|offset|length|4281394|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|0|1Z|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|S|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|T|8|@]|9|@$I|U|J|V|1|W]]|A|$]]|$1|K|3|-4|5|6|7|X|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|H]]]]

The compiler only infers closure return types when there is a single statement in the closure.

<pre><code>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
}()
</code></pre>

<a href="https://forums.swift.org/t/problems-with-closure-type-inference/11859/2" rel="nofollow noreferrer">https://forums.swift.org/t/problems-with-closure-type-inference/11859/2</a>

blocks|key|4281766|text|TLDR；单行闭包编译不同于多行|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4281767|长答案:让我们暂时忘记单行闭包。当我们编写接受泛型作为参数类型的泛型函数，然后调用这个函数时，编译器需要在调用时知道所需的函数类型，即它的参数类型。现在考虑这个论点是一个闭包。同样，编译器需要知道调用时闭包的类型(函数签名)。这些信息应该在闭包的签名(即参数和返回类型)中可用，编译器并不担心闭包的主体(这是正确的)。因此，服务A的行为完全符合编译器的预期，即闭包签名没有给出任何有关其类型的线索。|4281768|现在有了单行闭合。Swift编译器有一个内置的类型推断优化，仅用于单行闭包。当你编写单行闭包时，编译器首先会启动它的类型推断，并试图从它唯一的一行主体中找出闭包，包括它的返回类型等。这种类型推断适用于单行闭包(带或不带泛型上下文)。这种类型推断是服务B工作的原因|4281769|因此，我将这个问题重新表述为“为什么类型推断适用于单行闭包？”因为这是Swift仅为单行闭包提供的额外功能。一旦你转移到多行闭包(它不是特定于guard语句的，如果你放入print(“hello+world”)也会发生同样的事情)，这种类型推断就不再可用。尽管可能有其他类型推断检查可用于多行闭包。|4281770|您所能做的就是在闭包签名中提供类型信息，即(结果:+Response<模型>)|4281771|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|N|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|O|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|P|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|K|$]]

TLDR; single line closure compilation is different from multi line

Long answer: Let’s forget single line closures for sometime. When we write generic function accepting a generic as argument type and then call this function, compiler needs to know at time of invocation about what’s the type of function needed i.e. the type of its argument. Now consider this argument is a closure. Again compiler needs to know what’s the type of closure (function signature) at time of invocation. This info should be available in the signature of the closure (i.e. argument and return type), compiler doesn’t worry (and rightly so) about the body of the closure. So Service A is behaving perfectly as expected from compiler i.e. the closure signature doesn’t give any clue of its type.

Now comes in single line closure. Swift compiler has a built in type inference optimisation for single line closures only. When you write single line closure, compiler first kicks in its type inference and try to figure out about the closure including its return type etc from its only single line of body . This type inference kicks in for single line closures (with or without the context of generics). 
This type inference is the reason that your service B works

So I’ll rephrase the question as “Why does the type inference works for single line closures?” because that’s an extra feature provided by Swift for single line closures only. As soon as you move to multi line closure (its not guard statement specific, same will happen if you put print(“hello world”) as well), this type inference is no more available. Though there may be other type inference checks available for multi line closures.

What you can do is just provide the Type info in closure signature 
i.e (result: Response&lt; Model >)

I have met a problem like what title has described: the guard statement breaks type inference for some reason. I have created a <code>Playground</code> project to play around. 

Here are some boilerplate code for setup:

<pre><code>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&lt;T&gt; {
 var decodedData: T?
}

enum Result&lt;Value&gt; {
 case success(Value)
 case failure
}

struct Client {
 static let shared = Client()
 private init() {}

 func execute&lt;T: Decodable&gt;(completion: (Response&lt;T&gt;) -&gt; ()) {
 let decodedData = try! JSONDecoder().decode(T.self, from: jsonData!)
 completion(Response(decodedData: decodedData))
 }
}
</code></pre>

Here's the problem:

<pre><code>struct ServicesA {
 func loadSomething(completion: (Result&lt;Model&gt;) -&gt; ()) {
 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&lt;Model&gt;) -&gt; ()) {
 Client.shared.execute { result in
 completion(Result.success(result.decodedData!))
 }
 }
}
</code></pre>

<code>ServicesA</code> breaks whereas <code>ServicesB</code> compiles.

As what you can see, the only difference is <code>guard let decodedData = result.decodedData else { return }</code>. It breaks the type inference so that the <code>Client.shared.execute</code> function complains that the <code>T</code> can't be inferred.

I wonder why would this happen and what's the most appropriate way to deal with this issue.

why does guard break type inference?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

我遇到了一个问题，就像标题所描述的那样:由于某种原因，guard语句破坏了类型推断。我已经创建了一个Playground项目来解决这个问题。下面是一些用于设置的样板代码：import Foundationstruct Model: Decodable {    var i: String}let jsonString ...

问为什么守卫要破坏类型推断？
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么守卫要破坏类型推断？EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么守卫要破坏类型推断？
EN