Add a meeting Rate this page

A

uh Yeah, so I think we can go over sort of the quick step first and then get into the closure side stuff. I think it might require quite a bit of refactor and I just don't want to know, don't know too much about it. uh So yeah, let me share my screen or just send you the link to the blog post, roxanna and that were working on uh circumstances in the status think uh channel on zulu I'll, hear my stream.

A

That's on the recording.

A

I probably.

A

Okay, so basically, what no not one sec?

A

uh How do I? How do I get rid of these zoom thing that shows? uh Okay, that's where this works, so what we had talked about was we wanted to take the blog post and split that into uh post, like pages that will go in the last reference. So that's what we did. uh So we have two phases now which are now actually probably, this is easier. So there are two pages now that will go in the rough reference and then their blog post that will end up linking to them.

A

So the overall blog post now is just sort of a brief description that we talked about that we want to give about the feature uh and the fact that just give an idea that this this is going to be a breaking feature, so uh they're going to migration helps goes a little bit into water closures and really just ends up linking the rust book crossed by example and the rust reference, depending on the level of the experience the person has was reading. This gives.

B

A bit detail.

A

Into what this giant capture is and kind of links the rc, so that whoever cares about like knowing what the motivation is and all that stuff and the plan is over here, we'll end up linking the posts, uh our pages and rush reference, which, as one is there, are cases where what you like. The path is not captured to full precision and that there are minor breaking changes, and this is they're again documented in the rush reference uh details on using the lint and the that and and then.

C

Seems.

D

Good.

A

Yeah so and then just details into.

A

Each one of these cases.

B

um I'm wondering okay, can you scroll back up to the two reference pages? What's the difference in them, I see.

A

One gone sorry.

B

Well, the first one is changes to semantics. That's more like: when do you need migration, exactly okay? So this, I think, should also go.

A

In the migration.

B

In the migration guide, yeah and one nice thing is.

B

So if we put that in the migration guide, that'll be available immediately in the nightly links, the rust reference only contains stable things, which is kind of annoying. um I wish there. I don't actually like that. I think that's well, it makes sense, but it's annoying when you're trying to do what you're trying to do, because it means you can't link to uh to it. um But we could land this in the migration guide and link to it the next day via via a nightly link and then for the reference.

B

I guess we could link to a pr or something it's fine. um Okay,.

A

Make sense I I.

B

See why you set.

A

Up vr in the restaurants, now you have rocks an hour, a little confusion. Reading.

B

Yeah, that's probably why I said that um I do think it's a good idea. So scroll up um one thing: that's not in here under capture precision! Sorry, nothing far up.

A

Okay,.

B

I'm looking, I don't think this covers the case where you're dereferencing a reference we do talk about it uh here. I'm trying to see does that. Is that really all the cases? What about a box, for example,.

A

Okay, I can put a box example uh if you want that.

B

I think.

A

Like box and.

B

Rc.

A

Okay, uh I will, let's see how you add a comment here: okay,.

B

Like I guess, what I'm saying is there's a rule in my head, which is that a move closure will never move anything that wasn't on the stack.

A

um Yes, it is if a move closure will not move out of the reference is really what that rule is. So that is yes, we talk about it that uh well.

B

It's not only that this box is another example.

A

Yes, okay, fair enough fair enough.

B

I think the rest does fall out from capturing references because rc it might be worth adding a note about adding an example of rc. I would probably put it as like a it's, not a rule. It like is an example to work through, because, basically because what happens is the rc gets, the draft of the rc gets de-sugared into you know uh into this ampersand into this call to the draft method. So, from the compiler's point of view, it's a borrow of the variable.

B

So, like you know it's just using the existing rules, we can kind of.

A

uh Explain uh rfc.

B

I think the ideal for me would be like.

B

It's a move closure that borrows some data, that's inside an rc, that's in like a.b or something and so.

A

What winds up.

B

Happening is we, like you, can kind of show the capturing you can show a few things here right, like first, it de-sugars to a borrow of a dot b which maybe, if it's a move, closure that passes through a reference. I don't know. Maybe you can show that then the capturing reference and move context might apply in that.

A

Situation.

B

Does that make sense.

A

Somewhat a move closure containing energy, I suppose at that point we would also need to say box our special cases where the draft is.

B

I think you should just say have a section on move closures in box, because box is special right now because of d ref move.

A

Yeah, okay,.

B

But I think we would expect in the future that you know other kinds of moving would act analogously.

