.Net Foundation Design Reviews, 19 Jan 2021

Previous Meeting Next Meeting

⏯

youtube image

►

From YouTube: JSON DOM (2) and Index/Range methods for Linq

Description

Powered by Restream https://restream.io/

A

um Internally is stored as a adjacent element. I mean that's, not obvious, but we, but that's why we have this get value of t. If we ever change internal implementation, it would still work.

B

Right, yeah interesting, so the so I guess the other methods you get from ilist and- and I dictionary is all the mutation things right, add or remove right, which presumably are all public apis not explicitly implemented. So you can actually add a member to an array. Remove a member from an array- and you know.

A

That works awesome with dynamic, because um you know you just call add or remove or whatever you want on it, and you know we'll it'll just find those methods on you know I list or I dictionary if you're not using dynamic, you have to then know it's a json array or json object. You know or cast I list or I dictionary. If you want and then call add.

B

Yeah that makes sense.

B

Yeah, I guess I need to think a little bit more but like normally when you have a dom like there is um again. I guess I have to look at sample code like I have a hard time seeing because logically, it seems like all the interactions are likely going through json node, because um well that's just the way. Things are right, because that's the gives you the indexer for everything and then, when you want to mute it, you would have to downcast to the appropriate parent container in order to.

B

Do any meaningful modifications, um it also seems your dom does not have a parent pointer right. You can only get to children right, but not to the.

B

A

In the chat anyway, paste a link to.

A

A

Well, I I just some of the examples.

B

um I guess my other question is like you have an indexer on jason. No, that gives you an index, but how do I get the count or length for that matter?.

A

um Well, in that particular case, you would have to cast, if you're not using dynamic to the appropriate type.

A

Again, the indexer was recently added based upon feedback um where it was too difficult and too verbose. I guess to um navigate down a hierarchy so.

B

I mean I get that it's just like it seems to me like, if you want to enable navigation through json node then like what would make sense to me is if you can generically effectively enumerate the contents of a json without knowing whether it's an object or an array, but that would still require some level of you know.

B

You know, I don't know, keep it like, like a collection with like key value pairs, or you know the actual keys you can pass in. I mean I guess for keys. I can kind of buy that the idea is you know it already, so you you know you pass in name or first name, but for an array it seems weird that you know the dimensions up front.

B

Like I mean most of the time, I would think an array is unbounded, so you would think it can have n number of elements, and I have no idea how many elements it has in practice versus for the for the for the key values it's like. Well, you know this is my schema, so I expect them to have first name and last name and an address property right, but for the for the for the array, I would think a length would be probably necessary if you want to make that.

B

A

Okay, um if you want to scroll down to the next section, I think I have some examples.

B

A

A

Yeah, it's just showing um very short samples on on how to call.

A

Serialize, nothing too surprising here, um however, this section is there because there is a serialized method added to um jason node. That is a helper, and so I have equivalent longer versions here like if you didn't have this helper.

A

um What you would do so I'm proposing that for the simple cases anyway, that we um add some serializing and a static deserialized method as.

A

B

Okay, yeah, I don't have super strong opinions. I just have this gut feel. As I said earlier like to me, the it seems a bit weird that the dom holds on to serializer options and you know implements effectively civilization itself. That seems surprising to me, I'm not saying it's wrong, it's just what I would not intuitively expect. I would expect the sea level to be kind of like you know.

B

You know kind of like a higher level if you will over the over the dom, so that the ceiling is aware of the dom and like will do the right thing when you see last adjacent object or you deal as a json object, but I would probably not expect to find a serialized method on the objects or the options, but I'm not saying that's.

A

Completely optional, it was just a proposal to simplify these common scenarios, but.

B

Yeah, as I said earlier like, I would probably expect like a parse or a load method or something that they extend on the on. You know as a as a static cl, a static method on json node.json object or whatever the corresponding api is and then get back. The dome from there.

A

And instead of the d serialize, you mean or something in a you.

B

Know I think I think you want civilization support. I mean like if you still has a dom. You would expect that to go out as jason right, so I think the city that would have to special case the dom, no matter what. But I would say as the as the entry point, I find it weird to deselect as the only way to get the dom.

A

The the parse method that you're, referring to with that.

B

A

B

I'm I'm wrong. I just think it's cheaper. It might also not be true but like it seems to me, like you know, the jason is just you know effectively just parsing or the dome is just parsing right, so it's just basically going through the reader and then constructs objects as it does it, which is like. I would think much cheaper than going through civilization,.

A

Yeah, I I I hear what you're saying definitely um the jason element and jason document types already have parse methods and there's you know, there's a lot of them. There's like right, dozens of them, or at least a dozen and it's possible. You know to use those and then pass that in as the value, if you want. I don't think I show any examples of that. Whether we want to have um you know mirror that those parse methods on this type. You know I'm completely open to that.

A

um This just shows maybe the more simpler model where you um well simpler in the terms of keeping the api as small as possible right that they're, not there.

B

Yeah, I guess a very common example where you wouldn't call ciolas directly would be you have. You know, let's say your actual object like customer or whatever, and then you have this. You know json object directly on the customer as here's, my fallback for all the other json stuff. I don't want to talk about in my api and uh you would expect that to work properly right. So in this case people wouldn't directly call your list of json object.

B

They would just implicitly deserialize it because it's part of their api right or part of their data content memory, I'm going to call this right, and so in that sense yeah. I know it totally makes sense that the closer is a way of it.

A

Okay, bigfix screw down this talks a little bit about get value on. You can specify t um cast operators.

A

This section is just saying based upon discussion um that we're not going to add any cast operators by by default. I mean I decline a record.

A

And I have some rationale for that.

B

I think that makes sense, I mean you would get it when you use dynamic right, but outside of dynamic. I think my expectation would be that I mean an explicit cost, maybe but an implicit cost for sure not.

A

Yeah- and this has been different than other implementations that have casts and and of course you can only have the implicit and explicit casts if you know what the other type is right and um since this type supports are, since this programming model supports custom converters, where you can bring your own type and your own conversion, you know it wouldn't work with any of those.

B

A

But if you don't care about the performance hit from dynamic, you know the large assembly in the runtime performance. um You know you pretty much. You can do whatever you want at runtime. Regarding casting, um I mean as long as um basically as long as c sharp understands the type that you're trying to convert to either because the variable is of a certain type or you add an explicit cast, then you know it'll just do that, for you.

B

Yeah, I think it has been a while, but I think, last time I looked at json.net, I believe the dom supports explicit cast, so you can effectively fish out a string or an in directly by just casting that is not, I would say, intuitive, but looking at the api. So I think it's always good to have a get value of t method so that you or you know, I think he calls it value of t or whatever, but like uh basically strongly typed api to get that.

B

But uh you know once I saw a sample code where he did explicit cards, it was actually somewhat readable. It looked somewhat better than the get value in between. So that's what I'm saying, I think I'm I'm personally open to explicit cast because they still occur, and you know the failure. Points are clear in your code, um but yeah implicit costs seem very bad.

B

