No need to return value for Scope::get.

src/engine.rs

@@ -389,7 +389,7 @@ fn search_scope<'a>(
     id: &str,
     begin: Position,
 ) -> Result<(&'a mut Dynamic, ScopeEntryType), Box<EvalAltResult>> {
-    let (ScopeSource {  typ, index, .. }, _) = scope
+    let ScopeSource {  typ, index, .. } = scope
         .get(id)
         .ok_or_else(|| Box::new(EvalAltResult::ErrorVariableNotFound(id.into(), begin)))?;
 
@@ -1162,28 +1162,24 @@ impl Engine {
                             )))
                         }
 
-                        Some((
+                        Some(
                             entry
                             @
                             ScopeSource {
                                 typ: ScopeEntryType::Normal,
                                 ..
-                            },
+                            }) => {
-                            _,
-                        )) => {
                             // Avoid referencing scope which is used below as mut
                             let entry = ScopeSource { name, ..entry };
                             *scope.get_mut(entry) = rhs_val.clone();
                             Ok(rhs_val)
                         }
 
-                        Some((
+                        Some(
                             ScopeSource {
                                 typ: ScopeEntryType::Constant,
                                 ..
-                            },
+                            }) => Err(Box::new(EvalAltResult::ErrorAssignmentToConstant(
-                            _,
-                        )) => Err(Box::new(EvalAltResult::ErrorAssignmentToConstant(
                             name.to_string(),
                             *op_pos,
                         ))),

src/scope.rs

@@ -291,35 +291,22 @@ impl<'a> Scope<'a> {
     }
 
     /// Find an entry in the Scope, starting from the last.
-    pub(crate) fn get(&self, name: &str) -> Option<(EntryRef, Dynamic)> {
+    pub(crate) fn get(&self, name: &str) -> Option<EntryRef> {
         self.0
             .iter()
             .enumerate()
             .rev() // Always search a Scope in reverse order
-            .find_map(
+            .find_map(|(index, Entry { name: key, typ, .. })| {
-                |(
-                    index,
-                    Entry {
-                        name: key,
-                        typ,
-                        value,
-                        ..
-                    },
-                )| {
                 if name == key {
-                        Some((
+                    Some(EntryRef {
-                            EntryRef {
                         name: key,
                         index,
                         typ: *typ,
-                            },
+                    })
-                            value.clone(),
-                        ))
                 } else {
                     None
                 }
-                },
+            })
-            )
     }
 
     /// Get the value of an entry in the Scope, starting from the last.
@@ -365,21 +352,15 @@ impl<'a> Scope<'a> {
     /// ```
     pub fn set_value<T: Variant + Clone>(&mut self, name: &'a str, value: T) {
         match self.get(name) {
-            Some((
+            Some(EntryRef {
-                EntryRef {
                 typ: EntryType::Constant,
                 ..
-                },
+            }) => panic!("variable {} is constant", name),
-                _,
+            Some(EntryRef {
-            )) => panic!("variable {} is constant", name),
-            Some((
-                EntryRef {
                 index,
                 typ: EntryType::Normal,
                 ..
-                },
+            }) => self.0.get_mut(index).unwrap().value = Dynamic::from(value),
-                _,
-            )) => self.0.get_mut(index).unwrap().value = Dynamic::from(value),
             None => self.push(name, value),
         }
     }