pub struct Env {
pub names: Table<Name>,
pub levels: Table<Level>,
pub exprs: Exprs,
pub consts: FxHashMap<NameId, Const>,
pub order: Vec<NameId>,
pub recursors: FxHashMap<NameId, Vec<NameId>>,
pub modules: Vec<String>,
pub header: Header,
pub skipped: usize,
/* private fields */
}Expand description
Every constant reachable from a set of root modules, in import order.
Fields§
§names: Table<Name>§levels: Table<Level>§exprs: Exprs§consts: FxHashMap<NameId, Const>§order: Vec<NameId>§recursors: FxHashMap<NameId, Vec<NameId>>§modules: Vec<String>§header: Header§skipped: usizeImplementations§
Source§impl Env
impl Env
Sourcepub fn open(search: &[PathBuf], roots: &[&str], jobs: usize) -> Result<Self>
pub fn open(search: &[PathBuf], roots: &[&str], jobs: usize) -> Result<Self>
Like Env::load_with, but keeps the expression index so that Env::reload can
decode changed modules into the same tables. That costs about 10 bytes per expression.
Sourcepub fn reload(&mut self) -> Result<Reload>
pub fn reload(&mut self) -> Result<Reload>
Decode again the modules whose oleans changed since the last load, add newly imported
ones and drop those no longer imported. Every id stays valid and the tables only grow,
so an crate::Exporter can resume from a crate::Mark and write just the
changes. Binder names, which no kernel reads, may differ from a fresh load.
Source§impl Env
impl Env
Sourcepub fn load_cone(
search: &[PathBuf],
roots: &[&str],
consts: &[&str],
jobs: usize,
progress: &(dyn Fn(usize, usize) + Sync),
) -> Result<Self>
pub fn load_cone( search: &[PathBuf], roots: &[&str], consts: &[&str], jobs: usize, progress: &(dyn Fn(usize, usize) + Sync), ) -> Result<Self>
Like Env::load_with, but decode only the theorem values that exporting consts
reaches. The rest stay in their oleans, as None.
Sourcepub fn load_statements(
search: &[PathBuf],
roots: &[&str],
jobs: usize,
progress: &(dyn Fn(usize, usize) + Sync),
) -> Result<Self>
pub fn load_statements( search: &[PathBuf], roots: &[&str], jobs: usize, progress: &(dyn Fn(usize, usize) + Sync), ) -> Result<Self>
Load like Env::load_with, leaving every theorem value undecoded, for
Env::statement and crate::Exporter::statements.
Sourcepub fn statement(&self, consts: &[NameId]) -> Result<Vec<(usize, NameId)>>
pub fn statement(&self, consts: &[NameId]) -> Result<Vec<(usize, NameId)>>
What the statements of consts rest on, with the index of each one’s module, in
load order: everything their types mention, and through it the values of
definitions and whole inductive families, but no proof. A theorem reached inside a
definition is taken as stated, as crate::Exporter::statements writes it.
Source§impl Env
impl Env
Sourcepub fn load(search: &[PathBuf], roots: &[&str]) -> Result<Self>
pub fn load(search: &[PathBuf], roots: &[&str]) -> Result<Self>
Load roots and their transitive imports, resolving modules against search.
Sourcepub fn load_with(
search: &[PathBuf],
roots: &[&str],
jobs: usize,
progress: &(dyn Fn(usize, usize) + Sync),
) -> Result<Self>
pub fn load_with( search: &[PathBuf], roots: &[&str], jobs: usize, progress: &(dyn Fn(usize, usize) + Sync), ) -> Result<Self>
Like Env::load on jobs threads, calling progress with the number of modules
and constants decoded so far.
Modules decode in parallel straight into shared tables, and the result is the same
for any jobs.
Sourcepub fn roots(&self) -> impl Iterator<Item = NameId> + '_
pub fn roots(&self) -> impl Iterator<Item = NameId> + '_
The constants lean4export exports when given no explicit names.
Sourcepub fn find_name(&self, dotted: &str) -> Option<NameId>
pub fn find_name(&self, dotted: &str) -> Option<NameId>
Look up a dotted name such as Nat.add without interning it.
pub fn display(&self, n: NameId) -> String
pub fn is_internal(&self, n: NameId) -> bool
Trait Implementations§
Auto Trait Implementations§
impl Forget for Env
impl Freeze for Env
impl RefUnwindSafe for Env
impl Send for Env
impl Sync for Env
impl Unpin for Env
impl UnsafeUnpin for Env
impl UnwindSafe for Env
Blanket Implementations§
Source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
Source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Source§impl<T> IntoEither for T
impl<T> IntoEither for T
Source§fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ
fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ
self into a Left variant of Either<Self, Self>
if into_left is true.
Converts self into a Right variant of Either<Self, Self>
otherwise. Read moreSource§fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
self into a Left variant of Either<Self, Self>
if into_left(&self) returns true.
Converts self into a Right variant of Either<Self, Self>
otherwise. Read more