The only thing I'm not sure of because I don't understand necessarily like what that means is the idea that you can cast to custom types, because it seems again, maybe just some weird but like it seems odd to me that I can, you know, navigate the dominance. I'm doing that also dco lies into my custom types. That seems, I guess surprising to me, but.

C

I mean that would only work if you use dynamic.

C

Or wrote a cast operator on your custom type to go to or from json node.

B

C

The language would say it doesn't understand what to do with this.

B

Yeah, I mean steve listed it under non-dynamic right so like. If you do this here, doesn't that effectively do something that basically just just got this deceleration.

C

I don't see how that would compile.

C

uh I guess if value returns object, but then it's still going to do just a runtime cast. It's not going to do a dispatch or a change type or anything.

B

C

B

Yeah, I guess that depends on the behavior of video. I think I asked that earlier and I think steve said something to the extent of like no value can totally return your custom type because you're standing on the civilization options, so you can deserialize.

A

I think the way I have it here is that json array of sub index one or index one here um you're creating the json value of a custom data type and then, when you're accessing that in the line highlighted you're asking for the raw value.

C

A

C

Getting back the one from the assignment.

D

C

Yeah yeah so because it was a list of object, so you're you're getting back that object. But if you deserialize this, then it's nonsense and that would never work.

C

But that would depend on if json array.

C

On the indexer to turn it back into uh an object returning one instead of a json node one right, so the.

A

The next line that says order to support a possible conversion is um is, is a call to get value where you specify the t, assuming that the value is convertible, then you, instead of a cast, which you know, would only compile or run time and only work.

A

If um you specified the actual type, the get value would support a conversion in theory the next you know, basically the next line of code that you have highlighted.

D

A

So it's kind of like an explicit cast, but it's not because it you know it actually will. It might have to call a custom converter and do some other hoops to get that value.

B

Yeah, I guess I I would generally expect explicit costs only for, like you know, primitive types right like things you that are basically part of the json schema right strings ins. Floats doubles right things there we have intrinsic understanding for everything else would be yeah. You have to call get value with your custom t if there's a custom converter behind it. That seems fine.

A

Yeah, so this example, with the cast I get highlighted, is probably not the greatest example, because it wasn't intended to show something that we're doing you know just kind of comes for free right. I mean there's no explicit cast.

C

Well, I mean so is your intention that json array, the indexer that it exposes, is it returning json node or is it returning object because the base class has adjacent node one? So you have to decide if you're implicit, if you're, using new and implicit binding for the interface or, if you're, doing explicit and letting the json node dis, lift up for which, which line so the my custom data type v1 equal cast of jra1 sub value is? Is the indexer exposed off of json array without going through? I list?

C

Is it the I list one or is it the json node one? Oh.

A

You have conflicting.

C

Indexers, so only, and only one of them can be the public one.

A

Right, um I believe that this will call the indexer on well. Let me see adjacent value.

A

C

Because um because I list of objects, says you have to have an indexer that returns object and json node says you have an indexer that returns json node, so only one of those two can be the in the public indexer. If your concrete type is json array- and I can't tell which one you intended it to be.

B

I mean, I would generally say like it, needs to be the one from the base, because otherwise this guy is only useful for one hop right. If you want to do json array of one and then oh, that's an object now, and I want to access the first name property. You would expect us to to write j array of one and then of first.

C

B

And so that doesn't.

C

And in that case, in that case, the the line with the hard cast would not compile, because you would have a json node or I guess sorry, j array, sub 1 would be json node. Then you get back. The value value is, I think, also json node right.

A

No value object; okay, so to just return the internal object. I mean we can change the name to internal value or if we wanted to do something to make it more clear, like no.

C

That's why I just I remembered value being another decent node, because uh yeah that would.

A

I guess so value won't. Do any conversions. It just returns, hey whatever you, whatever I'm wrapping return, it.

A

And then, if you want a possible conversion, um you call get value on it of t.

B

Yeah, I guess I think this is the thing that confuses me. It's like it's! It's a bit weird to me and I haven't really thought about this in great detail. So, like I'm not saying the api is problematic. I just I just haven't done it in my head that when you look at a dom that you know there is a there's, a vague property that is basically unbounded and the customer can put whatever they want into it. um But I guess that's the behavior you have right.

B

Vader is just a pure storage for you of type object right.

A

B

A

Of this again is influence by the dynamic support where um the the value is determinant. Basically at runtime, not necessarily known to compile time.

A

I mean, for example, you can have a custom convergence registered um dynamically, which may may cause issues even with non-dynamic support. If you mix and match you know the t value with the incorrect custom converters or with incorrect json or you know, the internal value.

E

B

um And do you know what json.net does like does json.net dom have access to the converters, or is that something that you just have to pass in.

A

I um I'm pretty sure they will not I'm pretty sure that it does not work that way in noon. Soft.

B

Yeah again like to me like what I would intuitively understand with the domus, I would say it seems fine to have conversions, but I would say to me they only make sense for the primitives like basically or like you know, intrinsic understood types. I mean that don't have to be primitives in the json sense but like I think it makes sense to say you can pass this json string as a date time because we happen to understand day times or booleans or guides, or some other type that we think are common enough.

B

But, like it seems a bit weird to me that you can say you know, give me this json value and now convert it to you know my custom data type and when I'm doing that, then you know it may call through some json converter. That seems a bit like to me. That's kind of at that point.

B

You kind of blend the world between the dom and the serializer, to the point where I can't differentiate them anymore, and that seems, I think, that's kind of where my mental struggle is because, if you only think of read, I can kind of understand that.

B

But as soon as you think of read and write, I have a hard time understanding what the semantics now are when you put stuff back, because it seems like now, you can corner yourselves in weird ways where the structure of the dom and the structure of my objects don't match anymore right and now I have some really inconsistent state that I don't know how to reason about anymore.

A

I I do I I hear what you're saying again, I it all comes back to again. The dynamic support is like that right um and you definitely might want to have a custom data type work with dynamic without going through extra. You know I.

B

A

Depends on what you.

B

Mean by dynamic right I mean, I would think to me. The dynamic support would be based off of the schema so like. I would generally expect when, when I, when I do dynamic like I can, I can access the thing as it is in the in the you know, in the structure of the json document, so I can say dot, first name dot, last name or whatever the property names in the underlying json are right.

B

I would not expect to say uh you know, dot whatever, and then the property names now become, whatever my properties are in the corresponding. uh You know schema that I happen to have in terms of custom objects right.

B

Does that make sense? Like I mean to me the the so the dynamic.

A

D

B

Way to avoid the the string based indexers and casting right.

A

Well, it's it's trying to equalize the playing field for intrinsic types and custom data types in in this design right instead of hard coding, only types that we know about is saying you know we have this options class. It knows about all your custom data types. You don't have to know. Okay, um you might not even know what the custom, if you have a custom converter, I mean, if you have a custom converter for time, span.

F

A

Which you know stored as a string, saying jason um with with the proposal here forget about the none dynamic for a minute, but with dynamic. You know you just go time span. You know time equals whatever the value and it'll just work, and if you didn't have that you would have to know. Okay time span is not supported internally.

