evcxr

https://docs.rs/evcxr/0.21.1
Admin
evcxr is a Rust library providing interactive code evaluation and REPL capabilities, allowing...
Tokens:91,161
Snippets:577
Trust Score:9.1
Update:6 months ago
Show doc for...
Tokens:
Raw
### Creating a Scraped Example in Rust

Source: https://docs.rs/evcxr/0.21.1/scrape-examples-help.html

Create an example file that calls a documented item from your crate. This example will be scraped and included in the documentation for the called item.

```rust
// examples/ex.rs
fn main() {
  a_crate::a_func();
}
```

--------------------------------

### yansi::Paint Styling Example

Source: https://docs.rs/evcxr/0.21.1/evcxr/struct.Completions.html

Example demonstrating how to enable styling conditionally based on TTY status.

```APIDOC
## Example

Enable styling `painted` only when both `stdout` and `stderr` are TTYs:

```rust
use yansi::{Paint, Condition};

painted.red().on_yellow().whenever(Condition::STDOUTERR_ARE_TTY);
```
```

--------------------------------

### Apply Primary Color with Paint

Source: https://docs.rs/evcxr/0.21.1/evcxr/struct.CommandContext.html

Example of using the primary method to style output.

```rust
println!("{}", value.primary());
```

--------------------------------

### Apply background color methods

Source: https://docs.rs/evcxr/0.21.1/evcxr/struct.EvalContext.html

Examples of various background color methods available for painted objects.

```rust
println!("{}", value.on_primary());
```

```rust
println!("{}", value.on_fixed(color));
```

```rust
println!("{}", value.on_rgb(r, g, b));
```

```rust
println!("{}", value.on_black());
```

```rust
println!("{}", value.on_red());
```

```rust
println!("{}", value.on_green());
```

```rust
println!("{}", value.on_yellow());
```

```rust
println!("{}", value.on_blue());
```

```rust
println!("{}", value.on_magenta());
```

```rust
println!("{}", value.on_cyan());
```

```rust
println!("{}", value.on_white());
```

```rust
println!("{}", value.on_bright_black());
```

```rust
println!("{}", value.on_bright_red());
```

```rust
println!("{}", value.on_bright_green());
```

```rust
println!("{}", value.on_bright_yellow());
```

```rust
println!("{}", value.on_bright_blue());
```

```rust
println!("{}", value.on_bright_magenta());
```

```rust
println!("{}", value.on_bright_cyan());
```

```rust
println!("{}", value.on_bright_white());
```

--------------------------------

### Apply attribute methods

Source: https://docs.rs/evcxr/0.21.1/evcxr/struct.EvalContext.html

Examples of various text attribute methods available for painted objects.

```rust
println!("{}", value.bold());
```

```rust
println!("{}", value.dim());
```

```rust
println!("{}", value.italic());
```

```rust
println!("{}", value.underline());
```

```rust
println!("{}", value.blink());
```

```rust
println!("{}", value.rapid_blink());
```

--------------------------------

### Initialize EvalContext and Evaluate Code

Source: https://docs.rs/evcxr/0.21.1/evcxr/struct.EvalContext.html

Demonstrates initializing an EvalContext and evaluating multiple lines of Rust code. Ensure `evcxr::runtime_hook()` is called at the start of `main` to prevent issues.

```rust
11fn main() -> Result<(), Error> {
12    // You must call ```evcxr::runtime_hook()``` at the top of main, otherwise
13    // the library becomes a fork-bomb.
14    evcxr::runtime_hook();
15
16    let (mut context, outputs) = EvalContext::new()?;
17    context.eval("let mut s = String::new();")?;
18    context.eval(r#"s.push_str(\"Hello, \");"#)?;
19    context.eval(r#"s.push_str(\"World!\");"#)?;
20    context.eval(r#"println!(\"{}\", s);"#)?;
21
22    // For this trivial example, we just receive a single line of output from
23    // the code that was run. In a more complex case, we'd likely want to have
24    // separate threads waiting for output on both stdout and stderr.
25    if let Ok(line) = outputs.stdout.recv() {
26        println!("{line}");
27    }
28
29    Ok(())
30}
```

--------------------------------

### Get Code Completions

Source: https://docs.rs/evcxr/0.21.1/src/evcxr/command_context.rs.html

Provides code completions based on the current source and cursor position.

```rust
pub fn completions(&mut self, src: &str, position: usize) -> Result<Completions> {
        let (user_code, code_info) = CodeBlock::from_original_user_code(src);
        if let Some((segment, offset)) = user_code.command_containing_user_offset(position) {
            return self.command_completions(segment, offset, position);
        }
        let (non_command_code, state, _errors) = self.prepare_for_analysis(user_code)?;
        self.eval_context
            .completions(non_command_code, state, &code_info.nodes, position)
    }
```

--------------------------------

### Create New Painted Instance

Source: https://docs.rs/evcxr/0.21.1/evcxr/struct.EvalContextOutputs.html

Creates a new `Painted` instance with a default `Style`. Use this to start a new styling chain.

```rust
Painted::new()
```

--------------------------------

### Function: runtime_hook

Source: https://docs.rs/evcxr/0.21.1/evcxr/fn.runtime_hook.html

Initializes the evcxr runtime. This must be called at the start of main to handle subprocess execution correctly.

```APIDOC
## fn runtime_hook

### Description
Binaries can call this just after starting. If the process is detected as a subprocess, control will not return. This handles two types of subprocesses: the process that loads/runs user code and the wrapper around rustc.

### Signature
`pub fn runtime_hook()`

### Usage
Must be called at the top of the `main` function to prevent the library from becoming a fork-bomb.

### Example
```rust
fn main() -> Result<(), Error> {
    // You must call evcxr::runtime_hook() at the top of main
    evcxr::runtime_hook();

    let (mut context, outputs) = EvalContext::new()?;
    // ... rest of the logic
    Ok(())
}
```
```

