www.digitalmars.com         C & C++   DMDScript  

digitalmars.D - Targeting C

reply Tim Matthews <tim.matthews7 gmail.com> writes:
While C may be not much from assembly and C++ a mess. C with a strapped 
on GC can have full power, portability which just leaves the programmer 
to please.

Some of spotted this and instead of compiling directly, they output C 
code. Some examples of this are:

Bitc. Combines the flexibility, rich, safe of modern day functional 
languages with power of C. http://www.bitc-lang.org/

Vala. A Modern C# looking language that compiles to C with the resulting 
code using the GObject library. http://live.gnome.org/Vala

And 2 more recent ones:

OOC. I quite like how this one myself personally. http://ooc-lang.org/about

Zimbu. Quote from the zimbu page: "It has to run on most systems, 
anything with a C compiler, so D is out" http://www.zimbu.org/
Oct 21 2009
next sibling parent reply bearophile <bearophileHUGS lycos.com> writes:
Tim Matthews:

 OOC. I quite like how this one myself personally. http://ooc-lang.org/about

Type of arguments can be stated once: Vector3f: class { x, y, z : Float init: func(x, y, z : Float) { this x = x // 'this' is called 'self' in some other languages this y = y this z = z } } It doesn't need the is() when you test for type equality: print: func <T> (arg: T) { if(T == Int) { printf("%d\n", arg as Int) // 'as' allow casting } else if(T == String) { printf("%s\n", arg as String) } } Uses a syntax better than the D foreach: list := ArrayList<Int> new() for(i in 0..10) list add(i) // oh yeah no needs for brackets for(i in list) printf("%d\n") And I have omitted some other handy features. There's something to learn for D too :-) Bye, bearophile
Oct 22 2009
next sibling parent reply =?ISO-8859-1?Q?Pelle_M=E5nsson?= <pelle.mansson gmail.com> writes:
bearophile wrote:
 Tim Matthews:
 
 OOC. I quite like how this one myself personally. http://ooc-lang.org/about

Type of arguments can be stated once: Vector3f: class { x, y, z : Float init: func(x, y, z : Float) { this x = x // 'this' is called 'self' in some other languages this y = y this z = z } } It doesn't need the is() when you test for type equality: print: func <T> (arg: T) { if(T == Int) { printf("%d\n", arg as Int) // 'as' allow casting } else if(T == String) { printf("%s\n", arg as String) } } Uses a syntax better than the D foreach: list := ArrayList<Int> new() for(i in 0..10) list add(i) // oh yeah no needs for brackets for(i in list) printf("%d\n") And I have omitted some other handy features. There's something to learn for D too :-) Bye, bearophile

Personally, I like this: foreach (i; 0..10) list ~= i; more. :)
Oct 22 2009
parent reply bearophile <bearophileHUGS lycos.com> writes:
Pelle Månsson:

 Personally, I like this:
 foreach (i; 0..10) list ~= i;
 more. :)

While I like this more: for (i in 0 .. 10) list ~= i; Bye, bearophile
Oct 22 2009
parent reply Chris Nicholson-Sauls <ibisbasenji gmail.com> writes:
bearophile wrote:
 Pelle MÃ¥nsson:
 
 Personally, I like this:
 foreach (i; 0..10) list ~= i;
 more. :)

While I like this more: for (i in 0 .. 10) list ~= i; Bye, bearophile

I prefer this (Scala): list = list ++ (0 to 10) Okay, that's not really fair. The direct port to Scala would be more like: for { i <- 0 to 10 } list :::= List(i) Ultimately, syntax only really matters greatly where it provides some significant advantage or detours from some significant disadvantage. Kinda like the '$' in array indices. Early on in D, we had no such creature, but I threw my support fully behind it because of my prior experience with ColdC (and λμ, etc) and its use of the same syntax. Generally speaking, when a given language has an inordinate amount of syntax in some activity, it is probably a good sign that activity is uncommon when the language is properly applied. Conversely, a terse compact syntax is a good sign that's common usage. Depends on "genre"... and now I'm ranting and have no idea why. -- Chris Nicholson-Sauls
Oct 23 2009
parent reply bearophile <bearophileHUGS lycos.com> writes:
Chris Nicholson-Sauls:

 I prefer this (Scala):
 list = list ++ (0 to 10)

That's quite less readable. Scala sometimes has some unreadable syntax. Python has taught me how much useful a readable syntax is :-) Designing languages requires to find a balance between several different and opposed needs. Bye, bearophile
Oct 23 2009
next sibling parent reply Yigal Chripun <yigal100 gmail.com> writes:
On 23/10/2009 13:02, bearophile wrote:
 Chris Nicholson-Sauls:

 I prefer this (Scala):
 list = list ++ (0 to 10)

That's quite less readable. Scala sometimes has some unreadable syntax. Python has taught me how much useful a readable syntax is :-) Designing languages requires to find a balance between several different and opposed needs. Bye, bearophile

how about this hypothetical syntax: list ~= [0..10];
Oct 23 2009
parent reply Andrei Alexandrescu <SeeWebsiteForEmail erdani.org> writes:
Yigal Chripun wrote:
 On 23/10/2009 13:02, bearophile wrote:
 Chris Nicholson-Sauls:

 I prefer this (Scala):
 list = list ++ (0 to 10)

That's quite less readable. Scala sometimes has some unreadable syntax. Python has taught me how much useful a readable syntax is :-) Designing languages requires to find a balance between several different and opposed needs. Bye, bearophile

how about this hypothetical syntax: list ~= [0..10];

I'm not sure what the type of "list" is supposed to be, but this works today for arrays: list ~= array(iota(0, 10)); Andrei
Oct 23 2009
next sibling parent reply =?ISO-8859-1?Q?Pelle_M=E5nsson?= <pelle.mansson gmail.com> writes:
Andrei Alexandrescu wrote:
 Yigal Chripun wrote:
 On 23/10/2009 13:02, bearophile wrote:
 Chris Nicholson-Sauls:

 I prefer this (Scala):
 list = list ++ (0 to 10)

That's quite less readable. Scala sometimes has some unreadable syntax. Python has taught me how much useful a readable syntax is :-) Designing languages requires to find a balance between several different and opposed needs. Bye, bearophile

how about this hypothetical syntax: list ~= [0..10];

I'm not sure what the type of "list" is supposed to be, but this works today for arrays: list ~= array(iota(0, 10)); Andrei

Oct 23 2009
next sibling parent Max Samukha <spambox d-coding.com> writes:
On Fri, 23 Oct 2009 18:16:29 +0200, Pelle M?nsson
<pelle.mansson gmail.com> wrote:

Andrei Alexandrescu wrote:
 Yigal Chripun wrote:
 On 23/10/2009 13:02, bearophile wrote:
 Chris Nicholson-Sauls:

 I prefer this (Scala):
 list = list ++ (0 to 10)

That's quite less readable. Scala sometimes has some unreadable syntax. Python has taught me how much useful a readable syntax is :-) Designing languages requires to find a balance between several different and opposed needs. Bye, bearophile

how about this hypothetical syntax: list ~= [0..10];

I'm not sure what the type of "list" is supposed to be, but this works today for arrays: list ~= array(iota(0, 10)); Andrei


A sequence of integral numbers. I guess the name comes from APL.
Oct 23 2009
prev sibling next sibling parent reply Andrei Alexandrescu <SeeWebsiteForEmail erdani.org> writes:
Pelle Månsson wrote:
 Andrei Alexandrescu wrote:
 Yigal Chripun wrote:
 On 23/10/2009 13:02, bearophile wrote:
 Chris Nicholson-Sauls:

 I prefer this (Scala):
 list = list ++ (0 to 10)

That's quite less readable. Scala sometimes has some unreadable syntax. Python has taught me how much useful a readable syntax is :-) Designing languages requires to find a balance between several different and opposed needs. Bye, bearophile

how about this hypothetical syntax: list ~= [0..10];

I'm not sure what the type of "list" is supposed to be, but this works today for arrays: list ~= array(iota(0, 10)); Andrei


http://www.digitalmars.com/d/2.0/phobos/std_range.html#iota Irony minded. I'm destroyed. Andrei
Oct 23 2009
next sibling parent reply Andrei Alexandrescu <SeeWebsiteForEmail erdani.org> writes:
Steven Schveighoffer wrote:
 On Fri, 23 Oct 2009 12:50:34 -0400, Andrei Alexandrescu 
 <SeeWebsiteForEmail erdani.org> wrote:
 
 What does iota mean?

http://www.digitalmars.com/d/2.0/phobos/std_range.html#iota Irony minded. I'm destroyed.

Hm... this is slightly off topic, but that function signature is absolutely horrendous (in fact, I thought you linked to the wrong place at first). Isn't there any way to avoid putting half the type construction as the return value? Do all range-creating functions suffer from this problem? Maybe it's just a ddoc problem.

I wanted to use auto, but ddoc cannot document functions with auto returns. Andrei P.S. It looks like TDPL will scream today through the 100,000 words barrier (at 97,781 words now, see and track at www.erdani.com). When that happens, I'll celebrate by making another excerpt available online.
Oct 23 2009
next sibling parent Ary Borenszweig <ary esperanto.org.ar> writes:
Andrei Alexandrescu wrote:
 Steven Schveighoffer wrote:
 On Fri, 23 Oct 2009 12:50:34 -0400, Andrei Alexandrescu 
 <SeeWebsiteForEmail erdani.org> wrote:

 What does iota mean?

http://www.digitalmars.com/d/2.0/phobos/std_range.html#iota Irony minded. I'm destroyed.

Hm... this is slightly off topic, but that function signature is absolutely horrendous (in fact, I thought you linked to the wrong place at first). Isn't there any way to avoid putting half the type construction as the return value? Do all range-creating functions suffer from this problem? Maybe it's just a ddoc problem.

I wanted to use auto, but ddoc cannot document functions with auto returns.

Is it too hard to fix that? I think ddoc works before the semantic pass so the return type is null by then, but it isn't very hard to see a "if type.next != null" in the source code... I say it because I also find horrendous the signature. And what's more, it's hard to find the word "iota" there. I also think "iota" is an awful name for that function.
Oct 23 2009
prev sibling parent reply Max Samukha <spambox d-coding.com> writes:
On Fri, 23 Oct 2009 13:08:06 -0500, Andrei Alexandrescu
<SeeWebsiteForEmail erdani.org> wrote:

I wanted to use auto, but ddoc cannot document functions with auto returns.

Andrei

When I need to hack around an 'auto' bug, I sometimes factor out the return type to a template: template IotaRet(B, E, S = size_t) { alias Take!(Sequence!("a.field[0] + n * a.field[1]", Tuple!(CommonType!(B, E), S))) IotaRet; } IotaRet!(B, E, S) iota(B, E, S)(B begin, E end, S step) {} IotaRet!(B, E) iota(B, E)(B begin, E end) {}
P.S. It looks like TDPL will scream today through the 100,000 words 
barrier (at 97,781 words now, see and track at www.erdani.com). When 
that happens, I'll celebrate by making another excerpt available online.

Congrats!
Oct 24 2009
parent Andrei Alexandrescu <SeeWebsiteForEmail erdani.org> writes:
Max Samukha wrote:
 On Fri, 23 Oct 2009 13:08:06 -0500, Andrei Alexandrescu
 <SeeWebsiteForEmail erdani.org> wrote:
 
 I wanted to use auto, but ddoc cannot document functions with auto returns.

 Andrei

When I need to hack around an 'auto' bug, I sometimes factor out the return type to a template: template IotaRet(B, E, S = size_t) { alias Take!(Sequence!("a.field[0] + n * a.field[1]", Tuple!(CommonType!(B, E), S))) IotaRet; } IotaRet!(B, E, S) iota(B, E, S)(B begin, E end, S step) {} IotaRet!(B, E) iota(B, E)(B begin, E end) {}

I think I'll do that.
 P.S. It looks like TDPL will scream today through the 100,000 words 
 barrier (at 97,781 words now, see and track at www.erdani.com). When 
 that happens, I'll celebrate by making another excerpt available online.

Congrats!

Well not just yet. I had to remove a wad of text that was dedicated to T[new], so after a full day's work I'm only at 97,917 words. Andrei
Oct 24 2009
prev sibling parent reply grauzone <none example.net> writes:
Andrei Alexandrescu wrote:
 Pelle Månsson wrote:
 Andrei Alexandrescu wrote:
 Yigal Chripun wrote:
 On 23/10/2009 13:02, bearophile wrote:
 Chris Nicholson-Sauls:

 I prefer this (Scala):
 list = list ++ (0 to 10)

That's quite less readable. Scala sometimes has some unreadable syntax. Python has taught me how much useful a readable syntax is :-) Designing languages requires to find a balance between several different and opposed needs. Bye, bearophile

how about this hypothetical syntax: list ~= [0..10];

I'm not sure what the type of "list" is supposed to be, but this works today for arrays: list ~= array(iota(0, 10)); Andrei


http://www.digitalmars.com/d/2.0/phobos/std_range.html#iota

Take!(Sequence!("a.field[0] + n * a.field[1]",Tuple!(CommonType!(B,E),S))) iota(B, E, S)(B begin, E end, S step); Wow, please tell me this is a ddoc malfunction. I mean, that thing left to iota is supposed to be a type? (OK, it _is_ a malfunction, but that thing is still supposed to be... a type?)
Oct 23 2009
parent reply Andrei Alexandrescu <SeeWebsiteForEmail erdani.org> writes:
grauzone wrote:
 Andrei Alexandrescu wrote:
 Pelle MÃ¥nsson wrote:
 Andrei Alexandrescu wrote:
 Yigal Chripun wrote:
 On 23/10/2009 13:02, bearophile wrote:
 Chris Nicholson-Sauls:

 I prefer this (Scala):
 list = list ++ (0 to 10)

That's quite less readable. Scala sometimes has some unreadable syntax. Python has taught me how much useful a readable syntax is :-) Designing languages requires to find a balance between several different and opposed needs. Bye, bearophile

how about this hypothetical syntax: list ~= [0..10];

I'm not sure what the type of "list" is supposed to be, but this works today for arrays: list ~= array(iota(0, 10)); Andrei


http://www.digitalmars.com/d/2.0/phobos/std_range.html#iota

Take!(Sequence!("a.field[0] + n * a.field[1]",Tuple!(CommonType!(B,E),S))) iota(B, E, S)(B begin, E end, S step); Wow, please tell me this is a ddoc malfunction. I mean, that thing left to iota is supposed to be a type? (OK, it _is_ a malfunction, but that thing is still supposed to be... a type?)

Well what was I supposed to do? It was either define another type Iota, or reuse existing types. I chose to reuse. Andrei
Oct 23 2009
parent Andrei Alexandrescu <SeeWebsiteForEmail erdani.org> writes:
rmcguire wrote:
 Andrei Alexandrescu <SeeWebsiteForEmail erdani.org> wrote:
  
 grauzone wrote:
 Andrei Alexandrescu wrote:
 Pelle Månsson wrote:
 Andrei Alexandrescu wrote:
 Yigal Chripun wrote:
 On 23/10/2009 13:02, bearophile wrote:
 Chris Nicholson-Sauls:

 I prefer this (Scala):
 list = list ++ (0 to 10)

syntax. Python has taught me how much useful a readable syntax is :-) Designing languages requires to find a balance between several different and opposed needs. Bye, bearophile

