Rust documentation<\/a><\/cite><\/blockquote>\n\n\n\nIn other words, the find()<\/code> method returns None<\/code> as a way to say: There was an error. The value you attempted to find doesn’t exist.<\/em> Hence, we are in some way or another propagating the error as the function find_char_index_in_first_word<\/code> was meant to return a Some(<usize>)<\/code> value.<\/p>\n\n\n\n<\/span>Using the Question Mark (?<\/code>) Operator<\/span><\/h2>\n\n\n\nWe will show two different ways to define the function find_char_index_in_first_word<\/code> using the ?<\/code> operator. Remember what was the original function definition? Let’s check it out one more time.<\/p>\n\n\n\nfn find_char_index_in_first_word(text: &str, char: &char) -> Option<usize> {\n let first_word = match text.split(\" \").next().is_some() == true {\n true => text.split(\" \").next().unwrap(),\n false => return None\n };\n\n first_word.find(|x| &x == char)\n}<\/code><\/pre>\n\n\n\nWe use match<\/code>, before splitting<\/em> the text<\/code> string literal and using the next()<\/code> method to advance the iterator, with the purpose of determining whether the iteration has finished or not by checking if the value is Some(item)<\/code>.<\/p>\n\n\n\nOn one hand, if the iterator is Some(item)<\/code>, we unwrap the value of Some(item)<\/code>, which is used later in the code with the find<\/code> method to find the index of the character char<\/code>.<\/p>\n\n\n\nOn the other hand, if the iterator is None<\/code>, the function won’t execute subsequent lines of code as it will return None<\/code> to the caller function.<\/p>\n\n\n\nWe can achieve the same using the ?<\/code> operator. The ?<\/code> operator returns None<\/code> whenever there is the value is not Some<usize><\/code>. <\/p>\n\n\n\nfn find_char_index_in_first_word(text: &str, char: &char) -> Option<usize> {\n let first_word = text.split(\" \").next()?;\n let index = first_word.find(|x| &x == char)?;\n\n Some(index)\n}<\/code><\/pre>\n\n\n\nThere are a couple of things to look for from checking the code that gets the value of first_word<\/code> or text.split(\" \").next()?<\/code><\/p>\n\n\n\nThere is no need to unwrap the Option<\/code> value returned after triggering next()<\/code><\/li>There is no need to use the return<\/code> keyword to return None<\/code><\/li><\/ol>\n\n\n\nThe ?<\/code> operator magically extracts the value of the next iterator if the value is Some(item)<\/code>. <\/p>\n\n\n\nIn the case the next iterator is None<\/code>, it will behave as return None<\/code>, which prevents executing any additional logic written in the function and immediately return None<\/code> to the caller function.<\/p>\n\n\n\nIf we look further down the code in the function, the index variable works in a similar way.<\/p>\n\n\n\n
let index = first_word.find(|x| &x == char)?;<\/code><\/pre>\n\n\n\nIf the method find()<\/code> returns Some(element)<\/code>, it will extract the value from Some(index)<\/code> and assign the value element<\/code> to the index<\/code> variable. If it doesn’t find anything that meets the condition defined in the closure, it returns None<\/code> to the caller function.<\/p>\n\n\n\nLook at another variation of find_char_index_in_first_word<\/code> method.<\/p>\n\n\n\nfn find_char_index_in_first_word(text: &str, char: &char) -> Option<usize> {\n Some(text.split(\" \").next()?.find(|x| &x == char)?)\n}<\/code><\/pre>\n\n\n\nNotice we are executing the same logic from the original find_char_index_in_first_word<\/code>.<\/p>\n\n\n\n\/\/ long way without using question mark operator ?\nfn find_char_index_in_first_word(text: &str, char: &char) -> Option<usize> {\n let first_word = match text.split(\" \").next().is_some() == true {\n true => text.split(\" \").next().unwrap(),\n false => return None\n };\n\n first_word.find(|x| &x == char)\n}\n\n\/\/ understanding the ? question mark error propagation\nfn find_char_index_in_first_word(text: &str, char: &char) -> Option<usize> {\n let first_word = text.split(\" \").next()?;\n first_word.find(|x| &x == char)\n}\n\n\/\/ Shortcut\nfn find_char_index_in_first_word(text: &str, char: &char) -> Option<usize> {\n Some(text.split(\" \").next()?.find(|x| &x == char)?)\n}<\/code><\/pre>\n\n\n\nNotice how the ?<\/code> operator is often referred to as a shortcut for propagating errors<\/strong>. We went from having 4 lines of code to 2 lines of code. We even converted it into one line of code in our latest version of the find_char_index_in_first_word<\/code> function because the ?<\/code> allows us to chain the logic, even if we come across at any point with the values None<\/code> or Err<\/code>, as ?<\/code> operator will take care of it by returning the error right away. <\/p>\n\n\n\n<\/span>When and Where to Use the Question Mark (?<\/code>) Operator?<\/span><\/h2>\n\n\n\nUnfortunately, there are scenarios where you can or cannot use the question mark ?<\/code> operator. As mentioned in the definition, the ?<\/code> operator is used only in functions that return Result<\/code> or Option<\/code> types<\/strong>.<\/p>\n\n\n\nfn my_fn_one() -> Result<i32, ParseIntError> {}\nfn my_fn_two() -> Option<usize> {}<\/code><\/pre>\n\n\n\nThis doesn’t mean it is not possible to work with Result<\/code> and Option<\/code> types inside a function. However, the ?<\/code> operator should exclusively be used with types that return the same type in a function. <\/p>\n\n\n\nIn other words, if the function returns Result<\/code>, use the ?<\/code> operator in a Result<\/code> type. If the function returns an Option<\/code>, use the ?<\/code> operator in an Option<\/code> type<\/strong>.<\/p>\n\n\n\nAttempting to use the ?<\/code> operator in both types, Result<\/code> and Option<\/code>, in a function that only returns one of the two types will lead to errors. For example, if we were to write the following code:<\/p>\n\n\n\nfn bad_fn() -> Result<i32, String> {\n let b = Ok(\"Got it!\")?;\n let a = Some(1)?;\n\n Ok(a)\n}<\/code><\/pre>\n\n\n\nTrying to run it will cause the following error:<\/p>\n\n\n\n
the ?<\/code> operator can only be used on Result<\/code>s, not Option<\/code>s, in a function that returns Result<\/code><\/code><\/p>\n\n\n\nRemember, the ?<\/code> is a shortcut for error propagation. <\/p>\n\n\n\nIf the ?<\/code> is used in a type different from the type a function returns, there could be a chance of propagating errors unrelated to the type defined on a function to return. <\/p>\n\n\n\nLuckily, Rust is smart enough to detect these errors during compilation time. Hence, errors like this would not occur when running the code.<\/p>\n\n\n\n
<\/span>Conclusion<\/span><\/h2>\n\n\n\nIn conclusion, talking about the ?<\/code> operator is talking about error propagation but also writing less code. Why? because the ?<\/code> operator is capable of both: <\/p>\n\n\n\nExtracting the value of types such as Result<\/code> and Option<\/code>, allowing developers to not worry extracting or “unwrapping” values.<\/li>Returning the error type defined in the return type of a function without the need to explicitly use the return<\/code> type and return an error based on the return type of a function.<\/li><\/ul>\n\n\n\nWas this article helpful?<\/strong><\/p>\n\n\n\nI hope this article helped you to clarify doubts and concepts of Rust, especially to those new to the programming language.<\/strong><\/p>\n\n\n\nShare your thoughts by replying on Twitter of Become A Better Programmer<\/a> or to personal my Twitter account<\/a>.<\/p>\n\n\n\n\n