README std::cell::OnceLock usage example

[nyurik]

Rust v1.70 introduced a new std::cell::OnceCell primitive that should (in theory) replace the commonly used once_cell crate.

Regex README documents how to use the once_cell crate. Should it be updated with the now standardized OnceCell?

[BurntSushi]

I think you mean std::sync::OnceLock.

OnceLock is a slightly lower level primitive and is a little more annoying to use. It's also very new. I'd rather stick with once_cell for now. I do expect I'll update this at some point.

[nyurik]

Sure, and thx, you are right - I meant OnceLock. Just in case someone would like to use the Readme example with OnceLock, posting bellow. Could you clarify what you meant by a bit lower level - it seems the usage is nearly identical?

use regex::Regex;
use std::sync::OnceLock;

fn some_helper_function(haystack: &str) -> bool {
    static RE: OnceLock<Regex> = OnceLock::new();
    RE.get_or_init(|| Regex::new(r"...").unwrap())
        .is_match(haystack)
}

fn main() {
    assert!(some_helper_function("abc"));
    assert!(!some_helper_function("ac"));
}

[BurntSushi]

Compare static RE: Lazy<Regex> = Lazy::new(|| Regex::new(r"...").unwrap()); with what you have, which is two lines. It's a small thing, but the Lazy<Regex> approach is definitely a little nicer.

The once_cell crate docs do have a regex! macro that uses OnceCell and its use is pretty nice:

macro_rules! regex {
    ($re:literal $(,)?) => {{
        static RE: once_cell::sync::OnceCell<regex::Regex> = once_cell::sync::OnceCell::new();
        RE.get_or_init(|| regex::Regex::new($re).unwrap())
    }};
}

There is some more discussion about that in #709.

I overall don't think it's a huge problem to leave it as-is. I'm sure it will get migrated eventually, but I prefer to move more slowly.

[dharmesh404]

Sure, and thx, you are right - I meant OnceLock. Just in case someone would like to use the Readme example with OnceLock, posting bellow. Could you clarify what you meant by a bit lower level - it seems the usage is nearly identical?

use regex::Regex;
use std::sync::OnceLock;

fn some_helper_function(haystack: &str) -> bool {
static RE: OnceLock = OnceLock::new();
RE.get_or_init(|| Regex::new(r"...").unwrap())
.is_match(haystack)
}

fn main() {
assert!(some_helper_function("abc"));
assert!(!some_helper_function("ac"));
}

Rust documentation for get_or_init says:
pub fn get_or_init(&self, f: F) -> &T
where
F: FnOnce() -> T,
It is an error to reentrantly initialize the cell from f. The exact outcome is unspecified. Current implementation deadlocks, but this may be changed to a panic in the future.

Should this be handled in the above mentioned code ?

[nyurik]

By now the much better alternative is std::sync::LazyLock

use regex::Regex;
use std::sync::LazyLock;

fn some_helper_function(haystack: &str) -> bool {
    static RE: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"...").unwrap());

    RE.is_match(haystack)
}

fn main() {
    assert!(some_helper_function("abc"));
    assert!(!some_helper_function("ac"));
}