--------------------------------

### Install Crash Handlers

Source: https://docs.rs/evcxr/0.21.1/src/evcxr/runtime.rs.html

Platform-specific crash handlers for Unix systems to catch signals like SEGV and provide backtraces.

```rust
#[cfg(all(unix, not(target_os = "freebsd")))]
pub fn install_crash_handlers(&self) {
    use backtrace::Backtrace;
    use sig::ffi::Sig;
    extern "C" fn segfault_handler(signal: i32) {
        eprintln!(
            "{}",
            match signal {
                Sig::SEGV => "Segmentation fault.",
                Sig::ILL => "Illegal instruction.",
                Sig::BUS => "Bus error.",
                _ => "Unexpected signal.",
            }
        );
        eprintln!("{:?}", Backtrace::new());
        std::process::abort();
    }

    signal!(Sig::SEGV, segfault_handler);
    signal!(Sig::ILL, segfault_handler);
    signal!(Sig::BUS, segfault_handler);
}
```

--------------------------------

### Evaluate Rust Code with Evcxr

Source: https://docs.rs/evcxr/0.21.1/src/example_eval/example_eval.rs.html

Demonstrates how to initialize an Evcxr evaluation context, evaluate multiple lines of Rust code, and capture standard output. Ensure `evcxr::runtime_hook()` is called at the start of `main` to prevent potential issues.

```rust
use evcxr::Error;
use evcxr::EvalContext;

fn main() -> Result<(), Error> {
    // You must call ```evcxr::runtime_hook()``` at the top of main, otherwise
    // the library becomes a fork-bomb.
    evcxr::runtime_hook();

    let (mut context, outputs) = EvalContext::new()?;
    context.eval("let mut s = String::new();")?;
    context.eval(r#"s.push_str(\"Hello, \");"#)?;
    context.eval(r#"s.push_str(\"World!\");"#)?;
    context.eval(r#"println!(\"{}\", s);"#)?;

    // For this trivial example, we just receive a single line of output from
    // the code that was run. In a more complex case, we'd likely want to have
    // separate threads waiting for output on both stdout and stderr.
    if let Ok(line) = outputs.stdout.recv() {
        println!("{line}");
    }

    Ok(())
}

```

--------------------------------

### Call runtime_hook in main

Source: https://docs.rs/evcxr/0.21.1/evcxr/fn.runtime_hook.html

Call `evcxr::runtime_hook()` at the top of your `main` function. Failure to do so can result in a fork-bomb. This example demonstrates basic evaluation and output retrieval.

```rust
fn main() -> Result<(), Error> {
    // You must call ```evcxr::runtime_hook()``` at the top of main, otherwise
    // the library becomes a fork-bomb.
    evcxr::runtime_hook();

    let (mut context, outputs) = EvalContext::new()?;
    context.eval("let mut s = String::new();")?;
    context.eval(r#"s.push_str(\"Hello, \");"#)?;
    context.eval(r#"s.push_str(\"World!\");"#)?;
    context.eval(r#"println!(\"{}\", s);"#)?;

    // For this trivial example, we just receive a single line of output from
    // the code that was run. In a more complex case, we'd likely want to have
    // separate threads waiting for output on both stdout and stderr.
    if let Ok(line) = outputs.stdout.recv() {
        println!("{line}");
    }

    Ok(())
}
```

--------------------------------

### Initialization and Styling

Source: https://docs.rs/evcxr/0.21.1/evcxr/struct.EvalCallbacks.html

Methods for creating and applying styles.

```APIDOC
## POST /websites/rs_evcxr_0_21_1/new

### Description
Creates a new `Painted` with a default `Style`.

### Method
POST

### Endpoint
/websites/rs_evcxr_0_21_1/new

### Request Body
None

### Response
#### Success Response (200)
- Painted<Self> - A new `Painted` instance.

### Response Example
```rust
let painted = Painted::new();
```
```

```APIDOC
## POST /websites/rs_evcxr_0_21_1/paint

### Description
Applies a style wholesale to the painted text, replacing any previous style.

### Method
POST

### Endpoint
/websites/rs_evcxr_0_21_1/paint

### Parameters
#### Request Body
- **style** (S: Into<Style>) - Required - The style to apply.

### Response
#### Success Response (200)
- Painted<&Self> - The painted text with the new style applied.

### Response Example
```rust
let styled_text = painted.paint(Style::new().bold());
```
```

--------------------------------

### Get Error Level

Source: https://docs.rs/evcxr/0.21.1/evcxr/struct.CompilationError.html

Retrieves the severity level of the CompilationError as a string slice.

```rust
pub fn level(&self) -> &str
```

--------------------------------

### Show Dependencies Command

Source: https://docs.rs/evcxr/0.21.1/src/evcxr/command_context.rs.html

Displays a list of all current dependencies in the project.

```rust
AvailableCommand::new(
                ":show_deps",
                "Show the current dependencies",
                |_ctx, state, _args| process_show_deps_command(state),
            )
```

--------------------------------

### Initialize Config

Source: https://docs.rs/evcxr/0.21.1/src/evcxr/eval_context.rs.html

Creates a new Config instance with default settings for paths and build flags.

