Rust Programming Language RFC 2229 Working Group, 12 May 2020

Previous Meeting Next Meeting

⏯

youtube image

►

From YouTube: RFC 2229 Resync Discussion (2020.05.12)

Description

Discussion of RFC 2229 implementation plann

A

So what I figured we could do is sort of survey. I could talk you through this plan that I drew up and the context, and we can see where to go from there I try to explain how these parts of the compiler work. So let me first pull up.

A

Okay, you all can see that what yeah um first question I assume you all read the RC right. So we kind of know the general idea of what we're trying to do.

B

A

And how familiar are you with how the compiler and how the Russ language, but also the compiler, handles closures and things internally, nah? That's.

B

um They're close to zero I would say all.

A

Right so let me give a little like before we go. The RFC is saying: let's do like a.

A

Little intro into that I'll start with it's, not that complicated I'll start like sort of what they're like at the language level. So when you see a closure like.

A

Make some variables I have a fan of closure like this? What this winds up, getting compiled down to.

A

You can conceptually it's kind of a struct and well first I'll show it how how you might imagine it to be and we'll bring it down to more, like with the choir actor I.

A

Guess that would be an I-32 technically so.

A

Right so we're gonna kind of make a struct and that.

A

Constructing the closure is basically ya, be creating an instance of this struct right and then there's some involved of yeah. um This much I guess.

A

And so right, that's the basic model, but what the compiler actually does different.

A

It actually makes it does make kind of a struct like thing, but the struct looks a little different for one thing has and has this type parameter? You can't actually express this in real rust, I guess, but it has it has. It has some special type rumors in here, and one is a tuple like known to be a tuple which has for each of the captured variables XY.

A

It will have their type in there. So what that means is that.

A

The type would look something kind of like this that make sense yeah.

A

There's various reasons that we do it this way, but it is just kind of how we encode it um and then the other type parameters actually I'm gonna pull up the rusty Forks here, the other tech rameters encode. Other information about this.

A

And I'm assuming you're, not that familiar with how rusty works either uh no yeah that particularly just I'll dive in the middle and then I'll pull my way back out. So this is documentation. This type closure substance.

A

It's basically, let me just throw in this link here. So it's easy to find later. This basically defines the customer utility functions, we're working with the substitutions of a closure and substitutions means the value is provided for the generic arguments. Alright, so I, guess these! These types are the closure substance.

A

A

You can see there's this list.

A

The interesting ones will ignore this first set anyway. There's because these basically three parameters, three types, the closure, kind, closure signature and these types of the up-up variables is our name for captured variables and the closure kind. Is this really happy thing where we just we use like a number? So we want to record if that closure turned out to be basically which traits it turned out to implement, and we do that by encoding.

A

I, don't know, I, think I, don't know what it is exactly but like FN is I ate and FM you desire, 32 or something like that. It doesn't really matter. Okay, so I, just kind of records for us what things the closure implements and then this encodes, the closure signature. So the actual type would look something like in this case the closure signature. It doesn't take any arguments right, no and it's Vimes gonna call this I ate or sorry be like see.

A

Kc is the actual type here would be like I ate, maybe or whatever it is. That says it implements the F entry and then signature, and then the types the imperialism so that that's kind of how the compiler encodes these types internally. But you can see it Maps pretty closely yeah the other one yeah umm and.

A

What we are going to well, let me just explain a little bit more about fish. What this closure subs thing, how that works in, so just to show you where this comes up in the compiler, when we represent the types of things we do it with this. Okay.

A

And there's a bunch if you kind of skip through to the kind you see. These are all the different kinds of types in rust and one of them one of them is closure, and so each closure has a def ID. That's just a unique ID that we give to every definition.

A

So this type would be an instance of tie closure or tie kind closure rather ID would uniquely identify. You know this expression. Basically.

A

Alright pulled off in another window, the ID kind of identifies. Oh, it came from this expression.

A

And the substitutions are what I just talked about so sub stress. Those are like the list of substitutions the list of type parameters, and you can call as closure.

A

