All perguntas(coding)

Não consegui encontrar documentação para esse comportamento e parece ser um bug ([Editar] de fato é: gitlab.haskell.org/ghc/ghc/-/issues/10387 ). Estou esquecendo de algo?

Em GHCi:

    > import GHC.Real
    > inf = 1/O :: Double

    > inf
    Infinity

    > infinity
    1 % 0

    > fromRational infinity
    Infinity

    > toRational inf
    179769313486231590... % 1
    
    > toRational inf == infinity 
    False

[Editar:]

Existe uma solução alternativa. Usando o pacote ieee754 , é possível definir o seguinte:

import GHC.Real
import qualified Numeric.IEEE as IEEE

toRational' :: (IEEE.IEEE a, Real a) => a -> Rational
toRational' a
  | a == IEEE.infinity = infinity
  | a == -IEEE.infinity = -infinity
  | otherwise = toRational a

Tenho dois dataframes:

pesquisa df:

oldId <- c(123, 456, 567, 789)
newId <- c(1, 2, 3, 4)
lookup <- data.frame(oldId, newId)

dados df:

descr <- c("description with no match",
+ "description with one 123 match", 
+ "description with again no match",
+ "description 456 with two 789 matches")

Meta:

Quero um novo dataframe:

• mesma estrutura que os dados df
• mesmos valores de campo, exceto que todas as instâncias de números (ou seja, 123, 456, 789) são pesquisadas no outro dataframe e substituídas por lookup$newId.

O dataframe resultante ficará assim:

1. "descrição sem correspondência"
2. "descrição com uma correspondência"
3. "descrição sem correspondência novamente"
4. "descrição 2 com duas 4 correspondências"

Portanto, cada texto na coluna descr pode conter uma grande quantidade de números que precisam ser substituídos. Claro, este é um exemplo simplificado; meus dataframes da vida real são muito maiores.

Eu corrigi a parte regex:

fx <- function(x) {gsub("([[:digit:]]{3})", "TESTTEST", x)}
data$descr <- lapply(data$descr, fx)

Mas não tenho ideia de como deixar a função percorrer todas as correspondências em uma linha e, então, procurar o número e substituí-lo.

Estou tentando descobrir um comando/script awk para extrair um bloco de texto de um arquivo grande. A subseção do arquivo em que estou interessado é esta:

  Board Info: #512
    Manufacturer: "Dell Inc."
    Product: "0X3D66"
    Version: "A02"
    Serial: "..CN7016343F00IE."
  Chassis Info: #768

As linhas Board Info e Chassis Info têm 2 espaços à esquerda, enquanto o bloco recuado tem 4. Eu gostaria de não presumir que a linha final começa com Chassis Info (pode ser outra coisa) e apenas confiar em chegar à próxima linha começando com 2 espaços.

Esse:

awk '/^\s{2}Board Info/,/^\s{2}[^B ]/' dump.txt

resolve esta instância específica, mas não funcionará se, em vez de 'Informações do chassi', a linha do bloco final começar com a letra B (por exemplo, BOM).

Se eu usar:

awk '/^\s{2}Board Info/,/^\s{2}\S*/' dump.txt

O padrão final também corresponde à linha "Informações do Quadro", então eu obtenho apenas essa linha. Como obtenho esse bloco recuado (4 espaços à esquerda) sem codificar o bloco final (como acima) e depender do padrão final ser "a próxima linha que começa com exatamente 2 espaços à esquerda"?

O trecho de código a seguir chama a select()função.

n = select(max_fd, NULL, &write_set, NULL, NULL)

Ele verifica a disponibilidade de gravação em alguns soquetes. Como geralmente está disponível, o tempo limite não é definido. Em certas iterações do loop, é possível que write_setesteja vazio.

Abaixo está o rastreamento. Não há mais saída, então presumo que o programa trave.

