add a Variable::extend method that takes an iterator directly

Author: nikomatsakis

src/lib.rs

@@ -285,8 +285,8 @@ impl<Tuple: Ord> Variable<Tuple> {
     ///
     /// let mut iteration = Iteration::new();
     /// let variable = iteration.variable::<(usize, usize)>("source");
-    /// variable.insert((0 .. 10).map(|x| (x, x + 1)).collect());
-    /// variable.insert((0 .. 10).map(|x| (x + 1, x)).collect());
+    /// variable.extend((0 .. 10).map(|x| (x, x + 1)));
+    /// variable.extend((0 .. 10).map(|x| (x + 1, x)));
     ///
     /// while iteration.changed() {
     ///     variable.from_join(&variable, &variable, |&key, &val1, &val2| (val1, val2));
@@ -322,7 +322,7 @@ impl<Tuple: Ord> Variable<Tuple> {
     ///
     /// let mut iteration = Iteration::new();
     /// let variable = iteration.variable::<(usize, usize)>("source");
-    /// variable.insert((0 .. 10).map(|x| (x, x + 1)).collect());
+    /// variable.extend((0 .. 10).map(|x| (x, x + 1)));
     ///
     /// let relation: Relation<_> = (0 .. 10).filter(|x| x % 3 == 0).collect();
     ///
@@ -356,7 +356,7 @@ impl<Tuple: Ord> Variable<Tuple> {
     ///
     /// let mut iteration = Iteration::new();
     /// let variable = iteration.variable::<(usize, usize)>("source");
-    /// variable.insert((0 .. 10).map(|x| (x, x)).collect());
+    /// variable.extend((0 .. 10).map(|x| (x, x)));
     ///
     /// while iteration.changed() {
     ///     variable.from_map(&variable, |&(key, val)|
@@ -434,6 +434,7 @@ impl<Tuple: Ord> Variable<Tuple> {
             to_add: Rc::new(RefCell::new(Vec::new())),
         }
     }
+
     /// Inserts a relation into the variable.
     ///
     /// This is most commonly used to load initial values into a variable.
@@ -444,6 +445,18 @@ impl<Tuple: Ord> Variable<Tuple> {
             self.to_add.borrow_mut().push(relation);
         }
     }
+
+    /// Extend the variable with values from the iterator.
+    ///
+    /// This is most commonly used to load initial values into a variable.
+    /// it is not obvious that it should be commonly used otherwise, but
+    /// it should not be harmful.
+    pub fn extend<T>(&self, iterator: impl IntoIterator<Item = T>)
+        where Relation<Tuple>: FromIterator<T>
+    {
+        self.insert(iterator.into_iter().collect());
+    }
+
     /// Consumes the variable and returns a relation.
     ///
     /// This method removes the ability for the variable to develop, and

src/test.rs

@@ -16,7 +16,7 @@ fn reachable_with_var_join(edges: &[(u32, u32)]) -> Relation<(u32, u32)> {
     let mut iteration = Iteration::new();
 
     let edges_by_successor = iteration.variable::<(u32, u32)>("edges_invert");
-    edges_by_successor.insert(edges.iter().map(|&(n1, n2)| (n2, n1)).collect());
+    edges_by_successor.extend(edges.iter().map(|&(n1, n2)| (n2, n1)));
 
     let reachable = iteration.variable::<(u32, u32)>("reachable");
     reachable.insert(edges);
@@ -78,10 +78,10 @@ fn sum_join_via_var(
     let mut iteration = Iteration::new();
 
     let input1 = iteration.variable::<(u32, u32)>("input1");
-    input1.insert(input1_slice.iter().collect());
+    input1.extend(input1_slice);
 
     let input2 = iteration.variable::<(u32, u32)>("input1");
-    input2.insert(input2_slice.iter().collect());
+    input2.extend(input2_slice);
 
     let output = iteration.variable::<(u32, u32)>("output");