no way to bubble up Send/Freeze through raw pointers

[thestinger]

You can't write a correct smart pointer or vector type in a library at the moment.

[thestinger]

Nominating for the feature complete milestone.

[catamorphism]

Can you give an example that doesn't work? @nikomatsakis thinks raw pointers already have the Send trait.

[nikomatsakis]

It occurred to me that perhaps the point is that raw
pointers ALWAYS have the send trait, whereas you might
want something that is only sendable if it is a raw pointer
to a sendable thing (i.e., that simulates the behavior
of a ~ pointer).

[huonw]

@catamorphism Rc<T> is Freeze even when T is Send but not Freeze. e.g.

extern mod extra;
use std::cell::Cell;
use extra::rc::Rc;

fn is_freeze<T: Freeze>(_: T) {}

fn main() {
    // is_freeze(Cell::new(1)); // error: [...] Cell [...] does not fulfill Freeze

   is_freeze(Rc::from_send(Cell::new(1))); // compiles fine
}

(I believe @thestinger may be planning to remove from_send anyway, so this example may disappear.)

[thestinger]

@nikomatsakis: yup, the point is that you can't make a smart pointer or vector type behaving like ~T or ~[T] in a library at the moment if you don't use ~ to allocate the memory

[nikomatsakis]

I was thinking more about this problem. This ties in with some discussions that @pnkfelix and I were having regarding tracing GC: In particular, if you have smart pointers like Rc, you would like them to be traced for any kind of tracing GC -- but that means traversing * pointers, which is not necessarily a safe thing to do. However, if we had some other kind of pointer, perhaps itself a smart pointer (actually a lang item), that basically indicated a wrapper pointer, then we could know that we ought to trace the pointer, and also know to treat it properly in the kind computation.

This argues for replacing * with Raw<T>, as has been proposed, since it would make it cleaner to have a family of raw pointers for different purposes.

[catamorphism]

High but not 1.0

[nikomatsakis]

It's possible that the correct fix for this is just to change how we compute the kinds for *T. After all, why should a *&Foo be sendable, or a *Cell be considered freezeable?

[nikomatsakis]

If people REALLY want to hide the contents of their pointer from the type system, they can transmute to *i8 and back.

[thestinger]

+1, going to close the KindMimic PR

[nikomatsakis]

I can incorporate that change into PR #10158

[pnkfelix]

Hmm it is not clear from the links above which PR (if any) has committed the fix I believe was settled on (namely changing kind computation to traverse even a *TypeExpr)

Posting to remind self to check on that later

[pnkfelix]

Okay, the change landed in PR #10289 (which was the successful landing of many attempted PR's for #10157).