CalebK's questions

Então, por exemplo, este código:

func trigramSimilarity(to other: Set<String>) -> Double {
    let selfTrigram = trigrams()
    let total = selfTrigram.union(other)
    let common = selfTrigram.intersection(other)
    return total.isEmpty ? 0 : Double(common.count) / Double(total.count)
}

Espero que o compilador se transforme em

func trigramSimilarity(to other: Set<String>) -> Double {
    let selfTrigram = trigrams()
    let total = selfTrigram.union(other)
    return total.isEmpty ? 0 : Double(selfTrigram.intersection(other).count) / Double(total.count)
}

Percebendo que let commonnão é necessário que total.isEmptyo compilador Swift me permita escrever código mais simples, mas evite cálculos desnecessários.

Mas é mais seguro ser simplesmente explícito?

Estou tentando fazer um popover cujo conteúdo se expande dinamicamente com base nas escolhas acima. Eu me contentaria com nenhuma animação ou, idealmente, o popover se expandindo gradualmente para seu novo conteúdo, mas, em vez disso, parece que coloquei uma visualização de rolagem no popover e você pode ver o menu recarregar.

Curiosamente, se você fizer a mesma coisa com um botão, apenas modificando uma propriedade de estado, essa animação não acontece.

Imagino que, de alguma forma, esteja confundindo o sistema de animação com IDs não estáveis, mas tentei colocar argumentos .id() em tudo e isso não resolveu o problema.

struct DropdownTestView: View {
    @State var presentPopover: Bool = false
    @State var choice: Int = 0

    var body: some View {
        VStack {
            Button {
                presentPopover = true
            } label: {
                Text("Press To Choose")
            }
            .popover(isPresented: $presentPopover) {
                popoverView
                    .padding()
            }
            Spacer()
        }
        .padding()
    }

    var popoverView: some View {
        VStack(alignment: .leading) {
            Divider()

            Menu {
                ForEach(0..<6) { num in
                    Button {
                        choice = num
                    } label: {
                        Text("\(num)")
                    }
                }
            } label: {
                Text("Make A Choice")
            }

            if choice != 0 {
                Divider()
                HStack {
                    Text("WRONG CHOICE")
                }
            }
        }
        .frame(width: 220)
    }
}

Eu tentei algo assim:

HStack {
    Text("WRONG CHOICE")
}
.opacity(choice != 0 ? 1.0 : 0)
.frame(choice != 0 ? 30, 0)

Mas isso também não funciona.

Estou tentando criar botões que cresçam até uma largura máxima, se necessário, em que ponto eles usam "..." para truncar seu título. Sei que há algumas coisas incomuns sobre quadros de botões, como a diferença em aplicar quadro antes ou depois, .buttonStyleno entanto, esse comportamento é surpreendente para mim.

Parece que aplicar o maxWidthfaz o botão ocupar essa largura mesmo que não precise. Se você aplicar um estilo de botão que dê a ele um plano de fundo, ele teria espaço em branco ao redor do botão.

Descobri que isso Text()também se aplica a.

struct TestButton: View {
    let title: String

    var body: some View {
        Button {
            print(title)
        } label: {
            Text(title)
                .lineLimit(1)
        }
        .frame(maxWidth: 180)
        .background(.purple)
        .buttonStyle(PlainButtonStyle())
        .focusable()
    }
}
HStack {
    TestButton(title: "Bears")
    TestButton(title: "Battlestar Galactica")
}

Imagino que se o erro fosse mais útil isso seria óbvio, mas por enquanto esse é o código que estou tentando compilar.

struct MultiselectFilterDropdown<C>: View where C : Identifiable, C.ID : Equatable, C.ID : CustomStringConvertible {
    var allItems: [C]

    var body: some View {
        VStack {
            ForEach(allItems) { item in
                Text(item.description)
            }
        }
    }
}

E eu não sei por que o compilador não consegue resolver isso. Eu vi ele dizer que não consegue converter para Range<Int>ou Binding<C>então eu estou supondo que o compilador nem sabe qual inicializador de ForEach seria mais relevante.

Estou usando uma Lista para uma interface altamente personalizada. Isso ocorre principalmente por causa do headercampo e como no .plainmodo os cabeçalhos são fixos acima do conteúdo.

O problema é que os cabeçalhos parecem ter um efeito de vibração. Isso é indesejável porque, nesse caso, o cabeçalho deveria ser apenas um único botão à esquerda.

Existe alguma maneira de me livrar desse efeito de vibração? Ou devo construir minha própria implementação de cabeçalho fixo com alguma lógica complicada de leitor de geometria?

No meu aplicativo, tenho uma variedade de botões. Eles compartilham muitas qualidades, mas variam em cor. Estou tentando escrever uma classe que englobe cada um dos ButtonStyles, deixando claro que a única coisa que varia são suas cores.

O problema é que eu também gostaria de poder usar .tint para um deles. Mas isso é um ShapeStyleem vez de uma Cor.

struct CommonButtonStyle: ButtonStyle {
    @Environment(\.isEnabled) var isEnabled: Bool
    
    @Environment(\.isFocused) var isFocused: Bool
    
