Harry's questions

Como posso transformar idiomaticamente um Resulttipo em outro Resulttipo com base no Okvalor?

fn get_res1() -> Result<bool, ()> {
    Ok(true)
}

fn get_res2() -> Result<(), String> {
    let res = get_res1().map_err(|err| String::from("Execution failed"))?;

    // map Ok value to Result type(function return type) based on its value
    // Is it possible to combine the below transformation with the above Result type method map_err?
    if !res {
        return Err(String::from("Operation failed"));
    }

    Ok(())
}

É possível canonizar uma string de caminho de arquivo contendo o diretório atual ( .) com um diretório fornecido. Por exemplo, caminho de arquivo => ./abcd.txt, diretório fornecido => /a/b/c. O resultado esperado do caminho de arquivo resultante é /a/b/c/abcd.txt.

fn main() {
    let file_path = "./abcd.txt";
    let cur_dir = "/a/b/c";
    
    let path = std::fs::canonicalize(file_path).unwrap();
    println!("{:#?}", path);
}

Saída

thread 'main' panicked at src/main.rs:5:49:
called `Result::unwrap()` on an `Err` value: Os { code: 2, kind: NotFound, message: "No such file or directory" }
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

No código abaixo, estou tendo um problema relacionado ao verificador de empréstimo se eu comentar a println!declaração após a expressão de correspondência. E para corrigir esse problema, o compilador está me pedindo para colocar um ponto e vírgula no final da matchexpressão, o que resolve o problema, mas não consegui entender a necessidade disso.

use std::sync::{Arc, Mutex};

#[derive(Default)]
struct A {
    b: Arc<Mutex<B>>,
}

#[derive(Default)]
struct B {
    c: Arc<Mutex<C>>,
}

#[derive(Default)]
struct C {
    d: i32,
}

fn main() {
    let a = A::default();
    
    match a.b.lock().unwrap().c.lock().unwrap().d {
        0 => println!("zero"),
        _ => println!("non-zero"),
    }
    // uncommenting the below line makes borrow checker happy
    // println!("{}", a.b.lock().unwrap().c.lock().unwrap().d);
}

Erro

error[E0597]: `a.b` does not live long enough
  --> src/main.rs:21:11
   |
19 |     let a = A::default();
   |         - binding `a` declared here
20 |     
21 |     match a.b.lock().unwrap().c.lock().unwrap().d {
   |           ^^^----------------
   |           |
   |           borrowed value does not live long enough
   |           a temporary with access to the borrow is created here ...
...
27 | }
   | -
   | |
   | `a.b` dropped here while still borrowed
   | ... and the borrow might be used here, when that temporary is dropped and runs the `Drop` code for type `MutexGuard`
   |
help: consider adding semicolon after the expression so its temporaries are dropped sooner, before the local variables declared by the block are dropped
   |
24 |     };
   |      +

For more information about this error, try `rustc --explain E0597`.

Eu clonei um repositório git remoto e criei uma nova ramificação a partir da mainramificação. Agora eu quero obter a tag de repositório mais recente (se existir) em tempo de compilação. Eu consegui obter o hash de commit mais recente em tempo de compilação. Abaixo está meu código

// build.rs
use std::process::Command;
fn main() {
    let output = Command::new("git").args(&["rev-parse", "HEAD"]).output().unwrap();
    let git_hash = String::from_utf8(output.stdout).unwrap();
    println!("cargo:rustc-env=GIT_HASH={}", git_hash);
}

// main.rs
fn main() {
    println!("{}", env!("GIT_HASH"));
}

Estou usando clapcrate para manipular argumentos de linha de comando. Como imprimo o número da versão e um argumento de linha de comando personalizado juntos? O código abaixo, quando executado, cargo run -- --name Harry --versionimprime apenas o número da versão.

use clap::Parser;

/// Simple program to greet a person
#[derive(Parser, Debug)]
#[command(version, about, long_about = None)]
struct Args {
    /// Name of the person to greet
    #[arg(short, long)]
    name: String,

    /// Number of times to greet
    #[arg(short, long, default_value_t = 1)]
    count: u8,
}

fn main() {
    let args = Args::parse();

    for _ in 0..args.count {
        println!("Hello {}!", args.name);
    }
}

Saída de corrente

clap_demo 0.1.0

Saída esperada

Hello Harry!
clap_demo 0.1.0

Carga.toml

[package]
name = "clap_demo"
version = "0.1.0"
edition = "2021"

[dependencies]
clap = { version = "4.5.26", features = ["derive", "env"] }

