• Roel Meeuws (23/23) Nov 29 2006 Hi there,
• Sean Kelly (16/39) Nov 29 2006 For what it's worth, D actually had a bit type until recently when it

Roel Meeuws <r.j.meeuws gmail.com> writes:

Hi there,

I've been looking at D for some time now, and there are quite some interesting
features there! And because I feel this language has potential, I would like
to suggest a feature that would be beneficial within my research discipline.
I'm working with reconfigurable computing, and to be more precise at the
moment our group is automatically translating high-level languages to
hardware. This would make it possible for non-hardware designers to take
advantage of FPGAs and the like.

Anyway, the feature that about every language out there is lacking is easy
bitlevel manipulation... You will ask, why the heck would you want to do that?
Well, when considering cpus that do not make direct bitlevel manipulation
possible I would agree, but the future will not have a big role for "old" ways
of thinking. There will be hybrid environments with accelerators and FPGAs
etc. And doing a bitreversal without a for-loop and xors and shifts is
probably a lot easier...

How could this be done? When the elementary type bit is added and any integer
type can be casted to a bitarray and back, we would basically be done. Maybe
this could also make it possible to define arbitrary size integers like
1024-bit integer or something. Of course, this would require generic
implementations for any integer operators.

Anyway these were my two cents...


greetz,

Roel

Sean Kelly <sean f4.ca> writes:

Roel Meeuws wrote:
 Hi there,
 
 I've been looking at D for some time now, and there are quite some interesting
 features there! And because I feel this language has potential, I would like
 to suggest a feature that would be beneficial within my research discipline.
 I'm working with reconfigurable computing, and to be more precise at the
 moment our group is automatically translating high-level languages to
 hardware. This would make it possible for non-hardware designers to take
 advantage of FPGAs and the like.
 
 Anyway, the feature that about every language out there is lacking is easy
 bitlevel manipulation... You will ask, why the heck would you want to do that?
 Well, when considering cpus that do not make direct bitlevel manipulation
 possible I would agree, but the future will not have a big role for "old" ways
 of thinking. There will be hybrid environments with accelerators and FPGAs
 etc. And doing a bitreversal without a for-loop and xors and shifts is
 probably a lot easier...
 
 How could this be done? When the elementary type bit is added and any integer
 type can be casted to a bitarray and back, we would basically be done. Maybe
 this could also make it possible to define arbitrary size integers like
 1024-bit integer or something. Of course, this would require generic
 implementations for any integer operators.

For what it's worth, D actually had a bit type until recently when it 
was replaced by bool.  The bit type was one byte by itself and packed in 
arrays, which is about what you're asking for.  This was changed for two 
reasons: 'bit' and 'bool' aren't really the same thing, so using bit 
values to represent logical true/false didn't sit well with many D 
programmers; also, packed bit arrays represented an annoying corner case 
of array manipulation as it is not possible to take the address of a bit 
element.  The compromise, when bit changed to bool, was the addition of 
the BitArray class in Phobos.  That said, Phobos also contains "to the 
metal" instructions for bit manipulation in std.intrinsic: 
http://www.digitalmars.com/d/phobos/std_intrinsic.html  This isn't 
perhaps quite as nice, semantically, as dealing with a bit array, but 
it's quite optimal and far better than all the xor nonsense required in 
other languages.


Sean