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
    }
}

Nota: estritamente falando, não é necessária familiaridade com a biblioteca swift-case-paths do PointFree que estou usando aqui. Fundamentalmente, minha pergunta diz respeito somente ao Swift em si.
Então, dada a função correta acima, o objetivo é aplicá-la recursivamente, para recuperar o valor aninhado mais profundo.
Mas como lidar com os tipos aqui? Porque cada valor associado pode ser um tipo diferente. O problema é que a associatedValue()função retorna um genérico T, que deve ser especificado. Mas para uma solução geral, não podemos saber cada um Tcom antecedência.

Darei um exemplo concreto para maior contexto:

@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

Aqui está um trecho de código do meu 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
    }
}

Não tenho certeza se esta é a abordagem idiomática (sou relativamente novo no SwiftUI), mas funciona muito bem.

Minha pergunta é:
podemos nos livrar de uma "espera" mesclando as linhas em uma única?

await updateUI(with: NetworkManager.fetchData())

Este código é equivalente ao anterior?
Mais importante ainda, preciso que a chamada de rede seja executada em um thread em segundo plano enquanto as atualizações da IU são executadas no thread principal. Este ainda é o caso aqui?

Como isso pode ser comprovado? (você sabe, na era GPT tudo deveria ser verificado 😂)

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
    }
}

Por que precisamos dessa extensão na parte inferior? Por que o compilador não consegue simplesmente descobrir que struct PropertyWrapperjá está em conformidade com os requisitos para protocol EmptyInitializable? Parece tão feio...

PS: Acredito que isso realmente funcionasse em situações semelhantes antes.

Cada método em Swift possui uma função estática correspondente gerada automaticamente pelo Swift.
Mas estou tendo dificuldades para aplicar esse conceito map.
Por exemplo. Esta é uma maneira canônica de fazer as coisas:

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

O que eu quero é fazer com que o código a seguir seja compilado e funcione (porque em teoria ele deveria compilar e funcionar exatamente como o código acima):

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

PS A propósito, como esse recurso é chamado oficialmente?

protocol myProtocol {}

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

extension Int: myProtocol {}

doSomething(with: 1, 2, 3)

Erro de compilação na linha de declaração func:

'alguns' tipos são permitidos apenas em propriedades, subscritos e funções

Eu poderia simplesmente omitir completamente a palavra-chave, mas ela será considerada 'qualquer' por padrão. Conseqüentemente, não posso passar os parâmetros para uma função que espera [some SyntaxProtocol]como parâmetro.

Por que ele compila e funciona?
Não consigo encontrar nenhuma informação sobre isso.

Vou te dar um exemplo. Baseado na biblioteca SwiftSyntax.

@CodeBlockItemListBuilder statementsBuilder: () -> CodeBlockItemListSyntax

Então, digamos que temos uma função com esse parâmetro. A função espera um fechamento com CodeBlockItems e o resultBuilder criará CodeBlockItemList como resultado.

myFunction {
    item1
    item2
    item3
...
}

Parece que posso passar um itemList (um objeto do tipo resultante CodeBlockItemListSyntax) para isso também:

myFunction {
    itemList
}

Não entendo por que podemos fazer isso. Por que isso funciona? Como funciona?!
Na verdade, podemos até misturar objetos Item com objetos ItemList! Mas a saída é um pouco estranha... o que me confunde ainda mais.

PS
Fiquei bastante surpreso ao saber que ainda não existem tags "construtor de resultados" nem "sintaxe rápida" no StackOverFlow.

// 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)

Este é um trecho de código compatível com playgrounds e funciona conforme o esperado. Estou substituindo o inicializador para que o código sempre imprima "Roman", não importa o que realmente estejamos atribuindo.

Mas assim que movo o código da "Biblioteca de terceiros" para a pasta "Fontes" do playground (para imitar o uso da biblioteca de terceiros), o comportamento muda: meu método substituído é simplesmente ignorado 😣