[−][src]Crate batch_oper

batch_oper provides some batch operation macro for some operations

Features

default = ["std", "combin", "named-into", "macro-lit", "side-effect", "re-exports", "chain_panic", "chain_todo", "tuple_iter", "tuple_utils"]

"std" Enable std
"side-effect" Enable mod side_effect
"named-into" Enable mod named_into
"combin" Enable mod combin
"macro-lit" Enable macro like new, list
"chain_panic" Enable mod chain_panic
"chain_todo" Enable mod chain_todo
"tuples" Enable mod tuples
"once_get" Enable mod once_get
"re-exports" Enable re-export of all mods

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
ⓘThis example is not tested
```
let c = bop!(has; &1, &2 => in && r);
```
equivalent to
ⓘThis example is not tested
```
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)
  }
}

Re-exports

pub use side_effect::*;

pub use named_into::*;

pub use combin::*;

pub use chain_panic::*;

pub use chain_todo::*;

pub use crate::tuples::*;

pub use crate::once_get::*;

Modules

chain_panic	Chain Panic
chain_todo	Chain Todo
combin	No nesting combine
named_into	Use chained calls to avoid nesting
once_get
side_effect	Some extension functions that are convenient for side effects
tuples	Re-exports from tuples

Macros

arr	new a `Box<[T]>`
bop	batch opers
btmap	new a `BTreeMap<K, V>`
btset	new a `BTreeSet<V>`
deque	new a `VecDeque<T>`
heap	new a `BinaryHeap<V>`
list	new a `LinkedList<T>`
map	new a `HashMap<K, V>`
map_append	append items to a map
new	new a `Box<T>`
set	new a `HashSet<V>`
using	using