All perguntas(coding)

Estou bastante confortável com o Agda. Decidi experimentar o Lean, mas acho que a igualdade proposicional está realmente me atrapalhando. Às vezes, acho que o RFL simplesmente funciona, mas outras vezes não, por razões que me escapam completamente, o que é bastante frustrante. Para dar um exemplo:

inductive Λ where
  | var : String → Λ
  | app : Λ → Λ → Λ
  | abs : String → Λ → Λ
  deriving Repr, BEq, DecidableEq

def FV : Λ → HashSet String
  | Λ.var x => HashSet.ofList [x]
  | Λ.app m n  => FV m ∪ FV n
  | Λ.abs x m => (FV m).erase x
  
#eval FV (Λ.var "x")  -- Std.HashSet.ofList ["x"]
example : FV (Λ.var "x") = HashSet.ofList ["x"] := rfl  -- fine
example : (2 == 1 + 1) = true := rfl -- fine
#eval FV (Λ.var "x") == HashSet.ofList ["x"]  -- true
example : (FV (Λ.var "x") == HashSet.ofList ["x"]) = true := rfl
--type mismatch
--  rfl
--has type
--  ?m.9390 = ?m.9390 : Prop
--but is expected to have type
--  (FV (Λ.var "x") == HashSet.ofList ["x"]) = true : Prop

As expressões são avaliadas conforme o esperado, mas nos dois primeiros exemplos, rfl funciona perfeitamente, mas no último, misteriosamente, não funciona, aparentemente sem reduzir os termos em ambos os lados de = . Eu poderia imaginar dois HashSets com os mesmos valores nem sempre sendo iguais, pois poderiam ter acabado em grupos diferentes, mas não tenho certeza se esse é o problema, porque parece ser avaliado perfeitamente.

Sou iniciante em C#. Estou tentando converter uma string JSON em uma lista parecida com esta:

firstName   lastName  departmentID
John        Doe       AAA111
John2       Doe2      BBB222

Postagem atualizada - com base na resposta do David (obrigado por isso). Desculpe por toda a confusão que posso ter causado.

Aqui está o código:

public IActionResult JsonTest()
{

    var respJSON = @"
        [
              {
                ""firstName"": ""John"",
                ""lastName"": ""Doe"",
                ""departmentID"": { ""id"": ""AAA111"" },
              },
              {
                ""firstName"": ""John2"",
                ""lastName"": ""Doe2"",
                ""departmentID"": { ""id"": ""BBB222"" }
              }
          ]
        ";

    List<UserNameWithDept> user = JsonConvert.DeserializeObject<List<UserNameWithDept>>(respJSON);

    return Ok();
}


public class Identifier
{
    [JsonProperty("id")]
    public string Id { get; set; }
}

public class UserNameWithDept
{
    [JsonProperty("firstName")]
    public string FirstName { get; set; }

    [JsonProperty("lastName")]
    public string LastName { get; set; }

    [JsonProperty("departmentID")]
    public Identifier Department { get; set; }
}

Estou pegando o Departamento como um objeto e então o valor dentro dele.

Como posso fazer a lista ficar assim? Departamento tem valor, não objeto.

Department  "AAA111"
FirstName   "John"
LastName    "Doe"

Resumindo um problema maior ao essencial, eu gostaria de fazer o seguinte:

import numpy as np
import pandas as pd

df = pd.DataFrame({'a': np.random.randint(0, 5, 1000), 'b': np.random.random(1000)})

for aval, subdf in df.groupby('a'):
    subdf.to_parquet(f'/tmp/{aval}.parquet')

em Polares usando LazyFrame:

import numpy as np
import pandas as pd
import polars as pl

df = pd.DataFrame({'a': np.random.randint(0, 5, 1000), 'b': np.random.random(1000)})

lf = pl.LazyFrame(df)
# ???

Gostaria de poder controlar o nome dos arquivos de saída de maneira semelhante.

Obrigado!

No C++ moderno é possível escrever um alias de função membro com uma sintaxe diferente desta:

class C {
   int f(int a) { return ++a; }
   inline int g(int a) { return f(a); }
};

Tentei de algumas maneiras, mas nenhuma funcionou:

class C {
   int f(int a) { return ++a; }
   const auto g1 = f;  // error: 'auto' not allowed in non-static class member
   auto& g2 = f;       // error: 'auto' not allowed in non-static class member
   using g3 = f;       // error: unknown type name 'f'
};

Por favor, não sugira usar o pré-processador...

Por que preciso disso? Porque:

• Tenho um código existente que não posso modificar e que usa a função de membro antiga, e um código novo que deve usar a nova.
• Gostaria de evitar a chamada extra (mesmo que ela possa ser otimizada).

PS: erros gerados pelo clang 20.1.0

O problema básico é que preciso gerar todas as correspondências de uma regex dentro de um arquivo, mas há algumas propriedades que tornam a solução complicada:

1. O arquivo pode ser muito grande, então não é possível trazê-lo para a memória e digitalizá-lo inteiro de uma só vez.
2. O regex é fornecido pelo usuário, portanto não há estimativa de quão grande uma correspondência poderia ser
3. A expressão regular pode ter várias linhas, o que torna as correspondências possíveis ainda mais longas, e a varredura por linha pode fazer com que uma correspondência que cruze as linhas seja perdida.
4. Cada correspondência deve ser retornada com sua posição no arquivo inteiro.
5. As correspondências devem ser avaliadas lentamente (não há necessidade de encontrar todas as correspondências no arquivo de uma vez)

Como exemplo para 3, este algoritmo

while (not end of file):
  line = file.readNextLine()
  for (each match in regex.find(line)):
    results.append(match)
return results

quebras no caso de

// inline modifier to turn on DOTALL
regex = "(?s)start.*end"
content = "start
end"

porque startentão endseriam apresentados individualmente, quando o ponto pudesse corresponder a um caractere de nova linha.

Minha ideia atual é implementar Iterator<MatchResult>, e ler em a CharBuffercomo uma janela deslizante. java.util.regex.MatcherTambém tem hitEnd(), que pode sinalizar se mais entradas teriam alterado o resultado da última find()operação (se a expressão regular for "foobar" e o correspondente tiver sido avaliado em "foo", hitEnd()retornaria verdadeiro. Se o correspondente tiver sido avaliado em "bar", retornaria falso). Se o buffer estiver cheio e mais entradas puderem encontrar uma correspondência, o tamanho do buffer será dobrado até que uma correspondência seja encontrada. Eu poderia implementar Spliteratorem vez disso, mas não sei se isso é mais ou menos complicado.

Até agora, tenho esta estrutura básica (omitindo o tratamento de exceções por questões de brevidade):

public class RegexStreamIterator implements Iterator<MatchResult> {
  private static final int MIN_BUFFER_SIZE_BYTES = 8192;
  private static final int MAX_BUFFER_EXPANSIONS = 4;
  private static final int MAX_BUFFER_SIZE_BYTES = (int) Math.pow(2, MAX_BUFFER_EXPANSIONS) * MIN_BUFFER_SIZE_BYTES;

  private final Reader reader;
  private final Pattern pattern;

  private int readerIndex = 0;
  private Matcher matcher;
  private CharBuffer buffer = CharBuffer.allocate(MIN_BUFFER_SIZE_BYTES);
  private MatchResult currentMatch;

  public RegexStreamIterator(Reader reader, Pattern pattern) {
    this.reader = reader;
    this.pattern = pattern;
  }

  public boolean hasNext() {
    if (currentMatch != null) return true;
    advance();
    return currentMatch != null;
  }

  public MatchResult next() {
    if (currentMatch == null)
      advance();
    if (currentMatch == null)
      throw new NoSuchElementException();

    MatchResult ret = currentMatch;
    currentMatch = null;
    return ret;
  }

  private void advance() {
    // pseudocode while I'm stuck on actual implementation
    if matcher is null
      fill buffer
      if buffer is null
        return
      matcher = pattern.matcher(buffer)
    
    while not end of file:
      if matcher found result and not matcher.hitEnd() // match found and won't grow or get rejected with more input
        this.currentMatch = match
        advance matcher to next match
        return

      if matcher.hitEnd()
        if no match was found in buffer (matcher start index at 0)
          double buffer size 
            if new size bigger than max size, throw exception
          fill from file 
          reset matcher
        else (part of buffer consumed)
          move remaining buffer to new buffer 
          fill from file
          reset matcher
      else
        clear buffer (resetting size)
        fill from file
        reset matcher
  }
}

Estou muito preso a problemas como o tratamento de nulos e a criação de um loop que possa buscar a próxima correspondência e seja estável entre várias chamadas para advance(). Isso parece ser um problema que já foi resolvido antes. Se bibliotecas comuns como Apache ou Guava tiverem algo que cubra isso, seria fantástico.

Estou tentando aplicar um evento de mouseover para transformar uma imagem original em uma nova imagem e, em seguida, retornar à imagem original ao remover o mouse. No entanto, os arquivos de imagem originais são muito grandes, então estou usando uma classe de contêiner para exibi-los no tamanho desejado.

O problema é que quando passo o mouse sobre a imagem, ela exibe a nova imagem, mas ela está no tamanho original, em vez de estar dentro das restrições do contêiner.

const imageContainer = document.querySelector('.flex-container');
const image = document.getElementById('bookCover2');
const originalSrc = 'Book_2_Cover.png';
const newSrc = 'Book_2_Back.png';

imageContainer.addEventListener('mouseover', () => {
image.src = newSrc;
});

imageContainer.addEventListener('mouseout', () => {
image.src = originalSrc;
});

