Rust Programming Language RFC 2229 Working Group, 7 Jul 2021

Previous Meeting

Next Meeting

⏯

youtube image

►

From YouTube: 2021-07-07 RFC 2229 sync

Description

No description was provided for this meeting.
If this is YOUR meeting, an easy way to fix this is to add a description to your video, wherever mtngs.io found it (probably YouTube).

A

B

B

So right we're talking about this, um so the first example.

B

I really hate the uh way it puts.

A

B

Sign, why does it do that? It's so.

C

Annoying uh it does the.

B

C

If you have equal to- and I don't know.

B

I know, but it's it's very insistent on putting it there. It's like hard, not.

A

To put it there.

B

uh Okay, so so what is happening here here, we have a mutable reference to, and the full path is like star bx. That gives us star.

B

To go through the and mute dot x right.

B

Okay, let's do the next example before we dig into this and then your example um was a.

B

Immutable reference to.

B

B

Star t dot s, sorry.

B

That I just that um and the difference is, um was one other important.

B

B

B

I have to be consistent.

B

So the key point I'm trying to make here is that I distinguish these cases because in this first case both cases have a mutable reference.

B

The mode of access is sort of mutable reference right, um but in this case we have a draft of an ampersand mute in the place that's being accessed, but in this case we don't.

B

So I think in this case the second case.

B

B

So in the first case, we have a draft.

B

um In the place that is being accessed in the second case, we do not, uh and so my argument is basically that if we do have such a dref, we should not truncate and we should keep the mutable reference mode.

B

But if we do not have such a draft, um we should truncate and we should go to move.

B

Mode right, so I think we expect, at least by the semantics of rust today.

B

This closure takes ownership of tea and then mutates the thing that it owns, whereas this closure in rust today it does take ownership of bx, but the thing that's getting mutated. It doesn't own because.

C

B

To pass through immutable reference to get there, and that's the difference that in this closure, the data that's ultimately being accessed in russ today is not owned by the closure and just thinking more abstractly. The data that's ultimately being accessed is not owned by the variable that's being used to access it.

B

That's the really the case we're getting at the data ultimately being and that I think that's the distinction I'm trying to make.

B

And in the second case, the data being accessed is owned by the variable t.

B

So the idea was that, when we're accessing data that, through that we don't own or when we're accessing data through a variable that doesn't own it, we should borrow, and I think in those cases you will not cause compilation.

C

Errors does that make sense implementing this, it makes sense I feel like I'm preventing. This would be annoying.

B

Yeah, I kind of feel a bit lost about the global picture and maybe like we have a little time here. Maybe we want to spend a little time just like writing up the.

C

B

I think I think.

C

I think we should do that as a group. I started writing it and, like I think it gets far more complicated than I thought it was going to get.

B

C

uh Just because.

B

Yeah, I probably is complicated. So let's take a look, so we got, I mean the way I see it is go on.

C

I to me, I think the most generic case would be if the thing doesn't contain drafts, it's a very simple situation there and that is move. It's a move closure or uh was it called a borrow, immutably, mutably or uh depending on? If it's not a move closure and depending on how it gets used.

B

Yeah, so I think well before we go that deep, though the way I the model I have, in my mind, is that you analyze a closure c and you get a set of mode place, pairs that are accessed.

B

Mode is and and mute or or let's call it reference or move. I don't know by value.

C

Do we want to include uh unique immutable here, or is that part of rough mute.

B

uh Bother: okay.

C

B

Hey, let's just include it, but I don't think it makes much difference um and then closure mode is sort of ref or move.

D

B

um And the output yeah, so this is the input.

B

And the output is.

B

Basically, mode place pairs that are actually captured.

B

B

So now, let's see consideration so first thing is before we get into this stuff. There's already this minimization step that was going from like if I access.

B

B

This ordering is wrong right. It should be probably like this.

D

C

Yeah yeah, we can just say this is the strict week or like yeah at least too much that works so.

A

C

