.Net Foundation Design Reviews, 22 Jan 2019

Previous Meeting Next Meeting

⏯

youtube image

►

From YouTube: .NET Design Review: GitHub Quick Reviews

Description

00:00:00 - Approved: Add IAsyncEnumerable(T) support to System.Threading.Channels https://github.com/dotnet/corefx/issues/32742#issuecomment-456511279
00:23:17 - Approved: IAsyncDisposable.ConfigureAwait(bool continueOnCapturedContext) https://github.com/dotnet/corefx/issues/33336
00:29:43 - Approved: PlaceholderText API addition to TextBox control https://github.com/dotnet/winforms/issues/134#issuecomment-456519247
00:45:26 - Rejected: Allow recovering writable/heapable buffers from "lower level" types. https://github.com/dotnet/corefx/issues/33717#issuecomment-456520584
00:52:11 - Approved: Add Rune creation API from UTF-16 surrogate pair https://github.com/dotnet/corefx/issues/34683#issuecomment-456524835

A

All right, no, we are actually live but like or.

A

A

Is this something that we want? The other guys to be here is something that I guess. It's challenges, or your thing anyway, right.

B

I, don't think we meet others time.

A

So this was the so given is a new mobile. Your basic opposing to it make the channel leaders themselves effectively a new mobile via this pattern right yeah.

B

Basically be able to use a weight for each to pull stuff out of the channel so, rather than having to manually write out the bottom pattern, you can basically just say a weight for each now. The one open issue icon so there's basically two ways we could do this one is we make the channel reader itself implement isync enumerable, in which case you can just wait for ancient directly. The other is expose a method off of it.

B

That returns an is think enumerable, and then you will wait for each that one piece and you might want to do the leper, and I have a strong opinion on this- I'm open to other people's thoughts generally and on net. When you for each over something it's non mutating. You know you can forty to any number of times and you kind of get the same stuff out now.

B

That's that becomes less true when you start talking about pacing stuff, because it's async necessarily because there's some, you know long delay and that generally means that you're pulling the data from somewhere else, and so you know it's more likely that's going to change, but that aside, this one is explicitly like every time you get. The next element you're actually effectively removing it from the reader. So it feels a little strange to me that we would say you know you've just for a week for reaching this thing.

B

You know it gives you the data, but it also mutates it if we so for that argument, we would want to expose some other method. Similarly, if you look at like blocking collection, it has to a new. You can khanoom write it in two different ways. You can, if you just for each over blocking collection, you're, basically just getting all the data- that's currently inside it, but there's a method on it called get consuming enumerable, where, if you for each you call get consuming, will you for each that?

B

Well then, it's actually taking stuff out of the blocking collection, and so I was wondering if we wanted to do something similar here and have like a get consumed with a mobile method or get consuming a sink enumerable or something rather than just directly. You know for a chain for weight for teaching the channel. I don't have a strong.

A

Opinion I would maybe just go with something that has read in the name like we don't read items or something because I mean reading in general is consuming right.

A

Like I understand that is priority in blocking collections, but it seems like a mouthful to say, get a Seng. You get get consuming, acing innumerable or something that seems.

C

Even you would have Michael like a read items, async method that returns line. Second knowable.

B

A

As to me, reading implies that you are advancing the state right. If you, if you read from a file like you, would expect more from a stream that you expect that to advance the position as well.

D

So, in the beginning of the proposal you called the metal get async enumerator. That's.

E

The math that's the interface implementation.

D

E

This is already on the reader. Sorry yeah.

A

I mean the question: let me put the method right, they could have like I guess. Putting it on. Rita makes more sense of bringing her on the channel, but.

B

Yeah reader, you can have it on both and then the one on the channel would just delegate to the one on the reader, but we in general we haven't done that for any of the other methods. I.

A

Guess it depends, you have to say channels or reader, the blood and that's the way. It is yeah.

B

I mean when we did this initially, we basically said you know if it becomes a mouthful people care. We can add all the methods on the channel as well and just have a delegate but I think generally the way things emerge as people pass around the reader itself and then or any other writer for the other side and then you're just calling methods on the reader.

E

But we we already have this property channel, that reader correct, correct.

D

So if we implement it directly on the reader, it will be basically for each channel the reader correct.

D

Well, I think it feels actually the opposite. He was nice, but it's a bit confusing that it's you know it's consuming.

B

Yeah the biggest issue I have with this is: if, in the future, we ever wanted the ability to enumerate the contents like as they currently exist, or they don't know if we would. That would sort of naturally be what you know for each item and Channel is, although in that case it would probably the ienumerable rather than I a synchrony normal, so meaning if we had a preserving a numerator as.

F

Well, as a consuming a numerator exactly.

D

But I have to say I like the channel that leader approach much better than Charlie reader read they sink.

D

It just seems like too much ceremony.

G

Would we ever consider an extension bucket on the screen that reads, async and just keeps giving you like span of bite over and over and over, because if we would I would assume the same name.

A

Well, I guess it depends on what you mean by the like I. Think, like you look at stream right, the default behavior is that it advances right so thing in collections. Usually you don't expect to have any state where you just expect it. You can do it over and over again, but so that it makes the locking collection somewhat special in that, if you use them for consumer producer scenarios, you think of them as huge.

