• Jacob Carlborg (19/19) Feb 19 2011 Compiling the following code with DMD 2.052 on Mac OS X:
• Steven Schveighoffer (9/26) Feb 19 2011 D currently suffers from a form of schizophrenia. in Phobos, char[] and...
• Jacob Carlborg (5/36) Feb 20 2011 So you're saying that I can only use dstrings for anything with the same...
• Steven Schveighoffer (5/43) Feb 20 2011 Yes, dstrings act like arrays according to phobos. wstrings and strings...
• Jacob Carlborg (8/52) Feb 20 2011 I'm confused about how someone can implement a library like this. Every
• bearophile (18/20) Feb 20 2011 I use this thread to ask regarding one specific little problem I have wi...
• Steven Schveighoffer (6/29) Feb 20 2011 Just a blind guess, I have not tested, but maybe it's because the compil...
• bearophile (9/12) Feb 20 2011 Right, this works:
• bearophile (1/1) Feb 20 2011 http://d.puremagic.com/issues/show_bug.cgi?id=5630
• Lars T. Kyllingstad (3/42) Feb 21 2011 It's probably using immutable(char) since that's the element type of "AB...
• Steven Schveighoffer (17/22) Feb 20 2011 Strings are a sore spot for me, I think the current implementation is a ...
• Jacob Carlborg (5/28) Feb 20 2011 Oh, I remember that thread(s). It got so overly complicated so I stopped...
• Steven Schveighoffer (4/37) Feb 20 2011 Yeah, UTF is so overly complicated, it's difficult to properly implement...

Jacob Carlborg <doob me.com> writes:

Compiling the following code with DMD 2.052 on Mac OS X:

import std.array;

void main ()
{
     char[] a;
     char[] b;
     a.replace(1, 3, b);
}

Results in the following error:

test.d(7): Error: template std.array.replace(T,Range) if 
(isDynamicArray!(Range) && is(ElementType!(Range) : T)) does not match 
any function template declaration
test.d(7): Error: template std.array.replace(T,Range) if 
(isDynamicArray!(Range) && is(ElementType!(Range) : T)) cannot deduce 
template function from argument types !()(char[],int,int,char[])

What am I doing wrong or isn't std.array.replace supposed to work with 
char[]?

-- 
/Jacob Carlborg

"Steven Schveighoffer" <schveiguy yahoo.com> writes:

On Sat, 19 Feb 2011 16:23:12 -0500, Jacob Carlborg <doob me.com> wrote:

 Compiling the following code with DMD 2.052 on Mac OS X:

 import std.array;

 void main ()
 {
      char[] a;
      char[] b;
      a.replace(1, 3, b);
 }

 Results in the following error:

 test.d(7): Error: template std.array.replace(T,Range) if  
 (isDynamicArray!(Range) && is(ElementType!(Range) : T)) does not match  
 any function template declaration
 test.d(7): Error: template std.array.replace(T,Range) if  
 (isDynamicArray!(Range) && is(ElementType!(Range) : T)) cannot deduce  
 template function from argument types !()(char[],int,int,char[])

 What am I doing wrong or isn't std.array.replace supposed to work with  
 char[]?

D currently suffers from a form of schizophrenia.  in Phobos, char[] and  
wchar[] (and related const/immutable versions) are *NOT* treated as arrays  
of char and wchar.  They are treated as bi-directional ranges of dchar.   
The compiler does not see it this way, it thinks they are arrays.

The error in your assumption is that Range's element type is char, when in  
fact it is dchar (Range is the type of the second char[]).  So the  
is(ElementType!(char[]) : char) fails.

-Steve

Jacob Carlborg <doob me.com> writes:

On 2011-02-19 23:20, Steven Schveighoffer wrote:
 On Sat, 19 Feb 2011 16:23:12 -0500, Jacob Carlborg <doob me.com> wrote:

 Compiling the following code with DMD 2.052 on Mac OS X:

 import std.array;

 void main ()
 {
 char[] a;
 char[] b;
 a.replace(1, 3, b);
 }

 Results in the following error:

 test.d(7): Error: template std.array.replace(T,Range) if
 (isDynamicArray!(Range) && is(ElementType!(Range) : T)) does not match
 any function template declaration
 test.d(7): Error: template std.array.replace(T,Range) if
 (isDynamicArray!(Range) && is(ElementType!(Range) : T)) cannot deduce
 template function from argument types !()(char[],int,int,char[])

 What am I doing wrong or isn't std.array.replace supposed to work with
 char[]?

 D currently suffers from a form of schizophrenia. in Phobos, char[] and
 wchar[] (and related const/immutable versions) are *NOT* treated as
 arrays of char and wchar. They are treated as bi-directional ranges of
 dchar. The compiler does not see it this way, it thinks they are arrays.

 The error in your assumption is that Range's element type is char, when
 in fact it is dchar (Range is the type of the second char[]). So the
 is(ElementType!(char[]) : char) fails.

 -Steve