list ~= [0..10];

works today for arrays: list ~= array(iota(0, 10)); Andrei



Take!(Sequence!("a.field[0] + n * a.field[1]",Tuple!(CommonType!(B,E),S))) iota(B, E, S)(B begin, E end, S step); Wow, please tell me this is a ddoc malfunction. I mean, that thing left to iota is supposed to be a type? (OK, it _is_ a malfunction, but that thing is still supposed to be... a type?)

or reuse existing types. I chose to reuse. Andrei

Hi Andrei, Could you tell me why: Take!(Sequence!("a.field[0] + n * a.field[1]",Tuple!(CommonType!(B,E),S))) Is a type and not a value? -Rory

Take!( Sequence!( "a.field[0] + n * a.field[1]", Tuple!( CommonType!(B,E), S ) ) ) If you look here: http://www.dsource.org/projects/phobos/browser/trunk/phobos/std/algorithm.d and in related files, you'll see that Take is a type with one parameter. Then Sequence is a type with two parameters. Then Tuple is a type with any number of parameters, and so is CommonType. So in spite of it looking complicated, it's just a usual instantiation of a few parameterized types. (What may confuse a C++ programmer is the presence of the string - it's just a template argument.) Andrei
Oct 30 2009
prev sibling parent =?ISO-8859-1?Q?=22J=E9r=F4me_M=2E_Berger=22?= <jeberger free.fr> writes:
Content-Type: text/plain; charset=ISO-8859-1; format=flowed
Content-Transfer-Encoding: quoted-printable

