Unique pointers to state + callbacks in Rust - rust

Question

I am trying to bundle state in a struct together with callbacks that mutate the state. It works fine when I use managed pointers:
struct StateAndCallbacks01 {
state: #mut int,
inc: #fn(),
dec: #fn()
}
let state01: #mut int = #mut 0;
let inc01: #fn() = || {
*state01 += 1;
};
let dec01: #fn() = || {
*state01 -= 1;
};
let state_cbs_01 = #StateAndCallbacks01 {
state: state01,
inc: inc01,
dec: dec01
};
(state_cbs_01.inc)();
println(fmt!("state: %d", *state_cbs_01.state));
(state_cbs_01.dec)();
println(fmt!("state: %d", *state_cbs_01.state));
Next, I want to send this structure to another task, and thus have to switch to unique pointers everywhere. I cannot make that work: "error: obsolete syntax: const or mutable owned pointer"
struct StateAndCallbacks02 {
state: ~mut int,
inc: ~fn(),
dec: ~fn()
}
let state02: ~mut int = ~mut 0;
let inc02: ~fn() = || {
*state02 += 1;
};
let dec02: ~fn() = || {
*state02 -= 1;
};
let state_cbs_02 = ~StateAndCallbacks02 {
state: state02,
inc: inc02,
dec: dec02
};
let (port, chan): (Port<bool>, Chan<bool>) = stream();
do spawn {
(state_cbs_02.inc)();
println(fmt!("state: %d", *state_cbs_02.state));
(state_cbs_02.dec)();
println(fmt!("state: %d", *state_cbs_02.state));
chan.send(true);
};
let result = port.recv();
println(fmt!("result: %s", result));
Any suggestions? Any better ways to send callbacks across tasks?

Answer 1

Instead of keeping the functions as fields in the struct you can instead add methods to the struct.
struct Foo {
data: int
}
impl Foo {
fn inc(&mut self) {
self.data += 1;
}
}
The impl syntax lets you define methods on the struct. Which you can later call:
let mut my_foo = Foo { data: 0 };
my_foo.inc();
You have to declare my_foo as mutable since the inc method needs to take a mutable reference to it.
The reason for the obsolete syntax error is because doing ~mut 0 is deprecated since mutability is determined by who 'owns' the object. What you'd have to do instead is let mut foo = ~0. The variable foo is the 'owner' and thus is where you declare the mutability. #-pointers are special in that they don't inherit mutability and are managed by a task local GC. (Sections 8 & 9 of the Rust tutorial better explain this)
So with all that put together, you could write your original code like so:
struct State {
data: int
}
impl State {
fn inc(&mut self) {
self.data += 1;
}
fn dec(&mut self) {
self.data -= 1;
}
}
fn main() {
let state = State {
data: 0
};
let (port, chan) = stream();
do spawn {
let mut state = state;
state.inc();
println(fmt!("State: %d", state.data));
state.dec();
println(fmt!("State: %d", state.data));
chan.send(true);
};
let result = port.recv();
println(fmt!("Result: %?", result));
}