To sort of view them as a list of closure substitutions as opposed to a list of substitutions for some other kind of type, um because that same type sub stress is used for all kinds of things. So that's how the compiler represents closures internally and I. Don't know why. Let's see how why I chose to start it there well now, what I want to say is basically what we want to change here.

A

Right is the other part of what the compiler does is. It has to figure out couple things that are gonna have to change if we're gonna implement this RFC. For one thing, we currently do some analysis. We assume that there's one this tuple has one type in it. We basically assume there's one field per local variable that we access and therefore the tuple has exactly one entry per local variable. Then we access right and.

C

A

Break that Association, because we're going to have to you, want to support you know if we had got a closure like this.

A

Yeah we now want to have basically one of these trigger this. So then, instead of capturing the two bullets capturing these two fields in the tuple, that means we're gonna wind up with.

A

You know wind up with.

A

And the annoying thing is, this is very apt to fit you a little more about how the compilers pipeline works. Another thing is that this information is not gonna become available.

A

Until relatively late, you think so I just had an idea that all catalog for leader.

A

So the way that the compiler handles closures, snip and just in general works is during type checking.

A

So when we let me type check a function, we when we see a closure expression, see if I can find the code where this happens.

A

A

When we see a closure, expression will lined up invoking.

A

Check expert closure, but we're not expected the idea of dumping. All these details in here in case, it's not clear, is just that stuff. You can follow up on later, have some survey of what's going on the ideas when we see the closure expression, the we type check it and we can kind of figure out its type and we actually don't know a lot of the details yet so you know currently we know that it's gonna have. We know how many before we do this change.

A

We know how many up bars there will be, but we don't know their exact types. The reason for that is, we need to do this analysis.

A

Which we call the up for analysis to figure out how they're captured, which depends on how their years within the closure so like in these examples, we're only reading from them, and you see that I captured them by by reference yeah, but if they were getting moved, we would have captured them by value. If they were getting mutated, we would have done a mutable capture and to figure that out, we kind of have to know you kinda have to know the types enough of the types to figure out what's going on.

A

So let me show you what I mean like if we had an example like.

A

Was the other vector.

A

When we have a closure, it's calling vida push. If you don't do until you run the type-check, you don't really know what this method push. Does it might just read from thee and it might ask or it might move it don't know. You have to look at the signature to figure it out.

A

And that would tell us that, based on that, we can see. Oh actually, this closure needs to have a mutable reference and in fact we also also know that.

A

We know so that tells us like.

A

This is called the upper analysis. It would basically tell us that V is captured by an mute reference and also well. This isn't that relevant at the moment that the closure C implements F, mu, F and once.

A

You know what make sense.

C

Boys plays a both F n mute and F n. Once okay.

A

Good question: the reason is that there's a kind of hierarchy here so so you've got you've got the three. The three traits write. Fn means you can be called many times at once, so to speak, for the shared reference.

A

And that's because that's because you, you only read things: yeah.

C

A

You kind of be able to be called from as many click from up from a wide variety of places, because you do very few things. Fn mute means you have to be called with a mutable reference, because you mutate things, and so in this case you can be called from fewer places because you do more stuff right and the interesting thing about this is that if I have something that implements FN that only read things, I can also treat it as if it was FM, muted right, because I'm, basically being more conservative that makes sense.

A

I can call it I can say well. I could have called this from a shared reference, but I have a mutable reference and I'm going to use that instead, an FM once says I can be called at most once because I move things so I'm kind of phrasing. This a little confusing that I guess. But my point is anything that implements FM also implements FM: u + FN once because, if I could call it many times, I could surely call it just once. Ok,.

B

That makes sense and.

A

Similarly, here so it's always, it's always kind of you implement that one and all the ones below ok, but so we do this analysis and it tells us what they do and the way that we handle that in the compiler.

A

Look, what that means is there's a phase there's a period of time where we don't know Oh what traits that closure implements right. We know they're.

C

A

Of the function traits, but we don't know exactly which ones and we don't know it's full all the types of it's up bars because we don't know if they're by a value or not, and we have a period of uncertainty.

A