```rust
impl Config {
    pub fn new(tmpdir: PathBuf, subprocess_path: PathBuf) -> Result<Self> {
        let rustc_path = default_rustc_path()?;
        let core_extern = core_extern(&rustc_path)?;
        let target = get_host_target(Path::new(&rustc_path))?;
        Ok(Config {
            tmpdir,
            debug_mode: false,
            preserve_vars_on_panic: true,
            output_format: "{:?}".to_owned(),
            display_types: false,
            display_final_expression: true,
            expand_use_statements: true,
            opt_level: "2".to_owned(),
            error_fmt: &ERROR_FORMATS[0],
            time_passes: false,
            linker: "system".to_owned(),
            cache_bytes: 0,
            sccache: None,
            offline_mode: false,
            toolchain: String::new(),
            cargo_path: default_cargo_path()?,
            rustc_path,
            core_extern,
            target,
            // Forcing dynamic linking causes hard-to-diagnose problems in some cases, so it's off
            // by default.
            allow_static_linking: true,
            subprocess_path,
            codegen_backend: None,
            build_envs: Default::default(),
        })
    }
```

--------------------------------

### Dereference Pointer

Source: https://docs.rs/evcxr/0.21.1/evcxr/enum.Error.html

Dereferences a pointer to get an immutable reference to the data. This is an unsafe operation.

```rust
unsafe fn deref<'a>(ptr: usize) -> &'a T
Dereferences the given pointer. Read more
```

--------------------------------

### Get Compilation Error Message

Source: https://docs.rs/evcxr/0.21.1/evcxr/struct.CompilationError.html

Retrieves the main error message as a String from a CompilationError.

```rust
pub fn message(&self) -> String
```

--------------------------------

### Initialization and Styling

Source: https://docs.rs/evcxr/0.21.1/evcxr/enum.Theme.html

Methods for creating and applying styles to painted text.

```APIDOC
## POST /websites/rs_evcxr_0_21_1/new

### Description
Creates a new `Painted` with a default `Style`.

### Method
POST

### Endpoint
/websites/rs_evcxr_0_21_1/new

### Request Body
None

### Response
#### Success Response (200)
A new `Painted` object.

#### Response Example
```
Painted::new(self)
```
```

```APIDOC
## POST /websites/rs_evcxr_0_21_1/paint

### Description
Applies a style wholesale to `self`. Any previous style is replaced.

### Method
POST

### Endpoint
/websites/rs_evcxr_0_21_1/paint

### Parameters
#### Request Body
- **style** (S) - Required - The style to apply, where S implements `Into<Style>`.

### Response
#### Success Response (200)
Painted text with the specified style applied.

#### Response Example
```
painted.paint(style)
```
```

--------------------------------

### Initialize ConfigToml

Source: https://docs.rs/evcxr/0.21.1/src/evcxr/toml_parse.rs.html

Provides a default constructor for ConfigToml, initializing with default evcxr settings and an empty dependency table.

```rust
impl ConfigToml {
    fn new() -> Self {
        Self {
            evcxr: EvcxrToml::new(),
            dependencies: Default::default(),
            source_path: None,
        }
    }
// ...
```

--------------------------------

### Get Pointer Alignment

Source: https://docs.rs/evcxr/0.21.1/evcxr/enum.Error.html

Retrieves the alignment value for a pointer. This is a constant associated with the `Pointable` trait.

```rust
const ALIGN: usize
The alignment of pointer.
```

--------------------------------

### Implement Evaluation Context Methods

Source: https://docs.rs/evcxr/0.21.1/src/evcxr/eval_context.rs.html

Methods for initializing the evaluation context, including platform-specific environment configuration.

```rust
impl EvalContext {
    pub fn new() -> Result<(EvalContext, EvalContextOutputs), Error> {
        fix_path();

        let current_exe = std::env::current_exe()?;
        Self::with_subprocess_command(std::process::Command::new(current_exe))
    }

    fn apply_platform_specific_vars(config: &Config, command: &mut std::process::Command) {
        if cfg!(not(windows)) {
            return;
        }
        // Windows doesn't support rpath, so we need to set PATH so that it
        // knows where to find dlls.
        let mut path_var_value = OsString::new();
        path_var_value.push(config.deps_dir());
        path_var_value.push(";");

        let mut sysroot_command = std::process::Command::new("rustc");
        sysroot_command.arg("--print").arg("sysroot");
        path_var_value.push(format!(
            "{}\bin;",
            String::from_utf8_lossy(&sysroot_command.output().unwrap().stdout).trim()
        ));
        path_var_value.push(std::env::var("PATH").unwrap_or_default());

        command.env("PATH", path_var_value);
    }

    #[doc(hidden)]
    pub fn new_for_testing() -> (EvalContext, EvalContextOutputs) {
        let testing_runtime_path = std::env::current_exe()
            .unwrap()
            .parent()
            .unwrap()
            .parent()
            .unwrap()
            .join("testing_runtime");
        let (mut context, outputs) =
            EvalContext::with_subprocess_command(std::process::Command::new(testing_runtime_path))
                .unwrap();
        let mut state = context.state();
        state.set_offline_mode(true);
        context.commit_state(state);
        (context, outputs)
    }
}
```

--------------------------------

### Initialization and Styling

Source: https://docs.rs/evcxr/0.21.1/evcxr/struct.EvalContext.html

Methods for creating and applying styles to text.

```APIDOC
## fn new(self) -> Painted<Self>

### Description
Create a new `Painted` with a default `Style`.

### Method
POST

### Endpoint
N/A (Constructor)

### Request Example
```rust
let painted = Painted::new();
```

### Response Example
```rust
// Returns a new Painted object with default style
```
```

```APIDOC
## fn paint<S>(&self, style: S) -> Painted<&Self>

### Description
Apply a style wholesale to `self`. Any previous style is replaced.

### Method
POST

### Endpoint
N/A (Method on an object)

### Parameters
#### Query Parameters
- **style** (S: Into<Style>) - Required - The style to apply.

### Request Example
```rust
let styled_text = painted.paint(yansi::Style::new().red().bold());
```

### Response Example
```rust
// Returns a Painted object with the specified style applied
```
```

--------------------------------

