diff --git a/dogsdogsdogs/src/calculus.rs b/dogsdogsdogs/src/calculus.rs
index e0ce2b6bf..16546f226 100644
--- a/dogsdogsdogs/src/calculus.rs
+++ b/dogsdogsdogs/src/calculus.rs
@@ -34,7 +34,7 @@ impl<G, D, R> Differentiate<G, D, R> for Collection<G, D, R>
 where
     G: Scope,
     D: Data,
-    R: Abelian,
+    R: Abelian + 'static,
 {
     // For each (data, Alt(time), diff) we add a (data, Neu(time), -diff).
     fn differentiate<'a>(&self, child: &Child<'a, G, AltNeu<G::Timestamp>>) -> Collection<Child<'a, G, AltNeu<G::Timestamp>>, D, R> {
@@ -53,7 +53,7 @@ impl<'a, G, D, R> Integrate<G, D, R> for Collection<Child<'a, G, AltNeu<G::Times
 where
     G: Scope,
     D: Data,
-    R: Abelian,
+    R: Abelian + 'static,
 {
     // We discard each `neu` variant and strip off the `alt` wrapper.
     fn integrate(&self) -> Collection<G, D, R> {
diff --git a/dogsdogsdogs/src/lib.rs b/dogsdogsdogs/src/lib.rs
index 262e09609..3e7399469 100644
--- a/dogsdogsdogs/src/lib.rs
+++ b/dogsdogsdogs/src/lib.rs
@@ -44,7 +44,7 @@ impl<G, P, R> ProposeExtensionMethod<G, P, R> for Collection<G, P, R>
 where
     G: Scope,
     P: ExchangeData+Ord,
-    R: Monoid+Multiply<Output = R>,
+    R: Monoid+Multiply<Output = R>+'static,
 {
     fn propose_using<PE>(&self, extender: &mut PE) -> Collection<G, (P, PE::Extension), R>
     where
diff --git a/dogsdogsdogs/src/operators/half_join.rs b/dogsdogsdogs/src/operators/half_join.rs
index 799febeef..846107727 100644
--- a/dogsdogsdogs/src/operators/half_join.rs
+++ b/dogsdogsdogs/src/operators/half_join.rs
@@ -140,7 +140,7 @@ where
     FF: Fn(&G::Timestamp, &mut Antichain<G::Timestamp>) + 'static,
     CF: Fn(&G::Timestamp, &G::Timestamp) -> bool + 'static,
     DOut: Clone+'static,
-    ROut: Semigroup,
+    ROut: Semigroup + 'static,
     Y: Fn(std::time::Instant, usize) -> bool + 'static,
     I: IntoIterator<Item=(DOut, G::Timestamp, ROut)>,
     S: FnMut(&K, &V, Tr::Val<'_>, &G::Timestamp, &G::Timestamp, &R, &Tr::Diff)-> I + 'static,
diff --git a/dogsdogsdogs/src/operators/lookup_map.rs b/dogsdogsdogs/src/operators/lookup_map.rs
index c361871ac..ede8b1f3c 100644
--- a/dogsdogsdogs/src/operators/lookup_map.rs
+++ b/dogsdogsdogs/src/operators/lookup_map.rs
@@ -36,7 +36,7 @@ where
     D: ExchangeData,
     R: ExchangeData+Monoid,
     DOut: Clone+'static,
-    ROut: Monoid,
+    ROut: Monoid + 'static,
     S: FnMut(&D, &R, Tr::Val<'_>, &Tr::Diff)->(DOut, ROut)+'static,
 {
     // No need to block physical merging for this operator.
diff --git a/src/collection.rs b/src/collection.rs
index 2e82c7e62..ce2dd54a9 100644
--- a/src/collection.rs
+++ b/src/collection.rs
@@ -45,7 +45,7 @@ pub struct Collection<G: Scope, D, R: Semigroup = isize> {
     pub inner: Stream<G, (D, G::Timestamp, R)>
 }
 
-impl<G: Scope, D: Data, R: Semigroup> Collection<G, D, R> where G::Timestamp: Data {
+impl<G: Scope, D: Data, R: Semigroup+'static> Collection<G, D, R> where G::Timestamp: Data {
     /// Creates a new Collection from a timely dataflow stream.
     ///
     /// This method seems to be rarely used, with the `as_collection` method on streams being a more
@@ -226,7 +226,7 @@ impl<G: Scope, D: Data, R: Semigroup> Collection<G, D, R> where G::Timestamp: Da
     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: Data+Semigroup,
+          <R2 as Multiply<R>>::Output: Semigroup+'static,
           I: IntoIterator<Item=(D2,R2)>,
           L: FnMut(D)->I+'static,
     {
@@ -261,7 +261,7 @@ impl<G: Scope, D: Data, R: Semigroup> Collection<G, D, R> where G::Timestamp: Da
     where G::Timestamp: Lattice,
           D2: Data,
           R2: Semigroup+Multiply<R>,
-          <R2 as Multiply<R>>::Output: Data+Semigroup,
+          <R2 as Multiply<R>>::Output: Semigroup+'static,
           I: IntoIterator<Item=(D2,G::Timestamp,R2)>,
           L: FnMut(D)->I+'static,
     {
@@ -476,7 +476,7 @@ use timely::dataflow::scopes::ScopeParent;
 use timely::progress::timestamp::Refines;
 
 /// Methods requiring a nested scope.
-impl<'a, G: Scope, T: Timestamp, D: Data, R: Semigroup> Collection<Child<'a, G, T>, D, R>
+impl<'a, G: Scope, T: Timestamp, D: Data, R: Semigroup+'static> Collection<Child<'a, G, T>, D, R>
 where
     T: Refines<<G as ScopeParent>::Timestamp>,
 {
@@ -509,7 +509,7 @@ where
 }
 
 /// Methods requiring a region as the scope.
-impl<'a, G: Scope, D: Data, R: Semigroup> Collection<Child<'a, G, G::Timestamp>, D, R>
+impl<'a, G: Scope, D: Data, R: Semigroup+'static> Collection<Child<'a, G, G::Timestamp>, D, R>
 {
     /// Returns the value of a Collection from a nested region to its containing scope.
     ///
@@ -523,7 +523,7 @@ impl<'a, G: Scope, D: Data, R: Semigroup> Collection<Child<'a, G, G::Timestamp>,
 }
 
 /// Methods requiring an Abelian difference, to support negation.
-impl<G: Scope, D: Data, R: Abelian> Collection<G, D, R> where G::Timestamp: Data {
+impl<G: Scope, D: Data, R: Abelian+'static> Collection<G, D, R> where G::Timestamp: Data {
     /// Creates a new collection whose counts are the negation of those in the input.
     ///
     /// This method is most commonly used with `concat` to get those element in one collection but not another.
@@ -594,7 +594,7 @@ pub trait AsCollection<G: Scope, D: Data, R: Semigroup> {
     fn as_collection(&self) -> Collection<G, D, R>;
 }
 
-impl<G: Scope, D: Data, R: Semigroup> AsCollection<G, D, R> for Stream<G, (D, G::Timestamp, R)> {
+impl<G: Scope, D: Data, R: Semigroup+'static> AsCollection<G, D, R> for Stream<G, (D, G::Timestamp, R)> {
     fn as_collection(&self) -> Collection<G, D, R> {
         Collection::new(self.clone())
     }
@@ -625,7 +625,7 @@ pub fn concatenate<G, D, R, I>(scope: &mut G, iterator: I) -> Collection<G, D, R
 where
     G: Scope,
     D: Data,
-    R: Semigroup,
+    R: Semigroup+'static,
     I: IntoIterator<Item=Collection<G, D, R>>,
 {
     scope
diff --git a/src/consolidation.rs b/src/consolidation.rs
index 497d15b9a..1409da072 100644
--- a/src/consolidation.rs
+++ b/src/consolidation.rs
@@ -145,7 +145,7 @@ impl<D,T,R> ConsolidatingContainerBuilder<Vec<(D, T, R)>>
 where
     D: Data,
     T: Data,
-    R: Semigroup,
+    R: Semigroup+'static,
 {
     /// Flush `self.current` up to the biggest `multiple` of elements. Pass 1 to flush all elements.
     // TODO: Can we replace `multiple` by a bool?
@@ -165,7 +165,7 @@ impl<D,T,R> ContainerBuilder for ConsolidatingContainerBuilder<Vec<(D, T, R)>>
 where
     D: Data,
     T: Data,
-    R: Semigroup,
+    R: Semigroup+'static,
 {
     type Container = Vec<(D,T,R)>;
 
diff --git a/src/difference.rs b/src/difference.rs
index 46c7ba3eb..0a63e1682 100644
--- a/src/difference.rs
+++ b/src/difference.rs
@@ -6,8 +6,6 @@
 //! dataflow collections would then track for each record the total of counts and heights, which allows
 //! us to track something like the average.
 
-use crate::Data;
-
 #[deprecated]
 pub use self::Abelian as Diff;
 
@@ -22,7 +20,7 @@ pub use self::Abelian as Diff;
 /// There is a light presumption of commutativity here, in that while we will largely perform addition
 /// in order of timestamps, for many types of timestamps there is no total order and consequently no
 /// obvious order to respect. Non-commutative semigroups should be used with care.
-pub trait Semigroup<Rhs: ?Sized = Self> : Data + Clone {
+pub trait Semigroup<Rhs: ?Sized = Self> : Clone {
     /// The method of `std::ops::AddAssign`, for types that do not implement `AddAssign`.
     fn plus_equals(&mut self, rhs: &Rhs);
     /// Returns true if the element is the additive identity.
diff --git a/src/dynamic/mod.rs b/src/dynamic/mod.rs
index 18208d3ae..d13eadcd8 100644
--- a/src/dynamic/mod.rs
+++ b/src/dynamic/mod.rs
@@ -30,7 +30,7 @@ impl<G, D, R, T, TOuter> Collection<G, D, R>
 where
     G: Scope<Timestamp = Product<TOuter, PointStamp<T>>>,
     D: Data,
-    R: Semigroup,
+    R: Semigroup+'static,
     T: Timestamp+Default,
     TOuter: Timestamp,
 {
diff --git a/src/input.rs b/src/input.rs
index 889275563..5a73b14a9 100644
--- a/src/input.rs
+++ b/src/input.rs
@@ -42,7 +42,7 @@ pub trait Input : TimelyInput {
     /// }).unwrap();
     /// ```
     fn new_collection<D, R>(&mut self) -> (InputSession<<Self as ScopeParent>::Timestamp, D, R>, Collection<Self, D, R>)
-    where D: Data, R: Semigroup;
+    where D: Data, R: Semigroup+'static;
     /// Create a new collection and input handle from initial data.
     ///
     /// # Examples
@@ -94,13 +94,13 @@ pub trait Input : TimelyInput {
     /// }).unwrap();
     /// ```
     fn new_collection_from_raw<D, R, I>(&mut self, data: I) -> (InputSession<<Self as ScopeParent>::Timestamp, D, R>, Collection<Self, D, R>)
-    where I: IntoIterator<Item=(D,<Self as ScopeParent>::Timestamp,R)>+'static, D: Data, R: Semigroup+Data;
+    where I: IntoIterator<Item=(D,<Self as ScopeParent>::Timestamp,R)>+'static, D: Data, R: Semigroup+'static;
 }
 
 use crate::lattice::Lattice;
 impl<G: TimelyInput> Input for G where <G as ScopeParent>::Timestamp: Lattice {
     fn new_collection<D, R>(&mut self) -> (InputSession<<G as ScopeParent>::Timestamp, D, R>, Collection<G, D, R>)
-    where D: Data, R: Semigroup{
+    where D: Data, R: Semigroup+'static{
         let (handle, stream) = self.new_input();
         (InputSession::from(handle), stream.as_collection())
     }
@@ -111,7 +111,7 @@ impl<G: TimelyInput> Input for G where <G as ScopeParent>::Timestamp: Lattice {
     fn new_collection_from_raw<D,R,I>(&mut self, data: I) -> (InputSession<<G as ScopeParent>::Timestamp, D, R>, Collection<G, D, R>)
     where
         D: Data,
-        R: Semigroup+Data,
+        R: Semigroup+'static,
         I: IntoIterator<Item=(D,<Self as ScopeParent>::Timestamp,R)>+'static,
     {
         use timely::dataflow::operators::ToStream;
@@ -166,7 +166,7 @@ impl<G: TimelyInput> Input for G where <G as ScopeParent>::Timestamp: Lattice {
 ///
 /// }).unwrap();
 /// ```
-pub struct InputSession<T: Timestamp+Clone, D: Data, R: Semigroup> {
+pub struct InputSession<T: Timestamp+Clone, D: Data, R: Semigroup+'static> {
     time: T,
     buffer: Vec<(D, T, R)>,
     handle: Handle<T,(D,T,R)>,
@@ -193,7 +193,7 @@ impl<T: Timestamp+Clone, D: Data> InputSession<T, D, isize> {
 //     pub fn remove(&mut self, element: D) { self.update(element,-1); }
 // }
 
-impl<T: Timestamp+Clone, D: Data, R: Semigroup> InputSession<T, D, R> {
+impl<T: Timestamp+Clone, D: Data, R: Semigroup+'static> InputSession<T, D, R> {
 
     /// Introduces a handle as collection.
     pub fn to_collection<G: TimelyInput>(&mut self, scope: &mut G) -> Collection<G, D, R>
@@ -281,7 +281,7 @@ impl<T: Timestamp+Clone, D: Data, R: Semigroup> InputSession<T, D, R> {
     pub fn close(self) { }
 }
 
-impl<T: Timestamp+Clone, D: Data, R: Semigroup> Drop for InputSession<T, D, R> {
+impl<T: Timestamp+Clone, D: Data, R: Semigroup+'static> Drop for InputSession<T, D, R> {
     fn drop(&mut self) {
         self.flush();
     }
diff --git a/src/operators/arrange/arrangement.rs b/src/operators/arrange/arrangement.rs
index 83231d58c..f0454905d 100644
--- a/src/operators/arrange/arrangement.rs
+++ b/src/operators/arrange/arrangement.rs
@@ -244,7 +244,7 @@ where
     where
         T2: for<'a> TraceReader<Key<'a>=T1::Key<'a>,Time=T1::Time>+Clone+'static,
         T1::Diff: Multiply<T2::Diff>,
-        <T1::Diff as Multiply<T2::Diff>>::Output: Semigroup,
+        <T1::Diff as Multiply<T2::Diff>>::Output: Semigroup+'static,
         I: IntoIterator,
         I::Item: Data,
         L: FnMut(T1::Key<'_>,T1::Val<'_>,T2::Val<'_>)->I+'static
@@ -261,7 +261,7 @@ where
     where
         T2: for<'a> TraceReader<Key<'a>=T1::Key<'a>, Time=T1::Time>+Clone+'static,
         D: Data,
-        ROut: Semigroup,
+        ROut: Semigroup+'static,
         I: IntoIterator<Item=(D, G::Timestamp, ROut)>,
         L: FnMut(T1::Key<'_>, T1::Val<'_>,T2::Val<'_>,&G::Timestamp,&T1::Diff,&T2::Diff)->I+'static,
     {
@@ -603,7 +603,7 @@ where
 /// This arrangement requires `Key: Hashable`, and uses the `hashed()` method to place keys in a hashed
 /// map. This can result in many hash calls, and in some cases it may help to first transform `K` to the
 /// pair `(u64, K)` of hash value and key.
-pub trait ArrangeByKey<G: Scope, K: Data+Hashable, V: Data, R: Semigroup>
+pub trait ArrangeByKey<G: Scope, K: Data+Hashable, V: Data, R: Ord+Semigroup+'static>
 where G::Timestamp: Lattice+Ord {
     /// Arranges a collection of `(Key, Val)` records by `Key`.
     ///
@@ -634,7 +634,7 @@ where
 /// This arrangement requires `Key: Hashable`, and uses the `hashed()` method to place keys in a hashed
 /// map. This can result in many hash calls, and in some cases it may help to first transform `K` to the
 /// pair `(u64, K)` of hash value and key.
-pub trait ArrangeBySelf<G: Scope, K: Data+Hashable, R: Semigroup>
+pub trait ArrangeBySelf<G: Scope, K: Data+Hashable, R: Ord+Semigroup+'static>
 where
     G::Timestamp: Lattice+Ord
 {
diff --git a/src/operators/count.rs b/src/operators/count.rs
index 6c0400179..89659e4ce 100644
--- a/src/operators/count.rs
+++ b/src/operators/count.rs
@@ -41,12 +41,12 @@ pub trait CountTotal<G: Scope, K: ExchangeData, R: Semigroup> where G::Timestamp
     /// This method allows `count_total` to produce collections whose difference
     /// type is something other than an `isize` integer, for example perhaps an
     /// `i32`.
-    fn count_total_core<R2: Semigroup + From<i8>>(&self) -> Collection<G, (K, R), R2>;
+    fn count_total_core<R2: Semigroup + From<i8> + 'static>(&self) -> Collection<G, (K, R), R2>;
 }
 
 impl<G: Scope, K: ExchangeData+Hashable, R: ExchangeData+Semigroup> CountTotal<G, K, R> for Collection<G, K, R>
 where G::Timestamp: TotalOrder+Lattice+Ord {
-    fn count_total_core<R2: Semigroup + From<i8>>(&self) -> Collection<G, (K, R), R2> {
+    fn count_total_core<R2: Semigroup + From<i8> + 'static>(&self) -> Collection<G, (K, R), R2> {
         self.arrange_by_self_named("Arrange: CountTotal")
             .count_total_core()
     }
@@ -61,7 +61,7 @@ where
     T1::Time: TotalOrder,
     T1::Diff: ExchangeData,
 {
-    fn count_total_core<R2: Semigroup + From<i8>>(&self) -> Collection<G, (K, T1::Diff), R2> {
+    fn count_total_core<R2: Semigroup + From<i8> + 'static>(&self) -> Collection<G, (K, T1::Diff), R2> {
 
         let mut trace = self.trace.clone();
         let mut buffer = Vec::new();
diff --git a/src/operators/iterate.rs b/src/operators/iterate.rs
index 6d0e27144..32c6d1cda 100644
--- a/src/operators/iterate.rs
+++ b/src/operators/iterate.rs
@@ -76,7 +76,7 @@ pub trait Iterate<G: Scope, D: Data, R: Semigroup> {
             for<'a> F: FnOnce(&Collection<Iterative<'a, G, u64>, D, R>)->Collection<Iterative<'a, G, u64>, D, R>;
 }
 
-impl<G: Scope, D: Ord+Data+Debug, R: Abelian> Iterate<G, D, R> for Collection<G, D, R> {
+impl<G: Scope, D: Ord+Data+Debug, R: Abelian+'static> Iterate<G, D, R> for Collection<G, D, R> {
     fn iterate<F>(&self, logic: F) -> Collection<G, D, R>
         where G::Timestamp: Lattice,
               for<'a> F: FnOnce(&Collection<Iterative<'a, G, u64>, D, R>)->Collection<Iterative<'a, G, u64>, D, R> {
@@ -96,7 +96,7 @@ impl<G: Scope, D: Ord+Data+Debug, R: Abelian> Iterate<G, D, R> for Collection<G,
     }
 }
 
-impl<G: Scope, D: Ord+Data+Debug, R: Semigroup> Iterate<G, D, R> for G {
+impl<G: Scope, D: Ord+Data+Debug, R: Semigroup+'static> Iterate<G, D, R> for G {
     fn iterate<F>(&self, logic: F) -> Collection<G, D, R>
         where G::Timestamp: Lattice,
               for<'a> F: FnOnce(&Collection<Iterative<'a, G, u64>, D, R>)->Collection<Iterative<'a, G, u64>, D, R> {
@@ -151,7 +151,7 @@ impl<G: Scope, D: Ord+Data+Debug, R: Semigroup> Iterate<G, D, R> for G {
 ///     });
 /// })
 /// ```
-pub struct Variable<G: Scope, D: Data, R: Abelian>
+pub struct Variable<G: Scope, D: Data, R: Abelian+'static>
 where G::Timestamp: Lattice {
     collection: Collection<G, D, R>,
     feedback: Handle<G, Vec<(D, G::Timestamp, R)>>,
@@ -222,7 +222,7 @@ impl<G: Scope, D: Data, R: Abelian> Deref for Variable<G, D, R> where G::Timesta
 /// that do not implement `Abelian` and only implement `Semigroup`. This means
 /// that it can be used in settings where the difference type does not support
 /// negation.
-pub struct SemigroupVariable<G: Scope, D: Data, R: Semigroup>
+pub struct SemigroupVariable<G: Scope, D: Data, R: Semigroup+'static>
 where G::Timestamp: Lattice {
     collection: Collection<G, D, R>,
     feedback: Handle<G, Vec<(D, G::Timestamp, R)>>,
diff --git a/src/operators/join.rs b/src/operators/join.rs
index d5132d606..7db301fca 100644
--- a/src/operators/join.rs
+++ b/src/operators/join.rs
@@ -56,7 +56,7 @@ pub trait Join<G: Scope, K: Data, V: Data, R: Semigroup> {
         V2: ExchangeData,
         R2: ExchangeData+Semigroup,
         R: Multiply<R2>,
-        <R as Multiply<R2>>::Output: Semigroup
+        <R as Multiply<R2>>::Output: Semigroup+'static
     {
         self.join_map(other, |k,v,v2| (k.clone(),(v.clone(),v2.clone())))
     }
@@ -80,7 +80,7 @@ pub trait Join<G: Scope, K: Data, V: Data, R: Semigroup> {
     /// });
     /// ```
     fn join_map<V2, R2, D, L>(&self, other: &Collection<G, (K,V2), R2>, logic: L) -> Collection<G, D, <R as Multiply<R2>>::Output>
-    where K: ExchangeData, V2: ExchangeData, R2: ExchangeData+Semigroup, R: Multiply<R2>, <R as Multiply<R2>>::Output: Semigroup, D: Data, L: FnMut(&K, &V, &V2)->D+'static;
+    where K: ExchangeData, V2: ExchangeData, R2: ExchangeData+Semigroup, R: Multiply<R2>, <R as Multiply<R2>>::Output: Semigroup+'static, D: Data, L: FnMut(&K, &V, &V2)->D+'static;
 
     /// Matches pairs `(key, val)` and `key` based on `key`, producing the former with frequencies multiplied.
     ///
@@ -105,7 +105,7 @@ pub trait Join<G: Scope, K: Data, V: Data, R: Semigroup> {
     /// });
     /// ```
     fn semijoin<R2>(&self, other: &Collection<G, K, R2>) -> Collection<G, (K, V), <R as Multiply<R2>>::Output>
-    where K: ExchangeData, R2: ExchangeData+Semigroup, R: Multiply<R2>, <R as Multiply<R2>>::Output: Semigroup;
+    where K: ExchangeData, R2: ExchangeData+Semigroup, R: Multiply<R2>, <R as Multiply<R2>>::Output: Semigroup+'static;
 
     /// Subtracts the semijoin with `other` from `self`.
     ///
@@ -134,7 +134,7 @@ pub trait Join<G: Scope, K: Data, V: Data, R: Semigroup> {
     /// });
     /// ```
     fn antijoin<R2>(&self, other: &Collection<G, K, R2>) -> Collection<G, (K, V), R>
-    where K: ExchangeData, R2: ExchangeData+Semigroup, R: Multiply<R2, Output = R>, R: Abelian;
+    where K: ExchangeData, R2: ExchangeData+Semigroup, R: Multiply<R2, Output = R>, R: Abelian+'static;
 }
 
 impl<G, K, V, R> Join<G, K, V, R> for Collection<G, (K, V), R>
@@ -146,21 +146,21 @@ where
     G::Timestamp: Lattice+Ord,
 {
     fn join_map<V2: ExchangeData, R2: ExchangeData+Semigroup, D: Data, L>(&self, other: &Collection<G, (K, V2), R2>, mut logic: L) -> Collection<G, D, <R as Multiply<R2>>::Output>
-    where R: Multiply<R2>, <R as Multiply<R2>>::Output: Semigroup, L: FnMut(&K, &V, &V2)->D+'static {
+    where R: Multiply<R2>, <R as Multiply<R2>>::Output: Semigroup+'static, L: FnMut(&K, &V, &V2)->D+'static {
         let arranged1 = self.arrange_by_key();
         let arranged2 = other.arrange_by_key();
         arranged1.join_core(&arranged2, move |k,v1,v2| Some(logic(k,v1,v2)))
     }
 
     fn semijoin<R2: ExchangeData+Semigroup>(&self, other: &Collection<G, K, R2>) -> Collection<G, (K, V), <R as Multiply<R2>>::Output>
-    where R: Multiply<R2>, <R as Multiply<R2>>::Output: Semigroup {
+    where R: Multiply<R2>, <R as Multiply<R2>>::Output: Semigroup+'static {
         let arranged1 = self.arrange_by_key();
         let arranged2 = other.arrange_by_self();
         arranged1.join_core(&arranged2, |k,v,_| Some((k.clone(), v.clone())))
     }
 
     fn antijoin<R2: ExchangeData+Semigroup>(&self, other: &Collection<G, K, R2>) -> Collection<G, (K, V), R>
-    where R: Multiply<R2, Output=R>, R: Abelian {
+    where R: Multiply<R2, Output=R>, R: Abelian+'static {
         self.concat(&self.semijoin(other).negate())
     }
 }
@@ -175,7 +175,7 @@ where
     fn join_map<V2: ExchangeData, R2: ExchangeData+Semigroup, D: Data, L>(&self, other: &Collection<G, (K, V2), R2>, mut logic: L) -> Collection<G, D, <Tr::Diff as Multiply<R2>>::Output>
     where 
         Tr::Diff: Multiply<R2>,
-        <Tr::Diff as Multiply<R2>>::Output: Semigroup,
+        <Tr::Diff as Multiply<R2>>::Output: Semigroup+'static,
         L: for<'a> FnMut(Tr::Key<'a>, Tr::Val<'a>, &V2)->D+'static,
     {
         let arranged2 = other.arrange_by_key();
@@ -183,13 +183,13 @@ where
     }
 
     fn semijoin<R2: ExchangeData+Semigroup>(&self, other: &Collection<G, K, R2>) -> Collection<G, (K, V), <Tr::Diff as Multiply<R2>>::Output>
-    where Tr::Diff: Multiply<R2>, <Tr::Diff as Multiply<R2>>::Output: Semigroup {
+    where Tr::Diff: Multiply<R2>, <Tr::Diff as Multiply<R2>>::Output: Semigroup+'static {
         let arranged2 = other.arrange_by_self();
         self.join_core(&arranged2, |k,v,_| Some((k.clone(), v.clone())))
     }
 
     fn antijoin<R2: ExchangeData+Semigroup>(&self, other: &Collection<G, K, R2>) -> Collection<G, (K, V), Tr::Diff>
-    where Tr::Diff: Multiply<R2, Output=Tr::Diff>, Tr::Diff: Abelian {
+    where Tr::Diff: Multiply<R2, Output=Tr::Diff>, Tr::Diff: Abelian+'static {
         self.as_collection(|k,v| (k.clone(), v.clone()))
             .concat(&self.semijoin(other).negate())
     }
@@ -236,7 +236,7 @@ pub trait JoinCore<G: Scope, K: 'static + ?Sized, V: 'static + ?Sized, R: Semigr
     where
         Tr2: for<'a> TraceReader<Key<'a>=&'a K, Time=G::Timestamp>+Clone+'static,
         R: Multiply<Tr2::Diff>,
-        <R as Multiply<Tr2::Diff>>::Output: Semigroup,
+        <R as Multiply<Tr2::Diff>>::Output: Semigroup+'static,
         I: IntoIterator,
         I::Item: Data,
         L: FnMut(&K,&V,Tr2::Val<'_>)->I+'static,
@@ -279,7 +279,7 @@ pub trait JoinCore<G: Scope, K: 'static + ?Sized, V: 'static + ?Sized, R: Semigr
     where
         Tr2: for<'a> TraceReader<Key<'a>=&'a K, Time=G::Timestamp>+Clone+'static,
         D: Data,
-        ROut: Semigroup,
+        ROut: Semigroup+'static,
         I: IntoIterator<Item=(D, G::Timestamp, ROut)>,
         L: for<'a> FnMut(&K,&V,Tr2::Val<'_>,&G::Timestamp,&R,&Tr2::Diff)->I+'static,
         ;
@@ -298,7 +298,7 @@ where
     where
         Tr2: for<'a> TraceReader<Key<'a>=&'a K, Time=G::Timestamp>+Clone+'static,
         R: Multiply<Tr2::Diff>,
-        <R as Multiply<Tr2::Diff>>::Output: Semigroup,
+        <R as Multiply<Tr2::Diff>>::Output: Semigroup+'static,
         I: IntoIterator,
         I::Item: Data,
         L: FnMut(&K,&V,Tr2::Val<'_>)->I+'static,
@@ -313,7 +313,7 @@ where
         I: IntoIterator<Item=(D, G::Timestamp, ROut)>,
         L: FnMut(&K,&V,Tr2::Val<'_>,&G::Timestamp,&R,&Tr2::Diff)->I+'static,
         D: Data,
-        ROut: Semigroup,
+        ROut: Semigroup+'static,
     {
         self.arrange_by_key().join_core_internal_unsafe(stream2, result)
     }
diff --git a/src/operators/reduce.rs b/src/operators/reduce.rs
index 34e8fef96..0bd99995d 100644
--- a/src/operators/reduce.rs
+++ b/src/operators/reduce.rs
@@ -59,13 +59,13 @@ pub trait Reduce<G: Scope, K: Data, V: Data, R: Semigroup> where G::Timestamp: L
     ///          });
     /// });
     /// ```
-    fn reduce<L, V2: Data, R2: Abelian>(&self, logic: L) -> Collection<G, (K, V2), R2>
+    fn reduce<L, V2: Data, R2: Ord+Abelian+'static>(&self, logic: L) -> Collection<G, (K, V2), R2>
     where L: FnMut(&K, &[(&V, R)], &mut Vec<(V2, R2)>)+'static {
         self.reduce_named("Reduce", logic)
     }
 
     /// As `reduce` with the ability to name the operator.
-    fn reduce_named<L, V2: Data, R2: Abelian>(&self, name: &str, logic: L) -> Collection<G, (K, V2), R2>
+    fn reduce_named<L, V2: Data, R2: Ord+Abelian+'static>(&self, name: &str, logic: L) -> Collection<G, (K, V2), R2>
     where L: FnMut(&K, &[(&V, R)], &mut Vec<(V2, R2)>)+'static;
 }
 
@@ -77,21 +77,21 @@ impl<G, K, V, R> Reduce<G, K, V, R> for Collection<G, (K, V), R>
         V: ExchangeData,
         R: ExchangeData+Semigroup,
  {
-    fn reduce_named<L, V2: Data, R2: Abelian>(&self, name: &str, logic: L) -> Collection<G, (K, V2), R2>
+    fn reduce_named<L, V2: Data, R2: Ord+Abelian+'static>(&self, name: &str, logic: L) -> Collection<G, (K, V2), R2>
         where L: FnMut(&K, &[(&V, R)], &mut Vec<(V2, R2)>)+'static {
         self.arrange_by_key_named(&format!("Arrange: {}", name))
             .reduce_named(name, logic)
     }
 }
 
-impl<G, K: Data, V: Data, T1, R: Semigroup> Reduce<G, K, V, R> for Arranged<G, T1>
+impl<G, K: Data, V: Data, T1, R: Ord+Semigroup+'static> Reduce<G, K, V, R> for Arranged<G, T1>
 where
     G: Scope<Timestamp=T1::Time>,
     T1: for<'a> TraceReader<Key<'a>=&'a K, Val<'a>=&'a V, Diff=R>+Clone+'static,
     for<'a> T1::Key<'a> : IntoOwned<'a, Owned = K>,
     for<'a> T1::Val<'a> : IntoOwned<'a, Owned = V>,
 {
-    fn reduce_named<L, V2: Data, R2: Abelian>(&self, name: &str, logic: L) -> Collection<G, (K, V2), R2>
+    fn reduce_named<L, V2: Data, R2: Ord+Abelian+'static>(&self, name: &str, logic: L) -> Collection<G, (K, V2), R2>
         where L: FnMut(&K, &[(&V, R)], &mut Vec<(V2, R2)>)+'static {
         self.reduce_abelian::<_,K,V2,ValSpine<_,_,_,_>>(name, logic)
             .as_collection(|k,v| (k.clone(), v.clone()))
@@ -119,12 +119,12 @@ pub trait Threshold<G: Scope, K: Data, R1: Semigroup> where G::Timestamp: Lattic
     ///          .threshold(|_,c| c % 2);
     /// });
     /// ```
-    fn threshold<R2: Abelian, F: FnMut(&K, &R1)->R2+'static>(&self, thresh: F) -> Collection<G, K, R2> {
+    fn threshold<R2: Ord+Abelian+'static, F: FnMut(&K, &R1)->R2+'static>(&self, thresh: F) -> Collection<G, K, R2> {
         self.threshold_named("Threshold", thresh)
     }
 
     /// A `threshold` with the ability to name the operator.
-    fn threshold_named<R2: Abelian, F: FnMut(&K, &R1)->R2+'static>(&self, name: &str, thresh: F) -> Collection<G, K, R2>;
+    fn threshold_named<R2: Ord+Abelian+'static, F: FnMut(&K, &R1)->R2+'static>(&self, name: &str, thresh: F) -> Collection<G, K, R2>;
 
     /// Reduces the collection to one occurrence of each distinct element.
     ///
@@ -150,14 +150,14 @@ pub trait Threshold<G: Scope, K: Data, R1: Semigroup> where G::Timestamp: Lattic
     /// This method allows `distinct` to produce collections whose difference
     /// type is something other than an `isize` integer, for example perhaps an
     /// `i32`.
-    fn distinct_core<R2: Abelian+From<i8>>(&self) -> Collection<G, K, R2> {
+    fn distinct_core<R2: Ord+Abelian+'static+From<i8>>(&self) -> Collection<G, K, R2> {
         self.threshold_named("Distinct", |_,_| R2::from(1i8))
     }
 }
 
 impl<G: Scope, K: ExchangeData+Hashable, R1: ExchangeData+Semigroup> Threshold<G, K, R1> for Collection<G, K, R1>
 where G::Timestamp: Lattice+Ord {
-    fn threshold_named<R2: Abelian, F: FnMut(&K,&R1)->R2+'static>(&self, name: &str, thresh: F) -> Collection<G, K, R2> {
+    fn threshold_named<R2: Ord+Abelian+'static, F: FnMut(&K,&R1)->R2+'static>(&self, name: &str, thresh: F) -> Collection<G, K, R2> {
         self.arrange_by_self_named(&format!("Arrange: {}", name))
             .threshold_named(name, thresh)
     }
@@ -169,7 +169,7 @@ where
     T1: for<'a> TraceReader<Key<'a>=&'a K, Val<'a>=&'a (), Diff=R1>+Clone+'static,
     for<'a> T1::Key<'a>: IntoOwned<'a, Owned = K>,
 {
-    fn threshold_named<R2: Abelian, F: FnMut(&K,&R1)->R2+'static>(&self, name: &str, mut thresh: F) -> Collection<G, K, R2> {
+    fn threshold_named<R2: Ord+Abelian+'static, F: FnMut(&K,&R1)->R2+'static>(&self, name: &str, mut thresh: F) -> Collection<G, K, R2> {
         self.reduce_abelian::<_,K,(),KeySpine<_,_,_>>(name, move |k,s,t| t.push(((), thresh(k, &s[0].1))))
             .as_collection(|k,_| k.clone())
     }
@@ -201,26 +201,26 @@ pub trait Count<G: Scope, K: Data, R: Semigroup> where G::Timestamp: Lattice+Ord
     /// This method allows `count` to produce collections whose difference
     /// type is something other than an `isize` integer, for example perhaps an
     /// `i32`.
-    fn count_core<R2: Abelian + From<i8>>(&self) -> Collection<G, (K, R), R2>;
+    fn count_core<R2: Ord + Abelian + From<i8> + 'static>(&self) -> Collection<G, (K, R), R2>;
 }
 
 impl<G: Scope, K: ExchangeData+Hashable, R: ExchangeData+Semigroup> Count<G, K, R> for Collection<G, K, R>
 where
     G::Timestamp: Lattice+Ord,
 {
-    fn count_core<R2: Abelian + From<i8>>(&self) -> Collection<G, (K, R), R2> {
+    fn count_core<R2: Ord + Abelian + From<i8> + 'static>(&self) -> Collection<G, (K, R), R2> {
         self.arrange_by_self_named("Arrange: Count")
             .count_core()
     }
 }
 
-impl<G, K: Data, T1, R: Semigroup> Count<G, K, R> for Arranged<G, T1>
+impl<G, K: Data, T1, R: Data+Semigroup> Count<G, K, R> for Arranged<G, T1>
 where
     G: Scope<Timestamp=T1::Time>,
     T1: for<'a> TraceReader<Key<'a>=&'a K, Val<'a>=&'a (), Diff=R>+Clone+'static,
     for<'a> T1::Key<'a>: IntoOwned<'a, Owned = K>,
 {
-    fn count_core<R2: Abelian + From<i8>>(&self) -> Collection<G, (K, R), R2> {
+    fn count_core<R2: Ord + Abelian + From<i8> + 'static>(&self) -> Collection<G, (K, R), R2> {
         self.reduce_abelian::<_,K,R,ValSpine<_,R,_,_>>("Count", |_k,s,t| t.push((s[0].1.clone(), R2::from(1i8))))
             .as_collection(|k,c| (k.clone(), c.clone()))
     }
diff --git a/src/operators/threshold.rs b/src/operators/threshold.rs
index 1358d8e3b..e05854694 100644
--- a/src/operators/threshold.rs
+++ b/src/operators/threshold.rs
@@ -21,7 +21,7 @@ pub trait ThresholdTotal<G: Scope, K: ExchangeData, R: ExchangeData+Semigroup> w
     /// Reduces the collection to one occurrence of each distinct element.
     fn threshold_semigroup<R2, F>(&self, thresh: F) -> Collection<G, K, R2>
     where
-        R2: Semigroup,
+        R2: Semigroup+'static,
         F: FnMut(&K,&R,Option<&R>)->Option<R2>+'static,
         ;
     /// Reduces the collection to one occurrence of each distinct element.
@@ -39,7 +39,7 @@ pub trait ThresholdTotal<G: Scope, K: ExchangeData, R: ExchangeData+Semigroup> w
     ///          .threshold_total(|_,c| c % 2);
     /// });
     /// ```
-    fn threshold_total<R2: Abelian, F: FnMut(&K,&R)->R2+'static>(&self, mut thresh: F) -> Collection<G, K, R2> {
+    fn threshold_total<R2: Abelian+'static, F: FnMut(&K,&R)->R2+'static>(&self, mut thresh: F) -> Collection<G, K, R2> {
         self.threshold_semigroup(move |key, new, old| {
             let mut new = thresh(key, new);
             if let Some(old) = old { new.plus_equals(&thresh(key, old).negate()); }
@@ -74,7 +74,7 @@ pub trait ThresholdTotal<G: Scope, K: ExchangeData, R: ExchangeData+Semigroup> w
     /// This method allows `distinct` to produce collections whose difference
     /// type is something other than an `isize` integer, for example perhaps an
     /// `i32`.
-    fn distinct_total_core<R2: Abelian+From<i8>>(&self) -> Collection<G, K, R2> {
+    fn distinct_total_core<R2: Abelian+From<i8>+'static>(&self) -> Collection<G, K, R2> {
         self.threshold_total(|_,_| R2::from(1i8))
     }
 
@@ -84,7 +84,7 @@ impl<G: Scope, K: ExchangeData+Hashable, R: ExchangeData+Semigroup> ThresholdTot
 where G::Timestamp: TotalOrder+Lattice+Ord {
     fn threshold_semigroup<R2, F>(&self, thresh: F) -> Collection<G, K, R2>
     where
-        R2: Semigroup,
+        R2: Semigroup+'static,
         F: FnMut(&K,&R,Option<&R>)->Option<R2>+'static,
     {
         self.arrange_by_self_named("Arrange: ThresholdTotal")
@@ -102,7 +102,7 @@ where
 {
     fn threshold_semigroup<R2, F>(&self, mut thresh: F) -> Collection<G, K, R2>
     where
-        R2: Semigroup,
+        R2: Semigroup+'static,
         F: for<'a> FnMut(T1::Key<'a>,&T1::Diff,Option<&T1::Diff>)->Option<R2>+'static,
     {
 
diff --git a/src/trace/implementations/mod.rs b/src/trace/implementations/mod.rs
index 6a0fe72c9..d9fd29932 100644
--- a/src/trace/implementations/mod.rs
+++ b/src/trace/implementations/mod.rs
@@ -66,17 +66,17 @@ pub trait Update {
     /// Values associated with the key.
     type Val: Ord + Clone + 'static;
     /// Time at which updates occur.
-    type Time: Ord+Lattice+timely::progress::Timestamp+Clone;
+    type Time: Ord + Clone + Lattice + timely::progress::Timestamp;
     /// Way in which updates occur.
-    type Diff: Semigroup+Clone;
+    type Diff: Ord + Semigroup + 'static;
 }
 
 impl<K,V,T,R> Update for ((K, V), T, R)
 where
     K: Ord+Clone+'static,
     V: Ord+Clone+'static,
-    T: Ord+Lattice+timely::progress::Timestamp+Clone,
-    R: Semigroup+Clone,
+    T: Ord+Clone+Lattice+timely::progress::Timestamp,
+    R: Ord+Semigroup+'static,
 {
     type Key = K;
     type Val = V;
@@ -108,8 +108,7 @@ pub struct Vector<U: Update> {
 
 impl<U: Update> Layout for Vector<U>
 where
-    U::Key: 'static,
-    U::Val: 'static,
+    U::Diff: Ord,
 {
     type Target = U;
     type KeyContainer = Vec<U::Key>;
@@ -125,10 +124,10 @@ pub struct TStack<U: Update> {
 
 impl<U: Update> Layout for TStack<U>
 where
-    U::Key: Columnation + 'static,
-    U::Val: Columnation + 'static,
+    U::Key: Columnation,
+    U::Val: Columnation,
     U::Time: Columnation,
-    U::Diff: Columnation,
+    U::Diff: Columnation + Ord,
 {
     type Target = U;
     type KeyContainer = TimelyStack<U::Key>;
@@ -164,8 +163,8 @@ where
     K::Owned: Ord+Clone+'static,
     V: ToOwned + ?Sized,
     V::Owned: Ord+Clone+'static,
-    T: Ord+Lattice+timely::progress::Timestamp+Clone,
-    R: Semigroup+Clone,
+    T: Ord+Clone+Lattice+timely::progress::Timestamp,
+    R: Ord+Clone+Semigroup+'static,
 {
     type Key = K::Owned;
     type Val = V::Owned;
@@ -177,11 +176,10 @@ impl<K, V, T, D> Layout for Preferred<K, V, T, D>
 where
     K: Ord+ToOwned+PreferredContainer + ?Sized,
     K::Owned: Ord+Clone+'static,
-    // for<'a> K::Container: BatchContainer<ReadItem<'a> = &'a K>,
     V: Ord+ToOwned+PreferredContainer + ?Sized,
     V::Owned: Ord+Clone+'static,
-    T: Ord+Lattice+timely::progress::Timestamp+Clone,
-    D: Semigroup+Clone,
+    T: Ord+Clone+Lattice+timely::progress::Timestamp,
+    D: Ord+Clone+Semigroup+'static,
 {
     type Target = Preferred<K, V, T, D>;
     type KeyContainer = K::Container;
@@ -361,7 +359,7 @@ where
     K: Ord + Clone + 'static,
     V: Ord + Clone + 'static,
     T: Timestamp + Lattice + Clone + 'static,
-    R: Semigroup + Clone + 'static,
+    R: Ord + Semigroup + 'static,
 {
     type Key<'a> = K;
     type Val<'a> = V;
@@ -386,7 +384,7 @@ where
     K: Ord + Columnation + Clone + 'static,
     V: Ord + Columnation + Clone + 'static,
     T: Timestamp + Lattice + Columnation + Clone + 'static,
-    R: Semigroup + Columnation + Clone + 'static,
+    R: Ord + Clone + Semigroup + Columnation + 'static,
 {
     type Key<'a> = &'a K;
     type Val<'a> = &'a V;
@@ -414,8 +412,8 @@ where
     V: Ord+ToOwned+PreferredContainer + ?Sized,
     V::Owned: Columnation + Ord+Clone+'static,
     for<'a> <<V as PreferredContainer>::Container as BatchContainer>::ReadItem<'a> : IntoOwned<'a, Owned = V::Owned>,
-    T: Columnation + Ord+Lattice+Timestamp+Clone,
-    R: Columnation + Semigroup+Clone,
+    T: Columnation + Ord+Clone+Lattice+Timestamp,
+    R: Columnation + Ord+Clone+Semigroup+'static,
 {
     type Key<'a> = &'a K::Owned;
     type Val<'a> = &'a V::Owned;
diff --git a/src/trace/mod.rs b/src/trace/mod.rs
index 8980c7397..1f513333f 100644
--- a/src/trace/mod.rs
+++ b/src/trace/mod.rs
@@ -58,7 +58,7 @@ pub trait TraceReader {
     /// Timestamps associated with updates
     type Time: Timestamp + Lattice + Ord + Clone;
     /// Associated update.
-    type Diff: Semigroup;
+    type Diff: Semigroup + 'static;
 
     /// The type of an immutable collection of updates.
     type Batch: for<'a> BatchReader<Key<'a> = Self::Key<'a>, Val<'a> = Self::Val<'a>, Time = Self::Time, Diff = Self::Diff>+Clone+'static;