All perguntas(coding)

vamos pegar este pequeno exemplo:

std::expected<std::any, Fault> doN(int n) 
{
    switch (n) 
    {
        case 1: return do1();
        case 2: return do2();
        // ...
    }
}

std::expected<int, Fault> do1()
{
    if (error)
    {
        return std::unexpected<Fault>({/* ... */});
    }
    return 23;
}

Se eu fizer dessa forma e chamar auto result = doN(1)sem erros, então result.value()o tipo é std::expected<int, Fault>e não int(sem mencionar o any_cast).

A maneira que encontrei para resolver isso é destruir o resultado da chamada interna:

std::expected<std::any, Fault> doN(int n)
{
    switch (n) 
    {
        case 1: 
            auto value = do1();
            if (value.has_value()) {
                return value.value();
            }
            return std::unexpected(value.error());
        // ...
    }
}

O tipo doN(1).value()é int.

Então minha pergunta é: Como posso simplificar isso? Existe uma maneira de retornar o resultado da chamada de função?

Eu tinha o programa C abaixo:

__int64_t fib_tr_const (__int64_t n, __int64_t n_1, __int64_t n_2)
{
    if (n == 0x42 || n == 0x43 ) {
        return n_1 + n_2;
    }

    return 0x31 + fib_tr_const (n-1, n_2, n_1 + n_2);
}


void main (int argc, char ** argv)
{
    __int64_t n = atoi (argv[1]);
    // printf("fib(%ld) = %ld\n", n, fib(n));
    // printf("fib_tr(%ld) = %ld\n", n, fib_tr(n, 0, 1));
    __int64_t volatile result = 0x4567;
    printf ("11111\n");
    printf ("11111\n");
    result = fib_tr_const(n, 0x123, 0x234);
    printf ("22222\n");
    printf ("22222\n");
    printf("fib_tr_const(%ld) = %ld\n", n, result);
}

E eu construí isso com -O2.

gcc tail_call.c -O2 -o tail_call_const_O2

Desmontei o binário:

O principal():

00000000000010a0 <main>:
    10a0:   f3 0f 1e fa             endbr64 
    10a4:   41 54                   push   %r12
    10a6:   ba 0a 00 00 00          mov    $0xa,%edx
    10ab:   48 83 ec 10             sub    $0x10,%rsp
    10af:   48 8b 7e 08             mov    0x8(%rsi),%rdi
    10b3:   31 f6                   xor    %esi,%esi
    10b5:   e8 c6 ff ff ff          callq  1080 <strtol@plt>
    10ba:   48 8d 3d 43 0f 00 00    lea    0xf43(%rip),%rdi        # 2004 <_IO_stdin_used+0x4>
    10c1:   48 c7 44 24 08 67 45    movq   $0x4567,0x8(%rsp)
    10c8:   00 00 
    10ca:   4c 63 e0                movslq %eax,%r12
    10cd:   e8 9e ff ff ff          callq  1070 <puts@plt>
    10d2:   48 8d 3d 2b 0f 00 00    lea    0xf2b(%rip),%rdi        # 2004 <_IO_stdin_used+0x4>
    10d9:   e8 92 ff ff ff          callq  1070 <puts@plt>


------------------START-------------------

    10de:   49 8d 44 24 ff          lea    -0x1(%r12),%rax
    10e3:   48 83 f8 01             cmp    $0x1,%rax
    10e7:   76 75                   jbe    115e <main+0xbe>
    10e9:   4c 89 e0                mov    %r12,%rax
    10ec:   31 c9                   xor    %ecx,%ecx
    10ee:   ba 01 00 00 00          mov    $0x1,%edx
    10f3:   31 ff                   xor    %edi,%edi
    10f5:   eb 0c                   jmp    1103 <main+0x63>
    10f7:   66 0f 1f 84 00 00 00    nopw   0x0(%rax,%rax,1)
    10fe:   00 00 
    1100:   48 89 f2                mov    %rsi,%rdx
    1103:   48 8d 34 17             lea    (%rdi,%rdx,1),%rsi
    1107:   48 89 c7                mov    %rax,%rdi
    110a:   48 83 e8 01             sub    $0x1,%rax
    110e:   48 01 f9                add    %rdi,%rcx
    1111:   48 89 d7                mov    %rdx,%rdi
    1114:   48 83 f8 02             cmp    $0x2,%rax
    1118:   75 e6                   jne    1100 <main+0x60>
    111a:   48 01 f2                add    %rsi,%rdx
    111d:   48 01 d1                add    %rdx,%rcx
    1120:   48 8d 3d e3 0e 00 00    lea    0xee3(%rip),%rdi        # 200a <_IO_stdin_used+0xa>
    1127:   48 89 4c 24 08          mov    %rcx,0x8(%rsp)