select(7, NULL, [], NULL, NULL

Minha pergunta é: esse é o comportamento correto? Se o conjunto estiver vazio, o select deve retornar imediatamente? Não há motivo para select()esperar, certo?

Alguém poderia me explicar por que usar uma chamada de função como argumento padrão falha quando o nome da função é o mesmo que o nome do argumento?

f1 <- function(){
  2
}

f2 <- function(f1 = f1()){
  f1 * 2
}

f2()
#> Error in f2(): promise already under evaluation: recursive default argument reference or earlier problems?

Entendo que a função pode ser feita funcionar (1) renomeando a função f1ou (2) renomeando o argumento para f2(veja abaixo), mas não consigo entender por que essas correções funcionam, enquanto o caso com nomes alinhados falha. Também entendo que muitos considerariam esse tipo de nomenclatura inadequada, mas, para os propósitos desta pergunta, estou interessado nos processos subjacentes a esse erro, não na deficiência de estilo associada.

Correção 1

f <- function(){
  2
}

f2 <- function(f1 = f()){
  f1 * 2
}

f2()
#> [1] 4

Correção 2

f1 <- function(){
  2
}

f2 <- function(.f1 = f1()){
  .f1 * 2
}

f2()
#> [1] 4

Agradeço desde já a sua ajuda.

Encontrei uma ocorrência estranha ao trabalhar com Ngrx Store e Angular. Basicamente, o objetivo da minha tarefa é mostrado neste exemplo com cerca de 10 mil entradas em Person[]:

Meu objetivo é mostrar certas pessoas com sobrenomes específicos. Esta é a primeira revisão que fiz, que é bem lenta:

export const selectPerson = createSelector(
  selectCitizensState,
  (citizensState: CitizensState): Person[] => citizensState.people ?? []
);

export const selectPeopleWithSurname = createSelector(
  selectPerson,
  selectSelectedSurnames,
  (people: Person[], surnames: string[]) => {
    if (surnames.length === 0) {
      return people;
    }
    return people.filter((person) => surnames.includes(person.surname));
  }
);

Eu criei isso por acidente e é muito mais rápido que o código acima:

export const selectPerson = createSelector(
  selectCitizensState,
  (citizensState: CitizensState): Person[] => [...(citizensState.people ?? [])]
);

Por que isso acontece? Estou apenas criando uma cópia superficial da propriedade store. Imagino que tenha algo a ver com a detecção de alterações do Ngrx ou algo assim, mas não tenho certeza.

Meu objetivo é adicionar um recurso ao existente TreeTableViewonde clicar no nó de divulgação de um grupo com Alta tecla pressionada deve expandir apenas o grupo associado, mas com todos os seus filhos (subgrupos) recolhidos, independentemente de terem sido expandidos anteriormente.

Sem que a Alttecla seja mantida pressionada, o nó de divulgação deve apenas acionar o comportamento "padrão".

Por exemplo, vamos supor que o usuário tenha a seguinte hierarquia de nós:

ROOT
-> GROUP_1
----> GROUP_1_1
--------> CHILD_1_1_1
--------> CHILD_1_1_2
--------> CHILD_1_1_3
----> GROUP_1_2
--------> CHILD_1_2_1
--------> CHILD_1_2_2
-> GROUP_2
-> GROUP_3
-> ...

Quando o usuário mantém pressionada a Alttecla e clica no nó de divulgação ao lado ROOTpara expandi-lo, espera-se que o sistema mostre. É essencial que os grupos GROUP_1_1e GROUP_1_2sejam recolhidos.

ROOT
-> GROUP_1
-> GROUP_2
-> GROUP_3
-> ...

A diferença entre esse comportamento e o padrão é que se o usuário mantiver a Alttecla pressionada e clicar no nó de divulgação ao lado, ROOTo sistema deverá garantir que tudo dentro dele seja recolhido no final.

Estou procurando funções como CellBehaviorBase#doSelecte TreeTableCellBehavior#handleDisclosureNode, mas até agora não consegui encontrar nenhuma dica de como conseguir o que quero.

Exemplo mínimo para meus testes. O objetivo é ter a possibilidade de expandir o grupo raiz ("Carros") com todos os subgrupos recolhidos quando ALTpressionado:

import javafx.application.Application;
import javafx.beans.property.SimpleStringProperty;
import javafx.beans.property.StringProperty;
import javafx.scene.Scene;
import javafx.scene.control.TreeItem;
import javafx.scene.control.TreeTableColumn;
import javafx.scene.control.TreeTableView;
import javafx.scene.layout.Pane;
import javafx.scene.layout.VBox;
import javafx.stage.Stage;

public class HelloApplication extends Application {
    @Override
    public void start(Stage stage) {
        Pane rootNode = new VBox();
        Scene scene = new Scene(rootNode, 400, 300);
        stage.setTitle("TreeTableView Demo");
        stage.setScene(scene);

        TreeTableView<Car> treeTableView = new TreeTableView<>();

        TreeTableColumn<Car, String> treeTableColumn1 = new TreeTableColumn<>("Brand");
        treeTableColumn1.setPrefWidth(120);
        TreeTableColumn<Car, String> treeTableColumn2 = new TreeTableColumn<>("Model");
        treeTableColumn2.setPrefWidth(120);

        treeTableColumn1.setCellValueFactory(param -> param.getValue().getValue().brandProperty());
        treeTableColumn2.setCellValueFactory(param -> param.getValue().getValue().modelProperty());

        treeTableView.getColumns().add(treeTableColumn1);
        treeTableView.getColumns().add(treeTableColumn2);

        TreeItem<Car> mercedes1 = new TreeItem<>(new Car("Mercedes", "SL500"));
        TreeItem<Car> mercedes2 = new TreeItem<>(new Car("Mercedes", "SL500 AMG"));
        TreeItem<Car> mercedes3 = new TreeItem<>(new Car("Mercedes", "CLA 200"));

        TreeItem<Car> mercedes = new TreeItem<>(new Car("Mercedes", "..."));
        mercedes.getChildren().add(mercedes1);
        mercedes.getChildren().add(mercedes2);

        TreeItem<Car> audi1 = new TreeItem<>(new Car("Audi", "A1"));
        TreeItem<Car> audi2 = new TreeItem<>(new Car("Audi", "A5"));
        TreeItem<Car> audi3 = new TreeItem<>(new Car("Audi", "A7"));

        TreeItem<Car> audi = new TreeItem<>(new Car("Audi", "..."));
        audi.getChildren().add(audi1);
        audi.getChildren().add(audi2);
        audi.getChildren().add(audi3);

        TreeItem<Car> cars = new TreeItem<>(new Car("Cars", "..."));
        cars.getChildren().add(audi);
        cars.getChildren().add(mercedes);

        treeTableView.setRoot(cars);

        rootNode.getChildren().add(treeTableView);

        stage.show();
    }

    public static void main(String[] args) {
        launch();
    }
}

class Car {
    private StringProperty brand = new SimpleStringProperty();
    private StringProperty model = new SimpleStringProperty();

    public Car(String brand, String model) {
        this.brand.set(brand);
        this.model.set(model);
    }

    public String getBrand() {
        return brand.get();
    }

    public StringProperty brandProperty() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand.set(brand);
    }

    public String getModel() {
        return model.get();
    }

    public StringProperty modelProperty() {
        return model;
    }

    public void setModel(String model) {
        this.model.set(model);
    }
}

