• Vathix <chris dprogramming.com> Aug 22 2005
• Hasan Aljudy <hasan.aljudy gmail.com> Aug 22 2005
• Manfred Nowak <svv1999 hotmail.com> Aug 22 2005
• Hasan Aljudy <hasan.aljudy gmail.com> Aug 22 2005
• Freejack <freejack nowhere.net> Aug 27 2005

Vathix <chris dprogramming.com> writes:

As everyone knows, C will magically know the length of the array when  
leaving out the number of elements if specifying an initializer like so,
    char foo[] = "abcde";
and as you know, that's not going to happen the same way in D because  
that's how to declare a dynamic array. So I have an idea to allow D to  
support C's magic with the following D syntax:
    char[$] foo = "abcde";
good?

Hasan Aljudy <hasan.aljudy gmail.com> writes:

Vathix wrote:
 As everyone knows, C will magically know the length of the array when  
 leaving out the number of elements if specifying an initializer like so,
    char foo[] = "abcde";
 and as you know, that's not going to happen the same way in D because  
 that's how to declare a dynamic array. So I have an idea to allow D to  
 support C's magic with the following D syntax:
    char[$] foo = "abcde";
 good?


looks good to me.

Manfred Nowak <svv1999 hotmail.com> writes:

Vathix <chris dprogramming.com> wrote:

[...]
     char[$] foo = "abcde";
 good?


Maybe. But why is the D-way wrong, i.e. using a `.' when it suffices?
Saves two characters to type in addition.

     char. foo = "That is the point";

Ahh, I see, that will turn all assignments to fields or properties 
into a declaration. But D already has for ranges `[0..1]' the special
  <decimal number><point><point> - token
which is to my knowledge unique in the world of computer languages.

So why not define the
  <Identifier><point><point> - token
to be the automagic length inheretor?

     char..foo = "That is the D way";

-manfred ;-)

P.S.:
I really forget the range special point when posting
digitalmars.D/27953

 

Hasan Aljudy <hasan.aljudy gmail.com> writes:

Manfred Nowak wrote:
 Vathix <chris dprogramming.com> wrote:
 
 [...]
 
    char[$] foo = "abcde";
good?


 
 Maybe. But why is the D-way wrong, i.e. using a `.' when it suffices?
 Saves two characters to type in addition.
 
      char. foo = "That is the point";


Because D doesn't do that! I think you are referring to D using '.' 
instead of '->' for pointers? It's erroneous to claim that using a dot 
every where is the D way.

 
 Ahh, I see, that will turn all assignments to fields or properties 
 into a declaration. But D already has for ranges `[0..1]' the special
   <decimal number><point><point> - token
 which is to my knowledge unique in the world of computer languages.
 
 So why not define the
   <Identifier><point><point> - token
 to be the automagic length inheretor?
 
      char..foo = "That is the D way";
 
 -manfred ;-)
 
 P.S.:
 I really forget the range special point when posting
 digitalmars.D/27953
 
  


Well, char[$] makes more sense, because $ is already used to refer to 
the array's length, and because we usually put the length inside 
[brackets] when declaring a statically allocated array, so the concept 
already has some roots.

OTOH, char..foo means "from char to foo"!!!!!!!
That makes no sense if you ask me.

Freejack <freejack nowhere.net> writes:

On Mon, 22 Aug 2005 05:41:35 -0400, Vathix wrote:

 As everyone knows, C will magically know the length of the array when  
 leaving out the number of elements if specifying an initializer like so,
     char foo[] = "abcde";
 and as you know, that's not going to happen the same way in D because  
 that's how to declare a dynamic array. So I have an idea to allow D to  
 support C's magic with the following D syntax:
     char[$] foo = "abcde";
 good?


Sounds alright.

I'm new to D, but I've been doing C, Ada, and Assembler for better than
ten years now. One thing that chaffes my ass about C style arrays(or
imperative language arrays in general) is the error prone and tedious
indexing. I think a better solution would be to just switch to APL style
arrays and array handling(using D syntax of course). I like D, and for all
it's advancements, it's still stuck in the dark ages for array
manipulation. char[$] foo = "blah"; shouldn't be necessary with a language
sporting the features of D. 
APL style arrays would certainly give D a leg up and over it's competitors.

My .02 worth.

Freejack