And the way we express that is, we have this idea of influence variables, not the term you've heard before.

B

Is the idea to use them like some sort of server graph and C++ that they get resolved later yeah.

A

Basically so it's kind of the key building block of type infants right, you can create an infant's variable and it represents some type that you don't yet know, but that you'll figure out later, as you type do the rest of your type checking. Hopefully right and until you figure it out so infants variables have two states.

A

They start out, unbound, meaning you don't know what it is and at some point they become bound where you you now have assigned it a value and then it never changes again and so what we do for the closure type. You know I mentioned they have these these various variables so for a closer type, some of the values in its substitutions are variables. The way it works today it would be like. Oh this question notation is just.

A

Means infants variable like so you would start out with this is how it works today. We kind of this is what we know when we first create the closure. We know that it I'm not very much. We know that it has some kind, but we don't know what it is. It's some signature, but we don't know what it is. But one thing we do know is that it has a tuple of a certain arity. We know how many up bars there are all right.

A

That's that's true today and that's what gets expressed there and then what we'll do is later.

A

So those those clues, those inference variables remain unbound until the up our inference runs and it assigns them about. You know.

A

Basically, well after we've analyzed the body of the closure, and we saw what it does this, this will run after we've done all the tech points. So we know everything now we know what push is and then we can figure out, for example, that we need to assign this value. That is corresponds to FM mute and we have to assign this value for an n mute capture right. um That's kind of the idea.

B

How are how do we actually calculate the size of like the upward couple, because can we not just modify it to not actually drive um kids apparent that actually owns members? If that makes sense,.

A

Yeah, so just to be clear or I, think you're, saying or one of the things we're gonna have to change in case is we're not going to know who big these people is until we've had do the analysis.

B

Yes, but how do we know the size of the tupple today before we do the analysis, because what I can see the user still does not actually provide this any information to figure out the size so right, yeah, it's a freaking yeah.

A

Now, the way we know that today is that we haven't, we don't need before we do. The type check.

A

We do name resolution it looked and we've seen, which local variables that make sense is it reference, and so we have that information. That's a very good question and we have that information in this query: upwards. Okay, I, don't know if you know what a query is: I.

B

Think you had that in your on, so we looked it up a little yeah.

A

I did so quick yeah, so the query is basically just a lazily executed.

A

Here's the query, and so when you invoke up bars, what it will do is it will analyze the body of the closure and see which local verbals it references and it gives you back a list, so it doesn't need to do the type checking.

A

B

So I guess my follow-up would be so when we see a local variable as access- and let's say it's: do we at that point figure out like I assume we do that it's actually a member of a local variable, then actually a local variable itself. If that mean what I'm so, instead of having like, let's say, P dot X like like over here when when we are doing this name resolution like what we see in court is actually that we are accessing P, dot, X and not be so.

B

Can we just not reduce the amount of work we do to figure out which actual local variables owns a number figure out the length.

A

Of the right so I think what you're saying is I understand. We could- and you said over here- I guess maybe you meant like in this example exactly you could see that there's 2.0 and tuple dot, one. Yes yeah! That's true! However, there are some complications.

A

Here that was kind of this dummy fuels. Let me take all that question for one second, okay, why do we not know or why can't we figure out how many elements.

A

By syntactic analysis.

A

Well, I'll answer the question, but I think the answer is: maybe we could, but there is one complication which is sometimes.

A

One problem is that there's different aliases there like different ways to spell equivalent pads. We might have something like suppose you have a variable who has the type ampersand mute, 3232 or something, and then you closure.

A

A

Make a better better, nested, tuples and I have a closure that accesses star, V and I, don't know: V dot, one dot, o and star V dot one dot. One now like.

A

All of these are actually based on star V yeah. You can't see it here and you only know that after we've done, the type checking we've kind of figured out o V is a pointer, so actually there's an auto D ref yeah.

A

No one problem is yeah. We don't know.

A

Yeah and we prop- ideally, we would only capture start IV, yeah yeah. The other reason which is similar is that there are some limitations around draw. If I have a struct, it has.

A

Move out of that struct in rust today, like you, can't move out of fields of that struct, because if you think about it,.

