.Net Foundation Design Reviews, 2 Jun 2020

Previous Meeting Next Meeting

⏯

youtube image

►

From YouTube: .NET Design Review

Description

00:00:00 - Approved: Configuring request options in Browser WebAssembly https://github.com/dotnet/runtime/issues/34168#issuecomment-637712249
01:05:10 - Approved: ICastableObject interface https://github.com/dotnet/runtime/issues/36654#issuecomment-637742472

A

A

A

A

But you probably didn't mute. Your YouTube will be my guess that.

A

Might be possible, I mean feedback to me sounds more like you can hear something double or something, but you shouldn't yeah the background.

B

You can have other libraries pretty useless so, for example like if you were using system out ICP jisun, how can you have it produce this post request of the send request, but also use options that a user we want to say like so things like no cache or integrity checks or, like you know, including like credentials and so on so forth.

B

So I basically listed like like three options that I thought were interesting, so one was lik specifying cache and the second was like specifying an integrity check and the third one was liking to figure out if credentials need to be included when you are sending when you're making a fresh request- and my proposal is to it's something that we went over the last time we spoke about this, which was adding some sort of bag to the SGP request, and then so.

B

It's based on Cory's proposal for some other API, which basically did this was a more strongly typed dictionary property back of sauce, and so no you wouldn't get you weren't getting loose strings. You were getting like typed values back out of things so, like you had some like some level of typing to it, and then I have some examples of like how you might possibly use this.

A

Today we just cool down I guess to them. Actually, the IP apples are here. Okay, so.

C

I'm, a little confused, isn't the one that we were looking at in like Thursday, and we said we needed the networking team to review first or is that different? You.

A

Know that was the one but I tagged Korey to take a look at this on Thursday and I invited him to this meeting. That was the idea.

D

Right but doesn't look like Corey marked it back, is ready for review. It still says suggestion you.

A

Didn't want I mean the idea was if he had opinions. My hope would that he was voicing it here as well, but.

A

Yeah, well that sucks, we'll.

D

Have the same questions we had last time, which is, is the interface needed? Can this be unified with what the proposal is for I mean.

A

I guess you can still ask those questions here. Right, I mean so give him that foreign office- he probably has an opinion this so like. Is there any reason why it can't be just the time like what? Why do we need the abstraction.

B

Options, yeah I think I, basically like tailored this, based on the other issue, and so I thought that was like some history as to why the interface was chosen and why, like there, was an abstract implementation to it, but I think like the idea was like the interface was immutable, so once constructed like you were supposed to like treat it as immutable versus T concrete there for something that you created and passed.

B

So you had control over like or adding it and then like obviously like, if you as a consumer, wanted to, if you as a library or I, wanted to like add mod semantics to it, like you sort of control its destiny rather than us determining how that would be.

A

Yeah, that's what we thought last time. The problem of that is that people can cast it away right. So if you expose the AI, HTP request option somewhere and you actually just base we're the cover, just hold it as an HTTP request options thing, then people can cast it and then still add stuff to it right. So, if that's the immutability aspect is important, then you probably need a decent internal implementation of this. Some other people can't castaway, which I think, generally speaking, will probably defeat the purpose.

A

Another option is to literally have a cheapy request options. The type you can freeze effectively right where you can write, you can just say: okay, no, you can go on, modify it and then people call a door. It just throws an exception right.

B

We could switch it over to a builder pattern if, like that was important, but like I'm not strongly married to the idea of like having an interface and a thing, it just seemed it just seemed like you know, you wouldn't want to pass an immutable thing to like the actual HP client ya,.

A

Mean my default assumption is then, when API requests come home, asp net, they usually start of interfaces because that's kind of like their I, don't know aesthetic of style, choice for most of the functionality in asp net and that's okay. But like many bc, Aleph ID. We have to think about that and make sure that we don't just have interfaces for you know stylistic reasons, but they actually meaningful and then also whether we can convert some some of them to abstract based types because they usually version better than interfaces.

A

And if we don't need abstractions at all, that's even better because it's one less extension point to link to X having to support.

A

And enable poly be the number one feedback item, the other things. I gave it a quick read, it mean they look reasonable, given the other existing API, as we have.

A

Including the extension method for the JSON stuff, I.

A

Mean it certainly seems more closer to what we want this to look like based on the initial discussion we had. So maybe we should just end it here, like you know, maybe drill into the interface again and see what whether we actually need this and whether immutability is important there and then maybe convert it to a builder or just a feasible type, and then let quarry respond to that. We could take another look, a Thursday and whatever I mean.

D

To me, just just getting rid of the interface seems fine, like drop all the eyes and- and it looks reasonable I mean it doesn't like yeah, okay, so delete async has an object that is theoretically immutable, but it's probably not going to mutate it and it as the interface it wouldn't modify or wouldn't matter anyway and yeah so I just don't think the interface is adding anything I'm, also not sure if we actually want to do the complicated structured options on this one, as opposed like everything that I saw looked like it was just HTTP headers.

D

So it seems like you just want an extra headers collection if it's more complicated than that then ensure. But we're gonna have the same problem on this one that we were talking about with the system that connections one, which is. How does someone know what keys and such to use if it's just headers, that's easy? It's headers, they're public.

B

So, at least in this case, I was like this one like odd scenario where you didn't want to send like more than like a Hydra value. It was like a boolean value that configured how the HTTP response was being read and I. Think it's listed like up there. So I mean it's something that the HP client and whether simply already does so it's not something that, like I'm, not saying that it is correct or like that's the best way to go about it.

B

It was just like if we had that feature, and we had to use this as a way to configure it. Like you know, he having a named option would like or having a strongly that option kind of help. Stir the the headers do like, like I guess, like libraries that care about the headers would like all these options would have like static types that exposed slim. So you know so you would have like a browser request options or something like that could have like all of these keys in there.

B

So and then you know, they'll specifically, look for it and it kind of makes it easy for a user to use it and for the library to conceive, on the other end,.

C

One other thing to keep in mind as we're reviewing or revising this is I'm. These objects are already heavier weight than we would like, like you should be request message already. Has we've been trying to trim it down when trying to play internal tricks to reduce state? I will probably still continue to try and do more. So anything that increases the size is a little concerning just because we're we're using these more and more in situations where we actually care about. You know as much throughput as we can yet.

B

What would be the way to address it like if we do want to introduce like a first class API? In addition to this, like just cannot.

C

B

Would be sorry.

C

What option would be to yeah, just as an example? I'm not sure we should do this, but if it was purely a wrapper around the existing non strongly typed properties, then we would basically just be reusing the existing thing any paper play.

C

You know, there's already a fields for that properties, or maybe we reuse that field and we do something where, if you just use one or the other, you get to use that field and we cast into the appropriate things and if you use both well, then you pay for that and.

E

We allocate some.

C

New objects to store both there's something along those lines, because properties is very commonly used so that it's just something to keep in mind. I'm, not saying it's a deal breaker, it's just I want to limit how much more we, how much more state we shove into my default.

B

So for the plea to release like just because laser didn't require shipping, some of these API is like. We ended up using like the property bag and, like you know, a bunch of like private. Like a you know, a well known key that the laser implementation and the web assimilation knew about, and you know using that that works kind of well and out. But then I don't know how well it scales for, like an arbitrarily large number of libraries trying to like work on it.

B

C

I'm not saying I'm against the strongly type of thing I'm just saying if we can find a way to to not grow the state by default. That would be great. So that might be that we changed the existing field from the collection that it is to an object and we allow it to store either the strongly types or the non strongly typed.

C

We only bloke both it may be that we store the strongly typed inside the non strongly typed or you know we can play various tricks, but it'd be great to think through the design, the implementation as we're thinking through the design. Just to avoid adding more overhead. For this. You know scenarios like being used in a reverse proxy or folks that are trying to kind of just get as much throughput as they can using. This should be clients.

A

So what I'm hearing then as it is, what it is.

D

Didn't understand that, but it's back to ya the questions that we I.

B

Guess we can focus on the like what the abstraction would look like to configure it. um Just like I, don't hear anything, anyone saying specifically, if like adding the extra parameter to like all of these methods, it's problematic it's just. How do we actually expose it.

D

I mean yeah I, don't think, there's any way that we can get good per request things without adding the members. So that seems fine.

