# [−][src]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