qleisli 0.2.2

Experimental quantum language with linear ownership, exact contracts and independent finite IR verification
Documentation
use std::io::Write;
use std::process::ExitCode;

use qleisli::frontend::compile::{check_project_with_policy, compile_project_with_policy};
use qleisli::frontend::diagnostic::Diagnostic;
use qleisli::frontend::documentation::render_markdown;
use qleisli::frontend::project::read_source_file;
use qleisli::sim::{SimulationLimits, run_closed};

#[path = "qleisli/artifacts.rs"]
mod artifacts;
#[path = "qleisli/interop.rs"]
mod interop;
#[path = "qleisli/json.rs"]
mod json;
#[path = "qleisli/options.rs"]
mod options;
#[path = "qleisli/samples.rs"]
mod samples;
#[path = "qleisli/sized.rs"]
mod sized;

fn report(root: &std::path::Path, error: Diagnostic) {
    if let Some(p) = error.primary {
        eprintln!(
            "{}:{}:{}: {}: {}",
            p.path.display(),
            p.line,
            p.column,
            error.code,
            error.message
        );
    } else {
        eprintln!("{}: {}: {}", root.display(), error.code, error.message);
    }
}

fn main() -> ExitCode {
    let args: Vec<_> = std::env::args_os().skip(1).collect();
    if args.first().is_some_and(|arg| arg == "sized") {
        return sized::run(&args[1..]);
    }
    if args.first().is_some_and(|arg| arg == "interop") {
        return interop::run(&args[1..]);
    }
    if args.iter().any(|arg| arg == "--format=json") {
        return json::run(&args);
    }
    let Some(options) = options::Options::parse(&args, false) else {
        eprintln!("{}", options::USAGE);
        return ExitCode::from(2);
    };
    let source_root = &options.path;
    if matches!(options.command.as_str(), "emit-ir" | "verify-ir") {
        return match artifacts::execute(&options) {
            Ok(artifacts::Success::Emitted(path)) => {
                println!("emitted independently verified IR: {path}");
                ExitCode::SUCCESS
            }
            Ok(artifacts::Success::Verified(request)) => {
                println!("verified IR; request_checked: {request}");
                ExitCode::SUCCESS
            }
            Err(artifacts::Failure::Source(error)) => {
                report(source_root, error);
                ExitCode::FAILURE
            }
            Err(artifacts::Failure::Artifact(error)) => {
                eprintln!("{error}");
                ExitCode::FAILURE
            }
        };
    }
    if options.command == "doc" {
        let source = match read_source_file(source_root, options.policy) {
            Ok(source) => source,
            Err(error) => {
                report(source_root, error);
                return ExitCode::FAILURE;
            }
        };
        return match render_markdown(&source) {
            Ok(markdown) => match std::io::stdout().lock().write_all(markdown.as_bytes()) {
                Ok(()) => ExitCode::SUCCESS,
                Err(error) => {
                    eprintln!("could not write documentation: {error}");
                    ExitCode::FAILURE
                }
            },
            Err(error) => {
                eprintln!("{}: {error}", source_root.display());
                ExitCode::FAILURE
            }
        };
    }
    if options.command == "check" {
        return match check_project_with_policy(source_root, options.policy) {
            Ok(()) => {
                println!("checked source and verified IR: {}", source_root.display());
                ExitCode::SUCCESS
            }
            Err(error) => {
                report(source_root, error);
                ExitCode::FAILURE
            }
        };
    }
    let program = match compile_project_with_policy(source_root, options.policy) {
        Ok(program) => program,
        Err(error) => {
            report(source_root, error);
            return ExitCode::FAILURE;
        }
    };
    if options.command == "sample" {
        return match samples::collect(&program, options.shots.unwrap(), options.seed.unwrap()) {
            Ok((samples, _)) => {
                let mut text = String::new();
                for sample in samples {
                    if sample.bits.is_empty() {
                        text.push_str("()");
                    }
                    for bit in sample.bits {
                        text.push(if bit { '1' } else { '0' });
                    }
                    text.push('\n');
                }
                match std::io::stdout().lock().write_all(text.as_bytes()) {
                    Ok(()) => ExitCode::SUCCESS,
                    Err(e) => {
                        eprintln!("could not write sample results: {e}");
                        ExitCode::FAILURE
                    }
                }
            }
            Err(error) => {
                report(source_root, error);
                ExitCode::FAILURE
            }
        };
    }
    match run_closed(&program, SimulationLimits::default()) {
        Ok(distribution) => {
            for (outcome, probability) in distribution {
                let label: String = outcome
                    .iter()
                    .map(|bit| if *bit { '1' } else { '0' })
                    .collect();
                println!(
                    "{}: {probability:.12e}",
                    if label.is_empty() { "()" } else { &label }
                );
            }
            ExitCode::SUCCESS
        }
        Err(error) => {
            eprintln!("{error}");
            ExitCode::FAILURE
        }
    }
}