Rust Programming Language Language Design Team, 3 Feb 2020

Previous Meeting Next Meeting

⏯

youtube image

►

From YouTube: Design meeting 2020.02.03: Specialization overview

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

Okay, so I'll go through I'll I'm going to go because we're not that much time and I want to get to the end. I will skim through, but please interrupt me first of all, I collected a lot of links here is probably not every blog post we've, certainly not every blog post written on specialization, but it's a lot of the key ones on the original RFC and oh actually, something I wanted to write on. There is basically in reviewing this stuff I found. You know, there's a few.

A

What I would call yeah I, don't know what the word is: they're, not exactly unknowns or like future things or something few places where the design is like a little bit less than you might hope. One of them is I'll come to that in a second. Actually, let's go down first before I. Do that um they over coming. Let's see me just write notes for myself. One of them is that we have a somewhat simplistic notion of tree like specialization.

A

This is considered a conservative start, it's not a problem exactly, but it's just true I'm not to blame or what I mean by that in a second.

B

A

The other is the soundness are on lifetime's, which is what I think it's more important.

A

Yes, thank you soon. July wanted that in there so right, the key idea. I guess we all kind of have this idea, but that normally we don't permit overlapping impulse, but specialization does as long as one of them is more specific, and this is another key point that we discussed recently, that if the item there's two conditions, you can have two impulse that both supply a value for some function for some associated title for some associated item, and the problem would be done that you know you have two choices.

A

You have to pick which one, and so we require that one. The one in BO is clearly more specific than the other, and the other is that the less specific impulse been indicated with default, and the idea here is that, essentially, if you don't see the default keyword, then you know that the value in the imple applies.

B

A

You do see the input, the default keyword and you know locally that the value might not apply. If there's a more specific one to be found, we don't require you to signal at the moment. Is there's no indication that you are overwriting somebody else just it's just so um some languages like Java or whatever do or have been moving towards the main motivation. Probably this kind of three listed in the RFC, more or less performance is probably the single most common one.

A

It's being able to take some default, some implementation, that's correct, but inefficient and then give or potentially inefficient and then give more efficient variations. But the same thing applies for kind of ergonomics. You might like to have.

B

A

You might like to have things like one example that we can't add for backwards. Compatibility reasons, but which is interesting would be something like you know, waving up the debug in the display traits and maybe we'd like to say that if you just implement display you get that for debugger. Unless you also implements your book and then you override it, that's not performance exactly, but it's similar in some motion. You.

B

Get a kind of a quality of life improvement of not having to derive so many things right.

A

So you kind of get like an implementation- that's pretty good, but probably not as good as it can be, and then you can make it better. In that sense it's similar, but coming back to performance, this is kind of important there's all right, oh, not connect performance. One other thing is the other. The other concept in the RFC is improving. It's a sort of a subtle point, improving how we handle it buffets right.

A

So today we have this notion of a trait they can have default, or you don't write default in the trait, but you can have functions with default implementations and the idea is the input will use that if you don't give it up, if you don't override it.

A

Well that gets kind of generalized in this RFC so that it's like you can provide more than one set of defaults and they can be more narrow right so that, but that code above would sort of be equivalent to this in the RFC, so that the idea of a default in polis, basically it's an Impala. It's not an Impala in the sense that it doesn't fully implement the trait it's like.

A

It contains defaults that can be used by other impulse and so yeah that's correct, and so that can be useful. So you might I, don't know if this is a realistic example, but you might say if you have some skippable thing, you know if you're also random access and you can jump ahead in a more efficient way. That's what you'll get so.

A

The main thing is that there's sort of two or coming back to the idea of being more specific, they're kind of two ways to be more specific one is that you have more specific types.

A

So here we might say: okay, this is the trait that's, let's use when you call extend and it can, we can define it in general for all iterators, but then we can make a more specific one for slices where we can use mem copy or whatever um people might need to have you copy or something I, don't know, but let's keep it up, leave it out for now and.

B

A

For the other thing, which would also be useful, is to be able to narrow by traits so here I said yeah all iterators, but iterators that also implement trusted len. I could be more efficient. In that case, let's say, and these this turns out to be a pretty important distinction for soundness, and you can kind of combine them a little bit. You could have an imported, both has more specific on types and on traits and so on.

A

So that'll make sense so far. That was definitely make.

