Hi there 👋, I'm Gideon. Welcome to my GitHub Profile!
- Python
def feature(f: Callable[[], Tuple[Any, Exception]]) -> Callable[[], Tuple[Any, Exception]]: """ Wraps a function to run asynchronously in a thread and returns a closure to get the result. """ result = [None, None] # [result, error] done = threading.Event() def run(): try: result[0], result[1] = f() finally: done.set() threading.Thread(target=run, daemon=True).start() def get_result() -> Tuple[Any, Exception]: done.wait() return result[0], result[1] return get_result def retryable(call: Callable[[], Exception], max_retries: int, backoff: float) -> Exception: """ Executes a function with exponential backoff retries. backoff is in seconds (float). """ if max_retries == 0: return call() delay = backoff for i in range(max_retries + 1): err = call() if err is not None: if i == max_retries: return err time.sleep(delay) delay *= 2 continue return None return None- Go
// Retryable executes a function with exponential backoff retry logic func Retryable(call func() error, max int, backoff time.Duration) error { if max == 0 { return call() } for i := 0; i <= max; i++ { if err := call(); err != nil { if i == max { return err } time.Sleep(backoff) backoff *= 2 continue } return nil } return nil } /* The "Feature" function creates a goroutine to execute the wrapped function asynchronously, while the returned function waits for the execution to complete before returning the result. */ func Feature(f func(interface{}, error)) func() (interface{}, error) { var result interface{} var err error c := make(chan struct{}, 1) go func() { defer close(c) result, err = f() }() return func() (interface{}, error) { <-c return result, err } }- Rust
fn feature<F, T, E>(f: F) -> impl FnOnce() -> Result<T, E> where F: FnOnce() -> Result<T, E> + Send + 'static, T: Send + 'static, E: Send + 'static, { let (tx, rx): (mpsc::Sender<Result<T, E>>, mpsc::Receiver<Result<T, E>>) = mpsc::channel(); thread::spawn(move || { let result = f(); let _ = tx.send(result); }); move || rx.recv().unwrap() } fn retryable<F, E>(call: F, max: usize, backoff: Duration) -> Option<E> where F: Fn() -> Option<E>, { if max == 0 { return call(); } let mut delay = backoff; for _ in 0..=max { if let Some(err) = call() { if _ == max { return Some(err); } thread::sleep(delay); delay *= 2; continue; } return None; } None }