Crate batch_oper

batch_oper provides some batch operation macro for some operations

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);

• Using

  let v = (1, 2);
  let v2 = (3, 4);
  using!((a, b) = v, (c, d) = v2; {
    println!("{} {} {} {}", a, b, c, d)
  })

  equivalent to

  let v = (1, 2);
  let v2 = (3, 4);
  {
    let (a, b) = v;
    let (c, d) = v2;
    {
      println!("{} {} {} {}", a, b, c, d)
    }
  }

Macros

bop	Usage
using	Usage

Traits

Effect

Create an implicit variable, perform some side effects, and return it

Functions

effect	Create an implicit variable, perform some side effects, and return it
using	Create an implicit variable, and make a mapping for it