Pelle M=E5nsson wrote:
 Andrei Alexandrescu wrote:
 Yigal Chripun wrote:
 On 23/10/2009 13:02, bearophile wrote:
 Chris Nicholson-Sauls:

 I prefer this (Scala):
 list =3D list ++ (0 to 10)

That's quite less readable. Scala sometimes has some unreadable=20 syntax. Python has taught me how much useful a readable syntax is :-=




 Designing languages requires to find a balance between several=20
 different and opposed needs.

 Bye,
 bearophile

how about this hypothetical syntax: list ~=3D [0..10];

I'm not sure what the type of "list" is supposed to be, but this works=


 today for arrays:

 list ~=3D array(iota(0, 10));


 Andrei


In English: "A very small amount". This helped didn't it? ;) The=20 others have already answered for the D meaning. Jerome --=20 mailto:jeberger free.fr http://jeberger.free.fr Jabber: jeberger jabber.fr
Oct 23 2009
prev sibling next sibling parent reply Yigal Chripun <yigal100 gmail.com> writes:
On 23/10/2009 17:51, Bill Baxter wrote:
 On Fri, Oct 23, 2009 at 5:13 AM, Andrei Alexandrescu
 <SeeWebsiteForEmail erdani.org>  wrote:
 Yigal Chripun wrote:
 On 23/10/2009 13:02, bearophile wrote:
 Chris Nicholson-Sauls:

 I prefer this (Scala):
 list = list ++ (0 to 10)

