olean-export 0.7.0

Optimized library for reading Lean .olean files directly emitting lean4export-compatible NDJSON for external kernel checkers.
Documentation
#![allow(clippy::many_single_char_names)]

use olean_export::{Env, Expr, ExprId, Kind, LetNode, Level, LevelId, NameId};
use std::path::PathBuf;

fn level(env: &Env, l: LevelId) -> String {
    match env.levels[l] {
        Level::Zero => "0".into(),
        Level::Succ(a) => format!("{}+1", level(env, a)),
        Level::Max(a, b) => format!("max {} {}", level(env, a), level(env, b)),
        Level::IMax(a, b) => format!("imax {} {}", level(env, a), level(env, b)),
        Level::Param(n) => env.display(n),
    }
}

fn sort(env: &Env, l: LevelId) -> String {
    match env.levels[l] {
        Level::Zero => "Prop".into(),
        Level::Succ(a) if env.levels[a] == Level::Zero => "Type".into(),
        Level::Succ(a) => format!("Type {}", level(env, a)),
        _ => format!("Sort ({})", level(env, l)),
    }
}

fn binder(env: &Env, n: NameId, depth: usize) -> String {
    let s = env.display(n);
    let s = s.split("._@").next().unwrap_or_default();
    format!("{s}{depth}")
}

fn expr(env: &Env, e: ExprId, ctx: &mut Vec<String>) -> String {
    match &env.exprs[e] {
        Expr::BVar(i) => ctx[ctx.len() - 1 - usize::try_from(*i).unwrap()].clone(),
        Expr::Sort(l) => sort(env, *l),
        Expr::Const(n, _) => env.display(*n),
        Expr::App(f, a) => {
            let a = expr(env, *a, ctx);
            let a = if a.contains(' ') { format!("({a})") } else { a };
            format!("{} {a}", expr(env, *f, ctx))
        }
        Expr::Lam(n, t, b, _) | Expr::Pi(n, t, b, _) => {
            let ty = expr(env, *t, ctx);
            ctx.push(binder(env, *n, ctx.len()));
            let body = expr(env, *b, ctx);
            let x = ctx.pop().unwrap();
            let head = if matches!(env.exprs[e], Expr::Lam(..)) {
                "fun"
            } else {
                "forall"
            };
            format!("{head} ({x} : {ty}), {body}")
        }
        Expr::Let(l) => {
            let LetNode(n, t, v, b) = **l;
            let (ty, val) = (expr(env, t, ctx), expr(env, v, ctx));
            ctx.push(binder(env, n, ctx.len()));
            let body = expr(env, b, ctx);
            format!("let {} : {ty} := {val}; {body}", ctx.pop().unwrap())
        }
        Expr::Nat(v) => v.to_string(),
        Expr::Str(v) => format!("{v:?}"),
        Expr::Proj(_, i, x) => format!("({}).{}", expr(env, *x, ctx), i + 1),
    }
}

fn main() {
    let build = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("tests/cases/build");
    let env = Env::load(&[build], &["Top"]).expect("load fixture oleans");
    println!(
        "loaded {} from Lean {}",
        env.modules.join(" + "),
        env.header.version
    );
    println!(
        "{} constants ({} unsafe skipped), {} names, {} levels, {} expressions\n",
        env.consts.len(),
        env.skipped,
        env.names.len(),
        env.levels.len(),
        env.exprs.len()
    );
    for name in [
        "N",
        "N.add",
        "N.add_zero",
        "Pair.swap",
        "Quot.lift",
        "Even",
        "letty",
    ] {
        let k = &env.consts[&env.find_name(name).unwrap()];
        let ty = expr(&env, k.ty, &mut Vec::new());
        match &k.kind {
            Kind::Defn(d) => println!(
                "{name} : {ty}\n  := {}\n",
                expr(&env, d.value, &mut Vec::new())
            ),
            Kind::Thm(t) => println!(
                "{name} : {ty}\n  := {}\n",
                expr(&env, t.value.unwrap(), &mut Vec::new())
            ),
            Kind::Induct(ind) => {
                let cs: Vec<String> = ind.ctors.iter().map(|&c| env.display(c)).collect();
                println!("{name} : {ty}\n  ctors {}\n", cs.join(", "));
            }
            _ => println!("{name} : {ty}\n"),
        }
    }
}