replace the From impl with one that takes a vector

`foo.into()` should not require cloning and re-allocating

Author: nikomatsakis

src/lib.rs

@@ -133,9 +133,9 @@ impl<Tuple: Ord> Relation<Tuple> {
     }
 }
 
-impl<Tuple: Ord, I: IntoIterator<Item = Tuple>> From<I> for Relation<Tuple> {
-    fn from(iterator: I) -> Self {
-        Self::from_iter(iterator)
+impl<Tuple: Ord> From<Vec<Tuple>> for Relation<Tuple> {
+    fn from(iterator: Vec<Tuple>) -> Self {
+        Self::from_vec(iterator)
     }
 }
 
@@ -275,8 +275,8 @@ impl<Tuple: Ord> Variable<Tuple> {
     ///
     /// let mut iteration = Iteration::new();
     /// let variable = iteration.variable::<(usize, usize)>("source");
-    /// variable.insert(Relation::from((0 .. 10).map(|x| (x, x + 1))));
-    /// variable.insert(Relation::from((0 .. 10).map(|x| (x + 1, x))));
+    /// variable.insert((0 .. 10).map(|x| (x, x + 1)).collect());
+    /// variable.insert((0 .. 10).map(|x| (x + 1, x)).collect());
     ///
     /// while iteration.changed() {
     ///     variable.from_join(&variable, &variable, |&key, &val1, &val2| (val1, val2));
@@ -312,9 +312,9 @@ impl<Tuple: Ord> Variable<Tuple> {
     ///
     /// let mut iteration = Iteration::new();
     /// let variable = iteration.variable::<(usize, usize)>("source");
-    /// variable.insert(Relation::from((0 .. 10).map(|x| (x, x + 1))));
+    /// variable.insert((0 .. 10).map(|x| (x, x + 1)).collect());
     ///
-    /// let relation = Relation::from((0 .. 10).filter(|x| x % 3 == 0));
+    /// let relation: Relation<_> = (0 .. 10).filter(|x| x % 3 == 0).collect();
     ///
     /// while iteration.changed() {
     ///     variable.from_antijoin(&variable, &relation, |&key, &val| (val, key));
@@ -346,7 +346,7 @@ impl<Tuple: Ord> Variable<Tuple> {
     ///
     /// let mut iteration = Iteration::new();
     /// let variable = iteration.variable::<(usize, usize)>("source");
-    /// variable.insert(Relation::from((0 .. 10).map(|x| (x, x))));
+    /// variable.insert((0 .. 10).map(|x| (x, x)).collect());
     ///
     /// while iteration.changed() {
     ///     variable.from_map(&variable, |&(key, val)|

src/test.rs

@@ -12,11 +12,11 @@ fn inputs() -> impl Strategy<Value = Vec<(u32, u32)>> {
 
 /// The original way to use datafrog -- computes reachable nodes from a set of edges
 fn reachable_with_var_join(edges: &[(u32, u32)]) -> Relation<(u32, u32)> {
-    let edges = Relation::from(edges.iter().cloned());
+    let edges: Relation<_> = edges.iter().collect();
     let mut iteration = Iteration::new();
 
     let edges_by_successor = iteration.variable::<(u32, u32)>("edges_invert");
-    edges_by_successor.insert(Relation::from(edges.iter().map(|&(n1, n2)| (n2, n1))));
+    edges_by_successor.insert(edges.iter().map(|&(n1, n2)| (n2, n1)).collect());
 
     let reachable = iteration.variable::<(u32, u32)>("reachable");
     reachable.insert(edges);
@@ -35,7 +35,7 @@ fn reachable_with_relation_join(edges: &[(u32, u32)]) -> Relation<(u32, u32)> {
     let mut iteration = Iteration::new();
 
     // NB. Changed from `reachable_with_var_join`:
-    let edges_by_successor = Relation::from(edges.iter().map(|&(n1, n2)| (n2, n1)));
+    let edges_by_successor: Relation<_> = edges.iter().map(|&(n1, n2)| (n2, n1)).collect();
 
     let reachable = iteration.variable::<(u32, u32)>("reachable");
     reachable.insert(edges);
@@ -49,10 +49,10 @@ fn reachable_with_relation_join(edges: &[(u32, u32)]) -> Relation<(u32, u32)> {
 }
 
 fn reachable_with_leapfrog(edges: &[(u32, u32)]) -> Relation<(u32, u32)> {
-    let edges = Relation::from(edges.iter().cloned());
+    let edges: Relation<_> = edges.iter().collect();
     let mut iteration = Iteration::new();
 
-    let edges_by_successor = Relation::from(edges.iter().map(|&(n1, n2)| (n2, n1)));
+    let edges_by_successor: Relation<_> = edges.iter().map(|&(n1, n2)| (n2, n1)).collect();
 
     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(Relation::from(input1_slice.iter().cloned()));
+    input1.insert(input1_slice.iter().collect());
 
     let input2 = iteration.variable::<(u32, u32)>("input1");
-    input2.insert(Relation::from(input2_slice.iter().cloned()));
+    input2.insert(input2_slice.iter().collect());
 
     let output = iteration.variable::<(u32, u32)>("output");
 
@@ -99,8 +99,8 @@ fn sum_join_via_relation(
     input1_slice: &[(u32, u32)],
     input2_slice: &[(u32, u32)],
 ) -> Relation<(u32, u32)> {
-    let input1 = Relation::from(input1_slice.iter().cloned());
-    let input2 = Relation::from(input2_slice.iter().cloned());
+    let input1: Relation<_> = input1_slice.iter().collect();
+    let input2: Relation<_> = input2_slice.iter().collect();
     Relation::from_join(&input1, &input2, |&k1, &v1, &v2| (k1, v1 * 100 + v2))
 }