Rust way of magic methods - oop

Question

I want to map all children struct methods to it's parent with reducing some parameters.
Here is a example:-
PlayGround:- https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=0610b6abd57ab3d65435c821829e156b
struct World;
struct Sibling;
struct Parent {
pub child: Child,
pub sibling: Sibling
}
impl Parent {
pub fn new()->Parent {
Parent {
sibling: Sibling,
child: Child,
}
}
}
struct Child;
impl Child {
pub fn set_x(&mut self, _world: &mut World, _sibling: &mut Sibling, _x: f32 ){
// ..
}
pub fn set_y(&mut self, _world: &mut World, _sibling: &mut Sibling, _y: f32){
// ..
}
// 32 methods that taking World as first parameter and Sibling as second parameter
}
fn main(){
let mut world = World;
let mut parent = Parent::new();
parent.child.set_x(&mut world,&mut parent.sibling,0.23);
parent.child.set_y(&mut world,&mut parent.sibling, 0.12);
// Expectation:-
// parent.set_x(&mut world,0.23)
// parent.set_y(&mut world, 1.23)
}
Parent is know who is the sibling, who is the child. There is no need for guidance from the global scope. I need to hide child and sibling from outer scope. And I have tried in the following way.
impl Parent {
pub fn set_x(&mut self, world: &mut World, x: f32){
self.child.set_x(world, &mut self.sibling, x);
}
// ...
}
But I have 32 methods. This is not a clear way.

Answer 1

You can do it with a simple macro:
macro_rules! map_methods {
($stype:ty { $($method:ident ($($param:ident : $ptype:ty),*);)* }) => {
impl $stype {
$(
fn $method (&mut self, world: &mut World, $($param: $ptype),*) {
self.child.$method (world, &mut self.sibling, $($param),*)
}
)*
}
}
}
Which you then use like this:
map_methods!{ Parent {
set_x (_x: f32);
set_y (_y: f32);
}}
Playground
PS: Obligatory reading when starting with Rust macros: The Little Book of Rust Macros