Yes, I think the combination step is at the very end and that we don't really that that we can just do later on, like the common. The minimization step has a is a yes.

B

So let's do this.

C

B

C

B

B

Places like m1, p1 or yeah, okay, m2 p2, where p1 is a prefix of p2. um We basically want to remove both places and add max m1 m2.

C

B

To describe it in this weird way, uh but this is like this is sort of the formalism. I have in my mind that there's like a series of rounds where you take things out, and you put things back in uh and in the end you get to a fixed point and you're happy.

C

Yes, uh yeah either we can stay applied until this cannot be applied uh until the set has no p1 p. To says that p1 is a prefix of p2 or you start with an empty set, and that, like it, comes to an implementation detail after that. How you make this fast, but yeah.

A

The stopping point.

C

Of this is no two entities and.

B

B

It's actually I'm just remembering that there's a nice, I forget what it's called.

B

I have to look it up, but there's a prologue like language that has this as its basic model, take things out and put them back in and we could try to model it later on and no no datalog is different, uh but um I forget what it's called tuple space is one thing that works like this, but there's another one uh point being: if we get it properly done, it would actually be cool to try to specify it in that language and try it out test it, um but uh the I'll think of it later.

B

So the next thing is right. So we've got these rules around mutable references and moves. We have to take into account move mode now. So how does move mode move mode play in hey.

C

B

More closure, sorry, I mean closure.

C

B

Yeah, let's call this access mode and we'll call it closure. uh I mean closure mode where to move so I'm contending that.

B

I think move closures might be a first pass. I'm trying to remember how we ha I know we went through this and I don't remember where we landed, but I'm thinking of it now as move closures, are a first pass that mutates.

B

Like something like, if this is a move closure, then it kind of goes for each mode place in c um and we're going to map it. Basically, let's call it map each mode place in c, so we say basically, if the place contains a draft of an and mute, oh and and it's if mode is and mute and.

C

I think I like the idea of what's happening here, which is nicer right now,.

B

B

Or I guess it's like else or if this is really else, if um else, if place contains a draft.

D

B

Well that, because it doesn't really matter, it might not be a bff box, because the mode might not match.

B

Truncate, just before the draft capture, the pointer.

B

Let's call that or like let place one equals place truncated just before the draft. uh Then we add move place, one to c prime or something.

C

Yeah, this is looking farsi.

A

And then it's like.

B

Else add move place to c, I guess, and so here now, if it's refmute, I think these are the ones where we actually want to keep it just the way it is. I think.

D

B

This is probably refstar.

A

B

Think it matters it's going.

C

To be an error.

D

C

Me one second.

C

Let me think, if there's an edge case to.

C

C

Like I feel like the edge case to this will come only around when we are trying to return the quarter out anything else, but the point you made about, if the closure, if the root variable owns the data or like the way you're accessing to the root variable, ends up running the data versus not so right really define what you should do.

C

So if you have any reference of uh there's one more, the first scenario is then.

C

Then there's the unsafe and some uh all those.

B

Situations: uh okay, yeah: let's come back to that in a second um you're right, though, let's add that to the xxx unsafe. um So I think the other thing is if it's a ref closure, we have a similar bit of logic. To this, that says, if mode is move and place contains a.

C

B

And you're right about the unsafe, I think I think that comes in.

B

I think that's just here, and I think it that, like.

C

B

What happens at the very.

C

End, it's like yes, okay,.

B

I think it kind of doesn't matter where it happens. It happens somewhere. Oh yeah sort of like.

B

uh I'm just gonna write this.

C

It's situational.

C

It's just a little situational because you want to make sure I one of them applies in the scenario of I remember. uh One of them applies to only borrows, which is the taking a reference wrapper pack filled in at upper backdrop.

B

B

um Okay, so that might want it to come later, because.

C

No that's the first thing that happens the moment we see we have uh we're, borrowing, something and the what we're borrowing is of a wrapper factor. The reason we do that early on is so that, because it is possible that someone moves the same data later on and then does the and we we decided.

