Use let-else syntax more (#1148)

* refactor: avoid distant else, convert to `and_then`

- Simplified return flow in `InversePoseidonCache` `get` method in `hash.rs` using `and_then`.
- Refactored variable allocation within `from_ptr` method in `memoset/env.rs`.
- Made minor clean-up and formatting improvements to improve readability across multiple files.

* refactor: convert divergent if .. let to let .. else

* refactor: Refactor if let .. else into let .. else where relevant in store.rs

- Simplify code logic by replacing `if let` syntax with `let ... else`.

* refactor: transform match on option to let-else where relevant

lurk-metrics/src/lib.rs

@@ -158,13 +158,12 @@ impl ThreadMetricsSinkHandle {
 
     /// Initialize the thread-local metrics sink by registering it with the global sink
     fn init() -> ThreadMetricsSinkHandle {
-        if let Some(global_sink) = GLOBAL_SINK.get() {
-            let me = Arc::new(Mutex::new(ThreadMetricsSink::default()));
-            global_sink.threads.lock().unwrap().push(Arc::clone(&me));
-            ThreadMetricsSinkHandle { inner: me }
-        } else {
+        let Some(global_sink) = GLOBAL_SINK.get() else {
             panic!("global metrics sink must be installed first");
-        }
+        };
+        let me = Arc::new(Mutex::new(ThreadMetricsSink::default()));
+        global_sink.threads.lock().unwrap().push(Arc::clone(&me));
+        ThreadMetricsSinkHandle { inner: me }
     }
 }
 

src/coroutine/memoset/env.rs

@@ -207,22 +207,16 @@ impl<F: LurkField> CircuitQuery<F> for EnvCircuitQuery<F> {
 
     fn from_ptr<CS: ConstraintSystem<F>>(cs: &mut CS, s: &Store<F>, ptr: &Ptr) -> Option<Self> {
         let query = EnvQuery::from_ptr(s, ptr);
-        if let Some(q) = query {
-            match q {
-                EnvQuery::Lookup(var, env) => {
-                    let allocated_var = AllocatedNum::alloc_infallible(ns!(cs, "var"), || {
-                        *s.hash_ptr(&var).value()
-                    });
-                    let allocated_env = AllocatedNum::alloc_infallible(ns!(cs, "env"), || {
-                        *s.hash_ptr(&env).value()
-                    });
-                    Some(Self::Lookup(allocated_var, allocated_env))
-                }
-                _ => unreachable!(),
+        query.and_then(|q| match q {
+            EnvQuery::Lookup(var, env) => {
+                let allocated_var =
+                    AllocatedNum::alloc_infallible(ns!(cs, "var"), || *s.hash_ptr(&var).value());
+                let allocated_env =
+                    AllocatedNum::alloc_infallible(ns!(cs, "env"), || *s.hash_ptr(&env).value());
+                Some(Self::Lookup(allocated_var, allocated_env))
             }
-        } else {
-            None
-        }
+            _ => unreachable!(),
+        })
     }
 
     fn dummy_from_index<CS: ConstraintSystem<F>>(cs: &mut CS, s: &Store<F>, index: usize) -> Self {

src/hash.rs

@@ -128,14 +128,10 @@ impl<F: LurkField> InversePoseidonCache<F> {
         macro_rules! get {
             ($name:ident, $n: expr) => {{
                 let preimage = self.$name.get(key);
-                if let Some(p) = preimage {
-                    assert_eq!(ARITY, $n);
+                preimage.and_then(|p | { assert_eq!(ARITY, $n);
                     // SAFETY: we are just teaching the compiler that the slice has size, ARITY, which is guaranteed by
                     // the assertion above.
-                    Some(unsafe { std::mem::transmute::<&[F; $n], &[F; ARITY]>(p) })
-                } else {
-                    None
-                }
+                    Some(unsafe { std::mem::transmute::<&[F; $n], &[F; ARITY]>(p) }) })
             }};
         }
 

src/lem/multiframe.rs

@@ -304,14 +304,12 @@ impl<'a, F: LurkField, C: Coprocessor<F>> MultiFrame<'a, F, C> {
                             inner_frames.push(frames[current_frame_idx].clone());
                             chunk_start_idx = current_frame_idx + 1;
 
-                            if let Some(next_frame) = frames.get(chunk_start_idx) {
-                                next_pc = next_frame.pc;
-                                if next_pc != 0 {
-                                    // incompatible `pc` incoming
-                                    break;
-                                }
-                            } else {
-                                // not enough frames
+                            let Some(next_frame) = frames.get(chunk_start_idx) else {
+                                break;
+                            };
+                            next_pc = next_frame.pc;
+                            if next_pc != 0 {
+                                // incompatible `pc` incoming
                                 break;
                             }
                         }