On Wednesday, January 29, 2025 6:38:07 PM MST Kyle Ingraham via Digitalmars-d-learn wrote:
> Does D have a 'try' `std.conv:to` that does not throw if it
> fails? Something like:
> ```D
> string input = "9";
> int output;
> auto parsed = input.tryTo!int(output);
> ```
>
> `std.conv:to` is super flexible and does exactly what I need.
> However, hitting an exception for conversion failures really
> slows down my code. A conversion failure wouldn't be an exception
> for my use case. I'm trying to write web application route
> constraint code like what's [available in
> C#](https://github.com/dotnet/aspnetcore/blob/main/src/Http/Routing/src/Constraints/IntRouteConstraint.cs#L53). There, code like `Int.TryParse` is used to figure out whether a string meets a route constraint.
>
> `std.conv:to` is almost perfect with it's flexibility across types. I'm just hoping I've missed the version that doesn't throw.

Unfortunately, there isn't currently a function like std.conv.to which does not throw. It's been suggested before, but it's never been implemented (and would probably require quite a bit of refactoring if we want to avoid code duplication). It's definitely on the todo list for the next major version of Phobos, but we've never added such a function to the current version.

So, if you want to avoid having the conversion throw, you have to test the value that you're converting first to make sure that the conversion won't fail - e.g. something like all!isDigit(input) if you're converting a string to an int.

- Jonathan M Davis

On Thursday, 30 January 2025 at 02:08:49 UTC, Jonathan M Davis wrote:
> Unfortunately, there isn't currently a function like std.conv.to which does not throw. It's been suggested before, but it's never been implemented (and would probably require quite a bit of refactoring if we want to avoid code duplication). It's definitely on the todo list for the next major version of Phobos, but we've never added such a function to the current version.

Thanks very much Jonathan. That confirms what I thought (but really hoped wasn't the case). I'll take a look at what it might take to modify std.conv.to.

On Wed, Jan 29, 2025 at 07:08:49PM -0700, Jonathan M Davis via Digitalmars-d-learn wrote:
> On Wednesday, January 29, 2025 6:38:07 PM MST Kyle Ingraham via Digitalmars-d-learn wrote:
> > Does D have a 'try' `std.conv:to` that does not throw if it fails?
> > Something like:
> > ```D
> > string input = "9";
> > int output;
> > auto parsed = input.tryTo!int(output);
> > ```
> >
> > `std.conv:to` is super flexible and does exactly what I need.
> > However, hitting an exception for conversion failures really slows
> > down my code. A conversion failure wouldn't be an exception for my
> > use case. I'm trying to write web application route constraint code
> > like what's [available in
> > C#](https://github.com/dotnet/aspnetcore/blob/main/src/Http/Routing/src/Constraints/IntRouteConstraint.cs#L53).
> > There, code like `Int.TryParse` is used to figure out whether a
> > string meets a route constraint.
> >
> > `std.conv:to` is almost perfect with it's flexibility across types. I'm just hoping I've missed the version that doesn't throw.
> 
> Unfortunately, there isn't currently a function like std.conv.to which does not throw.

I thought std.conv.parse* is supposed to fill that role?  Or am I remembering wrong?  They don't quite have the same level of convenience as .to, though.


--T

-- 
One reason that few people are aware there are programs running the internet is that they never crash in any significant way: the free software underlying the internet is reliable to the point of invisibility. -- Glyn Moody, from the article "Giving it all away"

On Wednesday, January 29, 2025 8:00:43 PM MST H. S. Teoh via Digitalmars-d-learn wrote:
> > Unfortunately, there isn't currently a function like std.conv.to which does not throw.
>
> I thought std.conv.parse* is supposed to fill that role?  Or am I remembering wrong?  They don't quite have the same level of convenience as .to, though.

No, parse is for converting only the first part of the input, with the idea that you'll call it repeatedly to parse out multiple values, whereas to converts the entire string. parse will still throw. It's just not going to be under quite the same circumstances. And the fact that it parses what it can and leaves the rest behind to be parsed next can make for some surprising results sometimes, and you can easily end up with it converting less than you would have wanted, which can get rather interesting when it comes to reporting failures in a clean manner. parse has its uses, but personally, I prefer to split the input and then convert each piece individually rather than using parse. Either way, it's definitely not a nothrow version of to. It's its own thing with its own quirks.

What we really need is something like tryTo that returns a Nullable which has no value when the conversion fails, and then preferably, tryTo would share its implementation with to (though that could get tricky, particularly if you want to minimize how deep the templates go - even more so given that to can't simply be a wrapper around tryTo if you want to provide any information about why it failed like it currently does). But to's implementation is probably going to get a major overhaul for Phobos v3 anyway to try to reduce how many template instantiations it incurs. Either way, tryTo is definitely planned as part of Phobos v3.

- Jonathan M Davis