C

B

So far, yeah fast.

A

But okay, so it's worth talking a little bit about what happens during compilation because it's relevant, and this is where the soundness sort of problems come from. So in the type checker today we have or in compiler today we have kind of two at least two, but two main phases so is there's.

D

The question is this: dumb doing in the wealthy Jake wait just.

A

What done this? What I'm about to talk about? Hijacking? uh Yes, not exclusively, but it is done there there's really kind of two modes. Essentially you the type checking mode which is well when you're doing the main type check also occurs during bar check, for example, and in that case the idea is we're, checking the generic functions for correctness and and we're actually computing, the all the life times and other information as we do it right. So it's like a full compilation, and in that case we don't. We don't have a problem.

A

If we're in this mode, we don't really have a problem with the full range of impulse that we can have so, in other words, if you can have impulse like this one that require that something be in this case. It requires that a given reference is tick, static right, and that would mean if I were compiling here, I might say: I might have a variable.

A

I might call I might call bar with some reference right and now, what's gonna happen in this type, checking phase we're gonna create a infant's variable here, because we don't know we have to figure out what the lifetime of Y is. What is the range of code where it needs to be live and when we call bar, we find out?

A

Oh well, so in this case the type of t is basically the same as somewhat simplifying that it's okay for this purpose, basically the same as the type of Y, so ampersand six zero, and we know that T has to implement the trait and the only info we can use for that. Requires that tick zero. Is you 32?

A

So in order to type check this, we were basically first we have to show I'm gonna use chalk notation here, but we got to show that you 32 implements the trait and we figure out that this is true. If six zero is tick static, and so we wind up inferring that tick 0 equals tick static, which will give us an error which in turn triggers an error here, because.

A

That that variable X is not alive for the lifetime sticks head.

A

So this this all happens during type checking in and we're fine with that. So the problem is: when we get into trans we're gonna, we have to we're gonna.

A

Do we're going to do the monomer physician phase, where we we lay out all the generics, and we know all the tectum formations specifically and at that point we redo type checking because or we do not all type checking, but we redo certain parts of trait matching to figure out like ok, now that we know exactly what types are involved, what method should we call, and at that time we don't have the lifetime information?

A

This is for efficiency, it's also because otherwise we have to make many many copies of like you or a functions like bar that are getting called with with types that have lifetimes in them, but it's all slow and it's also a lot song.

A

Yeah well, this is what makes it might sound, I guess in part, um but right so we don't know what the lifetimes are. So we can't figure out. In short, does this trait apply or not? Because all we know is that there's a reference for some lifetime. We don't know what that lifetime is and that's where the soundness hole comes in, because now.

A

Now we have, we might have something like.

A

You might have a specialization where we say we have one trait, let's see my future, if not the best names in the world, but they have a specialization where we say there's one in pull and here's another one, but only if it implements the trait and we can't tell whether this applies or not and that's kind of the root of our problem, and it can show up in a lot of ways so like here. It was pretty obvious because I just wrote ecstatic, but actually, if we look a little bit lower, we'll see.

A

There's some other examples like first of all, I could have had at ecstatic bound or even something like this case, where there's no lifetimes at all actually violates these rules, because here I said any pair of types as long as they're the same type. So if I had two references, I would have to know that their lifetimes are the same. But if I don't know what their lifetimes.

B

A

Know if they're the same one.

B

Question here: are you suggesting that you can or not that.

B

D

B

D

B

A

Just try that again, just I heard a thing.

B

Would specify a trait sorry specify a lifetime and have that check study? Is it checked or is it actually affecting inference? Okay,.

A

So I didn't hear everything, but the last half sentence what you said, but I think I have a guess of what you were asked.

A

You were going to take a guess where you were asking actually I, don't really know, but what's even the last thing you said was: is it checked or is it in filling influencing inference, and the answer is the answer is during type checking it's a little bit of both kind of, but we're taking this constraint into account.

A

Basically, so we are influencing inference and figuring out if we can satisfy it, and then you know doing so if we can, by choosing types that satisfy it, which might then lead to borrow check errors or errors in later phases as a pilot, um but you know we're taking it into account and the key idea is we figure out during type checking. We know that this constraint will be satisfied for all the types that this function is used with right every time.

A