That's quite less readable. Scala sometimes has some unreadable syntax. Python has taught me how much useful a readable syntax is :-) Designing languages requires to find a balance between several different and opposed needs. Bye, bearophile

how about this hypothetical syntax: list ~= [0..10];

I'm not sure what the type of "list" is supposed to be, but this works today for arrays: list ~= array(iota(0, 10));

While we're not on the subject.... "Iota" is right up there with "inSitu". I know it has a precedent elsewhere, but it sounds about as user friendly as monads. It just sounds like the language it trying to be snooty. Like "if you don't even know what iota is, you're clearly not qualified to join our little D club. Maybe you should try Java... or Logo". Compare that to Python where it's called "range", something every Joe the Programmer can certainly grok without having to get a Greek to English dictionary. --bb

Ranges are already part of the compiler because of foreach, can we also add language support for Range literals? i.e (1..10) => range(1, 10) //(I'm using BB's much better name) [1..10] => array(range(1, 10)) it already is supported is foreach, isn't it? foreach (i; 1..10) {...}
Oct 23 2009
parent reply bearophile <bearophileHUGS lycos.com> writes:
Yigal Chripun:

 Ranges are already part of the compiler because of foreach, can we also 
 add language support for Range literals?

In both iota and other possible implementations I'd like the arguments used by Python range/xrange, they are optimal, and better than the currently ones used by iota. And being ranges lazy and eager (strict) so common, I may want both versions, so I don't need array(iota(...)) (all this is present in my dlibs). What about xiota for the lazy version? Or maybe aiota for the eager version? :-) Bye, bearophile
Oct 23 2009
parent reply Yigal Chripun <yigal100 gmail.com> writes:
On 23/10/2009 18:29, bearophile wrote:
 Yigal Chripun:

 Ranges are already part of the compiler because of foreach, can we
 also add language support for Range literals?