So you're saying that I can only use dstrings for anything with the same 
template constraint?

-- 
/Jacob Carlborg

"Steven Schveighoffer" <schveiguy yahoo.com> writes:

On Sun, 20 Feb 2011 09:45:36 -0500, Jacob Carlborg <doob me.com> wrote:

 On 2011-02-19 23:20, Steven Schveighoffer wrote:
 On Sat, 19 Feb 2011 16:23:12 -0500, Jacob Carlborg <doob me.com> wrote:

 Compiling the following code with DMD 2.052 on Mac OS X:

 import std.array;

 void main ()
 {
 char[] a;
 char[] b;
 a.replace(1, 3, b);
 }

 Results in the following error:

 test.d(7): Error: template std.array.replace(T,Range) if
 (isDynamicArray!(Range) && is(ElementType!(Range) : T)) does not match
 any function template declaration
 test.d(7): Error: template std.array.replace(T,Range) if
 (isDynamicArray!(Range) && is(ElementType!(Range) : T)) cannot deduce
 template function from argument types !()(char[],int,int,char[])

 What am I doing wrong or isn't std.array.replace supposed to work with
 char[]?

 D currently suffers from a form of schizophrenia. in Phobos, char[] and
 wchar[] (and related const/immutable versions) are *NOT* treated as
 arrays of char and wchar. They are treated as bi-directional ranges of
 dchar. The compiler does not see it this way, it thinks they are arrays.

 The error in your assumption is that Range's element type is char, when
 in fact it is dchar (Range is the type of the second char[]). So the
 is(ElementType!(char[]) : char) fails.

 -Steve

 So you're saying that I can only use dstrings for anything with the same  
 template constraint?

Yes, dstrings act like arrays according to phobos.  wstrings and strings  
do not.  Some functions have specialized versions for strings, some do  
not.  Expect to be confused...

-Steve

Jacob Carlborg <doob me.com> writes:

On 2011-02-20 17:12, Steven Schveighoffer wrote:
 On Sun, 20 Feb 2011 09:45:36 -0500, Jacob Carlborg <doob me.com> wrote:

 On 2011-02-19 23:20, Steven Schveighoffer wrote:
 On Sat, 19 Feb 2011 16:23:12 -0500, Jacob Carlborg <doob me.com> wrote:

 Compiling the following code with DMD 2.052 on Mac OS X:

 import std.array;

 void main ()
 {
 char[] a;
 char[] b;
 a.replace(1, 3, b);
 }

 Results in the following error:

 test.d(7): Error: template std.array.replace(T,Range) if
 (isDynamicArray!(Range) && is(ElementType!(Range) : T)) does not match
 any function template declaration
 test.d(7): Error: template std.array.replace(T,Range) if
 (isDynamicArray!(Range) && is(ElementType!(Range) : T)) cannot deduce
 template function from argument types !()(char[],int,int,char[])

 What am I doing wrong or isn't std.array.replace supposed to work with
 char[]?

 D currently suffers from a form of schizophrenia. in Phobos, char[] and
 wchar[] (and related const/immutable versions) are *NOT* treated as
 arrays of char and wchar. They are treated as bi-directional ranges of
 dchar. The compiler does not see it this way, it thinks they are arrays.

 The error in your assumption is that Range's element type is char, when
 in fact it is dchar (Range is the type of the second char[]). So the
 is(ElementType!(char[]) : char) fails.

 -Steve

 So you're saying that I can only use dstrings for anything with the
 same template constraint?

 Yes, dstrings act like arrays according to phobos. wstrings and strings
 do not. Some functions have specialized versions for strings, some do
 not. Expect to be confused...

 -Steve

I'm confused about how someone can implement a library like this. Every 
time I try to use D2 it's just a PITA to use. I've used D1 and Tango for 
several years and had no problem with that.