B

You either be structure the whole thing or you're done right.

A

Yeah right because, like how am I gonna run the destructor when some of the fields aren't there.

A

So now, if I use a closure in rust today, that's that's fine because well not drop X tubby, but maybe XIV dot, LAN or something yeah, because let's make this a move closure just to capture X, but we might want it to or if it didn't implement drop. You probably would want to capture xiv, but it does drop. So we probably want to capture X and we can't really know without knowing thanks.

B

No, no I. My question is more like when we do our first pass before we do any type analysis. Why don't do basically capture all information that we can from the poacher? So basically we are over here. Okay, in this example, we just say: okay, we will be capturing extra V, dot Len and we have okay, I guess. My point is more on the fact that the number of variables that we capture at, like just from a syntactic analysis, will always be more than then.

B

We actually need to really capture yes, so so we can use that to capture more information early on and just sort of reduce that information in a smart way. Once we actually have the types. What.

A

We could do that's what I meant by dummy fields. That's exactly right. We could we haven't, we could figure out an upper bound and we could make that many elements in the tuple, and maybe we don't use them all and we just make them unit or something yeah.

B

Basically, yeah.

A

We could do that, I, don't know. If that's really gonna make our lives yeah, it might make our lives somewhat easier cuz. That was one of the first steps that encouraging to do was to it's like it's, not that it turns out. It's actually not that hard to not know.

A

We could do that, but it would be less nice depending, although that might not be true depending how hard it is.

A

It's basically assuming we figured the way I originally was expecting, and the only thing that changes is that, instead of having a tuple of infant's variables, it's now just an infant's variable and in fact it sort of removes a special case, whereas before we instantiate everything with infants variables, except for this one I'll show you where that is in the code. Actually, this is the code that creates it's kind of complicated, but they create it. Creates that you should. You can see here it says somewhere.

A

Where does it do that? Actually all right? If, if it's the one for up verbals, then I make a tuple, otherwise I do this in some ways the code would be nicer if we didn't have that special case.

A

But, on the other hand, if it proves to be a pain in the butt, maybe we just they go I think you're right that we could upper bound it. It's not defecating yeah.

B

Basically, if you go online in 96 or I, guess what used to be lame? Can you scroll down no, no back on the Yammer done, I think around my 96, so yeah 96. Basically what I was thinking was we just captured that we're capturing star, V, V, dot, one dot o and star V dot, one dot one and basically, then we can reuse that list. Yeah.

A

I think that's right, so we could. We could get some upper bound from syntactic analysis.

A

So you, like you, said in the case of in the first case, we would guess we captures wind up with only one and unify the other two variables with unit.

A

So where was that anyway, so I guess what I was saying is in terms of the plane and let's go back to the plan. Now we've kind of got the.

A

There's some things work today: I do the first step is going to be, and this is true, regardless of how we handle the size of the tuple, essentially that there's a bunch of code that currently uses that a farce query to get the list of up bars and that code should all change, because what we want to be doing is producing type checks should produce a list of captured pads and we want to read the output from Ted a check instead of reading this other query that doesn't depend on type check at all right and so what I?

A

What I kind of described here was. First, we would rename the query to like raw up far as there are syntactic, afar's or I forget what I called it yeah and then, and then we can kind of go through and just it turns out that, like the actual format of the data right now is the same. So it's a pretty small refactoring we're basically we've taken quality is very imperative to this part and should be should work more or less, but then the advantage now is.

A

We can change the structure of this of this patch map and we'll have to refactor those more general.

B

Wait so so, like very, very chaining, the query like what are we actually query, so you froze for me Oh Unni, scroll down where you actually change the query like so what what the for, like what originally it was doing with it will return to the list of our parts for that closure does defined by that def ID mm-hmm.

B

Now. Are we planning on storing that type like this information directly in type check tables, or do we still want it to be associated with, like the closures itself, because I'm not sure how type tag tables work yeah.

A

