All perguntas(coding)

Eu tenho essa regex aaa.+?(?>bbb)je essa string de entrada aaa xxx bbby xxx bbbj. Quando executo essa regex, ela retorna aaa xxx bbby xxx bbbjMAS, como usei um grupo atômico, (?>bbb)a regex deveria ter falhado, porque li online que, ao usar um grupo atômico, o interpretador de regex não retrocede.

Então, ao encontrar o primeiro bbbna string de entrada, ele deve "ficar" com ele, então ele verificará a próxima letra e será yque não é a pretendida, jentão ele deve desistir e falhar. No entanto, por algum motivo, o interpretador regex continua tentando e, eventualmente, encontra o último bbbj. Como posso fazê-lo falhar no primeiro bbbque encontrou?

OBSERVAÇÃO: Tentei usar o quantificador ganancioso/preguiçoso, mas não fez diferença no caso acima.

Estou tentando extrair o texto desejado de um conjunto de texto fornecido. Criei a função abaixo.

   def extract_name(title):
        matches = re.findall(r'\b[A-Z0-9\s&.,()-]+(?:\s*\(\d\))?\b', title)
        return ', '.join(matches) if matches else None

Mas, ele produz indesejados (, ,para alguns títulos. Por exemplo, meus títulos são como abaixo.

THETA COMMERCIALS (2005) LIMITED, TEST CONNECTIONS LTD (In Relation), NANO CARE LIMITED (In Relation)

Resultado esperado:THETA COMMERCIALS (2005) LIMITED, TEST CONNECTIONS LTD, NANO CARE LIMITED

Como posso adicionar um controle de bússola ao meu mapa? Costumava haver uma função chamada addControlCompassem leaflet.extras, eu acredito, mas não existe mais. Alguém sabe como adicionar uma bússola ou uma seta indicando north up?

library(leaflet)
library(leaflet.extras)

# Create a basic Leaflet map
map <- leaflet() %>%
  addTiles() %>%
  setView(lng = -121.2722, lat = 38.1341, zoom = 10)  

# Add a scale bar and compass to the map
map <- map %>%
  addScaleBar(position = "bottomleft", options = scaleBarOptions(maxWidth = 100, metric = TRUE, imperial = FALSE)) %>%
  addControlCompass(position = "topright", options = compassOptions())
  map

Quero criar uma regex que corresponda a todos os caracteres sem escape $em strings que representam uma regex.

Nesse caso, um caractere não é escapado se ele contiver um número igual de barras invertidas atrás dele (cada par de barras invertidas representa o próprio caractere de barra invertida e, portanto, o próximo caractere não é escapado).

Eu criei este padrão: (?<!\\)(\\{2})*\$

Explicação: embora isso também corresponda às barras invertidas que precedem o $, essa é a solução mais próxima que cheguei. Isso garante um número igual de barras invertidas antes de a $que não é precedido por outra barra invertida, resultando em um número ímpar de barras invertidas.

Meu problema é que parece que preciso de 2 grupos consecutivos não consumidores para tornar o número total de barras invertidas par, mas isso não é possível. Existe outra maneira de fazer isso?

Sou novo no uso do Angular.

Ao usar um layout de grade, não estou obtendo o que quero. Para depurar, criei o seguinte elemento:

    <div *ngFor=" let tableVersionHeader of tableVersion.xAxis.tableVersionHeaders"
         class="grid-cell text"
         [ngStyle]="{
          'height': 'auto',
          'text-align': 'center !important',
          'border': '1px solid black',
          'padding': '8px',
          'grid-column': tableVersionHeader.columnIndex + 2 + ' / span ' + tableVersionHeader.breadth,
          'grid-row':  tableVersionHeader.level + ' / span ' + ((tableVersionHeader.children!.length === 0 || !tableVersionHeader.isAbstract)) ? (tableVersion.xAxis.rowCount - (tableVersionHeader.level ?? 0)) : 1
         }">
      <p>{{tableVersionHeader.headerVersion?.code}} - {{tableVersionHeader.headerVersion?.label}}</p>
      <p>grid-column: {{tableVersionHeader.columnIndex + 2}} / span {{tableVersionHeader.breadth}}</p>
      <p>grid-row: {{tableVersionHeader.level}} / span {{((tableVersionHeader.children!.length === 0 || !tableVersionHeader.isAbstract)) ? (tableVersion!.xAxis.rowCount - (tableVersionHeader.level ?? 0)) : 1}}</p>
    </div>

Como você pode ver, estou imprimindo os valores que espero para grid-columne grid-rowem meus divs.

Minha saída é, por exemplo:

0008 - Internal rating scale

grid-column: 2 / span 1

grid-row: 1 / span 1

Enquanto o estilo definido no elemento é:

height: auto;
border: 1px solid black;
padding: 8px;
grid-area: 3 / 2 / auto / span 1;

De alguma forma, angular (?) reescreve os valores grid-columne para, mas não da maneira correta.grid-rowgrid-area

Não consegui encontrar uma referência sobre o porquê do angular estar fazendo isso e como pará-lo. Verifiquei duas vezes com o Firefox e o Chrome, ambos mostram o mesmo comportamento.

Agradecemos antecipadamente sua ajuda.

Editar: código de exemplo do Stackblitz https://angular-3plybjxk.stackblitz.io

Posso paralelizar a execução usando o Hyper e funciona:

$ raku -e 'race for (^8).race(batch => 1, degree => 4) {sleep rand; .say}'
0
3
5
2
1
7
4
6

Mas como posso adicionar comportamento gather/take a esse loop?

Nessa abordagem, take não detectará que está encapsulado no contexto gather:

