fasttext 0.8.0

fastText pure Rust implementation
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
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

use std::io;

/// Error type for all fastText operations.
#[derive(Debug, thiserror::Error)]
pub enum FastTextError {
    /// An I/O error occurred.
    #[error("I/O error: {0}")]
    IoError(#[from] io::Error),
    /// An invalid argument was provided.
    #[error("Invalid argument: {0}")]
    InvalidArgument(String),
    /// The model file is invalid or corrupted.
    #[error("Invalid model: {0}")]
    InvalidModel(String),
    /// A NaN value was encountered during computation.
    #[error("Encountered NaN")]
    EncounteredNaN,
}

/// A specialized `Result` type for fastText operations.
pub type Result<T> = std::result::Result<T, FastTextError>;

#[cfg(test)]
mod tests {
    use super::*;
    use std::error::Error;
    use std::io;

    #[test]
    fn test_error_types() {
        // Verify all variants can be constructed
        let _io = FastTextError::IoError(io::Error::new(io::ErrorKind::NotFound, "not found"));
        let _arg = FastTextError::InvalidArgument("bad arg".to_string());
        let _model = FastTextError::InvalidModel("bad model".to_string());
        let _nan = FastTextError::EncounteredNaN;
    }

    #[test]
    fn test_error_display() {
        let io_err =
            FastTextError::IoError(io::Error::new(io::ErrorKind::NotFound, "file not found"));
        let display = format!("{}", io_err);
        assert!(!display.is_empty());
        assert!(display.contains("I/O error"));
        assert!(display.contains("file not found"));

        let arg_err = FastTextError::InvalidArgument("bad argument".to_string());
        let display = format!("{}", arg_err);
        assert!(display.contains("Invalid argument"));
        assert!(display.contains("bad argument"));

        let model_err = FastTextError::InvalidModel("corrupt header".to_string());
        let display = format!("{}", model_err);
        assert!(display.contains("Invalid model"));
        assert!(display.contains("corrupt header"));

        let nan_err = FastTextError::EncounteredNaN;
        let display = format!("{}", nan_err);
        assert!(display.contains("NaN"));
    }

    #[test]
    fn test_error_from_io() {
        let io_err = io::Error::new(io::ErrorKind::PermissionDenied, "access denied");
        let ft_err: FastTextError = io_err.into();
        match &ft_err {
            FastTextError::IoError(e) => {
                assert_eq!(e.kind(), io::ErrorKind::PermissionDenied);
            }
            _ => panic!("Expected IoError variant"),
        }
    }

    #[test]
    fn test_error_source() {
        let io_err = FastTextError::IoError(io::Error::new(io::ErrorKind::NotFound, "not found"));
        assert!(io_err.source().is_some());

        let arg_err = FastTextError::InvalidArgument("bad".to_string());
        assert!(arg_err.source().is_none());

        let model_err = FastTextError::InvalidModel("bad".to_string());
        assert!(model_err.source().is_none());

        let nan_err = FastTextError::EncounteredNaN;
        assert!(nan_err.source().is_none());
    }

    #[test]
    fn test_error_debug() {
        let err = FastTextError::EncounteredNaN;
        let debug = format!("{:?}", err);
        assert!(!debug.is_empty());
    }

    #[test]
    fn test_result_type_alias() {
        fn returns_ok() -> Result<i32> {
            Ok(42)
        }
        fn returns_err() -> Result<i32> {
            Err(FastTextError::InvalidArgument("test".to_string()))
        }
        assert_eq!(returns_ok().unwrap(), 42);
        assert!(returns_err().is_err());
    }
}