------------------END-------------------


    112c:   e8 3f ff ff ff          callq  1070 <puts@plt>
    1131:   48 8d 3d d2 0e 00 00    lea    0xed2(%rip),%rdi        # 200a <_IO_stdin_used+0xa>
    1138:   e8 33 ff ff ff          callq  1070 <puts@plt>
    113d:   48 8b 4c 24 08          mov    0x8(%rsp),%rcx
    1142:   48 83 c4 10             add    $0x10,%rsp
    1146:   31 c0                   xor    %eax,%eax
    1148:   4c 89 e2                mov    %r12,%rdx
    114b:   48 8d 35 be 0e 00 00    lea    0xebe(%rip),%rsi        # 2010 <_IO_stdin_used+0x10>
    1152:   bf 01 00 00 00          mov    $0x1,%edi
    1157:   41 5c                   pop    %r12
    1159:   e9 32 ff ff ff          jmpq   1090 <__printf_chk@plt>
    115e:   ba 01 00 00 00          mov    $0x1,%edx
    1163:   31 c9                   xor    %ecx,%ecx
    1165:   eb b6                   jmp    111d <main+0x7d>
    1167:   66 0f 1f 84 00 00 00    nopw   0x0(%rax,%rax,1)
    116e:   00 00 

O fib_tr_const():

00000000000012e0 <fib_tr_const>:
    12e0:   f3 0f 1e fa             endbr64 
    12e4:   48 8d 47 be             lea    -0x42(%rdi),%rax
    12e8:   48 89 f9                mov    %rdi,%rcx
    12eb:   48 83 f8 01             cmp    $0x1,%rax
    12ef:   77 0a                   ja     12fb <fib_tr_const+0x1b>
    12f1:   eb 35                   jmp    1328 <fib_tr_const+0x48>
    12f3:   0f 1f 44 00 00          nopl   0x0(%rax,%rax,1)
    12f8:   48 89 c2                mov    %rax,%rdx
    12fb:   48 83 ef 01             sub    $0x1,%rdi
    12ff:   48 8d 04 16             lea    (%rsi,%rdx,1),%rax
    1303:   48 89 d6                mov    %rdx,%rsi
    1306:   48 83 ff 43             cmp    $0x43,%rdi
    130a:   75 ec                   jne    12f8 <fib_tr_const+0x18>
    130c:   48 8d 34 49             lea    (%rcx,%rcx,2),%rsi
    1310:   48 01 c2                add    %rax,%rdx
    1313:   48 c1 e6 04             shl    $0x4,%rsi
    1317:   48 8d 8c 31 2d f3 ff    lea    -0xcd3(%rcx,%rsi,1),%rcx
    131e:   ff 
    131f:   48 8d 04 0a             lea    (%rdx,%rcx,1),%rax
    1323:   c3                      retq   
    1324:   0f 1f 40 00             nopl   0x0(%rax)
    1328:   48 89 d0                mov    %rdx,%rax
    132b:   48 89 f2                mov    %rsi,%rdx
    132e:   31 c9                   xor    %ecx,%ecx
    1330:   48 01 c2                add    %rax,%rdx
    1333:   48 8d 04 0a             lea    (%rdx,%rcx,1),%rax
    1337:   c3                      retq   
    1338:   0f 1f 84 00 00 00 00    nopl   0x0(%rax,%rax,1)
    133f:   00 

Com os marcos printf ("11111\n");e printf ("22222\n");, e assim putsem montagem. Acredito que a parte entre STARTe ENDdeve ser onde as main()chamadas fib_tr_const().

Não vejo nenhuma callou jmpinstruções que ramifiquem de main() para fib_tr_const(). Então como essa função é chamada?

Comparei a montagem entre os pontos marcados com a montagem do fib_tr_const(). O código asm parece ser similar. Parece que a função fib_tr_const() é inlined .

Outra questão surge - se a função é inlined, por que o código ainda existe no binário final? Economizaria espaço se fosse removido, então por que isso não acontece?

Aqui está o código:

fn main() {
    let foo: Foo<i32> = Foo(42);
    let bar: Foo<i64> = foo.map_ref(|x| *x as i64); // OK
    let baz: Foo<&i32> = foo.map_ref(|x| x); // Error
}

struct Foo<T>(T);

impl<T> Foo<T> {
    fn map_ref<U, F>(&self, f: F) -> Foo<U>
    where
        F: Fn(&T) -> U,
    {
        Foo(f(&self.0))
    }
}

Falha ao compilar quando Ué referência:

error: lifetime may not live long enough
 --> src\main.rs:4:48
  |
4 |     let baz: Foo<&i32> = foo.map_ref(|x: &i32| x); // Error
  |                                          -   - ^ returning this value requires that `'1` must outlive `'2`
  |                                          |   |
  |                                          |   return type of closure is &'2 i32
  |                                          let's call the lifetime of this reference `'1`
  |
help: dereference the return value
  |
4 |     let baz: Foo<&i32> = foo.map_ref(|x: &i32| *x); // Error
  |                                                +

Tentei introduzir um tempo de vida genérico 'ae Foo::map_refnão tenho ideia do que fazer a seguir.

Se ocorrer um push forçado ou exclusão de ramificação, o objeto antigo apontado pela referência poderá deixar de ser referenciado por qualquer referência e, portanto, ser elegível para coleta de lixo.

Durante a duração do gancho git post-receive de tal push, é garantido que o objeto antigo ainda seja válido?

Eu tenho uma string:

String inputDate = "18-FEB-24 10.02.33.578000000 AM";

Estou tentando lê-lo de volta e formatá-lo em AAAA-MM-DD HH:mm:ss.SSSSSS. Tentei as bibliotecas SimpleDateFormat e DateTimeFormatter, mas não consegui lê-lo de volta. Abaixo o código do chatgpt, mas está recebendo o erro "String cannot parse at index 3"

DateTimeFormatter inputFormatter = DateTimeFormatter.ofPattern("dd-MMM-yy hh.mm.ss.SSSSSSSSS a", Locale.ENGLISH);
DateTimeFormatter outputFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSSSSS");
LocalDateTime dateTime = LocalDateTime.parse(inputDate, inputFormatter);
String formattedDate = dateTime.format(outputFormatter);

Raku tem uma notação regex recursiva interessante e emocionante: <~~>.

Então no REPL, podemos fazer isso:

[0] > 'hellohelloworldworld' ~~ m/ helloworld /;
｢helloworld｣
[1] > 'hellohelloworldworld' ~~ m/ hello <~~>? world /;
｢hellohelloworldworld｣

Indo diretamente do Raku Docs para expressões regulares recursivas , podemos capturar/contar vários níveis de aninhamento:

~$ raku -pe '#acts like cat here' nest_test.txt
not nested

previous blank
nestA{1}
nestB{nestA{1}2}
nestC{nestB{nestA{1}2}3}

~$ raku -ne 'my $cnt = 0; say m:g/  \{  [  <( <-[{}]>*  )> | <( <-[{}]>* <~~>*? <-[{}]>* )>  ] \} {++$cnt} /, "\t  $cnt -levels nested";'  nest_test.txt
()    0 -levels nested
()    0 -levels nested
()    0 -levels nested
(｢1｣)     1 -levels nested
(｢nestA{1}2｣)     2 -levels nested
(｢nestB{nestA{1}2}3｣)     3 -levels nested

(Acima, altere saypara putpara retornar apenas a string capturada).

Mas recentemente me deparei com um problema ao tentar resolver uma questão sobre Unix e Linux , que é: como limitar a recursão? Digamos que queremos capturar apenas abaixo nestB. Existe alguma maneira de fazer isso usando a <~~>sintaxe regex recursiva?

~$ raku -ne 'my $cnt = 0; say m:g/ nestB  \{  [  <( <-[{}]>*  )> | <( <-[{}]>* <~~>*? <-[{}]>* )>  ] \} {++$cnt} /, "\t  $cnt -levels nested";'  nest_test.txt
()    0 -levels nested
()    0 -levels nested
()    0 -levels nested
()    0 -levels nested
()    0 -levels nested
()    0 -levels nested

NOTA: Acima, tentei forçar algum tipo de 'comportamento recursivo frugal' usando <~~>*?. A verdade é que <~~>(notação recursiva padrão), <~~>?, <~~>*, e <~~>*?todos dão resultados idênticos ( rakudo-moar-2024.09-01).

Qual é a sintaxe correta do regex recursivo Raku?

Tenho o seguinte código:

def my_zip(*iterables):
    iterators = tuple(map(iter, iterables))
    while True:
        yield tuple(map(next, iterators))

Quando my_zipé chamado, ele apenas cria um loop infinito e nunca termina. Se eu inserir uma instrução print (como mostrado abaixo), é revelado que my_zipestá produzindo tuplas vazias infinitamente!

def my_zip(*iterables):
    iterators = tuple(map(iter, iterables))
    while True:
        t = tuple(map(next, iterators))
        print(t)
        yield t

Entretanto, o código equivalente com uma expressão geradora funciona bem:

def my_genexp_zip(*iterables):
    iterators = tuple(iter(it) for it in iterables)
    while True:
        try:
            yield tuple(next(it) for it in iterators)
        except:
            print("exception caught!")
            return

Por que a função mapnão está se comportando como esperado? (Ou, se for o comportamento esperado, como eu poderia modificar seu comportamento para corresponder ao da função usando a expressão do gerador?)

Estou testando com o seguinte código:

print(list(my_genexp_zip(range(5), range(0, 10, 2))))
print(list(my_zip(range(5), range(0, 10, 2))))

esse comportamento tem me deixado louco ultimamente, embora provavelmente haja uma explicação razoável, talvez até uma solução.

Atualmente estou aprendendo C e tenho que escrever meu próprio shell na escola e estava explorando o sinal SIGQUIT. Achei algo estranho: quando escrevo um programa C "normal" e dou SIGQUIT usando Ctrl- \, ele faz SIGQUIT e envia uma mensagem dizendo "Quit (core dumped)". É o mesmo que, por exemplo, digitar "cat" no bash e depois Ctrl- \.

No entanto, quando coloco exatamente o mesmo programa em um processo filho usando fork, dizendo ao pai para SIG_IGN e ao filho para SIG_DFL, o filho receberá o sinal SIGQUIT e o processo será encerrado, mas a mensagem de erro mencionada acima não será exibida. Também usei waitpid para capturar o status e analisá-lo com WTERMSIG e ele diz que é 3, então foi encerrado por SIGQUIT. Anexei um código de exemplo para demonstrar meu problema, pois o código do shell que escrevi até agora é enorme.

Exemplo demonstrando o problema

int main(int argc, char **argv, char **envp)
{
    signal(SIGQUIT, SIG_IGN);
    int pid = fork();
    // signal(SIGQUIT, SIG_IGN);
    if (pid == 0)
    {
        signal(SIGQUIT, SIG_DFL);
        // execve("/usr/bin/cat", argv, envp);
        char buffer[100];
        read(0, buffer, 50);
        printf("buffer: %s\n", buffer);
        return (0);
    }
    int status;
    waitpid(pid, &status, 0);
    printf("Status: %i\n", WIFSIGNALED(status));
    if (WIFSIGNALED(status))
        printf("Signal: %i\n", WTERMSIG(status));
    #ifdef WCOREDUMP
        if (WCOREDUMP(status))
            printf("Core dumped!\n");
    #endif
    return (0);
}

Outras coisas que tentei

• ulimit -c ilimitado
• configurando SIGQUIT para SIG_IGN antes e depois da bifurcação (veja o código de exemplo)
• tentei com execve e "cat" - mesmo comportamento
• Executar o programa sem fork() se comporta conforme o esperado.
• core_uses_pid está definido como 1
• core_pipe_limit está definido como 0
• core_pattern diz: |/wsl-capture-crash %t %E %p %s
• Eu uso o wsl2 com o Ubuntu, mas já testei o programa em um computador da escola executando o Ubuntu "normal" e obtive o mesmo comportamento

Talvez esse comportamento também seja esperado? Mas se for, por quê? A razão pela qual isso é um problema para mim é que meu shell deve lidar com sinais semelhantes ao bash, então, no final, eu gostaria que a interrupção do cat se comportasse como interromper o cat no bash, se possível. Se não for, eu realmente quero saber por que há um comportamento diferente dos processos pai e filho.

Muito obrigado a todos antecipadamente! É minha primeira pergunta aqui, então, por favor, me avisem também, se eu puder melhorar minha pergunta no futuro.

Considere o seguinte código:

void f1(bool ok) {
    if (ok) [[likely]] {
        // ...
    } else [[unlikely]] {
        // ...
    }
}

void f2(bool ok) {
    if (ok) [[likely]] {
        // ...
    } else {
        // ...
    }
}

void f3(bool ok) {
    if (ok)  {
        // ...
    } else [[unlikely]] {
        // ...
    }
}

f1, f2, e são f3equivalentes do ponto de vista do compilador?

Dados dois números de ponto flutuante de precisão dupla, finitos e diferentes de zero xe y, é sempre verdade que a igualdade

x * y == ((x * y) / y) * y

mantém a semântica padrão IEEE 754?

Pesquisei programaticamente entre bilhões de possibilidades (inclusive na faixa subnormal) e não consegui encontrar um contraexemplo, mas também não tenho certeza de como provar que a afirmação é verdadeira.

(O que eu sei é que as afirmações mais simples x == (x / y) * ye x == (x * y) / ysão ambas falsas, pois posso facilmente encontrar contra-exemplos para elas.)