    var labelColor: Color
    
    var enabledColor: some ShapeStyle
    var pressedColor: Color
    
    func makeBody(configuration: Configuration) -> some View {
        configuration.label
            .font(.system(size: 14, weight: .bold))
            .padding(.horizontal, 16)
            .padding(.vertical, 10)
            .foregroundStyle(labelColor)
            .frame(maxHeight: 40)
            .background((isEnabled && configuration.isPressed) ? pressedColor : enabledColor)
            .clipShape(Capsule())
            .containerShape(Capsule())
            .opacity(isEnabled ? 1 : 0.5)
            .focusable()
    }
}

O problema aqui é a incompatibilidade dos tipos de retorno e a declaração de var enabledColor: some ShapeStylecomo o compilador reclama queProperty declares an opaque return type, but has no initializer expression from which to infer an underlying type

Existe uma maneira de fazer com que essa variável armazene a Colorou a ShapeStylepara que eu possa fazer

CommonButtonStyle(labelColor: .black, enabledColor: .tint, pressedColor: .white)

e

CommonButtonStyle(labelColor: .black, enabledColor: .blue, pressedColor: .white)

Tenho uma animação bem simples que estou tentando fazer, onde o item selecionado em uma lista recebe um plano de fundo aplicado. O objetivo é que a caixa cinza atrás do item selecionado se transforme da posição anterior para a próxima suavemente.

Eu consegui isso usando matchedGeometryEffectpara que o SwiftUI pudesse combinar as visualizações de fundo entre os dois estados, embora tecnicamente eles tenham um caminho de ID diferente. No entanto, esse esforço é frustrado porList

Aqui está o projeto de exemplo. Tudo o que você precisa fazer para quebrar a animação é cercar os botões em uma List.

Por que List quebra essa animação? Existe alguma maneira de contornar isso?

struct AnimationButtonStyle: ButtonStyle {
    
    var isCurrent: Bool
    var animationNamespace: Namespace.ID
    
    var backgroundView: some View {
        Color.gray
        .cornerRadius(8)
        .matchedGeometryEffect(id: "Shape", in: animationNamespace)
    }
    
    func makeBody(configuration: Configuration) -> some View {
        configuration.label
            .background(
                isCurrent ? backgroundView : nil
            )
            .opacity(configuration.isPressed ? 0.5 : 1.0)
    }
}

struct ContentView: View {
    enum cases: String, CaseIterable {
        case foo = "Foo"
        case bar = "Barrrrrr"
        case bat = "Battttttttttttttt"
    }
    
    @Namespace private var animationNamespace
    @State var animatedCurrentCase: cases = .foo
    @State var currentCase: cases = .foo
    @State var isAnimating: Bool = false
    
    var body: some View {
        VStack {
            // Without the list this animation will work
            List {
                Section {
                    VStack(alignment: .leading, spacing: 0) {
                        ForEach(Array(cases.allCases.enumerated()), id: \.offset) { index, theCase in
                            var isCurrent: Bool { theCase == animatedCurrentCase }
                            Button {
                                isAnimating = true
                                Task { @MainActor in
                                    animatedCurrentCase = theCase
                                    try? await Task.sleep(nanoseconds: 200_000_000)
                                    currentCase = theCase
                                    isAnimating = false
                                }
                            } label: {
                                Label {
                                    Text(theCase.rawValue)
                                } icon: {
                                    VStack(alignment: .leading) {
                                        Text("\(index)")
                                    }
                                    .frame(width: isCurrent ? 16 + 4 : 16)
                                }
                            }
                            .disabled(isAnimating)
                            .buttonStyle(AnimationButtonStyle(isCurrent: isCurrent, animationNamespace: animationNamespace))
                            .animation(.smooth, value: animatedCurrentCase)
                        }
                    }
                }
            }
            Spacer().frame(height: 10)
            Text("Selected: \(currentCase.rawValue)")
                .font(.title)
        }
        .padding()
    }
}

Estou tentando escrever uma linha que avalia um bool que diz se um objeto Date opcional está no futuro ou não.

Eu escrevi a seguinte declaração

let dateIsInFuture = (optionalDate ?? .now) >= .now

E estou curioso para saber se isso é ruim. Especialmente porque se o primeiro e o segundo .now forem avaliados em momentos diferentes, podem deixar de ser iguais. É claro que posso usar agora uma linha diferente para remover essa ambigüidade... mas estou curioso para saber se isso funcionaria com a maneira como o Swift compila e executa essa linha de código.

Tenho visto muitas perguntas sobre o AsyncImage e como atualizá-lo. Neste caso é um pouco diferente. O URL da imagem permanece o mesmo, mas a imagem muda periodicamente. Como tal, eu esperava ter um botão para atualizá-lo.

O problema é oldUrl == newURL. Eu até tentei alguns dos truques em que você define a cor da borda em um pai para tentar enganar o SwiftUI para atualizá-lo e nada disso funcionou. Por enquanto estou mostrando e ocultando manualmente a visualização para que isso funcione. É claro que isso é indesejável.

Poderia haver alguma outra maneira?