A

I need to now call a different method. You know maybe maybe some sort of deserialized method or helper method, I'm not sure, but then the intent was to equal um the playing field between custom data types and internal types, and also we have a bunch of internal custom converters on the serializers that we continuously add, for example, that and that do not work in json document and json element, because json document json element don't understand. Custom converters are the serializer in general right.

A

So there's a ton of types, including custom, collection types and um even things like you know, enums um that just won't work.

A

Unless you, you know about the custom converters.

B

A

B

Fair point, although, like.

B

Yeah, maybe, as I.

A

Said we'll spend any time thinking.

B

A

Yeah yeah I mean this was intended for discussion. um You know this meeting before we create you know. The official api we might have to have another on discussion definitely need to clean this up and to reflect the existing prototype and some feedback here, but this is the first wave. So it's good good to have these discussions.

B

Yeah you just go to gut feel right. So, like I spent you know the last hour thinking about this for the first time right, so don't read too much into what I'm saying. I'm just saying my gut feel reaction is x and that might be as wrong as they come right. So um yeah should we go further or is that enough.

A

um This section is not important: it's just some some ways to simplify the api with the with the options. So yes keep scrolling here, let's just kind of get to the end, and I think we can skip that um we're talking about indexers here, yeah. Here's an example of.

B

Yeah, that's what I meant earlier. Yeah.

A

Without that the example below is what we had previously in the previous iteration, um something like something like the below. You know it's like. Okay,.

B

That seems completely reasonable to me, like.

A

Yeah, so this was this feedback here um was from the azure team that you know they wanted a small turf syntax which they have in their prototype.

F

A

And you probably won't recommend using ours if we didn't have it.

B

Yeah I mean like that. I mean between these two, it's kind of obvious that you want this one. That's why I said earlier like I understand why you want navigation on the base.

B

I guess this is an example where you don't have to know the length right, because if I now basically assign it to the array you know 25, it just means that you effectively fill in. I don't know, 23 elements with zeros, right or nulls so makes sense.

A

um Let's go a little bit more, getting close to the end here, um just kind of cover everything really quick here um yeah. This is just saying: hey. If you want to change the, if you don't want to use json element, json node will provide a way for you to use um this writable dom these variable dom types instead of system instead of um json element.

B

A

B

A

The overflow bucket we have for extra properties that don't map to any clr. We put those in a dictionary and that's shown below here. You know, string, comma json, element or string, comma object, dictionary and now you'd be able to specify um string, json, um node or or just have object, be json node instead of um json element.

B

That seems a bit weird to me to be honest, because if, if, if I call enable dynamic types, I only have the behavior, if I say object that you give me back json node right rather than json.

A

Instead of json element.

B

Yeah, so I think it seems to me like, if you call the nemodynamic types, I would argue, it should always imply use json node for unknown types.

B

I think I would not have the middle ground where, if you say decellizer of object, you get back json node, but if you have overflow, we still give you back json element. That seems weird to me.

A

It could perhaps break some code um if you didn't have this option.

B

A

B

You break the code anyway right because, if you say enable dynamic types, you change. What object does right.

A

But but you could have the mode where you want to support where you don't want to enable dynamic, so yeah yeah so you're talking about if you actually call the method to enable it. We just do this automatically. Okay, fine, this! This is uh more, I think, makes more sense when you don't um enable.

B

Dynamics, okay, yeah- that makes sense to me.

A

Because it is, this is a common scenario. I don't think it's covered here, but it's just an area where you have these this overflow dictionary, which is kind of cool. You know that we create this dictionary if you're missing properties. However, that's kind of immutable in order to change a bill, you have to remove an item from the dictionary yeah and then add it again um or overwrite.

A

The value of that particular dictionary element- and that's just not very, I guess, intuitive, so it would really help with mutable dom for overflow properties or, basically, if you just want to change the the value of a of a typing return from system object, you can't do that today right because you get your element back and it's like. How do you change it? You can't you have to create another one, and how do you create another one? Well, it's complicated. You have to have jason and and parse it.

A

So it'll help with a lot of edge case scenarios.

B

Yeah, that makes sense- I mean yeah using this without then any dynamic types. I think I agree. It's probably very common.

A

The the missing versus null, if we want, if we're ready to move forward to that this is also based upon some feedback from previous mini review.

A

A

This is saying that we're returning null instead of some other um missing property, like jason element- actually, I believe, has on missing. um How does that work.

A

A

Yeah jeremy, are you there? What what is what is jason element? Does it have support for missing? I I! um No. If you ask for a property, that's not there. I think it'll throw, I believe, my recollection yeah yeah yeah. So um if you want to differentiate between missing and null, there are ways to do that and that's what this example here with try get value is doing.

F

A

Care about hey was this property in the json or not. You can still figure that out, but the default is that it will just um be known.

B

Json is destruct right.

A

Yes, that that's why yeah they have this missing.

B

Yeah, I think for dom. I think null makes more sense to me than um throwing.

A

Dynamic by default should have null semantics, so this kind of aligns with that. um We did get some feedback on this early on that it is expected to return null instead of throw because the the type um xmando object throws.

A

If you access a property, that's um not there, which is kind of counter-intuitive, because jason you may or may not know, because jason might not just include it if it's not there. So a lot of people do not like expandable object when it comes to processing json. Because of that semantics, and today it's not possible to change.

B

A

Either case we're not using expand to object, but that was a discussion that we had around issues with dynamic object.

A

Okay, so the rest, I think, is examples there might be some issues or something I'm not sure at the end, but.

B

I mean I'll say that this reads fairly.

B

Nicely the only thing that's.

E

B

Sad is that people have to know that they have to instantiate the.

C

Dynamic versions.

B

Of those objects, but I guess.

C

B

C

What does my array dot my object being yeah? That's what I was wondering too.

B

I guess if there's an index, I'm missing.

C

Well but arrays don't have named indexers unless that is doing what java.

A

C

Script would actually do and convert it into an associative array where the indexes now become keys.

B

No, I think the idea is that these guys here there's a there's: a bracket, two missing or bracket, one missing.

A

Yeah. Sorry, sorry I'll note that I'll look at also the code examples and synchronize them between this here.

B

You also have some json dynamic object and dynamic, json object, kind of thing: okay, big one um yeah, makes sense, and then this adjusts the converters directly right or the conversions.

A

First right, this is an example, this converter to say: hey I want to.

A

um I want to construct my own type and I, in order to do that, I might need to call it constructor and to call a constructor. I need one of the adjacent values, so this is just say: hey I mean it's not going to be the most performant thing in the world, but it says deserialize it as dynamic uh as a temporary value and then new up the real pocos. You know the strongly typed version using the state from that.

A

It's just kind of one example that dynamic could be used um in scenarios today. That is very difficult to do to do. Well, it's not very difficult. Basically, instead of this, you just use json element and do some more work, but this is a little cleaner.

A

Okay, I I, I think, there's just a couple things at the bottom um but, like I said all all of the.

A