A

So the scenario is you want to get a consuming or a non consuming right, so they are almost at equal footing, depending on how you use them right versus here. I think this is closer to where streams are aware. I think the default will be. You wanted to answer like I think that if you ever want to do the other one, then I think I would agree with you that we will need to have a naming convention that that is basically four types where you can provide a non consuming behavior, but it seems.

C

Very far-fetched X, even it kind of makes sense to me like if I were to say for.

B

Each buy an item in streaming there's something a little about. Well yeah, that's, like you know, pulling out the next thing from the stream, and it's gone after that, but at the same time, if I are same for each button in memory stream, I kind of imagine that I was just a new raining right now. Updating the position.

G

Yeah yeah and that's why I was thinking like if, if we were to theoretically add an extension method or something on stream when it reads asynchronously and just keeps giving me back buffer buffer buffer buffer buffer until the end, while consuming the stream, presumably it would have read in the name to match what stream already has his existing instance methods, which I mean this is basically the exact same scenario. Why wouldn't they use the same name.

A

So I'm not sure how this would work, so you are saying you would for each they'd say memory stream, and then you would just enumerate the buffers without events in the position. No.

G

It would advance the position was actually reading. Hence the name would have read in the method. So if.

H

G

Can imagine this extension method existing off extreme, a helper method that consumes asynchronously and allows you to write away for each if that method exists or if we had, you know a mental model for how that method could work. We could use the exact same name here.

F

G

F

One stream so that people could change the behavior of who think you know yeah.

I

I mean looking at the paper.

F

Breeder, like my my straw, man name, my straw, man would be that we had a like, read multiple async and that that is what returns the async enumerable.

F

Is it just? It feels it feels weird to me that that the reader, all of a sudden is a is destructive and immoral.

F

D

I cannot read, there is distracted when you get there either that read. You're gonna consume the item, but the code actually has the word read somewhere in it. Okay, that's that is yeah yeah.

F

My problem is that is the yeah while inspecting this object. Yeah looks like inspecting this.

D

Is only related note, my pass I understand how we were just a cancellation talking when we have actually a method when we don't have a method to have the advanced cancellation talking until.

B

We get a sink, a numerator on the innumerable.

G

It was I think in the first example above the screen, yeah.

D

So basically, this syntax is kind of really nicely looking syntax, where you just say, channel dot reader doesn't allow you to bus well,.

F

You have to say it at all that reader there's possibly read multiple async, that with cancellation in the past, except.

B

There's a whiff cancellation, extension method off of eyes and khanoom herbal so in this case, would be a way for each tea item in channel dot. Reader thought with cancellation token, if.

D

We have the method you kind of don't have to do it. It's just a parameter to the method. Well,.

B

No, no, you still do it would be to the reader done when it like, whatever the method was, will be returning an IU sync enumerable, and you wouldn't call that with cancellation of.

D

The method things cancellation, doesn't it's not a.

G

Method missing property.

B

A method like the pattern we're trying to like with the decision to move the cancellation token to the new plate or to you know, to get async enumerate or now, if you, if you start having a pattern where the things that create the enumerables also take a cancellation token. Now, there's a conflict between that token and the one that gets passed to the again async enumerate or so by having the it pass to get async doing right or we're basically saying the pattern is: don't have a cancellation passed in anywhere else. In addition,.

G

Just to clarify Steve getting the enumerator should be fully synchronous, correct, correct.

J

So it would be, you know, excited.

B

You see the yeah getting both the innumerable and the enumerate or is both synchronous, yeah.

F

The problem is, the person can calls the ID async and innumerable into being may have different cancellation semantics than the person who's doing the innovation. So the immersion has to move into week next, which we wrote everything he made it ugly because the language team says they don't they don't want to know about cancellation tokens and don't want to know.

D

F

D

F

I mean like it would certainly be possible to have a method that took in the cancellation token and then called with cancellation on it and then bound it in the closure, essentially for you, but I think it would create person. I think it would make the caller's be even more ugly pattern, and we says the has the consistency argument and, according to you, the most important thing in the friendly words.

B

To naming what, with there, was there a consensus from folks on what a name should be? Was it read something I suggested, read multiple async white.

G

K

Is read a sinks? Are you taking.

F

And it gives the indication that it's doing more than one thing.

B

But forever reason that feels to me like it should be accepting an array or a span and kind of reading into.

D

That okay drain async, what about anomaly they seem like we have these anomalies, might have seen some ideas. Generally, they don't mutate. The underlying state thing.

G

Yes, when I agreed and.

F

Really the question is: where do we have anywhere that it has consuming consuming enumerators I was.

A

Suggesting items read a single items, a sink.

G

What's another terms like a breed a sink right now now you have City tasks of tea or value tasks of tea yeah, and it just gets you one item. Okay,.

D

Read items async I think the negative is the other one also reads items now: the other one reads: item yeah well: okay,.

D

It's not going to read item.

L

We read items kind of feels like it should accept a count and an offset and you're specifying how many items you want to read. That's generally how we do that everywhere else.

