All perguntas(coding)

Dada uma definição de tipo de uma função, existe uma maneira de converter os parâmetros recebidos por meio de um modelo variádico como um argumento para os tipos exatos da typedeffunção ed?

#include <concepts>
#include <iostream>

typedef int foo(int, int);

template <typename func, typename... Args>
  requires std::invocable<func, Args &&...>
void bar(Args&&... args) {
  ((std::cout << std::forward<Args>(args)), ...);
}

int main() { bar<foo>(4, 4.1); }

Neste exemplo, verifico se funcwould seria invocável com os argumentos fornecidos e, em seguida, imprimo os argumentos passados. 4 e 4.1 são impressos (como esperado). Mas fooaceita int,int, então o objetivo seria imprimir 4 e 4 como resultado da conversão argspara os tipos de parâmetros aceitos por foo. Uma solução simples, porém funcional, seria muito apreciada.

Tenho uma consulta com baixo desempenho e não sei onde está o problema. Uma versão bastante reduzida da consulta, que ainda apresenta o mesmo problema, é:

SELECT members.id, 
FROM members
LEFT JOIN ( SELECT 
  member_id,
  GROUP_CONCAT(hobby)
  FROM member_hobbies
  GROUP BY member_id) AS hobbies
ON member.id=hobbies.member_id

Há um índice primário em members.ide um índice correspondente em hobbies.member_id.

Se eu remover o GROUP_CONCATa consulta será cerca de 50 vezes mais rápida.

Estou ciente de que o exemplo dado acima pode ser simplificado e não requer a subconsulta, e estou tentando simplificar minha consulta completa.

Gostaria de saber se é possível otimizar a consulta em seu formato atual e onde está o problema.

Criei um SPA com angular e resolvi o problema do tamanho da mensagem no signalR, mas antes de aumentar e mover o problema para mais tarde, eu queria dividir a mensagem com um fluxo.

é bem simples:

        const subject = new Subject<any>();

        try
        {
            await this.hubConn.send("Values", id, subject) // X
                .catch(err => console.error(err));

            for (let i = 0; i < values.length; ++i)
                subject.next(values[i]);

            subject.complete();
        }
        catch (err: any)
        {
            subject.error('Error');
            console.error(err.message);
        }

Mas recebo um erro na linha marcada com // X

depois de alguma investigação descobri que na segunda iteração streamIdé distinct:

Vou construir um pequeno exemplo para verificar o que acontece:

var streams = [];
streams[4] = {};

for (const streamId in streams)
    console.debug(streamId);

o que me dá este resultado:

4
distinct
equals
firstOrDefault
lastOrDefault
pushSorted

mas isso significa que iterar sobre as chaves sempre itera sobre as funções do array, mas não encontrei nada sobre esse problema...

Estou usando:

angular 16.2
typescript 5.1.6
signalR 7.0.9 and 8.0.7 (tried both)
nodejs 16.20.2
and I have the target ES2022

então, ou ninguém nunca tentou fazer streaming (o que parece muito improvável), ou tenho uma incompatibilidade de versão ou tenho algum erro no meu código que não consigo ver...

Alguém tem alguma ideia de por que isso pode não funcionar?

// Editar: Aqui está o método do lado do servidor para receber os valores:

[HubMethodName(nameof(Values))]
public async Task Values(string id, IAsyncEnumerable<object> values)
{
    try
    {
        object[] result = null;
        if (values != null)
            result = await values.ToArrayAsync();

        Debug.WriteLine(result);
    }
    catch (Exception ex)
    {
        SystemLogger.LogCritical("{ex}", ex);
    }
}

É explicado como:

Ccache é um cache de compilador. Ele acelera a recompilação armazenando em cache compilações anteriores e detectando quando a mesma compilação está sendo executada novamente.

