diff --git a/src/renderer/parameters_context.rs b/src/renderer/parameters_context.rs
index a52eb03..926def2 100644
--- a/src/renderer/parameters_context.rs
+++ b/src/renderer/parameters_context.rs
@@ -22,7 +22,7 @@ use std::rc::Rc;
 
 #[derive(Debug)]
 pub struct ParametersContext<'a> {
-    params: HashMap<&'a str, (&'a RValue<'a>, BreadcrumbTreeElement<'a>)>,
+    params: HashMap<&'a str, (&'a RValue<'a>, Option<BreadcrumbTreeElement<'a>>)>,
 }
 
 impl<'a> ParametersContext<'a> {
@@ -39,27 +39,26 @@ impl<'a> ParametersContext<'a> {
         // then those are resolved at the time of access rather than
         // the time of assignment, so we leave them into their
         // original IntoContextElement state.
-        let rendered_params: HashMap<&'a str, (&'a RValue<'a>, BreadcrumbTreeElement<'a>)> = params
-            .iter()
-            .map(|kvpair| {
-                let k = kvpair.key;
-                let v: Option<BreadcrumbTreeElement<'a>> = match &kvpair.value {
-                    RValue::RVLiteral(owned_literal) => {
-                        Some(BreadcrumbTreeElement::from_borrowed(&kvpair.value))
-                    }
-                    RValue::RVPath(path) => kvpair
-                        .value
-                        .into_context_element(renderer, breadcrumbs)
-                        .map(std::convert::From::from),
-                    RValue::RVTemplate(template) => {
-                        Some(BreadcrumbTreeElement::from_borrowed(&kvpair.value))
-                    }
-                };
-                v.map(|some_v| (k, (&kvpair.value, some_v)))
-            })
-            // TODO: Should a None value here be the same as a key not existing, or should we store the Nones?
-            .filter_map(|pair| pair)
-            .collect();
+        let rendered_params: HashMap<&'a str, (&'a RValue<'a>, Option<BreadcrumbTreeElement<'a>>)> =
+            params
+                .iter()
+                .map(|kvpair| {
+                    let k = kvpair.key;
+                    let v: Option<BreadcrumbTreeElement<'a>> = match &kvpair.value {
+                        RValue::RVLiteral(owned_literal) => {
+                            Some(BreadcrumbTreeElement::from_borrowed(&kvpair.value))
+                        }
+                        RValue::RVPath(path) => kvpair
+                            .value
+                            .into_context_element(renderer, breadcrumbs)
+                            .map(std::convert::From::from),
+                        RValue::RVTemplate(template) => {
+                            Some(BreadcrumbTreeElement::from_borrowed(&kvpair.value))
+                        }
+                    };
+                    (k, (&kvpair.value, v))
+                })
+                .collect();
 
         ParametersContext {
             params: rendered_params,
@@ -69,6 +68,10 @@ impl<'a> ParametersContext<'a> {
     pub fn get_original_rvalue(&self, segment: &str) -> Option<&'a RValue<'a>> {
         self.params.get(segment).map(|(rvalue, _bte)| *rvalue)
     }
+
+    pub fn contains_key(&self, segment: &str) -> bool {
+        self.params.contains_key(segment)
+    }
 }
 
 impl<'a> IntoContextElement for ParametersContext<'a> {
@@ -83,10 +86,10 @@ impl<'a> IntoContextElement for ParametersContext<'a> {
 
 impl<'a> Walkable for ParametersContext<'a> {
     fn walk(&self, segment: &str) -> Result<&dyn IntoContextElement, WalkError> {
-        self.params
-            .get(segment)
-            .map(|(_rvalue, bte)| bte.borrow())
-            .ok_or(WalkError::CantWalk)
+        match self.params.get(segment).map(|(_rvalue, bte)| bte) {
+            Some(Some(bte)) => Ok(bte.borrow()),
+            _ => Err(WalkError::CantWalk),
+        }
     }
 
     fn is_pseudo_element(&self) -> bool {
diff --git a/src/renderer/renderer.rs b/src/renderer/renderer.rs
index 79036b9..b6cc041 100644
--- a/src/renderer/renderer.rs
+++ b/src/renderer/renderer.rs
@@ -394,23 +394,24 @@ impl<'a> DustRenderer<'a> {
                     };
                 }
 
-                let left_side = match param_map
+                if !param_map.contains_key("key") {
+                    return Ok("".to_owned());
+                }
+                let left_side = param_map
                     .walk("key")
-                    .map(|ice| ice.into_context_element(self, breadcrumbs))
-                {
-                    Err(WalkError::CantWalk) | Ok(None) => return Ok("".to_owned()),
-                    Ok(Some(res)) => res,
-                };
+                    .map(|ice| ice.into_context_element(self, breadcrumbs));
                 let right_side = param_map
                     .walk("value")
                     .map(|ice| ice.into_context_element(self, breadcrumbs));
-                if Ok(Some(left_side.get_context_element_reference()))
-                    == right_side.as_ref().map(|maybe_ice| {
-                        maybe_ice
-                            .as_ref()
-                            .map(|ice| ice.get_context_element_reference())
-                    })
-                {
+                if left_side.as_ref().map(|maybe_ice| {
+                    maybe_ice
+                        .as_ref()
+                        .map(|ice| ice.get_context_element_reference())
+                }) == right_side.as_ref().map(|maybe_ice| {
+                    maybe_ice
+                        .as_ref()
+                        .map(|ice| ice.get_context_element_reference())
+                }) {
                     return self.render_maybe_body(
                         &parameterized_block.contents,
                         new_breadcrumbs.as_ref().unwrap_or(breadcrumbs),
@@ -453,23 +454,24 @@ impl<'a> DustRenderer<'a> {
                     };
                 }
 
-                let left_side = match param_map
+                if !param_map.contains_key("key") {
+                    return Ok("".to_owned());
+                }
+                let left_side = param_map
                     .walk("key")
-                    .map(|ice| ice.into_context_element(self, breadcrumbs))
-                {
-                    Err(WalkError::CantWalk) | Ok(None) => return Ok("".to_owned()),
-                    Ok(Some(res)) => res,
-                };
+                    .map(|ice| ice.into_context_element(self, breadcrumbs));
                 let right_side = param_map
                     .walk("value")
                     .map(|ice| ice.into_context_element(self, breadcrumbs));
-                if Ok(Some(left_side.get_context_element_reference()))
-                    != right_side.as_ref().map(|maybe_ice| {
-                        maybe_ice
-                            .as_ref()
-                            .map(|ice| ice.get_context_element_reference())
-                    })
-                {
+                if left_side.as_ref().map(|maybe_ice| {
+                    maybe_ice
+                        .as_ref()
+                        .map(|ice| ice.get_context_element_reference())
+                }) != right_side.as_ref().map(|maybe_ice| {
+                    maybe_ice
+                        .as_ref()
+                        .map(|ice| ice.get_context_element_reference())
+                }) {
                     return self.render_maybe_body(
                         &parameterized_block.contents,
                         new_breadcrumbs.as_ref().unwrap_or(breadcrumbs),
@@ -493,19 +495,18 @@ impl<'a> DustRenderer<'a> {
 
                 let param_map =
                     ParametersContext::new(self, breadcrumbs, &parameterized_block.params);
-                let left_side = match param_map
+                if !param_map.contains_key("key") {
+                    return Ok("".to_owned());
+                }
+                let left_side = param_map
                     .walk("key")
-                    .map(|ice| ice.into_context_element(self, breadcrumbs))
-                {
-                    Err(WalkError::CantWalk) | Ok(None) => return Ok("".to_owned()),
-                    Ok(Some(res)) => res,
-                };
+                    .map(|ice| ice.into_context_element(self, breadcrumbs));
                 let right_side = param_map
                     .walk("value")
                     .map(|ice| ice.into_context_element(self, breadcrumbs));
-                match (right_side) {
-                    Ok(Some(right_side_unwrapped)) => {
-                        if left_side.get_context_element_reference()
+                match (left_side, right_side) {
+                    (Ok(Some(left_side_unwrapped)), Ok(Some(right_side_unwrapped))) => {
+                        if left_side_unwrapped.get_context_element_reference()
                             > right_side_unwrapped.get_context_element_reference()
                         {
                             return self.render_maybe_body(
@@ -540,19 +541,18 @@ impl<'a> DustRenderer<'a> {
 
                 let param_map =
                     ParametersContext::new(self, breadcrumbs, &parameterized_block.params);
-                let left_side = match param_map
+                if !param_map.contains_key("key") {
+                    return Ok("".to_owned());
+                }
+                let left_side = param_map
                     .walk("key")
-                    .map(|ice| ice.into_context_element(self, breadcrumbs))
-                {
-                    Err(WalkError::CantWalk) | Ok(None) => return Ok("".to_owned()),
-                    Ok(Some(res)) => res,
-                };
+                    .map(|ice| ice.into_context_element(self, breadcrumbs));
                 let right_side = param_map
                     .walk("value")
                     .map(|ice| ice.into_context_element(self, breadcrumbs));
-                match (right_side) {
-                    Ok(Some(right_side_unwrapped)) => {
-                        if left_side.get_context_element_reference()
+                match (left_side, right_side) {
+                    (Ok(Some(left_side_unwrapped)), Ok(Some(right_side_unwrapped))) => {
+                        if left_side_unwrapped.get_context_element_reference()
                             >= right_side_unwrapped.get_context_element_reference()
                         {
                             return self.render_maybe_body(
@@ -587,19 +587,18 @@ impl<'a> DustRenderer<'a> {
 
                 let param_map =
                     ParametersContext::new(self, breadcrumbs, &parameterized_block.params);
-                let left_side = match param_map
+                if !param_map.contains_key("key") {
+                    return Ok("".to_owned());
+                }
+                let left_side = param_map
                     .walk("key")
-                    .map(|ice| ice.into_context_element(self, breadcrumbs))
-                {
-                    Err(WalkError::CantWalk) | Ok(None) => return Ok("".to_owned()),
-                    Ok(Some(res)) => res,
-                };
+                    .map(|ice| ice.into_context_element(self, breadcrumbs));
                 let right_side = param_map
                     .walk("value")
                     .map(|ice| ice.into_context_element(self, breadcrumbs));
-                match (right_side) {
-                    Ok(Some(right_side_unwrapped)) => {
-                        if left_side.get_context_element_reference()
+                match (left_side, right_side) {
+                    (Ok(Some(left_side_unwrapped)), Ok(Some(right_side_unwrapped))) => {
+                        if left_side_unwrapped.get_context_element_reference()
                             < right_side_unwrapped.get_context_element_reference()
                         {
                             return self.render_maybe_body(
@@ -634,19 +633,18 @@ impl<'a> DustRenderer<'a> {
 
                 let param_map =
                     ParametersContext::new(self, breadcrumbs, &parameterized_block.params);
-                let left_side = match param_map
+                if !param_map.contains_key("key") {
+                    return Ok("".to_owned());
+                }
+                let left_side = param_map
                     .walk("key")
-                    .map(|ice| ice.into_context_element(self, breadcrumbs))
-                {
-                    Err(WalkError::CantWalk) | Ok(None) => return Ok("".to_owned()),
-                    Ok(Some(res)) => res,
-                };
+                    .map(|ice| ice.into_context_element(self, breadcrumbs));
                 let right_side = param_map
                     .walk("value")
                     .map(|ice| ice.into_context_element(self, breadcrumbs));
-                match (right_side) {
-                    Ok(Some(right_side_unwrapped)) => {
-                        if left_side.get_context_element_reference()
+                match (left_side, right_side) {
+                    (Ok(Some(left_side_unwrapped)), Ok(Some(right_side_unwrapped))) => {
+                        if left_side_unwrapped.get_context_element_reference()
                             <= right_side_unwrapped.get_context_element_reference()
                         {
                             return self.render_maybe_body(