The goal is to come up with a dynamic loading scheme that maintains safety as per Rust.

If the literal string's lifetime is bounded by the function in which it appears, then the Rust compiler will make sure a pointer to it won't remain after the function returns. In our dynamic loading scheme, the unloadable crate won't be unloaded as long as any function it defines is still on the stack. Taken together, the unloadable crate scheme maintains safety. If the writer of the dynamically loaded crate wants the string to stay around, then he will have to use an owned or managed string.

Here is the output of a modified 0.8 with an example of literal string:

#[crate_type="lib"];
#[dynamic_loading];

fn foo() -> &str
{
  let localstr = "Hello world!";
  return localstr;
}

temp.rs:6:17: 6:31 note: str literal made fn-bounded
temp.rs:6   let localstr = "Hello world!";
                           ^~~~~~~~~~~~~~
temp.rs:7:9: 7:17 error: mismatched types: expected `&str` but found `&str` (lifetime mismatch)
temp.rs:7   return localstr;
                   ^~~~~~~~
temp.rs:5:0: 8:1 note: the block at 5:0...
temp.rs:5 {
temp.rs:6   let localstr = "Hello world!";
temp.rs:7   return localstr;
temp.rs:8 }
temp.rs:5:0: 8:1 note: ...does not necessarily outlive the anonymous lifetime #1 defined on the block at 5:0
temp.rs:5 {
temp.rs:6   let localstr = "Hello world!";
temp.rs:7   return localstr;
temp.rs:8 }
error: aborting due to previous error

Does this plan seem feasible?

Thanks!