I assume this has been discussed, did that resolve in any plans to solve 
this?

-- 
/Jacob Carlborg

bearophile <bearophileHUGS lycos.com> writes:

Jacob Carlborg:

 Every time I try to use D2 it's just a PITA to use. I've used D1 and Tango for 
 several years and had no problem with that.

I use this thread to ask regarding one specific little problem I have with
strings. I want to generate a random string of AB using the array, map, etc,
this looks like a possible implementation (in std.random there is no choice()
function yet):


import std.stdio, std.random, std.string, std.algorithm, std.range;
void main() {
    auto m = map!((i){ return "AB"[uniform(0,2)]; })(iota(10));
    string s = join(array(m));
    writeln(s);
}


It gives this error:
...\dmd\src\phobos\std\array.d(62): Error: result[i] isn't mutable
test.d(5): Error: template instance
std.array.array!(Map!(__dgliteral1,Iota!(int,uint))) error instantiating

What's the right way to write it in D?

The same code in Python2.x:

from random import choice
s = "".join(choice("AB") for _ in xrange(10))
print s

Bye,
bearophile

"Steven Schveighoffer" <schveiguy yahoo.com> writes:

On Sun, 20 Feb 2011 14:51:10 -0500, bearophile <bearophileHUGS lycos.com>  
wrote:

 Jacob Carlborg:

 Every time I try to use D2 it's just a PITA to use. I've used D1 and  
 Tango for
 several years and had no problem with that.

 I use this thread to ask regarding one specific little problem I have  
 with strings. I want to generate a random string of AB using the array,  
 map, etc, this looks like a possible implementation (in std.random there  
 is no choice() function yet):


 import std.stdio, std.random, std.string, std.algorithm, std.range;
 void main() {
     auto m = map!((i){ return "AB"[uniform(0,2)]; })(iota(10));
     string s = join(array(m));
     writeln(s);
 }


 It gives this error:
 ...\dmd\src\phobos\std\array.d(62): Error: result[i] isn't mutable
 test.d(5): Error: template instance  
 std.array.array!(Map!(__dgliteral1,Iota!(int,uint))) error instantiating

 What's the right way to write it in D?

 The same code in Python2.x:

 from random import choice
 s = "".join(choice("AB") for _ in xrange(10))
 print s

Just a blind guess, I have not tested, but maybe it's because the compiler  
is using const(char) as the return type for your delegate literal since  
you never specify one?

-Steve

bearophile <bearophileHUGS lycos.com> writes:

Steven Schveighoffer:

 Just a blind guess, I have not tested, but maybe it's because the compiler  
 is using const(char) as the return type for your delegate literal since  
 you never specify one?

Right, this works:

import std.stdio, std.random, std.string, std.algorithm, std.range;
void main() {
    string s = array(map!((i){ return cast(char)("AB"[uniform(0,2)]);
})(iota(10))).idup;
    writeln(s);
}

Thank you, bye,
bearophile

bearophile <bearophileHUGS lycos.com> writes:

http://d.puremagic.com/issues/show_bug.cgi?id=5630

"Lars T. Kyllingstad" <public kyllingen.NOSPAMnet> writes:

On Sun, 20 Feb 2011 15:23:29 -0500, Steven Schveighoffer wrote:

 On Sun, 20 Feb 2011 14:51:10 -0500, bearophile
 <bearophileHUGS lycos.com> wrote:
 
 Jacob Carlborg:

 Every time I try to use D2 it's just a PITA to use. I've used D1 and
 Tango for
 several years and had no problem with that.

 I use this thread to ask regarding one specific little problem I have
 with strings. I want to generate a random string of AB using the array,
 map, etc, this looks like a possible implementation (in std.random
 there is no choice() function yet):


 import std.stdio, std.random, std.string, std.algorithm, std.range;
 void main() {
     auto m = map!((i){ return "AB"[uniform(0,2)]; })(iota(10)); string
     s = join(array(m));
     writeln(s);
 }


 It gives this error:
 ...\dmd\src\phobos\std\array.d(62): Error: result[i] isn't mutable
 test.d(5): Error: template instance
 std.array.array!(Map!(__dgliteral1,Iota!(int,uint))) error
 instantiating

 What's the right way to write it in D?

 The same code in Python2.x:

 from random import choice
 s = "".join(choice("AB") for _ in xrange(10)) print s

 
 Just a blind guess, I have not tested, but maybe it's because the
 compiler is using const(char) as the return type for your delegate
 literal since you never specify one?

