message: doc(examples): Add comments to the early exit example
diff: //! This example shows how the host can terminate execution of Wasm early from
  //! inside a host function called by the Wasm.
  +//!
  +//! ```shell
  +//! cargo run --example early-exit --release --features "cranelift"
  +//! ```
  +//!
  +//! Ready?
  use anyhow::bail;
  use std::fmt;
  @@ -21,12 +27,6 @@ impl fmt::Display for ExitCode {
  // And then we implement `std::error::Error`.
  impl std::error::Error for ExitCode {}
  -// The host function that we'll use to terminate execution.
  -fn early_exit() {
  - // This is where it happens.
  - RuntimeError::raise(Box::new(ExitCode(1)));
  -}
  -
  fn main() -> anyhow::Result<()> {
  // Let's declare the Wasm module with the text representation.
  let wasm_bytes = wat2wasm(
  @@ -44,34 +44,52 @@ fn main() -> anyhow::Result<()> {
  "#,
  )?;
  + // Create a Store.
  + // Note that we don't need to specify the engine/compiler if we want to use
  + // the default provided by Wasmer.
  + // You can use `Store::default()` for that.
  let store = Store::new(&JIT::new(&Cranelift::default()).engine());
  +
  + println!("Compiling module...");
  + // Let's compile the Wasm module.
  let module = Module::new(&store, wasm_bytes)?;
  + // We declare the host function that we'll use to terminate execution.
  + fn early_exit() {
  + // This is where it happens.
  + RuntimeError::raise(Box::new(ExitCode(1)));
  + }
  +
  + // Create an import object.
  let import_object = imports! {
  "env" => {
  "early_exit" => Function::new_native(&store, early_exit),
  }
  };
  +
  + println!("Instantiating module...");
  + // Let's instantiate the Wasm module.
  let instance = Instance::new(&module, &import_object)?;
  - // Get the `run` function which we'll use as our entrypoint.
  + // Here we go.
  + //
  + // The Wasm module exports a function called `sum`. We'll use this function
  + // as our entrypoint.
  let run_func: NativeFunc<(i32, i32), i32> =
  instance.exports.get_native_function("run").unwrap();
  - // When we call a function it can either succeed or fail.
  + // When we call a function it can either succeed or fail. We expect it to fail.
  match run_func.call(1, 7) {
  Ok(result) => {
  - bail!(
  - "Expected early termination with `ExitCode`, found: {}",
  - result
  - );
  + bail!("Expected early termination with `ExitCode`, found: {}", result);
  }
  - // We're expecting it to fail.
  - // We attempt to downcast the error into the error type that we were expecting.
  + // In case of a failure, which we expect, we attempt to downcast the error into the error
  + // type that we were expecting.
  Err(e) => match e.downcast::<ExitCode>() {
  // We found the exit code used to terminate execution.
  Ok(exit_code) => {
  println!("Exited early with exit code: {}", exit_code);
  +
  Ok(())
  }
  Err(e) => {
  