A

Okay, so yeah, this is basically split up. The blog post is kind of nice and small. Now.

B

Yeah, it's great.

A

Second thing we wanted: our discussion is related also related to the edition guide uh creator and that we were we're those discussions about uh so one thing that we have talked about was annotating the raw standard library with um insignificant destructors. So how do we want to go about that?

A

um Is there like what kind of formal process or a? How do we plan on documenting all of that b?.

B

I think this would also be good material to include in the guide um and possibly the reference. I think.

A

Is that something um is that just okay, sorry.

B

Well, I was gonna say what I would like to say is that we should come up with a rule of what we believe to be insignificant and for me it's probably freeing memory, so any any drop that only frees memory is a candidate. um Probably a good idea is to ping the libs team.

B

And see if they have any other suggestions. Okay, I will, I would yeah, I think some obvious candidates would be vec drop. Sorry, backstring.

C

And.

B

Hashmap kind of container types like that.

B

Yeah and then I would think that the next thing I would do is to there's two approaches: either we go through all the drop dimples in the standard library and we look.

A

For those.

B

You know systematically, which may not be that bad. There may not be that many or else we um another approach is we turn on the lint on the compiler.

C

And.

B

See what we get.

D

And maybe that'll.

B

Take us to some, you know, maybe we'll see something that we missed and say. Oh, that's, obviously not significant. For example, okay,.

A

Yeah, so I think that was, I suppose I don't.

C

Know the real questions, no, that would make sense. I think, okay, when we were talking about we're, also enabling.

A

Okay, yeah.

B

I think what I would do is um start with the easy ones the collections run, the lint on the compiler and see what you get and see if anything sort of jumps out at you as like. This is not just freeing memory, but it's uh still seems insignificant.

B

Sort of my goal here is like before we we probably do want to go through the drop pimples one by one eventually, but before we do that, it's probably a good idea to have um an idea what the rules are that we're looking for. So we'll have to do it more than once.

C

Yep so let's start with the.

B

Yeah.

A

I'm just gonna leave a note in our status thing.

B

Another one that you might find.

B

No yeah, I was thinking. uh I know that some of the iterators like drain or into.

D

It or.

B

Back into it or have you know, will free memory so that might be another candidate.

A

Okay yeah, so I love these knowledge.

B

I'd hold off on pinging libs until we do the first like until we feel like we have.

C

A good.

B

Good suggestion yeah and we can give them the data, I'm 99.9 sure they will agree with the basic idea, but no, I guess we could just let them know that we're. This is what we plan to do in case. There's any immediate objections.

A

It might be a good idea to get uh first, just we are planning on doing going with the strategy.

B

Right right.

A

Now.

A

Okay,.

B

They may have good suggestions. Oh.

A

Yeah um so okay closure size. So I looked into some of the increases that we saw and like one of the interesting ones were. Let me change what I'm sharing once I figure out how to do that.

A

Oh new okay, that works. Let me know if you want me to zoom in a bit more, which I probably should. Okay, so so the closure size went up from uh 40 to 48. I suppose you can go up there and I should probably also open the source file. Just so that's easier to look at.

A

So that was yes, this function, uh what gets captured by this function, at least from in terms, is uh so we're. Looking at this lawyer, which is over here, which is like which includes this nasty enclosure within it uh package id coin, filter unit for and uh self get captured by this lawyer what's interesting is um before the feature.

A

What got captured is this reference directly and same for, I think the function uh this gets captured directly. What gets captured after the feature is a reference to the reference and reference to dereference filter.

A

So when I outputted the types of these things, I see this double reference situation, because a reference is being borrowed by a reference in the original like three two to nine implementation.

D

Yeah I see and again okay.

B

Over here, okay, so.

D

uh

B

Interesting and what's this impulled on, is it impulled on state.

A

It's emboldened, yes, okay,.

B

Yeah, so the problem is that it's now a fat pointer instead of a thin printer.

A

Yes, so uh I do not know too much details about that, but what what's the difference is this just the size of the pointer? That's different now because function versus.

B

If you have a reference to a din type like ampersand in then that's actually two words. One is the pointer to the data and one is a pointer to the v table.

A

Okay, that makes sense yes,.

B

And then, if you have a pointer to a pointer to din, then it's only one word, because it's just like.

A

One word.

B

Yeah, so it's worth noting that star, like capturing star of a reference, if you don't do anything else afterwards, you know doesn't actually narrow the set of things that are borrowed right. So if.