### Apply Foreground Color with Paint

Source: https://docs.rs/evcxr/0.21.1/evcxr/struct.CommandContext.html

Examples of applying foreground colors to types implementing the Paint trait.

```rust
use yansi::{Paint, Color};

painted.fg(Color::White);
```

```rust
use yansi::Paint;

painted.white();
```

--------------------------------

### Mutably Dereference Pointer

Source: https://docs.rs/evcxr/0.21.1/evcxr/enum.Error.html

Mutably dereferences a pointer to get a mutable reference to the data. This is an unsafe operation.

```rust
unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T
Mutably dereferences the given pointer. Read more
```

--------------------------------

### Define :help Command

Source: https://docs.rs/evcxr/0.21.1/src/evcxr/command_context.rs.html

Defines a command to print help information for available commands. It formats the output as both plain text and HTML.

```rust
AvailableCommand::new(":help", "Print command help", |_ctx, _state, _args| {
                use std::fmt::Write;
                let mut text = String::new();
                let mut html = String::new();
                writeln!(html, "<table>")?;
                let mut commands = CommandContext::create_commands();
                commands.sort_by(|a, b| a.name.cmp(b.name));
                for cmd in commands {
                    writeln!(text, "{:<17} {}", cmd.name, cmd.short_description).unwrap();
                    writeln!(
                        html,
                        "<tr><td>{}</td><td>{}</td></tr>",
                        cmd.name,
                        cmd.short_description
                    )?;
                }
                writeln!(html, "</table>")?;
                Ok(EvalOutputs::text_html(text, html))
            }),
```

--------------------------------

### Get Help Messages

Source: https://docs.rs/evcxr/0.21.1/evcxr/struct.CompilationError.html

Retrieves a vector of strings, where each string is a help message or suggestion for resolving the CompilationError.

```rust
pub fn help(&self) -> Vec<String>
```

--------------------------------

### Get Compilation Error Explanation

Source: https://docs.rs/evcxr/0.21.1/evcxr/struct.CompilationError.html

Retrieves an optional string slice providing a more detailed explanation of the CompilationError.

```rust
pub fn explanation(&self) -> Option<&str>
```

--------------------------------

### Get Compilation Error Message

Source: https://docs.rs/evcxr/0.21.1/src/evcxr/errors.rs.html

Returns a clone of the compilation error's main message string.

```rust
pub fn message(&self) -> String {
    self.message.clone()
}
```

--------------------------------

### RustAnalyzer Initialization and Source Management

Source: https://docs.rs/evcxr/0.21.1/src/evcxr/rust_analyzer.rs.html

Methods for creating a new RustAnalyzer instance and updating the source code being analyzed.

```rust
impl RustAnalyzer {
    pub(crate) fn new(root_directory: &Path) -> Result<RustAnalyzer> {
        use ra_vfs::loader::Handle;
        let (message_sender, message_receiver) = crossbeam_channel::unbounded();
        let mut vfs = ra_vfs::Vfs::default();
        let root_directory = AbsPathBuf::try_from(
            root_directory
                .to_str()
                .context("Root directory is not UTF-8")?,
        )
        .map_err(|path| anyhow!("Evcxr tmpdir is not absolute: '{:?}'", path))?;
        let source_file = root_directory.join("src/lib.rs");
        // We need to write the file to the filesystem even though we subsequently set the file
        // contents via the vfs and change.change_file. This is because the loader checks for the
        // files existence when determining the crate structure.
        let src_dir = root_directory.join("src");
        std::fs::create_dir_all(&src_dir)
            .with_context(|| format!("Failed to create directory `{src_dir:?}`"))?;
        // Pre-allocate an ID for our main source file.
        let vfs_source_file: ra_vfs::VfsPath = source_file.clone().into();
        vfs.set_file_contents(vfs_source_file.clone(), Some(vec![]));
        let (source_file_id, _) = vfs.file_id(&vfs_source_file).unwrap();
        Ok(RustAnalyzer {
            with_sysroot: true,
            root_directory,
            analysis_host: Default::default(),
            vfs,
            loader: vfs_notify::NotifyHandle::spawn(message_sender),
            message_receiver,
            last_cargo_toml: None,
            source_file,
            source_file_id,
            current_source: String::new(),
        })
    }

    pub(crate) fn set_source(&mut self, source: String) -> Result<()> {
        self.current_source = source;
        let mut change = ra_hir::ChangeWithProcMacros::default();

        std::fs::write(self.source_file.as_path(), &*self.current_source)
            .with_context(|| format!("Failed to write {:?}", self.source_file))?;
        self.vfs.set_file_contents(
            self.source_file.clone().into(),
            Some(self.current_source.bytes().collect()),
        );
        change.change_file(self.source_file_id, Some(self.current_source.clone()));

        // Check to see if we haven't yet loaded Cargo.toml, or if it's changed since we read it.
        let cargo_toml = Some(std::fs::read(self.cargo_toml_filename()).with_context(|| {
            format!(
```

--------------------------------

### Apply Foreground Colors with Paint

Source: https://docs.rs/evcxr/0.21.1/evcxr/struct.EvalOutputs.html

Examples of applying foreground colors to a painted value using the Paint trait.

```rust
use yansi::{Paint, Color};

painted.fg(Color::White);
```

```rust
use yansi::Paint;

painted.white();
```

```rust
println!("{}", value.primary());
```

```rust
println!("{}", value.fixed(color));
```

```rust
println!("{}", value.rgb(r, g, b));
```

```rust
println!("{}", value.black());
```

--------------------------------

### CommandContext::new

Source: https://docs.rs/evcxr/0.21.1/src/evcxr/command_context.rs.html

Creates a new CommandContext and initializes an EvalContext. Returns the CommandContext and any initial EvalContext outputs.