A

That we wanted to.

C

Avoid that, like like, if you look at the bottom of the file I'll write, something which is uh something like print uh a dot dot.

C

So in this we have talked.

C

C

uh What we had discussed was not capture pack.x by.

C

Like that would be the end result, but this would have been what your capture is.

B

So, let's do it: let's go through.

B

Right, so we've got some examples now, uh okay, I don't. I think we don't want to capture.

B

Because we want it to be unsafe, if we moved out of pack.x, it would actually be correct. That's safe to do.

C

Yes, but the access to pack.- yes, but we what we decided was. We would do this, which is uh graph or background yeah.

B

I'm trying to remember.

C

B

I think it makes sense, but I think the reasoning was like I.

C

Think it was just consistently.

B

It was more predictable, adding in the move.

C

B

Changed the behavior yeah okay. So why so key point here? This is an example of this is like um I don't know.

C

Nothing to unpack.

B

Called packed field ref and move when.

C

B

Have a closure that both references, a packed field which is unsafe and moves from it, which is safe. We.

B

Capture the yeah, um just the entire struct, rather than just moving the field. This is to aid in predict predictability so that removing the move doesn't make. The closure become unsafe.

B

This is really like.

C

Right, yeah, it was supposed to bring lambert. Yes, that's I think, just easier.

B

It's easier to see it that way, so how does that play out? That's why that's why we have to do this early? I think.

C

B

C

Did it early otherwise you'll lose contact about this.

B

Yeah, okay and then I think that comes out correctly from this algorithm as we wrote it. Let's look at this example.

B

Box mute, I don't know whatever so here, the c or the closure mode is move. Obviously the set is going to be just one member really, which is mute, ref or ref mute. However, I called it uh this guy and we're gonna.

B

um We're gonna pass that through the first round. I really, I wonder how I don't know. I don't really know how order sensitive these things are. I wonder if you can just put them all in one big bag, but anyway, we're going to do. C1 is like uh yeah.

C

B

This is going to change it, but we go to this rule, so we keep it the same. So basically we're.

A

Just going to keep.

B

It exactly the same. That's the output output.

C

C prime equals c yeah yeah yeah, like on the surface. This looks so much simpler than what our implementation is just based on, like I know where, like like, the different handling of move and stuff happens,.

B

Yeah, so the question is: why is implementation like more complex than this.

D

C

uh It could just be that I didn't realize this could be this simple.

C

It is I I think I know why this is okay, so I know uh why our implementation is a little different just because, if we think about this, this has three sort of okay. So this has three sort of passes. One is the collection phase, one is the apply, the rules phase and the third is minimization, and I think what we had initially talked about. While we were doing was like we can apply the rules on the fly yeah.

C

As we see the data- and I think over time, with all the different exceptions we found it just.

A

C

Of a uh just um mismanaged sort of situation so might be a good time just to rewrite this.

B

So I think we could do this in two passes for sure right, which is, we could say, we could say clean, cleanup and truncation, which is basically generate c, prime, by mapping each mode- and we start with this say: unsafe checks.

B

Oh well, I don't really want to add it right away. Stupid, mathematics,.

C

Yeah, I think, on subjects right now happen at the pretty near the end.

B

Right, but what I'm proposing is, I think, in the code itself, we sort of have this structure right. We have the first pass that like does the expression, use, visitor or whatever and and builds.

A

B

I don't think we should do any of this logic in the expression use visitor delegate like I would rather generate.

A

B

Simple list of where, like it says here, exactly what it accesses. No no.

D

B

No funny business and then and then do this, then we just do one iteration down through. We just do a map where we truncate things and we get a new set, uh and then we do a um yeah.

C

And then we do the minimization.

B

C

Yeah, so the reason also we have this a little bit of weirdness is because it's sort of like, I think what I inherited from the previous uh like 2018 version of this code, which was move closures, would have certain degree of just like uh things like the initialization for move closures happened early on than later.