In both iota and other possible implementations I'd like the arguments used by Python range/xrange, they are optimal, and better than the currently ones used by iota. And being ranges lazy and eager (strict) so common, I may want both versions, so I don't need array(iota(...)) (all this is present in my dlibs). What about xiota for the lazy version? Or maybe aiota for the eager version? :-) Bye, bearophile

Hell no. This is why I hate certain programming languages. if you are trying to obfuscate the language than why not just define: rtqfrdsg and fdkjtkf as the function names? names are important and they must be readable (in English. latin/greek/hindu/klingon/etc are not accepted). I don't care if I need to type ten letters instead of just five if later on I can understand immediately what the code does instead of spending half an hour reading the (outdated) documentation if I even bothered to write one.
Oct 23 2009
next sibling parent reply bearophile <bearophileHUGS lycos.com> writes:
Yigal Chripun:

 Hell no. This is why I hate certain programming languages.
 if you are trying to obfuscate the language than why not just define:
 rtqfrdsg and fdkjtkf as the function names?

Don't be silly. In my dlibs "xsomething" are the lazy functions, and "something" are the strict ones. That's not obfuscated, you need seconds to learn a single easy rule. Bye, bearophile
Oct 23 2009
parent reply =?ISO-8859-1?Q?Pelle_M=E5nsson?= <pelle.mansson gmail.com> writes:
bearophile wrote:
 Yigal Chripun:
 
 Hell no. This is why I hate certain programming languages.
 if you are trying to obfuscate the language than why not just define:
 rtqfrdsg and fdkjtkf as the function names?

Don't be silly. In my dlibs "xsomething" are the lazy functions, and "something" are the strict ones. That's not obfuscated, you need seconds to learn a single easy rule. Bye, bearophile

Seriously, iota? However, I like the array(range(0,10)) where range is always lazy, and array forces eagerness, better than separate xrange and range functions.
Oct 23 2009
next sibling parent Andrei Alexandrescu <SeeWebsiteForEmail erdani.org> writes:
Pelle Månsson wrote:
 bearophile wrote:
 Yigal Chripun:

 Hell no. This is why I hate certain programming languages.
 if you are trying to obfuscate the language than why not just define:
 rtqfrdsg and fdkjtkf as the function names?

Don't be silly. In my dlibs "xsomething" are the lazy functions, and "something" are the strict ones. That's not obfuscated, you need seconds to learn a single easy rule. Bye, bearophile

Seriously, iota? However, I like the array(range(0,10)) where range is always lazy, and array forces eagerness, better than separate xrange and range functions.

Orthogonality for the win. Andrei
Oct 23 2009
prev sibling parent Yigal Chripun <yigal100 gmail.com> writes:
On 23/10/2009 19:49, Pelle Månsson wrote:
 bearophile wrote:
 Yigal Chripun:

 Hell no. This is why I hate certain programming languages.
 if you are trying to obfuscate the language than why not just define:
 rtqfrdsg and fdkjtkf as the function names?

Don't be silly. In my dlibs "xsomething" are the lazy functions, and "something" are the strict ones. That's not obfuscated, you need seconds to learn a single easy rule. Bye, bearophile

Seriously, iota? However, I like the array(range(0,10)) where range is always lazy, and array forces eagerness, better than separate xrange and range functions.

first thing xsomthing *is* silly and I agree with andrei and pelle about having an array function that forces eagerness. but more generally speaking, each individual part can be rationalized like xsomething is lazy, iota generates a lazy range, etc.. but combined you get meaningless letters.. xaiota? rule 1 of programming - code is read 1000 times more then written. today at the age of terabyte HDDs writing strcmp instead of string_compare or stringCompare (depends on your love for camels) is absolutely ridiculous.
Oct 23 2009
prev sibling parent =?ISO-8859-1?Q?=22J=E9r=F4me_M=2E_Berger=22?= <jeberger free.fr> writes:
Content-Type: text/plain; charset=ISO-8859-1; format=flowed
Content-Transfer-Encoding: quoted-printable

Yigal Chripun wrote:
 On 23/10/2009 18:29, bearophile wrote:
 Yigal Chripun:

 Ranges are already part of the compiler because of foreach, can we
 also add language support for Range literals?

In both iota and other possible implementations I'd like the arguments used by Python range/xrange, they are optimal, and better than the currently ones used by iota. And being ranges lazy and eager (strict) so common, I may want both versions, so I don't need array(iota(...)) (all this is present in my dlibs). What about xiota for the lazy version? Or maybe aiota for the eager version? :-) Bye, bearophile

=20 Hell no. This is why I hate certain programming languages. if you are trying to obfuscate the language than why not just define: rtqfrdsg and fdkjtkf as the function names? =20 names are important and they must be readable (in English.=20 latin/greek/hindu/klingon/etc are not accepted). I don't care if I need=

 to type ten letters instead of just five if later on I can understand=20
 immediately what the code does instead of spending half an hour reading=

 the (outdated) documentation if I even bothered to write one.

