Use the ? operator

Author: cuviper

rayon-core/src/internal/worker.rs

@@ -60,15 +60,8 @@ pub fn if_in_worker_thread<F, R>(if_true: F) -> Option<R>
 where
     F: FnOnce(&WorkerThread) -> R,
 {
-    let worker_thread = registry::WorkerThread::current();
-    if worker_thread.is_null() {
-        None
-    } else {
-        unsafe {
-            let wt = WorkerThread {
-                thread: &*worker_thread,
-            };
-            Some(if_true(&wt))
-        }
+    unsafe {
+        let thread = registry::WorkerThread::current().as_ref()?;
+        Some(if_true(&WorkerThread { thread }))
     }
 }

rayon-core/src/lib.rs

@@ -202,7 +202,7 @@ impl ThreadPoolBuilder {
     /// will return an error. An `Ok` result indicates that this
     /// is the first initialization of the thread pool.
     pub fn build_global(self) -> Result<(), ThreadPoolBuildError> {
-        let registry = try!(registry::init_global_registry(self));
+        let registry = registry::init_global_registry(self)?;
         registry.wait_until_primed();
         Ok(())
     }
@@ -235,7 +235,8 @@ impl ThreadPoolBuilder {
 
     /// Get the thread name for the thread with the given index.
     fn get_thread_name(&mut self, index: usize) -> Option<String> {
-        self.get_thread_name.as_mut().map(|c| c(index))
+        let f = self.get_thread_name.as_mut()?;
+        Some(f(index))
     }
 
     /// Set a closure which takes a thread index and returns

rayon-core/src/registry.rs

@@ -74,7 +74,8 @@ pub fn init_global_registry(
         called = true;
     });
     if called {
-        init_result.map(|()| &**global_registry())
+        init_result?;
+        Ok(&**global_registry())
     } else {
         Err(ThreadPoolBuildError::new(
             ErrorKind::GlobalPoolAlreadyInitialized,
@@ -87,7 +88,9 @@ pub fn init_global_registry(
 /// function. Declared `unsafe` because it writes to `THE_REGISTRY` in
 /// an unsynchronized fashion.
 unsafe fn init_registry(builder: ThreadPoolBuilder) -> Result<(), ThreadPoolBuildError> {
-    Registry::new(builder).map(|registry| THE_REGISTRY = Some(leak(registry)))
+    let registry = Registry::new(builder)?;
+    THE_REGISTRY = Some(leak(registry));
+    Ok(())
 }
 
 struct Terminator<'a>(&'a Arc<Registry>);
@@ -179,12 +182,12 @@ impl Registry {
     /// Returns the current `WorkerThread` if it's part of this `Registry`.
     pub fn current_thread(&self) -> Option<&WorkerThread> {
         unsafe {
-            if let Some(worker) = WorkerThread::current().as_ref() {
-                if worker.registry().id() == self.id() {
-                    return Some(worker);
-                }
+            let worker = WorkerThread::current().as_ref()?;
+            if worker.registry().id() == self.id() {
+                Some(worker)
+            } else {
+                None
             }
-            None
         }
     }
 

rayon-core/src/thread_pool/mod.rs

@@ -54,7 +54,7 @@ pub struct ThreadPool {
 }
 
 pub fn build(builder: ThreadPoolBuilder) -> Result<ThreadPool, ThreadPoolBuildError> {
-    let registry = try!(Registry::new(builder));
+    let registry = Registry::new(builder)?;
     Ok(ThreadPool { registry })
 }
 
@@ -165,14 +165,8 @@ impl ThreadPool {
     /// [snt]: struct.ThreadPoolBuilder.html#method.num_threads
     #[inline]
     pub fn current_thread_index(&self) -> Option<usize> {
-        unsafe {
-            let curr = WorkerThread::current().as_ref()?;
-            if curr.registry().id() == self.registry.id() {
-                Some(curr.index())
-            } else {
-                None
-            }
-        }
+        let curr = self.registry.current_thread()?;
+        Some(curr.index())
     }
 
     /// Returns true if the current worker thread currently has "local
@@ -198,14 +192,8 @@ impl ThreadPool {
     /// [deque]: https://en.wikipedia.org/wiki/Double-ended_queue
     #[inline]
     pub fn current_thread_has_pending_tasks(&self) -> Option<bool> {
-        unsafe {
-            let curr = WorkerThread::current().as_ref()?;
-            if curr.registry().id() == self.registry.id() {
-                Some(!(*curr).local_deque_is_empty())
-            } else {
-                None
-            }
-        }
+        let curr = self.registry.current_thread()?;
+        Some(!curr.local_deque_is_empty())
     }
 
     /// Execute `oper_a` and `oper_b` in the thread-pool and return
@@ -324,12 +312,8 @@ impl fmt::Debug for ThreadPool {
 #[inline]
 pub fn current_thread_index() -> Option<usize> {
     unsafe {
-        let curr = WorkerThread::current();
-        if curr.is_null() {
-            None
-        } else {
-            Some((*curr).index())
-        }
+        let curr = WorkerThread::current().as_ref()?;
+        Some(curr.index())
     }
 }
 
@@ -342,11 +326,7 @@ pub fn current_thread_index() -> Option<usize> {
 #[inline]
 pub fn current_thread_has_pending_tasks() -> Option<bool> {
     unsafe {
-        let curr = WorkerThread::current();
-        if curr.is_null() {
-            None
-        } else {
-            Some(!(*curr).local_deque_is_empty())
-        }
+        let curr = WorkerThread::current().as_ref()?;
+        Some(!curr.local_deque_is_empty())
     }
 }

src/iter/chain.rs

@@ -60,10 +60,7 @@ where
     }
 
     fn opt_len(&self) -> Option<usize> {
-        match (self.a.opt_len(), self.b.opt_len()) {
-            (Some(a_len), Some(b_len)) => a_len.checked_add(b_len),
-            _ => None,
-        }
+        self.a.opt_len()?.checked_add(self.b.opt_len()?)
     }
 }
 

src/iter/chunks.rs

@@ -163,20 +163,16 @@ where
     type Item = Vec<P::Item>;
 
     fn next(&mut self) -> Option<Self::Item> {
-        match self.inner.take() {
-            Some(producer) => {
-                if self.len > self.chunk_size {
-                    let (left, right) = producer.split_at(self.chunk_size);
-                    self.inner = Some(right);
-                    self.len -= self.chunk_size;
-                    Some(left.into_iter().collect())
-                } else {
-                    debug_assert!(self.len > 0);
-                    self.len = 0;
-                    Some(producer.into_iter().collect())
-                }
-            }
-            _ => None,
+        let producer = self.inner.take()?;
+        if self.len > self.chunk_size {
+            let (left, right) = producer.split_at(self.chunk_size);
+            self.inner = Some(right);
+            self.len -= self.chunk_size;
+            Some(left.into_iter().collect())
+        } else {
+            debug_assert!(self.len > 0);
+            self.len = 0;
+            Some(producer.into_iter().collect())
         }
     }
 
@@ -201,24 +197,20 @@ where
     P: Producer,
 {
     fn next_back(&mut self) -> Option<Self::Item> {
-        match self.inner.take() {
-            Some(producer) => {
-                if self.len > self.chunk_size {
-                    let mut size = self.len % self.chunk_size;
-                    if size == 0 {
-                        size = self.chunk_size;
-                    }
-                    let (left, right) = producer.split_at(self.len - size);
-                    self.inner = Some(left);
-                    self.len -= size;
-                    Some(right.into_iter().collect())
-                } else {
-                    debug_assert!(self.len > 0);
-                    self.len = 0;
-                    Some(producer.into_iter().collect())
-                }
+        let producer = self.inner.take()?;
+        if self.len > self.chunk_size {
+            let mut size = self.len % self.chunk_size;
+            if size == 0 {
+                size = self.chunk_size;
             }
-            _ => None,
+            let (left, right) = producer.split_at(self.len - size);
+            self.inner = Some(left);
+            self.len -= size;
+            Some(right.into_iter().collect())
+        } else {
+            debug_assert!(self.len > 0);
+            self.len = 0;
+            Some(producer.into_iter().collect())
         }
     }
 }

src/iter/intersperse.rs

@@ -47,10 +47,9 @@ where
     }
 
     fn opt_len(&self) -> Option<usize> {
-        match self.base.opt_len() {
-            None => None,
-            Some(0) => Some(0),
-            Some(len) => len.checked_add(len - 1),
+        match self.base.opt_len()? {
+            0 => Some(0),
+            len => len.checked_add(len - 1),
         }
     }
 }

src/iter/map_with.rs

@@ -194,9 +194,8 @@ where
     type Item = R;
 
     fn next(&mut self) -> Option<R> {
-        self.base
-            .next()
-            .map(|item| (self.map_op)(&mut self.item, item))
+        let item = self.base.next()?;
+        Some((self.map_op)(&mut self.item, item))
     }
 
     fn size_hint(&self) -> (usize, Option<usize>) {
@@ -211,9 +210,8 @@ where
     R: Send,
 {
     fn next_back(&mut self) -> Option<R> {
-        self.base
-            .next_back()
-            .map(|item| (self.map_op)(&mut self.item, item))
+        let item = self.base.next_back()?;
+        Some((self.map_op)(&mut self.item, item))
     }
 }
 

src/iter/mod.rs

@@ -1350,9 +1350,8 @@ pub trait ParallelIterator: Sized + Send {
         K: Ord + Send,
         F: Sync + Send + Fn(&Self::Item) -> K,
     {
-        self.map(|x| (f(&x), x))
-            .min_by(|a, b| (a.0).cmp(&b.0))
-            .map(|(_, x)| x)
+        let (_, x) = self.map(|x| (f(&x), x)).min_by(|a, b| (a.0).cmp(&b.0))?;
+        Some(x)
     }
 
     /// Computes the maximum of all the items in the iterator. If the
@@ -1434,9 +1433,8 @@ pub trait ParallelIterator: Sized + Send {
         K: Ord + Send,
         F: Sync + Send + Fn(&Self::Item) -> K,
     {
-        self.map(|x| (f(&x), x))
-            .max_by(|a, b| (a.0).cmp(&b.0))
-            .map(|(_, x)| x)
+        let (_, x) = self.map(|x| (f(&x), x)).max_by(|a, b| (a.0).cmp(&b.0))?;
+        Some(x)
     }
 
     /// Takes two iterators and creates a new iterator over both.
@@ -2329,10 +2327,8 @@ pub trait IndexedParallelIterator: ParallelIterator {
     where
         P: Fn(Self::Item) -> bool + Sync + Send,
     {
-        self.map(predicate)
-            .enumerate()
-            .find_any(|&(_, p)| p)
-            .map(|(i, _)| i)
+        let (i, _) = self.map(predicate).enumerate().find_any(|&(_, p)| p)?;
+        Some(i)
     }
 
     /// Searches for the sequentially **first** item in the parallel iterator
@@ -2363,10 +2359,8 @@ pub trait IndexedParallelIterator: ParallelIterator {
     where
         P: Fn(Self::Item) -> bool + Sync + Send,
     {
-        self.map(predicate)
-            .enumerate()
-            .find_first(|&(_, p)| p)
-            .map(|(i, _)| i)
+        let (i, _) = self.map(predicate).enumerate().find_first(|&(_, p)| p)?;
+        Some(i)
     }
 
     /// Searches for the sequentially **last** item in the parallel iterator
@@ -2397,10 +2391,8 @@ pub trait IndexedParallelIterator: ParallelIterator {
     where
         P: Fn(Self::Item) -> bool + Sync + Send,
     {
-        self.map(predicate)
-            .enumerate()
-            .find_last(|&(_, p)| p)
-            .map(|(i, _)| i)
+        let (i, _) = self.map(predicate).enumerate().find_last(|&(_, p)| p)?;
+        Some(i)
     }
 
     #[doc(hidden)]

src/iter/try_reduce_with.rs

@@ -121,7 +121,8 @@ where
     }
 
     fn complete(self) -> Option<T> {
-        self.opt_result.map(|result| match result {
+        let result = self.opt_result?;
+        Some(match result {
             Ok(ok) => T::from_ok(ok),
             Err(error) => T::from_error(error),
         })