Have you ever written something like:

auto str = "hello".map(r => r.toUpper).array;

and been confronted with fun errors like:

Error: template std.algorithm.iteration.map cannot deduce function from argument types !()(string, void), candidates are:
/dlang/dmd/linux/bin64/../../src/phobos/std/algorithm/iteration.d(479):       map(fun...)
  with fun = ()
  must satisfy the following constraint:
       fun.length >= 1

What the hell is the "fun length"? This is not FUN!!!

In any case, I thought of maybe adding something like this:

void map()(...) {
   static assert(false, "You didn't mean to do this. Make your lambda a template parameter");
}

To instead get a better error message:

Error: static assert:  "You didn't mean to do this. Make your lambda a template parameter"

 Is this worth adding to Phobos?

-Steve

On Thursday, 15 April 2021 at 22:02:10 UTC, Steven Schveighoffer wrote:
> Have you ever written something like:
>
> auto str = "hello".map(r => r.toUpper).array;
>
> and been confronted with fun errors like:
>
> Error: template std.algorithm.iteration.map cannot deduce function from argument types !()(string, void), candidates are:
> /dlang/dmd/linux/bin64/../../src/phobos/std/algorithm/iteration.d(479):
>       map(fun...)
>   with fun = ()
>   must satisfy the following constraint:
>        fun.length >= 1
>
> What the hell is the "fun length"? This is not FUN!!!
>
> In any case, I thought of maybe adding something like this:
>
> void map()(...) {
>    static assert(false, "You didn't mean to do this. Make your lambda a template parameter");
> }
>
> To instead get a better error message:
>
> Error: static assert:  "You didn't mean to do this. Make your lambda a template parameter"
>
>  Is this worth adding to Phobos?
>
> -Steve

As a noob, when I see error messages like the first one, I immediately just pick out the line number, and just stare at the offending code until I realise I've missed an "!". I think your proposed error message tells me instantly what went wrong.

Thanks,

Jordan

On 4/15/21 3:02 PM, Steven Schveighoffer wrote:
> Have you ever written something like:
>
> auto str = "hello".map(r => r.toUpper).array;

> To instead get a better error message:
>
> Error: static assert:  "You didn't mean to do this. Make your lambda a
> template parameter"
>
>   Is this worth adding to Phobos?
>
> -Steve

YES! :)

Coincidentally, I have wasted considerable amount of time just now with the following error message:

import std.format;
import std.algorithm;

void main() {
  auto content = q"EOS
1 first line
2 second line
EOS";

  foreach (line; content) {
    int i;
    string s;
    line.formattedRead!"%s %s"(i, s);
  }
}

The first line of the 78-line error message is this:

/usr/include/dmd/phobos/std/format.d(1492): Error: template `std.range.primitives.empty` cannot deduce function from argument types `!()(immutable(char))`, candidates are:

but the line in format.d, which my editor was showing me was this:

    assert(!r.empty, "Required at least one more input");

I admit that my brain was reading the error message on the source code instead of the actual error message and I was scratching my head, trying to understand what "one more input" meant.

The programmer's error was something completely different: 'content' is not an iterable thing; it's a string. Argh! So, one solution is to iterate over content.splitter('\n') in the loop.

Ali

On 2021-04-16 00:02, Steven Schveighoffer wrote:
> Have you ever written something like:
> 
> auto str = "hello".map(r => r.toUpper).array;
> 
> and been confronted with fun errors like:
> 
> Error: template std.algorithm.iteration.map cannot deduce function from argument types !()(string, void), candidates are:
> /dlang/dmd/linux/bin64/../../src/phobos/std/algorithm/iteration.d(479):       map(fun...)
>   with fun = ()
>   must satisfy the following constraint:
>        fun.length >= 1

Yes, definitely. I doesn't help when there are longer chains and they're nested. It usually results in even more cryptic error messages.

BTW, what's stopping us from supporting the above syntax? Why do we still pass the lambda as a template argument? In that past, before proper support for lambdas, there was a use case to pass a string literal, which must be passed as a template argument. If DMD cannot inline the lambda, who cares, use LDC instead.

-- 
/Jacob Carlborg

On 4/16/21 7:23 AM, Jacob Carlborg wrote:
> On 2021-04-16 00:02, Steven Schveighoffer wrote:
>> Have you ever written something like:
>>
>> auto str = "hello".map(r => r.toUpper).array;
>>
>> and been confronted with fun errors like:
>>
>> Error: template std.algorithm.iteration.map cannot deduce function from argument types !()(string, void), candidates are:
>> /dlang/dmd/linux/bin64/../../src/phobos/std/algorithm/iteration.d(479):       map(fun...)
>>   with fun = ()
>>   must satisfy the following constraint:
>>        fun.length >= 1
> 
> Yes, definitely. I doesn't help when there are longer chains and they're nested. It usually results in even more cryptic error messages.
> 
> BTW, what's stopping us from supporting the above syntax? Why do we still pass the lambda as a template argument? In that past, before proper support for lambdas, there was a use case to pass a string literal, which must be passed as a template argument. If DMD cannot inline the lambda, who cares, use LDC instead.
> 

It could possibly work, if you specify the type. But I haven't thought about the ramifications. I want to avoid creating closures, and as you say, inlining might be affected.

-Steve