Can't process result of function call

I am a newbee.
I am trying to write loop future.
The code is

    let packet_sender = future::loop_fn(, move |peer| {
        if peer == None {
            return Ok(future::Loop::Break(peer));
        // here, peer is not None
        let peer = peer.unwrap();
        let mut server = server_obj_c_c.borrow_mut();
            .and_then(|()| Ok(future::Loop::Continue(
            .or_else(|_| Ok(future::Loop::Break(
    .map(|_| ());

function named send_ping_req() returns IoFuture<()> type.
when it compiles
the error msg is

130 | / server.send_ping_req(peer)
131 | | .and_then(|()| Ok(future::loop::Continue(
132 | | .or_else(|_| Ok(future::loop::Break(
| |_______________________________________________________________________^ expected enum std::result::Result, found struct futures::OrElse
= note: expected type std::result::Result<_, _>
found type `futures::OrElse<futures::AndThen<std::boxed::Box<futures::Future<Error=std::io::Error, Item=()> + std::marker::Send>,

thanks in advance!!!

(Please format error messages in your posts as well)

The loop_fn closure needs to return the same type, whereas it doesn’t in the code: it returns a Result and an OrElse. You can try one of these options:

  1. Use as the return type, with A and B being different (Future) types that resolve to Loop.
  2. Box the two different futures you have now, which will erase the type. The return type will be Box<Future<Item=Loop...>>

To flesh this out a bit, here’re the two options with code similar to yours (just enough to illustrate the idea):

fn option1() {
    let _ = future::loop_fn(next(), move |peer| match peer {
        None => Either::A(Ok::<_, ()>(future::Loop::Break(peer)).into_future()),
        Some(_peer) => Either::B(
                .map(|()| future::Loop::Continue(next()))
                .or_else(|_| Ok(future::Loop::Break(next()))),

type LoopFuture = Box<Future<Item = future::Loop<Option<Peer>, Option<Peer>>, Error = ()>>;

fn option2() {
    let _ = future::loop_fn(next(), move |peer| -> LoopFuture {
        match peer {
            None => Box::new(Ok(future::Loop::Break(peer)).into_future()),
            Some(_peer) => Box::new(
                    .map(|()| future::Loop::Continue(next()))
                    .or_else(|_| Ok(future::Loop::Break(next()))),

Thanks for your kind explanations!
I got it.