On 4/29/21 9:02 AM, novice2 wrote:

> format() can throw.

In order to throw for an int, I added a foo(x) expression to prove that the code works.

> I don't want embrace format into try..catch block,
> and i found elegant std.exception.ifThrown.

There are collectException and collectExceptionMsg as well. The following code works for 42 and uses the default string "error" for 43.

int foo(int x) {
  import std.exception : enforce;
  enforce(x == 42, "some error");
  return x;
}

nothrow string foo(int x, string def) {
  import std.format: format;
  import std.exception: collectException;

  string result;
  auto exc = collectException(format("%d", foo(x)), result);
  return (exc is null) ? result : def;
}

void main() {
  import std.stdio: writeln;
  writeln(foo(42, "error"));
  writeln(foo(43, "error"));
}

Ali

On 4/29/21 1:50 PM, Meta wrote:

> 
> The reason for this, apparently, is in the definition of `ifThrown`:
> ```
> CommonType!(T1, T2) ifThrown(E : Throwable = Exception, T1, T2)(lazy scope T1 expression, lazy scope T2 errorHandler) nothrow
> ```
> 
> It's not marked as `nothrow` in the function's definition, so even if the delegate passed to ifThrown _is_ nothrow, the compiler can't tell. There's no easy way around this that I can think of OTOH that doesn't involve some effort on your part.

Wait, I don't get what you are saying. You mean it should be marked nothrow? It's a template, so it *should* be inferred nothrow if it were actually nothrow.

The current definition is not marked nothrow as you alluded, and when I do mark it nothrow, it complains that the lazy parameter used for the exception handler is not nothrow.

It seems there's no way to infer the throwing of the lazy parameter, lazy parameters are never nothrow.

The higher order function DIP would I think help with this.

-Steve

On Friday, 30 April 2021 at 13:05:00 UTC, Steven Schveighoffer wrote:
> On 4/29/21 1:50 PM, Meta wrote:
>
>> 
>> The reason for this, apparently, is in the definition of `ifThrown`:
>> ```
>> CommonType!(T1, T2) ifThrown(E : Throwable = Exception, T1, T2)(lazy scope T1 expression, lazy scope T2 errorHandler) nothrow
>> ```
>> 
>> It's not marked as `nothrow` in the function's definition, so even if the delegate passed to ifThrown _is_ nothrow, the compiler can't tell. There's no easy way around this that I can think of OTOH that doesn't involve some effort on your part.
>
> Wait, I don't get what you are saying. You mean it should be marked nothrow? It's a template, so it *should* be inferred nothrow if it were actually nothrow.
>
> The current definition is not marked nothrow as you alluded, and when I do mark it nothrow, it complains that the lazy parameter used for the exception handler is not nothrow.
>
> It seems there's no way to infer the throwing of the lazy parameter, lazy parameters are never nothrow.
>
> The higher order function DIP would I think help with this.
>
> -Steve

Change it to a delegate and it's the same thing. ifThrown being a template is irrelevant in this case because it is accepting the handler as a function argument, not a template argument. You:

1. Need to make it a delegate instead of a lazy argument.

2. Need to mark the delegate as nothrow.

For the function to be inferred as nothrow.

On 4/30/21 9:24 AM, Meta wrote:
> On Friday, 30 April 2021 at 13:05:00 UTC, Steven Schveighoffer wrote:
>> On 4/29/21 1:50 PM, Meta wrote:
>>
>>>
>>> The reason for this, apparently, is in the definition of `ifThrown`:
>>> ```
>>> CommonType!(T1, T2) ifThrown(E : Throwable = Exception, T1, T2)(lazy scope T1 expression, lazy scope T2 errorHandler) nothrow
>>> ```
>>>
>>> It's not marked as `nothrow` in the function's definition, so even if the delegate passed to ifThrown _is_ nothrow, the compiler can't tell. There's no easy way around this that I can think of OTOH that doesn't involve some effort on your part.
>>
>> Wait, I don't get what you are saying. You mean it should be marked nothrow? It's a template, so it *should* be inferred nothrow if it were actually nothrow.
>>
>> The current definition is not marked nothrow as you alluded, and when I do mark it nothrow, it complains that the lazy parameter used for the exception handler is not nothrow.
>>
>> It seems there's no way to infer the throwing of the lazy parameter, lazy parameters are never nothrow.
>>
>> The higher order function DIP would I think help with this.
> 
> Change it to a delegate and it's the same thing. ifThrown being a template is irrelevant in this case because it is accepting the handler as a function argument, not a template argument. You:
> 
> 1. Need to make it a delegate instead of a lazy argument.
> 
> 2. Need to mark the delegate as nothrow.
> 
> For the function to be inferred as nothrow.

My point is that I think marking the *function* nothrow is not correct, it's the second parameter that dictates the throwing of the result.

And you can probably fix the second parameter to be a templated delegate:

```d
CommonType!(T1, T2) ifThrown(E : Throwable = Exception, T1, T2)(lazy scope T1 expression, scope T2 errorHandler) if (is(typeof(errorHandler(E.init))))
```

And of course, we get into chicken-and-egg problems with this because if you pass in a lambda, there's no types for it to figure this stuff out. Another option is to overload on the delegate, but meh. I'd really like to see a language change that says "infer the attributes of this function based on the fact that it calls the delegate passed in."

-Steve

On Friday, 30 April 2021 at 13:42:49 UTC, Steven Schveighoffer wrote:
> On 4/30/21 9:24 AM, Meta wrote:
>
> My point is that I think marking the *function* nothrow is not correct, it's the second parameter that dictates the throwing of the result.
>
> And you can probably fix the second parameter to be a templated delegate:
>
> ```d
> CommonType!(T1, T2) ifThrown(E : Throwable = Exception, T1, T2)(lazy scope T1 expression, scope T2 errorHandler) if (is(typeof(errorHandler(E.init))))
> ```
>
> And of course, we get into chicken-and-egg problems with this because if you pass in a lambda, there's no types for it to figure this stuff out. Another option is to overload on the delegate, but meh. I'd really like to see a language change that says "infer the attributes of this function based on the fact that it calls the delegate passed in."
>
> -Steve

Now that you mention it, I don't see why lazy parameters can't have their attributes inferred. What happened to the DIP to replace lazy parameters with automatic conversion of passed values to delegates, anyway? I.e.:
```
CommonType!(T1, T2) ifThrown(E: Throwable = Exception, T1, T2)(scope T1 delegate() expression, scope T2 delegate() errorHandler);

//getString() and "some string" automatically converted to `string delegate()`
auto s = getString().ifThrown("some string");
```