Unbounded -> unbound.

doc/src/language/functions.md

@@ -127,5 +127,5 @@ x.change();         // call 'change' in method-call style, 'this' binds to 'x'
 
 x == 42;            // 'x' is changed!
 
-change();           // <- error: `this` is unbounded
+change();           // <- error: `this` is unbound
 ```

src/engine.rs

@@ -556,7 +556,7 @@ pub fn search_scope_only<'s, 'a>(
         if let Some(val) = this_ptr {
             return Ok(((*val).into(), KEYWORD_THIS, ScopeEntryType::Normal, *pos));
         } else {
-            return Err(Box::new(EvalAltResult::ErrorUnboundedThis(*pos)));
+            return Err(Box::new(EvalAltResult::ErrorUnboundThis(*pos)));
         }
     }
 
@@ -1247,7 +1247,7 @@ impl Engine {
                 if let Some(val) = this_ptr {
                     Ok(val.clone())
                 } else {
-                    Err(Box::new(EvalAltResult::ErrorUnboundedThis((x.0).1)))
+                    Err(Box::new(EvalAltResult::ErrorUnboundThis((x.0).1)))
                 }
             }
             Expr::Variable(_) => {

src/result.rs

@@ -39,8 +39,8 @@ pub enum EvalAltResult {
     /// An error has occurred inside a called function.
     /// Wrapped values are the name of the function and the interior error.
     ErrorInFunctionCall(String, Box<EvalAltResult>, Position),
-    /// Access to `this` that is not bounded.
+    /// Access to `this` that is not bound.
-    ErrorUnboundedThis(Position),
+    ErrorUnboundThis(Position),
     /// Non-boolean operand encountered for boolean operator. Wrapped value is the operator.
     ErrorBooleanArgMismatch(String, Position),
     /// Non-character value encountered where a character is required.
@@ -112,7 +112,7 @@ impl EvalAltResult {
             Self::ErrorParsing(p, _) => p.desc(),
             Self::ErrorInFunctionCall(_, _, _) => "Error in called function",
             Self::ErrorFunctionNotFound(_, _) => "Function not found",
-            Self::ErrorUnboundedThis(_) => "'this' is not bounded",
+            Self::ErrorUnboundThis(_) => "'this' is not bound",
             Self::ErrorBooleanArgMismatch(_, _) => "Boolean operator expects boolean operands",
             Self::ErrorCharMismatch(_) => "Character expected",
             Self::ErrorNumericIndexExpr(_) => {
@@ -187,7 +187,7 @@ impl fmt::Display for EvalAltResult {
             Self::ErrorIndexingType(_, _)
             | Self::ErrorNumericIndexExpr(_)
             | Self::ErrorStringIndexExpr(_)
-            | Self::ErrorUnboundedThis(_)
+            | Self::ErrorUnboundThis(_)
             | Self::ErrorImportExpr(_)
             | Self::ErrorLogicGuard(_)
             | Self::ErrorFor(_)
@@ -276,7 +276,7 @@ impl EvalAltResult {
             Self::ErrorParsing(_, pos)
             | Self::ErrorFunctionNotFound(_, pos)
             | Self::ErrorInFunctionCall(_, _, pos)
-            | Self::ErrorUnboundedThis(pos)
+            | Self::ErrorUnboundThis(pos)
             | Self::ErrorBooleanArgMismatch(_, pos)
             | Self::ErrorCharMismatch(pos)
             | Self::ErrorArrayBounds(_, _, pos)
@@ -316,7 +316,7 @@ impl EvalAltResult {
             Self::ErrorParsing(_, pos)
             | Self::ErrorFunctionNotFound(_, pos)
             | Self::ErrorInFunctionCall(_, _, pos)
-            | Self::ErrorUnboundedThis(pos)
+            | Self::ErrorUnboundThis(pos)
             | Self::ErrorBooleanArgMismatch(_, pos)
             | Self::ErrorCharMismatch(pos)
             | Self::ErrorArrayBounds(_, _, pos)

tests/fn_ptr.rs

@@ -73,7 +73,7 @@ fn test_fn_ptr() -> Result<(), Box<EvalAltResult>> {
             "#
             )
             .expect_err("should error"),
-        EvalAltResult::ErrorInFunctionCall(fn_name, err, _) if fn_name == "foo" && matches!(*err, EvalAltResult::ErrorUnboundedThis(_))
+        EvalAltResult::ErrorInFunctionCall(fn_name, err, _) if fn_name == "foo" && matches!(*err, EvalAltResult::ErrorUnboundThis(_))
     ));
 
     Ok(())