Perguntas[swift](coding)

Estou brincando com a resposta desta questão: Como testar se uma variável genérica é do tipo AnyObject

Essa solução parece não funcionar mais. Tenho este código:

public struct ObjectHashable<T>: Hashable {
  
  public let object: T
  
  public init(object: T) {
    
    let t1 = type(of: object)
    let b1 = t1 is AnyClass
    print(t1) // Plugin
    print(b1) // false
    
    let t2 = T.self
    let b2 = t2 is AnyClass
    print(t2) // Plugin 
    print(b2) // false
    
    let t3 = Mirror(reflecting: object).subjectType 
    let b3 = t3 is AnyClass 
    print(t3) // P
    print(b3) // true 

    self.object = object
    
  }
  
  public static func ==(lhs: Self, rhs: Self) -> Bool {
    return true
  }
  
  public func hash(into hasher: inout Hasher) {
  }
}

protocol Plugin: AnyObject {}
class P: Plugin {}

typealias PluginHashable = ObjectHashable<Plugin>

PluginHashable(object: P())

Esse é um comportamento surpreendente.

1.

let t1 = type(of: object)

type(of:)deveria retornar o tipo dinâmico, que é P, não Plugin. Mas obtive "Plugin" impresso.

2.

let b1 = t1 is AnyClass

Não deveria ser verdade, já que t1 é um tipo de referência? (com base na resposta aqui: Como testar se uma variável genérica é do tipo AnyObject )

3.

let t2 = T.self

Isso imprime Plugin, o que faz sentido, porque eu Plugincoloquei<>

4.

let b2 = t2 is AnyClass

Isso é falso, mas acho que deveria ser verdade pelo mesmo motivo

5.

    let t3 = Mirror(reflecting: object).subjectType // P

Isso imprime P, o que faz sentido

6.

    let b3 = t3 is AnyClass // true

Isso é verdade, o que faz sentido. Mas por que é diferente dos outros dois casos?

Tenho um protocolo que é restrito apenas a tipos de classe:

protocol Plugin: AnyObject {}

Agora, quero usar o plugin como chave do mapa de hash. Não quero que o Pluginprotocolo se estenda de Hashable, porque teria que escrever any Pluginem todos os lugares (já que ele herdaria "Auto-Requisito" do protocolo pai).

Então, para contornar isso, quero criar um wrapper genérico. Não quero usar AnyHashable, porque quero um tipo mais restrito em caso de erros.

public struct ObjectHashable<T: AnyObject>: Hashable {
  
  public let object: T
  
  public init(object: T) {
    self.object = object
  }
  
  public static func ==(lhs: Self, rhs: Self) -> Bool {
    return ObjectIdentifier(lhs.object) == ObjectIdentifier(rhs.object)
  }
  
  public func hash(into hasher: inout Hasher) {
    hasher.combine(ObjectIdentifier(object))
  }
}

Agora eu quero fazer algo como

typealias PluginHashable = ObjectHashable<Plugin>

No entanto, isso me dá erro:

requisito especificado como 'T': 'AnyObject' [com T = qualquer plugin]

Então eu mudei para

typealias PluginHashable = ObjectHashable<any Plugin>

E recebi o mesmo erro:

requisito especificado como 'T': 'AnyObject' [com T = qualquer plugin]

Pelo que entendi, embora Plugino protocolo seja limitado a ser um tipo de classe, any Pluginele não é. No entanto, não sei o que fazer a seguir.

Atualizar:

Se eu não usar o genérico for ObjectHashable, funciona:

public struct PluginHashable: Hashable {
  
  public let plugin: Plugin
  
  public init(plugin: Plugin) {
    self.plugin = plugin
  }
  
  public static func ==(lhs: Self, rhs: Self) -> Bool {
    return ObjectIdentifier(lhs.plugin) == ObjectIdentifier(rhs.plugin)
  }
  
  public func hash(into hasher: inout Hasher) {
    hasher.combine(ObjectIdentifier(plugin))
  }
}

No entanto, esta solução só é utilizável para Pluginprotocolo, portanto não é ideal. Prefiro ter uma solução que funcione para todos os casos semelhantes.

Tento me familiarizar com a simultaneidade do Swift, especialmente com o MainActor.

Eu criei para mim esta classe de demonstração :

@MainActor
class ThreadsDemo {
  let range1000 = 0.. < 1000
  var randomNumber = 0

  init() {
    randomNumber = Int.random(in: range1000)
  }

  func modifyRandomNumber() async {
    print("2. isMain: \(Thread.isMainThread)")
    let newRandomNumber = Int.random(in: range1000)
    print("Generated random-number -> \(newRandomNumber)")
    Timer.scheduledTimer(withTimeInterval: 3.0, repeats: false) {
      _ in
        print("4. isMain (within wait): \(Thread.isMainThread)")
    }
    print("5. isMain: \(Thread.isMainThread)")
    randomNumber = newRandomNumber
  }
}