D

You can say again: I, don't know that the interface is buying anything over just having the type and and then Steve's is about implementation, which I think can all his comments could be done with the shape has suggested here. I.

A

Mean it is a bit of a.

C

If this is all sort of more advanced stuff, and it can be achieved, if you had the one property on the HP request message or folks that do want to tweak these per operation things, they can't just use the overload that takes an HTTP request message.

B

So if you scroll it down, that's a scenario where, if you were trying to electrically, have, for example, something else pretty use it, but then before it sends a request like something else: produces the SCP request message for you or there should be content for you when you want to assign this on top of it. So I guess appeal. Why.

C

Can't you just if someone hands you, they used to be request message you can modify it.

D

If the request options is public, you can just called and the options that you want. I think.

A

This in our that he has in mind, is more like the HCP extension methods, one where you'd never see the message right. The extension methods directly create the options and you mainly send it off. So this is an example where you basically would change to get from a Jason, a Singh extension method to take a request options because I love wise, you would have to do everything by hand, but that doesn't necessarily imply that we need to have well delete a sink and get a Singh and send a Singh right right.

D

So the yeah I mean the extension method. That's based on you, know, URI and and such obviously the the input would need to come from somewhere, but yeah I mean if we think that this is advanced and somebody who wants to do it is already building a request message. Then that doesn't mean we can drop all of the modifications to HTTP client and just add it to the Jason extensions and then the the one property on HTTP request message: I'm.

A

Not entirely sure, like last time, I looked, it seems like they're still somewhat of a steep fall off, though, if you like convenient wise, I'm, not sure, that's what we want in all cases, yeah.

D

I mean that's sort of my recollection as well, but then it makes me wonder if that just means that all of the places that we think that existing like delete, async taking a URI is easy. But building a message is hard that we need to just make building messages easier.

A

Yeah, maybe I mean I mean it certainly seems concerning right, because next time we need to do it. Something else. We again add 12 overloads right, that seems I mean not 12 but like for five I.

C

Think the intent of those those methods on HP client is their. The the trivial superfast like all you want to do is specify the URL and then oh yeah, I cancellation, delegate and anything beyond that. Is you start getting into the realm of you? Produce HTTP, request message so then, adding in these one-off options for this or that that makes me a little nervous.

A

Any thoughts from the hpid members I.

B

Mean at least of webassembly, like most of the scenarios, probably revolve around sending and receiving Jason, so we can be happy with to have Jason to start with and then like. If you do end up getting a lot of feedback we're like you know, people are trying to like use, delete, he's, saying or something like that and need to configure these options. We can always add them later on, like it's not a.

A

It seems for the web assembly scenario that probably so rather than paralyzing, that both of them prioritizing delete async at a sing and Sunday sync. It seems you're better off prioritizing some extension methods over the options from I collect like this set browser request. Cache, for example, rather than asking people to go through, the generic you know add key value pair API.

A

That would probably improve his ability more than the other ones.

B

Sorry I didn't fully follow this.

A

So, rather than like, it seems like what we are saying is the read async, async and sentencing overloads the take request. Options are not that important right now, but for web personally, what seems more useful is, if you ever have to add extension methods over the request options type to make setting whatever the Weathermen specific settings are more convenient, so people don't have to go through the generic key value pair API, because if I go request, options dot add like how the heck am I finding browser request options to begin with right.

A

I could just have to know that there's another tile that holds onto these keys right.

A

That seems to be more useful for their bottom scenario. At least.

D

Yeah, so it sounds like the minimum is the options class they get from Jason async and the request options: property on the request message.

B

Right so I mean it wouldn't be limited to get from like it might like it. Also like the post and delete I just didn't list all of them just because there'd be the same pattern. Sure.

D

So the Jason extension overloads the request, options, property and the request options class.

D

F

For wherever the keys come.

D

From for the initial supported numbers right.

B

For I guessed excitedly, you think you don't necessarily have strollin, because you can always configure DHCP request message. If you really need to like you. Have you have that message.

D

Messages are only used once right, yep.

B

Like in this, like I, think like T or your design bear like the type was he's like how the semblance of immutability made it like difficult to configure it, but if you say like it has API so like I, do it like that problem is solved? You don't need you don't need to explicitly pass another thing to like figure out how to merge, because you just set it on the request position. Yep.

C

So, just to clarify you can use request message as multiple times: well, people don't and the fast path helpers will new one up each time, but you can't create a message and send multiple times right.

B

Now I was saying that, like in the in this in this current iteration or at least and there's API proposal like T, the option property on request message was an IP request, options which was immutable like the like yet, but if you combine them like that, goes away.

A

So basically be able to just have our h-e-b request options. We would merge temp of the interface remove the interface, remove the overloads like delete async.

A

D

Remove all the modification stage to be client, I.

A

Guess it's true I'd just.

D

Send a sync takes the message: the message had the options that also removes any notion of a merged policy, so it it makes the API easier to reason about.

G

C

How do we rationalize sorry? How are we thinking about rationalizing the existing properties with the new one, I mean effectively. We are talking about two different property bags on a message when it's just struggling typed and what's not.

C

Is there a design where we don't add anything to a street request message, and we just have like you know if you want to pull one of these out. This is the name that it'll begin and you get out your request options from that I'm gonna. Try to balance. You know usability for the common case with usability for this or for the broader case, with usability for the blazer case. I guess.

A

My question would be I mean in order to the only reason why would have to split would be to say if, in cases where you don't construct the message, you basically have another thing that you can pass in like the the jason case right, but in the normal case yeah there probably isn't a lot of reasons why you would choose the options over the message.

D

But the the properties is already there's already an existing property named properties, which is a dictionary of string to a knowable object. Oh.

A

D

A

Asking the generic property back that we already have. How do you work inside that with the right.

D

So because it sounds like it's published, some well-known string keys instead of using the the type as the and or or.

C

Or I mean there's the middle ground, you still have the interface or whatever and there's a known key to pull out that from the property bag. So you don't add another property names for your quest message. You just say: if you want this object, is gonna be living in this property back then that has downsides as well I'm, just trying to think about how there's there's now two different things and neither of the two shall meet, and it feels just walking up to the API. It feels weird I mean.

A

Unfortunate thing is we decided to make the property bag generic right so as I dictionary of string comma objects? So it's very weird to pause that around and it makes it almost impossible for us to add extension methods over it. I mean we could, but we generally don't like doing that right. So I guess one takeaway for me would be every time you had a property back. We should have a very specific type for that and not some, you know, generate connection type, but.

D

We can certainly, we can add, you know, set cash option which just uses a well-known key and sets the thing and get cash option, which just does the try get value on the well-known key, like the fact that we have diction or string object like it, doesn't really change anything other than theirs. You know if somebody uses the same key and shoves the wrong kind of thing in it, but right.

A

D

A

Guess my point is that I think the to the way it's designed right now is so if we want to add a strongly typed helper for a request option, we can just define an extension method over HTTP request options or even add the API directly onto an HTP request options right. That option doesn't quite exist for an addiction area of string, comma object right, that's kind of I! Think where the problem is I mean.

D

Given either the question Steve asked or the question that appeared in my head after I was following up on what Steve was asking is we already have a per request properties right.

A

D

An open-ended property bag keyed by string, we don't need another one like we just need to define more keys and what they mean. I guess.

A

My question is it's a it's fine. If you talk about the HTTP message directly right that that falls a little bit apart when you have things like the JSON API away, you want to get the options in as an argument. Okay,.

D

C

Well, unless you do the middle ground, which is you still have the request, options thing and that can be stored into the properties, I mean.

A

One thing we could consider is having the request: options, implement I dictionary, a stream column, object and then just make the properties itself settable on the message, and then the semantics are whoever constructs the message just assigns the property back and then it's literally the same thing.

C

A

Fact it could go a step further and say this property that we only have we'll leave it, as is the market editor plausible? Never we had a new property on message. Options make that strongly typed and make the properties effectively just return. This guy, then we have literally one storage. The new thing is get set and strongly typed, and that should solve most of the problems. Then yeah.

B

That seems like a decent idea.

A

Let me try to sketch this here in the editor.

H

I

C

A

I'm sort of projecting, but it's via YouTube, so it's a it's a massive laser.

