News for hackers. Stuff that matters.
Re:Emulating the Rust borrow checker with C++ move-only types by masklinn on Saturday May 13, 2017 @04:32PM (#14332854)
> The difference is that you don't have to write "std::move" in Rust: the compiler just infers the right thing to do.

And of course since it's the language's default you don't have to write a dozen lines of boilerplate either, this is the C++ code stripped of the interspersed text:

    class MoveOnlyInt final {
    private:
       int i;

    void release() { /* call to release function here */ }

    public:
        explicit MoveOnlyInt(int i) : i(i) {}
        ~MoveOnlyInt() { release(); }

        MoveOnlyInt() = delete;
        MoveOnlyInt(const MoveOnlyInt &) = delete;
        MoveOnlyInt& operator=(const MoveOnlyInt &) = delete;

        MoveOnlyInt(MoveOnlyInt &&other) { i = other.i; other.i = -1; }
        MoveOnlyInt& operator=(MoveOnlyInt &&other) { release(); i = other.i; other.i = -1; return *this; }

        operator int() const { return i; }
    };
This seems like a fair Rust version, with as you noted the "move source" becoming inaccessible rather than just being in an invalid state:

    struct MoveOnlyInt {
        i: isize,
    }
    impl MoveOnlyInt {
        fn new(i: isize) -> MoveOnlyInt { MoveOnlyInt { i: i } }
    }
    // Rust doesn't have an "operator int", this seems close enough
    impl<'a> From<&'a MoveOnlyInt> for isize {
        fn from(m: &'a MoveOnlyInt) -> isize { m.i }
    }
Re:Emulating the Rust borrow checker with C++ move-only types by kibwen on Saturday May 13, 2017 @05:53PM (#14333220)
That's actually even way too much code for the Rust version. A wrapper type declaration is as simple as `struct MoveOnlyInt(i32);`, and construction is then just `let foo = MoveOnlyInt(42);`. (And of course, the wrapper type is only necessary because integers in Rust implement `Copy`, opting out of move semantics.)
Re:Emulating the Rust borrow checker with C++ move-only types by steveklabnik on Saturday May 13, 2017 @05:55PM (#14333224)
(and "operator int" would be foo.0 in this case)
Re:Emulating the Rust borrow checker with C++ move-only types by heinrich5991 on Sunday May 14, 2017 @07:36AM (#14335197)
Don't use `isize`, `isize` is not equivalent to C's `int`, but `intptr_t`. Specific sizes would be best, but if you need to copy C's `int`, there's `libc::c_int`.