#rust-lang

You mean if the caller wanted nothing to happen until it starts polling the future?

vadimcn: Yeah

Well, then you either allocate, or your Future is gonna have a lifetime...

even if coroutine started out running you'd have the same problem, wouldn't you?

You'd have more problems then. Coroutines which start out running only help out futures which don't start suspended

nrc: ping -- I'd like to discuss some ideas re goals / design space for macros 2.0 hygiene

(at some point)

Totally should use `not move` as a keyword for non-movable generators

woboats: ping -- I have an idea re our earlier conversation about hygiene and `#[defines]`

woboats: in response to your post, consider that people who are unsatisfied do complain, but those who aren’t don’t

nobody really needs to use modules either

woboats: for mod, its pretty orthogonal to `use` and any `mod` could be simply replaced by `use` from crate root :)

and if module is not `use`d, it does not exist

want to export modules from crate root? `pub use mod1::mod2::mod3` exports `mod1::mod2::mod3`, but not, say, `mod1::mod2::mod4`

aturon: this `pub(restricted)` thing is so annoying

nmatsakis: yes :(

nmatsakis: i personally feel pretty ok about restricting to crate, super and self

and I like the perversion with braces

eddyb: ugh please no :P

ok it is a bit ugly

i promise you it will be widely seen as a shark-jumping moment

nmatsakis: it might be worth spending some time at lang team meeting today to see if we can get to the bottom of it

aturon: I feel .. bah. I guess I'm ok w/ crate/super/self. I know in practice it'll be tolerable, it just annoys me that we are awfully close to a general model, but we wind up with these sort of artificial restrictions that force you into a shallower module hierarchy

at that level I am tempted to just make `crate` a new kind of decl, similar to `pub`, though it doesn't solve the `pub(self)` idea

that reminds me, I need to get back to trying to write up the virtual struct stuff we were talking about, which has already escaped my head. I'm glad I took some detailed notes.

nmatsakis: yeah, i hear you re: artificial restrictions. though if we allow `super::super` etc, at least in principle it's fully expressive

we could consider the lookahead idea instead...

yeah, I guess super::super does retain the principle

just seems ... super annoying

somehow once it gets past one ../ I am lost

yeah it'd be super ugly :)

it's annoying that we have to pick something and will be kind of stuck with it becuase of macros

if we adopt that visibility proposal, I guess

I also can't comprehend beyond about one level of super

It's why I love rust's preference for from-root paths instead of NodeJS' relative paths

FWIW petrochenkov did some analysis on common visibility and IIRC crate + super covered the vast majority

nmatsakis: thoughts on lookahead hackery instead?

I'm sure it will be the vast majority, yes

it's the princple of the thing =)

re: lookahead, well, I think it is ok for a real parser, but I am concerned about doing it in the macro parser,

I'm trying to decide why

I guess because it seems to imply a grammar

(tbh current state of macro parser is kin dof confusing anyway in this area)

I really really wish we had not tied fragment specifies to rust grammar

hmm

i mean, it'll be a burden to other tooling as well

I mean I guess you could just imagine it being defined as greedy

yeah, it will

I guess I am ok w/ crate/super/self -- the main thing I was weighing yesteday is whether, if we went that road,

I would rather have `crate fn foo()`

cc pnkfelix

which would then also allow `crate impl Foo { ... }` for inherent impls local to a crate

nmatsakis: yeah, i was just thinking about that

which I dearly want :)

seems a shame to lose pub(self) except that this is a horrible embarassing hack anyway that I'd probably never be able to recommend with a straight-face

huh

nmatsakis: isn't pub(self) the private default?

yes, the idea was that we could hack privacy into things like traits/ enums which (imo) should not have had defaults, but do