Yapılandırma yöntemi olmayan bir işleve önbelleğe almanın deyimsel yolu nedir?

Question

Böyle pahalı bir işlevi vardır:

pub fn get_expensive_value(n: u64): u64 { 
    let ret = 0; 
    for 0 .. n { 
     // expensive stuff 
    } 
    ret 
} 

Ve aynı argümanı ile çok sık çağrılır. Bu saf, yani aynı sonucu döndürecek ve bir önbellekten faydalanabileceği anlamına gelir.

Bu bir yapı yöntemi olsaydı, önbellek gibi davranan yapıya üye eklerdim, ancak değil. Yani benim seçenek statik kullanmak gibi görünüyor: Şimdi

static mut LAST_VAL: Option<(u64, u64)> = None; 

pub fn cached_expensive(n: u64) -> u64 { 
    unsafe { 
     LAST_VAL = LAST_VAL.and_then(|(k, v)| { 
      if k == n { 
       Some((n,v)) 
      } else { 
       None 
      } 
     }).or_else(|| { 
      Some((n, get_expensive_value(n))) 
     }); 
     let (_, v) = LAST_VAL.unwrap(); 
     v 
    } 
} 

, ben unsafe kullanmak zorunda kalmıştım. static mut yerine, bir RefCell bir const içine koyabilirsiniz. Ama ben daha güvenli olduğuna inanmıyorum - sadece unsafe bloğunu kullanmaktan kaçınıyor. Bir Mutex'u düşündüm, ama bunun da iplik güvenliği sağlayacağını sanmıyorum.

Depolama için bir yapı kullanılacak kodun yeniden tasarlanması gerçekten bir seçenek değildir.

Answer 1

Bence en iyi alternatif, global bir değişkeni muteks ile kullanmaktır. lazy_static kullanma kolaylaştırır ve fonksiyon

pub fn cached_expensive(n: u64) -> u64 { 
    use std::sync::Mutex; 
    lazy_static! { 
     static ref LAST_VAL: Mutex<Option<(u64, u64)>> = Mutex::new(None); 
    } 
    let mut last = LAST_VAL.lock().unwrap(); 
    let r = last.and_then(|(k, v)| { 
     if k == n { 
      Some((n, v)) 
     } else { 
      None 
     } 
    }).or_else(|| Some((n, get_expensive_value(n)))); 
    let (_, v) = r.unwrap(); 
    *last = r; 
    v 
}