D

Whilst read always.

D

I

D

I

D

People may think that and recycle that you know like yeah, that's the important, because your location them hey.

F

Steve, what's the what is the behavior of the enumerator? Does it only close when the channel gets closed yeah? So so it would be read all unless you had multiple readers, in which case they're stealing from each other correct, read all acing.

D

Logically, it basically returns an enumerator that represents all the items and we.

L

Use read all X async elsewhere.

G

L

Know over does it elsewhere, give.

G

You a single, continuous buffer but I.

F

Only read all that I'm saying is I'll read all lines, they say: yeah well, read all bytes and read all tanks. Okay, I searched for read all async and emos tool, but it's only what I don't do this.

L

I just search for read, although I'm looking with everything that has a sink on the end, yeah I'm sourced on that yeah.

G

And then generally it's going to be it just. It reads everything into a single buffer and just review the whole buffer again chocolate. We can probably make an exception here and wirelessly well,.

F

I mean we need to sort of define the precedence, yeah.

G

Or if you go like what's already kept in and the precedent is exactly the best function right so file.

F

Streaming I read all bytes to me: those aren't iterators I, don't know that we have any that are returning in here, but.

A

Victim files, the opposite right, the the the all ones have non iterator ones and the ones that are the 808 are the ones about all the other day. You do.

L

Anything whether.

A

It's one, usually a single string or an array of deaths turn that's actually.

G

A good question but I imagine we can enlighten the debugger to recognize a sink in the normals and to not evaluate sorry.

B

I missed it. What was the concern? My.

L

Question was: is the debugger planning on doing anything with ie Singh I async enumerable, like it does, with ienumerable.

F

They started the debugging display will delete all your data and, if you do, sighs and bugs potentially.

L

Yeah yeah I mean there are cases where the debugger, depending on what it's doing, doesn't actually create a copy, and you can mutate the original, so you could potentially be like. Oh there's an enumerator here. Let me expand it.

M

L

Then, all of a sudden, none of your code work.

B

I think that's I mean it could certainly happen, but I think that's unlikely in particular, because the debugger actually does a lot to ensure that it doesn't like jump around threads or use synchronization anytime in the debugger. You do something that would do that it stops execution and puts up a little icon. That says like this is gonna. Do a whole bunch of multi-threading stuff. Do you really want to do that? If so, you're gonna have to slip threads and stuff and I think numerals are pretty much always gonna be in that camp?

B

So if the debugger did were to do that, I would assume. Would they would just you know, would always have that error in place, but I'm hypothesizing, maybe.

J

Just something we should follow up with separately yeah yeah.

A

What we feel about read sequence,.

A

Well, it's kind of like the same of like innumerable sequence, equals right where you basically say like you, have two sequences and you just compare them. I mean it's the only other word that we have a thing for beat.

L

G

You create a sync reader.

A

Read as animal racing.

F

Problem is the reader itself is already yeah saying so everyday something's realizing green as a normal life. Worse, it's just. It is a little wordy.

H

Probably want to be read as a single right. Well read: isn't it well I, guess I think.

A

Yes, it would be read as acing in your mobile, because the operational service nor asynchronous.

D

hmm Then it should be good, basically model, because until you for each nothing gets read like.

A

Well, we said read because the idea is that you, then you make it clear that you consume, but yeah only would probably call again. Alright, let's make a decision on the name, so we can move on I think we all agree the business scenario. No, it's just well I mean like. Would it be here we'd be heard. We'd all do.

F

We have any guidelines like I'm, trying to skim the list right now, but that's say that in a new word and a numerator slash, innumerable should not be disrupted. If we do, then, then the guidelines call into question this feature well,.

D

It's like a second numerator numerator in the mobile would kind of design for destructive scenarios because they are, they are designed for kind of streaming scenarios and video. Can I yeah.

F

That was show me, like you, like I'm, just we're we're effectively inventing precedent might use.

L

F

L

Least for regular numerable I would say that they have to be non-destructive from the perspective of it has to throw if the underlying instance is mutated at all a sink numerable, though it's bit different, since it is a sink.

A

Yeah I, don't think, there's that much pressure, that's I would be shocked if there's not a single person who rode like an iterator that you know read: customers accepting a path and then just the pricing and returns to thing, and so once you pass all that in your mobile and you consume mineable, read from that file and like once it's once it's drained its drained that you start over right, like I. Think that's I, don't think that's unheard of as.

G

We've also said: enumerators don't have to be very sellable, yeah well, I know they'll, be that's already documented yeah.

A

And even the iterator, since you shop, you can be City there. You'll always see you look for most people that will not have reset at once. Yeah.

F

Like I've, definitely written.

F

A

I guess we do I think the reason we haven't introduced. It is not so much that we don't like them. It's just because that's usually a higher level and we usually don't have that I have a level in the VCL, but I. Don't think this and turn them into anything wrong with that.

L

Because we just take a reference to be underlying array and then tracking index right, it works way nicer.

A

All right so we'd all I think was the other one read areas. Was it read as because they say some.

G

A

Just racing, can you apply yes,.

G

I think someone's studying a very new singer.