C

Yes, exactly yeah.

B

Yeah because it's kind of all the data yeah, so you could certainly imagine us filtering that out sort of taking off any trailing stars.

A

Basically, like just to write it out, if we have ampersand star ampersand being capped well more like this being captured, then we can just reduce this to the ampersand. Whatever.

B

Yeah well.

B

Is that what's happening here right so you've got, I think you've actually got ampersand star star or.

A

I'm pretty sure we have ampersand star. I can confirm that real, quick.

B

Can you show like.

A

Yeah I'll show the adapter.

D

Analysis.

B

Because a single ampersand star is kind of a no-op, that's why but you've removed one level of.

A

Indirection, I think I cleaned right before this or I'm not sure what I did. Maybe people looking forward.

A

Oh, this is not with the feature enabled.

A

So, let's scroll up on my just have this yeah. This is this is I do have this? This is. This is pre feature, oh yeah. This is the post feature one. So a filter is being ordered by filter draft immutable.

A

Borrow oh, but our filter itself is an ampersand reference, ampersand star. um No, it's yeah! It's.

A

Ampersand.

B

Okay, so filter is an ampersand ampersand and.

A

We're borrowing, let me make sure filters, are ampersand or not.

A

I that was just an ampersand to a dent type.

B

I see no you're, probably right. Yes, that makes sense.

B

Okay: okay, okay, okay, I see what's happening so before.

B

Before right, okay, so here's the trade yeah, that's interesting, so we're adding a layer of indirection in exchange for a smaller closer.

B

I see yeah, I mean the way I'm thinking about it is basically I think you could remove any number of stars.

B

Like you wrote one there, but.

A

Like if this was a set of like star ampersand, star situation or.

B

No, you can't have more than one ampersand in there, so there could be any number of stars there, though.

A

Oh, I see right there wait. Is this valid.

B

That well, there would have to be a corresponding number of ampersands in this okay. Yes,.

A

Yes, okay, yes, exactly.

B

Yeah- and you could just kind of strip them all and you would get back to. However many there are, you could strip them uh and you would kind of get to the older semantics.

A

Willingly, I I'm I don't I'm not sure so.

B

However, I think it's better. I only think it makes sense to drop the star if, if it's a fat pointer, I don't know how much we care about this.

A

So like this is the new one right, so we had uh so we had a reference to our uh rough. Amber st, like we have t, is where the den function pointer is right.

B

So.

A

We have this ampersand d, we do a d reference and then we put an ampersand. What we get back again is if we remove that star, as we get wait, you're just saying: remove the start and not the ampersand with it.

B

Or with the.

A

Ampere.

B

Oh, I.

A

See.

B

No, you can't remove the ampersand when the star removes the star kind of removes the ampersand. So to speak, I'm saying you can remove the star.

A

Okay,.

B

And that's what you're saying too.

A

Yeah, but if I remove the star, it loses ampersand, which gets us back to the same.

B

No, you don't like you can't remove that hold on so put instead of ampersand t, I think you should put like x, colon ampersand t or something.

A

Oh, I see what you're saying.

B

And then put the star: that's what you actually have right: you're borrowing index which has this type, and so what I'm saying is any time that you have. We can ignore the leading ampersand, because that's more the mode by which we borrow.

C

Yes, this is the mod.

B

And- and we already it has to be some kind of reference mode because for moves we already truncated right, but what I'm basically saying is any like, I think, of it as trailing stars, but in this notation they come first like the outermost stars.

B

You know, if you make this as a tree, you have a star with a child of x or something.

D

uh

B

Any of those outermost stars you can drop and you won't cause new borrow check errors. That's what I'm saying, because, okay, because you're already sort of.

A

It doesn't affect the precision.

B

It's.

A

All the content.

B

Right, it's all the content of the reference.

A

If you have.

B

A dot if you have a field coming after it like if this were in parentheses, and there was a dot f.

A

Then.

B

You can't drop the star because then you would have to drop the field too right.

A

Yeah, I think that makes sense I had done. I I had implemented that actually at some point in the first one. Second, I have performance, I don't I'll. I have performance related like speed perspective. Let me just I don't remember the exact numbers give me one. Second I'll pull that out.

B

So I think this strictly. I think this can only make the size of your closure.

D

Smaller.

B

