knave 0.10.0

A small Lisp for humans and agents that infers types and ownership and compiles to readable Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

use std::io;
use std::path::Path;
use std::process::{self, Command};

use super::exit_status::ExitStatus;
use super::program_signal::ProgramSignal;
use super::standard_error::StandardError;

pub enum FinishedProgram {
    Exited(process::ExitStatus),
    NotStarted,
}

impl FinishedProgram {
    pub fn run(binary: &Path) -> Self {
        Self::run_with(binary, &[])
    }

    pub fn run_with(binary: &Path, arguments: &[String]) -> Self {
        Self::of(binary, Command::new(binary).args(arguments).status())
    }

    pub fn of(binary: &Path, status: io::Result<process::ExitStatus>) -> Self {
        match status {
            Ok(status) => Self::Exited(status),
            Err(error) => {
                StandardError::write_line(format_args!(
                    "error: cannot run `{}`: {error}",
                    binary.display()
                ));
                Self::NotStarted
            }
        }
    }

    pub fn status(&self) -> ExitStatus {
        let Self::Exited(status) = self else {
            return ExitStatus::Environment;
        };
        match ProgramSignal::of(*status) {
            Some(signal) => ExitStatus::KilledBy(signal),
            None => ExitStatus::Program(Self::code(*status)),
        }
    }

    fn code(status: process::ExitStatus) -> u8 {
        status
            .code()
            .and_then(|code| u8::try_from(code).ok())
            .unwrap_or(ProgramSignal::UNREPORTABLE_CODE)
    }
}