pub fn import_frontier<G>(&mut self, scope: &G, name: &str) -> (Arranged<G, TraceFrontier<TraceAgent<Tr>>>, ShutdownButton<CapabilitySet<Tr::Time>>)
    where
        G: Scope<Timestamp=Tr::Time>,
        Tr: TraceReader,
    {
        // This frontier describes our only guarantee on the compaction frontier.
        let since = self.get_logical_compaction().to_owned();
        self.import_frontier_core(scope, name, since, Antichain::new())
    }
Imports an arrangement into the supplied scope.

This variant of import uses the `get_logical_compaction` to forcibly advance timestamps in updates.

# Examples

```
use timely::Config;
use timely::progress::frontier::AntichainRef;
use timely::dataflow::ProbeHandle;
use timely::dataflow::operators::Probe;
use timely::dataflow::operators::Inspect;
use differential_dataflow::input::InputSession;
use differential_dataflow::operators::arrange::ArrangeBySelf;
use differential_dataflow::operators::reduce::Reduce;
use differential_dataflow::trace::Trace;
use differential_dataflow::trace::TraceReader;
use differential_dataflow::input::Input;

::timely::execute(Config::thread(), |worker| {

let mut probe = ProbeHandle::new();

// create a first dataflow
let (mut handle, mut trace) = worker.dataflow::<u32,_,_>(|scope| {
// create input handle and collection.
let (handle, stream) = scope.new_collection();
let trace = stream.arrange_by_self().trace;
(handle, trace)
});

handle.insert(0); handle.advance_to(1); handle.flush(); worker.step();
handle.remove(0); handle.advance_to(2); handle.flush(); worker.step();
handle.insert(1); handle.advance_to(3); handle.flush(); worker.step();
handle.remove(1); handle.advance_to(4); handle.flush(); worker.step();
handle.insert(0); handle.advance_to(5); handle.flush(); worker.step();

trace.set_logical_compaction(AntichainRef::new(&[5]));

// create a second dataflow
let mut shutdown = worker.dataflow(|scope| {
let (arrange, button) = trace.import_frontier(scope, "Import");
arrange
.as_collection(|k,v| (*k,*v))
.inner
.inspect(|(d,t,r)| {
assert!(t >= &5);
})
.probe_with(&mut probe);

button
});

worker.step();
worker.step();
assert!(!probe.done());

shutdown.press();

worker.step();
worker.step();
assert!(probe.done());

}).unwrap();
```
differential-dataflow/src/operators/arrange/agent.rs