Was trying to think if there was some way to get the closure bigger by dropping stars? But I don't think so um because you can't start through uh like basically, you can have a thin pointer to a fat pointer like we have now, and you can start through the thin pointer. But you can't have a fat pointer to a thin pointer like it's not a thing.

A

That makes sense.

B

Or at least you could but or if you did, it would have to be like an overloaded draft or something, and we wouldn't do it anyway. So um all right, so it's strictly going to make your closures smaller. It might make them marginally slower at run time. There's an extra load.

D

Yeah.

A

So it might.

B

Be worth only doing it, you know if you, if the outermost thing is a is a fat pointer, then maybe we want to.

A

So there isn't too much. At least this was what I did back in november december, uh so this was whatever our closure restriction was and we remove our trailing drops.

B

Yeah I mean we could do like a. We could do something where we say if, if it's a, if the type that we're borrowing, if there are trailing drafts and the type which we're borrowing.

A

Is a 500.

B

Is a din type.

A

Okay,.

B

Or is not sized in the general case.

B

Then remove the remove a trailing drive.

A

Okay, let me write that down as.

B

Well, that's probably the best behavior, because that you still it seems better to borrow ampersand state than ampersand ampersand state. That's kind of done.

A

uh So uh remove trailing.

B

At that point, it's kind of an optimization, I mean well, it's not kind of it's literally an optimization.

A

It's it's an uh optimization! Yes, so we have this okay, so.

B

We can yeah, you can sort of imagine that we.

B

I don't know to the extent there's a spec.

B

I don't know exactly what it would say here, but.

A

Okay, um yes, now I want to talk about profiling, generics.

D

Because it is, I.

B

Have a question before we do that, but which is you had previously talked about an optimization for if we capture all the fields.

A

I still have not tried that just because I do not have complete profiling, I don't have a profiling setup completely.

B

Yeah, but you don't make you don't know how worth it it is.

A

How worth it it is, uh so I wanted to do that first and I once I did send a message about, though I probably should have learned something. Also, uh I'm sharing wait. What am I saying right now I'll share this, so uh where was I think, david replied to this a little bit. Give me one. Second, I'm trying to look through it. Okay, yes!

A

So, uh okay! I don't see this here.

B

I don't, I don't really think the reference to polymorphization made sense.

A

So, okay, so what I was trying to do is we have this? So what we discussed was we have this function, which is like create mono items.

B

Yes and.

A

What we want to do is we want to basically polymorphize our closure and.

A

Essentially see the size of the polymorphis clear right, at least that's what I understand we were trying to do. Sorry, monomorphic, not polymorphised,.

B

I think the polymorphism is sort of a distraction, but like that's just an attempt to remove unused generic parameters, which is fine, but you know I think we can just ignore it for a time being, like it, probably doesn't even trigger for the code. We're talking about.

A

Okay, so that, if that's the case and this might be doable because what happens is so I have two different types right. I have the type after the closure, and I have the type before the employer. So before is fine, because it's sort of what's currently in how the data is pipeline, but the the way the polymorphism code ends up working as and I do not, it depends on the def id and everything is it? Does all the calculations based on def id, so uh-huh.

B

Are you, are you saying the polymorphisation code is interfering with you.

A

I think so uh it's less! That is interfering. It's more like. I would like it's difficult to make it work on two different types associated with the same definition id so one second I'll just go to.

B

Okay, I think I understand, um I don't think this is at all relevant. I think you could just comment that code out for now.

A

Would it not cause problems with anything else.

B

I don't know.

A

Okay,.

B

I doubt it, but it might. I think what that does is where we would have generated two monomorphised copies. We only.

D

Make.

B

One because.

D

Or like.

B

We would have generated n, we only make one because we see that you know that generic type parameter is not relevant. I.

A

See.

B

I think if we don't have that line of code in there, we just will make n again.

A

Okay,.

B

And I think that's fine for your purposes. In fact, it might even be better.

A

uh So one thing that you have.

B

You could ask uh david t.w co if there's an easy way to disable polymorphism, there might be a zed flag or something.

A

So one thing that we had discussed was: we want users to be able to submit profiling data.

B

Yes, so.

A

I do not want to do like my point. Like kind of was we I either we give them a different version of the compiler that they submit, which is kind of non-ideal, which is like again it's available on raw stuff, but.

B

I see your point um yeah yeah. We don't want that. We want it to be the standard one. uh Let me look real fast at that polymorphous code.

A

Code, I was talking about.

B

Now.

B

