Bug 8851 – std.string.join should allow 'char' as joiner

import std.string; void main() { char sep = '|'; string z = ["foo", "bar"].join(sep); } test.d(7): Error: template std.array.join does not match any function template declaration D:\DMD\dmd2\windows\bin\..\..\src\phobos\std\array.d(1273): Error: template std.array.join cannot deduce template function from argument types !()(string[],char) Well apparently it's std.array.join, but nevertheless it should work.

I expect that this stems from the stupidity of character literals defaulting to char rather than dchar, and when you couple that with the fact that templates always use the _exact_ type of what you give them, it's going to try and instantiate join with a separator of char, which doesn't work with ranges of dchar. I'm not sure how you'd go about fixing that.

(In reply to comment #1) > I expect that this stems from the stupidity of character literals defaulting to > char rather than dchar, and when you couple that with the fact that templates > always use the _exact_ type of what you give them, it's going to try and > instantiate join with a separator of char, which doesn't work with ranges of > dchar. I'm not sure how you'd go about fixing that. I investigated, and that's not it. It's *just* that std.array.join, like std.algorithm.joiner, expects the separator to be a range. The enhancement request here would be for both "std.array.join" std.algorithm.joiner" to accept a single element as a separator. In the meantime, of course, a simple workaround is to just "join([sep])". I think this needlessly allocates a 1 element array though, no? -------- On a side note, the current restrictions in join are overly restrictive, requiring an exact match, making this illegal: int[] sep = [1]; double[] z = [[0.1], [0.2]].join(sep); When it is perfectly supported: joiner supports it.

(In reply to comment #1) > I expect that this stems from the stupidity of character literals defaulting to > char rather than dchar, and when you couple that with the fact that templates > always use the _exact_ type of what you give them, it's going to try and > instantiate join with a separator of char, which doesn't work with ranges of > dchar. I'm not sure how you'd go about fixing that. I investigated, and that's not it. It's *just* that std.array.join, like std.algorithm.joiner, expects the separator to be a range. The enhancement request here would be for both "std.array.join" std.algorithm.joiner" to accept a single element as a separator. In the meantime, of course, a simple workaround is to just "join([sep])". I think this needlessly allocates a 1 element array though, no? -------- On a side note, the current restrictions in join are overly restrictive, requiring an *exact* ElementType match, making this illegal: int[] sep = [1]; double[] z = [[0.1], [0.2]].join(sep); The implementation actually perfectly supports it. As a matter of fact, joiner supports it. I'll see into relaxing the restraints for now, and taking the opportunity to investigate using an element as a separator.

(In reply to comment #3) > (In reply to comment #1) > > I expect that this stems from the stupidity of character literals defaulting to > > char rather than dchar, and when you couple that with the fact that templates > > always use the _exact_ type of what you give them, it's going to try and > > instantiate join with a separator of char, which doesn't work with ranges of > > dchar. I'm not sure how you'd go about fixing that. > > I investigated, and that's not it. > > It's *just* that std.array.join, like std.algorithm.joiner, expects the > separator to be a range. > > The enhancement request here would be for both "std.array.join" > std.algorithm.joiner" to accept a single element as a separator. > > In the meantime, of course, a simple workaround is to just "join([sep])". > > I think this needlessly allocates a 1 element array though, no? > > -------- > On a side note, the current restrictions in join are overly restrictive, > requiring an *exact* ElementType match, making this illegal: > > int[] sep = [1]; > double[] z = [[0.1], [0.2]].join(sep); > > The implementation actually perfectly supports it. As a matter of fact, joiner > supports it. I'll see into relaxing the restraints for now, and taking the > opportunity to investigate using an element as a separator. That was fast actually. Both the fix and the enhancement are trivially trivial. I believe in the change, so I'm assigning to self.

(In reply to comment #4) > I believe in the change, so I'm assigning to self. Is this part of any open pulls you've made?

(In reply to comment #5) > (In reply to comment #4) > > I believe in the change, so I'm assigning to self. > > Is this part of any open pulls you've made? Turns out I *completely* forgot about this. If you want to do anything regarding this pull, please go right on ahead. Seems code gets into Phobos faster when I review rather than write ^^

better yet, accept dchar

(In reply to comment #7) > better yet, accept dchar Well, it's just a public import of std.array.join, so it should really just accept "(R, E)" and "(R, R)".

See also Issue 5542 that is different but related.

anyone working on this currently?

(In reply to Robert Schadek from comment #10) > anyone working on this currently? No one that I know of. Although 'only' was recently introduced that helped work around the issue, it is still in need of fixing.

I've tried using only but it didn't really work.

(In reply to Andrej Mitrovic from comment #12) > I've tried using only but it didn't really work. example?

import std.string; void main() { char sep = '|'; string z = ["foo", "bar"].join(sep.only); }

(In reply to Andrej Mitrovic from comment #14) > import std.string; > > void main() > { > char sep = '|'; > string z = ["foo", "bar"].join(sep.only); > } I'll assume you also imported std.range, and got this error? Error: template std.array.join cannot deduce function from argument types ... It seems the issue here is that the template restrictions are overzealous in that it checks for exact element type matching, rather than checking if they have a common type (Or at the very least, if ElementType!Sep is implicitly convertible to ElementType!(ElementType!RoR)). As a workaround, using an (explicit) dchar only works. //---- import std.range; import std.stdio; void main() { ["foo", "bar"].join(dchar('|').only).writeln(); } //---- So Jonathan's original assesment(https://issues.dlang.org/show_bug.cgi?id=8851#c1) was also correct (it's a dual issue I guess)

Yeah, looks like we may have to make multiple fixes here? Anyway, it would be nice to get this taken care of. :)

I'm on it

issue 5542 refers to the same bug

(In reply to Robert Schadek from comment #18) > issue 5542 refers to the same bug Issue 5542: join("123", "x") ==> "1x2x3" This issue: join(["foo", "bar"], '|') ==> "foo|bar"

woops sry, lets stay both issues are from the same class

Commits pushed to master at https://github.com/D-Programming-Language/phobos https://github.com/D-Programming-Language/phobos/commit/082176b1b312c7070ef18e298ca38b40f485f64e issue8851 some more some review fixes some more removed a to https://github.com/D-Programming-Language/phobos/commit/6e626e0b6ed5c91307cbbbeedc9c18d82022adfc Merge pull request #2533 from burner/issue8851 issue8851