Macro bop 

macro_rules! bop {
    {} => { ... };
    { let $($p:pat $(| $t:ty)? $(= $e:expr)?),*} => { ... };
    { $($l:lifetime :)? match && $($p:pat = $e:expr),* => $b:block else $el:block } => { ... };
    { bool $($l:lifetime :)? match && $($p:pat = $e:expr),* => $b:block $(else $el:block)? } => { ... };
    { !loop match && $($p:pat = $e:expr),* => $b:block else $el:block } => { ... };
    { !loop bool match && $($p:pat = $e:expr),* => $b:block $(else $el:block)? } => { ... };
    { $x:expr $(;)? } => { ... };
    { || $x:expr $(;)? } => { ... };
    { && $x:expr $(;)? } => { ... };
    { = $x:ident $(;)? } => { ... };
    { || $x:expr ; $($op:tt $a:expr $(;$n:tt)?),* } => { ... };
    { && $x:expr ; $($op:tt $a:expr $(;$n:tt)?),* } => { ... };
    { = $x:ident ; $($op:tt $a:expr $(;$n:tt)?),* } => { ... };
    { || $x:expr ; $op:tt $(;)? } => { ... };
    { && $x:expr ; $op:tt $(;)? } => { ... };
    { = $x:ident ; $op:tt $(;)? } => { ... };
    { || $x:expr ; $op:tt ; $($a:expr $(;$n:tt)?),* } => { ... };
    { && $x:expr ; $op:tt ; $($a:expr $(;$n:tt)?),* } => { ... };
    { = $x:ident ; $op:tt ; $($a:expr $(;$n:tt)?),* } => { ... };
    { $fname:ident ; $($v:expr),* => in && $t:expr } => { ... };
    { $fname:ident ; $($v:expr),* => in || $t:expr } => { ... };
    { $fname:ident ; $v:expr => in && $($t:expr),* } => { ... };
    { $fname:ident ; $v:expr => in || $($t:expr),* } => { ... };
    { $($fname:ident ;)? => in && $t:expr  } => { ... };
    { $($fname:ident ;)? => in || $t:expr  } => { ... };
    { $($fname:ident ;)? $v:expr => in && } => { ... };
    { $($fname:ident ;)? $v:expr => in || } => { ... };
    { $($v:expr),* => in && $t:expr } => { ... };
    { $($v:expr),* => in || $t:expr } => { ... };
    { $v:expr => in && $($t:expr),* } => { ... };
    { $v:expr => in || $($t:expr),* } => { ... };
}

batch opers

Usage

• Basic
  • batch ||

    bop!(|| 4; == 2, > 3);

    equivalent to

    4 == 2 || 4 > 3;

  • batch &&

    bop!(&& 4; == 2, > 3);

    equivalent to

    4 == 2 && 4 > 3;

  • !

    bop!(|| a; == 1;!, == 2);

    equivalent to

    1 == a || a == 2

  • batch op

    bop!(&& 5; > ; 2, 3, 6;!);

    equivalent to

    5 > 2 && 5 > 3 && 6 > 5;

• Set

  let mut a = 1;
  bop!(= a; + 1, - 2;!, * 3);

  equivalent to

  let mut a = 1;
  a = a + 1;
  a = 2 - a;
  a = a * 3;

• Let

  bop! { let a|u8 = 1, mut b = 2 }

  equivalent to

  let a: u8 = 1;
  let mut b = 2;

• Let chain
  • basic

    let a = Some(1);
    let b = Some(2);
    
    let v: i32 = bop!(match && Some(va) = a, Some(vb) = b => {
        1
    } else {
        2
    });

    equivalent to

    let a = Some(1);
    let b = Some(2);
    
    let v: i32 = loop {
        if let Some(va) = a {
            if let Some(vb) = b {
                break { 1 };
            }
        }
        break { 2 };
    };

  • bool

    let v: bool = bop!(bool match && Some(va) = a, Some(vb) = b => {
        1
    } else {
        2
    });

    equivalent to

    let v: bool = loop {
        if let Some(va) = a {
            if let Some(vb) = b {
                { 1 };
                break true;
            }
        }
        { 2 };
        break false;
    };

  • !loop

    let v: i32 = bop!(!loop match && Some(va) = a, Some(vb) = b => {
        1
    } else {
        2
    });

    equivalent to

    let v: i32 = if let Some(va) = a {
        if let Some(vb) = b {
            { 1 }
        } else { { 2 } }
    } else  { { 2 } };

  • !loop bool

    let v: bool = bop!(!loop bool match && Some(va) = a, Some(vb) = b => {
        1
    } else {
        2
    });

    equivalent to

    let v: bool = if let Some(va) = a {
        if let Some(vb) = b {
            { 1 }; true
        } else { { 2 }; false }
    } else  { { 2 }; false };

• In

  let r = 0..5;
  let c = bop!(&1, &2 => in && r);

  equivalent to

  let r = 0..5;
  let c = r.contains(&1) && r.contains(&2);

  • ||

    let c = bop!(&1, &2 => in || r);

    equivalent to

    let c = r.contains(&1) || r.contains(&2);

  • custom funcion name

    let c = bop!(has; &1, &2 => in && r);

    equivalent to

    let c = r.has(&1) && r.has(&2);