Quiero poder usar Rust para generar un shell secundario, luego pasarle repetidamente comandos arbitrarios y procesar sus salidas. He encontrado muchos ejemplos en línea que me muestran cómo pasar un solo comando y recibir su única salida, pero parece que no puedo hacerlo repetidamente.

Por ejemplo, el siguiente código se cuelga en la línea después del comentario. (Me imagino que tal vezread_to_string() está bloqueando hasta que recibe stdout del proceso hijo, pero si es así, no entiendo por qué esa salida no está disponible ...)

let mut child_shell = match Command::new("/bin/bash")
    .stdin(Stdio::piped())
    .stdout(Stdio::piped())
    .spawn()
{
    Err(why) => panic!("couldn't spawn child_shell: {}", Error::description(&why)),
    Ok(process) => process,
};

loop {
    {
        match child_shell.stdin.as_mut().unwrap().write("ls".as_bytes()) {
            Err(why) => panic!(
                "couldn't send command to child shell: {}",
                Error::description(&why)
            ),
            Ok(_) => println!("sent command to child shell"),
        }
    }

    {
        let mut s = String::new();
        // ↓ hangs on this line ↓
        match child_shell.stdout.as_mut().unwrap().read_to_string(&mut s) {
            Err(why) => panic!("couldn't read bash stdout: {}", Error::description(&why)),
            Ok(_) => print!("bash responded with:\n{}", s),
        }
    }
}

Soy un principiante en Rust y creo que el problema es mi comprensión limitada de las reglas de verificación de préstamo / referencia, ya que lo anterior funciona bien (para una sola iteración) si elimino la instrucción de bucle del código y cambio las referencias a las entrañas de lastd::process::Child estructura a inmutable; por ejemplo de esto:

child_shell.stdin.as_mut().unwrap().write("ls".as_bytes())

a esto:

 child_shell.stdin.unwrap().write("ls".as_bytes())

Obviamente, corriendo repetidamentels no es mi objetivo final, y sé que podría escribir un script de shell y luego hacer que Rust lo ejecute repetidamente, pero (¡aparte del objetivo de aprender más sobre Rust!), esto es algo que necesito poder hacer , al menos en principio, para un proyecto más complicado (que me encantaría considerar si pudiera resultar relevante para cualquier solución, ¡pero probablemente esté fuera del alcance de esta pregunta!)

Finalmente, si resulta que no es posible usar un shell secundario de esta manera, sin embargo, me gustaría aprender cómo canalizar repetidamente / continuamente hacia y desde un proceso generado ejecutando algún otro comando arbitrario, ya que no estaba No puedo encontrar ninguna información en la documentación de Rust, tutoriales o en Stack Overflow.