Uh-Huh, so you can actually disable polymorphization with a command line flag. If you, um if you go to instance.rs.

A

Yes, I am okay. Let me share my screen. I am there.

B

uh I don't have here.

A

Yeah: okay, yes,.

B

Trying to pull your.

A

Oh.

B

You're not on.

A

It's probably on.

C

A different.

B

Different desktop and I'm trying to figure out how to I don't I don't know what how one gets.

D

I can I can, I can stop.

B

There.

D

We go, I figured it out all right. Okay,.

B

My doc is so full of garbage it's hard to find it uh so.

B

Okay, where are we here? Yes,.

A

There you go.

B

Wait that looks different.

A

There there's this function, which is polymorphized, which calls this volume of price.

B

Yeah go up to the function on there. You see that if right there on, if not.

C

Yeah.

B

So what that's saying is, if this flag, oh, it will return, as is it'll just return, as is you could probably make that change that if to like or we're ma, if we added a zed flag, that was like analyze, closure size.

A

I see.

B

We could just.

A

Change this.

B

To say if polymorphisation is disabled or we're analyzing closure size to return self, then it should be fine.

A

That makes sense, and is there an easy way to do? Well, I can probably look into this. I forgot and I might have uh of uh where's that function uh of creating an instance within the sorry. um Where does that go sorry? I will.

A

uh Mono.

A

It was the name of yes, this one create fm item. uh Is there a way to create an instance over here uh of, like a type that I want, like instance, on the fly like right now? Instance is positive, but I would have to create an instance myself before so I need an instance of the type that is before and an instance of the type of the closure that.

B

Yeah but instance, isn't really what you want. I don't think.

D

What's the code you've written actually.

B

Like an instant instance is like a resolved form of a method or something, let's.

A

See.

B

I don't think it's what you need to measure the size.

A

uh So wait doesn't polymorphis remove and, like put so at least when I did this a couple days ago uh again, I would probably change what I'm sharing again is. I was getting the same issues if I did not call polymorphis on like as I'm not okay I'll share my screen.

A

Sorry, I like this in two different places, but so what I had in uh earlier was I would uh polymorphize the instance and I'll read the type of the instance and do the size. I would not do this for new uh the new instance, because I did not have the uh right. It's.

C

Like not monomorphized.

B

Right.

A

So I will end up getting the same error as before, which is failed. uh I do not know these types and therefore I can't give you these, like the size of the player.

A

I think I figured this one out, but right now, if I move this back to mirror, I don't get this error so.

B

Go back to your code for a second. What is the closure size eval? What is the new tie? That's put in there.

A

New tie is the so I create two okay, so uh in write back or like in type check, I create the closure type, which is would be after the feature uh I just stored that I just create that as a like, I create a new closure type and store that information. What would the type have been if the feature was enabled and I'm accessing that type here.

B

But what what? What does it look like.

A

It's exactly just a device closures, it's exactly the same. Just the upward types within them is different than what they would have been if the feature is not enabled.

B

I see, um I wonder if that's causing a problem because.

B

Like I think the problem is not related to polymorphis necessarily, I would think the problem might be that we're not expecting a tuple with that parity like it has more or less fields than is expected.

B

But isn't that a closure? The closure is literally the same as a tuple right.

A

Closure is a structure and it has a tuple of average. Yes,.

B

So can we just instead of making a closure type? Can we just make a tuple type with all the upfar types in it.

A

We.

B

Can get the size of that.

A

We can yeah, we can do that. I can try.

A

My question is even if we do that, nowhere in the pipeline am I saying okay, these are the concrete types that are associated with that closure, because if I have a function, uh which is, if I have a generic function, that contains a claudia there's only at least oh.

B

Well, you have to apply a substitution.

A

Exactly that's not.

B

Exactly all right: okay! Well, that's easy! Yeah, yeah,.

A

So.

B

What you want to do is take the in the the new. I see your point yeah, so new tie here before you call like after.

D

You fetch.

B

It out of the type check results you need to do. Let new tie equals new tie, dot, subst open up.

D

Open up.

B

The type of instance instance should have a subs or something I don't know. Okay, it's like exactly but.

A

Okay, once I have instance, I I'll just open it here one second, I need to look up where it is yeah.

B

You could load it in the rest, doc that probably be.

A

Okay,.

B

That's wrong. Yes,.

A

That is good idea.

A

All right, uh yeah.

B

That looks right.

A

Yes, it contains the substitute.

