Function run 

pub fn run<F: FnOnce() -> R, R: IntoFuture>(f: F) -> Result<R::Item, R::Error>

Run the main loop and initialize it by running a function

This is basically a shortcut for:

let mut lp = Core::new().expect("create loop");
lp.run(futures::lazy(f))

The difference between run() and run_forever() is merely a convenience. Basically, you want to use run() in client applications when you have a future that should complete to proceed. And run_forever() in server applications which spawns some listeners and never exits.

But also initializes thread-local loop handle for the time of loop run

Examples found in repository

examples/mininal.rs (lines 8-10)

fn main() {

    run(|| {
        Ok::<_, io::Error>(())
    }).unwrap();
}

examples/timeout.rs (lines 10-17)

fn main() {

    run(|| {
        println!("Sleeping 1 second");
        timeout(Duration::new(1, 0))
        .and_then(|()| {
            println!("Done");
            Ok(())
        })
    }).unwrap();
}

examples/multi-threaded.rs (lines 23-31)

fn main() {
    let addr = env::args().nth(1).unwrap_or("127.0.0.1:7777".to_string());
    let addr = addr.parse::<SocketAddr>().expect("parse address");

    let socket = StdListener::bind(addr).expect("bind socket");
    let mut threads = Vec::new();
    for thread_no in 0..10 {
        let lst = socket.try_clone().expect("cloning bind socket");
        threads.push(thread::spawn(move || {
            run(|| {
                TcpListener::from_listener(lst, &addr, &handle())
                .expect("listener created")
                .incoming()
                .for_each(|(_sock, addr)| {
                    println!("Accepted {} in thread {}", addr, thread_no);
                    Ok(())
                })
            })
        }))
    }
    for t in threads {
        t.join().expect("thread never joins").expect("accept never fails");
    }
}