Invocando o método ThreadDemo:

.task {
  print("1. isMain: \(Thread.isMainThread)")
  print("Initial random-number -> \(threadsDemo.randomNumber)")
  await threadsDemo.modifyRandomNumber()
  print("Modified random-number -> \(threadsDemo.randomNumber)")
  print("6. isMain: \(Thread.isMainThread)")
}

Resultado:

1. isMain: true
Initial random-number -> 455
2. isMain: true
Generated random-number -> 578
5. isMain: true
Modified random-number -> 578
6. isMain: true
4. isMain (within wait): true

Obviamente executa tudo no thread principal, até mesmo o bloco dentro do temporizador agendado.

Estou confuso, porque pensei que ele usaria threads em segundo plano para evitar que a interface do usuário travasse e parasse de responder.

Se ele executa tudo no thread principal de qualquer maneira, então qual é o propósito de usar tarefas?

Mas o que eu realmente tentei descobrir:

A anotação @MainActor resulta na execução de tudo no thread principal (todo o código executável) ou resulta apenas em fazer alterações no estado (atribuições, etc.), sempre no thread principal?

Não tenho certeza do que estou fazendo errado, mas quando executo o código abaixo:

func twoSum(_ nums: [Int], _ target: Int) -> [Int] {
    let length = nums.count-1;

    for index1 in 0...length {
        let difference = target - nums[index1];
        print(target, difference, nums[index1])
        if (nums[index1] < difference) {
            for index2 in index1+1...length {
                if (nums[index2] == difference) {
                    return [index1, index2];
                }
            }
        }
    } 

    return [];
}

let summer = twoSum([-1,-2,-3,-4,-5], -8)

Recebo o seguinte erro:

Swift/ClosedRange.swift:347: Erro fatal: O intervalo requer lowerBound <= upperBound

Curiosamente, se eu alterar a condição da instrução if para nums[index1] <= target, ela não trava.

Este aplicativo de exemplo, quando executado no macOS 15.4, exibe um comportamento de animação estranho ao abrir e fechar a barra lateral.

Tudo o que você precisa fazer para corrigir o problema é remover a .frame(minWidth: 805, minHeight: 525)linha, mas isso significa que você não pode limitar o tamanho da janela.

Gostaria de ter um tamanho mínimo para meu aplicativo, mas isso defaultSize()não funciona.

enum Page: String, Hashable {
    case settings = "Settings"
    case radio = "Radio"
    case connect = "Connect"
    
    var systemImageName: String {
        switch self {
        case .settings:
            return "gear"
        case .radio:
            return "radio"
        case .connect:
            return "dot.radiowaves.right"
        }
    }
}

struct ContentView: View {
    @State var pages = [Page.settings, Page.radio, Page.connect]
    
    var body: some View {
        NavigationSplitView {
            List(pages, id: \.self) { page in
                Label(page.rawValue.capitalized, systemImage: page.systemImageName)
            }
        } detail: {
            Text("Content")
        }
    }
}

@main
struct NavigationTestsApp: App {
    var body: some Scene {
        Window("Navigation", id: "H") {
            Group {
                ContentView()
                    // Without this line this animation bug does not happen
                    .frame(minWidth: 805, minHeight: 525)
            }
        }
    }
}

Estou tentando aprender Swift 6. O problema que tenho enfrentado é que não consigo ler (não tentar modificar) as propriedades de actorum UI class.

É possível ler sem adicionar propriedades armazenadas extras ou aguardar?

Você pode me dar alguma solução para isso?

final actor Logger: Sendable {
    
    static let current = Logger()
    
    private(set) final var logs: [Int] = []
    
    private init() { }
    
    nonisolated var count: Int {
        
        return self.logs.count
    }
}

final class ViewController: NSViewController, NSTableViewDataSource {
   
    @IBOutlet weak var tableView: NSTableView!
     
    func numberOfRows(in tableView: NSTableView) -> Int {
        
        return Logger.current.count
    }
}

Erro:

A propriedade 'logs' isolada do ator não pode ser referenciada a partir de um contexto não isolado

Obrigado!

Tenho uma grande variedade de cerca de 50 mil itens, onde cada item está em conformidade com a identificação.

Eu não altero o conjunto de nenhuma forma, nem reorganizo nem nada.

Se eu passasse diretamente para ForEach, o desempenho de rolagem da lista seria significativamente mais suave do que se eu passasse os índices.

Percebo que a documentação menciona algo relacionado à identidade estrutural de cada célula, mas não consigo entender por que isso acontece.

ForEach(myArray, id: \.id) { item in
    MyRowView(item: item)
}