Tenho um monte de sobrecargas de funções, consistindo principalmente em duas assinaturas:

void func(const my_type1&);  
void func(const my_type2&, hash_t);

e uma função que tenta chamar func com base na existência da função:

template <typename T>
void func_imp(const T& t, hash_t hash){
    if constexpr (has_func_with_2nd_param_v<T>){
        func(t, hash);
    }else{
        func(t);
    }
}

mas estou tendo problemas de conversão que acabam chamando a sobrecarga 'errada':

#include <type_traits>
#include <cstdio>

struct hash_t{
};

struct my_type1{
    my_type1() {}
};

struct my_type2{
    my_type2() {}
    my_type2(const my_type1&){}
};

void func(const my_type1&){
    printf("no hash\n");
}

void func(const my_type2&, hash_t=hash_t()){
    printf("hash\n");
}

template<typename T, typename = void>
struct has_func_with_2nd_param : std::false_type {};

template<typename T>
struct has_func_with_2nd_param<T, std::void_t<decltype(func(std::declval<T>(), std::declval<hash_t>()))>> : std::true_type {};

template<typename T>
constexpr bool has_func_with_2nd_param_v = has_func_with_2nd_param<T>::value;

// I want to route to the appropriate function without conversion routing to the wrong func
template <typename T>
void func_imp(const T& t, hash_t hash){
    if constexpr (has_func_with_2nd_param_v<T>){
        func(t, hash);
    }else{
        func(t);
    }
}

