www.digitalmars.com         C & C++   DMDScript  

digitalmars.D - D vs Nice programming language

reply Peri Hankey <mpah thegreen.co.uk> writes:
Hello

The D language looks very interesting. I had also looked at nice 
(http://nice.sourceforge.net/) and was wondering if anyone had done a 
comparison. In some ways they seem to have a similar approach, although 
nice runs on the JVM and aims to be able to use Java libraries. 
Incidentally nice is listed in the language shootout at 
http://shootout.alioth.debian.org/ .

Nice permits methods to be defined outside classes, and selects the 
method to be called at run-time on the basis of the argument types, 
along the following lines:

class A { ... }
class B { ... }

display (A x)  { ... code to display an instance of A ...}
display (B x)  { ... code to display an instance of B ...}

connection (A x, B y) { ... deal with connections from an A to a B ...}
connection (B x, A y) { ... deal with connections from an B to a A ...}

For methods declared outside any class, the first argument is treated as 
the class to which the method has been added. So you could either say

A x = new A();
x.display();

or

A x = new A();
display(x);

Where a method is chosen on the basis of its argument types at run-time, 
you know that the right types have been provided: eg the method for 
connections from an A to a B can only be called when those are the 
argument types that were provided in a particular call, so there is no 
need to check that the second argument really is of class B.

The ability to add methods to a class relates at least slightly to the 
recent feature request for partial class definitions.
Jan 21 2005
next sibling parent Matthias Becker <Matthias_member pathlink.com> writes:
In article <csr550$2mb$1 digitaldaemon.com>, Peri Hankey says...
Hello

The D language looks very interesting. I had also looked at nice 
(http://nice.sourceforge.net/) and was wondering if anyone had done a 
comparison. In some ways they seem to have a similar approach, although 
nice runs on the JVM and aims to be able to use Java libraries. 

I don't think so. To me nice looks very much like Dylan with a C-like syntax.
Nice permits methods to be defined outside classes, and selects the 
method to be called at run-time on the basis of the argument types, 

This is normaly refered to as multi-methods.
The ability to add methods to a class relates at least slightly to the 
recent feature request for partial class definitions.

So do you suggest to completely redisign D and make it a different language? -- Matthias Becker
Jan 21 2005
prev sibling next sibling parent "Lionello Lunesu" <lionello.lunesu crystalinter.remove.com> writes:
 Nice permits methods to be defined outside classes, and selects the method 
 to be called at run-time on the basis of the argument types, along the 
 following lines:

 class A { ... }
 class B { ... }

 display (A x)  { ... code to display an instance of A ...}
 display (B x)  { ... code to display an instance of B ...}

This will work in D too! You can do both: A a = new A; display(a); a.display(); (IF I'm not mistaken) L.
Jan 21 2005
prev sibling parent reply parabolis <parabolis softhome.net> writes:
Peri Hankey wrote:
 Hello

 The D language looks very interesting. I had also looked at
 nice (http://nice.sourceforge.net/) and was wondering if
 anyone had done a comparison. In some ways they seem to have a
 similar approach...

I glanced over Nice's manual here: http://nice.sourceforge.net/manual.html D's spec can be found here: http://digitalmars.com/d/index.html The major differences I noticed are: (1) Nice seems primarily oriented towards OOP but allows structured programming whereas D is the opposite. I should mention Nice seems to support a structed programing style without gotchas wheras OOP in D is riddled with gotchas. (2) Nice is quite advanced at statically checking null pointers whereas D is not. (3) Nice compiles to Java bytecode and D compiles to native code with C linkage. (4) Nice interoperates with Java allowing access to arguably one of the most robust OOP libraries in the world. D interoperates with C allowing access to a massive collection of statically linked libraries and COM compatability. (5) Nice only has the Java primitive types. D has both signed and unsigned integer types and not just 80-bit floating point support but also the complex and imaginary primitive types. (6) Nice has no means for users to extend primitive types whereas D is quite advanced and has not one but two means of extending primitive types - typdef/alias. Unlike C/C++ typedef does not just make a new name for a primitive type but creates a whole new primitive type. (7) Nice has tuples and D has structs. Tuples can be quite useful for multiple assignments (ie swapping x and y as (x,y) = (y,x)). However the benefit of tuples returning multiple values from a function is comparable with D's in, inout and out parameters which are more straightforward than tuples. (8) Nice seems to allow parametric polymorphic types define their range as the union of any primitive types. (9) D includes an inline assembler. (10) D has native data structures. Namely associative arrays and bit arrays.
Jan 21 2005
parent reply "Thomas Kuehne" <thomas-dloop kuehne.cn> writes:
parabolis <parabolis softhome.net> schrieb:
 Peri Hankey wrote:
  > Hello
  >
  > The D language looks very interesting. I had also looked at
  > nice (http://nice.sourceforge.net/) and was wondering if
  > anyone had done a comparison. In some ways they seem to have a
  > similar approach...

 (3) Nice compiles to Java bytecode and D compiles to native code
 with C linkage.

I am sure you could adapt GDC/GCC/GCJ to emmit Java bytecode for D sources. Most of D's features should be easy to translate, but maybe the template-mixin pair might pose some hurdles.
 (10) D has native data structures. Namely associative arrays and
 bit arrays.

using them you'll notice that the current implementation has lot's of limitations. e.g. - no dummy ".sort" property - concat / shift limitated to byte boundries Thomas
Jan 21 2005
parent parabolis <parabolis softhome.net> writes:
Thomas Kuehne wrote:

 This is a (missing) feature of the compiler and not of the language specs.
 I am sure you could adapt GDC/GCC/GCJ to emmit Java bytecode for D sources.
Most of D's
 features should be easy to translate, but maybe the template-mixin pair might
pose some
 hurdles.

That is a good point.
 Oh those bit arrays ... At first this seems to be realy usefull, but as soon
as you start
 using them you'll notice that the current implementation has lot's of
limitations.

It was my intent to include the things that are expected and/or likely to work for the big 1.0. I did not count against Nice the lack of any typedef/alias as I got the impression the Nice creator has not yet ruled the possibility out. It is rather hard to compare features between two languages that don't officially exist yet.
Jan 21 2005