Roman's questions

import CasePaths

extension CasePathable where AllCasePaths: CasePathReflectable<Self> {
    func associatedValue<T: CasePathable>() -> T? where T.AllCasePaths: CasePathReflectable<T> {
        let caseKeyPath = Self.allCasePaths[self]
        return self[case: caseKeyPath] as? T
    }
}

注意：严格来说，我在这里使用的PointFree 的 swift-case-paths库不需要熟悉。从根本上讲，我的问题仅与 Swift 本身有关。
因此，给定上述正确的函数，目标是递归应用它，以检索最深的嵌套值。
但是如何处理这里的类型？因为每个关联值可能是不同的类型。问题是该associatedValue()函数返回一个T必须指定的泛型。但对于通用解决方案，我们无法T提前知道每一个。

我将给出一些具体的例子来提供更多背景信息：

@CasePathable
enum A {
    case a(B)
    case smthA
}

@CasePathable
enum B {
    case b(C)
    case smthB
}

@CasePathable
enum C {
    case c
    case smthC
}

let aValue: A = .a(.b(.c))
let bAssValue: B = aValue.associatedValue()! // .b(.c))
let cAssValue: C = bAssValue.associatedValue()! // .c

以下是我的 SwiftUI ViewModel 的代码片段：

@Published var data: Data
@Published var showingAlert = false
    
func fetchData() {
    Task {
        let result = await NetworkManager.fetchData(),
        await updateUI(with: result)
    }
}
    
@MainActor
private func updateUI(with result: Result<Data, Error>) {
    do {
        data = try result.get()
    } catch {
        showingAlert = true
    }
}

我不确定这是否是惯用的方法（我对 SwiftUI 还比较陌生）但效果很好。

我的问题是：
我们可以通过将这些行合并为一行来摆脱一个“await”吗？

await updateUI(with: NetworkManager.fetchData())

此代码与上一个代码相同吗？
最重要的是，我需要网络调用在后台线程上运行，而 UI 更新则在主线程上执行。这里还是这种情况吗？

这怎么证明呢？（你知道，在 GPT 时代一切都应该经过事实核查😂）

protocol EmptyInitializable {
    init()
}

@propertyWrapper
struct PropertyWrapper: EmptyInitializable {
    let wrappedValue: Int
    
    init(_ wrappedValue: Int = 0) {
        self.wrappedValue = wrappedValue
    }
}

// This one lools redundent
extension PropertyWrapper {
    public init() {
        wrappedValue = 0
    }
}

为什么我们需要在底部进行扩展？为什么编译器不能弄清楚，它struct PropertyWrapper已经符合 的要求protocol EmptyInitializable？看起来好丑啊...

PS我相信它以前确实在类似的情况下起作用过。

Swift 中的每个方法都有 Swift 自动生成的相应静态函数。
但我很难将这个概念应用到map.
例如。这是一种规范的做事方式：

let numbers = Set([1, 2, 3])
let doubled = numbers.map { $0 * 2 }
print(doubled) // [2, 4, 6]

我想要的是使以下代码编译和工作（因为理论上它应该像上面的代码一样编译和工作）：

let numbers = Set([1, 2, 3])
let doubled = Set.map(numbers) { $0 * 2 }
print(doubled) // [2, 4, 6]

PS顺便问一下，这个功能官方是怎么称呼的？

protocol myProtocol {}

func doSomething(with params: (some myProtocol)...) {
    // Implementation goes here
}

extension Int: myProtocol {}

doSomething(with: 1, 2, 3)

func 声明行出现编译错误：

“某些”类型仅允许在属性、下标和函数中使用

我可以简单地完全省略关键字，但默认情况下它被认为是“any”。因此，我无法将参数传递给需要[some SyntaxProtocol]作为参数的函数。

为什么它能编译并运行？
我找不到任何这方面的信息。

我给你举个例子。基于 SwiftSyntax 库。

@CodeBlockItemListBuilder statementsBuilder: () -> CodeBlockItemListSyntax

所以，假设我们有一个带有这样参数的函数。该函数需要使用 CodeBlockItems 进行闭包，并且 resultBuilder 将构建 CodeBlockItemList 作为结果。

myFunction {
    item1
    item2
    item3
...
}

看来我CodeBlockItemListSyntax也可以将 itemList （结果类型的对象）传递给它：

myFunction {
    itemList
}

我不明白为什么我们被允许这样做。为什么它有效？它是如何工作的？！
事实上，我们甚至可以将 Item 与 ItemList 对象混合使用！但输出有点奇怪......这让我更加困惑。

PS
非常惊讶的是，StackOverFlow 中仍然不存在“结果构建器”和“swift-syntax”标签。

// MARK: - Third Party Library

public protocol TestProtocol: ExpressibleByStringLiteral {
    init(str: String)
}

extension TestProtocol {
    public init(stringLiteral value: String) {
        self.init(str: value)
    }
}

public struct Test {
    public let str: String
    
    public init(str: String) {
        self.str = str
    }
}

extension Test: TestProtocol {}

// MARK: - My Swift Package

extension Test {
    public init(stringLiteral value: String) {
        self.init(str: "Roman")
    }
}

let test: Test = "Test"
print(test.str)

这是游乐场友好的代码片段，它按预期工作。我将重写初始化程序，以便无论我们真正分配什么，代码总是打印“Roman”。

但是，一旦我将“第三方库”代码移至游乐场的“源”文件夹（以模仿第三方库的使用），行为就会发生变化：我的重写方法被忽略😣