It's probably using immutable(char) since that's the element type of "AB".

-Lars

"Steven Schveighoffer" <schveiguy yahoo.com> writes:

On Sun, 20 Feb 2011 13:40:08 -0500, Jacob Carlborg <doob me.com> wrote:


 I'm confused about how someone can implement a library like this. Every  
 time I try to use D2 it's just a PITA to use. I've used D1 and Tango for  
 several years and had no problem with that.

Strings are a sore spot for me, I think the current implementation is a  
hack which leaves much to be desired.  However, it seems that Andrei  
believes the current implementation is not only decent, but actually  
better than any alternative.

 I assume this has been discussed, did that resolve in any plans to solve  
 this?

I am, in my spare time, working on a way to represent strings that allows  
strings to be what they are and arrays of chars or wchars to be what they  
are.  It is not finished yet, but I've put forth a couple incomplete  
examples.  Search for [review] on the D news group.

Things have gotten quite more complex when I realized that dchar is  
actually not the most natural "element" of a string, since a dchar doesn't  
represent a visible character (or one that a human would interpret as a  
single character) and also that the exact same string can be sometimes  
represented by two distinct sequences of dchars.  When I can finish the  
proposed change, I will probably try integrating it with Phobos to see how  
well it works.

-Steve

Jacob Carlborg <doob me.com> writes:

On 2011-02-20 21:30, Steven Schveighoffer wrote:
 On Sun, 20 Feb 2011 13:40:08 -0500, Jacob Carlborg <doob me.com> wrote:


 I'm confused about how someone can implement a library like this.
 Every time I try to use D2 it's just a PITA to use. I've used D1 and
 Tango for several years and had no problem with that.

 Strings are a sore spot for me, I think the current implementation is a
 hack which leaves much to be desired. However, it seems that Andrei
 believes the current implementation is not only decent, but actually
 better than any alternative.

 I assume this has been discussed, did that resolve in any plans to
 solve this?

 I am, in my spare time, working on a way to represent strings that
 allows strings to be what they are and arrays of chars or wchars to be
 what they are. It is not finished yet, but I've put forth a couple
 incomplete examples. Search for [review] on the D news group.

 Things have gotten quite more complex when I realized that dchar is
 actually not the most natural "element" of a string, since a dchar
 doesn't represent a visible character (or one that a human would
 interpret as a single character) and also that the exact same string can
 be sometimes represented by two distinct sequences of dchars. When I can
 finish the proposed change, I will probably try integrating it with
 Phobos to see how well it works.

 -Steve

Oh, I remember that thread(s). It got so overly complicated so I stopped 
reading it.

-- 
/Jacob Carlborg

"Steven Schveighoffer" <schveiguy yahoo.com> writes:

On Sun, 20 Feb 2011 17:10:28 -0500, Jacob Carlborg <doob me.com> wrote:

 On 2011-02-20 21:30, Steven Schveighoffer wrote:
 On Sun, 20 Feb 2011 13:40:08 -0500, Jacob Carlborg <doob me.com> wrote:


 I'm confused about how someone can implement a library like this.
 Every time I try to use D2 it's just a PITA to use. I've used D1 and
 Tango for several years and had no problem with that.

 Strings are a sore spot for me, I think the current implementation is a
 hack which leaves much to be desired. However, it seems that Andrei
 believes the current implementation is not only decent, but actually
 better than any alternative.

 I assume this has been discussed, did that resolve in any plans to
 solve this?

 I am, in my spare time, working on a way to represent strings that
 allows strings to be what they are and arrays of chars or wchars to be
 what they are. It is not finished yet, but I've put forth a couple
 incomplete examples. Search for [review] on the D news group.

 Things have gotten quite more complex when I realized that dchar is
 actually not the most natural "element" of a string, since a dchar
 doesn't represent a visible character (or one that a human would
 interpret as a single character) and also that the exact same string can
 be sometimes represented by two distinct sequences of dchars. When I can
 finish the proposed change, I will probably try integrating it with
 Phobos to see how well it works.

 -Steve

 Oh, I remember that thread(s). It got so overly complicated so I stopped  
 reading it.

Yeah, UTF is so overly complicated, it's difficult to properly implement  
it.

-Steve