B

C

So I tried to kind of keep the same situation where, whenever we initialized for something we would initialize using.

A

C

We would account for move four years early on and uh yeah. I think this can be rewritten and.

B

I think yeah. I think that.

C

B

Just is not very good yeah.

C

It's not feasible anymore.

B

Yeah, so here's my, uh I think this is the way I want to formulate it uh three helper.

A

B

C

Wait a move from should account for.

C

A move x from as in case of multiplier, I see.

B

Yeah yeah yeah yeah and then hold on I'm going to do this, but now because now we're going to do the map, it's going to say, like you know, mode one place, one equals unsafe check mode place.

B

If this is a ref closure, add ref x, form mode, one place one two c, prime else.

A

C

Form trying to remember or like think of this has something also to do with the fact that um how you would handle different modes just coming. I don't think that has something anything really to do with it yeah. I think they should be fine.

B

I think this will work um yeah and then minimization.

C

And that's just yeah minimization is just complete.

A

B

What this does is basically, the logic here is any.

B

We truncate accessed paths.

B

We yeah we ensure unsafe accesses, occur within the closure.

B

That's the idea, and here yeah: we closure takes ownership of data uh if only.

A

B

Accessed data is owned by the variable used to access it.

D

B

Closure takes ownership, but only of the data on the stack frame of closure creator and then else.

B

um Closure borrows.

B

Closure borrows data, and it's no notably you can't. You can't take ownership of data, you don't own. Anyway. That's a read uh like if you move out from something that's in a reference. You'll get an error anyway. So it's fine.

A

That makes sense.

B

Actually, what the closure does like.

C

Just thinking well, I think this is missing. One point which says uh like: if you it is possible that you're trying to move data out of a reference, but the closure doesn't still own the data, so you truncate to the pointer. I don't think these two lines express that unless I'm.

B

Well, yeah: it's it's you're right that if you try to move out from data you don't own, we will truncate it. You'll get an error later.

D

B

uh Right, like borrow checkers yeah,.

C

Yeah I realize that, while writing the reference that I'm pretty sure, I'm handling that case, which is just actually just an error.

B

C

So yeah there's a couple so.

B

That's kind of if, if that, if accessed so basically we're saying if taking ownership.

B

Of data or borrowing data owned by the variable used to access it, closure takes ownership of.

A

Yeah, like this.

B

It's kind of complicated, but that's what it is.

C

Wait so do we really care about situations where we see a move out of a? I suppose that is still so. We see okay, so there's a situation where we might have to do a copy instead of a move right.

B

uh uh But copies are copies, are treated as no.

D

B

Data, it's a ref, so that will be a ref right right right.

C

Yeah yeah suppose the new version doesn't really care about data being copied anymore, like it just fits into the model yeah, because.

B

Earlier they would.

C

A

A

B

Yeah, so this would be like this, this one's a little bit complicated. It's basically take ownership if.

B

If closure moves, the data out or the data being accessed is owned, it's I kind.

A

B

To keep this simpler, if data being access is owned by the variable used to access it, um I don't want to cover the error case because, like.

B

I'll put it in parentheses,.

B

um When taking ownership, only move data from enclosing stack frame um or like only capture data found on the stack.

C

D

C

Try if I write so, I think this may or may not be important, but so, when you do, when you see a let x equals y, let's say in a failure and y is a copy type.

C

I think uh experience visitor tells you it's a bi-value use.

B

I don't think so. It might be right, though I don't really know.

C

I'm trying to remember I'm trying to figure out why certain pieces of the previous chord existed.

B

Let's look um because I think I thought.

A

Let's see copy or move, oh, you might be right, it might do a consume with a mode copy. Okay,.

C

So, which would mean that we would see so now if we have a scenario where we have a reference dot y uh like let x equal, some.

C

Uh-Huh reference: in that scenario, we cannot, we cannot actually move or take a reference to ref dot x because we might like okay, let me write this out. It might be easier, but.