E

F

I mean honestly, we.

H

F

The Mendon, your calling isn't they sink. It.

B

All sound fine to me honestly.

A

That's gonna read all async.

A

I mean the only thing is a bit weird. Is that a sink? Is it's not an actually acing operation right.

B

No but I think that that's at least a language design meetings we talked about and I'll see if I can dig up a thread on it. We we talked about whether we would expect these async returned renewable returning methods to end an async, even though they were themselves not async and I. Think the general consensus was yes, because you're gonna see them 99.9 percent at the time written out in a wait for each, and so it kind of makes sense that async shows up there in the name.

D

Can you do configure away on the return? Can you do you know read or leasing configuring wait, phones, yeah, okay, yeah I,.

K

D

Was cancellation.

A

Alright, so retool acing, it is gently the only.

F

Place that I would have thought that maybe we had a destructive iterators with Q, but it looks like Q has a passive iterator yeah that lets you inspect the state without consuming it.

G

Pretty sure all of the system collections.

G

As they also as tender said, keep track of, if you make modifications to the collection so that they can fail.

G

Some versions in the window.

G

Another collection yeah as we introduced a breaking change between 400 and 45, where list of t's enumerator keeps track of whether it's changed and then fails.

A

B

Hopefully, this one is quick: we've already approved. This API is an extension for is Inc enumerable, but then there's also ice and disposable, and so, if you want to be able to use configure away and in a way using, you need to be able to tell the compiler basically how to will wait the ending dispose they sync. So this is basically you know effectively another overload of configure wait, but for icing, disposable and instead of icing them so actually.

D

We just got a discussion about the cancellation token. Would it make sense to have one configure methods where I can pass both shut? This thing and the cancellation token.

B

Two things there, one for disposing. We actually said that we don't want to make it cancelable, because you're you're supposed to be doing cleanup of other operations, and if that cleanup is itself cancelable, you start getting into really weird semantics. You know like throwing from a finally block for the other, one are enumerables. We talked about having a single method. The problem for me is with configure weight. In particular, we've talked in the past and we might there's even an open issue about it.

B

Having an overload of configuring weight for tasks that takes a cancellation token, but the behavior there is that it ends up cancelling the await operation.

L

B

This would end up stopping the enumeration and there's a important semantic difference there and so I'd be concerned that if this configure weight took a cancellation token, but not this one, the one on enumerable took a cancellation token that it would end up leading to a weird ambach. You are a weird semantic difference. When you look at it, it was configured on task versus on innumerable, which is how we landed on this separate with cancellation method.

D

And this one, how often people work to do something after awaiting this disposed, you might have to misspell it. It's.

K

For joining I, just cussing sorry.

B

I didn't understand the question crystal candelabras. How often.

D

People would do you know a weight using icing disposable and then do something after their weight complete like and what so, more specifically, why isn't configuring weight Falls default only disposable? Is it just for consistency, or we think that often people will await and then do something and they want the thread. Synchronization I.

B

Think it's very common to have code after you say if you live across corvax, or course he'll are there's it there's a lot. There are many many cases where something comes up and using it. It's just part of a function rather than the whole function and as far as the default yeah I think it would be. It's it's consistency, I think really strange if some of your awaits by default in your in the same method, if some of your weights did respect the current context and some of them didn't I, think that'd be really weird.

D

Yeah I I think if you think that people will be actually doing something after that, if it was just basically await and I, don't care yeah.

B

If it always came here or did you know, 99.999% of the time was the last thing that happens in a method. I could buy that, but I don't think that's true I, don't I, don't think it's like the you know the 1% case, but it's you know, maybe even 50%. So.

G

For your example, like I've written code before where I have an abstract, higher-level, dispose method and what it does, it has a socket underneath it and what it does is it closes. It sends out, like some closing frame on the socket waits for the acknowledgment that that was done, and then it disposes of the socket. So that means my higher-level dispose method, actually has two operations and a one right after the other. So that's a scenario here.

D

And so this will be on tactics is task, extensions, which is an existing guy yeah.

B

That's where we put the other configuration with cancellation, extensions and it's an existing type, which means you know as as written if we ever wanted to move them. It wouldn't, however, since the 99.999% use case is to use them as extensions. If we wanted a new, we would just put them on a different type and.

D

So that I a sink a numerable and disposable, are they remind me? I forgot what I did sorry, which ones are all the interfaces that we added other.

I

A

Think fundamental is one of those subs where it would be doable probably, but it would be more than just the interface it's right to make them usable. You have to have the compiler infrastructure types that makes it time actually await a woman. You know if you configure wait and all of that, so it would be not super tiny, but also not super large.

D

Then looks good.

D

A

From my career, thank you even you broke up, didn't you say something. Thank you. There's no means I have to do work to get into the standard, probably right.

A

A

F

Okay, oh that's the one right, so I had proposed extensions on span and memory hold slice which took spans and memories and such- and this was the.

F

If you have a lower-level thing, then this will give modify your thing. If you have an overlap. It was pointed out during a review that this is exactly what the overlaps API by the overlaps. Api lets. You write this yourself, but overlaps is I'm going to find on spam and then there was a question of well.