Não entendi. Quando uso um sistema de compilação como Ninja ou Makefiles e, por exemplo, altero um arquivo-fonte, o sistema de compilação já registra quais arquivos são dependências de quais unidades de tradução e evita recompilar essas unidades de tradução com base nessas informações, o que, até onde sei, eu descreveria como cache. Além disso, notei que, quando altero uma unidade de tradução, ele não apenas evita recompilar todas as unidades de tradução em arquivos-objeto novamente, mas também, de alguma forma (não sei como), evita vincular tudo novamente ao executável, de modo que, em um projeto muito grande, posso alterar o código em uma unidade de tradução, recompilar e tudo estará pronto para ser executado novamente em 2 segundos no meu rápido computador multi-core.

O que o ccache faz além disso, explique com exemplos concretos como "ele armazena em cache partes x, y, z do seu código".

Acho esse comportamento bastante contraintuitivo, embora eu suponha que haja uma razão para isso - o numba converte automaticamente meus tipos inteiros numpy diretamente em um int python:

import numba as nb
import numpy as np 

print(f"Numba version: {nb.__version__}")  # 0.59.0
print(f"NumPy version: {np.__version__}")  # 1.23.5

# Explicitly define the signature
sig = nb.uint32(nb.uint32, nb.uint32)

@nb.njit(sig, cache=False)
def test_fn(a, b):
    return a * b

res = test_fn(2, 10)
print(f"Result value: {res}")  # returns 20
print(f"Result type: {type(res)}")  # returns <class 'int'>

Este é um problema porque estou usando o retorno como uma entrada em outra função njit, então recebo um aviso de conversão (e também faço conversões desnecessárias entre as funções njit)

Existe alguma maneira de forçar o numba a me dar np.uint32um resultado?

--- EDITAR ---

Este é o melhor que consegui fazer sozinho, mas me recuso a acreditar que esta seja a melhor implementação que existe:

# we manually define a return record and pass it as a parameter
res_type = np.dtype([('res', np.uint32)])
sig = nb.void(nb.uint32, nb.uint32, nb.from_dtype(res_type))

@nb.njit(sig, cache=False)
def test_fn(a:np.uint32, b:np.uint32, res: res_type):
    res['res'] = a * b

# Call with Python ints (Numba should coerce based on signature)
res = np.recarray(1, dtype=res_type)[0]
res_py_in = test_fn(2, 10, res)
print(f"\nCalled with Python ints:")
print(f"Result value: {res['res']}")  # 20
print(f"Result type: {type(res['res'])}")  # <class 'numpy.uint32'>

Tenho uma implementação personalizada de controle deslizante. Quando ele está em :focus:visible, uso as teclas de seta ( Up/ Lefte Right/ Down) para mover o polegar. Suponho que isso seja suficiente para declarar o controle role="slider"em navegadores de desktop.

O que devo oferecer suporte em dispositivos com tela sensível ao toque?

MDN diz apenas:

Aviso: Para alterar o valor do controle deslizante, as tecnologias assistivas baseadas em toque precisam responder aos gestos do usuário para aumentar e diminuir o valor, sintetizando eventos-chave. Teste completamente os widgets de controle deslizante usando tecnologias assistivas em dispositivos onde o toque é o mecanismo de entrada principal antes de usar a função de controle deslizante (e todos os widgets de intervalo) .

ATUALIZAÇÃO Eu realmente acredito que não há necessidade de um MRE aqui, porque minha implementação é bem simples:

1. Eu uso o comportamento padrão de arrasto para o polegar. Há muitas implementações de arrasto, como uma incluída no jQuery UI , mas eu preferi o arrasto do interact.js (eixo Y travado, ou seja, unidimensional).

2. Para tornar o controle amigável para aqueles que têm dificuldades com movimentos E usuários de leitores de tela, eu também cuido das teclas de seta:

    function onArrowKey(e)
    {
        if (mouseDraggingIsInProcess)
            return;
    
        if (['ArrowDown', 'ArrowUp', 'ArrowLeft', 'ArrowRight'].includes(e.key))
        {
            e.stopImmediatePropagation();
            e.preventDefault();
    
            if (e.type == 'keydown')
            {
                const thumbPositionY = match(e)
                (
                    when(e => e.ctrlKey, 1),
                    when(e => e.shiftKey, (1 + options.stepsCount) / 2),
                    otherwise(options.stepsCount)
                );
    
                if ('ArrowDown' == e.key || 'ArrowRight' == e.key)
                    onThumbPositionChange(0, thumbPositionY);
                else if ('ArrowUp' == e.key || 'ArrowLeft' == e.key)
                    onThumbPositionChange(0, -thumbPositionY);
            }
            else if (e.type == 'keyup')
            {
                reset();
            }
        }
    }
        
    control.on('keydown keyup', onArrowKey);