So this might be a generic function, but we will figure out that for whatever T this is called with. All the lifetime constraints are met that occur inside the body; they don't create errors, and so then, when we're actually a trans time and we're ma no more fighting for specific types, we don't have to prove that again because it's already been proven for us in the same way that we know that the traits are implemented in general and the methods must be available, and so on. Does that make sense.

B

That made sense. Yes, thank you, I was trying to get I was trying to figure out in more detail because it seems like this is so closely related to the soundness hole regarding like time so I wanted to understand better how lifetimes interacted with specialization and that helped. Thank you.

A

So one of the most insidious parts of this thing, I'll point out, is that the problem is often not like local or doesn't have to be local. So if you hear in all these cases, I kind of wrote the implementations of citrate which fail to the parametric directly, but you can also have some that fail to be if there and ultimately depend on lifetimes but indirectly right. So here it does. This dependency comes from some other tradable, which creates a bunch of pain. When you try to solve this in any local. What.

D

You will see is probably well not you specifically, but yeah.

A

D

Up with other ways to.

A

To times like this, would this is obviously some other tree I guess because yeah this anytime, that the type parameters are kind of repeated, but one thing that's important is that it doesn't apply a case like this, which is to say we don't care about what appears inside the employee. We only care about the impeller right. What's.

C

That! Okay, up with the input that okay umpire and needs to be more problems, yeah.

B

So this seems really important I'd like to understand better you're, saying that in this case, if you were to, if a includes some manner of lifetime, then there is no enforcement that the for a and the output equals a have the same lifetime. There.

A

Is no enforcement trans-time like when we're generating code, but we don't need to enforce it because the type checker already proved it, and the important point would be that we know that that the the the what comes inside the employee doesn't affect which input we use is sort of where it comes down. To so like we will be able.

B

To figure out what the symbol applies,.

A

B

It can't affect impulse election, but it will not in any way be unchecked. It will always actually be checked if there is a lifetime constraint there yeah.

A

And the reason I bring this up is that the distinction like this is we typically call these input types that appear in the implementer, and these are output types associated types, okay and there's a kind of flexibility in how you choose to model your traits. Sometimes people prefer to put the put things all in the imple header, and sometimes they use associated types and the distinction matters a lot for it for this purpose. None like you really want to use associated times when it makes sense and.

D

The small note that if you have, if you are the bound on the output, a then that is actually part of the signature, we're close.

A

Actually, yes, but I'm, not sure that it has to be. It certainly isn't a way that compiler models it today wait.

B

You're saying, if you have type output colons some other traits, then that's considered a constraint as if it were in the header, rather than something that well.

A

C

A

C

Or you saw that playing with the hypo case, where the trait two's definition has that bound on the.

A

Right, so you don't hey, you don't put those bouncy animals today, although with guts you would but or you could, but oh.

D

Sorry yeah but no yeah. Sorry, yes, but that's about only it's not possible to put a bound on the.

D

B

A

Right and even even the bounds here, actually it's true that in the compilers D sugaring, presently we convert this to to a format like that. Yeah, however, I don't think that's actually necessary thing to do. I don't know, I have to think about it. Let's make some models model of the language actually I think it's actually makes it more complicated, but I've come to think over time, but uh depends on your point of view with.

B

Gas, it doesn't always.

A

Work quite as well, I, don't know, but it's it's it's a good way it's. It might be the case that well, in any case, let me take that back. It's true that we do that, but it's not relevant to this question, because those.

B

A

Up as where clauses on this imple right so they're, just things that the impo itself has to prove.

A

Okay, so we've thought a lot about this problem and we've been debating for a long time how to solve it. The RFC has one sort of sketch of an idea that doesn't really work out that well.

B

And this problem here, you're just I, think about correct specialization in general. Talking.

A

About the lifetime dispatch problem, so in particular, how can we kind of allow the use cases we wanted to allow with specialization, while also having the impulse that people can write and and retain soundness? Maybe I should show where it becomes unsound right.

B

This is what I was getting at is that before we go into, we've got a lot about the life time problem. It seems like that we have enough background to try to talk through the like time problem.

D

A

Well, I mean you remember, perhaps from like, when we were talking about didn't trade soundness and so on. The main the main problem has to do with, at least in the way the language works today with with associated type projection. Basically, so if we, if we had some imple like this.

B

You have a blanket imple of something for every type.

A

