koto 0.16.1

A simple, expressive, embeddable programming language
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

use thiserror::Error;

/// The different error types that can result from [Koto](crate::Koto) operations
#[derive(Debug, Error, Clone)]
#[allow(missing_docs)]
pub enum Error {
    #[error("{0}")]
    StringError(String),
    #[error("missing os module in the prelude")]
    MissingOsModule,
    #[error("no exported function named '{0}' found")]
    MissingFunction(String),
    #[error("{error}")]
    CompileError {
        error: String,
        is_indentation_error: bool,
    },
    #[cfg(feature = "serde")]
    #[error(transparent)]
    SerdeError(#[from] koto_serde::Error),
}

impl Error {
    /// Returns true if the error was caused by the parser expecting indentation
    pub fn is_indentation_error(&self) -> bool {
        match self {
            Self::CompileError {
                is_indentation_error,
                ..
            } => *is_indentation_error,
            _ => false,
        }
    }
}

impl From<koto_runtime::Error> for Error {
    fn from(error: koto_runtime::Error) -> Self {
        use koto_runtime::ErrorKind as RuntimeError;

        // Runtime errors aren't Send+Sync when compiled without multi-threaded support,
        // so render the error message to a String.
        match error.error {
            // Preserve compilation errors so they can be inspected by
            // [`is_indentation_error`](Self::is_indentation_error).
            RuntimeError::CompileError(error) => Self::from(error),
            _ => Self::StringError(error.to_string()),
        }
    }
}

impl From<koto_bytecode::ModuleLoaderError> for Error {
    fn from(error: koto_bytecode::ModuleLoaderError) -> Self {
        // Loader errors aren't Send+Sync when compiled without multi-threaded support,
        // so render the error message to a String.
        Self::CompileError {
            error: error.to_string(),
            is_indentation_error: error.is_indentation_error(),
        }
    }
}

/// The Result type returned by [Koto](crate::Koto) operations
pub type Result<T> = std::result::Result<T, Error>;