J

Projection right.

A

But how can you see that Steve I'm here walking around somewhere.

C

A

You're, looking at your phone I see.

C

But it also means that switching between teams and the browser and then YouTube is not the ideal experience. I can.

A

D

This is possibly a terrible idea, but I will try to help Steve out, but I will share YouTube.

C

I've never doubted you Jeremy yeah,.

D

Oh and now, YouTube sees YouTube, which sees YouTube, which sees YouTube.

A

So let me change the syntax here and zoom in.

A

It's kind of what I was proposing.

A

I guess, strictly speaking,.

C

I'd be willing to bed and we can look at api's usage to see if I'm, right or wrong, but I'm going to bet that very few call sites actually populate properties.

A

An API apologies is used by 6% of apps.

C

But it's weird having two things.

D

You know I wonder if it's just gonna be a bad experience for people as they straddle or if they straddle versions or like well. Upgrading like, on the one hand, I see the argument for hiding it. On the other hand, I see one for not hiding it and then maybe we just mark it obsolete and say you prefer the options instead, I.

A

Mean either one works for me, I mean that's.

D

A

So what is the Dom sense of hiding.

A

Sure reveal keep hops leading it, which creates a warning for.

K

Everybody that seems.

I

Good still works, fine, there's nothing saying not to use it and you have to tell them. You see it so you're, just very confusing, quite hidden.

A

Yeah I mean works, for me, I mean in this case generally speaking, I don't like hiding API is because when you call them it gets annoying, but in this case like why would you ever use properties? If you have options right, they really isn't the reason. In fact, you can treat options as an addiction area of string objects. So, even if you pass it around I mean.

D

A

D

So I don't know what uses anything on properties right now.

A

But if it's not following.

D

The pattern of using the the type name of the value as the key, then you would need to use property still to get legacy. Support.

D

Yeah so I guess, if you're on net five, because it is the I dictionary string object as long as we don't explicitly implement that interface, then just using options would give you everything. Properties did including non matched keys and values right. So.

A

I mean what I like about the design is that it composes very cleanly right. Basically, the semantics is for things like Jason. You just construct the message you assign the options directly. If you work with the message you just work with the options there, it's it's it's strongly typed. It can be strongly typed. We.

D

Make a public try, get value extension for our dictionary, I believe.

A

We might have I think there isn't it. This collection, extensions thing that we have yeah.

D

So, in that case, we should instead of try get of two value. It should be try to get value of two value, so.

I

D

Try get and try get value.

A

So we have trying so which one did you ask for triad well,.

D

So we have so as its proposed right now. The the get that uses generic inference you or the the generic get is just called try get, but if we have, if we made a try.

E

D

Value extension method apply to I dictionary. That means in intellisense, you'll have tried, get and try get value, so I think we should make it try, get value and try to get value.

A

I'm still confused, so what are you suggesting exactly renamed.

D

Line six from try get to try get value, yeah.

B

So this would match the dictionaries.

A

Okay, so now they're basing overloads so.

D

One takes a string and the other one takes a to value, well, an option key up to value. Where do we define option key.

A

I might have dropped it from there I. Don't.

D

C

In the proposal, I, don't remember, see sharp over over lock resolution rules if there is a generic on the instance and an extension with the concrete type that's being passed in which wins it.

A

Depends on where T is usually like in this case. Did he is bound right, so the t is bound to string already, because that's what you're implementing so it's basically Novolog between string and HTP request options of the generic from the method right.

D

My recollection is in through any kind of is that the evaluation is first done with no regard to extensions, so if, if it can work with an instance method that will always win I mean if it's you know, even if you had an exact type match on the extension method and something took object on as an instance, the object instance wins is my recollection. There's.

A

Also Trulia, if it can bind on the instance I, would prefer that.

A

So, in this case you have, we has to retest options. Key coming form is that an existing type I, don't think so. Alright I think we could design this as a strongly.

B

A

B

Think I missed like adding it to the AP. Are you.

A

But would it be a struct, oh.

A

It's probably it's just a struct based wrapper for a string right.

B

A

Then it basically holds the the thing in the actual tire brain.

D

Presumably it it's just a type safe reference to the type name.

A

I guess it's Julia like.

D

I assume HTTP request options. Key of to value just produces a two string, which is to value that full name.

A

It just means you can't have two keys with the same type, not sure you want that, but.

D

But I think that's what we were talking about for the connections. Api is because essentially that you're, just putting in the type as the key and getting back the the singleton value as the value yeah.

A

It just means, if you want to define something that is of type end, you have to kind of define your own struck. That just holds an end yep which not sure that's better necessarily but yeah. That's the implication.

A

Yeah I guess that would be good to define right.

D

Yeah I mean I. Guess one option is that it's struct HTTP request options key of T and it takes a string and then another one could be the default which just does the default like so I can just it can just be I'm. An arbitrary string wrapper that is carrying a type just for generic inference.

A

A

Mean the genetic influence one you get one way or the other right, but that's it.

D

So I get value is out to value value because you know I.

A

Guess that's true.

A

Do we want to try, add what do we not care? Well,.

D

I guess so the question is, is add, a door is add square bracket, I.

A

Mean if you're deriving from the ninety Canary, it better be known. That's.

D

D

Yeah I also don't know it needs to be builder pattern up, like this add returning it. This feels weird, given that the other ones void, I.

A

Groove that as well.

D

Yeah, so if we're having an ad then because I dictionary just says, use the square bracket for replace syntax right, there's no named version of the square bracket method, indexer, that's what we call them. There's no named equivalent of overwrite.

B

No there's no replays I, think yeah.

D

B

Can I indexer be generate like I think that was maybe why this hard to be ad.

D

D

Can't think of I don't know it to not be allowed, but maybe isn't.

D

I guess the problem is the indexer. You want a different I guess would be because it'd be this of I.

B

Mean it has to be like Kiki and I. Think I couldn't write the generate constraint on this.

D

Yep, and so that may mean that we need a method named set which I dictionary doesn't have, but it would just build the string correctly and then use the the indexer.

D

But we can't I mean we could have a triad which would just be calling try get value, but that makes it I don't think we would want to do it because it would be more expensive than it looks. It's a double dip method, inherently.

A

Yeah I mean I'm, not sure that performance is the biggest problem here, it's more like the semantics you want to have right. Do you want multiple parties to replace or do you want there? Do you want everybody to basically say if there are it's already there I'm, not overriding it.

D

Right so I think add and try get value like together, that's triad, because that's all that triad would do is called try get value and if it's right false, then it would call it had, but I think we need set which, if we can't have the generically constrained indexer, then we would need to name the set method on this type.

A

All because you can't constrain the indexer, that's true right, I mean another way. We can do it. We can just say the implement I dictionary explicitly everywhere, and we just only expose the API as you feel we should expose the.

D

Problem with doing it explicitly is the falling back to existing things where the I guess it's, because this isn't taking the type as the key it's taking a random key. So you could build your own key using the right value.

D

So, yes, it could just explicitly be AI dictionary, I, guess.

A

Can even go a step further and remove the inheritance hierarchy and just added an implicit conversion and returned some internal stuff or some private stuff and have the public API just forward. I.

D

Mean in as methods probably more f-sharp friendly, I.

A

Guess it's true I mean we could do both video.

A

Alright I think that's enough. I guess terms of feedback.

B

Sorry whoa: where did we land on the explicit implementation like? What's that recommendation I.

A

Guess the problem is, you need to define like what like big, because, basically, if I should be request, options implements an ideation area. The question is: do you want all the api's or nine dictionary to be in the public surface right like, and this goes back to what I said earlier about what semantics do you have because, like what do you want people to assume options like how like how do you want them to work with options? You want them to set everything or do you want them to try?

A

Everything and a dictionary is not necessarily communicating that very well, because if you open intellisense, you see like the typical dictionary methods versus in your case Chrome. They only have two methods and I'm not sure what you intended ad to do. If you intend an ad to behave like a dictionary ad, meaning it's those when the keys already said, or did you expect that to be, you know if it sets it, if it's not there, and it adds that otherwise and so I would kind of decide on what the semantics are and then based.

D

A

B

To be said, we should name it set right.

B