F

Should we define it on memory, so you can do memory overlaps, remember your memory overlap span without just writing that yourself of dropping both of them to span doing the overlaps, were calling back and coming always slice yourself, but we didn't in the discussion with yes, we should do it or no, we shouldn't, and so then this pop back up again is is: is this a thing that we want to do when you work for Cabrillo or consider the scenario satisfied and close it and tell people.

D

The background it's the background, but do we now have more convenient ApS for the Overland already know.

F

So easy so essentially I was suggesting these as I thought. It was the only way of achieving it, but apparently it's just the more convenient.

D

F

Of achieving it, and then it was insulation, like the methods, are.

D

Proposing and slicing it it's not to detect over lunch right.

F

So this was so my proposal was, if you have, if you had a memory, you called an API that you know only took a span. They didn't have a memory overload. You now get back at read-only span, but you know it's contained within your memory, but you can get the memory that maps to the same range and then it was pointed out that there's what the overlaps overload, that tells you what the offset is.

F

So if you get true with an offset, then you could call slice yourself and then that became those slice methods became a convenience method. It may be sort of said known to them as a convenience method. And now this is a question of convenience overloads to overlaps or okay.

D

So that's nice convenience methods, it's not part of the proposal anymore. It's just those overlap. Unless, as these span architect, you think that they work.

K

D

The point is that either, where there's a new API.

B

D

Overlock api's, it's so convoluted I mean for good reasons right there. You give you all the power lots of information, but they are super difficult to wrap your head around. Why? Because slice methods, I hope the Gemini enough as soon that they had these. That I think I. Think.

A

The general arguing last time was that these are basically or the the whole idea why we have to slice. People's in the first place is to have an escape hatch when the system screwed you over right so the years that hopefully, these are rare scenarios anyway. If we, if in order, people would have to call the sliced method all the time, because we up then what we should add the right types in those methods, right so I, think in that's and that's okay to say, yeah.

A

If we messed up, we have a way of doing in there in a type safe way. It just requires it to write a few lines of code. When we added read only.

F

Span of chart read, we then added the one for read only memory a charge with the argument of because if you had a memory, you can't figure out what the indexes should accept you can with over.

F

So now so technically we could have never added the comfort or the redundant version for memory, and we couldn't force people to use this API. Of course, then that's not user-friendly.

M

F

Leave it at the elbow woods.

M

F

Now the question is: if you fall into the pit of needing to use overlaps, if we make you drop all your memories to spans and call the existing.

M

F

Or should we also make overlays or memory overlaps memory and then we overlap Spanish? So that's really the question that's left now it should we had these overloads or say we're good enough, as is leave this alone until people.

F

The question I, don't have a strong opinion once we're making someone use like if anyone ends up in this zone. There they're already sad, as Chad pointed out twice to make sense to him. Overlaps is like good god. This is it.

A

Could be clearly the ones to be ad they're, not strictly speaking required, but you could you could do the exact same thing on it right.

F

You can write this like the memory of the bottom line. Would just be you call that span on both of those in call the previous book right. Then that gives you back the index. You can call on the outer memory. You can call slice start index comma other that link, so you can do it. The existing thing is it's just our we can. We do it more efficiently would be one reason to add them that, like we can do something better than dropping the span on both sides or for other loop.

G

Can be abilities not always we, so if all we have were strings and arrays, we could be more efficient than dropping to spend, but because we also allow you to pass in memory managers, we can't directly compare to memory managers for equality and know that they actually pointed the same thing. For instance, you could have two different handles of reference: the same discipline memory, so we in those cases we would have to drop down the stand anyway right. But if the, if.

F

If the detecting that we're in the array or straight VL case is better than dropping to span yeah.

G

That's that we can do very cheap, then we.

I

Could still make overlaps memory memory be cheaper, yeah. Well, on the other hand, we may.

D

And of all users in the wrong direction of just calling these methods and the news fan pulled out from this memory, please I mean you know. Basically, let's say: there's Czech overlap and they take a memory, they check overlap and then they do something with this band and they pull out span again, pull out the span from memory and they love this man from memory. That probably would be lesson so they maybe end.

G

Ss-Sorry, keep in mind, we've also optimized to spam, coffee together, quite normally, so this might not show up on one did you did you merge the so.

F

If we think that this is unnecessary, fluff slash, possibly a performance trap, then we can just close this as no actually.

D

Well, but having said that, I used overlap, IV I've, seen several places and I have to deal with what is issues.

M

Will happen or what's.

D

Wrong I now don't remember that I I just remember that it was super painful using overlaps or your syndrome using basically I needed to do something with you know, knowing where I am, and these ideas were not super completed. What.

A

Would you like to have that I, don't.

D

Know yeah, it does observe the problem. I don't have a solution. I see. Did you want slice to.

G

Is if so, I do.

D

G

Some value in slice, lady.

D

Let's go back so.

A

Before we go they're like dude, should we add these api's, regardless of whether we do you want to carry at them on whether we add slides to or not.

G

Thing is likely these api's, you can just hold out span and call the actual the existing overlaps api's. Okay, just going if.

F