Estou trabalhando com a consulta delta do Microsoft Graph para que os usuários rastreiem alterações em objetos do usuário.

Quando uso a solicitação HTTP diretamente (por exemplo, via Postman ou Invoke-RestMethod), recebo a resposta esperada, incluindo @odata.deltaLink e/ou @odata.nextLink, como esta:

{
  "@odata.context": "https://graph.microsoft.com/v1.0/$metadata#users",
  "value": [
    {
      "id": "some-user-id",
      "displayName": "John Doe"
    }
  ],
  "@odata.deltaLink": "https://graph.microsoft.com/v1.0/users/delta?$deltatoken=abc123"
}

No entanto, quando tento executar a mesma consulta delta usando o Microsoft Graph PowerShell SDK (por exemplo, usando Get-MgUserDelta) , recebo uma resposta diretamente, e @odata.deltaLink ou @odata.nextLink está faltando na resposta.

Como posso recuperar @odata.deltaLink e @odata.nextLink ao usar o Microsoft Graph PowerShell SDK?

Isso é o que espero ao executar Get-MgUserDelta

{
  "@odata.context": "https://graph.microsoft.com/v1.0/$metadata#users",
  "value": [
    {
      "id": "some-user-id",
      "displayName": "John Doe"
    }
  ],
  "@odata.deltaLink": "https://graph.microsoft.com/v1.0/users/delta?$deltatoken=abc123"
}

Usuários com privilégios EXECUTE para funções receberão um erro ao tentar executar a função, se não tiverem privilégios nos objetos referenciados na função.

Criei uma função my_function. Dentro dela, seleciono/insiro/atualizo/excluo dados de uma tabela my_table. Em seguida, concedo o privilégio EXECUTE a outro usuário, "user1".

Entretanto, quando o usuário1 tenta executar a função, ela falha com a mensagem "permissão negada para a tabela my_table".

Não quero dar permissão ao usuário user1 para acessar a tabela my_table diretamente. Esse é o propósito de criar a função my_function, pois quero controlar quais dados o user1 pode ver/modificar.

Isso é uma limitação (defeito) do Postgres? Para mim, isso é um grande problema de segurança/privacidade. Existe uma maneira de superar isso? Ou temos que conviver com isso?

Minha versão do Postgres é 15.x

Estou experimentando escrever uma classe leve de sinais/observadores que tem a seguinte interface (implementação removida para simplificação):

template <typename ... ARGS>
class Signal
{
public:
    void connect(AbstractSlot<ARGS...>& slot);
    void disconnect(AbstractSlot<ARGS...>& slot);
    void emit(const ARGS&...args);

    //...
};

Que é usado, por exemplo, assim:

Signal<> signal1; //A signal with no parameters
Signal<int, int> signal2; //A signal with two int parameters

signal1.emit();
signal2.emit(10, 20);

Quero poder tornar minha classe opcionalmente thread-safe. Pensei em modificar meu modelo para aceitar uma classe de "política de bloqueio" que, por padrão, é "vazia".

struct NoLock
{
    void lock() {}
    void unlock() {}
};

Na minha cabeça, eu gostaria de poder usar o modelo de sinal modificado assim:

Signal<> signal1;
Signal<std::mutex> signal1Locked;
Signal<int, int> signal2;
Signal<int, int, std::mutex> signal2Locked;

O que exigiria que eu escrevesse o modelo assim:

template <typename ... ARGS, typename LockPolicy = NoLock>
class Signal;

Exceto que isso não é C++ válido (e eu entendo o porquê; como o compilador saberia a diferença entre os argumentos policy e variadic).

Minha pergunta é: como posso alcançar o que desejo em uma sintaxe que não seja muito confusa/complexa de usar?

Estou tentando escrever um código Terraform que pegue um objeto aninhado e crie recursos. Normalmente, isso seria feito com o bloco dinâmico, mas o recurso em questão não oferece suporte a isso. Alguém tem alguma ideia sobre qual seria a melhor abordagem para lidar com isso?

A configuração ficaria assim:

 dashboards = {
  "Test Dashboards" = {
    folder_name = "Test Folder"
    dashboards = [
      {
        file.          = "test.json"
        overwrite      = true
      },
      {
        file           = "test1.json"
        overwrite      = false
      }
    ]
  }
}

e então na criação de recursos, normalmente seria algo assim:

resource "grafana_dashboard" "dashboards" {
  for_each    = var.dashboards
  folder      = each.value.folder_name
  dynamic "dashboard" {
    for_each = each.value.dashboards
      content {
        config_json    = file("../../dashboards/${dashboards.value["file"]}")
        overwrite      = dashboards.value["overwrite"]
      }
  }
}

Mas o bloco dinâmico não é suportado por esse recurso. A única maneira é não duplicar a configuração, pois ela pode ser compartilhada com vários recursos, se isso fizer sentido.