Yeah, like maybe set, would be appropriate here, like I, don't see like people trying to like build entire pipelines, usually like the idea is for you construct something you pass it on to something else, and then it goes on its way like we're not trying to build like pipelines of somebody configured something in my authority.

E

B

Gets passed on and then like not trying to build a whole Middlebury pipeline here.

B

So maybe it's just calling it said short, suffice for now and then lead to an explicit interpretation.

D

Yeah I mean I. Think generally, we found that explicit implementations end up making something more painful than it should have been eventually, but in this case it's probably fine I mean.

A

Keep in mind, you can always make explicit things, implicit things right. It's more breaking change, so I mean.

D

I'm just looking and thinking so we have these strongly type things and then we have like it contains key string right and it it does feel like. We have a good reason for having the addiction area of string object here so that we have compatibility with the existing API, but that really that's a compat detail, not a public detail, so yeah.

D

Say am I explicit, might be better and, as you said, we can that one we can undo.

D

All right, so the HTTP request options key. Is that just a structure that takes a string so public struct HTTP, request options? Key T wraps one string with a string constructor.

B

Right does it? Is there one which generates the key did okay from the type like so.

D

We'd have to use a named static method on it, because if.

A

A

Yeah because you kind of parameter list constructors, instructs right.

B

Yeah I guess like it's just something that takes the string, that's about it. Yeah.

D

I mean if we expect them to be instantiated once ever, I mean it would be a it could just be. It could be a class wrapping the string instead of a struct wrapping. The string gives the default constructor and yeah walks through one more indirection to get there, but that's not the end of the world seems.

A

Almost like you're one string to be always present.

A

Because what do you do when someone didn't spend you could just use the full name, but then yeah like the idea. You were that you never need another one of them.

I

B

Mean which, for a lot of these things, might be true right, like you're setting credentials through casual or all of these options, they would there's only one of them and you're always setting them like it becomes interesting. If you start wanting to send like bulls and like more primitive types, I.

A

Guess that's true! If you, if your types are compound already, then they're publishing news by that I mean in the end it's probably doesn't matter one way or the other, because, as Jeremy said, you very likely define a static type. Some ever you define all the keys. So whoever doesn't just pause it either a string directly above it which is done by our name of or they type it out. Right, like it's probably doesn't matter like.

E

A

If you were to add a creative method, I'm, not sure you're typing or you save that many characters but I don't care so.

B

One small sort of question, so if you happen to cast as the guys options to a dictionary and then you shove like a like a different value in there and then try to call try get value like. Is it fine for it to throw like cast exception? Yeah.

A

You would reject in I mean that's kind of the same thing happens of a race right when you have an array of customer and then somebody costs it to an array of object and then assigns into it. Then you get in I forgot what the exception is. You are getting, but basically you get a type mismatch exception that.

D

A

D

Yeah I would try methods they're supposed to have a clear answer of what false means and so having to try to get the strongly or the generic try get value return false. If and only if the string wouldn't return, false is good and then, if the string will return true, but it's the type doesn't make sense, then yeah, that's a invalid cast exception, just hard cast it and let the runtime deal with it. Okay,.

A

I mean I would expect the API here to verify that you can't put in an object that doesn't match the keys type.

D

Well, the set is guarding it from them the runtime type system. This is, if you turn it into I, Dick, ssin area of string, object or I. Guess you can make you your own HTTP request options, key of cache settings with the correct I?

D

Guess if you make it of cache settings, you'll get that so you make an HTTP request options key of potato whose to string produces the same one, that the one for cache settings would and then you save a potato now when someone asks for request options, key of cache settings, the type is wrong, but the value type is wrong, but the key matched, and so now we have a weight, bound conversion problem, I.

A

Guess that's true because you yeah, if the dictionary really holds the strings anyways, then you have no way in the setter to actually verify it right.

L

A

I think that's fine I mean it. You can either yeah I. Think people want to check on taking things out, then, which seems fine. It's not grainy.

D

What falls to mean it's not there or it's the wrong type, no.

A

I yeah, you can I mean all I'm saying is you have to verify one way or the other, and we can either decide that it's a fault, so we can say it's a throw. I would probably go over through all because to me to I get value means is to thing present. Not it doesn't have it right. Type and I.

D

I agree with that, in particular, it means the to try get values. Don't disagree on truthy this.

D

Yes, I can use words.

D

All right, so did we make request option key a class so that we can reject null or as a destruct and default is just very unfortunate.

F

A

D

Dictionaries itself gonna request null, so the default would presumably to string to null and then well then the underlying dictionary would throw of hey wait a minute I'm not allowed to have no keys so that.

A

Seems fine to me I mean use a default key. You should expect it to not work anyways right, fair.

D

Enough so I guess yeah. It can stay structure, strongly type string.

D

Emo, please put the L in the access modifier for HTTP request options, so it turns red.

A

We went in the L line.

B

A

I'm glad nobody made the obvious joke.

A

D

I found a polite way of saying it all.

A

Right but I think we have enough feedback for this API, which was all fast review. Ironically, yep.

A

So I guess we can consider this approved in and then we can say if cauri has any concerns you.

G

A

Bump it back, I.

A

Scalable score: I am.

A

A

All right, I think at this point we need to be honest because it's 11 I am somewhat skeptical that we will go through. I cos will object entirely.

A

So if you are here for the logger, I would suggest come back Thursday because I don't think this is going to happen all right, I castable object. Apparently you want to give us the the spiel on what this is. Yeah.

L

So this is basically a way for types to participate in the caste operation.

L

This technically doesn't really make a lot of sense in most cases, because metadata is static and if the metadata doesn't have the appropriate type, then it's a very simple question: you can't cast to it or you can.

L

There are scenarios incom specifically, which is I, don't know, I can't I can't Qi for the for every known gooood, it's just not official, so this basically says well, let's not try to generate all of the the GU, the our CW's statically, let's kind of be a little more flexible, so it's kind of like a you know, a dynamic interface addition to metadata.

L

It's basically what it is this. This concept exists in the.net native world and got net native static, CR, rst, W's and C CW's, and we're trying to bring some of that slowly into dotnet core.

L

This is kind of an extension of the comm wrappers API that was approved, moved in dotnet v. This is the RC W side of that, so that I don't need to know. Maybe I don't know at all the types it's the I have a hidden interface on here that isn't, in whatever description of my comm objects and I want to be able to query if that's really what it comes down to so.

A

As you can so how this is different from my custom, query interface, isn't because it sounds very similar to what you're describing.

L

That's true, so you do things like that. The downside is that I custom, query interface does not participate with a c-style cast in c-sharp.

L

So this allows basically what our built-in are CW and CCW system supports by allowing casting on an object and that that you don't that would add an interface, the interface metadata to a type at run time, instead of ahead of time, if you, if you scroll down, there's an example.

A

So how is this costing support coming because C sharp is not a way of I castable object when.

L

It is not that's true. This support is, this is a runtime. This is, this is support. That would could be added and say, you've written some sort of object, and if you hire hot, if you can, you have implemented I castable object and during the cast c-style cast and c-sharp, it says nope this doesn't exist and you implement this interface. You have an opportunity to say: I do are I can make that determination at runtime instead of just letting the runtime determine it from the metadata.

D

So presumably the only valid targets of this are comm types.

L

That is the canonical example. Yes, well.

D

I think, if the, if it was a if it's returning some other managed type the like what would it mean to say, the runtime thought I didn't fit in that hole, but I totally do with a type handle instead of a an object. That feels like the system's about to burn down.

L

Basically, what it allows you to do and we can have the you know the theoretical conversation. If this is relevant or not, or we want to do this, but it basically says types can now.

L

Participant asks for something, and they want to. They want to permit that operation to happen. This is actually safe, they're, either with the well. This is only safe because of things like default interfaces like we're really leveraging a lot of the new c-sharp language features that allow us to implement this in a safe way.

L

If you notice and I hope, it's obvious, or at least.

E

L

They're, the only type that you can return is an interface type and the only and the only reason that works is because you can return interface light because now, with default, the the with the default interface feature you. The an interface can have implementation.

D

Okay, so effectively, this can be used for you had to do a lot of work, but you made duck typing work. Yes, what would happen if you didn't like if, if an interface had an unbound member I think is it gonna? Do late binding on the on the object to find a compatible slot, or is that unstable or is that a throw I guess I want to know if we're adding something, that's doing like blind, vtable six jump, no.