Note that both "iota" and "in situ" are in the "Collins Cobuild=20 English Language Dictionary". Here are their definitions: "in situ" is used to describe something that remains in its original=20 or appropriate place while work is done on it. "iota" An iota of something is an extremely small amount of it. Therefore, both should be considered acceptable English words.=20 However whereas "inSitu" says exactly what it means, I'm not so sure=20 about "iota" Jerome PS: For those who don't know, the Collins Cobuild is special in that=20 it is built using statistics on word usage. They choose which words=20 to include based on how frequently those words are used in common=20 English. --=20 mailto:jeberger free.fr http://jeberger.free.fr Jabber: jeberger jabber.fr
Oct 23 2009
prev sibling next sibling parent reply Andrei Alexandrescu <SeeWebsiteForEmail erdani.org> writes:
Bill Baxter wrote:
 On Fri, Oct 23, 2009 at 5:13 AM, Andrei Alexandrescu
 <SeeWebsiteForEmail erdani.org> wrote:
 Yigal Chripun wrote:
 On 23/10/2009 13:02, bearophile wrote:
 Chris Nicholson-Sauls:

 I prefer this (Scala):
 list = list ++ (0 to 10)

Python has taught me how much useful a readable syntax is :-) Designing languages requires to find a balance between several different and opposed needs. Bye, bearophile

list ~= [0..10];

for arrays: list ~= array(iota(0, 10));

While we're not on the subject.... "Iota" is right up there with "inSitu". I know it has a precedent elsewhere, but it sounds about as user friendly as monads. It just sounds like the language it trying to be snooty. Like "if you don't even know what iota is, you're clearly not qualified to join our little D club. Maybe you should try Java... or Logo". Compare that to Python where it's called "range", something every Joe the Programmer can certainly grok without having to get a Greek to English dictionary.

Given that "range" is already taken, what name do you think would work best? (I sometimes deliberately prefer less-used names because the more used ones often come with baggage and ambiguities (as is the case with "range"). Case in point, "in-situ" is more informative than "in-place" because the former suggests emplacement of a substructure within a larger structure. So to me an "in-situ" class member inside a class has a clear meaning that the member sits right there within the class. But anyhow I will use in-place from now on.) Andrei
Oct 23 2009
parent =?UTF-8?B?UGVsbGUgTcOlbnNzb24=?= <pelle.mansson gmail.com> writes:
Leandro Lucarella wrote:
 Andrei Alexandrescu, el 23 de octubre a las 11:09 me escribiste:
 Bill Baxter wrote:
 On Fri, Oct 23, 2009 at 5:13 AM, Andrei Alexandrescu
 <SeeWebsiteForEmail erdani.org> wrote:
 Yigal Chripun wrote:
 On 23/10/2009 13:02, bearophile wrote:
 Chris Nicholson-Sauls:

 I prefer this (Scala):
 list = list ++ (0 to 10)

Python has taught me how much useful a readable syntax is :-) Designing languages requires to find a balance between several different and opposed needs. Bye, bearophile

list ~= [0..10];

for arrays: list ~= array(iota(0, 10));

"Iota" is right up there with "inSitu". I know it has a precedent elsewhere, but it sounds about as user friendly as monads. It just sounds like the language it trying to be snooty. Like "if you don't even know what iota is, you're clearly not qualified to join our little D club. Maybe you should try Java... or Logo". Compare that to Python where it's called "range", something every Joe the Programmer can certainly grok without having to get a Greek to English dictionary.

(I sometimes deliberately prefer less-used names because the more used ones often come with baggage and ambiguities (as is the case with "range"). Case in point, "in-situ" is more informative than "in-place" because the former suggests emplacement of a substructure within a larger structure. So to me an "in-situ" class member inside a class has a clear meaning that the member sits right there within the class. But anyhow I will use in-place from now on.)

I don't see "range" taken inside the range module. I think it even makes sense, iota() is the more primitive range ever, so why don't just call it range()? :)

I don't know if it fares well in the ambiguity department, though.
Oct 23 2009
prev sibling parent Brad Roberts <braddr bellevue.puremagic.com> writes:
On Fri, 23 Oct 2009, Ary Borenszweig wrote:

 Andrei Alexandrescu wrote:
 Steven Schveighoffer wrote:
 On Fri, 23 Oct 2009 12:50:34 -0400, Andrei Alexandrescu
 <SeeWebsiteForEmail erdani.org> wrote:
 
 What does iota mean?

http://www.digitalmars.com/d/2.0/phobos/std_range.html#iota Irony minded. I'm destroyed.

Hm... this is slightly off topic, but that function signature is absolutely horrendous (in fact, I thought you linked to the wrong place at first). Isn't there any way to avoid putting half the type construction as the return value? Do all range-creating functions suffer from this problem? Maybe it's just a ddoc problem.

I wanted to use auto, but ddoc cannot document functions with auto returns.

Is it too hard to fix that? I think ddoc works before the semantic pass so the return type is null by then, but it isn't very hard to see a "if type.next != null" in the source code... I say it because I also find horrendous the signature. And what's more, it's hard to find the word "iota" there. I also think "iota" is an awful name for that function.

