Rust

6447 readers

54 users here now

Welcome to the Rust community! This is a place to discuss about the Rust programming language.

Wormhole

[email protected]

Credits

The icon is a modified version of the official rust logo (changing the colors to a gradient and black background)

founded 2 years ago

MODERATORS

[email protected]

170

Rust-Written Zlib-rs Is Not Only Safer But Now Outperforming Zlib C Implementations (www.phoronix.com)

submitted 6 days ago* (last edited 5 days ago) by [email protected] to c/[email protected]

24 comments fedilink hide all child comments

Source Blog Post

you are viewing a single comment's thread
view the rest of the comments

[–] [email protected] 1 points 4 days ago (1 children)

like that an hour is in the range from 0 to 23

Rust can do that too with const generics, no?

I don't know much about Ada though, but I hear it rocks. Rust has a lot stronger community though, and that carries a lot of weight.

[–] [email protected] 6 points 4 days ago (1 children)

Hmm, I haven't really played around with const generics much, but I guess, you could maybe implement a custom InRange type, so you could use it like this:

type Hour = InRange<0, 23>;

let hour = Hour::new(17);

That ::new() function would contain the assertions and could be const, but I don't know, if that actually makes it execute at compile-time, when called in normal runtime code. Might be worth trying to implement it, just to see how it behaves.
Was that an open question or did you have a solution in mind? 😅

What would definitely work in Rust, though, is to implement a macro which checks the constraint and generates a compile_error!() when it's wrong. Typically, you'd use a (function-like) proc_macro for this, but in this case, you could even have a macro_rules! macro with 24 success cases and then a catch-all error case.
Well, and of course, it may also be fine (or even necessary) to check such numbers at runtime. For that, just a wrapper type with a ::new() function would work.

[–] [email protected] 2 points 4 days ago (1 children)

Was that an open question or did you have a solution in mind?

More open. I saw it land in stable some time back and haven't gotten around to playing with it. I honestly haven't done it much, because usually enums are plentywhen there are a finite set of options.

And yeah, I was thinking of runtime checks with const bounds, like this:

pub struct BoundedI32<const MIN: i32, const MAX: i32>(i32);

impl<const MIN: i32, const MAX: i32> BoundedI32<{ MIN }, { MAX }> {
    pub const MIN: i32 = MAX;
    pub const MAX: i32 = MAX;

    pub fn new(n: i32) -> Self {
        // or an assert
        BoundedI32(n.min(Self::MAX).max(Self::MIN))
    }
}

I'm not sure how magic Ada gets with things, so maybe it's a lot nicer there, but I honestly can't see how it could really improve on handling runtime checks.

[–] [email protected] 2 points 1 day ago (1 children)

Well, I don't know much about Ada, but it's typically lauded for all its compile-time checks. Obviously, you can't compile-time check something when it's loaded at runtime from e.g. a configuration file, but yeah, I'm guessing that's probably where it shines, that it uses compile-time checks when possible.

[–] [email protected] 2 points 1 day ago

I would really like the mythical higher kinded types (which I think covers what Ada does here), but unfortunately we don't have that yet.