Examples that I have in the tests in this um private branch- you know work and- and there might be some mismatches here from the document, but I would kind of use the tests as some examples and I'll make sure that you know this is updated to reflect the current support um you you have notes so emu so um I'll. Add those notes to here.

B

Yeah, I did not a good job keeping notes, but I will.

A

I will write.

G

A

B

B

Yeah, unless there's more, I think that you know, probably the next step would be that we did. You send out an api review for the whole surface area and then we can probably drill in a bit more.

B

Unless jeremy has other ideas.

B

A

Has no ideas- and you know I pull the branch and play around with the code- I you know I'd recommend it um to get a feel for the the current proposal here. um There are some questions you know with the api in general, but I I do think that this design meets the requirements um for the azure team, which I didn't originally have. That's you know to be able to navigate quickly down without using the dynamic support, so.

A

Given that you know the the, I think, the high level programming model you know has to have a node class, and then you know a collection of you know pretty much. What I have on here um with some indexers at the top newtonsoft has the same.

A

So I think at the heights level, the api for navigation is correct. I know there's lots of issues around get value and and then the value property that returns internal value. So I think I'll spend some time um documenting that and you know make sure that we can discuss it next time.

B

Sounds good all right, then. I think uh let's use the remaining 35 minutes to go over some more issues then, so I will. I will respond with notes to the pr of what I just said, but I will do it after this meeting, because I still have to write them because I was just too busy listening to you, I'm not actually typing anything.

B

All right is uh eric on the call by any chance.

H

Yep, I'm here perfect.

H

Okay, um uh we did talk a bit about this issue in the previous meeting, should I just take it from the top.

B

uh Yes, because I don't think, okay.

H

Remember anything.

B

H

Weren't sure, okay, so.

I

H

So this is a community request to basically add support for index and range types for innumerable.

H

While it's not necessarily a construct that is compatible with bioenumerable, I kind of see why people might want to use this for certain use cases.

H

So the proposal basically involves providing an overload for element that that accepts an index parameter as well as a slicing construct that accepts ranges.

H

Obviously, this won't be very performant because supporting this for arbitrary indices and ranges typically means that you might want to consume on space. um But that being said, uh it should provide the sort of convenience methods for certain applications, like testing, etc.

G

If you specify an offset from the end, this will have to at runtime just read through the entire thing and buffer that many spots.

H

Exactly so, if you do like a hat k element that operation, it would mean that you would need to keep the last k elements as you enumerate through the enumerable.

B

Right, which is not that bad right I mean I mean it's like.

G

H

B

Good, as you can make it right, yeah.

J

You would I mean, actually, you would actually need to potentially keep track of n elements. Where n is the entire length of the enumeration.

C

No, you would only need k, do it with a linked list, so you.

J

C

Know so here's an example.

J

So here's an example: you have innumerability and you index on one dot, dot carrot one billion.

C

Well, that that's slicing we're talking about elementary. Oh.

J

Talking about okay, yes, talking about indexing, yes,.

C

Slicing, I think we're going to reject, but we'll we'll get there. Okay, sorry. I jumped ahead.

G

Yeah I mean I feel like for small values like five. It probably doesn't matter, but it it seems like this is, is going to be some some performance pitfall that someone finds in their code when they start using a weird offset.

H

Yeah, uh I think I guess I guess the the answer that I have here is that element that the existing element- that overload isn't very performant in the first place, because you have to iterate through like k elements. So um you know this overload is worse in certain cases, but it still sort of seems to be acceptable uh for what this particular method is doing already. If that makes sense,.

B

Yeah, I mean I mean, to be honest, like to me element, add or similar apis on link they're really not meant for performance right. I think they're very useful when you you know in the debugger or when you're like in a in a workbook or something you want to just like. You know quickly, look at the thing without like doing some.

B

You know weird things, because it's hard to write code in the debugger in that sense right, but you know if, if you do index based arithmetic overnight on your mobile, like you're, in deep trouble right, so you would normally like rewrite your algorithm in such a way. You don't need that, but I don't know to me. The link apis are just great for exploration of like things you happen to have in memory right, and if you have a billion elements in memory, then yeah. I think you already paid the penalty for that right.

B

So it's not. It shouldn't be.

A

B

Terribly surprising that this doesn't perform very well.

E

You said this was we're talking about this in terms of like exploring data and testing scenarios and basically non-production scenarios. As far as I can tell, I gotta wonder if I was writing this code and wanted to do this. I think I'd kind of just do two array.

E

So you know what I mean I'd rather than deal with it as an enumerable. I just say: hey. I got a bunch of crap that you know just do dot to array and then deal with it as a um as an array which is much easier to fuel.

C

I mean that's true of almost anything that you do two link innumerable opera or two link operations on right. It's you want to know that it's in a good, concrete type uh and that link members are good for prototyping and for you did a thing at most once.

E

Yeah yeah, although one of the nice things about about link operators in general, is I I can string them together without getting to an array in the middle right, so I can say dot where dot select.

E

You know whatever and then at the end I can say 2.2 array dump it into array and do whatever I want with it.

H

I mean, obviously it depends on the use case like if you just need to read sort of the last element in a sequence. Why convert it into array in the first place,.

H

uh But I I see I agree with your point in general. uh It just feels like um it might be useful for certain cases and because apparently, users want to use indices and ranges in innumerable as well. um Obviously, given that we add it to the public api, there is potential for abuse, but.

E

Does link have an existing last operator like last or default? It does.

H

B

No, it does okay, if you want just the last element, it's easy right. If you want to add the last five, then we don't have that today.

C

Yeah, because last is you just you have to store one thing and just overwrite it. Every walk.

J

Through the loop yeah, the the closest thing we have today, if you want the last five elements and steve toe pointed this out, the other day is, um you can call take last five, but it's not guaranteed to actually give you five elements. It will give you up to five elements, so it does have slightly different semantics than what we're discussing.

B

Interesting so it's take last, I didn't even know we had that but like what is it.

J

Yeah, so so last we'll give you the actual last element. Unless the enumerable is empty, in which case it will throw right. Take last says it's basically take, but in reverse effectively. So it says, give me as give me as many elements from the end of the enumeration, as you can up to some maximum number and the result could be an empty enumeration if the input was also empty.

B

I see, but it's, but it's well defined as in like, if you have five elements or more then last five will give me five. It's not this. Well, you know I didn't feel like it. We're gonna give you three.

J

So to the last api will give you only the last element as a standalone value. If the underlying enumeration is empty, it will throw an exception. um Take last gives you up to the whatever account you specify, and if you specify one billion, then it will buffer a billion elements.

J

uh If your enumeration is that large.

E

E

The fact that we have those things seems pretty similar to both element and slice.

B

Yeah, I think the only benefit to support element add is that basically people can just have a single data type that has happen step language support right, the implementation would be trivial right. You would just say if from end then call take last right and then just check that the result is, you know, actually the you know these elements and if not you throw and say sorry, there are not enough elements right.

C

Yeah take looks like take last. Iterator is just q of t um yeah, when it's too full it does dq and q dq and q to maintain the right length.

G

C

We going to optimize.

J

These for efficient things- I guess I'm more comfortable.