B

I think we treat that. I think we should treat that as a ref, and I think that the code does that somewhere else.

C

uh Let me okay, let me write this out one second and see. What's uh like, I don't have a complete picture in my head, but I want to write it.

A

Out so I get an idea.

C

Of what's happening so we have, let's see.

C

C

Something like this and then it returns c. So what the closure will see here is x, dot x is a bi value use and let's just say this is a point and a point is defined as x. I thirty two y, I thirty two.

C

So we have this right now we see that x, dot x is a y value uh based on the algorithm. That is right. Now we will see that it is a move of a draft. So it's not.

B

A rough mute, it's.

C

Not this is the most power here, which is an order. We.

B

C

B

We forgot the optimization.

C

Yes, oh, I suppose, yeah I was going for optimization just being outside the bottle, checking out chloe. You are a little bit fair enough.

B

I think we should represent it.

B

um This is like capture, ref, borrow or capture a reference and not data. It owns or something I don't know.

B

I'm just gonna put this xxx for now, but I think this is the last step right uh like we do that as a final pass.

C

Well, no, that is the first thing that happens because, again like what we discussed was we want to do this as the first thing as we see here, but can be the last thing as well.

B

Okay, not sure.

C

uh I don't think either australia matters.

B

It probably doesn't.

C

All right, so if we have yeah so we have this and I think yeah, we will end up capturing if we apply the rules after rules, we capture x y value, which is fine.

C

Yes, I think it's correct.

B

um I'm trying to think what we actually want here so yeah.

B

Because another example might be.

C

I think right now, though, it might.

C

Exit.X by value, which is also not wrong to.

C

C

uh Wait, that's the.

D

B

C

One second, I'm just running this to play around just to see what the current output out of this is.

C

I have feeling it might do.

B

I'm trying to think what am I, what is my? What am I trying to prove with this example? uh I think if you.

B

B

I think I would like these to work yes, but that, but this is a ref mute access.

B

This is just gonna work, because you're gonna get the ref mute and it's gonna see that it's a draft of x right, um but if you did okay, so this is the this is a better example. I guess, if you just look at this example now we have a read from x and a read from y and what could happen if we move x we're going to get a compilation error here, because x can only be moved once because it's the ampersand mute?

B

C

B

What I would sort of, I guess even more interesting, would be like this one yeah. I think that this example ought to ought to be like ampersand star, let's rename this from x to p.

C

Yeah, that's yeah. That was a bad choice, so.

C

So 12 is behaving exactly as what you wrote right now like what do you wrote right now, yeah.

B

That's what you get today.

D

That's what I got today, yeah.

B

I think yeah no and I think that's. I don't quite know why that is. But I look: let's look at one other piece of code. I guess where's the up for our code.

A

C

Yeah and not this because we, I remember, handling tire specifically and they move things which can be handled later on without making it more complicated but yeah, it's pretty short. So, okay, can you share your screen for that? So I know which part you're talking about.

B

I am showing my screen.

C

Oh no, I was looking at this sorry. Yes,.

B

C

So let me explain where this is, so, if you look at line 1 357.

C

B

A

Where we see oh.

B

A

B

C

A

C

Of a yeah, so that's a copy type, so there's a move code here, it's a copy type that you're moving and the draft is of a reference. So we just return as is, and if you look up the function called init capture info. I think our init underscore capture mind uh it is. It would have initialized the place by uh by a reference, uh so this size of yeah and right, the the. So this is inner capture kind. There's another function which is like line 1576 that gets called.

B

C

So if you look over there, uh if it's a move, closure and all the dereferences are of a reference, uh then we initialize it another f. So we take a reference to that.

B

Yeah, so, okay, what I'm just trying to figure out is if it's a move or if it's a copy, is that, should we just treat it like a ref all the time, I think maybe.

A

B

I'm trying to come up with.

D

B

Where it does the wrong thing.

B

And I don't like I'm, I know that in you know, if you go to code today, like suppose, I have.