Right so now we have this trait and now the question is: what is the value of.

A

Of this way- and you don't know what this lifetime is I see, and so the problem is what comes down to the problem here. Is that ya the trance? The transcode just can't answer this question? It doesn't know what the light ended and the type checker might wind up with one of two answers.

A

There's like the type checker might wind up with one of two answers, depending on how much it knows about that lifetime so like, if you had, the type checker would be consumed. Okay, the type checker would be conservatively correct, but like, if you're in the context like this, it might not know you know it would wind up. It would not be sure whether this imple applies or not. So it would be conservative because it would fall back to this generic Kimball and see the default, and it would know that there might exist a specialization, but.

B

If you recovering in the room, this is starting to sound like some of the problems that can come up when you're dealing with overlapping instances and undecidable instances Monken hospital. This is what I just said. Yes,.

A

So it would be conservative here, I think there are ways but well. The bottom line is, of course, if you know, if you did happen, to have.

A

A tick static where the type checker does know or reference where it does know that it's tick static, then it would. It would pick you 16. So what I'm trying to say is it? It's not like the type checker could pick reasonably so sort of either one. So it's not like weekend on.

A

It's not like trans.

D

Can or if it knows, if it knows that it sticks, I could make you sit me, but if it doesn't know what the reason well, the reason is that it should not normalizable.

A

Yeah we have to leave it out structure but but nonetheless you don't want to just so. The only like trans could always pick you 16 in some sense, but that's clearly wrong because might not be static. Moreover, there's another sort of subtler point here, a lot of times.

A

People when this is raised, they they ask like why not maybe we don't want to differentiate between all lifetime, so maybe we can make tick static, special and and choose sort of montemor fights twice once for static like times and ones for non static, connects the only thing that we track, which would at least allow the type checker or at least allow trans to make a decision in some sense, but that that doesn't really work.

A

For one thing, it doesn't solve the Equality problems that we mentioned earlier and for another thing at least right now, the type checker kind of randomly randomly it picks, the smallest lifetimes it can that meet the constraints that it sees and now there's a sort of a choice like if it. If you had a function where you had, you had something where it can be static, but it doesn't necessarily have to be like this. Then.

A

Then there is a kind of choice. The type checkers making about is this going to beat ecstatic because it came from static data, or is it going to be less because it's not used in us in a scope where static is required and it right now we'll pick less than that case. We will be choosing what associated I forget hearing it's just kind of arbitrary, not easily explained, um and you really don't want us to pick the largest lifetime, because that will produce all kinds of bogus that doesn't make sense.

A

um There's lots of borrowed checkers, so so there's a kind of ambiguity where type checker has freedom of what lifetime to pick and it currently smaller I guess the bottom line. Is we don't want to expose just that? If we had exposed information like this, that would have prevented us from doing nll. It would prevent us from making future improvements. We want to keep the type checkers for yummier to make choices.

A

So so we really don't want to depend on the lifetime dispatch.

B

A

B

It's it's unfortunate, given that I can very easily imagine cases where somebody would want to specialize for us a reference to tick static, ster versus reference to non static stir, but at the same time, if that were simply a documented limitation of stable specialization, it would be the end of the world that you're not allowed to specialize on lifetime.

B

D

Specialize in the life sciences, it's like that violates parameter, C and maybe backwards. You.

A

Can certainly help imagine why people would want it, but, unfortunately, insurance it's not tenable, is very.

B

Precisely I can imagine why people would want to specialize on Ecstatic in particular,.

A

B

There are things you can.

A

D

B

Stir that you can't do with a non static, sir.

B

Like do this, then so be it right.

A

So, okay, so the solution that we have to make this sound.

D

If I might might inject, what you could do is like new type rock, it's not safe versus Blatz topic and then sort of dispatch on that type. Instead, yeah.

A

That's right, if you really wanted to specialize on static stir, well, you can't, but you can have other types like if it's, if you have total control of the project, you know you could imagine that you have some type like static string.

A

Sure and then your constant is actually a static string, struct and then you can specialize.

B

A lot effectively pull it out of parameterization and into a concrete type and then you're fine, yes,.

A

Yeah that would work like as long as you're, not getting these textures from other places that are out of your controller right.

B

It would be nice if we came up with a way in the compiler to make that possible to be the type of a tic static stir. But that's a problem for another day.

