⚡ Bolt: Optimize Context variable/function lookups

*   Removed redundant `.clone()` operations on inner data inside `get_func` and `get_variable` when mapping `ContextValue`.
*   Refactored `value` to perform a single `.get(name)` lookup rather than doing `is_none()` followed by `unwrap()`.
*   Avoided holding `MutexGuard` across `func(Vec::new())` execution, thus dropping the lock early and preventing potential deadlock.
*   Documented the learning in `.jules/bolt.md`.

Co-authored-by: ashyanSpada <22587148+ashyanSpada@users.noreply.github.com>

Author: google-labs-jules[bot]

.jules/bolt.md

@@ -0,0 +1,3 @@
+## 2024-05-18 - Avoid double lookups and redundant clones in Context
+**Learning:** The `Context` manager in `src/context.rs` performed redundant hash map lookups (e.g., calling `.get(name).is_none()` followed by `.get(name).unwrap()`) and cloned values that were already owned after being returned from `get()`. By relying on a single `get()` call and moving the inner `Arc` or `Value` directly via pattern matching, we can eliminate these unnecessary double hash map accesses and redundant allocations.
+**Action:** Always prefer matching on `Option` returned from a single map lookup instead of performing `is_none()` checks before `unwrap()`. Furthermore, when matching on an owned value (like an `enum` variant), directly move the inner data instead of cloning it unnecessarily.

src/context.rs

@@ -33,34 +33,29 @@ impl Context {
     pub fn get_func(&self, name: &str) -> Option<Arc<InnerFunction>> {
         let value = self.get(name)?;
         match value {
-            ContextValue::Function(func) => Some(func.clone()),
+            ContextValue::Function(func) => Some(func),
             ContextValue::Variable(_) => None,
         }
     }
 
     pub fn get_variable(&self, name: &str) -> Option<Value> {
         let value = self.get(name)?;
         match value {
-            ContextValue::Variable(v) => Some(v.clone()),
+            ContextValue::Variable(v) => Some(v),
             ContextValue::Function(_) => None,
         }
     }
 
     pub fn get(&self, name: &str) -> Option<ContextValue> {
-        let binding = self.0.lock().unwrap();
-        let value = binding.get(name)?;
-        Some(value.clone())
+        self.0.lock().unwrap().get(name).cloned()
     }
 
     pub fn value(&self, name: &str) -> Result<Value> {
-        let binding = self.0.lock().unwrap();
-        if binding.get(name).is_none() {
-            return Ok(Value::None);
-        }
-        let value = binding.get(name).unwrap();
+        let value = self.get(name);
         match value {
-            ContextValue::Variable(v) => Ok(v.clone()),
-            ContextValue::Function(func) => func(Vec::new()),
+            Some(ContextValue::Variable(v)) => Ok(v),
+            Some(ContextValue::Function(func)) => func(Vec::new()),
+            None => Ok(Value::None),
         }
     }
 }