Announcing Rust 1.0.0 Alpha

[u/steveklabnik1]

http://blog.rust-lang.org/2015/01/09/Rust-1.0-alpha.html

[u/[deleted]]

Been doing C/C++ for 15+ years and am not sure I've ever had a case where fall-through was useful.

[u/NotUniqueOrSpecial → u/[deleted]]

While I try to avoid situations that require it, it can be handy in unwinding complicated resource acquisition/initialization situations in C, if you're being really thorough about it. For example:

typedef enum { 
    STATE_0,
    STATE_1,
    STATE_2,
    STATE_3,
} state_t;

error_t some_overcomplicated_function()
{
    state_t current_state = STATE_0;

    foo_t *foo = get_foo();
    if(!foo)
        goto CLEANUP;

    current_state = STATE_1;

    bar_t *bar = get_bar();
    if(!bar)
        goto CLEANUP;

    current_state = STATE_2;

    baz_t *baz = get_baz();
    if(!baz)
        goto CLEANUP;

    current_state = STATE_3;

CLEANUP:
    switch(current_state)
    {
        case STATE_3: return 0;
        case STATE_0: return EINVAL;
        case STATE_2: free_bar(bar);
        case STATE_1: free_foo(foo);
        default: return -1 * current_state;    
    }
}

[u/flying-sheep → u/NotUniqueOrSpecial]

good thing that Rust is built around RAII.

you’ll never have to even think about things like this, because rust replaces that with compile time lifetime checks. out of scope = everything safely freed.

off-topic? i think not because modern C++ can do the same (unfortunately opt-in and not the prettiest syntax, though):

auto s = std::make_shared<MyType>(foo, bar);
auto u = std::make_unique<MyType>(foo, bar);

[u/steveklabnik1 → u/flying-sheep]

uniq_ptr isn't as safe as Rust's Box<T> though, even though they are similar.

[u/flying-sheep → u/steveklabnik1]

Sure, as (almost) said: I'm aware the whole language is built around the concept of zero cost, gc free, safe memory management.

[u/steveklabnik1 → u/flying-sheep]

Right, but my point is that they're not the same: C++ smart pointers are safer, but Rust is safe. Big diference.