G

H

Should optimize them for.

J

Eye collection- and I read only question.

H

J

H

uh Probably I list rather than my collection uh is, I collection.

J

B

J

H

I think it's not necessary.

C

Would slice ever perform worse.

B

We're not talking about slice, yet, okay, so so does anybody? Is anybody opposed to element to element? Add.

C

It seems fine to me the the perf is going to be exactly as bad as you want it to be.

C

If you use carrot, we can do a fast thing on indexable types and a very, very slow, inexpensive thing on large carrot numbers on large enumerables, but it's like sometimes things are ridiculously expensive and sometimes they're a one.

J

So we would, we would say we would document that element at might take. So an element out from from the front would be exactly the same performance that the existing element ad has element out from the end would take potentially o of n memory and o of n runtime.

J

Where n is the length of the enumeration potential well,.

C

O of k memory where k is.

B

H

B

H

Bounded by the size of the collection, so that would be oh then it would be.

G

H

G

H

G

Do we document the the weird memory usage of take last and group by.

C

We'll take last is as big as the thing that you ask for, or up to as big as the thing as you asked for so that one's easy you understand it.

H

C

H

C

That sometimes needs to do take last, and sometimes I mean it needs to do better than take last, but uh it it.

A

C

Does take last if it can't figure out any better option.

B

Yeah, but I think like in terms of memory, it would never be bounded by the size of the collection would be bounded by. You know how? How much do you want from the end right? Because that's only that's how much we have to buffer.

H

Yeah, I I guess saying users of this method would use like a carrot of a literal value and there wouldn't be many surprises.

C

Yeah, it does seem, I can understand somebody saying they want like the fifth from last. It seems weird, do you want the 10 000 from last but not least,.

J

C

At run time, though, that's the thing.

B

Sure no right but like it still means the space is o n. Where n is the index, not o n, where n is the the length of the innumerable right so like it like it's still fairly well bounded by arguments, the person actually passes in at the call side right.

C

Well, it'll have to do it will always have to do for a non-indexable enumerable. It will have to walk literally every element in the collection to figure out where the end was to know where five ago was right. So it's always going to be o n of the collection in time and then in space.

C

It's o of the value you passed in which, as eric pointed out, is of the same power and maximum value as the length of the collection. So it's oh in memory and owen uh sure within.

E

Practice could be much much smaller, probably often is much much smaller.

B

E

Yeah, it's weird to start asking for, like the 77th element from the end right, the first sure, the second third, fourth fifth yeah right, but like once, you get past a relatively small number unless you're doing something like like iterate from the end.

B

Yeah, I think in practice these will be things. People you in the debugger, rather just open.

A

B

Last n elements right and yeah, as you said, it will be whatever you know, the last the second to last, the third from last, and that's probably where that ends right. I I I don't think people will actually try to.

B

You know, as you said, like the 17 7 000 settlement from the end seems very unlikely.

C

The degenerate case would be that somebody is naively writing reverse uh and they have a an incrementing loop or to do negative indexes until this method throws yeah that took n squared time and space, but good job call.reverse.

C

We have a thing for that.

F

What's the behavior of element at caret 5, when the length of the enumerable is over four billion elements.

C

Same as two array like that, wouldn't matter.

B

It's uh you could.

C

In the implementation in my head, you would do something like take less like where you just use a cue. You would never have let it exceed whatever the passed in index value is so you once you hit the. If you asked for care at five once you hit five you're doing dq, dropping it to four in queue to get the most recent one and then now you uh do. The weird q lets me peek at the elements under the covers and go take. uh Actually at that point it would just be return q.dq.

C

So it's already in the right position.

J

So it should work just fine tanner, because we we don't care about the length we we never store that amount in memory. Okay,.

H

Yeah, I guess the only issue is if uh the index is carrot of a value, that's passed as an argument into a service.

B

Right but don't do that.

J

I mean that's no different than take last of user provided value and well you're just earning memory. At that point.

B

Yeah I mean there's worse things you can do right. Acceptor rejects as an argument. I mean there's many ways we can allow you to dos your own service. um How many gcs do you want to run on the service right, like the their creative ways,.

G

Eric have we looked at all the other link, things that might take offsense and indexes to see if we can upgrade more than these apis.

H

So there were a few other methods proposed in this issue, uh but we kind of decided to ask those because of issues- and just you know, focus on these two, because they are relatively unambiguous in terms of how they should be implemented. But I definitely think there's opportunity to expand in the future.

B

So what's wrong with element or element, add or default that seems fairly mundane as well.

H

Oh, so I I think the poster actually should have included element out or default as well. There wasn't anything controversial about that or overload to be honest. Yeah.

C

I mean technically, we haven't looked at the proposed apis, yet.

H

C

At the bottom of the screen, fair.

B

H

B

Okay, so here we go so then yeah. The first two seem fine based on our conversation right and then we can now argue over slice.

C

Right so for slice and the implicit indexer that uses system.range, what we said in the guidelines is do return the declaring type from an indexer except system.range. We can't do that with this sorry.

B

Say this again do return the declaring.

C

So, in a the range based indexer on an array returns an array, it doesn't return a slice the. So if you pass in levi's custom collection of t this, should this slice method should give back levi's an instance of levi's custom collection of t- that's not guaranteed possible, which means we can't add this. We would need to call it something other than slice and not support the range-based indexers.

F

But the user's.

C

F

In a custom type they're passing in an innumerable of t- and we are returning an I enumerable of t.

J

Yeah, what jeremy meant to say is that our slice methods return the actual type, not the not not the type that the compiler thinks a local is, and we can't return a type whose actual type or we can't return an object whose actual type is innumerable, because it's an interface.

F

Why does it have to match, though it's taking an innumerable and it's returning and I are numerable, so I think it still meets the original contract requirement. I mean it's technically.

C

What we've done for all of our other apis, because we didn't write it ever thinking anyone would ever try and do it with an extension method, but um but taking what we meant with the thing of matches. The input type.

B

I mean I, I hear what you're saying jeremy. At the same time, though, I would argue that that this is kind of how all the link methods work for better overs right I mean we had the same discussion on string where certain apis appear on string and they are confusing. I forgot which one it is. There was one that always happens. I think it's one of the contains overloads that didn't exist on string and they go through the link and like that's I mean it's unfortunate.

B

I don't think that's terrible, because I mean it's not that we don't have another option because realistically I think this method is super useful and I enumerable, and it seems weird to block that because realistically, if your type actually supports slicing, you can just add a static method on your type that that does whatever you want it to do right. So if you don't, then you don't and then you get the you know, shitty link implementation and if you do have a better, you know api for that.

B

Well then, it hides the link implementation, so this doesn't really prevent you from supporting slicing in a sensible way. It's just you have a fallback mechanism to say anything design removable. You know, there's a default slice implementation that might not be great but like it's probably decent enough for unless you care right.

C

The only way we could find, if you have other slice implementations, is um to to do reflection like this can't there's nothing optimal. It could do aside from special casing specifically list of t in array. No.

B