L

It is not so if you look at the in in the actual I got a proposal, there was some debate. What is what is the failure case here like if what, if someone decides to do something very cheeky and try to trick the system- and we investigated that an Eleanor who's actually already has an implementation up and linked against this was able to say, was able to mitigate that in a safe way and basically it'll fall back and say this doesn't have an implementation for that slot. So.

D

The cast will still fail the cast yes.

L

The cast would fail.

A

Which cast would fail the the cost to bar or the cost from basically the object to I food I flew info. Sorry.

L

I thought like.

A

Where does it yeah? Basically, where is the failure point here? The.

L

Failure point here would so the failure point here that the the concerning failure point would actually be inside of the call me function, that's what I thought.

A

L

Would be that would be where it would be fair, like everything else. So if we just look at this from me, I'm not calling any function, I'm, not calling any functions on I foo it the when I cast a B to I when I cast the bar to a I foo. At that point, there's really it's all types. It is correct. We have the appropriate I, guess method table for a knife ooh when we dispatch to it. One of two things is gonna happen, one.

L

It's going to say this interface has a default implementation and it will call it and we'll enter the I flew in pull right.

F

L

B, it will say the I foo imple does not have a default does has has no implementation, therefore, I'm going to throw method not implemented. So.

A

Against my other question is, maybe I'm not seeing it, but it seems like we're going out of our way to make something couple in a different way. I guess I mean how is this different from me implementing I foo directly on bar, because it seems bar already has to be aware of Eiffel anyways in order to implement this get interface implementation method. It knows about I for right, so it still can't extend bar from outside of bar. So.

L

Yes, I think conceptually. That is the that is the canonical example, because metadata is that, but the example that we were using here is the RCW concept. So, instead of instead of calling this bar, let's just assume that it was underscore underscore a comm class or underscore underscore comm object in our CW, so I don't know, and all I have that's associated with that underscore underscore calm object is an int pointer, I.

A

See you're saying the the implementation of get interface, implementation isn't actually hardwired to some interface. You'd have some other mechanism. You look at some other things, and then you know that all yeah this is other ifou over there. That I am supporting yes,.

L

Exactly this is a completely contrived example. This would. This makes no sense you're absolutely right what you would also see it would be sticker, be if interface type equals whatever and I've cue ID on some sort of hidden state, and it says yeah I do that too well. Now, I can do something so.

A

But that means I foo imple has to know about bar, but not the other way around I. Guess yes and then so when you said that perform design action on the disappoint, her I assume she sharp things. This is of type I fou in pole and then I just confirmed a basic just do a hard cast. Yes,.

L

And if you look at the implementation- and I fou call me in the Eiffel imple there are there- you could do any number of things. It's entirely up to you, but your point is taken. The best pointer is typed as an Eiffel imple, but it is really a bar.

A

And if I the concert, I'm recording I'm not causing any recursion problems right.

L

If you cast it.

A

But just do a normal c-style cast two bar right.

L

Because what it will do is it will look at the actual, this pointer and say: oh I'm, a bar I'm, okay, it's only when it does. It's only win. All of the built-in casting mechanisms fail. Okay,.

H

D

All right, I think.

A

I understand it now: I yeah this.

L

Is fully accepted, this is a very calm esque problem like it really is, but I think I think mr. Fowler actually did ask about this.

I

L

Can is this something that we could do with dynamically expanding a type and like theoretically? Yes, you could I, don't don't know if that I would advocate, for that. That seems like a Pandora's box of your making system very complicated, but if there is some value to it, then yeah you could do that. I.

A

Mean I would say, I mean I can already think of 100 ways how this would be useful, but I mean to me that yeah, the question really is like what are the? What are the boundaries? Big I mean people in the chat are kind of ask you the same question and I.

A

Think last of it we talked about this as well like I, Castle object sounds very generic and very appealing right, and so how much of this stuff is tied to calm calm like does it work cross-platform, for example, and does it work with any interfaces or are there any restrictions that are not outlined here? No.

L

This is actually like this, this unblocks an entire column scenario. Yes, that is true, but it is not bound to calm in any way, shape or form, and it.

A

Works for any interface, there's no history.

L

D

Any interface that has the castable object implementation attribute on it.

L

A

I meant like module. The attribute have to put on the interface. Are there any other restrictions? I cannot extend any other interfaces, or do they also have to have this attribute on them. So.

L

The so the attribute that we're adding is only on the returned default interface implementation, not the actual interface you're casting. Oh.

A

Because you I see so you basically yeah I see so you basically yeah okay, I get it now so.

L

We're basically saying this: AI interface is a part of some sort of castable scenario, and it needs to adhere to these constraints and that's almost entirely for the link ability, yeah.

A

Well, this is really your poor man's version of basically just implementing the interface but you're doing it by extending an interface with an interface and adding a default implementation to it. Yes,.

L

And this would never have worked without default interfaces like that. That is a key key feature. Yeah.

A

That makes sense to me cuz. You need an end to him. Mapping there so.

L

Just to complete I guess, maybe for the whole historical thing, dotnet native had two implementations: they had AI castable and then there was also a castable object. Implementation. The AI castable did not have any restrictions, because at the time there was no way to provide an implementation to an interface in c-sharp. So it basically said give me any type and I will let you do your job, which is very, very dangerous, because you could have fields and you could have all sorts of random problems.

L

There was another implementation which was castable object, which was a abstract base class and it had a bunch of private state that allowed you to store things and that allowed you to again to cast to any type in this case, because we have default interfaces, we could very tightly restricted to saying it has to be an interface type that you return. It has to have this attribute and we know that it's safe, because we we are not gonna, have any field accesses. We're not gonna.

L

Have any of these other problems that a class by definition exposes or can expose right.

A

When it sounds like a pretty much, it will work for any interface right, because the interface itself head doesn't have to be marked right. So it's only the in the in by me providing the implementation for the interface. That's when I have to mark my own implementation for that, but that's pretty much it so it should literally work for any interface and pretty much any object so long. The object and implement I cast a blue object right.

D

So the yeah, essentially it looks like the interface with the castable object. Implementation attribute, is using dims and this attribute as making a wrapper class, but don't ask it for complicated things, because it's not a wrapper class. It's dynamically interpreting this pointer. Yes,.

L

D

And so theoretically, this means like just just thinking through experience, if I foo extended I other and someone didn't explicitly register I other as the target. If they went through, I foo first the cast will succeed and then, when they goes to I other, it will explode because it can't figure out how to take that object and turn it to an eye other, because it's it's a bar, it's not actually the VI foo in pull or is it or is the does it know it's an eye foo in pull at that point or.

J

D

If you were so I foo interface, I, foo, :, I, other okay,.

B

D

I have I, have a bar and I do I, cast it into into I foo and then I cast that into I other, with this being exactly the same as it is right now. Well that second cast succeed, or will it fail because it sees it's a bar, it asks good interface implementation, it says I didn't handle I other, and then it fails so.

A

Where's your eye bar like it would be I other it's here on this line. It.

L

Would be it's not in there he's saying essentially.

D

Think of that I foo was an interface and some other assembly and someone added a new base interface to it. We wouldn't do that in the BCL, but let's say it's third party: oh.

A

D

What happens so there get interface, implementation explicitly was against I foods type handle which is fine and a cast has already succeeded to I foo, but now, if something is turning it into an eye other. So like you called a method that took a knife ooh, it does the dynamic thing you get, this middle interpreted, rapper class and then it passes that to a method that takes an eye other. Does any conversion happen at that point and does it succeed or fail so.

L

I, okay, so let me just ask this: the the I foo imple implemented, I fou. So if I foo extended, I other than I foo imple would have had that information right right.

D

I'm just curious what state the type system is in at that point. Oh I.

L

Got you well, I foo imple would would have I other that's fair, but it wouldn't have any default interfaces for us, so it would say that function isn't implemented right.

D

But let's say it was just a marker interface and therefore everything just worked that I had no methods so I'm, just wondering if the call site after you get back the I'm cast this to I foo. Does the runtime think of it as an I fou when it goes into future, casts or does it think of it as a bar which wasn't actually an eye foo, but things just kind of worked? Oh.