int main()
{
    // this is true as expected
    static_assert(has_func_with_2nd_param_v<my_type2>);

    // this is also true, since my_type2 is constructable from my_type1 and then finds finds func(my_type2, hash_t)
    static_assert(has_func_with_2nd_param_v<my_type1>);

    func_imp(my_type1(), hash_t()); // prints "hash", but wanting it to call the "no hash" version
    func_imp(my_type2(), hash_t()); // prints "hash"

    return 0;
}

Estou com dificuldades para encontrar a metafunção correta para obter o comportamento desejado. Alguém tem alguma ideia?

godbolt aqui

Procurei por todo lugar e não consigo encontrar uma resposta definitiva (atual) para essa pergunta.

Tenho um UILabel configurado para usar dimensionamento dinâmico de fontes por questões de acessibilidade. Funcionou muito bem com esta linha de código:

attributes[.font] = UIFont.preferredFont(forTextStyle: .body)

No entanto, a fonte padrão não funciona para mim do ponto de vista do design.

Quando tento usar uma fonte personalizada, faço isso:

attributes[.font] = UIFont(name: "Futura-Medium", size: 17)

Isso me força a definir o tamanho, o que acredito que anula a capacidade de alterar a fonte dinamicamente.

Eu adoraria descobrir uma de duas soluções...

Ou defina a preferredFont universalmente como a fonte da minha escolha. Ou uma linha de código melhor na qual eu possa selecionar uma fonte personalizada e ainda ajustá-la dinamicamente.

Para recapitular... Atualmente, meu resultado é dimensionar o texto corretamente, mas uma fonte genérica com este código:

var attributes = [NSAttributedString.Key: Any]()
attributes[.font] = UIFont.preferredFont(forTextStyle: .body)
attributes[.foregroundColor] = UIColor.black

Ou é uma fonte mais adequada, mas não escala nada com este código:

var attributes = [NSAttributedString.Key: Any]()
attributes[.font] = UIFont(name: "Futura-Medium", size: 17)
attributes[.foregroundColor] = UIColor.black

Estou explorando o novo recurso de dedução introduzido no C++23 e tentando entender como combiná-lo efetivamente com o Curiously Recurring Template Pattern (CRTP) para implementar comportamento polimórfico sem depender de funções virtuais tradicionais.

Meu objetivo é gerenciar uma coleção de objetos derivados (por exemplo, formas, processadores, etc.) de forma apagada ou semipolimórfica e ainda obter os benefícios do polimorfismo estático e possivelmente reduzir a indireção e a alocação dinâmica.

#include <vector>
#include <iostream>

template <typename Derived>
struct Base {
    void process(this Derived& self) {
        self.impl(); // supposed to call derived's impl()
    }
};

struct DerivedA : Base<DerivedA> {
    void impl() {
        std::cout << "DerivedA::impl\n";
    }
};

struct DerivedB : Base<DerivedB> {
    void impl() {
        std::cout << "DerivedB::impl\n";
    }
};

int main() {
    std::vector</* ??? */> collection;

    collection.push_back(DerivedA{});
    collection.push_back(DerivedB{});

    for (auto& obj : collection) {
        obj.process(); // call the correct impl() for each type
    }
}

Sei que essa std::varianté uma maneira de lidar com isso, mas estou procurando soluções alternativas de alto desempenho. Idealmente, gostaria de evitar a sobrecarga de alocações dinâmicas e funções virtuais e usar recursos modernos do C++23, como deduzir isso com CRTP, para obter os benefícios do polimorfismo estático.