It would be statically right, like you would say, like you know, string support, slicing right. So the fact that I knew mobile that the string is in your mobile of char, it just means the the implementation that we have on string hides this one right, that's realistically what happens right so, like you have a compile time polymorphism, if you will right like.

C

At one time I would using the okay, but, but if they yes, if they had the thing non-statically typed as the input type, because they already had it as another, I enumerable, then there is going to be a change of the shape of data. And, yes, that happens with all the link things, but it does mean that this this method does give up on performance.

C

Characteristics like I feel, like some of the link methods are if a countable thing went in a countable thing comes back out and it can to make further queries fast right, um but in this one it's this this loses all notion of countability. This is, if you hit this, it's garbage.

B

Yeah to be clear, like I'm, not saying necessarily like you know like if we feel strongly about the semantics of a method called slice, I would just name it differently. I mean I think it was reasonable to just take this sorry. We name this api to take, because that's probably more in the spirit of.

C

Link anyway, if it's take range and we don't add, the square bracket support, that's fine. The trouble is, if we do add this, it means that all collection types now support the square bracket notation and no one can reason about what the result is.

H

For what it's worth, uh there has been an alternative name proposed uh in in the issue. So you know, if you scroll down a bit uh you'll see that one alternative name was called elements in.

C

Yeah because it matches the existing take and take last. But.

B

Not least yeah, I would probably call it like something something take yeah but or take something something I mean.

C

Yeah, like the to me, it feels like the notion of letting this happen as I fall back on. All enumerable types means that we have completely lost the goal that we had with the square bracket with range, like you know what it means and it if you have an expensive type like an array, it's an expensive operation and if you have a cheap type like spam, it's a cheap operation, absolutely and.

B

C

There is, when you completely take that away.

B

Yeah, so if there is an extension method, called slice, does the compile allow it to use the bracket syntax? Even if it's on an interface, I don't think it does right. So, like I guess, my question is: if we rename this they'll be losing any syntactic sugar, I don't think so. I don't think you get to use brackets on immobile with that extension method, anyways.

C

If it won't find it on extension methods, then we could call it this, except if they add it in the future, then we've lost. So I think that we want a name. That's not sliced, I'm not I'm not objecting to the uh the concept I'm objecting to using the word slice.

B

Yeah, I think I can live with that like to me. I'm honestly, like I probably wouldn't even look for a slice because I would probably just look at take, would be my guess.

C

I mean we can even use the we can even just call it that range. um That takes a range like that.

H

uh There's already a static method, called uh yeah range.

C

B

C

B

Right, that's the.

C

I want I want you to give me back like five through 15 skipping, seven yeah, okay,.

B

C

Take range is fine.

B

Just take as an overload is also fine, because I think it's unambiguous as well, but, like, I think something prefixed with take, I think, is probably a good name for the method.

G

So, in my mind, slice it doesn't. It requires that amount of data to be in the source, whereas take will give you fewer elements right, you're right take is.

B

Basically, up to that's fair yep.

G

Yeah so we'd be changing this slightly if we called it take.

B

Or we just say we fail if it's not actually that range right I mean it also doesn't seem like a terrible.

G

Thing I mean we want to be consistent with the other range based stuff in link right.

C

I mean this one would be weird because if you, if you call this method um with five dot dot, caret 27 like we now have to count to figure out that carrot, 27 was below 5, which is negative, negative slicing, and then that would have to throw like so there there's. Definitely once ranges involved. The notion that I'm sorry you're in your your combination of beginning and end made no sense for your data. So I don't think that saying that this take can't return less than the x fully expressed range on. That is bad.

B

Yeah, I guess I guess it depends on today. Sorry.

C

If you call array.slice with where the end argument ends up being before the um start argument, that'll throw.

E

Yeah, but if I call if I call skip today, I say: skip ten and the numerable only has nine elements. What happens you get an empty numeral.

J

C

Right but you're not doing I guess yes, it's if we think that it's skip and take or skip and take last depending on where the the other one ended, then that would allow it to go empty. The question is, do you want? Do you want that when you computed the end index and it ended up being nonsense.

C

I

You do it as separate.

C

Operations, it's you can debug it and figure out. Oh, this is where it went wrong.

G

C

G

Work for all forms of range like say, I said from five to beginning to five to end. Give me everything there, but there's what four four items then it's different from just calling skip and take last.

C

Well, because skip would skip the whole thing right: uh you'd get back the assuming that it doesn't throw, you would get back the empty enumerable and then you would call take, and that would give you back the empty enumerable. Sorry take last, uh so you would, you would get back nothing yeah. So I don't.

G

Yeah, that's that's weird to me. If we named this take and it was suddenly validating.

C

Yeah, I mean, I guess, if we call it take and it does, what take would do, whether it's or then sure.

H

I mean I mean, regardless of what we call it, it would be a lazy operation and you know, unlike the existing slice implementations that are doing like eager copying, I think you know returning an empty enumerable if the ranges don't match exactly. I think that is to be expected.

C

Right well again, that's that- and that comes back to the weirdness with using the word slice, um because that is not what slice means anywhere else.

B

Yeah I mean, I think it's like, let's start differently. What should we want for this right? If we, if we want the symmetries that take, has, then I think calling a take or some version of take right, take or take range makes sense right. If you want the semantics that slice has, which is kind of you know, you need to be at least those numbers of elements or we throw then arguably take is a bad name right.

B

So I think, like I would turn it around and say like what semantics do you want for this method, and then we can pick the name that makes sense for it, like, I think personally, I think the semantics of take might make more sense, because the way I think about this api is that I would use it exploratory right, and so, if I'm off by one in you know one way or the other like, I probably don't care right.

B

But if I'm, if I actually want to get back effectively something that has the right size, then well, then I totally care when I'm off by one- and I don't want to now have an array that is like for for short or something right, um and so I guess it kind of boils down to what what you want from this method.

I

Why don't we have these take methods on array and string right like we did all this work for index and range for array and string, and we had the slice semantics right because that's important because that's what people want, I would assume the exact same reasoning applies here. It's just. I don't have a string or an array. I just have an I innumerable. So why wouldn't I want those semantics.

B

Yeah, I think it kind of depends on how you view the original right, because if you, if you talk about a string or on array like they are fixed size right, you know exactly how many elements are in there right versus nine numerable is a sequence, so I think the because of that mindset. I think you very often want to not have exact semantics, but you want the wall, take up two and then see how far we get or you know skip up to, and then we see how far we get right.

B

So that's that's why I think like in innumerable always had the you know loose semantics of saying: you know you provide a minimum or a maximum versus on string and and array. It's always like. No, this is a fixed size buffer. So you better know exactly what your boundaries are and so.

A

Yeah, I'm given that's.

H

B

Design, I think that's just where we came from.

H

Given that enumerable is lazy, it also means that you know you might evaluate this. You know at a later stage when the size is different or you may might might evaluate it multiple times, and I should also add I personally sort of lean towards adopting take semantics, primarily because there is nothing unsound about returning, an empty enumerable or an enumerable that has fewer elements than what is specified in the range argument, because it's basically like said theoretic semantics, so uh you know you could just adopt that approach without any real issues.