D

So you have the bar. You passed it into a method that takes an AI food that passes it into a method that takes an eye other. Does everything work? Does something explode in the middle mysteriously? No.

L

My I would I more than willing to add actually, if Eleanor's on the Eleanor's on the call Eleanor have you have you Bala dated what I did.

G

Try that so, when you first pass it over, it will just say everything: works, I am and I bar, but when you, if you actually try to use it for some method that doesn't exist but to your point of it, it's just a marker, I believe it'll just say it's. Fine, okay, I.

D

Mean yeah, like the notion of like you, get there and there's no method like that sure I'm just curious. If the, if the iPhone s is a real I foo or if it's a like as long as you don't squint or as long, you don't look too closely, we'll just make the syntax work. I, don't I, guess I'm, just curious that we've thought it through I, don't actually super care. What the answer is.

C

Is there a analyzer that goes along with this to make sure that eyes are dotted and T's are crossed that you don't hit these blow up situations.

L

What can you elaborate on the blow up situations? Well,.

C

You make a mistake in that there are lots of things you have to do correctly or you have to be returning an interface. You have to have attributed that interface as a castable object implementation. You have to have provided default, implementations of all the base, interfaces, methods and X&Y ins and so on there. So it seems like it's pretty easy to accidentally. Not do one of those things.

L

Right sure, that's a that's a great question so of those three that you mentioned, which is the attribute on it and the you must return an interface. Those are runtime checks. If you try to use this will blow up immediately, so no invalid type has been returned from whatever, so you won't get very far with that. The the state, the final one, which I think is a is, does probably warrant something which is the we did. We have not checked if the interface that has the attribute has an implementation for all the functions.

L

That is true, but that will blow up say that blows up safely in the sense of you haven't implemented this function or yeah you haven't implemented. This function, call where.

F

L

That blow up that blows up at the dispatch.

D

So, at the call to the method that doesn't exist, yes in our current type loading universe, when you, if somebody adds a method to an interface and the type doesn't have a compatible entry, do we look failed all with the type or do we fail to dispatch to the member.

H

We fail to load the type so.

D

I wonder if, for consistency that check should here, but maybe you have a performance reason why you can't do it here.

L

Me Hall is me: Hall did all the default interfaces? Is there a way to detect, if enumerate all of the methods on a on an interface and make sure that at least one and at least make sure that everyone has a default implementation.

H

Yes, even we could do a simpler thing like we don't even have to go through the default interface resolution logic, because you know the whole default interface resolution logic also gives you variant casting support and variant interfaces which work I. Don't really know whether we want to deal with that. Maybe it's nice, but I, don't know, but you can definitely check whether everything has implementations kind of when we other default interface methods.

H

We opened the Pandora's box that sometimes you call an interface method and it doesn't actually end up calling anything and that's kind of in the diamond case scenario, if you have, if you have an interface method that is implemented by two different different default implementations or more and kind of when we are trying to do the dispatch, we will throw an exception instead of actually calling something so kind of that. That's when we opened up the situation that you might have something type to some interface, but you cannot call the methods on it.

D

Okay I mean, if we have to do it late, bound late bound if we can do it early, so it looks more like a type load failure. Then that feels like it would be probably more helpful to someone, because the the failure is closer to where the action happened, which is you know, like Steve's, analyzer suggestion, but also, if the that helps you at compiling your type. But this is the case where the interface was defined by else and yes and the BCL we never add members to them.

D

But if somebody does add a member, what what story happens and can we make that be reasonable, but that's implementation, details.

C

Question on this sample is there any the visibility on ifou imple, the public? Is there a reason it has to be public as part of this, or is that just.

L

Now that was I did that because I think in the example oh I actually got rid of it. In the example, I had a an assert in there that I wanted to demonstrate, and but no it does not have people.

C

L

Would I would yes, I would I, don't know why anybody would do that, but.

D

L

D

Can certainly write in the analyte we can make the analyzer opinionated and say: don't don't put this attribute on a public interest.

C

D

It's also nested and I feel like you, have interfaces as nested types, but maybe I'm just misremembering. um You.

A

Totally can't you shouldn't, but you totally can in this case it makes sense, though it's influenced if it's a private time.

D

So, on I castable object, you have a boolean parameter, throw if not found I recommend you remove that parameter and let the caller deal with that.

L

That so so that function actually does two things it does. The as Andy is.

D

Right but you can the the call context would know which one it is, and it would just know whether default being returned, that it should throw the.

L

Call context doesn't know: okay,.

L

L

So the implementer needs it basically needs to be told. Is it okay to throw or should I throw a cast or should I do something else, and it doesn't know, is it needs to be told, is? Are you part? Is this cast operation a part of an is, or is it a part of an as why.

C

Wasn't um why wouldn't this sorry I missed the beginning of the discussion? But why wouldn't this be a try method and leave all throwing up to the runtime.

D

um Yeah, that's sort of where I'm going with it, but I, don't think even you could do it without the try, because runtime type, the default runtime type handle is presumably always invalid.

D

C

Communicating back here is the type handle you should use or I couldn't get one in a non-throw anyway.

D

Because if the.

E

D

Supposed to handle the I'm supposed to throw that means we'll end up with potentially non-standard exceptions, non-standard messages they have the boilerplate of, if throw throw. All of that feels like the one thing that called this has enough data that it should do it all in a standardized manner or the two things. If one of them's is, and one of them says, yeah.

L

Well, I guess the question comes down to what stopped it from doing that cast like that's the question here like if, if we go down the QI standpoint, let's continue down the calm approach, you're on the wrong Department.

L

Well, the the one of the most annoying things in calm is when it says cast failed was like well the cast really failed, but that's not the problem. The problem is is I'm on the wrong thread, and so you never tell me that, and therefore I'm kind of like well why'd the cast fail and I spend hours trying to figure out. Oh the cast failed because it's actually on the wrong thread. It had nothing to do with the cast so.

D

In your in the our CW's or the CCW, or whatever some sort of CW, your throw, if not found, is, is doing something different than someone would do. If they're doing this late bound duck typing for I mean it's not exactly duck typing but yeah. It's late, bound, dynamic, cast they'll end up with very boilerplate looking code, but in your in the comm layer, you're doing something different yeah.

L

Like it depends on how your any comments that, obviously, what we kind of talked about canonical example,.

E

L

I think that your point is fair. Let's say you're going down the not using comm I'm, just being very cute and I want to add interfaces. I want my object to support every interface and so I dynamically generate whatever. Yes, I agree with you that in that scenario, it's probably fair, but there is a whole slew of what are we really trying to expose here, and this is the unknown. Interaction between another system and a caste is not necessarily the appropriate statement of failure. So are you hoping that folks will customize.

C

The type of the exception that's thrown or the message for the invalid X cast exception that started I.

L

Guess it would be, I.

L

S I'm having trouble determining the difference, I think I think there probably is cases where you may want a very specific exception distinction, or there are cases where no I'm gonna use an argument exception and it's gonna have a custom message: I, don't write.

D

But is, is the runtime then gonna? Take that argument exception and wrap it in an invalid cast exception, or is there an argument exception going to have appeared literally out of nowhere an.

L

Argument exception is going to appear at that moment, so I.

C

Could say if a is foo and the implementation could have chosen to introduce an exception at that moment? Yes,.

L

That is true. We would never. We would always past false, like that.

C

L

Yes, you're, absolutely right you, you know, people could say no I, don't care what this bool says: I'm, throwing an exception every time. Yes, that is true when.

D

We're in this path can we treat it like Cece tours and just always wrap it in an invalid cast exception with context of whatever got thrown. If it's not an invalid cast exception, so casts are still always invalid.

D

Cat I mean it's weird that there is, would let any exception leak, but certainly it didn't return true or false, so so it has to throw but I wonder if letting arbitrary exceptions leak out of this is weird like that feels more like at that point, it should throw one of the nasty things like a seh exception like I'm. Sorry, someone did something terrible we're done. We couldn't answer is yeah.

L

I mean I think I have to like look at the performance. Characteristics of this I think that that, at that point, trying to put all that boilerplate around there to handle everything is going to impact that pipeline.

L

A