```APIDOC
## CommandContext::new

### Description
Creates a new `CommandContext` and initializes an `EvalContext`. This is the primary way to get started with `CommandContext`.

### Method
Associated function (constructor)

### Endpoint
N/A (Rust function)

### Parameters
None

### Request Example
```rust
let (command_context, outputs) = CommandContext::new()?;
```

### Response
#### Success Response
- `Result<(CommandContext, EvalContextOutputs), Error>`: A tuple containing the new `CommandContext` and `EvalContextOutputs` on success.

#### Response Example
```rust
// On success, returns a tuple like:
// (CommandContext { ... }, EvalContextOutputs { ... })
```
```

--------------------------------

### Get Rendered Error Output

Source: https://docs.rs/evcxr/0.21.1/evcxr/struct.CompilationError.html

Returns a String representing the fully rendered output of the CompilationError, suitable for display.

```rust
pub fn rendered(&self) -> String
```

--------------------------------

### Load Configuration Command

Source: https://docs.rs/evcxr/0.21.1/src/evcxr/command_context.rs.html

Reloads startup configuration files. Accepts an optional `--quiet` flag to suppress logging. Updates the Evcxr state based on the loaded configuration.

```rust
AvailableCommand::new(
                ":load_config",
                "Reloads startup configuration files. Accepts optional flag `--quiet` to suppress logging.",
                |ctx, state, args| {
                    let quiet = args.as_ref().map(String::as_str) == Some("--quiet");
                    let result = ctx.load_config(quiet);
                    *state = ctx.eval_context.state();
                    result
                },
            )
            .disable_in_analysis()
```

--------------------------------

### Get Help Spanned Messages

Source: https://docs.rs/evcxr/0.21.1/evcxr/struct.CompilationError.html

Retrieves a slice of SpannedMessage objects that provide help or suggestions related to the CompilationError.

```rust
pub fn help_spanned(&self) -> &[SpannedMessage]
```

--------------------------------

### Sample Command Arguments

Source: https://docs.rs/evcxr/0.21.1/src/evcxr/module/cache.rs.html

A constant slice containing a representative set of rustc command-line arguments used for testing cache key generation.

```rust
const SAMPLE_ARGS: &[&str] = &[
    "--crate-name",
    "regex",
    "--edition=2021",
    "/home/david/.cargo/registry/src/index.crates.io-6f17d22bba15001f/regex-1.10.2/src/lib.rs",
    "--error-format=json",
    "--json=diagnostic-rendered-ansi,artifacts,future-incompat",
    "--crate-type",
    "lib",
    "--crate-type",
    "dylib",
    "--emit=dep-info,metadata,link",
    "-C",
    "opt-level=2",
    "-C",
    "embed-bitcode=no",
    "-C",
    "codegen-units=16",
    "-C",
    "debug-assertions=on",
    "--cfg",
    "feature=\"default\"",
    "--cfg",
    "feature=\"perf\"",
    "--cfg",
    "feature=\"perf-backtrack\"",
    "--cfg",
    "feature=\"perf-cache\"",
    "--cfg",
    "feature=\"perf-dfa\"",
    "--cfg",
    "feature=\"perf-inline\"",
    "--cfg",
    "feature=\"perf-literal\"",
    "--cfg",
    "feature=\"perf-onepass\"",
    "--cfg",
    "feature=\"std\"",
    "--cfg",
    "feature=\"unicode\"",
    "--cfg",
    "feature=\"unicode-age\"",
    "--cfg",
    "feature=\"unicode-perl\"",
    "--cfg",
    "feature=\"unicode-script\"",
    "--cfg",
    "feature=\"unicode-segment\"",
    "-C",
    "metadata=7a60aee6f9c9be14",
    "-C",
    "extra-filename=-7a60aee6f9c9be14",
    "-C",
    "rpath",
    "--out-dir",
    "/tmp/.tmpAGPAC4/target/x86_64-unknown-linux-gnu/debug/deps",
    "--target",
    "x86_64-unknown-linux-gnu",
    "-C",
    "linker=/usr/bin/clang-15",
    "-C",
    "strip=debuginfo",
    "-L",
    "dependency=/tmp/.tmpAGPAC4/target/x86_64-unknown-linux-gnu/debug/deps",
    "-L",
    "dependency=/tmp/.tmpAGPAC4/target/debug/deps",
    "--extern",
    "aho_corasick=/tmp/.tmpAGPAC4/target/x86_64-unknown-linux-gnu/debug/deps/libaho_corasick-4147e32b287a933f.so",
    "--extern",
    "memchr=/tmp/.tmpAGPAC4/target/x86_64-unknown-linux-gnu/debug/deps/libmemchr-3ac30149df7a21d7.so",
    "--extern",
    "regex_automata=/tmp/.tmpAGPAC4/target/x86_64-unknown-linux-gnu/debug/deps/libregex_automata-b68475a948dc5cb3.so",
    "--extern",
    "regex_syntax=/tmp/.tmpAGPAC4/target/x86_64-unknown-linux-gnu/debug/deps/libregex_syntax-e85cd106ae7f15b9.so",
    "--cap-lints",
    "allow",
    "-Cprefer-dynamic",
    "--extern",
    "core=/home/david/.rustup/toolchains/stable-x86_64-unknown-linux-gnu/lib/rustlib/x86_64-unknown-linux-gnu/lib/libstd-6498d8891e016dca.so",
    "-C",
    "prefer-dynamic",
];
```

--------------------------------

### AvailableCommand Registration

Source: https://docs.rs/evcxr/0.21.1/src/evcxr/command_context.rs.html

Defines how to create and configure commands for the evcxr environment, including optional analysis callbacks.