D

Like this yeah.

A

There might I don't know if there might be some clever hacks you can do but anyway, yes, so.

A

So right so now we're coming to the the meat of it. What what can we do about this problem? I? Think the current, oh and I should add. One thing is we: we are starting to see bugs around this. In practice, people are adding specializations that depend on lifetime, parama tricity, without realizing it and that's not great um standard library, and in particular it seems like we have one the most annoying part. Is it's not even a performance question?

A

That's actually uh it appears to be part of its behavior, um which is worse because you can't just rip it out for sure to find a solution. So so what was this idea?

A

I think the last time I think it was after the 2018, All Hands or something I wrote this blog post always applicable impulse, and the core idea was that we only really have problems, because when the specialization, when the imple that is doing the specializing, is adding new constraints that the bay simple or the types involved in the info, don't already prove for you right. So essentially.

A

As long as you limit yourself, that's what this concept of always applicable means, if, if you in the simplest version, if you look at the types that the IMP applies to- and you say for every instance, any instance of those types, the symbol is always going to apply, then you don't have a problem. So an example like this was in our motivating examples. An example like specializing. Two slices of you is okay.

A

As long as you're specializing to all possible slices, it would not be okay if you were adding some constraint on you like, it has to be slices of ordered things or slices of copy things. That's not good because well copy, it might be a little bit special, but it's not presently. Actually, that's not good, because somebody could implement copy for my type of ant ecstatic, for example, and that's currently allowed, although we don't like it when you do that, what's the Salamis buck around it, okay close it in second.

A

Sorry, so that's the kaity of an always applicable imple. um You can extend it slightly, but I'm not gonna. There were a few possible extensions, but the key thing is it doesn't handle. You know this use case that we want to support of like where T is a trusted length and that's kind of annoying and in particular, that that's exactly what six seven one nine four was trying to do was to write again pull that's dated on implementing multiple traits and not based on being a specific type.

A

So this is where Aaron's I guess there were various extensions in Aaron had what may be the most promising one yeah I detailed.

D

Here, especially like the fact that this sort of makeup makes the specialization more visible, as well as being flexible. Yes,.

A

So what what this, what this, what this concept was is currently we have one kind of bound which is like t trait, and that says t implements trade right, but Aaron proposed adding another kind of bound which I'm just gonna write it like this I think the is pretty obvious that this syntax and name are not ideal and so we'll leave the bike set aside. But what with this for the moment, what this means is basically T implements trait with an always applicable in pull.

A

So it's a subset of the larger, the normal bound which I've written here in chalk notation. So if you know that specialized T trade, then you know that the trade is implemented. Well, you don't know the other way around, because if you know that it's implemented, you don't know that it was within always applicable. It might be with some other um and there's one subtle. Maybe it's worth going through some examples, because there's a kind of subtle point that I realized in reading the post.

A

It's I think it's what Aaron intended it's a little bit implied, which is that impulse can actually be kind of three-way.

A

Let me show you what I mean so imagine that I have right, I can make an Impala is clearly not not always applicable or a lifetime dependent. We have a bunch of examples, above maybe at references to ecstatic. Maybe it has the same type parameter twice and or I can make it and bullet is clearly always okay, which is what the post outlined always applicable, and it talked about some of the rules for that, but there are also these kind of neutral impulse that are okay. If you can sort of read either way.

A

Potentially so, if you just say like I, implement bar as long for all food types, you could say that well, when you're trying to test as far as implemented in a specialized compatible way, then you will then sort of propagate that to the where clause so that'll be true. If t foo is implemented in a specialized compatible way and then so then ultimately depends on what the base sort of belief impuls are. Are there any?

A

If you enumerate all the impulse out, are there any life time-dependent impulse in there or they all either neutral or lifetime? Independent and.

A

So when it comes down to then is when you're writing a specialization. If you want to add any trade balance, you would have to use this sort of mode to do so. So you could say: I extend T for all T the iterator as long as they're trusted Lin and you might be even simpler if you had to do it for all Craig downs period, um but it's not strictly necessary. That's kind of the.

D

High level idea of the facility-wide specialized.

A

Shorter, yes, that's actually a question from you, though, which I would want to come around to of like. Can you mix T, iterator and specialize, or how do I do that? You know with my patient we're gonna use something like this.

A