It'd be really sweet if someone stepped up to work on ddoc with the same gusto that Don has been on other parts of DMD. IMHO, without having done enough code study, ddoc should be split off into a separate executable that shared the first stages of DMD. I'm not sure that'd help it act different where it needs to act different, but it'd certainly be an interesting exercise to get more data about how re-usable parts of DMD are. Alternatively, it'd also be interesting to explore making it _really_ separate and use the new -X output and build docs completely off that. Later, Brad
Oct 23 2009
prev sibling parent Leandro Lucarella <llucax gmail.com> writes:
Andrei Alexandrescu, el 23 de octubre a las 13:06 me escribiste:
 Pelle MÃ¥nsson wrote:
bearophile wrote:
Yigal Chripun:

Hell no. This is why I hate certain programming languages.
if you are trying to obfuscate the language than why not just define:
rtqfrdsg and fdkjtkf as the function names?

Don't be silly. In my dlibs "xsomething" are the lazy functions, and "something" are the strict ones. That's not obfuscated, you need seconds to learn a single easy rule. Bye, bearophile

Seriously, iota? However, I like the array(range(0,10)) where range is always lazy, and array forces eagerness, better than separate xrange and range functions.

Orthogonality for the win.

Sometimes "practicality beats purity" :) But I don't really care that much about this one... -- Leandro Lucarella (AKA luca) http://llucax.com.ar/ ---------------------------------------------------------------------- GPG Key: 5F5A8D05 (F8CD F9A7 BF00 5431 4145 104C 949E BFB6 5F5A 8D05) ---------------------------------------------------------------------- DIEZ "PUNGAS" MENOS -- Crónica TV
Oct 23 2009
prev sibling next sibling parent Bill Baxter <wbaxter gmail.com> writes:
On Fri, Oct 23, 2009 at 5:13 AM, Andrei Alexandrescu
<SeeWebsiteForEmail erdani.org> wrote:
 Yigal Chripun wrote:
 On 23/10/2009 13:02, bearophile wrote:
 Chris Nicholson-Sauls:

 I prefer this (Scala):
 list = list ++ (0 to 10)

That's quite less readable. Scala sometimes has some unreadable syntax. Python has taught me how much useful a readable syntax is :-) Designing languages requires to find a balance between several different and opposed needs. Bye, bearophile

how about this hypothetical syntax: list ~= [0..10];

I'm not sure what the type of "list" is supposed to be, but this works today for arrays: list ~= array(iota(0, 10));

While we're not on the subject.... "Iota" is right up there with "inSitu". I know it has a precedent elsewhere, but it sounds about as user friendly as monads. It just sounds like the language it trying to be snooty. Like "if you don't even know what iota is, you're clearly not qualified to join our little D club. Maybe you should try Java... or Logo". Compare that to Python where it's called "range", something every Joe the Programmer can certainly grok without having to get a Greek to English dictionary. --bb
Oct 23 2009
prev sibling next sibling parent "Steven Schveighoffer" <schveiguy yahoo.com> writes:
On Fri, 23 Oct 2009 12:50:34 -0400, Andrei Alexandrescu  
<SeeWebsiteForEmail erdani.org> wrote:

 What does iota mean?

http://www.digitalmars.com/d/2.0/phobos/std_range.html#iota Irony minded. I'm destroyed.

Hm... this is slightly off topic, but that function signature is absolutely horrendous (in fact, I thought you linked to the wrong place at first). Isn't there any way to avoid putting half the type construction as the return value? Do all range-creating functions suffer from this problem? Maybe it's just a ddoc problem. -Steve
Oct 23 2009
prev sibling next sibling parent rmcguire <rjmcguire gmail.com> writes:
Andrei Alexandrescu <SeeWebsiteForEmail erdani.org> wrote:
 
 grauzone wrote:
 Andrei Alexandrescu wrote:
 Pelle Månsson wrote:
 Andrei Alexandrescu wrote:
 Yigal Chripun wrote:
 On 23/10/2009 13:02, bearophile wrote:
 Chris Nicholson-Sauls:

 I prefer this (Scala):
 list = list ++ (0 to 10)

That's quite less readable. Scala sometimes has some unreadable syntax. Python has taught me how much useful a readable syntax is :-) Designing languages requires to find a balance between several different and opposed needs. Bye, bearophile

how about this hypothetical syntax: list ~= [0..10];

I'm not sure what the type of "list" is supposed to be, but this works today for arrays: list ~= array(iota(0, 10)); Andrei


http://www.digitalmars.com/d/2.0/phobos/std_range.html#iota

Take!(Sequence!("a.field[0] + n * a.field[1]",Tuple!(CommonType!(B,E),S))) iota(B, E, S)(B begin, E end, S step); Wow, please tell me this is a ddoc malfunction. I mean, that thing left to iota is supposed to be a type? (OK, it _is_ a malfunction, but that thing is still supposed to be... a type?)

Well what was I supposed to do? It was either define another type Iota, or reuse existing types. I chose to reuse. Andrei

