Will we have a syntax that let a variant as a type?

(I don't know what category this topic should be, so I leave it uncategorized)

Let's look into the source of Option::get_or_insert function.

pub fn get_or_insert(&mut self, value: T) -> &mut T {
    if let None = *self {
        *self = Some(value);
    }

    // SAFETY: a `None` variant for `self` would have been replaced by a `Some`
    // variant in the code above.
    unsafe { self.as_mut().unwrap_unchecked() }
}

This function judges an Option is Some or None. If it is None, give it a value, let it become a Some. Then use unwrap_unchecked to return the inner value, using unsafe code to avoid overhead.

How about if we can retain the variant information? Just like this:

pub fn get_or_insert(&mut self, value: T) -> &mut T {
    let this: &mut Some = match self {
    
        // Rule1: variant information can be provided by the pattern matching
        // now `this`'s type is `&mut Option::Some`
        this @ Some(_) => this,
        
        // `_this`'s type is `&mut Option::None`
        _this @ None => {
        
            // Rule2: variant information can be provided
            // by direct assignment as well
            *self = Some(value);
            
            // now `self`'s type becomes to `&mut Option::Some`,
            // but only in the current scope
            self
        }
    }
    
    // `self`'s type is unchanged, still be `Option`
    
    // return `Some`'s first value, just like tuple struct
    &mut this.0
}

I believe this topic has been discussed many times. Can anybody bring me to the discussion place please?

I doubt this will ever happen.

(On mobile so excuse the brevity but) the closest idea receiving interest lately would be "pattern types". You can probably find more details by searching IRLO.

Thanks. I'll check it out.

Thanks.

This topic was automatically closed 90 days after the last reply. We invite you to open a new topic if you have further questions or comments.