```APIDOC
## AvailableCommand

### Description
Represents a command available in the evcxr environment. It holds the command name, description, and the callback function to execute.

### Methods
- **new(name, short_description, callback)**: Creates a new command instance.
- **with_analysis_callback(callback)**: Sets a specific callback to be executed during the analysis phase.
- **disable_in_analysis()**: Configures the command to return default outputs when called during analysis.
```

--------------------------------

### Get Spanned Messages

Source: https://docs.rs/evcxr/0.21.1/evcxr/struct.CompilationError.html

Retrieves a slice of SpannedMessage objects associated with the CompilationError, providing detailed locations and messages.

```rust
pub fn spanned_messages(&self) -> &[SpannedMessage]
```

--------------------------------

### Get Explanation from Error JSON

Source: https://docs.rs/evcxr/0.21.1/src/evcxr/errors.rs.html

Retrieves an explanation string related to the error from the underlying JSON data, if present.

```rust
pub fn explanation(&self) -> Option<&str> {
    if let JsonValue::Object(code) = &self.json["code"] {
        return code["explanation"].as_str();
    }
    None
}
```

--------------------------------

### EvalContext::new

Source: https://docs.rs/evcxr/0.21.1/evcxr/struct.EvalContext.html

Initializes a new evaluation context for running Rust code.

```APIDOC
## EvalContext::new

### Description
Creates a new EvalContext instance. Note: You must call evcxr::runtime_hook() at the top of your main function to prevent the library from becoming a fork-bomb.

### Response
- **Result<(EvalContext, EvalContextOutputs), Error>** - Returns a tuple containing the context and its output channels.
```

--------------------------------

### Try Convert From

Source: https://docs.rs/evcxr/0.21.1/evcxr/enum.Error.html

Performs a conversion from one type to another, returning a `Result`. The source type must be convertible into the target type.

```rust
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
Performs the conversion.
```

--------------------------------

### Get Rust Dependency Library Names

Source: https://docs.rs/evcxr/0.21.1/src/evcxr/eval_context.rs.html

Retrieves the names of library dependencies for a Rust project using cargo metadata.

```rust
cargo_metadata::get_library_names(&self.config)
```

--------------------------------

### Process show_deps Command

Source: https://docs.rs/evcxr/0.21.1/src/evcxr/command_context.rs.html

Displays a list of all external dependencies currently added to the project, formatted as 'name = config' strings, sorted alphabetically.

```rust
fn process_show_deps_command(state: &ContextState) -> Result<EvalOutputs, Error> {
    let external_deps = &state.external_deps;
    if external_deps.is_empty() {
        return Ok(EvalOutputs::new());
    }

    let mut deps: Vec<String> = external_deps
        .values()
        .map(|dep| format!("{} = {}", dep.name, dep.config))
        .collect();
    deps.sort();
    text_output(deps.join("\n"))
}
```

--------------------------------

### Get Optimization Level

Source: https://docs.rs/evcxr/0.21.1/src/evcxr/eval_context.rs.html

Retrieves the current optimization level string configured for the compiler. This affects the performance of the compiled code.

```rust
pub fn opt_level(&self) -> &str {
        &self.config.opt_level
    }
```

--------------------------------

### Get Last Compile Directory in evcxr

Source: https://docs.rs/evcxr/0.21.1/src/evcxr/eval_context.rs.html

Returns a reference to the path of the last compilation directory, as stored in the current configuration.

```rust
pub(crate) fn last_compile_dir(&self) -> &Path {
        self.committed_state.config.crate_dir()
    }
```

--------------------------------

### Initialize ContextState

Source: https://docs.rs/evcxr/0.21.1/src/evcxr/eval_context.rs.html

Creates a new ContextState with default values and a provided configuration. Used to set up the compilation environment.

```rust
fn new(config: Config) -> ContextState {
        ContextState {
            items_by_name: HashMap::new(),
            unnamed_items: vec![],
            external_deps: HashMap::new(),
            extern_crate_stmts: HashMap::new(),
            variable_states: HashMap::new(),
            stored_variable_states: HashMap::new(),
            attributes: HashMap::new(),
            async_mode: false,
            allow_question_mark: false,
            build_num: 0,
            config,
        }
    }
```

--------------------------------

### Manage module state and configuration

Source: https://docs.rs/evcxr/0.21.1/src/evcxr/module.rs.html

Struct definition and methods for managing the module's build state and path configuration.

```rust
#[derive(Default)]
pub(crate) struct Module {
    build_num: i32,
    last_allow_static: Option<bool>,
}

const CRATE_NAME: &str = "ctx";

impl Module {
    pub(crate) fn new() -> Result<Module, Error> {
        Ok(Module {
            build_num: 0,
            last_allow_static: None,
        })
    }

    pub(crate) fn so_path(&self, config: &Config) -> PathBuf {
        config
            .deps_dir()
            .join(shared_object_name_from_crate_name(CRATE_NAME))
    }

    // Writes Cargo.toml. Should be called before compile.
    pub(crate) fn write_cargo_toml(&self, state: &ContextState) -> Result<(), Error> {
        write_file(
            state.config.crate_dir(),
            "Cargo.toml",
            &self.get_cargo_toml_contents(state),
        )
    }
```

--------------------------------

### Get Compilation Error Code

Source: https://docs.rs/evcxr/0.21.1/evcxr/struct.CompilationError.html

Retrieves an optional string slice representing a specific error code associated with the CompilationError.

```rust
pub fn code(&self) -> Option<&str>
```

--------------------------------

### Get subprocess handle

Source: https://docs.rs/evcxr/0.21.1/src/evcxr/child_process.rs.html

Returns a handle to the subprocess, which can be used to terminate it. This handle remains valid across process restarts.

