moved to a callback BUT costed me a global so lets iterate to someTrait

src/main.rs

@@ -31,14 +31,17 @@ struct Flags {
    debug: bool,
 }
 
+static mut G_HANDLER: Handler = new_handler(&0.0, &0.0);
+
 fn main() {
    let flags = Flags::parse();
 
-   let handler = Handler{
-      head: flags.stream_head,
-      tail: flags.stream_tail,
-   };
-   let w = new_whisper(flags.model, flags.threads, handler).unwrap();
+   unsafe {
+      G_HANDLER.head = flags.stream_head.clone();
+      G_HANDLER.tail = flags.stream_tail.clone();
+   }
+
+   let w = new_whisper(flags.model, flags.threads, new_handler(&flags.stream_head, &flags.stream_tail)).unwrap();
    let stream_retain = (flags.stream_retain * 16_000.0) as usize;
    let stream_step = Duration::new(flags.stream_step, 0);
    match flags.wav {
@@ -63,9 +66,11 @@ fn main() {
          new_listener().listen(move |data: Vec<f32>| {
             data.iter().for_each(|x| buffer.push(*x));
             if Instant::now() - last > stream_step {
-               //match w.transcribe_async(&buffer) {
-               match w.transcribe_callback(&buffer, |x| {
-                  println!("CALLBACK: {:?}", &x);
+               match w.transcribe_async(&buffer, |result| {
+                  match result {
+                     Ok(whispered) => unsafe { G_HANDLER.on_success(&whispered) },
+                     Err(msg) => unsafe { G_HANDLER.on_error(msg) },
+                  };
                }) {
                   Ok(_) => (),
                   Err(msg) => eprintln!("{}", msg),
@@ -124,15 +129,11 @@ impl Whisper {
       recv.recv().unwrap();
    }
 
-   fn transcribe_callback(&self, data: &Vec<f32>, callback: fn(&Whispered)) -> Result<(), String> {
+   fn transcribe_async(&self, data: &Vec<f32>, callback: fn(Result<Whispered, String>)) -> Result<(), String> {
       self._transcribe_async(data, None, Some(callback))
    }
 
-   fn transcribe_async(&self, data: &Vec<f32>) -> Result<(), String> {
-      self._transcribe_async(data, None, None)
-   }
-
-   fn _transcribe_async(&self, data: &Vec<f32>, ack: Option<std::sync::mpsc::SyncSender<bool>>, callback: Option<fn(&Whispered)>) -> Result<(), String> {
+   fn _transcribe_async(&self, data: &Vec<f32>, ack: Option<std::sync::mpsc::SyncSender<bool>>, callback: Option<fn(Result<Whispered, String>)>) -> Result<(), String> {
       match self.jobs.try_send(AWhisper{
          data: data.clone().to_vec(),
          ack: ack,
@@ -164,16 +165,20 @@ impl WhisperEngine {
                         None => (),
                      };
                      match job.callback {
-                        Some(foo) => foo(&result),
+                        Some(foo) => foo(Ok(result)),
                         None => (),
                      };
                   },
                   Err(msg) => {
-                     self.handler.on_error(format!("failed to transcribe: {}", msg));
+                     self.handler.on_error(format!("failed to transcribe: {}", &msg));
                      match job.ack {
                         Some(ack) => { let _ = ack.send(false); },
                         None => (),
                      };
+                     match job.callback {
+                        Some(foo) => foo(Err(format!("failed to transcribe: {}", &msg))),
+                        None => (),
+                     };
                   },
                };
             },
@@ -213,7 +218,7 @@ impl WhisperEngine {
 struct AWhisper {
    data: Vec<f32>,
    ack: Option<std::sync::mpsc::SyncSender<bool>>,
-   callback: Option<fn(&Whispered)>,
+   callback: Option<fn(Result<Whispered, String>)>,
 }
 
 #[derive(Clone, Debug)]
@@ -283,11 +288,19 @@ impl Whispered {
    }
 }
 
+#[derive(Clone)]
 struct Handler {
    head: f32,
    tail: f32,
 }
 
+const fn new_handler(seconds_head: &f32, seconds_tail: &f32) -> Handler {
+   Handler{
+      head: *seconds_head,
+      tail: *seconds_tail,
+   }
+}
+
 impl Handler {
    fn on_success(&self, result: &Whispered) {
       eprintln!("{}: {:?}", chrono::Local::now(), &result);