Function Group is a Function Overloading macro/hack for the rust programing language. The macro allows you to define multiple functions that take a variable number of arguments! Actually the functions still only take one argument, but they accept multiple types of tuples
Function groups can take multiple types of arguments and even be recursive ```rust function_group! { fn add -> usize { (one : usize, two : usize) { one + two } (one : usize, two : usize, three: usize) { add((one, two)) + three } } }
assert!(add((5, 5)) == 10); assert!(add((5, 5, 5)) == 15); ```
The arguments can be mutable or immutable refrences. ```rust functiongroup! { fn addto { (one : &mut usize, two : usize) { *one += two; } (one : &mut usize, two : usize, three : usize) { *one += two + three; } } }
let mut x = 10; addto((&mut x, 5)); addto((&mut x, 5, 5)); assert!(x == 25); ```
Function Groups can even be associated with a Type. In the example below, each sub function will be passed a mutable refrence to self, and these functions will be usable by the TestStruct type. ```rust struct TestStruct(usize); functiongroup! { fn addto_struct(&mut self : TestStruct) { (one : usize) { self.0 += one; } (one : usize, two : usize){ self.0 += one + two; } } }
let mut x = TestStruct(10); x.addtostruct((1,2)); assert!(x.0 == 13); ```