Option

fn main() {
// Option

// map, as_ref
    // (owned) String
    let payload: String = "colony".to_string();
    
    // Wrap the String in an Option. This moves it, so payload is no more
    let optw: Option<String> = Some(payload);
    
    // in order to keep Option<String> alive and unmoved, as_ref will 
    // produce Option<&String> which will be sacrificed to map
    let rf: Option<&String> = optw.as_ref();
    
    // map converts Option<T> to Option<U> by applying fn to the wrapped value.
    // if map would eat Option<String>, optw would be moved. In order to save
    // optw, as_ref produces an Option<&String> for map to eat instead.
    let opt_len: Option<usize> = rf.map(|payload| payload.len());
    
    println!("map gets len, unwrapped: {:?}", opt_len.unwrap());
    println!("while original is still alive, wrapped: {:?}", optw);


// std::option::Option::take
// fn take(&mut self) -> Option<T>
// Takes the value out of the option, leaving a None in its place.
    let mut x = Some("thing".to_string());
    let d: Option<String> = x.take();
    assert_eq!(x, None);
    println!("take(), unwrapped value: {:?}", d.unwrap());


// and
// alternate: return Option<U> if Option<T>::None
// fn and<U>(self, optb: Option<U>) -> Option<U>;


// mem::swap
    let mut opt = Some(6_u8);
    let mut nada: Option<u8> = None;
    std::mem::swap(&mut nada, &mut opt);
    println!("mem::swapped: {:?}", nada);


// mem::replace
    let opt = Some(6_u8);
    let mut nada: Option<u8> = None;
    let res = std::mem::replace(&mut nada, opt);
    println!("mem::replaced: {:?}", nada); // Some(6)
    println!("mem::replaced, result: {:?}", res); // None


} // main