clean up compile_seq.

src/prolog/codegen.rs

@@ -466,7 +466,7 @@ impl<'a, TermMarker: Allocator<'a>> CodeGenerator<'a, TermMarker>
                    code: &mut Code, is_exposed: bool)
                    -> Result<(), ParserError>
     {
-        for (chunk_num, _, terms) in iter
+        for (chunk_num, _, terms) in iter.rule_body_iter()
         {
             for (i, term) in terms.iter().enumerate()
             {
@@ -476,12 +476,6 @@ impl<'a, TermMarker: Allocator<'a>> CodeGenerator<'a, TermMarker>
                     GenContext::Last(chunk_num)
                 };
 
-                let term = if let &ChunkedTerm::BodyTerm(ref term) = term {
-                    Ok(term)
-                } else {
-                    Err(ParserError::InadmissibleQueryTerm)
-                }?;
-
                 match *term {
                     &QueryTerm::Cut =>
                         code.push(if chunk_num == 0 {

src/prolog/iterators.rs

@@ -220,8 +220,29 @@ pub struct ChunkedIterator<'a>
     deep_cut_encountered: bool
 }
 
+type ChunkedIteratorItem<'a>  = (usize, usize, Vec<ChunkedTerm<'a>>);
+type RuleBodyIteratorItem<'a> = (usize, usize, Vec<&'a QueryTerm>);
+
 impl<'a> ChunkedIterator<'a>
 {
+    pub fn rule_body_iter(self) -> Box<Iterator<Item=RuleBodyIteratorItem<'a>> + 'a>
+    {
+        Box::new(self.filter_map(|(cn, lt_arity, terms)| {
+            let filtered_terms: Vec<_> = terms.into_iter().filter_map(|ct| {
+                    match ct {
+                        ChunkedTerm::BodyTerm(qt) => Some(qt),
+                        _ => None
+                    }
+                }).collect();
+
+            if filtered_terms.is_empty() {
+                None
+            } else {
+                Some((cn, lt_arity, filtered_terms))
+            }
+        }))
+    }
+
     pub fn from_term_sequence(terms: &'a [QueryTerm]) -> Self
     {
         ChunkedIterator {
@@ -311,7 +332,7 @@ impl<'a> ChunkedIterator<'a>
 impl<'a> Iterator for ChunkedIterator<'a>
 {
     // the chunk number, last term arity, and vector of references.
-    type Item = (usize, usize, Vec<ChunkedTerm<'a>>);
+    type Item = ChunkedIteratorItem<'a>;
 
     fn next(&mut self) -> Option<Self::Item> {
         self.iter.next().map(|term| self.take_chunk(term))