Hi Andrei, Could you tell me why: Take!(Sequence!("a.field[0] + n * a.field[1]",Tuple!(CommonType!(B,E),S))) Is a type and not a value? -Rory
Oct 30 2009
prev sibling parent "Denis Koroskin" <2korden gmail.com> writes:
On Fri, 30 Oct 2009 10:05:27 +0300, rmcguire <rjmcguire gmail.com> wrote=
:

 Andrei Alexandrescu <SeeWebsiteForEmail erdani.org> wrote:

 grauzone wrote:
 Andrei Alexandrescu wrote:
 Pelle M=C3=A5nsson wrote:
 Andrei Alexandrescu wrote:
 Yigal Chripun wrote:
 On 23/10/2009 13:02, bearophile wrote:
 Chris Nicholson-Sauls:

 I prefer this (Scala):
 list =3D list ++ (0 to 10)

That's quite less readable. Scala sometimes has some unreadable=








 syntax. Python has taught me how much useful a readable syntax =








 :-)
 Designing languages requires to find a balance between several
 different and opposed needs.

 Bye,
 bearophile

how about this hypothetical syntax: list ~=3D [0..10];

I'm not sure what the type of "list" is supposed to be, but this works today for arrays: list ~=3D array(iota(0, 10)); Andrei


http://www.digitalmars.com/d/2.0/phobos/std_range.html#iota

Take!(Sequence!("a.field[0] + n * a.field[1]",Tuple!(CommonType!(B,E),S))) iota(B, E, S)(B begin, E en=



 S
 step);

 Wow, please tell me this is a ddoc malfunction. I mean, that thing l=



 to iota is supposed to be a type?

 (OK, it _is_ a malfunction, but that thing is still supposed to be..=



 type?)

Well what was I supposed to do? It was either define another type Iot=


 or reuse existing types. I chose to reuse.

 Andrei

Hi Andrei, Could you tell me why: Take!(Sequence!("a.field[0] + n * =

 a.field[1]",Tuple!(CommonType!(B,E),S)))

 Is a type and not a value?

 -Rory

I guess Take!(T) is a type, returned by a take(T t, int limit) function = = (it accepts a range and returns other range with a "limit" elements at = most). The naming is consistent with a function, but capitalized to = reflect that it's actually a type, not a function.
Oct 30 2009
prev sibling next sibling parent Leandro Lucarella <llucax gmail.com> writes:
Bill Baxter, el 23 de octubre a las 08:51 me escribiste:
 list ~= array(iota(0, 10));

While we're not on the subject.... "Iota" is right up there with "inSitu". I know it has a precedent elsewhere, but it sounds about as user friendly as monads. It just sounds like the language it trying to be snooty. Like "if you don't even know what iota is, you're clearly not qualified to join our little D club. Maybe you should try Java... or Logo". Compare that to Python where it's called "range", something every Joe the Programmer can certainly grok without having to get a Greek to English dictionary.

Thanks for mention this, now I don't feel *that* idiotic to have to go and search what iota means every time I see it =) -- Leandro Lucarella (AKA luca) http://llucax.com.ar/ ---------------------------------------------------------------------- GPG Key: 5F5A8D05 (F8CD F9A7 BF00 5431 4145 104C 949E BFB6 5F5A 8D05) ---------------------------------------------------------------------- Did you know the originally a Danish guy invented the burglar-alarm unfortunately, it got stolen
Oct 23 2009
prev sibling parent Leandro Lucarella <llucax gmail.com> writes:
Andrei Alexandrescu, el 23 de octubre a las 11:09 me escribiste:
 Bill Baxter wrote:
On Fri, Oct 23, 2009 at 5:13 AM, Andrei Alexandrescu
<SeeWebsiteForEmail erdani.org> wrote:
Yigal Chripun wrote:
On 23/10/2009 13:02, bearophile wrote:
Chris Nicholson-Sauls:

I prefer this (Scala):
list = list ++ (0 to 10)

Python has taught me how much useful a readable syntax is :-) Designing languages requires to find a balance between several different and opposed needs. Bye, bearophile

list ~= [0..10];

for arrays: list ~= array(iota(0, 10));

While we're not on the subject.... "Iota" is right up there with "inSitu". I know it has a precedent elsewhere, but it sounds about as user friendly as monads. It just sounds like the language it trying to be snooty. Like "if you don't even know what iota is, you're clearly not qualified to join our little D club. Maybe you should try Java... or Logo". Compare that to Python where it's called "range", something every Joe the Programmer can certainly grok without having to get a Greek to English dictionary.

Given that "range" is already taken, what name do you think would work best? (I sometimes deliberately prefer less-used names because the more used ones often come with baggage and ambiguities (as is the case with "range"). Case in point, "in-situ" is more informative than "in-place" because the former suggests emplacement of a substructure within a larger structure. So to me an "in-situ" class member inside a class has a clear meaning that the member sits right there within the class. But anyhow I will use in-place from now on.)

I don't see "range" taken inside the range module. I think it even makes sense, iota() is the more primitive range ever, so why don't just call it range()? :) Anyway, I think it makes perfect sense to have the compiler translating x..y to a iota/range(x, y). -- Leandro Lucarella (AKA luca) http://llucax.com.ar/ ---------------------------------------------------------------------- GPG Key: 5F5A8D05 (F8CD F9A7 BF00 5431 4145 104C 949E BFB6 5F5A 8D05) ---------------------------------------------------------------------- CAROZO CON FARINGITIS -- Crónica TV
Oct 23 2009