Our answer is fan is fast enough that the optimal implementation that we can add is not worth doing.

F

I, don't care about nanosecond.

G

We could have these if you see evidence of its economy, I'm.

A

Kind of thing so I mean the argument before was that a point people in the wrong direction seems much more compelling than the other.

F

Reason that I was suggesting the slice to is I thought VB had less support for walking through, as fan than Nora had done, since Peavy has a as long as you stay in this little zone and I think Steve pointed out last time. We were doing this. That BB hand solved this scenario for themselves, though it was not a this unscrews other languages.

F

Oh yeah I'm I'm completely fine with no, we just since this was unresolved. He brought up the question of. Do we have anything left to do on. This seems.

D

Like the family, they overlap baby Isis. That I wish. It just told me, is it on the left right in the middle or not of the lucky, but we give people in disease and then I have to well. If you just want yes,.

F

D

I know if I just want yes, then it's simple and you never just want yet cause. Usually you implementing some algorithmic menu will override. Maybe.

F

The critical area is going in the OpenSSL, we have overlaps because it yes, they do not define the behavior and we have to use that very public. If the answer is yes, we don't know interaction. Was they explicitly say? If you give us overlapped memory, we will probably throw up your process.

D

Yeah I was trying to implement something. That is actually right. It's a mistake. Yes, then, you really need to know, tells.

M

You, which way.

D

You need to do you need to do right to left copy or afterward yeah, but we don't have that. Well then, you basically start like okay. So let me, let me know, think which comparison with the length I need to do and do I have one. You know off by one errors in my code and but.

L

You can determine left to right based on weather returns, a negative value.

M

Which one the offset it.

L

Just takes the offset from left to right, yeah.

D

I think that's what it was, but the problem is that then I have to like go to the whiteboard.

L

D

Which, in this is a negative which a positive that's.

L

Really no different than like compared to, though, as compared to also return negative and a positive based on whether it's less than greater than or you right.

G

But compared to is not one of our proudest api's I think well,.

D

I, don't know so I think it's so much easier to think about compared to three different values that you can retain. Well, technically, it's not too different a.

M

G

D

Could the only thing that she carries three sections yeah.

A

You came up this race, but yeah I. Think the the question is: is this a scenario that because, as you said, right I mean if you don't even remember what the actual coding struggles where you went through like it feel like designing a pair for that is hard, but actually going in that's now and I mean in this question, were the slice of what I felt you do begin with so.

D

The the problem that I have with the slice method is that I think there are so many scenarios we're like the slice tool that you propose is one of the scenarios. What you would want to use overlap inside in the implementation right, yeah.

K

D

Ran into so many different of these scenarios, and then we kind of singled out this nice dinner. Okay, a lot like my original circle takes up a lot that it's so trivial that you basically can't just write the code. You say yeah, my original.

F

Or suggestion for the slice too was I thought that VB was that if we missed in an overload on our we're returning an interior segment of the data that you gave us that he would end up in a in an identity, but they simply would never be able to use the thing, but we currently have a convention that will add all four or two if it's on Chara, specifically and so right now, we don't really need this.

F

I was just setting separate, but it is frustrating if you call, if you have a writable memory and you call an API that returns, you don't expand and you know it overlaps and trying to figure out what memory do you need to pass through? The second stage of it.

F

But that's fine.

D

There is something here you should I think we are missing somebody else. Okay, I, just don't know whether the neurons that you propose are not just like one of these factors and I, or we should holistically think like about this whole stage. It.

L

Might be good to talk to Earhart and see how they're using memory, because I know they're using memory heavily and they're at and they were having some problems with having to work to span and back.

L

F

Well, I guess: I, don't know who you suggesting that actual on this was already dead.

F

D

We should like gather more torches in this space into actually this issue and then at some point decide how we design it such that it's oh, he.

M

A

D

Quite a few problems: can you elaborate on what suppose I could I could try to search.

A

I'm, a close, so how do we totally describe this general problem? Like is it you want to deduce some information based on bounce of existing spans? Is that like I can try to? Let me enter one like how do you describe what the problem is you're trying to go after so.

D

Maybe you know everybody has a slightly different perspective, I kind of run quite often into a case where spam kind of is a black hawk. Alright, like it loses infantry lots of information, and often you kind of you call some operation, you get back a span now you lost information and now it's very difficult to write, cold dead. You know, compares memory and span and this, and that knows where they are copying. You know copying comparing slicing one based on where the other is so. We.

B

Added the overlap, any PS.

D

Exactly for these scenarios, but they are so low level and so difficult to use that every time I need to do. Something here takes me an hour I'm, drawing something automatically yeah.

L

And I think the primary case isn't, by going from span to read, only span or anything like that. It's just it's going from span back to memory because you can't store a span. You have to store memory in most normal structures and.

L

Most api's will want to work in terms of span because it's more complete well, so you've got the api's that have to be spam and the storage has to be memory. And how do you go between well.

G

Keep in mind that was the driving motivation for this anyway, because we were talking about a we have spam, I'm sorry read-only span of char doctrine as an extension method, and we were adding read-only memory of our doctrine as another extension of it and it was Oh. Can you build an arbitrary read-only memory of T, whatever extension method, on top of an arbitrary span of the extension method?

