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
//! The `Ref` and `RefMut` types in `std::cell` each have a `map` method that create //! a new `Ref` (`RefMut`) that borrows something (a sub-component) inside of a `RefCell`. //! //! When that component may or may not be there, //! you may find yourself checking for its precense twice: //! //! ``` //! # use std::cell::{RefCell, Ref}; //! # use std::collections::HashMap; //! fn borrow_get<'a>(hashmap: &'a RefCell<HashMap<String, String>>, key: &str) //! -> Option<Ref<'a, String>> { //! let hashmap = hashmap.borrow(); //! if hashmap.contains_key(key) { // Duplicated hash table lookup. //! Some(Ref::map(hashmap, |hashmap| { //! &hashmap[key] // panic!() for missing key unlikely to be optimized away //! })) //! } else { //! None //! } //! } //! ``` //! //! This crate define `ref_filter_map` and `ref_mut_filter_map` functions //! that are a lot like `Ref::map` and `RefMut::map`, //! but return `Option` and take closures that return `Option`. //! //! Internally they use a raw pointer and some `unsafe` code, //! but the API they provide is believed to be safe. //! //! This was once part of `std::cell` but has been deprecated there since it makes `Option` //! too much of a special case. //! //! https://github.com/rust-lang/rust/pull/25747 //! https://github.com/rust-lang/rust/issues/27746 use std::cell::{Ref, RefMut}; /// Make a new `Ref` for a optional component of the borrowed data, e.g. an enum variant. /// /// The `RefCell` is already immutably borrowed, so this cannot fail. /// /// This is an associated function that needs to be used as `Ref::filter_map(...)`. /// A method would interfere with methods of the same name on the contents of a `RefCell` /// used through `Deref`. /// /// # Example /// /// ``` /// use std::cell::{RefCell, Ref}; /// use ref_filter_map::ref_filter_map; /// /// let c = RefCell::new(Ok(5)); /// let b1: Ref<Result<u32, ()>> = c.borrow(); /// let b2: Ref<u32> = ref_filter_map(b1, |o| o.as_ref().ok()).unwrap(); /// assert_eq!(*b2, 5) /// ``` pub fn ref_filter_map< T: ?Sized, U: ?Sized, F: FnOnce(&T) -> Option<&U> >(orig: Ref<T>, f: F) -> Option<Ref<U>> { f(&orig) .map(|new| new as *const U) .map(|raw| Ref::map(orig, |_| unsafe { &*raw })) } /// Make a new `RefMut` for a optional component of the borrowed data, e.g. an enum variant. /// /// The `RefCell` is already mutably borrowed, so this cannot fail. /// /// This is an associated function that needs to be used as `RefMut::filter_map(...)`. /// A method would interfere with methods of the same name on the contents of a `RefCell` /// used through `Deref`. /// /// # Example /// /// ``` /// use std::cell::{RefCell, RefMut}; /// use ref_filter_map::ref_mut_filter_map; /// /// let c = RefCell::new(Ok(5)); /// { /// let b1: RefMut<Result<u32, ()>> = c.borrow_mut(); /// let mut b2: RefMut<u32> = ref_mut_filter_map(b1, |o| o.as_mut().ok()).unwrap(); /// assert_eq!(*b2, 5); /// *b2 = 42; /// } /// assert_eq!(*c.borrow(), Ok(42)); /// ``` pub fn ref_mut_filter_map< T: ?Sized, U: ?Sized, F: FnOnce(&mut T) -> Option<&mut U> >(mut orig: RefMut<T>, f: F) -> Option<RefMut<U>> { f(&mut orig) .map(|new| new as *mut U) .map(|raw| RefMut::map(orig, |_| unsafe { &mut *raw })) }