I, don't know I mean I think this goes also back to what we think the feature is forward. If you think of this is a interrupt kind of feature, I am okay with saying: don't don't throw unless throw, if not found it's true. If it's false, when you throw well, then you have buggy interrupts code. Don't do that if you throw anything but a limb with a cast exception, then you're doing it wrong. You shouldn't do that either.

A

You should always have him at the cast exception and maybe customize the message so that you know consumers always get cast exceptions or not some other render exception, and then that seems fine, but if I mean the thing we said last time, which is kind of where I was heading earlier was I. Canceled object seems like both in naming and in the behavior you kind of described as a you know. Yes, it's Interop II, but it seems like a very useful feature.

A

I can see being used more widely than you might want, so that kind of means. Maybe we should make it a bit more. You know I had to say it but kind of idiot proof where people can't accidentally do the wrong things because I'm kind of concerned I get this is used in some. You know advanced thing like, for example, our.

A

You know our CW's, that's fine, but if we, if we use it as a generic feature in let's say a spinet for example, then it would be pretty bad if people now get Rendel behavior, because people just implement these methods incorrectly yeah.

D

Like it would be very weird if you've you know written, if a is I foo and.

A

A

And it's those argument null exception because that's how we're.

L

All right, I fully agree I.

D

Mean there could always be a different version of this and you're calm generated thing and the managed objects coming to it, that the managed objects go through more structure and the calm one gets a fast path that you know, you're not going to cheat in so I.

H

Think the important part is still say that these are exceptions that will be thrown from the is ends cast class and unbox and maybe maker. The type reference font and kind of the exception that these are allowed to throw is specified in the ACMA spec, so kind of throwing something new out of there could potentially break tools like isn't failing, I'm, not sure if it will be able to.

H

That would be something.

D

Else for an analyzer on this is: are you throwing somewhere other than a throw away, if not found block? Certainly it won't understand, throw helpers, but- and are you throwing something other than one of the approved exception types so that'll at least help.

H

You not allow the exception to leak out unless it's like one of the allowed ones, which is just invalid cast exception, really like it, isn't, there's not not allowed to throw yeah.

D

And so that's sort of the like, if it can just do the like, hey I, called this wait and there's a new exception pushed on the stack and I'm is like great kill the process.

D

Like we're done, throw an uncatchable runtime exception, we're done. Someone did a bad thing. Oh.

A

The Destiny helps diagnose the Diagnostics, but yeah it's certainly at least food doesn't procrastinate. The problem tells.

D

You to stop writing your bad cast map yeah.

A

But I mean but I think this is the problem I like that, if you, if you use these things in a more complicated higher-level like I'm, not sure the the thing now crashes at the right point right, you might have changed something unrelated that causes this thing to misbehave and then what's.

D

A

I mean the question is also like: you're taking runtime type panels is any reason you can't take types and return types. That's.

L

An efficiency decision I.

A

A

Mean I'm kind of fine with the behavior you have, but I I think we should probably not have an a name as catchy as I. Castable object right.

D

I mean yeah, I was the best I've come up with so far is I dynamically castable.

D

Because I castable object sounds like object, like objects can be cast, I mean.

A

Normally I try to make interweb names better, but now I feel like I'm kind of want to make it worse. So people don't think of this as something that is easy.

L

A

Or the Evergreen I known, maybe.

D

L

So actually, what you said I, maybe I actually did consider calling it I may be or what is it? What was I also did I I am I am maybe or something like that it was like I had a bunch of those you know, other other languages have those maybe constructs and I was I tried that right, I couldn't think of anything and and I chose. You know we chose I got I, cast a logic cuz, that's. That is what the community knows as the concept from the done that native world.

L

You know the people that are interested in this feature know exactly what this is for.

A

Yeah I mean like that yeah I've know, I mean I'm, not I'm, not concerned about those people I'm more concerned about the the casual web developer, who thinks it's now in need way too interfaces, and maybe.

E

I'm overthinking this.

A

Because it's still not super convenient to write but I.

L

Mean I, don't I would be very surprised. Here's I guess here's. Why I think that this would I hear I hear the concerns about proliferation of usage. The thing that it comes down to is the implementation of the default interface right. Your people are going to get into there and they're going to realize the limitations that it does yeah.

A

So here's what will happen I can guarantee you is. Somebody will build a DI based system that implements this thing once and uses a DI container to find interface, implementations and then that method will do whatever it does and it might crash with random exceptions. Like oh.

E

Yeah that that that.

A

Will definitely be a case and that's that's kind of a my concern is coming from where but I guess like making that name shitty will not stop them from doing that. Yeah.

L

A

You put it in like interrupt services, and we have like you know already the flow that we have here. We take one time type panels and stuff like it's. It seems certainly Interop in the way you use it. So you should expect interval, P style constraints as well. I mean somebody in shed suggests I call rapper castable object, I mean that certain is meeting my bar for ugly enough, but I guess it still makes sense the way it is here.

D

Yeah, just that I mean the name, is I cast a bow object it just. It feels like. It applies to everything, instead of a corner case that I call rapper, castable object or I dynamically cast. The ball at least feel like it's something other than just the normal cast that this is a another thing happening. If.

M

I, if I can I will put in a vote for the I dine a mcli castable I like that, because it encompasses the concept, while also not being the unsalable yeah.

D

I mean I didn't have to look up how many elves were in dynamically, but once you get to I did and you just hit tab, so we all have to get it right once so.

L

I dine a mcclee castable would be a preferable term, which I'm, I think is reasonable. It's I.

A

Mean I, don't I, wouldn't mind if having the interface some. It would be also not too bad, because it's really about interfaces right, I mean yes, you have an object implementing it, but your body really casting to as an interface right.

I

D

Yeah I, dynamic interface, castable yeah.

A

Seems reasonable I mean that's describing what it does without looking super attractive, I.

L

Interface, castable.

A

Let me type this up, because there's no way I can replicate this. I dynamic interface.

A

A

Yeah, as I said earlier, that meets my bar for ugly, okay,.

D

I think the current proposal put this in compiler services, but it seems more like interrupts services, yeah.

L

Yeah, this was all of these types. The previous implementations of the I castable logic was always in compiler services, but moving it. It seems reasonable I mean.

A

This is cuvee excited which revived manually right for the most part.

E

I'm sorry say that.

A

That is code. We expect people to write manually, but that's not code, that's generated anyway. Is it oh? No.

L

You would well, you would expect a code generator to implement this, but.

D

The the normal c-sharp compiler is not going to really ever use this. That is correct. Yes, would.

K

The compiler need to recognize it if it ever gets the casting support.

A

What you mean by.

E

A

Support because I mean the idea is, you can just cast an arbitrary object instance to an arbitrary interface and the runtime will do the glue right, yeah.

K

Right, but that requires you to cast object. First, no.

I

D

I think it's the compiler right now will warn I I see that there is literally no path where a bar can turn into a knife ooh. Why are you casting this? If.

A

You call through bar all right, if you soon, as you call through an interface or object, which is that the same, the compiler will no longer give you any warnings, yeah but I. Think in practice you always go through an object or an interface right. You will never be on it on a concrete type.

A

Aesthetically I mean as far as the compiler is concerned,.

L

Sorry is that you're saying that the compiler will Ward if we try to use this so.

A

If you have, if you have a type called like an actual derived type of object, let's call it bar right if the compiler sees bar and you try to call it to an arbitrary other object on arbitrary other interface. The compiler will first check. Is there any interface hierarchy where this can be true? So, for example, if bar is sealed and you cast to another type that doesn't derive from bar, the compiler will really say we'll give you actually narrow and say that cast will never succeed.

A

If you cast to an arbitrary interface and the type is sealed, it will also say: well sorry, the type is sealed and none of the bases.

D

Are this interface.

A

So they will never succeed either so.

D

If it's an unsealed type, then it would.

A

Say: okay, the interface that I know yeah.

D

Then it'll usually say like oh well. This could be anything and the interface could be anything so I'm, just gonna, like whatever I'm gonna. What the call happened.

I

D

Only like right after a new where it knows what the concrete type is or if the type is sealed that it would be like, there's literally no way this casts and can succeed and you're like yeah. There is go through object, so.

L

A lot of the implementation or the examples that we've been using have gone through comm wrappers, the comm wrapper API, and that does return an object so.

