pub fn explode<D2, R2, I, L>(&self, mut logic: L) -> Collection<G, D2, <R2 as Multiply<R>>::Output>
    where D2: Data,
          R2: Semigroup+Multiply<R>,
          <R2 as Multiply<R>>::Output: Semigroup+'static,
          I: IntoIterator<Item=(D2,R2)>,
          L: FnMut(D)->I+'static,
    {
        self.inner
            .flat_map(move |(x, t, d)| logic(x).into_iter().map(move |(x,d2)| (x, t.clone(), d2.multiply(&d))))
            .as_collection()
    }
Replaces each record with another, with a new difference type.

This method is most commonly used to take records containing aggregatable data (e.g. numbers to be summed)
and move the data into the difference component. This will allow differential dataflow to update in-place.

# Examples

```
use differential_dataflow::input::Input;

::timely::example(|scope| {

let nums = scope.new_collection_from(0 .. 10).1;
let x1 = nums.flat_map(|x| 0 .. x);
let x2 = nums.map(|x| (x, 9 - x))
.explode(|(x,y)| Some((x,y)));

x1.assert_eq(&x2);
});
```
differential-dataflow/src/collection.rs