struct MyStruct {
    val: int
}

static mut global_data: Option<~MyStruct> = None;

fn test_call() {
    unsafe {
        match global_data {
            Some(data) => { println!("We have data {:?}", data);}
            None => { println!("We don't have data");}
        }
    }
}

fn main() {

    unsafe {
        global_data = Some(~MyStruct{val: 42});
    }

    test_call();
    test_call();
}

We have data ~MyStruct{val: 42}
We don't have data

We have data ~MyStruct{val: 42}
We have data ~MyStruct{val: 42}

lib.rs:38:15: 38:17 error: use of undeclared lifetime name `'a`
lib.rs:38     impl Drop<'a> for MyStruct {

    impl Drop for MyStruct {
        fn drop(&mut self) {

    impl Drop for MyStruct {
CU>        fn drop(&mut self) {

impl<'a> Drop for MyStruct<'a> {
    fn drop(&mut self) { /* ... */ }
}

extern mod std;

use std::{task, io, uint, libc};
use std::comm::{SharedChan};

struct TestInfo {
    mode: task::SchedMode,
    tasks_count: i32,
    timeout: i64
}

        pub type Callback<'a> = 'a |~[~str]|: -> ~str;
        ...
        pub fn registr_callback(&mut self, name: ~str, callback: Callback<'a>) {
            self.callbacks.insert(name.clone(), callback); // вставка в хеш-таблицу
            unsafe {
                let callback = self.callbacks.find(&name); // а здесь достаём указатель...
                match callback {
                    Some(cc) => {
                        name.with_c_str(|s| {
                                 // чтобы вот здесь передать
                                _ext_createcommand(to_unsafe_ptr(cc),...);
                            });
                    }
                    None => {}
                }
            }
        }

        pub fn registr_callback(&mut self, name: ~str, callback: Callback<'a>) {
            self.callbacks.insert(name.clone(), callback); // вставка в хеш-таблицу
            unsafe {
                        name.with_c_str(|s| {
                                // вот здесь передаём ссылку на регистрацию
                                _ext_createcommand(to_unsafe_ptr(&callback),...);
                            });
                    }
        }

note: `callback` moved here because it has type `'a |~[~str]| -> ~str`, which is 
a non-copyable stack closure (capture it in a new closure, e.g. `|x| f(x)`, to override)

managed_boxes — Usage of @ pointers is gated due to many planned changes to this feature. In the past, this has meant "a GC pointer", but the current implementation uses reference counting and will likely change drastically over time. Additionally, the @ syntax will no longer be used to create GC boxes.

#[feature(managed_boxes)]