```rust
/// Returns a handle to our subprocess. This handle may be used to terminate
/// the subprocess. The returned handle is valid across restarts. i.e. if
/// restart is called, then there is no need to call this method again to
/// get a fresh handle - the previously returned handle will work for the
/// new subprocess.

```

--------------------------------

### yansi::Paint Methods

Source: https://docs.rs/evcxr/0.21.1/evcxr/struct.Completions.html

Documentation for `yansi::Paint` methods.

```APIDOC
#### fn new(self) -> Painted<Self>
where Self: Sized,
Create a new `Painted` with a default `Style`. Read more
```

```APIDOC
#### fn paint<S>(&self, style: S) -> Painted<&Self>
where S: Into<Style>,
Apply a style wholesale to `self`. Any previous style is replaced. Read more
```

--------------------------------

### Define Default Configuration Values

Source: https://docs.rs/evcxr/0.21.1/src/evcxr/toml_parse.rs.html

Provides default settings for various configuration parameters.

```rust
mod default_value {
    pub(super) fn preserve_vars_on_panic() -> bool {
        true
    }
    pub(super) fn offline_mode() -> bool {
        false
    }
    pub(super) fn allow_static_linking() -> bool {
        true
    }
    pub(super) fn opt_level() -> String {
        String::from("2")
    }
}
```

--------------------------------

### Get Codegen Backend

Source: https://docs.rs/evcxr/0.21.1/src/evcxr/eval_context.rs.html

Retrieves the name of the currently configured code generation backend. Returns 'default' if no specific backend is set.

```rust
pub fn codegen_backend(&mut self) -> &str {
        self.config.codegen_backend.as_deref().unwrap_or("default")
    }
```

--------------------------------

### Retrieve Configuration Content

Source: https://docs.rs/evcxr/0.21.1/src/evcxr/toml_parse.rs.html

Fetches content from a specified configuration file within the Evcxr directory if it exists.

```rust
fn get_evcxr_config_content(file_name: &str) -> Result<Option<String>> {
    match crate::config_dir() {
        None => Ok(None),
        Some(evcxr_config_dir) => {
            let config_dir_prelude_path = evcxr_config_dir.join(file_name);
            match config_dir_prelude_path.exists() {
                false => Ok(None),
                true => {
                    let res = std::fs::read_to_string(&config_dir_prelude_path)?;
                    Ok(Some(res))
                }
            }
        }
    }
}
```

--------------------------------

### Initialize CommandContext

Source: https://docs.rs/evcxr/0.21.1/src/evcxr/command_context.rs.html

Creates a new CommandContext instance along with its associated output stream.

```rust
pub fn new() -> Result<(CommandContext, EvalContextOutputs), Error> {
        let (eval_context, eval_context_outputs) = EvalContext::new()?;
        let command_context = CommandContext::with_eval_context(eval_context);
        Ok((command_context, eval_context_outputs))
    }
```

--------------------------------

### Get Linker Path

Source: https://docs.rs/evcxr/0.21.1/src/evcxr/eval_context.rs.html

Returns the path to the linker executable currently configured for use. This is useful for debugging or verifying build settings.

```rust
pub fn linker(&self) -> &str {
        &self.config.linker
    }
```

--------------------------------

### Get Variables and Types in evcxr

Source: https://docs.rs/evcxr/0.21.1/src/evcxr/eval_context.rs.html

Returns an iterator over the defined variables and their types. This is useful for introspection and understanding the current state of the environment.

```rust
pub fn variables_and_types(&self) -> impl Iterator<Item = (&str, &str)> {
        self.committed_state
            .variable_states
            .iter()
            .map(|(v, t)| (v.as_str(), t.type_name.as_str()))
    }
```

--------------------------------

### Create EvalOutputs with Text and HTML Content in Rust

Source: https://docs.rs/evcxr/0.21.1/src/evcxr/eval_context.rs.html

A constructor for `EvalOutputs` that immediately populates it with both plain text and HTML content, keyed by their respective MIME types. Useful for setting initial output values.

```rust
pub fn text_html(text: String, html: String) -> EvalOutputs {
    let mut out = EvalOutputs::new();
    out.content_by_mime_type
        .insert("text/plain".to_owned(), text);
    out.content_by_mime_type
        .insert("text/html".to_owned(), html);
    out
}
```

--------------------------------

### Define ConfigToml Structure

Source: https://docs.rs/evcxr/0.21.1/src/evcxr/toml_parse.rs.html

Defines the main configuration structure loaded from a TOML file, including evcxr-specific settings and project dependencies. Uses serde for deserialization and provides default values.

```rust
use crate::eval_context::Config;
use anyhow::Result;
use serde::Deserialize;
use serde::Serialize;
use std::path::Path;
use std::path::PathBuf;
use tempfile::TempDir;
use toml::Table;
use toml::Value;

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct ConfigToml {
    #[serde(default = "EvcxrToml::new")]
    evcxr: EvcxrToml,
    #[serde(default = "Default::default")]
    dependencies: Table,
    #[serde(skip)]
    pub source_path: Option<PathBuf>,
}

#[derive(Serialize, Deserialize, Debug, Clone, Default)]
struct EvcxrToml {
    tmpdir: Option<String>,
    #[serde(default = "default_value::preserve_vars_on_panic")]
    preserve_vars_on_panic: bool,
    #[serde(default = "default_value::offline_mode")]
    offline_mode: bool,
    sccache: Option<String>,
    #[serde(default = "default_value::allow_static_linking")]
    allow_static_linking: bool,
    prelude: Option<String>,
    #[serde(default = "default_value::opt_level")]
    opt_level: String,
}
```

--------------------------------

### Get Process Handle in evcxr

Source: https://docs.rs/evcxr/0.21.1/src/evcxr/eval_context.rs.html

Provides access to the process handle for the child process, wrapped in an Arc and Mutex for thread-safe access.

