47db72cac4
The current situation with error_chain is less than ideal, and there are lots of conflicting interests that are impossible to meet at once. Here is an unorganized brain dump of the current situation, stay awhile and listen! This change was triggered ultimately by the desire to make LuaError implement Clone, and this is currently impossible with error_chain. LuaError must implement Clone to be a proper lua citizen that can live as userdata within a lua runtime, because there is no way to limit what the lua runtime can do with a received error. Currently, this is solved by there being a rule that the error will "expire" if the error is passed back into rust, and this is very sub-optimal. In fact, one could easily imagine a scenario where lua is for example memoizing some function, and if the function has ever errored in the past the function should continue returning the same error, and this situation immediately fails with this restriciton in place. Additionally, there are other more minor problems with error_chain which make the API less good than it could be, or limit how we can use error_chain. This change has already solved a small bug in a Chucklefish project, where the conversion from an external error type (Borrow[Mut]Error) was allowed but not intended for user code, and was accidentally used. Additionally, pattern matching on error_chain errors, which should be common when dealing with Lua, is less convenient than a hand rolled error type. So, if we decide not to use error_chain, we now have a new set of problems if we decide interoperability with error_chain is important. The first problem we run into is that there are two natural bounds for wrapped errors that we would pick, (Error + Send + Sync), or just Error, and neither of them will interoperate well with error_chain. (Error + Send + Sync) means we can't wrap error chain errors into LuaError::ExternalError (they're missing the Sync bound), and having the bounds be just Error means the opposite, that we can't hold a LuaError inside an error_chain error. We could just decide that interoperability with error_chain is the most important qualification, and pick (Error + Send), but this causes a DIFFERENT set of problems. The rust ecosystem has the two primary error bounds as Error or (Error + Send + Sync), and there are Into impls from &str / String to Box<Error + Send + Sync> for example, but NOT (Error + Send). This means that we are forced to manually recreate the conversions from &str / String to LuaError rather than relying on a single Into<Box<Error + Send + Sync>> bound, but this means that string conversions have a different set of methods than other error types for external error conversion. I have not been able to figure out an API that I am happy with that uses the (Error + Send) bound. Box<Error> is obnoxious because not having errors implement Send causes needless problems in a multithreaded context, so that leaves (Error + Send + Sync). This is actually a completely reasonable bound for external errors, and has the nice String Into impls that we would want, the ONLY problem is that it is a pain to interoperate with the current version of error_chain. It would be nice to be able to specify the traits that an error generated by the error_chain macro would implement, and this is apparently in progress in the error_chain library. This would solve both the problem with not being able to implement Clone and the problems with (Error + Send) bounds. I am not convinced that this library should go back to using error_chain when that functionality is in stable error_chain though, because of the other minor usability problems with using error_chain. In that theoretical situation, the downside of NOT using error_chain is simply that there would not be automatic stacktraces of LuaError. This is not a huge problem, because stack traces of lua errors are not extremely useful, and for external errors it is not too hard to create a different version of the LuaExternalResult / LuaExternalError traits and do conversion from an error_chain type into a type that will print the stacktrace on display, or use downcasting in the error causes. So in summary, this library is no longer using error_chain, and probably will not use it again in the future. Currently this means that to interoperate with error_chain, you should use error_chain 0.8.1, which derives Sync on errors, or wait for a version that supports user defined trait derives. In the future when error_chain supports user defined trait derives, users may have to take an extra step to make wrapped external errors print the stacktrace that they capture. This change works, but is not entirely complete. There is no error documentation yet, and the change brought to a head an ugly module organization problem. There will be more commits for documentation and reorganization, then a new stable version of rlua.
48 lines
1.3 KiB
Rust
48 lines
1.3 KiB
Rust
//! This example shows a simple read-evaluate-print-loop (REPL).
|
|
|
|
extern crate rlua;
|
|
|
|
use rlua::*;
|
|
use std::io::prelude::*;
|
|
use std::io::{stdin, stdout, stderr, BufReader};
|
|
|
|
fn main() {
|
|
let lua = Lua::new();
|
|
let mut stdout = stdout();
|
|
let mut stdin = BufReader::new(stdin());
|
|
|
|
loop {
|
|
write!(stdout, "> ").unwrap();
|
|
stdout.flush().unwrap();
|
|
|
|
let mut line = String::new();
|
|
|
|
loop {
|
|
stdin.read_line(&mut line).unwrap();
|
|
|
|
match lua.eval::<LuaMultiValue>(&line) {
|
|
Ok(values) => {
|
|
println!(
|
|
"{}",
|
|
values
|
|
.iter()
|
|
.map(|value| format!("{:?}", value))
|
|
.collect::<Vec<_>>()
|
|
.join("\t")
|
|
);
|
|
break;
|
|
}
|
|
Err(LuaError::IncompleteStatement(_)) => {
|
|
// continue reading input and append it to `line`
|
|
write!(stdout, ">> ").unwrap();
|
|
stdout.flush().unwrap();
|
|
}
|
|
Err(e) => {
|
|
writeln!(stderr(), "error: {}", e).unwrap();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|