So so what so? What is Technic tables type check tables is basically the output from type Jack and writes the type of every expression and a bunch of other bits and bobs of data. That type check figures out like how many Auto D reps you get at each spot and stuff like that, and one of the things that it contains, which they're added earlier there's a list called a parts list.

A

A

So one other thing: I should explain when you get the type check tables you don't get. The particular.

A

What you're actually gonna get is the tables for the enclosing function. Item okay,.

C

A

We scroll to my example.

A

Now, all of these, like these closures, are actually embedded in some.

A

And when I asked for the type check tables work at the level of functions like this, okay.

B

A

When I and that's because so when I asked for the type check tables for this, I actually get the type two closing function.

A

That's why you have a map here that goes from.

A

From the Deaf idea of the closure to a list of up bars used by the closure, okay, there were more closures.

B

Okay, so if I, okay, again, let's say, can you go back to your if a very heavily pattering yeah, so basically TC exit, type table or tables dot? Deaf ID is going to be the same for all closures that are defined within the same spot. Yes, like the first part, and the second part is just now specific to that very closure. Okay, I use the same deaf ID here, because not that makes sense.

B

Okay, yeah, it was yeah the fact there were two deaf ideas. What was confusing okay, it makes sense because of the same scope. The first bit is they're, actually the same or multiple entries and.

A

This is a query, so it's memorized, so you can just call it as many times as you want and.

A

Right so I looked over all the places that we invoked it a farz query and there's not that many, that's the good news and most of them I think, are pretty straightforward. The only reason they're the reason that things get complicated has to do with dependencies within the compiler. Basically, you can't have cyclic dependencies between queries.

A

All I'm computing, the type check tables I, can't use the type 50 for a given. You know for the same definite. No, the problem is these: these bits of code are these. Are these are exactly the code that the up for analysis uses the analysis to figure out which how the up bars are used within a given closure, and they can't use this query, because if they did well, that's the functions, they are computing. The result of that query.

A

Well, they move differently, but we can ignore them for now and pretty rs is annoying because that's the pretty printing code and that gets balled all the time from everywhere.

A

We'll probably just have to change how closure is pretty print, because we may not have the information available that we need to keep the current. Pretty printing, that's okay, because it's ugly anyway.

A

A

Think these yeah this just actually wants to be the raw up. First.

B

Is that just that's just the renaming and leave the dummy variable part are just.

A

Trying to figure out.

B

A

Are these basically the these? These four are all part of type checks. You can kind of see the name of their the crepe they're in, and so they probably don't want to change for now. Come back to it, but this stuff all happens, except for pretty printing all happens after type checks. So it's okay.

B

Yeah, how much of the work this part dating is parallelizable, especially let's say once we are done with the type track part like.

A

B

Just saying because you're multiple people, and especially now it co-ed pair programming, is a little harder sure.

A

I think I might note that I've never used it, but I heard the BS codes. Yeah I, think I mean this stuff can be done in independent PRS, like.

B

That's good: it.

A

Probably won't I think it would be worth like the actual PR here is not very long, maybe literally one line for each of these files, but it's a good exercise to do it because it kind of you know it gets you familiar with how PR the whole PR process, and maybe you've already done that this renaming. You know, that's also its own PR kind of orthogonal from these I suppose there.

C

Might be a bit like.

A

A

So the next step is going to be actually a more substantive change.

A

Because in writing a game tells birth is more complicated, but basically that's where we want to go and say: okay, now we have this list of up bars and right now what happens? Is we map? um Oh the here, ID? That's the identification of some expression within audio up. Our ideas like identifies a local variable in the outer context, and what we want to do is change this notion of a place and a place is a mirror term that we use.

A

We call it a place, it's kind of like a path, I think it's more common, like a dot, B dot C. But the idea is it's a place in memory. That's why it's called a place. There might be a field with the local variable, but it's some location and luckily there's actually already so we can't use the mere place because mirror is built after type check, but this other version of place, that's already been made for us very nicely, didn't exist. You last tried to do this work now. It exists.

A

And this is basically the same idea of this place, but expressed in terms of the here. So the ast based or the ast like I are the work we're using in type check and the structure is it has a bit which is like the start of the path? So that's usually a local variable right.