```rust
pub fn process_handle(&self) -> Arc<Mutex<std::process::Child>> {
        self.child_process.process_handle()
    }
```

--------------------------------

### Get Variables as HTML

Source: https://docs.rs/evcxr/0.21.1/src/evcxr/command_context.rs.html

Retrieves all currently defined variables and their types, formatted as an HTML table. Variable names and types are HTML-escaped.

```rust
fn vars_as_html(&self) -> String {
        let mut out = String::new();
        out.push_str("<table><tr><th>Variable</th><th>Type</th></tr>");
        for (var, ty) in self.eval_context.variables_and_types() {
            out.push_str("<tr><td>");
            html_escape(var, &mut out);
            out.push_str("</td><td>");
            html_escape(ty, &mut out);
            out.push_str("</td><tr>");
        }
        out.push_str("</table>");
        out
    }
```

--------------------------------

### Function: runtime_hook

Source: https://docs.rs/evcxr/0.21.1/index.html

Handles initialization for evcxr subprocesses, including user code execution and rustc wrappers.

```APIDOC
## POST runtime_hook

### Description
Binaries can call this just after starting. If the system detects that it is running as a subprocess, control will not return to the caller.

### Method
Function Call

### Parameters
- **None**

### Response
- **void** - If the process is a subprocess, this function does not return.
```

--------------------------------

### Styling Methods

Source: https://docs.rs/evcxr/0.21.1/evcxr/struct.Completions.html

Methods for applying background colors, text attributes, and quirks to terminal output.

```APIDOC
## Background Color Methods

### Description
Methods to set the background color of the output.

- `on_bright_yellow()`: Sets background to BrightYellow.
- `on_bright_blue()`: Sets background to BrightBlue.
- `on_bright_magenta()`: Sets background to BrightMagenta.
- `on_bright_cyan()`: Sets background to BrightCyan.
- `on_bright_white()`: Sets background to BrightWhite.

## Attribute Methods

### Description
Methods to apply text attributes like bold, italic, or underline.

- `attr(value: Attribute)`: Enables a specific styling attribute.
- `bold()`: Enables bold text.
- `dim()`: Enables dim text.
- `italic()`: Enables italic text.
- `underline()`: Enables underline.
- `blink()`: Enables blink.
- `rapid_blink()`: Enables rapid blink.
- `invert()`: Inverts colors.
- `conceal()`: Conceals text.
- `strike()`: Adds strikethrough.

## Quirk Methods

### Description
Methods to apply specific quirks to the output.

- `quirk(value: Quirk)`: Enables a specific quirk.
- `mask()`: Enables mask quirk.
- `wrap()`: Enables wrap quirk.
- `linger()`: Enables linger quirk.
- `resetting()`: Enables resetting quirk (formerly clear).
- `bright()`: Enables bright quirk.
- `on_bright()`: Enables on_bright quirk.

## Conditional Styling

### Description
- `whenever(value: Condition)`: Conditionally enable styling based on the provided condition.
```

--------------------------------

### Get Variables as Text

Source: https://docs.rs/evcxr/0.21.1/src/evcxr/command_context.rs.html

Retrieves all currently defined variables and their types, formatted as a plain text string with each variable on a new line.

```rust
fn vars_as_text(&self) -> String {
        let mut out = String::new();
        for (var, ty) in self.eval_context.variables_and_types() {
            out.push_str(var);
            out.push_str(": ");
            out.push_str(ty);
            out.push('\n');
        }
        out
    }
```

--------------------------------

### Get evcxr Extra Hint

Source: https://docs.rs/evcxr/0.21.1/evcxr/struct.CompilationError.html

Retrieves an optional static string slice containing extra hints specific to evcxr for the CompilationError.

```rust
pub fn evcxr_extra_hint(&self) -> Option<&'static str>
```

--------------------------------

### Get Code Snippet from Error JSON

Source: https://docs.rs/evcxr/0.21.1/src/evcxr/errors.rs.html

Extracts a code snippet string associated with the error from the underlying JSON data, if available.

```rust
pub fn code(&self) -> Option<&str> {
    if let JsonValue::Object(code) = &self.json["code"] {
        return code["code"].as_str();
    }
    None
}
```

--------------------------------

### Initialize EvcxrToml Defaults

Source: https://docs.rs/evcxr/0.21.1/src/evcxr/toml_parse.rs.html

Constructs a new EvcxrToml instance using predefined default values.

```rust
impl EvcxrToml {
    fn new() -> Self {
        Self {
            preserve_vars_on_panic: default_value::preserve_vars_on_panic(),
            offline_mode: default_value::offline_mode(),
            allow_static_linking: default_value::allow_static_linking(),
            opt_level: default_value::opt_level(),
            ..Default::default()
        }
    }
}
```

--------------------------------

### Get Configuration Directory

Source: https://docs.rs/evcxr/0.21.1/evcxr/fn.config_dir.html

Retrieves the directory path where evcxr tools store their configuration files. This can be influenced by the EVCXR_CONFIG_DIR environment variable.

```APIDOC
## Get Configuration Directory

### Description
Returns the directory that evcxr tools should use for their configuration. By default, this is the `evcxr` subdirectory of whatever `dirs::config_dir()` returns, but it can be overridden by the `EVCXR_CONFIG_DIR` environment variable.

### Method
GET

### Endpoint
`/config_dir`

### Parameters
#### Query Parameters
- **EVCXR_CONFIG_DIR** (string) - Optional - Overrides the default configuration directory.

### Response
#### Success Response (200)
- **config_dir** (Option<PathBuf>) - The path to the configuration directory.

#### Response Example
```json
{
  "config_dir": "/path/to/evcxr/config"
}
```
```
Tokens:
Raw