first opinion on rust: pointers are hard.

or at least neither easy nor simple. but if something better than C++
with similar performance comes out, maybe it'll stay. or the
docs/tutorials get better, we'll see.
add pointer examples.
fix prints to reflect what's actually being done.

a macro could do this, i'm sure...
add commented-out, failing example for cons with references.
demonstrate that plain cons moves the value it receives.
ref also doesn't work.
two more tries (boxed list and reference to boxed list).

both don't work as desired, boxed list moves the value and the reference
to it has the same error as all the other reference things.
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.