A

It could be an up farm, we're gonna um and then projections. These are like the dot b, dot c dot, whatever it's not as detailed as it could be.

A

Idea, a deer f, so you start out with like.

A

Even something like star V dot, B dot C. This would be a base. Local variable, V projections.

A

U F and field and field C.

A

And so what we want to do is we kind of want to refactor the list of up bars so that, instead of capturing.

A

My upper map, instead of mapping to a upper ID, it's gonna map to.

A

It's gonna map to a place, though, because that's just gonna list and right now the places will always just be local verbals right.

C

I had a question: how does the HR ID translates into def ID.

A

It doesn't oh there, it may not be a def ID for every year ID. The idea is, let me give an example to explain it. Imagine I have a I'll do it in here.

A

Def ID identifies like the top-level thing, and the here ID identifies something within a def ID and sometimes at the moment. Sometimes these things also have deaf IDs, which I'll explain like closures are a good example actually, but so, if I have this right, the function foo has a def ID, let's call it D and then this is actually like some ast, like or rather some here, hi which, by the way, stands for high level intermediate representation.

A

Okay, so that wasn't clear as I. Imagine you probably wasn't- and this might be- you know whatever a let statement with like a destination pattern that is X. You know it's some kind of some kind of tree, and each of these has a here ID and if you look actually at how your ID is defined, you will see that it has an owner which is the DEF ID and then, within that def ID it has a local ID.

A

So it's kind of like if this was D. This might be like d0, and this might be one.

A

So we want to remap yes, so we basically want to refactor this far this map so that the values are here places and that's well, I, don't say much more at this moment, because I think we're first of all running out of time and secondly, and probably dumping nothing of information on you for the time being. But what that's going to involve is and currently the only capturing local. So this is kind of an increase in expressiveness right now we can express capturing star, V or V of zero or whatever right and.

A

This will mean that we have to change a little bit of the code above to be more general, so like, for example, here in libera, see mirror build after you know, you all know what Mir is I've just been saying near, but it cooks me. You know middle.

B

And comedic representation. Yes,.

A

It is it's the middle and specifically it's like it: D sugars, a lot of the details.

A

Your matches reasonably closely to what you title, it's somewhat different, but it's pretty close, but the mir is, is quite a bit D, sugar and and especially around closures. This is true, so when you get to the mir level, this picture of closures that I showed up here where it's a struck field. This is exactly what you see in there. Yeah closer body is completely separate.

A

You know different, like different in a different mirror: there's a mirror for every function, body and I mean closures are separated out into their own mirrors, okay, um and so that that Mir construction step will read. These kind of currently is.

A

What's the local variable and what's the mode that I capture it in and then it construct this arguments right based on those two bits of information. What it would now do is say what is the mode and what is the place that I'm capturing so instead of just being ampersand X, it might be. You understand, x, dot y dot Z.

A

Well, probably, we would start with those things are always local variables. So nothing really changes, there's no deep change, but it just is more able to handle it when we generally that'll involve some amount of refactoring, because you have to make these data structures more general and we have to.

A

Write the code that can convert them into a mirror and so on. It shouldn't be too hard, but it's gonna be some some interesting work, so that's sort of once. We've got that far. Then. We've done a lot, but we're getting now to like at that point we're getting through the we kind of are able to do the optimization and I think will be. It will turn it on we'll be able to turn it on and have it.

A

Work and it'll have to be feature dated because it changes the semantics of some aspects of rust, most notably when destructors run and then we're gonna have to figure out like play around with, like I, would consider that a good end point to put it clear like in terms of you thinking of projects and so on.

A

That's not that the feature is ready to ship, but the future is ready to be experimented with, but then the next step before we can actually ship it is well have to figure out how we want to deal with those breaking changes, whether we want to them. In addition, if they actually matter or what- and maybe if we need to do any optimizations, because now we're gonna be capturing the way I described it, we're capturing a lot more.

A

We used to capture just the local variable now we're capturing potentially many paths from within the local variables, so the closure will get bigger. They'll have more pointers in it, it'll be less efficient, but more more ergonomic, and that might not matter at all, but it might matter in which case we want to optimize it. Somehow. That's all.

