What is "Evacuable"?

[jjtolton]

I see this term "Evacuable" a lot in some of the Scryer Prolog source code

use_module(Module) :-
    '$push_load_state_payload'(Evacuable),
    catch('$call'(loader:use_module(Module, [], Evacuable)),
          file_load_error,
          '$call'(builtins:false)).

use_module(Module, Exports) :-
    '$push_load_state_payload'(Evacuable),
    (  Exports == [] ->
       remove_module(Module, Evacuable)
    ;  use_module(Module, Exports, Evacuable)
    ).

use_module(Module, Exports, Evacuable) :-
    (  var(Module) ->
       instantiation_error(load/1)
    ;  Module = library(Library) ->
       (  path_atom(Library, LibraryPath) ->
          (  '$load_compiled_library'(LibraryPath, Exports, Evacuable) ->
             true
          ;  '$load_library_as_stream'(LibraryPath, Stream, Path),
             file_load(Stream, Path, Subevacuable),
             '$use_module'(Evacuable, Subevacuable, Exports)
          )
       ;  var(Library) ->
          instantiation_error(load/1)
       ;  type_error(atom, Library, load/1)
       )
    ;  (  path_atom(Module, ModulePath) ->
          load_context_path(ModulePath, Path),
          open_file(Path, Stream),
          stream_property(Stream, file_name(PathFileName)),
          file_load(Stream, PathFileName, Subevacuable),
          '$use_module'(Evacuable, Subevacuable, Exports)
       ;  type_error(atom, Module, load/1)
       )
    ).

I can't really figure out what that's supposed to be. 🤔 Anyone have any ideas?

[hurufu]

I understand it as a "ghost" value, it has attached Rust function inside VM.

[hurufu]

You are not supposed to use it :) only if you know exactly what is attached in the Rust side.

[jjtolton]

Ahhh very interesting. Well, I'll ask a more direct question then!

[jjtolton]

Or here:

compile_term(Term, Evacuable) :-
    expand_terms_and_goals(Term, Terms),
    !,
    (  var(Terms) ->
       instantiation_error(load/1)
    ;  Terms = [_|_] ->
       compile_dispatch_or_clause_on_list(list(Term), Terms, Evacuable)
    ;  compile_dispatch_or_clause(term(Term), Terms, Evacuable)
    ).

This looks like a REALLY fun predicate, but ... WHAT IS EVACUABLE?? 😭

[jjtolton]

Closest I can find is this:

scryer-prolog/src/machine/loader.rs

Lines 367 to 389 in 2f47343

	impl<'a> LoadState<'a> for BootstrappingLoadState<'a> {
	type TS = BootstrappingTermStream<'a>;
	type LoaderFieldType = BootstrappingLoadState<'a>;
	type Evacuable = CompilationTarget;
	#[inline(always)]
	fn new(_: &'a mut MachineState, payload: LoadStatePayload<Self::TS>) -> Self::LoaderFieldType {
	BootstrappingLoadState(payload)
	}
	fn evacuate(mut loader: Loader<'a, Self>) -> Result<Self::Evacuable, SessionError> {
	if !loader.payload.predicates.is_empty() {
	loader.compile_and_submit()?;
	}
	let repo_len = loader.wam_prelude.code.len();
	loader.payload.retraction_info.reset(repo_len);
	loader.remove_module_op_exports();
	Ok(loader.payload.compilation_target)
	}

It looks like these are things removed from the state or cleaned up, possibly to facilitate reloading modules during dynamic sessions?

[triska]

Yes, that is also my guess: These are things that must be removed when a file is reloaded, for example with consult/1.

[mthom]

I forgot why I called it Evacuable. It's meant to be the LoadState, which has a number of subtypes depending on what phase the load takes place. BootstrappingLoadState compiles builtins and other essential libraries without term and goal expansion directly from Rust while the other types do it with term and goal expansion, from the Prolog dispatch loop.