tobiasBora's questions

Estou pensando sobre os internos do Svelte para projetar adequadamente meu aplicativo para ter eficiência máxima (posso lidar com (dezenas?) de milhares de elementos para atualizar, então eficiência importa), notavelmente com como a reatividade é implementada. Então, usando este pequeno exemplo (no link você pode inspecionar o código JS na aba direita), implementei este código básico:

<script>
    let foo = $state(42);
    let bar = $state(52);
</script>

<div onclick={() => foo = foo + 2}>
    Hello {foo}
</div>
<span onclick={() => bar = bar + 1}>
    Hello {bar}
</span>

e obtenho o seguinte JavaScript compilado:

import 'svelte/internal/disclose-version';
import * as $ from 'svelte/internal/client';

var on_click = (_, foo) => $.set(foo, $.get(foo) + 2);
var on_click_1 = (__1, bar) => $.set(bar, $.get(bar) + 1);
var root = $.template(`<div> </div> <span> </span>`, 1);

export default function App($$anchor) {
    let foo = $.state(42);
    let bar = $.state(52);
    var fragment = root();
    var div = $.first_child(fragment);

    div.__click = [on_click, foo];

    var text = $.child(div);

    $.reset(div);

    var span = $.sibling(div, 2);

    span.__click = [on_click_1, bar];

    var text_1 = $.child(span);

    $.reset(span);

    $.template_effect(() => {
        $.set_text(text, `Hello ${$.get(foo) ?? ''}`);
        $.set_text(text_1, `Hello ${$.get(bar) ?? ''}`);
    });

    $.append($$anchor, fragment);
}

$.delegate(['click']);

O que parece importante é o código:

    $.template_effect(() => {
        $.set_text(text, `Hello ${$.get(foo) ?? ''}`);
        $.set_text(text_1, `Hello ${$.get(bar) ?? ''}`);
    });

Se meu entendimento de sinais estiver correto (eu segui esta ótima postagem para entender como os sinais são implementados), isso executará a função de retorno de chamada toda vez que um sinal mudar internamente... mas o problema é que se barmudar, o código $.set_text(text, `Hello ${$.get(foo) ?? ''}`);também mudará, ou seja, mudar um sinal aciona operações O(n) onde n é o número de sinais... Com 2 elementos isso não é muito, mas se eu tiver dezenas de milhares de elementos, temo ter um tempo de atualização não desprezível.

Então eu tenho duas perguntas:

1. Por que o Svelte não implementa um retorno de chamada por sinal para ter uma complexidade O(1) independente do número de sinais?
2. Além disso, a mesma ideia é seguida por observable? Meu objetivo final é entender a complexidade das atualizações no liveQueryobservable do Dexie.js.

Eu estaria interessado em usar o MiniZinc por sua experiência no navegador e seu suporte a muitos solucionadores, mas ao mesmo tempo acho o CP-SAT (da OR-Tools) muito eficiente e gostaria de ter certeza de que, ao escolher usar o MiniZinc com o CP-SAT como backend, não perderei nada em comparação ao uso direto do CP-SAT.

Então aqui estão minhas perguntas: quão eficiente é a tradução MiniZinc -> CP-SAT? Tenho algum benefício em codificar coisas diretamente no CP-SAT? Se sim, posso, de alguma forma, fornecer instruções alternativas no MiniZinc, como uma especializada para CP-SAT e uma para qualquer backend genérico? Existe uma lista de restrições que são conhecidas por serem mais eficientes com CP-SAT diretamente em comparação com a tradução do minizinc?

Para dar um exemplo mais preciso, o CP-SAT tem muitas funções como "NoOverlap2D", "circuits", "AddReservoirConstraint"... mas sempre há uma restrição MiniZinc equivalente, e ela será compilada corretamente para o CP-SAT? Por exemplo, para o NoOverlap2D, parece que eu quero usar diffn, então se eu usar diffn, o CP-SAT usará o código NoOverlap2D otimizado por baixo dos panos, ou ele começará de um conjunto de instruções de nível mais baixo que pode ter mais dificuldade para otimizar?

Além disso, no desafio MiniZinc, o desempenho do CP-SAT é obtido por meio de um código escrito em MiniZinc ou diretamente por meio de um código otimizado para CP-SAT?