Eu tenho uma função que retorna um Resulttipo. Dentro dessa função, outra função está sendo chamada, que retorna Resulto tipo. E, se o valor retornado for uma Errvariante, chame uma função/fechamento antes de borbulhar esse erro, senão, se for uma Okvariante, chame uma função/fechamento e então simplesmente retorne o valor contido. Isso é o que eu escrevi até agora

fn foo1() -> Result<i32, String> {
    Err("error".to_string())
}

fn foo2() -> Result<String, bool> {
    let res = foo1().map_err(|err| {
        println!("foo1 failed {}", err);
        false
    })?;

    // I know I can call some closure in here, but I want something like map_err which will call different closures depending on the Result variant
    Ok(res.to_string())
}

fn main() {
    foo2();
}

Existe um std::filesystemequivalente em C++ da stat()função C declarada em #include <sys/stat.h>para obter informações sobre o st_blksizeatributo?

Eu escrevi um script de shell para iniciar vários trabalhos em segundo plano e armazenar os IDs de processo deles em uma matriz usando $!. No final, imprimo todos os IDs de processo iterando pela matriz. Quero saber se o script de shell escrito tem um bug? E a razão pela qual sinto que há um bug no meu script de shell é porque $!pode retornar o ID de processo de outro processo se houver vários processos sendo criados no meu PC.

#!/bin/bash

ps -a & pids+=($!) #Does $! return process id of command ps -a for sure
ls -la & pids+=($!) #Does $! return process id of command ls -la for sure
echo ${pids[0]}
echo ${pids[1]}

Como passar um ponteiro duplo não constante como parâmetro constante para outra função?

Meu código:

#include <iostream>
    
void food(const char** begin, const char** end) {
    
}
    
int main(int argc, char** argv) {
    food(argv, argv + argc);    
}

O erro que recebo:

<source>: In function 'int main(int, char**)':
<source>:8:10: error: invalid conversion from 'char**' to 'const char**' [-fpermissive]
    8 |     food(argv, argv + argc);
      |          ^~~~
      |          |
      |          char**
