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 108 109 110 111 112 113 114 115 116
//! # About //! //! Welcome to the documentation for `math-calc`! This is a simple arithmatic //! library that gets an inputted [String], [u8] slice or a plain [&str](str) //! and outputs the finished calculation. //! //! This essentially means you can input multiple calculations seperated by a //! `,` (similar to how JSON can be used) and get a [Vec]<[i32]> containing the //! finished calculations. //! //! # Examples //! //! A basic parsing of a `&str` directly: //! //! ```rust //! use math_calc::{ErrorKind, parse_str}; //! //! fn main() { //! // Expected returns: 1st: 3, 2nd: 110, 3rd: 123 //! let inputted_calculations = "1 + 2, 550 / 5, 8 * 16 + (-25 / 5)"; //! //! // Generate results //! let output_vec: Vec<i32> = parse_str(inputted_calculations).unwrap(); //! //! // Output results of calculation //! println!("Calculation results (in vector):\n\n{:?}", output_vec); //! } //! ``` #[macro_use] extern crate lalrpop_util; use std::str; lalrpop_mod!(grammar); /// Primary error enum that is used on frontend functions to enable proper /// error parsing downstream. /// /// - [ErrorKind::ParseError]: The result when the parser has trouble /// understanding the inputted string. /// - [ErrorKind::InvalidInputEncoding]: When a given input is encoded poorly. /// **Make sure `input` in [parse_str] is UTF-8!** #[derive(Debug)] pub enum ErrorKind<'a> { ParseError(lalrpop_util::ParseError<usize, grammar::Token<'a>, &'a str>), InvalidInputEncoding(std::str::Utf8Error), } /// Parses a given [u8] slice into the expected [Vec]<[i32]> result. /// /// # Examples /// /// Basic valid [u8] slice parsing: /// /// ```rust /// use math_calc::{ErrorKind, parse_u8_slice}; /// /// fn main() { /// // Says "(90 + 5) / 5". Should result in `19`. /// let my_slice = &[40, 53, 32, 43, 32, 57, 48, 41, 32, 47, 32, 53]; /// /// // Parse `my_slice` into the resulting i32 vector /// let output_vec: Vec<i32> = parse_u8_slice(my_slice).unwrap(); /// /// // Outputs the final i32 vector /// println!("Calculation results (in vector):\n\n{:?}", output_vec); /// } /// ``` /// /// Error handling for an invalid u8 formatting (needs to be valid `UTF-8`): /// /// ```rust /// use math_calc::{ErrorKind, parse_u8_slice}; /// /// fn main() { /// // Invalid due to bad formatting (`255` is not a valid character). /// let bad_formatting = &[255, 255, 255, 255, 255, 255, 255, 255, 255]; /// /// // A test assert to prove threoy /// assert!(parse_u8_slice(bad_formatting).is_err()) /// } /// ``` pub fn parse_u8_slice(input: &[u8]) -> Result<Vec<i32>, ErrorKind> { let input_str = match str::from_utf8(input) { Ok(x) => x, Err(e) => return Err(ErrorKind::InvalidInputEncoding(e)), }; parse_str(input_str) } /// Parses a given [str] into the expected [Vec]<[i32]> result. /// /// ***NOTE: This is the primary function that other `parse_x()` functions hook onto***. /// /// # Examples /// /// ```rust /// use math_calc::{ErrorKind, parse_str}; /// /// fn main() { /// let test_operation = "12 + 24, 5 + (4 / (2 + 2))"; // 1: 36, 2: 6 /// /// println!( /// "Result of operation: {:?}", /// parse_str(&test_operation).unwrap() /// ); /// } /// ``` pub fn parse_str(arithmatic: &str) -> Result<Vec<i32>, ErrorKind> { match grammar::GrammarParser::new().parse(arithmatic) { Ok(x) => Ok(x), Err(e) => Err(ErrorKind::ParseError(e)), } }