Callbacks
Following is the definition of callbacks from wiki https://en.wikipedia.org/wiki/Callback_(computer_programming)
callback in Rust
Whenever I read any web code, callbacks are important part of the code.
So tried to build a basic callback in rust to understand what is it .
I believe , callbacks are basically storing functions/closures in array and calling them whenever required. Actually it is a little difficult to build in Rust because of the syntax and type checks.
But it’s work , type of the functions will be verified in compile time.
For example , if I give x+2 , instead of x +=2 in the below code, rust comiplier gives compilation error.
below code
Rust callback
//create a callbacks list and make some basic operations like
//register a function and calling it etc.
//callbacks struct to store the vector( list of functions)
struct CallbackV1{
callbacks:Vec<Box<FnMut(i32)>>
}
//implemenation of the CallbackV1
impl CallbackV1{
fn new() ->Self{
CallbackV1 {
callbacks : Vec::new()
}
}
//method to register functions in the callbacks vector
fn register(&mut self,f:Box<FnMut(i32)>){
self.callbacks.push(f)
}
//method to call the functions in the callbacks
fn call(&mut self,p:i32){
//iterate over the callbacks vector and take a mutable reference
for callback in self.callbacks.iter_mut(){
//dereference the callback function and call with passed argument.
(&mut *callback)(p);
}
}
}
fn add(x:i32){
println!("{}",x+1);
}
fn main() {
// let mut x = 2;
let mut mycallbacks = CallbackV1::new();
let f1 = |mut x:i32| {
x += 2
// println!("{}",x) ;
};
let f2 = add;
mycallbacks.register(Box::new(f1));
mycallbacks.register(Box::new(f2));
mycallbacks.call(4);
}
Callback in Python
Built the same code with Python as well. Its quite easy to build the same in python. But the type checks are not there . Its simply call the functions registered. I believe this can lead to vulnerabilities .
#create a callbacks list and make some basic operations like
#register a function and calling it etc.
class CallbacksV1:
def __init__(self):
self.callbacks = []
def register(self,f):
self.callbacks.append(f)
def call(self,value):
callback = self.callbacks.pop()
callback(value)
def add(x):
print(x+1)
def add_two(x):
print(x+2)
return (x+2)
c = CallbacksV1()
c.register(add)
c.register(add_two)
c.call(3)
c.call(5)