E

L

We haven't sees issues: okay, yeah.

D

Yeah, since all the comm stuff is in system runtime interrupt services like I, don't know that the compiler would ever really be able to make use of this, because it would essentially need to evaluate the the get runtime type handle to figure out what it would have done. So I don't see that ever having language support, so it seems good I would.

L

Be very much I, don't want the compiler to participate in this I think that's kind of our point. Yeah yeah.

M

I will say: I'm thinking about one of the scenarios. Where would where this would be used. So one of the scenarios is WinRT and with one RT, a lot of the types are sealed and we would want to have the I cast the eye dynamic interface, castable implementation on each of the on some of those sealed types. So we can do the casts so that error might come into play because some of those objects are just straight activatable. They can just do new, whatever right.

D

But that's I mean that's the compile the compiler I guess could gain support that if something implements I dynamic castable that it assumes it never has any idea what the cast restrictions are, but I think that would be the extent of compiler features here. We.

A

Just need to be careful.

D

A

Can't do that later? Probably so, if we ship the type now, we can't ask the compiler later to say: oh no, everything that implements this interface. Please change our behavior. If you want.

D

Everything to produce that uses this interface stop giving the error on that. You can only give it limited circumstances anyway. I think that would be fine yeah.

A

I mean you can try a bit. We should least bring it up for them because, usually, if you want to have behavior change by the presence of some interface or some type, you want to usually do them in conjunction a better I mean yeah I. Think that's reasonable, I think. If what you said Jeremy is true of intervener T. It would be probably helpful to have an example with the compiler team and say: here's here's, the static type declaration, here's the behavior that we want and they would be motivating I, guess, yeah.

D

So I guess it's try, try writing it, where you have a sealed type in the same assembly and and you write the new and then and immediately cast it where it will go through this thing. If the compiler produces a warning or an error for that telling you that it knows that it's not possible, then now you can raise an issue with the compiler team of hey. This new interface means the runtime will do different things with casting remove this means no longer or you can't produce the warnings anymore and they'll probably be like sure.

D

K

Also not too far off the path of the existing common Interop support they have where they special case things like outs and racks and everything else. If you have to come import attribute.

L

Yeah, so a quick I guess just to bring it up because it is comm mask or is involved in the comm world. Is the I? Didn't it died, a dynamic keyword? Is there any concern here about the since its I, dynamic interface, testable or cast?

L

Do you have any feeling on? It almost seems like that's related to the dynamic keyword, I.

D

Mean it's sort of related to the dynamic keyword. It's.

L

G

D

Don't know like magic happens now, and you can't ever predict what it's going to do and you really really really hope it works at run time I may be in the run time you have a stronger feeling of what dynamic does, but to me it's icy.

L

Snow me dragons semantic equivalence in your mind. Yes,.

D

It darby dragons. I.

A

Mean your notion of dragons a minor nowhere near they say: I can be with dynamism. I can't deal of Aimee's I mean.

L

Okay, I guess my only my only concern there would be. This has nothing to do with the dynamic keyword and I would I would be very I. Don't want people to think that it like if you slap dynamic on there, this will participate. This has anything to do with it. They mimic keyword, there's no implementation overlap. There, you're not gonna, get into some performance with dynamic. As a matter of fact, if you use this and dynamic you're gonna get some weird stuff going on.

A

Yeah I guess I agree with that. I mean to me. Dynamic is kind of it's not a very specific feature right, because then that you know that the notion of a dynamic behavior is pretty widespread through all our system.

A

So I wouldn't be too concerned about that. Okay,.

A

I mean this would be more I think for me, a constraint if it would move it to compiler services again because in the interweb services it really is a runtime concept right and the interval. The compiler service is more like a language, compiler kind of concept and yeah in the language world dynamic has a more specific meaning that in the runtime world, I guess but I mean if somebody can think of a different prefixes dynamic, then maybe, but.

A

Because if you just say interface, castable or I interface, castable into interface, custom implementation attribute, that seems also now lost in the noise I mean.

D

If I feel, like comm, uses the verb dispatch, maybe this is more of a dispatch than a caste, and so maybe its interface dispatchable, okay,.

L

He's learn to pick up.

A

L

That, for next time,.

A

Cool that was easy, um so let me just throw up the thing that I have right now: I think you on YouTube so probably take ten seconds for you to see.

A

And there it is apparently.

G

A

In chat says: well, we sure had a dispatch. Well, we don't hate it. Just really complicated.

L

Yeah I I'm fine, with dispatch I just there. That word is very. That means I dispatch. It means nothing else. In my world yeah.

J

And it seems that's that's.

L

All like I I'm, fine with I dispatch but yeah it's it's.

A

Basically comes version of identity of dynamic as well right, so in that sense, it's not really making things much better.

D

Certainly, this wins no awards for naming but, as mo said earlier, that that has actually value in that it doesn't win awards for naming yeah.

L

I think this is a very reasonable API I. The naming seems reasonable. I'm glad that everybody seems to be on the same page here. No.

A

I, like the feature, I, think that's a it's a good feature.

H

L

A

Right then, I will just copy paste this guy into the issue and then I think we're all happy with this.

C

C

If throw, if not found, is true and the implementation doesn't throw, what is.

L

The runtime do a great question, then it does fall back and just do the the castable there's been thrown so.

C

As implementer of this I, don't actually have to throw if I don't want to, I can just always return default if I couldn't successfully cast and the runtime will do the right thing. That is true. Okay,.

A

It's worth pointing out, then: um okay,.

D

A

D

Presumably means that for anything other than the comm dispatcher pretty much it's bool, don't look at this I. Think that's I think you could make that argument, sure that that the recommend that implementation would be just returned default and let the runtime throw the standard exception.

L

Yeah I, don't think that's unreasonable, but.

D

That, if you have additional context that you can provide of why the throw failed or of why you're failing such as comm you're in the wrong apartment, then then that allows you to handle that case. So that's Doc's and samples, yeah and.

C

The only other thing beyond Docs and samples, maybe but I, don't really care strongly is we might choose a different name for the parameter, conveying why this is being invoked rather than one action. You should take.

L

You know, oh I, see throw side of things yeah.

D

Yeah I sort of had the same like it'd, be nice. If this was explaining the MIS or as.

D

But I couldn't come up with a good name for it. So I was uncharacteristically quiet, I.

A

Mean Beulah's in woodwork right, but it would not be very great, probably.

C

If you can come up with a better name or I,.

L

Think that's fair feedback. I think that we can. We can definitely figure that out, because.

D

Then it especially if it moves it to its sharing, what the state is instead of demanding a behavior, then that would go with the hey. If this is the state that represents the actual cast and you return default, we're gonna throw the standard exception for you.

L

Yeah III think that's that's good feedback. Well, I think we can apply that pretty easily yeah.

A

D

A

Or ass to me, yeah.

D

I guess really: it's is.

A

D

A

D

Is it as hard cast yeah, but maybe those mean different things in the runtime than they do to the language.

D

Anything else Steve.

I

A

Wasn't done yet.

L

Right now, I think Eleanor would just hit merge. Dammit.

A

D

um Yeah, so we did mention that there's definitely some room for some analyzers here. Do we feel that that is part of this feature or just a nice to have I think.

C

Given the audience, it's probably nice to have it best: okay, just long cuts, just because we expect I mean how many can I count on one hand the number of people that are going to implement. This is not at five. You.

A

Might need to, but still that's still seems, very low I.

L

Think two of the people are actually on this call. Their names are Tanner and Jeremy I. Actually.

K

Don't know if I will be using this just because most of my rappers are currently bloody, bold and I'm. Not sure that this that the RCW is the right way to expose that, from my library, I'm still trying to figure that out.

E

Okay, so we're literally down to one person, who's going and.

M

I might I might be using this twice possibly three times, depending on a new source senator for Tom, okay,.

D

So it analyzed it would have value, but the audience is so low that we don't need to commit to it. Well,.

L

We- and we also are planning on the Interop team- is planning on putting an analyzer out there. So we can definitely add this to the list.

A

It sounds great, then things are gone and then for Thursday we will do the logging thing so I'm, Mary I'm, sorry David, didn't happen today.

L

Well, thank you all appreciate it. Thanks.