You know specializing involved more complex, so the reason that let me just rewind to make sure can you have both so basically I guess it comes down to what are the rules for what a specializing in pool when you have a when you were specializing in. But what are the exact rules we want to do?

A

Is this a question about some Nisour?

A

It's more of a question about it's, not a question of soundness. There's like a maximal system. We could do it's a question of how is it? How is it to explain, and so this is where, like the maximally conservative version, so the implement see I.

D

Would like a tracklist that with I think most of the people who would like a new specialization for very for a lot would be those who are doing my performance, work and building frameworks and I think those might and those might be, the people who can tolerate more than text me.

D

B

D

Of those segments.

A

So let me um I might be true, well, I feel, like I, haven't really explained very well, might be shock to people we're all following why you could I couldn't mix these two kinds of bounds, so maybe.

B

I can give an example.

A

To try and make it a little clearer one of them might be like imagine that I have I know this, isn't how hash said is defined, but just imagine if it was how hash that is defined, that, in the definition of has that I specified that all the keys have to be hashable now I might have some I might have some imple. That is true for all T and I might have an impulse.

A

That is true for hashed out of K we are K hash, and so the important point is this: this is not a specialized street-bound right. It's a full normal trade bound. However, I also know that I always know when I write an input that all my types, all my input types are well-formed, like the person who is using.

A

That imple has to prove that already that's part of the way that the rest type system works, and in that case I also already know the K implements hash in the full sense, because otherwise the type wouldn't be well formed. So I can actually write it here in it. It's okay, but if I were if I were to write today, hash plus, let's say Ord I would have to write specialized, ordered or whatever, because that does not follow from my type definition.

A

So that's one case, that's kind of the simpler case and then the more complicated case that was part of my list of possible extensions is that you could imagine if you're specializing another in pull. It might also give you some information. So if we had like.

A

This is a little more subtle, let's, let's to take study, if you had some imple that applied only to tic static types and then I want to.

A

I want to write a specialized version for hash set now.

A

Well, this Kate ecstatic is not implied by the type, but the type checker is going to guarantee that the conditions on the basement bullet at minimum have to apply, and so it's just not. It won't be sure whether this.

C

A

It sort of already implied the T must be tick static and we already have rules in the compiler. That say we allow us to know that it has that a patch set of K is too ecstatic and K must be too expanding, so we could kind of figure. This out, I would rather not handle this case for various reasons.

D

But it should be, it seems like it would be for impossible to do case just to play spawn and then maybe some other time decide that we will called monster in case two. That way, then it seems like a good idea to to only do case one for long.

D

At least it would be a guy started, I think yeah I think we need to. We need to ship something and try to keep it minimal red still stopping at maintenance.

D

Yeah seven minutes.

A

Right there might be some simplest version where we just said we're just going to require you to write specialize on everything but yeah.

A

And then it's kind of easier to explain. Well, if you're writing a specializing imple did at that point, you start to wonder all that seems a little silly to make me write it on every bone. Maybe it should be.

D

I think that's a good idea, ship, something that gives more users thing they want, and then we can try to make it more time. Then we can. Then we can also base that on using this like. How are they are? A lot of people complain. Do I have to write specialized law all the time.

A

Yeah that we think about one thing, I would add is one minor thing is if we had implied bones which we haven't shipped and we have some outstanding questions around. But if we did, one of the goals for implied bounds was to make it so that bounds, like kay hatch, didn't have to be bitten, in which case they're always applicable, rules are kind of nice.

A

It's basically, if you don't have any, where clauses or all the where clauses or specialized closes, because all the other stuff follows from implied pounds in the first one, um but in the one last thing which we said since we're in the last end of the meeting one.

B

A

I had while reviewing this is that we have the notion of always applicable already in the drop check which may help us both in implementation, but also in explaining things. So you cannot write, implement drop form. I struck with ecstatic, for example, for exactly the same reason that that we don't want you to have it in specialization that we won't know whether to run this in trance.

C

Wait, you mean the definition my struck, there's it's you take a an apt ecstatic. Yes, sorry.

A

So we've already got the code to do this kind of check is my point and it's it's relatively simple for the the case of okay, yeah.

D

I'm thinking about the minimal steps to to move forward right right now, I think it would be good to add the links or some sort of enforcement that we can use in this town library to at least not not add, more problematic specializations and like have a have a moratorium on using from adding new specializations till. We have that I.

