batch_oper 1.0.0

# batch_oper

batch_oper provides some batch operation macro for some operations
## Usage

- **Basic**  
  - batch `||`  
    ```rust  
    bop!(|| 4; == 2, > 3);
    ```
    *equivalent to*
    ```rust
    4 == 2 || 4 > 3
    ```
  - batch `&&`  
    ```rust  
    bop!(&& 4; == 2, > 3);
    ```
    *equivalent to*
    ```rust
    4 == 2 && 4 > 3
    ```
  - `!`
    ```rust
    bop!(|| a; == 1;!, == 2);
    ```
    *equivalent to*
    ```rust
    1 == a || a == 2
    ```
- **Set**
  ```rust
  let mut a = 1;
  bop!(= a; + 1, - 2;!, * 3);
  ```
  *equivalent to*
  ```rust
  let mut a = 1;
  a = a + 1;
  a = 2 - a;
  a = a * 3;
  ```
- **Let**
  ```rust
  bop! { let a|u8 = 1, mut b = 2 }
  ```
  *equivalent to*
  ```rust
  let a: u8 = 1;
  let mut b = 2;
  ```
- **Let chain**
  - basic
    ```rust
    let a = Some(1);
    let b = Some(2);

    let _: i32 = bop!(match && Some(va) = a, Some(vb) = b => {
        1
    } else {
        2
    });
    ```
    *equivalent to*
    ```rust
    let a = Some(1);
    let b = Some(2);

    let _: i32 = loop {
        if let Some(va) = a {
            if let Some(vb) = b {
                break { 1 };
            }
        }
        break { 2 };
    };
    ```
  - `bool`
    ```rust
    let _: bool = bop!(bool match && Some(va) = a, Some(vb) = b => {
        1
    } else {
        2
    });
    ```
    *equivalent to*
    ```rust
    let _: bool = loop {
        if let Some(va) = a {
            if let Some(vb) = b {
                { 1 };
                break true;
            }
        }
        { 2 };
        break false;
    };
    ```
  - `!loop`
    ```rust
    let _: i32 = bop!(!loop match && Some(va) = a, Some(vb) = b => {
        1
    } else {
        2
    });
    ```
    *equivalent to*
    ```rust
    let _: i32 = if let Some(va) = a {
        if let Some(vb) = b {
            { 1 }
        } else { { 2 } }
    } else  { { 2 } }
    ```
  - `!loop bool`
    ```rust
    let _: bool = bop!(!loop match && Some(va) = a, Some(vb) = b => {
        1
    } else {
        2
    });
    ```
    *equivalent to*
    ```rust
    let _: bool = if let Some(va) = a {
        if let Some(vb) = b {
            { 1 }; true
        } else { { 2 }; false }
    } else  { { 2 }; false }
    ```
- **In**
  ```rust
  let r = 0..5;
  let c = bop!(&1, &2 => in && r);
  ```
  *equivalent to*
  ```rust
  let r = 0..5;
  let c = r.contains(&1) && r.contains(&2);
  ```
  - `||`
    ```rust
    let c = bop!(&1, &2 => in || r);
    ```
    *equivalent to*
    ```rust
    let c = r.contains(&1) || r.contains(&2);
    ```
  - custom funcion name
    ```rust
    let c = bop!(has; &1, &2 => in && r);
    ```
    *equivalent to*
    ```rust
    let c = r.has(&1) && r.has(&2);
    ```
- `Using`
  ```rust
  let v = (1, 2);
  let v2 = (3, 4);
  using!((a, b) = v, (c, d) = v2; {
    println!("{} {} {} {}", a, b, c, d)
  })
  ```
  *equivalent to*
  ```rust
  let v = (1, 2);
  let v2 = (3, 4);
  {
    let (a, b) = v;
    let (c, d) = v2;
    {
      println!("{} {} {} {}", a, b, c, d)
    }
  }
  ```