rhai/src/result.rs

434 lines
18 KiB
Rust
Raw Normal View History

2020-03-08 12:54:02 +01:00
//! Module containing error definitions for the evaluation process.
2020-03-04 15:00:01 +01:00
2020-03-17 19:26:11 +01:00
use crate::stdlib::{
2020-04-24 06:39:24 +02:00
boxed::Box,
2020-03-17 19:26:11 +01:00
error::Error,
fmt,
string::{String, ToString},
};
2020-11-20 09:52:28 +01:00
use crate::{Dynamic, ImmutableString, ParseErrorType, Position, INT};
2020-03-17 19:26:11 +01:00
2020-03-04 15:00:01 +01:00
/// Evaluation result.
///
2020-11-20 09:52:28 +01:00
/// All wrapped [`Position`] values represent the location in the script where the error occurs.
///
2020-10-27 04:30:38 +01:00
/// # Thread Safety
///
2020-11-20 09:52:28 +01:00
/// Currently, [`EvalAltResult`] is neither [`Send`] nor [`Sync`].
/// Turn on the `sync` feature to make it [`Send`] `+` [`Sync`].
2020-03-04 15:00:01 +01:00
#[derive(Debug)]
2020-06-25 05:07:46 +02:00
#[non_exhaustive]
2020-03-04 15:00:01 +01:00
pub enum EvalAltResult {
2020-10-17 10:34:07 +02:00
/// System error. Wrapped values are the error message and the internal error.
2020-10-25 14:48:18 +01:00
#[cfg(not(feature = "sync"))]
2020-10-17 10:34:07 +02:00
ErrorSystem(String, Box<dyn Error>),
2020-10-25 14:48:18 +01:00
/// System error. Wrapped values are the error message and the internal error.
#[cfg(feature = "sync")]
ErrorSystem(String, Box<dyn Error + Send + Sync>),
2020-10-17 10:34:07 +02:00
2020-03-04 15:00:01 +01:00
/// Syntax error.
ErrorParsing(ParseErrorType, Position),
2020-03-30 16:19:37 +02:00
2020-10-05 07:45:57 +02:00
/// Usage of an unknown variable. Wrapped value is the variable name.
ErrorVariableNotFound(String, Position),
/// Call to an unknown function. Wrapped value is the function signature.
2020-03-04 15:00:01 +01:00
ErrorFunctionNotFound(String, Position),
/// An error has occurred inside a called function.
2020-12-30 14:12:51 +01:00
/// Wrapped values are the function name, function source, and the interior error.
ErrorInFunctionCall(String, String, Box<EvalAltResult>, Position),
2020-11-25 02:36:06 +01:00
/// Usage of an unknown [module][crate::Module]. Wrapped value is the [module][crate::Module] name.
2020-10-05 07:45:57 +02:00
ErrorModuleNotFound(String, Position),
2020-11-25 02:36:06 +01:00
/// An error has occurred while loading a [module][crate::Module].
/// Wrapped value are the [module][crate::Module] name and the interior error.
ErrorInModule(String, Box<EvalAltResult>, Position),
2020-07-30 17:29:11 +02:00
/// Access to `this` that is not bound.
ErrorUnboundThis(Position),
2020-10-03 17:27:30 +02:00
/// Data is not of the required type.
/// Wrapped values are the type requested and type of the actual result.
ErrorMismatchDataType(String, String, Position),
2020-10-05 07:45:57 +02:00
/// Returned type is not the same as the required output type.
/// Wrapped values are the type requested and type of the actual result.
ErrorMismatchOutputType(String, String, Position),
2020-03-04 15:00:01 +01:00
/// Array access out-of-bounds.
/// Wrapped values are the current number of elements in the array and the index number.
ErrorArrayBounds(usize, INT, Position),
2020-03-04 15:00:01 +01:00
/// String indexing out-of-bounds.
/// Wrapped values are the current number of characters in the string and the index number.
ErrorStringBounds(usize, INT, Position),
2020-12-26 06:05:57 +01:00
/// Trying to index into a type that is not an array, an object map, or a string, and has no
/// indexer function defined. Wrapped value is the type name.
ErrorIndexingType(String, Position),
2020-04-06 11:47:34 +02:00
/// Invalid arguments for `in` operator.
ErrorInExpr(Position),
2020-03-04 15:00:01 +01:00
/// The `for` statement encounters a type that is not an iterator.
ErrorFor(Position),
2020-10-05 07:45:57 +02:00
/// Data race detected when accessing a variable. Wrapped value is the variable name.
2020-08-02 07:33:51 +02:00
ErrorDataRace(String, Position),
2020-10-05 07:45:57 +02:00
/// Assignment to a constant variable. Wrapped value is the variable name.
2020-03-13 11:12:41 +01:00
ErrorAssignmentToConstant(String, Position),
2020-10-05 07:45:57 +02:00
/// Inappropriate property access. Wrapped value is the property name.
ErrorDotExpr(String, Position),
2020-03-04 15:00:01 +01:00
/// Arithmetic error encountered. Wrapped value is the error message.
ErrorArithmetic(String, Position),
/// Number of operations over maximum limit.
ErrorTooManyOperations(Position),
2020-11-25 02:36:06 +01:00
/// [Modules][crate::Module] over maximum limit.
2020-05-15 15:40:54 +02:00
ErrorTooManyModules(Position),
2020-03-27 07:34:01 +01:00
/// Call stack over maximum limit.
ErrorStackOverflow(Position),
2020-11-02 04:04:45 +01:00
/// Data value over maximum size limit. Wrapped value is the type name.
ErrorDataTooLarge(String, Position),
/// The script is prematurely terminated. Wrapped value is the termination token.
ErrorTerminated(Dynamic, Position),
/// Run-time error encountered. Wrapped value is the error token.
ErrorRuntime(Dynamic, Position),
2020-03-30 16:19:37 +02:00
2020-03-17 10:33:37 +01:00
/// Breaking out of loops - not an error if within a loop.
2020-04-01 10:22:18 +02:00
/// The wrapped value, if true, means breaking clean out of the loop (i.e. a `break` statement).
/// The wrapped value, if false, means breaking the current context (i.e. a `continue` statement).
2020-10-17 10:34:07 +02:00
LoopBreak(bool, Position),
2020-03-04 15:00:01 +01:00
/// Not an error: Value returned from a script via the `return` keyword.
/// Wrapped value is the result value.
Return(Dynamic, Position),
}
2020-03-14 16:39:45 +01:00
impl EvalAltResult {
pub(crate) fn desc(&self) -> &str {
2020-03-04 15:00:01 +01:00
match self {
2020-10-17 10:34:07 +02:00
#[allow(deprecated)]
Self::ErrorSystem(_, s) => s.description(),
Self::ErrorParsing(p, _) => p.desc(),
2020-12-30 14:12:51 +01:00
Self::ErrorInFunctionCall(_,_, _, _) => "Error in called function",
Self::ErrorInModule(_, _, _) => "Error in module",
2020-03-04 15:00:01 +01:00
Self::ErrorFunctionNotFound(_, _) => "Function not found",
2020-07-30 17:29:11 +02:00
Self::ErrorUnboundThis(_) => "'this' is not bound",
2020-10-03 17:27:30 +02:00
Self::ErrorMismatchDataType(_, _, _) => "Data type is incorrect",
Self::ErrorIndexingType(_, _) => {
2020-05-05 14:38:48 +02:00
"Indexing can only be performed on an array, an object map, a string, or a type with an indexer function defined"
}
2020-03-04 15:00:01 +01:00
Self::ErrorArrayBounds(_, index, _) if *index < 0 => {
"Array access expects non-negative index"
}
Self::ErrorArrayBounds(0, _, _) => "Empty array has nothing to access",
2020-03-04 15:00:01 +01:00
Self::ErrorArrayBounds(_, _, _) => "Array index out of bounds",
Self::ErrorStringBounds(_, index, _) if *index < 0 => {
"Indexing a string expects a non-negative index"
}
Self::ErrorStringBounds(0, _, _) => "Empty string has nothing to index",
2020-03-04 15:00:01 +01:00
Self::ErrorStringBounds(_, _, _) => "String index out of bounds",
Self::ErrorFor(_) => "For loop expects an array, object map, or range",
2020-03-04 15:00:01 +01:00
Self::ErrorVariableNotFound(_, _) => "Variable not found",
2020-08-02 07:33:51 +02:00
Self::ErrorModuleNotFound(_, _) => "Module not found",
Self::ErrorDataRace(_, _) => "Data race detected when accessing variable",
2020-11-03 06:08:19 +01:00
Self::ErrorAssignmentToConstant(_, _) => "Cannot assign to a constant",
2020-07-03 04:45:01 +02:00
Self::ErrorMismatchOutputType(_, _, _) => "Output type is incorrect",
2020-04-06 11:47:34 +02:00
Self::ErrorInExpr(_) => "Malformed 'in' expression",
Self::ErrorDotExpr(_, _) => "Malformed dot expression",
2020-03-04 15:00:01 +01:00
Self::ErrorArithmetic(_, _) => "Arithmetic error",
Self::ErrorTooManyOperations(_) => "Too many operations",
2020-05-15 15:40:54 +02:00
Self::ErrorTooManyModules(_) => "Too many modules imported",
2020-03-27 07:34:01 +01:00
Self::ErrorStackOverflow(_) => "Stack overflow",
2020-11-02 04:04:45 +01:00
Self::ErrorDataTooLarge(_, _) => "Data size exceeds maximum limit",
Self::ErrorTerminated(_,_) => "Script terminated.",
2020-03-04 15:00:01 +01:00
Self::ErrorRuntime(_, _) => "Runtime error",
2020-10-17 10:34:07 +02:00
Self::LoopBreak(true, _) => "Break statement not inside a loop",
Self::LoopBreak(false, _) => "Continue statement not inside a loop",
2020-03-04 15:00:01 +01:00
Self::Return(_, _) => "[Not Error] Function returns value",
}
}
}
2020-03-14 16:39:45 +01:00
impl Error for EvalAltResult {}
2020-03-08 12:54:02 +01:00
impl fmt::Display for EvalAltResult {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2020-03-14 16:39:45 +01:00
let desc = self.desc();
let pos = self.position();
2020-03-04 15:00:01 +01:00
match self {
2020-10-17 10:34:07 +02:00
Self::ErrorSystem(s, _) if s.is_empty() => f.write_str(desc)?,
Self::ErrorSystem(s, _) => write!(f, "{}: {}", s, desc)?,
2020-03-30 16:19:37 +02:00
Self::ErrorParsing(p, _) => write!(f, "Syntax error: {}", p)?,
2020-03-30 16:19:37 +02:00
2020-10-12 16:49:51 +02:00
#[cfg(not(feature = "no_function"))]
2020-12-30 14:12:51 +01:00
Self::ErrorInFunctionCall(s, src, err, _) if crate::engine::is_anonymous_fn(s) => {
write!(f, "{}, in call to closure", err)?;
if !src.is_empty() {
write!(f, " @ '{}'", src)?;
}
2020-10-12 16:49:51 +02:00
}
2020-12-30 14:12:51 +01:00
Self::ErrorInFunctionCall(s, src, err, _) => {
write!(f, "{}, in call to function {}", err, s)?;
if !src.is_empty() {
write!(f, " @ '{}'", src)?;
}
}
2020-12-30 14:12:51 +01:00
Self::ErrorInModule(s, err, _) if s.is_empty() => {
write!(f, "Error in module: {}", err)?
}
Self::ErrorInModule(s, err, _) => write!(f, "Error in module '{}': {}", s, err)?,
Self::ErrorFunctionNotFound(s, _)
| Self::ErrorVariableNotFound(s, _)
2020-12-30 14:12:51 +01:00
| Self::ErrorDataRace(s, _) => write!(f, "{}: {}", desc, s)?,
Self::ErrorModuleNotFound(s, _) => write!(f, "{}: '{}'", desc, s)?,
2020-05-04 11:43:54 +02:00
Self::ErrorDotExpr(s, _) if !s.is_empty() => write!(f, "{}", s)?,
2020-03-29 17:53:35 +02:00
2021-01-15 10:13:04 +01:00
Self::ErrorIndexingType(s, _) => write!(f, "Indexer not registered for type '{}'", s)?,
Self::ErrorUnboundThis(_)
| Self::ErrorFor(_)
| Self::ErrorInExpr(_)
| Self::ErrorDotExpr(_, _)
| Self::ErrorTooManyOperations(_)
| Self::ErrorTooManyModules(_)
| Self::ErrorStackOverflow(_)
2020-11-02 04:04:45 +01:00
| Self::ErrorTerminated(_, _) => f.write_str(desc)?,
2020-03-29 17:53:35 +02:00
Self::ErrorRuntime(d, _) if d.is::<ImmutableString>() => {
let s = d.as_str().unwrap();
write!(f, "{}: {}", desc, if s.is_empty() { desc } else { s })?
}
Self::ErrorRuntime(d, _) if d.is::<()>() => f.write_str(desc)?,
Self::ErrorRuntime(d, _) => write!(f, "{}: {}", desc, d)?,
2020-03-30 16:19:37 +02:00
2020-12-30 14:12:51 +01:00
Self::ErrorAssignmentToConstant(s, _) => write!(f, "Cannot assign to constant {}", s)?,
Self::ErrorMismatchOutputType(s, r, _) => {
2020-10-03 17:27:30 +02:00
write!(f, "Output type is incorrect: {} (expecting {})", r, s)?
}
Self::ErrorMismatchDataType(s, r, _) if r.is_empty() => {
2020-10-05 07:45:57 +02:00
write!(f, "Data type is incorrect, expecting {}", s)?
}
Self::ErrorMismatchDataType(s, r, _) if s.is_empty() => {
write!(f, "Data type is incorrect: {}", r)?
}
Self::ErrorMismatchDataType(s, r, _) => {
2020-10-03 17:27:30 +02:00
write!(f, "Data type is incorrect: {} (expecting {})", r, s)?
2020-07-03 04:45:01 +02:00
}
2020-07-02 15:46:08 +02:00
Self::ErrorArithmetic(s, _) => f.write_str(s)?,
2020-03-30 16:19:37 +02:00
2020-10-17 10:34:07 +02:00
Self::LoopBreak(_, _) => f.write_str(desc)?,
2020-07-02 15:46:08 +02:00
Self::Return(_, _) => f.write_str(desc)?,
2020-03-30 16:19:37 +02:00
Self::ErrorArrayBounds(_, index, _) if *index < 0 => {
write!(f, "{}: {} < 0", desc, index)?
2020-03-04 15:00:01 +01:00
}
2020-07-02 15:46:08 +02:00
Self::ErrorArrayBounds(0, _, _) => f.write_str(desc)?,
Self::ErrorArrayBounds(1, index, _) => write!(
2020-03-11 04:03:18 +01:00
f,
"Array index {} is out of bounds: only one element in the array",
index
)?,
Self::ErrorArrayBounds(max, index, _) => write!(
2020-03-05 13:28:03 +01:00
f,
"Array index {} is out of bounds: only {} elements in the array",
index, max
)?,
Self::ErrorStringBounds(_, index, _) if *index < 0 => {
write!(f, "{}: {} < 0", desc, index)?
2020-03-04 15:00:01 +01:00
}
2020-07-02 15:46:08 +02:00
Self::ErrorStringBounds(0, _, _) => f.write_str(desc)?,
Self::ErrorStringBounds(1, index, _) => write!(
2020-03-11 04:03:18 +01:00
f,
"String index {} is out of bounds: only one character in the string",
index
)?,
Self::ErrorStringBounds(max, index, _) => write!(
2020-03-05 13:28:03 +01:00
f,
"String index {} is out of bounds: only {} characters in the string",
index, max
)?,
2020-11-02 04:04:45 +01:00
Self::ErrorDataTooLarge(typ, _) => write!(f, "{} exceeds maximum limit", typ)?,
}
// Do not write any position if None
if !pos.is_none() {
write!(f, " ({})", pos)?;
2020-03-04 15:00:01 +01:00
}
Ok(())
2020-03-04 15:00:01 +01:00
}
}
2020-10-17 10:34:07 +02:00
impl<T: AsRef<str>> From<T> for EvalAltResult {
#[inline(always)]
fn from(err: T) -> Self {
2020-11-20 09:52:28 +01:00
Self::ErrorRuntime(err.as_ref().to_string().into(), Position::NONE)
2020-10-17 10:34:07 +02:00
}
}
impl<T: AsRef<str>> From<T> for Box<EvalAltResult> {
2020-10-08 16:25:50 +02:00
#[inline(always)]
fn from(err: T) -> Self {
Box::new(EvalAltResult::ErrorRuntime(
err.as_ref().to_string().into(),
2020-11-20 09:52:28 +01:00
Position::NONE,
))
}
}
impl EvalAltResult {
/// Is this a pseudo error? A pseudo error is one that does not occur naturally.
///
/// [`LoopBreak`][EvalAltResult::LoopBreak] or [`Return`][EvalAltResult::Return] are pseudo errors.
pub fn is_pseudo_error(&self) -> bool {
match self {
Self::LoopBreak(_, _) | Self::Return(_, _) => true,
_ => false,
}
}
/// Can this error be caught?
///
/// # Panics
///
/// Panics when [`LoopBreak`][EvalAltResult::LoopBreak] or [`Return`][EvalAltResult::Return].
pub fn is_catchable(&self) -> bool {
match self {
Self::ErrorSystem(_, _) => false,
Self::ErrorParsing(_, _) => false,
Self::ErrorFunctionNotFound(_, _)
2020-12-30 14:12:51 +01:00
| Self::ErrorInFunctionCall(_, _, _, _)
| Self::ErrorInModule(_, _, _)
| Self::ErrorUnboundThis(_)
| Self::ErrorMismatchDataType(_, _, _)
| Self::ErrorArrayBounds(_, _, _)
| Self::ErrorStringBounds(_, _, _)
| Self::ErrorIndexingType(_, _)
| Self::ErrorFor(_)
| Self::ErrorVariableNotFound(_, _)
| Self::ErrorModuleNotFound(_, _)
| Self::ErrorDataRace(_, _)
| Self::ErrorAssignmentToConstant(_, _)
| Self::ErrorMismatchOutputType(_, _, _)
| Self::ErrorInExpr(_)
| Self::ErrorDotExpr(_, _)
| Self::ErrorArithmetic(_, _)
| Self::ErrorRuntime(_, _) => true,
Self::ErrorTooManyOperations(_)
| Self::ErrorTooManyModules(_)
| Self::ErrorStackOverflow(_)
2020-11-02 04:04:45 +01:00
| Self::ErrorDataTooLarge(_, _)
| Self::ErrorTerminated(_, _) => false,
Self::LoopBreak(_, _) => panic!("EvalAltResult::LoopBreak should not occur naturally"),
Self::Return(_, _) => panic!("EvalAltResult::Return should not occur naturally"),
}
}
/// Is this error a system exception?
///
/// # Panics
///
/// Panics when [`LoopBreak`][EvalAltResult::LoopBreak] or [`Return`][EvalAltResult::Return].
pub fn is_system_exception(&self) -> bool {
match self {
Self::ErrorSystem(_, _) => true,
Self::ErrorParsing(_, _) => true,
Self::ErrorTooManyOperations(_)
| Self::ErrorTooManyModules(_)
| Self::ErrorStackOverflow(_)
2020-11-02 04:04:45 +01:00
| Self::ErrorDataTooLarge(_, _) => true,
2020-11-02 04:04:45 +01:00
Self::ErrorTerminated(_, _) => true,
Self::LoopBreak(_, _) => panic!("EvalAltResult::LoopBreak should not occur naturally"),
Self::Return(_, _) => panic!("EvalAltResult::Return should not occur naturally"),
_ => false,
}
}
2020-11-25 02:36:06 +01:00
/// Get the [position][Position] of this error.
pub fn position(&self) -> Position {
match self {
2020-11-20 09:52:28 +01:00
Self::ErrorSystem(_, _) => Position::NONE,
Self::ErrorParsing(_, pos)
| Self::ErrorFunctionNotFound(_, pos)
2020-12-30 14:12:51 +01:00
| Self::ErrorInFunctionCall(_, _, _, pos)
| Self::ErrorInModule(_, _, pos)
2020-07-30 17:29:11 +02:00
| Self::ErrorUnboundThis(pos)
2020-10-03 17:27:30 +02:00
| Self::ErrorMismatchDataType(_, _, pos)
| Self::ErrorArrayBounds(_, _, pos)
| Self::ErrorStringBounds(_, _, pos)
| Self::ErrorIndexingType(_, pos)
| Self::ErrorFor(pos)
| Self::ErrorVariableNotFound(_, pos)
2020-05-04 13:36:58 +02:00
| Self::ErrorModuleNotFound(_, pos)
2020-08-02 07:33:51 +02:00
| Self::ErrorDataRace(_, pos)
2020-03-13 11:12:41 +01:00
| Self::ErrorAssignmentToConstant(_, pos)
2020-07-03 04:45:01 +02:00
| Self::ErrorMismatchOutputType(_, _, pos)
2020-04-06 11:47:34 +02:00
| Self::ErrorInExpr(pos)
| Self::ErrorDotExpr(_, pos)
| Self::ErrorArithmetic(_, pos)
| Self::ErrorTooManyOperations(pos)
2020-05-15 15:40:54 +02:00
| Self::ErrorTooManyModules(pos)
2020-03-27 07:34:01 +01:00
| Self::ErrorStackOverflow(pos)
2020-11-02 04:04:45 +01:00
| Self::ErrorDataTooLarge(_, pos)
| Self::ErrorTerminated(_, pos)
| Self::ErrorRuntime(_, pos)
2020-10-17 10:34:07 +02:00
| Self::LoopBreak(_, pos)
| Self::Return(_, pos) => *pos,
}
}
2021-01-08 07:29:57 +01:00
/// Clear the [position][Position] information of this error.
pub fn clear_position(&mut self) -> &mut Self {
self.set_position(Position::NONE);
self
}
2020-11-25 02:36:06 +01:00
/// Override the [position][Position] of this error.
pub fn set_position(&mut self, new_position: Position) {
match self {
2020-10-17 10:34:07 +02:00
Self::ErrorSystem(_, _) => (),
Self::ErrorParsing(_, pos)
| Self::ErrorFunctionNotFound(_, pos)
2020-12-30 14:12:51 +01:00
| Self::ErrorInFunctionCall(_, _, _, pos)
| Self::ErrorInModule(_, _, pos)
2020-07-30 17:29:11 +02:00
| Self::ErrorUnboundThis(pos)
2020-10-03 17:27:30 +02:00
| Self::ErrorMismatchDataType(_, _, pos)
2020-04-05 06:37:07 +02:00
| Self::ErrorArrayBounds(_, _, pos)
| Self::ErrorStringBounds(_, _, pos)
| Self::ErrorIndexingType(_, pos)
| Self::ErrorFor(pos)
| Self::ErrorVariableNotFound(_, pos)
2020-05-04 13:36:58 +02:00
| Self::ErrorModuleNotFound(_, pos)
2020-08-02 07:33:51 +02:00
| Self::ErrorDataRace(_, pos)
2020-04-05 06:37:07 +02:00
| Self::ErrorAssignmentToConstant(_, pos)
2020-07-03 04:45:01 +02:00
| Self::ErrorMismatchOutputType(_, _, pos)
2020-04-06 11:47:34 +02:00
| Self::ErrorInExpr(pos)
2020-04-05 06:37:07 +02:00
| Self::ErrorDotExpr(_, pos)
| Self::ErrorArithmetic(_, pos)
| Self::ErrorTooManyOperations(pos)
2020-05-15 15:40:54 +02:00
| Self::ErrorTooManyModules(pos)
2020-04-05 06:37:07 +02:00
| Self::ErrorStackOverflow(pos)
2020-11-02 04:04:45 +01:00
| Self::ErrorDataTooLarge(_, pos)
| Self::ErrorTerminated(_, pos)
2020-04-05 06:37:07 +02:00
| Self::ErrorRuntime(_, pos)
2020-10-17 10:34:07 +02:00
| Self::LoopBreak(_, pos)
2020-04-05 06:37:07 +02:00
| Self::Return(_, pos) => *pos = new_position,
}
}
2020-11-20 09:52:28 +01:00
/// Consume the current [`EvalAltResult`] and return a new one with the specified [`Position`]
/// if the current position is [`Position::None`].
2020-10-08 16:25:50 +02:00
#[inline(always)]
2020-10-11 15:58:11 +02:00
pub(crate) fn fill_position(mut self: Box<Self>, new_position: Position) -> Box<Self> {
2020-06-01 09:25:22 +02:00
if self.position().is_none() {
self.set_position(new_position);
}
self
}
}
2020-08-06 04:17:32 +02:00
impl<T> From<EvalAltResult> for Result<T, Box<EvalAltResult>> {
2020-10-08 16:25:50 +02:00
#[inline(always)]
2020-08-06 04:17:32 +02:00
fn from(err: EvalAltResult) -> Self {
Err(err.into())
}
}