G

And the answer was yes, if you can kind of Reason how to think about these API is ready so having having sliced two or something like that would solve the more general case of what we were trying to do. When this proposal first came off.

B

F

So if we think that right now, there's not enough need and that what we should do is figure out more call, it usability problems span and particular things that overlap solves.

D

The need for them, but maybe so I, don't have a very as I said, I kind of observed some problems. I need picture of what the solution is. My initial reaction to this proposal was well.

D

We are adding kind of a very specific metal sheet. We fix all the lives that so trivial that I can just write this vise to myself, but maybe it's not if I mean, maybe we won't let those sliced methods- I, don't know I noticed writing. Like writing. Slice.

F

To in terms of overlaps is trivial in that it is there's the one correct like five line. Well, once implementation once you know what the lines are. Yes, yes, pseudo. Yes, there is, there is trivia. You just need to know the right.

D

Answer: it's not necessarily easy.

F

Yes, you just need to know so.

A

This is what I wrote up like. How do we generally agree with that, because then my proposal would be there be close this issue and they revisit this. When we have more evidence, you.

G

What would really help here is just like what code do we say, people from that right.

F

Well, I mean the part of the original proposal precise to is so that we didn't have to maintain the guidance that you know we have to always add before overloads. Yes,.

F

Memory, we don't memory, we don't span, you know, but and we're going to maintain a position that at least in the VCL and we're going to tell people if you are returning. If you take in a thing and return, it thing that you should return or.

G

Have all four of them, yeah I think we would have all four regardless because it makes it easier to use. But do me once other library, authors till I call forward I think.

L

Most library, authors will want to write span and we'd only span, so just talking on, like some discord channels and stuff with people. A lot of them don't even want to have like array overloads, because they're saying I'm on core I, don't have to worry about it.

L

I'm just gonna take a span because that will work for everything and the only reason to add array overloads is for Bakula, and so if people are already saying that about that, they're also going to say oh I, don't have to have to write a span and or we don't expand, and a memory and a memory of T overlooked, wouldn't span will be sufficient for everything. And the more remaining question is: how do I go back to memory? Well,.

F

Cause it was just span it like if you're doing you know some great sum over span is there on.

M

F

It's both an input and an output. Now you end up with quadruped.

L

And if we have a single API that says, given a span you can or given a read-only span, you can go back to a span or give a name read only spent you can go back to memory of T. Then we solve the bought over a little problem for any customer writing API, so including possibly ourselves.

L

F

Our guidance is, you should at all for the people who are only adding one or violating our unpublished guidance and something like slows to.

G

Work for people.

L

G

L

If we say at all, for you still have the case of I, don't want to write the implementation four times. I want to write at once, and then the others are helpers. That just call you know as spam and then twice so I think, no matter what we have a case. If we need something that goes from Ben to memory.

F

So that, but we've like we're suggesting going back on where we previously said no, it's like school. Why did we say hey Steve? Why did you say no to it? I don't know. Remember.

F

That you said that it was generally not needed and that it was accomplishable via overlaps and therefore it was fluff. That's the summary in my brain, not your exact words. Of course, it.

B

Sounds like me, I honestly, don't remember: I'd have to go back and look.

L

Maybe maybe this is a, we should get a couple more like examples of places where people will probably probably be doing this already and then revisit and say. This is what the API should look like. You.

F

You know it's um it's unclear whose action that's supposed to be. If it's mine, then I, don't know what it will happen. I.

L

Can personally send an email.

L

He's got some more data on hairy mole nets. Doing this soon as I know that they're having to do it already so I think.

A

In general, it's always best if the person who has the problem is driving they're collecting what the problem is at least right, because otherwise it's a bit like fishing in there right.

F

So, like I, wouldn't I originally proposed the slice. It was so that we, as the VCL did not have to always at all. For that we could add all four when we Brad it was more convenient or prettier or something, but that this gave us an escape valve and but third parties have an escape valve and then and then we kind of we sort of said we don't need it because overlaps and our guidance right now is we always helpful and yeah I.

F

Think that's, and if we want to waffle on that position, then that's fine. I, just don't have anything different than the original proposal. All.

A

Right so any objections, any closing position, then, if we can revisit it, if.

F

We get more data, we can reopen it exactly.

A

All right the thing we're over time now so, unless this is super controversial, easy seems easy enough.

A

I'm sure, good parent, so.

G

The scenario here was that um Assam had code that's gone into the the chasing stuff where he wants to recreate the scalar value from a surrogate hair right now, there's an API char dots gets what does it charge off from utf-32 or to utf-32? Something like that, however, a it's not a try API and be like it doesn't really use the we're in type that we're trying to drive people toward. This is basically wrapping that logic in a convenient. Try based pattern and when doesn't you can both it returns false.

G

If you pass in something that's not a ballot surrogate huh in particular, I surrogates, not a hi surrogate and.

F

There we go so that.

D

Can be checked that could be done as a precondition check before you throw a method that throws, if you us, but how do you know what those.

K

Checks are or not it's a surrogate.

G

