huzzah, pointers in the list itself seem to be the solution.

because that's actually what we want here: we want to *reference* other
immutable lists in our own, so that we don't have to create them twice.

in the previous attempts, any "list construction" using other lists
would move that list, which isn't what we want.

we also need references both in the data structure *and* the functions
using them, to be able to apply those functions and still be able to use
the arguments we used afterwards.

also, the lifetime annotations are quite tricky.

now, should we *still* use boxes inside the references? if references
are really allocated on the stack, then we probably should. but i think
if we let users box the list heads themselves, it's better, because we
don't want to dictate where to allocate things.

rust/pointers.rs

    }
}
mod list_with_ref_box {
    #[deriving(Show)]
    enum List<'a, A: 'a> {
        Nil,
        Cons(A, &'a Box<List<'a A>>)
    }
    pub fn cons<'a, A>(x: A, xs: &'a Box<List<'a A>>) -> List<'a A> {
        Cons(x, xs)
    }
    pub fn run() {
        println!("\nlist_with_ref_box:");
        let nil = &box Nil;
        let l: &Box<List<int>> = &box cons(1, nil);
        println!("l = {:?}", l);
        println!("cons(2, l) = {:?}", cons(2, l));
        println!("cons(3, l) = {:?}", cons(3, l));
    }
}
pub fn main() {
    wrapped::run();
    list_with_box::run();
    list_with_ref::run();
    list_with_ref_box::run();
}