onThumbPositionChange(0, thumbPositionY);é exatamente o mesmo manipulador que é chamado pelo comportamento arrastável .

Além disso, adicionei o divseguinte atributo:

<div aria-label="A joystick. Use arrow keys to move it fast.
Shift makes it move at medium speed. Control makes it move at slow speed.
After releasing the keys it returns to initial position." …>

Sou novo no dplyr e gostaria de saber uma maneira rápida de obter esses dados:

Para esses dados (contando cada sobrevivente por idade, ou seja, se um ID tem 5 anos, ele passou das idades 1, 2, 3, 4, 5, enquanto um ID de 2 passa apenas de 2 idades (1, 2) (isso faz sentido?):

Também é possível combinar o resultado anterior com estes (número de IDs na categoria)?:

Este foi meu código inicial para o último caso:

groupedDf <- inputDf %>%
               count(Age)  %>%
               group_by(Age = case_when(Age == 1 ~ '1',
                                          TRUE ~ as.character(Age))) %>%
               group_by(Age = case_when(Age == 2 ~ '2',
                                          TRUE ~ as.character(Age))) %>%
               group_by(Age = case_when(Age == 3 ~ '3',
                                          TRUE ~ as.character(Age))) %>%
               group_by(Age = case_when(Age == 4 ~ '4',
                                          TRUE ~ as.character(Age))) %>%
               group_by(Age = case_when(Age == 5 ~ '5',
                                          TRUE ~ as.character(Age))) %>%
               summarise(n = sum(n))  %>%
               arrange(nchar(Age), Age)

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

Considere o seguinte cenário (comum) ao lidar com, por exemplo, OpenGL:

Você tem void glUseProgram(GLuint program);, assim como uma série de outras funções que exigem GLuint; mas não há glGetUint, você está preso a glGetInteger.

Então, digamos que você tem

class Foo() {
public:
    Foo::Foo() {
        glGetIntegerv(GL_CURRENT_PROGRAM, &program);
    }

private:
    GLuint program;
    void Bar();
};

Por literalmente mais de 10 anos em nosso projeto, tivemos um trecho de código semelhante e somente agora, sem realmente alterar a configuração, o compilador começou a reclamar sobre esta conversão específica:

error: implicit conversion changes signedness: 'GLint' (aka 'int') to 'GLuint' (aka 'unsigned int') [-Werror,-Wsign-conversion] 

A solução é obviamente simples:

class Foo() {
public:
    Foo::Foo() {
        int _program;
        glGetIntegerv(GL_CURRENT_PROGRAM, &_program);
        program = static_cast<GLuint>(_program);
    }

private:
    GLuint program;
    void Bar();
};

Mas a questão é: posso fazer a mesma coisa em apenas uma etapa, sem precisar usar um int de escopo local no meio?

Estou trabalhando no vscode com Pylance e Pylint. Poder usar "ir para definição" e "encontrar todas as referências" é extremamente útil para mim. No entanto, quando passo uma instância de uma classe personalizada como argumento, ele não faz a conexão de que esse argumento é essa classe e não conecta esses pontos. Existe uma maneira de informar ao linter que esse argumento é uma determinada classe, para que, quando eu encontrar todas as referências de say_goodnightdentro de , AlphaClassele também encontre a instância dentro de make_it_say_goodnight? Neste exemplo simplificado, eu poderia obviamente mover a função como um método de classe, mas no meu código real isso não faria sentido.

class AlphaClass:
  def say_goodnight(self):
    print("Goodnight Kevin")

def make_it_say_goodnight(spam):
  print("Say Goodnight Kevin!")
  spam.say_goodnight()

macaulay = AlphaClass()
make_it_say_goodnight(macauly)