<source>:3:24: note:   initializing argument 1 of 'void food(const char**, const char**)'
    3 | void food(const char** begin, const char** end) {
      |           ~~~~~~~~~~~~~^~~~~
<source>:8:21: error: invalid conversion from 'char**' to 'const char**' [-fpermissive]
    8 |     food(argv, argv + argc);
      |                ~~~~~^~~~~~
      |                     |
      |                     char**
<source>:3:44: note:   initializing argument 2 of 'void food(const char**, const char**)'
    3 | void food(const char** begin, const char** end) {
      |      

Quero dividir uma string contendo -como primeiro caractere usando espaço em branco como delimitador. Mas o código a seguir parece não funcionar. Se eu remover o -caractere, ele será dividido corretamente. Este é o script

#!/bin/bash

string="-e -/a/b/c/d"
arr=($string)
arrLen=${#arr[@]}
echo $arrLen
echo ${arr[0]} #prints empty
if [ $arrLen = 2 ] && [ ${arr[0]} = "-e" ]; then #this condition gets passed surprisingly
    echo "Hi ${arr[1]}"
fi

Saída

2

Hi -a/b/c/d

Como posso criar um arquivo usando o catcomando com um here-document dentro do script de shell"

#!/bin/bash

create_file () {
    cat > a.txt << EOF
    0 abc def 
    ghi jkl mno
    pqrs tuv wxyz
    EOF
}

create_file

Erro

Syntax error: end of file unexpected (expecting "}")

É possível passar o endereço do primeiro elemento de um array como argumento para std::bit_cast.

#include <bit>
#include <iostream>

struct A {
    int a;
    int b;
    int c;
    int d;
    int e;

    void print() {
        std::cout << a << ", " << b << ", " << c << ", " << d << ", " << e << std::endl;
    }
};

int main() {
    char arr[20]{};
    // arr is filled with some data
    A a = std::bit_cast<A>(arr);
    a.print();

    const char* arrp = arr;
    // doesn't compile
    A b = std::bit_cast<A>(arrp);
    b.print();
}

Erro

<source>: In function 'int main()':
<source>:23:27: error: no matching function for call to 'bit_cast<A>(const char*&)'
   23 |     A b = std::bit_cast<A>(arrp);
      |           ~~~~~~~~~~~~~~~~^~~~~~
In file included from <source>:1:
/opt/compiler-explorer/gcc-13.2.0/include/c++/13.2.0/bit:81:5: note: candidate: 'template<class _To, class _From> constexpr _To std::bit_cast(const _From&) requires  sizeof (_To) == sizeof (_From) && __is_trivially_copyable(_To) && __is_trivially_copyable(_From)'
   81 |     bit_cast(const _From& __from) noexcept
      |     ^~~~~~~~
/opt/compiler-explorer/gcc-13.2.0/include/c++/13.2.0/bit:81:5: note:   template argument deduction/substitution failed:
/opt/compiler-explorer/gcc-13.2.0/include/c++/13.2.0/bit:81:5: note: constraints not satisfied
/opt/compiler-explorer/gcc-13.2.0/include/c++/13.2.0/bit: In substitution of 'template<class _To, class _From> constexpr _To std::bit_cast(const _From&) requires  sizeof (_To) == sizeof (_From) && __is_trivially_copyable(_To) && __is_trivially_copyable(_From) [with _To = A; _From = const char*]':
<source>:23:27:   required from here
/opt/compiler-explorer/gcc-13.2.0/include/c++/13.2.0/bit:81:5:   required by the constraints of 'template<class _To, class _From> constexpr _To std::bit_cast(const _From&) requires  sizeof (_To) == sizeof (_From) && __is_trivially_copyable(_To) && __is_trivially_copyable(_From)'
/opt/compiler-explorer/gcc-13.2.0/include/c++/13.2.0/bit:83:27: note: the expression 'sizeof (_To) == sizeof (_From) [with _To = A; _From = const char*]' evaluated to 'false'
   83 |     requires (sizeof(_To) == sizeof(_From))
      |              ~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~
Compiler returned: 1

Estou recebendo dados de outro host via soquete de rede no formato big endian. Como interpretar os bytes recebidos no formato endian nativo (como obter uma visualização ou reinterpretar esses bytes) sem copiar para uma variável temporária.

#include <iostream>
#include <cstdint>

struct A {
    uint16_t msg_id;
    // contains many other fields where total size is greater than 4096

    void print() const {
        // print all the fields of struct A
    }
};

struct B {
    uint16_t msg_id;
    // contains many other fields where total size is greater than 4096

    void print() const {
        // print all the fields of struct B
    }
};

struct C {
    uint16_t msg_id;
    // contains many other fields where total size is greater than 4096

    void print() const {
        // print all the fields of struct C
    }
};

int main() {
    char buff[8192];
    while (true) {
        // data is received in network byte order (big endian) but my system is little endian
        const auto recvd_len = recvfrom(sock_fd, buff, sizeof(buff), 0, nullptr, nullptr);
        const uint16_t msg_id = (buff[0] << 8) | (buff[1] & 0xFF);

        switch (msg_id) {
            case 0x0001: {
                // reinterpret the bytes received as struct A, copy elision
                const A* a_obj = reinterpret_cast<const A*>(buff);
                a_obj->print();
                // the above print call works correctly only if my system is big endian but not little endian
            }

            break;

            case 0x0002: {
                // reinterpret the bytes received as struct B, copy elision
                const B* b_obj = reinterpret_cast<const B*>(buff);
                b_obj->print();
                // the above print call works correctly only if my system is big endian but not little endian
            }

            break;

            case 0x0003: {
                // reinterpret the bytes received as struct C, copy elision
                const C* c_obj = reinterpret_cast<const C*>(buff);
                c_obj->print();
                // the above print call works correctly only if my system is big endian but not little endian
            }

            break;

            default:
            break;
        }
    }
}

Como usar operator()(Generator& g, const param_type& params);o std::uniform_int_distribution. Este é o meu código

#include <iostream>
#include <random>

int get_random_int(const int lower_limit, const int upper_limit) {
   std::random_device rd{};
   std::mt19937 gen{rd()};

   static std::uniform_int_distribution<> dist;
   
   // use operator()(Generator& g, const param_type& params);
   return dist(gen, lower_limit, upper_limit);
}

int main() {
    std::cout << get_random_int(1, 1000000) << std::endl;
}

Gostaria de saber se é possível usar if let Ok()sintaxe no Result<Tuple(Struct, usize), DecodeError>tipo retornado da bincode::decode_from_slicefunção de bincodecrate https://docs.rs/bincode/2.0.0-rc.3/bincode/fn.decode_from_slice.html que requer anotações de tipo explícitas

Eu tentei a seguinte sintaxe

struct A {
    a: i32,
    b: i32,
}

let mut recv_buff = [0u8; 1024];

if let Ok((a_obj, _): (A, usize)) = bincode::decode_from_slice(recv_buff, bincode::config::standard().with_big_endian()) {
        
}

Erro

if let Ok((a_obj, _): (A, usize)) = bincode::decode_from_slice(recv_buff, bincode::config::standard()....
    |                                         ^ expected one of `)`, `,`, or `|`