A

Agree dad is a good next step. I also think it would allow us to start doing creative runs and test and look for, like surprises.

D

Another another thing which feels like the moment like irrelevant next step would be to finish associated type defaults and ship, those yeah we didn't.

A

D

A

That at all but I, agree and I know there's a PR, that's yeah.

C

A

Know I owe you honest, like a that, should mail him some chocolate or something very.

D

Thorough with the tests I think at this point, which of his movements nice job on those tastes. Good, oh good,.

A

Yeah so just in case well I, let's not go into detail on what the interactions here are good.

B

A

Think another thing would be writing up. In my view, it would be good to revise the specialization RFC and like include this material or try to have, if not the art like, maybe not as in the phone where I see, but some kind of I would like a canonical thing. That includes the defaults, this these concepts and puts it together and we probably start with the artsy in the starting point, but so that we have a like reference to go to. We say: okay, what is the rules now right now? That is a pretty disjointed.

D

I think this review.

D

It's not that much I agree. We got a lot.

A

Of the pieces so.

A

I, like this idea, I think the question which we can figure out our finest who or what shall do the Lind but I bet I have some thoughts on that. It would.

D

Be good to be mentored out for sure. Do you want to they want to regarding the.

D

Comment to the the moratorium ones that we have the looms yeah.

A

I cannot account I'm, not sure where to put the comment, I think it's more likely. It's ping, the lips team or something.

D

Yeah, you might not, unfortunately, I think they have some section about specialization in in there yeah.

D

That can they're about specialization, yep, yeah I.

C

Assume that you're expecting the Lindt that you want to add in here to be simple enough, that it's not worth adding a different Lynch that just Flags any specialization and then you know some way to be to say I'm mark. This is actually.

A

Not sure it seems like it seems like.

A

We could do I mean we could certainly move faster with a limp that Flags any specialization and requires us to at least vet them.

D

Should be I mean that.

D

B

You the base, I literally.

D

Every specialization to.

B

That that individually, I think you'd find people not so much vetting as placating the compiler yeah.

A

But well I think that's true in the wild it might help in the center in libraries. It.

B

Might at least be a review flag.

A

That you could notice, like I, think it would go. It would work only if we also handed with guidelines like like it directs you to an issue, and the issue says make sure the impose is only for concrete types and doesn't that in a tree.

D

Ya know probably mean maybe that could be other to like I think I guess. The question is.

A

Like how much work, probably it's worth just looking quickly at the drop check code, to see just how hard is it to me, because that would be better wait.

C

I was sort of hoping that we could filter out the concrete types. As part of this you know like the lint, it wasn't just a grep, but rather it must mean the compiler. You should be I would hope easily. You might say: okay, concrete fits our accepted.

A

Well, at some point you're getting kind of close to the actual Chuck, so I guess the question is like how hard is the actual check, because.

C

You're worried about like the end of level and direction same problem. They you spoke up above where you know, that's why the local check doesn't suffice, that, where you're kind of against you're worried about here, I'm.

A

Just saying that the local check, when you say, filter out concrete types like really you have to look for you're looking for things like is it is the perimeter repeated like I, think many specializations still have some type rumors. That guests are missing because they're implemented for patch set of prefer avec of tea or something- and this is not enough to say it- must be fully hungry. That would be pretty strict, though you could do that.

A

You would, but if you're then starting to write anything more than that, and maybe it's easier to just extract the code, we have that exists. That's.

D

All I'm saying look, but at least we're now like people are adding more specialization.

A

We shouldn't do is stall for a long time, I'm getting a perfect thing, I think, but if we can, you should figure out what we can get any reasonable in that time. Let's just discuss this. This is like I veneering question. I think we should discuss it afterwards done dead in the last like before we close the call and more curious to know whether I guess there were lingering questions about meaning or design that we could discuss. Let.

C

Me know: I'll, be honest, I, don't understand a specialized predicate, because what was presented here, I, don't accept lis understand what that adds. So for the ample that you, you know, you described it as being difference in terms of you know a directionality in the application, but I don't actually understand why that is no I, don't understand what it means. Yeah.

C

A

Me give you an example, this very concrete going over to this bug that came up in practice.

A

Right there's this partial EQ, your did a partial order.

A

