Catching null pointers at compile time is just one of the benefits of building the language around a reasonably powerful type system. Other benefits of precise typing will come to Java with Generics (note that GJ and Nice are based on different powerful type systems).
Nice provides both extensible data (objects) and extensible operations (functions) in a unified way. Class based extensible data is similar to Java, but Nice multi-methods are very different from Java methods.
In Nice, choice of method implementation at execution time is based on the class of all the method parameters (not just the type of the receiver object). In Nice, and at the assembler level in Java, you can think of the receiver object as just another parameter passed to a static method. In other words myObj.myMethod( myParm ) is equivalent to myMethod( myObj, myParm ). In Java, which version of myMethod that gets used depends only on the type of the myObj object. In Nice it depends on the dynamic types all the parameters — including both myObj and myParam. In other words Nice seeks a closer fit for the method based not only on the receiver’s dynamic type but on the parameters as well. Like Java, there are also static constraints on the types of the parameters. Like Java, the compiler checks there exists at least one match.
Methods can be added to an existing class without editing the source (and without subclassing). (Yes, you can add a method to String.)
Nice provides for functional programming — parameters and return types can be methods or functions, anonymous functions, closures or Hindley Milner ML based type system extended for subtypes.
This page is posted
Optional Replicator mirror
|no blog for this page||Canadian
Your face IP:[18.104.22.168]
You are visitor number|