Documentation fixes ✔

3 files changed, 16 insertions, 11 deletions

diff --git a/src/eval/capture.rs b/src/eval/capture.rs
index 05760594..182468f7 100644
--- a/src/eval/capture.rs
+++ b/src/eval/capture.rs
@@ -32,7 +32,7 @@ impl<'ast> Visit<'ast> for CapturesVisitor<'_> {
         match node {
             Expr::Ident(ident) => {
                 // Find out whether the identifier is not locally defined, but
-                // captured, and if so, replace it with its value.
+                // captured, and if so, capture its value.
                 if self.internal.get(ident).is_none() {
                     if let Some(slot) = self.external.get(ident) {
                         self.captures.def_slot(ident.as_str(), Rc::clone(slot));
diff --git a/src/eval/mod.rs b/src/eval/mod.rs
index 17620161..524ef43a 100644
--- a/src/eval/mod.rs
+++ b/src/eval/mod.rs
@@ -32,9 +32,9 @@ pub fn eval(env: &mut Env, tree: &Tree, scope: &Scope) -> Pass<ExprMap> {
 
 /// A map from expressions to the values they evaluated to.
 ///
-/// The raw pointers point into the expressions contained in some [tree](Tree).
+/// The raw pointers point into the expressions contained in some [`Tree`].
 /// Since the lifetime is erased, the tree could go out of scope while the hash
-/// map still lives. Though this could lead to lookup panics, it is not unsafe
+/// map still lives. Although this could lead to lookup panics, it is not unsafe
 /// since the pointers are never dereferenced.
 pub type ExprMap = HashMap<*const Expr, Value>;
 
@@ -84,8 +84,8 @@ impl Eval for Tree {
         }
 
         impl<'ast> Visit<'ast> for ExprVisitor<'_, '_> {
-            fn visit_expr(&mut self, item: &'ast Expr) {
-                self.map.insert(item as *const _, item.eval(self.ctx));
+            fn visit_expr(&mut self, node: &'ast Expr) {
+                self.map.insert(node as *const _, node.eval(self.ctx));
             }
         }
 
@@ -443,8 +443,8 @@ impl Eval for ExprIf {
         if let Value::Bool(condition) = condition {
             if condition {
                 self.if_body.eval(ctx)
-            } else if let Some(expr) = &self.else_body {
-                expr.eval(ctx)
+            } else if let Some(else_body) = &self.else_body {
+                else_body.eval(ctx)
             } else {
                 Value::None
             }
diff --git a/src/eval/scope.rs b/src/eval/scope.rs
index c0926c0c..69d519fd 100644
--- a/src/eval/scope.rs
+++ b/src/eval/scope.rs
@@ -52,16 +52,21 @@ impl<'a> Scopes<'a> {
         self.top = self.scopes.pop().expect("no pushed scope");
     }
 
-    /// Define a constant variable in the active scope.
+    /// Define a constant variable with a value in the active scope.
     pub fn def_const(&mut self, var: impl Into<String>, value: impl Into<Value>) {
         self.top.def_const(var, value);
     }
 
-    /// Define a mutable variable in the active scope.
+    /// Define a mutable variable with a value in the active scope.
     pub fn def_mut(&mut self, var: impl Into<String>, value: impl Into<Value>) {
         self.top.def_mut(var, value);
     }
 
+    /// Define a variable with a slot in the active scope.
+    pub fn def_slot(&mut self, var: impl Into<String>, slot: Slot) {
+        self.top.def_slot(var, slot);
+    }
+
     /// Look up the slot of a variable.
     pub fn get(&self, var: &str) -> Option<&Slot> {
         iter::once(&self.top)
@@ -84,7 +89,7 @@ impl Scope {
         Self::default()
     }
 
-    /// Define a constant variable.
+    /// Define a constant variable with a value.
     pub fn def_const(&mut self, var: impl Into<String>, value: impl Into<Value>) {
         let cell = RefCell::new(value.into());
 
@@ -95,7 +100,7 @@ impl Scope {
         self.values.insert(var.into(), Rc::new(cell));
     }
 
-    /// Define a mutable variable.
+    /// Define a mutable variable with a value.
     pub fn def_mut(&mut self, var: impl Into<String>, value: impl Into<Value>) {
         self.values.insert(var.into(), Rc::new(RefCell::new(value.into())));
     }