# Trait differential_dataflow::operators::reduce::Threshold

source · ```
pub trait Threshold<G: Scope, K: Data, R1: Semigroup>{
// Required method
fn threshold_named<R2: Ord + Abelian + 'static, F: FnMut(&K, &R1) -> R2 + 'static>(
&self,
name: &str,
thresh: F,
) -> Collection<G, K, R2>;
// Provided methods
fn threshold<R2: Ord + Abelian + 'static, F: FnMut(&K, &R1) -> R2 + 'static>(
&self,
thresh: F,
) -> Collection<G, K, R2> { ... }
fn distinct(&self) -> Collection<G, K, isize> { ... }
fn distinct_core<R2: Ord + Abelian + 'static + From<i8>>(
&self,
) -> Collection<G, K, R2> { ... }
}
```

## Expand description

Extension trait for the `threshold`

and `distinct`

differential dataflow methods.

## Required Methods§

source#### fn threshold_named<R2: Ord + Abelian + 'static, 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>

A `threshold`

with the ability to name the operator.

## Provided Methods§

source#### fn threshold<R2: Ord + Abelian + 'static, 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>

Transforms the multiplicity of records.

The `threshold`

function is obliged to map `R1::zero`

to `R2::zero`

, or at
least the computation may behave as if it does. Otherwise, the transformation
can be nearly arbitrary: the code does not assume any properties of `threshold`

.

##### §Examples

```
use differential_dataflow::input::Input;
use differential_dataflow::operators::Threshold;
::timely::example(|scope| {
// report at most one of each key.
scope.new_collection_from(1 .. 10).1
.map(|x| x / 3)
.threshold(|_,c| c % 2);
});
```

source#### fn distinct(&self) -> Collection<G, K, isize>

#### fn distinct(&self) -> Collection<G, K, isize>

Reduces the collection to one occurrence of each distinct element.

##### §Examples

```
use differential_dataflow::input::Input;
use differential_dataflow::operators::Threshold;
::timely::example(|scope| {
// report at most one of each key.
scope.new_collection_from(1 .. 10).1
.map(|x| x / 3)
.distinct();
});
```

source#### fn distinct_core<R2: Ord + Abelian + 'static + From<i8>>(
&self,
) -> Collection<G, K, R2>

#### fn distinct_core<R2: Ord + Abelian + 'static + From<i8>>( &self, ) -> Collection<G, K, R2>

Distinct for general integer differences.

This method allows `distinct`

to produce collections whose difference
type is something other than an `isize`

integer, for example perhaps an
`i32`

.

## Object Safety§

This trait is

**not**object safe.