H

In my opinion, uh the only issue, of course, is consistency with uh uh the slice implementations in the other concrete types, but if we name it something different that shouldn't be a problem.

B

Yeah, I mean I, I guess I'm leaning towards take as well or the take semantics, because it seems more useful in practice and.

A

To work with what eric.

B

Said like on a race, I've often used skip and take for that reason, because they all implicitly I I I knew mobile right, so I could use the innumerable apis on it on string, it's weird because you get an idea of char, which is usually not what you want.

I

What are the listed use cases for this slice like do we have? We normally have like here's? What I would normally want to do.

B

uh I mean I've often used skip followed by take, which is kind of what this thing would do right as a shortcut.

I

Or, are they not in the issue or is your screen frozen.

B

Sorry, like no I'm saying like the existing skip and take methods, I've often used them in combination. I started with skip and then take, and so to me, this take range. Would just allow me to do this in one line rather than two lines right. So that's why I'm leaning towards the take semantics, um but that's my opinion on how I would use the api right. I don't know what the original issue opener had in mind for this.

J

So you're just to flesh out your example. You're thinking you type dot, take range open, parens, 5.6, close friends, and you want that to be equivalent to skip five. Take one.

B

Basically, yeah.

I

I mean if you read the very first sentence of the original issue.

I

It's like, I want to generally support what we did in c, sharp eight on high numerable, so I kind of think we're changing the semantics here or the at least the intention as.

B

Originally open I mean, I guess it depends how you read it like the way I read it is basically people want the syntactic sugar that index and range operators give you and want this to be applied for a new mobile right. I don't think necessarily that you know. I don't think that means what you what you said, or that means what I want right like it just. I think it's kind of ill-defined, if you will.

C

B

Don't know that.

C

They want the square bracket notation just that they want the carrot and the dot dot notation.

B

Yeah- and I mean I like as.

C

B

Like I, I don't have a strong opinion, I'm just saying, based on my own usage of innumerable and what I would expect the api to do. I would personally expect take semantics, but like that doesn't mean that that's the only way to do it and all I'm saying is. I think we should be clear on what the semantics are, that this thing would do and then pick a name accordingly and it's conceivable that we end up with both take and slice because well depends on what you want right.

B

So so that's another way to think about it, but I I personally would probably say: if we have take that just takes a range. I think it probably would address the 90 percentile.

H

Agreed, uh I should also say that you know the index and range types, don't have any semantics hard baked into them uh and I think it. It is wise that we use completely different names for the index and range methods precisely to highlight the fact that I enumerable is something completely different to the I list. Like types so yeah, I I would, I would think like calling the range method take is good idea and, following the same semantics,.

G

Likewise, I mean, I think, it's probably also good to point out that this is really not saving you that much. So no, if the usage is something that half the people who use it are going to think it does something different. Maybe we just don't add it.

H

I mean, presumably we would optimize if the underlying type is stylist, then we wouldn't be doing it. The expensive way.

B

Yeah, although, like again like the way, I would use this apis, it probably wouldn't matter like the 99 percent case for me- would be a pass in collections that have less than 10 elements or something right so where, even if you do it a super naive way like it would be still fast enough uh to me the argument for supporting it, I think, is more to do with touristness in the usual sp. You know you.

A

Know in the debugger.

B

And and in other places where, if space is limited, you just want quick answers right, uh I and I think I guess general orthogonality with language features. You mean something fundamental as dot dot or a carrot. You probably would expect that to have wide support, um so I think that's. These are the only the only reason. I don't think this api would do anything that you couldn't already do right.

B

So yeah yeah, I mean my other question is is like you know, there's other overloads where that would make sense, and maybe you have two array, for example. It doesn't strike me as insane to say two array has an overload. That also takes a range right and then this would have the normal slice semantics, but you would say: well you better, have these elements in it, because you would expect an array to get that size right.

C

G

C

The only we don't have any notion of a sliced version of two array: it's if you, because if you wanted something smaller than you would call, you know, skip or take on a thing already.

J

C

So I don't know that I would add a two array overload that took a range because that.

C

Given that we didn't already add an offset and count type thing, it feels weird to have an overload that takes.

B

A range like yeah to me, it's kind of like the orthogonal thing of like s-ban right.

B

Right but you basically say I want this thing as a spam, but I want a subsection of it.

C

B

Like we call it two here because well, it's allocating clearly.

C

Right, I just like it. I think that that the I can see the value in such an overload, but I think that it becomes confusing um and that and if you want the hard bounded one yourself, you know that could easily be written.

J

Yeah some someone in chat just brought up something. That's been bugging me for a few minutes, which is uh the I queryable implementations are going to be insanely complicated, because if, if the index or range that you pass in consists of only read from the front values 2.3 whatever those are really easy to do, because you can literally rewrite them in terms of skip and take if we start doing from the end, things get very complicated very quickly and these apis actually cannot be written in terms of existing apis.

J

Once you start doing from the end semantics.

C

If queryable supports take last, then it's a.

J

It's the slightly expensive version.

C

J

No so so say that you do uh say that you do one dot, dot carrot, one right. You want to skip the very first element and stick the very last element you can't chain the final skip on top of the first step, because the count's going to be wrong.

B

I mean my problem here is, I don't even know how variable works so like what? What what are these method expected to do?.

J

They basically get translated into link, expressions and then passed off to something like linkedin.

C

Right, but that would, if you had one dot dot carrot, one that would be uh queryable dot skip one dot skip last one and we have enumerable.skiplast.

C

I

C

Have queryable.skiplast.

C

A

C

Carrot number is skip last. uh We were calling it take class, but it's really skip last.

C

So the this this take method is uh yeah return, skip on a from index or skip last on a on a back index. So if you did carrot, 17. care at 5 that would be return. Skip last 17 dot well skip last 16 dot skip last zero. One.

J

There's a off by one error.

C

In negative indexes.

J

I I did I did have something in mind that would potentially be a problem and I'm trying to remember what it was. Maybe it was like carrot, two dot dot error three or something like that. Basically, where the the input values get flipped and you end up having a negative count.

C

J

Because that would.

C

Be skip skip less to, and I guess you'd need to have, looked and realized that the indexes are going to have gone wrong, and then you turn that into whatever we said it would do for you've gone too far. It looks like enumerable.skip. If you give it a negative number, it just turns it into zero and moves on.

C

So uh if it's, if it's from beginning and from or from end and from end, we would need to do the math before deferring to the existing things, but I think that for the most part, this can just all be it's a four-way table of calling skip and skip lasts.

C

Carrots end up being skip, lasts and uh non-carrots end up being skips, and you need to figure out if you need to do uh offsetting, or maybe it's positive positive is skip and take. But yeah like everything is expressible. I think in terms of skip skip last, take and take last.

B

So, given that we are over time now, how about we do the simple thing for now: let's improve element, element or default because that's clearly easy on both sides and then, let's just say, for slice, we are not sure what semantics are desirable here like we can either go with it with the text semantics or we can go with the you know, you must have exactly those elements in the semantics and then you know once we have an answer to that, we can approve the other one.

