Improve mdo syntax

[Boscop]

Why not use <- (instead of =<<) just like haskell? (This crate also uses <-.)

[TeXitoi]

Because of rust macro system constraint, we can't put < after a pattern. Hado use an indent and not a pattern, that's why it can use <-, but hado can't do (a, b) <- expr, mdo can.

In pre rust 1.0, mdo was using <-.

[Boscop]

Ok, thanks for the explanation.

Btw, what's the recommended way to do embed non-monadic code in mdo! {} that uses the previous symbols? Currently I'm doing let _ = {...}

[TeXitoi]

Can you point to your usage of mdo, I'd like to read them and maybe propose some syntax to ease the usage of mdo.

I think you can't do better than what you're doing now, but we can improve mdo.

[Boscop]

Here is an example that contains the let _ = {} pattern for non-monadic code:

if let Some(data) = mdo! {
    places =<< place::Place::all_of_customer(customer_id).ok();
    trucks =<< truck::Truck::all_of_customer(customer_id).ok();
    truck_types =<< TruckType::all_of_customer(customer_id).ok();
    contained_products =<< ContainedProduct::all_of_customer(customer_id).ok();
    first_contained_product =<< contained_products.first();
    maybe_customer =<< Customer::find(customer_id).ok();
    customer =<< maybe_customer;
    drivers =<< Driver::all_of_customer(customer_id).ok();
    first_place =<< places.first().cloned();
    tablets =<< Tablet::all_of_customer(customer_id).ok();
    let origin = first_place.location();
    let drivers = drivers.into_iter().filter_map(|user| Driver::find(user.id).ok().and_then(|x| x)).collect::<Vec<_>>();
    let _ = {
        use std::iter::repeat;
        for (&driver, maybe_tablet) in drivers.iter().zip(tablets.into_iter().map(Some).chain(repeat(None))) {
            let tablet = maybe_tablet.or_else(|| {
                use diesel::Connection;
                use db;
                use models::tablet::*;
                let conn = &db::conn();
                conn.transaction(move || -> error::Result<_> {
                    let mut rng = thread_rng();
                    let unique_id = rng.gen_ascii_chars().take(25).collect::<String>();
                    let tablet_id = Tablet::create_from(NewTablet {
                        unique_id: &unique_id,
                        device_name: "fake demo device"
                    })?;
                    let tablet = Tablet::find_conn(conn, tablet_id)?.expect("bug");
                    tablet.update(&UpdateTablet::customer(Some(customer_id)))?;
                    Ok(tablet)
                }).ok()
            }).expect("tablet");
            tablet::set_logged_in(driver, Json(tablet.id));
        }
    };
    ret ret(CustomerData {
        customer,
        contained_product_id: first_contained_product.id,
        product_id: first_contained_product.product_id,
        truck_data: {
            drivers.into_iter().zip(&trucks).filter_map(|(driver, truck)|
                mdo! {
                    _ =<< truck.set_driver(driver.user_id).ok();
                    ret ret((truck.id, TruckData {
                        driver,
                        route: vec![],
                        truck: Truck::new(0, Vec2::new(0., 0.)),
                    }))
                }
            ).collect()
        },
        places: places.into_iter().enumerate().map(|(i, p)| (p.id, to_vrp_place(&origin, p, i))).collect(),
        origin,
        truck_ids: trucks.into_iter().map(|t| t.id).collect(),
    })
} {
    customer_data.insert(customer_id, data);
}

Also, I often have this pattern: if let Some(x) = mdo! { ... x =<< foo(); ret ret(x) } { /* do something with x */ } (like in the above example). It would be nice if I could write it like mdo! { ... x =<< foo(); /* do something with x */ }. Right now I'd have to write mdo! { ... x =<< foo(); let _ = { /* do something with x */ }; ret ret(()) } which is awkward.

Another pattern I often have is: mdo! { maybe_x =<< foo(); x =<< maybe_x; ... } Is there a way to do that in one line? If not, it would be nice if such a way could be added..

And maybe ret ret(x) could be shortened to just ret(x)?

[TeXitoi]

Whaou! That's a heavy use of mdo 😄

Do you have an idea of a great syntax for the let _ = { ... } pattern? can't think of any just now.

if let Some(x) = mdo! { ... x =<< foo(); ret ret(x) } { /* do something with x */ } can be rewritten if let Some(x) = mdo! { ... ret foo() } { /* do something with x */ }

I think I'd personnally write mdo! { ... x =<< foo(); let _ = { /* do something with x */ }; ret ret(()) } as

if let Some(x) = mdo! { ...; ret foo() } {
    /* do something with x */
}

for mdo! { maybe_x =<< foo(); x =<< maybe_x; ... } I don't get it, foo() returns Option<Option<T>>?

I think you're right, ret ret(x) can be shortened to just ret(x) with just a special case.

[TeXitoi]

I forgot, you can write _ =<< expr; as ign expr;

[Boscop]

Whaou! That's a heavy use of mdo 😄

Before I was using mdo it was even heavier with lots of map/and_then and deep indentation.. :)

Do you have an idea of a great syntax for the let _ = { ... } pattern? can't think of any just now.

If it's possible with the way macro parsing works, if a statement is not of the form x =<< y; or ret .. it can be treated like normal non-monadic code as if it was written in let _ = { ... }.

if let Some(x) = mdo! { ... x =<< foo(); ret ret(x) } { / do something with x / } can be rewritten if let Some(x) = mdo! { ... ret foo() } { / do something with x / }

Yeah, but I meant the extra if let Some(x) = .. {..} around mdo!{}, like in my code above.

I think I'd personnally write mdo! { ... x =<< foo(); let _ = { / do something with x / }; ret ret(()) } as

if let Some(x) = mdo! { ...; ret foo() } { / do something with x / }

Yes, this is what I did in the above example. But what I'd prefer to write is: mdo!{ ...<deps>... x =<< foo(<deps>); /* do something with x */ } (no ret, and no let _ = {..})

for mdo! { maybe_x =<< foo(); x =<< maybe_x; ... } I don't get it, foo() returns Option<Option>?

I often have db functions returning Result<Option<T>>, (Result because it could be a db error, Option because there could be no query result) so I often have mdo! { maybe_x =<< foo().ok(); x =<< maybe_x; ... }. That's what I meant. Is there a way to chain both into one line?

[TeXitoi]

For Result<Option<T>> is something like mdo! { x =<< foo().ok().unwrap_or(None); ... } acceptable?

[Boscop]

Ah, yes.