$ raku -e '
    my @x = gather race for (^8).race(batch => 1, degree => 4) {
        sleep rand;
        take $_;
    };
    @x.say
'

Died at:
    take without gather

Nessa abordagem, o gather consumirá o HyperSeq sem realmente "hiper" sobre ele:

$ raku -e '
    my @x = race gather for (^8).race(batch => 1, degree => 4) {
        sleep rand;
        take $_;
    };
    @x.say
'

[0 1 2 3 4 5 6 7]

Estou tentando implementar o modelo usando uma função globalmente sobrecarregada para executar ações personalizadas por assinatura. Como pode haver um grupo de tipos (por exemplo, tipos numéricos) com uma implementação semelhante, tentei usar conceitos para cobri-lo, mas tropecei no problema em que o compilador não vê a definição com conceito sem instanciação explícita.

MSVC 17.13.0 (/std:c++latest)

// my.hpp
template <typename value_type>
void bar(value_type value);

template <typename value_type>
void foo(value_type value)
{
    bar<value_type>(value);
}

// my.cpp
#include "my.hpp"
#include <print>
#include <type_traits>

template<std::integral value_type>
void bar(value_type value)
{
    std::println("bar(integral[{}])", value);
}

int main()
{
    //bar(5);
    foo(6);
}

O programa acima não é compilado porque o vinculador não vê bara definição de :

símbolo externo não resolvido "void __cdecl bar(int)" (??$bar@H@@YAXH@Z) referenciado na função "void __cdecl foo(int)" (??$foo@H@@YAXH@Z)

Porém, se eu descomentar a linha bar(5);em main(), isso obviamente instanciará o modelo restrito ao conceito, e o resultado será adequado (mas com saída extra da chamada direta bar(5)):

barra(integral[5])

barra(integral[6])

Existe um padrão comum para resolver tal tarefa? Basicamente, eu quero que o template que recebe o tipo seja capaz de encontrar a definição adequada da função template em si, void bar<int>no meu caso.

DB-Violino

CREATE TABLE vouchers (
    id SERIAL PRIMARY KEY,
    customer VARCHAR,
    collected_date DATE,
    balance INT
);

INSERT INTO vouchers
(customer, collected_date, balance
)
VALUES 
('customer_a', '2024-03-09', '1600'),
('customer_a', '2024-04-20', '2700'),
('customer_a', '2024-05-24', '3100'),
('customer_a', '2025-03-09', '1500'),
('customer_a', '2025-04-20', '400'),
('customer_a', '2025-05-24', '0'),
('customer_b', '2024-10-17', '200'),
('customer_b', '2025-02-15', '1000'),
('customer_b', '2025-10-17', '800'),
('customer_b', '2025-11-18', '950'),
('customer_b', '2026-02-15', '1150'),  
('customer_b', '2026-11-18', '0');

Resultado esperado:

No resultado esperado, quero exibir apenas o mais recente disponível balancepor customercom base em uma determinada data.
Neste exemplo 2025-03-31.

Até agora consegui desenvolver esta consulta:

select
    customer as customer,
    collected_date as collected_date,
    sum(balance) as balance,
    max(collected_date) over (partition by customer) AS max_date
from vouchers
where collected_date < '2025-03-31' 
group by 1, 2
order by 1, 2 desc;

Ele quase me leva ao resultado correto. No entanto, não consegui fazê-lo funcionar completamente.
O que preciso mudar para obter o resultado esperado?

Aqui está a definição da mônada de estado do capítulo 13 de Learn You a Haskell

instance Monad (State s) where
    return x = State $ \s -> (x,s)
    (State h) >>= f = State $ \s -> let (a, newState) = h s
                                        (State g) = f a
                                    in  g newState

Com base nessa definição, parece-me que o estado na tupla retornada por f aserá substituído por newStatemesmo que seja a versão mais recente. Para pegar um exemplo específico do capítulo 10 do Real World Haskell, onde isso claramente não é o que os autores pretendem (observe o uso de em vez de porque eles ainda não introduziram formalmente as mônadas)==>>>=

parseByte :: Parse Word8
parseByte =
    getState ==> \initState ->
    case L.uncons (string initState) of
      Nothing ->
          bail "no more input"
      Just (byte,remainder) ->
          putState newState ==> \_ ->
          identity byte
        where newState = initState { string = remainder,
                                     offset = newOffset }
              newOffset = offset initState + 1

Onde

newtype Parse a = Parse {
      runParse :: ParseState -> Either String (a, ParseState)
    }

identity :: a -> Parse a
identity a = Parse (\s -> Right (a, s))
 
(==>) :: Parse a -> (a -> Parse b) -> Parse b
firstParser ==> secondParser  =  Parse chainedParser
  where chainedParser initState   =
          case runParse firstParser initState of
            Left errMessage ->
                Left errMessage
            Right (firstResult, newState) ->
                runParse (secondParser firstResult) newState

Em parseByte, não vejo como initStatenão substitui newState.

Eu tenho um number[] | string[]e quero filtrá-lo. O problema é que a função de filtro muda o tipo para (number | string)[]instead.

// list of numbers OR list of strings
let myList = Math.random() < 0.5 ? [1, 2, 3] : ["a", "b", "c"];

// filter the list
const filtered = myList.filter((x) => { return true; });

// oh no, the result is Array<number | string> instead of (number[] | string[])
myList = filtered;

Erro na última linha:

Type '(string | number)[]' is not assignable to type 'number[] | string[]'.
  Type '(string | number)[]' is not assignable to type 'number[]'.
    Type 'string | number' is not assignable to type 'number'.
      Type 'string' is not assignable to type 'number'.(2322)

Como posso expressar o fato de que a matriz não pode ser mista , mas pode conter qualquer tipo de elemento?

Link do parque infantil