C

Right yeah.

B

So just do a subs with that subs do.

C

A substitution.

B

With that set of subs on the new tie, variable that you have.

A

Is there a function that does I'll see how this is just.

B

Okay, there's this function.

A

Okay,.

B

Well, that works. Wait, wait, wait, wait, but that's that that doesn't do quite what you want you I mean you want to do the you don't want to actually call this function. You want the function.

A

On line.

B

101. you want to imagine yes, yes,.

A

Like this function, right yeah.

B

I need to, I need to call.

A

Do this call okay, I.

B

Don't know where the params is, I think you can just give a dummy one, because.

A

uh No, I if that one does not work at least uh so over here. In my implementation I had vertical. I did remove it, one second yeah. So in my implementation, I do this review all.

B

Yeah that looks right.

A

uh I get this normalizing uh uh erasing errors thing when I do that. Well, it's probably.

B

Because I haven't done this: yes, because I haven't done.

A

The substitution yet yeah weirdly enough. I do not get this error when I do this in russian or russiaville.

A

Which is interesting.

B

Yeah, I don't know, uh but.

A

Okay,.

B

This.

A

Makes sense.

B

Anyway, if you put the subs there- and I think you should- I would change it to a tuple myself, because it just makes me uncomfortable to have a closure type that has the wrong up bars. You know that don't match the rest of the compiler, it seems okay,.

A

Something.

B

Might get confused um fair.

A

Enough makes my life makes a little bit of the uh type check code a lot more well, not a little. It makes it a lot cleaner to see what's happening.

B

It makes it a lot cleaner.

A

It makes it a lot pleasing.

A

Okay, because, like for closures, I need to construct the closure parts and then.

B

Right right, it's kind of a pain.

A

Actually, don't no, we probably don't want that, because if we do that we will lose the parent subs, but I suppose those don't matter, because I can just steal that from instance over here.

B

I don't think you need don't. Do you need parent subs for anything? I don't think you need that.

A

uh I I can just get it out of the instance that is over here, because the parent stuffs for the both new and also here are still the same. So it doesn't matter.

B

Yeah, I don't think you need it. I think you can make it a tuple.

A

Okay I'll try that, because.

B

It'll it'll have references to some generic types, but that may appear, but it's okay.

A

Okay, I will try.

B

It see what happens yeah. You can also just try the dot subs. It may work the way it is so try that.

D

First,.

B

And see if the goat is working, okay, fine, but it does make me a little uncomfortable, but it won't be there forever. So.

A

uh So the difference is if we keep a closure, as is versus, if we keep a.

B

Tuple in there.

A

Duple is uh the percentage increase, might look different because right now the closure size probably also includes the size of the chlorine coin and the other thing or does it.

B

No well, I hope not. I mean I hope those are just dummy variables. I hope we're not actually storing data for them.

A

Okay, fair enough.

B

If you look at the layout code, I I bet you um it's pretty much.

A

Yeah, fair enough, I I suppose there's no runtime benefit of keeping that data.

A

uh It's and okay suppose. Maybe this one is this one or yeah.

A

All right now that was the first.

A

One yeah: I think this is a question mark, get me anywhere.

A

Oh no.

A

Okay, yeah so yeah.

B

Just takes.

A

The advertise- okay, I think generator- does complicate and that's what was confusing me generator. Does some things. Generators.

B

Are complicated, yeah.

A

Yeah, okay, yeah, so, okay, I think I have an idea I'll, hopefully have something by the weekend that I'll post up and we can discuss it next week.

B

Great um yeah or next week I might not be able to make our meeting, but we can discuss.

D

Anything.

B

One.

D

Thing, I would say, is.

B

Do make the flag, I think that's the first thing I would do uh both because you probably want this code to be behind a flag, but also.

A

Yeah.

B

I was gonna say just so. You can turn off the polymorphization sort of uniformly by.

D

Doing it.

B

In the right spot, I don't know it could also make weird ices or something.

A

I can try it out, I'm currently just using an environment variable to do all the checks, which is technically the same thing, just the wrong interface for using.

B

Yeah yeah, that's fine. I mean we should.

D

Land, it.

B

That way, but it's fine for yeah.

A

For casting yeah, that's all right! Thank you. So much all.

B

Right cool great work. um Thank you. Yeah see you later all right, see ya.

A

All right, I'm the host.
youtube image
From YouTube: 2021-06-02 RFC 2229

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).