www.digitalmars.com         C & C++   DMDScript  

digitalmars.D.learn - bringToFront() and arrays of char

reply "Mu" <invalid_email address.int> writes:
Why doesn't the below code compile?
How to rewrite it so that it does?
Using: DMD64 D Compiler v2.060.
Thank you.

Code:
----------------

import std.algorithm, std.ascii, std.stdio;

void main()
{
       char[] rot13 = lowercase.dup;

       bringToFront(rot13[0 .. 13], rot13[13 .. $]);
       writeln(rot13);
}

----------------

Errors:

/usr/include/dmd/phobos/std/algorithm.d(1762): Error: front(r1)
is not an lvalue
/usr/include/dmd/phobos/std/algorithm.d(1763): Error: r2.front is
not an lvalue
/usr/include/dmd/phobos/std/algorithm.d(5944): Error: template
instance std.algorithm.swapFront!(char[],char[]) error
instantiating
rot13_test.d(7):        instantiated from here:
bringToFront!(char[],char[])
/usr/include/dmd/phobos/std/algorithm.d(1762): Error: not a
property r1.front
/usr/include/dmd/phobos/std/algorithm.d(1763): Error: r2.front is
not an lvalue
/usr/include/dmd/phobos/std/algorithm.d(5944): Error: template
instance std.algorithm.swapFront!(Take!(char[]),char[]) error
instantiating
/usr/include/dmd/phobos/std/algorithm.d(5973):
instantiated from here: bringToFront!(Take!(char[]),char[])
rot13_test.d(7):        instantiated from here:
bringToFront!(char[],char[])
/usr/include/dmd/phobos/std/algorithm.d(5973): Error: template
instance std.algorithm.bringToFront!(Take!(char[]),char[]) error
instantiating
rot13_test.d(7):        instantiated from here:
bringToFront!(char[],char[])
rot13_test.d(7): Error: template instance
std.algorithm.bringToFront!(char[],char[]) error instantiating
Dec 12 2012
parent reply =?UTF-8?B?QWxpIMOHZWhyZWxp?= <acehreli yahoo.com> writes:
On 12/12/2012 05:18 PM, Mu wrote:

 Why doesn't the below code compile?
 How to rewrite it so that it does?
 Using: DMD64 D Compiler v2.060.
 Thank you.

 Code:
 ----------------

 import std.algorithm, std.ascii, std.stdio;

 void main()
 {
 char[] rot13 = lowercase.dup;

 bringToFront(rot13[0 .. 13], rot13[13 .. $]);
 writeln(rot13);
 }

 ----------------

 Errors:

 /usr/include/dmd/phobos/std/algorithm.d(1762): Error: front(r1)
 is not an lvalue


This is a common pitfall of using char[] with range functions. Range 
functions like bringToFront() use the .front property. .front 
unintuitively returns dchar for a char[] range. That dchar is decoded 
from the UTF-8 code units of the char[].

You can use std.conv.to:

import std.algorithm, std.ascii, std.stdio;
import std.conv;

void main()
{
     dchar[] rot13 = lowercase.to!(dchar[]);

     bringToFront(rot13[0 .. 13], rot13[13 .. $]);
     writeln(rot13);
}

By dtext:

     dchar[] rot13 = lowercase.dtext.dup;

If you are dealing with ASCII, you may want to use ubyte instead. The 
following is one way of achieving that:

import std.array;
// ...
     ubyte[] rot13 = lowercase.map!(a => cast(ubyte)a).array;

(There must be an easier way of doing that. :))

Ali
Dec 12 2012
parent reply "Jonathan M Davis" <jmdavisProg gmx.com> writes:
On Wednesday, December 12, 2012 17:34:53 Ali Çehreli wrote:

 (There must be an easier way of doing that. :))


If you have a string that's really ASCII and you're _sure_ that it's only 
ASCII, then I'd suggest simply casting it to immutable(ubyte)[] and operating 
on that with all range based functions. That way, no decoding occurs, and you 
don't have to dup the string. If you want, you could also easily create a 
funtion called something like assumeASCII that did that cast in order to make 
it more idiomatic (similar to std.exception.assumeUnique).