C

I'm just going to take how I.

B

B

If I just have this copy type here right and I try to return something that uses it, this is going to give me an error.

B

um Yeah, you need a multiplier there right and so the point being we're treating it as if we borrowed it. Oh println isn't the best example, because println actually does borrow it.

B

But I think here.

A

B

Also need a move closure unless I'm totally mistaken, which would be yeah yeah. So, even though this is a copy right, we treated it like a borrow, so I think we can just treat copies as refs, and that means in terms of our description up here, I to actually change this to move, and I would say note by value, use of a copy type is considered ref and I think that'll get us the right behavior, um because if it's a move closure we're going to change that ref to a move.

C

So should we should we add a thing which basically like before we start our so there's a thing where you, the cleanup and truncation, I suppose part where you have.

C

uh Maybe maybe we should add that if it is a like basically have a helper function from like completeness of the algorithm perspective, where your place, dot type is a copy type and mode is by value, it converts it to place dot type and makes that into a rough. So that's the algorithm.

B

Sure I yeah, I change sure, that's not a bad idea. I had made this move, but if we make it that's yeah, that's probably better. Okay, let's do that. This goes back to by value, and then we say.

A

B

Copy type, uh it's basically if mode equals, pi value and type of place, is copy.

B

Ref place return else, return mode place, place.

A

Yeah that makes sense.

A

B

Sure um and then we can just sort of throw this in there.

B

And these places where we wrote move, we really meant by value.

A

Wait message mode: no, this actually meant mode. This is that's a subtle. It's a subtle point.

B

uh Or did it mean move? What did it mean for plays.

C

Now that that's a mod, that's mod, that's mod.

B

Yeah it's mode, whereas here is actually by.

C

That, nationally.

A

A

This and so is this, and then this is mode only. It should be returned. Okay, yeah.

C

Yeah, all of that.

D

I, like the simplicity, yeah yeah,.

B

Yeah, I think we could actually implement it this way right. This is not like wildly inefficient. It's perfectly reasonable um yeah. This.

D

C

Put it here in some sense.

B

I would this by the way. This is exactly what I think would be night. It would be great to include in the reference.

C

I think we can just force it out of this.

B

Basically, just copy and.

C

Paste this into the reference.

B

It was fine, it's good enough. um I.

C

I think I think it's like concise. I I like it's, there isn't really any shorthand here. It's like well explained and less complicated than the specification. I was thinking of writing.

D

Yeah, it's really easy to read too.

C

Yeah yeah, we had to write specification for our project and it was far more complicated and weird.

B

All right, I'm feeling satisfied, I'm curious whether we we should try to implement it and see if we encounter any weird behavior.

C

B

C

B

Implement it today.

C

And see how wait I don't have anything else, spending other than this right effects. They should fix one of the bugs as well, which is the.

B

Only other thing was the dash z closure size, flag, working with 2021, with really think we need especially.

C

If we can close it, I don't mind closing it just like there aren't and changing the other thing that you pointed out to stand it out is.

D

Also, just pretty.

C

D

Because yeah yeah.

B

Especially if we're just going to use it for a crater run, then, and not really request people to do it, which is kind of easier for us honestly, then, uh and who cares? Okay, so, okay, uh yeah.

D

As long as it doesn't like totally high.

B

What was this reflection.

C

Oh, we were about to write that.

B

Oh, the optimization right, yeah, yes, optimization dome, borrow the ref, not data owned by ref. um So here we say if this is like: if mode is ref and place, contains the draft of an ampersand or something I'll. Let you if we.

C

Don't even need the more we we can. The mode is move, we can still buy value. We can still do it right.

B

A

Yeah, that's true. Yeah.

C

I I'll do this once the current reference. Pr is merge, then I'll just copy paste this as well.

B

All right well great! I.

C

B

Run to another meeting, thanks y'all I'll post.

C

That thank you so much.

B

C

B

C

Pause, this link and see ya.