So if we have here this version right where you have your specializing for K as long as K is org, but not all words just specialized word and then there's this imple.

A

This impulse says requires the sent uses the same to K, twice right so based on the simple we can say that it's implemented, but it is not specialized.

C

Derive what that what you can loot is specialized that it filter else. It lifts up these cases. Okay, yeah.

B

C

Zoom, it's all the KC described above I just not quite understand clear what the deficit would be, that I understand. Yet the go language.

A

C

Yeah I didn't have quite.

A

Time to dive into the exact details, but yeah, that's the idea is this: you sort of screen out, which means you might get I mean you will be potentially you could imagine being surprised. It's certainly potentially surprising that you don't really know what this means. You're, just gonna think it's like a variation on or even you're like. Well, why isn't this triggering might type this word and the reason is that your type is only sometimes depending on right, right.

C

Yeah, we might need have a way to specify that, like admission is intended to be specialized all right like some sort of a tree or something away for some noise. Sorry, like my pigeons at this, be that way and then that way, future changes will be. You know detected a question.

A

I wanted to bring out the way and get to but I'll just plant. The seed is that you know we're talking about additional changes and so on. I think it's plausible to imagine like starting to lend this one. We have to be tied to the addition, even necessarily trying to warn people about impulse that would be screened out and require them to be marked in some way. That's something I would only want to be hard to know without measuring how often they occur, but I think we could start to think about.

A

You can certainly imagine warnings that say we chose not to apply this specialization, because this imported meet the criteria like dice, but that's gonna occur it that you say which is suboptimal but yeah, but still may be useful.

D

Getting this getting this funds rights.

A

One other interesting question would be yeah, I, think I'm the way I'm thinking of it is I. Think it's probably the only way is that you're doing all this checks generically like pre amount of more physician, though there is a world where you say: okay, if you had an impulse s.

A

If a trans time T, is you 32, you could sort of consider this simple, but I think that's gonna go in 10 I'm, not you know, I! Take it back. Don't forget. I said that I'm sure that will lead to beg to some thoughts on this bolt. The whole goal is to be like obviously reasonable.

A

So yeah there that would be the idea and there's some potential for confusion that we would have to think about how to mitigate. If.

A

The main change from what the RFC says and what this is is basically that you have to write specialize in which a central point of like at least there's a key word in there that you can be like what is happening right.

A

Maybe that's because of my confusion and then you look up and you understand to understand.

D

They're, actually, maybe don't I actually don't mind. The concrete syntax of this right I mean if it's gonna change the semantics I think it's good. You.

C

Won't you know me: Nico I wanted to have variants annotation, so I'm not gonna ejected this, but I do think that I will I can imagine some people saying why don't we just infer it, which is what the RC I guess said like right, you can go figure out which which balance are introduced and do the same thing, but it's bad error messaging. You.

D

Sort of this this specialized would be usable in like it doesn't have to be in an improvised. It could be anywhere, it would yeah. You could I.

A

Mean if we allow it to be anywhere, there's no reason we shouldn't spirit that way, but is that meaningful? What would be useful, I'm, not sure, maybe.

D

Simpler, probably simplest, just allow like yeah.

A

I would I would default to allowing it just because that's just less otherwise we're sort of screening out where causes in random geez.

D

Yeah I mean it wouldn't be hard to check. You would just traverse the ast and like yeah, it's not hard. It's just not.

A

Wisely explained why I think the main variation that I'm somewhat like I'm, not in I, think there's some I, see some value to writing that you're, declaring that you're specializing and then that having instead of writing it on all the bounds, it just seems a little easier.

C

To explain what's happening.

A

C

You imagine that as an as an extra syntax or you imagine that as being the only syntax cuz it's then it's an expressiveness issue right. That's right, I, don't know.

A

Okay, I imagine it I mean I that was kind of why I brought up this question of. Should we allow mixing and stuff it's exactly that, because if you we don't know what I feel level yeah we'll find out, I I guess at minimum I, don't like this keyword in this location because it doesn't it's okay, it's just very! It doesn't carry any intuition for me, the easy part! Sadly, it's like yes I would like a name that carried some intuition. We could come up with about that right now.

A

You got bigger problems, all right, I'm glad we did the meeting the proof, productive, I! Think thank you. Bye, everybody I! It's that Felix Cartal cool.