- Jonathan M Davis
Dec 12 2012
next sibling parent =?UTF-8?B?QWxpIMOHZWhyZWxp?= <acehreli yahoo.com> writes:
On 12/12/2012 07:22 PM, Jonathan M Davis wrote:

 On Wednesday, December 12, 2012 17:34:53 Ali Çehreli wrote:

 (There must be an easier way of doing that. :))


 If you have a string that's really ASCII and you're _sure_ that it's only
 ASCII, then I'd suggest simply casting it to immutable(ubyte)[] and 


operating

 on that with all range based functions. That way, no decoding occurs, 


and you

 don't have to dup the string. If you want, you could also easily create a
 funtion called something like assumeASCII that did that cast in order 


to make

 it more idiomatic (similar to std.exception.assumeUnique).

 - Jonathan M Davis


I like that. :)

Potentially, the function can check in debug compilation that a random 
selection of characters are really ASCII. Similar to what the 
constructor of std.range.SortedRange (used as assumeSorted) does:

 
https://github.com/D-Programming-Language/phobos/blob/master/std/range.d#L7015

struct SortedRange(Range, alias pred = "a < b")
if (isRandomAccessRange!Range)
{
// ...

     // Undocummented because a clearer way to invoke is by calling
     // assumeSorted.
     this(Range input)
     {
         this._input = input;
         if(!__ctfe)
         debug
         {
             import std.random;

             // Check the sortedness of the input
             if (this._input.length < 2) return;
             immutable size_t msb = bsr(this._input.length) + 1;
             assert(msb > 0 && msb <= this._input.length);
             immutable step = this._input.length / msb;
             static MinstdRand gen;
             immutable start = uniform(0, step, gen);
             auto st = stride(this._input, step);
             assert(isSorted!pred(st), text(st));
         }
     }

// ...
}

Ali
Dec 13 2012
prev sibling parent reply Dmitry Olshansky <dmitry.olsh gmail.com> writes:
12/13/2012 7:22 AM, Jonathan M Davis пишет:

 On Wednesday, December 12, 2012 17:34:53 Ali Çehreli wrote:

 (There must be an easier way of doing that. :))


 If you have a string that's really ASCII and you're _sure_ that it's only
 ASCII, then I'd suggest simply casting it to immutable(ubyte)[] and operating
 on that with all range based functions. That way, no decoding occurs, and you
 don't have to dup the string. If you want, you could also easily create a
 funtion called something like assumeASCII that did that cast in order to make
 it more idiomatic (similar to std.exception.assumeUnique).


Yup. Plus there is a not commonly known 'representation' function that 
does just that for (w|d|)string:

auto repro = lowercase.representation;
//typeof(repro) should be immutable(ubyte)[]



-- 
Dmitry Olshansky
Dec 13 2012
parent "Jonathan M Davis" <jmdavisProg gmx.com> writes:
On Friday, December 14, 2012 00:27:39 Dmitry Olshansky wrote:

 12/13/2012 7:22 AM, Jonathan M Davis пишет:

 On Wednesday, December 12, 2012 17:34:53 Ali Çehreli wrote:

 (There must be an easier way of doing that. :))


 
 If you have a string that's really ASCII and you're _sure_ that it's only
 ASCII, then I'd suggest simply casting it to immutable(ubyte)[] and
 operating on that with all range based functions. That way, no decoding
 occurs, and you don't have to dup the string. If you want, you could also
 easily create a funtion called something like assumeASCII that did that
 cast in order to make it more idiomatic (similar to
 std.exception.assumeUnique).


 
 Yup. Plus there is a not commonly known 'representation' function that
 does just that for (w|d|)string:
 
 auto repro = lowercase.representation;
 //typeof(repro) should be immutable(ubyte)[]


Wow. Good to know about that one. I feel kind of stupid for not realizing that 
it was there given how much I've worked in std.string. And here I was doing 
that cast manually in some of my code recently and having to put comments to 
indicate why I was doing it. std.string.representation is much better.

- Jonathan M Davis
Dec 13 2012