B

I believe so not like a program perspective like should drop, really change like when drop run, should really I guess affect the actual program like in, in the sense that, let's say we take the example like that you had earlier, where we take ownership over a vector or where we take ownership of like apart within, like a part of the member that we are gets destructed a part of the structure gets instructor would require the whole structure to get disrupted when that not aligned with the current implementation itself.

B

A

In the event that you implemented drop in light in this example that I gave yes, you still capture, X and not attach it's gotta be so nothing would actually yeah exactly a more interesting or more about interesting, but a more a different example might be.

A

Yeah so now in the in this code today.

A

Get being bending in this code today.

A

Today, see is dropped here and it drops to bullet yeah, but.

A

If, if we do this naively, at least when you move to ballsy row under this change, it will only move to compare zero and tuple dot, one will stay where it is and so two dot one will be dropped at the exit from this block.

B

Yes, oh so, within two apples we can draw entry separately. Yes, that makes sense. Okay,.

A

It doesn't matter for this, like this example, is a good case where you probably don't care you remember, it gets freed either way it gets freed a little earlier or later you might care, but you probably don't, but um but sometimes jobs have side effects and then it's very visible. Okay,.

B

That's fair so.

A

I think I think what we would do well, yeah I think my preferred plan would be that we make the change we change when drop runs, but we do it on an addition boundary and we warn people like if, if, when you're converting between additions, if we see the closure it would capture like it will change drop order and we probably look a little bit make a good heuristic like in this case. We might be change not make any change because we're guessing you don't care, but suppose it had side effects.

A

Then we would rewrite the code to insert it like this, but this is all for the next year to figure out. My goal for this year is that we are actually in the place to like that. We have the breaking change implemented, not the fixing change, let's start, but if you did that you know now we preserve the semantics of the program and then the user can come back and say like I, don't really care, I'm gonna delete that line, or maybe I do right. um Maybe we Adam fix me comment, yeah, whatever that's.

B

The whole point of vision, or are they just just like? We could have a compiler flag that just enables this fix up yeah.

A

We already we have that machinery for for for new additions us when we release trust 2018. We made a number of small changes like this they're kind of technically they changed your code, but you probably don't care, so we would make the edits for you and then you can.

B

Okay, one more question as to how deep an analysis we want so I can. Let me see if I can share my screen so that it makes it a little easier to for me to explain.

B

Okay, I think you would have to stop sharing transform, reduce your screen. Thank you.

B

Okay, I'm just gonna, actually other stand. Okay, I'll just explain my god: I would have to kill the session my own session. Okay, so basically, let's say so. We have within our closure. Let's your call to print point. So endpoint is our member. Like a local variables, a point will get captured and it will do its thing now. Let's say the print function, all it does. Is it only accesses point with P dot X? So it's point is basically an X Y I tell you to fear, so it only captures P dot X.

B

Now, in this case, do we want only P dot X to get captured or do we expect the whole point P to get captured? Let.

A

Me just share what I think you.

B

Can I send a message?

B

B

Okay, so I have okay. If you look at the chat, I send the whole code that I have in the zone chat.

B

Ii share the father's: oh okay, that I think.

A

B

So I have this here. So basically, I have yeah.

A

We can't no, we don't cross function boundaries, so in this case we would capture all of P. Okay.

B

Yeah, so we all need to see what okay, that makes sense, yeah an awesome, become way too expensive, otherwise, yeah.

A

A

After we complete this work, you know on my list of like things I'd like to do eventually is to enable this sort of cross.

B

Sorry, you can.

A

Completely cut out any can.

B

I repeat here completely cut out for me: I'm.

A

Just saying in the far future, maybe a few years- you know this is on my wish list. Okay,.

A

All right, I have to run to another meeting. I hope this was helpful. I hope, you're still interested.

B

A

B

No yeah I think we are I'll, still discuss this with my team and thank you very much. I'm.

A

Gonna post recording in the stream, I guess: okay.

B

A

All right thanks, thank.

C