J

And are we proving this on innumerable query or both.

B

Well, the element adder would approve them both because they seem unproblematic.

B

I mean it seems generally weird to have an api on a new move, but not not incurable, but eric might know more, but I would think we generally would strive for having it on both sides. If we can.

H

There is one potential downside of adding element that uh in queryable, and that is it could break existing query providers because we would be adding uh an overload for elementat where one didn't exist before so, assuming that they did a bit of reflection code that assumed that hey, there's only one element that method that could end up breaking the query providers. So the question is what is the precedent when adding methods in link here, because I'm not familiar with what we've been doing in the past in similar situations.

B

I am almost certain the approved api is recruitable, I mean well.

C

But have we approved going from reflection, gives you a unique answer to it? Gives you a you need to have told me the signature.

B

C

So that introducing the first overload is when life gets complicated,.

B

That's fair, but I think our general breaking bar policy for that is yeah. That's a potentially a breaking change, but one we consider acceptable because otherwise we can't evolve our api service. Like we generally don't say you can't go from zero overloads to more than one overload right. Like that's, not a rule. We follow and I would think most query providers if they want to do something sensible like they. It's not that they can just blindly reflect over the time either right.

B

They have to know what to translate it to right, like if you have to, if you, if you have to translate their stuff to sql like you can't just reflect over accrual, but you have to have a table that says this operation maps to the sql right, and so you have to know every single operation, no matter what you do so I think, like practically speaking yeah, if we add new stuff to curable, I would assume that there might be some work down level.

B

Four query providers if somebody calls the api, but it's based on whether somebody uses the api right. If nobody uses the api, it's fine. It's if somebody calls the api yeah that might not work anymore, but that seems, in my opinion, fine. I mean that's just life right.

C

Like when I write the reflection code, I always pass the arguments right, even when there's one overload just in case, I feel like.

D

You do if you're serious.

B

Yeah I mean we say things like that, but, like we've all been broken by code, that didn't do that. So I'm just saying I think we would accept this as a yeah. You have a buck in your code. Go fix. It.

C

Yeah, the only or you know when I wrote down, wrote the breaking changes section and was looking at our precedent uh that yeah we adding the first overload can break reflection, we're generally okay with it, uh but that there then becomes some weirdness if null was allowed to be passed in or well default, but um because generally, that would be if we were simplifying a signature.

C

But but then yeah queriable could have been special. I think is really eric's question.

B

C

I don't know the answer to that.

B

I think we should double check but, like I think we have approved apis previously for for variable.

B

I don't remember ever having had a conversation about overloads, so we should check, but I'm pretty sure we already have done that and I think we consider that acceptable, but it wouldn't be hard to check just see what the difference is between that zedon and framework and dotnet course link and uh links variable and see what the what the discrepancy is.

C

H

C

I don't know that we've ever done a partial approved before with the the slice slash with the the thing that wants to take assistant.range now move to a new issue.

H

C

H

Mark it as needs more work and I'll come back once uh we've ironed out like a final proposal for slice, including semantics.

B

Yeah, that would be my proposals. Like you know, I I would just say we are okay with the element ad on both sides. We are unsure about slice and then would it. You know push.

A

B

To api needs work and then the uk.

A

B

Decide what to do.

H

C

I just wanted to understand our parliamentary procedure here.

B

One of us has to loudly yell treason at some point. I think that's requirement now.

C

I think he yelled no confidence here in the parliament, but yeah.

B

um All right, so let me just paste this in here and then are folks. Okay with what I've written here.

B

I should probably make adds a comment.

C

Oh, um and one more note to take while taking notes, is, uh does parallel, enumerable need any of these. It looks like we have parallel enumerable element at so.

C

I don't know if it makes, I don't know if it even makes sense. I just noticed in source.net that I had two hits on.

C

Enumerable.Element.

H

So in terms of the action items for the original poster.

H

J

uh Modt source return, value on element- header default should be nullable.

B

Sorry, which one.

J

Element at or default should return t source question.

B

um I don't think we can do t source question mark, but it would be something like an attribute right.

C

Yeah, I think it's.

B

C

Maybe null or return, maybe null.

J

The the existing element or default method returns t source question mark really yeah, because it's not constrained to struct, so it automatic, like the compiler, turns it into the whole attribute thing, but anyway nullable annotations right. It could return.

B

C

Thought that was yeah. I agree with demo. I thought that was one of the places we needed an attribute, because uh how.

B

Do you know how to return the question question? Are you looking at the code? Are you looking at apis? I've done and.

C

Looking at the source.

B

Yeah then I don't know okay, I thought I thought if t source is not constrained to be class, you can't use question mark. That was my I'm.

J

I'm just looking at the existing code so.

C

Maybe it's: it only turns it into nullable of t if it's constrained to be struct, yeah or otherwise, it'll emit the attribute, so it it must be doing the right thing, because there's only one thing that makes sense here, which is a if this is a reference type. It could be null answer.

J

Yeah, I I posted and shot a link to the existing code.

J

Anyway, no little annotations, I know, we've said we care about.

B

That, yes, I think that it's generally a true statement. I mean the nice thing is now that it if the type is already annotated, I think you will get probably warnings if you actually add meaningful test coverage for those, um so we will probably find it so all right. So I added a node on p link. I did a node on deck variable, um breaking change with link provider thing, and so let me comment this now and then, let's just mark it as api needs to work and call it a day.

J

Cool, it's the first part of it's approved right.

B

Well, I mean so yes, I would. We probably should call this all but, like I would generally say like if the if the proposal owner is okay with removing the slice method, then we can improve it if they don't want.

A

B

Then you know up to them.

H

Okay, so uh so what is there to be done to bring uh a second round of reviews for a slice-like method or a range method? Rather.

C

H

C

Need to understand, I think, scenarios and semantics.

H

Okay, so working with prototypes- and you know bringing out examples, presumably.

C

Because, if what's wanted is take semantics, where, if the range expresses a where the end is before the beginning, etc that it turns into empty, then I think that the right answer is take and we then we then probably decide we're okay with it.

C

If we want hard slicing, we need to understand what other things in a numerable look like that, and I'm still going to be wary of using the word slice, because if even if the language doesn't support picking it up off of extension methods now, if they did in the future, then we'd have a very long argument with the language team that we didn't want this to have been found. So so I think we want to avoid the word slice, no matter what, but in order to know what the best name for it is.

C

We need to know what it's supposed to do.

J

Make sense I I also posted into chat um an example of a call that is extremely complicated for variable semantics, and we would need answers to stuff like that. I would need to put that into the github issue as well, because clearly people can't see our team chat.

B

Yeah, so to me, the action items is the symbolics of take it's figuring out whether we should address anything in p-link and then making sure that we are okay with adding new members to curable right and if the answer for that is no, then we can just change the proposal to only evolve. Innumerable that's also fine, but but I think we need answers for all three of them.

H

B

Right then, I think that's all we had for today, so we reviewed one one thing all right but like better than nothing. So then I guess I'll see you on thursday.

H

H

B

B