We have it yeah the same thing: you're gonna call inside yeah.

F

G

Like you can you can already do this using existing public API? So the thing is: this is a one-liner to do it, whereas previously you would have to do like five or six or seven lines to set everything up so.

A

How does it like how would I use this API from the point of you're like how do I know my short pairs like how do I come.

G

Up with the model thin air, usually so you're they're not coming out of thin air you're generally getting them because you're reading some data coming across the wire in Alison's case he sees /q encoded data, I mean inside the JSON payload and the very first thing he does is he tries to he. He takes the the first last year that he sees and he says, okay, let me try to treat this as a standalone, scalar value. If that fails, read the second slash here.

G

If there's not one just fails trade off once you decode the second slash, you call this API passing both of the men. If this one still fails the data spam, then he broke and he throws this. So he.

B

G

To play, but either he goes you could he could do other actions I.

B

Would say if they're there an equivalent room today that throws, or is this confusion, nothing that today that takes a high and a low surrogate and creates Abreu nada, correct.

G

We have we have AP is that we we have try, create api's already that return false. The idea is those api's return false. If you want an api, the throws call a constructor overloading so there's a constructor terminal that takes two charts. There's not I. Have it's a last line here, I say hey.

G

If we want to not try pattern for this, we should add that constructor overloading there, our constructor, overloading to take a single char, constructor, overloading a single int and so on, they're also trying a P is to take a single char, a single int and so on so I sure we appear specific to utf-16. They are yes, there's no UTI 3d cubicle.

A

And there's no there's no utf-8 equivalent, there's no utf-32 the.

K

Utf-16 specific problem of how do you represent data that doesn't fit in the system.

G

And that's why these are tied to system chart.

D

Methods in the framework and I, basically just helpers on something or something that color in check cuz I. We have lots of try api's @ 32.5 parts. No, that's not the same, because basically you would have to kind of parse the text yourself. So it's not that a simple check like is it you know it's the text. If we had method here, is the text win32 and show it to do it before you compares, but we don't have it. This one is an example of something that, like you, could just write before only this match.

D

So how long is implement here is literally like the one.

A

On implementation, no.

G

I mean calling this is a one-line diplomat against this. If you want, if you blow up this channel, like the implementation of this check, is around a termite. What's really, why? Because you need to check the inputs, and then you need to reconfirm value for me. Well,.

B

The just isn't it just charge on is hi surrogate hi surrogate and charge on his low surrogate most surrogate new room convert to utf-32. It's a much more optimized.

G

Implementation about that, yes, I, understand.

B

But that's functionally that's when it's do actually that's what it does. Yes,.

D

B

G

K

D

Thing is some kind of guidance for like when to introduce Tribeca. That is, you know if I just call the throwing exception method and you slow. The second thing is, you know: it's not the precondition.

G

That I could just right, so we we already have eighty eyes on room, try create a P is like try create from char try create from int like. Why did we have those ad is, if lon as conveniences, to create these things, where you want the framework to do the check for you, so that you don't have to like that. So we could try create possible what I'm sorry.

D

Yep and basically pizzas, so that we I.

L

Would think like the common case here? Is you have a parser and you get a character and you want to say if care is surrogate, then try create with current and next and if that fails, throw otherwise you're, not in a surrogate parent. You just processes so.

G

That API already exists here already existed, a own system has burn, there is a. There is an API that takes a read-only span of char and says just like read the first thing from us. If that handles both these are going on circuit.

D

So we already have a metal try, create that takes just one child, and this one is just a you know: it's more of the same yeah. My comment was many. We have guidance, wanna, try. We try to avoid adding try methods because we kind of are opening the gates a bit more and more he's like hey. You know if adding try, api's or various things that nobody would yeah, they put.

G

Our triad, it's it's! Really! It's really nothing more than a helper that wraps all of the truck so that you wouldn't have done yourself well,.

L

And we also already have the helper method care dot is surrogate pair.

L

K

L

Specific health or nothing another thing, I could always sorry. We shouldn't image surrogate pair yeah. We have is surrogate pair, which takes the low and high returns true or false.

F

So these are one BIOS well I'm, because that one so again that one does get a little a little weird in that that work then gets replicated when you call create, but they're these a stupid, simple check social.

L

That this method could be implemented, as return is surrogate pair question mark and then new rune, otherwise throw expression. People.

G

Yeah yeah I mean that's. That is highly not optimized for yeah I mean.

A

Honestly, giving them a have, try, create I mean I would suggest if you ship this method of a public just call it try, create not even bother with the puncture gate pair in the method name, because even your argument list, you have it's clear that you created from and then the pair and then the basically comes an overload of the existing three which, in my opinion is said.

G

Also out of this constructor, because that we already have that establish, have enjoyed all the try, create methods have equivalent constructors personally.

A

I would be okay with it and then Devon would through alright yeah constructors, always go away. Yeah I'm fine with that too.

A

Let me just add: this is a No you, you.

A

A

A

All right, so then it's through this.

A

You all right, I think that's it for today.

F

Consider the Triforce pattern for members that might throw exceptions.

A

And thanks to people online I.

D

Have perfectly this guy.