// Extremely choppy scroll
ForEach(myArray.indices, id: \.self) { index in
    MyRowView(item: myArray[index])
}

Estou tentando passar um valor @Binding para a hierarquia de visualizações do SwiftUI usando uma @EnvironmentKey personalizada. Na minha NestedView, estou usando uma combinação de @Environment e @Binding como esta:

@Environment(\.featureEnabledBinding) @Binding var myBool: Bool

Eu deveria conseguir usar isso em um Toggle como: Toggle(isOn: $myBool, label: { Text("Toggle") })

Entretanto, isso me dá um erro do compilador:

Não é possível encontrar '$myBool' no escopo

isso funciona perfeitamente: Toggle(isOn: _myBool.wrappedValue, label: { Text("Toggle") })

Isso é o oposto do que eu esperava. Pelo que entendi: • _myBool deve ser o wrapper (Binding) • $myBool deve ser o valor projetado (também um Binding)

Aqui está meu código

Configuração do ambiente:

struct FeatureEnabledKey: EnvironmentKey {
    static let defaultValue: Binding<Bool> = .constant(false)
}

extension EnvironmentValues {
    var featureEnabledBinding: Binding<Bool> {
        get { self[FeatureEnabledKey.self] }
        set { self[FeatureEnabledKey.self] = newValue }
    }
}

e Exemplo Mínimo

struct ParentView: View {
    @State private var isFeatureEnabled = false

    var body: some View {
        NestedView()
            .environment(\.featureEnabledBinding, $isFeatureEnabled)
    }
}

struct NestedView: View {
    @Environment(\.featureEnabledBinding) @Binding var myBool: Bool

    var body: some View {
        VStack {
            // ❌ This gives an error : Cannot find '$myBool' in scope
            // Toggle(isOn: $myBool, label: { Text("Toggle") })

            // ✅ This works fine
            Toggle("Working Toggle", isOn: _myBool.wrappedValue)
        }
    }
}

Pergunta: Por que $myBool está indisponível ou inválido neste contexto? É um bug conhecido do SwiftUI/compilador com wrappers de propriedade dupla (@Environment @Binding)? Ou meu entendimento não está correto.

Xcode: 16.3

Tenho uma tela no aplicativo iOS com NavigationStack (ou NavigationView) que contém diferentes elementos. Um deles é a Lista pesquisável, que está encapsulada no NavigationLink. Portanto, essa lista pesquisável aparece em uma nova tela.

E quando o usuário seleciona algum elemento da Lista, ele deve retornar automaticamente à tela anterior sem dois cliques adicionais nos botões Cancelar (se usar a pesquisa) e depois "Voltar".

Existe alguma maneira certa de fazer isso? Obrigado por qualquer conselho!

import SwiftUI

struct TheItem: Identifiable {
    let id = UUID()
    let name: String
}

class SomeModel: ObservableObject {
    
    @Published var selectedId: UUID?
    @Published var searchText: String = ""

    var items: [TheItem] = [
        TheItem(name:"Item 1"),
        TheItem(name:"Item 2"),
        TheItem(name:"Item 3"),
        // ...
        TheItem(name:"Item N")
    ]
    
    var filteredItems: [TheItem] {
        guard !searchText.isEmpty else { return self.items }
        return self.items.filter { item in
            item.name.lowercased().contains(self.searchText.lowercased())
        }
    }
    
    var selectedItemName: String {
        if selectedId != nil {
            return filteredItems.first(where: {$0.id == selectedId})?.name ?? "-"
        }
        return "-"
    }
    
    init () {
        selectedId = items.first?.id
    }
}

struct TestNavigationLinkBackkView: View {
    
    @EnvironmentObject private var model: SomeModel
    
    var body: some View {
        NavigationStack {
            NavigationLink(model.selectedItemName) {
                List {
                    Picker("Item", selection: $model.selectedId) {
                        ForEach(model.filteredItems) { item in
                            Text(item.name).tag(item.id)
                        }
                    }
                }
                .searchable(text: $model.searchText, placement: .navigationBarDrawer(displayMode: .always))
                .pickerStyle(.inline)
            }
        }
    }
}

#Preview {
    TestNavigationLinkBackkView()
        .environmentObject(SomeModel())
}

Sou novo no CoreData, mas criei um objeto que pretendo usar como uma matriz dentro de um loop ForEach no SwiftUI.

No editor de entidades, adicionei um atributo UUID stored_id. Em seguida, em uma extensão, escrevi isto:

extension Item: Identifiable {
    public var id: UUID {
        guard let stored_id else {
            assertionFailure("No stored ID")
            return UUID()
        }
        return stored_id
    }
    
}

Isso me parece bastante estranho por vários motivos, como o fato de stored_id ser opcional dada a semântica do CoreDatas. Será que isso é uma prática ruim por algum motivo?